# Lexicographically largest permutation of array possible by reversing suffix subarrays

• Last Updated : 08 Jun, 2021

Given an array arr[] of size N, the task is to find the lexicographically largest permutation array by reversing any suffix subarrays from the array.

Examples:

Input: arr[] = {3, 5, 4, 1, 2}
Output: 3 5 4 2 1
Explanation: Reversing the suffix subarray {1, 2} generates the lexicographically largest permutation of the array elements possible.

Input: arr[] = {3, 5, 1, 2, 1}
Output: 3 5 1 2 1
Explanation:
The given array arr[] is already the lexicographically largest permutation of the array possible.

Naive Approach: The simplest approach is to reverse every possible suffix subarrays from the array and print the permutation of array elements that is lexicographically largest possible.
Time Complexity: O(N2)
Auxiliary Space: O(N)

Efficient Approach: To optimize the above approach, the idea is to use Greedy Approach. The given problem can be solved based on the following observations:

It can be observed that by choosing the suffix array as subarray in the range [i, N – 1] such that arr[i] < arr[N – 1] and reversing it, the obtained array will be lexicographically the largest array.

Follow the steps below to solve the problem:

• Initialize a variable, say flag as -1, that represents an index is found which has the value less than the last element.
• Traverse the given array arr[] and in each iteration, check if arr[i] < arr[N – 1] or not. Then, store the current index in the variable flag and break the loop.
• After completing the above steps, check if the value of flag is -1 or not. If found to be true, then reverse the suffix subarray i.e., subarray in the range [flag, N – 1].
• After completing the above steps, print the array arr[] as the result.

Below is the implementation of the above approach:

## C++

 `// CPP program for the above approach``#include ``using` `namespace` `std;` `// Function that`` ``void` `LLA(vector<``int``> A)``{` `    ``// Stores the index that have``    ``// element less than the``    ``// element at last index``    ``int` `flg = -1;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < A.size(); i++)``    ``{` `        ``// Checks if value at the``        ``// current index is less``        ``// than value at last index``        ``if` `(A[i] < A[A.size() - 1])``        ``{` `            ``// Assign the current``            ``// index value to index``            ``flg = i;``            ``break``;``        ``}``    ``}` `    ``// Check if index is not -1 then``    ``// reverse the suffix from the``    ``// index stored at flg``    ``if` `(flg != -1)``    ``{` `        ``// Reversal of suffix``        ``for` `(``int` `i = flg, j = A.size() - 1;``             ``i <= j; i++, j--)``        ``{` `            ``// Swapping Step``            ``int` `temp = A[i];``            ``A[i] = A[j];``            ``A[j] = temp;``        ``}``    ``}` `    ``// Print the final Array``    ``for` `(``int` `i = 0; i < A.size(); i++)``         ``cout< arr= { 3, 5, 4, 1, 2 };` `  ``// Function Call``  ``LLA(arr);``}` `// This code is contributed by mohit kumar 29.`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `class` `GFG {` `    ``// Function that``    ``public` `static` `void` `LLA(``int` `A[])``    ``{` `        ``// Stores the index that have``        ``// element less than the``        ``// element at last index``        ``int` `flg = -``1``;` `        ``// Traverse the array``        ``for` `(``int` `i = ``0``; i < A.length; i++) {` `            ``// Checks if value at the``            ``// current index is less``            ``// than value at last index``            ``if` `(A[i] < A[A.length - ``1``]) {` `                ``// Assign the current``                ``// index value to index``                ``flg = i;``                ``break``;``            ``}``        ``}` `        ``// Check if index is not -1 then``        ``// reverse the suffix from the``        ``// index stored at flg``        ``if` `(flg != -``1``) {` `            ``// Reversal of suffix``            ``for` `(``int` `i = flg, j = A.length - ``1``;``                 ``i <= j; i++, j--) {` `                ``// Swapping Step``                ``int` `temp = A[i];``                ``A[i] = A[j];``                ``A[j] = temp;``            ``}``        ``}` `        ``// Print the final Array``        ``for` `(``int` `i = ``0``; i < A.length; i++)``            ``System.out.print(A[i] + ``" "``);``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `arr[] = { ``3``, ``5``, ``4``, ``1``, ``2` `};` `        ``// Function Call``        ``LLA(arr);``    ``}``}`

## Python3

 `# Python program for the above approach` `# Function that``def` `LLA(A):``  ` `    ``# Stores the index that have``    ``# element less than the``    ``# element at last index``    ``flg ``=` `-``1``;` `    ``# Traverse the array``    ``for` `i ``in` `range``(``len``(A)):` `        ``# Checks if value at the``        ``# current index is less``        ``# than value at last index``        ``if` `(A[i] < A[``len``(A) ``-` `1``]):``          ` `            ``# Assign the current``            ``# index value to index``            ``flg ``=` `i;``            ``break``;` `    ``# Check if index is not -1 then``    ``# reverse the suffix from the``    ``# index stored at flg``    ``if` `(flg !``=` `-``1``):` `        ``# Reversal of suffix``        ``j ``=` `len``(A) ``-` `1``;``        ``for` `i ``in` `range``(flg, j ``+` `1``):` `            ``# Swapping Step``            ``temp ``=` `A[i];``            ``A[i] ``=` `A[j];``            ``A[j] ``=` `temp;``            ``j ``-``=` `1``;` `    ``# Print the final Array``    ``for` `i ``in` `range``(``len``(A)):``        ``print``(A[i], end``=``" "``);` `# Driver Code``if` `__name__ ``=``=` `'__main__'``:``    ``arr ``=` `[``3``, ``5``, ``4``, ``1``, ``2``];` `    ``# Function Call``    ``LLA(arr);` `    ``# This code is contributed by 29AjayKumar`

## C#

 `// C# program for the above approach``using` `System;` `public` `class` `GFG``{` `  ``// Function that``  ``public` `static` `void` `LLA(``int` `[]A)``  ``{` `    ``// Stores the index that have``    ``// element less than the``    ``// element at last index``    ``int` `flg = -1;` `    ``// Traverse the array``    ``for` `(``int` `i = 0; i < A.Length; i++)``    ``{` `      ``// Checks if value at the``      ``// current index is less``      ``// than value at last index``      ``if` `(A[i] < A[A.Length - 1])``      ``{` `        ``// Assign the current``        ``// index value to index``        ``flg = i;``        ``break``;``      ``}``    ``}` `    ``// Check if index is not -1 then``    ``// reverse the suffix from the``    ``// index stored at flg``    ``if` `(flg != -1)``    ``{` `      ``// Reversal of suffix``      ``for` `(``int` `i = flg, j = A.Length - 1;``           ``i <= j; i++, j--)``      ``{` `        ``// Swapping Step``        ``int` `temp = A[i];``        ``A[i] = A[j];``        ``A[j] = temp;``      ``}``    ``}` `    ``// Print the readonly Array``    ``for` `(``int` `i = 0; i < A.Length; i++)``      ``Console.Write(A[i] + ``" "``);``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main(String[] args)``  ``{``    ``int` `[]arr = { 3, 5, 4, 1, 2 };` `    ``// Function Call``    ``LLA(arr);``  ``}``}` `// This code is contributed by 29AjayKumar`

## Javascript

 ``

Output:

`3 5 4 2 1`

Time Complexity: O(N)
Auxiliary Space: O(1)

My Personal Notes arrow_drop_up