Given numeric string S of size N and a positive integer K, the task is to find the minimum number of adjacent swaps required in S to obtain the Kth smallest numeric string greater than the given string.
Examples:
Input: S = “11112”, K = 4
Output: 4
Explanation:
The Kth(= 4th) smallest numeric string which is greater than the given string is “21111”. The sequence of adjacent swap to reach the string “21111” is “11112” -> “11121” -> “11211″ -> “12111″ -> “21111″.
Therefore, the minimum number of adjacent swaps required is 4.Input: S = “12345”, K = 1
Output: 1
Approach: The given problem can be solved by using the Greedy Approach. Follow the steps below to solve the problem:
- Store the copy of the current numeric string in a variable, say res.
- Create a variable, say totalSwaps that stores the minimum swaps required.
- Since K-th largest number is required, this statement is equal to finding K-th permutation starting from the current string.
- Find the K-th permutation using the function next_permutation().
-
Iterate over the range [0, N) using the variable i and perform the following tasks:
- If res[i] is not equal to str[i] then initialize the variable start as i+1 and traverse over a while loop till res[i] is not equal to str[start] and increase the value of i by 1.
- Iterate a loop till i is not equal to start and swap the values str[start] and str[start – 1] and decrease the value of start by 1 and increase the value of totalSwaps by 1.
- After performing the above steps, print the value of totalSwaps as the answer.
Below is the implementation of the above approach:
// C++ program for the above approach #include <bits/stdc++.h> using namespace std;
// Function to find the minimum number // of swaps required to make the Kth // smallest string greater than str void minSwapsKthLargest(string str, int k)
{ // Store the copy of the string
string res = str;
// Find the K-th permutation of
// the given numeric string
for ( int i = 0; i < k; i++) {
next_permutation(
str.begin(), str.end());
cout<< "str = " <<str<<endl;
}
// Stores the count of swaps required
int swap_count = 0;
// Traverse the string and find the
// swaps required greedily
for ( int i = 0; i < res.length(); i++) {
// If both characters do not match
if (res[i] != str[i]) {
int start = i + 1;
// Search from i+1 index
while (res[i] != str[start]) {
// Find the index to swap
start++;
}
while (i != start) {
swap(str[start], str[start - 1]);
// Swap until the characters
// are at same index
start--;
swap_count++;
}
}
}
// Print the minimum number of counts
cout << swap_count;
} // Driver Code int main()
{ string S = "11112" ;
int K = 4;
minSwapsKthLargest(S, K);
return 0;
} |
// Java program for the above approach import java.util.*;
class GFG {
static char [] next_permutation( char [] array) {
int i = array.length - 1 ;
while (i > 0 && array[i - 1 ] >= array[i]) {
i--;
}
int j = array.length - 1 ;
while (array[j] <= array[i - 1 ]) {
j--;
}
char temp = array[i - 1 ];
array[i - 1 ] = array[j];
array[j] = temp;
j = array.length - 1 ;
while (i < j) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
j--;
}
return array;
}
// Function to find the minimum number
// of swaps required to make the Kth
// smallest String greater than str
static void minSwapsKthLargest(String str, int k)
{
// Store the copy of the String
char [] res = str.toCharArray();
char [] s = str.toCharArray();
// Find the K-th permutation of
// the given numeric String
for ( int i = 0 ; i < k; i++) {
s = next_permutation(s);
}
// Stores the count of swaps required
int swap_count = 0 ;
// Traverse the String and find the
// swaps required greedily
for ( int i = 0 ; i < res.length; i++) {
// If both characters do not match
if (res[i] != s[i]) {
int start = i + 1 ;
// Search from i+1 index
while (res[i] != s[start]) {
// Find the index to swap
start++;
}
while (i != start) {
char t = s[start];
s[start] = s[start - 1 ];
s[start - 1 ] = t;
// Swap until the characters
// are at same index
start--;
swap_count++;
}
}
}
// Print the minimum number of counts
System.out.print(swap_count);
}
// Driver Code
public static void main(String[] args) {
String S = "11112" ;
int K = 4 ;
minSwapsKthLargest(S, K);
}
} // This code is contributed by Rajput-Ji |
# Python Program to implement # the above approach def next_permutation(array):
i = len (array) - 1
while (i > 0 and ord (array[i - 1 ]) > = ord (array[i])):
i - = 1
if (i < = 0 ):
return False
j = len (array) - 1
while ( ord (array[j]) < = ord (array[i - 1 ])):
j - = 1
array[j],array[i - 1 ] = array[i - 1 ],array[j]
j = len (array) - 1
while (i < j):
array[i],array[j] = array[j],array[i]
i + = 1
j - = 1
return array
# Function to find the minimum number # of swaps required to make the Kth # smallest string greater than str def minSwapsKthLargest( Str , k):
# Store the copy of the string
res = list ( Str )
Str = list ( Str )
# Find the K-th permutation of
# the given numeric string
for i in range (k):
next_permutation( Str )
# Stores the count of swaps required
swap_count = 0
# Traverse the string and find the
# swaps required greedily
for i in range ( len (res)):
# If both characters do not match
if (res[i] ! = Str [i]):
start = i + 1
# Search from i+1 index
while (res[i] ! = Str [start]):
# Find the index to swap
start + = 1
while (i ! = start):
Str [start], Str [start - 1 ] = Str [start - 1 ], Str [start]
# Swap until the characters
# are at same index
start - = 1
swap_count + = 1
# Print the minimum number of counts
print (swap_count)
# Driver Code S = "11112"
K = 4
minSwapsKthLargest(S, K) # This code is contributed by shinjanpatra |
// C# program for the above approach using System;
class GFG {
static char [] next_permutation( char [] array)
{
int i = array.Length - 1;
while (i > 0 && array[i - 1] >= array[i]) {
i--;
}
int j = array.Length - 1;
while (array[j] <= array[i - 1]) {
j--;
}
char temp = array[i - 1];
array[i - 1] = array[j];
array[j] = temp;
j = array.Length - 1;
while (i < j) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
j--;
}
return array;
}
// Function to find the minimum number
// of swaps required to make the Kth
// smallest string greater than str
static void minSwapsKthLargest( string str, int k)
{
// Store the copy of the string
string res = str;
char [] str1 = str.ToCharArray();
// Find the K-th permutation of
// the given numeric string
for ( int i = 0; i < k; i++) {
next_permutation(str1);
}
// Stores the count of swaps required
int swap_count = 0;
// Traverse the string and find the
// swaps required greedily
for ( int i = 0; i < res.Length; i++) {
// If both characters do not match
if (res[i] != str1[i]) {
int start = i + 1;
// Search from i+1 index
while (res[i] != str1[start]) {
// Find the index to swap
start++;
}
while (i != start) {
char temp = str1[start];
str1[start] = str1[start - 1];
str1[start - 1] = temp;
// Swap until the characters
// are at same index
start--;
swap_count++;
}
}
}
// Print the minimum number of counts
Console.WriteLine(swap_count);
}
// Driver Code
public static void Main()
{
string S = "11112" ;
int K = 4;
minSwapsKthLargest(S, K);
}
} // This code is contributed by ukasp. |
<script> // JavaScript Program to implement
// the above approach
function next_permutation(array)
{
var i = array.length - 1;
while (i > 0 && array[i - 1].charCodeAt(0) >= array[i].charCodeAt(0)) {
i--;
}
if (i <= 0) {
return false ;
}
var j = array.length - 1;
while (array[j].charCodeAt(0) <= array[i - 1].charCodeAt(0)) {
j--;
}
var temp = array[i - 1];
array[i - 1] = array[j];
array[j] = temp;
j = array.length - 1;
while (i < j) {
temp = array[i];
array[i] = array[j];
array[j] = temp;
i++;
j--;
}
return array;
}
// Function to find the minimum number
// of swaps required to make the Kth
// smallest string greater than str
function minSwapsKthLargest(str, k)
{
// Store the copy of the string
let res = str.split( '' );
str = str.split( '' )
// Find the K-th permutation of
// the given numeric string
for (let i = 0; i < k; i++) {
next_permutation(
str);
}
// Stores the count of swaps required
let swap_count = 0;
// Traverse the string and find the
// swaps required greedily
for (let i = 0; i < res.length; i++) {
// If both characters do not match
if (res[i] != str[i]) {
let start = i + 1;
// Search from i+1 index
while (res[i] != str[start]) {
// Find the index to swap
start++;
}
while (i != start) {
let temp = str[start];
str[start] = str[start - 1]
str[start - 1] = temp;
// Swap until the characters
// are at same index
start--;
swap_count++;
}
}
}
// Print the minimum number of counts
document.write(swap_count);
}
// Driver Code
let S = "11112" ;
let K = 4;
minSwapsKthLargest(S, K);
// This code is contributed by Potta Lokesh
</script>
|
4
Time Complexity: O(N*(N + K))
Auxiliary Space: O(N)