题意：
给出两棵树，每棵树的节点都有一个权值。
同一棵树上的节点的权值互不相同，不同树上节点的权值可以相同。
要求回答如下询问：
- (u_1 \, v_1 \, u_2 \, v_2)：询问第一棵树的路径(u_1 o v_1)的节点权值 与 第一棵树的路径(u_2 o v_2)的节点权值的交集的大小。
分析：
通用的思路是这样的：首先解决线性区间上的问题，然后用树链剖分来将树上问题转化为线性问题。
考虑两个序列之间求交集：给出两个序列(S_1, S_2)，(S_1)有(n_1)个元素(a_1, a_2, cdots , a_{n_1})，(S_2)有(n_2)个元素(b_1, b_2, cdots , b_{n_2})。
每次询问(S_1)的子区间([l_1,r_1])和(S_2)的子区间(l_2,r_2)的交集的大小。
首先定义一个函数(f)把(a_1 sim a_{n_1})映射为(1 sim n_1)
同样地，如果(b_i)在(S_1)中出现另(b_i=f(b_i))，否则另(b_i=0)
这样就将问题转化为求(S_2)的子区间([l_2,r_2])中值在([l_1, r_1])范围中元素的个数。
因此可以用线段树来解决。
回到本问题，先把第一棵树剖分，路径(u_1 o v_1)就变成若干个连续的区间。
再对第二棵树建一棵主席树，维护的是根节点到当前节点对应区间的元素的个数。
对于每个区间，查询一次在这个区间内路径(u_2 o v_2)上在这个区间内的元素的个数。
处理每次询问的复杂度为(O(log^2n))
#include <cstdio>
#include <cstring>
#include <algorithm>
#include <vector>
#include <map>
#define MP make_pair
#define F first
#define S second
using namespace std;
typedef pair<int, int> PII;
const int maxn = 100000 + 10;
struct Edge
{
int v, nxt;
Edge() {}
Edge(int v, int nxt): v(v), nxt(nxt) {}
};
struct Tree
{
int n, w[maxn];
int ecnt, head[maxn];
Edge edges[maxn];
int fa[maxn], dep[maxn], sz[maxn], son[maxn];
void init() { ecnt = 0; memset(head, -1, sizeof(head)); }
void AddEdge(int u, int v) {
edges[ecnt] = Edge(v, head[u]);
head[u] = ecnt++;
}
bool read() {
if(scanf("%d", &n) != 1) return false;
init();
for(int u = 2; u <= n; u++) {
scanf("%d", fa + u);
AddEdge(fa[u], u);
}
for(int i = 1; i <= n; i++) scanf("%d", w + i);
return true;
}
void dfs(int u) {
sz[u] = 1; son[u] = 0;
for(int i = head[u]; ~i; i = edges[i].nxt) {
int v = edges[i].v;
dep[v] = dep[u] + 1;
dfs(v);
sz[u] += sz[v];
if(sz[v] > sz[son[u]]) son[u] = v;
}
}
};
Tree t1, t2;
int n1, n2;
int x[maxn];
//Heavy Light Decomposition
int tot;
int id[maxn], pos[maxn], top[maxn];
void dfs2(int u, int tp) {
id[u] = ++tot;
int p = lower_bound(x + 1, x + 1 + n1, t1.w[u]) - x;
pos[p] = tot;
top[u] = tp;
if(!t1.son[u]) return;
dfs2(t1.son[u], tp);
for(int i = t1.head[u]; ~i; i = t1.edges[i].nxt) {
int v = t1.edges[i].v;
if(v == t1.son[u]) continue;
dfs2(v, v);
}
}
vector<PII> inter;
void getIntervals(int u, int v) {
inter.clear();
while(top[u] != top[v]) {
if(t1.dep[top[u]] < t1.dep[top[v]]) swap(u, v);
inter.push_back(MP(id[top[u]], id[u]));
u = t1.fa[top[u]];
}
if(t1.dep[u] > t1.dep[v]) swap(u, v);
inter.push_back(MP(id[u], id[v]));
}
//Least Common Ancestor
int anc[maxn][20];
void preprocess() {
memset(anc, 0, sizeof(anc));
for(int i = 1; i <= n2; i++) anc[i][0] = t2.fa[i];
for(int j = 1; (1 << j) < n2; j++)
for(int i = 1; i <= n2; i++) if(anc[i][j-1])
anc[i][j] = anc[anc[i][j-1]][j-1];
}
int LCA(int u, int v) {
int log;
if(t2.dep[u] < t2.dep[v]) swap(u, v);
for(log = 0; (1 << log) < t2.dep[u]; log++);
for(int i = log; i >= 0; i--)
if(t2.dep[u] - (1<<i) >= t2.dep[v]) u = anc[u][i];
if(u == v) return u;
for(int i = log; i >= 0; i--)
if(anc[u][i] && anc[u][i] != anc[v][i])
u = anc[u][i], v = anc[v][i];
return t2.fa[u];
}
//Functional Segment Tree
const int maxnode = maxn << 5;
int sz, root[maxn];
int lch[maxnode], rch[maxnode], sum[maxnode];
int update(int pre, int L, int R, int p) {
int rt = ++sz;
sum[rt] = sum[pre] + 1;
if(L < R) {
int M = (L + R) / 2;
if(p <= M) { rch[rt] = rch[pre]; lch[rt] = update(lch[pre], L, M, p); }
else { lch[rt] = lch[pre]; rch[rt] = update(rch[pre], M+1, R, p); }
}
return rt;
}
void build(int u, int p) {
if(!t2.w[u]) root[u] = root[p];
else root[u] = update(root[p], 1, n1, t2.w[u]);
for(int i = t2.head[u]; ~i; i = t2.edges[i].nxt) {
int v = t2.edges[i].v;
build(v, u);
}
}
int query(int u, int v, int lca, int L, int R, int qL, int qR) {
if(qL <= L && R <= qR) { return sum[u] + sum[v] - sum[lca] * 2; }
int ans = 0;
int M = (L + R) / 2;
if(qL <= M) ans += query(lch[u], lch[v], lch[lca], L, M, qL, qR);
if(qR > M) ans += query(rch[u], rch[v], rch[lca], M+1, R, qL, qR);
return ans;
}
int main()
{
while(t1.read()) {
t2.read();
n1 = t1.n; n2 = t2.n;
for(int i = 1; i <= n1; i++) x[i] = t1.w[i];
sort(x + 1, x + 1 + n1);
t1.dfs(1); t2.dfs(1);
preprocess();
tot = 0; dfs2(1, 1);
for(int i = 1; i <= n2; i++) {
int p = lower_bound(x + 1, x + 1 + n1, t2.w[i]) - x;
if(p < 1 || p > n2 || x[p] != t2.w[i]) t2.w[i] = 0;
else t2.w[i] = pos[p];
}
sz = 1;
build(1, 0);
int q; scanf("%d", &q);
while(q--) {
int u1, v1, u2, v2;
scanf("%d%d%d%d", &u1, &v1, &u2, &v2);
getIntervals(u1, v1);
int ans = 0;
int lca = LCA(u2, v2);
for(PII a : inter) {
if(a.F <= t2.w[lca] && t2.w[lca] <= a.S) ans++;
ans += query(root[u2], root[v2], root[lca], 1, n1, a.F, a.S);
}
printf("%d
", ans);
}
}
return 0;
}