120. Triangle [Medium]

这种三角形求顶底之间最短路径的题，动态规划的思路没错，但不应该自顶向底处理，而要自底向顶

自顶向底的缺点：

1. 底部的元素较多，求出从顶部到底部每个元素的最短路径之后，还需要找出这些元素的最短路径中的最小值

2. 每一层的最后一个元素只能由上一层对应位置的左边元素获得，但该层其他元素可以由上一层对应位置元素或者对应位置但左边元素获得，导致情况变得复杂

自底向顶：

1. 最后归为顶部的一个元素，该元素的值就是答案，不需要单独一个数来保存和更新最小值

2. 每一个元素都有下一层对应位置或对应位置的右边元素获得，情况统一

/**
 * 自己的代码
 * 自顶而下做动态规划，新建dp矩阵保存途中结果
 * 相对于用triangle本身的空间，空间效率较低，但时间效率高
 * Runtime: 2 ms, Memory Usage: 39.5 MB
 */
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int size = triangle.size(), ans = 0;
        if (size <= 1)
            return triangle.get(0).get(0);
        int[][] dp = new int[size][size];
        dp[0][0] = triangle.get(0).get(0);
        for (int i = 1; i < size; i++) {
            dp[i][0] = dp[i - 1][0] + triangle.get(i).get(0);
            if (i == size - 1)
                ans = dp[size - 1][0];
            for (int j = 1; j <= i; j++) {
                if (j <= i - 1)
                    dp[i][j] = Math.min(dp[i - 1][j], dp[i - 1][j - 1]) + triangle.get(i).get(j);
                else
                    dp[i][j] = dp[i - 1][j - 1] + triangle.get(i).get(j);
                if (i == size - 1 && dp[i][j] < ans)
                    ans = dp[i][j];
            }
        }
        return ans;
    }
}

/**
 * 同样是自顶向下做动态规划，但不开辟新的空间，直接修改原三角形的值
 * 空间效率高，时间效率低
 * Runtime: 4 ms, Memory Usage: 39.2 MB
 */
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int size = triangle.size(), ans = 0;
        if (size == 1)
            return triangle.get(0).get(0);
        for (int i = 1; i < size; i++) {
            triangle.get(i).set(0, triangle.get(i).get(0) + triangle.get(i - 1).get(0));
            if (i == size - 1)
                ans = triangle.get(i).get(0);
            int j = 1;
            for (; j < i; j++) {
                triangle.get(i).set(j, Math.min(triangle.get(i - 1).get(j), triangle.get(i - 1).get(j - 1)) + triangle.get(i).get(j));
                if (i == size - 1 && triangle.get(i).get(j) < ans)
                    ans = triangle.get(i).get(j);
            }
            triangle.get(i).set(j, triangle.get(i - 1).get(j - 1) + triangle.get(i).get(j));
            if (i == size - 1 && triangle.get(i).get(j) < ans)
                ans = triangle.get(i).get(j);
        }
        return ans;
    }
}

/**
 * 自底向顶的处理方法，妙极
 * 但使用triangle自身的空间，虽然节省了空间，时间效率低了
 * Runtime: 4 ms, Memory Usage: 38.7 MB
 */
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        for (int i = triangle.size() - 2; i >= 0; i--)
            for (int j = 0; j <= i; j++)
                triangle.get(i).set(j, triangle.get(i).get(j) + Math.min(triangle.get(i + 1).get(j), triangle.get(i + 1).get(j + 1)));
        return triangle.get(0).get(0);
    }
}

/**
 * 自底向顶的动态规划，开辟新的dp数组存储途中结果，时间效率高
 * Runtime: 1 ms, faster than 95.86%
 * Memory Usage: 39 MB, less than 70.52%
 */
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int size = triangle.size();
        int[][] dp = new int[size][size];
        dp[0][0] = triangle.get(0).get(0);
        for (int i = 0; i < size; i++)
            dp[size - 1][i] = triangle.get(size - 1).get(i);
        for (int i = size - 2; i >= 0; i--)
            for (int j = 0; j <= i; j++)
                dp[i][j] = triangle.get(i).get(j) + Math.min(dp[i + 1][j], dp[i + 1][j + 1]);
        return dp[0][0];
    }
}

第二次做：

/**
 * 自己的代码1
 * 从下往上处理dp数组，这样最后只会汇聚为顶尖上的一个元素
 * 如果从上往下，就会是一排元素，到时候还要遍历这一排找最小值
 */
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int rows = triangle.size();
        if (rows == 1) {
            return triangle.get(0).get(0);
        }
        int[][] dp = new int[rows - 1][]; // dp数组可以比triangle少一行，因为dp数组有一行是和triangle中一样的，可以直接用triangle的这一行计算得到dp数组的相邻行作为dp的初始赋值，这样节省了一行的空间，但是让代码的可读性变得比较差
        // 处理dp数组最后一行
        dp[rows - 2] = new int[triangle.get(rows - 2).size()];
        List<Integer> lastRow = triangle.get(rows - 1);
        for (int i = 0; i < triangle.get(rows - 2).size(); i++) {
            dp[rows - 2][i] = triangle.get(rows - 2).get(i) + Math.min(lastRow.get(i), lastRow.get(i + 1));
        }
        // 处理dp数组倒数第二行以及往上的行
        for (int i = rows - 3; i >= 0; i--) {
            dp[i] = new int[i + 1];
            for (int j = 0; j <= i; j++) {
                dp[i][j] = triangle.get(i).get(j) + Math.min(dp[i + 1][j], dp[i + 1][j + 1]);
            }
        }
        return dp[0][0];
    }
}

/**
 * 自己的代码2，和上一段同样的思路，但dp数组多一行
 * Runtime: 1 ms, faster than 95.84%
 * Memory Usage: 39.3 MB, less than 30.06%
 */
class Solution {
    public int minimumTotal(List<List<Integer>> triangle) {
        int rows = triangle.size();
        int[][] dp = new int[rows][];
        // 初始化dp数组最后一行
        dp[rows - 1] = new int[rows];
        for (int i = 0; i < dp.length; i++) {
            dp[dp.length - 1][i] = triangle.get(rows - 1).get(i);
        }
        // 计算其他行
        for (int i = rows - 2; i >= 0; i--) {
            dp[i] = new int[i + 1];
            for (int j = 0; j <= i; j++) {
                dp[i][j] = triangle.get(i).get(j) + Math.min(dp[i + 1][j], dp[i + 1][j + 1]);
            }
        }
        return dp[0][0];
    }
}