CF28B pSort 解题报告

CF28B pSort 解题报告

1 题目链接

https://codeforces.com/problemset/problem/28/B

2 题目整理

题目 ：pSort

题目描述

有一天，某个数组的$n$个单元格决定玩下面的游戏。最初，每个单元格包含一个数字，这个数字等于它的序数(从$1$开始)。同时，每个单元格也确定了它最喜欢的数字。如果$|i-j|=d_i$，其中$d_i$是第$i$个单元格的最喜欢的数字，则第$i$个单元格可以与其他第$j$个单元格交换其值。单元格移动的顺序是任意的，移动的数量是无限的。

每个单元格的最喜欢的数字将会给你。你也会得到一个从$1$到$n$的数字排列。你要决定游戏是否可以移动到这个状态。

输入格式

第一行一个整数$n$，表示一共有$n$个单元格。

第二行有$n$个整数，第$i$个为$a_I$，表示我希望移动到的目标状态。

第三行有$n$个整数，第$i$个位$b_i$,表示第$i$个单元格喜欢的数字。

输出格式

输出一行一个字符串,如果可以，输出$"YES"$,否则输出$"NO"$。

样例输入1

5
5 4 3 2 1
1 1 1 1 1

样例输出1

YES

样例输入2

7
4 3 5 1 2 7 6
4 6 6 1 6 6 1

样例输出2

NO

样例输入3

7
4 2 5 1 3 7 6
4 6 6 1 6 6 1

样例输出3

YES

数据范围

对于$100\%$的数据:

• $1\le n\le 100$

3 题意分析

3.1 题目大意

有$n$个单元格，第$i$个单元格有一个自己喜欢的数$d_i$。如果$|i-j|=d_i$,那么单元格$i$和单元格$j$交换。问能否通过一系列的交换，使得棋盘成为一种状态。

3.2 样例分析

如上所述。

4 解法分析

这道题又双叒叕是一道建图+并查集的简单题目。

首先，根据题意，我们可以运用并查集来建图。建图后，我们只需要遍历一遍目标状态，当$i$能通过一系列的交换让$d_i$到$i$的位置，那么就可以；否则不行。

(代码里面还有一个大神用了DP！！！）

AC代码

ACCode #001

// From andrey-tsb
// Rating 2010
// reason : 思路新颖，代码简洁，运用了DP!!!!!
// dp[i][j][k]表示能否经过最多k次的交换，使得j移动到i？（我不知道他是什么意思）
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <set>
#include <map>
#include <string>
#include <vector>
#include <algorithm>
#include <ctype.h>
#include <math.h>
using namespace std;
int n,mas[110],d[110][110][110],like[110]; 

int main(){
	//freopen("input.txt","r",stdin);
	scanf("%d",&n);
	for (int i=1;i<=n;i++)
		scanf("%d",&mas[i]);
	for (int i=1;i<=n;i++)
		scanf("%d",&like[i]);
	for (int i=1;i<=n;i++){
		d[i][i][0]=1;
	}
	for (int k=1;k<=n;k++){
		for (int i=1;i<=n;i++){
			for (int j=1;j<=n;j++){
				d[i][j][k]=max(d[i][j][k],d[i][j][k-1]);
				if (d[i][j][k-1]){
					if (j-like[j]>=1)
						d[i][j-like[j]][k]=1;
					if (j+like[j]<=n)
						d[i][j+like[j]][k]=1;
				}
				if (j-like[j]>=1)
					d[i][j][k]=max(d[i][j][k],d[i][j-like[j]][k-1]);
				if (j+like[j]<=n)
					d[i][j][k]=max(d[i][j][k],d[i][j+like[j]][k-1]);
			}
		}
	}
	for (int i=1;i<=n;i++){
		if (!d[mas[i]][i][n]){
			printf("NO");
			return 0;
		}
	}
	printf("YES");
	return 0;
}

ACCode #002

// From ko_osaga
// Rating 3276
// reason : 思路清晰代码简洁明了，运用了dfs代替并查集和is_sorted(怎么感觉好像枚举虽然本来就是枚举)
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include <math.h>
#include <limits.h>
#include <stack>
#include <queue>
#include <map>
#include <set>
#include <algorithm>
#include <string>
#include <functional>
#include <vector>
#include <numeric>
#include <deque>
#include <utility>
#include <bitset>
#include <iostream>
using namespace std;
typedef long long lint;
typedef long double llf;
typedef pair<int, int> pi;
 
vector<int> gph[105];
int n, a[105], b[105];
 
bool vis[105];
vector<int> elem, dfn;
 
void dfs(int x){
	if(vis[x]) return;
	vis[x] = 1;
	elem.push_back(a[x]);
	dfn.push_back(x);
	for(auto &i : gph[x]){
		dfs(i);
	}
}
int main(){
	cin >> n;
	for(int i=0; i<n; i++){
		cin >> a[i];
	}
	for(int i=0; i<n; i++){
		cin >> b[i];
		for(int j=0; j<n; j++){
			if(abs(j - i) == b[i]){
				gph[i].push_back(j);
				gph[j].push_back(i);
			}
		}
	}
	for(int i=0; i<n; i++){
		if(vis[i]) continue;
		elem.clear();
		dfn.clear();
		dfs(i);
		sort(elem.begin(), elem.end());
		sort(dfn.begin(), dfn.end());
		int p = 0;
		for(auto &i : dfn){
			a[i] = elem[p++];
		}
	}
	puts(is_sorted(a, a+n) ? "YES" : "NO");
}

ACCode #003

// From Heart_Blue
// Rating 2425
// reason ： 思路清晰，代码简洁，运用了并查集。
#include <cstdlib>
#include <cctype>
#include <cstring>
#include <cstdio>
#include <cmath>
#include <algorithm>
#include <vector>
#include <string>
#include <iostream>
#include <sstream>
#include <map>
#include <set>
#include <queue>
#include <stack>
#include <fstream>
#include <numeric>
#include <iomanip>
#include <bitset>
#include <list>
#include <stdexcept>
#include <functional>
#include <utility>
#include <ctime>
using namespace std;
typedef long long LL;
typedef unsigned long long ULL;
#define MEM(a,b) memset((a),(b),sizeof(a))
const LL INF = 1e9 + 7;
const int N = 2e3 + 10;
class UnionSet
{
public:
	int fa[N];
	void init()
	{
		MEM(fa, -1);
	}
	int treesize(int x)
	{
		return -fa[Find(x)];
	}
	int Find(int x)
	{
		int root = x;
		while (fa[root] >= 0) root = fa[root];
		while (x != root)
		{
			int tmp = fa[x];
			fa[x] = root;
			x = tmp;
		}
		return root;
	}
	void Union(int x, int y)
	{
		int px = Find(x);
		int py = Find(y);
		if (fa[px] > fa[py]) swap(px, py);
		int sz = fa[px] + fa[py];
		fa[py] = px;
		fa[px] = sz;
	}
} uf;
int a[N];
map<int, int> ms[N];
int main()
{
	//freopen("input.txt", "r", stdin);
	//freopen("output.txt", "w", stdout);
	int n;
	uf.init();
	cin >> n;
	for (int i = 1; i <= n; i++) cin >> a[i];
	for (int i = 1; i <= n; i++)
	{
		int d;
		cin >> d;
		if (i + d <= n && uf.Find(i) != uf.Find(i + d)) uf.Union(i + d, i);
		if (i - d >= 1 && uf.Find(i) != uf.Find(i - d)) uf.Union(i - d, i);
	}
	for (int i = 1; i <= n; i++)
	{
		ms[uf.Find(i)][i] = 1;
	}
	for (int i = 1; i <= n; i++)
	{
		int p = uf.Find(i);
		if (!ms[p].count(a[i]))
		{
			puts("NO");
			return 0;
		}
	}
	puts("YES");
	return 0;
}