完美树

思路

观察发现：如果一颗子树 $u$，它刚好有偶数个节点，那么 $0$ 和 $1$ 的染色数量一定相等，如果有奇数个节点，那么 $0$ 和 $1$ 的数量一定恰好相差 $1$（可能是 $0$ 多，也可能是 $1$ 多）
对于当前节点 $u$，先算出它的子树大小，然后对于它的每个儿子 $v$：

1. 如果 $v$ 的子树大小是偶数，那么就加上 $v$ 的 $0,1$ 相等最小花费
2. 如果 $v$ 的子树大小是奇数，那么需要考虑 $v$ 选 $0$ 还是 $1$ 的最小花费

这里存在一些子状态，我们可以使用树形 $DP$，定义：

• $dp[u][0]$ 为以 $u$ 为完美子树，$0$ 恰好比 $1$ 多一个
• $dp[u][1]$ 为以 $u$ 为完美子树，$1$ 恰好比 $0$ 多一个
• $dp[u][2]$ 为以 $u$ 为完美子树，$0$ 与 $1$ 数量相等

那么前面的转移可以变为：

1. 如果 $v$ 的子树大小是偶数，加上 $dp[v][2]$
2. 如果 $v$ 的子树大小是奇数，那么需要考虑选 $dp[v][0]$ 还是 $d[v][1]$，注意这里不能全选最小，因为最后 $u$ 还要保证 $0$ 和 $1$ 的数量不能相差超过 $1$ 个，因此 $01$ 的选择要均衡一些

其实这里是一个经典模型：

给定 $k$ 个物品，每个物品有 $0$ 和 $1$ 两种状态，两种状态各有一个价值
问从中选 $x$ 个 $0$， $k-x$ 个 $1$ 的最小花费是多少？


我们先将 $w[i][0]-w[i][1]$ 最为一个衡量标准，如果这个值越小（有可能为负数），说明这个物品越适合选 $0$ 而不是 $1$
那么我们可以假设全部选上 $1$，当前花费 $cost=\sum w[i][1]$
然后将所有物品按照 $w[i][0]-w[i][1]$ 升序 排列，选择前 $x$ 个改为 $0$ 即可
即 $cost+={\sum }_{i=1}^x(w[i][0]-w[i][1])$
这样子一定是最小花费

回到这题，其实也是一样的道理，对于 $u$ 的大小分奇偶讨论，然后从它所有大小为奇数的儿子中选择一些为 $0$，另一些为 $1$ 即可

#include<bits/stdc++.h>
#define fore(i,l,r)	for(int i=(int)(l);i<(int)(r);++i)
#define fi first
#define se second
#define endl '\n'
#define ull unsigned long long
#define ALL(v) v.begin(), v.end()
#define Debug(x, ed) std::cerr << #x << " = " << x << ed;

const int INF=0x3f3f3f3f;
const long long INFLL=1e18;

typedef long long ll;

const int N = 100050;

std::vector<int> g[N];
ll p[N];
int c[N];
ll dp[N][3];
int son[N];

void dfs(int u){
    dp[u][0] = dp[u][1] = dp[u][2] = INF;
    son[u] = 1;
    int sz = 1;
    ll sum = (c[u] ? 0 : p[u]);
    std::vector<ll> vec;
    vec.push_back((c[u] ? p[u] : -p[u]));
    for(auto v : g[u]){
        dfs(v);
        son[u] += son[v];
        if(son[v] % 2 == 0){ //儿子偶数直接加
            sum += dp[v][2];
            continue;
        }
        else{
            ++sz;
            sum += dp[v][1];
            vec.push_back(dp[v][0] - dp[v][1]); //奇数要先选1
        }
    }
    std::sort(ALL(vec)); //按衡量标准升序排序
    if(son[u] % 2 == 0){ //偶数 0 和 1 一样多
        fore(i, 0, sz / 2) sum += vec[i];
        dp[u][2] = sum;
    }
    else{ //奇数要考虑 0 多还是 1 多
        fore(i, 0, sz / 2) sum += vec[i];
        dp[u][1] = sum;
        dp[u][0] = sum + vec[sz / 2];
    }
}

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int n;
    std::cin >> n;
    fore(i, 1, n + 1){
        int k;
        std::cin >> c[i] >> p[i] >> k;
        while(k--){
            int v;
            std::cin >> v;
            g[i].push_back(v);
        }
    }
    dfs(1);
    if(n & 1) std::cout << std::min(dp[1][0], dp[1][1]);
    else std::cout << dp[1][2];
    return 0;
}