Рекурсия Java над текстовым файлом

Question

У меня есть текстовый файл, представляющий здание. В здании есть полы, а полы - номера.

Первый этаж этаж 0.

Текстовый файл структурирован следующим образом:

Description 
Image 
North 
East 
South 
West 
Up 
Down 

Где север, восток, юг, запад, вверх и вниз целые числа, обозначающие номер, что направление ведет к. Целое число -1 используется для обозначения того, что в этом направлении нет выхода.

Это повторяется для количества комнат, которые имеет здание.

Так в течение четырех комнат содержимое текстового файла может быть:

this is room 0 
somefilepath 
1 
-1 
-1 
-1 
2 
-1 
this is room 1 
somefilepath 
-1 
-1 
-1 
0 
-1 
-1 
this is room 2 
somefilepath 
-1 
-1 
-1 
-1 
3 
0 
this is room 3 
somefilepath 
-1 
-1 
-1 
-1 
-1 
2 

Я пытаюсь написать рекурсивную функцию, которая позволит мне рассчитать количество этажей в здании на основе вверх значения. Например, если у нас есть комната, которая поднимается до 1-го места, а комната 1 поднимается в комнату 2, и никакие другие номера не выходят выше этого, тогда мы знаем, что есть 3 этажа.

Я знаю, как использовать объект BufferedReader или Scanner для чтения текстового файла, но рекурсия - это то, о чем я беспокоюсь.

Я хочу сказать спасибо заранее, сообщество здесь удивительно.

Мой метод расчета количества этажей (неполное и может быть неправильным):

public int calculateFloors(int previousUp, int currentRoom) { 
    Scanner scanner; 
    int total = 0; 
    try { 
     scanner = new Scanner(currentMap); 
     while (scanner.hasNextLine()) { 
      scanner.nextLine(); 
      scanner.nextLine(); 
      scanner.nextLine(); 
      scanner.nextLine(); 
      scanner.nextLine(); 
      scanner.nextLine(); 
      int up = Integer.parseInt(scanner.nextLine()); 
      scanner.nextLine(); 
      if (up > 0) { 
       // do something 
       if (currentRoom == previousUp) { 
        // do something 
       } 
      } 
      currentRoom++; 
     } 
    } catch (Exception e) { 
     e.printStackTrace(); 
    } 
    return total; 
} 

Answer 1

Ok я редактировал мою мысль:

Так что нам нужно сделать: Мы посещаем каждую комнату и следуйте всем возможным путям из этой комнаты. Если мы поднимемся, мы добавим +1, если мы пойдем вниз, получим выражение -1, и если мы останемся на том же уровне, мы не добавим значения. Также нам нужно следить за уже посещенными комнатами, чтобы не ходить в цикле.

public int calculateFloors(int current, Set<Integer> visited) { 
    int floors = 0; 

    // get the values of the directions (add your code here to get them) 
    int north = Integer.parseInt(scanner.nextLine()); 
    int east = Integer.parseInt(scanner.nextLine()); 
    int west = Integer.parseInt(scanner.nextLine()); 
    int south = Integer.parseInt(scanner.nextLine()); 
    int down = Integer.parseInt(scanner.nextLine()); 
    int up = Integer.parseInt(scanner.nextLine()); 


    if (up > 0 && !visited.contains(up)) { 
     visited.add(up); 
     floors = calculateFloors(up, visited) + 1; 
    } 

    if (down > 0 && !visited.contains(down)) { 
     visited.add(down); 
     int result = calculateFloors(down, visited) - 1; 
     floors = result > floors ? result : floors; 
    } 

    if (north > 0 && !visited.contains(north)) { 
     visited.add(north); 
     int result = calculateFloors(norht, visited); 
     floors = result > floors ? result : floors; 
    } 

    if (south > 0 && !visited.contains(south)) { 
     visited.add(south); 
     int result = calculateFloors(south, visited); 
     floors = result > floors ? result : floors; 
    } 
    if (west > 0 && !visited.contains(west)) { 
     visited.add(west); 
     int result = calculateFloors(west, visited); 
     floors = result > floors ? result : floors; 
    } 
    if (east > 0 && !visited.contains(east)) { 
     visited.add(east); 
     int result = calculateFloors(east, visited); 
     floors = result > floors ? result : floors; 
    } 


    return floors; 
} 

Это должно работать (просто добавьте код, чтобы найти значения направлений текущей комнаты) в моем opinioin.

Answer 2

public int calculateFloors(int count) { 
    Scanner scanner; 
    int count=1; 
    try { 
     scanner = new Scanner(currentMap); 
     //uses count to work out what rooms we can skip 
     for(int i=0;i<count*6) 
      scanner.nextLine(); 
     //gets the value of up 
     int up = Integer.parseInt(scanner.nextLine()); 
     //our base case --- if there are no more floors, return the number --- otherwise perform the recursive call. 
     if(up==-1) 
      return count; 
     else 
      count+=calculateFloors(count++); 
    }catch(Exception e){ 
     System.out.println(e); 
    } 
    return count; 
} 

Попробуйте это.

Answer 3

Просто сделайте глубину-первый поиск по комнатам (вам не нужна рекурсивная функция). Вы можете идти вверх и вниз, чтобы достичь вершины.

public static class Room { 
    public final int[] neighborsSameFloor; // indices of the rooms on the same floor 
    public final int neighborUp; // index of the room above 
    public final int neighborDown; // index of the room below 
    public Room(/*???*/) { 
    // do the initialisation 
    } 
} 

public Room[] readRooms() { 
    // read file here 
} 

public int getEntry() { 
    // returns the first room to enter 
} 

public int calculateFloorCount() { 
    Room[] rooms = readRooms(); 
    int currentRoomIndex = getEntry(); 
    int minFloor = 0; 
    int maxFloor = 0; 
    int roomFloors[] = new int[rooms.length]; 
    boolean[] visited = new boolean[rooms.length]; 
    Stack<Integer> roomStack = new Stack<>(); 
    roomStack.push(currentRoomIndex); 
    // roomFloors[currentRoom] = 0; 
    // Arrays.fill(visted, false); both should happen automatically when the arrays are initialized 

    while (!roomStack.empty()) { 
    currentRoomIndex = roomStack.pop(); 
    // ignore already visited rooms 
    if (visited[currentRoomIndex]) continue; 
    visited[currentRoomIndex] = true; 
    Room room = rooms[currentRoomIndex]; 
    int currentFloor = roomFloors[currentRoomIndex]; 

    if (currentFloor > maxFloor) 
     maxFloor = currentFloor; 
    else if (currentFloor < minFloor) 
     minFloor = currentFloor; 

    // add room one floor up 
    if (room.neighborUp >= 0 && !visited[room.neighborUp]) { 
     roomFloors[room.neighborUp] = currentFloor+1; 
     roomStack.push(room.neighborUp); 
    } 

    // add room one floor down 
    if (room.neighborDown >= 0 && !visited[room.neighborDown]) { 
     roomFloors[room.neighborDown] = currentFloor-1; 
     roomStack.push(room.neighborDown); 
    } 

    // add rooms on the same floor 
    for (int i = 0; i < room.neighborsSameFloor.length; i++) { 
     int index = room.neighborsSameFloor[i]; 
     roomFloors[index] = currentFloor; 
     roomStack.push(index); 
    } 
    } 

    return maxFloor-minFloor+1; 
}