线性DP

线性DP主要是一类转移过程近似线性的dp问题，其状态转移过程近似于线性变换。

数字三角形

我们考虑其中的某一个点，到达该节点的路径只能从左上或者右上的节点到达，以该节点结束的所有路径最大值，为两条路径的最大值加上自己的值，因为每次遍历到一个节点，最大值就可以得到，且层层遍历，转移过程近似线性。

#include <iostream>
using namespace std;const int N = 510, INF = 1e9;int n;
int a[N][N];
int f[N][N];int main()
{cin >> n;for(int i = 1; i <= n; i ++){for(int j = 1; j <= i; j ++) cin >> a[i][j];}for(int i = 1; i <= n; i ++){for(int j = 0; j <= i + 1; j ++) f[i][j] = -INF;}f[1][1] = a[1][1];for(int i = 2; i <= n; i ++){for(int j = 1; j <= i; j ++) f[i][j] = max(f[i - 1][j - 1] + a[i][j], f[i - 1][j] + a[i][j]);}int res = -INF;for(int i = 1; i <= n; i ++) res = max(res, f[n][i]);cout << res << endl;return 0;
}

最长上升子序列

最长上升子序列我们从第一个数开始枚举，每次都将位置 i i i之前的所有数枚举，求出小于该数的上升子序列最大值，再加1即为以位置 i i i结尾的上升子序列的最大值。
f [ i ] f[i] f[i]表示以 a [ i ] a[i] a[i]结尾的上升子序列的最大长度，我们每次从 0 0 0~ i − 1 i - 1 i−1遍历，取最大值加一即可，时间复杂度为 O ( n 2 ) O(n^2) O(n2)

#include <iostream>
using namespace std;const int N = 1010;int a[N], f[N];
int n;int main()
{cin >> n;for(int i = 1; i <= n; i ++) cin >> a[i];f[1] = 1;for(int i = 2; i <= n; i ++){f[i] = 1;for(int j = 1; j < i; j ++){if(a[j] < a[i]) f[i] = max(f[i], f[j] + 1);}}int res = 0;for(int i = 1; i <= n; i ++) res = max(res, f[i]);cout << res << endl;return 0;
}

二分优化：
我们思考得出，我们的上升子序列长度是递增的，且我们的上升子序列中的数值也是严格递增的，我们可以利用这个信息来优化，我们让 f [ i ] f[i] f[i]来表示上升子序列以长度 i i i结尾的最小数字，当 a [ i ] a[i] a[i]大于当前的数字，我们让长度加一，若小于当前最小数字，为了保持单调性，我们需要找到第一个大于 a [ i ] a[i] a[i]的数，并将其更新。

#include <iostream>
#include <vector>
#include <algorithm>
using namespace std;const int N = 100010;int a[N];
int n;int main()
{cin >> n;for(int i = 0; i < n; i ++) cin >> a[i];vector<int> f;for(int x : a){if(f.empty() || x > f.back()) f.push_back(x);else f[lower_bound(f.begin(),f.end(), x) - f.begin()] = x;}cout << f.size() << endl;return 0;
}

最长公共子序列

