2012Noip提高组Day2 T3 疫情控制

题目描述

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。

这是一棵树，我们可以很容易发现对于一支军队把他往树根走是不影响他本身已经能够封锁的子树的

另外我们还可以发现 对于一支军队越接近树根越好，因为这样他能封锁的子树可以尽可能的多

我们还可以发现 对于还没有封锁的子树，我们必须外调可以调过来的军队来封锁。

假设时间无现长 且军队足够多的情况下肯定能控制疫情。

这是一个可行性的方案 时间可以二分。

如何知道哪些军队可以外调？

我们可以发现如果一个军队到了首都 还有时间可以继续走，那就说明可以外调。

到这里就有一个很明显的贪心分配的方法了：

让还剩时间多的军队走尽可能长的路

特别的，如果一个军队到了首都后 他原本封锁的子树不安全了（没有军队了），且自己还剩下的时间不能再走回去那么就让他退一步。

如何把军队往上推到首都？

一步一步显然过慢了

由于路径是确定的，跟开车旅行一样，倍增即可。

于是问题就可以解决了。

二分时间，判断在这个时间里能不能控制疫情，用倍增把军队往首都那推，然后把那些剩余时间不够回去原来子树的军队退回去，然后剩下的军队贪心分配就可以了。

至于不能控制疫情的情况，就是军队数小于根孩子个数，然而数据似乎并没有这个数据（于是乎我也没判了2333）

#include <cstring>
#include <cstdio>
#include <iostream>
#include <algorithm>
#define N 100005
using namespace std;
struct data{
long long di;
int loc;
}em[N/2],li[N/2],cap[N/2];
int num,n,m,next
,to
,head[N/2],fa
,from[N/2],ca,lis,f[N/2][17],list[N/2];
long long l,r,ti,up[N/2][17],ans,dis[N/2],power
,w,sign[N/2],visit[N/2],unsafe[N/2];
void add(int u,int v,long long w){
num++;
next[num]=head[u];
to[num]=v;
power[num]=w;
head[u]=num;
num++;
next[num]=head[v];
to[num]=u;
power[num]=w;
head[v]=num;
}
void DFS(int x){
for (int v,i=head[x];i;i=next[i]){
v=to[i];
if (!visit[v]&&(fa[x]!=v||x==1)){
visit[v]=1;
fa[v]=x;
dis[v]=dis[x]+power[i];
ti=ti<dis[v]?dis[v]:ti;
DFS(v);
}
}
}
void pre(){
for (int i=1;i<=n;++i){
f[i][0]=fa[i];
up[i][0]=dis[i]-dis[fa[i]];
}
for (int j=1;j<=16;++j)
for (int i=1;i<=n;++i){
f[i][j]=f[f[i][j-1]][j-1];
up[i][j]=dis[i]-dis[f[i][j]];
}
}
bool cmp1(const struct data a,const struct data b){
return (a.di>b.di);
}
bool cmp3(int a,int b){
return (a>b);
}
void updata(int x,long long ti){
int pos=li[x].loc;
long long qwq=ti;
for (int i=16;i>=0;--i)
if (up[pos][i]<=ti&&f[pos][i]!=1&&f[pos][i]!=0){
ti-=up[pos][i];
pos=f[pos][i];
}
if (fa[pos]==1&&ti>=up[pos][0])
from[x]=pos,cap[++ca].loc=x,cap[ca].di=ti-up[pos][0];
else sign[pos]=qwq;
}
void check(int x,long long ti,int son){
int qwq=0;
for (int i=head[x],v;i;i=next[i]){
v=to[i];
qwq++;
if (v==fa[x]) continue;
if (sign[v]==ti) continue;
if (x==1) check(v,ti,v);
else check(v,ti,son);
}
if (qwq==1) visit[son]=ti;
}
bool work(long long ti){
lis=ca=0;
for (int i=1;i<=m;++i)
li[i]=em[i];
for (int i=m;i>=1;--i)
updata(i,ti);
check(1,ti,0);
for (int i=head[1];i;i=next[i])
if (visit[to[i]]==ti) unsafe[to[i]]=ti;
for (int i=1;i<=ca;++i)
if (cap[i].di<=dis[from[cap[i].loc]]&&unsafe[from[cap[i].loc]]==ti){
cap[i].di=0;
unsafe[from[cap[i].loc]]=0;
}
sort(cap+1,cap+1+ca,cmp1);
while (cap[ca].di==0&&ca>0) ca--;
for (int i=head[1];i;i=next[i])
if (unsafe[to[i]]==ti) list[++lis]=power[i];
sort(list+1,list+1+lis,cmp3);
int l=1,r=1;
while (l<=ca&&r<=lis)
if (list[r]<=cap[l].di) l++,r++;
else break;
if (r>lis) return true;
else return false;
}
int main(){
num=0;
scanf("%d",&n);
for (int u,v,i=1;i<n;++i){
scanf("%d%d%lld",&u,&v,&w);
r+=w;
add(u,v,w);
}
scanf("%d",&m);
for (int i=1;i<=m;++i)
scanf("%d",&em[i].loc);
fa[1]=1;
DFS(1);
dis[1]=0;
fa[1]=1;
memset(visit,0,sizeof(visit));
for (int i=1;i<=m;++i)
em[i].di=dis[em[i].loc];
sort(em+1,em+1+m,cmp1);
pre();
l=0;
ans=0;
while (l<r){
ti=(l+r)>>1;
if (work(ti)) ans=ti,r=ti;
else l=ti+1;
}
if (l==r) if (work(l)) ans=l;
printf("%lld\n",ans);
return 0;
}

神奇的代码
（代码写的巨烂无比qwq）