NOIP2015D2T3-运输计划

问题描述

公元 2044 年，人类进入了宇宙纪元。
L 国有 nn 个星球，还有 n-1n−1 条双向航道，每条航道建立在两个星球之间，这 n-1n−1 条航道连通了 LL 国的所有星球。
小 P 掌管一家物流公司， 该公司有很多个运输计划，每个运输计划形如：有一艘物流飞船需要从 ui​号星球沿最快的宇航路径飞行到 vi号星球去。显然，飞船驶过一条航道是需要时间的，对于航道 jj ，任意飞船驶过它所花费的时间为 tj，并且任意两艘飞船之间不会产生任何干扰。
为了鼓励科技创新， L 国国王同意小 P 的物流公司参与 L 国的航道建设，即允许小 P 把某一条航道改造成虫洞，飞船驶过虫洞不消耗时间。
在虫洞的建设完成前小 P 的物流公司就预接了 m 个运输计划。在虫洞建设完成后，这 m 个运输计划会同时开始，所有飞船一起出发。当这 m 个运输计划都完成时，小 P 的物流公司的阶段性工作就完成了。
如果小 P 可以自由选择将哪一条航道改造成虫洞， 试求出小 P 的物流公司完成阶段性工作所需要的最短时间是多少？
输入格式
第一行包括两个正整数n,m ，表示 L 国中星球的数量及小 P 公司预接的运输计划的数量，星球从 1 到 n 编号。
接下来 n−1 行描述航道的建设情况，其中第 i行包含三个整数 $a_i, b_i$和 ti，表示第 i 条双向航道修建在 ai与 bi两个星球之间，任意飞船驶过它所花费的时间为 ti。数据保证$1 \leq a_i,b_i \leq n且 0 \leq t_i \leq 1000$
接下来 m 行描述运输计划的情况，其中第 j 行包含两个正整数 uj 和 vj ，表示第 j 个运输计划是从 uj号星球飞往 vj号星球。数据保证$1 \leq u_i,v_i \leq 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

思路分析

n个节点, n-1条边,保证连通,一看就知道是一棵树,再看看这是道紫题,又看了一下是求什么两点距离的,那么八成就能估计出是lca的题了,然后再想想这道题可能用倍增更舒服,但是想想树剖打着也挺顺手了那么也可以来个树剖
求两点间距离应该要用一下树的某种性质： dis[i,j]=dis[1,i]+dis[1,j]-2*dis[1,lca(i,j)]
这道题中要求输出的就是一个最短时间,再加上时间的单调性可以非常显然的看出答案是可以二分的
二分的时候先找出 m 条路径中距离大于 mid 的所有路径,然后找到他们的最长公共边(按照题意只能有一条边可以改成虫洞), 再用最长的路径减去最长公共边,如果结果大于 mid 则代表在 mid 时间内可以完成任务
但是这里要解释一下4：为什么在找出路径长度大于 mid 的路径后要找到他们的最长 公共 边？ 为什么一定要是公共的？ 呃… 这不是很显然吗？如果找出的最长边不是公共的,那么必然有一条距离大于 mid 的路径没有被缩短过,那么也就不满足条件了

#include<algorithm>
#include<iostream>
#include<cstdio>
#define max(a,b) ((a)>(b)?(a):(b))
#define rint register int
using namespace std;
const int M=3e5+100;
const int inf=1e9;
inline int read(){
    int x=0,f=1; char c=getchar();
    for(;!isdigit(c);c=getchar()) if(c=='-') f=-1;
    for(;isdigit(c);c=getchar()) x=x*10+c-'0';
    return x*f;
}
int n,m,tim,pat;
int head[M],dis[M],cost[M],dp[M],vis[M];
// head你懂的  dis[i]指从根到节点 i 的路程, cost[i] 指节点 i 的父节点到达它的路程 , dp用于树上差分, vis用于check记忆化优化 
int f[M],son[M],siz[M],dep[M],top[M],dfn[M],wrh[M];
// f 、son 、siz 不解释 , dfn[i] 节点 i 的时间戳 dep[i] wrh[i]指向时间戳为 i 的节点的cost,可与dfn互逆 top不解释你懂的 
struct Edge{
    int to,val,next;
}e[M<<1];
struct query{  //记录询问,之后要按 len 用 sort 排序保证 query 的单调递减 
    int x,y,len;
}q[M];
inline void add(int u,int v,int c){
    e[++pat].to=v, e[pat].val=c;
    e[pat].next=head[u], head[u]=pat;
}
inline bool cmp(query x, query y)
{ return x.len > y.len; }
void dfs(int u){
    siz[u]=1;
    for(rint i=head[u];i;i=e[i].next){
        rint v=e[i].to,w=e[i].val;
        if(v!=f[u]){
            dep[v]=dep[u]+1, f[v]=u,dis[v]=dis[u]+w;
            cost[v]=w, dfs(v), siz[u]+=siz[v];
            if(siz[v]>siz[son[u]]) son[u]=v;
        }
    }
}
void dfs_(int u){
    dfn[u]=++tim,wrh[tim]=cost[u];
    if(!top[u]) top[u]=u;
    if(son[u]) top[son[u]]=top[u], dfs_(son[u]);
    for(rint i=head[u];i;i=e[i].next){
        rint v=e[i].to;
        if(v!=f[u] && v!=son[u]) dfs_(v);
    }
}
inline int LCA(int u,int v){
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u , v);
        u=f[top[u]];
    }
    return dep[u]<dep[v]? u:v;
}
inline void work(int u,int v){ //差分部分 
    while(top[u]!=top[v]){
        if(dep[top[u]]<dep[top[v]]) swap(u , v);
        ++dp[dfn[top[u]]],--dp[dfn[u]+1];
        u=f[top[u]];
    }
    if(u==v) return ;
    if(dep[u]>dep[v]) swap(u , v); //这里不用解释吧? 
    ++dp[dfn[u]+1], --dp[dfn[v]+1]; //注意是 dfn[u]+1,避免差分时算入 u 和 v 的 LCA 的 cost值 
}
inline int check(int tim){
    int num=0;
    while(q[num].len>tim) ++num;
    if(vis[num]) return vis[num];
    for(int i=1;i<=n;++i) dp[i]=0; 
    for(rint i=0;i<num;++i)
        work(q[i].x , q[i].y);
    int tot=0,mx=0;
    for(rint i=1;i<=n;++i){
        tot+=dp[i];
        if(tot==num) mx=max(mx , wrh[i]);
    }
    return vis[num]=mx;
}
int main(){
    n=read(), m=read();
    for(rint i=1;i<n;++i){
        rint x=read(), y=read(), w=read();
        add(x , y , w), add(y , x , w);
    }
    dep[1]=1, dfs(1), dfs_(1);
    for(rint i=0;i<m;++i){
        int x=read(),y=read(); q[i].x=x, q[i].y=y;
        q[i].len=dis[x]+dis[y]-(dis[LCA(x,y)]<<1);
        //from 要点2
    }
    sort(q , q+m , cmp); //保证 m 条路径单调递减
    rint L=0, R=q[0].len;
    while(L<=R){ //二分答案不解释
        int mid=L+R>>1;
        if(q[0].len-check(mid)>mid) L=mid+1;
        else R=mid-1;
    }
    printf("%d\n",L);
    return 0;
}