bzoj4515 [Sdoi2016]游戏 树链剖分+李超树

Description

---

Alice 和 Bob 在玩一个游戏。
游戏在一棵有 n 个点的树上进行。最初，每个点上都只有一个数字，那个数字是 123456789123456789。
有时，Alice 会选择一条从 s 到 t 的路径，在这条路径上的每一个点上都添加一个数字。对于路径上的一个点 r，
若 r 与 s 的距离是 dis，那么 Alice 在点 r 上添加的数字是 a×dis+b。有时，Bob 会选择一条从 s 到 t 的路径。
他需要先从这条路径上选择一个点，再从那个点上选择一个数字。
Bob 选择的数字越小越好，但大量的数字让 Bob 眼花缭乱。Bob 需要你帮他找出他能够选择的最小的数字。

n≤100000，m≤100000，∣a∣≤10000,0<=w，|b|<=10^9

Solution

---

看到树上路径可以想到用lca拆，那么从s到lca和lca到t变成两条路径且只和当前点有关
注意到现在变成了给定一些直线的斜率和截距求区间内最小值，考虑在树链剖分+李超树搞这个问题
我们发现一条直线在区间内的最值一定在两端点取得，并且对于dfs序连续的一段它们dis的值域也是连续的，因此可以在线段树上记录所表示区间的dis的值域

细节非常多，一不小心就写会挂(⊙﹏⊙)b

Code

---

#include <stdio.h>
#include <string.h>
#include <algorithm>
#define rep(i,st,ed) for (int i=st;i<=ed;++i)

typedef long long LL;
const LL INF=123456789123456789;
const int N=100005;

struct edge {int y; LL w; int next;} e[N*2];
struct line {
    LL k,b,mn,mx,min;

    LL get_y(LL mmn,LL mmx) {
        return std:: min(INF,std:: min(k*mmn+b,k*mmx+b));
    }
} rec[N<<2];

int size[N],pos[N],bl[N],dep[N],fa[N];
int dfn[N],ls[N],edCnt;

LL dis[N],ans;

void add_edge(int x,int y,LL w) {
    e[++edCnt]=(edge) {y,w,ls[x]}; ls[x]=edCnt;
    e[++edCnt]=(edge) {x,w,ls[y]}; ls[y]=edCnt;
}

void dfs1(int now) {
    size[now]=1;
    for (int i=ls[now];i;i=e[i].next) {
        if (e[i].y==fa[now]) continue;
        fa[e[i].y]=now; dep[e[i].y]=dep[now]+1;
        dis[e[i].y]=dis[now]+e[i].w;
        dfs1(e[i].y); size[now]+=size[e[i].y];
    }
}

void dfs2(int now,int up) {
    pos[now]=++pos[0]; bl[now]=up;
    dfn[pos[0]]=now;
    int mx=0;
    for (int i=ls[now];i;i=e[i].next) {
        if (e[i].y!=fa[now]&&size[e[i].y]>size[mx]) mx=e[i].y;
    }
    if (!mx) return ;
    dfs2(mx,up);
    for (int i=ls[now];i;i=e[i].next) {
        if (e[i].y!=fa[now]&&e[i].y!=mx) dfs2(e[i].y,e[i].y);
    }
}

int get_lca(int x,int y) {
    for (;bl[x]!=bl[y];) {
        if (dep[bl[x]]<dep[bl[y]]) std:: swap(x,y);
        x=fa[bl[x]];
    }
    return (dep[x]<dep[y])?x:y;
}

void push_up(int now,int tl,int tr) {
    rec[now].min=rec[now].get_y(rec[now].mn,rec[now].mx);
    if (tl==tr) return ;
    rec[now].min=std:: min(rec[now].min,std:: min(rec[now<<1].min,rec[now<<1|1].min));
}

void query(int now,int tl,int tr,int l,int r,LL &mn,LL &mx) {
    if (r<l) return ;
    if (tl==l&&tr==r) {
        mn=std:: min(mn,rec[now].mn);
        mx=std:: max(mx,rec[now].mx);
        ans=std:: min(rec[now].min,ans);
        return ;
    }
    int mid=(tl+tr)>>1;
    LL mn1=INF,mn2=INF,mx1=0,mx2=0;
    query(now<<1,tl,mid,l,std:: min(r,mid),mn1,mx1);
    query(now<<1|1,mid+1,tr,std:: max(mid+1,l),r,mn2,mx2);
    mn=std:: min(mn1,mn2); mx=std:: max(mx1,mx2);
    ans=std:: min(ans,rec[now].get_y(mn,mx));
}

