GeeksforGeeks App
Open App
Browser
Continue

# 8 queen problem

The eight queens problem is the problem of placing eight queens on an 8×8 chessboard such that none of them attack one another (no two are in the same row, column, or diagonal). More generally, the n queens problem places n queens on an n×n chessboard. There are different solutions for the problem. Backtracking | Set 3 (N Queen Problem) Branch and Bound | Set 5 (N Queen Problem) You can find detailed solutions at http://en.literateprograms.org/Eight_queens_puzzle_(C)

Explanation:

• This pseudocode uses a backtracking algorithm to find a solution to the 8 Queen problem, which consists of placing 8 queens on a chessboard in such a way that no two queens threaten each other.
• The algorithm starts by placing a queen on the first column, then it proceeds to the next column and places a queen in the first safe row of that column.
• If the algorithm reaches the 8th column and all queens are placed in a safe position, it prints the board and returns true.
If the algorithm is unable to place a queen in a safe position in a certain column, it backtracks to the previous column and tries a different row.
• The “isSafe” function checks if it is safe to place a queen on a certain row and column by checking if there are any queens in the same row, diagonal or anti-diagonal.
• It’s worth to notice that this is just a high-level pseudocode and it might need to be adapted depending on the specific implementation and language you are using.

Here is an example of pseudocode for solving the 8 Queen problem using backtracking:

## C++

 `#include ``#include ` `using` `namespace` `std;` `const` `int` `N = 8;` `bool` `isSafe(vector >& board, ``int` `row, ``int` `col)``{``    ``for` `(``int` `x = 0; x < col; x++)``        ``if` `(board[row][x] == 1)``            ``return` `false``;``    ``for` `(``int` `x = row, y = col; x >= 0 && y >= 0; x--, y--)``        ``if` `(board[x][y] == 1)``            ``return` `false``;``    ``for` `(``int` `x = row, y = col; x < N && y >= 0; x++, y--)``        ``if` `(board[x][y] == 1)``            ``return` `false``;``    ``return` `true``;``}` `bool` `solveNQueens(vector >& board, ``int` `col)``{``    ``if` `(col == N) {``        ``for` `(``int` `i = 0; i < N; i++) {``            ``for` `(``int` `j = 0; j < N; j++)``                ``cout << board[i][j] << ``" "``;``            ``cout << endl;``        ``}``        ``cout << endl;``        ``return` `true``;``    ``}``    ``for` `(``int` `i = 0; i < N; i++) {``        ``if` `(isSafe(board, i, col)) {``            ``board[i][col] = 1;``            ``if` `(solveNQueens(board, col + 1))``                ``return` `true``;``            ``board[i][col] = 0;``        ``}``    ``}``    ``return` `false``;``}` `int` `main()``{``    ``vector > board(N, vector<``int``>(N, 0));``    ``if` `(!solveNQueens(board, 0))``        ``cout << ``"No solution found"``;``    ``return` `0;``}`

