NOIP2015 运输计划 (树上差分+二分答案)

题目大意：给你一颗树，你可以把其中一条边的边权改成0，使给定的一些树链的权值和的最大值最小

把lenth定义为未修改边权时的答案

考虑二分答案，如果二分的答案成立，设修改成0的边边权为k，那么所有原链长>mid的链都要被这条边影响，显然这些链存在边权为k的公共边

那么我们二分出一个答案，然后把所有原链长>mid的链在树上打差分来记录每条边被覆盖多少次

如果某条边的满足lenth-边权<=mid 且 这条边被覆盖次数==原链长>mid的链数，说明这条边作为0边可行。

会卡常，据说树剖不会被卡但我用了结果还是被卡了。懒得优化了

#include <cstdio>
#include <algorithm>
#include <cstring>
#define N 300100
using namespace std;

int n,m,cte,mxl,cnt,lth,ct,idd;
int head[N],sz[N],tp[N],hvy[N],fa[N],dep[N],dif[N],sum[N],d[N],dis[N];
struct EDGE{
    int to,nxt,val;
}edge[N*2];
struct FLY{
    int x,y,ff,len;
}fly[N];
void edge_add(int u,int v,int w)
{
    cte++;
    edge[cte].to = v;
    edge[cte].nxt= head[u];
    edge[cte].val= w;
    head[u]=cte;
}
int gc()
{
    int rett=0,fh=1;char p=getchar();
    while(p<'0'||p>'9') {p=getchar();}
    while(p>='0'&&p<='9') {rett=rett*10+p-'0';p=getchar();}
    return rett*fh;
}
void dfs_order1(int u,int dad)
{
    int h=0,id=0;
    for(int j=head[u];j!=-1;j=edge[j].nxt)
    {
        int v=edge[j].to;
        if(v==dad) continue;
        dis[v]=dis[u]+edge[j].val;
        dep[v]=dep[u]+1;
        dfs_order1(v,u);
        d[v]=edge[j].val;
        fa[v]=u;
        if(sz[v]>h) h=sz[v],id=v;
        sz[u]+=sz[v];
    }
    sz[u]++;
    if(head[u]==-1) return;
    hvy[u]=id;
}
void dfs_order2(int u,int dad,int tpp)
{
    tp[u]=tpp;
    if(hvy[u]) tp[hvy[u]]=tp[u],dfs_order2(hvy[u],u,tpp);
    for(int j=head[u];j!=-1;j=edge[j].nxt)
    {
        int v=edge[j].to;
        if(v==dad||v==hvy[u]) continue;
        dfs_order2(v,u,v);
    }
}
void dfs_maxlenth(int u,int dad)
{
    sum[u]+=dif[u];
    for(int j=head[u];j!=-1;j=edge[j].nxt)
    {
        int v=edge[j].to;
        if(v==dad) continue;
        dfs_maxlenth(v,u);
        sum[u]+=sum[v];
    }
    if(sum[u]>=ct&&d[u]>mxl) idd=u,mxl=d[u];
}
int LCA(int x,int y)
{
    while(tp[x]!=tp[y])
    {
        if(dep[tp[x]]<dep[tp[y]]) swap(x,y);
        x=fa[tp[x]];
    }
    return dep[x]<=dep[y]?x:y;
}
bool check(int mid)
{
    memset(sum,0,sizeof(sum));
    mxl=0,ct=0;;
    for(int i=1;i<=m;i++) 
        if(fly[i].len>mid)
        {
            sum[fly[i].x]++,sum[fly[i].y]++;
            sum[fly[i].ff]-=2;
            ct++;
        }
    dfs_maxlenth(1,-1);
    if(lth-mxl<=mid) return 1;
    else return 0;
}

int main()
{
    //freopen("testdata.in","r",stdin);
    scanf("%d%d",&n,&m);
    memset(head,-1,sizeof(head));
    int x,y,z;
    for(int i=1;i<n;i++)
    {
        x=gc(),y=gc(),z=gc();
        edge_add(x,y,z);
        edge_add(y,x,z);
    }
    dfs_order1(1,-1);
    tp[1]=1;
    dfs_order2(1,-1,1);
    lth=0;
    for(int i=1;i<=m;i++)
    {
        fly[i].x=gc(),fly[i].y=gc();
        fly[i].ff=LCA(fly[i].x,fly[i].y);
        fly[i].len=dis[fly[i].x]+dis[fly[i].y]-2*dis[fly[i].ff];
        lth=max(lth,fly[i].len);
    }
    int l=0,r=0;
    r=lth;
    int ret=0;
    while(l<r)
    {
        int mid=(l+r)>>1;
        if(check(mid)) r=mid,ret=mid;
        else l=mid+1;
    }
    printf("%d",ret);
    return 0;
}