【题解】【LibreOJ Beta Round #5】游戏 LOJ 531 基环树 博弈论

Prelude

题目链接：萌萌哒传送门♪(^∇*)

---

Subtask 1 & 2

这是什么鬼题面。。。

首先要看出，这就是一个基环树博弈。

具体题意：给出一个基环内向树，一个棋子初始在\(1\)号节点，双方轮流操作，设棋子所在节点为\(u\)，每次可以从所有指向\(u\)的节点中选择一个，把棋子移动过去，不能操作者输，问先手是否有必胜策略，或者是否平局。

但是，这个图是可以变的，每次询问，假如我选择环上的两个点\(u\)和\(v\)，把\(u\)的出边指向\(v\)，那么游戏的结果如何？

考虑如果只有一次询问，不修改的话怎么做。

这么裸的博弈随便做吧？先假设把环上的所有边断开，然后dp求出每个节点的状态，最后再考虑环上的情况，当环上所有点都是必败态的时候就是平局，否则两个人沿着环走，第一个走到必胜节点的人获胜。

求解一次是\(O(n)\)的，一共\(q\)次询问，总时间复杂度\(O(nq)\)。

---

Subtask 3 & 4

首先我们可以预处理求出离环上每个点最近的必胜点是哪个，我这里用\(left_{i}\)表示。

每次对原图做修改，相当于把环缩小到原来的环的一个片段。

假如我们选了环上的\(u\)和\(v\)两个节点，并且把\(u\)的出边连接到\(v\)，那么\(f_{u}\)到\(v\)这一段的dp值都可能会改变。

我们可以用倍增预处理，用\(jump[x][s][k]\)表示假如点\(x\)的状态为\(s\)，那么\(x\)之后第\(2^{k}\)个点的状态是什么，这样，查询一个点的状态就是\(O(\log n)\)的了。

对于点\(1\)不在环上的情况，我们可以直接查询，\(O(\log n)\)解决。

如果点\(1\)在环上，我们因为有之前预处理的结果，所以只需要求出点\(v\)的新的dp值（\(O(\log n)\)），然后大力分类讨论（\(O(1)\)）解决。

总体复杂度就是\(O(n \log n)\)，能过87分辣~

---

Subtask 5

LCA告诉我可以线性做，然而我并不会。

瓶颈是倍增，怎么去掉倍增？怎么降低查询的复杂度？

我们离线所有的询问，这样就可以用并查集，在\(O(n \alpha(n))\)的时间内处理出所有的“对点\(v\)的dp值的询问”。

这样总体复杂度就变成了\(O(n \alpha(n))\)辣~

因为我比较懒，所以离线询问的时候对询问排了序，复杂度还是\(O(n \log n)\)的，但是这个\(O(n \log n)\)比倍增的\(O(n \log n)\)要小得多了，也是能AC的。

---

Conclusion

为了处理方便，我们通常把环拆开，拆成一条链来处理。

于是就少不了大量的分类讨论，我写了200行。

这件事告诉我们，LCA题不可做(╯‵□′)╯︵┻━┻。

---

Code

#include <cstring>
#include <algorithm>
#include <cstdio>
#include <queue>
#include <cctype>

using namespace std;
const int MAXN = 1000010;
const int LOGN = 21;
int _w;

int read() {
	int x = 0, ch;
	while( isspace(ch = getchar()) );
	do x = x * 10 + ch - '0';
	while( isdigit(ch = getchar()) );
	return x;
}

int n, q, f[MAXN];

int lp[MAXN], lpsz, pos[MAXN]; // lp为环上的每个节点，lpsz为环的大小，pos为原图中的节点在环中的位置
void find_loop() {
	int u = 1;
	while( !pos[u] ) {
		pos[u] = ++lpsz;
		lp[lpsz] = u;
		u = f[u];
	}
	int sz = 0;
	for( int i = pos[u]; i <= lpsz; ++i )
		lp[++sz] = lp[i];
	lpsz = sz;
	for( int i = 1; i <= n; ++i ) pos[i] = 0; // 不在环中的节点pos == 0
	for( int i = 1; i <= lpsz; ++i )
		pos[lp[i]] = i;
}

int pa[MAXN<<1]; // 并查集相关
int find( int u ) {
	return pa[u] == u ? u : pa[u] = find(pa[u]);
}

