SPOJ-COT2 Count on a tree II （树上莫队 ，欧拉序)

题目描述

给定一个n个节点的树，每个节点表示一个整数，问u到v的路径上有多少个不同的整数。

输入格式

第一行有两个整数n和m（n＝40000，m＝100000）。
第二行有n个整数。第i个整数表示第i个节点表示的整数。
在接下来的n-1行中，每行包含两个整数u v，描述一条边（u，v）。
在接下来的m行中，每一行包含两个整数u v，询问u到v的路径上有多少个不同的整数。

输出格式

对于每个询问，输出结果。

输入输出样例

输入 #1

8 2
105 2 9 3 8 5 7 7
1 2
1 3
1 4
3 5
3 6
3 7
4 8
2 5
7 8

输出 #1

4
4

思路：

有一道莫队入门题是求区间内不同数的个数

这题直接就是树上路径中不同点权的个数
想用莫队首先要把树上问题转化成序列问题，可以想到dfs序
这题要用欧拉序，因为dfs序无法判断lca的贡献

写这题之前没听过欧拉序，其实和dfs序差不多
dfs序转区间的是在入点时L[x]=++tot,出点时R[x]=tot，R[x]其实是不在序列中的
欧拉序在入点时也是L[x]=++tot，但是出点时R[x]=++tot
也就是把出点的时间也加入序列

设要求x和y路径上的不同点权个数
L[x]为入x的时间，R[x]为出x的时间，y同理
假设L[x]<L[y]，即dfs先搜到x再搜到y

两种情况：
1.lca(x,y)=x，这时候xy在同一条链，则**L[x]到L[y]**中出现过一次的点对答案有贡献
注意这里是L[x]到L[y]

只有出现一次的才有贡献是因为:
一个点在L[x]到L[y]中要不出现一次要不出现两次，如果出现两次说明进入这个点之后又出来了，而树上路径指的是最短路径，x到y每个点只经过一次，所以序列中出现两次的都不在x到y的路径上（画图模拟一下可以看出来）

2.lca(x,y)!=x，这时候xy不在同一条链，则**R[x]到L[y]**中出现过一次的点对答案有贡献，且lca(x,y)对答案有贡献，要特判一下lca
注意这里是R[x]到L[y]

lca也要统计是因为R[x]到L[y]中没有lca(x,y)而lca(x,y)也对答案有贡献，所以要特判一下

code：

#include<cstring>
#include<cstdio>
#include<iostream>
#include<cmath>
#include<algorithm>
#include<vector>
using namespace std;
const int maxm=1e5+5;
struct Node{
    int l,r,lca,id;
}q[maxm];
int d[maxm],fa[maxm],sz[maxm],son[maxm],top[maxm],L[maxm],R[maxm],rk[maxm],tot;
vector<int>g[maxm];
int a[maxm];
int xx[maxm],num;
int n,m;
int block;
int mark[maxm];
int cnt[maxm];
int res[maxm],ans;
bool cmp(Node a,Node b){
    if(a.l/block!=b.l/block)return a.l<b.l;
    return a.r<b.r;
}
void dfs1(int x){//树剖dfs1
    sz[x]=1;
    d[x]=d[fa[x]]+1;
    int len=g[x].size();
    for(int i=0;i<len;i++){
        int v=g[x][i];
        if(v==fa[x])continue;
        fa[v]=x;
        dfs1(v);
        sz[x]+=sz[v];
        if(sz[son[x]]<sz[v]){
            son[x]=v;
        }
    }
}
void dfs2(int x,int tp){//树剖dfs2
    top[x]=tp;
    L[x]=++tot;
    rk[tot]=x;//欧拉序对应的点
    if(son[x]){
        dfs2(son[x],tp);
    }
    int len=g[x].size();
    for(int i=0;i<len;i++){
        int v=g[x][i];
        if(v==fa[x]||v==son[x])continue;
        dfs2(v,v);
    }
    R[x]=++tot;//欧拉序出点的时候=++tot，而dfs序直接=tot，这是两者的区别
    rk[tot]=x;//欧拉序对应的点
}
int getlca(int x,int y){//lca
    while(top[x]!=top[y]){
        if(d[top[x]]<d[top[y]]){
            swap(x,y);
        }
        x=fa[top[x]];
    }
    if(d[x]>d[y])swap(x,y);
    return x;
}
void add(int x){//add
    cnt[a[x]]++;
    if(cnt[a[x]]==1)ans++;
}
void del(int x){//del
    cnt[a[x]]--;
    if(cnt[a[x]]==0)ans--;
}
void cal(int x){//判断是add还是del
    if(mark[x])del(x);//如果出现过就删除
    else add(x);//如果没出现过就添加
    mark[x]^=1;//修改mark的状态
}
int main(){
    scanf("%d%d",&n,&m);
    block=sqrt(n);//block
    for(int i=1;i<=n;i++){
        scanf("%d",&a[i]);
        xx[i]=a[i];
    }
    sort(xx+1,xx+1+n);//离散化
    num=unique(xx+1,xx+1+n)-xx-1;
    for(int i=1;i<=n;i++){
        a[i]=lower_bound(xx+1,xx+1+num,a[i])-xx;
    }
    for(int i=1;i<n;i++){
        int a,b;
        scanf("%d%d",&a,&b);
        g[a].push_back(b);
        g[b].push_back(a);
    }
    dfs1(1);
    dfs2(1,1);
    for(int i=1;i<=m;i++){
        int x,y;
        scanf("%d%d",&x,&y);
        if(L[x]>L[y])swap(x,y);
        int lca=getlca(x,y);
        q[i].id=i;
        if(lca==x){
            q[i].l=L[x],q[i].r=L[y];
            q[i].lca=0;
        }else{
            q[i].l=R[x],q[i].r=L[y];
            q[i].lca=lca;
        }
    }
    sort(q+1,q+1+m,cmp);//询问排序
    int l=q[1].l,r=l-1;
    for(int i=1;i<=m;i++){//莫队
        int ql=q[i].l,qr=q[i].r;
        while(l<ql)cal(rk[l++]);//rk是欧拉序对应节点
        while(l>ql)cal(rk[--l]);
        while(r<qr)cal(rk[++r]);
        while(r>qr)cal(rk[r--]);
        if(q[i].lca)cal(q[i].lca);//特判lca
        res[q[i].id]=ans;
        if(q[i].lca)cal(q[i].lca);//消除影响
    }
    for(int i=1;i<=m;i++){
        printf("%d\n",res[i]);
    }
    return 0;
}