在矩阵中找到最少和最加权的路径

如何解决在矩阵中找到最少和最加权的路径

我尝试使用最有效的方法来找到从[min（m），min（n）]到[max（m），max（n）]穿过矩阵的最小和最大权重路径，选择一个步骤[m，n]时，下一步应该是[m + i，n + j]。

+---+----+---+---+---+---+----+
| 1 | 0  | 5 | 2 | 5 | 4 | 10 |
+---+----+---+---+---+---+----+
| 2 | 3  | 2 | 5 | 0 | 0 | 1  |
+---+----+---+---+---+---+----+
| 1 | 3  | 5 | 1 | 4 | 1 | 1  |
+---+----+---+---+---+---+----+
| 0 | 0  | 0 | 1 | 2 | 3 | 5  |
+---+----+---+---+---+---+----+
| 2 | 3  | 4 | 2 | 3 | 1 | 1  |
+---+----+---+---+---+---+----+
| 0 | 10 | 1 | 2 | 2 | 3 | 10 |
+---+----+---+---+---+---+----+

这是一个生成的矩阵，应该使用哪种算法，或者对如何进行处理有任何建议？预先感谢。

编辑：感谢您的帮助，但是当我放入下面的测试用例时，我感到很奇怪：

+---+---+---+---+---+
| 0 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+
| 0 | 0 | 1 | 0 | 0 |
+---+---+---+---+---+
| 0 | 0 | 1 | 0 | 0 |
+---+---+---+---+---+
| 0 | 0 | 0 | 0 | 0 |
+---+---+---+---+---+

在上述测试案例中，预期最大重量路径的成本为1。

我很抱歉在线程中未提及，所以i和j必须> = 1，因此下一步不应位于同一列或同一行。

解决方法

这可以通过动态编程解决，因为矩阵上没有负值。

如亨利所说，寻找最小值路径（这只是通向max（m），max（n）的直接路径）没有意义。

此代码将找到最大值。

#include <iostream>
#include <vector>

using namespace std;

int main()
{
    int n,m;
    cin >> n >> m;
    vector<vector<int>> arr;
    arr.resize(n + 1);
    for (int i = 1; i <= n; i++) {
        arr[i].resize(m + 1);
        for (int j = 1; j <= m; j++) {
            cin >> arr[i][j];
        }
    }

    for (int i = n; i >= 1; i--) {
        for (int j = m; j >= 1; j--) {
            int maxval;
            if (i == n && j == m) continue;
            else if (i == n) {
                maxval = arr[i][j + 1];
            }
            else if(j == m) {
                maxval = arr[i + 1][j];
            }
            else {
                maxval = arr[i + 1][j] > arr[i][j + 1] ? arr[i + 1][j] : arr[i][j + 1];
            }           
            arr[i][j] += maxval;
        }
    }

    cout << arr[1][1];
    
    return 0;
}
//test case
//6 7
//1 0 5 2 5 4 10 
//2 3 2 5 0 0 1  
//1 3 5 1 4 1 1  
//0 0 0 1 2 3 5 
//2 3 4 2 3 1 1 
//0 10 1 2 2 3 10 
//answer : 45

,

可以使用动态编程方法解决该问题。即使在给定矩阵上存在负值，也可以实现正确的解决方案。

定义和注意事项：
数组索引从0开始。
A->输入矩阵（n行m列）
DP->用于存储计算值的矩阵
如果x≤x + a

DP [i] [j]存储从（0，0）开始到（i，j）结束的最小成本路径的成本。计算后，可以在DP [n-1] [m-1]找到问题的答案。

定义重复关系：

为了避免在DP [i] [j]的计算中出现O（n ² ）循环，我们使用辅助矩阵MN，其中：

您可以自己证明平等。

代码：

for(int i = 0; i < n; ++i)
    for(int j = 0; j < m; ++j)
    {
        if(i == 0 && j == 0)
            MN[i][j] = DP[i][j] = A[i][j];
        else if(i == 0 && 0 < j)
        {
            DP[i][j] = MN[i][j - 1] + A[i][j];
            MN[i][j] = min(MN[i][j - 1],DP[i][j]);
        }
        else if(0 < i && j == 0)
        {
            DP[i][j] = MN[i - 1][j] + A[i][j];
            MN[i][j] = min(MN[i - 1][j],DP[i][j]);
        }
        else
        {
            DP[i][j] = min(MN[i - 1][j],MN[i][j - 1]) + A[i][j];
            MN[i][j] = min({MN[i - 1][j],MN[i][j - 1],DP[i][j]});
        }
    }

时间复杂度：
有n * m个元素，我们对每个元素执行恒定时间操作，因此算法的运行时间为O（n * m）。

注意： 要解决最大成本问题，只需使用max而不是min操作。