树链剖分专题

学习了一下树链剖分，找了几个有意义的题目训练一下

前4题是基础训练， A、B是AOV树（点记录信息） C、D是AOE树（边记录信息）

*注意一下poj好像是提交的代码包含/**/这样的注释会出问题

A、HDU 3966

题意：给你N个点M条边的一棵AOV树，有P次操作

操作分别是：‘I’：将C1到C2路径上的点增加K；

　　　　     ‘D’：将C1到C2路径上的点减少K；

　　　　     ‘Q’：问你C点上的权；

解：树链剖分基础题，需要注意的是杭电的服务器是windows的，代码中加入用下面这句话扩栈

#pragma comment(linker, "/STACK:1024000000,1024000000") 

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/6/11 星期四 12:10:10
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#pragma comment(linker, "/STACK:1024000000,1024000000")  
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
using namespace std;

typedef long long int64;

const int MaxA=5e4+7;

struct Edge {
    int v, nt;
    Edge() {}
    Edge(int v, int nt):v(v), nt(nt) {}
} edges[MaxA<<1];

int head[MaxA], edgeNum;

struct Fenwick {
    int n;
    int c[MaxA];
    
    void init(int n) {
        this->n=n;
        memset(c, 0, sizeof(c[0])*(n+3));
    }

    int lowbit(int x) {
        return x&(-x);
    }

    void update(int x, int d) {
        while(x>0) {
            c[x]+=d;
            x-=lowbit(x);
        }
    }

    int query(int x) {
        int res=0;
        while(x<=n) {
            res+=c[x];
            x+=lowbit(x);
        }
        return res;
    }
} fw;

int N, M, P;
int oval[MaxA], val[MaxA];

void init() {
    memset(head, -1, sizeof(head));
    edgeNum=0;
}
void addEdge(int u, int v) {
    edges[edgeNum]=Edge(v, head[u]); 
    head[u]=edgeNum++;
}
namespace LCT {
    int fa[MaxA];
    int dep[MaxA];
    int siz[MaxA];
    int son[MaxA];
    int top[MaxA];
    int w[MaxA];
    int id;

    int dfs1(int u, int d) {
        dep[u]=d; siz[u]=1; son[u]=-1;
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u]) continue;
            fa[e.v]=u;
            siz[u]+=dfs1(e.v, d+1);
            if(son[u]==-1 || siz[son[u]]<siz[e.v]) son[u]=e.v;
        }
        return siz[u];
    }

    void dfs2(int u, int tp) {
        w[u]=++id; top[u]=tp; 
        if(~son[u]) dfs2(son[u], tp);
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u] || e.v==son[u]) continue;
            dfs2(e.v, e.v);
        }
    }

    void init() {
        int root=1;
        id=0;
        fa[root]=-1;
        dfs1(root, 0);
        dfs2(root, root);
        fw.init(N);
        for(int i=1; i<=N; i++) {
            fw.update(w[i]-1, -oval[i]);
            fw.update(w[i], oval[i]);
        }
    }

    void update(int u, int v, int d) {
        int f1=top[u], f2=top[v];
        while(f1!=f2) {
            if(dep[f1]<dep[f2]) { swap(f1, f2); swap(u, v); }
            fw.update(w[f1]-1, -d); fw.update(w[u], d); 
            u=fa[f1]; f1=top[u];
        }
        if(dep[u]>dep[v]) swap(u, v);
        fw.update(w[u]-1, -d);    fw.update(w[v], d);
    }

    int query(int x) {
        return fw.query(w[x]);
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d%d", &N, &M, &P)) {
        for(int i=1; i<=N; i++) {
            scanf("%d", &oval[i]);
        }
        init();
        for(int i=0; i<M; i++) {
            int a, b;
            scanf("%d%d", &a, &b);
            addEdge(a, b);
            addEdge(b, a);
        }
        LCT::init();
        while(P--) {
            char op[2];
            scanf("%s", op);
            if(op[0]=='Q') {
                int x;
                scanf("%d", &x);
                printf("%d
", LCT::query(x));
            } else {
                int a, b, c;
                scanf("%d%d%d", &a, &b, &c);
                if(op[0]=='D') c=-c;
                LCT::update(a, b, c);
            }
        }
    }
    return 0;
}

 B、BZOJ 2243

题意：N个点的点AOV树，M次操作

