矩阵从左上角向右下角走，每次只能向右或者向下移动，求经过最小的路径

最新推荐文章于 2021-07-17 10:49:46 发布

weixin_30646315

最新推荐文章于 2021-07-17 10:49:46 发布

阅读量1.5k

点赞数 1

CC 4.0 BY-SA版权

文章标签： c/c++ 数据结构与算法 java

原文链接：http://www.cnblogs.com/inception6-lxc/p/9316782.html

本文介绍了一种使用动态规划寻找矩阵中从起点到终点的最小路径的方法，并通过一个示例程序详细展示了如何实现这一算法。从初始化边界条件开始，逐步递推至目标位置，最后逆向追踪得到具体的路径。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

先通过动态规划求出最小路径的值，然后根据dp二维数组倒推所走路径。参考找出最大公共子序列解法。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;

int minsum(vector<vector<int>>a, vector<int>&reg){
    vector<vector<int>>dp(a.size(), vector<int>(a[0].size(), a[0][0]));
    
    for (int i = 1; i < a.size(); i++){
        dp[i][0] = dp[i - 1][0]+a[i][0];
    }
    for (int j = 1; j < a[0].size(); j++){
        dp[0][j] = dp[0][j - 1] + a[0][j];
    }
    for (int i = 1; i < a.size(); i++){
        for (int j = 1; j < a[0].size(); j++){
            dp[i][j] = min(dp[i - 1][j], dp[i][j - 1]) + a[i][j];
        }
    }
    /*for (int i = 0; i < dp.size(); i++){
        for (int j = 0; j < dp[0].size(); j++){
            cout << dp[i][j] << " ";
        }
        cout << endl;
    }*/
    
    int i = dp.size() - 1;
    int j = dp[0].size() - 1;
    while (i >= 0 && j >= 0){
        reg.push_back(a[i][j]);
        if (i > 0 && j > 0){
            if (dp[i][j - 1] > dp[i - 1][j]){
                i--;
            }
            else{
                j--;
            }
            continue;
        }
        else if (i == 0){
            j--;
        }
        else{
            i--;
        }
    }
    return dp[a.size()-1][a[0].size()-1];
}

int main(){
    vector<vector<int>>a = { { 1, 3, 1 }, { 1, 5, 1 }, { 4, 2, 1 } };
    vector<int>reg;
    int res = minsum(a,reg);
    reverse(reg.begin(), reg.end());
    for (int i = 0; i < reg.size(); i++){
        cout << reg[i] << endl;
    }

    system("pause");
    return 0;
}