矩阵&三角形最小路径和

最小路径和

方阵中的最小路径和

给定一个包含非负整数的 m x n 网格，请找出一条从左上角到右下角的路径，使得路径上的数字总和为最小。

说明：每次只能向下或者向右移动一步。

贪婪法，从终点开始，到每一个方块都计算出最小路径，然后一直反推到起点。

int minPathSum(vector<vector<int>>& grid) {
    int m,n;
    n=grid.size();
    m=grid[0].size();
    if(!n)
        return 0;
    int temp=0;
    for(int i=m-1;i>=0;--i)   //将最下面一条边和最右边一条的值先计算出来
    {
        temp+=grid[n-1][i];
        grid[n-1][i]=temp;
    }
    temp=0;
    for(int j=n-1;j>=0;--j)
    {
        temp+=grid[j][m-1];
        grid[j][m-1]=temp;
    }
    for (int j=2; j <= n; ++j) {
        for (int i=2; i <= m; ++i) {

            grid[n-j][m-i] = min(grid[n-j+1][m-i] , grid[n-j][m-i+1])+grid[n-j][m-i];
        }
    }

    return grid[0][0];
}

三角形中的最小路径和

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
例如，给定三角形：

[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
最短路径为1+5+3+2=11

自顶向下，对每一步都计算出最小路径和。然后遍历找出底部一排的最小值。
这里有一个问题是，自顶向下的方法所比较的最小值，不是三角形中的值，而是前一步计算出来的value值。

int minimumTotal(vector<vector<int>>& triangle) {
    int n;
    int temp;
    n=triangle.size();
    int *value=new int [n];
    int *pre=new int [n];
    if(!n)
        return 0;
    for(int i=0;i<n;++i) {
        value[i] = 0;
        pre[i]=0;
    }
    value[0]=triangle[0][0];
    pre[0]=triangle[0][0];
    for(int i=1;i<n;++i) {
        for (int j = 0; j <= i; ++j) {
            if (j == 0)
                value[j] = pre[j] + triangle[i][j];
            else if (j == i)
                value[j] = pre[j-1] + triangle[i][j];
            else value[j] = triangle[i][j] + min(pre[j], pre[j - 1]);
        }
        for(int k=0;k<=i;++k)
            pre[k]=value[k];
    }
    int MIn=value[0];
    for(int i=0;i<n;++i)
    {
        if(MIn>value[i])
            MIn=value[i];
    }
    return MIn;
}

自底向上更简单，不需要考虑边界情况，而且最后仅剩下唯一值，即为结果

int minimumTotal(vector<vector<int>>& triangle) {
    int n = triangle.size();
        vector<vector<int>> dp(triangle);
                
        for(int i=n-2;i>=0;i--) {        
            for(int j=0; j<triangle[i].size(); j++) {
                dp[i][j] = min(dp[i+1][j], dp[i+1][j+1]) + triangle[i][j];
            }
        }
        return dp[0][0];
    }