树形DP泛做

因为树形DP也算是dp里面的一种类型，虽然感觉没有什么总结的必要，但是碰到一些经典的套路还是想要记录一下，所以发在这个博客里

树形dp可以分为两种类型，一个是选择节点类，一个是树上背包类，大致如下

1. 牛客小白月赛55F

题目描述:

给出一个拓扑序关系的树型图，问图上的节点有多少种排列可能

思路:

首先考虑下面这个问题:有a个红气球,b个绿气球，c个蓝气球有多少种排列组合，这就是一个多重全排列问题 ans=(a+b+c)!/a!/b!/c!  即为所有气球的全排列除以各个相同颜色的气球的全排列，即各个子集和的全排列除以各个子集和的限制条件    

那么对于这一题，用这个思想，他们满足以下关系

代码:

#include<bits/stdc++.h>
#define int long long
#define io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const int maxn=2e5+5;
const int inf=1e9+7;
const int mod=1e9+7;
vector<int>vec[maxn];
int fac[maxn],inv[maxn];
void init(int n=1e5+5){
	fac[0]=1;
	fac[1]=1;
	for(int i=2;i<=n;i++){
		fac[i]=fac[i-1]*i%mod;
	}
	inv[1]=1;
	for(int i=2;i<=n;i++){
		inv[i]=(mod-mod/i)*inv[mod%i]%mod;
	}
	for(int i=2;i<=n;i++){
		inv[i]=inv[i]*inv[i-1]%mod;
	}
}
int dp[maxn];
int siz[maxn];
void dfs1(int u,int fa){
	siz[u]=1;
	for(int v:vec[u]){
		if(v!=fa){
			dfs1(v,u);
			siz[u]+=siz[v];
		}
	}
}
void dfs(int u,int fa){
	dp[u]=fac[siz[u]-1];
	for(int v:vec[u]){
		if(v!=fa){
			dfs(v,u);
			dp[u]=dp[u]*dp[v]%mod;
			dp[u]=dp[u]*inv[siz[v]]%mod;
		}
	}
}
int dpp[maxn];
int sizz[maxn];
void solve(){
	int n;
	cin>>n;
	int zong=0;
	for(int i=1;i<=n;i++){
		int m;
		cin>>m;
		for(int j=0;j<=m;j++){
			vec[j].clear();		
		}
		for(int j=2;j<=m;j++){
			int u,v;
			cin>>u;
			v=j;
			vec[u].push_back(v);
			vec[v].push_back(u);
		}
		dfs1(1,0);
		dfs(1,0);
		dpp[i]=dp[1];
		sizz[i]=siz[1];
		zong+=sizz[i];
	}
	int ans=fac[zong];
	for(int i=1;i<=n;i++){
		ans=ans*dpp[i]%mod;
		ans=ans*inv[sizz[i]]%mod;
	}
	cout<<ans<<"\n";
}
signed main(){
	init();
	int t=1;
	//cin>>t;
	while(t--){
		solve();
	}
}

2.Codeforces Round #686 (Div. 3) E

这题是一个基环树，即n个节点n条边，那么一定会构成一个环，把这个环上面的各个点当作树的根节点，那么就是一个环上面有若干颗树

一个经典的套路:树里面任意两点都有一条简单路径，所以假设一颗树有n个节点，则有n*(n-1)/2条简单路径

#include<bits/stdc++.h>
using namespace std;
typedef long long ll;
const int N = 2e5 + 5;
set<int> G[N];
ll vis[N];
int main() {
  ios::sync_with_stdio(false), cin.tie(nullptr), cout.tie(nullptr);
  int T; cin >> T;
  while(T--) {
    int n; cin >> n;
    for(int i = 1; i <= n; i++) G[i].clear(), vis[i] = 1;
    for(int i = 1; i <= n; i++) {
      int u, v; cin >> u >> v;
      G[u].insert(v);
      G[v].insert(u);
    }
    queue<int> q;
    for(int i = 1; i <= n; i++) {
      if(G[i].size() == 1) {
        q.push(i);
        vis[i] = 1;
      }
    }
    while(!q.empty()) {
      int u = q.front(); q.pop();
      for(auto &v : G[u]) {
        vis[v] += vis[u];
        vis[u] = 0;
        G[v].erase(u);
        if(G[v].size() == 1) {
          q.push(v);
        }
      }
    }  
    ll ans = 0;
    for(int i = 1; i <= n; i++) {
      ans += (vis[i] - 1) * vis[i] / 2;
      ans += vis[i] * (n - vis[i]);
    } 
    cout << ans << '\n';
  }  
  return 0;
}

