Print k different sorted permutations of a given array

Given an array arr[] containing N integers, the task is to print k different permutations of indices such that the values at those indices form a non-decreasing sequence. Print -1 if it is not possible.

Examples: 

Input: arr[] = {1, 3, 3, 1}, k = 3 
Output: 
0 3 1 2 
3 0 1 2 
3 0 2 1 
For every permutation, the values at the indices form the following sequence {1, 1, 3, 3}
Input: arr[] = {1, 2, 3, 4}, k = 3 
Output: -1 
There is only 1 non decreasing sequence possible {1, 2, 3, 4}. 

Approach: Sort the given array and keep track of the original indices of each element. That gives one required permutation. Now if any 2 continuous elements are equal then they can be swapped to get another permutation. Similarly, the third permutation can be generated.

Below is the implementation of the above approach: 



C++

filter_none

edit
close

play_arrow

link
brightness_4
code

// C++ implementation of the approach
#include <bits/stdc++.h>
using namespace std;
 
int next_pos = 1;
// Utility function to print the original indices
// of the elements of the array
void printIndices(int n, pair<int, int> a[])
{
    for (int i = 0; i < n; i++)
        cout << a[i].second << " ";
    cout << endl;
}
 
// Function to print the required permutations
void printPermutations(int n, int a[], int k)
{
 
    // To keep track of original indices
    pair<int, int> arr[n];
    for (int i = 0; i < n; i++)
    {
        arr[i].first = a[i];
        arr[i].second = i;
    }
 
    // Sort the array
    sort(arr, arr + n);
 
    // Count the number of swaps that can
    // be made
    int count = 1;
    for (int i = 1; i < n; i++)
        if (arr[i].first == arr[i - 1].first)
            count++;
 
    // Cannot generate 3 permutations
    if (count < k) {
        cout << "-1";
        return;
    }
 
    for (int i = 0; i < k - 1; i++)
    {
        // Print the first permutation
        printIndices(n, arr);
 
        // Find an index to swap and create
        // second permutation
        for (int j = next_pos; j < n; j++)
        {
            if (arr[j].first == arr[j - 1].first)
            {
                swap(arr[j], arr[j - 1]);
                next_pos = j + 1;
                break;
            }
        }
    }
 
    // Print the last permuation
    printIndices(n, arr);
}
 
// Driver code
int main()
{
    int a[] = { 1, 3, 3, 1 };
    int n = sizeof(a) / sizeof(a[0]);
 
    int k = 3;
   
    // Function call
    printPermutations(n, a, k);
 
    return 0;
}

chevron_right


Java

filter_none

edit
close

play_arrow

link
brightness_4
code

// Java implementation of the approach
import java.util.*;
 
class GFG {
    static int next_pos = 1;
    static class pair {
        int first, second;
        pair()
        {
            first = 0;
            second = 0;
        }
    }
 
    // Utility function to print the original indices
    // of the elements of the array
    static void printIndices(int n, pair a[])
    {
        for (int i = 0; i < n; i++)
            System.out.print(a[i].second + " ");
        System.out.println();
    }
    static class sort implements Comparator<pair>
    {
        // Used for sorting in ascending order
        public int compare(pair a, pair b)
        {
            return a.first < b.first ? -1 : 1;
        }
    }
 
    // Function to print the required permutations
    static void printPermutations(int n, int a[], int k)
    {
 
        // To keep track of original indices
        pair arr[] = new pair[n];
        for (int i = 0; i < n; i++)
        {
            arr[i] = new pair();
            arr[i].first = a[i];
            arr[i].second = i;
        }
 
        // Sort the array
        Arrays.sort(arr, new sort());
 
        // Count the number of swaps that can
        // be made
        int count = 1;
        for (int i = 1; i < n; i++)
            if (arr[i].first == arr[i - 1].first)
                count++;
 
        // Cannot generate 3 permutations
        if (count < k)
        {
            System.out.print("-1");
            return;
        }
 
        for (int i = 0; i < k - 1; i++)
        {
            // Print the first permutation
            printIndices(n, arr);
 
            // Find an index to swap and create
            // second permutation
            for (int j = next_pos; j < n; j++)
            {
                if (arr[j].first == arr[j - 1].first)
                {
                    pair t = arr[j];
                    arr[j] = arr[j - 1];
                    arr[j - 1] = t;
 
                    next_pos = j + 1;
                    break;
                }
            }
        }
 
        // Print the last permuation
        printIndices(n, arr);
    }
 
    // Driver code
    public static void main(String arsg[])
    {
        int a[] = { 1, 3, 3, 1 };
        int n = a.length;
 
        int k = 3;
       
        // Function call
        printPermutations(n, a, k);
    }
}
 
// This code is contributed by Arnab Kundu

chevron_right


Python3

filter_none

edit
close

play_arrow

link
brightness_4
code

# Python 3 implementation of the approach
 
# Utility function to print the original
# indices of the elements of the array
 
 
def printIndices(n, a):
    for i in range(n):
        print(a[i][1], end=" ")
    print("\n", end="")
 
# Function to print the required
# permutations
 
 
def printPermutations(n, a, k):
 
    # To keep track of original indices
    arr = [[0, 0] for i in range(n)]
    for i in range(n):
        arr[i][0] = a[i]
        arr[i][1] = i
 
    # Sort the array
    arr.sort(reverse=False)
 
    # Count the number of swaps that
    # can be made
    count = 1
    for i in range(1, n):
        if (arr[i][0] == arr[i - 1][0]):
            count += 1
 
    # Cannot generate 3 permutations
    if (count < k):
        print("-1", end="")
        return
 
    next_pos = 1
    for i in range(k - 1):
 
        # Print the first permutation
        printIndices(n, arr)
 
        # Find an index to swap and create
        # second permutation
        for j in range(next_pos, n):
            if (arr[j][0] == arr[j - 1][0]):
                temp = arr[j]
                arr[j] = arr[j - 1]
                arr[j - 1] = temp
                next_pos = j + 1
                break
 
    # Print the last permuation
    printIndices(n, arr)
 
 
# Driver code
if __name__ == '__main__':
    a = [1, 3, 3, 1]
    n = len(a)
    k = 3
     
    # Function call
    printPermutations(n, a, k)
 
# This code is contributed by
# Surendra_Gangwar

chevron_right


Output

0 3 1 2 
3 0 1 2 
3 0 2 1 

Time Complexity: O(N log N + K N)
 

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.




My Personal Notes arrow_drop_up

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.