疫情控制
思路
我们的方法是：二分+贪心+倍增。
我们可以知道：如果这个时间可以让题意满足，则比它大的时间也可以让题意满足。
所以有单调性，我们就可以二分答案。
但\(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;
}
好恶心啊~~，打了两个小时都没打出来。
