A题 Ancient Distance

题意

个点以点为根的树，在树上确定个关键点，每个点的权值为点与点到根节点上碰到的第一个关键点的距离(若路径上没有关键点, 那么权值为)，答案为所有点中最大权值的最小值。
现在求的答案之和

题解

题意比较难理解，看看样例应该能懂
考虑已经确定答案的情况下，最少需要多少关键点
因为点的权值为点与点到根节点上碰到的第一个关键点的距离，其实就是点与其祖先结点中的关键点的深度之差
这里确定答案为后，我们要将树中深度都处理掉
对于树中最深的点，将从一直往上个点得到的设为关键点，这样
至于为什么恰好是级祖先，因为关键点只要是的级祖先就可以使
考虑到一个关键点的设立，会使得的子树中所有的点权值都变小，所以我们要让关键点影响的点越多越好(离根越近越好)，即越小越好，所以我们选择恰好是级祖先
所以每次我们确定一个后，其子树中的点均有，当我们继续找深度最大的点，是不会再考虑及其子树中的点，因此我们将他们覆盖掉，即我们每次找未被覆盖的点中最大的点，不断重复这个过程，直到所有点均满足

代码实现

可以看到，我们需要的操作是寻找树中深度最大的结点，以及覆盖一个点的子树，所以考虑按dfs序建立线段树

void dfs(int u, int fa) {
    st[u] = ++dfnt;//dfs到这个点的时刻
    for (auto &v: g[u]) if (v != fa) dfs(v, u);
    ed[u] = dfnt;//dfs完这个点及其子树的时刻
    //所以[st, ed]这之间就是u及其子树
}

可以看到，只要我们覆盖线段树中即可覆盖点子树中所有结点
至于查询最大深度结点，就是线段树基本操作了

还有一个操作，我们要查找一个点的祖先
这里可以倍增处理：

void dfs() {
    //dfs过程中预处理每个点的2^i级祖先
    for (int i = 1; i <= 19; i++) anc[u][i] = anc[anc[u][i - 1]][i - 1];
}

int kthFa(int u, int k) {//查询的时候倍增跳祖先, 复杂度log(k)
    int bit = 0; 
    while (k) { 
        if (k & 1) u = anc[u][bit]; 
        k >>= 1; 
        bit++;
    } 
    return u; 
}

复杂度分析

对于每一个答案，我们至多确定个关键点
考虑关键点会对子树中所有点有影响，那么我们最坏的情况就是子树是一条链，所影响的点只有个
所以每个答案只要确定个关键点就能影响到所有点
而我们单次操作就是线段树的覆盖及其查询，还有查找k级祖先，这些操作都是级别的

总体复杂度

代码

#include<bits/stdc++.h>
#define lc  u<<1
#define rc  u<<1|1
#define mid (t[u].l+t[u].r)/2
using namespace std;
typedef long long ll;
const int MAX = 2e5 + 10;

int N;
int ans[MAX];
vector<int> store;

vector<int> g[MAX];
int anc[MAX][20], dep[MAX], st[MAX], ed[MAX], nodeOf[MAX], dfnt;
void dfs(int u, int fa) {
    dep[u] = dep[anc[u][0] = fa] + 1, nodeOf[st[u] = ++dfnt] = u;
    for (int i = 1; i <= 19; i++) anc[u][i] = anc[anc[u][i - 1]][i - 1];
    for (auto &v: g[u])
        if (v != fa) dfs(v, u);
    ed[u] = dfnt;
}
//k级祖先, 倍增跳
int kthFa(int u, int k) { int bit = 0; while (k) { if (k & 1) u = anc[u][bit]; k >>= 1; bit++;} return u; }

struct SegmentTree {
    int mx, node, l, r;
    bool cover;
} t[MAX << 2];
void push_up(int u) {
    t[u].mx = 0;
    if (!t[lc].cover && t[lc].mx > t[u].mx) t[u].node = t[lc].node, t[u].mx = t[lc].mx;
    if (!t[rc].cover && t[rc].mx > t[u].mx) t[u].node = t[rc].node, t[u].mx = t[rc].mx;
}
void build(int u, int l, int r) {
    t[u].l = l, t[u].r = r;
    if (l == r) {
        t[u].mx = dep[t[u].node = nodeOf[l]];
        return;
    }
    build(lc, l, mid); build(rc, mid + 1, r);
    push_up(u);
}
void update(int u, int ql, int qr, int k) {
    if (ql <= t[u].l && t[u].r <= qr) {
        t[u].cover = k;
        return;
    }
    if (ql <= mid) update(lc, ql, qr, k);
    if (qr > mid) update(rc, ql, qr, k);
    push_up(u);
}


void init() {
    dfnt = 0;
    for (int i = 1; i <= N; i++) g[i].clear();
}

int main() {

    while (~scanf("%d", &N)) {
        init();
        for (int i = 2; i <= N; i++) {
            int x; scanf("%d", &x);
            g[x].push_back(i); g[i].push_back(x);
        }
        dep[0] = -1; dfs(1, 0);
        build(1, 1, dfnt);//按dfs序建立线段树
        for (int i = 1; i <= N; i++) ans[i] = N - 1;
        for (int nowans = N - 1; nowans >= 0; nowans--) {
            int cost = 0;
            store.clear();
            while (1) {
                cost++;
                if (t[1].mx <= nowans) break;//如果树中未覆盖的最大值<=ans, 那么就不需要再覆盖了
                int u = t[1].node;
                u = kthFa(u, nowans);//让最深的点u的贡献值变为nowans, 所以从u往上找nowans个点, 即u的nowans-th祖先
                store.push_back(u);//将覆盖的部分记录, 之后线段树清空
                update(1, st[u], ed[u], 1);//覆盖u的子树, 因为我们将u设为关键点, 且u中最深的点都满足<=nowans, 因此整个子树都满足
            }
            ans[cost] = nowans;//设cost个关键点的答案
            for (auto &i: store) update(1, st[i], ed[i], 0);//清空线段树
        }
        for (int i = 2; i <= N; i++) ans[i] = min(ans[i], ans[i - 1]);//如果设更少的关键点的答案能更小, 那答案就取小的
        ll sum = 0;
        for (int i = 1; i <= N; i++) sum += ans[i];
        printf("%lld\n", sum);
    }



    return 0;
}