Algorithm 算法-最长路径网格难题

所以情况是：
1.有NxN网格，所以它是方形网格
2.将给出最大步数
3.网格中的每个单元格都有一定量的值，这将减少最大步长
4.我们只能向右和向下移动。
5.起点是网格的左上角，目标是网格的右下角。
6.我们需要确定最长路径（剩余最大步数最少的路径）
7.如果没有可能的路径，结果将为-1

因此，目前我已经编写了一个代码，可以处理某些情况，但仍然不是最佳情况。
我现在正在做的是：
1.检查右下一个值和下一个下一个值是否正确。
2.转到较大的值。
3.如果最大步长变为0，则返回上一个单元格并移动到另一个方向。
4.如果右值和下值相同，我将在下一个单元格之后检查下一个单元格

看来问题出在第四点

这是我的第四点代码：

private static int determineBestNext(int[][] grid, int currentX, int currentY) {
    int nextRight = 0;
    int nextBelow = 0;
    int numberOfRows = grid.length - 1;
    for(int i=currentX+1;i<numberOfRows-1;i++) {
        nextRight += grid[currentY][i+1];
        if(currentY != numberOfRows) {
            nextRight += grid[currentY+1][i+1];
        }
    }
    for(int i=currentY+1;i<numberOfRows-1;i++) {
        nextBelow = grid[i+1][currentX];
        if(currentX != numberOfRows) {
            nextBelow += grid[i+1][currentX+1];
        }
    }
    if(nextRight > nextBelow) {
        return 1;
    } else if (nextBelow > nextRight) {
        return 2;
    } else {
        return determineBestNext(grid, currentX+1,currentY+1);
    }
}

private static int determinatebestnext（int[][]网格，int currentX，int currentY）{
int-nextRight=0；
int nextBelow=0；
int numberOfRows=grid.length-1；
用于（int i=当前x+1；i下一个）{
返回2；
}否则{
返回determineBestNext（网格，currentX+1，currentY+1）；
}
}

我猜退步是当X大于Y时，Y中的步长更大，因此正确的概率值将大于X，反之亦然

你们还有别的想法吗？谢谢

---

谢谢

您可以在

O（n^2）

中找到最佳路径。我将调用（1,1）左上角的单元格（起点），网格（I，j）将是单元格的值。步骤（i，j）是到达单元（i，j）所需的最小步骤数

您可以快速识别关系

steps(i,j) = min(steps(i-1,j), steps(i,j-1)) + grid(i,j)  // if i,j > 1

如果

i=1

或

j=1

或

i=j=1

则更容易，因为只有一条可能的路径

所以我们要计算

步数（N，N）

，我们得到

步数（N，N）=min（步数（N-1，N），步数（N，N-1））+网格（N，N）

。对于计算，我们需要

步骤（N-1，N）

和

步骤（N，N-1）

。因此

步骤（N-1，N）=min（步骤（N-2，N），步骤（N-1，N-1））+网格（N-1，N）

和

步骤（N，N-1）=min（步骤（N-1，N-1），步骤（N，N-2））+网格（N，N-1）

。我们看到，对于每个结果，我们都需要

步骤（N-1，N-1）

的值。这将是一个腰围，计算两次这个值。如果我们只计算一次并记住值，我们可以保存一次计算。这些事情经常发生

记住的最好方法是有一个固定的评估顺序。 下面是一些伪代码：

function getBestPath(grid, N)
    steps = new N x N int-array //initialized with 0

    //first row
    steps[0][0] = grid[0][0] 
    // only one path to get to (0,0), it's doing nothing
    for (i = 1; i < N; i++)
        steps[0][i] = steps[0][i-1] + grid[0][i] 
        // only one path each, just going right

    //other rows
    for (row = 1; row < N; row++)
        steps[row][0] = steps[row-1][0] + grid[row][0] 
        //only one way to get to (row,0), only go down

        for (i = 1; i < N; i++)
            steps[row][i] = min(steps[row-1][i], steps[row][i-1]) + grid[row][i]

    return steps[N-1][N-1]

函数getBestPath（网格，N） 步骤=新的N x N int数组//用0初始化 //第一排 步骤[0][0]=网格[0][0] //只有一条路径可以到达（0,0），它什么也不做 对于（i=1；i第7点让我觉得您遗漏了一些细节

什么时候不可能有路径？是否假设阶跃量必须为非负

如果不是，那么路径总是可能的，并且一个简单的动态规划O（N^2）算法是可能的，正如另一个答案告诉您的那样

---

你是否试图通过修改问题和遗漏过程中的重要细节来在编程测试中作弊？

我猜你有点误解了我的问题，但你的回答让我想到了一个点子。实际上，我想要的不是最短的路径，而是最昂贵的路径