# 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}.

## Recommended: Please try your approach on {IDE} first, before moving on to the solution.

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

 `// C++ implementation of the approach ` `#include ` `using` `namespace` `std; ` ` `  `// 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 = 1; j < n; j++) { ` `            ``if` `(arr[j].first == arr[j - 1].first) { ` `                ``swap(arr[j], arr[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); ` ` `  `    ``int` `k = 3; ` `    ``printPermutations(n, a, k); ` ` `  `    ``return` `0; ` `} `

## Java

 `// Java implementation of the approach ` `import` `java.util.*; ` ` `  `class` `GFG ` `{ ` `     `  `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  ` `{  ` `    ``// 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 = ``1``; j < n; j++)  ` `        ``{ ` `            ``if` `(arr[j].first == arr[j - ``1``].first) ` `            ``{ ` `                ``pair t = arr[j]; ` `                ``arr[j] = arr[j - ``1``]; ` `                ``arr[j - ``1``] = t; ` `                ``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``; ` `    ``printPermutations(n, a, k); ` `} ` `} ` ` `  `// This code is contributed by Arnab Kundu `

## Python3

 `# 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` ` `  `    ``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``(``1``, n): ` `            ``if` `(arr[j][``0``] ``=``=` `arr[j ``-` `1``][``0``]): ` `                ``temp ``=` `arr[j] ` `                ``arr[j] ``=` `arr[j ``-` `1``] ` `                ``arr[j ``-` `1``] ``=` `temp ` `                ``break` ` `  `    ``# Print the last permuation ` `    ``printIndices(n, arr) ` ` `  `# Driver code ` `if` `__name__ ``=``=` `'__main__'``: ` `    ``a ``=` `[``1``, ``3``, ``3``, ``1``] ` `    ``n ``=` `len``(a) ` `    ``k ``=` `3` `    ``printPermutations(n, a, k) ` ` `  `# This code is contributed by ` `# Surendra_Gangwar `

Output:

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

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

GeeksforGeeks has prepared a complete interview preparation course with premium videos, theory, practice problems, TA support and many more features. Please refer Placement 100 for details

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.