# Lexicographically smallest permutation number up to K having given array as a subsequence

• Last Updated : 09 Mar, 2022

Given an integer K and an array arr[] having N pairwise distinct integers in the range [1, K], the task is to find the lexicographically smallest permutation of the first K positive integers such that the given array arr[] is a subsequence of the permutation.

Examples:

Input: arr[] = {1, 3, 5, 7}, K = 8
Output: 1 2 3 4 5 6 7 8
Explanation: {1, 2, 3, 4, 5, 6, 7, 8} is the lexicographically smallest permutation of the first 8 positive integers such that the given array  {1, 3, 5, 7} is also a subsequence of the permutation.

Input: arr[] = {6, 4, 2, 1}, K=7
Output: 3 5 6 4 2 1 7

Approach: The given problem can be solved by using a greedy approach. Below are the steps to follow:

• Create a vector missing[] that stores the integers in the range [1, K] in increasing order that are not present in the given array arr[] using the approach discussed in this article.
• Create two pointers p1 and p2 which store the current index in arr[] and missing[] respectively. Initially, both are equal to 0.
• Greedily take and store the minimum of arr[p1] and missing [p2] into a vector, say ans[] and increment the respective pointer to the next position till the count of the stored integers is less than K.
• In order to make things easier, append INT_MAX at the end of the array missing[] and arr[] which will avoid getting out of bounds.
• After completing the above steps, all the values stored in the ans[] is the required result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach` `#include ` `using` `namespace` `std;`   `// Function to find the lexicographically` `// smallest permutation such that the` `// given array is a subsequence of it` `void` `findPermutation(``int` `K, vector<``int``> arr)` `{` `    ``// Stores the missing elements in` `    ``// arr in the range [1, K]` `    ``vector<``int``> missing;`   `    ``// Stores if the ith element is` `    ``// present in arr or not` `    ``vector<``bool``> visited(K + 1, 0);`   `    ``// Loop to mark all integers present` `    ``// in the array as visited` `    ``for` `(``int` `i = 0; i < arr.size(); i++) {` `        ``visited[arr[i]] = 1;` `    ``}`   `    ``// Loop to insert all the integers` `    ``// not visited into missing` `    ``for` `(``int` `i = 1; i <= K; i++) {` `        ``if` `(!visited[i]) {` `            ``missing.push_back(i);` `        ``}` `    ``}` `    ``// Append INT_MAX at end in order` `    ``// to prevent going out of bounds` `    ``arr.push_back(INT_MAX);` `    ``missing.push_back(INT_MAX);`   `    ``// Pointer to the current element` `    ``int` `p1 = 0;`   `    ``// Pointer to the missing element` `    ``int` `p2 = 0;`   `    ``// Stores the required permutation` `    ``vector<``int``> ans;`   `    ``// Loop to construct the permutation` `    ``// using greedy approach` `    ``while` `(ans.size() < K) {`   `        ``// If missing element is smaller` `        ``// that the current element insert` `        ``// missing element` `        ``if` `(arr[p1] < missing[p2]) {` `            ``ans.push_back(arr[p1]);` `            ``p1++;` `        ``}`   `        ``// Insert current element` `        ``else` `{` `            ``ans.push_back(missing[p2]);` `            ``p2++;` `        ``}` `    ``}`   `    ``// Print the required Permutation` `    ``for` `(``int` `i = 0; i < K; i++) {` `        ``cout << ans[i] << ``" "``;` `    ``}` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `K = 7;` `    ``vector<``int``> arr = { 6, 4, 2, 1 };`   `    ``// Function Call` `    ``findPermutation(K, arr);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.util.*;`   `class` `GFG{`   `// Function to find the lexicographically` `// smallest permutation such that the` `// given array is a subsequence of it` `static` `void` `findPermutation(``int` `K, Vector arr)` `{` `    ``// Stores the missing elements in` `    ``// arr in the range [1, K]` `    ``Vector missing = ``new` `Vector();`   `    ``// Stores if the ith element is` `    ``// present in arr or not` `    ``boolean` `visited[] = ``new` `boolean``[K + ``1``];`   `    ``// Loop to mark all integers present` `    ``// in the array as visited` `    ``for` `(``int` `i = ``0``; i < arr.size(); i++) {` `        ``visited[arr.get(i)] = ``true``;` `    ``}`   `    ``// Loop to insert all the integers` `    ``// not visited into missing` `    ``for` `(``int` `i = ``1``; i <= K; i++) {` `        ``if` `(!visited[i]) {` `            ``missing.add(i);` `        ``}` `    ``}` `    ``// Append Integer.MAX_VALUE at end in order` `    ``// to prevent going out of bounds` `    ``arr.add(Integer.MAX_VALUE);` `    ``missing.add(Integer.MAX_VALUE);`   `    ``// Pointer to the current element` `    ``int` `p1 = ``0``;`   `    ``// Pointer to the missing element` `    ``int` `p2 = ``0``;`   `    ``// Stores the required permutation` `    ``Vector ans = ``new` `Vector();`   `    ``// Loop to construct the permutation` `    ``// using greedy approach` `    ``while` `(ans.size() < K) {`   `        ``// If missing element is smaller` `        ``// that the current element insert` `        ``// missing element` `        ``if` `(arr.get(p1) < missing.get(p2)) {` `            ``ans.add(arr.get(p1));` `            ``p1++;` `        ``}`   `        ``// Insert current element` `        ``else` `{` `            ``ans.add(missing.get(p2));` `            ``p2++;` `        ``}` `    ``}`   `    ``// Print the required Permutation` `    ``for` `(``int` `i = ``0``; i < K; i++) {` `        ``System.out.print(ans.get(i)+ ``" "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `K = ``7``;` `    ``Integer []a = {``6``, ``4``, ``2``, ``1``};` `    ``Vector arr = ``new` `Vector<>(Arrays.asList(a));`   `    ``// Function Call` `    ``findPermutation(K, arr);`   `}` `}`   `// This code is contributed by 29AjayKumar`

## Python3

 `# Python program for the above approach`   `# Function to find the lexicographically` `# smallest permutation such that the` `#  given array is a subsequence of it` `def` `findPermutation(K, arr):` `  `  `    ``# Stores the missing elements in` `        ``# arr in the range [1, K]` `    ``missing ``=` `[]`   `    ``# Stores if the ith element is` `    ``# present in arr or not` `    ``visited ``=` `[``0``]``*``(K``+``1``)`   `    ``# Loop to mark all integers present` `    ``# in the array as visited` `    ``for` `i ``in` `range``(``4``):` `        ``visited[arr[i]] ``=` `1`   `    ``# Loop to insert all the integers` `    ``# not visited into missing` `    ``for` `i ``in` `range``(``1``, K``+``1``):` `        ``if``(``not` `visited[i]):` `            ``missing.append(i)`   `    ``# Append INT_MAX at end in order` `        ``# to prevent going out of bounds` `    ``INT_MAX ``=` `2147483647` `    ``arr.append(INT_MAX)` `    ``missing.append(INT_MAX)`   `    ``# Pointer to the current element` `    ``p1 ``=` `0`   `    ``# Pointer to the missing element` `    ``p2 ``=` `0`   `    ``# Stores the required permutation` `    ``ans ``=` `[]`   `    ``# Loop to construct the permutation` `    ``# using greedy approach`   `    ``while` `(``len``(ans) < K):` `        ``# If missing element is smaller` `                ``# that the current element insert` `        ``# missing element` `        ``if` `(arr[p1] < missing[p2]):` `            ``ans.append(arr[p1])` `            ``p1 ``=` `p1 ``+` `1`   `        ``# Insert current element` `        ``else``:` `            ``ans.append(missing[p2])` `            ``p2 ``=` `p2 ``+` `1`   `    ``# Print the required Permutation` `    ``for` `i ``in` `range``(``0``, K):` `        ``print``(ans[i], end``=``" "``)`   `# Driver Code` `if` `__name__ ``=``=` `"__main__"``:` `    ``K ``=` `7` `    ``arr ``=` `[``6``, ``4``, ``2``, ``1``]`   `    ``# Function Call` `    ``findPermutation(K, arr)` `    `  `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections;` `class` `GFG{`   `// Function to find the lexicographically` `// smallest permutation such that the` `// given array is a subsequence of it` `static` `void` `findPermutation(``int` `K, ArrayList arr)` `{` `  `  `    ``// Stores the missing elements in` `    ``// arr in the range [1, K]` `    ``ArrayList missing = ``new` `ArrayList();`   `    ``// Stores if the ith element is` `    ``// present in arr or not` `    ``bool` `[] visited = ``new` `bool``[K + 1];`   `    ``// Loop to mark all integers present` `    ``// in the array as visited` `    ``for` `(``int` `i = 0; i < arr.Count; i++) {` `        ``visited[(``int``)arr[i]] = ``true``;` `    ``}`   `    ``// Loop to insert all the integers` `    ``// not visited into missing` `    ``for` `(``int` `i = 1; i <= K; i++) {` `        ``if` `(!visited[i]) {` `            ``missing.Add(i);` `        ``}` `    ``}` `    ``// Append Int32.MaxValue at end in order` `    ``// to prevent going out of bounds` `    ``arr.Add(Int32.MaxValue);` `    ``missing.Add(Int32.MaxValue);`   `    ``// Pointer to the current element` `    ``int` `p1 = 0;`   `    ``// Pointer to the missing element` `    ``int` `p2 = 0;`   `    ``// Stores the required permutation` `    ``ArrayList ans = ``new` `ArrayList();`   `    ``// Loop to construct the permutation` `    ``// using greedy approach` `    ``while` `(ans.Count < K) {`   `        ``// If missing element is smaller` `        ``// that the current element insert` `        ``// missing element` `        ``if` `((``int``)arr[p1] < (``int``)missing[p2]) {` `            ``ans.Add(arr[p1]);` `            ``p1++;` `        ``}`   `        ``// Insert current element` `        ``else` `{` `            ``ans.Add(missing[p2]);` `            ``p2++;` `        ``}` `    ``}`   `    ``// Print the required Permutation` `    ``for` `(``int` `i = 0; i < K; i++) {` `        ``Console.Write(ans[i]+ ``" "``);` `    ``}` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `K = 7;` `    ``int` `[] a = {6, 4, 2, 1};` `    ``ArrayList arr = ``new` `ArrayList(a);`   `    ``// Function Call` `    ``findPermutation(K, arr);` `}` `}`   `// This code is contributed by ihritik.`

## Javascript

 ``

Output:

`3 5 6 4 2 1 7`

Time Complexity: O(N)
Auxiliary Space: O(N)

My Personal Notes arrow_drop_up
Recommended Articles
Page :