# Largest lexicographic array with at-most K consecutive swaps

Given an array arr[], find the lexicographically largest array that can be obtained by performing at-most k consecutive swaps.

Examples :

```Input : arr[] = {3, 5, 4, 1, 2}
k = 3
Output : 5, 4, 3, 2, 1
Explanation : Array given : 3 5 4 1 2
After swap 1 : 5 3 4 1 2
After swap 2 : 5 4 3 1 2
After swap 3 : 5 4 3 2 1

Input : arr[] = {3, 5, 1, 2, 1}
k = 3
Output : 5, 3, 2, 1, 1
```

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

Brute Force Approach : Generate all permutation of the array and then pick the one which satisfies the condition of at most K swaps. The time complexity of this approach is O(n!).

Optimized Approach : In this greedy approach, first find the largest element present in the array which is greater than(if the 1st position element is not the greatest) the 1st position and which can be placed at the 1st position with at-most K swaps. After finding that element, note its index. Then, swap elements of the array and update K value. Apply this procedure for other positions till k is non-zero or array becomes lexicographically largest.

Below is the implementation of above approach :

## C++

 `// C++ program to find lexicographically ` `// maximum value after k swaps. ` `#include ` `using` `namespace` `std; ` ` `  `// Function which modifies the array ` `void` `KSwapMaximum(``int` `arr[], ``int` `n, ``int` `k) ` `{ ` `    ``for` `(``int` `i = 0; i < n - 1 && k > 0; ++i) { ` ` `  `        ``// Here, indexPositionition is set where we ` `        ``// want to put the current largest integer ` `        ``int` `indexPosition = i; ` `        ``for` `(``int` `j = i + 1; j < n; ++j) { ` ` `  `            ``// If we exceed the Max swaps ` `            ``// then break the loop ` `            ``if` `(k <= j - i) ` `                ``break``; ` ` `  `            ``// Find the maximum value from i+1 to ` `            ``// max k or n which will replace ` `            ``// arr[indexPosition] ` `            ``if` `(arr[j] > arr[indexPosition]) ` `                ``indexPosition = j; ` `        ``} ` ` `  `        ``// Swap the elements from Maximum indexPosition ` `        ``// we found till now to the ith index ` `        ``for` `(``int` `j = indexPosition; j > i; --j) ` `            ``swap(arr[j], arr[j - 1]); ` ` `  `        ``// Updates k after swapping indexPosition-i ` `        ``// elements ` `        ``k -= indexPosition - i; ` `    ``} ` `} ` ` `  `// Driver code ` `int` `main() ` `{ ` `    ``int` `arr[] = { 3, 5, 4, 1, 2 }; ` `    ``int` `n = ``sizeof``(arr) / ``sizeof``(arr); ` `    ``int` `k = 3; ` ` `  `    ``KSwapMaximum(arr, n, k); ` ` `  `    ``// Print the final Array ` `    ``for` `(``int` `i = 0; i < n; ++i) ` `        ``cout << arr[i] << ``" "``; ` `} `

