E. Shuffle

题意

给定一颗 $n$ 个节点的树 $T$，现在要求恰好执行下面的程序操作一次：

1. 从 $T$ 中选择一个点，作为 $T_2$ 的新根节点
2. 将这个点从 $T$ 中删除，现在 $T$ 被分成了一个或一个以上的连通块树
3. 对每一个连通块重复上述的操作，并将这个新的点连接到上一个步骤添加到 $T_2$ 的点

即上述操作是一个递归的过程。

现在要回答经过一次上次的程序后，生成的 $T_2$ 最多有多少个叶节点

思路

首先我们需要指出结论：除去 $T_2$ 的根节点，我们能拥有的最大叶子数量就是各个连通块的最大独立集，如果根节点度数为一，我们需要特判并给答案额外加一

这是因为：在我们选择第一个点作为 $T_2$ 的根节点后，剩下的每一对相邻的点都不可能同时成为叶子，因为它们必定存在一个先后顺序，那么先被选择的那个一定会成为后被选择的那个点的祖先。
那么我们可以得出结论（必要条件）：最后的叶子集合一定是一个独立集（点集内部没有边）

假设我们已经有了一个独立集作为最终的目标叶子集合，我们如何保证它们一定是 $T_2$ 的叶子呢？
我们可以每一步都选择不在 $MIS$ （maximum independent set） 中的点，让它们连接到 $T_2$ 上，那么最后一定会只剩下我们的叶子集合，即我们的 $MIS$，它们连接到 $T_2$ 上自然就是叶子了。
那么到了这里，答案很显然就是最大独立集的大小了，最后特判一下根节点的度数

问题是，我们第一步选择的 $T_2$ 的根节点是不固定的，我们可以考虑在 $T$ 上做 $dfs$ 换根$DP$，通过枚举当前点 $u$ 作为根节点，并统计答案

除了当前节点 $u$ 外，它将 $T$ 分割成了若干个连通子树，那么这些子树内的最大独立集我们可以用类似 树形$DP$ 模板题 ”没有上司的舞会“ 的处理方式，以 $dp[u][0]$ 表示 $u$ 的子树中，不选 $u$ 的最多能选择的点，$dp[u][1]$ 表示选了 $u$，按照独立集的定义，如果 $u$ 被选了，那么他的邻居都不能被选

问题在于，如何换根，在线统计当前节点 $u$ 的祖先节点的信息？

注意到其实 $u$ 的祖先节点也可以看成一颗连通树，我们以 $s[0]$ 和 $s[1]$ 分别表示不选 $u$ 的祖先和选了 $u$ 的祖先的最大独立集大小。

那么从 $u$ 转移到它的儿子 $v$ 时，$s$ 的变化是： s [ 0 ] = max ⁡ { s 0 , s 1 } + ∑ e ≠ v ∧ e ∈ s o n { u } max ⁡ { d p e , 0 , d p e , 1 } s[0] = \max \{ s_0, s_1 \} + \sum_{e \neq v \wedge e \in son \{u \}} \max \{dp_{e, 0}, dp_{e, 1} \} s[0]=max{s0​,s1​}+e=v∧e∈son{u}∑​max{dpe,0​,dpe,1​}
意思就是：转移到 $v$ 时，父亲变为了 $u$，那么 $u$ 不选的话，$u$ 的其他儿子可以选或不选（取 $\max$），$u$ 原本的父亲也可以选或不选

同理， s [ 1 ] = 1 + s 0 + ∑ e ≠ v ∧ e ∈ s o n { u } d p e , 0 s[1] = 1 + s_0 + \sum_{e \neq v \wedge e \in son \{u \}} dp_{e, 0} s[1]=1+s0​+e=v∧e∈son{u}∑​dpe,0​
表示选了 $u$，并且其他邻居都不能选。

时间复杂度：$O(n)$

#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 = 200005;

std::vector<int> g[N];
int dp[N][2];
int sum_mx[N];
int sum0[N];
int ans;

void dfs0(int u, int fa){
    dp[u][1] = 1;
    dp[u][0] = 0;
    sum_mx[u] = sum0[u] = 0;
    for(auto v : g[u])
        if(v != fa){
            dfs0(v, u);
            sum_mx[u] += std::max(dp[v][0], dp[v][1]);
            sum0[u] += dp[v][0];
            dp[u][0] += std::max(dp[v][0], dp[v][1]);
            dp[u][1] += dp[v][0];
        }
}

void dfs1(int u, int fa, std::array<int, 2> s){
    ans = std::max(ans, sum_mx[u] + std::max(s[0], s[1]) + (g[u].size() == 1));
    for(auto v : g[u])
        if(v != fa){
            std::array<int, 2> a;
            a[0] = std::max(s[0], s[1]) + sum_mx[u] - std::max(dp[v][0], dp[v][1]);
            a[1] = 1 + s[0] + sum0[u] - dp[v][0];
            dfs1(v, u, a);
        }
}

int main(){
    std::ios::sync_with_stdio(false);
    std::cin.tie(nullptr);
    std::cout.tie(nullptr);
    int t;
    std::cin >> t;
    while(t--){
        int n;
        std::cin >> n;
        fore(i, 1, n){
            int u, v;
            std::cin >> u >> v;
            g[u].push_back(v);
            g[v].push_back(u);
        }

        dfs0(1, 0);
        ans = 0;
        dfs1(1, 0, {0, 0});

        std::cout << ans << endl;

        fore(i, 1, n + 1) g[i].clear();
    }
    return 0;
}