Open In App
Related Articles

N Queen Problem

Improve Article
Improve
Save Article
Save
Like Article
Like

We have discussed Knight’s tour and Rat in a Maze problem earlier as examples of Backtracking problems. Let us discuss N Queen as another example problem that can be solved using backtracking.

What is N-Queen problem?

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

For example, the following is a solution for the 4 Queen problem.

The expected output is in the form of a matrix that has ‘Q‘s for the blocks where queens are placed and the empty spaces are represented by ‘.’ . For example, the following is the output matrix for the above 4-Queen solution.

. Q . .
. . . Q 
Q . . .
. . Q . 

N Queen Problem using Backtracking:

The idea is to place queens one by one in different columns, starting from the leftmost column. When we place a queen in a column, we check for clashes with already placed queens. In the current column, if we find a row for which there is no clash, we mark this row and column as part of the solution. If we do not find such a row due to clashes, then we backtrack and return false.

Below is the recursive tree of the above approach:

Recursive tree for N Queen problem

Follow the steps mentioned below to implement the idea:

  • Start in the leftmost column
  • If all queens are placed return true
  • Try all rows in the current column. Do the following for every row.
    • If the queen can be placed safely in this row
      • Then mark this [row, column] as part of the solution and recursively check if placing queen here leads to a solution.
      • If placing the queen in [row, column] leads to a solution then return true.
      • If placing queen doesn’t lead to a solution then unmark this [row, column] then backtrack and try other rows.
    • If all rows have been tried and valid solution is not found return false to trigger backtracking.

For better visualisation of this backtracking approach, please refer 4 Queen problem.

Note: We can also solve this problem by placing queens in rows as well.

Below is the implementation of the above approach:

C++




// C++ program to solve N Queen Problem using backtracking
 
#include <bits/stdc++.h>
#define N 4
using namespace std;
 
// A utility function to print solution
void printSolution(int board[N][N])
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++)
           if(board[i][j])
            cout << "Q ";
           else cout<<". ";
        printf("\n");
    }
}
 
// A utility function to check if a queen can
// be placed on board[row][col]. Note that this
// function is called when "col" queens are
// already placed in columns from 0 to col -1.
// So we need to check only left side for
// attacking queens
bool isSafe(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 solveNQUtil(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 (isSafe(board, i, col)) {
             
            // Place this queen in board[i][col]
            board[i][col] = 1;
 
            // recur to place rest of the queens
            if (solveNQUtil(board, col + 1))
                return true;
 
            // If placing queen in board[i][col]
            // doesn't lead to a solution, then
            // remove queen from board[i][col]
            board[i][col] = 0; // BACKTRACK
        }
    }
 
    // If the queen cannot be placed in any row in
    // this column col  then return false
    return false;
}
 
// This function solves the N Queen problem using
// Backtracking. It mainly uses solveNQUtil() to
// solve the problem. It returns false if queens
// cannot be placed, otherwise, return true and
// prints placement of queens in the form of 1s.
// Please note that there may be more than one
// solutions, this function prints one  of the
// feasible solutions.
bool solveNQ()
{
    int board[N][N] = { { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 } };
 
    if (solveNQUtil(board, 0) == false) {
        cout << "Solution does not exist";
        return false;
    }
 
    printSolution(board);
    return true;
}
 
// Driver program to test above function
int main()
{
    solveNQ();
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


C




// C program to solve N Queen Problem using backtracking
 
#define N 4
#include <stdbool.h>
#include <stdio.h>
 
// A utility function to print solution
void printSolution(int board[N][N])
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++) {
            if(board[i][j])
                printf("Q ");
            else
                printf(". ");
        }
        printf("\n");
    }
}
 
