Knight’s Tour Problem in C++

// C++ program to solve  Knight’s tour problem using backtracking

#include <iomanip>
#include <iostream>
#include <vector>

#define N 8

using namespace std;

// Function to check if (x, y) is a valid move for the knight
bool isSafe(int x, int y, vector<vector<int>> &sol)
{
    return (x >= 0 && x < N && y >= 0 && y < N && sol[x][y] == -1);
}

// Function to print the solution matrix
void printSolution(vector<vector<int>> &sol)
{
    for (int x = 0; x < N; x++)
    {
        for (int y = 0; y < N; y++)
            cout << " " << setw(2) << sol[x][y] << " ";
        cout << endl;
    }
}

// Utility function to solve the Knight's Tour problem
bool solveKTUtil(int x, int y, int movei, vector<vector<int>> &sol, const vector<int> &xMove,
                 const vector<int> &yMove)
{
    int k, next_x, next_y;
    if (movei == N * N)
        return true;

    // Try all next moves from the current coordinate x, y
    for (k = 0; k < 8; k++)
    {
        next_x = x + xMove[k];
        next_y = y + yMove[k];
        if (isSafe(next_x, next_y, sol))
        {
            sol[next_x][next_y] = movei;
            if (solveKTUtil(next_x, next_y, movei + 1, sol, xMove, yMove))
                return true;
            else
                sol[next_x][next_y] = -1; // Backtracking
        }
    }
    return false;
}

// This function solves the Knight's Tour problem using Backtracking
bool solveKT()
{
    vector<vector<int>> sol(N, vector<int>(N, -1));

    // xMove[] and yMove[] define the next move of the knight.
    vector<int> xMove = {2, 1, -1, -2, -2, -1, 1, 2};
    vector<int> yMove = {1, 2, 2, 1, -1, -2, -2, -1};

    // Starting position of knight
    sol[0][0] = 0;

    // Start from (0, 0) and explore all tours using solveKTUtil()
    if (!solveKTUtil(0, 0, 1, sol, xMove, yMove))
    {
        cout << "Solution does not exist" << endl;
        return false;
    }
    else
        printSolution(sol);

    return true;
}

int main()
{
    solveKT();
    return 0;
}

// C++ program to solve the Knight’s tour problem using Warnsdorff’s algorithm.

#include <cstdlib>
#include <ctime>
#include <iomanip>
#include <iostream>
#include <vector>

#define N 8

using namespace std;

// Move pattern on basis of the change of x and y coordinates respectively
static int cx[N] = {1, 1, 2, 2, -1, -1, -2, -2};
static int cy[N] = {2, -2, 1, -1, 2, -2, 1, -1};

// Function to restrict the knight to remain within the 8x8 chessboard
bool limits(int x, int y)
{
    return ((x >= 0 && y >= 0) && (x < N && y < N));
}

// Checks whether a square is valid and empty or not
bool isempty(int a[], int x, int y)
{
    return (limits(x, y)) && (a[y * N + x] < 0);
}

// Returns the number of empty squares adjacent to (x, y)
int getDegree(int a[], int x, int y)
{
    int count = 0;
    for (int i = 0; i < N; ++i)
        if (isempty(a, x + cx[i], y + cy[i]))
            count++;
    return count;
}

// Picks next point using Warnsdorff's heuristic
bool nextMove(int a[], int &x, int &y)
{
    int min_deg_idx = -1, c, min_deg = (N + 1), nx, ny;

    // Try all N adjacent of (x, y) starting from a random adjacent
    int start = rand() % N;
    for (int count = 0; count < N; ++count)
    {
        int i = (start + count) % N;
        nx = x + cx[i];
        ny = y + cy[i];
        if (isempty(a, nx, ny) && (c = getDegree(a, nx, ny)) < min_deg)
        {
            min_deg_idx = i;
            min_deg = c;
        }
    }

    // If we could not find a next cell
    if (min_deg_idx == -1)
        return false;

    // Store coordinates of next point
    nx = x + cx[min_deg_idx];
    ny = y + cy[min_deg_idx];

    // Mark next move
    a[ny * N + nx] = a[y * N + x] + 1;

    // Update next point
    x = nx;
    y = ny;

    return true;
}

// Displays the chessboard with all the legal knight's moves
void print(int a[])
{
    for (int i = 0; i < N; ++i)
    {
        for (int j = 0; j < N; ++j)
            cout << setw(2) << a[j * N + i] << "\t";
        cout << endl;
    }
}

// Checks its neighboring squares. If the knight ends on a square that is one knight's move from the beginning
// square, then the tour is closed
bool neighbour(int x, int y, int xx, int yy)
{
    for (int i = 0; i < N; ++i)
        if ((x + cx[i] == xx) && (y + cy[i] == yy))
            return true;
    return false;
}

// Generates the legal moves using Warnsdorff's heuristics. Returns false if not possible
bool findClosedTour()
{
    // Filling up the chessboard matrix with -1's
    int a[N * N];
    for (int i = 0; i < N * N; ++i)
        a[i] = -1;

    // Random initial position
    int sx = rand() % N;
    int sy = rand() % N;

    // Current points are the same as initial points
    int x = sx, y = sy;
    a[y * N + x] = 1; // Mark first move

    // Keep picking next points using Warnsdorff's heuristic
    for (int i = 0; i < N * N - 1; ++i)
        if (!nextMove(a, x, y))
            return false;

    // Check if tour is closed (can end at starting point)
    if (!neighbour(x, y, sx, sy))
        return false;

    print(a);
    return true;
}

int main()
{
    // To make sure that different random initial positions are picked
    srand(time(NULL));

    // While we don't get a solution
    while (!findClosedTour())
    {
        ;
    }

    return 0;
}