动态规划c++

1. 什么是动态规划动态规划

（英语：Dynamic programming，简称 DP），是一种在数学、管理科学、计算机科学、经济学和生物信息学中使用的，通过把原问题分解为相对简单的子问题的方式求解复杂问题的方法。动态规划常常适用于有重叠子问题和最优子结构性质的问题。

1.1 重叠子问题与最优子结构

1.1.1 重叠子问题

重叠子问题是指在问题的求解过程中，存在多次使用相同的子问题的情况，即在求解问题的不同阶段，需要求解的子问题可能是相同的。重叠子问题是动态规划算法设计的基础之一，利用子问题的重叠性可以减少重复计算，提高算法效率。

1.1.2 最优子结构

最优子结构是指问题的最优解可以通过子问题的最优解来构造得到。也就是说，问题的最优解包含子问题的最优解。通俗地说，就是大问题的最优解可以由小问题的最优解推出。这是动态规划的关键性质之一。

1.1.3 举例

举个例子，假设有一个包含n个元素的序列，需要找出其中的最长递增子序列（LIS，Longest Increasing Subsequence）。这个问题就具有最优子结构性质。如果一个序列的LIS已知，那么如果在其末尾添加一个元素，就有两种情况：

1.如果该元素大于当前LIS的末尾元素，那么新序列的LIS为当前LIS加上这个元素，长度为原序列的LIS长度加1；
2.如果该元素小于等于当前LIS的末尾元素，那么当前LIS不会受到影响，新序列的LIS仍然是原序列的LIS。

因此，该问题的最优解可以通过已知的子问题的最优解构造得到。

1.2 动态规划的核心思想

动态规划最核心的思想，就在于拆分子问题，记住过往，减少重复计算。

我们来看下，网上比较流行的一个例子：

A ： "1+1+1+1+1+1+1+1 =？"
A ： "上面等式的值是多少"
B ： 计算 "8"
A : 在上面等式的左边写上 "1+" 呢？
A : "此时等式的值为多少"
B : 很快得出答案 "9"
A : "你怎么这么快就知道答案了"
A : "只要在8的基础上加1就行了"
A : "所以你不用重新计算，因为你记住了第一个等式的值为8!动态规划算法也可以说是 '记住求过的解来节省时间'"

1.3 从青蛙跳台阶进入动态规划

leetcode原题：一只青蛙一次可以跳上1级台阶，也可以跳上2级台阶。求该青蛙跳上一个 10 级的台阶总共有多少种跳法

1.3.1 解题思路

