SPOJ COT2 Count on a tree II（树上莫队）

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

You are given a tree with N nodes.The tree nodes are numbered from 1 to N.Each node has an integer weight.

We will ask you to perfrom the following operation:

• u v : ask for how many different integers that represent the weight of nodes there are on the path from u to v.

Input

In the first line there are two integers N and M.(N<=40000,M<=100000)

In the second line there are N integers.The ith integer denotes the weight of the ith node.

In the next N-1 lines,each line contains two integers u v,which describes an edge (u,v).

In the next M lines,each line contains two integers u v,which means an operation asking for how many different integers that represent the weight of nodes there are on the path from u to v.

Output

For each operation,print its result.

题目大意：给一棵树，每个点有一个权值。多次询问路径(a, b)上有多少个权值不同的点。

思路：参考VFK WC 2013 糖果公园 park 题解（此题比COT2要难。）

http://vfleaking.blog.163.com/blog/static/174807634201311011201627/

代码（2.37S）：

#include <bits/stdc++.h>
using namespace std;

const int MAXV = 40010;
const int MAXE = MAXV << 1;
const int MAXQ = 100010;
const int MLOG = 20;

namespace Bilibili {

int head[MAXV], val[MAXV], ecnt;
int to[MAXE], next[MAXE];
int n, m;

int stk[MAXV], top;
int block[MAXV], bcnt, bsize;

struct Query {
    int u, v, id;
    void read(int i) {
        id = i;
        scanf("%d%d", &u, &v);
    }
    void adjust() {
        if(block[u] > block[v]) swap(u, v);
    }
    bool operator < (const Query &rhs) const {
        if(block[u] != block[rhs.u]) return block[u] < block[rhs.u];
        return block[v] < block[rhs.v];
    }
} ask[MAXQ];
int ans[MAXQ];
/// Graph
void init() {
    memset(head + 1, -1, n * sizeof(int));
    ecnt = 0;
}

void add_edge(int u, int v) {
    to[ecnt] = v; next[ecnt] = head[u]; head[u] = ecnt++;
    to[ecnt] = u; next[ecnt] = head[v]; head[v] = ecnt++;
}

void gethash(int a[], int n) {
    static int tmp[MAXV];
    int cnt = 0;
    for(int i = 1; i <= n; ++i) tmp[cnt++] = a[i];
    sort(tmp, tmp + cnt);
    cnt = unique(tmp, tmp + cnt) - tmp;
    for(int i = 1; i <= n; ++i)
        a[i] = lower_bound(tmp, tmp + cnt, a[i]) - tmp + 1;
}

void read() {
    scanf("%d%d", &n, &m);
    for(int i = 1; i <= n; ++i) scanf("%d", &val[i]);
    gethash(val, n);
    init();
    for(int i = 1, u, v; i < n; ++i) {
        scanf("%d%d", &u, &v);
        add_edge(u, v);
    }
    for(int i = 0; i < m; ++i) ask[i].read(i);
}
/// find_block
void add_block(int &cnt) {
    while(cnt--) block[stk[--top]] = bcnt;
    bcnt++;
    cnt = 0;
}

void rest_block() {
    while(top) block[stk[--top]] = bcnt - 1;
}

int dfs_block(int u, int f) {
    int size = 0;
    for(int p = head[u]; ~p; p = next[p]) {
        int v = to[p];
        if(v == f) continue;
        size += dfs_block(v, u);
        if(size >= bsize) add_block(size);
    }
    stk[top++] = u;
    size++;
    if(size >= bsize) add_block(size);
    return size;
}

void init_block() {
    bsize = max(1, (int)sqrt(n));
    dfs_block(1, 0);
    rest_block();
}
/// ask_rmq
int fa[MLOG][MAXV];
int dep[MAXV];

void dfs_lca(int u, int f, int depth) {
    dep[u] = depth;
    fa[0][u] = f;
    for(int p = head[u]; ~p; p = next[p]) {
        int v = to[p];
        if(v != f) dfs_lca(v, u, depth + 1);
    }
}

void init_lca() {
    dfs_lca(1, -1, 0);
    for(int k = 0; k + 1 < MLOG; ++k) {
        for(int u = 1; u <= n; ++u) {
            if(fa[k][u] == -1) fa[k + 1][u] = -1;
            else fa[k + 1][u] = fa[k][fa[k][u]];
        }
    }
}

int ask_lca(int u, int v) {
    if(dep[u] < dep[v]) swap(u, v);
    for(int k = 0; k < MLOG; ++k) {
        if((dep[u] - dep[v]) & (1 << k)) u = fa[k][u];
    }
    if(u == v) return u;
    for(int k = MLOG - 1; k >= 0; --k) {
        if(fa[k][u] != fa[k][v])
            u = fa[k][u], v = fa[k][v];
    }
    return fa[0][u];
}
/// modui
bool vis[MAXV];
int diff, cnt[MAXV];

void xorNode(int u) {
    if(vis[u]) vis[u] = false, diff -= (--cnt[val[u]] == 0);
    else vis[u] = true, diff += (++cnt[val[u]] == 1);
}

void xorPathWithoutLca(int u, int v) {
    if(dep[u] < dep[v]) swap(u, v);
    while(dep[u] != dep[v])
        xorNode(u), u = fa[0][u];
    while(u != v)
        xorNode(u), u = fa[0][u],
        xorNode(v), v = fa[0][v];
}

void moveNode(int u, int v, int taru, int tarv) {
    xorPathWithoutLca(u, taru);
    xorPathWithoutLca(v, tarv);
    //printf("debug %d %d
", ask_lca(u, v), ask_lca(taru, tarv));
    xorNode(ask_lca(u, v));
    xorNode(ask_lca(taru, tarv));
}

void make_ans() {
    for(int i = 0; i < m; ++i) ask[i].adjust();
    sort(ask, ask + m);
    int nowu = 1, nowv = 1; xorNode(1);
    for(int i = 0; i < m; ++i) {
        moveNode(nowu, nowv, ask[i].u, ask[i].v);
        ans[ask[i].id] = diff;
        nowu = ask[i].u, nowv = ask[i].v;
    }
}

void print_ans() {
    for(int i = 0; i < m; ++i)
        printf("%d
", ans[i]);
}

void solve() {
    read();
    init_block();
    init_lca();
    make_ans();
    print_ans();
}

};

int main() {
    Bilibili::solve();
}