蓝桥杯14届真题-树上选点

按照树的深度进行dp
通过递归得到每个点的深度
通过一个 map数组 记录 深度i上的 每个点为根的子树的权值最大和，根据遍历的点，删除它的孩子节点作为根的子树的权值最大和（这是选择当前节点的情况dp[u][1]）

#include <iostream>
#include <vector>
#include <map>
#include <cstring>
using namespace std;
const int N = 200010;
// 点个数
int n;
// 邻接表
int h[N],e[N], ne[N], idx;
//父数组
int f[N];
//深度数组
int dep[N];
// level[i]: 深度为i 的节点有哪些
vector<int> level[N];
//树的最大深度
int maxDepth;
//权值
int w[N];
// dp状态数组
int dp[N][2];       // dp[i][0] 表示以i为根节点的子树，在不选择当前节点的情况下的点权和最大值（以下统称为 答案）
map<int, int> max_dp_at_depth[N];       // max_dp_at_depth[i]: 数组元素是一个map; 键：深度为i的节点的答案 ; 值：出现了几次

void add(int a, int b){     // a指向b的一条边
    e[idx] = b;
    ne[idx] = h[a];
    h[a] = idx++;
}

//递归实现 求每个点的深度
void dfs(int u, int p){
    //子节点的深度是父节点的深度+1
    dep[u] = dep[p]+1;
    //更新最大深度
    maxDepth = max(maxDepth, dep[u]);
    // 当前节点u，放到深度集合中
    level[dep[u]].push_back(u);
    //遍历当前节点的每个孩子
    for(int i = h[u]; i!=-1; i = ne[i]){
        int j = e[i];
        dfs(j, u);  //继续往下递归
    }

}
int main()
{
    memset(h, -1, sizeof h);
    scanf("%d", &n);
    for(int i = 2; i <= n; i++){
        int a;
        scanf("%d", &a);
        add(a,i);
        f[i] = a;
    }
    for(int i = 1; i <= n; i++){
        scanf("%d", &w[i]);
    }
    
    //更新每个点的深度
    dfs(1,0);
    // 按照深度进行遍历，从叶子节点到根节点
    for(int d = maxDepth; d; d--){
        //从level中拿到当前深度的所有节点，进行遍历
        for(int i = 0; i < level[d].size(); i++){
            int u = level[d][i];    //当前节点
            // 1. 不选择当前节点，那dp[u][0]可以来自 下一层深度上的答案的最大值（map默认根据键从小到大排序，所以rbegin取最后一个答案）
            if(max_dp_at_depth[d+1].size()){
                dp[u][0] = max_dp_at_depth[d+1].rbegin()->first;
            }
            // 2. 当选择当前时 , 每个子节点不能再选，所以再深度为d+1的答案map中删除掉该答案（-1）
            // 遍历当前节点u的每个子节点
            for(int j = h[u]; j!=-1; j = ne[j]){
                int child = e[j];
                //把下一层深度上的 答案为dp[child][1]的情况的数量 减1
                max_dp_at_depth[d+1][dp[child][1]] -= 1;
                // 把下一层深度上的 答案为dp[child][1]的情况的数量变成0后，就在map中（max_dp_at_depth[d+1]）删除该项
                if(max_dp_at_depth[d+1][dp[child][1]] == 0){
                    max_dp_at_depth[d+1].erase(dp[child][1]);
                }
            }
            // 但d+1层还有答案，也就是说是在同一层的不同子树上， 选择当前节点的答案就是本身的权值+下一层的最大答案
            if(max_dp_at_depth[d+1].size()){
                dp[u][1] = w[u] + max_dp_at_depth[d+1].rbegin()->first;
            }else{
                dp[u][1] = w[u];
            }
            // 计算完成后， 恢复前面-=1减1操作
            for(int j = h[u]; j != -1; j=ne[j]){
                int child = e[j];
                max_dp_at_depth[d+1][dp[child][1]] += 1;
            }
            // 把当前深度上的答案保存下来
            max_dp_at_depth[d][dp[u][0]] += 1;
            max_dp_at_depth[d][dp[u][1]] += 1;

        }
        //为节省空间，把下两层的答案清理到(此时d深度的已经更新完了，d+1就不用了)
        max_dp_at_depth[d+1].clear();
    }
    printf("%d", max(dp[1][0], dp[1][1]));

    return 0;
}

支持点赞收藏哟😀