Question

我想用Java创建一个程序来计算机器人从网格T（x，y）左上角到左下角的路径数。使用网格中的每个方块只使用一次并使用网格中的所有方块。机器人可以向左和向下移动，使其更复杂。我知道这是一个递归程序，我只是不知道如何实现它。

Answer 1

那么，你需要知道什么？您需要知道电路板的当前状态以及机器人的位置。从那里，您可以探索尚未访问过的每个相邻单元格。在浏览每个单元格时，应用递归算法来探索其相邻单元格。最终，每次探索都会找到目标，或者没有机会。

基本算法看起来像这样：

explore(board, position) {
  if (position == goal) {
    count++
    return
  }
  board.mark(position)
  for cell in position.neighbors
     if not board.ismarked(cell)
       explore(board, cell)
  board.unmark(position)
}

Answer 2

你需要跟踪自由方格的数量，当你到达左下角时，检查你是否用尽了所有方格。

static int countPaths(boolean[][] grid) {
    int freeSquares = 0;
    for(int y = 0; y < grid.length; y++) {
        for(int x = 0; x < grid[y].length; x++) {
            if(grid[y][x]) freeSquares++;
        }
    }
    return _countPaths(grid, 0, 0, freeSquares);
}

static int _countPaths(boolean[][] grid, int x, int y, int freeSquares) {
    if(!grid[y][x]) return 0;
    if(y == grid.length-1 && x == 0) { // bottom left
        if(freeSquares == 1) return 1;
        else return 0;
    }
    int sum = 0;
    grid[y][x] = false;
    for(int dy = -1; dy <= 1; dy++) {
        for(int dx = -1; dx <= 1; dx++) {
            int newX = x+dx, newY = y+dy;
            if(newX < 0 || newY < 0 || newY >= grid.length || newX >= grid[y].length) continue;
            if((dx == 0 && dy == 0) || (dx != 0 && dy != 0)) continue;
            sum += _countPaths(grid, x+dx, y+dy, freeSquares-1);
        }
    }
    grid[y][x] = true;
    return sum;
}

public static void main (String args[]) {
    boolean[][] grid = {{true, true, true, false},
                        {true, true, true, false},
                        {true, true, true,  true},
                        {true, true, true,  true}};
    System.out.println(countPaths(grid));
}

计算X×Y网格中路径数的算法

2 个答案: