动态规划|树形dp-派对的最大快乐值

题目描述

题目连接

整个公司的人员结构可以看作是一棵标准的多叉树。树的头节点是公司唯一的老板，除老板外，每个员工都有唯一的直接上级，叶节点是没有任何下属的基层员工，除基层员工外，每个员工都有一个或多个直接下级，另外每个员工都有一个快乐值。
这个公司现在要办 party，你可以决定哪些员工来，哪些员工不来。但是要遵循如下的原则：
1.如果某个员工来了，那么这个员工的所有直接下级都不能来。
2.派对的整体快乐值是所有到场员工快乐值的累加。
3.你的目标是让派对的整体快乐值尽量大。
给定一棵多叉树，请输出派对的最大快乐值。

输入描述:

第一行两个整数 n 和 root，n 表示公司的总人数，root 表示公司的老板。

第二行 n 个整数 happy_i 表示员工 i 的快乐值。

接下来 n - 1 行每行两个整数 u_i 和 v_i 表示 u_i 是 v_i 的直接上级。
输出描述:
输出一个整数表示最大快乐值。

示例1

输入

3 1
5 1 1
1 2
1 3

输出

5

解题思路

以dp[i][0]记录以第i个节点不参加派对的，以它为根节点的子树的最大快乐值
以dp[i][1]记录它参加派对的最大快乐值。

j 为i的子节点
dp[i][0] += max{dp[j][0],dp[j]1];
dp[i][1] += dp[j][0];

然后用深度优先算法遍历树，这里的动态规划思想体现在计算以当前节点为根节点的快乐值时，它所需要的子节点的信息已经求解出来。

代码中以邻接表法表示一棵树。

#include
#include
#include
using namespace std;
int n;
int (*dp)[2];
int *vis;

struct Node{
    int num;
    Node* next;
}* head;

int max(int a,int b){
    return a>b?a:b;
}

void dfs(int root){
    vis[root] = true;
    for(Node * child = head[root].next;child;child = child->next){
        if(vis[child->num])
            continue;
        dfs(child->num);
        dp[root][0] += max(dp[child->num][0],dp[child->num][1]);
        dp[root][1] += dp[child->num][0];
    }
}

int main(void){
    int n,root;
    cin>>n>>root;
    dp = (int (*)[2])new int[(n+1)*2];
    vis = new int[n+1];
    head = (Node*)malloc(sizeof(Node)*(n+1));
    memset(dp,0,sizeof(dp));
    memset(vis,0,sizeof(vis));
    for(int i = 1;i<=n;i++){
    	head[i].next = NULL;
    	dp[i][0] = 0;
	}
    	
    for(int i = 1,t;i<=n;i++){
        cin>>t;
        dp[i][1] = t;
    }
    int a,b;
    for(int i = 1;i<=n-1;i++){
        cin>>a>>b;
        Node *temp = new Node;
        temp->num = b;
        temp->next = head[a].next;
        head[a].next = temp;
    }
    
    dfs(root);
    int res = max(dp[root][0],dp[root][1]);
    cout<<res<<endl;
    delete[] dp;
    free(vis);
    free(head);
    
    return 0;
}