Skip to content
Related Articles

Related Articles

Improve Article
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: 

0 <= K < N-1

, 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;
}

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 industry experts, please refer Geeks Classes Live 




My Personal Notes arrow_drop_up
Recommended Articles
Page :