\(Description\)

题面
给你一颗\(n\)个节点带权的树，告诉你有\(m\)个军队以及他们驻扎的节点，军队经过一条边的时间是这条边的权值，要求移动军队（所有军队可以同时移动，可以重合），使得每一条从根到叶子结点上都有军队驻扎，根节点不能驻扎军队，叶子结点可以驻扎军队。求完成部署的最短时间是多少。

\(Solution\)

因为所有军队可以同时移动，所以部署完成的时间就是到达指定位置最慢的那个军队花费的时间，也就是让最长时间最短，这样一归纳显然这道题是个二分答案。
那么如何\(check\)呢，考虑到一个点上有军队，他子树的所有路径都已经合法了，所以让他尽量往上移动，一定能让合法的路径数更多，所以在二分出的时间内，让每个军队尽可能往上走，并且记录他的最终位置。
假如一个军队能到达根节点，那么他可以走到根节点的其他子树了。所以我们用结构体记录下他来，然后\(DFS\)整棵树，假如根节点的某棵子树没有被完全覆盖，那我们记录一下这颗子树的编号，他们是需要别的军队从别的子树经过根节点过来帮忙，根据贪心，显然这些军队只需要从根节点走到这个子树的根节点距离最短而且覆盖所有子树内的点（也就是经过子树-根节点这条边）。

总结一下，开两个结构体，一个记录到达根节点可以去支援的军队的编号以及他还能走的时间，一个记录没有被覆盖的根节点的子树以及他到根节点的距离，将两个结构体从大到小，剩余时间长的去覆盖距离长的子树（假如答案是合法的这样贪心一定是对的），如果覆盖不了就是无解。不过需要注意一点，有可能一颗子树有自己军队可以覆盖，但是他走到了根节点上，在\(DFS\)过程中这颗子树会被视为没有覆盖，这种情况我们从所有从该子树走出去的军队选出剩余时间最短的拿来覆盖，这样也是个对的贪心，剩余时间长的去覆盖别的子树。所以我们记录所有根节点的子树的走出去军队的最小剩余时间和编号，匹配的时候先看能不能被自己军队覆盖，然后标记用过，如果不行就找最大的来覆盖。

另外向上走的过程可以使用倍增优化，还有注意开\(long\ long\)。

更多细节见代码

\(Code\)

#include<cstdio>
#include<iostream>
#include<algorithm>
#include<cstring>
#define re register
#define maxn 50010
#define ll long long
using namespace std;
inline int read()
{
    int x=0,f=1; char ch=getchar();
    while(ch<'0'||ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0'&&ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
struct Edge{
    int v,w,nxt;
}e[maxn<<2];
bool flag,flag2,okk[maxn];
ll tmp1;
ll rest[maxn],dis[maxn][23];
int used[maxn];
int x,y,z,head[maxn],cnt,n,m,loc[maxn];
int restmin[maxn],restid[maxn],vis[maxn];
int cnt2,na,nb,f[maxn][23];
struct node{
    int id;
    ll res;
}a[maxn],b[maxn];
inline void add(int u,int v,int w)
{
    e[++cnt].v=v;
    e[cnt].w=w;
    e[cnt].nxt=head[u];
    head[u]=cnt;
}
void dfs1(int now,int fa,ll w)//预处理 
{
    //fat[now]=fa;
    f[now][0]=fa;
    dis[now][0]=w;
    for(re int i=1;i<=18;++i)
    {
        f[now][i]=f[f[now][i-1]][i-1];//f[i][j]表示从i往上跳2^j步到达的点 
        dis[now][i]=dis[now][i-1]+dis[f[now][i-1]][i-1];//dis[i][j]表示从i节点向上跳2^j步所经过的路程 
    }
    for(int i=head[now];i;i=e[i].nxt)
    {
        int ev=e[i].v;
        if(ev==fa) continue;
         dfs1(ev,now,e[i].w);
    }
}
bool cmp(node A,node B)
{
    return A.res>B.res;//按 剩余时间/需要的时间 从大到小排序 
}
void dfs2(int now,int fa)
{
   bool h=false;
   if(vis[now])  return ;//访问过就回溯 
   for(int i=head[now];i;i=e[i].nxt)
   {
     int ev=e[i].v;
     
     if(ev==fa) continue;
     h=true;//h记录有没有儿子，叶子节点没有儿子 
     dfs2(ev,now);
   }
   if(!h)  flag=false;//如果是叶子节点还没有回溯就代表这条路径没被占领 
}
bool check(ll co)
{
    int x;
    ll num=0;//开long long 
    na=nb=0;//表示结构体大小，注意清零 
    memset(vis,0,sizeof(vis));   //标记最终军队在哪些点 
    memset(restid,0,sizeof(restid));//restid[i]表示从i这颗子树中出去的军队中，剩余时间最短的编号 
    memset(used,0,sizeof(used));
    for(int i=1;i<=m;++i)
    {
        x=loc[i],num=0;//num表示条的距离 
        for(int j=17;j>=0;--j)
         if(f[x][j]>1&&num+dis[x][j]<=co)//倍增，注意先不要条到根节点 
          num+=dis[x][j],x=f[x][j];
        if(f[x][0]==1&&num+dis[x][0]<=co)//假如可以跳到根节点 
        {
            a[++na].res=co-num-dis[x][0],a[na].id=i;//a数组记录军队编号和剩余时间 
            if(!restid[x]||a[na].res<restmin[x])//restmin记录最短剩余时间，不清空的话要加前面!restid[x]判断 
             restmin[x]=a[na].res,restid[x]=i;
        }
        else vis[x]=1;  //到不了根节点再标记位置 
    }
    for(re int i=head[1];i;i=e[i].nxt)
    {
        int ev=e[i].v;
        flag=true;
        dfs2(ev,1);//每颗根节点的子树dfs，没被覆盖则记录 
        if(!flag) b[++nb].id=ev,b[nb].res=e[i].w;
    }
    sort(a+1,a+na+1,cmp);
    sort(b+1,b+nb+1,cmp);//从大到小排序 
    x=1,used[0]=1;//x在军队数组中扫描 
    for(re int i=1;i<=nb;++i)
    {
        if(!used[restid[b[i].id]]){used[restid[b[i].id]]=1;continue;}//如果从这颗子树中出去的剩余时间最短的 
        while(x<=na&&(used[a[x].id]||a[x].res<b[i].res)) ++x;//往后找，用过的别用 
        if(x>na) return false;
        used[a[x].id]=1;
    }
    return true;
    
}
ll erfen()
{
    ll l=0,r=tmp1;
    while(l<=r)
    {
        ll mid=(l+r)>>1;
        if(check(mid)) r=mid-1;
        else l=mid+1;
    }
    return l;
}
int main()
{
    n=read();
    for(re int i=1;i<n;++i)
    {
        x=read(),y=read(),z=read();
        add(x,y,z);
        add(y,x,z);
        tmp1+=z;//二分边界 
    }
    m=read();
    for(re int i=1;i<=m;++i) loc[i]=read();
    dfs1(1,0,0);
    printf("%lld\n",erfen());//输出用long long 
    return 0;
}

标签：子树,覆盖,NOIP,int,军队,long,P1084,节点,2012
来源： https://www.cnblogs.com/Liuz8848/p/11708806.html