NOIP2012 day2 T3 疫情控制

真是一道难题。观察到题目的时间这个量，时间越大显然覆盖的点越多，所以我们说答案具有单调性，这样便可以二分答案了。

接下来最关键的就是如何检验这一个答案，对于一个答案k:

如果有一些点往回移动k的距离仍然不能达到根节点，我们肯定要尽量的把它往上移，这里采用暴力即可。

有些点可以到根。好吧这个时候呢，把还没有控制的根的儿子节点们拿出来，把可以越过根且没有匹配的军队拿出来跑二分图匹配。复杂度O（nmlogn)显然TLE。

我们可以脑补一种贪心的匹配方法。记R[i]表示i这只军队到达根节点后还剩下的时间，B[j]表示j这个根结点的子节点（第二层节点）到根的时间。

那么一只军队能控制一个子节点当且仅当R[i]>=B[j]。这样的话军队移动的时间为k-(R[i]-B[j]),我们的任务是找到一种匹配方法，使得这个式子的最大值最小。

脑补一下便可发现R[i],B[j]越近越好，所以就两个数组排好序匹配啦，下面给出个人认为正确的证明：

如果一只军队不与他本应（指排好序的）那个数配对，那么R[i]-B[j]可能会变小，如果这次的差没变小也会引起别的i的差变小，所以这个式子的最大值变大。

事实真的如此简单吗？不

如果一只军队可以与自己那条路径上的那个第二层根节点（A）配对，且这个军队如果到达根便无法返回A，那么就让他驻扎在A。

证：如果这只军队去了别的地方x点，然后y军队来填补A，由已知得w(A)>W(x)显然让y去x，这支军队驻扎在A最好。

所以如果存在R[i]<B[j]且也能匹配到自己路上的那个点时，取R[i]值最小的匹配。剩下的实现自己去弄吧。感谢Dash的帮助。%%__debug大神。

#include<cstdio>
#include<queue>
#include<cstdlib>
#include<cstring>
#include<iostream>
#include<algorithm>
#define x first
#define y second
#define pii std::pair<long long,int>
const int MAXN=50005*2;
int first[MAXN],next[MAXN],m,Militar[MAXN],n,fa[MAXN],isLeaf[MAXN];
int e=0,v[MAXN],hasf[MAXN],vis[MAXN],bel[MAXN],f[MAXN];
long long ww[MAXN],dis[MAXN],w[MAXN];
bool use[MAXN];
void add(int a,int b,int c)
{
e++;next[e]=first[a];first[a]=e;ww[e]=c;v[e]=b;
}
bool cmp(const pii& a,const pii& b)
{
return a.x<b.x;
}
void push_up(int u,int k)
{
int sum=0;
vis[u]=1;
while(1)
{
sum+=w[u];
if(sum>k)break;
u=fa[u];if(u==-1)break;
}
vis[u]=1;
}
pii sons[MAXN];
pii R[MAXN];
void calc(int u,int fa,int vt)
{
if(hasf[u])bel[u]=vt;
for(int i=first[u];i!=-1;i=next[i])
{
int to=v[i];
if(to==fa)continue;
calc(to,u,vt);
}
}
bool dfs(int u,int fa)
{
if(isLeaf[u])return 1;
for(int i=first[u];i!=-1;i=next[i])
{
int to=v[i];
if(to==fa)continue;
if(!vis[to])
{
if(dfs(to,u))return 1;
}
}
return 0;
}
void calc_vis(int u,int fa)
{
int flag=1;
if(vis[u])return ;
for(int i=first[u];i!=-1;i=next[i])
{
int to=v[i];
if(to==fa)continue;
calc_vis(to,u);
if(!vis[to])flag=0;
}
if(!isLeaf[u])vis[u]=flag;
}
void clear()
{
memset(vis,0,sizeof(vis));
memset(sons,0,sizeof(sons));
memset(R,0,sizeof(R));
memset(f,0,sizeof(f));
memset(use,0,sizeof(use));
}
int check(long long  k)
{
clear();
int o=1,p=1;
for(int i=1;i<=m;i++)
{
if(dis[Militar[i]]>=k)
push_up(Militar[i],k);
else R[o].x=k-dis[Militar[i]],R[o++].y=Militar[i];
}
calc_vis(1,-1);
for(int i=first[1];i!=-1;i=next[i])
{
int to=v[i];
if(!vis[to])sons[p].x=w[to],sons[p++].y=to,f[to]=p-1;
}
std::sort(R+1,R+o,cmp);
std::sort(sons+1,sons+p,cmp);
int a=1,b=1;
for(int i=1;i<o;i++)
if(vis[bel[R[i].y]]==0)
if(R[i].x<dis[bel[R[i].y]])
vis[bel[R[i].y]]=1,use[i]=1;
for(int i=1;a<o&&b<p;i++)
{
if(use[a]){a++;continue;}
if(vis[sons[b].y]==0)
{
if(R[a].x>=sons[b].x)vis[sons[b].y]=1,a++,b++;
else  a++;
}
else {b++;continue;}
}
return dfs(1,-1);
}
void BFS(int u,int f)
{
fa[u]=f;
if(next[first[u]]==-1)isLeaf[u]=1;
for(int i=first[u];i!=-1;i=next[i])
{
int to=v[i];
if(to==f)continue;
dis[to]=dis[u]+ww[i],w[to]=ww[i];
BFS(to,u);
}
}
int main()
{
scanf("%d",&n);
long long  sum=0;
int cnt=0;
for(int i=0;i<=n;i++)first[i]=-1;
for(int i=1;i<n;i++)
{
int a,b;long long c=0;
scanf("%d %d %I64d",&a,&b,&c);sum+=c;
add(a,b,c);
add(b,a,c);
}
scanf("%d",&m);
for(int i=1;i<=m;i++)
{
int a;
scanf("%d",&a);
Militar[i]=a;
hasf[a]=1;
}
BFS(1,-1);
long long  l=0,r=sum;
for(int i=first[1];i!=-1;i=next[i])
calc(v[i],1,v[i]),cnt++;
if(m<cnt){printf("-1");return 0;}
if(!check(0)){printf("0\n");return 0;}
while(l+1!=r)
{
long long  mid=(long long)(l+r)>>1;
if(!check(mid))
r=mid;
else l=mid;
}
printf("%I64d\n",r);
}