关于动态规划

主要问题大概是动规基础（斐波那契），背包，打家劫舍，股票，子序列。
解决也主要是先分类，建立dp数组，明确dp数组的含义，dp数组的初始化，遍历顺序。
动规基础斐波那契数列，爬楼梯，建立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]; }