mirror of
https://hub.njuu.cf/TheAlgorithms/C-Plus-Plus.git
synced 2023-10-11 13:05:55 +08:00
[fix/docs]: Update backtracking folder (#916)
* [fix/docs]: Update backtracking/graph_coloring.cpp * Add CMakeLists.txt in backtracking folder * Add backtracking to CMakeLists.txt * fix: Fix build issues * docs: Various documentation fixes * fix: minimax.cpp issues * fix: sudoku_solve.cpp fixes * formatting source-code for8ffbbb35ce* make he code neat and clean without global variables * fix 2 stars in comment * fix MSVC errors by forcing template parameter in function calls Note: This is identical to passing it as a function parameter, and may not be helpful * Update minimax.cpp * docs: minimax.cpp improvements * docs: Add Wikipedia link in minimax.cpp * fix: minimax.cpp vector fix * docs: fix Wikipedia link in minimax.cpp * docs: fix return statement in minimax.cpp * fix: sudoku_solve.cpp fixes * fix: more sudoku_solve.cpp fixes * fix: sudoku_solve.cpp fixes * fix: sudoku_solve.cpp * formatting source-code for13b5b9b829* docs: update graph_coloring.cpp description * fix: use array instead of vector (minimax.cpp) * feat: add namespace (minimax.cpp) * docs: update namespace description (graph_coloring.cpp) * fix: graph_coloring.cpp * fix: sudoku_solve.cpp fixes * fix: graph_coloring.cpp * fix: minimax.cpp * fix: more sudoku_solve.cpp fixes * fix: more graph_coloring.cpp fixes * fix: graph_coloring.cpp fixes * fix: sudoku_solve.cpp fixes * fix: minimax.cpp * fix: sudoku_solve.cpp fixes * fix: too few template arguments (std::array) * fix: too few template arguments (std::array, minimax.cpp) * fix: narrowing conversion from double to int (minimax.cpp) * fix: excess elements in struct initializer (graph_coloring.cpp) * fix: no matching function (graph_coloring.cpp) * fix: graph_coloring.cpp issues/errors * fix: knight_tour.cpp issues/errors * fix: sudoku_solve.cpp issues/errors * [fix/docs]: Various fixes in graph_coloring.cpp * fix: More graph_coloring.cpp fixes * docs: Add initial comment block (sudoku_solve.cpp) * fix: Add return statement (knight_tour.cpp) * fix: array fixes (graph_coloring.cpp) * docs: documentation improvements (sudoku_solve.cpp) * docs: documentation improvements (knight_tour.cpp) * docs: documentation improvements (sudoku_solve.cpp) * docs: documentation improvements (graph_coloring.cpp) * docs: Documentation improvements (graph_coloring.cpp) Thanks, @kvedala! * docs: Documentation improvements (sudoku_solve.cpp) * docs: Document function parameter (sudoku_solve.cpp) * docs: Documentation improvements (knight_tour.cpp) * docs: Add long description (graph_coloring.cpp) * docs: Add long description (minimax.cpp) * docs: Add long description (sudoku_solve.cpp) * docs: Documentation improvements (knight_tour.cpp) * docs: Documentation improvements (sudoku_solve.cpp) * docs: Documentation improvements (minimax.cpp) * docs: More documentation improvements (minimax.cpp) * docs: Documentation improvements (sudoku_solve.cpp) * fix: sudoku_solve.cpp improvements Co-authored-by: github-actions <${GITHUB_ACTOR}@users.noreply.github.com> Co-authored-by: Krishna Vedala <7001608+kvedala@users.noreply.github.com>
This commit is contained in:
David Leal
GitHub
parent
b36ce9a8c0
commit
25b39a34fa
@ -36,6 +36,7 @@ add_subdirectory(sorting)
|
||||
add_subdirectory(geometry)
|
||||
add_subdirectory(graphics)
|
||||
add_subdirectory(probability)
|
||||
add_subdirectory(backtracking)
|
||||
add_subdirectory(data_structures)
|
||||
add_subdirectory(machine_learning)
|
||||
add_subdirectory(numerical_methods)
|
||||
|
||||
18
backtracking/CMakeLists.txt
Normal file
18
backtracking/CMakeLists.txt
Normal file
@ -0,0 +1,18 @@
|
||||
# If necessary, use the RELATIVE flag, otherwise each source file may be listed
|
||||
# with full pathname. RELATIVE may makes it easier to extract an executable name
|
||||
# automatically.
|
||||
file( GLOB APP_SOURCES RELATIVE ${CMAKE_CURRENT_SOURCE_DIR} *.cpp )
|
||||
# file( GLOB APP_SOURCES ${CMAKE_SOURCE_DIR}/*.c )
|
||||
# AUX_SOURCE_DIRECTORY(${CMAKE_CURRENT_SOURCE_DIR} APP_SOURCES)
|
||||
foreach( testsourcefile ${APP_SOURCES} )
|
||||
# I used a simple string replace, to cut off .cpp.
|
||||
string( REPLACE ".cpp" "" testname ${testsourcefile} )
|
||||
add_executable( ${testname} ${testsourcefile} )
|
||||
|
||||
set_target_properties(${testname} PROPERTIES LINKER_LANGUAGE CXX)
|
||||
if(OpenMP_CXX_FOUND)
|
||||
target_link_libraries(${testname} OpenMP::OpenMP_CXX)
|
||||
endif()
|
||||
install(TARGETS ${testname} DESTINATION "bin/backtracking")
|
||||
|
||||
endforeach( testsourcefile ${APP_SOURCES} )
|
||||
@ -1,72 +1,117 @@
|
||||
#include <stdio.h>
|
||||
/**
|
||||
* @file
|
||||
* @brief prints the assigned colors
|
||||
* using [Graph Coloring](https://en.wikipedia.org/wiki/Graph_coloring) algorithm
|
||||
*
|
||||
* @details
|
||||
* In graph theory, graph coloring is a special case of graph labeling;
|
||||
* it is an assignment of labels traditionally called "colors" to elements of a graph subject to certain constraints.
|
||||
* In its simplest form, it is a way of coloring the vertices of a graph such that no two adjacent vertices are of the same color;
|
||||
* this is called a vertex coloring. Similarly, an edge coloring assigns
|
||||
* a color to each edge so that no two adjacent edges are of the same color,
|
||||
* and a face coloring of a planar graph assigns a color to each face or
|
||||
* region so that no two faces that share a boundary have the same color.
|
||||
*
|
||||
* @author [Anup Kumar Panwar](https://github.com/AnupKumarPanwar)
|
||||
* @author [David Leal](https://github.com/Panquesito7)
|
||||
*/
|
||||
#include <iostream>
|
||||
#include <array>
|
||||
#include <vector>
|
||||
|
||||
// Number of vertices in the graph
|
||||
#define V 4
|
||||
/**
|
||||
* @namespace
|
||||
* @brief Backtracking algorithms
|
||||
*/
|
||||
namespace backtracking {
|
||||
/** A utility function to print solution
|
||||
* @tparam V number of vertices in the graph
|
||||
* @param color array of colors assigned to the nodes
|
||||
*/
|
||||
template <size_t V>
|
||||
void printSolution(const std::array <int, V>& color) {
|
||||
std::cout << "Following are the assigned colors\n";
|
||||
for (auto &col : color) {
|
||||
std::cout << col;
|
||||
}
|
||||
std::cout << "\n";
|
||||
}
|
||||
|
||||
void printSolution(int color[]);
|
||||
|
||||
/* A utility function to check if the current color assignment
|
||||
is safe for vertex v */
|
||||
bool isSafe(int v, bool graph[V][V], int color[], int c) {
|
||||
for (int i = 0; i < V; i++)
|
||||
if (graph[v][i] && c == color[i])
|
||||
/** A utility function to check if the current color assignment is safe for
|
||||
* vertex v
|
||||
* @tparam V number of vertices in the graph
|
||||
* @param v index of graph vertex to check
|
||||
* @param graph matrix of graph nonnectivity
|
||||
* @param color vector of colors assigned to the graph nodes/vertices
|
||||
* @param c color value to check for the node `v`
|
||||
* @returns `true` if the color is safe to be assigned to the node
|
||||
* @returns `false` if the color is not safe to be assigned to the node
|
||||
*/
|
||||
template <size_t V>
|
||||
bool isSafe(int v, const std::array<std::array <int, V>, V>& graph, const std::array <int, V>& color, int c) {
|
||||
for (int i = 0; i < V; i++) {
|
||||
if (graph[v][i] && c == color[i]) {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
return true;
|
||||
}
|
||||
|
||||
/* A recursive utility function to solve m coloring problem */
|
||||
void graphColoring(bool graph[V][V], int m, int color[], int v) {
|
||||
/* base case: If all vertices are assigned a color then
|
||||
return true */
|
||||
/** A recursive utility function to solve m coloring problem
|
||||
* @tparam V number of vertices in the graph
|
||||
* @param graph matrix of graph nonnectivity
|
||||
* @param m number of colors
|
||||
* @param [in,out] color description // used in,out to notify in documentation
|
||||
* that this parameter gets modified by the function
|
||||
* @param v index of graph vertex to check
|
||||
*/
|
||||
template <size_t V>
|
||||
void graphColoring(const std::array<std::array <int, V>, V>& graph, int m, std::array <int, V> color, int v) {
|
||||
// base case:
|
||||
// If all vertices are assigned a color then return true
|
||||
if (v == V) {
|
||||
printSolution(color);
|
||||
backtracking::printSolution<V>(color);
|
||||
return;
|
||||
}
|
||||
|
||||
/* Consider this vertex v and try different colors */
|
||||
// Consider this vertex v and try different colors
|
||||
for (int c = 1; c <= m; c++) {
|
||||
/* Check if assignment of color c to v is fine*/
|
||||
if (isSafe(v, graph, color, c)) {
|
||||
// Check if assignment of color c to v is fine
|
||||
if (backtracking::isSafe<V>(v, graph, color, c)) {
|
||||
color[v] = c;
|
||||
|
||||
/* recur to assign colors to rest of the vertices */
|
||||
graphColoring(graph, m, color, v + 1);
|
||||
// recur to assign colors to rest of the vertices
|
||||
backtracking::graphColoring<V>(graph, m, color, v + 1);
|
||||
|
||||
/* If assigning color c doesn't lead to a solution
|
||||
then remove it */
|
||||
// If assigning color c doesn't lead to a solution then remove it
|
||||
color[v] = 0;
|
||||
}
|
||||
}
|
||||
}
|
||||
} // namespace backtracking
|
||||
|
||||
/* A utility function to print solution */
|
||||
void printSolution(int color[]) {
|
||||
printf(" Following are the assigned colors \n");
|
||||
for (int i = 0; i < V; i++) printf(" %d ", color[i]);
|
||||
printf("\n");
|
||||
}
|
||||
|
||||
// driver program to test above function
|
||||
int main() {
|
||||
/* Create following graph and test whether it is 3 colorable
|
||||
(3)---(2)
|
||||
| / |
|
||||
| / |
|
||||
| / |
|
||||
(0)---(1)
|
||||
/**
|
||||
* Main function
|
||||
*/
|
||||
bool graph[V][V] = {
|
||||
{0, 1, 1, 1},
|
||||
{1, 0, 1, 0},
|
||||
{1, 1, 0, 1},
|
||||
{1, 0, 1, 0},
|
||||
int main() {
|
||||
// Create following graph and test whether it is 3 colorable
|
||||
// (3)---(2)
|
||||
// | / |
|
||||
// | / |
|
||||
// | / |
|
||||
// (0)---(1)
|
||||
|
||||
const int V = 4; // number of vertices in the graph
|
||||
std::array <std::array <int, V>, V> graph = {
|
||||
std::array <int, V>({0, 1, 1, 1}),
|
||||
std::array <int, V>({1, 0, 1, 0}),
|
||||
std::array <int, V>({1, 1, 0, 1}),
|
||||
std::array <int, V>({1, 0, 1, 0})
|
||||
};
|
||||
|
||||
int m = 3; // Number of colors
|
||||
std::array <int, V> color{};
|
||||
|
||||
int color[V];
|
||||
|
||||
for (int i = 0; i < V; i++) color[i] = 0;
|
||||
|
||||
graphColoring(graph, m, color, 0);
|
||||
backtracking::graphColoring<V>(graph, m, color, 0);
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,60 +1,105 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief [Knight's tour](https://en.wikipedia.org/wiki/Knight%27s_tour) algorithm
|
||||
*
|
||||
* @details
|
||||
* A knight's tour is a sequence of moves of a knight on a chessboard
|
||||
* such that the knight visits every square only once. If the knight
|
||||
* ends on a square that is one knight's move from the beginning
|
||||
* square (so that it could tour the board again immediately, following
|
||||
* the same path, the tour is closed; otherwise, it is open.
|
||||
*
|
||||
* @author [Nikhil Arora](https://github.com/nikhilarora068)
|
||||
* @author [David Leal](https://github.com/Panquesito7)
|
||||
*/
|
||||
#include <iostream>
|
||||
#define n 8
|
||||
#include <array>
|
||||
|
||||
/**
|
||||
A knight's tour is a sequence of moves of a knight on a chessboard
|
||||
such that the knight visits every square only once. If the knight
|
||||
ends on a square that is one knight's move from the beginning
|
||||
square (so that it could tour the board again immediately, following
|
||||
the same path), the tour is closed; otherwise, it is open.
|
||||
**/
|
||||
|
||||
using std::cin;
|
||||
using std::cout;
|
||||
|
||||
bool issafe(int x, int y, int sol[n][n]) {
|
||||
return (x < n && x >= 0 && y < n && y >= 0 && sol[x][y] == -1);
|
||||
* @namespace backtracking
|
||||
* @brief Backtracking algorithms
|
||||
*/
|
||||
namespace backtracking {
|
||||
/**
|
||||
* A utility function to check if i,j are valid indexes for N*N chessboard
|
||||
* @tparam V number of vertices in array
|
||||
* @param x current index in rows
|
||||
* @param y current index in columns
|
||||
* @param sol matrix where numbers are saved
|
||||
* @returns `true` if ....
|
||||
* @returns `false` if ....
|
||||
*/
|
||||
template <size_t V>
|
||||
bool issafe(int x, int y, const std::array <std::array <int, V>, V>& sol) {
|
||||
return (x < V && x >= 0 && y < V && y >= 0 && sol[x][y] == -1);
|
||||
}
|
||||
bool solve(int x, int y, int mov, int sol[n][n], int xmov[n], int ymov[n]) {
|
||||
|
||||
/**
|
||||
* Knight's tour algorithm
|
||||
* @tparam V number of vertices in array
|
||||
* @param x current index in rows
|
||||
* @param y current index in columns
|
||||
* @param mov movement to be done
|
||||
* @param sol matrix where numbers are saved
|
||||
* @param xmov next move of knight (x coordinate)
|
||||
* @param ymov next move of knight (y coordinate)
|
||||
* @returns `true` if solution exists
|
||||
* @returns `false` if solution does not exist
|
||||
*/
|
||||
template <size_t V>
|
||||
bool solve(int x, int y, int mov, std::array <std::array <int, V>, V> &sol,
|
||||
const std::array <int, V> &xmov, std::array <int, V> &ymov) {
|
||||
int k, xnext, ynext;
|
||||
|
||||
if (mov == n * n)
|
||||
if (mov == V * V) {
|
||||
return true;
|
||||
}
|
||||
|
||||
for (k = 0; k < 8; k++) {
|
||||
for (k = 0; k < V; k++) {
|
||||
xnext = x + xmov[k];
|
||||
ynext = y + ymov[k];
|
||||
|
||||
if (issafe(xnext, ynext, sol)) {
|
||||
if (backtracking::issafe<V>(xnext, ynext, sol)) {
|
||||
sol[xnext][ynext] = mov;
|
||||
|
||||
if (solve(xnext, ynext, mov + 1, sol, xmov, ymov) == true)
|
||||
if (backtracking::solve<V>(xnext, ynext, mov + 1, sol, xmov, ymov) == true) {
|
||||
return true;
|
||||
else
|
||||
}
|
||||
else {
|
||||
sol[xnext][ynext] = -1;
|
||||
}
|
||||
}
|
||||
}
|
||||
return false;
|
||||
}
|
||||
} // namespace backtracking
|
||||
|
||||
/**
|
||||
* Main function
|
||||
*/
|
||||
int main() {
|
||||
// initialize();
|
||||
const int n = 8;
|
||||
std::array <std::array <int, n>, n> sol = { 0 };
|
||||
|
||||
int sol[n][n];
|
||||
int i, j;
|
||||
for (i = 0; i < n; i++)
|
||||
for (j = 0; j < n; j++) sol[i][j] = -1;
|
||||
for (i = 0; i < n; i++) {
|
||||
for (j = 0; j < n; j++) { sol[i][j] = -1; }
|
||||
}
|
||||
|
||||
std::array <int, n> xmov = { 2, 1, -1, -2, -2, -1, 1, 2 };
|
||||
std::array <int, n> ymov = { 1, 2, 2, 1, -1, -2, -2, -1 };
|
||||
|
||||
int xmov[8] = {2, 1, -1, -2, -2, -1, 1, 2};
|
||||
int ymov[8] = {1, 2, 2, 1, -1, -2, -2, -1};
|
||||
sol[0][0] = 0;
|
||||
|
||||
bool flag = solve(0, 0, 1, sol, xmov, ymov);
|
||||
if (flag == false)
|
||||
cout << "solution doesnot exist \n";
|
||||
bool flag = backtracking::solve<n>(0, 0, 1, sol, xmov, ymov);
|
||||
if (flag == false) {
|
||||
std::cout << "Error: Solution does not exist\n";
|
||||
}
|
||||
else {
|
||||
for (i = 0; i < n; i++) {
|
||||
for (j = 0; j < n; j++) cout << sol[i][j] << " ";
|
||||
cout << "\n";
|
||||
for (j = 0; j < n; j++) { std::cout << sol[i][j] << " "; }
|
||||
std::cout << "\n";
|
||||
}
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,27 +1,61 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief returns which is the longest/shortest number
|
||||
* using [minimax](https://en.wikipedia.org/wiki/Minimax) algorithm
|
||||
*
|
||||
* @details
|
||||
* Minimax (sometimes MinMax, MM or saddle point) is a decision rule used in
|
||||
* artificial intelligence, decision theory, game theory, statistics,
|
||||
* and philosophy for minimizing the possible loss for a worst case (maximum loss) scenario.
|
||||
* When dealing with gains, it is referred to as "maximin"—to maximize the minimum gain.
|
||||
* Originally formulated for two-player zero-sum game theory, covering both the cases where players take
|
||||
* alternate moves and those where they make simultaneous moves, it has also been extended to more
|
||||
* complex games and to general decision-making in the presence of uncertainty.
|
||||
*
|
||||
* @author [Gleison Batista](https://github.com/gleisonbs)
|
||||
* @author [David Leal](https://github.com/Panquesito7)
|
||||
*/
|
||||
#include <algorithm>
|
||||
#include <cmath>
|
||||
#include <iostream>
|
||||
#include <vector>
|
||||
#include <array>
|
||||
|
||||
using std::cout;
|
||||
using std::endl;
|
||||
using std::max;
|
||||
using std::min;
|
||||
using std::vector;
|
||||
|
||||
int minimax(int depth, int node_index, bool is_max, vector<int> scores,
|
||||
int height) {
|
||||
if (depth == height)
|
||||
/**
|
||||
* @namespace backtracking
|
||||
* @brief Backtracking algorithms
|
||||
*/
|
||||
namespace backtracking {
|
||||
/**
|
||||
* Check which number is the maximum/minimum in the array
|
||||
* @param depth current depth in game tree
|
||||
* @param node_index current index in array
|
||||
* @param is_max if current index is the longest number
|
||||
* @param scores saved numbers in array
|
||||
* @param height maximum height for game tree
|
||||
* @return maximum or minimum number
|
||||
*/
|
||||
template <size_t T>
|
||||
int minimax(int depth, int node_index, bool is_max,
|
||||
const std::array<int, T> &scores, double height) {
|
||||
if (depth == height) {
|
||||
return scores[node_index];
|
||||
}
|
||||
|
||||
int v1 = minimax(depth + 1, node_index * 2, !is_max, scores, height);
|
||||
int v2 = minimax(depth + 1, node_index * 2 + 1, !is_max, scores, height);
|
||||
|
||||
return is_max ? max(v1, v2) : min(v1, v2);
|
||||
return is_max ? std::max(v1, v2) : std::min(v1, v2);
|
||||
}
|
||||
} // namespace backtracking
|
||||
|
||||
/**
|
||||
* Main function
|
||||
*/
|
||||
int main() {
|
||||
vector<int> scores = {90, 23, 6, 33, 21, 65, 123, 34423};
|
||||
int height = log2(scores.size());
|
||||
std::array<int, 8> scores = {90, 23, 6, 33, 21, 65, 123, 34423};
|
||||
double height = log2(scores.size());
|
||||
|
||||
cout << "Optimal value: " << minimax(0, 0, true, scores, height) << endl;
|
||||
std::cout << "Optimal value: " << backtracking::minimax(0, 0, true, scores, height)
|
||||
<< std::endl;
|
||||
return 0;
|
||||
}
|
||||
|
||||
@ -1,9 +1,39 @@
|
||||
/**
|
||||
* @file
|
||||
* @brief [Sudoku Solver](https://en.wikipedia.org/wiki/Sudoku) algorithm.
|
||||
*
|
||||
* @details
|
||||
* Sudoku (数独, sūdoku, digit-single) (/suːˈdoʊkuː/, /-ˈdɒk-/, /sə-/, originally called
|
||||
* Number Place) is a logic-based, combinatorial number-placement puzzle.
|
||||
* In classic sudoku, the objective is to fill a 9×9 grid with digits so that each column,
|
||||
* each row, and each of the nine 3×3 subgrids that compose the grid (also called "boxes", "blocks", or "regions")
|
||||
* contain all of the digits from 1 to 9. The puzzle setter provides a
|
||||
* partially completed grid, which for a well-posed puzzle has a single solution.
|
||||
*
|
||||
* @author [DarthCoder3200](https://github.com/DarthCoder3200)
|
||||
* @author [David Leal](https://github.com/Panquesito7)
|
||||
*/
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
/// N=9;
|
||||
int n = 9;
|
||||
#include <array>
|
||||
|
||||
bool isPossible(int mat[][9], int i, int j, int no) {
|
||||
/**
|
||||
* @namespace backtracking
|
||||
* @brief Backtracking algorithms
|
||||
*/
|
||||
namespace backtracking {
|
||||
/**
|
||||
* Checks if it's possible to place a 'no'
|
||||
* @tparam V number of vertices in the array
|
||||
* @param mat matrix where numbers are saved
|
||||
* @param i current index in rows
|
||||
* @param j current index in columns
|
||||
* @param no number to be added in matrix
|
||||
* @param n number of times loop will run
|
||||
* @returns `true` if 'mat' is different from 'no'
|
||||
* @returns `false` if 'mat' equals to 'no'
|
||||
*/
|
||||
template <size_t V>
|
||||
bool isPossible(const std::array <std::array <int, V>, V> &mat, int i, int j, int no, int n) {
|
||||
/// Row or col nahin hona chahiye
|
||||
for (int x = 0; x < n; x++) {
|
||||
if (mat[x][j] == no || mat[i][x] == no) {
|
||||
@ -25,45 +55,63 @@ bool isPossible(int mat[][9], int i, int j, int no) {
|
||||
|
||||
return true;
|
||||
}
|
||||
void printMat(int mat[][9]) {
|
||||
/**
|
||||
* Utility function to print matrix
|
||||
* @tparam V number of vertices in array
|
||||
* @param mat matrix where numbers are saved
|
||||
* @param n number of times loop will run
|
||||
* @return void
|
||||
*/
|
||||
template <size_t V>
|
||||
void printMat(const std::array <std::array <int, V>, V> &mat, int n) {
|
||||
for (int i = 0; i < n; i++) {
|
||||
for (int j = 0; j < n; j++) {
|
||||
cout << mat[i][j] << " ";
|
||||
std::cout << mat[i][j] << " ";
|
||||
if ((j + 1) % 3 == 0) {
|
||||
cout << '\t';
|
||||
std::cout << '\t';
|
||||
}
|
||||
}
|
||||
if ((i + 1) % 3 == 0) {
|
||||
cout << endl;
|
||||
std::cout << std::endl;
|
||||
}
|
||||
cout << endl;
|
||||
std::cout << std::endl;
|
||||
}
|
||||
}
|
||||
|
||||
bool solveSudoku(int mat[][9], int i, int j) {
|
||||
/**
|
||||
* Sudoku algorithm
|
||||
* @tparam V number of vertices in array
|
||||
* @param mat matrix where numbers are saved
|
||||
* @param i current index in rows
|
||||
* @param j current index in columns
|
||||
* @returns `true` if 'no' was placed
|
||||
* @returns `false` if 'no' was not placed
|
||||
*/
|
||||
template <size_t V>
|
||||
bool solveSudoku(std::array <std::array <int, V>, V> &mat, int i, int j) {
|
||||
/// Base Case
|
||||
if (i == 9) {
|
||||
/// Solve kr chuke hain for 9 rows already
|
||||
printMat(mat);
|
||||
backtracking::printMat<V>(mat, 9);
|
||||
return true;
|
||||
}
|
||||
|
||||
/// Crossed the last Cell in the row
|
||||
if (j == 9) {
|
||||
return solveSudoku(mat, i + 1, 0);
|
||||
return backtracking::solveSudoku<V>(mat, i + 1, 0);
|
||||
}
|
||||
|
||||
/// Blue Cell - Skip
|
||||
if (mat[i][j] != 0) {
|
||||
return solveSudoku(mat, i, j + 1);
|
||||
return backtracking::solveSudoku<V>(mat, i, j + 1);
|
||||
}
|
||||
/// White Cell
|
||||
/// Try to place every possible no
|
||||
for (int no = 1; no <= 9; no++) {
|
||||
if (isPossible(mat, i, j, no)) {
|
||||
if (backtracking::isPossible<V>(mat, i, j, no, 9)) {
|
||||
/// Place the no - assuming solution aa jayega
|
||||
mat[i][j] = no;
|
||||
bool aageKiSolveHui = solveSudoku(mat, i, j + 1);
|
||||
bool aageKiSolveHui = backtracking::solveSudoku<V>(mat, i, j + 1);
|
||||
if (aageKiSolveHui) {
|
||||
return true;
|
||||
}
|
||||
@ -75,17 +123,28 @@ bool solveSudoku(int mat[][9], int i, int j) {
|
||||
mat[i][j] = 0;
|
||||
return false;
|
||||
}
|
||||
} // namespace backtracking
|
||||
|
||||
/**
|
||||
* Main function
|
||||
*/
|
||||
int main() {
|
||||
int mat[9][9] = {{5, 3, 0, 0, 7, 0, 0, 0, 0}, {6, 0, 0, 1, 9, 5, 0, 0, 0},
|
||||
{0, 9, 8, 0, 0, 0, 0, 6, 0}, {8, 0, 0, 0, 6, 0, 0, 0, 3},
|
||||
{4, 0, 0, 8, 0, 3, 0, 0, 1}, {7, 0, 0, 0, 2, 0, 0, 0, 6},
|
||||
{0, 6, 0, 0, 0, 0, 2, 8, 0}, {0, 0, 0, 4, 1, 9, 0, 0, 5},
|
||||
{0, 0, 0, 0, 8, 0, 0, 7, 9}};
|
||||
const int V = 9;
|
||||
std::array <std::array <int, V>, V> mat = {
|
||||
std::array <int, V> {5, 3, 0, 0, 7, 0, 0, 0, 0},
|
||||
std::array <int, V> {6, 0, 0, 1, 9, 5, 0, 0, 0},
|
||||
std::array <int, V> {0, 9, 8, 0, 0, 0, 0, 6, 0},
|
||||
std::array <int, V> {8, 0, 0, 0, 6, 0, 0, 0, 3},
|
||||
std::array <int, V> {4, 0, 0, 8, 0, 3, 0, 0, 1},
|
||||
std::array <int, V> {7, 0, 0, 0, 2, 0, 0, 0, 6},
|
||||
std::array <int, V> {0, 6, 0, 0, 0, 0, 2, 8, 0},
|
||||
std::array <int, V> {0, 0, 0, 4, 1, 9, 0, 0, 5},
|
||||
std::array <int, V> {0, 0, 0, 0, 8, 0, 0, 7, 9}
|
||||
};
|
||||
|
||||
printMat(mat);
|
||||
cout << "Solution " << endl;
|
||||
solveSudoku(mat, 0, 0);
|
||||
backtracking::printMat<V>(mat, 9);
|
||||
std::cout << "Solution " << std::endl;
|
||||
backtracking::solveSudoku<V>(mat, 0, 0);
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
Loading…
Reference in New Issue
Block a user