【HDU 4897 多校联合】Little Devil I【树链刨分】

题意：给一棵树，三种操作，1.把a到b路径上的边翻转（黑变白 白变黑），2.把a到b路径上的邻居边给翻转，邻居边的定义是有且只有一个断点在这条路径上的边，3.求出a到b路径上黑边的个数。（初始态都是白边）

思路：看题目所述就像是拿树链刨分乱搞，如果没有第二个操作，这题目就是裸的树链刨分。我们把这棵树刨成若干条重链和轻边，可以知道两个重链之间是有一条轻边所相连接的。我们对于每条重链都建立一棵线段树（记为weight），保存的就是黑边的个数。如果只有第一种操作的话，这样子就可以用线段树的来解决了。对于第二种操作，我们需要对于每条重链再建立一棵线段树（记为light），表示这一条重链上每一节点所相连的轻边的反转情况。

          对于第一种操作，假设a，b在一条重链上，则直接对于这条重链所对应的线段树进行操作。如果不在一条重链上，我们就需要把两个节点跳到一条重链上，假设b所在的重链在a的重链的下方，我们就先对与b重链的线段树进行相应的反转操作，然后b往上跳时肯定会经过一条轻边，这条轻边肯定也是要反转的，我们就用一个数组来表示这轻边的翻转情况。一直使得a，b在一条重链上。

          对于第二种操作，同样的假设a，b在一条重链上，则对于light线段树进行相应反转，不过还要考虑a与a的前驱节点所连的边和b与b的后继节点所连的边也要翻转，这可以分为两种情况，一种是那个节点也在这个重链上，另一种是a是链头，第一种情况就直接在weight线段树上修改，另一种就要对于light线段树上修改。如果a，b不在一条重链上，同样我们需要把两个点跳到同一条重链上，对于跳的操作同上述一样，跳到轻边的时候，用数组来表示轻边的翻转情况。

          接下来就是求值，如果a，b在一条重链上，直接对于weight线段树求值。如果不在一条重链上，一样要跳到同一条重链上，这里注意的是在从一条重链跳到另一条重链上的时候，经过的那条轻边，要检查这条轻边是黑色还是白色。这里的检验方式就是用之前记录轻边的反转情况的数组以及在上方的重链所对应的light线段树来求的。

具体细节见代码。

#pragma comment(linker, "/STACK:102400000,102400000")
#include 
#include 
#include 
#include 
using namespace std;
#define N 100005
#define lc (tr[d].ls)
#define rc (tr[d].rs)

struct Tr{
    int sum, ls, rs, l, r;
    bool lz;
}tr[N<<4];

int ca = 0, weight[N], light[N], tid[N], dep[N], fa[N];
int sun[N], pathf[N], flag[N] = {0}, tot;
bool col[N];
int isbuild[N] = {0};
vectorV[N];

inline void Push(int d) {
    tr[d].sum = tr[lc].sum+tr[rc].sum;
}

inline void resum(int d) {
    tr[d].sum = tr[d].r-tr[d].l-tr[d].sum;
}

inline void lazy(int d) {
    if (tr[d].lz) {
        resum(lc), resum(rc);
        tr[lc].lz ^= 1, tr[rc].lz ^= 1;
        tr[d].lz = false;
    }
}

int build(int l, int r) {
    int root = tot++;
    tr[root].l = l, tr[root].r = r;
    tr[root].lz = tr[root].sum = 0;
    if (l == r-1) {
        tr[root].ls = tr[root].rs = -1;
        return root;
    }
    int mid = l+r>>1;
    tr[root].ls = build(l, mid);
    tr[root].rs = build(mid, r);
    return root;
}

void update(int d, int l, int r) {
    if (r <= l) return;
    if (l >= tr[d].r || r <= tr[d].l) return;
    if (tr[d].l == l && r == tr[d].r) {
        tr[d].lz ^= 1;
        tr[d].sum = tr[d].r-tr[d].l-tr[d].sum;
        return;
    }
    lazy(d);
    int mid = tr[d].l+tr[d].r>>1;
    if (r <= mid) update(lc, l, r);
    else if (l >= mid) update(rc, l, r);
    else update(lc, l, mid), update(rc, mid, r);
    Push(d);
}

