Bzoj4515 [Sdoi2016]游戏

Time Limit: 40 Sec  Memory Limit: 256 MB
Submit: 594  Solved: 234

Description

Alice 和 Bob 在玩一个游戏。

游戏在一棵有 n 个点的树上进行。最初，每个点上都只有一个数字，那个数字是 123456789123456789。

有时，Alice 会选择一条从 s 到 t 的路径，在这条路径上的每一个点上都添加一个数字。对于路径上的一个点 r，

若 r 与 s 的距离是 dis，那么 Alice 在点 r 上添加的数字是 a×dis+b。有时，Bob 会选择一条从 s 到 t 的路径。

他需要先从这条路径上选择一个点，再从那个点上选择一个数字。

Bob 选择的数字越小越好，但大量的数字让 Bob 眼花缭乱。Bob 需要你帮他找出他能够选择的最小的数字。

 

Input

第一行两个数字 n、m，表示树的点数和进行的操作数。

接下来 n−1 行，每行三个数字 u、v、w，表示树上有一条连接 u、v 的边，长度是 w。

接下来 m 行。每行第一个数字是 1 或 2。

若第一个数是 1，表示 Alice 进行操作，接下来四个数字 s、t、a、b。

若第一个数是 2，表示 Bob 进行操作，接下来四个数字 s、t。

 

Output

每当 Bob 进行操作，输出一行一个数，表示他能够选择的最小的数字

 

Sample Input

3 5
1 2 10
2 3 20
2 1 3
1 2 3 5 6
2 2 3
1 2 3 -5 -6
2 2 3

Sample Output

123456789123456789
6
-106

HINT

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

Source

鸣谢Menci上传

树链剖分+李超线段树

似乎是传说中的线段树维护半平面交。

在从s到t的路径上的每一个点上都添加一个值，添加的值满足某个函数关系；

询问从s到t的路径上最小的值。

如果把从s到t的路径从树上拎出来，那就得到了一条链，这条链可以看作是以s为原点的数轴，在数轴上脑补一个平面直角坐标系，我们要做的其实是往坐标系中添加线段，并查询某个横坐标x对应的最小的线段纵坐标f(x)。

拎一条链出来，当然就是树链剖分了。

接下来在线段树上维护线段（好像略喜感）。在线段树的每个结点上，存长度大于该结点对应区间的最优的线段。

当更新区间的时候，如果新线段完全比结点上存的旧线段优或者劣，就可以替换/舍弃。但如果只是一部分比旧线段优，就应该把占优比例更多的那条留在当前结点，把另一条下传到子区间递归更新。

询问的时候，由于每一层都存有线段，在每一层都需要更新。

我的线段树写法是(L<=l && r<=R)时更新，结点最小值取min(F(L),F(R))，在这个问题中，显然如果线段的左右端点在l和L之间，这样更新会记录下实际不属于该结点对应区间的值。

解决办法是最小值取min (F(max(L,l)),F(min(r,R)) )

而我并没有意识到这个显然的问题，加上另一些细节问题，WA记录成功刷了半页

CGOS提供数据真是良心

肝了差不多两晚上才切掉，终于可以安心刷会儿邦邦了

#include<iostream>
#include<algorithm>
#include<cstring>
#include<cstdio>
#include<cmath>
#define LL long long
using namespace std;
const LL INF =123456789123456789LL;
const int mxn=200010;
LL read(){
    LL x=0,f=1;char ch=getchar();
    while(ch<'0' || ch>'9'){if(ch=='-')f=-1;ch=getchar();}
    while(ch>='0' && ch<='9'){x=x*10+ch-'0';ch=getchar();}
    return x*f;
}
void write(LL x){
    if(x>9)write(x/10);
    putchar(x%10+'0');
    return;
}
//
struct edge{
    int v,nxt,w;
}e[mxn<<1];
int hd[mxn],mct=0;
void add_edge(int u,int v,int w){
    e[++mct].v=v;e[mct].nxt=hd[u];e[mct].w=w;hd[u]=mct;return;
}
//
struct node{
    int fa,son,top;
    int w,e;
}t[mxn];
int sz[mxn],dep[mxn],tct=0;
int mp[mxn];
LL dis[mxn];
void DFS1(int u,int fa){
    sz[u]=1;
    dep[u]=dep[fa]+1;
    for(int i=hd[u],v;i;i=e[i].nxt){
        v=e[i].v;
        if(v==fa)continue;
        t[v].fa=u;
        dis[v]=dis[u]+e[i].w;
        DFS1(v,u);
        sz[u]+=sz[v];
        if(sz[v]>sz[t[u].son])t[u].son=v;
    }
    return;
}
void DFS2(int u,int top){
//    printf("dfs:%u
",u);
    t[u].w=++tct;
    t[u].top=top;
    mp[tct]=u;//反向映射 
    if(t[u].son){
        DFS2(t[u].son,top);
        for(int i=hd[u],v;i;i=e[i].nxt){
            v=e[i].v;
            if(v==t[u].fa || v==t[u].son)continue;
            DFS2(v,v);
        }
    }
    t[u].e=tct;
    return;
}
int LCA(int x,int y){
    while(t[x].top!=t[y].top){
        if(dep[t[x].top]<dep[t[y].top])swap(x,y);
        x=t[t[x].top].fa;
    }
    return dep[x]<dep[y]?x:y;
}
//
struct SGT{
    int l,r;
    LL a,b,mini;
}st[mxn<<2];
int cnt=0,rot;
int n,m;
inline LL F(LL a,LL b,int x){
    return a*dis[mp[x]]+b;
}
inline void pushup(int rt){
    st[rt].mini=min(st[rt].mini,min(st[st[rt].l].mini,st[st[rt].r].mini));
    return;
}
void Build(int l,int r,int &rt){
    if(!rt)rt=++cnt;
    st[rt].a=0;
    st[rt].b=st[rt].mini=INF;
    if(l==r)return;
    int mid=(l+r)>>1;
    Build(l,mid,st[rt].l);
    Build(mid+1,r,st[rt].r);
//    pushup(rt);
    return;
}

