基础 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。
cpp
#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 函数进行二分查找，查找这个要放进去的值所在的区间。
代码如下：
cpp
#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 问题。
代码如下：
cpp
#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）
cpp
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）：