3.P2014 [CTSC1997] 选课

 树上背包板子题

此题的上下界优化代码(其实就是把上下界限制了一下),时间复杂度O(n^2)，即限制好子树和父亲的上下界转移就好，这样是不会超时的，不可能遇到这样优化还不够的题目

#include<bits/stdc++.h>
#define int long long
#define io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const int maxn=1005;
const int inf=1e9+7;
const int mod=1e9+7;
vector<int>vec[maxn];
int a[maxn];
int dp[maxn][maxn];
int sz[maxn];
int n,m;
void dfs(int u,int fa){
	sz[u]=1;
	dp[u][0]=0;
	for(int v:vec[u]){
		if(v==fa)continue;
		else{
			dfs(v,u);			
			for(int i=sz[u];i>=0;i--){
				for(int j=sz[v];j>=0;j--){
					if(i+j>m+1){
						continue;
					}
					dp[u][i+j]=max(dp[u][i+j],dp[u][i]+dp[v][j]);
				}
			}
			sz[u]+=sz[v];
		}
	}
	for(int i=sz[u];i>=1;i--){
		dp[u][i]=dp[u][i-1]+a[u];
	}
}
void solve(){
	cin>>n>>m;
	//从n个里面选择m个,要求总价值最大
	memset(dp,-0x3f,sizeof(dp));
	for(int i=1;i<=n;i++){
		int now,val;
		cin>>now>>val;
		vec[now].push_back(i);
		vec[i].push_back(now);
		a[i]=val;
	}
	dfs(0,-1);
	cout<<dp[0][m+1]<<"\n";
}
signed main(){
	int t=1;
	//cin>>t;
	while(t--){
		solve();
	}
}

4.202南京站M题

定义dp[i][j][k]代表以i为根节点的子树，消去了j个节点，其中第i个节点消去/不消去的最小值，转移即可

#include<bits/stdc++.h>
#define int long long
#define io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const int maxn=2005;
const int inf=1e9+7;
const int mod=1e9+7;
vector<int>vec[maxn];
int a[maxn];
int dp[maxn][maxn][2];
//0/1 消去/不消去
//dp[i][j][k]代表以i为根节点的子树,消去了j个节点,其中第i个消去/不消去的最小值
int sz[maxn];
int n;
int tmp00[maxn];
int tmp11[maxn];
void dfs(int u,int fa){	
	int tmp0[maxn];
	int tmp1[maxn];
	int check=0;
	sz[u]=0;
	for(int v:vec[u]){
		if(v==fa){
			continue;
		}
		else{
			dfs(v,u);		
			if(!check){
				check=1;
				//如果当前节点消掉
				for(int j=0;j<=sz[v];j++){
					tmp0[j]=min(dp[v][j][0],dp[v][j][1]);
				}
				//如果当前节点不消掉
				for(int j=0;j<=sz[v];j++){
					tmp1[j]=min(dp[v][j][0],dp[v][j][1]+a[v]);
				}
			}
			else{
				for(int i=0;i<=sz[u]+sz[v];i++){
					tmp00[i]=1e18;
					tmp11[i]=1e18;
				}
				//可以枚举了
				for(int i=sz[u];i>=0;i--){
					for(int j=sz[v];j>=0;j--){
						if(i+j>n){
							continue;
						}
						else{
							tmp00[i+j]=min(tmp00[i+j],tmp0[i]+min(dp[v][j][0],dp[v][j][1]));
							tmp11[i+j]=min(tmp11[i+j],tmp1[i]+min(dp[v][j][0],dp[v][j][1]+a[v]));
						}
					}
				}
				for(int i=0;i<=sz[u]+sz[v];i++){
					tmp0[i]=tmp00[i];
					tmp1[i]=tmp11[i];
				}
			}
			sz[u]+=sz[v];
		}
	}
	sz[u]+=1;
	if(check){
		for(int i=sz[u];i>=1;i--){
			//第u个消掉
			dp[u][i][0]=tmp0[i-1];
		}
		for(int i=sz[u];i>=0;i--){
			dp[u][i][1]=tmp1[i]+a[u];
		}
	}
	else{
		//说明是叶子节点
		dp[u][1][0]=0;
		dp[u][0][1]=a[u];
	}
}
void solve(){
	cin>>n;
    for(int i=1;i<=n;i++){
        for(int j=0;j<=n;j++){
            dp[i][j][0]=dp[i][j][1]=1e18;
        }
    }
	for(int i=1;i<=n;i++){
		vec[i].clear();
	}
	for(int i=1;i<=n-1;i++){
		int fa;
		cin>>fa;
		vec[fa].push_back(i+1);
		vec[i+1].push_back(fa);
	}
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	dfs(1,0);
	for(int i=0;i<=n;i++){
		cout<<min(dp[1][i][0],dp[1][i][1])<<" ";
	}
	cout<<"\n";
}
/*
1
4
1 1 2
5 10 14 10*/
signed main(){
	io;
	int t=1;
	cin>>t;
	while(t--){
		solve();
	}
}