// A utility function to check if a queen can
// be placed on board[row][col]. Note that this
// function is called when "col" queens are
// already placed in columns from 0 to col -1.
// So we need to check only left side for
// attacking queens
bool isSafe(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 solveNQUtil(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 (isSafe(board, i, col)) {
             
            // Place this queen in board[i][col]
            board[i][col] = 1;
 
            // Recur to place rest of the queens
            if (solveNQUtil(board, col + 1))
                return true;
 
            // If placing queen in board[i][col]
            // doesn't lead to a solution, then
            // remove queen from board[i][col]
            board[i][col] = 0; // BACKTRACK
        }
    }
 
    // If the queen cannot be placed in any row in
    // this column col  then return false
    return false;
}
 
// This function solves the N Queen problem using
// Backtracking. It mainly uses solveNQUtil() to
// solve the problem. It returns false if queens
// cannot be placed, otherwise, return true and
// prints placement of queens in the form of 1s.
// Please note that there may be more than one
// solutions, this function prints one  of the
// feasible solutions.
bool solveNQ()
{
    int board[N][N] = { { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 } };
 
    if (solveNQUtil(board, 0) == false) {
        printf("Solution does not exist");
        return false;
    }
 
    printSolution(board);
    return true;
}
 
// Driver program to test above function
int main()
{
    solveNQ();
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Java




// Java program to solve N Queen Problem using backtracking
 
public class NQueenProblem {
    final int N = 4;
 
    // A utility function to print solution
    void printSolution(int board[][])
    {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++) {
                if (board[i][j] == 1)
                    System.out.print("Q ");
                else
                    System.out.print(". ");
            }
            System.out.println();
        }
    }
 
    // A utility function to check if a queen can
    // be placed on board[row][col]. Note that this
    // function is called when "col" queens are already
    // placeed in columns from 0 to col -1. So we need
    // to check only left side for attacking queens
    boolean isSafe(int board[][], int row, int col)
    {
        int i, j;
 
        // Check this row on left side
        for (i = 0; i < col; i++)
            if (board[row][i] == 1)
                return false;
 
        // Check upper diagonal on left side
        for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
            if (board[i][j] == 1)
                return false;
 
        // Check lower diagonal on left side
        for (i = row, j = col; j >= 0 && i < N; i++, j--)
            if (board[i][j] == 1)
                return false;
 
        return true;
    }
 
    // A recursive utility function to solve N
    // Queen problem
    boolean solveNQUtil(int board[][], 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 (isSafe(board, i, col)) {
                 
                // Place this queen in board[i][col]
                board[i][col] = 1;
 
                // Recur to place rest of the queens
                if (solveNQUtil(board, col + 1) == true)
                    return true;
 
                // If placing queen in board[i][col]
                // doesn't lead to a solution then
                // remove queen from board[i][col]
                board[i][col] = 0; // BACKTRACK
            }
        }
 
        // If the queen can not be placed in any row in
        // this column col, then return false
        return false;
    }
 
    // This function solves the N Queen problem using
    // Backtracking.  It mainly uses solveNQUtil () to
    // solve the problem. It returns false if queens
    // cannot be placed, otherwise, return true and
    // prints placement of queens in the form of 1s.
    // Please note that there may be more than one
    // solutions, this function prints one of the
    // feasible solutions.
    boolean solveNQ()
    {
        int board[][] = { { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 } };
 
        if (solveNQUtil(board, 0) == false) {
            System.out.print("Solution does not exist");
            return false;
        }
 
        printSolution(board);
        return true;
    }
 
    // Driver program to test above function
    public static void main(String args[])
    {
        NQueenProblem Queen = new NQueenProblem();
        Queen.solveNQ();
    }
}
// This code is contributed by Abhishek Shankhadhar


Python3




# Python3 program to solve N Queen
# Problem using backtracking
 
global N
N = 4
 
 
def printSolution(board):
    for i in range(N):
        for j in range(N):
            if board[i][j] == 1:
                print("Q",end=" ")
            else:
                print(".",end=" ")
        print()
 
 
