# Leetcode N-Queens II problem solution

In this Leetcode N-Queens II problem solution, The n-queens puzzle is the problem of placing n queens on an n x n chessboard such that no two queens attack each other. we have given an integer n, return the number of distinct solutions to the n-queens puzzle.

## Problem solution in Python.

```class Solution:
def __init__(self):
self.res = 0

def totalNQueens(self, n: int) -> int:
def BT(cur_row, n, queens):
if cur_row == n:
self.res += 1
return
for cur_col in range(n):
good = True
for q in queens:
if cur_col == q[1] or abs(q[0] - cur_row) == abs(q[1] - cur_col):
good = False
break
if good:
queens.append((cur_row, cur_col))
BT(cur_row+1, n, queens)
queens.pop()

queens = []
BT(0, n, queens)
return self.res
```

## Problem solution in Java.

```class Solution {
int count=0;
public int totalNQueens(int n) {
if(n==1)
return 1;
if(n==0)
return 0;
char board[][]=new char[n][n];
nqueens(n,0,board);
return count;
}
boolean isSafe(int row,int i,int n,char[][]board){

for(int r=1;r<n;r++){
if(row-r>=0)
if(board[row-r][i]=='Q')
return false;
}
for(int r=1;r<n;r++){
if(row-r>=0&&i-r>=0)
if(board[row-r][i-r]=='Q')
return false;
}
for(int r=1,k=1;r<n&&k<n;r++,k++){
if(row-r>=0&&i+k<n)
if(board[row-r][i+k]=='Q')
return false;
}
return true;
}
void nqueens(int n,int row,char[][]board){
if(row==n){
count++;
return;
}
for(int i=0;i<n;i++){
if(isSafe(row,i,n,board)){
board[row][i]='Q';
nqueens(n,row+1,board);
board[row][i]='.';
}
}

}

}
```

## Problem solution in C++.

```typedef vector<bool> vb;
class Solution {
vector<vb> dp;
void whatTheFuck(int &ans,int k,int &n){
if(k==n){
++ans;
return;
}
for(int i=0;i<n;++i) if(dp[0][i] && dp[1][k+i] && dp[2][n+k-i]){
dp[0][i] = dp[1][k+i] = dp[2][n+k-i] = false;
whatTheFuck(ans,k+1,n);
dp[0][i] = dp[1][k+i] = dp[2][n+k-i] = true;
}
}
public:
int totalNQueens(int n) {
dp = vector<vb>(3,vb(2*n+1,true));
int ans;
whatTheFuck(ans,0,n);
return ans;
}
};
```

## Problem solution in C.

```void DFS(bool** flag,int* count,int deep,int n)
{
int i,j;
deep++;
if(deep==n)
{
(*count)++;
return;
}
for(i=0;i<n;i++)
{
if(!flag[1][i]&&!flag[2][i+deep]&&!flag[3][deep-i+n-1])
{
flag[1][i]=true;
flag[2][i+deep]=true;
flag[3][deep-i+n-1]=true;
DFS(flag,count,deep,n);
flag[1][i]=false;
flag[2][i+deep]=false;
flag[3][deep-i+n-1]=false;
}
}
return;
}
int totalNQueens(int n) {
bool** flag;
char*** Queen;
int i,*returnSize;
flag=(bool**)malloc(sizeof(bool*)*4);
flag[1]=(bool*)malloc(sizeof(bool)*9);
flag[2]=(bool*)malloc(sizeof(bool)*17);
flag[3]=(bool*)malloc(sizeof(bool)*17);
returnSize=(int*)malloc(sizeof(int*));
for(i=0;i<9;i++)
{
flag[1][i]=false;
}
for(i=0;i<17;i++)
{
flag[2][i]=false;
flag[3][i]=false;
}
DFS(flag,returnSize,-1,n);
return *returnSize;
}
```