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

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

参考博客：http://www.cnblogs.com/xcw0754/p/4763804.html
上面这个人推导部分写的简洁明了，方便理解，但是最后的分情况讨论有些迷，感觉是不必要的，更简洁的思路看下面的博客

传送门：http://blog.csdn.net/kuribohg/article/details/41458639

题意是这样的，给你一棵无根树，给你m个查询，每次查询输出节点x到节点y路径上不同颜色的节点有多少个（包括xy）

没什么说的，直接上代码吧

#include<cstdio>
#include<cstring>
#include<iostream>
#include<algorithm>
#include<cmath>
#include<vector>
using namespace std;
int const MAX_N=40000+5;
int const MAX_M=100000+5;
int n,m,ans,nowLca,lastL,lastR,tempAns;
int color[MAX_N];
vector<int> allColor;
vector<int>::iterator it;
int lin[MAX_N],e_cnt;
struct Query{
    int x;
    int y;
    int id;
    int ans;
}query[MAX_M];
struct Edge{
    int next;
    int y;
}e[2*MAX_N];
void insert(int u,int v){
    e[++e_cnt].next=lin[u];
    e[e_cnt].y=v;
    lin[u]=e_cnt;
}
int b_len,b_cnt,bk[MAX_N];
int fa[MAX_N][20],deep[MAX_N];
int n_cnt,dfn[MAX_N],top,stack[MAX_N];
bool vis[MAX_N];
void dfs(int u){
    dfn[u]=++n_cnt;
    int btm=top;
    for(int i=lin[u];i;i=e[i].next){
        int v=e[i].y;
        if(!dfn[v]){
            fa[v][0]=u;
            deep[v]=deep[u]+1;
            dfs(v);
            if(top-btm>=b_len){
                b_cnt++;
                while(top>btm){
                    bk[stack[top--]]=b_cnt;
                }
            }
        }
    }
    stack[++top]=u;
}
bool queryCmp_xkb_ydfn(Query a,Query b){
    if(bk[a.x]==bk[b.x])return dfn[a.y]<dfn[b.y];
    return bk[a.x]<bk[b.x];
}
bool queryCmp_id(Query a,Query b){
    return a.id<b.id;
}
int lca(int u,int v){
    if(deep[u]<deep[v])swap(u,v);
    for(int i=17;~i;i--)
        if(deep[fa[u][i]]>=deep[v])
            u=fa[u][i];
    if(u == v) return u;
    for(int i=17;~i;i--)
        if(fa[u][i]!=fa[v][i])
            u=fa[u][i],v=fa[v][i];
    return fa[u][0];
}
int c_cnt[MAX_N];
void MoveToLca(int u){
    for(;u!=nowLca;u=fa[u][0]){
        if(vis[u]){
            vis[u]=false;
            c_cnt[color[u]]--;
            if(!c_cnt[color[u]])ans--;
        }else{
            vis[u]=true;
            if(!c_cnt[color[u]])ans++;
            c_cnt[color[u]]++;
        }
    }
}
int GetAns(int x,int u,int v){
    int tlca=lca(u,v);
    if(c_cnt[color[tlca]])return x;
    else return x+1;
}

