BZOJ3757【树上莫队算法】

/* I will wait for you*/

#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <cmath>
#include <ctime>
#include <algorithm>
#include <iostream>
#include <fstream>
#include <vector>
#include <queue>
#include <deque>
#include <map>
#include <set>
#include <string>
#define make make_pair
#define fi first
#define se second

using namespace std;

typedef long long ll;
typedef unsigned long long ull;
typedef pair<int,int> pii;

const int maxn = 100010;
const int maxm = 1010;
const int maxs = 26;
const int inf = 0x3f3f3f3f;
const int P = 1000000007;
const double error = 1e-9;

inline int read()
{
int x = 0, f = 1;
char ch = getchar();
while (ch <= 47 || ch >= 58)
f = (ch == 45 ? -1 : 1), ch = getchar();
while (ch >= 48 && ch <= 57)
x = x * 10 + ch - 48, ch = getchar();
return x * f;
}

struct edge
{
int v, next;
} e[maxn];

struct query
{
int u, v, a, b, pos;
} q[maxn];

int n, m, blnum, ans, cnt, top, root, clo,
head[maxn], res[maxn], fa[maxn][20], bel[maxn], deep[maxn], bin[maxn],
size[maxn], dfn[maxn], vis[maxn], co[maxn], in[maxn], s[maxn];

void insert(int u, int v)
{
e[cnt] = (edge) {v, head[u]}, head[u] = cnt++;
e[cnt] = (edge) {u, head[v]}, head[v] = cnt++;
}

void dfs(int u)
{
dfn[u] = ++clo;

for (int i = 1; i <= 16; i++)
if (deep[u] >= bin[i])
fa[u][i] = fa[fa[u][i - 1]][i - 1];
else
break;

for (int i = head[u]; i != -1; i = e[i].next) {
int v = e[i].v;

if (v != fa[u][0]) {
fa[v][0] = u, deep[v] = deep[u] + 1;
dfs(v), size[u] += size[v];

if (size[u] >= 300) {
blnum++;
for (int j = 1; j <= size[u]; j++)
bel[s[top--]] = blnum;
size[u] = 0;
}
}
}

s[++top] = u, size[u]++;
}

int lca(int u, int v)
{
if (deep[u] < deep[v])
swap(u, v);

int t = deep[u] - deep[v];

for (int i = 0; i <= 16; i++)
if (t & bin[i])
u = fa[u][i];

for (int i = 16; 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];
}

void reverse(int u)
{
if (vis[u] == 0 && (in[co[u]]++) == 0)
ans++;
if (vis[u] == 1 && (--in[co[u]]) == 0)
ans--;
vis[u] ^= 1;
}

void solve(int u, int v)
{
while (u != v) {
if (deep[u] < deep[v])
swap(u, v);
reverse(u), u = fa[u][0];
}
}

bool cmp(query a, query b)
{
return bel[a.u] < bel[b.u] ||
bel[a.u] == bel[b.u] && dfn[a.v] < dfn[b.v];
}

int main()
{
for (int i = 0; i <= 16; i++)
bin[i] = (1 << i);

n = read(), m = read();

for (int i = 1; i <= n; i++)
co[i] = read();

memset(head, -1, sizeof head);

for (int i = 1; i <= n; i++) {
int u = read(), v = read();

if (!u)
root = v;
if (!v)
root = u;

if (u && v)
insert(u, v);
}

dfs(root), blnum++;

while (top)
bel[s[top--]] = blnum;

for (int i = 1; i <= m; i++) {
q[i].u = read(), q[i].v = read();
q[i].a = read(), q[i].b = read();
q[i].pos = i;
}

sort(q + 1, q + 1 + m, cmp);

for (int i = 1; i <= m; i++) {
if (i == 1)
solve(q[i].u, q[i].v);

else {
solve(q[i - 1].u, q[i].u);
solve(q[i - 1].v, q[i].v);
}

int t = lca(q[i].u, q[i].v);

reverse(t), res[q[i].pos] = ans;

if (in[q[i].a] && in[q[i].b] && q[i].a != q[i].b)
res[q[i].pos]--;

reverse(t);
}

for (int i = 1; i <= m; i++)
printf("%d\n", res[i]);

return 0;
}