疫情控制 2012年NOIP全国联赛提高组(二分答案+贪心)

P1084 疫情控制

题目描述

H 国有 n 个城市，这 n 个城市用 n-1 条双向道路相互连通构成一棵树，1 号城市是首都，也是树中的根节点。

H 国的首都爆发了一种危害性极高的传染病。当局为了控制疫情，不让疫情扩散到边境城市（叶子节点所表示的城市），决定动用军队在一些城市建立检查点，使得从首都到边境城市的每一条路径上都至少有一个检查点，边境城市也可以建立检查点。但特别要注意的是，首都是不能建立检查点的。

现在，在 H 国的一些城市中已经驻扎有军队，且一个城市可以驻扎多个军队。一支军队可以在有道路连接的城市间移动，并在除首都以外的任意一个城市建立检查点，且只能在一个城市建立检查点。一支军队经过一条道路从一个城市移动到另一个城市所需要的时间等于道路的长度（单位：小时）。

请问最少需要多少个小时才能控制疫情。注意：不同的军队可以同时移动。

输入输出格式

输入格式：

第一行一个整数 n，表示城市个数。

接下来的 n-1 行，每行 3 个整数，u、v、w，每两个整数之间用一个空格隔开，表示从城市 u 到城市 v 有一条长为 w 的道路。数据保证输入的是一棵树，且根节点编号为 1。

接下来一行一个整数 m，表示军队个数。

接下来一行 m 个整数，每两个整数之间用一个空格隔开，分别表示这 m 个军队所驻扎的城市的编号。

输出格式：

共一行，包含一个整数，表示控制疫情所需要的最少时间。如果无法控制疫情则输出-1。

输入输出样例

输入样例#1： 复制

4
1 2 1
1 3 2
3 4 3
2
2 2

输出样例#1： 复制

3

说明

【输入输出样例说明】

第一支军队在 2 号点设立检查点，第二支军队从 2 号点移动到 3 号点设立检查点，所需时间为 3 个小时。

【数据范围】

保证军队不会驻扎在首都。

对于 20%的数据，2≤ n≤ 10；

对于 40%的数据，2 ≤n≤50，0<w <10^5；

对于 60%的数据，2 ≤ n≤1000，0<w <10^6；

对于 80%的数据，2 ≤ n≤10,000；

对于 100%的数据，2≤m≤n≤50,000，0<w <10^9。

NOIP 2012 提高组 第二天 第三题

/*
首先可知，根节点的儿子个数如果大于军队个数，则无解
然后考虑同一时间，军队往上走一定比往下走更优
最后的答案取决于时间最长的军队，有要求最小值。最大值最小考虑二分答案。
问题转化为判定性问题。
因为每个军队要往上蹦，考虑倍增预处理。
军队分为两种情况：能到根，不能到根
对于不能到根的军队，让它尽可能往上去。
对于能到根的军队，一定要覆盖根节点的儿子。
把他们到根后还能走的距离排序，由近到远依次覆盖。
还有两个问题，如果根节点的某个军队它来的那个子树没有被覆盖，先让这个军队去覆盖它来的子树
并且对于能来到根节点却不能回去的不能用它覆盖。
*/
#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

#define N 50007
#define ll long long

using namespace std;
ll n,m,k,cnt,num;
bool flag,opt;
ll ans,l,r,mid,ecnt,inf,tot;
ll head[N],root[N],a[N],has[N];
ll fa[N][],g[N][];
struct B{
    ll root;ll rest;
    bool operator < (const B &X) const{
            return rest<X.rest;
    }
}b[N];
struct C{
    ll pos;ll dis;
    bool operator < (const C &x) const{
            return dis<x.dis;
    }
}c[N];
struct edge{
    ll u,v,net,w;
}e[N<<];

inline void add(ll u,ll v,ll w)
{
    e[++cnt].v=v;e[cnt].w=w;e[cnt].net=head[u];head[u]=cnt;
}

inline ll read()
{
    ll x=,f=;char c=getchar();
    while(c>''||c<''){if(c=='-')f=-;c=getchar();}
    while(c>=''&&c<=''){x=x*+c-'';c=getchar();}
    return x*f;
}

inline void init()
{
    memset(has,,sizeof has);
    memset(b,,sizeof b);
    memset(c,,sizeof c);
    cnt=tot=;
}

void dfs(ll x)
{
    for(ll i=head[x];i;i=e[i].net)
    {
        ll v=e[i].v;
        if(v==fa[x][]) continue;
        fa[v][]=x;g[v][]=e[i].w;
        if(x==) root[v]=v;
        else root[v]=root[x];
        dfs(v);
    }
}

void get()
{
    for(ll j=;j<=;j++)
      for(ll i=;i<=n;i++)
        fa[i][j]=fa[fa[i][j-]][j-],
        g[i][j]=g[i][j-]+g[fa[i][j-]][j-];
}

void dfs2(ll x)
{
    bool flag=false,opt=true;
    for(ll i=head[x];i;i=e[i].net)
    {
        ll v=e[i].v;
        if(v==fa[x][]) continue;
        flag=true;
        if(!has[v]) opt=false;
        dfs2(v);
    }
    if(flag && opt && x!=) has[x]=;
}

bool check(ll lim)
{
    init();
    for(ll i=; i<=m; i++)
    {
        ll u=a[i];
        ll tot=lim;
        for(ll j=; j>=; j--)
          if(g[u][j]<=tot&&fa[u][j]!=)
            tot-=g[u][j],u=fa[u][j];
        if(u==) b[++cnt].rest=tot,b[cnt].root=root[a[i]];
        else has[u]=;
    }
    dfs2();tot=;
    for(ll i=head[];i;i=e[i].net)
    {
        ll v=e[i].v;
        if(has[v]) continue;
        c[++tot].pos=v;c[tot].dis=e[i].w;
    }
    if(tot>cnt) return false;

    sort(b+,b+cnt+);sort(c+,c+tot+);
    ll now=;c[tot+].dis=0x3f3f3f3f;
    for(ll i=; i<=cnt; i++)
    {
        if(has[b[i].root]==)has[b[i].root]=;
        else
        {
            while(has[c[now].pos])now++;
            if(b[i].rest>=c[now].dis)has[c[now++].pos]=;
        }
        while(has[c[now].pos])now++;
    }
    return now>tot;
}

void solve()
{
    l=,r=;
    if(!check(r)){printf("-1");return;}
    while(l<=r)
    {
        mid=l+r>>;
        if(check(mid)) ans=mid,r=mid-;
        else l=mid+;
    }
}

int main()
{
    ll x,y,z;
    n=read();
    for(ll i=;i<n;i++)
    {
        x=read();y=read();z=read();
        add(x,y,z);add(y,x,z);
        if(x== || y==) num++;
    }
    m=read();
    for(ll i=;i<=m;i++) a[i]=read();
    if(num>m){printf("-1\n");return ;}
    dfs();get();solve();
    printf("%lld\n",ans);
    return ;
}