# Find a permutation of 1 to N, such that A is minimum in left half and B is maximum in right half

• Difficulty Level : Easy
• Last Updated : 28 Jan, 2022

Given three integers N, A, and B, the task is to find a permutation of pairwise distinct numbers from 1 to N such that A is the minimum element of the left half and B is the maximum element of the right half. It is also given that N is even. If no such permutations exist print -1.

Examples:

Input: N = 6,  A = 2, B = 5
Output: 6, 2, 4, 3, 5, 1
Explanation:  A = 2 is the minima of the left half.
B = 5 is the maxima of the right half.

Input: N = 6,  A = 1, B = 3
Output: -1
Explanation:  No such permutation exists.

Naive Approach (Brute Force): In this approach, generate all permutations of 1 to N numbers and check each one individually. Follow the below steps, to solve this problem:

• Generate all the permutations of numbers from 1 to N and store them in an array.
• Traverse through each permutation, if in the following permutation A is the minima of the left half and B is the maxima of the right half then print the permutation.
• If no such permutation exists, then print -1.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to generate next permutation``void` `nextPermutation(vector<``int``>& nums)``{``    ``int` `n = nums.size(), k, l;``    ``for` `(k = n - 2; k >= 0; k--) {``        ``if` `(nums[k] < nums[k + 1]) {``            ``break``;``        ``}``    ``}``    ``if` `(k < 0) {``        ``reverse(nums.begin(), nums.end());``    ``}``    ``else` `{``        ``for` `(l = n - 1; l > k; l--) {``            ``if` `(nums[l] > nums[k]) {``                ``break``;``            ``}``        ``}``        ``swap(nums[k], nums[l]);``        ``reverse(nums.begin() + k + 1, nums.end());``    ``}``}` `// Factorial function``int` `factorial(``int` `n)``{``    ``return` `(n == 1 || n == 0) ? 1 : factorial(n - 1) * n;``}` `// Function to returns all the permutations``// of a given array or vector``vector > permute(vector<``int``>& nums)``{``    ``vector > permuted;``    ``int` `n = nums.size();``    ``int` `factn = factorial(n);``    ``for` `(``int` `i = 0; i < factn; i++) {``        ``permuted.push_back(nums);``        ``nextPermutation(nums);``    ``}``    ``return` `permuted;``}` `// Function to find the permutation``// of 1 to N numbers``// having A minimas and B maximas``void` `findPermutation(``int` `n, ``int` `a, ``int` `b)``{` `    ``// Generate the array``    ``// containing one permutation``    ``vector<``int``> nums(n);``    ``for` `(``int` `i = 0; i < n; i++) {``        ``nums[i] = i + 1;``    ``}` `    ``// Generate all the permutations``    ``vector > allpermutations``        ``= permute(nums);` `    ``int` `total = allpermutations.size();``    ``int` `ansindex = -1;` `    ``for` `(``int` `i = 0; i < total; i++) {` `        ``// Find the minima of the left half``        ``// maxima of the right half``        ``int` `leftmin = allpermutations[i][0];``        ``int` `rightmax = allpermutations[i][n - 1];``        ``for` `(``int` `j = 0; j < n / 2; j++) {``            ``if` `(allpermutations[i][j] < leftmin) {``                ``leftmin = allpermutations[i][j];``            ``}``        ``}` `        ``for` `(``int` `j = n / 2; j < n; j++) {``            ``if` `(allpermutations[i][j] > rightmax) {``                ``rightmax = allpermutations[i][j];``            ``}``        ``}``        ``if` `(leftmin == a && rightmax == b) {` `            ``// Store the index``            ``// of a perfect permutation``            ``ansindex = i;``            ``break``;``        ``}``    ``}` `    ``// Print -1 if no such permutation exists``    ``if` `(ansindex == -1) {``        ``cout << -1;``    ``}``    ``else` `{` `        ``// Print the perfect permutation if exists``        ``for` `(``int` `i = 0; i < n; i++) {``            ``cout << allpermutations[ansindex][i]``                 ``<< ``" "``;``        ``}``    ``}``}` `// Driver Code``int` `main()``{``    ``int` `N = 6, A = 2, B = 5;``    ``findPermutation(N, A, B);``    ``return` `0;``}`

