[树上倍增+二分答案][NOIP2012]运输计划

题目背景

公元 2044 年,人类进入了宇宙纪元。

题目描述

公元 2044 年，人类进入了宇宙纪元

L 国有 nn 个星球，还有 n-1n−1 条双向航道，每条航道建立在两个星球之间，这 n-1n−1 条航道连通了 LL 国的所有星球。

小 P 掌管一家物流公司， 该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从 u_iui​ 号星球沿最快的宇航路径飞行到 v_ivi​ 号星球去。显然，飞船驶过一条航道是需要时间的，对于航道 jj ，任意飞船驶过它所花费的时间为 t_jtj​ ，并且任意两艘飞船之间不会产生任何干扰。

为了鼓励科技创新， L 国国王同意小 P 的物流公司参与 L 国的航道建设，即允许小P 把某一条航道改造成虫洞，飞船驶过虫洞不消耗时间。

在虫洞的建设完成前小 P 的物流公司就预接了 mm 个运输计划。在虫洞建设完成后，这 mm 个运输计划会同时开始，所有飞船一起出发。当这 mm 个运输计划都完成时，小 P 的物流公司的阶段性工作就完成了。

如果小 P 可以自由选择将哪一条航道改造成虫洞， 试求出小 P 的物流公司完成阶段性工作所需要的最短时间是多少？

输入输出格式

输入格式：

第一行包括两个正整数 n, mn,m ，表示 L 国中星球的数量及小 P 公司预接的运输计划的数量，星球从 11 到 nn 编号。

接下来 n-1n−1 行描述航道的建设情况，其中第 ii 行包含三个整数 a_i, b_iai​,bi​ 和 t_iti​ ，表示第 ii 条双向航道修建在 a_iai​ 与 b_ibi​ 两个星球之间，任意飞船驶过它所花费的时间为 t_iti​ 。数据保证 1 leq a_i,b_i leq n1≤ai​,bi​≤n 且 0 leq t_i leq 10000≤ti​≤1000 。

接下来 mm 行描述运输计划的情况，其中第 jj 行包含两个正整数 u_juj​ 和 v_jvj​ ，表示第 jj 个运输计划是从 u_juj​ 号星球飞往 v_jvj​号星球。数据保证 1 leq u_i,v_i leq n1≤ui​,vi​≤n

输出格式：

输出文件只包含一个整数，表示小 P 的物流公司完成阶段性工作所需要的最短时间。

输入输出样例

输入样例：

6 3 
1 2 3 
1 6 4 
3 1 7 
4 3 6 
3 5 5 
3 6 
2 5 
4 5

输出样例：

11



二分移动所需的时间，在二分出的时间里用树上倍增检验能否实现
看了题解还是调到吐血，最后发现m放在n后面直接读入了..
代码：

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

const int Maxv = 50005; 
int Book[Maxv], Head[Maxv], f[Maxv][20], st[Maxv][20], Top[Maxv], Tdis[Maxv], q[Maxv], rnum, tail, cnt, n, m; 
bool lea[Maxv], vis[Maxv], fs; 

struct Node{
    int u, v, w, next; 
}e[Maxv << 2]; 

struct Army{
    int Rest, Top; 
}army[Maxv]; 

int read(){
    int x = 0, f = 1; 
    char ch = getchar(); 
    while (ch < '0' || ch > '9') {
        if (ch == '-') {
            f = -1; 
        }
        ch = getchar(); 
    }
    while (ch >= '0' && ch <= '9') {
        x = x * 10 + ch - '0'; 
        ch = getchar(); 
    }
    return x * f; 
}

void Add_Edge(int u, int v, int w){
    cnt++; 
    e[cnt].v = v; 
    e[cnt].w = w; 
    e[cnt].next = Head[u]; 
    Head[u] = cnt; 
}

void Add(int u, int v, int w){
    Add_Edge(u, v, w); 
    Add_Edge(v, u, w); 
}

inline bool Cmp(int a, int b){
    return a > b;   
}
inline bool Cmpmin(Army a, Army b){
    return a.Rest < b.Rest; 
}

inline bool Cmpmax(Army a, Army b){
    return a.Rest > b.Rest; 
}

