Minimize swaps required to maximize the count of elements replacing a greater element in an Array

• Last Updated : 17 May, 2021

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, are maximized.

Examples:

Input: A[] = {4, 3, 3, 2, 5}
Output:
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}
Output: 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 the 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 using namespace std; // Function to find the minimum// number of swaps requiredint 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 Codeint main(){     int A[] = { 4, 3, 3, 2, 5 };    cout << countSwaps(A, 5);     return 0;}

Java

 // Java Program to implement// the above approachimport java.util.*;class GFG{ // Function to find the minimum// number of swaps requiredstatic 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 Codepublic 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 requireddef 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 CodeA = [ 4, 3, 3, 2, 5 ] print (countSwaps(A, 5)) # This code is contributed by chitranayal

C#

 // C# Program to implement// the above approachusing System;class GFG{ // Function to find the minimum// number of swaps requiredstatic 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 Codepublic static void Main(String[] args){    int []A = { 4, 3, 3, 2, 5 };    Console.Write(countSwaps(A, 5));}} // This code is contributed by Amit Katiyar

Javascript


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 using namespace std; // Function to find the minimum// number of swaps requiredint countSwaps(int A[], int n){    // Stores the frequency of the    // array elements    map 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 Codeint main(){     int A[] = { 6, 5, 4, 3, 2, 1 };     // function call    cout << countSwaps(A, 6);     return 0;}

Java

 // Java Program to implement// the above approachimport java.util.*;class GFG{ // Function to find the minimum// number of swaps requiredstatic int countSwaps(int arr[], int n){    // Stores the frequency of the    // array elements    HashMap mp = new HashMap();     // 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 Codepublic 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 requireddef 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 codeif __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 approachusing System;using System.Collections.Generic; class GFG{ // Function to find the minimum// number of swaps requiredstatic int countSwaps(int []arr, int n){         // Stores the frequency of the    // array elements    Dictionary mp = new Dictionary();     // 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 Codepublic 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

Javascript


Output:
5

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up