dp套dp

我们先说一下 $d p$ 套 $d p$ 大概是个什么东西。

感性理解一些，你现在有一个动态规划数组 $g$ ，然后你的 $f$ 用 $g$ 的某种方式作为下标进行转移。

事实上，这个 $g$ 需要满足单调性，然后相当于你是在一个 $D A G$ 上做 $d p$ 。为什么要满足单调性，否则有可能出现环，有环代表你的状态有后效性，有后效性则无法转移。

游园会

首先最长公共子序列的动态规划是好做的，这里就不说了。

这里设最长公共子序列的动态规划数组为 $g$ 。

我们先设 $f_{i, w_{1}, w_{2}, \dots, w_{k}}$ 为长度为 $i$ 且 $g_{i, j} = w_{j}$ 的字符串个数。

但是你发现 $w$ 你存不下来。于是我们考虑有没有什么性质能够帮助我们优化。

显然有 $g_{i, j} - g_{i, j - 1} \leq 1$ 。于是你考虑 $f$ 的后面维度不存储真正意义上的 $w$ ，而存储 $w$ 的差分数组，于是每一位都是 $0$ 或者 $1$ 。状态数共 $n \times 2^{k}$ ，可以接受。

但是你又发现，我们知道 $s_{i}$ （题目给出），也就是说当前的 $g_{i}$ 只跟 $t_{i}$ 和 $g_{i - 1}$ 有关。于是我们在做 $g$ 的转移时只记 $g_{i - 1}$ 就行（就是滚动数组优化）。

然后是我们的 $f$ 也可以用滚动数组优化，否则空间会爆。

代码：

#include<bits/stdc++.h>
#define int long long
#define mod 1000000007
#define N 40005
using namespace std;
int n,k,f[2][N][3],g[2][20],cnt[N],res[20];
char s[20];
void solve1(int state){
	memset(g[0],0,sizeof g[0]);
	for(int i=0;i<k;i++){
		g[0][i+1]=state>>i&1;
	}
	for(int i=1;i<=k;i++){
		g[0][i]+=g[0][i-1];
	}
}
int solve2(){
	int state=0;
	for(int i=1;i<=k;i++){
		int x=g[1][i]-g[1][i-1];
		state|=x*(1<<i-1);
	}
	return state;
}
void solve(int cur,int state,char c,int now,int las){
	if(las==0)return;//没有贡献不用转移 
	if(c=='I'&&now==2)return;//包含了子串NOI 
	int ne=c=='N'?1:0;//如果是N，下一个就从I匹配，否则从N 
	if(now==0&&c=='N')ne=1;//如果当前应匹配第0个且是N，后跳一位 
	else if(now==1&&c=='O')ne=2;//同上 
	solve1(state);//把差分记录的状态还原 
	memset(g[1],0,sizeof g[1]);//先清空 
	for(int i=1;i<=k;i++){
		if(s[i]==c){//如果s_i=t_j，可以使用特殊转移 
			g[1][i]=max(g[1][i],g[0][i-1]+1);//这里的g_{0,i-1}就是lcs_{i-1,j-1} 
		}
		g[1][i]=max({g[1][i],g[0][i],g[1][i-1]});//否则使用一般转移（g_{0,i}就是lcs_{i,j-1}，g_{1,i-1}就是lcs_{i-1,j} 
	}
	int res=solve2();//再把当前数组弄成差分状态存进去 
	(f[cur][res][ne]+=las)%=mod;//继承上一个 
} 
signed main(){
	cin>>n>>k>>s+1;
	int cur=0;
	f[0][0][0]=1;
	for(int i=1;i<=n;i++){
		cur^=1;
		memset(f[cur],0,sizeof f[cur]);
		for(int j=0;j<1<<k;j++){
			for(int p=0;p<3;p++){
				char c=p==0?'N':p==1?'O':'I';
				solve(cur,j,c,0,f[cur^1][j][0]);
				solve(cur,j,c,1,f[cur^1][j][1]);
				solve(cur,j,c,2,f[cur^1][j][2]);
			}
		}
	}
	for(int i=1;i<1<<k;i++){
		cnt[i]=cnt[i>>1]+(i&1);//cnt是这个数二进制表示有几个1，这里有几个1代表lcs长度就是几 
	}
	for(int i=0;i<1<<k;i++){
		for(int j=0;j<3;j++){
			(res[cnt[i]]+=f[cur][i][j])%=mod;
		}
	}
	for(int i=0;i<=k;i++){
		cout<<res[i]<<'\n';
	}
	return 0;
}

