@loj - 2865@ 「IOI2018」狼人

目录

• @description@
• @solution@
• @accepted code@
• @details@

---

@description@

在日本的茨城县内共有 N 个城市和 M 条道路。这些城市是根据人口数量的升序排列的，依次编号为 0 到 N-1。每条道路连接两个不同的城市，并且可以双向通行。由这些道路，你能从任意一个城市到另外任意一个城市。

你计划了 Q 个行程，这些行程分别编号为 0 至 Q-1。第 i（0 <= i <= Q - 1）个行程是从城市 Si 到城市 Ei。

你是一个狼人。你有两种形态：人形和狼形。在每个行程开始的时候，你是人形。在每个行程结束的时候，你必须是狼形。在行程中，你必须要变身（从人形变成狼形）恰好一次，而且只能在某个城市内（包括可能是在 Si 或 Ei 内）变身。

狼人的生活并不容易。当你是人形时，你必须避开人少的城市，而当你是狼形时，你必须避开人多的城市。对于每一次行程 i（0 <= i <= Q - 1），都有两个阈值 Li 和 Ri（0 <= Li <= Ri <= N - 1），用以表示哪些城市必须要避开。

准确地说，当你是人形时，你必须避开城市 0, 1, ..., Li - 1；而当你是狼形时，则必须避开城市 Ri + 1, Ri + 2, ..., N - 1。

这就是说，在行程 i 中，你必须在城市 Li, Li+1, ..., Ri 中的其中一个城市内变身。

你的任务是，对每一次行程，判定是否有可能在满足上述限制的前提下，由城市 Si 走到城市 Ei。你的路线可以有任意长度。

输入格式

你需要实现下面的函数：

int[] check_validity(int N, int[] X, int[] Y, int[] S, int[] E, int[] L, int[] R)

N：城市的数量

X 和 Y：两个长度为 M 的数组。对于每个 j（0 <= j <= M - 1），城市 X[j] 都有道路直接连到城市 Y[j]。

S, E, L, 及 R：均为长度为 Q 的数组，以表示行程。

数据范围与提示

2 <= N <= 200000, N - 1 <= M <= 400000, 1 <= Q <= 200000。

0 <= Li <= Si <= N - 1, 0 <= Ei <= Ri <= N - 1, Si ≠ Ei, Li <= Ri。

保证没有重边自环，保证图连通。

@solution@

等价的题意：

从 S 出发只经过 L ~ N-1 的点能够到达的点集，与从 E 出发只经过 0 ~ R 的点能够到达的点集，两个集合是否有交集。

现先考虑从 E 出发只经过 0 ~ R 的点能够到达的点。

如果从点 0 到点 N - 1 依次加入它们向前连的边，并用类似于可持久化并查集的东西维护，只要调用第 R 个版本的并查集就可以得到 E 能到达的点。

可持久化并查集？有没有想起 NOI2018 的 D1T1？是否对于这道题我们也可以转成 kruskal 重构树来做？

考虑对于所有边，记边权为 min{它连接的两个端点的编号}，则只经过 0 ~ R 的点等价于只经过边权 <= R 的边。

于是一个点能够到达的点集，通过倍增可以找到 kruskal 重构树中对应的子树，子树内的所有点都是可到达的。

从 S 出发只经过 L ~ N-1 的点能够到达的点集可以类比着建另一棵树。

通过 dfs 序，我们可以把问题转化为：

是否存在一个 (dfn1[x], dfn2[x])，使得 a <= dfn1[x] <= b, c <= dfn2[x] <= d。

经典的二维偏序问题，相当于统计这个二维区域的点数。

我懒得动脑子为了强化代码能力打了个可持久化线段树。

时间复杂度 O(nlogn)。

@accepted code@