int query(int d, int l, int r) {
    if (r <= l) return 0;
    if (l >= tr[d].r || r <= tr[d].l) return 0;
    if (tr[d].l == l && tr[d].r == r) return tr[d].sum;
    lazy(d);
    int mid = tr[d].l+tr[d].r>>1;
    if (r <= mid) return query(lc, l, r);
    else if (l >= mid) return query(rc, l, r);
    else return query(lc, l, mid)+query(rc, mid, r);
}

inline void init() {
    ca++;
    tot = 0;
    memset(tid, -1, sizeof(tid));
    memset(dep, -1, sizeof(dep));
    memset(sun, -1, sizeof(sun));
    memset(col, false, sizeof(col));;
    memset(pathf, -1, sizeof(pathf));
}

int dfs(int u) {
    int i, v, re = 1, tm = 0, sid = u;
    for (i = 0;i < V[u].size();i++) {
        v = V[u][i];
        if (flag[v] == ca) continue;
        flag[v] = ca;
        int t = dfs(v);
        if (t > tm) tm = t, sid = v;
        re += t;
    }
    sun[u] = sid;
    return re;
}

void dfs1(int u, int f, int top, int d, int id) {
    dep[u] = d, tid[u] = id, pathf[u] = top, fa[u] = f;
    if (tid[sun[u]] == -1) dfs1(sun[u], u, top, d+1, id+1);
    if (isbuild[top] != ca) {
        weight[top] = build(0, id+1);
        light[top] = build(0, id+1);
        isbuild[top] = ca;
    }
    for (int i = 0;i < V[u].size();i++) {
        int v = V[u][i];
        if (tid[v] != -1) continue;
        dfs1(v, u, v, d+1, 0);
    }
}

int cal(int u) {
    int f = fa[u];
    return col[u]^query(light[pathf[f]], tid[f], tid[f]+1);
}

void reverse1(int u, int v) {
    while (pathf[u] != pathf[v]) {
        if (dep[pathf[u]] < dep[pathf[v]]) swap(u, v);
        update(weight[pathf[u]], 1, tid[u]+1);
        u = pathf[u];
        col[u] ^= 1;
        u = fa[u];
    }
    if (tid[u] > tid[v]) swap(u, v);
    update(weight[pathf[u]], tid[u]+1, tid[v]+1);
}

void reverse2(int u, int v) {
    while (pathf[u] != pathf[v]) {
        if (dep[pathf[u]] < dep[pathf[v]]) swap(u, v);
        update(light[pathf[u]], 0, tid[u]+1);
        update(weight[pathf[u]], tid[u]+1, tid[u]+2);
        u = pathf[u];
        col[u] ^= 1;
        u = fa[u];
    }
    if (tid[u] > tid[v]) swap(u, v);
    update(light[pathf[u]], tid[u], tid[v]+1);
    if (u == pathf[u]) {
        col[u] ^= 1;
    }else {
        update(weight[pathf[u]], tid[u], tid[u]+1);
    }
    update(weight[pathf[u]], tid[v]+1, tid[v]+2);
}

int sum(int u, int v) {
    int re = 0;
    while (pathf[u] != pathf[v]) {
        if (dep[pathf[u]] < dep[pathf[v]]) swap(u, v);
        re += query(weight[pathf[u]], 1, tid[u]+1);
        u = pathf[u];
        re += cal(u);
        u = fa[u];
    }
    if (tid[u] > tid[v]) swap(u, v);
    re += query(weight[pathf[u]], tid[u]+1, tid[v]+1);
    return re;
}

inline int in() {
    int tm = 0;
    char c;
    c = getchar();
    while (c < '0' || c > '9') c = getchar();
    while (c >= '0' && c <= '9') {
        tm = tm*10+c-'0';
        c = getchar();
    }
    return tm;
}

int main() {
    int T, n, m, u, v, i, q;
    T = in();
    while (T--) {
        n = in();
        init();
        for (i = 0;i < n;i++) V[i].clear();
        for (i = 0;i < n-1;i++) {
            u = in(), v = in();
            u--, v--;
            V[u].push_back(v), V[v].push_back(u);
        }
        flag[0] = ca;
        dfs(0);
        dfs1(0, -1, 0, 0, 0);//建树完毕
        m = in();
        while (m--) {
           q = in(), u = in(), v = in();// scanf("%d%d%d", &q, &u, &v);
            v--, u--;
            if (q == 1) {
                reverse1(u, v);
            }else if (q == 2) {
                reverse2(u, v);
            }else {
                printf("%d\n", sum(u, v));
            }
        }
    }
}