计算前 N 个自然数的排列，其中相邻元素的总和等于一个完全平方数

给定一个正整数N ，任务是找到前N 个自然数的唯一排列的数量，其中相邻元素的总和等于一个完美的平方。

例子：

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

方法：给定的问题可以通过使用图的概念来解决。请按照以下步骤解决问题：

• 列出可以通过将任意两个正整数相加得到的直到(2*N – 1) 的所有完全平方数。
• 将图表示为邻接表表示，如果两个数X和Y 的和是一个完全平方数，则添加从节点X到节点Y 的边。
• 计算图中入度为 1 的节点数并将其存储在变量X 中。
• 现在，可以根据以下条件计算排列数：
  • 如果X 的值为0 ，则总共可能有N个排列。因此，打印N作为结果。
  • 如果X 的值为1或2 ，则总共可能有2个排列。因此，打印2作为结果。
  • 否则，不存在满足给定标准的此类排列。因此，打印0作为结果。

下面是上述方法的实现：

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());
 
    // 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

 
// 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
 

输出：

2

时间复杂度： O(N ² )
辅助空间： O(N ² )