操作：‘C a b c’：把节点a到节点b路径上所有点（包括a和b）都染成颜色c；

　　   ‘Q a b’：询问节点a到节点b（包括a和b）路径上的颜色段数量；

解：在A的基础上修改一下就好，需要理解树剖的分链而治

/**************************************************************
    Problem: 2243
    User: shjwudp
    Language: C++
    Result: Accepted
    Time:4324 ms
    Memory:17388 kb
****************************************************************/
 
/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/6/11 星期四 19:27:57
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
 
using namespace std;
 
const int MaxA=1e5+7;
 
struct Edge {
    int v, nt;
    Edge(){}
    Edge(int v, int nt):v(v), nt(nt){}
} edges[MaxA<<1];
 
int head[MaxA], edgeNum;
 
struct SegmentTree {
    struct Node {
        int l, r;
        int cnt;
        int mark;
    } c[MaxA<<2];
    int n;
    int *val;
    int L, R, v;
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define RUSH Node& u=c[rt]; Node& ls=c[rt<<1]; Node& rs=c[rt<<1|1];
 
    void pushUp(int rt) {
        RUSH
        u.cnt=ls.cnt+rs.cnt-(ls.r==rs.l?1:0);
        u.l=ls.l;
        u.r=rs.r;
    }
 
    void pushDown(int rt) {
        RUSH
        if(~u.mark) {
            ls.mark=rs.mark=ls.l=ls.r=rs.l=rs.r=u.mark;
            ls.cnt=rs.cnt=1;
            u.mark=-1;
        }
    }
 
    void doBuild(int l, int r, int rt) {
        c[rt].mark=-1;
        if(l==r) {
            c[rt].l=c[rt].r=val[l];
            c[rt].cnt=1;
        } else {
            int m=(l+r)>>1;
            doBuild(lson);
            doBuild(rson);
            pushUp(rt);
        }
    }
 
    void build(int n, int *val) {
        this->n=n; this->val=val;
        doBuild(1, n, 1);
    }
 
    void doColor(int l, int r, int rt) {
        if(L<=l && r<=R) {
            c[rt].l=c[rt].r=c[rt].mark=v;
            c[rt].cnt=1;
        } else {
            pushDown(rt);
            int m=(l+r)>>1;
            if(L<=m) doColor(lson);
            if(m<R) doColor(rson);
            pushUp(rt);
        }
    }
 
    void color(int L, int R, int v) {
        this->L=L; this->R=R; this->v=v;
        doColor(1, n, 1);
    }
 
    int doQuery(int l, int r, int rt) {
        RUSH
        if(L<=l && r<=R) {
            return u.cnt;
        } else {
            pushDown(rt);
            int m=(l+r)>>1;
            int res=0;
            if(L<=m) res+=doQuery(lson);
            if(m<R) res+=doQuery(rson)-(res&&ls.r==rs.l?1:0);
            return res;
        }
    }
 
    int query(int L, int R) {
        this->L=L; this->R=R;
        return doQuery(1, n, 1);
    }
 
    int qcolor(int p) {
        int l=1, r=n, rt=1;
        while(l<r) {
            pushDown(rt);
            int m=(l+r)>>1;
            if(p<=m) r=m, rt=rt<<1;
            else l=m+1, rt=rt<<1|1;
        }
        return c[rt].l;
    }
 
#undef lson
#undef rson
#undef RUSH
} st;
 
int N, M;
int oval[MaxA], val[MaxA];  ///oval:原树上结点编号到值的映射
                            ///val:树剖后生成的线性表上编号到值的映射
void init() {
    edgeNum=0;
    memset(head, -1, sizeof(head));
}
void addEdge(int u, int v) {
    edges[edgeNum]=Edge(v, head[u]);
    head[u]=edgeNum++;
}
namespace LCT {
    int fa[MaxA];
    int siz[MaxA];
    int son[MaxA];
    int dep[MaxA];
    int top[MaxA];
    int w[MaxA];
    int id;
 
    int dfs1(int u, int d) {
        siz[u]=1; dep[u]=d; son[u]=-1;
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u]) continue;
            fa[e.v]=u;
            siz[u]+=dfs1(e.v, d+1);
            if(son[u]==-1 || siz[son[u]]<siz[e.v]) son[u]=e.v;
        }
        return siz[u];
    }
 
    void dfs2(int u, int tp) {
        w[u]=++id; top[u]=tp;
        if(~son[u]) dfs2(son[u], tp);
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u] || e.v==son[u]) continue;
            dfs2(e.v, e.v);
        }
    }
 
    void init() {
        int root=1;
        id=0;
        fa[root]=-1;
        dfs1(root, 0);
        dfs2(root, root);
        for(int i=1; i<=N; i++) {
            val[w[i]]=oval[i];
        }
        st.build(N, val);
    }
 
    int find(int u, int v) {
        int res=0;
        int f1=top[u], f2=top[v];
        while(f1!=f2) {
            if(dep[f1]<dep[f2]) { swap(f1, f2); swap(u, v); }
            res+=st.query(w[f1], w[u])
               +(fa[f1]!=-1&&st.qcolor(w[f1])==st.qcolor(w[fa[f1]])?-1:0);
            u=fa[f1]; f1=top[u];
        }
        if(dep[u]>dep[v]) swap(u, v);
        return res+st.query(w[u], w[v]);
    }
 
    void update(int u, int v, int op) {
        int f1=top[u], f2=top[v];
        while(f1!=f2) {
            if(dep[f1]<dep[f2]) { swap(f1, f2); swap(u, v); }
            st.color(w[f1], w[u], op);
            u=fa[f1]; f1=top[u];
        }
        if(dep[u]>dep[v]) swap(u, v);
        st.color(w[u], w[v], op);
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d", &N, &M)) {
        for(int i=1; i<=N; i++) {
            scanf("%d", &oval[i]);
        }
        init();
        for(int i=1; i<N; i++) {
            int a, b;
            scanf("%d%d", &a, &b);
            addEdge(a, b);
            addEdge(b, a);
        }
        LCT::init();
        while(M--) {
            char op[2];
            scanf("%s", op);
            if(op[0]=='C') {
                int a, b, c;
                scanf("%d%d%d", &a, &b, &c);
                LCT::update(a, b, c);
            } else {
                int a, b;
                scanf("%d%d", &a, &b);
                printf("%d
", LCT::find(a, b));
            }
        }
    }
    return 0;
}

C、POJ 2763

题意：N个点的AOE树，q次操作，你开始在S点

操作：‘0 u’：你要去u点，问你你走过路径上的所有边的边权和；

　　　‘1 i w’：将第i条边的边权值变为w；

解：以点代边，根不代表任何边，明白每个点代表哪条边就不会有问题

#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int MaxA=1e5+7;

struct Edge {
    int v, nt;
    int w;
    Edge(){}
    Edge(int v, int nt, int w):v(v), nt(nt), w(w) {}
} edges[MaxA<<1];

int head[MaxA], edgeNum;

struct Fenwick {
    int n;
    int c[MaxA];

    void init(int n) {
        this->n=n;
        memset(c, 0, sizeof(c[0])*(n+3));
    }

    int lowbit(int x) {
        return x&-x;
    }

    void update(int x, int d) {
        while(x<=n) {
            c[x]+=d;
            x+=lowbit(x);
        }
    }

    int query(int x) {
        int res=0;
        while(x>0) {
            res+=c[x];
            x-=lowbit(x);
        }
        return res;
    }

    void change(int x, int d) {
        int tmp=query(x)-query(x-1);
        update(x, d-tmp);
    }
} fw;

int N, Q, S;
int oval[MaxA];
void init() {
    memset(head, -1, sizeof(head));
    edgeNum=0;
}
void addEdge(int u, int v, int w) {
    edges[edgeNum]=Edge(v, head[u], w);
    head[u]=edgeNum++;
}
namespace LCT {
    int fa[MaxA];
    int siz[MaxA];
    int son[MaxA];
    int dep[MaxA];
    int top[MaxA];
    int w[MaxA];
    int e2p[MaxA];    ///边到点的映射
    int id;

