Question

我试图在棋盘上找到左上角和右下角的单元格之间的路径数。我只能移动到相邻的右侧和相邻的底部单元格。这样我最多可以有2个不相交的简单路径。我正在使用递归方法。

    private void processMatrix() 
{
    if(matrix[0][0]!=1 || matrix[0][0]!=matrix[ROWS-1][COLUMNS-1])
        System.out.println("No Path Exists between bottom right and top left cells");
    int row=0;
    int col=0;
    traverse(row,col);
}

    private boolean traverse(int row, int col) 
{
    path.add(new Point(row,col));

    if(row+1<ROWS)
    {
        if(matrix[row+1][col]==0)
        {
            return false;
        }
        if(matrix[row+1][col]==1)
        {
            traverse(row+1,col);
        }
    }
    if(col+1<COLUMNS)
    {
        if(matrix[row][col+1]==0)
         {
             return false;
         }
        if(matrix[row][col+1]==1)
        {
            traverse(row,col+1);
        }
    }
    if(col==COLUMNS-1 && row==ROWS-1)
        return true;
    return false;
}

但是使用这段代码我只能遍历下三角矩阵。当我在traverse（）函数中反转if块的顺序时，我只能遍历上三角矩阵中的路径。无法弄清楚出了什么问题。我也想检测交叉路径。请帮忙。

修改矩阵由0和1组成。如果路径由仅包含1的相邻单元连接，则存在路径。换句话说，路径将是1的链。

Answer 1

您的代码似乎过于复杂。如果矩阵为0和1，则使用布尔值而不是int。非交叉路径似乎有点傻，因为所有路径在出租车几何中都同样有效。这是找到所有路径的简单解决方案，它将向您展示它如何与system.out打印块一起工作：

int rows = 9;
int columns = 8;
boolean[][] matrix = new boolean[rows][columns];
for (boolean[] arr : matrix) {/* Set values of matrix such that true = can pass thru that space, false = space blocked */
    Arrays.fill(arr, true);
}
matrix[4][6] = false;
matrix[2][5] = false;
int[][] paths = new int[rows][columns];//number of paths reaching each space in i steps
paths[0][0] = 1; //Starting space
for (int i = 0; i < rows + columns - 2; i++) {//Taxicab distance is always x+y, i = distance travelled so far
    int[][] newPaths = new int[rows][columns]; //number of paths reaching each space in i+1 steps
    for (int x = i >= columns ? i - columns + 1 : 0; x <= i && x < rows;) { //x is traditionally columns but it doesn't matter
        int y = i - x; //if statement is x declaration ensures that this is < columns
        int newX = x + 1; //will be used repeatedly
        int newY = y + 1; //will be used repeatedly
        if (newX < rows && matrix[newX][y]) newPaths[newX][y] += paths[x][y];
        if (newY < columns && matrix[x][newY]) newPaths[x][newY] += paths[x][y];
        x = newX;
    }
    paths = newPaths;
    for (int x = 0; x < rows; x++) { //optional, show the algorithm at work
        for (int y = 0; y < columns; y++) {
            int r = paths[x][y];
            System.out.print(r);
            if (r < 100) System.out.print(" ");
            if (r < 10) System.out.print(" ");
        }
        System.out.println();
    }
    System.out.println();
}
System.out.println(paths[rows - 1][columns - 1]); //result

如果要确定路径是否存在，请用boolean [] []路径替换int [] []路径并相应地更改操作。

Answer 2

这是一个基本的动态编程问题。

让dp[R][C]为从左上角的单元格到行R和列C上的单元格的路径数（1索引）。

初始值（当R或C为1时）：
- dp[R][1] = 0如果dp[1][C] = 1的值为matrix[1][j]，则为j = 1..C。
如果dp[1][C] = 0，则dp[R][C] = dp[R-1][C] + dp[R][C-1]，否则matrix[R][C] = 1（对于R，C＆gt; = 2）

就是这样。这个想法背后的直觉是，如果我们知道我们可以通过N个不同的道路进入R-1排C列，那么如果我们下降一次，我们将获得N个不同的道路到单元格[R，C]。类似地，从细胞[R，C-1]到[R，C]。

最后，答案在dp[R][C] = 0，其中N和M是矩阵的维度。

无法在网格中查找路径

2 个答案: