Skip to content
Related Articles

Related Articles

Minimum swaps to minimize the sum of first K elements of the Permutation

Improve Article
Save Article
  • Last Updated : 14 Sep, 2022
Improve Article
Save Article

Given a permutation A[] of first N integers (i.e. array contains integers from 1 to N exactly once) and an integer K, the task is to find the minimum number of swaps needed to minimize the sum of the first K elements of the array.

Examples:

Input: N = 4, K = 2, A[] = {3, 4, 1, 2}
Output: 2
Explanation: The swaps performed are as follows: 
{3, 4, 1, 2}  -> {1, 4, 3, 2}, {1, 4, 3, 2}  -> {1, 2, 3, 4
The sum of first K(2) elements becomes 3,  
which is minimum possible for the given permutation. 

Input: N = 3, K = 1, A[] = {3, 2, 1}
Output: 1

Approach: The problem can be solved easily by a greedy approach

The minimum possible sum of K elements of a permutation would be the sum of integers from 1 to K. i.e. A[1] + A[2] + . . . + A[K] can’t be less than 1 + 2 + …. + K. Therefore, apply the swap operation whenever A[i] > K (1 = i ≤ K).

Based on the above observation, the following approach can be followed to arrive at the answer:

  • Declare a hash-set and initialize a variable (say count = 0) to store the total number of swap operations.
  • Store first K elements of the given permutation in the set.
  • Traverse through the permutation from i = 0 to K-1:
    • At each iteration, check if A[i] is present in the set. If not, increment the count by 1.
  • At the end of the iteration, return the count.

Below is the implementation for the above approach:

C++




// C++ code to implement the approach
 
#include <bits/stdc++.h>
using namespace std;
 
// Function to find minimum swaps needed
// to minimize the sum of first K elements
// of the array
int minimumSwaps(int A[], int N, int K)
{
    // Declaring the Hash-set
    set<int> S;
 
    // Variable to store the count of
    // swaps required
    int count = 0;
 
    // Inserting initial K elements of
    // the permutation into the set
    for (int i = 1; i <= K; i++) {
        S.insert(i);
    }
 
    // Checking which among 1 to K is not
    // present in the initial K elements
    for (int i = 0; i < K; i++) {
        if (S.find(A[i]) == S.end()) {
            count++;
        }
    }
 
    // Returning the count of swaps
    // required
    return count;
}
 
// Driver code
int main()
{
    int N = 4;
    int K = 2;
    int A[] = { 3, 4, 1, 2 };
 
    // Function Call
    int answer = minimumSwaps(A, N, K);
    cout << answer;
 
    return 0;
}


Java




// Java code for the above approach
import java.io.*;
import java.util.*;
 
class GFG
{
 
// Function to find minimum swaps needed
// to minimize the sum of first K elements
// of the array
static int minimumSwaps(int A[], int N, int K)
{
    // Declaring the Hash-set
     Set<Integer> S = new HashSet<>();
 
    // Variable to store the count of
    // swaps required
    int count = 0;
 
    // Inserting initial K elements of
    // the permutation into the set
    for (int i = 1; i <= K; i++) {
        S.add(i);
    }
 
    // Checking which among 1 to K is not
    // present in the initial K elements
    for (int i = 0; i < K; i++) {
        if (! S.contains(A[i])) {
            count++;
        }
    }
 
    // Returning the count of swaps
    // required
    return count;
}
 
    // Driver code
    public static void main(String[] args)
    {
    int N = 4;
    int K = 2;
    int A[] = { 3, 4, 1, 2 };
 
    // Function Call
    int answer = minimumSwaps(A, N, K);
    System.out.println( answer);
    }
}
 
 // This code is contributed by sanjoy_62.


Python3




# Function to check if it is possible to
 
# Function to find minimum swaps needed
# to minimize the sum of first K elements
# of the array
def minimumSwaps(A, N, K) :
 
    # Declaring the Hash-set
    S = set()
 
    # Variable to store the count of
    # swaps required
    count = 0
 
    # Inserting initial K elements of
    # the permutation into the set
    for i in range(1, K+1):
        S.add(i)
     
    # Checking which among 1 to K is not
    # present in the initial K elements
    for i in range(K):
        if ((A[i]) not in S) :
            count += 1
         
    # Returning the count of swaps
    # required
    return count
 
# Driver code
if __name__ == "__main__":
 
    N = 4
    K = 2
    A = [ 3, 4, 1, 2 ]
 
    # Function Call
    answer = minimumSwaps(A, N, K)
    print(answer)
 
    # This code is contributed by code_hunt.


C#




// C# code for the above approach
using System;
using System.Collections.Generic;
 
public class GFG {
 
  // Function to find minimum swaps needed
  // to minimize the sum of first K elements
  // of the array
  static int minimumSwaps(int[] A, int N, int K)
  {
    // Declaring the Hash-set
    HashSet<int> S = new HashSet<int>();
 
    // Variable to store the count of
    // swaps required
    int count = 0;
 
    // Inserting initial K elements of
    // the permutation into the set
    for (int i = 1; i <= K; i++) {
      S.Add(i);
    }
 
    // Checking which among 1 to K is not
    // present in the initial K elements
    for (int i = 0; i < K; i++) {
      if (!S.Contains(A[i])) {
        count++;
      }
    }
 
    // Returning the count of swaps
    // required
    return count;
  }
 
  static public void Main()
  {
 
    // Code
    int N = 4;
    int K = 2;
    int[] A = { 3, 4, 1, 2 };
 
    // Function Call
    int answer = minimumSwaps(A, N, K);
    Console.WriteLine(answer);
  }
}
 
// This code is contributed by lokeshmvs21.


Javascript




// Javascript code to implement the approach
function minimumSwaps(A, N, K)
{
 
  // Declaring the Hash-set
  let S = new Set();
 
  // Variable to store the count of
  // swaps required
  let count = 0;
 
  // Inserting initial K elements of
  // the permutation leto the set
  for (let i = 1; i <= K; i++) {
    S.add(i);
  }
 
  // Checking which among 1 to K is not
  // present in the initial K elements
  for (let i = 0; i < K; i++) {
    if (!S.has(A[i])) {
      count++;
    }
  }
 
  // Returning the count of swaps
  // required
  return count;
}
 
let N = 4;
let K = 2;
let A = [3, 4, 1, 2];
 
// Function Call
let answer = minimumSwaps(A, N, K);
console.log(answer);
 
// This code iscontributed by ishankhandelwals.


Output

2

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


My Personal Notes arrow_drop_up
Related Articles

Start Your Coding Journey Now!