noip2012 疫情控制

题意

一棵带权有根树，有m个军队。对于每个军队，移动到其距离不超过K且不为根节点的一个点，使得最终根节点与原来的所有叶子的路径上都至少有一个军队。求最小的K。

对于 100%的数据，2≤m≤n≤50,000,0<w <10⁹.

1. 首先我们要求军队移动的最大值最小，所以我们可以二分答案，二分一个移动距离的最大值。
2. 我们考虑贪心，一个军队肯定是能向根走就向根走，这种向上走的问题显然可以倍增加速。
3. 我们分类讨论，如果一个军队最多不能到达根，那就就地驻扎，如果可以到达根，那就在根等待着，分配到根的各个儿子。
4. 对于这些到根的，我们还要去掉一些，就是这个军队到根了，但不能回去的军队，它不能回这个，那别的来这里就浪费了，不如直接让它回去。
5. 做完这些处理之后，我们有一个ned数组，表示需求军队的儿子到根的距离，spl表示能从根出发的军队剩余的行动力，分别从大到小排序，twopiont匹配一下即可。
6. 如果此mid可行，缩小行动值试一试。二分左开右闭。
7. 多次调用，注意数组清零！

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>
#include<queue>
#include<cmath>
#include<cstdlib>
#include<ctime>
using namespace std;
typedef long long ll;
const int inf=0x3f3f3f3f;

inline int read(){
	char ch=' ';int f=1;int x=0;
	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;
}
const int M=1e5+100;
const int N=5e4+100;
struct node{int nxt,w,v;}edge[M];
int head[N],cnt;
void add(int u,int v,int w)
{
	cnt++;
	edge[cnt].v=v;
	edge[cnt].w=w;
	edge[cnt].nxt=head[u];
	head[u]=cnt;
}
int n,m,f[N][20],a[N];
int dis[N][20];

void dfs(int u,int fa,int val)
{
	f[u][0]=fa;dis[u][0]=val;
	for(int i=1;i<=17;i++)
	{
		f[u][i]=f[f[u][i-1]][i-1];
		dis[u][i]=dis[u][i-1]+dis[f[u][i-1]][i-1];
	}
	for(int i=head[u];i;i=edge[i].nxt)
	{
		int v=edge[i].v,w=edge[i].w;
		if(v==fa) continue;
		dfs(v,u,w);
	}
}
int c;
pair<int,int> xz[N];
bool sta[N],need[N];
int spl[N],atot,ned[N],btot;
bool dfs1(int u,int fa)
{
	bool son=0;
	if(sta[u]) return true;
	for(int i=head[u];i;i=edge[i].nxt)
	{
		int v=edge[i].v;
		if(v==fa) continue;
		son=1;
		if(!dfs1(v,u)) return 0;
	}
	if(!son) return 0;
	return 1;
}
bool check(int lim)
{
	int ca=0;
	atot=0;btot=0;
	memset(sta,0,sizeof(sta));
	memset(need,0,sizeof(need));
	for(int i=1;i<=m;i++)
	{
		int x=a[i],cc=0;
		for(int j=17;j>=0;j--)
		if(f[x][j]>1&&cc+dis[x][j]<=lim)
		{
			cc+=dis[x][j];
			x=f[x][j];
		}
		if(f[x][0]==1&&cc+dis[x][0]<=lim)
			xz[++ca]=make_pair(lim-cc-dis[x][0],x);
		else
			sta[x]=1;
	}
	for(int i=head[1];i;i=edge[i].nxt)
	{
		int v=edge[i].v;
		if(!dfs1(v,1)) need[v]=1;
	}
	sort(xz+1,xz+1+ca);
	
	for(int i=1;i<=ca;i++)
		if(need[xz[i].second]&&xz[i].first<dis[xz[i].second][0])
			need[xz[i].second]=0;
		else
			spl[++atot]=xz[i].first;
	sort(spl+1,spl+1+atot,greater<int>());
	for(int i=head[1];i;i=edge[i].nxt)
	{
		int w=edge[i].w,v=edge[i].v;
		if(need[v]) ned[++btot]=w;
	}
	if(atot<btot) return false;
	sort(ned+1,ned+1+btot,greater<int>());
	int i=1,j=1;
	while(i<=atot&&j<=btot)
	{
		if(spl[i]>=ned[j])
		i++,j++;
		else i++;
	}
	if(j>btot) return 1;
	return 0;
}
int main()
{
	n=read();
	int u,v,w;
	for(int i=1;i<n;i++)
	{
		u=read();v=read();w=read();
		add(u,v,w);add(v,u,w);
	}
	dfs(1,0,0);

	m=read();
	for(int i=1;i<=m;i++)
	a[i]=read();
	int l=0,r=1e9,mid;
	while(l<r)
	{
		mid=(l+r)>>1;
		if(check(mid)) r=mid;
		else l=mid+1;
	}
	cout<<r<<endl;
	return 0;
}