数据结构：树状dp

一、派对的最大快乐值

1、题目描述

整个公司的人员结构可以看作是一棵标准的多叉树。树的头节点是公司唯一的老板，除老板外，每个员工都有唯一的直接上级，叶节点是没有任何下属的基层员工，除基层员工外，每个员工都有一个或多个直接下级，另外每个员工都有一个快乐值。

这个公司现在要办 party，你可以决定哪些员工来，哪些员工不来。但是要遵循如下的原则：

1.如果某个员工来了，那么这个员工的所有直接下级都不能来。

2.派对的整体快乐值是所有到场员工快乐值的累加。

3.你的目标是让派对的整体快乐值尽量大。

给定一棵多叉树，请输出派对的最大快乐值。

输入描述:

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

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

接下来 n - 1 行每行两个整数 u_i 和 v_i 表示 u_i 是 v_i 的直接上级。

输出描述:

输出一个整数表示最大快乐值。

输入

3 1
5 1 1
1 2
1 3

输出

5

备注:

1 ≤ n ≤ 500000
0 ≤ happyi ​≤ 1000

2、敲代码

       上层dp要用到下层dp，因此应该从下到上的进行dp。

       （1）先层序遍历，保存每一层的节点。

       （2）初始化，最低层。

       （3）从下到上进行dp。

#include <iostream>
#include <vector>
#include <unordered_map>
#include <queue>
using namespace std;

//层序遍历，保存每一层的节点
void bfs(unordered_map<int, vector<int>> &mp, int root, vector<vector<int>> &stk)
{
    queue<int> q;
    q.push(root);
    while(!q.empty())
    {
        vector<int> temp;       //保存每一层的元素
        int qs = q.size();
        while(qs--)
        {
            int qf = q.front();
            q.pop();
            temp.push_back(qf);
            
            for(auto a : mp[qf])
            {
                q.push(a);
            }
        }
        stk.push_back(temp);    //
    }
}

/*
输入
	3 1
	5 1 1
	1 2
	1 3
输出
	5
*/

int main()
{
    int n, root;
    cin >> n >> root;
    vector<int> nums(n+1);
    for(int i=1; i<=n; i++) 
        cin >> nums[i];
    
    //mp
    unordered_map<int, vector<int>> mp;   //父找子
    for(int i=0; i<n-1; i++)
    {
        int x, y;  cin >> x >> y;
        mp[x].push_back(y);
    }
    
    //bfs
    vector<vector<int>> stk;      //保存每一层的节点
    bfs(mp, root, stk);
    
    //reverse-dfs
    vector<int> dp(nums);         //快乐值
    
    //初始化stk最低层的快乐值
    for(auto s : stk[stk.size()-1])
        dp[s] = nums[s];
    
    //从下到上，逐层上升，计算快乐值
    for(int i=stk.size()-2; i>=0; i--)     //从下到上，倒数第二层开始
    {
        for(int j=0; j<(int)stk[i].size(); j++)
        {
            //当前节点
            int now = stk[i][j];
            
            //不选择当前节点，则添加孩子节点
            int unselnow = 0;
            for(auto s : mp[now])   //孩子
                unselnow += dp[s];
            
            //选当前节点,则添加孙子节点,（包含当前节点是中间层的叶子节点的情况）
            int selnow = nums[now];
            for(auto s : mp[now])   //孩子
                for(auto s2 : mp[s])   //孙子
                    selnow += dp[s2];
            
            //选择最大值
            dp[now] = max(selnow, unselnow);
        }
    }
    cout << dp[root];
    
    return 0;
}