NOIP 2012 疫情控制

疫情控制2012年NOIP全国联赛提高组

题目描述：

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

也是树中的根节点。

H 国的首都爆发了一种危害性极高的传染病。当局为了控制疫情，不让疫情扩散到边境

城市（叶子节点所表示的城市），决定动用军队在一些城市建立检查点，使得从首都到边境

城市的每一条路径上都至少有一个检查点，边境城市也可以建立检查点。但特别要注意的是，

首都是不能建立检查点的。

现在，在 H国的一些城市中已经驻扎有军队，且一个城市可以驻扎多个军队。一支军

队可以在有道路连接的城市间移动，并在除首都以外的任意一个城市建立检查点，且只能在

一个城市建立检查点。一支军队经过一条道路从一个城市移动到另一个城市所需要的时间等

于道路的长度（单位：小时）。

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

输入描述：

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

接下来的 n-1 行，每行 3 个整数，u、v、w，每两个整数之间用一个空格隔开，表示从

城市 u 到城市 v 有一条长为 w 的道路。数据保证输入的是一棵树，且根节点编号为 1。

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

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

的城市的编号。

输出描述：

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

样例输入：

4 

1 2 1 

1 3 2 

3 4 3 

2 

2 2 

样例输出：

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。

首先来分析题意：给定一棵树，用军队来割去一些点。每个军队有初始位置，每条边有边权，

军队移动的时间等于走过的路径长度。求切断所有叶子节点与根节点的连接最短需要多长时间。

直接求整个问题的答案感觉无从下手，但是我们会发现一些性质：

一个深度小的点，控制的叶子节点一定不会少于一个深度大的点（同一子树中）。

这样，会发现在时间给定的情况下，根据上面的贪心，每支军队的移动策略其实很容易可以确定

　　————尽可能的走向深度小的节点以控制更多叶子节点。

这样一来，我们可以通过二分答案+检验来解决此题。那么关键就是怎么检验了

想清楚这样一件事：

封锁一个节点的效果，可以转换成，封锁他所有的子节点

由于根节点不能封锁，所以我们将问题转换为，封锁所有根节点的直系儿子

（同理，封锁一个根节点的直系儿子，可以转换成封锁这一儿子的所有儿子）

然后我们按照以上贪心策略来移动军队时，可以把军队分为两类：

1，在规定时间内不能到达根的军队

2，在规定时间内可以到达根的军队

对于第一种军队，最优的位置是一直往上走，最终停下的位置。

对于第二种军队，他又可以有两种选择：

1，到达根节点的直系儿子之后，不再移动，封锁那一节点

2，移动到根节点，并且再往下走，封锁其他节点

先来考虑比较简单的第一种军队，由于第一种军队的最优策略可以直接确定

那我们便按照最优策略进行，然后，如果有一些二层的节点（根的直系儿子）

被这些军队控制（如上面所说，不一定是直接到这个节点控制）了的话，那以后便可以不必考虑这些二层的点

我们要考虑的其实是：如何调度第二类军队，去封锁还没有被控制的二层节点

到这里，我们又可以贪心啦！

能到达根的军队必然会有剩余的时间，我们只要贪心的让剩余时间小的，去控制更近的二层点就好了。

也就是用能控制一个二层的点的剩余时间最少的军队，去控制这个点。

这里还有一个细节：能到达根的军队，如果他来自那个二层节点没有被控制的话，应该让这支军队留在那个二层节点

　　　　　　　　　不然我们必然要花费另一剩余时间长的军队来控制他，这样不够优。

最后的问题，怎样移动军队，找到军队的位置呢？倍增就可以解决了。

下面贴代码

#include<iostream>
#include<cstdio>
#include<cstring>
#include<algorithm>

#define RI register int
using namespace std;
typedef long long ll;

const int INF = 1e9 + 7;
const int MAXN = 50000 + 5;

#define max(a,b) ((a) > (b) ? (a) : (b))
#define min(a,b) ((a) < (b) ? (a) : (b))

