树形dp

树形dp方法小结

树形dp是什么？
树形dp就是在树上dp

• 简单的树形dp

一道例题
树形dp往往跟dfs有很大的联系，我们在做时，可以先dfs然后再dp，也可以一边dfs一边dp
动态规划的核心在于状态的设计与转移

• 设计状态
  f[i][j]
  第一维表示以i为开始
  第二维表示以j结束
  其实这里就有点像区间dp了，我们再循环的时候只用枚举这个区间的断点，就是转移的中继点。
  状态转移方程如下：

$$f[i][j]=f[i][k-1]\ast f[k+1][j]+f[k][k];$$
通过这题我们学到了啥？
如果你看到一棵树，然后有一个明确的计算权的公式，然后你可以考虑用区间动规的思想，毕竟树的本质是递归，乱搞一个三层循环，再做的时候要特别注意一下是顺着循环还是倒着循环。

• 资源分配型

更难的一题
最经典的树莫过于二叉树了，我们在做多叉树时都要把多叉树转为二叉树。所以你连最简单的二叉树你都不会你就凉了

分析题意，你把它爹剪了它也跟着掉了，在去掉了父节点后，以它为根的子树的苹果全没了。
一看这题输入格式，如果你以前没做过，你就会一脸懵B，这玩意咋变成树啊。
你可以熟练的打出你打了无数遍的邻接表存图（链式前向星），或者你用vector
然后开始dfs，随便从哪一个点开始
对了，这里有一个小细节，我自己总结出来的，可能不对，如果你不能判断出这个树的根咋找，那你就建双向边dfs（你可以把它当作一棵无根树），那你又比如你可以通过一些方式，比如说看入度等，就是说它时一棵有根树，那你就可以建单向边然后直接dfs，但是着也不是绝对的，最重要的就是根据实际的题目来看，OI这个东西本来就是很灵活的
扯远了

我们可以新建一个结构体

struct tree{
	int l,r;
}

然后开始dfs

void dfs(int u,int fa){
    for(int i=head[u];i;i=e[i].next){
        int v=e[i].to,w=e[i].number_of_apple;
        if(v!=fa){
            f[v][1]=w;
            if(!tr[u].l) tr[u].l=v;
            else tr[u].r=v;
            dfs(v,u);
        }
    }
}

这大概就是一个基本模板了，如果左子树为空那它就是左子树，如果不为空那它就是右子树。

建完树后你就可以dp了
其实这个题是个资源分配类的题
你可以这么考虑，你还是像刚刚我写的那样考虑断点，
你就可以得到一个这样的方程
$$f[root][j]=max(f[root][j],f[v][k]+f[root][j-k])$$
你这个点的状态可以由那些状态转移而来？
你可以很简单的发现，它是由它的子树决定的，毕竟这样是无后效性的
那我们就得到了一个很重要的结论，我们是从叶子节点开始dp的。
注意，我这里说的是算法的原理
树形dp其实就是在递归上做状态的转移
有了这个思想之后你就可以尝试写写代码了
像这样

void dp(int root){
	for(int i=head[root];i;i=e[i].next){
		int v=e[i].to;
		dp(v);
		for(int j=m+1;j>=1;j--){
			for(int k=0;k<j;k++){
				f[root][j]=max(f[root][j],f[v][k]+f[root][j-k]);
			}
		}
	}
}

一个小细节，这个j中是有root这个根节点的，所以最大子树的资源应该是j-1

从这题我们学到了什么
这个题是一个树上资源型二叉树dp
思路还是先dfs建树，然后考虑断点设计状态方程，进行dp，再考虑一些细节，比如说循环的边界条件，顺序等

• 树上背包
  经典例题
  看完题，只有选了父节点才能选它的子节点，很容易想到状态的第一维是根；然后你只能选一些，那第二维就是分配的资源数，就是课的个数了
  $$f[root][j]=max(f[root][j],f[v][k]+f[root][j-k]);$$
  没错，还是他
  然后你还是像上一题一样递归，但是这题是个森林，你要处理这个问题，最简单的方法还是加一个根节点，原来每棵树的根就是它，那森林就变成一棵树了
  再看下代码就应该懂了，毕竟写的还是简单易懂的

#include<bits/stdc++.h>
using namespace std;
int n,m;
const int maxm=400; 
struct node{
	int to;
	int next;
	int w;
}e[maxm];

int head[maxm],cnt,f[400][400];

void add(int u,int v){
	e[++cnt].next=head[u];
	e[cnt].to=v;
	head[u]=cnt;	
}

