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

题目

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。
相邻的结点在这里指的是下标与上一层结点下标相同或者等于上一层结点下标 + 1的两个结点。

【例如】给定三角形：

[
[2],
[3,4],
[6,5,7],
[4,1,8,3]
]
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

【说明】
如果你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题，那么你的算法会很加分。

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/triangle
著作权归领扣网络所有。商业转载请联系官方授权，非商业转载请注明出处。

思路一

最简单粗暴的思路是遍历所有路径，找出最小值。遍历路径问题最容易想到的方法是深度优先遍历，代码如下：

public int minimumTriangle(List<List<Integer>> triangle){
    // 特殊值处理
    int len = triangle.size();
    if(len == 0){
       return 0;
    }
    if(len == 1){
       return triangle.get(0).get(0);
    }
    
    // 记录每次选择的路径
    List<Integer> path = new ArrayList<>(triangle.size());
    // 记录每一条路径的路径和
    List<Integer> pathSum = new ArrayList<>();
    // 深度优先遍历
    dfsTriangle(triangle, path, pathSum, 0, 0);
    
    // 找出 pathSum 中的最小值
    int min = Integer.MAX_VALUE;
    for(int num : pathSum){
       min = Math.min(min, num);
    }
    return min;
}

    /**
     * 深度优先遍历
     * @param triangle
     * @param path 当前路径
     * @param pathSum 记录每一条完整路径的路径和
     * @param row 当前行
     * @param index 当前列
     */
    private void dfsTriangle(List<List<Integer>> triangle, List<Integer> path, List<Integer> pathSum, int row, int index){
    // 当 path 的大小等于三角形行数时，说明已完成一条路径
    // 求当前路径和，添加至 pathSum
    if(path.size() == triangle.size()){
        int sum = 0;
        for(int num : path){
            sum += num;
        }
        pathSum.add(sum);
        return;
    }

    // 分别将下一行可选的位置添加进路径
    for(int i = index; i <= index + 1; i++){
        if(i == triangle.get(row).size()){
            continue;
        }
        path.add(triangle.get(row).get(i));
        dfsTriangle(triangle, path, pathSum, row + 1, i);
        path.remove(path.size() - 1);
    }
}

该方法的问题在于需要对所有可能情况进行遍历，时间复杂度高，超时

思路二

寻找最优解的问题通常可转化为动态规划问题。
设$f(i,j)$为走到$(i,j)$处时的最小路径和，则转移方程为
$$\{\begin{array}{ll}f(i-1,j)+triangle(i,j)& j=0\\ Min(f(i-1,j-1),f(i-1,j)+triangle(i,j)& 0<j<i\\ f(i-1,j-1)+triangle(i,j)& j=i\end{array}$$
代码如下：

public int minimumTriangle(List<List<Integer>> triangle){
    // 特殊值判断
    int row = triangle.size();
    if(row == 0){
        return 0;
    }
    
    // 建立 n * n 的动态规划数组并初始化
    int[][] dp = new int[row][row];
    dp[0][0] = triangle.get(0).get(0);

    // 通过转移方程填满动态规划数组
    for(int r = 1; r < row; r++){
        for(int c = 0; c <= r; c++){
            int f1 = c > 0 ? dp[r-1][c-1] : Integer.MAX_VALUE;
            int f2 = c < r ? dp[r-1][c] : Integer.MAX_VALUE;
            dp[r][c] = Math.min(f1, f2) + triangle.get(r).get(c);
        }
    }

    // 找出最后一行的最小值
    int min = Integer.MAX_VALUE;
    for(int num : dp[row - 1]){
        min = Math.min(num, min);
    }
    return min;
}

思路三

在思路二的基础上进行空间优化。由于每一行的结果只与上一行有关，所以可以将 n*n 的动态规划数组简化为两个长度为 n 的一维数组，根据行号的奇偶性交替更新。
代码如下：

public int minimumTriangle(List<List<Integer>> triangle){
    // 特殊值处理
    int row = triangle.size();
    if(row == 0){
        return 0;
    }

    // 2 * n 的动态规划数组
    int[][] dp = new int[2][row];
    dp[0][0] = triangle.get(0).get(0);

    for(int r = 1; r < row; r++){
        for(int c = 0; c <= r; c++){
            // 当前行号
            int curRow = r % 2;
            int f1 = c > 0 ? dp[1 - curRow][c - 1] : Integer.MAX_VALUE;
            int f2 = c < r ? dp[1 - curRow][c] : Integer.MAX_VALUE;
            dp[curRow][c] = Math.min(f1, f2) + triangle.get(r).get(c);
        }
    }

    int min = Integer.MAX_VALUE;
    for(int num : dp[1 - row % 2]){
        min = Math.min(min, num);
    }
    return min;
}