GeeksforGeeks App
Open App
Browser
Continue

# Lexicographically smallest Permutation of Array by reversing at most one Subarray

Given an array arr[] of size N which is a permutation from 1 to N, the task is to find the lexicographically smallest permutation that can be formed by reversing at most one subarray.

Examples:

Input : arr[] = {1, 3, 4, 2, 5}
Output : 1 2 4 3 5
Explanation: The subarray from index 1 to index 3 can be reversed to get the lexicographically smallest permutation.

Input : arr[] = {4, 3, 1, 2}
Output: 1 3 4 2

Approach: The idea to solve the problem is based on the traversal of the array

• In the given problem the lexicographically smallest permutation can be obtained by placing the least number at its correct place by one reversal by traversing from left and checking (i+1) is equal to arr[i]
• If it is not equal find the index of that i+1 in the array and reverse the subarray from ith index to the position (i+1).

Below is the implementation of the above approach.

## C++

 `// C++ code for the above approach``#include ``using` `namespace` `std;`` ` `// Function to find the``// Lexicographically smallest``// Permutation by one subarray reversal``void` `lexsmallest(vector<``int``>& arr, ``int` `n)``{`` ` `    ``// Initialize the variables``    ``// To store the first and last``    ``// Position of the subarray``    ``int` `first = -1, flag = 0, find = -1, last = -1;`` ` `    ``// Traverse the array``    ``// And check if arr[i]!=i+1``    ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(arr[i] != i + 1) {``            ``flag = 1;`` ` `            ``// Mark the first position``            ``// Of the Subarray to be reversed``            ``first = i;``            ``find = i + 1;``            ``break``;``        ``}``    ``}`` ` `    ``// If flag == 0, it is the``    ``// Smallest permutation,``    ``// So print the array``    ``if` `(flag == 0) {``        ``for` `(``int` `i = 0; i < n; i++) {``            ``cout << arr[i] << ``" "``;``        ``}``    ``}`` ` `    ``// Check where the minimum element is present``    ``else` `{``        ``for` `(``int` `i = 0; i < n; i++) {`` ` `            ``// It is the last position``            ``// Of the subarray to be``            ``// Reversed``            ``if` `(arr[i] == find) {``                ``last = i;``                ``break``;``            ``}``        ``}`` ` `        ``// Reverse the subarray``        ``// And print the array``        ``reverse(arr.begin() + first,``                ``arr.begin() + last + 1);``        ``for` `(``int` `i = 0; i < n; i++) {``            ``cout << arr[i] << ``" "``;``        ``}``    ``}``}`` ` `// Driver Code``int` `main()``{``    ``// Initialize the array arr[]``    ``vector<``int``> arr = { 1, 3, 4, 2, 5 };``    ``int` `N = arr.size();`` ` `    ``// Function call``    ``lexsmallest(arr, N);``    ``return` `0;``}`

## Java

 `// Java code for the above approach``import` `java.util.*;`` ` `class` `GFG{`` ` `// Function to find the``// Lexicographically smallest``// Permutation by one subarray reversal``static` `void` `lexsmallest(``int` `[]arr, ``int` `n)``{`` ` `    ``// Initialize the variables``    ``// To store the first and last``    ``// Position of the subarray``    ``int` `first = -``1``, flag = ``0``, find = -``1``, last = -``1``;`` ` `    ``// Traverse the array``    ``// And check if arr[i]!=i+1``    ``for` `(``int` `i = ``0``; i < n; i++) {``        ``if` `(arr[i] != i + ``1``) {``            ``flag = ``1``;`` ` `            ``// Mark the first position``            ``// Of the Subarray to be reversed``            ``first = i;``            ``find = i + ``1``;``            ``break``;``        ``}``    ``}`` ` `    ``// If flag == 0, it is the``    ``// Smallest permutation,``    ``// So print the array``    ``if` `(flag == ``0``) {``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``System.out.print(arr[i]+ ``" "``);``        ``}``    ``}`` ` `    ``// Check where the minimum element is present``    ``else` `{``        ``for` `(``int` `i = ``0``; i < n; i++) {`` ` `            ``// It is the last position``            ``// Of the subarray to be``            ``// Reversed``            ``if` `(arr[i] == find) {``                ``last = i;``                ``break``;``            ``}``        ``}`` ` `        ``// Reverse the subarray``        ``// And print the array``        ``arr = reverse(arr,first,last);``        ``for` `(``int` `i = ``0``; i < n; i++) {``            ``System.out.print(arr[i]+ ``" "``);``        ``}``    ``}``}``static` `int``[] reverse(``int` `str[], ``int` `start, ``int` `end) {`` ` `    ``// Temporary variable to store character ``    ``int` `temp;``    ``while` `(start <= end) {``        ``// Swapping the first and last character ``        ``temp = str[start];``        ``str[start] = str[end];``        ``str[end] = temp;``        ``start++;``        ``end--;``    ``}``    ``return` `str;``}``   ` `// Driver Code``public` `static` `void` `main(String[] args)``{``   ` `    ``// Initialize the array arr[]``    ``int` `[]arr = { ``1``, ``3``, ``4``, ``2``, ``5` `};``    ``int` `N = arr.length;`` ` `    ``// Function call``    ``lexsmallest(arr, N);``}``}`` ` `// This code contributed by shikhasingrajput`

