【NOIP 2012 疫情控制】***

题目描述

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

也是树中的根节点。

H 国的首都爆发了一种危害性极高的传染病。当局为了控制疫情，不让疫情扩散到边境

城市（叶子节点所表示的城市），决定动用军队在一些城市建立检查点，使得从首都到边境

城市的每一条路径上都至少有一个检查点，边境城市也可以建立检查点。但特别要注意的是，

首都是不能建立检查点的。

现在，在 H 国的一些城市中已经驻扎有军队，且一个城市可以驻扎多个军队。一支军队可以在有道路连接的城市间移动，并在除首都以外的任意一个城市建立检查点，且只能在

一个城市建立检查点。一支军队经过一条道路从一个城市移动到另一个城市所需要的时间等

于道路的长度（单位：小时）。

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

输入输出格式

输入格式：

第一行一个整数 n，表示城市个数。

接下来的 n-1 行，每行 3 个整数，u、v、w，每两个整数之间用一个空格隔开，表示从

城市 u 到城市 v 有一条长为 w 的道路。数据保证输入的是一棵树，且根节点编号为 1。

接下来一行一个整数 m，表示军队个数。

接下来一行 m 个整数，每两个整数之间用一个空格隔开，分别表示这 m 个军队所驻扎

的城市的编号。

输出格式：

共一行，包含一个整数，表示控制疫情所需要的最少时间。如果无法控制疫情则输出-1。

输入输出样例

输入样例#1：

4
1 2 1
1 3 2
3 4 3
2
2 2

输出样例#1：

3

说明

【输入输出样例说明】

第一支军队在 2 号点设立检查点，第二支军队从 2 号点移动到 3 号点设立检查点，所需

时间为 3 个小时。

【数据范围】

保证军队不会驻扎在首都。

对于 20%的数据，2≤ n≤ 10；

对于 40%的数据，2 ≤n≤50，0<w <10^5；

对于 60%的数据，2 ≤ n≤1000，0<w <10^6；

对于 80%的数据，2 ≤ n≤10,000；

对于 100%的数据，2≤m≤n≤50,000，0<w <10^9。

NOIP 2012 提高组 第二天 第三题

又理解错题了，是同时的。

往往不容易直接进行最优解的时候都要考虑一下二分。那么就给你一个限定时间，你在限定时间之内完成就好了。

我们会发现，其实你越往上走，覆盖的路径越多，所以每个点都尽量往上走。

有些点走到了根，有些点没有，没有走到根的点就直接对子树做贡献。走到根的点要合理分配，使得在限定时间内覆盖子树。

这时如果子树没有被覆盖，那么从根往下走一步就好了。

很容易想到贪心，两个都排序，大的对大的，小的对小的。

但是有一个问题，有时候你从子树走到根，然后走不回来了。【但其实他留在那棵子树上可能更好【相当于他下来完全不用时间的

考虑一个子树，从他出发的点剩余时间最少的是x，如果x不能走回来，那么就让x留在那子树上，否则这种情况不用管【因为都能走回来了，就不用管了

为什么走不会来，就直接留下呢，因为这样你覆盖这棵子树一定用了其他点，说明这个点比x更强，那么如果x能做到的事，这个点更能做到，所以x不需做别的，管好这棵子树就好。

