[NOIP2012 提高组] 疫情控制 题解
[NOIP2012 提高组] 疫情控制
题意：
给定一棵树，边有边权，有一些结点上有军队（可能不止一支），军队可移动。求最短的时间，使得军队移动后，从根到每个叶子结点的路径上都有军队驻扎。军队可以同时移动。
思路：
咳咳咳我当时读错题了以为这题虚高，然后才意识到边境结点只有叶子结点。
首先一个很明显的贪心就是，军队能往根移动就一定会往根移动，因为深度浅的结点能控制的叶子结点一定不少于深度深的结点。
然后我就不会了，看了题解。咳咳咳，然后既然要求最短的时间，想到二分。这题的重点就是二分后的 check 的写法。
首先还是像刚才的贪心，让军队能往上走就往上走，走的过程用倍增加速。如果有的军队能够走到根节点的子节点，那么就记录下来剩下的时间还有多少；走不到的，就对终点打上标记，代表这个子树已经被封死了。注意根节点的子节点很特殊！，要特殊处理，所以就不打标记。这是第一遍 dfs。
然后是第二遍 dfs，这一遍是在处理子树是否被封死，分以下几种情况：
- 是叶子，但没有标记，则未被封死。
- 有标记，且不是根节点的子节点，被封死。
- 不是叶子，没有标记，但所有的儿子都被封死，被封死。
这样处理完后，我们就得到了根结点儿子的所有信息了。最后一步，就是分配军队。下面所说的上传军队，都是在把剩余时间大于到根的距离的军队上传。
对于一个根节点的子节点，也要分情况：
- 如果被封死，则所有的军队都可以上传；
- 如果没被封死，如果最小的军队的剩余时间不足以从该结点走上根节点再走下来，则留驻更优；否则上传更优。下面会给出证明；
其实关于第二种情况的证明，貌似没有题解真正给出一个合理的解释。我个人觉得下面的证明更加有力：
第一个方面同第一篇题解，就是如果这个节点剩余最小的军队（设为 \(A\)）去分配，则只能分配给边权比该节点的边权还要小的结点，而这些结点让这个结点其他的军队去匹配照样没问题。但这里并没有说明，为什么让其他结点的军队来入驻会不优。
我们来考虑，如果让其他结点的军队来入驻，那一定是剩余时间大于该结点对应边权的军队，这些军队都比 \(A\) 上传后能匹配更多的结点。所以，让 \(A\) 留下可以增加那些军队匹配其他结点的机会。
那么接下来就好办了。我们把能上传的结点减掉消耗的边权后扔进 multiset 里，然后对于每个没有匹配的结点，按照边权找到第一个大于的军队来匹配就好。
代码（又丑又乱，凑合看吧 xwx）：
#include<bits/stdc++.h>
using namespace std;
const int N = 5e4+100;
#define ll long long
inline int read(){
int x = 0; char ch = getchar();
while(ch<'0' || ch>'9') ch = getchar();
while(ch>='0'&&ch<='9') x = x*10+ch-48, ch = getchar();
return x;
}
int head[N], tot;
struct node{
int nxt, to, w;
}edge[N<<1];
void add(int u, int v, int w){
edge[++tot].nxt = head[u];
edge[tot].to = v;
edge[tot].w = w;
head[u] = tot;
}
int dep[N]; ll dst[N];
int cnt[N];
int n;
int m;
int lg[N];
int fa[N][16];
bool not_leaf[N];
void predfs(int u, int fath){
fa[u][0] = fath;
for(int i = 1; i<=lg[dep[u]]; ++i){
fa[u][i] = fa[fa[u][i-1]][i-1];
}
bool flag = 0;
for(int i = head[u]; i;i = edge[i].nxt){
int v = edge[i].to;
if(v == fath) continue;
flag = 1;
dep[v] = dep[u] + 1;
dst[v] = dst[u] + edge[i].w;
predfs(v, u);
}
not_leaf[u] = flag;
}
bool vis[N];
vector<long long> vc[N];
long long mxdst;
void dfs(int u, int fath){
if(cnt[u]){
int tmp = u;
long long rsd = mxdst;
for(int i = lg[dep[u]]; i>=0; --i){
if(fa[tmp][i] != 1 && dst[tmp] - dst[fa[tmp][i]] <= rsd){
rsd-= (dst[tmp] - dst[fa[tmp][i]]);
tmp = fa[tmp][i];
i = lg[dep[tmp]];
}
}
if(fa[tmp][0] == 1){
for(int i = 1; i<=cnt[u]; ++i){
vc[tmp].push_back(rsd);
}
} else{
vis[tmp] = 1;
}
}
for(int i = head[u]; i; i = edge[i].nxt){
int v = edge[i].to;
if(v == fath) continue;
dfs(v, u);
}
}
vector<int> single_p;
void dfs2(int u, int fath){
if(vis[u]) return;
bool flag = not_leaf[u];
// if(fath == 1 && !head[u]) flag = 0;
for(int i = head[u]; i; i = edge[i].nxt){
int v = edge[i].to;
if(v == fath) continue;
dfs2(v, u);
flag&=vis[v];
}
vis[u] = flag;
}
// priority_queue<long long> q;
multiset<long long> s;
bool check(ll x){
mxdst = x;
memset(vis, 0, sizeof(vis));
// for(int i = head[1]; i; i = edge[i].nxt){
// vc[edge[i].to].clear();
// }
single_p.clear();
s.clear();
dfs(1, 0);
dfs2(1, 0);
for(int i = head[1]; i; i = edge[i].nxt){
int v = edge[i].to;
if(vc[v].size()){
if(vis[v]){
for(auto j:vc[v]){
if(j > dst[v]) s.insert(j - dst[v]);
}
} else{
sort(vc[v].begin(), vc[v].end());
int st = 0;
if(vc[v][0]< 2*dst[v]) st = 1;
for(int j = st; j<(int)vc[v].size(); ++j){
if(vc[v][j] > dst[v]) s.insert(vc[v][j] - dst[v]);
}
if(!st)single_p.push_back(v);
}
vc[v].clear();
} else{
if(!vis[v]) single_p.push_back(v);
}
}
multiset<long long >::iterator it;
for(auto u: single_p){
it = s.lower_bound(dst[u]);
if(it == s.end()){
return 0;
}
s.erase(it);
}
return 1;
}
int main(){
// freopen("data.txt", "r", stdin);
// freopen("my.out", "w", stdout);
n = read();
for(int i = 2; i<=n; ++i){
lg[i] = lg[i>>1] + 1;
}
int cntrt = 0;
for(int i = 1; i<n; ++i){
int u =read(), v = read(), w = read();
add(u, v, w);
add(v, u, w);
if(u == 1 || v == 1) ++cntrt;
}
m = read();
for(int i = 1; i<=m; ++i){
++cnt[read()];
}
if(m < cntrt){
puts("-1");
return 0;
}
predfs(1, 0);
ll l = 0, r = 500000000;
ll ans = 0;
while(l <= r){
// puts("1");
ll mid = (l+r)>>1;
if(check(mid)){
r = mid-1;
ans = mid;
} else{
l = mid+1;
}
}
printf("%lld\n", ans);
return 0;
}
