运输计划洛谷P2680-CSDN博客

题目链接

题目描述

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

输入输出格式

输入格式:

第一行包括两个正整数 $n, m$，表示 L 国中星球的数量及小 P 公司预接的运输计划的数量，星球从 $1$ 到 $n$ 编号
接下来 $n-1$ 行描述航道的建设情况，其中第 $i$ 行包含三个整数 $a_i, b_i$ 和 $t_i$，表示第 $i$ 条双向航道修建在 $a_i$ 与 $b_i$ 两个星球之间，任意飞船驶过它所花费的时间为 $t_i$。
接下来 $m$ 行描述运输计划的情况，其中第 $j$ 行包含两个正整数 $u_j$ 和 $v_j$，表示第 $j$ 个运输计划是从 $u_j$ 号星球飞往 $v_j$号星球。

输出格式:

一个整数，表示小 $P$ 的物流公司完成阶段性工作所需要的最短时间。

数据范围:

样例

样例一输入:

样例一输出:

思路

1.二分,树上差分

首先预处理所有运输计划首末两点的lca和距离,然后按距离长短降序排列
二分所需的最短时间为h
显然,被修改的航道一定被所有距离大于h的路径覆盖
那么就转化成了一道树上差分裸题
维护全局变量 $ mx $ 表示满足上述条件的路径的最大值
dfs回溯时统计即可

#include <algorithm>
#include <iostream>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <queue>
#include <list>
#include <map>

#define ll long long
#define ull unsigned long long

using namespace std;

const int mx_n = 300010;
int n,m,st;
int dep[mx_n];
int num[mx_n];
int fa[mx_n][21],le[mx_n][21];
int h[mx_n],to[mx_n<<1],nx[mx_n<<1],w[mx_n<<1],cnt;

struct stu {
    int u,v,lca;
    int le;
    bool operator < (const stu&a)const {
        return le > a.le;
    }
} a[mx_n];

struct io
{
    char op[10000000],* s;
    io(){fread(s=op,1,1<<26,stdin);}
    inline int read()
    {
        register int u = 0;
        while(*s<48) s++;
        while(*s>32)
            u=u*10+* s++ -48;
        return u;
    }
} ip;
#define read ip.read

inline void add(int f,int t,int co) {
    nx[++cnt] = h[f]; h[f] = cnt; to[cnt] = t; w[cnt] = co;
    nx[++cnt] = h[t]; h[t] = cnt; to[cnt] = f; w[cnt] = co;
}

void dfs(int x) {
    for(int i = h[x]; i; i = nx[i])
        if(to[i] != fa[x][0]) {
            le[to[i]][0] = w[i];
            fa[to[i]][0] = x;
            dep[to[i]] = dep[x] + 1;
            dfs(to[i]);
        }
}

inline void LCA_1(int m) {
    int tmp = 0;
    int x = a[m].u,y = a[m].v;
    if(dep[x] < dep[y]) swap(x,y);
    for(int i =20; i >= 0; i--)
        if(dep[fa[x][i]] >= dep[y]) {
            tmp += le[x][i];
            x = fa[x][i];
        }
    if(x == y) {
        a[m].le = tmp;
        a[m].lca = x;
        return;
    }
    for(int i =20; i >= 0; i--)
        if(fa[x][i] != fa[y][i]) {
            tmp += le[x][i] + le[y][i];
            x = fa[x][i];
            y = fa[y][i];
        }
    tmp += le[x][0] + le[y][0];
    a[m].le = tmp;
    a[m].lca = fa[x][0];
}

inline int deal(int x,const int&bs) {
    int now = num[x];num[x] = 0;
    for(int i = h[x]; i; i = nx[i])
        if(to[i] != fa[x][0]) {
            now += deal(to[i],bs);
        }
    if(now == bs) st = max(st,le[x][0]);
    return now;
}

bool check(int x) {
    st = 0;int i;
    for(i = 1; i <= m && a[i].le > x; i++) {
        num[a[i].u]++;
        num[a[i].v]++;
        num[a[i].lca] -= 2;
    }
    if(i == 1) return true;
    deal(1,i-1);
    return x >= a[1].le - st;
}

int main() {
    int aa,b,c;
    n = read(),m = read();
    for(int i = 1; i < n; i++) {
        aa = read(),b = read(), c = read();
        add(aa,b,c);
    }
    fa[1][0] = 1;
    dfs(1);
    for(int i = 1; i <=20; i++)
        for(int j = 1; j <= n; j++) {
            fa[j][i] = fa[fa[j][i-1]][i-1];
            le[j][i] = le[j][i-1] + le[fa[j][i-1]][i-1];
        }
            
    for(int i = 1; i <= m; i++) {
        a[i].u = read(),a[i].v = read();
        LCA_1(i);
    }
    sort(a+1,a+1+m);
    // for(int i = 1; i <= m; i++)
    //     printf("%lld\n",a[i].le);
    int l = 1,r = a[1].le,ans;
    while(l <= r) {
        int mid = (l+r) >> 1;
        if(check(mid)) {
            ans = mid;
            r = mid - 1;
        } else l = mid + 1;
    }
    printf("%d\n", ans);
}

转载于:https://www.cnblogs.com/ullio/p/9866383.html