[CodeChef-QUERY]Observing the Tree

题目大意：
　　给你一棵树，一开始每个点的权值都是0，要求支持一下三种操作：
　　　　1.路径加等差数列。
　　　　2.路径求和。
　　　　3.回到以前的某次操作。
　　强制在线。

思路：
　　树链剖分+主席树。
　　最坏情况下，n个点的树最多会被分成n-1个链，
　　这里不能每个点都开一个主席树，因为主席树中要存每个线段树的根结点编号，总共有m次操作，
　　因此最坏情况下，总共要存nm个根结点，显然会爆空间，因此我们可以考虑将所有点合并在一个主席树中。
　　路径加等差数列时，我们可以先求出两个端点x和y上加的值ax和ay，然后往上爬的过程中根据跳过的长度维护ax和ay即可。
　　交换x和y的时候就相当于翻转等差数列，只要交换ax和ay并对公差b取反即可。
　　然后随随便便就跑了Rank2（Rank2的vjudge7和Rank3的skylee都是我的程序），0.63s。
　　后来想抢Rank发现刷不上去了（似乎CodeChef是根据第一次交的程序来排名的）。
　　交的时候发现忘记处理强制在线的操作也能AC？

细节：
　　题目中回退操作以后并不能删掉中间被跳过的操作，比如从第四次操作回退到第三次操作，如果再进行一次修改，那么这个修改操作就是第五次操作。

#include<cstdio>
#include<cctype>
#include<vector>
#include<cstring>
inline int getint() {
    char ch;
    while(!isdigit(ch=getchar()));
    int x=ch^'0';
    while(isdigit(ch=getchar())) x=(((x<<2)+x)<<1)+(ch^'0');
    return x;
}
const int V=100001,logV=200,M=100001;
std::vector<int> e[V];
inline void add_edge(const int u,const int v) {
    e[u].push_back(v);
}
int par[V],size[V],son[V],top[V],dep[V],id[V],cnt;
void dfs1(const int x,const int p) {
    dep[x]=dep[p]+1;
    par[x]=p;
    size[x]=1;
    for(unsigned i=0;i<e[x].size();i++) {
        int &y=e[x][i];
        if(y==p) continue;
        dfs1(y,x);
        size[x]+=size[y];
        if(size[y]>size[son[x]]) son[x]=y;
    }
}
void dfs2(const int x) {
    top[x]=x==son[par[x]]?top[par[x]]:x;
    id[x]=++cnt;
    if(son[x]) dfs2(son[x]);
    for(unsigned i=0;i<e[x].size();i++) {
        int &y=e[x][i];
        if(y==par[x]||y==son[x]) continue;
        dfs2(y);
    }
}
class FotileTree {
    private:
        long long first[M*logV],diff[M*logV],sum[M*logV];
        int left[M*logV],right[M*logV];
        int sz;
        int newnode() {
            return ++sz;
        }
        void push_up(const int p,const int b,const int e) {
            sum[p]=sum[left[p]]+sum[right[p]]+(first[p]*2+(e-b)*diff[p])*(e-b+1)/2;
        }
    public:
        int root[M];
        void modify(int &p,const int old_p,const int b,const int e,const int l,const int r,const long long x,const long long y) {
            if(!p||p==old_p) p=newnode();
            first[p]=first[old_p];
            diff[p]=diff[old_p];
            if((b==l)&&(e==r)) {
                first[p]+=x;
                diff[p]+=y;
                if(!left[p]) left[p]=left[old_p];
                if(!right[p]) right[p]=right[old_p];
                push_up(p,b,e);
                return;
            }
            int mid=(b+e)>>1;
            if(l<=mid) modify(left[p],left[old_p],b,mid,l,std::min(mid,r),x,y);
            if(r>mid) modify(right[p],right[old_p],mid+1,e,std::max(mid+1,l),r,x+(std::max(mid+1,l)-l)*y,y);
            if(!left[p]) left[p]=left[old_p];
            if(!right[p]) right[p]=right[old_p];
            push_up(p,b,e);
        }
        long long query(const int p,const int b,const int e,const int l,const int r) {
            if(!p) return 0;
            if((b==l)&&(e==r)) return sum[p];
            int mid=(b+e)>>1;
            long long ret=(first[p]*2+(l+r-b*2)*diff[p])*(r-l+1)/2;
            if(l<=mid) ret+=query(left[p],b,mid,l,std::min(mid,r));
            if(r>mid) ret+=query(right[p],mid+1,e,std::max(mid+1,l),r);
            return ret;
        }
};
FotileTree t;
inline int get_lca(int x,int y) {
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) std::swap(x,y);
        x=par[top[x]];
    }
    if(dep[x]>dep[y]) std::swap(x,y);
    return x;
}
int n;
inline void modify(const int old_root,int &root,int x,int y,const long long a,long long b) {
    int lca=get_lca(x,y);
    int dis=dep[x]+dep[y]-dep[lca]*2;
    int ax=a,ay=a+b*dis;
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) {
            std::swap(x,y);
            std::swap(ax,ay);
            b=-b;
        }
        t.modify(root,old_root,1,n,id[top[x]],id[x],ax+(dep[x]-dep[top[x]])*b,-b);
        ax+=(dep[x]-dep[top[x]]+1)*b;
        x=par[top[x]];
    }
    if(dep[x]<dep[y]) {
        std::swap(x,y);
        std::swap(ax,ay);
        b=-b;
    }
    t.modify(root,old_root,1,n,id[y],id[x],ax+(dep[x]-dep[y])*b,-b);
}
inline long long query(const int root,int x,int y) {
    long long ret=0;
    while(top[x]!=top[y]) {
        if(dep[top[x]]<dep[top[y]]) std::swap(x,y);
        ret+=t.query(root,1,n,id[top[x]],id[x]);
        x=par[top[x]];
    }
    if(dep[x]<dep[y]) std::swap(x,y);
    ret+=t.query(root,1,n,id[y],id[x]);
    return ret;
}
inline void rollback(int &cur,const int x) {
    cur=x;
}
int main() {
    n=getint();
    int m=getint();
    for(int i=1;i<n;i++) {
        int u=getint(),v=getint();
        add_edge(u,v);
        add_edge(v,u);
    }
    dfs1(1,0);
    dfs2(1);
    long long lastans=0;
    int cnt_c=0,cur=0;
    while(m--) {
        char op[2];
        scanf("%1s",op);
        switch(op[0]) {
            case 'c': {
                int x=(getint()+lastans)%n+1,y=(getint()+lastans)%n+1,a=getint(),b=getint();
                cnt_c++;
                t.root[cnt_c]=0;
                modify(t.root[cur],t.root[cnt_c],x,y,a,b);
                cur=cnt_c;
                break;
            }
            case 'q': {
                int x=(getint()+lastans)%n+1,y=(getint()+lastans)%n+1;
                printf("%lld
",lastans=query(t.root[cur],x,y));
                break;
            }
            case 'l': {
                int x=(getint()+lastans)%(cnt_c+1);
                rollback(cur,x);
                break;
            }
        }
    }
    return 0;
}