Aizu 2450 Do use segment tree （树链剖分）

Aizu 2450 Do use segment tree

树链剖分 + 线段树区间更新，就是用线段树求区间最大连续子序列和。

求区间最大连续子序列和  的  区间更新   都很好实现。

要注意的是最后询问的时候多个区间合并的顺序和正反的问题(就是后面swap那儿)

一开始线段树初始化那儿写残了调了好久  -  -

--------

孙大大的板子好长啊 -   -

#include <bits/stdc++.h>
#define lson num<<1
#define rson num<<1|1
#define gl l,m,lson
#define gr m+1,r,rson
#define PARA int l=L,int r=R,int num=1
using namespace std;
const int MAXN = 2e5+100;
const int INF = 0x2f2f2f2f;

struct Node
{
    long long lmx,rmx,mx,sum,tag;
    long long l,r;
    void init(int a,int b)
    {
        l=a,r=b;
        tag=INF;
    }
    void mark(long long v)
    {
        tag=v;
        sum=v*(r-l+1);
        mx=lmx=rmx=max(v,sum);
    }
    void merge(Node a, Node b)
    {
        lmx=max(max(a.lmx,a.sum),max(a.sum+b.lmx,a.sum+b.sum));
        rmx=max(max(b.rmx,b.sum),max(b.sum+a.rmx,a.sum+b.sum));
        sum=a.sum+b.sum;
        mx=max(max(max(lmx,rmx),max(a.mx,b.mx)),a.rmx+b.lmx);
    }
    void swap()
    {
        ::swap(lmx,rmx);
    }
};

int L,R;
struct SegTree
{
    int num[MAXN];
    Node st[MAXN<<2];
    void pushUp(int num)
    {
        st[num].merge(st[lson],st[rson]);
    }
    void pushDown(int num)
    {
        long long &v=st[num].tag;
        int l=st[num].l,r=st[num].r;
        if(l!=r&&v!=INF)
        {
            st[lson].mark(v);
            st[rson].mark(v);
            pushUp(num);
        }
        v=INF;
    }
    void init(int v[],PARA)
    {
        int m=l+r>>1;
        st[num].init(l,r);
        if(l!=r)
            init(v,gl),init(v,gr),pushUp(num);
        else
            st[num].mark(v[l]);
    }
    void update(int a,int b,int v,PARA)
    {
        pushDown(num);
        if(a<=l&&r<=b)
            st[num].mark(v);
        else
        {
            int m=l+r>>1;
            if(b<=m)
                update(a,b,v,gl);
            else if(a>m)
                update(a,b,v,gr);
            else
                update(a,b,v,gl),update(a,b,v,gr);
            pushUp(num);
        }
    }
    Node query(int a,int b,PARA)
    {
        pushDown(num);
        Node ret;
        if(a<=l&&r<=b)
            return st[num];
        int m=l+r>>1;
        if(b<=m)
            ret=query(a,b,gl);
        else if(a>m)
            ret=query(a,b,gr);
        else
            ret.merge(query(a,b,gl),query(a,b,gr));
        pushUp(num);
        return ret;
    }
} tr;
const int maxn=MAXN;
const int maxm=maxn+maxn;

struct EDGENODE
{
    int to;
    int next;
} edges[maxm];
int head[maxn],edge;
inline void init()
{
    edge=0;
    memset(head,-1,sizeof(head));
}
inline void addedge(int u,int v)
{
    edges[edge].to=v,edges[edge].next=head[u],head[u]=edge++;
    edges[edge].to=u,edges[edge].next=head[v],head[v]=edge++;
}
int que[maxn]; // 队列
bool vis[maxn]; // 访问标记
int son[maxn]; // 重儿子
int idx[maxn]; // 结点v在其路径中的编号
int dep[maxn]; // 结点v的深度
int siz[maxn]; // 以结点v为根的子树的结点个数
int belong[maxn]; // 结点v所属的路径编号
int fa[maxn]; // 结点v的父亲结点
int top[maxn]; // 编号为p的路径的顶端结点
int len[maxn]; // 路径p的长度
int sump[maxn]; // 路径p的编号
int seg[maxn]; // 结点v的父边在线段树中的位置
int wei[maxn]; // 结点v的父边的权值
int l,r,ans,cnt;
int n;
char cmd[22];

