[清华集训2017]榕树之心[树dp]

题意

题目链接

分析

• 首先解决 \(subtask3\) ，我们的策略就是进入子树，然后用其它子树来抵消，注意在子树内还可以抵消。

• 可以转化为此模型：有一个数列 \(a\) ，每次我们可以选定两个值 \(>0\) 的数并让他们同时减 1，让最后 \(S=\sum a\) 最小。

  • 如果最大的数 \(a_{mx}\ge S\) ，显然答案为 \(2*a_{mx}-S\) 。

  • 否则我们每次把最大和次大的两个数进行操作，容易证明最后的答案为 \(S\ \rm mod\ 2\) 。

• 现在数列的每一项就是子树的大小。

• 也就是说，如果我们能够尽量多地让重儿子内部相互抵消（假设最多抵消剩 \(x\) 个节点，那么可以保留的节点就是 (\(x+2k+1\))），以至于重儿子剩余的大小 \(\le \frac{S}{2}\) 且保持最大或最大-1(如果只有两棵子树，且初始次大子树比最大子树小1不会影响讨论)，就可以让结果得至多为 1 了。

• 发现这变成了一个子问题，所以记状态 \(f_u\) 表示从 \(u\) 出发再回到 \(u\) 之后最少剩下多少节点。转移就比较显然了。

• 对于不止查询一号点的情况，给每个点记个最大和次大的儿子， dfs 到 \(u\) 时把路径上的点看成一个点即可。

• 时间复杂度 \(O(n)​\) 。

代码

#include<bits/stdc++.h>
using namespace std;
typedef long long LL;
#define go(u) for(int i = head[u], v = e[i].to; i; i=e[i].lst, v=e[i].to)
#define rep(i, a, b) for(int i = a; i <= b; ++i)
#define pb push_back
#define re(x) memset(x, 0, sizeof x)
inline int gi() {
    int x = 0,f = 1;
    char ch = getchar();
    while(!isdigit(ch)) { if(ch == '-') f = -1; ch = getchar();}
    while(isdigit(ch)) { x = (x << 3) + (x << 1) + ch - 48; ch = getchar();}
    return x * f;
}
template <typename T> inline bool Max(T &a, T b){return a < b ? a = b, 1 : 0;}
template <typename T> inline bool Min(T &a, T b){return a > b ? a = b, 1 : 0;}
const int N = 1e5 + 7, inf = 0x3f3f3f3f;
int n, W, T;
int ans[N], dep[N];
vector<int>G[N];
struct data {
    int son, f;
    data(){}data(int son, int f):son(son), f(f){}
    bool operator <(const data &rhs) const {
        if(son != rhs.son) return son < rhs.son;
        return f > rhs.f;
    }
    bool operator ==(const data &rhs) const {
        return son == rhs.son && f == rhs.f;
    }
}f[N][2], g[N];
void Add(int a, int b) {
    G[a].pb(b);
    G[b].pb(a);
}
void dfs1(int u, int fa) {
    g[u].son = 1;
    for(auto v:G[u]) if(v ^ fa) {
        dep[v] = dep[u] + 1;
        dfs1(v, u);
        if(f[u][0] < g[v]) {
            f[u][1] = f[u][0];
            f[u][0] = g[v];
        }else if(f[u][1] < g[v]) {
            f[u][1] = g[v];
        }
        g[u].son += g[v].son;
    }
    if(f[u][0].son) {
        if(g[u].son - f[u][0].son - 1 >= f[u][0].f + 1)
            g[u].f = (g[u].son - 1) % 2;
        else
            g[u].f = f[u][0].f + 1 - (g[u].son - f[u][0].son - 1);
    }else g[u].f = 0;
}
void dfs2(int u, int fa, data mx) {
    data now = max(mx, f[u][0]);
    int son = n - dep[u];
    if(now.son) {
        if(son - now.son - 1 >= now.f + 1)
            ans[u] = (son - 1) % 2;
        else
            ans[u] = now.f + 1 - (son - now.son - 1);
    }
    for(auto v:G[u]) if(v ^ fa) {
        if(f[u][0] == g[v]) dfs2(v, u, max(mx, f[u][1]));
        else dfs2(v, u, max(mx, f[u][0]));
    }
}
int main() {
    W = gi(), T = gi();
    while(T--) {
        n = gi();
        rep(i, 1, n) G[i].clear(), f[i][0] = f[i][1] = g[i] = data(0, inf);
        rep(i, 1, n - 1) {
            int a = gi(), b = gi();
            Add(a, b);
        }
        dfs1(1, 0);
        dfs2(1, 0, data(0, inf));
        if(W == 3)
            printf("%d\n", ans[1] == 0);
        else
            rep(i, 1, n) printf("%d", ans[i] == 0);
        puts("");
    }
    return 0;
}