5.2022CCPC广州站I

思路:定义

f[i][j]代表以i为根节点的子树当中没有起始节点从第i个开始其子树选择了j个的概率

g[i][j]代表以i为根节点的子树当中有起始节点从第i个开始其子树选择了j个的概率

子树向上面转移时如果选若干个那么第i个是一定要第一个选的，否则相当于跟子树断开了

#include<bits/stdc++.h>
#define int long long
#define io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const int maxn=2e3+5;
const int inf=1e9+7;
const int mod=1e9+7;
vector<int>vec[maxn];
int a[maxn],b[maxn],c[maxn],p[maxn];
int f[maxn][maxn];  //初始感染源不来自u子树
int g[maxn][maxn]; //初始感染源来自u子树
int invsum;
int sz[maxn],t1[maxn],t2[maxn];
int ans[maxn];
int pre[maxn];
int ksm(int x,int n){
	int ans=1;
	while(n){
		if(n&1){
			ans=ans*x%mod;
		}
		x=x*x%mod;
		n>>=1;
	}
	return ans;
}
void dfs(int u,int fa){
	sz[u]=1;
	pre[u]=fa;
	if(u==1){
		pre[u]=1;
	}
	f[u][1]=p[u];
	g[u][1]=a[u]*invsum%mod;
	f[u][0]=g[u][0]=(1-p[u]+mod)%mod;
	for(auto v:vec[u]){
		if(v==fa){
			continue;
		}
		else{
			dfs(v,u);
			memset(t1,0,sizeof(t1));
			memset(t2,0,sizeof(t2));
			for(int i=1;i<=sz[u];i++){
				for(int j=0;j<=sz[v];j++){
					t1[i+j]=(t1[i+j]+f[u][i]*f[v][j]%mod)%mod;
					t2[i+j]=(t2[i+j]+g[u][i]*f[v][j]%mod)%mod;
					if(j){
						t2[i+j]=(t2[i+j]+f[u][i]*g[v][j]%mod)%mod;
					}
				}
			}
			for(int i=1;i<=sz[u]+sz[v];i++){
				f[u][i]=t1[i];
			}
			for(int i=1;i<=sz[u]+sz[v];i++){
				g[u][i]=t2[i];
			}
			sz[u]+=sz[v];
		}
	}
}
void solve(){
	int n;
	cin>>n;
	for(int i=1;i<=n-1;i++){
		int x,y;
		cin>>x>>y;
		vec[x].push_back(y);
		vec[y].push_back(x);
	}
	int sum=0;
	for(int i=1;i<=n;i++){
		cin>>a[i]>>b[i]>>c[i];
		p[i]=b[i]*ksm(c[i],mod-2)%mod;
		sum=(sum+a[i])%mod;
	}
	invsum=ksm(sum,mod-2);
	dfs(1,0);
	for(int i=1;i<=n;i++){
		ans[i]=g[1][i];
		for(int j=2;j<=n;j++){
			ans[i]=(ans[i]+g[j][i]*((1-p[pre[j]]+mod)%mod)%mod)%mod;
		}
	}
	for(int i=1;i<=n;i++){
		cout<<ans[i]<<"\n";
	}
}
signed main(){
	int t=1;
	//cin>>t;
	while(t--){
		solve();
	}
}

6.求断开任意一条边后，两颗子树分别的最长直径 ( 2022CCPC昆明站G )