void split()
{
    memset(dep,-1,sizeof(dep));
    l=0;
    dep[ que[r=1]=1 ]=0; // 将根结点插入队列，并设深度为0
    fa[1]=-1; // 默认 1 为根结点
    while (l<r)  // 第一遍搜索求出 fa,dep,wei
    {
        int u=que[++l];
        vis[u]=false; // 顺便初始化vis
        for (int i=head[u]; i!=-1; i=edges[i].next)
        {
            int v=edges[i].to;
            if (dep[v]==-1)  // 未访问过的结点
            {
                dep[ que[++r]=v ]=dep[u]+1; // 将v插入队列并设深度为dep[u]+1
                fa[v]=u; // v的父结点为u
            }
        }
    }
    cnt=0; // 重链编号
    for (int i=n; i>0; i--)
    {
        int u=que[i],p=-1;
        siz[u]=1;
        son[u]=p;
        for (int k=head[u]; k!=-1; k=edges[k].next)
        {
            int v=edges[k].to;
            if (vis[v])  // 若v是u的子结点
            {
                siz[u]+=siz[v]; // 计数
                if (p==-1||siz[v]>siz[p])
                {
                    son[u]=v;
                    p=v; // u的重儿子是v
                }
            }
        }
        if (p==-1)  // u是叶子结点
        {
            idx[u]=len[++cnt]=1; // 一个新的路径编号为cnt，u是路径中的第一个结点
            belong[ top[cnt]=u ]=cnt; // u是顶端结点，且u属于路径cnt
        }
        else  // u不是叶子结点
        {
            idx[u]=++len[ belong[u]=belong[p] ]; // u属于重儿子所在的链，链长+1，u是路径中第len个结点
            top[ belong[u] ]=u; // u是顶端结点
        }
        vis[u]=true; // 访问标记
    }
    sump[0]=0;
    for (int i=1;i<=cnt;i++) sump[i]=sump[i-1]+len[i];
    for (int i=1;i<=n;i++){
        seg[i]=sump[ belong[i] ]-idx[i]+1;
        tr.num[ seg[i] ]=wei[i];
    }
}
int in[MAXN];

void build()
{
    int a,b;
    for(int i=1;i<=n;i++)
        scanf("%d",&wei[i]);
    for(int i=1;i<n;i++)
        scanf("%d%d",&a,&b),addedge(a,b);
    split();
    for(int i=1;i<=n;i++)
        in[seg[i]]=wei[i];
    L=1,R=n;
    tr.init(in);
}

Node q1[MAXN],q2[MAXN];
long long find(int va,int vb)
{
    int f1=top[belong[va]],f2=top[belong[vb]];
    int s1=0,s2=0;
    while (f1!=f2)
    {
        if (dep[f1]<dep[f2])
        {
            q2[s2++]=tr.query(seg[f2],seg[vb]);
            vb=fa[f2];
            f2=top[belong[vb]];
        }
        else
        {
            q1[s1]=tr.query(seg[f1],seg[va]);
            q1[s1++].swap();
            va=fa[f1];
            f1=top[belong[va]];
        }
    }
    for(int i=1;i<s1;i++)
        q1[0].merge(q1[0],q1[i]);
    for(int i=1;i<s2;i++)
        q2[0].merge(q2[i],q2[0]);
    int d=0;
    if (dep[va]>dep[vb]) swap(va,vb),d=1;
    Node ret=tr.query(seg[va],seg[vb]);
    if(d)
        ret.swap();
    if(s1)
        ret.merge(q1[0],ret);
    if(s2)
        ret.merge(ret,q2[0]);
    return ret.mx;
}

void update(int va,int vb,int v){
    int f1=top[belong[va]],f2=top[belong[vb]],tmp=-INF;
    while (f1!=f2){
        if (dep[f1]<dep[f2]){
            swap(f1,f2);
            swap(va,vb);
        }
        tr.update(seg[f1],seg[va],v);
        va=fa[f1];
        f1=top[belong[va]];
    }
    if (dep[va]>dep[vb]) swap(va,vb);
    tr.update(seg[va],seg[vb],v);
}

int main()
{
    int q,a,b,c,d;
    while(scanf("%d%d",&n,&q)!=EOF)
    {
        init();
        build();
        for(int i=0;i<q;i++)
        {
            scanf("%d%d%d%d",&a,&b,&c,&d);
            if(a==1)
                update(b,c,d);
            else
                printf("%lld\n",find(b,c));
        }
    }
    return 0;
}