SPOJ--Count on a tree II(树上莫队)

Description

 

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.

Example

Input:

8 5 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

Output: 4
4 

 #include <iostream>
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#include <cmath>
#include <queue>
#include <string>
#include <set>
#include <stack>
using namespace std;
#define LL long long int
#define maxn 100800
#define maxm 210008
int vv[maxm],nxt[maxm],first[maxn],e,deep;
void init()
{
memset(first,-1,sizeof(first));
e = deep = 0;
}
void addedge(int u,int v)
{
vv[e] = v; nxt[e] = first[u]; first[u] = e++;
vv[e] = u; nxt[e] = first[v]; first[v] = e++;
}
int val[maxn],in[maxn],out[maxn];
int col[maxn],a[maxn],dep[maxn];
int lisan[maxm],cnt;
int fa[maxn][20];
int ID(int x)
{
return lower_bound(lisan,lisan+cnt,x) - lisan;
}

void dfs(int u,int pre)
{
in[u] = ++deep; a[deep] = val[u];
col[deep] = 1; dep[u] = dep[pre] + 1;
for(int i = 0;fa[u][i];i++)
fa[u][i+1] = fa[fa[u][i]][i];
for(int i = first[u];i != -1;i = nxt[i])
{
int v = vv[i];
if(v != pre)
fa[v][0] = u,dfs(v,u);
}
out[u] = ++deep; a[deep] = val[u];
col[deep] = -1;
}
int jump(int u,int d)
{
for(int i = 0;d;i++) if(d >> i & 1)
u = fa[u][i],d -= 1 << i;
return u;
}
int lca(int u,int v)
{
if(dep[u] < dep[v]) swap(u,v);
u = jump(u,dep[u] - dep[v]);
for(int i = 19;i >= 0;i--)
if(fa[u][i] != fa[v][i])
u = fa[u][i],v = fa[v][i];
return u == v ? u:fa[u][0];
}

int B;
struct Q
{
int u,v;
int b,id;
void scan(int i)
{
id = i;
scanf("%d%d",&u,&v);
if(in[u] > in[v]) swap(u,v);
b = in[u] / B;
}
bool operator < (const Q & a) const
{
return b < a.b || a.b == b && in[v] < in[a.v];
}
}q[maxm];
int F,U,V;
int ans,num[maxn];
int sum[maxn];
void gao(int x,int k)
{
int pre = num[x];
num[x] += k;
if(pre == 0 && num[x] == 1) ++ans;
if(pre == 1 && num[x] == 0) --ans;
}
int solve( int f, int u, int v )
{
while( F < f ){
++F;
gao( a[F], -col[F] );
gao( a[F], -col[F] );
}
while( F > f ){
gao( a[F], col[F] );
gao( a[F], col[F] );
--F;
}
gao( a[f], col[f] );

while( U < u ){
++U;
gao( a[U], col[U] );
}
while( U > u ){
gao( a[U], -col[U] );
--U;
}
while( V < v ){
++V;
gao( a[V], col[V] );
}
while( V > v ){
gao( a[V], -col[V] );
--V;
}
int tmp = ans;
gao( a[f], -col[f] );
return tmp;
}
int main()
{
int n,m,u,v;
scanf("%d%d",&n,&m);
cnt = 0;
init();
for(int i = 1;i <= n;i++)
{
scanf("%d",&val[i]);
lisan[cnt++] = val[i];
}
sort(lisan,lisan+cnt);
cnt = unique(lisan,lisan+cnt) - lisan;
for(int i = 1;i <= n;i++) val[i] = ID(val[i]);
memset(first,-1,sizeof(first));
e = 0;
for(int i = 1;i < n;i++)
{
scanf("%d%d",&u,&v);
addedge(u,v);
}
B = sqrt(n+0.5);
memset(fa,0,sizeof(fa));
dfs(1,0);
for(int i = 0;i < m;i++)
q[i].scan(i);
sort(q,q+m);
memset( num, 0, sizeof(num) );
F = U = V = ans = 0;
int f;
for( int i = 0; i < m; ++i ){
u = q[i].u, v = q[i].v;
f = lca( u, v );
sum[q[i].id] = solve( in[f], in[u], in[v] );
}
for( int i = 0; i < m; ++i )
printf( "%d\n", sum[i] );
}