# A utility function to check if a queen can
# be placed on board[row][col]. Note that this
# function is called when "col" queens are
# already placed in columns from 0 to col -1.
# So we need to check only left side for
# attacking queens
def isSafe(board, row, col):
 
    # Check this row on left side
    for i in range(col):
        if board[row][i] == 1:
            return False
 
    # Check upper diagonal on left side
    for i, j in zip(range(row, -1, -1),
                    range(col, -1, -1)):
        if board[i][j] == 1:
            return False
 
    # Check lower diagonal on left side
    for i, j in zip(range(row, N, 1),
                    range(col, -1, -1)):
        if board[i][j] == 1:
            return False
 
    return True
 
 
def solveNQUtil(board, 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 i in range(N):
 
        if isSafe(board, i, col):
 
            # Place this queen in board[i][col]
            board[i][col] = 1
 
            # Recur to place rest of the queens
            if solveNQUtil(board, col + 1) == True:
                return True
 
            # If placing queen in board[i][col
            # doesn't lead to a solution, then
            # queen from board[i][col]
            board[i][col] = 0
 
    # If the queen can not be placed in any row in
    # this column col then return false
    return False
 
 
# This function solves the N Queen problem using
# Backtracking. It mainly uses solveNQUtil() to
# solve the problem. It returns false if queens
# cannot be placed, otherwise return true and
# placement of queens in the form of 1s.
# note that there may be more than one
# solutions, this function prints one of the
# feasible solutions.
def solveNQ():
    board = [[0, 0, 0, 0],
             [0, 0, 0, 0],
             [0, 0, 0, 0],
             [0, 0, 0, 0]]
 
    if solveNQUtil(board, 0) == False:
        print("Solution does not exist")
        return False
 
    printSolution(board)
    return True
 
 
# Driver Code
if __name__ == '__main__':
    solveNQ()
 
# This code is contributed by Divyanshu Mehta


C#




// C# program to solve N Queen Problem
// using backtracking
using System;
     
class GFG
{
    readonly int N = 4;
 
    // A utility function to print solution
    void printSolution(int [,]board)
    {
        for (int i = 0; i < N; i++)
        {
            for (int j = 0; j < N; j++)
            {
                if (board[i, j] == 1)
                    Console.Write("Q ");
                else
                    Console.Write(". ");
            }
            Console.WriteLine();
        }
    }
 
    // A utility function to check if a queen can
    // be placed on board[row,col]. Note that this
    // function is called when "col" queens are already
    // placeed in columns from 0 to col -1. So we need
    // to check only left side for attacking queens
    bool isSafe(int [,]board, int row, int col)
    {
        int i, j;
 
        // Check this row on left side
        for (i = 0; i < col; i++)
            if (board[row,i] == 1)
                return false;
 
        // Check upper diagonal on left side
        for (i = row, j = col; i >= 0 &&
             j >= 0; i--, j--)
            if (board[i,j] == 1)
                return false;
 
        // Check lower diagonal on left side
        for (i = row, j = col; j >= 0 &&
                      i < N; i++, j--)
            if (board[i, j] == 1)
                return false;
 
        return true;
    }
 
    // A recursive utility function to solve N
    // Queen problem
    bool solveNQUtil(int [,]board, 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 (isSafe(board, i, col))
            {
                // Place this queen in board[i,col]
                board[i, col] = 1;
 
                // Recur to place rest of the queens
                if (solveNQUtil(board, col + 1) == true)
                    return true;
 
                // If placing queen in board[i,col]
                // doesn't lead to a solution then
                // remove queen from board[i,col]
                board[i, col] = 0; // BACKTRACK
            }
        }
 
        // If the queen can not be placed in any row in
        // this column col, then return false
        return false;
    }
 
    // This function solves the N Queen problem using
    // Backtracking. It mainly uses solveNQUtil () to
    // solve the problem. It returns false if queens
    // cannot be placed, otherwise, return true and
    // prints placement of queens in the form of 1s.
    // Please note that there may be more than one
    // solutions, this function prints one of the
    // feasible solutions.
    bool solveNQ()
    {
        int [,]board = {{ 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 }};
 
        if (solveNQUtil(board, 0) == false)
        {
            Console.Write("Solution does not exist");
            return false;
        }
 
        printSolution(board);
        return true;
    }
 
    // Driver Code
    public static void Main(String []args)
    {
        GFG Queen = new GFG();
        Queen.solveNQ();
    }
}
 
