SP6779 GSS7

GSS7解题报告

前言

唔，有点恶心哪，废了两个多小时debug

思路

很容易看出傻子都知道，这个是树链剖分+线段树的裸题，只不过是恶心了点，这里重点讲一下细节问题

线段树

做过GSS系列的都应该很熟悉了
线段树维护的前缀最大子段和，后缀最大子段和，和区间最大子段和
那么我们就可以很容易的写出他合并orpushup

void pushup(node &a,node x,node y) {
    a.ans=max(max(x.ans,y.ans),x.rk+y.lk);
    a.lk=max(x.sum+y.lk,x.lk);
    a.rk=max(y.sum+x.rk,y.rk);
    a.sum= x.sum +y.sum;
}

这里写成这种形式对下面的跳链比较友好
查询也是比较套路的 返回一个node，如果在mid两边，再次合并，这里就不多说了

树剖跳链

修改操作：

跳链，修改,和平常一样

查询操作：

x到y的路径是一条链子
如果我们把它伸直，捋平咯，那他就是一串数列
那我们就可以一块一块的合并喽
想一下我们是怎么跳的
是从链的两端跳，一直跳到他们相遇
那我们就维护两端的信息,也就是从起点到现在的x的区间和从现在的y到终点的区间
最后再合并起来,就是整个区间的信息喽
不过要注意合并时候的次序和l,r的交换
也许不swap而分类讨论就没这个东西了吧
我们的一条重链是从浅处到深处依次排列
我们跳的时候是从深处到浅出跳(从两端逼近中间)
所以合并就要考虑清楚了
是合并x，y还是合并y，x
文字说起来不太明白，我举个栗子吧

2号权值为-1，其他权值为1，要从4号到5号点
我们先从5号节点跳到1号所属重链
在跳之前我们先查询一下5号的值，得到一个node，和x
合并

我们再从4号节点跳到1号所属重链
在跳之前我们先查询一下4号的值，又得到一个node，和y合并
然后交换x，y(别问我为什么)

现在x,y都到了一条链子上了（注意前提）
我们考虑一下两端区间的方向

有一个是反着的，我们翻过来其中一个然后全部合并起来就好了
这里给出我的两组简单但易错数据(反正错了我好多次)

5
-1 1 1 1 1
1 5
1 2
2 3
2 4
1
1 4 5
ans=2

5
-3 -2 -1 -2 -3
1 2
2 3
1 4
4 5
2   
2 3 4 2
1 2 5
ans=6

代码