小 N 的独立集

独立集是指，一堆点他们两两之间没有边。最大权独立集是指，所有的独立集中，权值之和最大的那个。

这道题我们从部分分说起。

$n \leq 8$

枚举所有可能的权值分配。然后参照这道题写个动态规划就行了。

$n \leq 100$

首先 $f$ 数组与这道题的设立相同。

我们考虑将 $f$ 数组的值设为状态。

设 $g_{u, v_{0}, v_{1}}$ 为 $f_{u, 0} = v_{0}, f_{u, 1} = v_{1}$ 的方案数。

我们枚举 $i, j, p, q$ 分别为 $f_{u, 0}, f_{u, 1}, f_{v, 0}, f_{v, 1}$ 。

于是有 $g_{u, i + max (p, q), j + p}^{'} \to g_{u, i + max (p, q), j + p}^{'} + g_{u, i, j} \times g_{v, p, q}$ 。

$n \leq 1000$

上述转移无法通过的一个重要原因是，我们的状态复杂度过高，所以我们要优化状态。

我们重新定义 $f_{u, 1 / 0}$ 为 $u$ 子树内是否强制不选节点 $u$ 时的最大权值。于是有 $0 \leq f_{u, 0} - f_{u, 1} \leq k$ 。因为两者之差不超过 $u$ 点的权值，而权值不超过 $k$ ，这样就优化掉了一个 $n$ 。

于是 $g_{u, v_{1}, d}$ 为 $u$ 子树内 $f_{u, 0 / 1}$ 分别为 $v_{1} + d, v_{1}$ 的方案数，然后还是枚举 $i, j, p, q$ ，有： $g_{u, i + p + q, max (i + j + p, i + p + q) - (i + p + q))}^{'} \to g_{u, i + p + q, max (i + j + p, i + p + q) - (i + p + q))}^{'} + g_{u, i, j} + \times g_{v, p, q}$ 。

此时复杂度 $O (n^{2} \times k^{4})$ ，可以通过。

代码：

#include<bits/stdc++.h>
#define int long long
#define N 1005
#define M 2009
#define mod 1000000007
using namespace std;
int n,k,siz[N];
int f[N][N*6][6],g[N*6][6];
int h[N],e[M],ne[M],idx; 
void add(int a,int b){
	e[idx]=b;ne[idx]=h[a];h[a]=idx++;
}
void dfs(int u,int fa){
	siz[u]=1;
	for(int i=1;i<=k;i++){
		f[u][0][i]=1;
	}
	for(int a=h[u];~a;a=ne[a]){
		int v=e[a];
		if(v==fa)continue;
		dfs(v,u);
		memset(g,0,sizeof g);
		for(int i=0;i<=k*siz[u];i++){
			for(int j=0;j<=k;j++){
				if(f[u][i][j]==0)continue;
				for(int p=0;p<=k*siz[v];p++){
					for(int q=0;q<=k;q++){
						if(f[v][p][q]==0)continue;
						int &t=g[i+p+q][max(i+j+p,i+p+q)-(i+p+q)];
						(t+=f[u][i][j]*f[v][p][q]%mod)%=mod;
					}
				}
			}
		}
		memcpy(f[u],g,sizeof g);
		siz[u]+=siz[v];
	}
}
signed main(){
	cin>>n>>k;
	memset(h,-1,sizeof h);
	for(int i=1;i<n;i++){
		int a,b;
		cin>>a>>b;
		add(a,b);add(b,a); 
	}
	dfs(1,0);
	for(int i=1;i<=k*n;i++){
		int res=0;
		for(int j=0;j<=min(i,k);j++){
			(res+=f[1][i-j][j])%=mod;
		}
		cout<<res<<'\n';
	}
	return 0;
}