Backtrack Problems

Competitive Coding/Backtrack/Sudoku.cpp

@@ -0,0 +1,132 @@
+// A Backtracking program  in C++ to solve Sudoku problem
+#include <stdio.h>
+
+// UNASSIGNED is used for empty cells in sudoku grid
+#define UNASSIGNED 0
+
+// N is used for size of Sudoku grid. Size will be NxN
+#define N 9
+
+// This function finds an entry in grid that is still unassigned
+bool FindUnassignedLocation(int grid[N][N], int &row, int &col);
+
+// Checks whether it will be legal to assign num to the given row,col
+bool isSafe(int grid[N][N], int row, int col, int num);
+
+/* Takes a partially filled-in grid and attempts to assign values to
+  all unassigned locations in such a way to meet the requirements
+  for Sudoku solution (non-duplication across rows, columns, and boxes) */
+bool SolveSudoku(int grid[N][N])
+{
+    int row, col;
+
+    // If there is no unassigned location, we are done
+    if (!FindUnassignedLocation(grid, row, col))
+       return true; // success!
+
+    // consider digits 1 to 9
+    for (int num = 1; num <= 9; num++)
+    {
+        // if looks promising
+        if (isSafe(grid, row, col, num))
+        {
+            // make tentative assignment
+            grid[row][col] = num;
+
+            // return, if success, yay!
+            if (SolveSudoku(grid))
+                return true;
+
+            // failure, unmake & try again
+            grid[row][col] = UNASSIGNED;
+        }
+    }
+    return false; // this triggers backtracking
+}
+
+/* Searches the grid to find an entry that is still unassigned. If
+   found, the reference parameters row, col will be set the location
+   that is unassigned, and true is returned. If no unassigned entries
+   remain, false is returned. */
+bool FindUnassignedLocation(int grid[N][N], int &row, int &col)
+{
+    for (row = 0; row < N; row++)
+        for (col = 0; col < N; col++)
+            if (grid[row][col] == UNASSIGNED)
+                return true;
+    return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+   in the specified row matches the given number. */
+bool UsedInRow(int grid[N][N], int row, int num)
+{
+    for (int col = 0; col < N; col++)
+        if (grid[row][col] == num)
+            return true;
+    return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+   in the specified column matches the given number. */
+bool UsedInCol(int grid[N][N], int col, int num)
+{
+    for (int row = 0; row < N; row++)
+        if (grid[row][col] == num)
+            return true;
+    return false;
+}
+
+/* Returns a boolean which indicates whether any assigned entry
+   within the specified 3x3 box matches the given number. */
+bool UsedInBox(int grid[N][N], int boxStartRow, int boxStartCol, int num)
+{
+    for (int row = 0; row < 3; row++)
+        for (int col = 0; col < 3; col++)
+            if (grid[row+boxStartRow][col+boxStartCol] == num)
+                return true;
+    return false;
+}
+
+/* Returns a boolean which indicates whether it will be legal to assign
+   num to the given row,col location. */
+bool isSafe(int grid[N][N], int row, int col, int num)
+{
+    /* Check if 'num' is not already placed in current row,
+       current column and current 3x3 box */
+    return !UsedInRow(grid, row, num) &&
+           !UsedInCol(grid, col, num) &&
+           !UsedInBox(grid, row - row%3 , col - col%3, num);
+}
+
+/* A utility function to print grid  */
+void printGrid(int grid[N][N])
+{
+    for (int row = 0; row < N; row++)
+    {
+       for (int col = 0; col < N; col++)
+             printf("%2d", grid[row][col]);
+        printf("\n");
+    }
+}
+
+/* Driver Program to test above functions */
+int main()
+{
+    // 0 means unassigned cells
+    int grid[N][N] = {{3, 0, 6, 5, 0, 8, 4, 0, 0},
+                      {5, 2, 0, 0, 0, 0, 0, 0, 0},
+                      {0, 8, 7, 0, 0, 0, 0, 3, 1},
+                      {0, 0, 3, 0, 1, 0, 0, 8, 0},
+                      {9, 0, 0, 8, 6, 3, 0, 0, 5},
+                      {0, 5, 0, 0, 9, 0, 6, 0, 0},
+                      {1, 3, 0, 0, 0, 0, 2, 5, 0},
+                      {0, 0, 0, 0, 0, 0, 0, 7, 4},
+                      {0, 0, 5, 2, 0, 6, 3, 0, 0}};
+    if (SolveSudoku(grid) == true)
+          printGrid(grid);
+    else
+         printf("No solution exists");
+
+    return 0;
+}

Competitive Coding/Backtrack/nQueen.cpp

@@ -0,0 +1,104 @@
+/* C/C++ program to solve N Queen Problem using backtracking */
+#define N 4
+#include<stdio.h>
+
+/* A utility function to print solution */
+void printSolution(int board[N][N])
+{
+    for (int i = 0; i < N; i++)
+    {
+        for (int j = 0; j < N; j++)
+            printf(" %d ", board[i][j]);
+        printf("\n");
+    }
+}
+
+/* A utility function to check if a queen can
+   be placed on board[row][col]. Note that this
+   function is called when "col" queens are
+   already placed in columns from 0 to col -1.
+   So we need to check only left side for
+   attacking queens */
+bool isSafe(int board[N][N], int row, int col)
+{
+    int i, j;
+
+    /* 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;
+}
+
+/* A recursive utility function to solve N Queen problem */
+bool solveNQUtil(int board[N][N], int col)
+{
+    /* base case: If all queens are placed then return true */
+    if (col >= N)
+        return true;
+
+    /* 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(board, i, col) )
+        {
+            /* Place this queen in board[i][col] */
+            board[i][col] = 1;
+
+            /* recur to place rest of the queens */
+            if ( solveNQUtil(board, col + 1) )
+                return true;
+
+            /* If placing queen in board[i][col] doesn't lead to a solution, then remove queen from board[i][col] */
+            board[i][col] = 0; // BACKTRACK
+        }
+    }
+
+     /* If queen can not be place in any row in this colum col  then return false */
+    return false;
+}
+
+/* This function solves the N Queen problem using
+   Backtracking. It mainly uses solveNQUtil() to
+   solve the problem. It returns false if queens
+   cannot be placed, otherwise return true and
+   prints placement of queens in the form of 1s.
+   Please note that there may be more than one
+   solutions, this function prints one  of the
+   feasible solutions.*/
+bool solveNQ()
+{
+    int board[N][N] = { {0, 0, 0, 0},
+        {0, 0, 0, 0},
+        {0, 0, 0, 0},
+        {0, 0, 0, 0}
+    };
+
+    if ( solveNQUtil(board, 0) == false )
+    {
+      printf("Solution does not exist");
+      return false;
+    }
+
+    printSolution(board);
+    return true;
+}
+
+// driver program to test above function
+int main()
+{
+    solveNQ();
+    return 0;
+}