牛客练习赛 F红蓝树【Kruskal重构树】【主席树】

牛客练习赛 F红蓝树

有一张 n 个点，m 条边的无向图。点从 0 到 n-1 编号。边有边权和颜色，颜色为红色和蓝色中的一种。给定 q 组询问，每次给定两个参数 x,t。删除边权大于 t 的红色边和边权小于 t 的蓝色边。如果此时两个点 x,y 既有仅经过红色边的路径相连，又有仅经过蓝色边的路径相连，那么称这两个点连通。求与编号为 x 的点连通的点的数量（包括 x 本身）。询问间相互独立，每次询问的删除不会影响其他询问。

分析

对于一个无向图，对于边权大小讨论的问题，通常与$Kruskal$重构树有关
对于$Kruskal$重构树，这里有篇比较简单的重构树应用
BZOJ 3732 Network【kruskal重构树、树上倍增、树链剖分】

• 对于红边，构造一棵最小生成树，因为要删掉大于的边，重构树里面的子树得是小于的边
• 对于蓝边，构造一棵最大生成树，因为要删掉小于的边，重构树里面的子树得是大于的边

维护子树的信息，可以使用树链剖分维护子树（子树$dfn$序连续）
我们现在需要求的就是，子树点的交集

考虑使用主席树维护
以红树中的点$dfn序$作为下标
将蓝树中的点，按照点编号相同，加到红树中对应点的版本中
意义是，红树此点在蓝树的某个时刻($dfn$序，时间戳)出现过
最后子树，在红树中的子树开始版本，结束版本中查找（在蓝树开始时刻，结束时刻）中的数量
这样就能求出，红树子树和蓝树子树的点交集个数，如果要求点的话，按照$dfn序$映射过去即可

代码

//N7745F 
/*
  @Author: YooQ
*/
#include <bits/stdc++.h>
using namespace std;
#define sc scanf
#define pr printf
#define ll 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;

struct Tr {
	int k, l, r;
}tr[MAX_N<<2];
int root[MAX_N];
int indx = 0;

int clone(int rt) {
	tr[++indx] = tr[rt];
	return indx;
}

void push_up(int rt) {
	tr[rt].k = tr[tr[rt].l].k + tr[tr[rt].r].k;
}

void update(int &rt, int l, int r, int x, int k) {
	rt = clone(rt);
	if (l == r) {
		tr[rt].k += k;
		return;
	}
	int mid = l + ((r-l)>>1);
	if (x <= mid) update(tr[rt].l, l, mid, x, k);
	if (x  > mid) update(tr[rt].r, mid+1, r, x, k);
	push_up(rt);
}

int query(int p, int q, int l, int r, int x, int y) {
	if (!q) return 0;
	if (x <= l && r <= y) {
		return tr[q].k - tr[p].k;
	}
	int mid = l + ((r-l)>>1);
	if (y <= mid) return query(tr[p].l, tr[q].l, l, mid, x, y);
	if (x  > mid) return query(tr[p].r, tr[q].r, mid+1, r, x, y);
	return query(tr[p].l, tr[q].l, l, mid, x, y) + query(tr[p].r, tr[q].r, mid+1, r, x, y);
}

struct Node {
	int u, v, w, ty;
}node[MAX_N];

struct Ex_kruskal {
	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++;
	}
	
	int val[MAX_N];
	int father[MAX_N];
	
	int find(int x) {
		return x == father[x] ? x : father[x] = find(father[x]);
	}
	
	int L[MAX_N];
	int R[MAX_N];
	int sa[MAX_N];
	int tim = 0;
	int parent[MAX_N][22];
	
	void dfs(int u, int from) {
		L[u] = ++tim;
		sa[tim] = u;
		parent[u][0] = from;
		for (int i = 1; i <= 20; ++i) {
			parent[u][i] = parent[parent[u][i-1]][i-1];
		}
		
		for (int i = head[u]; ~i; i=edge[i].nxt) {
			dfs(edge[i].to, u);
		}
		
		R[u] = tim;
	}
	
	void init () {
		memset(head, -1, sizeof head);
		tot = 0;
	}
	
	void run(int ty) {
		init();
		for (int i = 1; i < 2*N; ++i) {
			father[i] = i;
		}
		
		int indx = N;
		int x, y;
        int done = 1;
		for (int i = 1; i <= M && done < N; ++i) {
			if (node[i].ty != ty) continue;
			
			x = find(node[i].u);
			y = find(node[i].v);
			if (x == y) continue;
			
			val[++indx] = node[i].w;
			if (x <= N) val[x] = node[i].w;
			if (y <= N) val[y] = node[i].w;
			
			addEdge(indx, x);
			addEdge(indx, y);
			father[x] = indx;
			father[y] = indx;
		}
		
		for (int i = 1; i < 2*N; ++i) {
			if (find(i) == i) {
				dfs(i, i);
			}
		}
	}
}A, B;

int arr[MAX_N];

void solve(){
	sc("%d%d%d", &N, &M, &K);
	
	int u, v, ty;
	for (int i = 1; i <= M; ++i) {
		sc("%d%d%d", &u, &v, &ty);
		++u, ++v;
		node[i] = {u, v, i, ty};
	}
	
	A.run(0);
	reverse(node+1, node+1+M);
	B.run(1);
	
	for (int i = 1; i < 2*N; ++i) {
		root[i] = root[i-1];
		if (A.sa[i] <= N) update(root[i], 1, 2*N, B.L[A.sa[i]], 1);
	}
	
	int x, y, t;
	for (int i = 1; i <= K; ++i) {
		sc("%d%d", &u, &t);
		++u;
		x = u;
		y = u;
		for (int i = 20; i+1; --i) {
			if (A.val[A.parent[x][i]] <= t) x = A.parent[x][i];
		}
		for (int i = 20; i+1; --i) {
			if (B.val[B.parent[y][i]] >= t) y = B.parent[y][i];
		}
		cout << query(root[A.L[x]-1], root[A.R[x]], 1, 2 * N, B.L[y], B.R[y]) << "\n";
	}
	
}

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

	return AC;
}