洛谷P1084 疫情控制

版权声明：我这么弱的蒟蒻，虽然博文不是很好，但也请标明转发地址喵！ https://blog.csdn.net/ACerAndAKer/article/details/82716698

LCA毒瘤题

一个很显然的性质，一个点尽量向上跑，可以阻断更多的子树

还有就是这种求最小啊最大啊的题，都可以二分答案

于是我们得到了一个优秀的做法，二分答案，然后去判断是否合法

如何判断

我们用倍增的方法，让每个军队在mid的时间内尽可能向上跳，直到到达根节点或者不能向上跳为止，然后我们把每个能到根节点的军队放到一个数组里，并记录下他还能走多远，因为他还能够去到其他点，然后我们能到的点打上vis标记，然后对于能从根节点且未被打上标记的点，我们也存到一个数组里，然后对于这些没被控制的点，显然它可以由本来就在它的子树里，但是到了根节点的军队控制，也可以由根节点下来的军队控制，显然让这两个里面剩余路径 大的来控制更优，于是乎，我们就优先让剩余路径大的军队匹配距离远的未被控制点就吼了

代码

//By AcerMo
#include<cmath>
#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
using namespace std;
const int M=100500; 
struct rot{int now,tp;}can[M];
int n,m,lef,tot;
bool vis[M];
int to[M],nxt[M],w[M],head[M],cnt;
int dep[M],f[M][20],id[M],d[M][20],top[M],ono[M];
inline int read()
{
    int x=0;char ch=getchar();
    while (ch>'9'||ch<'0') ch=getchar();
    while (ch>='0'&&ch<='9') x=x*10+ch-'0',ch=getchar();
    return x;
}
inline void add(int x,int y,int z)
{
    to[++cnt]=y;w[cnt]=z;nxt[cnt]=head[x];head[x]=cnt;
    to[++cnt]=x;w[cnt]=z;nxt[cnt]=head[y];head[y]=cnt;
    return (void)(lef+=(x==1||y==1),tot+=z);
}
inline bool cmp1(rot a,rot b){return a.now<b.now;}
inline bool cmp2(rot a,rot b){return a.now>b.now;}
inline bool cmp3(int a,int b){return a>b;}
inline void dfs(int x,int fa,int t)
{
    f[x][0]=fa;dep[x]=dep[fa]+1;top[x]=t;
    for (int i=1;i<=18;i++)
    f[x][i]=f[f[x][i-1]][i-1],
    d[x][i]=d[x][i-1]+d[f[x][i-1]][i-1];
    for (int i=head[x];i;i=nxt[i])
    if (to[i]!=fa) d[to[i]][0]=w[i],dfs(to[i],x,x==1?to[i]:t);
    return ; 
}
inline bool jud(int x,int fa)
{
    if (vis[x]) return 1;
    int all=0;
    for (int i=head[x];i;i=nxt[i])
    if (to[i]!=fa)
    {
        all++;
        if (!jud(to[i],x)) return 0;
    }
    return all!=0;
}
inline bool che(int e)
{
    fill(vis,vis+n+1,0);int all=0;
    for (int i=1;i<=m;i++)
    {
        int x=id[i],dis=e;
        for (int k=18;k>=0;k--)
        {
            if (!f[x][k]||d[x][k]>dis) continue;
            dis-=d[x][k];
            if (f[x][k]==1) 
            {
                can[++all].tp=top[x];x=f[x][k];
                can[all].now=dis;break;
            }
            x=f[x][k];
        }   
        vis[x]=1;
    }   
    vis[1]=0;
    if (jud(1,1)) return 1;
    sort(can+1,can+all+1,cmp1);
    for (int i=1;i<=all;i++)
    if (can[i].now<d[can[i].tp][0])
    if (!jud(can[i].tp,1)) 
    can[i].now=-1,vis[can[i].tp]=1;
    sort(can+1,can+all+1,cmp2);
    can[all+1].now=-1e12;all=0;
    for (int i=head[1];i;i=nxt[i])
    if (!jud(to[i],1)) ono[++all]=w[i];
    sort(ono+1,ono+all+1,cmp3);
    for (int i=1;i<=all;i++)
    if (ono[i]>can[i].now) return 0;
    return 1;
}
signed main()
{
    n=read();int x,y,z;
    for (int i=1;i<n;i++)
    x=read(),y=read(),z=read(),add(x,y,z);
    dfs(1,0,0);m=read();
    if (lef>m) return puts("-1"),0;
    for (int i=1;i<=m;i++) id[i]=read();
    int l=0,r=tot;
    while (l<r)
    {
        int mid=(l+r)>>1;
        if (!che(mid)) l=mid+1;
        else r=mid;
    }
    cout<<l;
    return 0;
}