# Lexicographically smallest array formed by at most one swap for every pair of adjacent indices

Given an array **A[] **of length **N**, the task is to find lexicographically smallest array by swapping adjacent elements for each index atmost once. Thus, for any index: , at most one swap between A[K] and A[K+1] is allowed.

**Example:**

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

Output:1 3 2 4

Explanation:Perform the following swaps:

Swap A[1] and A[2], now A[] = { 3, 1, 2, 4 }

Swap A[0] and A[1], now A[] = { 1, 3, 2, 4 }

No further swaps are possible as A[1] and A[2] have already been swapped.

Input:A[] = { 2, 1, 4, 3, 6, 5 }

Output:1 2 3 4 5 6

Explanation:Perform the following swaps:

Swap A[0] and A[1], now A[] = { 1, 2, 4, 3, 6, 5 }

Swap A[2] and A[3], now A[] = { 1, 2, 3, 4, 6, 5 }

Swap A[4] and A[5], now A[] = { 1, 2, 3, 4, 5, 6 }

**Approach:**

To solve the problem mentioned above we can apply **Greedy method**. We know that we can perform at most **N – 1 swaps** to make the given array as smallest as possible.

- Create a
**counter**variable and initialize with N-1 and a hash-map to store performed swaps. - Find the position of the minimum element from current index onward.
- Now perform swap backwards until we reach current element position.
- Also check if current swap is possible or not and decrement the counter also at each swap.
- Finally print the required array.

Below is the implementation of above approach:

## C++

`// C++ implementation to find the ` `// lexicographically smallest ` `// array by at most single swap ` `// for every pair of adjacent indices ` ` ` `#include <bits/stdc++.h> ` `using` `namespace` `std; ` ` ` `// Function to find the ` `// lexicographically smallest array ` `void` `findSmallestArray(` `int` `A[], ` `int` `n) ` `{ ` ` ` `// maximum swaps possible ` ` ` `int` `count = n - 1; ` ` ` ` ` `// hash to store swaps performed ` ` ` `map<pair<` `int` `, ` `int` `>, ` `int` `> mp; ` ` ` ` ` `for` `(` `int` `i = 0; i < n && count > 0; ++i) { ` ` ` ` ` `// let current element be ` ` ` `// the minimum possible ` ` ` `int` `mn = A[i], pos = i; ` ` ` ` ` `// Find actual position of ` ` ` `// the minimum element ` ` ` `for` `(` `int` `j = i + 1; j < n; ++j) { ` ` ` ` ` `// Update minimum element and ` ` ` `// its position ` ` ` `if` `(A[j] < mn) { ` ` ` `mn = A[j]; ` ` ` `pos = j; ` ` ` `} ` ` ` `} ` ` ` ` ` `// Perform swaps if possible ` ` ` `while` `(pos > i && count > 0 ` ` ` `&& !mp[{ pos - 1, pos }]) { ` ` ` ` ` `// Insert current swap in hash ` ` ` `mp[{ pos - 1, pos }] = 1; ` ` ` ` ` `swap(A[pos], A[pos - 1]); ` ` ` `--pos; ` ` ` `--count; ` ` ` `} ` ` ` `} ` ` ` ` ` `// print the required array ` ` ` `for` `(` `int` `i = 0; i < n; ++i) ` ` ` `cout << A[i] << ` `" "` `; ` `} ` ` ` `// Driver code ` `int` `main() ` `{ ` ` ` ` ` `int` `A[] = { 2, 1, 4, 3, 6, 5 }; ` ` ` `int` `n = ` `sizeof` `(A) / ` `sizeof` `(A[0]); ` ` ` ` ` `findSmallestArray(A, n); ` ` ` ` ` `return` `0; ` `} ` |

*chevron_right*

*filter_none*

**Output:**

1 2 3 4 5 6

**Time Complexity:*** O(N ^{2})*

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.

## Recommended Posts:

- Find the lexicographically smallest sequence which can be formed by re-arranging elements of second array
- Order of indices which is lexicographically smallest and sum of elements is <= X
- Lexicographically Smallest Permutation of length N such that for exactly K indices, a[i] > a[i] + 1
- Lexicographically smallest string which differs from given strings at exactly K indices
- Swap all occurrences of two characters to get lexicographically smallest string
- Lexicographically smallest string formed by removing at most one character
- Number of indices pair such that element pair sum from first Array is greater than second Array
- Lexicographically smallest string formed by appending a character from first K characters of a string | Set 2
- Lexicographically smallest string formed by appending a character from the first K characters of a given string
- Lexicographically smallest array after at-most K consecutive swaps
- Form smallest number using indices of numbers chosen from Array with sum less than S
- Print the lexicographically smallest array by swapping elements whose sum is odd
- Lexicographically smallest string obtained after concatenating array
- Greatest number that can be formed from a pair in a given Array
- Maximum sum of Array formed by replacing each element with sum of adjacent elements
- Maximize distance between smallest and largest Array elements by a single swap
- Smallest Pair Sum in an array
- Find the smallest contiguous sum pair in an Array
- Lexicographically largest string possible in one swap
- Maximum number formed from array with K number of adjacent swaps allowed

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.