## Python3

 `# Python code for the above approach`` ` `# Function to find the``# Lexicographically smallest``# Permutation by one subarray reversal``def` `lexsmallest(arr, n):`` ` `    ``# Initialize the variables``    ``# To store the first and last``    ``# Position of the subarray``    ``first ``=` `-``1``    ``flag ``=` `0``    ``find ``=` `-``1``    ``last ``=` `-``1`` ` `    ``# Traverse the array``    ``# And check if arr[i]!=i+1``    ``for` `i ``in` `range``(``0``, n):``        ``if` `(arr[i] !``=` `i ``+` `1``):``            ``flag ``=` `1`` ` `            ``# Mark the first position``            ``# Of the Subarray to be reversed``            ``first ``=` `i``            ``find ``=` `i ``+` `1``            ``break`` ` `    ``# If flag == 0, it is the``    ``# Smallest permutation,``    ``# So print the array``    ``if` `(flag ``=``=` `0``):``        ``for` `i ``in` `range``(``0``, n):``            ``print``(arr[i], end``=``" "``)`` ` `    ``# Check where the minimum element is present``    ``else``:``        ``for` `i ``in` `range``(``0``, n):`` ` `            ``# It is the last position``            ``# Of the subarray to be``            ``# Reversed``            ``if` `(arr[i] ``=``=` `find):``                ``last ``=` `i``                ``break`` ` `        ``# Reverse the subarray``        ``# And print the array``        ``arr[first: last ``+` `1``] ``=` `arr[first: last ``+` `1``][::``-``1``]`` ` `        ``print``(``*``arr)`` ` `# Driver Code`` ` `# Initialize the array arr[]``arr ``=` `[``1``, ``3``, ``4``, ``2``, ``5``]``N ``=` `len``(arr)`` ` `# Function call``lexsmallest(arr, N)`` ` `# This code is contributed by Samim Hossain Mondal.`

## C#

 `// C# code for the above approach``using` `System;`` ` `class` `GFG{`` ` `  ``// Function to find the``  ``// Lexicographically smallest``  ``// Permutation by one subarray reversal``  ``static` `void` `lexsmallest(``int` `[]arr, ``int` `n)``  ``{`` ` `    ``// Initialize the variables``    ``// To store the first and last``    ``// Position of the subarray``    ``int` `first = -1, flag = 0, find = -1, last = -1;`` ` `    ``// Traverse the array``    ``// And check if arr[i]!=i+1``    ``for` `(``int` `i = 0; i < n; i++) {``      ``if` `(arr[i] != i + 1) {``        ``flag = 1;`` ` `        ``// Mark the first position``        ``// Of the Subarray to be reversed``        ``first = i;``        ``find = i + 1;``        ``break``;``      ``}``    ``}`` ` `    ``// If flag == 0, it is the``    ``// Smallest permutation,``    ``// So print the array``    ``if` `(flag == 0) {``      ``for` `(``int` `i = 0; i < n; i++) {``        ``Console.Write(arr[i]+ ``" "``);``      ``}``    ``}`` ` `    ``// Check where the minimum element is present``    ``else` `{``      ``for` `(``int` `i = 0; i < n; i++) {`` ` `        ``// It is the last position``        ``// Of the subarray to be``        ``// Reversed``        ``if` `(arr[i] == find) {``          ``last = i;``          ``break``;``        ``}``      ``}`` ` `      ``// Reverse the subarray``      ``// And print the array``      ``arr = reverse(arr,first,last);``      ``for` `(``int` `i = 0; i < n; i++) {``        ``Console.Write(arr[i]+ ``" "``);``      ``}``    ``}``  ``}``  ``static` `int``[] reverse(``int``[] str, ``int` `start, ``int` `end) {`` ` `    ``// Temporary variable to store character ``    ``int` `temp;``    ``while` `(start <= end)``    ``{``       ` `      ``// Swapping the first and last character ``      ``temp = str[start];``      ``str[start] = str[end];``      ``str[end] = temp;``      ``start++;``      ``end--;``    ``}``    ``return` `str;``  ``}`` ` `  ``// Driver Code``  ``static` `public` `void` `Main (){`` ` `    ``// Initialize the array arr[]``    ``int` `[] arr = { 1, 3, 4, 2, 5 };``    ``int` `N = arr.Length;`` ` `    ``// Function call``    ``lexsmallest(arr, N);``  ``}``}`` ` `// This code is contributed by hrithikgarg03188.`

## Javascript

 ``

Output

`1 2 4 3 5 `

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

Related Topic: Subarrays, Subsequences, and Subsets in Array

My Personal Notes arrow_drop_up