基础 DP

LIS

LIS（Longest Increasing Subsequence），顾名思义，就是最长上升子序列问题。

在这里我们要区分一下子串和子序列的区别，很简单，子串连续，子序列可以不连续。然而就在几小时之前本蒟蒻还不知道

简单来说，就是给出一个内容不重复的序列，求它的最长上升子序列。听君一席话，如听一席话

下面介绍两种做法，$O(n^2)$ 的 DP 做法和 $O(n\log n)$ 的二分做法。

$O(n^2)$ DP

我们用 dp[i] 表示以 a[i] 为结尾的 LIS，剩下的自己理解就好啦 QwQ 学了优化之后就不会朴素做法了

#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)$ 二分

显然，对于一个 LIS，要让它结尾的数尽量的小，才能使LIS最长。

举个栗子：对于“$\text{5201314}$”，第一步为“$\text{5}$”；第二步发现 $2<5$，所以换为“$\text{2}$”；第三步发现 $0<2$，所以换为“$\text{0}$”；第四步发现$1>0$，把$1$放进去变为“$\text{05}$”；第五步发现$0<3<5$，所以换为“$\text{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\log n)$。

$O(n^2)$ DP

假设 $\mathrm{dp}(i,j)$ 为序列 $A=a_1{a}_2\cdots a_i$ 与序列 $B=b_1{b}_2\cdots B_j$ 的最长公共子序列的长度。当 $i=0$ 或 $j=0$ 时，空序列是 $A$、$B$ 序列的最长子序列，状态转移方程如下：
$$dp(i,j)=\{\begin{array}{ll}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\ne y_j\end{array}$$

$O(n\log n)$ 二分

我们可以建立一个映射，把序列 $A$ 中的每一个元素映射为它对应的数组下标（这里本可以用 map 炫技，但是我们还是采用朴素的数组实现），显然这个序列是上升的，我们把 $B$ 中可以转换的元素都转换为它在 $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 位运算技巧，转载自 Xu brezza，原文链接

1. 询问第 $i$ 位是否为 $1$:

   x&(1<<(i-1))
   

   • 如果这么写返回的不是 $1$ ！

   (x>>(i-1))&1
   

   • 这样才返回 $01$

2. 将 $x$ 第 $i$ 位取反

   x^=1<<(i-1)
   

3. 将 $x$ 第 $i$ 位变为 $1$

   x|=1<<(i-1)
   

4. 将 $x$ 第 $i$ 位变为 $0$

   x&=(~(1<<(i-1)))
   

5. 去掉 $x$ 最右边的 $1$，也就是 $\text{lowbit}(x)$

   x&=x-1
   

6. 取出最右边的 $1$ ，还是 $\text{lowbit}(x)$

   x&(-x)
   

7. 判断是否有连续的 $1$

   x&(x<<1)
   

还是注意，不返回 $1$。

8. 枚举子集

敲黑板，非常重要且实用！

for(int y=x;y;y=(y-1)&x)

数位 DP

数位 DP，顾名思义，就是针对数位的 DP。

举个栗子，求给定区间中，满足给定条件的，某个进制数或此类数的数量。给定条件通常与数位有关，例如数位之和、指定数码个数、数的大小顺序分组等。邪恶的出题人往往把区间开的很大，让我们的暴力解法无法实现，所以我们就需要采用数位 DP 解决。

数位 DP 的基本思想：逐位确定。

练手板子题：P2657

区间 DP

区间类动态规划问题，首先考虑的就是建立一个数组 $f(i,j)$ 存储区间内的最优解，然后枚举断点 $k$，$f(i,j)=f(i,k)+f(k+1,j)$。

区间 DP 的解法基本满足：

1. 枚举区间
2. 枚举左端点
3. 枚举断点

区间DP的特点：

• 合并：合并区间或拆分区间
• 特征：能将问题转化为区间合并
• 求解：类似分治

区间DP有一种特殊情况，即环状区间，我们可以把一个长为 $n$ 的环转化为 $2n$ 长的链，枚举 $f(1,n),f(2,n+1),\cdots ,f(n,2n-1)$ 找到最优值即可。

树形 DP（树上背包）

对于一棵树，每个节点上有一个物品，每个体积为 $w_i$，价值为 $v_i$。选了一个点必须选它的父亲。问总体积不超过 $m$ 的情况下总价值最大值。

乍一看，很像一道 $01$ 背包，但是又有基于树状数据结构的限制条件。

于是乎，我们请出神级 DP 状态设计。

首先我们来一种更加好懂的三维思路。我们设 $f(i,j,k)$ 表示对于根节点为 $i$ 的子树，考虑它的前 $k$ 棵子树，给它 $j$ 的体积，能得到的最大价值。显然这时候，$i$ 物品一定要选。显然，当前状态一定是由前 $k-1$ 棵子树转移而来，于是乎我们可以用 $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）：