刷好题，固基础-9

L3-035 完美树

分数 30

给定一棵有 N 个结点的树（树中结点从 1 到 N 编号，根结点编号为 1）。每个结点有一种颜色，或为黑，或为白。

称以结点 u 为根的子树是 好的，若子树中黑色结点与白色结点的数量之差的绝对值不超过 1。称整棵树是 完美树，若对于所有 1 ≤ i ≤ N，以结点 i 为根的子树都是好的。

你需要将整棵树变成完美树，为此你可以进行以下操作任意次（包括零次）：选择任意一个结点 i (1 ≤ i ≤ N)，改变结点 i 的颜色（若结点 i 目前是黑色则将其改为白色，若结点 i 目前是白色则将其改为黑色）。这次操作的代价为 Pi​。

求将给定的树变为完美树的最小代价。

注：以结点 i 为根的子树，由结点 i 以及结点 i 的所有后代结点组成。

输入格式:

输入第一行为一个数 N (1≤N≤105)，表示树的结点个数。

接下来的 N 行，第 i 行的前三个数为 Ci​,Pi​,Ki​ (1≤Pi​≤104,0≤Ki​≤N)，分别表示树上编号为 i 的结点的初始颜色（0 为白色，1 为黑色）、变换颜色的代价及孩子结点的数量。紧跟着有 Ki​ 个数，为孩子结点的编号。数字均用一个空格隔开，所有的编号保证在 1 到 N 里，且不会有环。

数据中只包含一棵树。

输出格式:

输出一行一个数，表示将树 T 变为完美树的最小代价。

输入样例:

10
1 100 3 2 3 4
0 20 1 7
0 5 2 5 6
0 8 1 10
0 7 0
0 2 0
1 1 2 8 9
0 15 0
0 13 0
1 8 0

输出样例:

15

提示:

样例中最佳的方案是：将 9 号点和 6 号点从白色变为黑色，此时代价为 13 + 2 = 15。

AC代码：

#include<bits/stdc++.h>
using namespace std;


struct Node{
    int color,power,res; // 节点的颜色、代价、结果值
    vector<int> v; // 存储子节点的索引
}n[100001];

// 比较函数，用于根据代价对节点进行排序
bool cmp(int x,int y){
    return n[x].power < n[y].power;
}

// 递归构建树，并计算结果值的函数
int buildTree(int inx)
{
    vector<int> hei,bai; // 分别存储黑色和白色节点的索引
    if(n[inx].color==0) bai.push_back(inx); // 如果当前节点是白色，加入bai
    else hei.push_back(inx); // 否则加入hei

    // 遍历当前节点的所有子节点
    for(int x:n[inx].v) {
        int key = buildTree(x); // 递归构建子树，并接收返回值
        if(key!=0){
            // 根据返回的节点颜色，将节点加入相应的颜色向量
            if(n[key].color==0) bai.push_back(key);
            else hei.push_back(key);
        }
        // 累加子节点的结果值到当前节点
        n[inx].res += n[x].res;
    }

    // 根据代价对黑白节点进行排序
    sort(hei.begin(),hei.end(),cmp);
    sort(bai.begin(),bai.end(),cmp);

    // 移除最强的黑白节点，直到只剩下一个或没有
    while(!hei.empty() && !bai.empty()){
        hei.pop_back();
        bai.pop_back();
    }

    // 处理剩余的黑色节点
    int op = 0;
    while(!hei.empty() && hei.size()-op>1){
        int key = hei.front();
        n[inx].res += n[key].power; // 增加结果值
        op++;
        hei.erase(hei.begin()); // 移除已处理的节点
    }

    // 处理剩余的白色节点
    while(!bai.empty() && bai.size()-op>1){
        int key = bai.front();
        n[inx].res += n[key].power; // 增加结果值
        op++;
        bai.erase(bai.begin()); // 移除已处理的节点
    }

    // 返回剩余的节点，如果有的话
    if(!hei.empty() && hei.size()-op>0) return hei[0];
    if(!bai.empty() && bai.size()-op>0) return bai[0];
    return 0;
}

int main()
{
    int N;
    cin >> N; // 读取节点数量
    for(int z=1;z<=N;z++){
        int a,b,c;
        cin >> a >> b >> c; // 读取节点颜色、代价和子节点数量
        n[z].color = a;
        n[z].power = b;
        while(c--){
            int d;
            cin >> d; // 读取子节点索引
            n[z].v.push_back(d); // 将子节点索引加入当前节点的向量中
        }
    }
    buildTree(1); // 从根节点开始构建树并计算结果值
    cout << n[1].res; // 输出根节点的结果值
    return 0;
}