Check Knight Tour Configuration - Practice Coding Problems

Check Knight Tour Configuration - Problem

Knight's Chess Adventure: Validating the Perfect Tour

Imagine a chess knight embarking on an epic journey across an n × n chessboard, with one ambitious goal: visit every single square exactly once, starting from the top-left corner (0,0).

You're given a special grid that supposedly records this knight's journey. Each cell grid[row][col] contains a number indicating the order in which the knight visited that position (0-indexed). For example, if grid[2][3] = 5, it means the knight visited position (2,3) as its 6th move.

Your Mission: Determine if this grid represents a valid knight's tour - meaning the knight could actually make this journey following proper chess rules.

Knight Movement Rules:
• Move in an 'L' shape: 2 squares in one direction + 1 square perpendicular
• This creates exactly 8 possible moves from any position
• Must visit all n² - 1 squares exactly once

Return true if the tour is valid, false otherwise.

Input & Output

example_1.py — Valid 3×3 Knight Tour

$ Input: grid = [[0,11,16,5,20,17,2,21,6],[23,4,15,10,1,18,7,22,3],[14,9,24,19,8,13,12,25,0]]

› Output: true

💡 Note: This represents a valid knight's tour starting from (0,0) with move 0, and each consecutive move follows valid knight movement rules (L-shaped: 2+1 or 1+2 squares).

example_2.py — Invalid Knight Move

$ Input: grid = [[0,1,2],[5,4,3],[6,7,8]]

› Output: false

💡 Note: Move 0→1 goes from (0,0) to (0,1), which is only 1 square horizontally. Knights must move in L-shape (2+1), so this is invalid.

example_3.py — Wrong Starting Position

$ Input: grid = [[2,0,1],[3,4,5],[6,7,8]]

› Output: false

💡 Note: The knight must start at position (0,0), but grid[0][0] = 2, not 0. Invalid starting position.

Visualization

Tap to expand

Understanding the Visualization

📍 Map the Kingdom

First, we create a royal registry mapping each delivery number to its house address (position)

🏃‍♂️ Trace the Route

Follow the messenger's path by checking if each consecutive delivery follows valid knight movement rules

✅ Validate Each Hop

Ensure every move is L-shaped: exactly 2 squares in one direction plus 1 square perpendicular

🏁 Deliver Verdict

If any move breaks the knight's movement rules, the tour is invalid

Key Takeaway

🎯 Key Insight: Use a hash map to store positions for O(1) lookup, then validate each consecutive move follows the L-shaped pattern (|dr|=2,|dc|=1 or |dr|=1,|dc|=2)

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass to build map O(n²) + validate n² moves with O(1) lookups

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map storing all n² positions

⚠ Quadratic Space

Constraints

n == grid.length == grid[i].length
3 ≤ n ≤ 7
0 ≤ grid[i][j] < n²
All integers in grid are unique
Grid represents moves numbered from 0 to n² - 1

Asked in

G Google 25 f Meta 18 a Amazon 15 ⊞ Microsoft 12

The optimal approach uses a hash map to store move positions in O(n²) time, then validates consecutive moves in O(1) lookup time. Key insight: since moves are numbered 0 to n²-1, we can directly map positions and validate the L-shaped knight movement pattern efficiently.

Common Approaches

Approach	Time	Space	Notes
✓ One-Pass Hash Map (Optimal)	O(n²)	O(n²)	Build position map in one pass, then validate consecutive moves efficiently
Brute Force (Find Each Move Sequentially)	O(n⁴)	O(1)	For each move number, search the entire grid to find its position, then validate the move

One-Pass Hash Map (Optimal) — Algorithm Steps

Create a hash map to store move_number → (row, col) position
Scan grid once to populate the position map
Check if move 0 starts at position (0,0)
For each consecutive pair of moves, validate knight move in O(1) time
Return false if any validation fails, true otherwise

Visualization

Tap to expand

Step-by-Step Walkthrough

Build Position Map

Single pass through grid to map move_number → position

Validate Moves

Check consecutive moves using O(1) hash map lookups

Knight Move Check

Verify L-shaped movement pattern for each pair

Code -

solution.c — C

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

typedef struct {
    int row, col;
} Position;

bool isValidKnightMove(int r1, int c1, int r2, int c2) {
    int dr = abs(r2 - r1);
    int dc = abs(c2 - c1);
    return (dr == 2 && dc == 1) || (dr == 1 && dc == 2);
}

bool checkValidGrid(int** grid, int n) {
    if (grid[0][0] != 0) return false;
    
    // Create position array (move number as index)
    Position* positions = malloc((n * n) * sizeof(Position));
    
    // Build position map
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int move = grid[i][j];
            positions[move].row = i;
            positions[move].col = j;
        }
    }
    
    // Validate consecutive moves
    for (int move = 0; move < n * n - 1; move++) {
        Position pos1 = positions[move];
        Position pos2 = positions[move + 1];
        
        if (!isValidKnightMove(pos1.row, pos1.col, pos2.row, pos2.col)) {
            free(positions);
            return false;
        }
    }
    
    free(positions);
    return true;
}

int main() {
    int n = 3;
    int** grid = malloc(n * sizeof(int*));
    for (int i = 0; i < n; i++) {
        grid[i] = malloc(n * sizeof(int));
    }
    
    int values[3][3] = {{0,1,2},{5,4,3},{6,7,8}};
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            grid[i][j] = values[i][j];
        }
    }
    
    printf("%s\n", checkValidGrid(grid, n) ? "true" : "false");
    
    for (int i = 0; i < n; i++) {
        free(grid[i]);
    }
    free(grid);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n²)

Single pass to build map O(n²) + validate n² moves with O(1) lookups

⚠ Quadratic Growth

Space Complexity

O(n²)

Hash map storing all n² positions

⚠ Quadratic Space

Constraints

n == grid.length == grid[i].length
3 ≤ n ≤ 7
0 ≤ grid[i][j] < n²
All integers in grid are unique
Grid represents moves numbered from 0 to n² - 1

26.4K Views

Medium Frequency

~15 min Avg. Time

892 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

Visualization

Time & Space Complexity

Related Problems

Constraints

Common Approaches

One-Pass Hash Map (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Constraints

Select Compiler