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:
- {17, 8, 1, 15, 10, 6, 3, 13, 12, 4, 5, 11, 14, 2, 7, 9, 16}
- {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++ program for the above approach
#include <bits/stdc++.h>
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<vector<int> > 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 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<Integer>> adj = new ArrayList<
ArrayList<Integer>>(105);
for(int i = 0; i < 105; i++)
adj.add(new ArrayList<Integer>());
// 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.
# 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# 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<List<int>> adj = new List<List<int>>(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
<script>
// JavaScript program for the above approach
// Function to count total number of
// permutation of the first N natural
// number having the sum of adjacent
// elements as perfect square
function countPermutations(N)
{
// Create an adjacency matrix
let adj = [];
for(let i = 0; i < 105; i++)
adj.push([]);
// Count elements whose indegree
// is 1
let indeg = 0;
// Generate adjacency matrix
for(let i = 1; i <= N; i++)
{
for(let j = 1; j <= N; j++)
{
if (i == j)
continue;
// Find the sum of i and j
let 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[i].push(j);
}
}
// If any list is of size 1,
// then the indegree is 1
if (adj[i].length == 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
let N = 17;
document.write(countPermutations(N));
// This code is contributed by patel2127
</script>
Output:
2
Time Complexity: O(N2)
Auxiliary Space: O(N2)