【BZOJ 4539】【HNOI 2016】树

#include<cstdio>
#include<cstring>
#include<algorithm>
using namespace std;
typedef long long ll;
const int N = 100003;
int in() {
	int k = 0, fh = 1; char c = getchar();
	for(; c < ‘0‘ || c > ‘9‘; c = getchar())
		if (c == ‘-‘) fh = -1;
	for(; c >= ‘0‘ && c <= ‘9‘; c = getchar())
		k = (k << 3) + (k << 1) + c - ‘0‘;
	return k * fh;
}

ll inll() {
	ll k = 0; int fh = 1; char c = getchar();
	for(; c < ‘0‘ || c > ‘9‘; c = getchar())
		if (c == ‘-‘) fh = -1;
	for(; c >= ‘0‘ && c <= ‘9‘; c = getchar())
		k = (k << 3) + (k << 1) + c - ‘0‘;
	return k * fh;
}


int n, m, q;


namespace Small {
	struct node {
		int nxt, to;
	} E[N << 1];
	int cnt = 0, point[N], f[N][18], deep[N], L[N], R[N], a[N];
	bool vis[N];
	void ins(int u, int v) {
		E[++cnt].nxt = point[u]; E[cnt].to = v; point[u] = cnt;
	}
	
	void dfs(int x) {
		vis[x] = true; L[x] = ++cnt; a[cnt] = x;
		for(int i = point[x]; i; i = E[i].nxt) if (!vis[E[i].to]) {
			deep[E[i].to] = deep[x] + 1;
			f[E[i].to][0] = x;
			dfs(E[i].to);
		}
		R[x] = cnt;
	}
	
	struct node2 {
		int l, r, s;
	} T[N * 20];
	int root[N], tot = 0;
	
	void update(int &pos, int l, int r, int key) {
		T[++tot] = T[pos]; pos = tot; ++T[pos].s;
		if (l == r) return;
		int mid = (l + r) >> 1;
		if (key <= mid) update(T[pos].l, l, mid, key);
		else update(T[pos].r, mid + 1, r, key);
	}
	void BuildPT() {
		for(int i = 1; i <= n; ++i) {
			root[i] = root[i - 1];
			update(root[i], 1, n, a[i]);
		}
	}
	
	void work() {
		int u, v;
		for(int i = 1; i < n; ++i) {
			u = in(); v = in();
			ins(u, v); ins(v, u);
		}
		cnt = 0; memset(vis, 0, sizeof(vis));
		deep[1] = 0; dfs(1);
		for(int j = 1; j < 18; ++j)
			for(int i = 1; i <= n; ++i) {
				f[i][j] = f[f[i][j - 1]][j - 1];
			}
		BuildPT();
	}
	
	int Sum(int x) {return R[x] - L[x] + 1;}
	
	int kth(int left, int right, int l, int r, int key) {
		if (l == r) return l;
		int mid = (l + r) >> 1, sum = T[T[right].l].s - T[T[left].l].s;
		if (sum >= key) return kth(T[left].l, T[right].l, l, mid, key);
		else return kth(T[left].r, T[right].r, mid + 1, r, key - sum);
	}
	int Query(int rt, int k) {
		int l = L[rt], r = R[rt];
		return kth(root[l - 1], root[r], 1, n, k);
	}
	
	int todeep(int a, int b) {return deep[a] - deep[b];}
	
	int LCA(int u, int v) {
		if (deep[u] < deep[v]) swap(u, v);
		int d = deep[u] - deep[v];
		for(int i = 17; i >= 0; --i)
			if ((1 << i) & d)
				u = f[u][i];
		if (u == v) return d;
		for(int i = 17; i >= 0; --i)
			if (f[u][i] != f[v][i]) {
				u = f[u][i]; v = f[v][i];
				d += (1 << (i + 1));
			}
		return d + 2;
	}
}

namespace Big {
	ll c[N][18];
	int f[N][18], deep[N];
	int tablenum = 0, table_to[N], table_rt[N];
	ll table_l[N], table_r[N], up;
	
	int pos(ll x) {
		int mid, left = 1, right = tablenum;
		while (left < right) {
			mid = (left + right) >> 1;
			if (x < table_l[mid]) right = mid - 1;
			else if (x > table_r[mid]) left = mid + 1;
			else return mid;
		}
		return left;
	}
		
	void work() {
		int a; ll b;
		up = n;
		tablenum = 1; table_l[1] = 1; table_r[1] = n; table_rt[1] = 1;
		for(int i = 1; i <= m; ++i) {
			a = in(); b = inll();
			int P = pos(b);
			table_rt[++tablenum] = a;
			table_l[tablenum] = up + 1;
			up += Small::Sum(a);
			table_r[tablenum] = up;
			f[tablenum][0] = P;
			deep[tablenum] = deep[P] + 1;
			table_to[tablenum] = Small::Query(table_rt[P], b - table_l[P] + 1);
			c[tablenum][0] = Small::todeep(table_to[tablenum], table_rt[P]) + 1;
		}
		for(int j = 1; j < 18; ++j)
			for(int i = 1; i <= tablenum; ++i) {
				f[i][j] = f[f[i][j - 1]][j - 1];
				c[i][j] = c[i][j - 1] + c[f[i][j - 1]][j - 1];
			}
		
		int changeu, changev, posu, vnum, posv, u, v;
		ll U, V, ret;
		for(int i = 1; i <= q; ++i) {
			U = inll(); V = inll(); ret = 0;
			posu = pos(U); posv = pos(V);
			if (deep[posu] < deep[posv]) {
				swap(posu, posv); swap(U, V);
			}
			
			changeu = Small::Query(table_rt[posu], U - table_l[posu] + 1);
			changev = Small::Query(table_rt[posv], V - table_l[posv] + 1);
			
			if (posu == posv) {
				printf("%d\n", Small::LCA(changeu, changev));
				continue;
			}
			
			u = posu; v = posv;
			for(int i = 17; i >= 0; --i)
				if (deep[f[u][i]] > deep[v]) {
					ret += c[u][i];
					u = f[u][i];
				}
			
			if (f[u][0] == v) {
				ret += 1;
				u = table_to[u];
				v = changev;
				ret += Small::LCA(u, v);
				ret += Small::todeep(changeu, table_rt[posu]);
			} else {
				if (deep[u] > deep[v]) {
					ret += c[u][0];
					u = f[u][0];
				}
				for(int i = 17; i >= 0; --i)
					if (f[u][i] != f[v][i]) {
						ret += (c[u][i] + c[v][i]);
						u = f[u][i];
						v = f[v][i];
					}
				ret += 2;
				ret += Small::LCA(table_to[u], table_to[v]);
				ret += Small::todeep(changeu, table_rt[posu]) + Small::todeep(changev, table_rt[posv]);
			}

			printf("%lld\n", ret);
		}
	}
}


int main() {
	n = in(); m = in(); q = in();
	
	Small::work();
	Big::work();
	return 0;
}