#include<bits/stdc++.h>
#define int long long
#define io ios::sync_with_stdio(false);cin.tie(0);cout.tie(0);
using namespace std;
const int maxn=2e5+5;
vector<int>vec[maxn];
int n,u[maxn],v[maxn],a[maxn],down[maxn],up[maxn],dp[maxn][5],len[maxn][2],d[maxn],b[maxn];
//dp[u][0|1|2|3]:u的子树的经过u的第1,2,3,4长链
//down[u]代表以u为根的子树的最大直径
//up[u]代表去掉以u为根的子树后的最大直径

/*
第一次dfs预先处理出的数据dp[u][0|1|2|3]表示u的最长|次长|次次长 链
down[u]表示u子树里的最长链长度 */
void dfs1(int u,int fa){
	for(int i=0;i<=3;i++){
		dp[u][i]=a[u];
	}
	for(int v:vec[u]){
		if(v==fa){
			continue;
		}
		else{
			dfs1(v,u);
			int tmp=dp[v][0]+a[u];
			for(int i=0;i<=3;i++){
				if(tmp>dp[u][i]){
					swap(dp[u][i],tmp);
				}
			}
			down[u]=max(down[u],down[v]);
		}
	}
	down[u]=max(down[u],dp[u][0]+dp[u][1]-a[u]);
}

/*
第二次dfs求出
len[u][0|1]表示u子树里的不经过u的最长|次长 链
枚举每个儿子v，
求出dp[v][3]表示v上面的最长链
up[v]表示切断(u，v)后，u所在块的最长链
那么切断(u,v)后，两个子树的直径就是down[v],up[v]
down[v]好求，up[v]要通过u来求出
换根的过程：从u换到v时，up[v]有3种情况，1.一条u的上面+一条u的下面 2.两条u的下面 3.子树的最长链*/

void dfs2(int u,int fa){ //len[u][0|1]:u子树中不经过u的第1,2长直径
	multiset<int,greater<int>>s;
	for(int i=0;i<=3;i++){
		s.insert(dp[u][i]-a[u]);
	}
	s.insert(dp[u][4]);
	int sum=0;
	for(int i=1;i<=4;i++){
		sum+=*s.begin();
		s.erase(s.begin());
	}
	b[u]=sum;
	for(int v:vec[u]){
		if(v==fa){
			continue;
		}
		int tmp=down[v];
		if(tmp>len[u][0]){
			swap(tmp,len[u][0]);
		}
		if(tmp>len[u][1]){
			swap(tmp,len[u][1]);
		}
	}
	for(int v:vec[u]){  //把u->v分成两颗子树
		if(v==fa){
			continue;
		}
		//原树删掉v子树后，求v上方的不包含v的最长链dp[v][4]，同时求出考虑第1,2种情况的最大up[v] 
		if(dp[u][0]==dp[v][0]+a[u]){
			dp[v][4]=max(dp[u][4]+a[u],dp[u][1]);
			up[v]=max(dp[u][2]-a[u],dp[u][4])+dp[u][1];
		}
		else if(dp[u][1]==dp[v][0]+a[u]){//v是u的次深子树 
			dp[v][4]=max(dp[u][4]+a[u],dp[u][0]); 
			up[v]=max(dp[u][2]-a[u],dp[u][4])+dp[u][0];
		}
		else {//v是u的其他子树 
			dp[v][4]=max(dp[u][4]+a[u],dp[u][0]);
			up[v]=max(dp[u][1]-a[u],dp[u][4])+dp[u][0]; 
		}
		//求第3种情况的up[v]也要特别判一下v子树里是否有u下的最长链 
		if(len[u][0]==down[v])up[v]=max(up[v],len[u][1]); 
		else up[v]=max(up[v],len[u][0]);
		dfs2(v,u);
	}
}
void solve(){
	int n;
	cin>>n;
	for(int i=1;i<=n;i++){
		cin>>a[i];
	}
	for(int i=1;i<=n-1;i++){
		int u,v;
		cin>>u>>v;
		vec[u].push_back(v);
		vec[v].push_back(u);
	}
	if(n==1){
		cout<<"0"<<"\n";
		return;
	}
	dfs1(1,0);
	dfs2(1,0);
	int maxx=0;
	for(int i=1;i<=n;i++){
		maxx=max({maxx,up[i]+down[i],b[i]});
	}
	cout<<maxx<<"\n";
}
signed main(){
	int t=1;
	while(t--){
		solve();
	}
}