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

// 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

//Java code for this approach
import java.util.*;

class Main {
    // Find operation of Union-Find algorithm
    static int find(int[] parent, int i) {
        if (parent[i] == i) // If i is the parent of itself, return i
            return i;
        parent[i] = find(parent, parent[i]); // Path compression
        return parent[i];
    }

    // Union operation of Union-Find algorithm
    static void unionSets(int[] parent, int i, int j) {
        parent[find(parent, j)] = find(parent, i); // Connect the two sets by setting the parent of one to the other
    }

    // Function to check if it's possible to sort the array using the given pairs
    static String canSortArray(List<Integer> arr, List<Pair<Integer, Integer>> pairs) {
        int n = arr.size();

        // Initialize the parent array with each node being a separate set
        int[] parent = new int[n];
        for (int i = 0; i < n; i++)
            parent[i] = i;

        // Merge the sets based on the given pairs
        for (Pair<Integer, Integer> p : pairs)
            unionSets(parent, p.first, p.second);

        // Check if each element is connected to its correct index
        for (int i = 0; i < n; i++) {
            if (find(parent, i) != find(parent, arr.get(i))) // If the parent of i is not the same as the parent of arr[i]
                return "No"; // Return "No" as the array cannot be sorted using the given pairs
        }

        return "Yes"; // If all elements are connected to their correct index, return "Yes"
    }

    // Driver code
    public static void main(String[] args) {
        List<Integer> arr = Arrays.asList(0, 4, 3, 2, 1, 5);
        List<Pair<Integer, Integer>> pairs = Arrays.asList(new Pair<>(1, 4), new Pair<>(2, 3));

        System.out.println(canSortArray(arr, pairs)); // Output: Yes

        arr = Arrays.asList(1, 2, 3, 0, 4);
        pairs = Arrays.asList(new Pair<>(2, 3));

        System.out.println(canSortArray(arr, pairs)); // Output: No
    }
}

class Pair<A, B> {
    public A first;
    public B second;

    public Pair(A first, B second) {
        this.first = first;
        this.second = second;
    }
}
// Sundaram Singh