Java 计算矩阵中的路径

这是家庭作业中的一个问题，我一直在想，如果有人能指点我，我会很高兴的

通过在第一个单元格（第0行COLLMN 0）处停留，并通过添加单元格中数字的第一位和第二位开始下一步，直到到达最后一个单元格（第n行COLLMN n），定义合法路径

例如： 如果在单元格[2][3]中有数字15，则下一步可以是： +第1行和第5行至[3][8] 或 +第5行和第1行至[7][4]

该方法应返回有多少合法路径

我尝试使用回溯递归方法来解决这个问题，除了重载方法之外，我不能使用任何循环或其他方法

以下是我到目前为止提出的代码：

public static int countPaths (int[][] mat)
{
    return countPaths(mat,0,0);
}

private static int countPaths(int[][] mat, int col, int row)
{


    if ((col==mat.length-1 && row==mat[0].length-1 )  {
        return 1;
    }    
    return countPaths(mat,mat[col][row]/10+col,mat[col][row]%10+row) + countPaths(mat,mat[col][row]%10-col,mat[col][row]/10-row);

} 

---

谢谢你的帮助

因为这是一个家庭作业，所以请给我一些提示

不仅返回1，还返回故障状态。例如，如果列或行大于长度，则返回0。（也可以使用true/false）

您正在添加两个递归函数。不要这样做，试着一个接一个地做。例如，首先使用（行+1，com+5）进行检查，如果它重试失败，则尝试（行+5，列+1）

“通过在第一个单元格（第0行，第0行）处停留，并通过将单元格中数字的第一位和第二位相加，直到到达最后一个单元格（第n行），来定义合法路径，并进入下一步。”

例如：如果在单元格[2][3]中有数字15，则下一步可以是：+1行+5行+5到[3][8]或+5行+1行+1到[7][4]。”

在我看来，你们确定行和列的逻辑在某种程度上是错的。不管怎样，你都应该得到相同的两个数字，只是把它们切换一下。我的建议是将数字值存储在变量中，以使代码更清晰。我知道如何解决这个问题，但如果我帮你解决，你就什么也学不到

---

正如另一位用户所指出的，我还要确保通过检查“死胡同”路径是否仍然有效来关闭它们。此时，返回0。

您就快到了，有几件事：

• 您对下一步可能尝试的步骤的计算似乎有错误
• 在访问数组/进行递归调用之前，应该检查边界，以避免ArrayOutOfBoundsException

---

如果我正确理解了问题，这是一个解决方案

公共类MatrixPathCounter{ 私有静态int[]mat={{10,11,0}，{10,11,10}，{10,10,0}

public static void main(String[] args)
{
    System.out.println(countPath(mat,0,0));
}

private static int countPath(int[][] mat, int x, int y)
{
    int n = mat.length -1;

    if (x==n && y==n)
        return 1;

    if(x>n || y>n)
        return 0;

    if(mat[x][y]==0)
        return 0;

    if(x+mat[x][y]/10 == x+mat[x][y]%10 && x+mat[x][y]%10 == x+mat[x][y]/10)
        return countPath(mat,x+mat[x][y]/10,y+mat[x][y]%10);
    else
        return countPath(mat,x+mat[x][y]/10,y+mat[x][y]%10) + countPath(mat,x+mat[x][y]%10,y+mat[x][y]/10 ); 
}

---

}以下是我的想法：

public static void main(String[] args)
{
    int[][] mat = 
        {
                {12, 22, 23, 54},
                {43, 35, 21, 20},
                {34, 21, 43, 21},
                {25, 30, 0,  20},
                {0,  22, 10, 10},
                {20, 13, 3,  45},
        };
    
    System.out.println(countPaths(mat)); // 3
}

public static int countPaths(int[][] mat)
{
    return countPaths(mat, 0, 0);
}

private static int countPaths(int[][] mat, int row, int col)
{           
    if (row == mat.length - 1 && col == mat[row].length - 1)
        return 1;
    
    if (row >= mat.length || col >= mat[row].length)
        return 0;
    
    if (mat[row][col] <= 0 || mat[row][col] >= 100)
        return 0;
    
    int currentNumber = mat[row][col];
    int rightDigit = currentNumber % 10, leftDigit = (currentNumber / 10) % 10;
    
    int r1 = countPaths(mat, row + rightDigit, col + leftDigit);
    int r2 = countPaths(mat, row + leftDigit, col + rightDigit);
    
    return r1 + r2;
}

publicstaticvoidmain（字符串[]args）
{
int[][]mat=
{
{12, 22, 23, 54},
{43, 35, 21, 20},
{34, 21, 43, 21},
{25, 30, 0,  20},
{0,  22, 10, 10},
{20, 13, 3,  45},
};
System.out.println（countpath（mat））；//3
}
公共静态int countpath（int[]mat）
{
返回计数路径（mat，0，0）；
}
私有静态int countpath（int[][]mat，int行，int列）
{           
if（row==mat.length-1&&col==mat[row].length-1）
返回1；
如果（行>=mat.length |列>=mat[row].length）
返回0；
如果（物料[行][列]=100）
返回0；
int currentNumber=mat[行][col]；
int rightDigit=currentNumber%10，leftDigit=（currentNumber/10）%10；
int r1=计数路径（mat、行+右位、列+左位）；
int r2=计数路径（矩阵、行+左位、列+右位）；
返回r1+r2；
}

问题是什么？@SimonAndréForsberg问题是OP遇到了这个问题，需要帮助。这是一个合理的问题。@LuiggiMendoza我只是不明白他被困在哪里了。如果我知道的更多，回答这个问题就会容易得多。是否有一些东西没有按预期工作？今天代码的结果是什么？“遗漏了什么？”西蒙南德·福斯伯格阅读了问题陈述。然后，阅读OP提供的代码。如果您都理解，那么您可以注意到递归方法的当前设计没有处理回溯解决方案（这是问题中的一个标记）。这不是离题，但这个问题首先不应该使用递归来解决。你应该告诉你的老师去学一个更好的例子。嘿，谢谢你的回答。如果我一个接一个地执行函数，那么我应该如何返回有多少合法路径，我需要计算路径。哦，我错过了。。好的，您可以使用计数器变量。它将在每次递归时增加1。。如果递归返回true，那么couter将是您的路径长度。如果为false，则减少1。这不是一个完全可靠的想法，因为我现在没有编码。。你可以试着这样想你假设的是一个正方形矩阵。对于家庭作业，你不应该给出完整的答案；只是暗示。（这只是我的观点，但我总是对的。）@EdwardFalk我之所以这样认为是因为他说：……直到到达最后一个牢房（n排）啊，好的。这可能是一个合理的假设。

public static void main(String[] args)
{
    int[][] mat = 
        {
                {12, 22, 23, 54},
                {43, 35, 21, 20},
                {34, 21, 43, 21},
                {25, 30, 0,  20},
                {0,  22, 10, 10},
                {20, 13, 3,  45},
        };
    
    System.out.println(countPaths(mat)); // 3
}

public static int countPaths(int[][] mat)
{
    return countPaths(mat, 0, 0);
}

private static int countPaths(int[][] mat, int row, int col)
{           
    if (row == mat.length - 1 && col == mat[row].length - 1)
        return 1;
    
    if (row >= mat.length || col >= mat[row].length)
        return 0;
    
    if (mat[row][col] <= 0 || mat[row][col] >= 100)
        return 0;
    
    int currentNumber = mat[row][col];
    int rightDigit = currentNumber % 10, leftDigit = (currentNumber / 10) % 10;
    
    int r1 = countPaths(mat, row + rightDigit, col + leftDigit);
    int r2 = countPaths(mat, row + leftDigit, col + rightDigit);
    
    return r1 + r2;
}