在N * N棋盘上放置两个皇后的方式数量

给定一个表示N * N棋盘的整数N ，任务是计算在板上放置两个皇后的方式的数量，以使它们不会互相攻击。
例子：

Input: N = 9 
Output: 2184 
Explanation: 
There are 2184 ways to place two queens on 9 * 9 chess-board.
Input: N = 3 
Output: 8 
Explanation: 
There are 8 ways to place two queens on 3 * 3 chess-board.

天真的方法：一个简单的解决方案是为N * N矩阵上的两个女王选择每个可能的位置，并检查它们是否不在水平，垂直，正对角线或负对角线上。如果是，则将计数增加1。
时间复杂度： O(N ⁴ )
高效的方法：想法是使用组合来计算皇后区的可能位置，以使它们不会互相攻击。一个有用的观察结果是，计算单个女王/王后攻击的位置数量非常容易。那是 –

Number of positions a queen attack = 
    (N - 1) + (N - 1) + (D - 1)

Here, 
// First N-1 denotes positions in horizontal direction
// Second N-1 denotes positions in vertical direction
// D = Number of positions in 
    positive and negative diagonal

如果我们不将女王/王后放在最后一行和最后一列上，那么答案将只是在(N-1)*(N-1)的棋盘中放置的位置数，而如果我们将其放置在最后一排第一列和最后一行，则皇后区的可能位置将为2 * N – 1，并在3 *(N – 1)位置进行攻击。因此，另一个皇后的可能位置为N ² – 3 *(N-1)–1。最后，有(N-1)*(N-2)个组合，两个皇后都在最后一行和最后一个柱子。因此，递归关系将是–

Q(N) = Q(N-1) + (N2-3*(N-1)-1)-(N-1)*(N-2)

// By Induction
Q(N) = (N4)/2 - 5*(N3)/3 + 3*(N2)/2 - N/3

下面是上述方法的实现：

C++

// C++ implementation to find the
// number of ways to place two
// queens on the N * N chess board
 
#include 
 
#define ll long long
using namespace std;
 
// Function to find number of valid
// positions for two queens in the
// N * N chess board
ll possiblePositions(ll n)
{
    ll term1 = pow(n, 4);
    ll term2 = pow(n, 3);
    ll term3 = pow(n, 2);
    ll term4 = n / 3;
    ll ans = (ceil)(term1) / 2 -
             (ceil)(5 * term2) / 3 +
             (ceil)(3 * term3) / 2 - term4;
    return ans;
}
 
// Driver Code
int main()
{
    ll n;
    n = 3;
     
    // Function Call
    ll ans = possiblePositions(n);
    cout << ans << endl;
    return 0;
}

Java

// Java implementation to find the
// number of ways to place two
// queens on the N * N chess board
class GFG{
 
// Function to find number of valid
// positions for two queens in the
// N * N chess board
static double possiblePositions(double n)
{
    double term1 = Math.pow(n, 4);
    double term2 = Math.pow(n, 3);
    double term3 = Math.pow(n, 2);
    double term4 = n / 3;
    double ans = (Math.ceil(term1 / 2)) -
                 (Math.ceil(5 * term2) / 3) +
                 (Math.ceil(3 * term3) / 2) - term4;
 
    return (long)ans;
}
 
// Driver Code
public static void main(String[] args)
{
    double n;
    n = 3;
     
    // Function Call
    double ans = possiblePositions(n);
    System.out.print(ans + "\n");
}
}
 
// This code is contributed by sapnasingh4991

Python3

# Python3 implementation to find the
# number of ways to place two
# queens on the N * N chess board
import math
 
# Function to find number of valid
# positions for two queens in the
# N * N chess board
def possiblePositions(n):
     
    term1 = pow(n, 4);
    term2 = pow(n, 3);
    term3 = pow(n, 2);
    term4 = n / 3;
     
    ans = ((math.ceil(term1)) / 2 -
           (math.ceil(5 * term2)) / 3 +
           (math.ceil(3 * term3)) / 2 - term4);
            
    return ans;
 
# Driver code
if __name__ == '__main__':
     
    n = 3
 
    # Function call
    ans = possiblePositions(n)
     
    print(int(ans))
 
# This code is contributed by jana_sayantan

C#

// C# implementation to find the
// number of ways to place two
// queens on the N * N chess board
using System;
 
class GFG{
 
// Function to find number of valid
// positions for two queens in the
// N * N chess board
static double possiblePositions(double n)
{
    double term1 = Math.Pow(n, 4);
    double term2 = Math.Pow(n, 3);
    double term3 = Math.Pow(n, 2);
    double term4 = n / 3;
    double ans = (Math.Ceiling(term1 / 2)) -
                 (Math.Ceiling(5 * term2) / 3) +
                 (Math.Ceiling(3 * term3) / 2) - term4;
 
    return (long)ans;
}
 
// Driver Code
public static void Main(String[] args)
{
    double n;
    n = 3;
     
    // Function Call
    double ans = possiblePositions(n);
    Console.Write(ans + "\n");
}
}
 
// This code is contributed by Amit Katiyar

Javascript

 
// Javascript implementation to find the
// number of ways to place two
// queens on the N * N chess board
 
// Function to find number of valid
// positions for two queens in the
// N * N chess board
function possiblePositions(n)
{
    let term1 = Math.pow(n, 4);
    let term2 = Math.pow(n, 3);
    let term3 = Math.pow(n, 2);
    let term4 = n / 3;
    let ans = (Math.ceil(term1 / 2)) -
                 (Math.ceil(5 * term2) / 3) +
                 (Math.ceil(3 * term3) / 2) - term4;
   
    return ans;
}
 
    // Driver Code
    let n;
    n = 3;
       
    // Function Call
    let ans = possiblePositions(n);
    document.write(Math.floor(ans));
 
// This code is contributed by souravghosh0416.

输出：

8

时间复杂度： O(1)