Merge pull request matthewsamuel95#1 from nonejk/backtracking

Added Backtracking algorithms

Author: ssumukh

BackTracking/KnightsTour/knightstour.cpp

@@ -0,0 +1,100 @@
+#include <iostream>
+#define N 8
+using namespace std;
+
+// defines a structure for chess moves
+typedef struct chess_moves {
+   // 'x' and 'y' coordinates on chess board
+   int x,y;
+}chess_moves;
+
+// displays the knight tour solution
+void printTour(int tour[N][N]) {
+   int i,j;
+   for (i = 0; i < N; i++) {
+      for (j = 0; j < N; j++) {
+          cout<<tour[i][j]<<"\t";
+      }
+      cout<<endl;
+   }
+}
+
+// check if the next move (as per knight's constraints) is possible
+bool isMovePossible(chess_moves next_move, int tour[N][N]) {
+   int i = next_move.x;
+   int j = next_move.y;
+   if ((i >= 0 && i < N) && (j >= 0 && j < N) && (tour[i][j] == 0))
+      return true;
+   return false;
+}
+
+
+// recursive function to find a knight tour
+bool findTour(int tour[N][N], chess_moves move_KT[],
+               chess_moves curr_move, int move_count) {
+   int i;
+   chess_moves next_move;
+   if (move_count == N*N-1) {
+      // Knight tour is completed i.e all cells on the
+      // chess board has been visited by knight once 
+      return true;
+   }
+
+   // try out the possible moves starting from the current coordinate
+   for (i = 0; i < N; i++) {
+      // get the next move
+      next_move.x = curr_move.x + move_KT[i].x;
+      next_move.y = curr_move.y + move_KT[i].y;
+
+      if (isMovePossible(next_move, tour)) {
+         // if the move is possible
+         // increment the move count and store it in tour matrix
+         tour[next_move.x][next_move.y] = move_count+1;
+         if (findTour(tour, move_KT, next_move, move_count+1) == true) {
+            return true;
+         }
+         else {
+            // this move was invalid, try out other possiblities 
+            tour[next_move.x][next_move.y] = 0;
+         }
+      }
+   }
+   return false;
+}
+
+// wrapper function
+void knightTour() {
+   int tour[N][N];
+   int i,j;
+
+   // initialize tour matrix
+   for (i = 0; i < N; i++) {
+      for (j = 0; j < N; j++) {
+         tour[i][j] = 0;
+      }
+   }
+
+   // all possible moves that knight can take
+   chess_moves move_KT[8] = { {2,1},{1,2},{-1,2},{-2,1},
+                              {-2,-1},{-1,-2},{1,-2},{2,-1} };
+
+   // knight tour starts from coordinate (0,0)
+   chess_moves curr_move = {0,0};
+
+   // find a possible knight tour using a recursive function
+   // starting from current move 
+   if(findTour(tour, move_KT, curr_move, 0) == false) {
+      cout<<"Knight tour does not exist for the 8 x 8 board\n";
+   }
+   else {
+      cout<<"Tour exists for the 8 x 8 board\n";
+      printTour(tour);
+   }
+}
+
+// main
+int main() {
+   knightTour();
+   cout<<endl;
+   return 0;
+}

BackTracking/NQueens/nqueens.c

@@ -0,0 +1,124 @@
+/* C/C++ program to solve n Queen Problem using
+backtracking */
+#include <stdio.h>
+#include <stdbool.h> 
+ int n;
+/* A utility function to print solution */
+void printSolution(int board[n][n])
+{
+    static  int k = 1;
+    printf("%d-\n",k++);
+    for (int i = 0; i < n; i++)
+    {
+        for (int j = 0; j < n; j++)
+            printf(" %d ", board[i][j]);
+        printf("\n");
+    }
+    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 )
+    {
+        printSolution(board);
+        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 */
+            solvenQUtil(board, col + 1) ;
+ 
+            // below commented statement is replaced
+            // by above one
+            /* 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 column 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
+canot 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.*/
+void solvenQ()
+{
+    int board[n][n];
+    for(int i = 0; i < n; i++)
+        for (int j = 0; j < n; ++j)
+        {
+            board [i] [j] = 0;
+        }
+ 
+    if (solvenQUtil(board, 0))
+    {
+        printf("Solution does not exist\n");
+        return ;
+    }
+ 
+    return ;
+}
+ 
+// driver program to test above function
+int main()
+{
+    printf("Enter the size of the board, ie value of n:\n");
+    scanf("%d",&n);
+    solvenQ();
+    return 0;
+}