【倍增打错了，捂脸

 #include<cstdio>
 #include<cstdlib>
 #include<cstring>
 #include<iostream>
 #include<algorithm>
 #include<queue>
 #include<cmath>
 using namespace std;
 #define Maxn 50010
 #define Maxd 25
 #define INF 0xfffffff
 #define LL long long
 
 struct node
 {
     LL x,y,next,c;
 }t[Maxn*];LL len;
 LL first[Maxn];
 LL n,m;
 
 void ins(LL x,LL y,LL c)
 {
     t[++len].x=x;t[len].y=y;t[len].c=c;
     t[len].next=first[x];first[x]=len;
 }
 
 LL mymin(LL x,LL y) {return x<y?x:y;}
 
 bool am[Maxn];
 LL ff[Maxn],d[Maxn][Maxd],f[Maxn][Maxd],id[Maxn];
 LL dis[Maxn],dep[Maxn];
 
 void dfs(LL x,LL fa)
 {
     for(LL i=;i<=;i++)
         d[x][i]=d[f[x][i-]][i-],f[x][i]=f[f[x][i-]][i-];
     if(fa==) ff[x]=x;
     else ff[x]=ff[fa];
     for(LL i=first[x];i;i=t[i].next) if(t[i].y!=fa)
     {
         LL y=t[i].y;
         d[y][]=t[i].c;f[y][]=x;
         dis[y]=dis[x]+t[i].c;dep[y]=dep[x]+;
         dfs(y,x);
     }
 }
 
 LL mn[Maxn];
 bool g[Maxn];
 void dfs2(LL x,LL fa)
 {
     LL ans=;
     bool ok=,sm=;
     for(LL i=first[x];i;i=t[i].next) if(t[i].y!=fa)
     {
         sm=;
         LL y=t[i].y;
         dfs2(y,x);
         if(!g[y]) ok=;
     }
     if(am[x]||(ok&&sm)) g[x]=;
 }
 
 struct hp
 {
     LL x,w;
 }q1[Maxn],q2[Maxn];
 
 LL lf[Maxn];
 
 bool cmp(hp x,hp y) {return x.w<y.w;}
 
 bool us[Maxn];
 bool check(LL x)
 {
     memset(am,,sizeof(am));
     memset(g,,sizeof(g));
     memset(lf,-,sizeof(lf));
     for(LL i=first[];i;i=t[i].next) mn[t[i].y]=-;
     LL xx;
     for(LL i=;i<=m;i++)
     {
         LL now=id[i];xx=x;
         for(LL j=;j>=;j--)
         {
             if((<<j)<=dep[now]&&dis[now]-dis[f[now][j]]<=xx)
             {
                 xx-=dis[now]-dis[f[now][j]];
                 now=f[now][j];
             }
         }
         am[now]=;
         if(now==) lf[i]=x-dis[id[i]];
         if(now==&&(mn[ff[id[i]]]==-||lf[mn[ff[id[i]]]]>lf[i])) mn[ff[id[i]]]=i;
     }
     dfs2(,);
     LL l1=,l2=;
     for(LL i=;i<=m;i++) if(lf[i]!=-) q1[++l1].x=i,q1[l1].w=lf[i];
     // for(LL i=1;i<=m;i++) if(id[i]==1) q1[++l1].x=0,q1[l1].w=x;
     for(LL i=first[];i;i=t[i].next)
     {
         LL y=t[i].y;
         if(!g[y]) q2[++l2].x=y,q2[l2].w=t[i].c;
     }
     memset(g,,sizeof(g));
     sort(q1+,q1++l1,cmp);
     sort(q2+,q2++l2,cmp);
     LL j=,i;
     // LL k=l1;
     if(l1<l2) return ;
     for(i=;i<=l2;i++)if(mn[q2[i].x]!=-&&g[mn[q2[i].x]]==&&lf[mn[q2[i].x]]<q2[i].w)
         {
             g[mn[q2[i].x]]=;
             q2[i].x=-;
         }
 
     for(i=;i<=l2;i++) if(q2[i].x!=-)
     {
         while(g[q1[j].x]&&j<=l1) j++;
         // if(j>l1) return 0;
         /*if(mn[q2[i].x]!=-1&&g[mn[q2[i].x]]==0&&lf[mn[q2[i].x]]<q2[i].w)
         {
             g[mn[q2[i].x]]=1;
             continue;
         }*/
         /*else*/ if(mn[q2[i].x]==-||lf[mn[q2[i].x]]>=q2[i].w)
         {
             while((g[q1[j].x]||q1[j].w<q2[i].w)&&j<=l1) j++;
         }
         if(j>l1) return ;
         g[q1[j].x]=;
         j++;
     }
     return ;
 }
 
 void ffind(LL l,LL r)
 {
     LL ans=-;
     while(l<r)
     {
         LL mid=(l+r)>>;
         if(check(mid)) ans=mid,r=mid;
         else l=mid+;
     }
     if(check(l)) ans=l;
     printf("%lld\n",ans);
 }
 
 int main()
 {
     scanf("%lld",&n);
     len=;
     memset(first,,sizeof(first));
     LL sum=;
     for(LL i=;i<n;i++)
     {
         LL x,y,c;
         scanf("%lld%lld%lld",&x,&y,&c);
         ins(x,y,c);ins(y,x,c);
         sum+=c;
     }
     memset(am,,sizeof(am));
     scanf("%lld",&m);
     for(LL i=;i<=m;i++)
     {
         LL x;
         scanf("%lld",&x);
         am[x]++;
         id[i]=x;
     }
     f[][]=;
     dis[]=;dep[]=;
     dfs(,);
     ffind(,sum);
     return ;
 }

【打得丑并且调了一个晚上，捂脸= =

2016-11-17 07:52:50