【LeetCode】120. Triangle 基于C++和Java的分析及解法，动态规划

120. Triangle

Total Accepted: 69567 Total Submissions: 229977 Difficulty: Medium

Given a triangle, find the minimum path sum from top to bottom. Each step you may move to adjacent numbers on the row below.

For example, given the following triangle

[
     [2],
    [3,4],
   [6,5,7],
  [4,1,8,3]
]

The minimum path sum from top to bottom is 11 (i.e., 2 + 3 + 5 + 1 = 11).

Note:
Bonus point if you are able to do this using only O(n) extra space, where n is the total number of rows in the triangle.

【分析】

    首先重述一下题意：输入一个（等腰）三角形数阵，寻找从三角形顶部达到底部的最小路径和，从顶部达到底部的过程中，从上一行的某个位置只能移动到下一行的与其相邻位置，如题中举例：第一行的2可以移动到第二行的3或者4；第二行的3只能移动到第三行的6或者5，第二行的4只能移动到第三行中的5或者7，以此类推。

     此题明显是一个求取约束条件下最小路径的题，用动态规划（Dynamic Programming）解再合适不过，既然是DP问题，那么我们需要抽象出状态转移方程：把三角形数阵可以抽象成一个二维矩阵，那么：

     设：从位置（i,j）达到底部的最小路径和为MP(i,j)；根据约束条件，从位置（i,j）只能达到下一行的（i+1,j）和（i+1,j+1）两个位置；如果，根据题意我们知道，位置（i,j）处的权值为输入三角形数阵对应的数据：triangle[i][j];So,状态转移方程为：MP(i,j)=min{MP(i+1,j),MP(i+1,j+1)}+triangle[i][j];三角形顶部到底部最小路径和：MP(0,0)=min{MP(1,0),MP(1,1)}+triangle[0][0];而：MP(1,0)=min{MP(2,0),MP(2,1)}+triangle[1][0];MP(1,1)=min{MP(2,1),MP(2,2)}+triangle[1][1]....

    很明显，这种自顶向下的求解方式会形成一个“树形结构”，并且自顶向下的求解过程，计算式中一直存在未知式，这显然不是一种好的方式，因此，我们采用自底向上的求解思路：以题目中给出的例子为例：

MP(3,0)=triangle[3][0]=4;

MP(3,1)=triangle[3][1]=1;

MP(3,2)=triangle[3][1]=8;

MP(3,3)=triangle[3][1]=3;

MP(2,0)=min{MP(3,0),MP(3,1)}+triangle[2][0]=1+6=7;

MP(2,1)=min{MP(3,1),MP(3,2)}+triangle[2][1]=1+5=6;

MP(2,2)=min{MP(3,2),MP(3,3)}+triangle[2][2]=3+7=10;

MP(1,0)=min{MP(2,0),MP(2,1)}+triangle[1][0]=6+3=9;

MP(1,1)=min{MP(2,1),MP(2,2)}+triangle[1][1]=6+6=12;

MP(0,0)=min{MP(1,0),MP(1,1)}+triangle[0][0]=9+2=11;

很明显，自底向上计算，最后MP(0,0)就是我们要的结果，采用两重循环即可完成求解,程序如下：

int minimumTotal(vector<vector<int>>& triangle) 
    {
        int length=triangle.size();
        if(length==0)return 0;
        if(length==1)return triangle[0][0];
        vector<int>temp(triangle.size(),0);   
        vector<vector<int>> MP(length,temp);
        MP[length-1]=triangle[length-1];//三角形底部一行任何一个位置达到底部最短路径为其本身
        
        for(int i=length-2;i>=0;i--)
        {
            for(int j=0;j<triangle[i].size();j++)
            {
                MP[i][j]=min(MP[i+1][j],MP[i+1][j+1])+triangle[i][j];
            }
        }
        return MP[0][0];
    }

       但是，像这样解决，需要消耗额外的空间，空间复杂度为O(n2)，因此该解法不可取，我们可以对其进行改进，借助输入数阵本身的空间来存储中间的迭代值：

完整代码为：

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

            分析：这样做虽然表面上节省了空间消耗，但是事实上依赖于输入数阵的空间，空间消耗并没有实际减小，并且会改变输入三角形数阵的原始数据，很多时候，这样做都是不可取的。

【解法一：基于C++解法】

    经过上面的分析，我们进一步优化空间消耗的问题，事实上，我们可以用一个一维数组来存储自底向上的路径向量，路径向量初始化为三角形数阵底部向量，此后每计算一次，更新一次，空间复杂度为O(n),且不影响输入三角形数阵的原始数据，程序如下：

int minimumTotal(vector<vector<int>>& triangle) 
    {
        int length=triangle.size();
        if(length==0)return 0;//特殊情况处理，容错机制
        if(length==1)return triangle[0][0];  
        vector<int> sum=triangle[triangle.size()-1];//初始化路径和存储向量，自底向上
        
        for(int i=triangle.size()-2;i>=0;i--)//自底向上迭代
        {
            for(int j=0;j<triangle[i].size();j++)
            {
                sum[j]=min(triangle[i][j]+sum[j],triangle[i][j]+sum[j+1]);
            }
        }
        return sum[0];
    }

运行结果：

【解法二：基于Java的解法】

     根据上面的思路，Java的解法程序如下：

public int minimumTotal(List<List<Integer>> triangle)
    {
        int length=triangle.size();
        if(length==0)return 0;
        if(length==1)return triangle.get(0).get(0);
        
        List<Integer> sum=triangle.get(length-1);
        for(int i=length-2;i>=0;i--)
        {
            for(int j=0;j<triangle.get(i).size();j++)
            {
                int sum1=triangle.get(i).get(j)+sum.get(j);
                int sum2=triangle.get(i).get(j)+sum.get(j+1);
                sum.set(j,Math.min(sum1,sum2));
            }
        }
        return sum.get(0);
        
    }