算法之树形dp

1.没有上司的舞会

• 题目链接
• 参考代码：

#include<bits/stdc++.h>
using namespace std;
int dfs(int root,vector<int> &vec,
		vector<vector<int>> &child,vector<int> &dp){
	if(dp[root]!=0) return dp[root];
	
	//没有选择该节点，那么可以选择子节点；
	int res1=0;
	for(int i=0;i<child[root].size();i++){
		int tmp=child[root][i];
		res1+=dfs(tmp,vec,child,dp);
	}
	
	//选择该节点，那么不可以选择子节点，但是可以选择子孙节点。
	int res2=vec[root];
	for(int i=0;i<child[root].size();i++){
		int tmp1=child[root][i];
		for(int j=0;j<child[tmp1].size();j++){
			int tmp2=child[tmp1][j];
			res2+=dfs(tmp2,vec,child,dp);
		}
	}
	
	//记忆化搜索和树形dp核心所在；
	dp[root]=max(res1,res2);
	return dp[root];
}
int main()
{
	int n;
	vector<int> vec(n+1,0);
	vector<vector<int>> child(n+1,vector<int>());
	vector<int> dp(n+1,0);
	vector<int> flag(n+1,0);
	
	cin>>n;
	for(int i=1;i<=n;i++) cin>>vec[i];
	for(int i=0;i<n-1;i++){
		int x,y;cin>>x>>y;
		child[y].push_back(x);
		flag[x]++;
	} 
	int root=0;
	for(int i=1;i<=n;i++){
		if(flag[i]==0){
			root=i;
			break;
		}
	}
	
	cout<<dfs(root,vec,child,dp);
    return 0;
}

2.上司舞会变形

2.1 描述

• G将军有一支训练有素的军队，这个军队除开G将军外，每名士兵都有一个直接上级(可能是其他士兵，也可能是G将军)。现在G将军将接受一个特别的任务，需要派遣一部分士兵(至少一个)组成一个敢死队，为了增加敢死队队员的独立性，要求如果一名士兵在敢死队中，他的直接上级不能在敢死队中。请问，G将军有多少种派出敢死队的方法。注意，G将军也可以作为一个士兵进入敢死队。
• 输入格式：输入的第一行包含一个整数n，表示包括G将军在内的军队的人数。军队的士兵从1至n编号，G将军编号为1。接下来n-1个数，分别表示编号为2, 3, …, n的士兵的直接上级编号，编号i的士兵的直接上级的编号小于i。
• 输出格式：输出一个整数，表示派出敢死队的方案数。由于数目可能很大，你只需要输出这个数除10007的余数即可。

样例1：
输入：3 1 1
输出：4
样例说明，这四种方式分别是：选1，选2，选3，选2和3。
样例2
输入：7 1 1 2 2 3 3
输出：40
数据规模与约定
对于20%的数据，n ≤ 20；
对于40%的数据，n ≤ 100；
对于100%的数据，1 ≤ n ≤ 100000；

2.2 分析

• 首先，这道题和第一道题是同种类型的题目，只是最后要求的结果不一样，树形dp的难点在于树上做动态规划。dp[i][0]代表第i个节点的人不去的方案数，dp[i][1]代表第i个节点去的方案数。难点来了， i节点去和不去的方案数和什么有关呢？仔细分析得到，如果i节点去，那么他的下属都不能去，因此dp[i][1]=dp[j][0]*dp[k][0]*dp[x][0]....(j,k,x都是i节点的下属，为什么用的是乘法呢，这是应用到了乘法原理，下边还会用到)。同理分析可得不去的情况：dp[i][0]=dp[j][0]*dp[j][1]+dp[k][0]*dp[k][1]+dp[x][0]*dp[x][1]......。
• 根据题目简化表达式，可以把所有人都不去的情况先算在内，最后输出答案的时候减1即可。这样的话，我们可以通过乘法原理简化出上边的代码dp[i][0]=(dp[j][0]+dp[j][1])* (dp[k][0]+dp[k][1])*......(其中j,k,.....为孩子节点)。
• 到此，递推公式可以写成下面的形式：

dp[i][1]=dp[j][0]*dp[k][0]*dp[x][0].....; //其中j,k,x都是i节点的下属;
dp[i][0]=(dp[j][0]+dp[j][1])*·········;   //其中j为i的子节点;

• 最后，就是如上的代码，得到的递推式最终形式：

dp[i][1]*=dp[m[i][j]][0];
dp[i][0]*=(dp[m[i][j]][0]+dp[m[i][j]][1]);
//其中m[i][j]就是i节点的子节点，j=0,1,2,3.....；

• 然后把每个节点的初始值为1。当节点为叶子时，没有下属，他去和不去只和他自己有关，去是一种方案，不去是另外一种方案，最后的方案总数应该是根节点去dp[root][1]和不去dp[root][0]之和，再减去所有人都不去的情况。

2.3 参考代码

#include<bits/stdc++.h>
using namespace std;
const int mod=10007;
const int N=100000+5;
vector<vector<int>> vec(N);
vector<vector<int>> dp(N,vector<int>(2,1));
int dfs(int x){
	for(int i=0;i<vec[x].size();i++){
		int tmp=vec[x][i];
		dfs(tmp); 
		//不选择该节点；
		dp[x][0]*=dp[tmp][0]+dp[tmp][1];
		dp[x][0]%=mod;
		//选择该节点；
		dp[x][1]*=dp[tmp][0];
		dp[x][1]%=mod;
	}
}
int main()
{
	int n;cin>>n;
	for(int i=2;i<=n;i++){
		int x;cin>>x;
		vec[x].push_back(i);
	}
	int root=1;
	dfs(root);
	cout<<(dp[root][0]+dp[root][1]-1)%mod;
	return 0;
}

2.4 改进

• 虽然使用递归可以解决问题，但是该题的数据规模比较大，不适合使用递归，因此，我们选择使用迭代的方式解决(前提是题目提示编号i的士兵的直接上级的编号小于i)，代码是差不多相同的。
• 参考代码：

#include<bits/stdc++.h>
using namespace std;
const int mod=10007;
const int N=100000+5;
vector<vector<int>> vec(N);
vector<vector<int>> dp(N,vector<int>(2,1));
int main()
{
	int n;cin>>n;
	for(int i=2;i<=n;i++){
		int x;cin>>x;
		vec[x].push_back(i);
	}
	for(int x=n;x>=1;x--){
		for(int j=0;j<vec[x].size();j++){
			int tmp=vec[x][j];
			//不选择该节点；
			dp[x][0]*=dp[tmp][0]+dp[tmp][1];
			dp[x][0]%=mod;
			//选择该节点；
			dp[x][1]*=dp[tmp][0];
			dp[x][1]%=mod;
		}	
	}
	int root=1;
	cout<<(dp[root][0]+dp[root][1]-1)%mod;
	return 0;
}

3.相关应用

• 打家劫舍序列三