SPOJ 6779 Can you answer these queries VII(动态树)

题目链接：http://www.spoj.com/problems/GSS7/

题意：一棵树，每个节点有一个权值。两种操作：（1）将某条路经的权值统一修改为某个值；（2）询问某个路径上最大的连续和。

思路：节点保存sum,size,val,Max,LMax,RMax。

const int N=200005;

struct node
{
    int isRoot,val,sum,Max,LMax,RMax,Size;
    int isChanged;
    node *c[2],*f;

    void change(int x)
    {
        isChanged=1;
        val=x;
        sum=Size*x;
        Max=LMax=RMax=x>0?sum:0;
    }
};

node a[N],*nullNode;
int n;

void up(node *p)
{
    p->Size=p->c[0]->Size+p->c[1]->Size+1;
    p->sum=p->c[0]->sum+p->c[1]->sum+p->val;

    p->Max=max(max(p->c[0]->Max,p->c[1]->Max),p->c[0]->RMax+p->val+p->c[1]->LMax);
    p->LMax=max(p->c[0]->LMax,p->c[0]->sum+p->val+p->c[1]->LMax);
    p->RMax=max(p->c[1]->RMax,p->c[1]->sum+p->val+p->c[0]->RMax);
}

void pushDown(node *p)
{
    if(p->isChanged)
    {
        if(p->c[0]!=nullNode) p->c[0]->change(p->val);
        if(p->c[1]!=nullNode) p->c[1]->change(p->val);
        p->isChanged=0;
    }
}

void rotate(node *p,int k)
{
    node *q=p->f;
    pushDown(q);
    pushDown(p);
    q->c[k]=p->c[!k];
    if(p->c[!k]!=nullNode) p->c[!k]->f=q;
    p->c[!k]=q;
    p->f=q->f;
    if(q->f!=nullNode)
    {
        if(p->f->c[0]==q) p->f->c[0]=p;
        if(p->f->c[1]==q) p->f->c[1]=p;
    }
    q->f=p;
    up(q);
    p->isRoot=q->isRoot;
    q->isRoot=0;
}

int isRoot(node *p)
{
    return p->f==nullNode||p->f->c[0]!=p&&p->f->c[1]!=p;
}


void splay(node *p)
 {
     pushDown(p);
     while (!isRoot(p))
     {
         if(isRoot(p->f))
         {
             if(p==p->f->c[0]) rotate(p,0);
             else rotate(p,1);
         }
         else
         {
             if(p->f->f->c[0]==p->f)
             {
                 if(p->f->c[0]==p) rotate(p->f,0);
                 else rotate(p,1);
                 rotate(p,0);
             }
             else
             {
                 if(p->f->c[1]==p) rotate(p->f,1);
                 else rotate(p,0);
                 rotate(p,1);
             }
         }
     }
     up(p);
}

node* access(node *p)
{
    node *q=nullNode;
    while(p!=nullNode)
    {
        splay(p);
        p->c[1]->isRoot=1;
        p->c[1]=q;
        q->isRoot=0;
        up(p);
        q=p;
        p=p->f;
    }
    return q;
}


void change(int x,int y,int val)
{
    access(a+x);
    node *lca=access(a+y);
    lca->val=val;
    lca->c[1]->change(val);
    splay(a+x);
    if(a+x!=lca) a[x].change(val);
    up(lca);
}

int query(int x,int y)
{
    access(a+x);
    node *lca=access(a+y);
    splay(a+x);
    int ans;
    if(a+x!=lca)
    {
        ans=max(lca->c[1]->Max,a[x].Max);
        ans=max(ans,lca->c[1]->LMax+lca->val+a[x].LMax);
    }
    else
    {
        ans=lca->c[1]->Max;
        ans=max(ans,lca->c[1]->LMax+lca->val);
    }
    return ans;
}

struct Node
{
    int v,next;
};

Node edges[N];
int head[N],e;


void Add(int u,int v)
{
    edges[e].v=v;
    edges[e].next=head[u];
    head[u]=e++;

    edges[e].v=u;
    edges[e].next=head[v];
    head[v]=e++;
}

void build()
{
    queue<int> Q;
    Q.push(1);
    int i,u,v;
    while(!Q.empty())
    {
        u=Q.front();
        Q.pop();

        for(i=head[u];i!=-1;i=edges[i].next)
        {
            v=edges[i].v;
            if(a+v==a[u].f) continue;
            a[v].f=a+u;
            Q.push(v);
        }
    }

}


void init()
{
    nullNode=new node();
    nullNode->Size=0;
    nullNode->isChanged=0;
    nullNode->c[0]=nullNode->c[1]=nullNode->f=nullNode;
    nullNode->Max=nullNode->LMax=nullNode->RMax=nullNode->val=0;
    RD(n);
    int i,u,v,dis;
    FOR1(i,n)
    {
        RD(dis);
        a[i].c[0]=a[i].c[1]=a[i].f=nullNode;
        a[i].isRoot=1;
        a[i].Size=1;
        a[i].isChanged=0;
        a[i].sum=a[i].Max=a[i].LMax=a[i].RMax=a[i].val=dis;
    }
    clr(head,-1);
    e=0;
    FOR1(i,n-1) RD(u,v),Add(u,v);
    build();
}

int main()
{
    init();
    int a,b,c,op,m;
    RD(m);
    while(m--)
    {
        RD(op);
        if(op==1) RD(a,b),PR(query(a,b));
        else RD(a,b,c),change(a,b,c);
    }
    return 0;
}