Tsinsen A1303. tree(伍一鸣) （LCT+处理标记）

【题目链接】

    http://www.tsinsen.com/A1303

【题意】

    给定一棵树，提供树上路径乘/加一个数，加边断边，查询路径和的操作。

【思路】

    LCT+传标

    一次dfs构造LCT。

    LCT维护信息：v,sum,rev,add,mul,siz

    提取路径(u,v):evert(u)->Access(v),splay(v)，此时以v为根的splay辅助树即u->v的路径，直接进行操作即可。

    关于下传标记：

        Hezecong神犇的总结

    对于一个节点的标记，始终保持该标记已作用在该节点上。

　 给节点打标记后作用于该节点，每次传标，给儿子打上标记且作用于该儿子。

    对于覆盖类标记，直接覆盖即可。反转标记单独处理。

　 对于非覆盖类标记，考虑操作先后:先下传乘法标记，然后下传加法标记。对于乘法下传，还需要作用在加法标记上。

【代码】

#include<cstdio>
#include<cstring>
#include<iostream>
#define FOR(a,b,c) for(int a=b;a<=c;a++)
#define trav(u,i) for(int i=front[u];i;i=e[i].nxt)
using namespace std;

typedef long long ll;
typedef unsigned int ul;
const int N = 4e5+10;
const int MOD = 51061;

namespace LCT {

    struct Node {
        Node *ch[2],*fa;
        ul v,siz,rev,add,mul,sum;
        Node() ;
        //给当前结点打上标记 且更新当前结点 
        void mulv(int x) {
            mul=(mul*x)%MOD;
            v=(v*x)%MOD;
            add=(add*x)%MOD;
            sum=(sum*x)%MOD;
        }
        void addv(int x) {
            v=(v+x)%MOD;
            add=(add+x)%MOD;
            sum=(sum+siz*x)%MOD;
        }
        void reverse() {
            rev^=1;
            swap(ch[0],ch[1]);
        }
        //up push down
        void up_push() {
            if(fa->ch[0]==this||fa->ch[1]==this)
                fa->up_push();
            if(mul^1) {                             //mul != 1
                ch[0]->mulv(mul);
                ch[1]->mulv(mul);
                mul=1;
            }
            if(add) {
                ch[0]->addv(add);
                ch[1]->addv(add);
                add=0;
            }
            if(rev) {
                ch[0]->reverse();
                ch[1]->reverse();
                rev=0;
            }
        }
        void maintain() {
            siz=ch[0]->siz+ch[1]->siz+1;
            sum=(ch[0]->sum+ch[1]->sum+v)%MOD;
        }
    } *null=new Node, T[N];
    Node:: Node() {
        fa=ch[0]=ch[1]=null;
        add=rev=0,mul=siz=1;
        sum=v=0;
    }
    
    void rot(Node* o,int d) {
        Node *p=o->fa;
        p->ch[d]=o->ch[d^1];
        o->ch[d^1]->fa=p;
        o->ch[d^1]=p;
        o->fa=p->fa;
        if(p==p->fa->ch[0])
            p->fa->ch[0]=o;
        else if(p==p->fa->ch[1])
            p->fa->ch[1]=o;
        p->fa=o;
        p->maintain();
    }
    void splay(Node* o) {
        o->up_push();
        Node *nf,*nff;
        while(o->fa->ch[0]==o||o->fa->ch[1]==o) {
            nf=o->fa,nff=nf->fa;
            if(o==nf->ch[0]) {
                if(nf==nff->ch[0]) rot(nf,0);
                rot(o,0);
            } else {
                if(nf==nff->ch[1]) rot(nf,1);
                rot(o,1);
            }
        }
        o->maintain();
    }
    void Access(Node* o) {
        Node* son=null;
        while(o!=null) {
            splay(o);
            o->ch[1]=son;
            o->maintain();
            son=o; o=o->fa;
        }
    }
    void evert(Node* o) {
        Access(o); 
        splay(o);
        o->reverse();
    }
    void Link(Node *u,Node *v) {
        evert(u);
        u->fa=v;
    }
    void Cut(Node *u,Node *v) {
        evert(u);
        Access(v); splay(v);
        u->fa=v->ch[0]=null;
        v->maintain();
    }

}
using namespace LCT;

struct Edge { int v,nxt;
}e[N<<2];
int en=1,front[N];
void adde(int u,int v) {
    e[++en]=(Edge){v,front[u]}; front[u]=en;
}

ll read()
{
    char c=getchar(); 
    ll f=1,x=0;
    while(!isdigit(c)) {
        if(c=='-') f=-1; 
        c=getchar();
    }
    while(isdigit(c))
        x=x*10+c-'0',
        c=getchar();
    return x*f;
}

int n,q;

void build(int u,int fa) {
    T[u].sum=T[u].v=1;
    trav(u,i) {
        int v=e[i].v;
        if(v!=fa) {
            T[v].fa=&T[u];
            build(v,u);
        }
    }
}

int main()
{
    null->siz=null->mul=0;
    n=read(),q=read();
    for(int i=1;i<n;i++) {
        int u=read(),v=read();
        adde(u,v),adde(v,u);
    }
    build(1,-1);
    char op[2];
    int u,v,x,y;
    while(q--) {
        scanf("%s",&op);
        u=read(),v=read();
        if(op[0]=='+' || op[0]=='*') {
            x=read();
            evert(&T[u]);
            Access(&T[v]); splay(&T[v]);
            if(op[0]=='+') T[v].addv(x);
            else T[v].mulv(x);
        } else
        if(op[0]=='-') {
            x=read(),y=read();
            Cut(&T[u],&T[v]);
            Link(&T[x],&T[y]);
        } else {
            evert(&T[u]);
            Access(&T[v]); splay(&T[v]);
            printf("%d
",T[v].sum);
        }
    }
    return 0;
}