LeetCode-动态规划篇

动态规划

重叠子问题、最优子结构、状态转移方程就是动态规划三要素

• 思考状态转移方程：

  明确 base case -> 明确「状态」-> 明确「选择」 -> 定义 dp 数组/函数的含义。

  # 初始化 base case

  dp[0][0][...] = base

  # 进行状态转移

  for 状态1 in 状态1的所有取值：
for 状态2 in 状态2的所有取值：
for ...
dp[状态1][状态2][...] = 求最值(选择1，选择2...)

• PS：但凡遇到需要递归的问题，最好都画出递归树，这对你分析算法的复杂度，寻找算法低效的原因都有巨大帮助。

• 如何列出正确的状态转移方程？

  1、确定 base case，这个很简单，显然目标金额 amount 为 0 时算法返回 0，因为不需要任何硬币就已经凑出目标金额了。

  2、确定「状态」，也就是原问题和子问题中会变化的变量。由于硬币数量无限，硬币的面额也是题目给定的，只有目标金额会不断地向 base case 靠近，所以唯一的「状态」就是目标金额 amount。

  3、确定「选择」，也就是导致「状态」产生变化的行为。目标金额为什么变化呢，因为你在选择硬币，你每选择一枚硬币，就相当于减少了目标金额。所以说所有硬币的面值，就是你的「选择」。

  4、明确 dp 函数/数组的定义。我们这里讲的是自顶向下的解法，所以会有一个递归的 dp 函数，一般来说函数的参数就是状态转移中会变化的量，也就是上面说到的「状态」；函数的返回值就是题目要求我们计算的量。就本题来说，状态只有一个，即「目标金额」，题目要求我们计算凑出目标金额所需的最少硬币数量。所以我们可以这样定义 dp 函数：

  dp(n) 的定义：输入一个目标金额 n，返回凑出目标金额 n 的最少硬币数量。

  • dp 数组的迭代解法

    也可以自底向上使用 dp table 来消除重叠子问题，关于「状态」「选择」和 base case 与之前没有区别，dp 数组的定义和刚才 dp 函数类似，也是把「状态」，也就是目标金额作为变量。不过 dp 函数体现在函数参数，而 dp 数组体现在数组索引：

    dp 数组的定义：当目标金额为 i 时，至少需要 dp[i] 枚硬币凑出。

    int coinChange(vector<int>& coins, int amount) {
// 数组大小为 amount + 1，初始值也为 amount + 1
vector<int> dp(amount + 1, amount + 1);
// base case
dp[0] = 0;
// 外层 for 循环在遍历所有状态的所有取值
for (int i = 0; i < dp.size(); i++) {
// 内层 for 循环在求所有选择的最小值
for (int coin : coins) {
// 子问题无解，跳过
if (i - coin < 0) continue;
dp[i] = min(dp[i], 1 + dp[i - coin]);
}
}
return (dp[amount] == amount + 1) ? -1 : dp[amount];
}

动态规划-最长递增子序列

动态规划的核心设计思想是数学归纳法。

思路：

• 首先明确 dp 数组所存数据的含义。这步很重要，如果不得当或者不够清晰，会阻碍之后的步骤。

• 然后根据 dp 数组的定义（dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度。），运用数学归纳法的思想，假设 dp[0...i−1]dp[0...i−1] 都已知，想办法求出 dp[i]dp[i]，一旦这一步完成，整个题目基本就解决了。

• 但如果无法完成这一步，很可能就是 dp 数组的定义不够恰当，需要重新定义 dp 数组的含义；或者可能是 dp 数组存储的信息还不够，不足以推出下一步的答案，需要把 dp 数组扩大成二维数组甚至三维数组。

• 最后想一想问题的 base case 是什么，以此来初始化 dp 数组，以保证算法正确运行。

最长递增子序列

题目描述
给你一个整数数组 nums ，找到其中最长严格递增子序列的长度。

子序列是由数组派生而来的序列，删除（或不删除）数组中的元素而不改变其余> 元素的顺序。例如，[3,6,2,7] 是数组 [0,3,1,6,2,2,7] 的子序列。

代码题解：

class Solution {
    public int lengthOfLIS(int[] nums) {
        int[] dp = new int[nums.length];
        int res=0;
        Arrays.fill(dp,1);
        // dp[i] 表示以 nums[i] 这个数结尾的最长递增子序列的长度
        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);
                }
            }
        }
        for(int i=0;i<dp.length;i++) {
            res = Math.max(res,dp[i]);
        }
        return res;
    }
}

零钱兑换

题目描述
给定不同面额的硬币 coins 和一个总金额 amount。编写一个函数来计算可以凑成总金额所需的最少的硬币个数。如果没有任何一种硬币组合能组成总金额，返回 -1。

你可以认为每种硬币的数量是无限的。

代码题解：

class Solution {
    public int coinChange(int[] coins, int amount) {
        // base case
        if(amount ==0) {
            return 0;
        }
        int dp[] =new int[amount+1];
        // dp[i] 存放的是金额为i的最少硬币数
        dp[0] =0;
        for(int i=1;i<=amount;i++) {
            dp[i] = amount+1;
        }
        // 遍历状态
        for(int i=0;i<=amount;i++) {
            //遍历每个状态的选择，求出该状态下的最小值的选择
            for (int j=0;j<coins.length;j++) {
                if(i-coins[j]<0) continue;
                dp[i] = (dp[i]<=dp[i-coins[j]]+1)?dp[i]:dp[i-coins[j]]+1;
            }
        }
        return (dp[amount]== amount+1)?-1:dp[amount];
    }
}