Skip to content
Related Articles
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)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up