void dp(int root){
	for(int i=head[root];i;i=e[i].next){
		int v=e[i].to;
		dp(v);
		for(int j=m+1;j>=1;j--){
			for(int k=0;k<j;k++){
				f[root][j]=max(f[root][j],f[v][k]+f[root][j-k]);
			}
		}
	}
}

int main(){
	cin>>n>>m;
	for(int i=1;i<=n;i++){
		int x,y;
		cin>>x>>y;
		add(x,i);
		f[i][1]=y;
	}
	dp(0);
	cout<<f[0][m+1]<<endl;///把0作为一个点，加入这棵树进行dp(作为根节点)，那么就要取m+1门课 
	return 0;
	
}

一道经典例题
思路跟上题差不多，详细的都在代码注释里

#include<bits/stdc++.h>
#define inf 0x3f3f3f3f
using namespace std;
const int maxm=1000000;
struct node{
	int next;
	int to;
}e[maxm];
int head[maxm],rd[maxm],cnt,f[400][400];
void add(int u,int v){
	e[++cnt].next=head[u];
	e[cnt].to=v;
	head[u]=cnt;
}
int n,m; 
int ans=inf;
void dfs(int u,int fa){
	 
	f[u][1]=rd[u];//在这些边中，有那么一条是连着它和它父节点的，那么你在下面dp的时候，这个边应该
	//已经被减去了，因为你是向下dfs的过程嘛，那么这条边在u中算了一次，在v中算了一次，-2 
	for(int k=head[u];k;k=e[k].next){
		int v=e[k].to;
/*		
		在树上背包的时候一定要记住，第一层循环的是总容量，倒序循环（子树的子节点总和） 
		第二层 当前节点的子节点选择情况，即对于给定的容量，当前子树的最优解，正序循环 
*/
 
		if(v!=fa){  
			dfs(v,u);
			for(int i=m;i>=1;i--){//一共要m个子节点（边） 
				for(int j=1;j<=i;j++){//我儿子切（j）,这里一定要记住枚举的是子树分割的情况，因为这是一个dfs
				//的过程，那么当前节点的其他子节点还正在递归的过程中，所以通过枚举子节点取得个数
				//反推当前节点切掉的个数 
					f[u][i]=min(f[u][i],f[v][j]+f[u][i-j]-2);
				}
			}
		}
	}
}
int main(){
	scanf("%d%d",&n,&m);
	for(int i=1;i<=n-1;i++){
		int u,v;
		scanf("%d%d",&u,&v);
		add(u,v);
		add(v,u);
		rd[u]++;
		rd[v]++;
	}
	memset(f,inf,sizeof(f));
	dfs(1,0);//我们对于有根树，建立单向边，从root开始dfs，对于无根树，建立双向边，把1当作根进行dfs
	for(int i=1;i<=n;i++){
		ans=min(ans,f[i][m]);//f[i][j] [i]第i个节点，[j]保留[j]个结点最少要删去的边数 
	} 
	printf("%d\n",ans);
	return 0;
}

没有上司的舞会
这题也是很有代表性的一题了，就是一条边上至多能取一个点的问题。
类似这样的问题还有，战略游戏
具体的他们是怎么样我真的说不清楚，就是那种对于一定边上点的取舍的限制型题目吧。
这种题就是关于一个点取不取的问题了，我们把0记作不取，1记作取
那么当前点取得时候，他的所有儿子不能取；0就是在儿子当中选择取或不取了
$$f[u][1]=max(max(f[u][1],f[u][1]+f[v][0]),f[v][0]);$$$$f[u][0]=max(max(f[u][0],f[u][0]+f[v][1]),max(f[v][0],f[v][1]));$$
得到了方程就很好做了，代码就不贴了

• 数字变换
  讲道理，这题还是很有意思的。
  我们经常会碰到一些像是小学奥数的题目；那你除了找规律之外，你往往还要想到图论。其实图论的一大难点在于你根本看不出来这是个图论，而且你也不知道咋建图，其实这题本身还是很水的。
  你可以把每一种转换，当成一条边
  就是说一个数它的约数和如果小于它，他们之间就可以相互转换
  那你就会想到建一条双向边对吧
  怎么统计约数和呢，这里提供一种统计约束的方法。

int b[1010][1010]; 
int a[1010];
int n;
void solve(){
	for(int i=1;i<=n;i++){
		for(int j=2;j<=n/i;j++){
			if(i*j>n) continue;
			a[i*j]++;
			b[i*j][a[i*j]]=j;
		}
	}
} 

相信有了我的提示之后
接下来你就可以很快切掉了吧