树上着色问题 | 这个世界不能非黑即白，但树可以！

题目描述

对一棵树进行着色，每个结点可着黑色或白色，相邻结点不能着相同黑色，但可着相同白色。请设计一种算法对树中尽量多的节点着黑色。

输入格式：
第一行输入 T 表示有 T 组数据。
每组数据先输入一个正整数 N，表示共有 N 个结点。
接下来输入 N - 1 对（u，v），表示 u 与 v 之间有一条边。

输出格式：
输出 T 行正整数，第 i 行表示第 i 棵树最多能着色几个黑点。

输入样例：

3
2
1 2
4
1 2
2 3
3 4
4
1 2
1 3
1 4

输出样例：

1
2
3

问题分析

对于这种树状的数据结构，我们可以采用 DFS 或 BFS 进行搜索。考虑到这道题需要优先计算子节点，进而推算出父节点的值，这里采用 DFS 进行遍历搜索每个节点。

对于每个节点，若没有子节点，可以选择染成黑色或白色。若当前节点有子节点，将当前节点染成白色，子节点可以染成任意颜色，选择让子树黑色节点数最多的情况即可；将当前节点染成黑色，子节点只能染成白色。

通过上述的分析，可以发现原问题的最优解可以通过组合子问题的最优解得到。因此，我们可以采用动态规划的思路来求解该问题。

算法描述

状态定义：

• dp[i][0]：以节点 i 为根节点的子树，根节点染成白色，子树中黑色节点的最大个数。
• dp[i][1]：以节点 i 为根节点的子树，根节点染成黑色，子树中黑色节点的最大个数。

状态转移方程：

• dp[i][0] = sum( max(dp[child][0], dp[child][1]) )：根节点染成白色，子节点可以染成任意颜色，取子树中黑色节点数最多情况进行累加。
• dp[i][1] = sum( dp[child][0] ) + 1：根节点染成黑色，子节点只能染成白色，累加以子节点为根节点的子树的黑色节点数。同时，要加上染成黑色的父节点。

复杂度分析

由于每个节点只计算一次，所以时间复杂度取决于节点的个数，即 $O(N)$

程序代码

#include <iostream>
#include <cstring>
#include <algorithm>
#include <unordered_map>
using namespace std;

const int N = 100100;
int h[N];  // 与该节点(父节点)相连的最后一条边(索引最大的)
int e[N];  // 边i指向的节点
int ne[N];  // 边i的上一条边
int idx = 0;  // 边的下标索引
bool st[N];  // 该节点是否计算过
int dp[N][2];

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

void dfs(int root)
{
    // 叶节点
    if(h[root] == -1) {
        dp[root][0] = 0;
        dp[root][1] = 1;
        return ;
    }
    
    // 重置
    dp[root][0] = dp[root][1] = 0;
    
    for(int i = h[root]; i != -1; i = ne[i]) {
        int j = e[i];  // 子节点
        // 还没有计算过
        if( !st[j] ) {
            dfs(j);
        }
        dp[root][0] += max(dp[j][0], dp[j][1]);
        dp[root][1] += dp[j][0];
    }
    // 加上自身的黑色
    dp[root][1]++;
}

int main()
{
    int t;
    cin >> t;
    while( t-- ) {
        int n;
        cin >> n;
        idx = 0;
        memset(h, -1, sizeof(h));
        memset(dp, 0, sizeof(dp));
        // memset(e, 0, sizeof(e));
        // memset(ne, 0, sizeof(ne));
        memset(st, false, sizeof(st));
        // 记录每个节点父节点个数
        unordered_map<int, int> pnums;
        for(int i = 0; i < n-1; i++) {
            int a, b;
            cin >> a >> b;
            add(a, b);
            pnums[b]++;
            pnums[a] += 0;
        }
        
        int root = -1;
        for(auto t : pnums) {
            if(t.second == 0) {
                root = t.first;
                break;
            }
        }
        dfs(root);
        cout << max(dp[root][0], dp[root][1]) << endl;
    }
    
    return 0;
}