// This code is contributed by Princi Singh


Javascript




<script>
// JavaScript program to solve N Queen
// Problem using backtracking
const N = 4
 
function printSolution(board)
{
    for(let i = 0; i < N; i++)
    {
        for(let j = 0; j < N; j++)
        {
            if(board[i][j] == 1)
                document.write("Q ")
            else
                document.write(". ")
        }
        document.write("</br>")
    }
}
 
// A utility function to check if a queen can
// be placed on board[row][col]. Note that this
// function is called when "col" queens are
// already placed in columns from 0 to col -1.
// So we need to check only left side for
// attacking queens
function isSafe(board, row, col)
{
 
    // Check this row on left side
    for(let i = 0; i < col; i++){
        if(board[row][i] == 1)
            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
}
 
function solveNQUtil(board, 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(let i=0;i<N;i++){
 
        if(isSafe(board, i, col)==true){
             
            // Place this queen in board[i][col]
            board[i][col] = 1
 
            // recur to place rest of the queens
            if(solveNQUtil(board, col + 1) == true)
                return true
 
            // If placing queen in board[i][col
            // doesn't lead to a solution, then
            // queen from board[i][col]
            board[i][col] = 0
        }
    }
    // if the queen can not be placed in any row in
    // this column col then return false
    return false
}
 
// This function solves the N Queen problem using
// Backtracking. It mainly uses solveNQUtil() to
// solve the problem. It returns false if queens
// cannot be placed, otherwise return true and
// placement of queens in the form of 1s.
// note that there may be more than one
// solutions, this function prints one of the
// feasible solutions.
function solveNQ(){
    let board = [ [0, 0, 0, 0],
              [0, 0, 0, 0],
              [0, 0, 0, 0],
              [0, 0, 0, 0] ]
 
    if(solveNQUtil(board, 0) == false){
        document.write("Solution does not exist")
        return false
    }
 
    printSolution(board)
    return true
}
 
// Driver Code
solveNQ()
 
// This code is contributed by shinjanpatra
 
</script>


Output

. . Q . 
Q . . . 
. . . Q 
. Q . . 

Time Complexity: O(N!)
Auxiliary Space: O(N2)

Further Optimization in is_safe() function:

The idea is not to check every element in the right and left diagonal, instead use the property of diagonals: 

  • The sum of i and j is constant and unique for each right diagonal, where i is the row of elements and j is the 
    column of elements. 
  • The difference between i and j is constant and unique for each left diagonal, where i and j are row and column of element respectively.

Below is the implementation:

C++




// C++ program to solve N Queen Problem using backtracking
 
#include <bits/stdc++.h>
using namespace std;
#define N 4
 
// ld is an array where its indices indicate row-col+N-1
// (N-1) is for shifting the difference to store negative
// indices
int ld[30] = { 0 };
 
// rd is an array where its indices indicate row+col
// and used to check whether a queen can be placed on
// right diagonal or not
int rd[30] = { 0 };
 
// Column array where its indices indicates column and
// used to check whether a queen can be placed in that
// row or not*/
int cl[30] = { 0 };
 
// A utility function to print solution
void printSolution(int board[N][N])
{
    for (int i = 0; i < N; i++) {
        for (int j = 0; j < N; j++)
            cout << " " << (board[i][j]==1?"Q":".") << " ";
        cout << endl;
    }
}
 
// A recursive utility function to solve N
// Queen problem
bool solveNQUtil(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]
 
        // To check if a queen can be placed on
        // board[row][col].We just need to check
        // ld[row-col+n-1] and rd[row+coln] where
        // ld and rd are for left and right
        // diagonal respectively
        if ((ld[i - col + N - 1] != 1 && rd[i + col] != 1)
            && cl[i] != 1) {
 
            // Place this queen in board[i][col]
            board[i][col] = 1;
            ld[i - col + N - 1] = rd[i + col] = cl[i] = 1;
 
            // Recur to place rest of the queens
            if (solveNQUtil(board, col + 1))
                return true;
 
            // If placing queen in board[i][col]
            // doesn't lead to a solution, then
            // remove queen from board[i][col]
            board[i][col] = 0; // BACKTRACK
            ld[i - col + N - 1] = rd[i + col] = cl[i] = 0;
        }
    }
 
    // If the queen cannot be placed in any row in
    // this column col  then return false
    return false;
}
 
