Anniversary party poj 2342（树，树状dp入门或两种记忆化搜索可做）

本文介绍了一种解决员工派对欢乐值最大化问题的方法。在考虑员工间的上下级关系及欢乐值的基础上，通过记忆化搜索或树状DP来确定参与派对人员组合，以实现总欢乐值最大。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

There is going to be a party to celebrate the 80-th Anniversary of the Ural State University. The University has a hierarchical structure of employees. It means that the supervisor relation forms a tree rooted at the rector V. E. Tretyakov. In order to make the party funny for every one, the rector does not want both an employee and his or her immediate supervisor to be present. The personnel office has evaluated conviviality of each employee, so everyone has some number (rating) attached to him or her. Your task is to make a list of guests with the maximal possible sum of guests' conviviality ratings.

Input

Employees are numbered from 1 to N. A first line of input contains a number N. 1 <= N <= 6 000. Each of the subsequent N lines contains the conviviality rating of the corresponding employee. Conviviality rating is an integer number in a range from -128 to 127. After that go N – 1 lines that describe a supervisor relation tree. Each line of the tree specification has the form:
L K
It means that the K-th employee is an immediate supervisor of the L-th employee. Input is ended with the line
0 0

Output

Output should contain the maximal sum of guests' ratings.

Sample Input

Sample Output

题意：题意为有n个人要开一个PARTY，编号1到n，每个人都有一个欢乐值，并且每个人都有一个直接上司，为了让气氛更好，要求在这n个人中选一些人去参加PARTY，并且选出的这些人中任意两个人之间都没有直接上司或直接下属关系，求选出人的最大欢乐值。

思路：可以记忆化搜索，可树状dp；

定义dp[i][0] 为第i个人不选择所获得的最大欢乐值,dp[i][1] 为第i个人被选择所获得的最大欢乐值

假设 j 是第i个人的下属，那么有转移方程：

dp[i][0]+=max( dp[j][0],dp[j][1]); 注意是+=，因为一个父节点有多个子节点

dp[i][1]+=dp[j][0];

在这里把边定义这是双向边，可以把任意节点看做根节点开始搜，每个顶点被访问，且只被访问一次。

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define Max 6060
#include<vector>

vector<int >v[Max];
int dp[Max][2],n,book[Max];
// dp[x][0] 表示当前x节点没有选， 获得的最大欢乐值；
// dp[x][1] 表示当前x节点选了， 获得的最大欢乐值；

void dfs(int x)
{
	book[x] = 1;
	for(int i = 0;i<v[x].size();i++)
	{
		int k = v[x][i];
		if(!book[k])
		{
			dfs(k);
			dp[x][1] += dp[k][0];
			dp[x][0] += max(dp[k][0],dp[k][1]);
		}
	}
	//printf("dp[%d][0]==%d dp[%d][1]==%d\n",x,dp[x][0],x,dp[x][1]);
}
void init()
{
	int i,j;
	for( i = 0;i<=n;i++)
		v[i].clear();
	memset(book,0,sizeof(book));
}
int main()
{
	int i,j;
	while(~scanf("%d%d",&n,&dp[1][1])&&(n||dp[1][1]))
	{
		dp[1][0] = 0;
		for(i = 2;i<=n;i++)
		{
			scanf("%d",&dp[i][1]);
			dp[i][0] = 0;
		}
		init();
		int x,y;
		for(i = 0;i<n-1;i++)
		{
			scanf("%d%d",&x,&y);
			v[y].push_back(x);
			v[x].push_back(y);   //	 双向的话，直接就把1看做根节点， 
		}						 // 要是单向的话，我觉着一定要用记忆化搜化的； 
		dfs(1);
		
		printf("%d\n",max(dp[1][0],dp[1][1]));
	}
	return 0;
}

代码二：记忆化搜索：dp数组中定义略有不同，但状态转移方程式一样的；

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define Max 6060
#include<vector>

