# Count permutations of first N natural numbers having sum of adjacent elements equal to a perfect square

• Last Updated : 02 Jul, 2021

Given a positive integer N, the task is to find the number of unique permutations of first N natural numbers having sum of the adjacent elements equal to a perfect square.

Examples:

Input: N = 17
Output: 2
Explanation:
Following permutations have sum of adjacent elements equal to a perfect square:

1. {17, 8, 1, 15, 10, 6, 3, 13, 12, 4, 5, 11, 14, 2, 7, 9, 16}
2. {16, 9, 7, 2, 14, 11, 5, 4, 12, 13, 3, 6, 10, 15, 1, 8, 17}

Therefore, count of such permutations is 2.

Input: N = 13
Output: 0

Approach: The given problem can be solved by using the concepts of Graph. Follow the steps below to solve the problem:

• List all the perfect square numbers up to (2*N – 1) that can be obtained by adding any two positive integers.
• Represent the graph as the adjacency list representation such that if the sum of two numbers X and Y is a perfect square, then add an edge from node X to node Y.
• Count the number of nodes in the graph whose in-degree is 1 and store it in a variable X.
• Now, the number of permutation can be calculated as per the following conditions:
• If the value of X is 0, then a total of N permutations are possible. Hence, print N as the result.
• If the value of X is 1 or 2, then a total of 2 permutations are possible. Hence, print 2 as the result.
• Otherwise, no such permutations exist satisfying the given criteria. Hence, print 0 as the result.

Below is the implementation of the above approach:

## C++

 `// C++ program for the above approach`   `#include ` `using` `namespace` `std;`   `// Function to count total number of` `// permutation of the first N natural` `// number having the sum of adjacent` `// elements as perfect square` `int` `countPermutations(``int` `N)` `{` `    ``// Create an adjacency matrix` `    ``vector > adj(105);`   `    ``// Count elements whose indegree` `    ``// is 1` `    ``int` `indeg = 0;`   `    ``// Generate adjacency matrix` `    ``for` `(``int` `i = 1; i <= N; i++) {` `        ``for` `(``int` `j = 1; j <= N; j++) {`   `            ``if` `(i == j)` `                ``continue``;`   `            ``// Find the sum of i and j` `            ``int` `sum = i + j;`   `            ``// If sum is perfect square.` `            ``// then move from i to j` `            ``if` `(``ceil``(``sqrt``(sum))` `                ``== ``floor``(``sqrt``(sum))) {`   `                ``// Add it in adjacency` `                ``// list of i` `                ``adj[i].push_back(j);` `            ``}` `        ``}`   `        ``// If any list is of size 1,` `        ``// then the indegree is 1` `        ``if` `(adj[i].size() == 1)` `            ``indeg++;` `    ``}`   `    ``// If there is no element whose` `    ``// indegree is 1, then N such` `    ``// permutations are possible` `    ``if` `(indeg == 0)` `        ``return` `N;`   `    ``// If there is 1 or 2 elements` `    ``// whose indegree is 1, then 2` `    ``// permutations are possible` `    ``else` `if` `(indeg <= 2)` `        ``return` `2;`   `    ``// If there are more than 2` `    ``// elements whose indegree is` `    ``// 1, then return 0` `    ``else` `        ``return` `0;` `}`   `// Driver Code` `int` `main()` `{` `    ``int` `N = 17;` `    ``cout << countPermutations(N);`   `    ``return` `0;` `}`

## Java

 `// Java program for the above approach` `import` `java.io.*;` `import` `java.util.*;` `import` `java.lang.*;`   `class` `GFG{` `  `  `// Function to count total number of` `// permutation of the first N natural` `// number having the sum of adjacent` `// elements as perfect square` `static` `int` `countPermutations(``int` `N)` `{` `    `  `    ``// Create an adjacency matrix` `    ``ArrayList<` `    ``ArrayList> adj = ``new` `ArrayList<` `                                  ``ArrayList>(``105``);` `  `  `      ``for``(``int` `i = ``0``; i < ``105``; i++)` `        ``adj.add(``new` `ArrayList());`   `    ``// Count elements whose indegree` `    ``// is 1` `    ``int` `indeg = ``0``;`   `    ``// Generate adjacency matrix` `    ``for``(``int` `i = ``1``; i <= N; i++)` `    ``{` `        ``for``(``int` `j = ``1``; j <= N; j++)` `        ``{` `            ``if` `(i == j)` `                ``continue``;`   `            ``// Find the sum of i and j` `            ``int` `sum = i + j;`   `            ``// If sum is perfect square.` `            ``// then move from i to j` `            ``if` `(Math.ceil(Math.sqrt(sum)) == ` `                ``Math.floor(Math.sqrt(sum)))` `            ``{` `                `  `                ``// Add it in adjacency` `                ``// list of i` `                ``adj.get(i).add(j);` `            ``}` `        ``}`   `        ``// If any list is of size 1,` `        ``// then the indegree is 1` `        ``if` `(adj.get(i).size() == ``1``)` `            ``indeg++;` `    ``}`   `    ``// If there is no element whose` `    ``// indegree is 1, then N such` `    ``// permutations are possible` `    ``if` `(indeg == ``0``)` `        ``return` `N;`   `    ``// If there is 1 or 2 elements` `    ``// whose indegree is 1, then 2` `    ``// permutations are possible` `    ``else` `if` `(indeg <= ``2``)` `        ``return` `2``;`   `    ``// If there are more than 2` `    ``// elements whose indegree is` `    ``// 1, then return 0` `    ``else` `        ``return` `0``;` `}`   `// Driver Code` `public` `static` `void` `main(String[] args)` `{` `    ``int` `N = ``17``;` `    `  `    ``System.out.println(countPermutations(N));` `}` `}`   `// This code is contributed by Dharanendra L V.`

