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++ code for the above approach
#include <bits/stdc++.h>
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 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
# 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# 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.
<script>
// JavaScript code for the above approach
// Function to find the
// Lexicographically smallest
// Permutation by one subarray reversal
const lexsmallest = (arr, n) => {
// Initialize the variables
// To store the first and last
// Position of the subarray
let first = -1, flag = 0, find = -1, last = -1;
// Traverse the array
// And check if arr[i]!=i+1
for (let 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 (let i = 0; i < n; i++) {
document.write(`${arr[i]} `);
}
}
// Check where the minimum element is present
else {
for (let 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.splice(first, last, ...arr.slice(first, last + 1).reverse());
for (let i = 0; i < n; i++) {
document.write(`${arr[i]} `);
}
}
}
// Driver Code
// Initialize the array arr[]
let arr = [1, 3, 4, 2, 5];
let N = arr.length;
// Function call
lexsmallest(arr, N);
// This code is contributed by rakeshsahni
</script>
Output
1 2 4 3 5
Time Complexity: O(N)
Auxiliary Space: O(1)
Related Topic: Subarrays, Subsequences, and Subsets in Array