void modify(int now,int tl,int tr,int l,int r,line x) {
    if (r<l) return ;
    int mid=(tl+tr)>>1;
    if (tl==l&&tr==r) {
        if (x.k>=rec[now].k&&x.b>=rec[now].b) return ;
        if (x.k<=rec[now].k&&x.b<=rec[now].b) {
            rec[now].k=x.k; rec[now].b=x.b;
            return push_up(now,tl,tr);
        }
        if (rec[now].get_y(rec[now].mn,rec[now].mx)>x.get_y(rec[now].mn,rec[now].mx)) {
            std:: swap(x.k,rec[now].k),std:: swap(x.b,rec[now].b);
        }
        if (tl==tr) return push_up(now,tl,tr);
        long double pos=1.0*(rec[now].b-x.b)/(x.k-rec[now].k);
        if (x.k>rec[now].k) {
            if (pos>=rec[now<<1].mn) modify(now<<1,tl,mid,l,mid,x);
            if (pos>=rec[now<<1|1].mn) modify(now<<1|1,mid+1,tr,mid+1,r,x);
        } else {
            if (pos<=rec[now<<1|1].mx) modify(now<<1|1,mid+1,tr,mid+1,r,x);
            if (pos<=rec[now<<1].mx) modify(now<<1,tl,mid,l,mid,x);
        }
        return push_up(now,tl,tr);
    }
    modify(now<<1,tl,mid,l,std:: min(r,mid),x);
    modify(now<<1|1,mid+1,tr,std:: max(mid+1,l),r,x);
    push_up(now,tl,tr);
}

void solve(int x,int y) {
    ans=INF;
    for (;bl[x]!=bl[y];) {
        if (dep[bl[x]]<dep[bl[y]]) std:: swap(x,y);
        LL mn=INF,mx=0;
        query(1,1,pos[0],pos[bl[x]],pos[x],mn,mx);
        x=fa[bl[x]];
    }
    if (pos[x]>pos[y]) std:: swap(x,y);
    LL mn=INF,mx=0;
    query(1,1,pos[0],pos[x],pos[y],mn,mx);
    printf("%lld\n", ans);
}

void change(int x,int y,line c) {
    for (;bl[x]!=bl[y];) {
        if (dep[bl[x]]<dep[bl[y]]) std:: swap(x,y);
        modify(1,1,pos[0],pos[bl[x]],pos[x],c);
        x=fa[bl[x]];
    }
    if (pos[x]>pos[y]) std:: swap(x,y);
    modify(1,1,pos[0],pos[x],pos[y],c);
}

void build(int now,int tl,int tr) {
    rec[now].min=rec[now].b=INF; rec[now].k=0;
    if (tl==tr) {
        rec[now].mx=rec[now].mn=dis[dfn[tl]];
        return ;
    }
    int mid=(tl+tr)>>1;
    build(now<<1,tl,mid); build(now<<1|1,mid+1,tr);
    rec[now].mn=std:: min(rec[now<<1].mn,rec[now<<1|1].mn);
    rec[now].mx=std:: max(rec[now<<1].mx,rec[now<<1|1].mx);
}

int main(void) {
    int n,m; scanf("%d%d",&n,&m);
    rep(i,2,n) {
        int x,y; LL w; scanf("%d%d%lld",&x,&y,&w);
        add_edge(x,y,w);
    }
    for (dfs1(dep[1]=1),dfs2(1,1),build(1,1,n);m--;) {
        int opt,x,y; scanf("%d%d%d",&opt,&x,&y);
        if (opt==1) {
            int lca=get_lca(x,y); LL a,b; scanf("%lld%lld",&a,&b);
            change(x,lca,(line) {-a,a*dis[x]+b});
            change(y,lca,(line) {a,b+a*(dis[x]-2*dis[lca])});
        } else solve(x,y);
    }
    return 0;
}