## Java

 `// Java program to find  ` `// lexicographically  ` `// maximum value after ` `// k swaps. ` `import` `java.io.*; ` ` `  `class` `GFG ` `{  ` `    ``static` `void` `SwapInts(``int` `array[],  ` `                         ``int` `position1,  ` `                         ``int` `position2) ` `    ``{ ` `        ``// Swaps elements ` `        ``// in an array. ` `         `  `        ``// Copy the first  ` `        ``// position's element ` `        ``int` `temp = array[position1];  ` `         `  `        ``// Assign to the  ` `        ``// second element ` `        ``array[position1] = array[position2]; ` `         `  `        ``// Assign to the  ` `        ``// first element ` `        ``array[position2] = temp;  ` `    ``} ` `     `  `    ``// Function which  ` `    ``// modifies the array ` `    ``static` `void` `KSwapMaximum(``int` `[]arr,  ` `                             ``int` `n, ``int` `k) ` `    ``{ ` `        ``for` `(``int` `i = ``0``;  ` `                 ``i < n - ``1` `&& k > ``0``; ++i)  ` `        ``{ ` `     `  `            ``// Here, indexPositionition  ` `            ``// is set where we want to ` `            ``// put the current largest  ` `            ``// integer ` `            ``int` `indexPosition = i; ` `            ``for` `(``int` `j = i + ``1``; j < n; ++j)  ` `            ``{ ` `     `  `                ``// If we exceed the  ` `                ``// Max swaps then  ` `                ``// break the loop ` `                ``if` `(k <= j - i) ` `                    ``break``; ` `     `  `                ``// Find the maximum value  ` `                ``// from i+1 to max k or n  ` `                ``// which will replace  ` `                ``// arr[indexPosition] ` `                ``if` `(arr[j] > arr[indexPosition]) ` `                    ``indexPosition = j; ` `            ``} ` `     `  `            ``// Swap the elements from  ` `            ``// Maximum indexPosition ` `            ``// we found till now to  ` `            ``// the ith index ` `            ``for` `(``int` `j = indexPosition; j > i; --j) ` `                ``SwapInts(arr, j, j - ``1``); ` `     `  `            ``// Updates k after swapping ` `            ``// indexPosition-i elements ` `            ``k -= indexPosition - i; ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``public` `static` `void` `main(String args[]) ` `    ``{ ` `        ``int` `[]arr = { ``3``, ``5``, ``4``, ``1``, ``2` `}; ` `        ``int` `n = arr.length; ` `        ``int` `k = ``3``; ` `     `  `        ``KSwapMaximum(arr, n, k); ` `     `  `        ``// Print the final Array ` `        ``for` `(``int` `i = ``0``; i < n; ++i) ` `            ``System.out.print(arr[i] + ``" "``); ` `    ``} ` `} ` ` `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) `

## Python3

 `# Python program to find  ` `# lexicographically  ` `# maximum value after ` `# k swaps. ` ` `  `arr ``=` `[``3``, ``5``, ``4``, ``1``, ``2``] ` ` `  `# Function which ` `# modifies the array ` `def` `KSwapMaximum(n, k) : ` `     `  `    ``global` `arr ` `    ``for` `i ``in` `range``(``0``, n ``-` `1``) :  ` `        ``if` `(k > ``0``) :  ` `         `  `            ``# Here, indexPositionition ` `            ``# is set where we want to ` `            ``# put the current largest  ` `            ``# integer ` `            ``indexPosition ``=` `i ` `            ``for` `j ``in` `range``(i ``+` `1``, n) :          ` `     `  `                ``# If we exceed the Max swaps ` `                ``# then break the loop ` `                ``if` `(k <``=` `j ``-` `i) : ` `                    ``break` `     `  `                ``# Find the maximum value  ` `                ``# from i+1 to max k or n ` `                ``# which will replace ` `                ``# arr[indexPosition] ` `                ``if` `(arr[j] > arr[indexPosition]) : ` `                    ``indexPosition ``=` `j ` `             `  `            ``# Swap the elements from  ` `            ``# Maximum indexPosition ` `            ``# we found till now to  ` `            ``# the ith index ` `            ``for` `j ``in` `range``(indexPosition, i, ``-``1``) : ` `                ``t ``=` `arr[j] ` `                ``arr[j] ``=` `arr[j ``-` `1``] ` `                ``arr[j ``-` `1``] ``=` `t ` `     `  `            ``# Updates k after swapping  ` `            ``# indexPosition-i elements ` `            ``k ``=` `k ``-` `indexPosition ``-` `i ` ` `  `# Driver code ` `n ``=` `len``(arr) ` `k ``=` `3` ` `  `KSwapMaximum(n, k) ` ` `  `# Print the final Array ` `for` `i ``in` `range``(``0``, n) : ` `    ``print` `(``"{} "` `.  ` `            ``format``(arr[i]),  ` `                 ``end ``=` `"") ` `     `  `# This code is contributed by  ` `# Manish Shaw(manishshaw1) `

