[fix/docs]: Improve backtracking/n_queens.cpp

backtracking/n_queens.cpp

@@ -1,63 +1,123 @@
+/**
+ * @file n_queens.cpp
+ * @brief [Eight Queens](https://en.wikipedia.org/wiki/Eight_queens_puzzle)
+ * puzzle
+ *
+ * @details
+ * 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
+ * @author [David Leal](https://github.com/Panquesito7)
+ *
+ */
 #include <iostream>
-#define N 4
+#include <array>
-using namespace std;
 
-void printSolution(int board[N][N]) {
+/**
-    cout << "\n";
+ * @namespace backtracking
-    for (int i = 0; i < N; i++) {
+ * @brief Backtracking algorithms
-        for (int j = 0; j < N; j++) cout << "" << board[i][j];
+ */
-        cout << "\n";
+namespace backtracking {
+/**
+ * Utility function to print matrix
+ * @tparam n number of matrix size
+ * @param board matrix where numbers are saved
+ */
+template <size_t n>
+void printSolution(const std::array<std::array<int, n>, n> &board) {
+  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";
+  }
 }
 
-bool isSafe(int board[N][N], int row, int col) {
+/**
-    int i, j;
+ * Check if a queen can be placed on matrix
+ * @tparam n number of matrix size
+ * @param board matrix where numbers are saved
+ * @param row current index in rows
+ * @param col current index in columns
+ * @returns `true` if queen can be placed on matrix
+ * @returns `false` if queen can't be placed on matrix
+ */
+template <size_t n>
+bool isSafe(const std::array<std::array<int, n>, n> &board, const int &row,
+            const int &col) {
+  int i = 0, j = 0;
 
-    /* Check this row on left side */
+  // Check this row on left side
-    for (i = 0; i < col; i++)
+  for (i = 0; i < col; i++) {
-        if (board[row][i])
+    if (board[row][i]) {
-            return false;
+      return false;
+    }
+  }
 
-    /* Check upper diagonal on left side */
+  // Check upper diagonal on left side
-    for (i = row, j = col; i >= 0 && j >= 0; i--, j--)
+  for (i = row, j = col; i >= 0 && j >= 0; i--, j--) {
-        if (board[i][j])
+    if (board[i][j]) {
-            return false;
+      return false;
-
+    }
-    /* Check lower diagonal on left side */
+  }
-    for (i = row, j = col; j >= 0 && i < N; i++, j--)
+  // Check lower diagonal on left side
-        if (board[i][j])
+  for (i = row, j = col; j >= 0 && i < n; i++, j--) {
-            return false;
+    if (board[i][j]) {
-
+      return false;
-    return true;
+    }
+  }
+  return true;
 }
 
-void solveNQ(int board[N][N], int col) {
+/**
-    if (col >= N) {
+ * Solve n queens problem
-        printSolution(board);
+ * @tparam n number of matrix size
-        return;
+ * @param board matrix where numbers are saved
-    }
+ * @param col current index in columns
-
+ */
-    /* Consider this column and try placing
+template <size_t n>
-       this queen in all rows one by one */
+void solveNQ(std::array<std::array<int, n>, n> board, const int &col) {
-    for (int i = 0; i < N; i++) {
+  if (col >= n) {
-        /* Check if queen can be placed on
+    printSolution<n>(board);
-          board[i][col] */
+    return;
-        if (isSafe(board, i, col)) {
+  }
-            /* Place this queen in board[i][col] */
+
-            //            cout<<"\n"<<col<<"can place"<<i;
+  // Consider this column and try placing
-            board[i][col] = 1;
+  // this queen in all rows one by one
-
+  for (int i = 0; i < n; i++) {
-            /* recur to place rest of the queens */
+    // Check if queen can be placed
-            solveNQ(board, col + 1);
+    // on board[i][col]
-
+    if (isSafe<n>(board, i, col)) {
-            board[i][col] = 0;  // BACKTRACK
+      // Place this queen in matrix
-        }
+      board[i][col] = 1;
+
+      // Recur to place rest of the queens
+      solveNQ<n>(board, col + 1);
+
+      board[i][col] = 0; // backtrack
     }
+  }
 }
+} // namespace backtracking
 
+/**
+ * Main function
+ */
 int main() {
-    int board[N][N] = {{0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}, {0, 0, 0, 0}};
+  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})
+    };
 
-    solveNQ(board, 0);
+  backtracking::solveNQ<n>(board, 0);
-    return 0;
+  return 0;
 }