Related Articles

# 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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with experts, please refer DSA Live Classes for Working Professionals and Competitive Programming Live for Students.

My Personal Notes arrow_drop_up