120.三角形最小路径和（动态规划）

给定一个三角形，找出自顶向下的最小路径和。每一步只能移动到下一行中相邻的结点上。

例如，给定三角形：

输入
[
          [2],
        [3,4],
      [6,5,7],
    [4,1,8,3]
]

输出11 (2 + 3 + 5 + 1 = 11).
自顶向下的最小路径和为 11（即，2 + 3 + 5 + 1 = 11）。

说明：

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

算法分析：
动态规划 时间O(n2) 空间O(1)
解法一：
1、点(i,j)的下一行的相邻数字是(i+1,j)和(i+1,j+1)。
2、f(i,j)表示从下往上走到位置(i,j)时的最小路径和，计算方式/状态转移方程是
3、f(i,j) = [i,j] + Min【f(i + 1,j) ,f(i + 1, j + 1)】
4、使用int[] cache = new int[n + 1]数组获取最后一行为起点，从下到上层层覆盖

复杂度分析：
直接把f(i,j)存在位置(i,j)处，不使用额外空间，因此空间复杂度为O(1)。
从倒数第二行自底向上计算出所有位置的最小值

package 动态规划;

import java.util.ArrayList;
import java.util.List;
/*[
    [2],
   [3,4],
  [6,5,7],
 [4,1,8,3]
]*/
public class 三角形最小路径和 {
    /*为了避免重复递归，使用动态规划将结果记录在数组中
     * f(i,j) = [i,j] + Min【f(i + 1,j) ,f(i + 1, j + 1)】
     * 从倒数第二行自底向上计算出所有位置的最小值
     * */
    public int minimumTotal(List> triangle) {
        int n = triangle.size();
        //获取最后一行数据为起点
        int[] cache = new int[n + 1];
        //从倒数第二行开始，遍历改行的所有元素
        for(int i = n - 1;i >= 0;i--)
        {
            for(int j = 0;j <= i;j++)
            {
                int value = triangle.get(i).get(j) + Math.min(cache[j], cache[j+1]);
                cache[j] = value;
            }
        }
        return cache[0];
    }
}

解法二：

image.png

package 动态规划;

import java.util.ArrayList;
import java.util.List;
/*[
    [2],
   [3,4],
  [6,5,7],
 [4,1,8,3]
]*/
public class 三角形最小路径和2 {
    /*为了避免重复递归，使用动态规划将结果记录在数组中
     * f(i,j) = [i,j] + Min【f(i - 1,j - 1) ,f(i - 1, j)】
     * 从倒数第二行自底向上计算出所有位置的最小值
     * */
    public int minimumTotal(List> triangle) {
        int n = triangle.size();
        //使用滚动数组记录每一层的最大集合
        int[] cache = new int[n];
        int[] caches = new int[n];
        cache[0] = triangle.get(0).get(0);
        //自顶向下遍历
        for(int i = 1;i < n;i++)
        {
            for(int j = 0;j <= i;j++)
                caches[j] = cache[j];
            for(int j = 0;j <= i;j++)
            {
                //若该路径来自左边
                int leftMin = Integer.MAX_VALUE;
                if(j > 0) leftMin = caches[j - 1];
                //若该路径来自右边
                int rightMin = Integer.MAX_VALUE;
                if(j < i) rightMin = caches[j];
                cache[j] = triangle.get(i).get(j) + Math.min(leftMin, rightMin);
            }
        }
        int ans = Integer.MAX_VALUE;
        for(int i = 0;i < n;i++)
            ans = Math.min(ans, cache[i]);
        return ans;
    }
}