n_queens.cpp File Reference

Eight Queens puzzle More...

#include <iostream>
#include <array>

Include dependency graph for n_queens.cpp:

Namespaces
namespace	backtracking
	Backtracking algorithms.
namespace	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;
}

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";
      }
    }

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: