Given an array A[], consisting of N elements, the task is to find the minimum number of swaps required such that array elements swapped to replace a higher element, in the original array, is maximized.
Examples:
Input: A[] = {4, 3, 3, 2, 5}
Output: 3
Explanation:
Swap 1: {4, 3, 3, 2, 5} -> {5, 3, 3, 2, 4}
Swap 2: {5, 3, 3, 2, 4} -> {3, 3, 5, 2, 4}
Swap 3: {3, 3, 5, 2, 4} -> {3, 3, 2, 5, 4}
Therefore, elements {4, 3, 2} occupies original position of a higher element after swapping
Input:. A[] = {6, 5, 4, 3, 2, 1}
OutputL 5
Naive Approach: The simplest approach to solve the problem can be implemented as follows:
- Sort the array in ascending order.
- Initialize two variables, result, and index, to store the count and the index up to which it has been considered in the original array, respectively.
- Iterate over the array elements. For any element A[i], go to a value in the array which is greater than ai and increment the index variable accordingly.
- After finding an element greater than A[i], increment result, and index.
- If index has reached the end of the array, no elements are left to be swapped with previously checked elements.
- Therefore, print count.
Below is the implementation of the above approach:
C++
// C++ Program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function to find the minimum // number of swaps required int countSwaps( int A[], int n) { // Sort the array in ascending order sort(A, A + n); int ind = 1, res = 0; for ( int i = 0; i < n; i++) { // Iterate until a greater element // is found while (ind < n and A[ind] == A[i]) // Keep incrementing ind ind++; // If a greater element is found if (ind < n and A[ind] > A[i]) { // Increase count of swap res++; // Increment ind ind++; } // If end of array is reached if (ind >= n) break ; } // Return the answer return res; } // Driver Code int main() { int A[] = { 4, 3, 3, 2, 5 }; cout << countSwaps(A, 5); return 0; } |
Java
// Java Program to implement // the above approach import java.util.*; class GFG{ // Function to find the minimum // number of swaps required static int countSwaps( int A[], int n) { // Sort the array in ascending order Arrays.sort(A); int ind = 1 , res = 0 ; for ( int i = 0 ; i < n; i++) { // Iterate until a greater element // is found while (ind < n && A[ind] == A[i]) // Keep incrementing ind ind++; // If a greater element is found if (ind < n && A[ind] > A[i]) { // Increase count of swap res++; // Increment ind ind++; } // If end of array is reached if (ind >= n) break ; } // Return the answer return res; } // Driver Code public static void main(String[] args) { int A[] = { 4 , 3 , 3 , 2 , 5 }; System.out.print(countSwaps(A, 5 )); } } // This code is contributed by gauravrajput1 |
Python3
# Python3 program to implement # the above approach # Function to find the minimum # number of swaps required def countSwaps(A, n): # Sort the array in ascending order A.sort() ind, res = 1 , 0 for i in range (n): # Iterate until a greater element # is found while (ind < n and A[ind] = = A[i]): # Keep incrementing ind ind + = 1 # If a greater element is found if (ind < n and A[ind] > A[i]): # Increase count of swap res + = 1 # Increment ind ind + = 1 # If end of array is reached if (ind > = n): break # Return the answer return res # Driver Code A = [ 4 , 3 , 3 , 2 , 5 ] print (countSwaps(A, 5 )) # This code is contributed by chitranayal |
C#
// C# Program to implement // the above approach using System; class GFG{ // Function to find the minimum // number of swaps required static int countSwaps( int []A, int n) { // Sort the array in ascending order Array.Sort(A); int ind = 1, res = 0; for ( int i = 0; i < n; i++) { // Iterate until a greater element // is found while (ind < n && A[ind] == A[i]) // Keep incrementing ind ind++; // If a greater element is found if (ind < n && A[ind] > A[i]) { // Increase count of swap res++; // Increment ind ind++; } // If end of array is reached if (ind >= n) break ; } // Return the answer return res; } // Driver Code public static void Main(String[] args) { int []A = { 4, 3, 3, 2, 5 }; Console.Write(countSwaps(A, 5)); } } // This code is contributed by Amit Katiyar |
3
Time Complexity: O(N * log N)
Auxiliary Space: O(1)
Efficient Approach:
Since any swap between two unequal elements leads to an element replacing a higher element, it can be observed that the minimum number of swaps required is N – (the maximum frequency of an array element). Therefore, find the most frequent element in the array using HashMap, and print the result.
Below is the implementation of the above approach:
C++
// C++ Program to implement // the above approach #include <bits/stdc++.h> using namespace std; // Function to find the minimum // number of swaps required int countSwaps( int A[], int n) { // Stores the frequency of the // array elements map< int , int > mp; // Stores maximum frequency int max_frequency = 0; // Find the max frequency for ( int i = 0; i < n; i++) { // Update frequency mp[A[i]]++; // Update maximum frequency max_frequency = max(max_frequency, mp[A[i]]); } return n - max_frequency; } // Driver Code int main() { int A[] = { 6, 5, 4, 3, 2, 1 }; // function call cout << countSwaps(A, 6); return 0; } |
Java
// Java Program to implement // the above approach import java.util.*; class GFG{ // Function to find the minimum // number of swaps required static int countSwaps( int arr[], int n) { // Stores the frequency of the // array elements HashMap<Integer, Integer> mp = new HashMap<Integer, Integer>(); // Stores maximum frequency int max_frequency = 0 ; // Find the max frequency for ( int i = 0 ; i < n; i++) { // Update frequency if (mp.containsKey(arr[i])) { mp.put(arr[i], mp.get(arr[i]) + 1 ); } else { mp.put(arr[i], 1 ); } // Update maximum frequency max_frequency = Math.max(max_frequency, mp.get(arr[i])); } return n - max_frequency; } // Driver Code public static void main(String[] args) { int A[] = { 6 , 5 , 4 , 3 , 2 , 1 }; // function call System.out.print(countSwaps(A, 6 )); } } // This code is contributed by Rohit_ranjan |
Python3
# Python3 Program to implement # the above approach # Function to find the minimum # number of swaps required def countSwaps(A, n): # Stores the frequency of the # array elements mp = {} # Stores maximum frequency max_frequency = 0 # Find the max frequency for i in range (n): # Update frequency if A[i] in mp: mp[A[i]] + = 1 else : mp[A[i]] = 1 # Update maximum frequency max_frequency = max (max_frequency, mp[A[i]]) return n - max_frequency # Driver code if __name__ = = "__main__" : A = [ 6 , 5 , 4 , 3 , 2 , 1 ] # function call print (countSwaps(A, 6 )) # This code is contributed by divyeshrabadiya07 |
C#
// C# program to implement // the above approach using System; using System.Collections.Generic; class GFG{ // Function to find the minimum // number of swaps required static int countSwaps( int []arr, int n) { // Stores the frequency of the // array elements Dictionary< int , int > mp = new Dictionary< int , int >(); // Stores maximum frequency int max_frequency = 0; // Find the max frequency for ( int i = 0; i < n; i++) { // Update frequency if (mp.ContainsKey(arr[i])) { mp[arr[i]] = mp[arr[i]] + 1; } else { mp.Add(arr[i], 1); } // Update maximum frequency max_frequency = Math.Max(max_frequency, mp[arr[i]]); } return n - max_frequency; } // Driver Code public static void Main(String[] args) { int []A = { 6, 5, 4, 3, 2, 1 }; // Function call Console.Write(countSwaps(A, 6)); } } // This code is contributed by 29AjayKumar |
5
Time Complexity: O(N)
Auxiliary Space: O(N)
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.