Skip to content
Related Articles

Related Articles

Improve Article

Check if the array can be sorted using swaps between given indices only

  • Difficulty Level : Hard
  • Last Updated : 03 Jun, 2021

Given an array arr[] of size N consisting of distinct integers from range [0, N – 1] arranged in a random order. Also given a few pairs where each pair denotes the indices where the elements of the array can be swapped. There is no limit on the number of swaps allowed. The task is to find if it is possible to arrange the array in ascending order using these swaps. If possible then print Yes else print No.
Examples: 
 

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 
 

 

Approach: The given problem can be considered as a graph problem where N denotes the total number of nodes in the graph and each swapping pair denotes an undirected edge in the graph. We have to find out if it is possible to convert the input array in the form of {0, 1, 2, 3, …, N – 1}. 
Let us call the above array as B. Now find out all the connected components of both the arrays and if the elements differ for at least one component then the answer is No else the answer is Yes.
Below is the implementation of the above approach: 
 

CPP




// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
// Function that returns true if the array elements
// can be sorted with the given operation
bool canBeSorted(int N, vector<int> a, int P,
vector<pair<int, int> > vp)
{
 
    // To create the adjacency list of the graph
    vector<int> 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<int> q;
            vector<int> v1;
            vector<int> 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<int> a = { 0, 4, 3, 2, 1, 5 };
    int n = a.size();
    vector<pair<int, int> > 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<Integer> a,
                             int p, ArrayList<ArrayList<Integer>> vp)
  {
     
    // To create the adjacency list of the graph
    ArrayList<ArrayList<Integer>> v = new ArrayList<ArrayList<Integer>>();
    for(int i = 0; i < N; i++)
    {
      v.add(new ArrayList<Integer>());
    }
     
    // 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<Integer> q = new LinkedList<>();
        ArrayList<Integer> v1 = new ArrayList<Integer>();
        ArrayList<Integer> v2 = new ArrayList<Integer>();
 
        // 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<Integer> a = new ArrayList<Integer>(Arrays.asList(0, 4, 3, 2, 1, 5));
    int n = a.size();
    ArrayList<ArrayList<Integer>> vp = new ArrayList<ArrayList<Integer>>();
    vp.add(new ArrayList<Integer>(Arrays.asList(1, 4)));
    vp.add(new ArrayList<Integer>(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
Javascript



<script>
 
// Javascript implementation of the approach
     
    // Function that returns true if the array elements
   // can be sorted with the given operation
    function canBeSorted(N,a,p,vp)
    {
        // To create the adjacency list of the graph
    let v= [];
    for(let i = 0; i < N; i++)
    {
      v.push([]);
    }
      
    // Boolean array to mark the visited nodes
    let vis = new Array(N);
  
    // Creating adjacency list for undirected graph
    for (let i = 0; i < p; i++)
    {
      v[vp[i][0]].push(vp[i][1]);
      v[vp[i][1]].push(vp[i][0]);
    }
    for (let i = 0; i < N; i++)
    {
        
      // If not already visited
      // then apply BFS
      if (!vis[i])
      {
        let q = [];
        let v1 = [];
        let v2 = [];
  
        // Set visited to true   
        vis[i] = true;
  
        // Push the node to the queue
        q.push(i);
  
        // While queue is not empty
        while (q.length > 0)
        {
          let u = q.shift();
          v1.push(u);
          v2.push(a[u]);
  
          // Check all the adjacent nodes
          for(let s=0;s<v[u].length;s++)
          {
              
            // If not visited
            if (!vis[v[u][s]])
            {
                
              // Set visited to true
              vis[v[u][s]] = true;
              q.push(v[u][s]);
            }
          }
  
        }
        v1.sort(function(c,d){return c-d;});
        v2.sort(function(c,d){return c-d;});
  
        // If the connected component does not
        // contain same elements then return false
        if(v1.toString()!=(v2).toString())
        {
          return false;
        }
      }
    }
    return true;
    }
     
    // Driver code
    let a = [0, 4, 3, 2, 1, 5];
    let n = a.length;
    let vp = [];
    vp.push([1, 4]);
    vp.push([2, 3]);
    let p = vp.length;
    if (canBeSorted(n, a, p, vp))
    {
      document.write("Yes");  
    }
    else
    {
      document.write("No");
    }
 
 
// This code is contributed by unknown2108
 
</script>
Output: 
Yes
 
Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.
In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.



My Personal Notes
arrow_drop_up
Next

Check if it is possible to sort an array with conditional swapping of adjacent allowed
Recommended Articles
Page :
Check if the array can be sorted only if the elements on given positions can be swapped
07, May 20
Count pairs of indices having sum of indices same as the sum of elements at those indices
21, Jul 21
Count of indices pairs such that product of elements at these indices is equal to absolute difference of indices
07, Jul 21
Check if an array can be sorted by swapping pairs from indices consisting of unequal elements in another array
03, Feb 21
Check if end of a sorted Array can be reached by repeated jumps of one more, one less or same number of indices as previous jump
24, Nov 20
Check if an Array can be Sorted by picking only the corner Array elements
12, Aug 20
Minimize swaps required to place largest and smallest array elements at first and last array indices
28, Jan 21
Minimum swaps to reach permuted array with at most 2 positions left swaps allowed
26, Mar 17
Find if array can be sorted by swaps limited to multiples of k
27, Apr 20
Check if two sorted arrays can be merged to form a sorted array with no adjacent pair from the same array
16, Nov 20
Minimum number of swaps required to make parity of array elements same as their indices
08, Mar 21
Find the Array Permutation having sum of elements at odd indices greater than sum of elements at even indices
07, Jul 21
Longest increasing subsequence consisting of elements from indices divisible by previously selected indices
04, Dec 20
Count pairs with product of indices equal to the product of elements present at those indices
18, Mar 21
Check if a palindromic string can be obtained by concatenating substrings split from same indices of two given strings
16, Oct 20
Number of swaps to sort when only adjacent swapping allowed
25, Nov 16
Count number of common elements between a sorted array and a reverse sorted array
12, May 21
Maximum number of partitions that can be sorted individually to make sorted
28, Feb 18
Check if a decreasing Array can be sorted using Triple cyclic shift
09, Jul 20
Find the string from an array that can be converted to a string S with minimum number of swaps
16, Mar 21
Check if array can be sorted by swapping pairs with GCD of set bits count equal to that of the smallest array element
17, Sep 20
Check if array can be sorted by swapping pairs having GCD equal to the smallest element in the array
16, Sep 20
Maximum types of candies a person can eat if only N/2 of them can be eaten
16, Jun 21
Minimize swaps between two arrays such that sum of the first array exceeds sum of the second array
18, Jan 21
Article Contributed By :
https://media.geeksforgeeks.org/auth/avatar.png
Azad
@Azad
Vote for difficulty
Current difficulty :
Hard





Improved By :
Article Tags :
Practice Tags :
Report Issue

We use cookies to ensure you have the best browsing experience on our website. By using our site, you
acknowledge that you have read and understood our
Cookie Policy &
        Privacy Policy

Lightbox