给定大小为N的数组arr [] ，该数组arr []由范围为[0，N – 1]的不同整数组成，这些整数以随机顺序排列。还给出了几对，其中每对表示可以交换数组元素的索引。允许的交换数量没有限制。任务是查找是否有可能使用这些交换以升序排列阵列。如果可能，请打印“是”，否则打印“否” 。
例子：
Input: arr[] = {0, 4, 3, 2, 1, 5}, pairs[][] = {{1, 4}, {2, 3}}
Output: Yes
swap(arr[1], arr[4]) -> arr[] = {0, 1, 3, 2, 4, 5}
swap(arr[2], arr[3]) -> arr[] = {0, 1, 2, 3, 4, 5}
Input: arr[] = {1, 2, 3, 0, 4}, pairs[][] = {{2, 3}}
Output: No
方法：给定问题可以视为图问题，其中N表示图中的节点总数，每个交换对表示图中的无向边。我们必须找出是否可以将输入数组转换为{0，1，2，3，…，N – 1}的形式。
让我们将上面的数组称为B。现在找出两个数组的所有连接组件，如果至少一个组件的元素不同，则答案为“否”，否则答案为“是” 。
下面是上述方法的实现：
CPP
// C++ implementation of the approach
#include
using namespace std;
// Function that returns true if the array elements
// can be sorted with the given operation
bool canBeSorted(int N, vector a, int P,
vector > vp)
{
// To create the adjacency list of the graph
vector v[N];
// Boolean array to mark the visited nodes
bool vis[N] = { false };
// Creating adjacency list for undirected graph
for (int i = 0; i < P; i++) {
v[vp[i].first].push_back(vp[i].second);
v[vp[i].second].push_back(vp[i].first);
}
for (int i = 0; i < N; i++) {
// If not already visited
// then apply BFS
if (!vis[i]) {
queue q;
vector v1;
vector v2;
// Set visited to true
vis[i] = true;
// Push the node to the queue
q.push(i);
// While queue is not empty
while (!q.empty()) {
int u = q.front();
v1.push_back(u);
v2.push_back(a[u]);
q.pop();
// Check all the adjacent nodes
for (auto s : v[u]) {
// If not visited
if (!vis[s]) {
// Set visited to true
vis[s] = true;
q.push(s);
}
}
}
sort(v1.begin(), v1.end());
sort(v2.begin(), v2.end());
// If the connected component does not
// contain same elements then return false
if (v1 != v2)
return false;
}
}
return true;
}
// Driver code
int main()
{
vector a = { 0, 4, 3, 2, 1, 5 };
int n = a.size();
vector > vp = { { 1, 4 }, { 2, 3 } };
int p = vp.size();
if (canBeSorted(n, a, p, vp))
cout << "Yes";
else
cout << "No";
return 0;
} Java
// Java implementation of the approach
import java.io.*;
import java.util.*;
class GFG
{
// Function that returns true if the array elements
// can be sorted with the given operation
static boolean canBeSorted(int N, ArrayList a,
int p, ArrayList> vp)
{
// To create the adjacency list of the graph
ArrayList> v = new ArrayList>();
for(int i = 0; i < N; i++)
{
v.add(new ArrayList());
}
// Boolean array to mark the visited nodes
boolean[] vis = new boolean[N];
// Creating adjacency list for undirected graph
for (int i = 0; i < p; i++)
{
v.get(vp.get(i).get(0)).add(vp.get(i).get(1));
v.get(vp.get(i).get(1)).add(vp.get(i).get(0));
}
for (int i = 0; i < N; i++)
{
// If not already visited
// then apply BFS
if (!vis[i])
{
Queue q = new LinkedList<>();
ArrayList v1 = new ArrayList();
ArrayList v2 = new ArrayList();
// Set visited to true
vis[i] = true;
// Push the node to the queue
q.add(i);
// While queue is not empty
while (q.size() > 0)
{
int u = q.poll();
v1.add(u);
v2.add(a.get(u));
// Check all the adjacent nodes
for(int s: v.get(u))
{
// If not visited
if (!vis[s])
{
// Set visited to true
vis[s] = true;
q.add(s);
}
}
}
Collections.sort(v1);
Collections.sort(v2);
// If the connected component does not
// contain same elements then return false
if(!v1.equals(v2))
{
return false;
}
}
}
return true;
}
// Driver code
public static void main (String[] args)
{
ArrayList a = new ArrayList(Arrays.asList(0, 4, 3, 2, 1, 5));
int n = a.size();
ArrayList> vp = new ArrayList>();
vp.add(new ArrayList(Arrays.asList(1, 4)));
vp.add(new ArrayList(Arrays.asList(2, 3)));
int p = vp.size();
if (canBeSorted(n, a, p, vp))
{
System.out.println("Yes");
}
else
{
System.out.println("No");
}
}
}
// This code is contributed by avanitrachhadiya2155 Python3
# Python3 implementation of the approach
from collections import deque as queue
# Function that returns true if the array elements
# can be sorted with the given operation
def canBeSorted(N, a, P, vp):
# To create the adjacency list of the graph
v = [[] for i in range(N)]
# Boolean array to mark the visited nodes
vis = [False]*N
# Creating adjacency list for undirected graph
for i in range(P):
v[vp[i][0]].append(vp[i][1])
v[vp[i][1]].append(vp[i][0])
for i in range(N):
# If not already visited
# then apply BFS
if (not vis[i]):
q = queue()
v1 = []
v2 = []
# Set visited to true
vis[i] = True
# Push the node to the queue
q.append(i)
# While queue is not empty
while (len(q) > 0):
u = q.popleft()
v1.append(u)
v2.append(a[u])
# Check all the adjacent nodes
for s in v[u]:
# If not visited
if (not vis[s]):
# Set visited to true
vis[s] = True
q.append(s)
v1 = sorted(v1)
v2 = sorted(v2)
# If the connected component does not
# contain same elements then return false
if (v1 != v2):
return False
return True
# Driver code
if __name__ == '__main__':
a = [0, 4, 3, 2, 1, 5]
n = len(a)
vp = [ [ 1, 4 ], [ 2, 3 ] ]
p = len(vp)
if (canBeSorted(n, a, p, vp)):
print("Yes")
else:
print("No")
# This code is contributed by mohit kumar 29输出：
Yes