NOIP2012疫情控制(二分答案+树上贪心)

H 国有n个城市，这 n个城市用n-1条双向道路相互连通构成一棵树，1号城市是首都，也是树中的根节点。

H国的首都爆发了一种危害性极高的传染病。当局为了控制疫情，不让疫情扩散到边境城市（叶子节点所表示的城市），决定动用军队在一些城市建立检查点，使得从首都到边境城市的每一条路径上都至少有一个检查点，边境城市也可以建立检查点。但特别要注意的是，首都是不能建立检查点的。

现在，在 H 国的一些城市中已经驻扎有军队，且一个城市可以驻扎多个军队。一支军队可以在有道路连接的城市间移动，并在除首都以外的任意一个城市建立检查点，且只能在一个城市建立检查点。一支军队经过一条道路从一个城市移动到另一个城市所需要的时间等于道路的长度（单位：小时）。

请问最少需要多少个小时才能控制疫情。注意：不同的军队可以同时移动。

Solution

一眼望上去十分不可做，开始%大佬的博客。

发现正解是二分答案。

发现确实有单调性（有单调性一定要二分！！）

首都把整颗树分成了好几个部分。

对于每个军队，在不跳过首都的情况下，越靠上越优，所以我们把没治军队暴力向上跳答案的高度。

但会有跳过的情况。。

跳到首都的军队，不会再跳到别的地方了，我们干脆让它跳到根节点下的那个点。

对于跳过的点，我们记下它在那个部分和它还能跳多远，放到数组里按距离从小到大排序。

遍历这颗子树，求出没有被覆盖完全的子树根，放到数组/堆中从小到大排序。

扫一遍所有军队。

若军队所在子树没有被覆盖，那我就守家(因为这是它最好的选择）。

否则让它去别的子树。

Code

#include<iostream>
#include<cstdio>
#include<queue>
#include<algorithm>
#include<cstring>
#include<vector>
#define N 60009
using namespace std;
int n,head[N],tot,p[N][],deep[N],maxdeep,dep[N],top,m,w[N],tag[N],bu,ans;
bool has[N];
long long d[N][];
struct node{
    int id,s;
    bool operator < (const node &b)const{
        return s>b.s;
    }
};
bool cmp(node a,node b){
    return a.s<b.s;
}
node ve[N];
priority_queue<node>q;
struct fd{
    int n,to,l;
}e[N<<];
inline void add(int u,int v,int l){e[++tot].n=head[u];e[tot].to=v;e[tot].l=l;head[u]=tot;}
int rd(){
    int x=;
    char c=getchar();
    while(!isdigit(c))c=getchar();
    while(isdigit(c)){
        x=(x<<)+(x<<)+(c^);
        c=getchar();
    }
    return x;
}
void dfs(int u,int fa){
    p[u][]=fa;d[u][]=deep[u]-deep[fa];maxdeep=max(maxdeep,deep[u]);
    for(int i=;(<<i)<=dep[u];++i)
      p[u][i]=p[p[u][i-]][i-],d[u][i]=deep[u]-deep[p[u][i]];
    for(int i=head[u];i;i=e[i].n)if(e[i].to!=fa){
        int v=e[i].to;
        deep[v]=deep[u]+e[i].l;
        dep[v]=dep[u]+;
        dfs(v,u);
    }
}
bool dfs3(int u,int fa){
    if(has[u])return ;
    bool tt=;
    for(int i=head[u];i;i=e[i].n)if(e[i].to!=fa){
      if(dfs3(e[i].to,u))return ;
      tt=;
     }
     if(!tt)return ;
    return ;
}
bool check(int pos){
    top=;
    while(q.size())q.pop();
    memset(has,,sizeof(has));
    for(int i=;i<=m;++i){
        int now=w[i],D=pos;
        for(int j=;j>=;--j)
          if(D>=d[now][j]&&p[now][j])D-=d[now][j],now=p[now][j];
       if(now==&&!D)has[tag[w[i]]]=;
       if(now==&&D)ve[++top]=node{tag[w[i]],D};
       if(now!=)has[now]=;
    }
    sort(ve+,ve+top+,cmp);
//    for(int i=1;i<=top;++i)cout<<ve[i].s<<" "<<ve[i].id<<endl;
//    cout<<top<<endl;
    for(int i=head[];i;i=e[i].n){
        int v=e[i].to;
        if(dfs3(v,))q.push(node{v,e[i].l});
        else has[v]=;
    }
    for(int i=;i<=top;++i){
        if(q.empty())return true;
        if(!has[ve[i].id])has[ve[i].id]=;
        else{
            node x=q.top();
            while(q.size()&&has[x.id]){//care
                q.pop();x=q.top();
            }
            if(has[x.id])return ;
            if(x.s<=ve[i].s){
            q.pop();
            has[x.id]=;//care
            }
        }
    }
    while(q.size()&&has[q.top().id])q.pop();
    if(q.empty())return true;
    else return false;
}
void dfs2(int u,int fa){
    tag[u]=bu;for(int i=head[u];i;i=e[i].n)if(e[i].to!=fa)dfs2(e[i].to,u);
}
int main(){
    n=rd(); int u,v,ww;
    for(int i=;i<n;++i)u=rd(),v=rd(),ww=rd(),add(u,v,ww),add(v,u,ww);
    m=rd();
    for(int i=;i<=m;++i)w[i]=rd();
    dfs(,);
    for(int i=head[];i;i=e[i].n){
        bu=e[i].to;
        dfs2(bu,);
    }
    int l=,r=maxdeep*;//care
    ans=-;
    while(l<=r){
        int mid=(l+r)>>;
        if(check(mid)){
            ans=mid;
            r=mid-;
        }
        else l=mid+;
    }
    printf("%d\n",ans);
    return ;
}