Find Maximum number possible by doing at-most K swaps

10 Jun, 2022
Given a positive integer, find the maximum integer possible by doing at-most K swap operations on its digits.Examples: 
Input: M = 254, K = 1
Output: 524
Swap 5 with 2 so number becomes 524

Input: M = 254, K = 2
Output: 542
Swap 5 with 2 so number becomes 524
Swap 4 with 2 so number becomes 542

Input: M = 68543, K = 1 
Output: 86543
Swap 8 with 6 so number becomes 86543

Input: M = 7599, K = 2
Output: 9975
Swap 9 with 5 so number becomes 7995
Swap 9 with 7 so number becomes 9975

Input: M = 76543, K = 1 
Output: 76543
Explanation: No swap is required.

Input: M = 129814999, K = 4
Output: 999984211
Swap 9 with 1 so number becomes 929814991
Swap 9 with 2 so number becomes 999814291
Swap 9 with 8 so number becomes 999914281
Swap 1 with 8 so number becomes 999984211
Naive Solution:Approach: The idea is to consider every digit and swap it with digits following it one at a time and see if it leads to the maximum number. The process is repeated K times. The code can be further optimized, if the current digit is swapped with a digit less than the following digit.Algorithm:  
Create a global variable which will store the maximum string or number.Define a recursive function that takes the string as number and value of kRun a nested loop, the outer loop from 0 to length of string -1 and inner loop from i+1 to end of the string.Swap the ith and jth character and check if the string is now maximum and update the maximum string.Call the function recursively with parameters: string and k-1.Now again swap back the ith and jth character.
Create a global variable which will store the maximum string or number.
Define a recursive function that takes the string as number and value of k
Run a nested loop, the outer loop from 0 to length of string -1 and inner loop from i+1 to end of the string.
Swap the ith and jth character and check if the string is now maximum and update the maximum string.
Call the function recursively with parameters: string and k-1.
Now again swap back the ith and jth character.
C++
Java
Python3
C#
Javascript
// C++ program to find maximum// integer possible by doing// at-most K swap operations// on its digits.#include <bits/stdc++.h>using namespace std; // Function to find maximum// integer possible by// doing at-most K swap// operations on its digitsvoid findMaximumNum(    string str, int k, string& max){    // Return if no swaps left    if (k == 0)        return;     int n = str.length();     // Consider every digit    for (int i = 0; i < n - 1; i++) {         // Compare it with all digits after it        for (int j = i + 1; j < n; j++) {            // if digit at position i            // is less than digit            // at position j, swap it            // and check for maximum            // number so far and recurse            // for remaining swaps            if (str[i] < str[j]) {                // swap str[i] with str[j]                swap(str[i], str[j]);                 // If current num is more                // than maximum so far                if (str.compare(max) > 0)                    max = str;                 // recurse of the other k - 1 swaps                findMaximumNum(str, k - 1, max);                 // Backtrack                swap(str[i], str[j]);            }        }    }} // Driver codeint main(){    string str = "129814999";     int k = 4;     string max = str;    findMaximumNum(str, k, max);     cout << max << endl;     return 0;}
// Java program to find maximum// integer possible by doing// at-most K swap operations// on its digits.import java.util.*;class GFG{   static String max;// Function to find maximum// integer possible by// doing at-most K swap// operations on its digitsstatic void findMaximumNum(char[] str,                           int k){  // Return if no swaps left  if (k == 0)    return;   int n = str.length;   // Consider every digit  for (int i = 0; i < n - 1; i++)  {    // Compare it with all digits    // after it    for (int j = i + 1; j < n; j++)    {      // if digit at position i      // is less than digit      // at position j, swap it      // and check for maximum      // number so far and recurse      // for remaining swaps      if (str[i] < str[j])      {        // swap str[i] with        // str[j]        char t = str[i];        str[i] = str[j];        str[j] = t;         // If current num is more        // than maximum so far        if (String.valueOf(str).compareTo(max) > 0)          max = String.valueOf(str);         // recurse of the other        // k - 1 swaps        findMaximumNum(str, k - 1);         // Backtrack        char c = str[i];        str[i] = str[j];        str[j] = c;      }    }  }} // Driver codepublic static void main(String[] args){  String str = "129814999";  int k = 4;  max = str;  findMaximumNum(str.toCharArray(), k);  System.out.print(max + "\n");}} // This code is contributed by 29AjayKumar
# Python3 program to find maximum# integer possible by doing at-most# K swap operations on its digits. # utility function to swap two# characters of a stringdef swap(string, i, j):     return (string[:i] + string[j] +            string[i + 1:j] +            string[i] + string[j + 1:]) # function to find maximum integer# possible by doing at-most K swap# operations on its digitsdef findMaximumNum(string, k, maxm):         # return if no swaps left    if k == 0:        return     n = len(string)     # consider every digit    for i in range(n - 1):         # and compare it with all digits after it        for j in range(i + 1, n):             # if digit at position i is less than            # digit at position j, swap it and            # check for maximum number so far and            # recurse for remaining swaps            if string[i] < string[j]:                 # swap string[i] with string[j]                string = swap(string, i, j)                 # If current num is more than                # maximum so far                if string > maxm[0]:                    maxm[0] = string                 # recurse of the other k - 1 swaps                findMaximumNum(string, k - 1, maxm)                 # backtrack                string = swap(string, i, j) # Driver Codeif __name__ == "__main__":    string = "129814999"    k = 4    maxm = [string]    findMaximumNum(string, k, maxm)    print(maxm[0]) # This code is contributed# by vibhu4agarwal
// C# program to find maximum// integer possible by doing// at-most K swap operations// on its digits.using System;class GFG{   static String max;// Function to find maximum// integer possible by// doing at-most K swap// operations on its digitsstatic void findMaximumNum(char[] str,                           int k){  // Return if no swaps left  if (k == 0)    return;   int n = str.Length;   // Consider every digit  for (int i = 0; i < n - 1; i++)  {    // Compare it with all digits    // after it    for (int j = i + 1; j < n; j++)    {      // if digit at position i      // is less than digit      // at position j, swap it      // and check for maximum      // number so far and recurse      // for remaining swaps      if (str[i] < str[j])      {        // swap str[i] with        // str[j]        char t = str[i];        str[i] = str[j];        str[j] = t;         // If current num is more        // than maximum so far        if (String.Join("", str).CompareTo(max) > 0)          max = String.Join("", str);         // recurse of the other        // k - 1 swaps        findMaximumNum(str, k - 1);         // Backtrack        char c = str[i];        str[i] = str[j];        str[j] = c;      }    }  }} // Driver codepublic static void Main(String[] args){  String str = "129814999";  int k = 4;  max = str;  findMaximumNum(str.ToCharArray(), k);  Console.Write(max + "\n");}} // This code is contributed by gauravrajput1
<script>// Javascript program to find maximum// integer possible by doing// at-most K swap operations// on its digits. let max; // Function to find maximum// integer possible by// doing at-most K swap// operations on its digitsfunction findMaximumNum(str,k){     // Return if no swaps left  if (k == 0)    return;    let n = str.length;    // Consider every digit  for (let i = 0; i < n - 1; i++)  {       // Compare it with all digits    // after it    for (let j = i + 1; j < n; j++)    {      // if digit at position i      // is less than digit      // at position j, swap it      // and check for maximum      // number so far and recurse      // for remaining swaps      if (str[i] < str[j])      {               // swap str[i] with        // str[j]        let t = str[i];        str[i] = str[j];        str[j] = t;          // If current num is more        // than maximum so far        if ((str).join("")>(max) )          max = (str).join("");          // recurse of the other        // k - 1 swaps        findMaximumNum(str, k - 1);          // Backtrack        let c = str[i];        str[i] = str[j];        str[j] = c;      }    }  }} // Driver codelet str = "129814999";let k = 4;max = str;findMaximumNum(str.split(""), k);document.write(max + "<br>"); // This code is contributed by unknown2108</script>
999984211
 
