Science & Technology

N Queen Problem Analysis

The N Queen is the problem of placing N chess queens on an N×N chessboard so that no two queens attack each other.

N Queen Problem

For a larger N, this problem couldn’t be solved in polynomial time. So, it is an NP-Complete problem. However, this problem could be solved by backtracking in non-polynomial time for a smaller N.

Backtracking is a general algorithm for finding all (or some) solutions to some computational problems, notably constraint satisfaction problems, that incrementally builds candidates to the solutions, and abandons a candidate (“backtracks”) as soon as it determines that the candidate cannot possibly be completed to a valid solution.

Solution of N Queen problem using backtracking checks for all possible arrangements of N Queens on the chessboard. And then checks for the validity of the solution. The code for the problem is below:

/* C/C++ program to solve N Queen Problem using 
backtracking */
#define N 8 
#include <stdbool.h> 
#include <stdio.h>

/* A utility function to print solution. 
It prints 1 where Queen is placed */
void printSolution(int board[N][N]) { 
 for (int i = 0; i < N; i++) { 
  for (int j = 0; j < N; j++) 
   printf(" %d ", board[i][j]); 
/* A utility function to check if a queen can 
be placed on board[row][col]. */
bool check(int board[N][N], int row, int col) { 
 int i, j;
/* Check this row on left side */
 for (i = 0; i < col; i++) 
  if (board[row][i]) 
   return false;
/* Check upper diagonal on left side */
 for (i = row, j = col; i >= 0 && j >= 0; i--, j--) 
  if (board[i][j]) 
   return false;
/* Check lower diagonal on left side */
 for (i = row, j = col; j >= 0 && i < N; i++, j--) 
  if (board[i][j]) 
   return false;
return true; 
/* A recursive utility function to solve N 
Queen problem */
bool solveUtil(int board[N][N], int col) { 
 /* base case: If all queens are placed 
 then return true */
 if (col >= N) 
  return true;
/* Consider this column and try placing 
 this queen in all rows one by one */
 for (int i = 0; i < N; i++) { 
  /* Check if the queen can be placed on 
  board[i][col] */
  if (check(board, i, col)) { 
   board[i][col] = 1;
/* recur to place rest of the queens */
   if (solveUtil(board, col + 1)) 
    return true;
   board[i][col] = 0; // BACKTRACK 
 return false; 

int main() { 
 int board[N][N] = {0};
 if (solveUtil(board, 0) == false) { 
  printf("Solution does not exist");  
 } else {
 return 0;

Here is a working example – N Queen solution. (Try changing the value of N)

Now number of possible arrangements of N Queens on N x N chessboard is N!, given you are skipping row or column, already having a queen placed.
So average and worst case complexity of the solution is O(N!) (since, you are checking all the possible solutions i.e. N^N arrangements). The best case occurs if you find your solution before exploiting all possible arrangements. This depends on your implementation. Also there could be more than one solution for this problem, but we stop as soon as we find one feasible solution to the problem.

And if you need all the possible solutions, the best, average and worst case complexity remains O(N!).

Happy Programming!

P.S. Check out our new tool on our website for intelligent and cool quotes & captions for your social media as well as blogs – CAPTAGRAM