## Java

 `import` `java.util.Arrays;``class` `GFG {` `    ``static` `final` `int` `N = ``8``;` `    ``// function to check if it is safe to place``    ``// a queen at a particular position``    ``static` `boolean` `isSafe(``int``[][] board, ``int` `row, ``int` `col)``    ``{` `        ``// check if there is a queen in the same row to the``        ``// left``        ``for` `(``int` `x = ``0``; x < col; x++)``            ``if` `(board[row][x] == ``1``)``                ``return` `false``;` `        ``// check if there is a queen in the upper left``        ``// diagonal``        ``for` `(``int` `x = row, y = col; x >= ``0` `&& y >= ``0``;``             ``x--, y--)``            ``if` `(board[x][y] == ``1``)``                ``return` `false``;` `        ``// check if there is a queen in the lower left``        ``// diagonal``        ``for` `(``int` `x = row, y = col; x < N && y >= ``0``;``             ``x++, y--)``            ``if` `(board[x][y] == ``1``)``                ``return` `false``;` `        ``// if there is no queen in any of the above``        ``// positions, then it is safe to place a queen``        ``return` `true``;``    ``}` `    ``// function to solve the N-queens problem using``    ``// backtracking``    ``static` `boolean` `solveNQueens(``int``[][] board, ``int` `col)``    ``{` `        ``// if all queens are placed, print the board``        ``if` `(col == N) {``            ``for` `(``int``[] row : board)``                ``System.out.println(Arrays.toString(row));``            ``System.out.println();``            ``return` `true``;``        ``}` `        ``// try placing a queen in each row of the current``        ``// column``        ``for` `(``int` `i = ``0``; i < N; i++) {``            ``if` `(isSafe(board, i, col)) {``                ``board[i][col] = ``1``; ``// place the queen``                ``if` `(solveNQueens(board, col + ``1``))``                    ``return` `true``;` `                ``// backtrack if placing the queen doesn't``                ``// lead to a solution``                ``board[i][col] = ``0``;``            ``}``        ``}` `        ``// if no solution is found, return false``        ``return` `false``;``    ``}` `    ``// initialize the board with zeros and call the``    ``// solveNQueens function to solve the problem``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int``[][] board = ``new` `int``[N][N];``        ``if` `(!solveNQueens(board, ``0``))``            ``System.out.println(``"No solution found"``);``    ``}``}`

## Python3

 `N ``=` `8` `# (size of the chessboard)` `def` `solveNQueens(board, col):``    ``if` `col ``=``=` `N:``        ``print``(board)``        ``return` `True``    ``for` `i ``in` `range``(N):``        ``if` `isSafe(board, i, col):``            ``board[i][col] ``=` `1``            ``if` `solveNQueens(board, col ``+` `1``):``                ``return` `True``            ``board[i][col] ``=` `0``    ``return` `False` `def` `isSafe(board, row, col):``    ``for` `x ``in` `range``(col):``        ``if` `board[row][x] ``=``=` `1``:``            ``return` `False``    ``for` `x, y ``in` `zip``(``range``(row, ``-``1``, ``-``1``), ``range``(col, ``-``1``, ``-``1``)):``        ``if` `board[x][y] ``=``=` `1``:``            ``return` `False``    ``for` `x, y ``in` `zip``(``range``(row, N, ``1``), ``range``(col, ``-``1``, ``-``1``)):``        ``if` `board[x][y] ``=``=` `1``:``            ``return` `False``    ``return` `True` `board ``=` `[[``0` `for` `x ``in` `range``(N)] ``for` `y ``in` `range``(N)]``if` `not` `solveNQueens(board, ``0``):``    ``print``(``"No solution found"``)`

## C#

 `using` `System;``using` `System.Linq;` `class` `GFG {` `  ``static` `readonly` `int` `N = 8;` `  ``// function to check if it is safe to place``  ``// a queen at a particular position``  ``static` `bool` `isSafe(``int``[,] board, ``int` `row, ``int` `col)``  ``{` `    ``// check if there is a queen in the same row to the``    ``// left``    ``for` `(``int` `x = 0; x < col; x++)``      ``if` `(board[row, x] == 1)``        ``return` `false``;` `    ``// check if there is a queen in the upper left``    ``// diagonal``    ``for` `(``int` `x = row, y = col; x >= 0 && y >= 0;``         ``x--, y--)``      ``if` `(board[x, y] == 1)``        ``return` `false``;` `    ``// check if there is a queen in the lower left``    ``// diagonal``    ``for` `(``int` `x = row, y = col; x < N && y >= 0;``         ``x++, y--)``      ``if` `(board[x, y] == 1)``        ``return` `false``;` `    ``// if there is no queen in any of the above``    ``// positions, then it is safe to place a queen``    ``return` `true``;``  ``}` `  ``// function to solve the N-queens problem using``  ``// backtracking``  ``static` `bool` `solveNQueens(``int``[,] board, ``int` `col)``  ``{` `    ``// if all queens are placed, print the board``    ``if` `(col == N) {``      ``for` `(``int` `i = 0; i < N; i++) {``        ``for` `(``int` `j = 0; j < N; j++) {``          ``Console.Write(board[i, j] + ``" "``);``        ``}``        ``Console.WriteLine();``      ``}``      ``Console.WriteLine();``      ``return` `true``;``    ``}` `    ``// try placing a queen in each row of the current``    ``// column``    ``for` `(``int` `i = 0; i < N; i++) {``      ``if` `(isSafe(board, i, col)) {``        ``board[i, col] = 1; ``// place the queen``        ``if` `(solveNQueens(board, col + 1))``          ``return` `true``;` `        ``// backtrack if placing the queen doesn't``        ``// lead to a solution``        ``board[i, col] = 0;``      ``}``    ``}` `    ``// if no solution is found, return false``    ``return` `false``;``  ``}` `  ``// initialize the board with zeros and call the``  ``// solveNQueens function to solve the problem``  ``public` `static` `void` `Main(``string``[] args)``  ``{``    ``int``[,] board = ``new` `int``[N, N];``    ``if` `(!solveNQueens(board, 0))``      ``Console.WriteLine(``"No solution found"``);``  ``}``}`

