5.24算法练习三角形最小路径和#动态规划

Posted 2021-06-04 在路上的德尔菲

题目

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

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

示例二
输入：triangle = [[-10]]
输出：-10

解题

我写的第一版代码，不太优美…

    public int minimumTotal(List<List<Integer>> triangle) {
        int n = triangle.size();
        int res = Integer.MAX_VALUE;
        //当数据为空时逻辑
        if (n == 0) return 0;
        int m = Integer.MIN_VALUE;
        for (int i = 0; i < n; i++) {
            m = triangle.get(i).size() > m ? triangle.get(i).size() : m;
        }
        //当只有一个点时逻辑，最小路径和即为这个点的值
        if (n == 1 && m == 1) return triangle.get(0).get(0);
        
        int[][] dp = new int[m][n];
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                dp[i][j] = Integer.MAX_VALUE;
            }
        }
        List<Integer> first = triangle.get(0);
        for (int i = 0; i < first.size(); i++) {
            dp[0][i] = first.get(i);
        }
        //核心逻辑
        //行
        for (int i = 1; i < n; i++) {
        	//列
            for (int j = 0; j < triangle.get(i).size(); j++) {
                if (j == 0) {
                    dp[i][j] = dp[i - 1][j] + triangle.get(i).get(j);
                } else {
                    dp[i][j] = Math.min(dp[i - 1][j - 1], dp[i - 1][j]) + triangle.get(i).get(j);
                }
            }
        }
        //取最后一行最小的值为即为自顶向下的最小路径和
        for (int i = 0; i < m; i++) {
            if (dp[n - 1][i] < res) res = dp[n - 1][i];
        }
        return res;
    }

• 时间复杂度:O(N2)，其中n为三角形行数
• 空间复杂度:O(N2)，需要一个n*n的二维数组。

参考力扣上高票答案，上面代码没有考虑到三角形这个特征，如果将输入左端对齐，将是一个等腰三角形，第i行有i+1个元素，行总数和最后一行列数相同。那么对上面代码进行优化

    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) {
        	//外层循环只负责每行第一个值，根据上方值+当前值，没得选，也让下面j从1开始循环
            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);
            }
            //到(i,i)节点路径和也是没得选
            f[i][i] = f[i - 1][i - 1] + triangle.get(i).get(i);
        }
        int minTotal = f[n - 1][0];
        for (int i = 1; i < n; ++i) {
            minTotal = Math.min(minTotal, f[n - 1][i]);
        }
        return minTotal;
    }

• 时间复杂度:O(N2)，其中n为三角形行数
• 空间复杂度:O(N2)，需要一个n*n的二维数组。

这道题要求能否用O(N)空间复杂度来完成，那就是不能使用n*n的二维数组，只能使用一维数组。
我们知道到每行第一个位置路径和到(i, i)位置的路径和是固定的，列数在开区间(0, i) 时可以选择的，一维数组每个元素，代表什么含义呢？
举个例子，循环第三次，在三角形从上到下数第三层，一维数组第一个元素就代表到第三层第一个位置路径和，一维数组第二个元素就代表到第三层第二个位置路径和，依次类推。注意这个一维数据为了节约空间，每次循环里面的元素是会迭代更新的。

    public static int minimumTotal3(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) {
        	//到(i, i)位置的路径和
            f[i] = f[i - 1] + triangle.get(i).get(i);
            //列数在开区间(0, 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;
    }

• 时间复杂度:O(N2)，其中n为三角形行数
• 空间复杂度:O(N)，需要一个n的二维数组。

小结

从代码可读性上优化代码，一开始写的代码虽然功能上没有问题，但是对一些特殊输入的处理增加了代码的复杂性，不够优美，完善的算法其实可以cover所有输入场景。
从空间复杂度上优化算法，从而达到O(N)的空间复杂度，其他场景如果也要求O(N)的空间复杂度也可以用同样的思路去分析，一维数组里的值每次循环去更新迭代。

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