Complexity Analysis:  
Time Complexity: O((n^2)^k). For every recursive call n^2 recursive calls is generated until the value of k is 0. So total recursive calls are O((n^2)^k).
Space Complexity:O(n). This is the space required to store the output string.
Efficient Solution:Approach: The above approach traverses the whole string at each recursive call which is highly inefficient and unnecessary. Also, pre-computing the maximum digit after the current at a recursive call avoids unnecessary exchanges with each digit. It can be observed that to make the maximum string, the maximum digit is shifted to the front. So, instead of trying all pairs, try only those pairs where one of the elements is the maximum digit which is not yet swapped to the front. There is an improvement by 27580 microseconds for each test case.Algorithm:  
Create a global variable which will store the maximum string or number.Define a recursive function that takes the string as a number, the value of k, and the current index.Find the index of the maximum element in the range current index to end.if the index of the maximum element is not equal to the current index then decrement the value of k.Run a loop from the current index to the end of the arrayIf the ith digit is equal to the maximum elementSwap the ith and element at the current index and check if the string is now maximum and update the maximum string.Call the function recursively with parameters: string and k.Now again swap back the ith and element at the current index.
Create a global variable which will store the maximum string or number.
Define a recursive function that takes the string as a number, the value of k, and the current index.
Find the index of the maximum element in the range current index to end.
if the index of the maximum element is not equal to the current index then decrement the value of k.
Run a loop from the current index to the end of the array
If the ith digit is equal to the maximum element
Swap the ith and element at the current index and check if the string is now maximum and update the maximum string.
Call the function recursively with parameters: string and k.
Now again swap back the ith and element at the current index.
C++
Java
Python3
C#
// C++ program to find maximum// integer possible by doing// at-most K swap operations on// its digits.#include <bits/stdc++.h>using namespace std; // Function to find maximum// integer possible by// doing at-most K swap operations// on its digitsvoid findMaximumNum(    string str, int k,    string& max, int ctr){    // return if no swaps left    if (k == 0)        return;     int n = str.length();     // Consider every digit after    // the cur position    char maxm = str[ctr];    for (int j = ctr + 1; j < n; j++) {        // Find maximum digit greater        // than at ctr among rest        if (maxm < str[j])            maxm = str[j];    }     // If maxm is not equal to str[ctr],    // decrement k    if (maxm != str[ctr])        --k;     // search this maximum among the rest from behind    //first swap the last maximum digit if it occurs more then 1 time   //example str= 1293498 and k=1 then max string is 9293418 instead of 9213498    for (int j = n-1; j >=ctr; j--) {        // If digit equals maxm swap        // the digit with current        // digit and recurse for the rest        if (str[j] == maxm) {            // swap str[ctr] with str[j]            swap(str[ctr], str[j]);             // If current num is more than            // maximum so far            if (str.compare(max) > 0)                max = str;             // recurse other swaps after cur            findMaximumNum(str, k, max, ctr + 1);             // Backtrack            swap(str[ctr], str[j]);        }    }} // Driver codeint main(){    string str = "129814999";    int k = 4;     string max = str;    findMaximumNum(str, k, max, 0);     cout << max << endl;     return 0;}
// Java program to find maximum// integer possible by doing// at-most K swap operations on// its digits. import java.io.*;class Res {    static String max = "";} class Solution {    // Function to set highest possible digits at given    // index.    public static void findMaximumNum(char ar[], int k,                                      Res r)    {        if (k == 0)            return;        int n = ar.length;        for (int i = 0; i < n - 1; i++) {            for (int j = i + 1; j < n; j++) {                // if digit at position i is less than digit                // at position j, we swap them and check for                // maximum number so far.                if (ar[j] > ar[i]) {                    char temp = ar[i];                    ar[i] = ar[j];                    ar[j] = temp;                     String st = new String(ar);                     // if current number is more than                    // maximum so far                    if (r.max.compareTo(st) < 0) {                        r.max = st;                    }                    // calling recursive function to set the                    // next digit.                    findMaximumNum(ar, k - 1, r);                     // backtracking                    temp = ar[i];                    ar[i] = ar[j];                    ar[j] = temp;                }            }        }    }     // Function to find the largest number after k swaps.    public static void main(String[] args)    {        String str = "129814999";        int k = 4;        Res r = new Res();        r.max = str;        findMaximumNum(str.toCharArray(), k, r);        //Print the answer stored in res class        System.out.println(r.max);    }}
# Python3 program to find maximum# integer possible by doing at-most# K swap operations on its digits. # function to find maximum integer# possible by doing at-most K swap# operations on its digitsdef findMaximumNum(string, k, maxm, ctr):          # return if no swaps left    if k == 0:        return      n = len(string)    # Consider every digit after    # the cur position    mx = string[ctr]     for i in range(ctr+1,n):        # Find maximum digit greater        # than at ctr among rest        if int(string[i]) > int(mx):            mx=string[i]                 # If maxm is not equal to str[ctr],    # decrement k           if(mx!=string[ctr]):        k=k-1         # search this maximum among the rest from behind    # first swap the last maximum digit if it occurs more then 1 time    # example str= 1293498 and k=1 then max string is 9293418 instead of 9213498    for i in range(ctr,n):        # If digit equals maxm swap        # the digit with current        # digit and recurse for the rest        if(string[i]==mx):            # swap str[ctr] with str[j]            string[ctr], string[i] = string[i], string[ctr]            new_str = "".join(string)            # If current num is more than            # maximum so far            if int(new_str) > int(maxm[0]):                  maxm[0] = new_str              # recurse of the other k - 1 swaps            findMaximumNum(string, k , maxm, ctr+1)             # backtrack            string[ctr], string[i] = string[i], string[ctr]  # Driver Codeif __name__ == "__main__":    string = "129814999"    k = 4    maxm = [string]    string = [char for char in string]    findMaximumNum(string, k, maxm, 0)    print(maxm[0])  # This code is contributed Aarti_Rathi
// C# program to find maximum// integer possible by doing// at-most K swap operations on// its digits.using System; class Res {  public String max = "";} public class Solution {  // Function to set highest possible digits at given  // index.  static void findMaximumNum(char []ar, int k,                             Res r)  {    if (k == 0)      return;    int n = ar.Length;    for (int i = 0; i < n - 1; i++)    {      for (int j = i + 1; j < n; j++)      {        // if digit at position i is less than digit        // at position j, we swap them and check for        // maximum number so far.        if (ar[j] > ar[i]) {          char temp = ar[i];          ar[i] = ar[j];          ar[j] = temp;           String st = new String(ar);           // if current number is more than          // maximum so far          if (r.max.CompareTo(st) < 0) {            r.max = st;          }                     // calling recursive function to set the          // next digit.          findMaximumNum(ar, k - 1, r);           // backtracking          temp = ar[i];          ar[i] = ar[j];          ar[j] = temp;        }      }    }  }   // Function to find the largest number after k swaps.  public static void Main(String[] args)  {    String str = "129814999";    int k = 4;    Res r = new Res();    r.max = str;    findMaximumNum(str.ToCharArray(), k, r);     // Print the answer stored in res class    Console.WriteLine(r.max);  }} // This code is contributed by shikhasingrajput
999984211
 
Complexity Analysis:  
Time Complexity: O(n^k). For every recursive call n recursive calls is generated until the value of k is 0. So total recursive calls are O((n)^k).
Space Complexity: O(n). The space required to store the output string.
Exercise:  
Find minimum integer possible by doing at-least K swap operations on its digits.Find maximum/minimum integer possible by doing exactly K swap operations on its digits.
Find minimum integer possible by doing at-least K swap operations on its digits.
Find maximum/minimum integer possible by doing exactly K swap operations on its digits.
This article is contributed by Aarti Rathi and Aditya Goel.If you like GeeksforGeeks and would like to contribute, you can also write an article using write.geeksforgeeks.org or mail your article to review-team@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above. 
vibhu4agarwal
machinepainter
andrew1234
29AjayKumar
GauravRajput1
RohitOberoi
unknown2108
harsh_walia
shikhasingrajput
adi1212
Amazon
MakeMyTrip
Morgan Stanley
Walmart
Backtracking
Morgan Stanley
Amazon
MakeMyTrip
Walmart
Backtracking
Writing code in comment?
Please use ide.geeksforgeeks.org,
generate link and share the link here.