动态规划总结

适用情况

1. 问题需要求最优解
2. 最优子结构：大问题可以分解为子问题，子问题间必须互相独立，并且大问题的最优解可以由子问题的最优解推导而得
3. 重叠子问题：一个子问题需要被重复求解

思路流程

1. 确定base case：即最小的子问题，可以直接求解得到。
2. 确定【状态】：即大问题和子问题中会变化的变量是什么
3. 确定【选择】【状态转移方程】：也就是导致【状态】产生变化的行为
4. 明确 dp 函数/数组的定义：我们这里讲的是自顶向下的解法，所以会有一个递归的 dp 函数，一般来说函数的参数就是状态转移中会变化的量，也就是上面说到的【状态】；函数的返回值就是题目要求我们计算的量。

如何确定状态转移方程

1. 明确 dp 数组的定义
2. 根据dp数组的定义。运用数学归纳法的思想，假设dp[0,…,i-1]都已知，求dp[i]
3. 如果第二步不顺利，可能是dp数组设置的不恰当，需要重新定义数组

如何确定dp数组的遍历方向

1. 遍历的过程中，所需的状态必须是已经计算出来的。

2. 遍历结束后，存储结果的那个位置必须已经被计算出来。

空间压缩

能够使用空间压缩技巧的动态规划都是二维 dp 问题，你看它的状态转移方程，如果计算状态 dp[i][j] 需要的都是 dp[i][j] 相邻的状态，那么就可以使用空间压缩技巧，将二维的 dp 数组转化成一维，将空间复杂度从 O(N^2) 降低到 O(N)。

例子 子序列问题

1. 第一种思路模板是一个一维的dp数组:

int n=array.length;
int[] dp=new int[n];
for(int i=1;i<n;i++){
	for(int j=0;j<i;j++){
			dp[i]=最值(dp[i],do[j]+...);
	}
}

在子数组arr[0..i]中，我们要求的子序列(最长递增子序列)的长度是dp[i]。

2. 第二种思路模板是一个二维的dp数组:

int n=array.length;
int[][] dp=new int[n][n];
for(int i=0;i<n;i++){
	for(int j=0;j<n;j++){
			if(arr[i]==arr[j])
				dp[i][j]=dp[i][j]+...
			else
				dp[i][j]=最值(...)
	}
}

2.1 涉及两个字符串/数组的场景，dp数组的定义如下:

在子数组arr1[0..i]和子数组arr2[0..j]中，我们要求的子序列长度为dp[i][j]。

2.2 只涉及一个字符串/数组的场景，dp数组的定义如下:

在子数组array[i..j]中，我们要求的子序列的长度为dp[i][j]。

例子「 零钱兑换」：

给你 k 种面值的硬币，面值分别为 c1, c2 … ck，每种硬币的数量无限，再给一个总金额 amount，问你最少需要几枚硬币凑出这个金额，如果不可能凑出，算法返回 -1 。算法的函数签名如下：

// coins 中是可选硬币面值，amount 是目标金额
int coinChange(int[] coins, int amount);

1. 确定 base case：这个很简单，显然目标金额 amount 为 0 时算法返回 0，因为不需要任何硬币就已经凑出目标金额了。
2. 确定「状态」：也就是原问题和子问题中会变化的变量。由于硬币数量无限，硬币的面额也是题目给定的，只有目标金额会不断地向 base case 靠近，所以唯一的「状态」就是目标金额 amount。
3. 确定「选择」：也就是导致「状态」产生变化的行为。目标金额为什么变化呢，因为你在选择硬币，你每选择一枚硬币，就相当于减少了目标金额。所以说所有硬币的面值，就是你的「选择」。
4. 明确 dp 函数/数组的定义：我们这里讲的是自顶向下的解法，所以会有一个递归的 dp 函数，一般来说函数的参数就是状态转移中会变化的量，也就是上面说到的「状态」；函数的返回值就是题目要求我们计算的量。就本题来说，状态只有一个，即「目标金额」，题目要求我们计算凑出目标金额所需的最少硬币数量。

解法1 暴力递归

int coinChange(int[] coins, int amount) {
    // 题目要求的最终结果是 dp(amount)
    return dp(coins, amount)
}

// 定义：要凑出金额 n，至少要 dp(coins, n) 个硬币
int dp(int[] coins, int amount) {
    // base case
    if (amount == 0) return 0;
    if (amount < 0) return -1;

    int res = Integer.MAX_VALUE;
    for (int coin : coins) {
        // 计算子问题的结果
        int subProblem = dp(coins, amount - coin);
        // 子问题无解则跳过
        if (subProblem == -1) continue;
        // 在子问题中选择最优解，然后加一
        res = Math.min(res, subProblem + 1);
    }

    return res == Integer.MAX_VALUE ? -1 : res;
}

可以看到状态转移方程：

解法2 带备忘录的递归

int[] memo;

int coinChange(int[] coins, int amount) {
    memo = new int[amount + 1];
    // 备忘录初始化为一个不会被取到的特殊值，代表还未被计算
    Arrays.fill(memo, -666);

    return dp(coins, amount);
}

int dp(int[] coins, int amount) {
    if (amount == 0) return 0;
    if (amount < 0) return -1;
    // 查备忘录，防止重复计算
    if (memo[amount] != -666)
        return memo[amount];

    int res = Integer.MAX_VALUE;
    for (int coin : coins) {
        // 计算子问题的结果
        int subProblem = dp(coins, amount - coin);



        // 子问题无解则跳过
        if (subProblem == -1) continue;
        // 在子问题中选择最优解，然后加一
        res = Math.min(res, subProblem + 1);
    }
    // 把计算结果存入备忘录
    memo[amount] = (res == Integer.MAX_VALUE) ? -1 : res;
    return memo[amount];
}

解法3 迭代动态规划

int coinChange(int[] coins, int amount) {
    int[] dp = new int[amount + 1];
    // 数组大小为 amount + 1，初始值也为 amount + 1
    Arrays.fill(dp, amount + 1);

    // base case
    dp[0] = 0;
    // 外层 for 循环在遍历所有状态的所有取值
    for (int i = 0; i < dp.length; i++) {
        // 内层 for 循环在求所有选择的最小值
        for (int coin : coins) {
            // 子问题无解，跳过
            if (i - coin < 0) {
                continue;
            }
            dp[i] = Math.min(dp[i], 1 + dp[i - coin]);



        }
    }
    return (dp[amount] == amount + 1) ? -1 : dp[amount];
}

例子「 最长递增子序列」

我们的定义是这样的：dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度。

base case：dp[i] 初始值为 1，因为以 nums[i] 结尾的最长递增子序列起码要包含它自己。

int lengthOfLIS(int[] nums) {
    // 定义：dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度
    int[] dp = new int[nums.length];
    // base case：dp 数组全都初始化为 1
    Arrays.fill(dp, 1);
    for (int i = 0; i < nums.length; i++) {
        for (int j = 0; j < i; j++) {
            if (nums[i] > nums[j]) 
                dp[i] = Math.max(dp[i], dp[j] + 1);



        }
    }
    
    int res = 0;
    for (int i = 0; i < dp.length; i++) {
        res = Math.max(res, dp[i]);
    }
    return res;
}