Open In App

# 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 ``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;``}`

## Java

 `// Java implementation to find the``// lexicographically smallest``// array by at most single swap``// for every pair of adjacent indices``import` `java.util.*;` `class` `GFG``{` `  ``// Function to find the``  ``// lexicographically smallest array``  ``static` `void` `findSmallestArray(``int``[] A, ``int` `n)``  ``{` `    ``// maximum swaps possible``    ``int` `count = n - ``1``;` `    ``// hash to store swaps performed``    ``HashMap mp``      ``= ``new` `HashMap();` `    ``for` `(``int` `i = ``0``; i < n && count > ``0``; ++i) {` `      ``// let current element be``      ``// the minimum possible``      ``int` `mn = A[i];``      ``int` `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.containsKey(``               ``String.valueOf(pos - ``1``) + ``"#"``               ``+ String.valueOf(pos))) {` `        ``// Insert current swap in hash``        ``mp.put(String.valueOf(pos - ``1``) + ``"#"``               ``+ String.valueOf(pos), ``1``);` `        ``var temp = A[pos];``        ``A[pos] = A[pos - ``1``];``        ``A[pos - ``1``] = temp;``        ``--pos;``        ``--count;``      ``}``    ``}` `    ``// print the required array``    ``for` `(``int` `i = ``0``; i < n; ++i)``      ``System.out.print(A[i] + ``" "``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `main(String[] args)``  ``{` `    ``int``[] A = { ``2``, ``1``, ``4``, ``3``, ``6``, ``5` `};``    ``int` `n = A.length;` `    ``findSmallestArray(A, n);``  ``}``}` `// This code is contributed by phasing17.`

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

## C#

 `// C# implementation to find the``// lexicographically smallest``// array by at most single swap``// for every pair of adjacent indices``using` `System;``using` `System.Collections.Generic;` `class` `GFG``{` `  ``// Function to find the``  ``// lexicographically smallest array``  ``static` `void` `findSmallestArray(``int``[] A, ``int` `n)``  ``{``    ` `    ``// maximum swaps possible``    ``int` `count = n - 1;` `    ``// hash to store swaps performed``    ``Dictionary<``string``, ``int``> mp``      ``= ``new` `Dictionary<``string``, ``int``>();` `    ``for` `(``int` `i = 0; i < n && count > 0; ++i) {` `      ``// let current element be``      ``// the minimum possible``      ``int` `mn = A[i];``      ``int` `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.ContainsKey(``               ``Convert.ToString(pos - 1) + ``"#"``               ``+ Convert.ToString(pos))) {` `        ``// Insert current swap in hash``        ``mp[Convert.ToString(pos - 1) + ``"#"``           ``+ Convert.ToString(pos)]``          ``= 1;` `        ``var` `temp = A[pos];``        ``A[pos] = A[pos - 1];``        ``A[pos - 1] = temp;``        ``--pos;``        ``--count;``      ``}``    ``}` `    ``// print the required array``    ``for` `(``int` `i = 0; i < n; ++i)``      ``Console.Write(A[i] + ``" "``);``  ``}` `  ``// Driver code``  ``public` `static` `void` `Main(``string``[] args)``  ``{` `    ``int``[] A = { 2, 1, 4, 3, 6, 5 };``    ``int` `n = A.Length;` `    ``findSmallestArray(A, n);``  ``}``}` `// This code is contributed by phasing17.`

## Javascript

 `// JS 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``function` `findSmallestArray(A, n)``{``    ``// maximum swaps possible``    ``let count = n - 1;` `    ``// hash to store swaps performed``    ``let mp = {};` `    ``for` `(``var` `i = 0; i < n && count > 0; ++i) {` `        ``// let current element be``        ``// the minimum possible``        ``var` `mn = A[i], pos = i;` `        ``// Find actual position of``        ``// the minimum element``        ``for` `(``var` `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.hasOwnProperty(pos - 1 + ``"#"` `+ pos)) {` `            ``// Insert current swap in hash``            ``mp[ pos - 1 + ``"#"` `+ pos] = 1;``            ` `            ``var` `temp = A[pos];``            ``A[pos] = A[pos - 1]``            ``A[pos - 1] = temp``            ``--pos;``            ``--count;``        ``}``    ``}` `    ``// print the required array``    ``console.log(A.join(``" "``))``    ` `}` `// Driver code``let A = [ 2, 1, 4, 3, 6, 5 ];``let n = A.length;` `findSmallestArray(A, n);` `// This code is contributed by phasing17`

Output:

`1 2 3 4 5 6`

Time Complexity: O(N2)