## Python3

 `# Python code to implement the above approach` `num ``=``[]``# Function to generate next permutation``def` `nextPermutation(nums):``    ``global` `num``    ``n ``=` `len``(nums)``    ``for` `k ``in` `range``(n ``-` `2``, ``-``1``,``-``1``):``        ``if` `(nums[k] < nums[k ``+` `1``]):``            ``break``            ` `    ``if` `(k < ``0``):``        ``nums.reverse()``        ` `    ``else``:``        ``for` `l ``in` `range``(n ``-` `1``, k, ``-``1``):``            ``if` `(nums[l] > nums[k]):``                ``break``                ` `        ``nums[k], nums[l] ``=` `nums[l], nums[k]``        ``temp ``=` `nums[k``+``1``:]``        ``temp.reverse()``        ``nums ``=` `nums[:k``+``1``] ``+``temp``    ` `    ``return` `nums` `# Factorial function``def` `factorial(n):``    ` `    ``return` `1` `if``(n ``=``=` `1` `or` `n ``=``=` `0``) ``else` `factorial(n ``-` `1``) ``*` `n` `# Function to returns all the permutations``# of a given array or vector``def` `permute(nums):``    ``global` `num``    ``permuted ``=``[]``    ``n ``=` `len``(nums)``    ``factn ``=` `factorial(n)``    ``for` `i ``in` `range``(factn):``        ``permuted.append(nums)``        ``nums ``=` `nextPermutation(nums)``    ``permuted.append(nums)``    ``return` `permuted` `# Function to find the permutation``# of 1 to N numbers``# having A minimas and B maximas``def` `findPermutation(n, a, b):``    ` `    ``# Generate the array``    ``# containing one permutation``    ``nums ``=` `[``0``]``*``n``    ``for` `i ``in` `range``(n):``        ``nums[i] ``=` `i ``+` `1``        ` `    ``# Generate all the permutations``    ``allpermutations ``=` `permute(nums)``    ` `    ``total ``=` `len``(allpermutations)``    ``ansindex ``=` `-``1``     ` `    ``for` `i ``in` `range``(total):``        ` `        ``# Find the minima of the left half``        ``# maxima of the right half``        ``leftmin ``=` `allpermutations[i][``0``]``        ``rightmax ``=` `allpermutations[i][n ``-` `1``]``        ``for` `j ``in` `range``(n ``/``/` `2``):``            ``if` `(allpermutations[i][j] < leftmin):``                ``leftmin ``=` `allpermutations[i][j]``                ` `        ``for` `j ``in` `range``(n ``/``/` `2``,n):``            ``if` `(allpermutations[i][j] > rightmax):``                ``rightmax ``=` `allpermutations[i][j]``        ` `        ``if` `(leftmin ``=``=` `a ``and` `rightmax ``=``=` `b):``            ` `            ``# Store the index``            ``# of a perfect permutation``            ``ansindex ``=` `i``            ``break``        ` `    ``# Pr-1 if no such permutation exists``    ``if` `(ansindex ``=``=` `-``1``):``        ``print``(``-``1``)``        ` `    ``else``:``        ` `        ``# Print the perfect permutation if exists``        ``for` `i ``in` `range``(n):``            ``print``(allpermutations[ansindex][i], end ``=``" "``)` `# Driver Code``N ``=` `6``A ``=` `2``B ``=` `5``findPermutation(N, A, B)` `# This code is contributed by Shubham Singh`
Output
`2 3 6 1 4 5 `

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

Efficient Approach (Greedy Method): The above brute force method can be optimized using the Greedy Algorithm. Greedy is an algorithmic paradigm that builds up a solution piece by piece, always choosing the next piece that offers the most obvious and immediate benefit. So, break the problem into different usable pieces according to the values of N, A, B. Follow the below steps to solve this problem:

• Initialize the variables left as n-b and right as a-1.
• If left or right is greater than n/2 then print -1
• Else if a and b are less than equal to n/2 then print -1.
• Else if a and b are greater than n/2 then print -1.
• Else if a equals n/2+1 and b equals n/2 then print n to 1 as the answer.
• Else, iterate over the range [0, n) using the variable i and perform the following tasks:
• If n-i equals a or b then print a or b else print n-i.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach``#include ``using` `namespace` `std;` `// Function to get the desired permutation``void` `getpermutation(``int` `n, ``int` `a, ``int` `b)``{``    ``int` `left = n - b, right = a - 1;` `    ``// When b < n/2 or a > n/2``    ``if` `(left > n / 2 || right > n / 2) {``        ``cout << -1;``    ``}` `    ``// When a and b both are``    ``// in the same half``    ``else` `if` `(a <= n / 2 && b <= n / 2) {``        ``cout << -1;``    ``}``    ``else` `if` `(a > n / 2 && b > n / 2) {``        ``cout << -1;``    ``}` `    ``// The corner case``    ``else` `if` `(a == n / 2 + 1 && b == n / 2) {``        ``for` `(``int` `i = 0; i < n; i++) {``            ``cout << n - i << ``" "``;``        ``}``    ``}` `    ``// Rest other combinations``    ``else` `{``        ``for` `(``int` `i = 0; i < n; i++) {``            ``if` `(n - i == b) {``                ``cout << a << ``" "``;``            ``}``            ``else` `if` `(n - i == a) {``                ``cout << b << ``" "``;``            ``}``            ``else` `{``                ``cout << n - i << ``" "``;``            ``}``        ``}``    ``}` `    ``cout << endl;``}` `// Driver Code``int` `main()``{` `    ``int` `N = 6, A = 2, B = 5;``    ``getpermutation(N, A, B);` `    ``return` `0;``}`