## Javascript

 `const N = 8;` `// function to check if it is safe to place a queen at a particular position``function` `isSafe(board, row, col) {``  ``// check if there is a queen in the same row to the left``  ``for` `(let x = 0; x < col; x++) {``    ``if` `(board[row][x] == 1) {``      ``return` `false``;``    ``}``  ``}` `  ``// check if there is a queen in the upper left diagonal``  ``for` `(let x = row, y = col; x >= 0 && y >= 0; x--, y--) {``    ``if` `(board[x][y] == 1) {``      ``return` `false``;``    ``}``  ``}` `  ``// check if there is a queen in the lower left diagonal``  ``for` `(let x = row, y = col; x < N && y >= 0; x++, y--) {``    ``if` `(board[x][y] == 1) {``      ``return` `false``;``    ``}``  ``}` `  ``// if there is no queen in any of the above positions, then it is safe to place a queen``  ``return` `true``;``}` `// function to solve the N-queens problem using backtracking``function` `solveNQueens(board, col) {``  ``// if all queens are placed, print the board``  ``if` `(col == N) {``    ``for` `(let i = 0; i < N; i++) {``      ``console.log(board[i].join(``" "``));``    ``}``    ``console.log(``"\n"``);``    ``return` `true``;``  ``}` `  ``// try placing a queen in each row of the current column``  ``for` `(let i = 0; i < N; i++) {``    ``if` `(isSafe(board, i, col)) {``      ``board[i][col] = 1; ``// place the queen``      ``if` `(solveNQueens(board, col + 1)) {``        ``return` `true``;``      ``}``      ``board[i][col] = 0; ``// backtrack if placing the queen doesn't lead to a solution``    ``}``  ``}` `  ``// if no solution is found, return false``  ``return` `false``;``}` `// initialize the board with zeros and call the solveNQueens function to solve the problem``let board = Array(N)``  ``.fill()``  ``.map(() => Array(N).fill(0));` `if` `(!solveNQueens(board, 0)) {``  ``console.log(``"No solution found"``);``}`

Output

`[[1, 0, 0, 0, 0, 0, 0, 0], [0, 0, 0, 0, 0, 0, 1, 0], [0, 0, 0, 0, 1, 0, 0, 0], [0, 0, 0, 0, 0, 0, 0, 1], [0, 1, 0, 0, 0, 0, 0, 0], [0, 0, 0, 1, 0, 0, 0, 0], [0, 0, 0, 0, 0, 1, 0, 0], [0, 0, 1, 0, 0, 0, 0, 0]]`

Time Complexity : O((m + q) log^2 n)
Space Complexity : O((m + q) log n)

My Personal Notes arrow_drop_up