120. 三角形最小路径和

120. 三角形最小路径和

给定一个三角形 triangle ，找出自顶向下的最小路径和。

每一步只能移动到下一行中相邻的结点上。相邻的结点 在这里指的是 下标 与 上一层结点下标 相同或者等于 上一层结点下标 + 1 的两个结点。也就是说，如果正位于当前行的下标 i ，那么下一步可以移动到下一行的下标 i 或 i + 1 。

示例 1：

输入：triangle = [[2],[3,4],[6,5,7],[4,1,8,3]]
输出：11
解释：如下面简图所示：
   2
  3 4
 6 5 7
4 1 8 3
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

示例 2：

输入：triangle = [[-10]]
输出：-10

提示：

• 1 <= triangle.length <= 200
• triangle[0].length == 1
• triangle[i].length == triangle[i - 1].length + 1
• -10^4 <= triangle[i][j] <= 10^4

进阶：

• 你可以只使用 O(n) 的额外空间（n 为三角形的总行数）来解决这个问题吗？

动态规划，数组递推

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        // 定义：走到第 i 行第 j 个元素的最小路径和是 dp[i][j]
        int[][] dp = new int[n][n];
        
        for (int i = 0; i < dp.length; i++) {
            // 因为要求最小值，所以我们把元素全都初始化为极大值
            Arrays.fill(dp[i], Integer.MAX_VALUE);
        }
        
        // base case，第零行只有一个元素。
        dp[0][0] = triangle.get(0).get(0);
        
        // 进行状态转移。从三角形的第一行开始计算
        for (int i = 1; i < dp.length; i++) {
            // 获取该行的所有元素
            List<Integer> row = triangle.get(i);
            // 正序遍历该行的所有元素
            for (int j = 0; j < row.size(); j++) {
                // 状态转移方程。如果j>=1，则有两条路径走到(i,j)。
                if (j - 1 >= 0) {
                    dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1]) + row.get(j);
                } else { // 如果j=0，则只有一条路径走到(i,j)
                    dp[i][j] = dp[i - 1][j] + row.get(j);
                }
            }
        }
        
        // 找出落到最后一层的最小路径和
        int res = Integer.MAX_VALUE;
        for (int j = 0; j < dp[n - 1].length; j++) {
            res = Math.min(res, dp[n - 1][j]);
        }
        return res;
    }
}

• 时间复杂度：O(n^2)，其中 n 是三角形的行数。
• 空间复杂度：O(n^2)。我们需要一个 n∗n 的二维数组存放所有的状态。

滚动更新，O(n)

观察状态转移方程：

dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1]) + row.get(j);

我们发现dp数组中第i行的第j个元素的值依赖于上一行的第j和第j-1个元素，因此我们可以用滚动更新的方法优化空间复杂度。注意要正序遍历i，倒序遍历j，因为dp[i][j]依赖于dp[i-1][j-1]而不是dp[i][j-1]。

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        // 使用一维数组 dp 来存储当前行的最小路径和
        int[] dp = new int[n];
        // 初始化 dp 数组
        Arrays.fill(dp, Integer.MAX_VALUE);
        
        // base case
        dp[0] = triangle.get(0).get(0);
        
        // 进行状态转移
        for (int i = 1; i < n; i++) {
            List<Integer> row = triangle.get(i);
            // 从右向左遍历，先计算dp[j]，再计算dp[j-1]，以防止覆盖上一轮 dp[j-1] 的值，我们需要用上一轮的dp[j-1]计算dp[j]。
            for (int j = row.size() - 1; j >= 0; j--) {
                // 状态转移方程
                if (j - 1 >= 0) {
                    // 此时的dp[j-1]是上一轮i循环中的dp[j-1]，因为j是后序遍历的，所以此时 dp[j-1]还没有被更新。
                    dp[j] = Math.min(dp[j], dp[j - 1]) + row.get(j);
                } else {
                    dp[j] = dp[j] + row.get(j);
                }
            }
        }
        
        // 找出落到最后一层的最小路径和
        int res = Integer.MAX_VALUE;
        for (int j = 0; j < n; j++) {
            res = Math.min(res, dp[j]);
        }
        return res;
    }
}

• 时间复杂度：O(n^2)，其中 n 是三角形的行数。
• 空间复杂度：O(n)。