LeetCode 120. Triangle 三角形最小路径和（Java）

题目：

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.

解答：

本题是一道动态规划的题，寻找从顶至底的最小和路径，则每个位置都能通过上一层的相邻两个位置到达。令每个位置存储从顶到该位置的最小和路径，则我们可以得出：
该位置的最小和 = 上一层两个相邻的路径最小值 + 该位置的值
即状态转移方程为：dp[i][j]=Math.min(dp[i-1][j-1],dp[i-1][j])+list.get(j)

首先想到的思路为：用一个二维数组 min，存储到达每个位置的最小值。依次遍历原数组，从上一行能到达该点的两个点中选择小的那个点，然后加上当前点的值。对于每行的第一个点和最后一个点，只有一种方法能到达该点，所以直接加上当前点的值即可。最后遍历二维数组的最后一行，取最小值，即可得到最终结果

以题中数组为例，具体过程如下：

代码实现如下：

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int len = triangle.size();
        if(triangle.get(0).size() == 0) {
            return 0;
        }
        if(len == 1) {
            return triangle.get(0).get(0);
        }
        int[][] min = new int[len][len];
        min[0][0] = triangle.get(0).get(0);
        int res = Integer.MAX_VALUE;
        for(int i=1; i<len; i++) {
            List<Integer> list = triangle.get(i);
            for(int j=0; j<list.size(); j++) {
                if(j == 0) {
                    min[i][j] = min[i-1][j] + list.get(j);
                } else if (j == list.size()-1) {
                    min[i][j] = min[i-1][j-1] + list.get(j);
                } else {
                    min[i][j] = Math.min(min[i-1][j-1], min[i-1][j]) + list.get(j);
                }
                if(i == len-1) {
                    if(min[i][j] < res) {
                        res = min[i][j];
                    }
                }
            }
        }
        return res;
    }
}

但上述代码有很多不足之处，比如：

1. 采用了 O(n*n) 的额外空间，题目中要求我们尽量使用 O(n) 的额外空间
2. 需要进行很多特殊处理，比如：
   • 遍历前，对数组为空，或数组只有一行的特殊情况均需要
   • 进行处理
   • 数组 min[0][0] 的位置需要直接赋值
   • 遍历时，每一行第一个及最后一个数都需要单独进行逻辑处理

因此参考了他人代码，对以上进行了进一步优化

他人的优化思路为：定义一个 min[n+1] 的数组，然后从底向上进行遍历寻找，不断更新 min[] 的值，用一个一维数组保存当前行每个数的路径最小和，最终 min[0] 即为结果值。且状态转移过程中，不需要对每行中两侧的值进行单独的逻辑处理

具体思路如下：

代码实现如下：

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int len = triangle.size();
        if(len == 0) {
            return 0;
        }
        int[] min = new int[len+1];
        for(int i=len-1; i>=0; i--) {
            List<Integer> list = triangle.get(i);
            for(int j=0; j<list.size(); j++) {
                min[j] = Math.min(min[j], min[j+1]) + list.get(j);
            }
        }
        return min[0];
    }
}