Check if an array can be sorted by swapping pairs from indices consisting of unequal elements in another array

// Java program of the above approach
import java.io.*;

class GFG {

    
    // Function to check if array, A[] can be converted 
    // into sorted array by swapping (A[i], A[j]) if B[i]
    // not equal to B[j]
    static boolean checkifSorted(int A[], int B[], int N)
    {
        
        // Stores if array A[] is sorted 
        // in descending order or not
        boolean flag = false;

        // Traverse the array A[]
        for (int i = 0; i < N - 1; i++) {

            // If A[i] is greater than A[i + 1]
            if (A[i] > A[i + 1]) {

                // Update flag
                flag = true;
                break;
            }
        }

        // If array is sorted 
        // in ascending order
        if (!flag) {
            return true;
        }

        // count = 2: Check if 0s and 1s 
        // both present in the B[]
        int count = 0;

        // Traverse the array
        for (int i = 0; i < N; i++) {
            
            // If current element is 0
            if (B[i] == 0) {
                
                // Update count
                count++;
                break;
            }
        }
        
        
        // Traverse the array B[]
        for (int i = 0; i < N; i++) {
            
            // If current element is 1
            if (B[i] == 1) {
                count++;
                break;
            }
        }

        // If both 0s and 1s are present
        // in the array
        if (count == 2) {
            return true;
        }
        return false;
    }

    // Driver Code
    public static void main(String[] args)
    {
        // Input array A[]
        int A[] = { 3, 1, 2 };

        // Input array B[]
        int B[] = { 0, 1, 1 };

        int N = A.length;
        // Function call
        boolean check = checkifSorted(A, B, N);

        // If true,print YES
        if (check) {
            System.out.println("YES");
        }
        // Else print NO
        else {
            System.out.println("NO");
        }
    }
}

// Nikunj Sonigara

import java.util.*;

class Main {
    // This function checks if the given arrays A and B can be sorted by swapping
    // elements in such a way that the resulting array is sorted in ascending order.
    static boolean checkIfSorted(int[] A, int[] B, int N) {
        List<Pair<Integer, Integer>> vec = new ArrayList<>();
        
        // Create a list of pairs, where each pair consists of elements from arrays A and B.
        for (int i = 0; i < N; i++) {
            vec.add(new Pair<>(A[i], B[i]));
        }
        
        // Sort the list of pairs in descending order based on the A values.
        vec.sort((a, b) -> Integer.compare(b.getKey(), a.getKey()));
        
        int unsortedIndex = -1;
        
        // Find the index where the list becomes unsorted in terms of B values.
        for (int i = 0; i < N - 1; i++) {
            if (vec.get(i).getValue() > vec.get(i + 1).getValue()) {
                unsortedIndex = i;
                break;
            }
        }
        
        if (unsortedIndex == -1) {
            return true; // If the list is already sorted by B values, return true.
        }
        
        // Find an element with B value equal to 1 and swap it with the unsorted element.
        for (int i = unsortedIndex + 1; i < N; i++) {
            if (vec.get(i).getValue() == 1) {
                Collections.swap(vec, unsortedIndex, i);
                break;
            }
        }
        
        // Check if the list is sorted in ascending order by A values after the swap.
        for (int i = 0; i < N - 1; i++) {
            if (vec.get(i).getKey() > vec.get(i + 1).getKey()) {
                return false; // If not sorted, return false.
            }
        }
        
        return true; // If sorted after the swap, return true.
    }

    public static void main(String[] args) {
        int[] A = {3, 1, 2};
        int[] B = {0, 1, 1};
        int N = A.length;
        boolean check = checkIfSorted(A, B, N);
        if (check) {
            System.out.println("YES"); // Output "YES" if the arrays can be sorted.
        } else {
            System.out.println("NO"); // Output "NO" if the arrays cannot be sorted.
        }
    }
    
    // Definition of the Pair class for storing pairs of elements.
    static class Pair<K, V> {
        private final K key;
        private final V value;

        public Pair(K key, V value) {
            this.key = key;
            this.value = value;
        }

        public K getKey() {
            return key;
        }

        public V getValue() {
            return value;
        }
    }
}