// This function solves the N Queen problem using
// Backtracking. It mainly uses solveNQUtil() to
// solve the problem. It returns false if queens
// cannot be placed, otherwise, return true and
// prints placement of queens in the form of 1s.
// Please note that there may be more than one
// solutions, this function prints one  of the
// feasible solutions.
bool solveNQ()
{
    int board[N][N] = { { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 },
                        { 0, 0, 0, 0 } };
 
    if (solveNQUtil(board, 0) == false) {
        cout << "Solution does not exist";
        return false;
    }
 
    printSolution(board);
    return true;
}
 
// Driver program to test above function
int main()
{
    solveNQ();
    return 0;
}
 
// This code is contributed by Aditya Kumar (adityakumar129)


Java




// Java program to solve N Queen Problem using backtracking
 
import java.util.*;
 
class GFG {
    static int N = 4;
 
    // ld is an array where its indices indicate row-col+N-1
    // (N-1) is for shifting the difference to store
    // negative indices
    static int[] ld = new int[30];
 
    // rd is an array where its indices indicate row+col
    // and used to check whether a queen can be placed on
    // right diagonal or not
    static int[] rd = new int[30];
 
    // Column array where its indices indicates column and
    // used to check whether a queen can be placed in that
    // row or not
    static int[] cl = new int[30];
 
    // A utility function to print solution
    static void printSolution(int board[][])
    {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++)
                System.out.printf(" %d ", board[i][j]);
            System.out.printf("\n");
        }
    }
 
    // A recursive utility function to solve N
    // Queen problem
    static boolean solveNQUtil(int board[][], 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]
 
            // To check if a queen can be placed on
            // board[row][col].We just need to check
            // ld[row-col+n-1] and rd[row+coln] where
            // ld and rd are for left and right
            // diagonal respectively
            if ((ld[i - col + N - 1] != 1
                 && rd[i + col] != 1)
                && cl[i] != 1) {
                // Place this queen in board[i][col]
                board[i][col] = 1;
                ld[i - col + N - 1] = rd[i + col] = cl[i]
                    = 1;
 
                // Recur to place rest of the queens
                if (solveNQUtil(board, col + 1))
                    return true;
 
                // If placing queen in board[i][col]
                // doesn't lead to a solution, then
                // remove queen from board[i][col]
                board[i][col] = 0; // BACKTRACK
                ld[i - col + N - 1] = rd[i + col] = cl[i]
                    = 0;
            }
        }
 
        // If the queen cannot be placed in any row in
        // this column col then return false
        return false;
    }
 
    // This function solves the N Queen problem using
    // Backtracking. It mainly uses solveNQUtil() to
    // solve the problem. It returns false if queens
    // cannot be placed, otherwise, return true and
    // prints placement of queens in the form of 1s.
    // Please note that there may be more than one
    // solutions, this function prints one of the
    // feasible solutions.
    static boolean solveNQ()
    {
        int board[][] = { { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 } };
 
        if (solveNQUtil(board, 0) == false) {
            System.out.printf("Solution does not exist");
            return false;
        }
 
        printSolution(board);
        return true;
    }
 
    // Driver Code
    public static void main(String[] args)
    {
        solveNQ();
    }
}
 
// This code is contributed by Princi Singh


Python3




# Python3 program to solve N Queen Problem using
# backtracking
N = 4
 
# ld is an array where its indices indicate row-col+N-1
# (N-1) is for shifting the difference to store negative
# indices
ld = [0] * 30
 
# rd is an array where its indices indicate row+col
# and used to check whether a queen can be placed on
# right diagonal or not
rd = [0] * 30
 
