Java 查找两个单元格之间的路由数

以下是练习： 我需要编写一个递归方法，该方法以n*n的大小获取具有正整数的矩阵、起始单元格行和列索引以及结束单元格行和列索引，并且该方法需要返回从起始单元格到结束单元格的可能路由数，这些约束条件包括： a、 您可以从当前位置移动到左侧单元格、右侧单元格、上部单元格或下部单元格 b、 您不能穿过主对角线，但可以进入对角线上的单元格（但不能穿过）。 c、 路由中的每个单元只发生一次。 D矩阵需要像原始矩阵一样，在末尾有原始单元格值

以下是我目前得到的信息：

public static int numPaths (int[][] mat,int x1, int y1, int x2, int y2){
        if(x1>y1 || x2>y2 || y1<x1 || y2<x2) return 0;
        return numPaths(mat ,x1, y1, x2, y2, x1, y1);
    }
    public static int numPaths (int[][] mat ,int x1, int y1, int x2, int y2, int row, int col){
        if(row<0 || col <0 || row>=mat.length || col>=mat.length ) return 0;
        if(row==x2 && col==y2){ 
            return 1;
        }
        if(row==col){ 
            return numPaths ( mat ,x1, y1, x2, y2, row, col+1) + numPaths( mat ,x1, y1, x2, y2, row-1,col);

        }
        else{
            return numPaths( mat ,x1, y1, x2, y2, row, col+1) + numPaths( mat ,x1, y1, x2, y2, row+1, col)+
                    numPaths( mat ,x1, y1, x2, y2, row-1, col) + numPaths( mat ,x1, y1, x2, y2, row, col-1);    
            }

        }

public static int numPaths（int[][]mat，int-x1，int-y1，int-x2，int-y2）{
如果（x1>y1 | | x2>y2 | | y1如果您打算使用该矩阵来存储是否访问了某个单元格，那么最好将其设置为布尔矩阵。然后，只需在递归之前将该值设置为true，然后再设置为false即可

像下面这样的东西应该可以工作。我已经将变量移动到类中，因为似乎没有必要传递它们

比如：

private final int size;
private final boolean visited[][] = new boolean[size][size];

public int numPaths(int x, int y) {
    if (visited[x][y] || x < 0 || y < 0 || x >= size || y >= size)
        return 0;
    if (x == size - 1 && y == size - 1)
        return 1;
    visited[x][y] = true;
    int numPaths = 0;
    numPaths += numPaths(x - 1, y) + numPaths(x, y - 1);
    if (x != y)
        numPaths += numPaths(x + 1, y) + numPaths(x, y + 1;
    visited[x][y] = false;
    return numPaths;
}

私有最终整数大小；
访问的私有最终布尔值[][]=新布尔值[size][size]；
公共整数（整数x，整数y）{
如果（访问[x][y]| | x<0 | | | y<0 | | x>=大小| | y>=大小）
返回0；
如果（x==大小-1&&y==大小-1）
返回1；
访问[x][y]=真；
int numpath=0；
numPaths+=numPaths（x-1，y）+numPaths（x，y-1）；
如果（x！=y）
numPaths+=numPaths（x+1，y）+numPaths（x，y+1；
访问[x][y]=错误；
返回数值；
}
如果您打算使用该矩阵来存储是否访问了某个单元格，那么最好将其设置为布尔矩阵。然后，只需在递归之前将该值设置为true，然后再设置为false即可

像下面这样的东西应该可以工作。我已经将变量移动到类中，因为似乎没有必要传递它们

比如：

private final int size;
private final boolean visited[][] = new boolean[size][size];

public int numPaths(int x, int y) {
    if (visited[x][y] || x < 0 || y < 0 || x >= size || y >= size)
        return 0;
    if (x == size - 1 && y == size - 1)
        return 1;
    visited[x][y] = true;
    int numPaths = 0;
    numPaths += numPaths(x - 1, y) + numPaths(x, y - 1);
    if (x != y)
        numPaths += numPaths(x + 1, y) + numPaths(x, y + 1;
    visited[x][y] = false;
    return numPaths;
}

私有最终整数大小；
访问的私有最终布尔值[][]=新布尔值[size][size]；
公共整数（整数x，整数y）{
如果（访问[x][y]| | x<0 | | | y<0 | | x>=大小| | y>=大小）
返回0；
如果（x==大小-1&&y==大小-1）
返回1；
访问[x][y]=真；
int numpath=0；
numPaths+=numPaths（x-1，y）+numPaths（x，y-1）；
如果（x！=y）
numPaths+=numPaths（x+1，y）+numPaths（x，y+1；
访问[x][y]=错误；
返回数值；
}
您从未引用过矩阵中的任何值。这是否正确？如果是，为什么要将其传递给该方法？这只是为了通过半个矩阵找到所有潜在路径吗？如果是这样，随着潜在路径的数量呈指数级增加，大矩阵肯定会出现堆栈溢出。对于具有已知路径的小矩阵，请尝试使用此方法在尝试任何较大的操作之前，确保其行为的路径数。您从不引用矩阵中的任何值。这是否正确？如果是，为什么要将其传递给该方法？这只是为了通过半个矩阵找到所有潜在路径？如果是，则肯定会将大型矩阵的溢出作为矩阵中潜在路径的数量进行堆栈以指数方式折痕。在尝试任何大的操作之前，请先尝试具有已知路径数的小矩阵，以确保其行为正常。