2018.12.08【BZOJ2599】【IOI2011】Race（点分治）

传送门

---

解析：

点分治一般是统计问题，而这道是一个最优化问题，所以处理上不方便使用容斥原理。

思路：

那么怎么统计呢？

考虑我们维护一个数组$f$，表示距离当前分治重心距离为$i$的点，到分治重心路径上的最小边数，然后每次处理一棵子树，直接把子树内部所有点的信息先在$f$上面询问一次，看能否凑成$k$， 整棵子树处理完了之后再把这颗子树的信息加到$f$数组里面去，供其他子树查询的时候用。

分治其他重心之前记住要清空$f$数组，直接$dfs$一次清空就行了。

---

代码：

#include<bits/stdc++.h>
using namespace std;
#define ll long long
#define re register
#define gc getchar
#define pc putchar
#define cs const

inline int getint(){
    re int num;
    re char c;
    while(!isdigit(c=gc()));num=c^48;
    while(isdigit(c=gc()))num=(num+(num<<2)<<1)+(c^48);
    return num;
}

cs int N=200005,INF=0x3f3f3f3f;
int last[N],nxt[N<<1],to[N<<1],ecnt;
int w[N<<1];
inline void addedge(int u,int v,int val){
    nxt[++ecnt]=last[u],last[u]=ecnt,to[ecnt]=v,w[ecnt]=val;
    nxt[++ecnt]=last[v],last[v]=ecnt,to[ecnt]=u,w[ecnt]=val;
}

cs int M=1000006;
int f[M];
int total,maxn,G;
int siz[N];
bool ban[N];
inline void find_G(int u,int fa){
    siz[u]=1;
    int mx=0;
    for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]]){
        if(v==fa||ban[v])continue;
        find_G(v,u);
        siz[u]+=siz[v];
        mx=max(mx,siz[v]);
    }
    mx=max(mx,total-siz[u]);
    if(maxn>=mx)maxn=mx,G=u;
}

int ans,k,n;
int dist[N],dep[N];
inline void calc(int u,int fa){
    if(dist[u]<=k&&dep[u]<ans){
        ans=min(ans,f[k-dist[u]]+dep[u]);
        for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]]){
            if(v==fa||ban[v])continue;
            dep[v]=dep[u]+1;
            dist[v]=dist[u]+w[e];
            calc(v,u);
        }
    }
}

inline void update(int u,int fa,bool flag){
    if(dist[u]<=k&&dep[u]<ans){
        if(flag)f[dist[u]]=min(f[dist[u]],dep[u]);
        else f[dist[u]]=INF;
        for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]]){
            if(v==fa||ban[v])continue;
            update(v,u,flag);
        }
    }
}

inline void calc_G(int u){
    ban[u]=true;f[0]=0;
    for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]]){
        if(ban[v])continue;
        dist[v]=w[e];dep[v]=1;
        calc(v,0);
        update(v,0,1);
    }
    for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]]){
        if(ban[v])continue;
        update(v,0,0);
    }
    for(int re e=last[u],v=to[e];e;v=to[e=nxt[e]]){
        if(ban[v])continue;
        total=maxn=siz[v];
        find_G(v,u);
        calc_G(G);
    }
}

signed main(){
    n=getint();
    k=getint();
    for(int re i=1;i<n;++i){
        int u=getint(),v=getint(),w=getint();
        addedge(u,v,w);
    }
    total=maxn=n;
    memset(f,INF,sizeof f);
    ans=INF;
    find_G(0,-1);
    calc_G(G);
    printf("%d",ans>n?-1:ans);
    return 0;
}