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++ 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 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.
|
# 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# 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 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 into 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. |
2
Time Complexity: O(N)
Auxiliary Space: O(N)