# Count permutations of all integers upto N that can form an acyclic graph based on given conditions

• Last Updated : 28 Apr, 2021

Given an integer N, the task is to find the number of permutations of integers from the range [1, N] that can form an acyclic graph according to the following conditions:

• For every 1 ≤ i ≤ N, find the largest j such that 1 ≤ j < i and A[j] > A[i], and add an undirected edge between node i and node j.
• For every 1 ≤ i ≤ N, find the smallest j such that i < j ≤ N and A[j] > A[i], and add an undirected edge between node i and node j.

Examples:

Input: 3
Output: 4
Explanation:
{1, 2, 3}: Possible (Graph Edges : { [1, 2], [2, 3] }. Therefore, no cycle exists)
{1, 3, 2}: Possible (Graph Edges : { [1, 3], [2, 3] }. Therefore, no cycle exists)
{2, 1, 3}: Not possible (Graph Edges : { [2, 3], [1, 3], [1, 2] }. Therefore, cycle exists)
{2, 3, 1}: Possible (Graph Edges : { [2, 3], [1, 3] }. Therefore, no cycle exists)
{3, 1, 2}: Not possible (Graph Edges : { [1, 2], [1, 3], [2, 3] }. Therefore, cycle exists)
{3, 2, 1}: Possible (Graph Edges : { [2, 3], [1, 2] }. Therefore, no cycle exists)

Input : 4
Output : 8

Approach: Follow the steps below to solve the problem:

• There are a total of N! possible arrays that can be generated consisting of permutations of integers from the range [1, N].
• According to the given conditions, if i, j, k (i < j < k) are indices from the array, then if A[i] > A[j] and A[j] < A[k], then there will be a cycle consisting of edges {[A[j], A[i]], [A[j], A[k]], [A[i], A[k]]}.
• Removing these permutations, there are 2(N – 1) possible permutations remaining.
• Remaining permutations gives only two possible positions for integers from the range [1, N – 1] and 1 possible position for N.

Illustration:
For N = 3:
Permutation {2, 1, 3} contains a cycle as A > A and A < A.
Permutation {3, 1, 2} contains a cycle as A > A and A < A.
All remaining permutations can generate an acyclic graph.
Therefore, the count of valid permutations = 3! – 2 = 4 = 23 – 1

• Therefore, print 2N – 1 as the required answer.

Below is the implementation of the above approach :

## C++

 `// C++ implementation of above approach``#include ``using` `namespace` `std;` `// Find the count of possible graphs``void` `possibleAcyclicGraph(``int` `N)``{``    ``cout << ``pow``(2, N - 1);``    ``return``;``}` `// Driver Code``int` `main()``{` `    ``int` `N = 4;``    ``possibleAcyclicGraph(N);` `    ``return` `0;``}`

## Java

 `// Java implementation of``// the above approach``import` `java.util.*;``class` `GFG{` `// Find the count of``// possible graphs``static` `void` `possibleAcyclicGraph(``int` `N)``{``  ``System.out.print((``int``)Math.pow(``2``,``                                 ``N - ``1``));``  ``return``;``}` `// Driver Code``public` `static` `void` `main(String[] args)``{``  ``int` `N = ``4``;``  ``possibleAcyclicGraph(N);``}``}` `// This code is contributed by Princi Singh`

## Python3

 `# Python3 implementation of above approach` `# Find the count of possible graphs``def` `possibleAcyclicGraph(N):``    ` `    ``print``(``pow``(``2``, N ``-` `1``))``    ``return` `# Driver code``if` `__name__ ``=``=` `'__main__'``:``    ` `    ``N ``=` `4``    ` `    ``possibleAcyclicGraph(N)` `# This code is contributed by mohit kumar 29`

## C#

 `// C# implementation of``// the above approach``using` `System;` `class` `GFG{``    ` `// Find the count of``// possible graphs``static` `void` `possibleAcyclicGraph(``int` `N)``{``    ``Console.Write((``int``)Math.Pow(2, N - 1));``    ` `    ``return``;``}`` ` `// Driver Code``public` `static` `void` `Main()``{``    ``int` `N = 4;``    ` `    ``possibleAcyclicGraph(N);``}``}` `// This code is contributed by sanjoy_62`

## Javascript

 ``

Output

`8`

Time Complexity: O(logN)
Space Complexity: O(1)

My Personal Notes arrow_drop_up