[nowcoder5669A]Ancient Distance

对于一个$k$，可以二分枚举答案并判断，判断过程可以贪心找最深的点（线段树区间max）+倍增+线段树区间覆盖（清0）来实现，时间复杂度$o(klog_{2}n)$

考虑反过来，暴力枚举答案$x$并求出最少需要的点数量$f(x)=k$，那么$\forall \ f(x)\le i< f(x-1)$，都有$i$的答案为$x$

这样的复杂度看似仍然是$o(n^{2}log_{2}n)$，但发现一次贪心至少覆盖$x+1$个点或者已经是最后一次，也就是说最多说单次复杂度为$o(\lceil \frac{n}{x+1}\rceil log_{2}n)$，累加后通过调和级数保证复杂度为$o(nlog^{\ 2
}_{2}n)$

具体线段树的实现上可能比较难，可以再维护一个$tag[k]$表示，可能标记永久化+重新修改来实现会比较方便

另外常数较大，注意线段树常数

#include<bits/stdc++.h>
using namespace std;
#define N 200005
#define L (k<<1)
#define R (L+1)
#define mid (l+r>>1)
struct ji{
    int nex,to;
}edge[N];
vector<int>v;
int E,n,x,head[N],dfn[N],sz[N],sh[N],tr[N<<2],tr2[N<<2],tag[N<<2],f[N][21];
void add(int x,int y){
    edge[E].nex=head[x];
    edge[E].to=y;
    head[x]=E++;
}
void build(int k,int l,int r){
    tag[k]=1;
    if (l==r){
        tr[k]=tr2[k]=sh[l];
        return;
    }
    build(L,l,mid);
    build(R,mid+1,r);
    tr[k]=tr2[k]=max(tr[L],tr[R]);
}
void update(int k,int l,int r,int x,int y,int z){
    if ((l>y)||(x>r))return;
    if ((x<=l)&&(r<=y)){
        tag[k]=z;
        tr[k]=tr2[k]*z;
        return;
    }
    update(L,l,mid,x,y,z);
    update(R,mid+1,r,x,y,z);
    tr[k]=max(tr[L],tr[R])*tag[k];
}
int query(int k,int l,int r){
    if (l==r)return l;
    if (tr[k]==tr[L])return query(L,l,mid);
    return query(R,mid+1,r);
}
void dfs(int k,int fa,int s){
    sz[k]=1;
    sh[k]=s;
    dfn[k]=++x;
    f[k][0]=fa;
    for(int i=1;i<=20;i++)f[k][i]=f[f[k][i-1]][i-1];
    for(int i=head[k];i!=-1;i=edge[i].nex){
        dfs(edge[i].to,k,s+1);
        sz[k]+=sz[edge[i].to];
    }
}
int find(int k,int x){
    for(int i=0;i<=20;i++)
        if (x&(1<<i))k=f[k][i];
    return k;
}
int main(){
    while (scanf("%d",&n)!=EOF){
        E=0;
        for(int i=1;i<=n;i++)head[i]=-1;
        for(int i=2;i<=n;i++){
            scanf("%d",&x);
            add(x,i);
        }
        x=0;
        dfs(1,1,1);
        build(1,1,n);
        int ans=-1;
        for(int i=1;i<=n;i++){
            v.clear();
            while (1){
                x=find(query(1,1,n),i);
                if (x==1)break;
                v.push_back(x);
                update(1,1,n,dfn[x],dfn[x]+sz[x]-1,0);
            }
            for(int j=0;j<v.size();j++)update(1,1,n,dfn[v[j]],dfn[v[j]]+sz[v[j]]-1,1);
            ans+=v.size()+1;
        }
        printf("%d\n",ans);
    }
}