## Python3

 `# python program for the above approach` `from` `math ``import` `sqrt,floor,ceil`   `# Function to count total number of` `# permutation of the first N natural` `# number having the sum of adjacent` `# elements as perfect square` `def` `countPermutations(N):` `    ``# Create an adjacency matrix` `    ``adj ``=` `[[] ``for` `i ``in` `range``(``105``)]`   `    ``# bCount elements whose indegree` `    ``# bis 1` `    ``indeg ``=` `0`   `    ``# bGenerate adjacency matrix` `    ``for` `i ``in` `range``(``1``, N ``+` `1``):` `        ``for` `j ``in` `range``(``1``, N ``+` `1``):` `            ``if` `(i ``=``=` `j):` `                ``continue`   `            ``# Find the sum of i and j` `            ``sum` `=` `i ``+` `j`   `            ``# If sum is perfect square.` `            ``# then move from i to j` `            ``if` `(ceil(sqrt(``sum``)) ``=``=` `floor(sqrt(``sum``))):`   `                ``# Add it in adjacency` `                ``# list of i` `                ``adj[i].append(j)`   `        ``# If any list is of size 1,` `        ``# then the indegree is 1` `        ``if` `(``len``(adj[i]) ``=``=` `1``):` `            ``indeg ``+``=` `1`   `    ``# If there is no element whose` `    ``# indegree is 1, then N such` `    ``# permutations are possible` `    ``if` `(indeg ``=``=` `0``):` `        ``return` `N`   `    ``# If there is 1 or 2 elements` `    ``# whose indegree is 1, then 2` `    ``# permutations are possible` `    ``elif` `(indeg <``=` `2``):` `        ``return` `2`   `    ``# If there are more than 2` `    ``# elements whose indegree is` `    ``# 1, then return 0` `    ``else``:` `        ``return` `0`   `# Driver Code` `if` `__name__ ``=``=` `'__main__'``:` `    ``N ``=` `17` `    ``print` `(countPermutations(N))`   `# This code is contributed by mohit kumar 29.`

## C#

 `// C# program for the above approach` `using` `System;` `using` `System.Collections.Generic;`   `class` `GFG{` `  `  `// Function to count total number of` `// permutation of the first N natural` `// number having the sum of adjacent` `// elements as perfect square` `static` `int` `countPermutations(``int` `N)` `{` `    `  `    ``// Create an adjacency matrix` `    ``List> adj = ``new` `List>(105);` `  `  `    ``for``(``int` `i = 0; i < 105; i++)` `        ``adj.Add(``new` `List<``int``>());`   `    ``// Count elements whose indegree` `    ``// is 1` `    ``int` `indeg = 0;`   `    ``// Generate adjacency matrix` `    ``for``(``int` `i = 1; i <= N; i++)` `    ``{` `        ``for``(``int` `j = 1; j <= N; j++)` `        ``{` `            ``if` `(i == j)` `                ``continue``;`   `            ``// Find the sum of i and j` `            ``int` `sum = i + j;`   `            ``// If sum is perfect square.` `            ``// then move from i to j` `            ``if` `(Math.Ceiling(Math.Sqrt(sum)) == ` `                ``Math.Floor(Math.Sqrt(sum)))` `            ``{` `                `  `                ``// Add it in adjacency` `                ``// list of i` `                ``adj[i].Add(j);` `            ``}` `        ``}`   `        ``// If any list is of size 1,` `        ``// then the indegree is 1` `        ``if` `(adj[i].Count == 1)` `            ``indeg++;` `    ``}`   `    ``// If there is no element whose` `    ``// indegree is 1, then N such` `    ``// permutations are possible` `    ``if` `(indeg == 0)` `        ``return` `N;`   `    ``// If there is 1 or 2 elements` `    ``// whose indegree is 1, then 2` `    ``// permutations are possible` `    ``else` `if` `(indeg <= 2)` `        ``return` `2;`   `    ``// If there are more than 2` `    ``// elements whose indegree is` `    ``// 1, then return 0` `    ``else` `        ``return` `0;` `}`   `// Driver Code` `public` `static` `void` `Main()` `{` `    ``int` `N = 17;` `    `  `    ``Console.WriteLine(countPermutations(N));` `}` `}`   `// This code is contributed by SoumikMondal`

## Javascript

 ``

Output:

`2`

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

My Personal Notes arrow_drop_up
Related Articles