动态规划DP

动态规划（英语：Dynamic programming，简称 DP），通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。复杂问题不能分解成几个子问题，而分解成一系列子问题；

DP通常基于一个递推公式及一个(或多个)初始状态，当前子问题解由上一次子问题解推出。

动态规划算法的关键在于解决冗余，以空间换时间的技术，需要存储过程中的各种状态。可以看着是分治算法+解决冗余

动态规划算法也可以说是 记住求过的解来节省时间 ; 比如 Fibonacci数列中，先直接从最小，最简单的 f(1) , f(2) 开始，自低向上一直到 f(20) , 这就是动态规划的思路

【初始状态】→【决策1】→【决策2】→…→【决策n】→【结束状态】

DP 应用场景

如果一个问题，可以把所有可能的答案穷举出来，并且穷举出来后，发现存在重叠子问题，就可以考虑使用动态规划。

使用动态规划算法的问题的特征是子问题的重叠性，最优子结构 ，否则动态规划算法不具备优势。

动态规划的核心思想就是穷举求最值；动态规划问题的一般形式就是求最值,动态规划其实是运筹学的一种最优化方法，只不过在计算机问题上应用比较多，比如说：

Fibonacci数列代码参考这里递归
凑零钱问题
股票问题代码参考这里
打家劫舍问题 : num[i] 代表第i个房子中的现金数目，从房子中取钱的最大数目，约束是相邻房子的钱不能同时取出
接雨水问题：num[i]表示柱子高度，计算下雨之后能接多少雨水
青蛙跳阶问题：一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 10 级的台阶总共有多少种跳法。
最小编辑距离
最长递增子序列（LIS Longest Increasing Subsequence），如【5，6，7，3，2，8】 最长子序列 【5，6，7，8】, 输出4
最大子数组和
最长公共子序列（LIS Longest public Subsequence）
最长回文子序列（LIS Longest public Subsequence）
0-1 背包问题

[更多动态规划案例代码实现参考deep-in-java])(https://github.com/nonstriater/deep-in-java/tree/master/src/main/java/com/nonstriater/deepinjava/algo/framework/dynamic)

青蛙跳阶问题

想跳到第10级台阶，要么是先跳到第9级，然后再跳1级台阶上去;要么是先跳到第8级，然后一次迈2级台阶上去。
同理，要想跳到第9级台阶，要么是先跳到第8级，然后再跳1级台阶上去;要么是先跳到第7级，然后一次迈2级台阶上去。
要想跳到第8级台阶，要么是先跳到第7级，然后再跳1级台阶上去;要么是先跳到第6级，然后一次迈2级台阶上去

即通用公式为: f(n) = f(n-1) + f(n-2)

那f(2) 或者 f(1) 等于多少呢？

当只有2级台阶时，有两种跳法，第一种是直接跳两级，第二种是先跳一级，然后再跳一级。即f(2) = 2;
当只有1级台阶时，只有一种跳法，即f（1）= 1；

DP VS 分治法

与分治法不同的是，适合于用动态规划求解的问题，经分解得到子问题往往不是互相独立的。若用分治法来解这类问题，则分解得到的子问题数目太多，有些子问题被重复计算了很多次。如果我们能够保存已解决的子问题的答案，而在需要时再找出已求得的答案，这样就可以避免大量的重复计算，节省时间。我们可以用一个表来记录所有已解的子问题的答案。

DP VS 回溯法

DP 和回溯法都会用到递归

动态规划的暴力求解阶段就是回溯算法。只是有的问题具有重叠子问题性质，可以用 dp table 或者备忘录优化，将递归树大幅剪枝，这就变成了动态规划；而有些问题没有重叠子问题，也就是回溯算法问题了，复杂度非常高是不可避免的

DP 解题模板

基本步骤

划分问题
状态
状态转移方程, 这一步最为困难 ; 暴力解法就是状态转移方程
状态压缩

# 初始化 base case
dp[0][0][...] = base

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

凑零钱问题

凑零钱问题视频解读参考这里

如果使用贪心策略，并不能得到最优解。

//递归解法，处理重叠子问题, 使用 dp[amount+1] 备忘录
    int coinChange2(int[] coins, int amount) {
        int[] dp = new int[amount + 1];

        // 数组大小为 amount + 1，初始值也为 amount + 1
        // 为啥 dp 数组初始化为 amount + 1 呢，因为凑成 amount 金额的硬币数最多只可能等于 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];
    }

5.7 KiB Raw Blame History Unescape Escape