Check Knight Tour Configuration

Check Knight Tour Configuration - Problem

There is a knight on an n x n chessboard. In a valid configuration, the knight starts at the top-left cell of the board and visits every cell on the board exactly once.

You are given an n x n integer matrix grid consisting of distinct integers from the range [0, n * n - 1] where grid[row][col] indicates that the cell (row, col) is the grid[row][col]th cell that the knight visited. The moves are 0-indexed.

Return true if grid represents a valid configuration of the knight's movements or false otherwise.

Note: A valid knight move consists of moving two squares vertically and one square horizontally, or two squares horizontally and one square vertically.

Input & Output

Example 1 — Valid Knight Tour

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

› Output: true

💡 Note: The knight starts at (0,0) with move 0, then follows valid knight moves through all positions: 0→1→2→3...→24, visiting each cell exactly once.

Example 2 — Invalid Knight Tour

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

› Output: false

💡 Note: The knight starts at (0,0) with move 0, but move 1 is at position (2,1). A knight cannot move from (0,0) to (2,1) in one valid L-shaped move.

Example 3 — Wrong Starting Position

$ Input: grid = [[1,0],[2,3]]

› Output: false

💡 Note: Move 0 should start at top-left (0,0), but here it's at (0,1). Invalid tour configuration.

Constraints

n == grid.length == grid[i].length
3 ≤ n ≤ 7
0 ≤ grid[row][col] < n * n
All integers in grid are unique

Visualization

Tap to expand

Asked in

G Google 15 f Meta 12 a Amazon 8

The key insight is to map each move number to its position coordinates, then validate that consecutive moves follow valid knight movement patterns. The optimal approach uses a hash map for O(1) position lookup, achieving O(n²) time complexity.

Common Approaches

✓ Brute Force Validation

⏱️ Time: O(n⁴) Space: O(1)

For each move from 0 to n²-1, find its position in the grid, then find the next move's position and verify it's a valid knight move. This requires searching the grid for each move number.

Position Mapping Optimization

⏱️ Time: O(n²) Space: O(n²)

Build a hash map that maps each move number to its position coordinates, then iterate through moves 0 to n²-1 and validate each consecutive pair is a valid knight move using the position lookup.

Brute Force Validation — Algorithm Steps

Step 1: Start with move 0 (must be at top-left)
Step 2: For each move, search grid to find its position
Step 3: Find next move's position and validate knight move

Visualization

Tap to expand

Step-by-Step Walkthrough

Find Move 0

Search entire grid to find position of move 0

Find Move 1

Search entire grid to find position of move 1

Validate

Check if move from position 0 to position 1 is valid knight move

Code -

solution.c — C

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

static int grid[50][50];
static int positions[2500][2];

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

bool checkValidGrid(int n) {
    // Special case: 1x1 grid
    if (n == 1) {
        return grid[0][0] == 0;
    }
    
    // Build position array
    for (int i = 0; i < n; i++) {
        for (int j = 0; j < n; j++) {
            int val = grid[i][j];
            if (val >= 0 && val < n * n) {
                positions[val][0] = i;
                positions[val][1] = j;
            }
        }
    }
    
    // Check if knight starts at (0,0)
    if (positions[0][0] != 0 || positions[0][1] != 0) {
        return false;
    }
    
    // Check each consecutive move
    for (int i = 0; i < n * n - 1; i++) {
        int r1 = positions[i][0];
        int c1 = positions[i][1];
        int r2 = positions[i + 1][0];
        int c2 = positions[i + 1][1];
        
        if (!isValidKnightMove(r1, c1, r2, c2)) {
            return false;
        }
    }
    
    return true;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    // Parse the grid
    int n = 0;
    int i = 0, j = 0;
    int pos = 0;
    
    // Skip initial characters until we find the first '['
    while (line[pos] && line[pos] != '[') pos++;
    if (line[pos] == '[') pos++; // Skip outer '['
    
    while (line[pos]) {
        if (line[pos] == '[') {
            // Start of new row
            pos++;
            j = 0;
        } else if (line[pos] == ']') {
            // End of row or entire grid
            pos++;
            if (j > 0) { // Only increment if we actually read numbers
                i++;
                if (n == 0) n = j; // Set n based on first row
            }
        } else if (line[pos] == ',') {
            pos++;
        } else if (line[pos] >= '0' && line[pos] <= '9') {
            // Parse number
            int num = 0;
            while (line[pos] >= '0' && line[pos] <= '9') {
                num = num * 10 + (line[pos] - '0');
                pos++;
            }
            grid[i][j] = num;
            j++;
        } else {
            pos++;
        }
    }
    
    bool result = checkValidGrid(n);
    printf("%s\n", result ? "true" : "false");
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n⁴)

For each of n² moves, we search the n×n grid to find positions

⚠ Quadratic Growth

Space Complexity

O(1)

Only using constant extra variables

⚠ Quadratic Space

12.0K Views

Medium Frequency

~15 min Avg. Time

542 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

Brute Force Validation — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler