The Knight's Tour - Practice Coding Problems

The Knight's Tour - Problem

The Knight's Tour is a classic chess puzzle where you must move a knight across a chessboard so that it visits every square exactly once.

You're given a rectangular board with dimensions m × n and a starting position (r, c) for the knight. Your task is to find a sequence of valid knight moves that visits all squares on the board exactly once.

Knight Movement Rules: A knight moves in an L-shape - exactly 2 squares in one direction and 1 square perpendicular to that, or vice versa. From position (r1, c1), a knight can move to (r2, c2) if:
• The destination is within bounds: 0 ≤ r2 < m and 0 ≤ c2 < n
• The move forms an L-shape: min(|r1-r2|, |c1-c2|) = 1 and max(|r1-r2|, |c1-c2|) = 2

Return a 2D array where each cell contains the order of visit (starting from 0 for the initial position).

Input & Output

example_1.py — Small 3×3 Board

$ Input: m = 3, n = 3, r = 0, c = 0

› Output: [[0, 5, 2], [3, 8, 7], [6, 1, 4]]

💡 Note: Starting from top-left corner (0,0), the knight visits all 9 squares. The numbers show the order of visits: start at 0, then move to position (2,1) for step 1, then to (0,2) for step 2, and so on.

example_2.py — Rectangular 4×3 Board

$ Input: m = 4, n = 3, r = 1, c = 1

› Output: [[9, 4, 7], [2, 11, 6], [5, 8, 1], [10, 3, 0]]

💡 Note: Starting from the middle position (1,1), the knight completes a tour of all 12 squares on this rectangular board. Note how the tour ends at position (3,2) with step 0 being the starting position.

example_3.py — Edge Case 1×1 Board

$ Input: m = 1, n = 1, r = 0, c = 0

› Output: [[0]]

💡 Note: On a 1×1 board, the knight can only occupy the single square, so the tour is trivially complete with just the starting position marked as step 0.

Constraints

1 ≤ m, n ≤ 8 (standard chessboard size limit)
0 ≤ r < m (starting row must be within bounds)
0 ≤ c < n (starting column must be within bounds)
Note: Some board configurations may have no valid solution

Visualization

Tap to expand

Understanding the Visualization

Start Position

Place the knight at the given starting square and mark it as step 0

Analyze Options

From current position, identify all valid L-shaped moves the knight can make

Apply Warnsdorff's Rule

For each possible move, count future options and prioritize moves with fewer choices

Make Smart Move

Choose the move that leaves the most future flexibility (ironically, the most constrained next position)

Continue Recursively

Repeat the process from the new position until all squares are visited

Key Takeaway

🎯 Key Insight: Warnsdorff's heuristic works by choosing moves that preserve maximum future flexibility - a classic example of how being greedy about constraints can lead to optimal solutions.

Asked in

G Google 35 f Meta 28 a Amazon 22 ⊞ Microsoft 18

The Knight's Tour is optimally solved using backtracking with Warnsdorff's heuristic. The key insight is to always move to squares with the fewest onward moves, dramatically reducing the search space and avoiding dead ends. This approach combines the completeness guarantee of backtracking with intelligent move ordering for practical efficiency.

Common Approaches

Approach	Time	Space	Notes
✓ Backtracking with Warnsdorff's Heuristic (Optimal)	O(8^(mn)) worst case, but much better in practice	O(mn)	Use Warnsdorff's rule to guide the search toward promising moves first
Brute Force Backtracking	O(8^(mn))	O(mn)	Try all possible sequences of knight moves using recursive backtracking

Backtracking with Warnsdorff's Heuristic (Optimal) — Algorithm Steps

Start from the given position and mark it as visited
For each possible knight move, count how many unvisited squares can be reached from that destination
Sort moves by accessibility count (Warnsdorff's rule: prefer moves with fewer onward options)
Try moves in this prioritized order using backtracking
If a move leads to a dead end, backtrack and try the next move in the sorted list

Visualization

Tap to expand

Step-by-Step Walkthrough

Count Accessibility

For each possible move, count how many squares can be reached next

Sort Moves

Order moves by accessibility count (fewest options first)

Try Best Move

Attempt the move with the lowest accessibility count first

Recursive Search

Continue with Warnsdorff's rule from the new position

Code -

solution.c — C

#include <stdio.h>
#include <stdlib.h>
#include <stdbool.h>

int moves[8][2] = {{2,1}, {2,-1}, {-2,1}, {-2,-1}, {1,2}, {1,-2}, {-1,2}, {-1,-2}};
int **board;
int m, n;

typedef struct {
    int accessibility;
    int r, c;
} Move;

bool isValid(int r, int c) {
    return r >= 0 && r < m && c >= 0 && c < n && board[r][c] == -1;
}

int countAccessibility(int r, int c) {
    int count = 0;
    for (int i = 0; i < 8; i++) {
        if (isValid(r + moves[i][0], c + moves[i][1])) {
            count++;
        }
    }
    return count;
}

int compareMove(const void *a, const void *b) {
    Move *moveA = (Move*)a;
    Move *moveB = (Move*)b;
    return moveA->accessibility - moveB->accessibility;
}

int getSortedMoves(int r, int c, Move *sortedMoves) {
    int count = 0;
    
    for (int i = 0; i < 8; i++) {
        int nextR = r + moves[i][0];
        int nextC = c + moves[i][1];
        if (isValid(nextR, nextC)) {
            int accessibility = countAccessibility(nextR, nextC);
            sortedMoves[count].accessibility = accessibility;
            sortedMoves[count].r = nextR;
            sortedMoves[count].c = nextC;
            count++;
        }
    }
    
    // Sort by accessibility (Warnsdorff's rule)
    qsort(sortedMoves, count, sizeof(Move), compareMove);
    return count;
}

bool backtrack(int r, int c, int step) {
    board[r][c] = step;
    
    if (step == m * n - 1) {
        return true;
    }
    
    Move sortedMoves[8];
    int moveCount = getSortedMoves(r, c, sortedMoves);
    
    for (int i = 0; i < moveCount; i++) {
        if (backtrack(sortedMoves[i].r, sortedMoves[i].c, step + 1)) {
            return true;
        }
    }
    
    // Backtrack
    board[r][c] = -1;
    return false;
}

int** solveKnightsTourOptimized(int rows, int cols, int startR, int startC) {
    m = rows;
    n = cols;
    
    board = (int**)malloc(m * sizeof(int*));
    for (int i = 0; i < m; i++) {
        board[i] = (int*)malloc(n * sizeof(int));
        for (int j = 0; j < n; j++) {
            board[i][j] = -1;
        }
    }
    
    if (backtrack(startR, startC, 0)) {
        return board;
    } else {
        for (int i = 0; i < m; i++) {
            free(board[i]);
        }
        free(board);
        return NULL;
    }
}

int main() {
    int r, c;
    scanf("%d %d %d %d", &m, &n, &r, &c);
    
    int** result = solveKnightsTourOptimized(m, n, r, c);
    
    if (result) {
        for (int i = 0; i < m; i++) {
            for (int j = 0; j < n; j++) {
                printf("%d ", result[i][j]);
            }
            printf("\n");
        }
    }
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(8^(mn)) worst case, but much better in practice

Warnsdorff's heuristic dramatically reduces the branching factor in practice, though worst-case remains exponential

✓ Linear Growth

Space Complexity

O(mn)

Space for the board and recursion stack, plus temporary arrays for move sorting

⚡ Linearithmic Space

28.3K Views

Medium Frequency

~25 min Avg. Time

847 Likes

Ln 1, Col 1

Smart Actions

💡 Explanation

AI Ready

💡 Suggestion Tab to accept Esc to dismiss

// Output will appear here after running code

Code Editor Closed

Click the red button to reopen

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Backtracking with Warnsdorff's Heuristic (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler