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

• Last Updated : 17 Jul, 2020

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 and A, now A[] = { 3, 1, 2, 4 }
Swap A and A, now A[] = { 1, 3, 2, 4 }
No further swaps are possible as A and A 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 and A, now A[] = { 1, 2, 4, 3, 6, 5 }
Swap A and A, now A[] = { 1, 2, 3, 4, 6, 5 }
Swap A and A, 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 ``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, ``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);`` ` `    ``findSmallestArray(A, n);`` ` `    ``return` `0;``}`

## Python3

 `# Python3 implementation to find the``# lexicographically smallest array by``# at most single swap for every pair``# of adjacent indices`` ` `# Function to find the``# lexicographically smallest array``def` `findSmallestArray(A, n):``     ` `    ``# Maximum swaps possible``    ``count ``=` `n ``-` `1`` ` `    ``# Hash to store swaps performed``    ``mp ``=` `{''}`` ` `    ``for` `i ``in` `range``(``0``, n):``        ``if``(count <``=` `0``):``            ``break``;`` ` `        ``# Let current element be``        ``# the minimum possible``        ``mn ``=` `A[i]``        ``pos ``=` `i`` ` `        ``# Find actual position of``        ``# the minimum element``        ``for` `j ``in` `range``(i ``+` `1``, n):`` ` `            ``# Update minimum element ``            ``# and its position``            ``if` `(A[j] < mn):``                ``mn ``=` `A[j]``                ``pos ``=` `j`` ` `        ``# Perform swaps if possible``        ``while` `(pos > i ``and` `count > ``0` `and` `             ``((pos ``-` `1``, pos) ``not` `in` `mp)):`` ` `            ``# Insert current swap in hash``            ``mp.add((pos ``-` `1``, pos))`` ` `            ``A[pos], A[pos ``-` `1``] ``=` `A[pos ``-` `1``], A[pos]``            ``pos ``-``=` `1``            ``count ``-``=` `1`` ` `    ``# Print the required array``    ``for` `i ``in` `range``(``0``, n):``        ``print``(A[i], end ``=` `" "``)`` ` `# Driver code``A ``=` `[ ``2``, ``1``, ``4``, ``3``, ``6``, ``5` `]``n ``=` `len``(A)`` ` `findSmallestArray(A, n)`` ` `# This code is contributed by Sanjit_Prasad`

Output:

```1 2 3 4 5 6

```

Time Complexity: O(N2)

My Personal Notes arrow_drop_up