# Minimum adjacent swaps required to get Kth smallest number greater than given number

• Difficulty Level : Easy
• Last Updated : 19 May, 2022

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++

 `// C++ program for the above approach` `#include ` `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 = "``<

## Java

 `// 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 `

## Python3

 `# 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#

 `// 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.`

## Javascript

 ``

Output:

`4`

Time Complexity: O(N*(N + K))
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :