SP10707 COT2 - Count on a tree II【树上莫队】

传送门
给定一颗无根树，求树上两点路径上的节点有多少不同的数字
可以离线

分析

前提，能够通过某种操作，将树上路径问题，转化成区间问题
这样，类似于求区间不同数，区间众数，区间mex等操作就能通过莫队离线来做了
这里采用 欧拉序(相关性质介绍) 进行求解，将树链问题转化成区间问题

这里注意，欧拉序求解的过程中，需要统计路径上的不同数，同时还要统计$lca$的值，且，如果某个节点出现了偶数次，意味着不是链上的点，所以需要去掉偶数次的点

代码

//SP10707 
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll long long
#define int long long
#define FILE_OUT freopen("out", "w", stdout);
#define FILE_IN freopen("in", "r", stdin);
#define debug(x) cout << #x << ": " << x << "\n";
#define AC 0
#define WA 1
#define INF 0x3f3f3f3f
const ll MAX_N = 1e6+5;
const ll MOD = 1e9+7;
int N, M, K;

int arr[MAX_N];
int uniarr[MAX_N];
int unicnt = 0;

int head[MAX_N];
int tot = 0;
struct Edge {
	int to, nxt;
}edge[MAX_N];

void addEdge(int u, int v) {
	edge[tot].nxt = head[u];
	edge[tot].to = v;
	head[u] = tot++;
	edge[tot].nxt = head[v];
	edge[tot].to = u;
	head[v] = tot++;
}

int dep[MAX_N];
int father[MAX_N][21];
int dfn[MAX_N];
int out[MAX_N];
int sa[MAX_N];
int indx = 0;

void dfs(int u, int from) {
	dfn[u] = ++indx;
	sa[indx] = u;
	father[u][0] = from;
	dep[u] = dep[from] + 1;
	for (int i = 1; i <= 20; ++i) {
		father[u][i] = father[father[u][i-1]][i-1];
	}
	int v;
	for (int i = head[u];~i;i=edge[i].nxt) {
		if ((v=edge[i].to) == from) continue;
		dfs(v, u);
	}
	out[u] = ++indx;
	sa[indx] = u;
}

int LCA(int x, int y) {
	if (dep[x] > dep[y]) swap(x, y);
	for (int i = 20; i+1; --i) {
		if (dep[father[y][i]] >= dep[x]) y = father[y][i];
	}
	if (x == y) return x;
	for (int i = 20; i+1; --i) {
		if (father[x][i] != father[y][i]) {
			x = father[x][i];
			y = father[y][i];
		}
	}
	return father[x][0];
}

int block = 1;

int idb(int x) {
	return x / block;
}

struct Qr {
	int l, r, lca, id;
	bool operator < (const Qr& B) const {
		return idb(l) ^ idb(B.l) ? l < B.l : (idb(l) & 1) ? r < B.r : r > B.r;
	}
}qr[MAX_N];


Qr pre(int x, int y) {
	Qr res;
	if (dfn[x] > dfn[y]) swap(x, y);
	int lca = LCA(x, y);
	if (x != lca) {
		res.l = out[x];
		res.lca = lca;
	} else {
		res.l = dfn[x];
		res.lca = 0;
	}
	res.r = dfn[y];
	return res;
}

int ans[MAX_N];
int cnt[MAX_N];
int mo = 0;
bool vis[MAX_N];

void add(int x) {
	if (cnt[arr[x]]++);
	else ++mo;
}

void del(int x) {
	if (--cnt[arr[x]]);
	else --mo;
}

void go(int x) {
	x = sa[x];
	if (vis[x]) {
		del(x);
	} else {
		add(x);
	}
	vis[x] ^= 1;
}

int check(int x) {
	if (!x) return mo;
	if (cnt[arr[x]]) return mo;
	else return mo + 1;
}

void init() {
	memset(head, -1, sizeof head);
	memset(ans, 0, sizeof ans);
	memset(vis, 0, sizeof vis);
	memset(cnt, 0, sizeof vis);
	indx = 0;
	mo = 0;
	tot = 0;
}

void solve(){
	init();
	sc("%lld%lld", &N, &M);
	block = max(sqrt(2*N*2*N/M), 1.1);
	
	for (int i = 1; i <= N; ++i) {
		sc("%lld", &arr[i]);
		uniarr[i] = arr[i];
	}
	unicnt = N;
	
	int u, v;
	for (int i = 2; i <= N; ++i) {
		sc("%lld%lld", &u, &v);
		addEdge(u, v);
	}
	
	dfs(1, 1);
	
	for (int i = 1; i <= M; ++i) {
		sc("%lld%lld", &u, &v);
		qr[i] = pre(u, v);
		qr[i].id = i;
	}
	
	sort(qr+1, qr+1+M);
	sort(uniarr+1, uniarr+1+unicnt);
	unicnt = unique(uniarr+1, uniarr+1+unicnt) - uniarr - 1;
	
	for (int i = 1; i <= N; ++i) {
		arr[i] = lower_bound(uniarr+1, uniarr+1+unicnt, arr[i]) - uniarr;
	}
	
	int l = 1, r = 0;
	for (int i = 1; i <= M; ++i) {
		while (l > qr[i].l) go(--l);
		while (r < qr[i].r) go(++r);
		while (l < qr[i].l) go(l++);
		while (r > qr[i].r) go(r--);
		ans[qr[i].id] = check(qr[i].lca);
	}
	
	for (int i = 1; i <= M; ++i) {
		pr("%lld\n", ans[i]);
	}
}

signed main()
{
	#ifndef ONLINE_JUDGE
	//FILE_IN
	FILE_OUT
	#endif
	int T = 1;//cin >> T;
	while (T--) solve();

	return AC;
}