关于动态规划

主要问题大概是

• 动规基础（斐波那契）
• 背包
• 打家劫舍
• 股票
• 子序列

解决问题的方法主要是

1. 分类
2. 明确dp数组的含义
3. 建立dp数组
4. dp数组的初始化
5. 遍历顺序

动规基础
斐波那契数列，爬楼梯

建立dp数组的时候，递推公式的推导就要参考建立dp数组并且明确dp数组的含义
比如下面的最小花费爬楼梯，明确含义就可以在爬楼梯的原有递推公式上进行修改，在对应的部分添加上相应的花费就可以找到新的递推公式，动规的其他问题找递推公式也是在明确建立的dp数组的含义后进行对应的推导，从而得出相应的递推公式。

下为爬楼梯递推公式
dp[i]=dp[i-2]+dp[i-1]
上到n阶的方法数为n-2阶加上n-1阶

下为最小花费爬楼梯递推公式
dp[i] = fmin(dp[i - 1] + cost[i - 1], dp[i - 2] + cost[i - 2]
上到n阶的最小花费为第n-2阶的最小花费加上n-1阶的最小花费

递推公式中的加一减一之类的也是在明确了dp数组的含义之后才好定下来，在不同路径问题中比较明显

dp[i][j]=dp[i-1][j]+dp[i][j-1]
这里的i和j分别代表着网格中的列和行，对应的加减就代表着左右方向，加减的数量就表示了具体的格子坐标

dp数组的初始化也要视不同情况而定
像在不同路径中，对于行和列的初始化都是1，但是在不同路径Ⅱ中的初始化就要考虑到因为存在障碍物以及限制了方向，所以有些格子需要初始化为0，而不能完全的全都初始换为1

遍历的顺序也要根据情况而定，主要是从前到后和从后向前，但有些特殊的问题两层循环的顺序也要考虑到

在解决动规问题的过程中，最先想到的通常是暴力，但是很多时候会超限，然后递归也可能会超限，可以尝试着用记忆化搜索和递推方法还有滚动数组，这些方法可以大幅度的缩减所需要的时间和内存

记忆化搜索
记忆化搜索是在递归的基础上添加了一个用于储存计算结果的功能，因为在某些问题当中使用递归会造成大量的重复运算，添加了这个功能之后就可以避免因重复计算导致的时间浪费

例：leetcode LCR 127

这题中如果直接使用递归会导致超时，无法通过测试用例（如图）

这时候我们可以使用记忆化搜索的方式来节约时间

define MOD 1000000007

int trainWays(int num) {
if (num < 0) {
return 0;
}

int vis[num + 1];
for (int i = 0; i <= num; i++) {
    vis[i] = -1;
}

int dfs(int n) {
    if (vis[n] != -1) {
        return vis[n];
    }
    if (n == 0 || n == 1) {
        return 1;
    }
    vis[n] = (dfs(n - 1) % MOD + dfs(n - 2) % MOD) % MOD;
    return vis[n];
}
return dfs(num);

}

例：leetcode 392

同样直接使用递归会导致超时（如下图）

下为使用滚动数组的方法

int longestCommonSubsequence(char* text1, char* text2) {
int m = strlen(text1);
int n = strlen(text2);
int dp[2][n + 1];
for (int i = 0; i <= 1; i++) {
for (int j = 0; j <= n; j++) {
dp[i][j] = 0;
}
}
int now = 0, pre = 1;
for (int i = 1; i <= m; i++) {
now = 1 - now;
pre = 1 - pre;
for (int j = 1; j <= n; j++) {
if (text1[i - 1] == text2[j - 1]) {
dp[now][j] = dp[pre][j - 1] + 1;
} else {
dp[now][j] = dp[pre][j] > dp[now][j - 1]? dp[pre][j] : dp[now][j - 1];
}
}
}
return dp[now][n];
}