inline void read(int &x)
{
    x = 0;
    bool flag = 0;
    char ch = getchar();
    while(ch < '0' || ch > '9')
    {
        if(ch == '-')    flag = 1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    if(flag)    x *= -1;
}

inline void read(ll &x)
{
    x = 0;
    bool flag = 0;
    char ch = getchar();
    while(ch < '0' || ch > '9')
    {
        if(ch == '-')    flag = 1;
        ch = getchar();
    }
    while(ch >= '0' && ch <= '9')
    {
        x = x * 10 + ch - '0';
        ch = getchar();
    }
    if(flag)    x *= -1;
}

struct edge
{
    int f,t;
    ll v;
    edge(int _f,int _t,ll _v)
    {f = _f,t = _t,v = _v;}
    edge(){}
}l[MAXN << 1];

ll v,rs;
int n,m,u,t;
int first[MAXN],next[MAXN << 1],tot;

ll f[MAXN][21];
int g[MAXN][21],army[MAXN];
//f[i][j]表示点i向上跳2^j的父亲
//g[i][j]表示点i跳到向上2^j步的父亲的距离 

int rtson,rch[MAXN];
//存储根节点的直系儿子 
int cancover[MAXN],son[MAXN],from[MAXN];
//cancover[i]表示覆盖点i是否等价于覆盖i向上到达的根的直系儿子，也就是是否i到二层节点只有一条路径
//son[i]表示i的儿子的数量
//from[i]表示i点向上跳到的二层节点是谁 

inline void build(int f,int t,ll v)
{
    l[++ tot] = edge(f,t,v);
    next[tot] = first[f];
    first[f] = tot;
}

void init()
{
    tot = 0,rtson = 0,rs = 0;
    memset(first,-1,sizeof(first));
    read(n);
    for(RI i = 1;i < n;i ++)
    {
        read(u),read(t),read(v);
        build(u,t,v),build(t,u,v),rs += v;
    }
    read(m);
    for(RI i = 1;i <= m;i ++)
        read(army[i]);
}

void init_dfs(int u)
{ 
    if(g[u][0] == 1)    from[u] = u;
    else from[u] = from[g[u][0]];
    for(int i = first[u];i != -1;i = next[i])
    {
        int v = l[i].t;
        if(u == 1)
            rch[++ rtson] = v;
        if(v == g[u][0])
            continue;
        son[u] ++;
        g[v][0] = u;
        f[v][0] = l[i].v;
        init_dfs(v);
    }
}

void dfs(int u)
{
    cancover[u] = 1;
    if(son[u] > 1)    return;
    for(int i = first[u];i != -1;i = next[i])
        if(l[i].t != g[u][0])
            dfs(l[i].t);
}

void init_cancover()
{
    for(int i = 1;i <= rtson;i ++)
        dfs(rch[i]);
}

void init_rmq_fg()
{
    for(int j = 1;j <= 20;j ++)
        for(int i = 1;i <= n;i ++)
        {
            g[i][j] = g[g[i][j - 1]][j - 1];
            f[i][j] = f[i][j - 1] + f[g[i][j - 1]][j - 1];
        }
}

ll lim;
int cnt1,cnt2;
//分别表示可调度军队数量，未被控制的城市数量 
int pos[MAXN],resdis[MAXN],cover[MAXN];
//pos[i]表示军队i最终的位置，resdis[i]表示到达根的军队还能走的距离
//cover[i]表示城市i是否被覆盖 

void work(int u)
{
    ll tmp = lim;
    pos[u] = army[u];
    for(int i = 20;i >= 0;i --)
    {
        if(f[pos[u]][i] <= tmp && g[pos[u]][i] != 0)
        {
            tmp -= f[pos[u]][i];
            pos[u] = g[pos[u]][i];
        }
    }
    resdis[u] = tmp;
}

struct ARMY
{
    int resdis,from;
    bool operator < (const ARMY &a) const
    {
        return resdis < a.resdis;
    }
}A[MAXN];

struct CITY
{
    int id,d;
    bool operator < (const CITY &a) const
    {
        return d < a.d;
    }
}B[MAXN];

bool check(ll mid)
{
    memset(cover,0,sizeof(cover));
    lim = mid,cnt1 = cnt2 = 0;
    for(int i = 1;i <= m;i ++)
    {
        work(i);
        if(pos[i] != 1)
        {
            if(cancover[pos[i]])
                cover[from[pos[i]]] = 1;
        }
        else
        {
            cnt1 ++;
            A[cnt1].resdis = resdis[i];
            A[cnt1].from = from[army[i]]; 
        }
    }
    for(int i = 1;i <= rtson;i ++)
    {
        if(!cover[rch[i]])
        {
            cnt2 ++;
            B[cnt2].id = rch[i];
            B[cnt2].d = f[rch[i]][0];
        }
    }
    if(cnt2 > cnt1)    return 0;
    int i = 1,j = 1;
    sort(A + 1,A + cnt1 + 1);
    sort(B + 1,B + cnt2 + 1);
    while(i <= cnt1)
    {
        if(!cover[A[i].from])
            cover[A[i].from] = 1;
        else
        {
            while(j <= cnt2 && cover[B[j].id])    j ++;
            if(B[j].d <= A[i].resdis) cover[B[j].id] = 1,j ++;
        }
        i ++;
    }
    for(int i = 1;i <= cnt2;i ++)
        if(!cover[B[i].id])    return 0;
    return 1;
}

ll solve()
{
    ll l = 0,r = rs,mid;
    while(r - l > 1)
    {
        mid = (l + r) >> 1;
        if(check(mid))
            r = mid;
        else
            l = mid;
    }
    if(check(l))    return l;
    return r;
}

int main()
{
    init();
    init_dfs(1);
    if(rtson > m)
    {puts("-1");return 0;}
    init_cancover();
    init_rmq_fg();
    printf("%lld
",solve());
    return 0;
}