基本思想：动态规划从较小问题的解，由交叠性质，逐步决策出较大问题的解，它是从f(1)往f(10）方向，往上推求解，所以称为自底向上的解法。

什么意思，我们从第一个台阶往上推，假设跳到第n级台阶的跳数我们定义为f(n):

1.当只有1级台阶时，只有一种跳法，即f（1）= 1；
2.当只有2级台阶时，有两种跳法。第一种是直接跳两级。第二种是先跳一级，然后再跳一级。即f(2) = 2;
3.当有3级台阶时，也有两种跳法。第一种是从第1级台阶直接跳两级。第二种是从第2级台阶跳一级。即f(3) = f(1) + f(2);
4.要想跳到第4级台阶，要么是先跳到第3级，然后再跳1级台阶上去;要么是先跳到第2级，然后一次迈2级台阶上去。即f(4) = f(2) + f(3);

此时，我门就能得到公式：

f(1) = 1;
f(2) = 2;
f(3) = f(1) + f(2);
f(4) = f(2) + f(3);
…
f(10) = f(8) + f(9);
即f(n) = f(n - 2) + f(n - 1)。

此时我们来看看动态规划的典型特征在此题中的展现：

1.最优子结构：f(n-1)和f(n-2) 称为 f(n) 的最优子结构。
2.重叠子问题：比如f(10)= f(9)+f(8),f(9) = f(8) + f(7) ,f(8)就是重叠子问题。
3.状态转移方程：f(n)= f(n-1)+f(n-2)就称为状态转移方程。
4.边界：f(1) = 1, f(2) = 2 就是边界。

1.3.2 代码

代码思路如图：

代码实现：

class Solution {
public:
    int numWays(int n) {
        int dp[101] = {0};
        int mod = 1000000007;

        dp[0] = 1;
        dp[1] = 1;
        dp[2] = 2;
        for (int i = 3; i <= n; i++) {
            dp[i] = dp[i - 1] + dp[i - 2];
            dp[i] %= mod;
        }

        return dp[n] % mod;
    }
};

这个方法空间复杂度是O(n)，但是呢，仔细观察上图，可以发现，f（n）只依赖前面两个数，所以只需要两个变量a和b来存储，就可以满足需求了，因此空间复杂度是O(1)就可以啦。

代码实现：

class Solution {
public:
    int numWays(int n) {
        if (n < 2) {
            return 1;
        }
        if (n == 2) {
            return 2;
        }
        int a = 1;
        int b = 2;
        int temp = 0;
        for (int i = 3; i <= n; i++) {
            temp = (a + b)% 1000000007;
            a = b;
            b = temp;
        }
        return temp;
    }
};

2. 动态规划解题套路

2.1 核心思想

动态规划的核心思想就是拆分子问题，记住过往，减少重复计算。 并且动态规划一般都是自底向上的，因此到这里，基于青蛙跳阶问题，总结了一下做动态规划的思路：

1.穷举分析
2.确定边界
3.找出规律，确定最优子结构
4.写出状态转移方程

2.1.1按例分析

1.穷举分析
（1）当台阶数是1的时候，有一种跳法，f（1） =1）
（2）当只有2级台阶时，有两种跳法，第一种是直接跳两级，第二种是先跳一级，然后再跳一级。即f(2) = 2;
（3）当台阶是3级时，想跳到第3级台阶，要么是先跳到第2级，然后再跳1级台阶上去，要么是先跳到第 1级，然后一次迈 2 级台阶上去。所以f(3) = f(2) + f(1) =3
（4）当台阶是4级时，想跳到第3级台阶，要么是先跳到第3级，然后再跳1级台阶上去，要么是先跳到第 2级，然后一次迈 2 级台阶上去。所以f(4) = f(3) + f(2) =5
（5）当台阶是5级时…

2.确定边界
通过穷举分析，我们发现，当台阶数是1的时候或者2的时候，可以明确知道青蛙跳法。f(1) =1，f(2) = 2，当台阶n>=3时，已经呈现出规律f(3) = f(2) + f(1) =3，因此f(1) =1，f(2) = 2就是青蛙跳阶的边界。

3.找规律，确定最优子结构
n>=3时，已经呈现出规律 f(n) = f(n-1) + f(n-2) ，因此，f(n-1)和f(n-2) 称为 f(n) 的最优子结构。什么是最优子结构？有这么一个解释：

一道动态规划问题，其实就是一个递推问题。假设当前决策结果是f(n),则最优子结构就是要让 f(n-k) 最优,最优子结构性质就是能让转移到n的状态是最优的,并且与后面的决策没有关系,即让后面的决策安心地使用前面的局部最优解的一种性质

4.通过前面3步，穷举分析，确定边界，最优子结构，我们就可以得出状态转移方程啦：

3. 例题

3.1 递增子序列

3.1.1. 穷举分析：

1.当nums只有10的时候，最长子序列[10]，长度1。
2.当nums加入9时，最长子序列[10]或[9]，长度1。
3.当nums加入2时，最长子序列[10]或[9]或[2]，长度1。
4.当nums加入5时，最长子序列[2, 5]，长度2。
5.当nums加入3时，最长子序列[2, 5]或[2, 3]，长度2。
6.当nums加入7时，最长子序列[2, 5, 7]或[2, 3, 7]，长度3。
…
7.当nums再加入一个元素18时,最长递增子序列是[2,5,7,101]或者[2,3,7,101]或者[2,5,7,18]或者[2,3,7,18],长度是4。

3.1.2 确定边界

对于nums数组的每一个元素而言，当我们还没有开始遍历寻找时，它们的初始最长子序列就是它们本身长度为1。

3.1.3 找规律，确定最优子结构

通过上面分析，我们可以发现一个规律：

nums[i]结尾的自增子序列，只要找到结尾nums[j]比nums[i]小的子序列，加上nums[i] 就可以。显然，可能形成多种新的子序列，我们选最长那个，就是的最长递增子序列。

得到最优子结构：

最长递增子序列(nums[i]) = max(最长递增子序列(nums[j])) + nums[i]; 0<= j < i, nums[j] < nums[i];

3.1.4 写出状态转移方程

我们设立dp数组储存以nums数组的元素结尾的最长子序列的长度，将其初始化为1，由最优子结构得到状态转移方程：

dp[i] = max(dp[j]) + 1; 0<= j < i, nums[j] < nums[i];

3.1.5 代码
class Solution {
public:
    int lengthOfLIS(vector<int>& nums) {
        vector<int> dp(nums.size(), 1);
        int ans = 1;
        for (int i = 1; i < nums.size(); i++) {
            for (int j = 0; j < i; j++) {
                if (nums[j] < nums[i]) {
                    dp[i] = max(dp[i], dp[j] + 1);
                }
            }
            ans = max(ans, dp[i]);
        }
        return ans;
    }
};