#include "werewolf.h"
#include <vector>
#include <iostream>
#include <algorithm>
using namespace std;
#define vi vector<int>
#define pb push_back
const int MAXN = 200000;
const int MAXQ = 200000;
const int MAXM = 400000;
int N, M, Q;
struct Graph{
	bool type;
	struct edge{
		int to; edge *nxt;
	}edges[2*MAXN + 5], *adj[2*MAXN + 5], *ecnt;
	int v[2*MAXN + 5], fa[20][2*MAXN + 5];
	Graph(int p) {ecnt = edges, type = p;}
	void addedge(int u, int v) {
		edge *p = (++ecnt);
		p->to = v, p->nxt = adj[u], adj[u] = p;
//		printf("! %d %d\n", u, v);
	}
	void dfs(int x, int f) {
		fa[0][x] = f;
		for(int i=1;i<20;i++)
			fa[i][x] = fa[i-1][fa[i-1][x]];
		for(edge *p=adj[x];p;p=p->nxt)
			dfs(p->to, x);
	}
	void build(int x) {v[0] = type ? (MAXN + 5) : 0; dfs(x, 0);}
	int query(int x, int k) {
		for(int i=19;i>=0;i--)
			if( type ) {
				if( v[fa[i][x]] <= k )
					x = fa[i][x];
			}
			else {
				if( v[fa[i][x]] >= k )
					x = fa[i][x];
			}
		return x;
	}
}G1(0), G2(1);
int fa[2*MAXN + 5];
int find(int x) {
	return fa[x] = (fa[x] == x ? x : find(fa[x]));
}
vi e[MAXN + 5];
void build1() {
	int cnt = N;
	for(int i=1;i<(N<<1);i++) fa[i] = i;
	for(int i=N;i>=1;i--) {
		G1.v[i] = i;
		for(int j=0;j<(int)e[i].size();j++)
			if( e[i][j] > i ) {
				int p = e[i][j], f = find(i), g = find(p);
				if( f != g ) {
					int x = (++cnt);
					G1.addedge(x, f), G1.addedge(x, g);
					fa[f] = fa[g] = x;
					G1.v[x] = i;
				}
			}
	}
	G1.build((N<<1)-1);
}
void build2() {
	int cnt = N;
	for(int i=1;i<(N<<1);i++) fa[i] = i;
	for(int i=1;i<=N;i++) {
		G2.v[i] = i;
		for(int j=0;j<(int)e[i].size();j++)
			if( e[i][j] < i ) {
				int p = e[i][j], f = find(i), g = find(p);
				if( f != g ) {
					int x = (++cnt);
					G2.addedge(x, f), G2.addedge(x, g);
					fa[f] = fa[g] = x;
					G2.v[x] = i;
				}
			}
	}
	G2.build((N<<1)-1);
}
struct segtree{
	struct node{
		int cnt; node *ch[2];
	}pl[20*MAXN + 5], *NIL, *ncnt;
	segtree() {
		NIL = ncnt = pl;
		NIL->ch[0] = NIL->ch[1] = NIL;
		NIL->cnt = 0;
	}
	node *insert(node *pre, int l, int r, int ps) {
		node *p = (++ncnt); (*p) = (*pre); p->cnt++;
		if( l == r ) return p;
		int mid = (l + r) >> 1;
		if( ps <= mid )
			p->ch[0] = insert(pre->ch[0], l, mid, ps);
		else p->ch[1] = insert(pre->ch[1], mid + 1, r, ps);
		return p;
	}
	int query(node *L, node *R, int l, int r, int ql, int qr) {
		if( ql > r || qr < l ) return 0;
		if( ql <= l && r <= qr ) return R->cnt - L->cnt;
		int mid = (l + r) >> 1;
		return query(L->ch[0], R->ch[0], l, mid, ql, qr) + query(L->ch[1], R->ch[1], mid + 1, r, ql, qr);
	}
}T;
segtree::node *rt[MAXN + 5];
int tid[2][MAXN + 5], dfn[2][MAXN + 5], dcnt[2];
int le[2][2*MAXN + 5], ri[2][2*MAXN + 5];
void dfs(const Graph &G, int x, int t) {
	if( x <= N ) {
		dfn[t][le[t][x] = ri[t][x] = tid[t][x] = (++dcnt[t])] = x;
	}
	else {
		le[t][x] = dcnt[t] + 1;
		for(Graph::edge *p=G.adj[x];p;p=p->nxt)
			dfs(G, p->to, t);
		ri[t][x] = dcnt[t];
	}
}
void get() {
	build1();
	build2();
	dfs(G1, (N<<1)-1, 0), dfs(G2, (N<<1)-1, 1);
	rt[0] = T.NIL;
	for(int i=1;i<=N;i++)
		rt[i] = T.insert(rt[i-1], 1, N, tid[1][dfn[0][i]]);
}
bool query(int s, int e, int l, int r) {
	int x = G1.query(s, l), y = G2.query(e, r);
	return T.query(rt[le[0][x]-1], rt[ri[0][x]], 1, N, le[1][y], ri[1][y]);
}
vi check_validity(int _N, vi X, vi Y, vi S, vi E, vi L, vi R) {
	N = _N, Q = S.size(), M = X.size();
	for(int i=0;i<M;i++)
		e[X[i]+1].pb(Y[i]+1), e[Y[i]+1].pb(X[i]+1);
	get(); vi A(Q);
	for(int i=0;i<Q;i++)
		A[i] = query(S[i]+1, E[i]+1, L[i]+1, R[i]+1);
	return A;
}
/*
S -> L ~ N (L <= S)
E -> 1 ~ R (E <= R)
*/

@details@

对于 kruskal 重构树，其实我更愿意将其看作 “可持久化并查集”。

因为它的作用就是将某时刻 t 之前的加边操作执行后，图连通的情况。

但是某种意义上来说，kruskal 重构树的思想更类似于点分树之类的东西。即用数据结构再现某一算法的过程。

不管怎么说，会用就行。

另外，比狠人还多一点——是个狼人。