n_queens.cpp File Reference

Eight Queens puzzle More...

`#include <iostream>`
`#include <array>`
Include dependency graph for n_queens.cpp:

## Namespaces

| backtracking
| Backtracking algorithms.
| n_queens
| Functions for Eight Queens puzzle.

## Functions

template<size_t n>
void | backtracking::n_queens::printSolution (const std::array< std::array< int, n >, n > &board)
template<size_t n>
bool | backtracking::n_queens::isSafe (const std::array< std::array< int, n >, n > &board, const int &row, const int &col)
template<size_t n>
void | backtracking::n_queens::solveNQ (std::array< std::array< int, n >, n > board, const int &col)
int | main ()

## Detailed Description

Eight Queens puzzle

The eight queens puzzle is the problem of placing eight chess queens on an 8×8 chessboard so that no two queens threaten each other; thus, a solution requires that no two queens share the same row, column, or diagonal. The eight queens puzzle is an example of the more general n queens problem of placing n non-attacking queens on an n×n chessboard, for which solutions exist for all natural numbers n with the exception of n = 2 and n = 3.

Author
  Unknown author
  David Leal

## Function Documentation

## isSafe()

template<size_t n>

bool backtracking::n_queens::isSafe | ( | const std::array< std::array< int, n >, n > & | board,
|  | const int & | row,
|  | const int & | col
| ) |  |

Check if a queen can be placed on matrix

Template Parameters

  n | number of matrix size

Parameters

  board | matrix where numbers are saved
  row | current index in rows
  col | current index in columns

Returns
  `true` if queen can be placed on matrix
  `false` if queen can't be placed on matrix

{
int i = 0, j = 0;
// 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;
}

## main()

int main | ( | void |  | ) |

Main function

{
const int n = 4;
std::array<std::array<int, n>, n> board = {
std::array<int, n>({0, 0, 0, 0}),
std::array<int, n>({0, 0, 0, 0}),
std::array<int, n>({0, 0, 0, 0}),
std::array<int, n>({0, 0, 0, 0})
};
backtracking::n_queens::solveNQ<n>(board, 0);
return 0;
}
std::array

## printSolution()

template<size_t n>

void backtracking::n_queens::printSolution | ( | const std::array< std::array< int, n >, n > & | board | ) |

Utility function to print matrix

Template Parameters

  n | number of matrix size

Parameters

  board | matrix where numbers are saved

{
std::cout << "\n";
for (int i = 0; i < n; i++) {
for (int j = 0; j < n; j++) {
std::cout << "" << board[i][j] << " ";
}
std::cout << "\n";
}
}
std::cout

## solveNQ()

template<size_t n>

void backtracking::n_queens::solveNQ | ( | std::array< std::array< int, n >, n > | board,
|  | const int & | col
| ) |  |

Solve n queens problem

Template Parameters

  n | number of matrix size

Parameters

  board | matrix where numbers are saved
  col | current index in columns

{
if (col >= n) {
printSolution<n>(board);
return;
}
// Consider this column and try placing
// this queen in all rows one by one
for (int i = 0; i < n; i++) {
// Check if queen can be placed
// on board[i][col]
if (isSafe<n>(board, i, col)) {
// Place this queen in matrix
board[i][col] = 1;
// Recursive to place rest of the queens
solveNQ<n>(board, col + 1);
board[i][col] = 0; // backtrack
}
}
}
Here is the call graph for this function: