# Lexicographically smallest permutation of length 2N that can be obtained from an N-length array satisfying given conditions

Given an array **arr[] **of size **N**, the task is to find the lexicographically smallest permutation of first** 2*N** natural numbers such that every **i ^{th} **element in the given array is equal to the minimum of the

**(2 * i)**and

^{th}**(2 * i – 1)**element of the permutation.

^{th}**Examples:**

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

Input:arr[] = {2, 3, 4, 5}Output:-1

**Approach: **The given problem can be solved based on the following observations:

- Assuming array
P[]contains the required permutation, and from the condition thatarr[i] = min(P[2*i], P[2*i-1]), then it is best to assignarr[i]toP[2*i-1]as it will give the lexicographically smaller permutation.- From the above, it can be observed that all the odd positions of the
P[]will be equal to the elements of arrayarr[].- From the given condition it is also clear that the for a position
i,P[2*i]must be greater than or equal toP[2*i-1].- Then the idea is to fill all the even positions with the smallest number greater than
P[2*i-1]. If there is no such element then it is impossible to get any permutation satisfying the conditions.

Follow the steps below to solve the problem:

- Initialize a vector say
**W**, and**P**to store if an element is in array**arr[]**or not, and to store the required permutation. - Initialize a set
**S**to store all the elements in the range**[1, 2*N]**which are not in array**arr[].** - Traverse the array
**arr[]**and mark the current element**true**in the vector**W**. - Iterate in the range
**[1, 2*N]**using the variable**i**and then insert the**i**into set**S**. - Iterate in the range
**[0, N-1]**using the variable**i**and perform the following steps:- Find the iterator pointing to the smallest integer greater than the integer,
**arr[i]**using lower_bound(), and store it in a variable**it**. - If it is equal to
**S.end()**then print “**-1**” and return. - Otherwise, Push the
**arr[i]**and***it**into the vector**P**and then erase the element pointed by iterator**it**.

- Find the iterator pointing to the smallest integer greater than the integer,
- Finally, after completing the above steps, if none of the above cases satisfy then print the vector
**P[]**as the obtained permutation.

Below is the implementation of the above approach:

## C++

`// C++ program for the above approach` `#include <bits/stdc++.h>` `using` `namespace` `std;` `// Function to find the lexicographically` `// smallest permutation of length 2 * N` `// satisfying the given conditions` `void` `smallestPermutation(` `int` `arr[], ` `int` `N)` `{` ` ` `// Stores if i-th element is` ` ` `// placed at odd position or not` ` ` `vector<` `bool` `> w(2 * N + 1);` ` ` `// Traverse the array` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Mark arr[i] true` ` ` `w[arr[i]] = ` `true` `;` ` ` `}` ` ` `// Stores all the elements` ` ` `// not placed at odd positions` ` ` `set<` `int` `> S;` ` ` `// Iterate in the range [1, 2*N]` ` ` `for` `(` `int` `i = 1; i <= 2 * N; i++) {` ` ` `// If w[i] is not marked` ` ` `if` `(!w[i])` ` ` `S.insert(i);` ` ` `}` ` ` `// Stores whether it is possible` ` ` `// to obtain the required` ` ` `// permutation or not` ` ` `bool` `found = ` `true` `;` ` ` `// Stores the permutation` ` ` `vector<` `int` `> P;` ` ` `// Traverse the array arr[]` ` ` `for` `(` `int` `i = 0; i < N; i++) {` ` ` `// Finds the iterator of the` ` ` `// smallest number greater` ` ` `// than the arr[i]` ` ` `auto` `it = S.lower_bound(arr[i]);` ` ` `// If it is S.end()` ` ` `if` `(it == S.end()) {` ` ` `// Mark found false` ` ` `found = ` `false` `;` ` ` `break` `;` ` ` `}` ` ` `// Push arr[i] and *it` ` ` `// into the array` ` ` `P.push_back(arr[i]);` ` ` `P.push_back(*it);` ` ` `// Erase the current` ` ` `// element from the Set` ` ` `S.erase(it);` ` ` `}` ` ` `// If found is not marked` ` ` `if` `(!found) {` ` ` `cout << ` `"-1\n"` `;` ` ` `}` ` ` `// Otherwise,` ` ` `else` `{` ` ` `// Print the permutation` ` ` `for` `(` `int` `i = 0; i < 2 * N; i++)` ` ` `cout << P[i] << ` `" "` `;` ` ` `}` `}` `// Driver Code` `int` `main()` `{` ` ` `// Given Input` ` ` `int` `arr[] = { 4, 1, 3 };` ` ` `int` `N = ` `sizeof` `(arr) / ` `sizeof` `(arr[0]);` ` ` `// Function call` ` ` `smallestPermutation(arr, N);` ` ` `return` `0;` `}` |

