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

树剖优化与二分搜索

最新推荐文章于 2024-07-15 18:43:11 发布

原创最新推荐文章于 2024-07-15 18:43:11 发布 · 360 阅读

0 ·

CC 4.0 BY-SA版权

二分答案同时被 3 个专栏收录

5 篇文章

订阅专栏

NOIP

4 篇文章

订阅专栏

树上差分

3 篇文章

订阅专栏

本文介绍了一种使用树剖结合二分搜索的方法解决特定树形结构问题的算法实现。该问题要求通过更改树中某条边的权重来最小化特定路径长度的最大值。文章详细阐述了算法思路，包括如何利用树剖进行节点遍历优化及二分搜索验证可行性。

题目大意：给你一颗树，你可以把其中一条边的边权改成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;
}