最长公共子序列问题我们用 i i i表示字符串 A A A的前 i i i个字符， j j j表示字符串 B B B的前 j j j个字符， f [ i , j ] f[i,j] f[i,j]表示前 i i i个字符和前 j j j个字符中的公共子序列的最大长度，对于以 a [ i ] , b [ j ] a[i],b[j] a[i],b[j]结尾的子序列，一共有四种情况，分别为包含或者不包含 a [ i ] , b [ j ] a[i], b[j] a[i],b[j],那么 f [ i , j ] f[i,j] f[i,j]可以由 f [ ] i − 1 , j − 1 ] , f [ i − 1 , j ] , f [ i , j − 1 ] , f [ i − 1 , j − 1 ] + 1 f[]i-1,j-1],f[i -1, j], f[i, j - 1], f[i - 1, j- 1] + 1 f[]i−1,j−1],f[i−1,j],f[i,j−1],f[i−1,j−1]+1四种情况求最大值可得到，其中 f [ i − 1 , j − 1 ] f[i-1,j-1] f[i−1,j−1]的情况包含在了 f [ i − 1 , j ] , f [ i , j − 1 ] f[i -1, j], f[i, j - 1] f[i−1,j],f[i,j−1]两种情况中，注意子序列中含 a [ i ] a[i] a[i],不含 b [ j ] b[j] b[j]的情况包含在了 f [ i , j − 1 ] f[i,j-1] f[i,j−1]中，但两者并不相等。因为是求最大值，所以可以有重复的情况，只要求得所有情况的最大值即可。

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;const int N = 1010;int n, m;
char a[N], b[N];
int f[N][N];int main()
{cin >> n >> m;for(int i = 1; i <= n; i ++) cin >> a[i];for(int i = 1; i <= m; i ++) cin >> b[i];for(int i = 1; i <= n; i ++){for(int j = 1; j <= m; j ++){f[i][j] = max(f[i][j - 1], f[i - 1][j]);if(a[i] == b[j]) f[i][j] = max(f[i][j], f[i - 1][j - 1] + 1);}}cout << f[n][m] << endl;return 0;
}

区间DP

石子合并

石子合并中为了求出从 1 1 1~ n n n合并的最小代价，我们可以尝试枚举最后一次合并的分界线位置，将问题划分为两个子问题，然后递归求解。在此过程中，我们可以求得从 i i i到 j j j石子合并的最小代价，为了求出所有情况，我们按照区间长度从小到大枚举。

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;
const int N = 310;int n;
int s[N];
int f[N][N];int main()
{cin >> n;for(int i = 1; i <= n; i ++){cin >> s[i];s[i] += s[i - 1];}for(int len = 1; len < n; len ++){for(int i = 1; i + len <= n; i ++){int l = i, r = i + len;f[l][r] = 1e9;for(int k = l; k <= r; k ++){f[l][r] = min(f[l][r], f[l][k] + f[k + 1][r] + s[r] - s[l - 1]);}}}cout << f[1][n] << endl;return 0;
}

计数类DP

整数划分

整数划分问题可以看作完全背包问题，从 1 1 1到 n n n个数中选，正好和是 j j j的所有集合，每个数可以选无数个。 f [ i , j ] = f [ i − 1 , j ] + f [ i − 1 , j − i ] + . . . + f [ i − 1 , j − s ∗ i ] f[i,j] = f[i-1,j]+f[i-1,j-i]+...+f[i-1,j-s*i] f[i,j]=f[i−1,j]+f[i−1,j−i]+...+f[i−1,j−s∗i], f [ i , j − i ] = f [ i − 1 , j − i ] + f [ i − 1 , j − 2 i ] + . . . + f [ i − 1 , j − s ∗ i ] f[i,j - i] = f[i-1,j - i]+f[i-1,j-2i]+...+f[i-1,j-s*i] f[i,j−i]=f[i−1,j−i]+f[i−1,j−2i]+...+f[i−1,j−s∗i],因此 f [ i , j ] = f [ i − 1 , j ] + f [ i , j − i ] f[i,j] = f[i-1,j]+f[i,j-i] f[i,j]=f[i−1,j]+f[i,j−i]

#include <iostream>
using namespace std;
const int N = 1010, M = 1e9 + 7;int n;
int f[N];int main()
{cin >> n;f[0] = 1;for(int i = 1; i <= n; i ++)for(int j = i; j <= n; j ++)f[j] = (f[j] + f[j - i]) % M;cout << f[n] << endl;return 0;
}

数位统计类DP

计数问题