## Java

 `// Java program for the above approach``import` `java.util.*;` `class` `GFG{` `// Function to get the desired permutation``static` `void` `getpermutation(``int` `n, ``int` `a, ``int` `b)``{``    ``int` `left = n - b, right = a - ``1``;``    ` `    ``// When b < n/2 or a > n/2``    ``if` `(left > n / ``2` `|| right > n / ``2``)``    ``{``        ``System.out.print(-``1``);``    ``}``    ` `    ``// When a and b both are``    ``// in the same half``    ``else` `if` `(a <= n / ``2` `&& b <= n / ``2``)``    ``{``        ``System.out.print(-``1``);``    ``}``    ``else` `if` `(a > n / ``2` `&& b > n / ``2``)``    ``{``        ``System.out.print(-``1``);``    ``}``    ` `    ``// The corner case``    ``else` `if` `(a == n / ``2` `+ ``1` `&& b == n / ``2``)``    ``{``        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ``System.out.print(n - i + ``" "``);``        ``}``    ``}``    ` `    ``// Rest other combinations``    ``else``    ``{``        ``for``(``int` `i = ``0``; i < n; i++)``        ``{``            ``if` `(n - i == b)``            ``{``                ``System.out.print(a + ``" "``);``            ``}``            ``else` `if` `(n - i == a)``            ``{``                ``System.out.print(b + ``" "``);``            ``}``            ``else``            ``{``                ``System.out.print(n - i + ``" "``);``            ``}``        ``}``    ``}``    ``System.out.println();``}` `// Driver Code``public` `static` `void` `main(String args[])``{``    ``int` `N = ``6``, A = ``2``, B = ``5``;``    ` `    ``getpermutation(N, A, B);``}``}` `// This code is contributed by Samim Hossain Mondal.`

## Python3

 `# python program for the above approach` `# Function to get the desired permutation``def` `getpermutation(n, a, b):` `    ``left ``=` `n ``-` `b``    ``right ``=` `a ``-` `1` `    ``# When b < n/2 or a > n/2``    ``if` `(left > n ``/` `2` `or` `right > n ``/` `2``):``        ``print``(``-``1``)` `        ``# When a and b both are``        ``# in the same half``    ``elif` `(a <``=` `n ``/` `2` `and` `b <``=` `n ``/` `2``):``        ``print``(``-``1``)` `    ``elif` `(a > n ``/` `2` `and` `b > n ``/` `2``):``        ``print``(``-``1``)` `        ``# The corner case``    ``elif` `(a ``=``=` `n ``/` `2` `+` `1` `and` `b ``=``=` `n ``/` `2``):``        ``for` `i ``in` `range``(``0``, n):``            ``print``(n ``-` `i, end``=``" "``)` `        ``# Rest other combinations``    ``else``:``        ``for` `i ``in` `range``(``0``, n):``            ``if` `(n ``-` `i ``=``=` `b):``                ``print``(a, end``=``" "``)` `            ``elif` `(n ``-` `i ``=``=` `a):``                ``print``(b, end``=``" "``)` `            ``else``:``                ``print``(n ``-` `i, end``=``" "``)` `    ``print``()` `# Driver Code``if` `__name__ ``=``=` `"__main__"``:` `    ``N ``=` `6``    ``A ``=` `2``    ``B ``=` `5` `    ``getpermutation(N, A, B)` `    ``# This code is contributed by rakeshsahni`

## C#

 `// C# program for the above approach``using` `System;``class` `GFG {` `  ``// Function to get the desired permutation``  ``static` `void` `getpermutation(``int` `n, ``int` `a, ``int` `b)``  ``{``    ``int` `left = n - b, right = a - 1;` `    ``// When b < n/2 or a > n/2``    ``if` `(left > n / 2 || right > n / 2) {``      ``Console.Write(-1);``    ``}` `    ``// When a and b both are``    ``// in the same half``    ``else` `if` `(a <= n / 2 && b <= n / 2) {``      ``Console.Write(-1);``    ``}``    ``else` `if` `(a > n / 2 && b > n / 2) {``      ``Console.Write(-1);``    ``}` `    ``// The corner case``    ``else` `if` `(a == n / 2 + 1 && b == n / 2) {``      ``for` `(``int` `i = 0; i < n; i++) {``        ``Console.Write(n - i + ``" "``);``      ``}``    ``}` `    ``// Rest other combinations``    ``else` `{``      ``for` `(``int` `i = 0; i < n; i++) {``        ``if` `(n - i == b) {``          ``Console.Write(a + ``" "``);``        ``}``        ``else` `if` `(n - i == a) {``          ``Console.Write(b + ``" "``);``        ``}``        ``else` `{``          ``Console.Write(n - i + ``" "``);``        ``}``      ``}``    ``}` `    ``Console.WriteLine();``  ``}` `  ``// Driver Code``  ``public` `static` `void` `Main()``  ``{` `    ``int` `N = 6, A = 2, B = 5;``    ``getpermutation(N, A, B);``  ``}``}` `// This code is contributed by ukasp.`

## Javascript

 ``
Output
`6 2 4 3 5 1 `

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

My Personal Notes arrow_drop_up