## Python3

`# Python3 program for the above approach` `from` `bisect ` `import` `bisect_left` `# Function to find the lexicographically` `# smallest permutation of length 2 * N` `# satisfying the given conditions` `def` `smallestPermutation(arr, N):` ` ` ` ` `# Stores if i-th element is` ` ` `# placed at odd position or not` ` ` `w ` `=` `[` `False` `for` `i ` `in` `range` `(` `2` `*` `N ` `+` `1` `)]` ` ` `# Traverse the array` ` ` `for` `i ` `in` `range` `(N):` ` ` ` ` `# Mark arr[i] true` ` ` `w[arr[i]] ` `=` `True` ` ` `# Stores all the elements` ` ` `# not placed at odd positions` ` ` `S ` `=` `set` `()` ` ` `# Iterate in the range [1, 2*N]` ` ` `for` `i ` `in` `range` `(` `1` `, ` `2` `*` `N ` `+` `1` `, ` `1` `):` ` ` ` ` `# If w[i] is not marked` ` ` `if` `(w[i] ` `=` `=` `False` `):` ` ` `S.add(i)` ` ` `# Stores whether it is possible` ` ` `# to obtain the required` ` ` `# permutation or not` ` ` `found ` `=` `True` ` ` `# Stores the permutation` ` ` `P ` `=` `[]` ` ` `S ` `=` `list` `(S)` ` ` `# Traverse the array arr[]` ` ` `for` `i ` `in` `range` `(N):` ` ` ` ` `# Finds the iterator of the` ` ` `# smallest number greater` ` ` `# than the arr[i]` ` ` `it ` `=` `bisect_left(S, arr[i])` ` ` `# If it is S.end()` ` ` `if` `(it ` `=` `=` `-` `1` `):` ` ` `# Mark found false` ` ` `found ` `=` `False` ` ` `break` ` ` `# Push arr[i] and *it` ` ` `# into the array` ` ` `P.append(arr[i])` ` ` `P.append(S[it])` ` ` `# Erase the current` ` ` `# element from the Set` ` ` `S.remove(S[it])` ` ` `# If found is not marked` ` ` `if` `(found ` `=` `=` `False` `):` ` ` `print` `(` `"-1"` `)` ` ` ` ` `# Otherwise,` ` ` `else` `:` ` ` ` ` `# Print the permutation` ` ` `for` `i ` `in` `range` `(` `2` `*` `N):` ` ` `print` `(P[i], end ` `=` `" "` `)` `# Driver Code` `if` `__name__ ` `=` `=` `'__main__'` `:` ` ` ` ` `# Given Input` ` ` `arr ` `=` `[ ` `4` `, ` `1` `, ` `3` `]` ` ` `N ` `=` `len` `(arr)` ` ` ` ` `# Function call` ` ` `smallestPermutation(arr, N)` ` ` `# This code is contributed by SURENDRA_GANGWAR` |

**Output:**

4 5 1 2 3 6

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

Attention reader! Don’t stop learning now. Get hold of all the important Comcompetitivepetitve Programming concepts with the **Competitive Programming Live ** course.