分情况讨论：
注，当统计0出现的次数时，因为第 i i i位之前的应该从1开始

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;int power10(int i)
{int res = 1;while(i --) res *= 10;return res;
}int get_num(vector<int>& num, int l, int r)
{if(l < r) return 0;int res = 0;for(int i = l; i >= r; i --){res = res * 10 + num[i];}return res;
}int count(int n, int x)
{if(!n) return 0;//将每一位取出来vector<int> num;while (n){num.push_back(n % 10);n /= 10;}n = num.size();int res = 0;for(int i = n - 1 - !x; i >= 0; i --){res += get_num(num, n - 1, i + 1) * power10(i);if(!x) res -= power10(i);if(num[i] == x) res += get_num(num, i - 1, 0) + 1;if(num[i] > x) res += power10(i);}return res;}int main()
{int a, b;while(cin >> a >> b, a || b){if(a > b) swap(a, b);for(int i = 0; i < 10; i ++){cout << count(b, i) - count(a - 1, i) << ' ';}cout << endl;}
}

状态压缩DP

蒙德里安的梦想

分析题目，当我们先摆横着放的方块，再摆放竖着放的方块，当横着放的小方块摆放完后，竖着放的方块也就确定了，因此总方案数应该等于只放横着的小方块的合法方案数。我们考虑每一列可以摆放成功的小方块，每一种情况可以由一个二进制数来表示，位数等于行数。我们用 f [ i , j ] f[i,j] f[i,j]来表示第 i i i列的第 j j j个状态的合法方案数，可以知道 f [ i , j ] f[i,j] f[i,j]可以由第 i − 1 i - 1 i−1列的状态转移过来，只要第 i − 1 i-1 i−1列的第 k k k个状态与第 i i i列的第 j j j个状态不重叠（ j j j& k k k == 0），且摆放之后不存在连续奇数个0（无法竖着摆放，方案不合法），就代表 f [ i , j ] f[i,j] f[i,j]可以由 f [ i − 1 , k ] f[i-1,k] f[i−1,k]转移过来，且 f [ i , j ] + = f [ i − 1 , k ] f[i,j] +=f[i-1,k] f[i,j]+=f[i−1,k].

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;const int N = 12, M = 1 << 12;int n, m;
long long f[N][M];
bool st[M];int main()
{while(cin >> n >> m, n || m){memset(f, 0, sizeof f);//预处理奇数个0的状态，将其标记for(int i = 0; i < 1 << n; i ++){st[i] = true;int cnt = 0;//将每一位取出来for(int j = 0; j < n; j ++){if(i >> j & 1){if(cnt & 1){st[i] = false;break;}}else cnt ++;}if(cnt & 1) st[i] = false;}f[0][0] = 1; //第0列只有竖着摆放一种情况for(int i = 1; i <= m; i ++){for(int j = 0; j < 1 << n; j ++){for(int k = 0; k < 1 << n; k ++){//是否可以从i-1列的第k个状态转移过来if((j & k) == 0 && st[j | k]){f[i][k] += f[i - 1][j];}}}}//第m列全0，就代表0~m-1列已经摆放合法cout << f[m][0] << endl;}return 0;
}

最短Hamilton路径

如果我们依次枚举所有点，时间复杂度为 O ( n ! ∗ n ) O(n!*n) O(n!∗n)，因此我们用一个二进制的数来表示所有经过的情况，位数是1代表经过了这个点，我们还需要表示该种情况的终点是那个点，如000111表示经过了0到2号点，但我们并不知道终点是那个点，因此我们用 f [ i , j ] f[i,j] f[i,j]来表示，当前经过了 i i i个点且终点为 j j j最小代价， i i i就是我们用来表示所有情况的二进制数。我们要求从0到 n − 1 n -1 n−1经过所有点，就代表 111... 111... 111...这个状态且终点为 n − 1 n-1 n−1，我们可以思考该状态可以由那种状态转移过来，很显然是 011... 011... 011...这状态，而我们知道 011... 011... 011...这个状态是代表了很多终点不同的路径，我们只要枚举 011... 011... 011...该状态下，以终点 k k k结尾的路径再加上 k k k到 j j j的权重 w [ k , j ] w[k,j] w[k,j]，求最小值即可。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;const int N = 20, M = 1 << N;int n;
int w[N][N];
int f[M][N];int main()
{cin >> n;memset(w, 0x3f, sizeof w);for(int i = 0; i < n; i ++)for(int j = 0; j < n; j ++)cin >> w[i][j];memset(f, 0x3f, sizeof f);f[1][0] = 0; //初始时只有0号点for(int i = 0; i < 1 << n; i ++){//枚举当前状态的最后一个点jfor(int j = 0; j < n; j ++){if((i >> j) & 1){// i-(1<<j)是上一个状态，即j位上是0for(int k = 0; k < n; k ++){//枚举到上一个状态的终点k，求最小值if(i - (1 << j) >> k & 1) f[i][j] = min(f[i][j], f[i - (1 << j)][k] + w[k][j]);}}}}cout << f[(1 << n) - 1][n - 1] << endl;return 0;
}

树形DP

没有上司的舞会

对于每一个根节点，我们求出包含该节点和不含该节点的最大值，其中包含该节点的最大值 f [ u , 1 ] f[u,1] f[u,1]应该等于不含其所有子节点的最大值之和，不包含该节点的最大值 f [ u , 0 ] f[u,0] f[u,0]应该等于其所有包含或者不包含子节点的最大值之和。

#include <iostream>
#include <cstring>
#include <algorithm>
using namespace std;const int N = 6010;
int n;
int h[N], e[N], ne[N], idx;
int f[N][2];
int happy[N];
bool have[N];void add(int a, int b)
{e[idx] = b, ne[idx] = h[a], h[a] = idx ++;
}int dfs(int u)
{f[u][1] = happy[u];//邀请某人，就要先把某人的加上for(int i = h[u]; i != -1; i = ne[i]){int j = e[i];dfs(j); //递归求解每个子节点的最大利益f[u][0] += max(f[j][0], f[j][1]); //不邀请上司，要让下属的利益最大化f[u][1] += f[j][0]; //邀请上司，则下属都不来}
}
int main()
{cin >> n;memset(h, -1, sizeof h);for(int i = 1; i <= n; i ++) cin >> happy[i];for(int i = 1; i < n; i ++){int a, b;cin >> a >> b;have[a] = true;//判断其有没有父节点add(b, a);}int root = 1;while(have[root]) root ++;//找到根节点dfs(root);int res = max(f[root][0], f[root][1]);cout << res << endl;return 0;
}

记忆化搜索

记忆化搜索=递归+备忘录
我们在求解一个问题时，将其拆分为子问题，递归求解每一个子问题的解，而在递归求解过程中，我们有时候会重复计算某一个状态的值，因此我们可以使用一个备忘录将其存下来，每次遍历到这个状态时直接返回即可。

滑雪

#include <iostream>
#include <algorithm>
#include <cstring>
using namespace std;const int N = 310;int n, m;
int g[N][N];
int f[N][N];int dx[4] = {-1, 0, 1, 0}, dy[4] = {0, 1, 0, -1};int dfs(int x, int y)
{//状态已经计算过，就返回int& v = f[x][y];if(v != -1) return v;v = 1;for(int i = 0; i < 4; i ++){int a = x + dx[i], b = y + dy[i];if(a > 0 && a <= n && b > 0 && b <= m && g[a][b] < g[x][y]){//递归求解每一个子问题的解v = max(v, dfs(a, b) + 1);}}return v;
}int main()
{cin >> n >> m;for(int i = 1; i <= n; i ++)for(int j = 1; j <= m; j ++)cin >> g[i][j];memset(f, -1, sizeof f);int res = 0;for(int i = 1; i <= n; i ++)for(int j = 1; j <= m; j ++)res = max(res, dfs(i, j));cout << res << endl;return 0;
}

算法笔记——常见DP问题汇总相关推荐

1. 机器学习及大数据经典算法笔记汇总

   机器学习及大数据经典算法笔记汇总 一.总结 二.机器学习及大数据算法 机器学习及大数据经典算法笔记汇总 一.总结 前面的博文,介绍了很多TensorFlow 以及 DeepLeaning 的算法.这里 ...

2. 《算法笔记》中文版 - 包括数组，链表，树，图，递归，DP，有序表等相关数据结构与算法的讲解及代码实现...

   来源:专知本文为资源,建议阅读5分钟本文为你分享<算法笔记>中文版. https://github.com/Dairongpeng/algorithm-note 目录概览 第一节 复杂度. ...

3. 《algorithm-note》算法笔记中文版正式发布！

   无论是做机器学习.深度学习.自然语言处理还是其它领域,算法的重要性不言而喻!吃透算法底层原理.掌握算法数学推导和代码实现,对提高自己的硬核实力来说非常重要!今天给大家推荐一个超赞的开源算法笔记!中文版 ...

4. 【算法】《algorithm-note》算法笔记中文版正式发布！

   无论是做机器学习.深度学习.自然语言处理还是其它领域,算法的重要性不言而喻!吃透算法底层原理.掌握算法数学推导和代码实现,对提高自己的硬核实力来说非常重要!今天给大家推荐一个超赞的开源算法笔记!中文版 ...

5. 【算法笔记】极客时间　算法面试通关40讲　笔记　　覃超

   [算法笔记]极客时间 算法面试通关40讲 覃超 [算法笔记]极客时间 算法面试通关40讲 覃超 相关链接 在leetcode 上的题号 数组.链表: (堆)栈stack.队列queue 优先队列 哈希 ...

6. 算法笔记知识点整理大全

   每次刷题都觉得自己吃了知识点不全,基础不牢固的亏,刷题的时候目标也不明确,于是看完了算法笔记并把知识点归纳了一下,当然直接看书会更加详细,这个归纳只是学习时加深印象以及方便自己之后回顾而已:之后刷题大 ...

7. 算法笔记——每日一题（完结）

   算法笔记 From Now To My Death 前言 初级算法 1.两数之和 7.整数反转 9.回文数 14.最长公共前缀 27.移除元素[拷贝复制] 28.实现strStr()[双指针] 35. ...

8. 《算法笔记》——笔记

   算法笔记 胡凡 曾磊 主编 机械工业出版社 文章目录 算法笔记 C/C++快速入门 提醒 memset sscanf与sprintf 引用 浮点数的比较 圆周率 复杂度 黑盒测试 入门篇(1)--入门 ...

9. 数据结构与算法笔记（十五）—— 散列(哈希表)

   一.前沿 1.1.直接寻址表 当关键字的全域U比较小时,直接寻址是一种简单而有效的技术.假设某应用要用到一个动态集合,其中每个元素都有一个取自全域U={0,1,-,m-1)的关键字,此处m是一个不很大 ...

最新文章

1. 拼接召回在飞猪交通域的实践
2. 热键枚举Winform程序全局热键与局部热键(键盘快捷键的捕获)
3. php 字符串判空,php 使用 preg_replace 去除空格后的字符串无法判空
4. 鸿蒙系统笔记本价格,鸿蒙系统手机华为P50将明年3月发售，华为P40价格骤降至冰点...
5. 判别分析分为r型和q型吗_电流互感器天天见，但是你真正了解和知道它的一些注意事项吗？...
6. android jni fork()子进程不运行_Android高级面试谈谈Zygote的理解
7. 【vue】路由Router基础详解，带你快速入门~
8. 在线电子商务网站 分页 的封装
9. Intellij IDEA之Mybatis插件：Free Mybatis Plugin
10. postman安装与使用
11. 为你的域名添加子域名（二级域名）并绑定网站
12. 使用github搭建网站
13. 吉大17秋计算机应用二,吉大17秋《计算机应用基础》在线作业二.doc
14. 您只能在Photoshop CS4中做的3酷技巧
15. 问题-fuxi job failed ,cased by:Invalid decimal format.
16. Pycaffe 使用集锦
17. 【攻防世界】REVERSE新手练习区 - Hollo，CTF
18. 基于asp.net执勤综合管理系统的设计与实现
19. 链表2--JZ25复杂链表的复制JZ36两个链表的第一个公共结点JZ55链表中环的入口结点JZ56删除链表中重复的结点
20. 突发！链家程序员删了公司9TB数据，被判7年。。

热门文章

1. 关于urllib2.urlopen()的理解
2. docker安装mysql（PXC）集群
3. python实训报告万能模板_(完整word版)实训报告万能模板
4. 雅思写作6.5分的奥秘在这里
5. linux 移除用户所在的组,Linux用户及用户组添加和删除操作
6. 零碎知识点之二：循环平稳信号
7. 设计一个互联网交换设备的SNMP MIB库“X-MIB”
8. oracle vba 数组_vba 数据库目录
9. ios 闪退的原因及解决方案
10. 关于VMware虚拟机萌新使用教程