vector<int >v[Max];
int dp[Max][2],n, a[Max];
// dp[x][0] 表示当前x节点没有选，以x为根节点的树的所能 获得的最大欢乐值；
// dp[x][1] 表示当前x节点选了，以x为根节点的树的所能 获得的最大欢乐值；

int dfs(int x,int f)
{
	if(dp[x][f] !=-1 )
		return dp[x][f];
	int M;
	if(f==1) M = a[x];
	else M = 0;
	for(int i = 0;i<v[x].size();i++)
	{
		int k = v[x][i];
		if(f) M += dfs(k,0) ;
		else  M += max(dfs(k,1),dfs(k,0));
	}
	//printf(" dp[%d][%d]==%d\n",x,f,M);
	return dp[x][f] = M;

}
void init()
{
	int i,j;
	for( i = 0;i<=n;i++)
		v[i].clear();
	memset(dp,-1,sizeof(dp));
}
int main()
{
	int i,j;
	while(~scanf("%d%d",&n,&a[1])&&(n||a[1]))
	{
		dp[1][0] = 0;
		for(i = 2;i<=n;i++)
			scanf("%d",&a[i]);
		init();
		int x,y;
		for(i = 0;i<n-1;i++)
		{
			scanf("%d%d",&x,&y);
			v[y].push_back(x);
			//v[x].push_back(y);   //	 双向的话，直接就把1看做根节点， 
		}						 // 要是单向的话，我觉着一定要用记忆化搜化的； 
		for(i = 1;i<=n;i++)
		{
			if(dp[i][0]==-1)
			{
				dfs(i,0);
				dfs(i,1);
			}
			
		}
		int Ma = -1;
		for(i = 1;i<=n;i++)
		{
			Ma = max(Ma,dp[i][0]);
			Ma = max(Ma,dp[i][1]);
		}
		printf("%d\n",Ma);
	}
	return 0;
}

代码三：为我第一次写的时候的代码，记忆化搜索和前的dp数组定义不同；

代码：

#include<stdio.h>
#include<string.h>
#include<algorithm>
using namespace std;
#define Max 6060
#include<vector>
vector<int > v[Max];
int dp[Max][2],a[Max],n; 
void init()
{
	int i,j;
	for(i = 0;i<=n;i++)
		v[i].clear();
	memset(dp,-1,sizeof(dp));
	
}

int dfs(int x,int f)      //f ==1 表示父亲节点选了，本节点可以不能选， 
{							// f == 0 表示父亲节点没有选，本节点可选，可不选； 
	if(dp[x][f]!=-1)
		return dp[x][f];   // dp[x][1]  表示x的父亲被选时，x为根节点的这颗树满足条件的情况下所获得的最大欢乐值   
	int Ma1 = 0;			// dp[x][0] 表示x的父亲不被选时，x为根节点的这颗树满足条件的情况下所获得的最大欢乐值
	for(int i = 0;i<v[x].size();i++)
	{
		Ma1 += dfs(v[x][i],0);
	}
	int Ma2 = 0;
	if(!f)
	{
		Ma2 = a[x];
		for(int i = 0;i<v[x].size();i++)
		{
			Ma2 += dfs(v[x][i],1);
		}
	}
	if(!f) dp[x][f] = max(Ma1,Ma2);
	else dp[x][f] = Ma1;
	return dp[x][f];
	
}
int main()
{
	int i,j;
	while(~scanf("%d%d",&n,&a[1]))
	{
		if(n==0&&a[1]==0)
			break;
		for(i = 2;i<=n;i++)
			scanf("%d",&a[i]);
		init();
		for(i = 0;i<n-1;i++)
		{
			int x,y;
			scanf("%d%d",&x,&y);
			v[y].push_back(x);
		}
		for(i = 1;i<=n;i++)
		{
			if(dp[i][0]==-1)
			{
				dfs(i,0);  
				dfs(i,1);
			}
		}
		int Ma  = -1;
		for(i = 1;i<=n;i++)
		{
			Ma = max(Ma,dp[i][0]);
			Ma = max(Ma,dp[i][1]);
		}
		printf("%d\n",Ma);
	}
	return 0;
}