void modify(LL a,LL b,int l,int r,int rt){
    LL fL=F(st[rt].a,st[rt].b,l); LL fR=F(st[rt].a,st[rt].b,r);
    LL nL=F(a,b,l);    LL nR=F(a,b,r);
    if(fL>=nL && fR>=nR){//完全更优 
        st[rt].a=a;st[rt].b=b;return;
    }
    if(fL<=nL && fR<=nR)return;//完全更差 
    int mid=(l+r)>>1;
    LL fM=F(st[rt].a,st[rt].b,mid);
    LL nM=F(a,b,mid);
    if(fM>nM){
        swap(st[rt].a,a);swap(st[rt].b,b);
        swap(fL,nL);swap(fR,nR);
    }
    if(fL>=nL)modify(a,b,l,mid,st[rt].l);
    if(fR>=nR)modify(a,b,mid+1,r,st[rt].r);
//    pushup(rt);
    return;
}
void update(LL a,LL b,int L,int R,int l,int r,int rt){
    st[rt].mini=min(st[rt].mini,min(F(a,b,max(L,l)),F(a,b,min(r,R))));//取正确端点 
    if(L<=l && r<=R){
        modify(a,b,l,r,rt);
        return;
    }
    int mid=(l+r)>>1;
    if(L<=mid)update(a,b,L,R,l,mid,st[rt].l);
    if(R>mid)update(a,b,L,R,mid+1,r,st[rt].r);
//    pushup(rt);
    return;
}
LL query(int L,int R,int l,int r,int rt){
//    printf("%lld %lld %lld L:%d R:%d l:%d r:%d rt:%d
",
//        st[rt].a,st[rt].b,st[rt].mini,L,R,l,r,rt);
    LL res=INF;
    res=min(F(st[rt].a,st[rt].b,max(L,l)),F(st[rt].a,st[rt].b,min(r,R)));
    if(L<=l && r<=R){
        res=min(res,st[rt].mini);
        return res;
    }
    int mid=(l+r)>>1;
    if(L<=mid)res=min(res,query(L,R,l,mid,st[rt].l));
    if(R>mid)res=min(res,query(L,R,mid+1,r,st[rt].r));
    return res;
}
void T_add(int x,int y,LL a,LL b){
    while(t[x].top!=t[y].top){
        if(dep[t[x].top]<dep[t[y].top])swap(x,y);
        update(a,b,t[t[x].top].w,t[x].w,1,n,rot);
        x=t[t[x].top].fa;
    }
    if(dep[x]>dep[y])swap(x,y);
    update(a,b,t[x].w,t[y].w,1,n,rot);
    return;
}
LL Que(int x,int y){
    LL res=INF;
    while(t[x].top!=t[y].top){
        if(dep[t[x].top]<dep[t[y].top])swap(x,y);
        res=min(res,query(t[t[x].top].w,t[x].w,1,n,rot));
        x=t[t[x].top].fa;
    }
    if(dep[x]>dep[y])swap(x,y);
    res=min(res,query(t[x].w,t[y].w,1,n,rot));
    return res;
}
int main(){
//    freopen("menci_game.in","r",stdin);
//    freopen("menci_game.out","w",stdout);
    int i,j,u,v,w;
    n=read();m=read();
    for(i=1;i<n;i++){
        u=read();v=read();w=read();
        add_edge(u,v,w);
        add_edge(v,u,w);
    }
    DFS1(1,0);
    DFS2(1,1);
    Build(1,n,rot);
    int op,s,t;
    LL a,b;
    for(i=1;i<=m;i++){
        op=read();
        if(op==1){
            s=read();t=read();a=read();b=read();
            int tmp=LCA(s,t);
            T_add(s,tmp,-a,a*dis[s]+b);
            T_add(tmp,t,a,a*(dis[s]-dis[tmp]*2)+b);
        }
        else{
            s=read();t=read();
            LL res=Que(s,t);
            printf("%lld
",res);
        }
    }
    return 0;
}