算法笔记动态规划总结
数塔问题：
f[i][j]存储第i行第j个点的数值，令dp[i][j]表示第i行第j个数字出发的到达最底层的所有路径中能得到的最大和。i,j都从1开始
显然： dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+f[i][j] 
得到状态转移方程，而最后一层dp值总是等于元素本身。
即：dp[n][j]==f[n][j](1<=j<=n) 把这种可以直接确定其结果的部分称为边界而动规的递推写法总是从这些边界出发，通过状态转移方程扩散到整个dp数组。
从最底层各位置的dp值开始，不断往上求出每一层各位置的dp值，最后就会得到最终结果dp[1][1]
//录入边界
for(int j=1;j<=n;j++){
dp[n][j]=f[n][j];
}
//状态转移 从n-1层不断往上计算出dp[i][j]
for(int i=n-1;i>=1;i--){
for(int j=1;j<=i;j++){
dp[i][j]=max(dp[i+1][j],dp[i+1][j+1])+f[i][j];
//每次通过i+1层求第i层 且每次i+1都先求出来了
}
}
最大连续子序列和
- 给定序列，求连续的子序列要求和最大，求最大的和为多少
- dp[i]表示以a[i]作为末尾的连续序列的最大和（a[i]必须是末尾被选的数啊啊），dp数组中所有的数据的最大值就是所求
- dp[0]初始化为a[0]，dp数组从1生成到n-1
- 因为a[i]一定是所选序列的末尾，所以分为两种情况：
- a[i]开始，a[i]结束
- 某数开始，到a[i]结束（最大和是dp[i-1] + a[i]）
- 所以递推方程为dp[i] = max(a[i], dp[i-1]+a[i]);
- dp数组中所有的数据的最大值就是所求：maxn = max(dp[i], maxn);
// a数组从下标0开始
dp[0] = a[0];
int maxn = a[0];
for(int i = 1; i < n; i++) {
dp[i] = max(a[i], dp[i-1]+a[i]);
maxn = max(dp[i], maxn);
}
printf("%d", maxn);
最长不下降子序列（LIS）
- 求一个序列的最长的子序列（可以不连续），使得这个子序列是不下降的
- dp[i]表示必须以a[i]结尾的最长不下降子序列的长度，dp数组中所有数据的最大值即为所求
- i从0到n-1依次更新dp[i]的值，dp[i]的值需要由之前所生成的所有dp[j]递推而得（j从1到i-1），每次检查是否a[i]>=a[j]，即是否构成最长不下降子序列，如果构成，会有两种结果：
- dp[j]+1比dp[i]大，则更新dp[i] = dp[j] + 1
- dp[j]+1比dp[i]小，则dp[i]保持不变
- 所以递推方程为dp[i] = max{dp[i], dp[j] + 1};
- dp数组中所有数据的最大值即为所求：ans = max(dp[i], ans);
int ans = 0;
for(int i = 0; i < n; i++) {
for(int j = 1; j < i; j++) {
if(a[i] >= a[j])
dp[i] = max(dp[i], dp[j] + 1);
}
ans = max(dp[i], ans);
}
printf("%d", ans);
最长公共子序列（LCS）
- 给定两个字符串或者数字序列A和B，求一个字符串，使得这个字符串是A和B的最长公共部分（子序列可以不连续）
dp[i][j]表示A的第 i 位之前和B的第 j 位之前的这两个序列的LCS最长公共子序列的长度（下标从1开始），那么dp[lena][lenb]即为所求- 递推方程：
- 当a[i] == b[j] :
dp[i][j] = dp[i-1][j-1] + 1 - 当a[i] != b[j] :
dp[i][j] = max(dp[i-1][j], dp[i][j-1]) - 边界：
dp[i][0] = dp[0][j] = 0(0 <= i <= lena, 1 <= j <= lenb)
- 当a[i] == b[j] :
char a[100], b[100];
scanf("%s", a+1);
scanf("%s", b+1);
int lena = strlen(a + 1), lenb = strlen(b + 1);
for(int i = 0; i <= lena; i++) dp[i][0] = 0;
for(int j = 0; j <= lenb; j++) dp[0][j] = 0;
for(int i = 1; i <= lena; i++) {
for(int j = 1; j <= lenb; j++) {
if(a[i] == b[j])
dp[i][j] = dp[i-1][j-1] + 1;//若可以产生重复元素
// dp[i][j] =max(dp[i-1][j], dp[i][j-1]) + 1;
else
p[i][j] = max(dp[i-1][j], dp[i][j-1]);
}
}
printf("%d", dp[lena][lenb]);
最长回文子串
- 给出一个字符串s，求s的最长回文子串的长度
dp[i][j]表示 s[i] 到 s[j] 所表示的字串是否是回文字串，值只有0和1- 初始化长度1和2的值：
dp[i][i] = 1, dp[i][i+1] = (s[i] == s[i+1]) ? 1 : 0，然后长度L从3到len，满足的最大长度L即为所求的ans值 - 递推方程：
- 当s[i] == s[j] :
dp[i][j] = dp[i+1][j-1] - 当s[i] != s[j] :
dp[i][j] = 0
- 当s[i] == s[j] :
- 因为i、j如果从小到大的顺序来枚举的话，无法保证更新
dp[i][j]的时候dp[i+1][j-1]已经被计算过。因此不妨考虑按照字串的长度和子串的初试位置进行枚举，即第一遍将长度为3的子串的dp的值全部求出，第二遍通过第一遍结果计算出长度为4的子串的dp的值…这样就可以避免状态无法转移的问题
int len = s.length();
//先把1和2长度的都初始化了
int ans = 1;
for(int i = 0; i < len; i++) {
dp[i][i] = 1;
if(i < len - 1 && s[i] == s[i+1]) {
dp[i][i+1] = 1;
ans = 2;
}
}
//状态转移方程
for(int L = 3; L <= len; L++) {
for(int i = 0; i + L - 1 < len; i++) {
int j = i + L - 1;
if(s[i] == s[j] && dp[i+1][j-1] == 1) {
dp[i][j] = 1;
ans = L;
}
}
}
printf("%d", ans);
背包问题
01背包问题
- 有n件物品，每件物品的重量为w[i]，价值为c[i]。现有一个重量为V的背包，问如何选取物品放入背包，使得背包内物品的总价值最大。其中每种物品只有1件
dp[i][j]表示前i件物品恰好装入容量为j的背包所能获得的最大价值- 不放第i件物品，则
dp[i][j] = dp[i-1][j] - 放第i件物品，那么问题转化为前i – 1件物品恰好装入容量j – w[i]的背包中所能获得的最大价值
dp[i-1][j-w[i]] + c[i]
- 不放第i件物品，则
- 递推方程
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]]+c[i]);
for(int i = 1; i <= n; i++) {
for(int j = 1, j <= v; j++)
if(j - w[i] >= 0)
dp[i][j] = max(dp[i-1][j], dp[i-1][j-w[i]] + c[i]);
else
dp[i][j] = dp[i-1][j];
}
- 一维：
for(int i = 1; i <= n; i++) {
for(int j = v; j >= w[i]; j--)
dp[v] = max(dp[v], dp[v-w[i]] + c[i]);
}