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 swappingInput:. 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, repectively.
- Iterate over the array elements. For any element A[i], go to a value in the array which is greater than ai and increment 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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output:
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; } |
chevron_right
filter_none
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 |
chevron_right
filter_none
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 |
chevron_right
filter_none
Output:
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.
Recommended Posts:
- Minimize array length by repeatedly replacing pairs of unequal adjacent array elements by their sum
- Minimize swaps to rearrange array such that parity of index and corresponding element is same
- Maximize count of equal numbers in Array of numbers upto N by replacing pairs with their sum
- Minimum swaps to reach permuted array with at most 2 positions left swaps allowed
- Minimize count of array elements to be removed to maximize difference between any pair up to K
- Minimize count of increments of each element of subarrays required to make Array non-increasing
- Maximize distance between two elements of Array by at most X swaps
- Minimize Array length by repeatedly replacing co-prime pairs with 1
- Maximize modulus by replacing adjacent pairs with their modulus for any permutation of given Array
- Maximize array sum by replacing equal adjacent pairs by their sum and X respectively
- Maximize the number of indices such that element is greater than element to its left
- Replacing an element makes array elements consecutive
- Maximum sum of Array formed by replacing each element with sum of adjacent elements
- Minimize operations required to make each element of Array equal to it's index value
- Minimum swaps required to bring all elements less than or equal to k together
- Minimize steps required to make all array elements same by adding 1, 2 or 5
- Minimize subarray increments/decrements required to reduce all array elements to 0
- Count of Array elements greater than all elements on its left and at least K elements on its right
- Count of Array elements greater than all elements on its left and next K elements on its right
- Maximize the given number by replacing a segment of digits with the alternate digits given
If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.
Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.