# Column array where its indices indicates column and
# used to check whether a queen can be placed in that
# row or not
cl = [0] * 30
 
 
# A utility function to print solution
def printSolution(board):
    for i in range(N):
        for j in range(N):
            print(board[i][j], end=" ")
        print()
 
 
# A recursive utility function to solve N
# Queen problem
def solveNQUtil(board, 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 i in range(N):
 
        # Check if the queen can be placed on board[i][col]
 
        # To check if a queen can be placed on
        # board[row][col] We just need to check
        # ld[row-col+n-1] and rd[row+coln]
        # where ld and rd are for left and
        # right diagonal respectively
        if ((ld[i - col + N - 1] != 1 and
             rd[i + col] != 1) and cl[i] != 1):
 
            # Place this queen in board[i][col]
            board[i][col] = 1
            ld[i - col + N - 1] = rd[i + col] = cl[i] = 1
 
            # Recur to place rest of the queens
            if (solveNQUtil(board, col + 1)):
                return True
 
            # If placing queen in board[i][col]
            # doesn't lead to a solution,
            # then remove queen from board[i][col]
            board[i][col] = 0  # BACKTRACK
            ld[i - col + N - 1] = rd[i + col] = cl[i] = 0
 
            # If the queen cannot be placed in
            # any row in this column col then return False
    return False
 
 
# This function solves the N Queen problem using
# Backtracking. It mainly uses solveNQUtil() to
# solve the problem. It returns False if queens
# cannot be placed, otherwise, return True and
# prints placement of queens in the form of 1s.
# Please note that there may be more than one
# solutions, this function prints one of the
# feasible solutions.
def solveNQ():
    board = [[0, 0, 0, 0],
             [0, 0, 0, 0],
             [0, 0, 0, 0],
             [0, 0, 0, 0]]
    if (solveNQUtil(board, 0) == False):
        printf("Solution does not exist")
        return False
    printSolution(board)
    return True
 
 
# Driver Code
if __name__ == '__main__':
    solveNQ()
 
# This code is contributed by SHUBHAMSINGH10


C#




// C# program to solve N Queen Problem using backtracking
 
using System;
 
class GFG {
    static int N = 4;
 
    // ld is an array where its indices indicate row-col+N-1
    // (N-1) is for shifting the difference to store
    // negative indices
    static int[] ld = new int[30];
 
    // rd is an array where its indices indicate row+col
    // and used to check whether a queen can be placed on
    // right diagonal or not
    static int[] rd = new int[30];
 
    // Column array where its indices indicates column and
    // used to check whether a queen can be placed in that
    // row or not
    static int[] cl = new int[30];
 
    // A utility function to print solution
    static void printSolution(int[, ] board)
    {
        for (int i = 0; i < N; i++) {
            for (int j = 0; j < N; j++)
                Console.Write(" {0} ", board[i, j]);
            Console.Write("\n");
        }
    }
 
    // A recursive utility function to solve N
    // Queen problem
    static bool solveNQUtil(int[, ] board, 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]
 
            // To check if a queen can be placed on
            // board[row,col].We just need to check
            // ld[row-col+n-1] and rd[row+coln] where
            // ld and rd are for left and right
            // diagonal respectively
            if ((ld[i - col + N - 1] != 1
                 && rd[i + col] != 1)
                && cl[i] != 1) {
                // Place this queen in board[i,col]
                board[i, col] = 1;
                ld[i - col + N - 1] = rd[i + col] = cl[i]
                    = 1;
 
                // Recur to place rest of the queens
                if (solveNQUtil(board, col + 1))
                    return true;
 
                // If placing queen in board[i,col]
                // doesn't lead to a solution, then
                // remove queen from board[i,col]
                board[i, col] = 0; // BACKTRACK
                ld[i - col + N - 1] = rd[i + col] = cl[i]
                    = 0;
            }
        }
 
        // If the queen cannot be placed in any row in
        // this column col then return false
        return false;
    }
 
    // This function solves the N Queen problem using
    // Backtracking. It mainly uses solveNQUtil() to
    // solve the problem. It returns false if queens
    // cannot be placed, otherwise, return true and
    // prints placement of queens in the form of 1s.
    // Please note that there may be more than one
    // solutions, this function prints one of the
    // feasible solutions.
    static bool solveNQ()
    {
        int[, ] board = { { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 },
                          { 0, 0, 0, 0 } };
 
        if (solveNQUtil(board, 0) == false) {
            Console.Write("Solution does not exist");
            return false;
        }
 
        printSolution(board);
        return true;
    }
 
    // Driver Code
    public static void Main(String[] args)
    {
        solveNQ();
    }
}
 
