疫情控制

目录

• 思路
  • 输入
  • 二分
  • 倍增预处理
  • dfs寻找路径未被驻扎的叶子节点
  • check函数
• 代码

题目传送门

思路

我们的方法是：二分+贪心+倍增。

我们可以知道：如果这个时间可以让题意满足，则比它大的时间也可以让题意满足。

所以有单调性，我们就可以二分答案。

但(check)函数怎么打呢？我们要使用贪心：显然我们希望每个军队都停留在深度更小的节点（从而管理更多的路径），所以我们就需要军队向上走。

若一个军队可以走到根节点的子节点，则令其暂时停在根节点的子节点。

否则走到能够走到的深度最小的节点。

可以使用树上倍增进行优化。

对于跳得到根节点的子节点军队，我们有两个选择：

对于跳至根的子节点后仍有剩余时间的军队(s)，分成两种情况：

1.如果剩余时间不能使其在根节点之间跳一个往返，即剩余时间小于(2×dist(s,root))的军队，原地驻扎。

2.将符合此条件的所有军队按照剩余时间排序，并将还未控制住疫情的根的子节点按照距根的距离排序，用双指针将军队与城市一一进行匹配。这些军队按照剩余时间从小到大排序，然后和上一步处理出来的这些节点一一进行匹配。这是一个可以证明正确性的贪心策略。若所有未被驻扎的节点都有军队驻扎，则说明当前的时间限制可行；反之则不可行。

考虑这么贪心做的正确性，对于剩余时间不够的军队，如果选择跳过树根去另一个子节点(s′)驻扎，则必然(dist(root,s)>dist(root,s′))，这么做可能会导致需要一个剩余时间足够的军队(s′′)从其本来位置跨过根跳至(s)，花费时间(dist(root,s′′)+dist(root,s))，而这样做花的时间显然比(s)原地驻扎，(s′′)跨过根跳至(s′)的情况长，于是贪心策略正确。

当然，也有可能存在一个军队剩余时间不够，但是其子树已被另一个军队控制的情况，那么这个军队就应算入到上文的第二种情况中。

输入

void add_edge(int u,int v,int w) { ver[++cnt]=v,edge[cnt]=w,next[cnt]=head[u],head[u]=cnt; }

scanf("%d",&n);
for(int i=1,u,v,w;i<n;i++) {
	scanf("%d %d %d",&u,&v,&w);
	add_edge(u,v,w),add_edge(v,u,w);
	sum+=w;
}
scanf("%d",&m);
for(int i=1;i<=m;i++) scanf("%d",&b[i]);

（打着水博客的心思写了上来）

二分

int l=1,r=sum,ans;
bool flag=1;
while(l<=r) {
	int mid=(l+r)>>1;
	if(check(mid)) flag=0,ans=mid,r=mid-1;
	else l=mid+1;
}
if(flag) printf("-1");
else printf("%d",ans);

倍增预处理

void bfs() {
	queue<int> q;
	q.push(1);
	dep[1]=1;
	while(q.size()) {
		int x=q.front(); q.pop();
		for(int i=head[x];i;i=next[i]) {
			int y=ver[i];
			if(dep[y]) continue;
			dep[y]=dep[x]+1,f[y][0]=x,dist[y][0]=edge[i];
			for(int j=1;j<=(int)(log(n)/log(2))+1;j++) f[y][j]=f[f[y][j-1]][j-1],dist[y][j]=dist[y][j-1]+dist[f[y][j-1]][j-1];
			q.push(y);
		}
	}
	return ;
}

dfs寻找路径未被驻扎的叶子节点

bool dfs(int x) {
	bool is_my_son=0;
	if(vis[x]) return 1;
	for(int i=head[x];i;i=next[i]) {
		int y=ver[i];
		if(dep[y]<dep[x]) continue;
		is_my_son=1;
		if(!dfs(y)) return 0;
	}
	if(!is_my_son) return 0;
	return 1;
}

check函数

bool check(ll mid) {
	memset(vis,0,sizeof(vis));
	memset(tim,0,sizeof(tim));
	memset(ned,0,sizeof(ned));
	memset(h,0,sizeof(h));
	memset(need,0,sizeof(need));
	atot=btot=ctot=0;
	for(int i=1;i<=m;i++) {
		ll x=b[i],cnt=0;
		for(int j=(int)(log(n)/log(2))+1;j>=0;j--)
			if(f[x][j]>1 && cnt+dist[x][j]<=mid) cnt+=dist[x][j],x=f[x][j];
		if(f[x][0]==1 && cnt+dist[x][0]<=mid) h[++ctot]=make_pair(mid-cnt-dist[x][0],x);
		else vis[x]=1;
	}
	
	for(int i=head[1];i;i=next[i])
		if(!dfs(ver[i])) need[ver[i]]=1;
		
	sort(h+1,h+ctot+1);
	for(int i=1;i<=ctot;i++) {
		if(need[h[i].second] && h[i].first<dist[h[i].second][0]) need[h[i].second]=0;
		else tim[++atot]=h[i].first;
	}
		
	for(int i=head[1];i;i=next[i])
		if(need[ver[i]]) ned[++btot]=dist[ver[i]][0];
		
	if(atot<btot) return 0;
	
	sort(tim+1,tim+atot+1),sort(ned+1,ned+btot+1);
	int i=1,j=1;
	while(i<=btot && j<=atot) {
		if(tim[j]>=ned[i]) i++,j++;
		else j++;
	}
		
	if(i>btot) return 1;
	return 0;
}

