noip2015 运输计划

题目描述 Description

公元 2044 年，人类进入了宇宙纪元。L 国有 n 个星球，还有 n−1 条双向航道，每条航道建立在两个星球之间，这 n−1 条航道连通了 L 国的所有星球。小 P 掌管一家物流公司， 该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从 ui 号星球沿最快的宇航路径飞行到 vi 号星球去。显然，飞船驶过一条航道是需要时间的，对于航道 j，任意飞船驶过它所花费的时间为 tj，并且任意两艘飞船之间不会产生任何干扰。为了鼓励科技创新， L 国国王同意小 P 的物流公司参与 L 国的航道建设，即允许小P 把某一条航道改造成虫洞，飞船驶过虫洞不消耗时间。在虫洞的建设完成前小 P 的物流公司就预接了 m 个运输计划。在虫洞建设完成后，这 m 个运输计划会同时开始，所有飞船一起出发。当这 m 个运输计划都完成时，小 P 的物流公司的阶段性工作就完成了。如果小 P 可以自由选择将哪一条航道改造成虫洞， 试求出小 P 的物流公司完成阶段性工作所需要的最短时间是多少?

输入描述 Input Description

第一行包括两个正整数 n,m，表示 L 国中星球的数量及小 P 公司预接的运输计划的数量，星球从 1 到 n 编号。接下来 n−1 行描述航道的建设情况，其中第 i 行包含三个整数 ai,bi 和 ti，表示第 i 条双向航道修建在 ai 与 bi 两个星球之间，任意飞船驶过它所花费的时间为 ti。数据保证 1<=ai,bi<=n 且 0<=ti<=1000。接下来 m 行描述运输计划的情况，其中第 j 行包含两个正整数 uj 和 vj，表示第 j 个运输计划是从 uj 号星球飞往 vj号星球。数据保证 1<=ui,vi<=n

输出描述 Output Description

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

样例输入 Sample Input

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

样例输出 Sample Output

11

数据范围及提示 Data Size & Hint

样例解释:
将第 1 条航道改造成虫洞： 则三个计划耗时分别为：11,12,11，故需要花费的时间为 12。
将第 2 条航道改造成虫洞： 则三个计划耗时分别为：7,15,11，故需要花费的时间为 15。
将第 3 条航道改造成虫洞： 则三个计划耗时分别为：4,8,11，故需要花费的时间为 11。
将第 4 条航道改造成虫洞： 则三个计划耗时分别为：11,15,5，故需要花费的时间为 15。
将第 5 条航道改造成虫洞： 则三个计划耗时分别为：11,10,6，故需要花费的时间为 11。
故将第 3 条或第 5 条航道改造成虫洞均可使得完成阶段性工作的耗时最短，需要花费的时间为 11。

测试数据及约定:

95%: n, m <= 100000
100%:n, m <= 300000
有40%的数据成一条链

题解

预处理每个计划的LCA以及路径长。然后二分答案，然后判断可行性，判断时并不会什么树剖之类的高级算法，所以用了gty讲课时提到的树上前缀和。设有x个计划比二分的答案要长，对于每一个这样的计划，起点与终点打上+1的前缀和标记，LCA上打上-2的前缀和标记。然后dfs一遍合并标记，找出所有标记数量等于x的点（对应其上面的那条边）中边权最大的，将最长计划减去它的长度。若小于二分的答案，则代表此二分的答案可行，否则不行。
因为卡常LCA并且我太弱了不会tarjan，所以下面的代码是95分的。
另外，用对数组的差分可以在10分钟内拿到在链上的40分。

代码

#include<cstdio>
#include<cstring>
#include<algorithm>
#include<iostream>
#define maxn 600500
using namespace std;

struct Edge{
    int u, v, w;
    int next;
}e[maxn];

struct Plan{
    int len, lca;
    int x, y;
}c[maxn]; 

long long n, m, k, WW;
int d[maxn], book[maxn], p[maxn];
int st[maxn][30], a[maxn], fi[maxn];
long long st_len[maxn][30];

bool cmp(Plan a, Plan b) {
    return a.len > b.len;
}

void add_edge(int u, int v, int w, int i) {
    e[i].u = u, e[i].v = v, e[i].w = w;
    e[i].next = fi[u], fi[u] = i;
}

void build_tree(int x, int fa, int dep) {
    d[x] = dep;
    p[x] = fa;
    for(int i = fi[x]; i != -1; i = e[i].next) {
        int v = e[i].v;
        if(v != fa) {
            build_tree(v, x, dep+1);
            st_len[v][0] = e[i].w;
        }
    }
}

void lca_maker() {
    for(int i = 1; i <= n; i++)
        st[i][0] = p[i];
    for(int j = 1; j < 21; j++)
        for(int i = 1; i <= n; i++) {
            st[i][j] = st[st[i][j-1]][j-1];
            st_len[i][j] = st_len[i][j-1] + st_len[st[i][j-1]][j-1];
        }
}

int lca(int x, int y, int i) {
    int ans = 0;
    for(int j = 21; j >= 0; j--)
        if(d[st[x][j]] >= d[y]) {
            ans += st_len[x][j];
            x = st[x][j];       
        }
    for(int j = 21; j >= 0; j--)
        if(st[x][j] != st[y][j]) {
            ans += (st_len[x][j] + st_len[y][j]);
            x = st[x][j], y = st[y][j];
        }
    if(x != y) {
        ans += (st_len[x][0] + st_len[y][0]);
        x = st[x][0];
    }
    c[i].len = ans;
    return x;
}

int dfs(int x, int fa) {
    int Now = 0;
    for(int i = fi[x]; i != -1; i = e[i].next) {
        int v = e[i].v;
        if(v != fa)
            Now += dfs(v, x);
    }
    Now += book[x];
    if(Now == k && WW < st_len[x][0]) {
        WW = st_len[x][0];
    }
    return Now;
}

int main() {
    cin >> n >> m;
    for(int i = 0; i <= n; i++) 
        fi[i] = -1, d[i] = -1;
    for(int i = 1; i < n; i++) {
        int u, v, w;
        scanf("%d%d%d", &u, &v, &w);
        add_edge(u, v, w, i);
        add_edge(v, u, w, i+n); 
    }
    build_tree(1, -1, 1);
    lca_maker();
    for(int i = 1; i <= m; i++) {
        scanf("%d%d", &c[i].x, &c[i].y);
        if(d[c[i].x] < d[c[i].y]) {
            int cc = c[i].x;
            c[i].x = c[i].y;
            c[i].y = cc;
        } 
        c[i].lca = lca(c[i].x, c[i].y, i);
    }
    sort(c+1, c+1+m, cmp);
    long long l = 1, r = 2147483647;
    while(1) {
        k = 0, WW = 0;
        memset(book, 0, sizeof(book));
        int M = l + (r-l)/2;
        if(l == r) {
            cout << l << endl;
            return 0;
        }
        for(int i = 1; i <= m; i++) {
            if(c[i].len > M) {
                book[c[i].x] += 1;
                book[c[i].y] += 1;
                book[c[i].lca] -= 2;
                k++;
            }
        }
        if(k != 0) dfs(1, -1);
        if(c[1].len - WW <= M) //当前解可行 
            r = M;
        else
            l = M+1;
    }
}