void FirstMo(){
    int L=query[1].x,R=query[1].y;
    nowLca=lca(L,R);
    MoveToLca(L);
    MoveToLca(R);
    query[1].ans=GetAns(ans,L,R);
    lastL=L;lastR=R;
}
int main()
{
    while(~scanf("%d%d",&n,&m)){
        allColor.clear();
        //read colors
        for(int i=1;i<=n;i++){
            scanf("%d",&color[i]);
            allColor.push_back(color[i]);
        }
        //Discretization the color
        sort(allColor.begin(),allColor.end());
        it=unique(allColor.begin(),allColor.end());
        allColor.resize(distance(allColor.begin(),it));
        for(int i=1;i<=n;i++){
            color[i]=lower_bound(allColor.begin(),allColor.end(),color[i])-allColor.begin()+1;
        }
        //read the tree
        memset(lin,0,sizeof(lin));
        e_cnt=0;
        for(int i=1;i<n;i++){
            int u,v;
            scanf("%d%d",&u,&v);
            insert(u,v);
            insert(v,u);
        }
        //divide in blocks
        //prepare for lca: get deep, dfs order, get father
        b_len=sqrt((double)n);
        b_cnt=0;
        n_cnt=0;
        top=0;
        deep[0]=0,deep[1]=1;
        memset(fa,0,sizeof(fa));
        memset(dfn,0,sizeof(dfn));
        memset(vis,0,sizeof(vis));
        memset(stack,0,sizeof(stack));
        dfs(1);
        b_cnt++;
        while(top){
            bk[stack[top--]]=b_cnt;
        }
        for(int i = 1; (1<<i) <= n; i++)
            for(int j = 1; j <= n; j++)
                fa[j][i] = fa[fa[j][i-1]][i-1];
        //read the query
        for(int i=1;i<=m;i++){
            scanf("%d%d",&query[i].x,&query[i].y);
            query[i].id=i;
            if(dfn[query[i].x]>dfn[query[i].y])
                swap(query[i].x,query[i].y);
        }
        //mo's algorithm
        sort(query+1,query+m+1,queryCmp_xkb_ydfn);
        memset(vis,0,sizeof(vis));
        memset(c_cnt,0,sizeof(c_cnt));
        lastL=1,lastR=1,ans=0;
        for(int i=1;i<=m;i++){
            int L=query[i].x,R=query[i].y;
            nowLca=lca(L,lastL);
            MoveToLca(L);
            MoveToLca(lastL);
            nowLca=lca(R,lastR);
            MoveToLca(R);
            MoveToLca(lastR);
            query[i].ans=GetAns(ans,L,R);
            lastL=L;lastR=R;
        }
        sort(query+1,query+m+1,queryCmp_id);
        for(int i=1;i<=m;i++){
            printf("%d
",query[i].ans);
        }
    }
    return 0;
}

wa了无数发，最后发现是dfs的时候用vis数组判断点是否访问过，结果忘记初始化vis[1]了。。。。好蠢，后来改成了直接用dfn数组判断是否访问过了，本意是节省资源，结果居然A了。。。人生处处是惊喜。

这里顺便总结下lca写法吧。

这里的是倍增法求LCA

int fa[MAX_N][20],deep[MAX_N];
int dfn[MAX_N];

void dfs(int u){
    dfn[u]=++n_cnt;
    for(int i=lin[u];i;i=e[i].next){
        int v=e[i].y;
        if(!dfn[v]){
            fa[v][0]=u;
            deep[v]=deep[u]+1;
            dfs(v);
        }
    }
}
int lca(int u,int v){
    if(deep[u]<deep[v])swap(u,v);
    for(int i=17;~i;i--)
        if(deep[fa[u][i]]>=deep[v])
            u=fa[u][i];
    if(u == v) return u;
    for(int i=17;~i;i--)
        if(fa[u][i]!=fa[v][i])
            u=fa[u][i],v=fa[v][i];
    return fa[u][0];
}

int main()
{
        n_cnt=0;
        deep[0]=0,deep[1]=1;
        memset(fa,0,sizeof(fa));
        memset(dfn,0,sizeof(dfn));
        dfs(1);

        for(int i = 1; (1<<i) <= n; i++)
            for(int j = 1; j <= n; j++)
                fa[j][i] = fa[fa[j][i-1]][i-1];
            return 0;
}

dfn换成vis也是一样的

首先初始化deep数组表示节点深度，然后是fa[i][j]表示节点i的第2^j的父亲节点是什么，

先dfs求出deep和直系父亲

然后双重循环处理fa数组

lca的时候，先对齐u和v，就是让他们处于同一深度，然后一起向上，直到lca的儿子为止，返回他的父亲，就是lca。