---

代码

#include <bits/stdc++.h>
#include <queue>
#define ll long long
using namespace std;
int n,m,head[50005],ver[100005],edge[100005],next[100005],cnt；//链式前向星
int b[50005];//军队的驻扎地
int dep[50005];//深度
int f[50005][25];//倍增
int sum;//树的边的和
int atot,btot,ctot;
long long tim[50005],ned[50005],dist[50005][25];
//tim是存剩余时间，ned是存储需要匹配的点
pair<long long,int> h[50005];
bool vis[50005],need[50005];//need是存储没被封死的子树的节点

void add_edge(int u,int v,int w) { ver[++cnt]=v,edge[cnt]=w,next[cnt]=head[u],head[u]=cnt; }

void bfs() {
	queue<int> q;
	q.push(1);
	dep[1]=1;
	while(q.size()) {
		int x=q.front(); q.pop();
		for(int i=head[x];i;i=next[i]) {
			int y=ver[i];
			if(dep[y]) continue;
			dep[y]=dep[x]+1,f[y][0]=x,dist[y][0]=edge[i];
			for(int j=1;j<=(int)(log(n)/log(2))+1;j++) f[y][j]=f[f[y][j-1]][j-1],dist[y][j]=dist[y][j-1]+dist[f[y][j-1]][j-1];
			q.push(y);
		}
	}
	return ;
}

bool dfs(int x) {//查这子树是否被封死了
	bool is_my_son=0;
	if(vis[x]) return 1;
	for(int i=head[x];i;i=next[i]) {
		int y=ver[i];
		if(dep[y]<dep[x]) continue;
		is_my_son=1;
		if(!dfs(y)) return 0;
	}
	if(!is_my_son) return 0;
	return 1;
}

bool check(ll mid) {
	memset(vis,0,sizeof(vis));
	memset(tim,0,sizeof(tim));
	memset(ned,0,sizeof(ned));
	memset(h,0,sizeof(h));
	memset(need,0,sizeof(need));
	atot=btot=ctot=0;
	for(int i=1;i<=m;i++) {
		ll x=b[i],cnt=0;
		for(int j=(int)(log(n)/log(2))+1;j>=0;j--)
			if(f[x][j]>1 && cnt+dist[x][j]<=mid) cnt+=dist[x][j],x=f[x][j];
		if(f[x][0]==1 && cnt+dist[x][0]<=mid) h[++ctot]=make_pair(mid-cnt-dist[x][0],x);//如果我们可以把这个军队提到根节点，我们就暂时放在根节点的子节点上
		else vis[x]=1;
	}
	
	for(int i=head[1];i;i=next[i])//查这子树是否被封死了
		if(!dfs(ver[i])) need[ver[i]]=1;
		
	sort(h+1,h+ctot+1);
	for(int i=1;i<=ctot;i++) {
		if(need[h[i].second] && h[i].first<dist[h[i].second][0]) need[h[i].second]=0;//我们这个子树需要封，且剩余时间不够我们换一个分支了，我们就使用这个军队，我们这个子树就被封死了，即我们的选择1
		else tim[++atot]=h[i].first;//否则选择2
	}
		
	for(int i=head[1];i;i=next[i])
		if(need[ver[i]]) ned[++btot]=dist[ver[i]][0];//找出需要封的子树的要花费的时间
		
	if(atot<btot) return 0;//如果军队不足了，我们的时间就不符合
	
	sort(tim+1,tim+atot+1),sort(ned+1,ned+btot+1);
	int i=1,j=1;
	while(i<=btot && j<=atot) {
		if(tim[j]>=ned[i]) i++,j++;//如果可以匹配，我们就使用。因为排了序，我们就一定使用的时间是最小的
		else j++;
	}
		
	if(i>btot) return 1;
	return 0;
}

int main() {
	bool flag=0;
	ll l=0,r=0,mid,ans;
	scanf("%d",&n);
	for(int i=1,u,v,w;i<n;i++) {
		scanf("%d %d %d",&u,&v,&w);
		add_edge(u,v,w),add_edge(v,u,w);
		r+=w;
	}
	bfs();
	scanf("%d",&m);
	for(int i=1;i<=m;i++) scanf("%d",&b[i]);
	while(l<=r) {
		mid=(l+r)>>1;
		if(check(mid)) r=mid-1,ans=mid,flag=1;
		else l=mid+1;
	}
	if(!flag) printf("-1");
	else printf("%lld",ans);
	return 0;
}

好恶心啊~~，打了两个小时都没打出来。