## C#

 `// C# program to find  ` `// lexicographically  ` `// maximum value after ` `// k swaps. ` `using` `System; ` ` `  `class` `GFG ` `{  ` `    ``static` `void` `SwapInts(``int``[] array,  ` `                         ``int` `position1,  ` `                         ``int` `position2) ` `    ``{ ` `        ``// Swaps elements in an array. ` `         `  `        ``// Copy the first position's element ` `        ``int` `temp = array[position1];  ` `         `  `        ``// Assign to the second element ` `        ``array[position1] = array[position2]; ` `         `  `        ``// Assign to the first element ` `        ``array[position2] = temp;  ` `    ``} ` `     `  `    ``// Function which  ` `    ``// modifies the array ` `    ``static` `void` `KSwapMaximum(``int` `[]arr,  ` `                             ``int` `n, ``int` `k) ` `    ``{ ` `        ``for` `(``int` `i = 0;  ` `                 ``i < n - 1 && k > 0; ++i)  ` `        ``{ ` `     `  `            ``// Here, indexPositionition  ` `            ``// is set where we want to ` `            ``// put the current largest  ` `            ``// integer ` `            ``int` `indexPosition = i; ` `            ``for` `(``int` `j = i + 1; j < n; ++j)  ` `            ``{ ` `     `  `                ``// If we exceed the  ` `                ``// Max swaps then  ` `                ``// break the loop ` `                ``if` `(k <= j - i) ` `                    ``break``; ` `     `  `                ``// Find the maximum value  ` `                ``// from i+1 to max k or n  ` `                ``// which will replace  ` `                ``// arr[indexPosition] ` `                ``if` `(arr[j] > arr[indexPosition]) ` `                    ``indexPosition = j; ` `            ``} ` `     `  `            ``// Swap the elements from  ` `            ``// Maximum indexPosition ` `            ``// we found till now to  ` `            ``// the ith index ` `            ``for` `(``int` `j = indexPosition; j > i; --j) ` `                ``SwapInts(arr, j, j - 1); ` `     `  `            ``// Updates k after swapping ` `            ``// indexPosition-i elements ` `            ``k -= indexPosition - i; ` `        ``} ` `    ``} ` `     `  `    ``// Driver code ` `    ``static` `void` `Main() ` `    ``{ ` `        ``int` `[]arr = ``new` `int``[]{ 3, 5, 4, 1, 2 }; ` `        ``int` `n = arr.Length; ` `        ``int` `k = 3; ` `     `  `        ``KSwapMaximum(arr, n, k); ` `     `  `        ``// Print the final Array ` `        ``for` `(``int` `i = 0; i < n; ++i) ` `            ``Console.Write(arr[i] + ``" "``); ` `    ``} ` `} ` `// This code is contributed by  ` `// Manish Shaw(manishshaw1) `

## PHP

 ` 0; ``\$i``++)  ` `    ``{ ` `         `  `        ``// Here, indexPositionition ` `        ``// is set where we want to ` `        ``// put the current largest  ` `        ``// integer ` `        ``\$indexPosition` `= ``\$i``; ` `        ``for` `(``\$j` `= ``\$i` `+ 1;  ` `             ``\$j` `< ``\$n``; ``\$j``++) ` `        ``{ ` ` `  `            ``// If we exceed the Max swaps ` `            ``// then break the loop ` `            ``if` `(``\$k` `<= ``\$j` `- ``\$i``) ` `                ``break``; ` ` `  `            ``// Find the maximum value  ` `            ``// from i+1 to max k or n ` `            ``// which will replace ` `            ``// arr[indexPosition] ` `            ``if` `(``\$arr``[``\$j``] > ``\$arr``[``\$indexPosition``]) ` `                ``\$indexPosition` `= ``\$j``; ` `        ``}  ` `         `  `        ``// Swap the elements from  ` `        ``// Maximum indexPosition ` `        ``// we found till now to  ` `        ``// the ith index ` `        ``for` `(``\$j` `= ``\$indexPosition``;  ` `             ``\$j` `> ``\$i``; ``\$j``--) ` `            ``swap(``\$arr``[``\$j``], ``\$arr``[``\$j` `- 1]); ` ` `  `        ``// Updates k after swapping  ` `        ``// indexPosition-i elements ` `        ``\$k` `-= ``\$indexPosition` `- ``\$i``; ` `    ``} ` `} ` ` `  `// Driver code ` `\$arr` `= ``array``( 3, 5, 4, 1, 2 ); ` `\$n` `= ``count``(``\$arr``); ` `\$k` `= 3; ` ` `  `KSwapMaximum(``\$arr``, ``\$n``, ``\$k``); ` ` `  `// Print the final Array ` `for` `(``\$i` `= 0; ``\$i` `< ``\$n``; ``\$i``++) ` `    ``echo` `(``\$arr``[``\$i``].``" "``); ` `     `  `// This code is contributed by  ` `// Manish Shaw(manishshaw1) ` `?> `

Output:

```5 4 3 1 2
```

Time Complexity: O(N*N)
Auxilliary Space: O(1)

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Improved By : manishshaw1

Article Tags :
Practice Tags :

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.