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

Output:

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

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

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.