#include <bits/stdc++.h>
#define FOR(i,a,b) for(int i=a;i<=b;++i)
using namespace std;
const int N=6e5+7;
const int inf=0x3f3f3f3f;
inline int read() {
    int x=0,f=1;char s=getchar();
    for(;s>'9'||s<'0';s=getchar()) if(s=='-') f=-1;
    for(;s>='0'&&s<='9';s=getchar()) x=x*10+s-'0';
    return x*f;
}
vector<int> G[N];
int n,m;
int a[N],w[N],idx[N],top[N],son[N],siz[N],f[N],dep[N],cnt;
inline int max(const int &x,const int &y) {return x>y?x:y;}
void dfs1(int u,int fa) {
    f[u]=fa;
    siz[u]=1;
    dep[u]=dep[fa]+1;
    for(std::vector<int>::iterator it=G[u].begin();it!=G[u].end();++it) {
        if(fa==*it) continue;
        dfs1(*it,u);
        siz[u]+=siz[*it];
        if(siz[son[u]]<siz[*it]) son[u]=*it;
    }
}
void dfs2(int u,int topf) {
    idx[u]=++cnt;
    a[cnt]=w[u];
    top[u]=topf;
    if(!son[u]) return;
    dfs2(son[u],topf);
    for(std::vector<int>::iterator it=G[u].begin();it!=G[u].end();++it)
        if(!idx[*it]) dfs2(*it,*it);
}
namespace seg_tree {
    #define ls rt<<1
    #define rs rt<<1|1
    struct node {
        int l,r,siz,lk,rk,ans,lazy,sum;
    }e[N<<2];
    inline void pushup(node &a,node x,node y) {
        a.ans=max(max(x.ans,y.ans),x.rk+y.lk);
        a.lk=max(x.sum+y.lk,x.lk);
        a.rk=max(y.sum+x.rk,y.rk);
        a.sum= x.sum +y.sum;
    }
    void build(int l,int r,int rt) {
        e[rt].l=l,e[rt].r=r,e[rt].siz=r-l+1;
        e[rt].lazy=inf;
        if(l==r) {
            e[rt].sum=a[l];
            e[rt].lk=e[rt].rk=e[rt].ans=max(a[l],0);
            return;
        }
        int mid=(l+r)>>1;
        build(l,mid,ls);
        build(mid+1,r,rs);
        pushup(e[rt],e[ls],e[rs]);
    }
    inline void tag(int rt,int k) {
        e[rt].sum=e[rt].siz*k;
        if(k>=0) e[rt].lk=e[rt].rk=e[rt].ans=e[rt].sum;
        else e[rt].lk=e[rt].rk=e[rt].ans=0;
        e[rt].lazy=k;
    }
    inline void pushdown(int rt) {
        if(e[rt].lazy!=inf) {
            tag(ls,e[rt].lazy);
            tag(rs,e[rt].lazy);
            e[rt].lazy=inf;
        }
    }
    void modify(int L,int R,int k,int rt) {
        if(L<=e[rt].l&&e[rt].r<=R) {
            tag(rt,k);
            return;
        }
        pushdown(rt);
        int mid=(e[rt].l+e[rt].r)>>1;
        if(L<=mid) modify(L,R,k,ls);
        if(R>mid) modify(L,R,k,rs);
        pushup(e[rt],e[ls],e[rs]);
    }
    node query(int L,int R,int rt) {
        if(L<=e[rt].l&&e[rt].r<=R) return e[rt];
        pushdown(rt);
        int mid=(e[rt].l+e[rt].r)>>1;
        if(L<=mid && R>mid) {
            node a=query(L,R,ls),b=query(L,R,rs),c;
            pushup(c,a,b);
            return c;
        }
        if(L<=mid) return query(L,R,ls);
        if(R>mid) return query(L,R,rs);
    }
}
void QQ(int x,int y) {
    seg_tree::node tot_x={},tot_y={};
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) swap(x,y),swap(tot_x,tot_y);
        seg_tree::node tmp=seg_tree::query(idx[top[x]],idx[x],1);
        seg_tree::pushup(tot_x,tmp,tot_x);
        x=f[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y),swap(tot_x,tot_y);
    seg_tree::node tmp=seg_tree::query(idx[x],idx[y],1);
    swap(tot_x.lk,tot_x.rk);
    seg_tree::pushup(tot_x,tot_x,tmp);
    seg_tree::pushup(tot_y,tot_x,tot_y);
    printf("%d\n",tot_y.ans);
}
void CC(int x,int y,int c) {
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) swap(x,y);
        seg_tree::modify(idx[top[x]],idx[x],c,1); 
        x=f[top[x]];
    }
    if(dep[x]>dep[y]) swap(x,y);
    seg_tree::modify(idx[x],idx[y],c,1);
}
int main() {
    n=read();
    FOR(i,1,n) w[i]=read();
    FOR(i,2,n) {
        int x=read(),y=read();
        G[x].push_back(y);
        G[y].push_back(x);
    }
    dfs1(1,0);
    dfs2(1,1);
    seg_tree::build(1,n,1);
    m=read();
    FOR(i,1,m) {
        int opt=read(),x=read(),y=read(),z;
        if(opt==1) QQ(x,y);
        else z=read(),CC(x,y,z);
    }
    return 0;
}