AcWing4084 号码牌 (并查集 / bitset优化Floyd)

题目链接: 号码牌

大致题意

给定一个长度为$n$的序列, 第$i$个位置的值为$a_i$. (保证$a$是$1$~$n$的一个排列)

每个位置还有一个值$d_i$, 若满足$|i-j=d_i|$, 表示位置$i$和位置$j$可以进行任意次交换.

问: 能否使得最终的序列满足$a_i=i$.

解题思路

并查集 (数据太小了, 比赛时写了个Floyd)

由于两个位置的交换次数是任意次. 因此, 如果$x$和$y$可以交换, 且$y$和$z$可以交换, 则$x,y,z$三个位置处的$a$值可以互换.

上述分析可以推广到一个有限大小的连通集合中.

因此, 我们只需要判断每个连通集合内部$a_i$值是否和该集合下标$i$相同即可.

---

Floyd

设$mp[]$, 其中$mp[val]$记录$val$元素所处原序列的位置.

我们考虑题目的本质: 如果有$a_i\ne i$, 表明$i$位置需要与$mp[a[i]]$位置进行交换. 即: 我们需要判断$i,j$两个位置是否可达. 我们比较容易想到通过多源最短路进行处理.

考虑到本题并不需要求出两点的距离, 只需要判断是否可达, 因此若采用$Floyd$算法, 第三层循环可以认为是在求并集, 我们可以通过$bitset$进行优化.

写上这个做法, 主要感觉这个题作为$bitset$优化$Floyd$入门题很友好.

AC代码

并查集DSU

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E2 + 10;
int a[N], d[N];

/* 并查集模版 */
struct DSU {
	int p[N];
	int find(int x) { return x == p[x] ? x : p[x] = find(p[x]); }
	void merge(int a, int b) {
		a = find(a), b = find(b);
		if (a == b) return;
		p[b] = a;
	}
	void init(int n) { rep(i, n) p[i] = i; }
}dsu;

vector<int> v1[N], v2[N];
int main()
{
	int n; cin >> n;
	rep(i, n) scanf("%d", &a[i]);
	rep(i, n) scanf("%d", &d[i]);

	dsu.init(n);

	rep(i, n) {
		int x = i - d[i], y = i + d[i];
		if (x >= 1) dsu.merge(i, x);
		if (y <= n) dsu.merge(i, y);
	}

	rep(i, n) v1[dsu.find(i)].push_back(a[i]), v2[dsu.find(i)].push_back(i);

	bool flag = 1;
	rep(i, n) {
		if (i != dsu.find(i)) continue;

		sort(v1[i].begin(), v1[i].end());
		if (v1[i] != v2[i]) flag = 0;
	}

	puts(flag ? "YES" : "NO");

	return 0;
}

Floyd + bitset

#include <bits/stdc++.h>
#define rep(i, n) for (int i = 1; i <= (n); ++i)
using namespace std;
typedef long long ll;
const int N = 1E2 + 10;
int a[N], d[N], mp[N];
bitset<N> can[N];

void fact(int a, int b) { can[a][b] = can[b][a] = 1; }
int main()
{
	int n; cin >> n;
	rep(i, n) scanf("%d", &a[i]), mp[a[i]] = i;
	rep(i, n) {
		scanf("%d", &d[i]);
		if (i - d[i] > 0) fact(i, i - d[i]);
		if (i + d[i] <= n) fact(i, i + d[i]);
		can[i][i] = 1;
	}

	rep(k, n) rep(i, n) {
        if (can[i][k]) can[i] |= can[k];
    }

	bool flag = 1;
	rep(i, n) flag &= can[i][mp[i]];

	puts(flag ? "YES" : "NO");

	return 0;
}

END