LeetCode刷题第十二天（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

方法一 动态规划

算法思想

我们用 $f[i][j]$ 表示从三角形顶部走到位置 $(i,j)$ 的最小路径和。这里的位置 $(i,j)$ 指的是三角形中第 iii 行第 jjj 列（均从 $0$ 开始编号）的位置。

由于每一步只能移动到下一行「相邻的节点」上，因此要想走到位置 $(i,j)$，上一步就只能在位置 $(i-1,j-1)$ 或者位置 $(i-1,j)$。我们在这两个位置中选择一个路径和较小的来进行转移，状态转移方程为：

$f[i][j]=min(f[i-1][j-1],f[i-1][j])+c[i][j]$

其中 $c[i][j]$ 表示位置 $(i,j)$ 对应的元素值。

注意第 $i$ 行有 $i+1$ 个元素，它们对应的 $j$ 的范围为 $[0,i]$。当 $j=0$ 或 $j=i$ 时，上述状态转移方程中有一些项是没有意义的。例如当 $j=0$ 时，$f[i-1][j-1]$ 没有意义，因此状态转移方程为：

$f[i][0]=f[i-1][0]+c[i][0]$

即当我们在第 iii 行的最左侧时，我们只能从第 $i-1$ 行的最左侧移动过来。当 $j=i$ 时，$f[i-1][j]$ 没有意义，因此状态转移方程为：

$f[i][i]=f[i-1][i-1]+c[i][i]$

即当我们在第 $i$ 行的最右侧时，我们只能从第 $i-1$ 行的最右侧移动过来。

最终的答案即为 $f[n-1][0]$ 到 $f[n-1][n-1]$ 中的最小值，其中 $n$ 是三角形的行数。

细节
状态转移方程的边界条件是什么？由于我们已经去除了所有「没有意义」的状态，因此边界条件可以定为：

$f[0][0]=c[0][0]$

即在三角形的顶部时，最小路径和就等于对应位置的元素值。这样一来，我们从 $1$ 开始递增地枚举 $i$，并在 $[0,i]$ 的范围内递增地枚举 $j$，就可以完成所有状态的计算。

JAVA代码

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {

        int n =triangle.size();
        int[][] f =new int[n][n];
        f[0][0]=triangle.get(0).get(0);
        for(int i =1;i<n;i++){
            f[i][0]=f[i-1][0]+triangle.get(i).get(0);
            for(int j = 1;j<i;j++){
                f[i][j]=Math.min(f[i-1][j-1],f[i-1][j])+triangle.get(i).get(j);
            }
            f[i][i]=f[i-1][i-1]+triangle.get(i).get(i);
        }
        int min=f[n-1][0];
        for(int i =1;i<n;i++){
            min=Math.min(min,f[n-1][i]);
        }
        return min;
    }
}

复杂度分析

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

方法二：动态规划 + 空间优化

算法思想

JAVA代码

class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        int[][] f = new int[2][n];
        f[0][0] = triangle.get(0).get(0);
        for (int i = 1; i < n; ++i) {
            int curr = i % 2;
            int prev = 1 - curr;
            f[curr][0] = f[prev][0] + triangle.get(i).get(0);
            for (int j = 1; j < i; ++j) {
                f[curr][j] = Math.min(f[prev][j - 1], f[prev][j]) + triangle.get(i).get(j);
            }
            f[curr][i] = f[prev][i - 1] + triangle.get(i).get(i);
        }
        int minTotal = f[(n - 1) % 2][0];
        for (int i = 1; i < n; ++i) {
            minTotal = Math.min(minTotal, f[(n - 1) % 2][i]);
        }
        return minTotal;
    }
}

上述方法的空间复杂度为 $O(n)$，使用了 $2n$ 的空间存储状态。我们还可以继续进行优化吗？

答案是可以的。我们从 $i$ 到 $0$ 递减地枚举 $j$，这样我们只需要一个长度为 $n$ 的一维数组 $f$，就可以完成状态转移。
为什么只有在递减地枚举 $j$ 时，才能省去一个一维数组？当我们在计算位置 $(i,j)$ 时，$f[j+1]$ 到 $f[i]$ 已经是第 $i$ 行的值，而 $f[0]$ 到 $f[j]$ 仍然是第 $i-1$ 行的值。此时我们直接通过

$f[j]=min(f[j-1],f[j])+c[i][j]$

进行转移，恰好就是在 $(i-1,j-1)$ 和 $(i-1,j)$ 中进行选择。但如果我们递增地枚举 $j$，那么在计算位置 $(i,j)$ 时，$f[0]$ 到 $f[j-1]$ 已经是第 $i$ 行的值。如果我们仍然使用上述状态转移方程，那么是在 $(i,j-1)$和 $(i-1,j)$ 中进行选择，就产生了错误。
这样虽然空间复杂度仍然为 $O(n)$，但我们只使用了 $n$ 的空间存储状态，减少了一半的空间消耗。

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

复杂度分析

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

链接：https://leetcode-cn.com/problems/triangle/solution/san-jiao-xing-zui-xiao-lu-jing-he-by-leetcode-solu/
来源：力扣（LeetCode）