// This code is contributed by Rajput-Ji


Javascript




<script>
    // JavaScript code to implement the approach
 
let N = 4;
  
// ld is an array where its indices indicate row-col+N-1
// (N-1) is for shifting the difference to store negative
// indices
let ld = new Array(30);
  
// rd is an array where its indices indicate row+col
// and used to check whether a queen can be placed on
// right diagonal or not
let rd = new Array(30);
  
// Column array where its indices indicates column and
// used to check whether a queen can be placed in that
// row or not
let cl = new Array(30);
  
// A utility function to print solution
function printSolution( board)
{
    for (let i = 0; i < N; i++)
    {
        for (let j = 0; j < N; j++)
            document.write(board[i][j] + " ");
        document.write("<br/>");
    }
}
  
// A recursive utility function to solve N
// Queen problem
function solveNQUtil(board, 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 (let i = 0; i < N; i++)
    {
          
        // Check if the queen can be placed on
        // board[i][col]
         
        // To check if a queen can be placed on
        // board[row][col].We just need to check
        // ld[row-col+n-1] and rd[row+coln] where
        // ld and rd are for left and right
        // diagonal respectively
        if ((ld[i - col + N - 1] != 1 &&
             rd[i + col] != 1) && cl[i] != 1)
        {
            // Place this queen in board[i][col]
            board[i][col] = 1;
            ld[i - col + N - 1] =
            rd[i + col] = cl[i] = 1;
  
            // Recur to place rest of the queens
            if (solveNQUtil(board, col + 1))
                return true;
  
            // If placing queen in board[i][col]
            // doesn't lead to a solution, then
            // remove queen from board[i][col]
            board[i][col] = 0; // BACKTRACK
            ld[i - col + N - 1] =
            rd[i + col] = cl[i] = 0;
        }
    }
  
    // If the queen cannot be placed in any row in
    // this column col then return false
    return false;
}
 
// This function solves the N Queen problem using
// Backtracking. It mainly uses solveNQUtil() to
// solve the problem. It returns false if queens
// cannot be placed, otherwise, return true and
// prints placement of queens in the form of 1s.
// Please note that there may be more than one
// solutions, this function prints one of the
// feasible solutions.
function solveNQ()
{
    let board = [[ 0, 0, 0, 0 ],
                     [ 0, 0, 0, 0 ],
                     [ 0, 0, 0, 0 ],
                     [ 0, 0, 0, 0 ]];
  
    if (solveNQUtil(board, 0) == false)
    {
        document.write("Solution does not exist");
        return false;
    }
  
    printSolution(board);
    return true;
}
 
// Driver code
solveNQ();
 
// This code is contributed by sanjoy_62.
</script>


Output

 .  .  Q  . 
 Q  .  .  . 
 .  .  .  Q 
 .  Q  .  . 

Time Complexity: O(N!) 
Auxiliary Space: O(N)

Related Articles:

Please write comments if you find anything incorrect, or you want to share more information about the topic discussed above.
 


Feeling lost in the world of random DSA topics, wasting time without progress? It's time for a change! Join our DSA course, where we'll guide you on an exciting journey to master DSA efficiently and on schedule.
Ready to dive in? Explore our Free Demo Content and join our DSA course, trusted by over 100,000 geeks!

Last Updated : 03 Oct, 2023
Like Article
Save Article
Similar Reads
Complete Tutorials