[CF768G] The Winds of Winter

Posted 2021-02-06 qrsikno

显然对于删去一个点之后形成的森林, 就是把最大的那棵树砍下来, 接到最小的树上.

设删去当前点删去后形成的所有树中最大的那一棵大小为(Max) , 最小的为Min, 次小值为Sec

设从最大树砍掉的节点为u, 答案就是(max{Max - Size_u, Min + size_u, Sec})

它关于(Size_u)变化的函数显然是单峰的, 所以可以二分答案(Ans)一定要满足(Max - Size_u leq Ans, Min + Size_u leq Ans)

就是: (Max - Ans leq Siz_u leq Ans - Min) , 只要找是否存在这样的点即可

这样处理的时候就很像DSU on tree, 每次暴力把轻儿子的贡献加入整体, 重儿子直接继承, 然后清空轻儿子的贡献.

讨论的时候要注意分三类讨论, 分成两大类, 分别是去掉这个点有无影响, 然后无影响又分为子树和其他部分.

时间复杂度是(O(n log^2 n log V))? 不知道为什么跑这么快

---

二分答案其实就是一个放宽答案取值区间的操作, 因为二分答案的时候保证了单调性, 所以可以直接计算考虑函数在定义域内的极值, 那么就转换成了最大/最小问题, 这也是他所以直接跟贪心相关.

那么就自然要求统计树上信息, 因为没有修改, 所以直接DSU on tree,

Code

#include<bits/stdc++.h>
using namespace std;
#define rep(i, a, b) for(int i = (a), i##_end_ = (b); i <= i##_end_; ++i)
#define drep(i, a, b) for(int i = (a), i##_end_ = (b); i >= i##_end_; --i)
#define clar(a, b) memset((a), (b), sizeof(a))
#define debug(...) fprintf(stderr, __VA_ARGS__)
typedef long long LL;
typedef long double LD;
int read() {
    char ch = getchar();
    int x = 0, flag = 1;
    for (;!isdigit(ch); ch = getchar()) if (ch == ‘-‘) flag *= -1;
    for (;isdigit(ch); ch = getchar()) x = x * 10 + ch - 48;
    return x * flag;
}
void write(int x) {
    if (x < 0) putchar(‘-‘), x = -x;
    if (x >= 10) write(x / 10);
    putchar(x % 10 + 48);
}

const int Maxn = 500009;
struct edge {
    int to, nxt;
}g[Maxn << 1];
int n, fa[Maxn], head[Maxn], e, rt = 0;
int ans[Maxn];

void add(int u, int v) {
    g[++e] = (edge){v, head[u]}, head[u] = e;
}

int size[Maxn], son[Maxn]; 

int val[Maxn];

multiset <int> Ots, ancestor, Self[Maxn];

void dfsInit(int u) {
    size[u] = 1;            
    for (int i = head[u]; ~i; i = g[i].nxt) {
        int v = g[i].to;
        if (v != fa[u]) {
            dfsInit(v);
            if (size[v] > size[son[u]]) son[u] = v;
            size[u] += size[v];
        }
    }
    if (u != rt) Ots.insert(size[u]);
}
void init() {
    clar(head, -1);
    n = read();
    rep (i, 1, n) {
        int u = read(), v = read();
        fa[v] = u; add(v, u); add(u, v);
        if (!u) rt = v;
    }

    dfsInit(1);
}

bool check(int opt, int val, int u, int Min, int Max) {
    if (opt == 1) {
        multiset <int> :: iterator IT = Self[son[u]].lower_bound(Max - val);
        if (IT != Self[son[u]].end() && (*IT) <= val - Min) return true;
    } else {
        multiset <int> :: iterator IT = Ots.lower_bound(Max - val);
        if (IT != Ots.end() && (*IT) <= val - Min) return true;

        IT = ancestor.lower_bound(Max - val + size[u]);
        if (IT != ancestor.end() && (*IT) <= val - Min + size[u]) return true;
    }
    return 0;
}

void dfs(int u) {
    if (u != rt) Ots.erase(Ots.find(size[u]));
    if (fa[u] && fa[u] != rt) ancestor.insert(size[fa[u]]); 
    int Fisr = max(n - size[u], size[son[u]]), Seco = min(n - size[u], size[son[u]]), Min = n - size[u];
    if (!Min) Min = size[son[u]];

    for (int i = head[u]; ~i; i = g[i].nxt) {
        int v = g[i].to;
        if (v != fa[u] && v != son[u]) {
            dfs(v);
            for (multiset <int> :: iterator IT = Self[v].begin(); IT != Self[v].end(); ++IT) 
                Ots.insert(*IT);
            Min = min(Min, size[v]); Seco = max(Seco, size[v]);
        }
    }
    if (son[u]) dfs(son[u]), Min = min(Min, size[son[u]]);

    for (int i = head[u]; ~i; i = g[i].nxt) {
        int v = g[i].to;
        if (v != fa[u] && v != son[u]) 
            for (multiset <int> :: iterator IT = Self[v].begin(); IT != Self[v].end(); ++IT) 
                Ots.erase(Ots.find(*IT));
    }

    if (Seco != Fisr) {
        int l = Seco, r = Fisr, opt = (Fisr == size[son[u]]);
        while (l <= r) {
            int mid = (l + r) >> 1;
            if (check(opt, mid, u, Min, Fisr)) ans[u] = mid, r = mid - 1;
            else l = mid + 1;
        }
    }

    if (!ans[u]) ans[u] = Fisr;
    if (son[u]) swap(Self[son[u]], Self[u]);

    for (int i = head[u]; ~i; i = g[i].nxt) {
        int v = g[i].to;
        if (v != fa[u] && v != son[u]) 
            for (multiset <int> :: iterator IT = Self[v].begin(); IT != Self[v].end(); Self[v].erase(IT++)) Self[u].insert(*IT);
    }

    if (fa[u] && fa[u] != rt) ancestor.erase(ancestor.find(size[fa[u]])); 
    Self[u].insert(size[u]);
}

void solve() {
    dfs(rt);
    rep (i, 1, n) printf("%d
", ans[i]);
}

int main() {
    freopen("del.in", "r", stdin);
    freopen("del.out", "w", stdout);

    init();
    solve();

#ifdef Qrsikno
    debug("
Running time: %.3lf(s)
", clock() * 1.0 / CLOCKS_PER_SEC);
#endif
    return 0;
}

?