基础 DP
LIS
LIS(Longest Increasing Subsequence),顾名思义,就是最长上升子序列问题。
在这里我们要区分一下子串和子序列的区别,很简单,子串连续,子序列可以不连续。
简单来说,就是给出一个内容不重复的序列,求它的最长上升子序列。
下面介绍两种做法, O ( n 2 ) O(n^2) O(n2) 的 DP 做法和 O ( n log n ) O(n\log n) O(nlogn) 的二分做法。
O ( n 2 ) O(n^2) O(n2) DP
我们用 dp[i]
表示以 a[i]
为结尾的 LIS。
#include <bits/stdc++.h>
using namespace std;
const int maxn=105,inf=0x7f7f7f7f;
int a[maxn],dp[maxn],n,ans=-inf;
int main()
{
cin>>n;
for(int i=1;i<=n;i++)
cin>>a[i],dp[i]=1;
for(int i=1;i<=n;i++)
for(int j=1;j<i;j++)
if(a[j]<a[i])
dp[i]=max(dp[i],dp[j]+1);
for(int i=1;i<=n;i++)
ans=max(ans,dp[i]);
cout<<ans;
return 0;
}
O ( n log n ) O(n\log n) O(nlogn) 二分
显然,对于一个 LIS,要让它结尾的数尽量的小,才能使LIS最长。
举个栗子:对于“ 5201314 \texttt{5201314} 5201314”,第一步为“ 5 \texttt{5} 5”;第二步发现 2 < 5 2<5 2<5,所以换为“ 2 \texttt{2} 2”;第三步发现 0 < 2 0<2 0<2,所以换为“ 0 \texttt{0} 0”;第四步发现 1 > 0 1>0 1>0,把 1 1 1 放进去变为“ 05 \texttt{05} 05”;第五步发现 0 < 3 < 5 0<3<5 0<3<5,所以换为“ 03 \texttt{03} 03”,以此类推。
对于这个的实现,我们可以巧妙地运用 lower_bound
函数进行二分查找,查找这个要放进去的值所在的区间。
代码如下:
#include <bits/stdc++.h>
using namespace std;
int a[105],f[105];//f is LIS
int main()
{
int n;cin>>n;
for(int i=1;i<=n;i++) cin>>a[i];
f[1]=a[1];
int len=1;
for(int i=2;i<=n;i++)
{
if(a[i]>f[len]) len++,f[len]=a[i];
else
{
int j=lower_bound(f+1,f+n+1,a[i])-f;
f[j]=a[i];
}
}
cout<<len;
return 0;
}
LCS
LCS(Longest Common Sequence),顾名思义,就是最长公共子序列问题。
同样的,还是有两种不同时间复杂度的做法,一种 O ( n 2 ) O(n^2) O(n2),一种 O ( n log n ) O(n\log n) O(nlogn)。
O ( n 2 ) O(n^2) O(n2) DP
假设
dp
(
i
,
j
)
\operatorname{dp}(i,j)
dp(i,j) 为序列
A
=
a
1
a
2
⋯
a
i
A=a_1a_2\cdots a_i
A=a1a2⋯ai 与序列
B
=
b
1
b
2
⋯
B
j
B=b_1b_2\cdots B_j
B=b1b2⋯Bj 的最长公共子序列的长度。当
i
=
0
i=0
i=0 或
j
=
0
j=0
j=0 时,空序列是
A
A
A、
B
B
B 序列的最长子序列,状态转移方程如下:
d
p
(
i
,
j
)
=
{
0
i
=
0
∨
j
=
0
d
p
(
i
−
1
,
j
−
1
)
+
1
i
,
j
>
0
,
x
i
=
y
j
max
(
d
p
(
i
,
j
−
1
)
,
d
p
(
i
−
1
,
j
)
)
x
i
≠
y
j
dp(i,j)= \begin{cases}0&i=0\vee j=0\\ dp(i-1,j-1)+1&i,j>0,x_i=y_j\\ \max(dp(i,j-1),dp(i-1,j))&x_i\neq y_j \end{cases}
dp(i,j)=⎩
⎨
⎧0dp(i−1,j−1)+1max(dp(i,j−1),dp(i−1,j))i=0∨j=0i,j>0,xi=yjxi=yj
O ( n log n ) O(n\log n) O(nlogn) 二分
我们可以建立一个映射,把序列
A
A
A 中的每一个元素映射为它对应的数组下标(这里本可以用 map
炫技,但是我们还是采用朴素的数组实现),显然这个序列是上升的,我们把
B
B
B 中可以转换的元素都转换为它在
A
A
A 中的数组下标,由于要满足递增才能保证序列公共,所以我们就把问题转化成了一个 LIS 问题。
代码如下:
#include <bits/stdc++.h>
using namespace std;
int a[100005],b[100005],c[100005],dp[100005],mp[100005];
int main()
{
int n;cin>>n;
for(int i=1;i<=n;i++) cin>>a[i],mp[a[i]]=i;
for(int i=1;i<=n;i++) scanf("%d",&b[i]);
for(int i=1;i<=n;i++)
c[i]=mp[b[i]];//c存储公共子序列
int temp=0,ans=-0x7fffffff;
for(int i=1;i <= n;i++)
{
int j=upper_bound(dp+1,dp+temp+1,c[i])-dp;
if(j==temp+1) temp++,dp[j]=c[i];
else dp[j]=c[i];
}
cout<<temp;
return 0;
}
状压 DP
状压 DP 的特点:
- 数据规模的某一维或几维很小
- 最优性原理
- 无后效性
状压 DP 的灵魂就是位运算和二进制,可以复习一下 qwq。
详见 P1896题解。
数位 DP
数位 DP,顾名思义,就是针对数位的 DP。
举个栗子,求给定区间中,满足给定条件的,某个进制数或此类数的数量。给定条件通常与数位有关,例如数位之和、指定数码个数、数的大小顺序分组等。邪恶的出题人往往把区间开的很大,让我们的暴力解法无法实现,所以我们就需要采用数位 DP 解决。
数位 DP 的基本思想:逐位确定。
练手板子题:P2657
区间 DP
区间类动态规划问题,首先考虑的就是建立一个数组 f ( i , j ) f(i,j) f(i,j) 存储区间内的最优解,然后枚举断点 k k k, f ( i , j ) = f ( i , k ) + f ( k + 1 , j ) f(i,j)=f(i,k)+f(k+1,j) f(i,j)=f(i,k)+f(k+1,j)。
区间 DP 的解法基本满足:
- 枚举区间
- 枚举左端点
- 枚举断点
区间 DP 的特点:
- 合并:合并区间或拆分区间
- 特征:能将问题转化为区间合并
- 求解:类似分治
区间DP有一种特殊情况,即环状区间,我们可以把一个长为 n n n 的环转化为 2 n 2n 2n 长的链,枚举 f ( 1 , n ) , f ( 2 , n + 1 ) , ⋯ , f ( n , 2 n − 1 ) f(1,n),f(2,n+1),\cdots,f(n,2n-1) f(1,n),f(2,n+1),⋯,f(n,2n−1) 找到最优值即可。
树形 DP(树上背包)
对于一棵树,每个节点上有一个物品,每个体积为 w i w_i wi,价值为 v i v_i vi。选了一个点必须选它的父亲。问总体积不超过 m m m 的情况下总价值最大值。
乍一看,很像一道 01 01 01 背包,但是又有基于树状数据结构的限制条件。
首先我们来一种更加好懂的三维思路。我们设 f ( i , j , k ) f(i,j,k) f(i,j,k) 表示对于根节点为 i i i 的子树,考虑它的前 k k k 棵子树,给它 j j j 的体积,能得到的最大价值。显然这时候, i i i 物品一定要选。显然,当前状态一定是由前 k − 1 k-1 k−1 棵子树转移而来,于是乎我们可以用 01 01 01 背包的思想压掉一维。
常见状态转移方程:(注意由于要考虑儿子的状态,所以要先 DFS)
void dfs(int x)
{
f[x][1]=val[x];
for(int i=head[x];i;i=nxt[i])
{
dfs(to[i]);
for(int j=M+1;j;j--)
for(int k=1;k<j;k++)
f[x][j]=max(f[x][j],f[to[i]][k]+f[x][j-k]);
}
}
树上背包的时间复杂度证明(来自 @Steven24):