
Introduction Historically, various methods have been used to solve the Knight's Tour problem. One frequently used method is to break up the 8x8 chessboard into smaller rectangles and solve the problem for the smaller rectangles in such a way that it is possible to combine the smaller paths into one grand path.
In the following we will see a method that is easy to learn and can be used to easily construct a knight's tour in less than 5 minutes. The tours so constructed will have the additional property that it is possible for the knight to step from the final square to the initial square, thus forming a closed path or a cycle.
Broadly, our strategy is to stay near the edges of the board as much as possible, so that towards the end, the squares that are remaining form a wellconnected subgraph at the center of the board, enabling us to complete the last few moves by trial and error.
Figure 1. If you can move to a corner square, you must do so.
Figure 2. Step 1 completed.
Figure 3. The sequence 5>6 has been extended to 5>5a>5b>5c>5d>6 and 8>9 has been extended to 8>8a>8b>8c>8d>8e>8f>9 to complete the tour.
Figure 4. Completed and properly numbered tour.
One popular heuristic for solving the knight's tour problem is the Warnsdorff rule. According to this rule, at each step the knight must move to that square which has the lowest degree (the degree of a square is the number of squares to which the knight can move from that square). The rationale for this is that towards the end, we will be left with squares having a high degree, and so there is a smaller chance of arriving at a square from which there is no move. The Warnsdorff rule is particularly suitable for writing computer programs to solve the knight's tour. Below is an example C program which uses this heuristic.
Example C program for solving the knight's tour using the Warnsdorff rule
#include <stdio.h> #include <stdlib.h>
/* The dimensions of the chess board */ #define BWID 8 #define BHEIT 8 /* The moves of the knight */ #define JWID 1 #define JHEIT 2
/* Macros for convenience */ #define isinboard(board,x,y) ((x)>=0 && (y)>=0 && (x)<BWID && (y)<BHEIT) #define isfree(board,x,y) (isinboard(board,x,y) && board[y * BWID + x] < 0)
/* These arrays define the set of neighbors of a square */ static int incx[8] = {JWID, JWID, JHEIT, JHEIT, JWID, JWID, JHEIT, JHEIT}; static int incy[8] = {JHEIT, JHEIT, JWID, JWID, JHEIT, JHEIT, JWID, JWID};
/* The number of neighbors of a square to which we can move */ int get_nbr_cnt(int *board, int x, int y) { int i, cnt = 0; for (i=0; i<8; i++) if (isfree(board, x+incx[i], y+incy[i])) cnt++; return cnt; }
/* Make a move according to the smallest degree heuristic */ int make_move(int *board, int *x, int *y) { int start, cnt, i, best = 1, nbrs, min_nbrs = 9, newx, newy; start = random() % 8; for (cnt=0; cnt<8; cnt++) { i = (start+cnt) % 8; newx = *x + incx[i]; newy = *y + incy[i]; if (isfree(board, newx, newy) && (nbrs = get_nbr_cnt(board, newx, newy)) < min_nbrs) { best = i; min_nbrs = nbrs; } } if (min_nbrs == 9) return 0; newx = *x + incx[best]; newy = *y + incy[best]; board[newy * BWID + newx] = board[*y * BWID + *x] + 1; *x = newx; *y = newy; return 1; }
/* Print the solved position */ void print_board(int *board) { int i, j; for(i=0; i<BWID; i++) { for(j=0; j<BHEIT; j++) printf ("%d\t", board[j * BWID + i]); printf ("\n"); } }
/* Check if 2 squares are neighbors of each other */ int is_nbr (int x1, int y1, int x2, int y2) { int i; for (i=0; i<8; i++) if (x1 + incx[i] == x2 && y1 + incy[i] == y2) return 1; return 0; }
/* Generate a path with a random starting square and each square * chosen according to the smallest degree rule. If a hamiltonian * cycle results, print the solution and return 1. Else return 0. */ int gen_sol() { /* board[y * BWID + x] represents the move number in which the square (x, y) was visited. It is 1 if the square has not been visited so far */ int board[BWID*BHEIT]; /* x and y represent the coordinates of the square being currently visited */ int i, x, y, startx, starty; for(i=0; i<BWID*BHEIT; i++) board[i] = 1; startx = x = random() % BWID; starty = y = random() % BHEIT; board[y * BWID + x] = 1; for(i=0; i<BWID*BHEIT1; i++) if (make_move(board, &x, &y) == 0) return 0; if (!is_nbr (x, y, startx, starty)) return 0; print_board(board); return 1; }
/* Loop endlessly until a solution is found */ int main(void) { while (!gen_sol()) ; return 0; }
Note that the above program is not restricted to 8x8 chessboards; the parameters BWID and BHEIT control the width and the height respectively.
One solution obtained using the above program is shown below.
Figure 5. Computer solution using the Warnsdorff heuristic.
Search Encyclopedia

Featured Article
