洛谷 2680[NOIP2015] 运输计划 二分+lca+树上差分+dfs序

题目：
https://www.luogu.org/problem/show?pid=2680

思路：
终于把noip2015最难的一道攻下来了（说的就跟你自己做的似的QAQ）；

满足最大值最小化，二分验证；

明确：这条边权为0的边一定在最长路上；

验证方法:

如果有一条边是所有>mid的路径的交并满足边权>=最大差值，那么这条边就是修虫洞的边（细细品味一下），因为删掉此边所有路程都<=mid；

so,记录一下每个边被路径经过的次数；

可以用二分+树剖(树状数组维护)强行做；
但是O(nlog^3n)，常数大？（当然，如果你以树的重心为根剖，再加上卡常，可能能过）；

怎么办？

好了，那么有请新同学——树上差分登场；
树上差分：。。。。

树上差分：
复杂度O(nlogn),完爆树剖O(nlog^3n),而且代码超级简单；
其实很简单，跟区间差分一样，不过要将lca-2；
然后统计dfs序，将树变为区间，按区间做就行了；

然后………………………………完了；

总结：
1.注意二分适用条件；
2.注意二分边界，因为结果可能为0，所以左边界设为-1；
3.差分要在dfs序上做；

#include<iostream>
#include<cstdio>
#include<algorithm>
#include<cstring>
using namespace std;
const int MAXN=600008;
int fst[MAXN],nxt[MAXN],num[MAXN],tmp[MAXN],dis[MAXN];
int deep[MAXN],top[MAXN],sz[MAXN],fa[MAXN],son[MAXN],dfn[MAXN];
int tot,n,m,l=-1,r,totp;
struct hh {int from,to,cost;}ss[MAXN];
struct edge {int from,to,lca,dis;}ma[MAXN];
void build(int f,int t,int c)
{
    tot++;
    ss[tot]=(hh){f,t,c};
    nxt[tot]=fst[f];
    fst[f]=tot;
    return;
}
void dfs1(int x,int f,int c)
{
    dfn[++totp]=x;
    fa[x]=f,deep[x]=deep[f]+1,sz[x]=1,dis[x]=c;
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ss[i].to;
        if(v==f) continue;
        num[v]=ss[i].cost;
        dfs1(v,x,c+ss[i].cost),sz[x]+=sz[v];
        if(!son[x] || sz[son[x]]<sz[v]) son[x]=v;
    }
    return;
}
void dfs2(int x,int st)
{
    top[x]=st;
    if(!son[x]) return;
    dfs2(son[x],st);
    for(int i=fst[x];i;i=nxt[i])
    {
        int v=ss[i].to;
        if(v==fa[x] || v==son[x]) continue;
        dfs2(v,v);
    }
    return;
}
int lca(int x,int y)
{
    int fx=top[x],fy=top[y];
    while(fx!=fy)
    {
        if(deep[fx]<deep[fy]) swap(fx,fy),swap(x,y);
        x=fa[fx],fx=top[x];
    }
    return deep[x]<deep[y]?x:y;
}
bool check(int ans)
{
    int lim=-1,cnt=0;
    memset(tmp,0,sizeof(tmp));
    for(int i=1;i<=m;i++)
    {
        if(ma[i].dis>ans)
        {
            tmp[ma[i].from]++,tmp[ma[i].to]++;
            tmp[ma[i].lca]-=2;
            lim=max(lim,ma[i].dis-ans);
            cnt++;
        }
    }
    if(!cnt) return true;
    for(int i=n;i>=1;i--) tmp[fa[dfn[i]]]+=tmp[dfn[i]];
    for(int i=2;i<=n;i++)
        if(num[i]>=lim && tmp[i]==cnt) return true;
    return false;
}
void solve()
{
    int x,y,z;
    scanf("%d%d",&n,&m);
    for(int i=1;i<n;i++)
    {
        scanf("%d%d%d",&x,&y,&z);
        build(x,y,z),build(y,x,z);
        r+=z;
    }
    dfs1(1,0,0),dfs2(1,1);
    for(int i=1;i<=m;i++)
    {
        scanf("%d%d",&x,&y);
        ma[i]=(edge){x,y,lca(x,y),dis[x]+dis[y]-2*dis[lca(x,y)]};
    }
    while(r-l>1)
    {
        int mid=(l+r)>>1;
        if(check(mid)) r=mid;
        else l=mid;
    }
    cout<<r;
    return;
}
int main()
{
    solve();
    return 0;
}