int dp[MAXN], deg[MAXN], left[MAXN];
queue<int> bfsq;
int toend[MAXN][2], to1[MAXN][2]; // to1[x][s]表示当x点的状态为s的时候，点1的状态是什么，toend类似，表示序列上最后一个点的信息
void prelude() {
	find_loop();
	for( int i = 1; i <= n; ++i )
		++deg[f[i]];
	for( int i = 1; i <= n; ++i )
		if( !deg[i] )
			bfsq.push(i);
	while( !bfsq.empty() ) {
		int u = bfsq.front(); bfsq.pop();
		if( !dp[u] ) dp[f[u]] = 1;
		if( --deg[f[u]] == 0 )
			bfsq.push(f[u]);
	}
	for( int i = 1; i <= lpsz; ++i )
		if( dp[lp[i]] ) left[i] = i;
		else left[i] = left[i-1];
	for( int i = 1; i < lpsz; ++i ) {
		pa[i] = i+1+lpsz;
		pa[i+lpsz] = i+1 + dp[lp[i+1]] * lpsz;
	}
	pa[lpsz] = lpsz;
	pa[lpsz+lpsz] = lpsz+lpsz;
	for( int i = 1; i <= lpsz; ++i ) {
		toend[i][0] = find(i) > lpsz;
		toend[i][1] = find(i+lpsz) > lpsz;
	}
	if( pos[1] ) {
		for( int i = 1; i != pos[1]; ++i ) {
			pa[i] = i+1+lpsz;
			pa[i+lpsz] = i+1 + dp[lp[i+1]] * lpsz;
		}
		pa[pos[1]] = pos[1];
		pa[pos[1]+lpsz] = pos[1]+lpsz;
		for( int i = 1; i != pos[1]; ++i ) {
			to1[i][0] = find(i) > lpsz;
			to1[i][1] = find(i+lpsz) > lpsz;
		}
		to1[pos[1]][0] = 0;
		to1[pos[1]][1] = 1;
	}
	for( int i = 1; i <= lpsz; ++i ) {
		pa[i] = i;
		pa[i+lpsz] = i+lpsz;
	}
}

int calc( int t, int v, int p ) {
	static int right = 1;
	if( t > p ) { // 把环拆成序列就要大力分类讨论。。。
		v = toend[t][v];
		t = 1;
		v = !v || dp[lp[1]];
	}
	if( p == pos[1] )
		return to1[t][v];
	while( right < p ) { // 对所有询问按照查询位置排序
		pa[right] = right+1+lpsz;
		pa[right+lpsz] = right+1 + dp[lp[right+1]] * lpsz;
		++right;
	}
	return find(t + v*lpsz) > lpsz;
}

int solve( int l, int r ) {
	if( !pos[1] ) return dp[1]; // 点1不在环上
	l = pos[l], r = pos[r];
	int p = pos[1];
        if( l >= r ) { // 下面都是分类讨论。。。
		swap(l, r);
		if( p < l || p > r ) { // 点1不在环上
			int t = r == lpsz ? 1 : r+1;
			return calc(t, dp[lp[t]], p);
		} else {
			int dpl = dp[lp[l]];
			if( l > 1 || r < lpsz ) {
				int t = r == lpsz ? 1 : r+1;
				dpl = calc(t, dp[lp[t]], l);
			}
			if( left[p] >= l+1 ) {
				int q = left[p];
				return (p-q+1)&1;
			} else if( dpl ) {
				return (p-l+1)&1;
			} else if( left[r] >= l+1 ) {
				int q = left[r];
				return (p-l+1+r-q+1)&1;
			} else {
				return 2;
			}
		}
	} else {
		if( p > l && p < r ) {
			int t = l+1;
			return calc(t, dp[lp[t]], p);
		} else if( p <= l ) {
			int t = l+1;
			int dpr = calc(t, dp[lp[t]], r);
			if( left[p] ) {
				int q = left[p];
				return (p-q+1)&1;
			} else if( left[lpsz] >= r+1 ) {
				int q = left[lpsz];
				return (lpsz-q+1+p)&1;
			} else if( dpr ) {
				return (p+lpsz-r+1)&1;
			} else if( left[l] ) {
				int q = left[l];
				return (lpsz-r+1+p+l-q+1)&1;
			} else {
				return 2;
			}
		} else {
			int t = l+1;
			int dpr = calc(t, dp[lp[t]], r);
			if( left[p] >= r+1 ) {
				int q = left[p];
				return (p-q+1)&1;
			} else if( dpr ) {
				return (p-r+1)&1;
			} else if( left[l] ) {
				int q = left[l];
				return (p-r+1+l-q+1)&1;
			} else if( left[lpsz] >= r+1 ) {
				int q = left[lpsz];
				return (p-r+1+l+lpsz-q+1)&1;
			} else {
				return 2;
			}
		}
	}
}

int qu[MAXN], qv[MAXN]; // 存放询问的地方
int rk[MAXN], ans[MAXN];

bool cmp_qv( int i, int j ) { // 对询问按照点在序列上的位置排序
	i = pos[qv[i]], j = pos[qv[j]];
	return i < j;
}

int main() {
	n = read(), q = read();
	for( int i = 1; i <= n; ++i )
		f[i] = read();
	prelude();
	for( int i = 0; i < q; ++i )
		qu[i] = read(), qv[i] = read(), rk[i] = i;
	sort(rk, rk+q, cmp_qv);
	for( int i = 0; i < q; ++i )
		ans[rk[i]] = solve(qu[rk[i]], qv[rk[i]]);
	for( int i = 0; i < q; ++i )
		printf( "%d\n", ans[i] );
	return 0;
}