void dfs(int u, int father){
    for (int i = Head[u]; i; i = e[i].next) {
        int v = e[i].v; 
        if (v == father) {
            continue; 
        }
        f[v][0] = u; 
        st[v][0] = e[i].w; 
        dfs(v, u); 
    }
}//预处理倍增

void RMQ(){
    for (int j = 1; j <= 18; j++) {
        for (int i = 1; i <= n; i++) {
            f[i][j] = f[ f[i][j - 1] ][j - 1]; 
            st[i][j] = st[i][j - 1] + st[ f[i][j - 1] ][j - 1]; 
        }
    }
}//预处理倍增

void dfs1(int u, int father, int topf, int dist){
    Top[u] = topf; 
    Tdis[u] = dist; 
    bool ft = false; 
    for (int i = Head[u]; i; i = e[i].next) {
        int v = e[i].v; 
        if (v == father) {
            continue; 
        }
        ft = true; 
        dfs1(v, u, topf, dist); 
    }
    if (!ft) {
        lea[u] = true; //标记叶子节点
    }
}

void dfs2(int u, int father){
    if (lea[u]) {
        fs = true; 
        return; 
    }
    for (int i = Head[u]; i; i = e[i].next) {
        int v = e[i].v; 
        if (v == father) {
            continue; 
        }
        else if (vis[v]) {
            continue; 
        }
        dfs2(v, u); 
        if (fs) {
            return; 
        }
    }
}

inline bool Look(int v){
    fs = false; 
    dfs2(v, f[v][0]); 
    return fs; 
}

inline bool judge(int mid){
    memset(vis, false, sizeof(vis)); 
    memset(q, 0, sizeof(q)); 
    memset(army, 0, sizeof(army)); 
    rnum = 0; 
    tail = 0; 
    for (int i = 1; i <= m; i++) {
        int tim = mid; 
        int now = Book[i]; 
        bool syst = false; 
        while (1) {
            for (int j = 18; j >= 0; j--) {
                if (f[now][j] && st[now][j] <= tim) {
                    tim -= st[now][j]; 
                    now = f[now][j];  //向上跳
                    break; 
                }
                if (j == 0 || now == 1) {
                    syst = true; 
                    break; //停止条件
                }
            }
            if (syst) {
                break; 
            }
        }
        if (now == 1) {
            army[++rnum].Top = Top[ Book[i] ]; 
            army[rnum].Rest = tim; 
        }
        else {
            vis[now] = true; 
        }
    }
    std::sort(army + 1, army + m + 1, Cmpmin); 
    for (int i = 1; i <= m; i++) {
        if (army[i].Rest < Tdis[ army[i].Top ]) {
            if (!vis[ army[i].Top ] && Look(army[i].Top)) {
                vis[ army[i].Top ] = true; 
                army[i].Rest = -1; 
            }
        }
    }
    std::sort(army + 1, army + m + 1, Cmpmax); 
    for (int i = Head[1]; i; i = e[i].next) {
        int v = e[i].v; 
        if (!vis[v] && Look(v)) {
            q[++tail] = e[i].w; 
        }
    }
    std::sort(q + 1, q + tail + 1, Cmp); 
    for (int i = 1; i <= tail; i++) {
        if (army[i].Rest < q[i]) {
            return false;
        }
    }
    return true; 
}

int main(){
    int u, v, w, R = 0, cnt1 = 0, Ans = 0; 
    n = read(); 
    
    for (int i = 1; i < n; i++) {
        u = read(); 
        v = read(); 
        w = read(); 
        Add(u, v, w); 
        R += w; 
    }
    dfs(1, 0); 
    for (int i = Head[1]; i; i = e[i].next) {
        int v = e[i].v; 
        dfs1(v, 1, v, e[i].w); 
    }
    RMQ(); 
    m = read(); 
    for (int i = 1; i <= m; i++) {
        Book[i] = read(); 
    }
    for (int i = Head[1]; i; i = e[i].next) {
        cnt1++; 
    }
    if (cnt1 > m) {
        printf("-1
"); 
        return 0; 
    }
    int L = 0; 
    while (L <= R) {
        int mid = (L + R) >> 1; 
        if (judge(mid)) {
            Ans = mid; 
            R = mid - 1;
        }
        else {
            L = mid + 1; 
        }
    }
    printf("%d
", Ans); 
    return 0; 
}