noip2015day2-运输计划

题目描述

公元$ 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$ 的物流公司完成阶段性工作所需要的最短时间是多少?

Input

第一行包括两个正整数 $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$ 号星球。

数据保证 $1≤u_i,v_i≤n,1<=n,m<=300000$

数据保证 $1≤a_i,b_i≤n$ 且 $0≤t_i≤1000$。

Output

输出共$1$行,包含$1$个整数,表示小$P$的物流公司完成阶段性工作所需要的最短时间。

Sample Input

Sample Output

首先，看到了最大值最小就很自然的想到了二分答案。

嗯，二分是很显然的。。。。

那么，我们该如何$check$呢？，对于两点间路径已经小于当前$x$的路径可以直接忽视掉。

那么剩下来的路径就是大于当前$x$的路径了，对于这些路径我们需要去掉一条边是所有的路径中最大值最小。

即，我们需要减去路径交集中最大的边。

这个操作是很显然的，因为只有减得越多才可以剩的越少。

现在，我们需要做的就是求出所有路径的交集了？

怎么求呢？我们可以利用树上差分来进行求解。

我们需要将边转换到点上，那么我们该如何转换呢？

由于一条边的节点一定是父亲节点和儿子节点之分。

而儿子节点所对应的边只有一条，所以我们将边转移到子节点上。

当加入一条路径$a,b$时，设$LCA$为$a,b$的$lca$，则$Sum[a]++,Sum[b]++,Sum[LCA]-=2$。

我们统计答案时若当前节点的$Sum$值为不满足条件的路径个数，说明该节点所对应的边为所有路径的交集，

更新答案即可。。。

最后看一下最长的路径减去路径上的最大值是否$<=$当前$x$即可。

不过这道题的数据较大，普通的算法容易被卡掉。

那么，我们就需要一些优化。。。

1.优化二分上下界：

$L=$最长的路径长度减去最大的边权，$R=$最长的路径长度。

这样二分的次数保证在$10$以内。

2.避免递归：

由于统计答案时，我们需要递归求解，而递归是有常数的，

我们又发现一个节点的值只和其子树有关,而子树在$dfs$序中时保证子节点编号大于根节点编号。

于是，我们可以利用$dfs$序倒着更新$Sum$值。

代码如下

#include <bits/stdc++.h>
using namespace std;
#define LL long long
#define reg register
#define Raed Read
#define debug(x) cerr<<#x<<" = "<<x<<endl;
#define rep(a,b,c) for(reg int a=(b),a##_end_=(c); a<=a##_end_; ++a)
#define ret(a,b,c) for(reg int a=(b),a##_end_=(c); a<a##_end_; ++a)
#define drep(a,b,c) for(reg int a=(b),a##_end_=(c); a>=a##_end_; --a)
#define erep(i,G,x) for(int i=(G).Head[x]; i; i=(G).Nxt[i])
inline char G1() {
    static const int LEN=2000005;
    static char U[LEN],*T=U,*E=U;
    if(T==E)T=U,E=U+fread(U,1,LEN,stdin);
    return T==E?EOF:*T++;
}
inline int Read(void) {
    int res=0,f=1;
    char c;
    while(c=G1(),c<48||c>57)if(c=='-')f=0;
    do res=(res<<3)+(res<<1)+(c^48);
    while(c=G1(),c>=48&&c<=57);
    return f?res:-res;
}
template<class T>inline bool Min(T &a,T const&b) {
    return a>b ?a=b,1:0;
}
template<class T>inline bool Max(T &a,T const&b) {
    return a<b?a=b,1:0;
}
const int N=3e5+5,M=3e5+5,mod=1e9+7;
bool MOP1;
int n,m,A[N],B[N],TT[M];
struct Link_list {
    int Tot,Head[N],to[M<<1],Nxt[M<<1],cost[M<<1];
    inline void clear(void) {
        Tot=0;
        memset(Head,0,sizeof Head);
    }
    inline void AddEdgepair(int a,int b,int c) {
        to[++Tot]=b,cost[Tot]=c,Nxt[Tot]=Head[a],Head[a]=Tot;
        to[++Tot]=a,cost[Tot]=c,Nxt[Tot]=Head[b],Head[b]=Tot;
    }
} G;
int Fa[M],dep[M],top[M],sz[M],son[M],Dis[M],LCA[N],cnt,Id[N];
void dfs1(int x,int f) {
    Id[++cnt]=x;
    dep[x]=dep[f]+1,Fa[x]=f,sz[x]=1;
    erep(i,G,x) {
        int y=G.to[i];
        if(y==f)continue;
        Dis[y]=Dis[x]+G.cost[i];
        TT[y]=G.cost[i];
        dfs1(y,x),sz[x]+=sz[y];
        if(sz[y]>sz[son[x]])son[x]=y;
    }
}
void dfs2(int x,int f) {
    top[x]=f;
    if(son[x])dfs2(son[x],f);
    else return;
    erep(i,G,x) {
        int y=G.to[i];
        if(y==Fa[x]||y==son[x])continue;
        dfs2(y,y);
    }
}
inline int lca(int x,int y) {
    while(top[x]!=top[y]) {
        if(dep[top[x]]>dep[top[y]])x=Fa[top[x]];
        else y=Fa[top[y]];
    }
    return dep[x]<dep[y]?x:y;
}
int res,tot,Sum[N];
inline bool check(int x) {
    res=-1,tot=0;
    rep(i,1,n)Sum[i]=0;
    rep(i,1,m) {
        if(Dis[A[i]]+Dis[B[i]]-2*Dis[LCA[i]]<=x)continue;
        tot++,Sum[A[i]]++,Sum[B[i]]++,Sum[LCA[i]]-=2;
    }
    drep(i,n,1) {
        int u=Id[i];
        erep(i,G,u) {
            int y=G.to[i];
            if(y==Fa[u])continue;
            Sum[u]+=Sum[y];
        }
        if(Sum[u]==tot)Max(res,TT[u]);
    }
    if(res==-1)return false;
    rep(i,1,m) {
        if(Dis[A[i]]+Dis[B[i]]-2*Dis[LCA[i]]<=x)continue;
        if(Dis[A[i]]+Dis[B[i]]-2*Dis[LCA[i]]-res>x)return false;
    }
    return true;
}
int Ma;
inline void solve(void) {
    int L=0,R=0,Ans=0;
    rep(i,1,m)Max(R,Dis[A[i]]+Dis[B[i]]-2*Dis[LCA[i]]);
    L=R-Ma;
    while(L<=R) {
        int mid=(L+R)>>1;
        if(check(mid))Ans=mid,R=mid-1;
        else L=mid+1;
    }
    printf("%d\n",Ans);
}
bool MOP2;
inline void _main(void) {
    n=Read(),m=Read();
    int f=1;
    ret(i,1,n) {
        int a=Read(),b=Read(),c=Read();
        Max(Ma,c),G.AddEdgepair(a,b,c);
    }
    dfs1(1,0),dfs2(1,1);
    rep(i,1,m)A[i]=Read(),B[i]=Read(),LCA[i]=lca(A[i],B[i]);
    solve();
}
signed main() {
    _main();
    return 0;
}