    int dfs1(int u, int d) {
        siz[u]=1; dep[u]=d; son[u]=-1;
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u]) continue;
            e2p[(i>>1)+1]=e.v;    ///边的编号映射到点
            fa[e.v]=u; oval[e.v]=e.w;    ///以点代边，根节点不代表任何边
            siz[u]+=dfs1(e.v, d+1);
            if(son[u]==-1 || siz[son[u]]<siz[e.v]) son[u]=e.v;
        }
        return siz[u];
    }

    void dfs2(int u, int tp) {
        w[u]=++id; top[u]=tp;
        if(~son[u]) dfs2(son[u], tp);
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u] || e.v==son[u]) continue;
            dfs2(e.v, e.v);
        }
    }

    void init() {
        int root=(N+1)>>1;
        id=0;
        fa[root]=-1; oval[root]=0;///以点代边，根节点不代表任何边，因此权为0
        dfs1(root, 0);
        dfs2(root, root);
        fw.init(N);
        for(int i=1; i<=N; i++) {
            fw.update(w[i], oval[i]);
        }
    }

    int query(int u, int v) {
        int res=0;
        int f1=top[u], f2=top[v];
        while(f1!=f2) {
            if(dep[f1]<dep[f2]) { swap(f1, f2); swap(u, v); }
            res+=fw.query(w[u])-fw.query(w[f1]-1);
            u=fa[f1]; f1=top[u];
        }
        if(dep[u]>dep[v]) swap(u, v);
        return res+fw.query(w[v])-fw.query(w[u]);
    }

    void update(int x, int d) {
        fw.change(w[e2p[x]], d);
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    while(~scanf("%d%d%d", &N, &Q, &S)) {
        init();
        for(int i=1; i<N; i++) {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            addEdge(a, b, c);
            addEdge(b, a, c);
        }
        LCT::init();
        while(Q--) {
            int op;
            scanf("%d", &op);
            if(op==0) {
                int x;
                scanf("%d", &x);
                printf("%d
", LCT::query(S, x));
                S=x;
            } else {
                int a, b;
                scanf("%d%d", &a, &b);
                LCT::update(a, b);
            }
        }
    }
    return 0;
}

D、POJ 3237

题意：N个结点的AOE树，各种操作~

操作：‘CHANGE i v’：将第i条边的权值变为w；

　　　‘NEGATE a b’：将把节点a到节点b路径上所有边的权值取负；

　　　‘QUERY a b’：询问节点a到节点b路径上的最大边权值；

　　　‘DONE’：操作结束

解：和C题差不多，只是需要修改树剖分之后的操作

/*
 * Problem:  
 * Author:  SHJWUDP
 * Created Time:  2015/6/11 星期四 15:57:34
 * File Name: 233.cpp
 * State: 
 * Memo: 
 */
#include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>

using namespace std;

const int INF=0x7f7f7f7f;

const int MaxA=1e4+7;

struct Edge {
    int v, nt;
    int w;
    Edge() {}
    Edge(int v, int nt, int w):v(v), nt(nt), w(w){}
} edges[MaxA<<1];

int head[MaxA], edgeNum;

struct SegmentTree {
    int n;
    struct Node {
        int mx, mi;
        int mark;
    } c[MaxA<<2];
    int *val;
    int p, v;
    int L, R;
#define lson l, m, rt<<1
#define rson m+1, r, rt<<1|1
#define RUSH Node& u=c[rt]; Node& ls=c[rt<<1]; Node& rs=c[rt<<1|1];

    void pushUp(int rt) {
        RUSH
        u.mx=max(ls.mx, rs.mx);
        u.mi=min(ls.mi, rs.mi);
    }

    void pushDown(int rt) {
        RUSH
        if(u.mark) {
            ls.mx=-ls.mx; ls.mi=-ls.mi; swap(ls.mx, ls.mi);
            ls.mark^=1;
            rs.mx=-rs.mx; rs.mi=-rs.mi; swap(rs.mx, rs.mi);
            rs.mark^=1;
            u.mark=0;
        }
    }

    void doBuild(int l, int r, int rt) {
        c[rt].mark=0;
        if(l==r) {
            c[rt].mx=c[rt].mi=val[l];
        } else {
            int m=(l+r)>>1;
            doBuild(lson);
            doBuild(rson);
            pushUp(rt);
        }
    }

    void build(int n, int *val) {
        this->n=n; this->val=val;
        doBuild(1, n, 1);
    }
    
    void doChange(int l, int r, int rt) {
        if(l==r) {
            c[rt].mx=c[rt].mi=v;
        } else {
            pushDown(rt);
            int m=(l+r)>>1;
            if(p<=m) doChange(lson);
            else doChange(rson);
            pushUp(rt);
        }
    }

    void change(int p, int v) {
        this->p=p; this->v=v;
        doChange(1, n, 1);
    }


    void doNegate(int l, int r, int rt) {
        if(L<=l && r<=R) {
            c[rt].mx=-c[rt].mx; c[rt].mi=-c[rt].mi;
            swap(c[rt].mx, c[rt].mi);
            c[rt].mark^=1;
        } else {
            pushDown(rt);
            int m=(l+r)>>1;
            if(L<=m) doNegate(lson);
            if(m<R) doNegate(rson);
            pushUp(rt);
        }
    }

    void negate(int L, int R) {
        this->L=L; this->R=R;
        doNegate(1, n, 1);
    }


    int doQuery(int l, int r, int rt) {
        if(L<=l && r<=R) {
            return c[rt].mx;
        } else {
            pushDown(rt);
            int m=(l+r)>>1;
            int res=-INF;
            if(L<=m) res=max(res, doQuery(lson));
            if(m<R) res=max(res, doQuery(rson));
            return res;
        }
    }

    int query(int L, int R) {
        this->L=L; this->R=R;
        return doQuery(1, n, 1);
    }
#undef lson
#undef rson
#undef RUSH
} st;

int N;
int oval[MaxA], val[MaxA];
void init() {
    edgeNum=0;
    memset(head, -1, sizeof(head));
}
void addEdge(int u, int v, int w) {
    edges[edgeNum]=Edge(v, head[u], w);
    head[u]=edgeNum++;
}
namespace LCT {
    int fa[MaxA];
    int siz[MaxA];
    int son[MaxA];
    int dep[MaxA];
    int top[MaxA];
    int w[MaxA];
    int id;
    int e2p[MaxA];        ///边到点的映射

    int dfs1(int u, int d) {
        siz[u]=1; dep[u]=d; son[u]=-1;
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u]) continue;
            e2p[(i>>1)+1]=e.v;        ///边到点的映射
            fa[e.v]=u; oval[e.v]=e.w;    ///以点代边
            siz[u]+=dfs1(e.v, d+1);
            if(son[u]==-1 || siz[son[u]]<siz[e.v]) son[u]=e.v;
        }
        return siz[u];
    }

    void dfs2(int u, int tp) {
        w[u]=++id; top[u]=tp;
        if(~son[u]) dfs2(son[u], tp);
        for(int i=head[u]; ~i; i=edges[i].nt) {
            Edge& e=edges[i];
            if(e.v==fa[u] || e.v==son[u]) continue;
            dfs2(e.v, e.v);
        }
    }

    void init() {
        int root=1;
        id=0; oval[root]=-INF; ///以点代边，根结点不代表任何边
        fa[root]=-1;
        dfs1(root, 0);
        dfs2(root, root);
        for(int i=1; i<=N; i++) {
            val[w[i]]=oval[i];
        }
        st.build(N, val);
    }

    void change(int p, int v) {
        st.change(w[e2p[p]], v);
    }

    int find(int u, int v, int op) {
        int res=-INF;
        int f1=top[u], f2=top[v];
        while(f1!=f2) {
            if(dep[f1]<dep[f2]) { swap(f1, f2); swap(u, v); }
            if(op==0) res=max(res, st.query(w[f1], w[u]));
            else st.negate(w[f1], w[u]);
            u=fa[f1]; f1=top[u];
        }
        if(u==v) return res;
        if(dep[u]>dep[v]) swap(u, v);
        if(op==0) res=max(res, st.query(w[u]+1, w[v]));
        else st.negate(w[u]+1, w[v]);
        return res;
    }
}
int main() {
#ifndef ONLINE_JUDGE
    freopen("in", "r", stdin);
    //freopen("out", "w", stdout);
#endif
    int T;
    scanf("%d", &T);
    while(T--) {
        scanf("%d", &N);
        init();
        for(int i=1; i<N; i++) {
            int a, b, c;
            scanf("%d%d%d", &a, &b, &c);
            addEdge(a, b, c);
            addEdge(b, a, c);
        }

        LCT::init();
        char op[7];
        while(scanf("%s", op), op[0]!='D') {
            int a, b;
            scanf("%d%d", &a, &b);
            switch(op[0]) {
                case 'C': LCT::change(a, b);
                    break;
                case 'N': LCT::find(a, b, 1);
                    break;
                default: printf("%d
", LCT::find(a, b, 0));
            }
        }
    }
    return 0;
}