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: 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++

filter_none

edit
close

play_arrow

link
brightness_4
code

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

chevron_right


Output:

1 2 3 4 5 6

Time Complexity: O(N2)

Don’t stop now and take your learning to the next level. Learn all the important concepts of Data Structures and Algorithms with the help of the most trusted course: DSA Self Paced. Become industry ready at a student-friendly price.




My Personal Notes arrow_drop_up

Recommended Posts:


Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.