DP问题
线性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 ++)
{
//枚举当前状态的最后一个点j
for(int j = 0; j < n; j ++)
{
if((i >> j) & 1)
{
// i-(1<<j)是上一个状态，即j位上是0
for(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;
}
1673
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
