# 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[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 ` `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[0]); ` ` `  `    ``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
Recommended Articles
Page :