[NOIP2012]疫情控制（贪心）

题意

给一颗树，树边带权，有一些标记了的点，每个点可以在树上沿边移动，移动代价为边权。求一种移动策略，使得移动之后的树从根节点到每个叶子都至少有一个标记点，且每个点移动代价的最大值最小。最终状态下根节点不能带标记，无解输出-1

思路

1. 最值问题，且问题有单调性，可以二分，设当前要check的最大值为x，那么每个点都可以移动x

2. 对于一个带了标记的点来说，它的子树中的叶子都是满足条件的，如果把这个点向上移动，它能覆盖到的叶子只会多不会少，所以采用贪心策略，将每个点向上移动x，向上跳的过程可以用倍增完成，接下来分为两种情况（设跳到的点为i）：

   ①跳了x之后未到根。即i !=1，此时直接给i点打上标记，表示跳到这个点，这个是较简单的情况

   ②跳了x之后到了根。那么此时可以消耗的代价还有剩的，那么它可以从根节点走向其它的未标记点

3. 记录一下这个点到1的过程中经过的1的儿子节点（即depth==2的点），设它为j，对所有可以到1的标记点按照剩余代价从小到大排序，从小到大枚举，对于一个标记点，如果它的剩余代价小于dis(1,j)且j未被标记，那么就将它移动到j点，因为如果移动其它点的话会消耗dis(1,j)的代价，但是移动它只会消耗剩余代价，而剩余代价小于dis(1,j)，所以血赚不亏

4. 处理好j->1->j这种情况后，所有的点都当成是从1出发向某一个点，不考虑返回的情况，即使它就是从j->1->j。这就很简单了，对所有未标记的点到1的距离从大到小排序，对剩余代价大小从大到小排序，大的对应大的即可

P.S.标记可以从儿子向父亲转移，即如果一个点的所有儿子都带有标记，它也会带标记

Code：

#include<bits/stdc++.h>
#define N 50005
typedef long long ll;
const int temp=19;
const ll INF = 10000000000000000;
using namespace std;
int n,m;
int fa[N][temp],dep[N],r[N];
ll dis[N][temp];
vector< pair<ll,int> > rest;
vector<ll> ret,q;
bool v[N];
//当前点的军队还可以走的路 

struct Edge
{
	int next,to;
	ll dis;
}edge[N<<1];int head[N],cnt=1;
void add_edge(int from,int to,ll dis)
{
	edge[++cnt].next=head[from];
	edge[cnt].to=to;
	edge[cnt].dis=dis;
	head[from]=cnt;
}
template <class T>
void read(T &x)
{
	char c;int sign=1;
	while((c=getchar())>'9'||c<'0') if(c=='-') sign=-1; x=c-48;
	while((c=getchar())>='0'&&c<='9') x=x*10+c-48; x*=sign;
}
void dfs(int rt)
{
	dep[rt]=dep[fa[rt][0]]+1;
	for(int i=head[rt];i;i=edge[i].next)
	{
		int to=edge[i].to;
		if(to==fa[rt][0]) continue;
		fa[to][0]=rt;
		dis[to][0]=edge[i].dis;
		for(int i=1;i<temp;++i) fa[to][i]=fa[fa[to][i-1]][i-1];
		for(int i=1;i<temp;++i) dis[to][i]=dis[to][i-1]+dis[fa[to][i-1]][i-1];
		dfs(to);
	}
}
void DFS(int rt)//收束 
{
	bool flag=1,son=0;
	for(int i=head[rt];i;i=edge[i].next)
	{
		int to=edge[i].to;
		if(to==fa[rt][0]) continue;
		son=1;
		DFS(to);
		flag&=v[to];
	}
	if(!son) flag=0;
	v[rt]|=flag;
}
bool cmp(ll a,ll b) {return a>b;}
bool check(ll x)//每个军队可以走x 
{
	rest.clear();
	ret.clear();
	q.clear();
	memset(v,0,sizeof(v));
	for(int i=1;i<=m;++i)
	{
		int now=r[i];//对now进行倍增，最多跳到dep==2 
		ll res=x;
		for(int j=temp-1;j>=0;--j)
		{
			if(dep[fa[now][j]]>=2&&res>=dis[now][j])
			{
				res-=dis[now][j];
				now=fa[now][j];
			}
		}
		if(dep[now]!=2||res<dis[now][0]) v[now]=1;
		else rest.push_back(make_pair(res-dis[now][0],now));
	}
	DFS(1);
	sort(rest.begin(),rest.end());
	for(int i=0;i<(int)rest.size();++i)
	{
		ll d=rest[i].first;
		int to=rest[i].second;
		if(d<dis[to][0]&&!v[to]) v[to]=1;
		else ret.push_back(d);
	}
	sort(ret.begin(),ret.end(),cmp);
	for(int i=head[1];i;i=edge[i].next)
	{
		int to=edge[i].to;
		if(!v[to]) q.push_back(edge[i].dis);
	}
	sort(q.begin(),q.end(),cmp);
	if((int)ret.size()<(int)q.size()) return false;
	for(int i=0;i<(int)q.size();++i)
	{
		if(ret[i]<q[i]) return false;
	}
	return true;
}
int main()
{
	read(n);
	for(int i=1;i<n;++i)
	{
		int x,y; ll z;
		read(x);read(y);read(z);
		add_edge(x,y,z);
		add_edge(y,x,z); 
	}
	dfs(1);
	read(m);
	for(int i=1;i<=m;++i) read(r[i]);
	ll l=0,r=INF,ans=-1;
	while(l<=r)
	{
		ll mid=(l+r)>>1;
		if(check(mid)) ans=mid,r=mid-1;
		else l=mid+1;
	}
	cout<<ans<<endl;
	return 0;
}