SPOJ COT2 树上找路径上不同值的个数

 题目大意

给出多个询问u ， v ， 求出u-v路径上点权值不同的个数

开始做的是COT1，用主席树写过了，理解起来不难

很高兴的跑去做第二道，完全跟普通数组区间求k个不同有很大区别，完全没思路

膜拜http://www.cnblogs.com/oyking/p/4265823.html

这里利用莫队思想来做，在树上分块，尽可能让相连部分作为一个联通块，那么就在dfs过程中加个手写栈，如果回溯上来的时候保存的值的个数超过每块中应有的

个数那么就将他们分到同一个id块

排序也是跟普通莫队上一样，按分块编号排序，这里有两个端点，那么就先将编号小的摆在前面在排序

离线排序做好了，剩下就是转移的问题，从当前一条路径转移到下一条，diff保存了之前记录的路径上不同点的个数

之前是u，v ， 现在去curu ， curv ， 那么先找到u-curu路径上的点，添加进来，v-curv路径上的点添加进来

画个图可以看出这是原来的路径基础上不需要的点会被再多访问一次，那些需要的点要么本身在原基础上不再访问，要么又多访问两次保持不变，像异或一样

所以记录当前点有没有被访问奇数次就行了，多访问就翻转

最后会有多余的点没有被访问到，就是LCA(u,v) LCA(curu , curv) ， 这个要在访问一次即可

这里因为是分块的，所以跑的是曼哈顿距离的询问区间，不会超时

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

#define N 40010
int first[N] , k;
int block[N] , sz;//对应分到的块的编号和每块应含的大小
int _stack[N] , top , cursz , ID;//手写栈
int n , m;
int hash[N] , a[N] , b[N];

struct Edge{
    int x , y , next;
    Edge(){}
    Edge(int x , int y , int next):x(x),y(y),next(next){}
}e[N<<1];

void add_edge(int x , int y)
{
    e[k] = Edge(x , y , first[x]);
    first[x] = k++;
}

int dp[N<<1][30] , id[N<<1] , dep[N<<1] , No[N] , fa[N] , dfs_clock;
int depth[N];

void add_block(int &cursz , int ID)
{
    while(cursz){
        block[_stack[--top]] = ID;
       // cout<<"IN: "<<ID<<" "<<_stack[top]<<" "<<top<<" "<<sz<<endl;
        cursz--;
    }
}

void dfs(int u , int f , int d)
{
    id[++dfs_clock] = u , No[u] = dfs_clock , dep[dfs_clock] = d;
    fa[u] = f , depth[u] = d;
    for(int i=first[u] ; ~i ; i=e[i].next){
        int v = e[i].y;
        if(v == f) continue;
        dfs(v , u , d+1);
        id[++dfs_clock] = u , dep[dfs_clock] = d;
    }
    //树上分块重要部分
    cursz++;
    _stack[top++] = u;
    if(cursz>=sz) add_block(cursz , ++ID);
}

void ST(int n)
{
    for(int i=1 ; i<=n ; i++) dp[i][0] = i;
    for(int j=1 ; (1<<j)<=n ; j++){
        for(int i=1 ; i+(1<<j)-1<=n ; i++){
            int a = dp[i][j-1] , b=dp[i+(1<<(j-1))][j-1];
            dp[i][j] = dep[a]<dep[b]?a:b;
        }
    }
}

int RMQ(int l , int r)
{
    int k=0;
    while((1<<(k+1))<=r-l+1) k++;
    int a = dp[l][k] , b = dp[r-(1<<k)+1][k];
    return dep[a]<dep[b]?a:b;
}

int LCA(int u , int v)
{
    int x=No[u] , y=No[v];
    if(x>y) swap(x , y);
    return id[RMQ(x,y)];
}

void get_hash(int n){
    for(int i=1 ; i<=n ; i++)
        hash[i] = lower_bound(b+1 , b+n+1 , a[i])-b;
}

struct Query{
    int u , v , id;
    void reset(){
        if(block[u]>block[v]) swap(u , v);
    }
    bool operator<(const Query &m) const{
        return block[u]<block[m.u]||(block[u]==block[m.u] && block[v]<block[m.v]);
    }
    void in(int i){scanf("%d%d" , &u , &v);id=i;}
}qu[100010];

int ans[100010] , vis[N] , cnt[N] , diff;

void xorNode(int x)
{
   // cout<<"xor: "<<x<<endl;
    if(vis[x]) vis[x]=false , diff -= (--cnt[hash[x]]==0);
    else vis[x] = true , diff += (++cnt[hash[x]]==1);
}

void xorPath(int x , int y)
{
   // cout<<"path: "<<x<<" "<<y<<endl;
    if(depth[x]<depth[y]) swap(x , y);
    while(depth[x]>depth[y]){
        xorNode(x);
        x = fa[x];
    }
    while(x!=y){
        xorNode(x) , xorNode(y);
        x = fa[x] , y=fa[y];
    }
}

void debug()
{
  //  for(int i=1 ; i<=n ; i++) cout<<"i: "<<block[i]<<" "<<hash[i]<<" fa: "<<fa[i]<<" "<<depth[i]<<endl;
    cout<<"test: "<<LCA(7,8)<<" "<<LCA(7 , 1)<<endl;
}
void solve()
{
    sz = (int)sqrt(n+0.5);
    dfs(1 , 0 , 1);
    ST(n*2-1);
    add_block(cursz , ++ID);
  //  debug();
    for(int i=0 ; i<m ; i++){
        qu[i].in(i);
        qu[i].reset();
    }
    sort(qu , qu+m);
    memset(vis , 0 , sizeof(vis));
    diff = 0;
    int curu=1 , curv=1;
    xorNode(1);
    for(int i=0 ; i<m ; i++){
        xorPath(curu , qu[i].u);
        xorPath(curv , qu[i].v);
        xorNode(LCA(curu , curv));
        xorNode(LCA(qu[i].u , qu[i].v));
        curu = qu[i].u , curv = qu[i].v;
        ans[qu[i].id] = diff;
       // cout<<"----华丽的分割线---"<<endl;
    }
    for(int i=0 ; i<m ; i++) printf("%d
" , ans[i]);
}

int main()
{
  //  freopen("in.txt" , "r" , stdin);
    scanf("%d%d" , &n , &m);
    for(int i=1 ; i<=n ; i++) scanf("%d" , &a[i]) , b[i]=a[i];
    sort(b+1 , b+n+1);
    get_hash(n);
    int x , y;
    memset(first , -1 , sizeof(first));
    top = cursz = ID = k = 0;
    for(int i=1 ; i<n ; i++){
        scanf("%d%d" , &x , &y);
        add_edge(x , y);
        add_edge(y , x);
    }
    solve();
    return 0;
}