Knight Dialer

Knight Dialer - Problem

Dynamic Programming Medium

Imagine you have a chess knight placed on a phone dialer pad! A knight moves in an L-shape: either 2 squares vertically and 1 horizontally, or 2 squares horizontally and 1 vertically.

The phone pad looks like this:

Given an integer n, determine how many distinct phone numbers of length n you can dial by moving the knight around the pad. You can start on any numeric key (0-9), then make exactly n-1 valid knight moves.

Goal: Count all possible phone numbers of length n that can be formed by valid knight moves.

Note: Since the answer can be very large, return it modulo 10^9 + 7.

Input & Output

example_1.py — Small Case

$ Input: n = 1

› Output: 10

💡 Note: With only 1 digit, we can start on any of the 10 digits (0-9) and don't need to make any moves. So there are 10 possible phone numbers of length 1.

example_2.py — Two Digits

$ Input: n = 2

› Output: 20

💡 Note: For length 2, we need exactly 1 knight move. From digit 5, no moves are possible. From other digits, we can make various moves: 0→4,6; 1→6,8; 2→7,9; etc. Total valid 2-digit numbers: 20.

example_3.py — Larger Case

$ Input: n = 3131

› Output: 136006598

💡 Note: For very large n, the number of possible phone numbers grows exponentially, but due to the modulo operation (10^9 + 7), we return 136006598.

Constraints

1 ≤ n ≤ 5000
Answer should be returned modulo 10⁹ + 7
Knight can start on any digit (0-9)
All moves must be valid knight moves within the phone pad

Visualization

Tap to expand

Asked in

G Google 45 a Amazon 38 f Facebook 32 ⊞ Microsoft 28

The optimal approach uses dynamic programming with memoization to avoid recalculating the same subproblems. By caching results for each (digit, remaining_moves) pair, we reduce the time complexity from exponential O(3^n) to linear O(n). The key insight is that the number of ways to reach any digit with k moves depends only on the digit and k, not on the path taken to get there.

Common Approaches

✓ Optimized

⏱️ Time: N/A Space: N/A

Binary Search

⏱️ Time: N/A Space: N/A

Dynamic Programming with Memoization (Optimal)

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

Use memoization to store results of subproblems. When we calculate how many ways we can dial from a specific digit with k remaining moves, we cache this result to avoid recalculating it.

Recursive Brute Force

⏱️ Time: O(3^n) Space: O(n)

For each starting digit (0-9), recursively explore all valid knight moves to generate phone numbers of length n. This approach explores every possible path without optimization.

Algorithm Steps — Algorithm Steps

Code -

solution.c — C

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

typedef struct {
    int** matrix;
    int rows;
    int cols;
    int calls;
} BinaryMatrix;

int get(BinaryMatrix* bm, int row, int col) {
    bm->calls++;
    return bm->matrix[row][col];
}

int* dimensions(BinaryMatrix* bm) {
    int* dims = (int*)malloc(2 * sizeof(int));
    dims[0] = bm->rows;
    dims[1] = bm->cols;
    return dims;
}

int solution(BinaryMatrix* binaryMatrix) {
    int* dims = dimensions(binaryMatrix);
    int rows = dims[0], cols = dims[1];
    free(dims);
    
    int row = 0, col = cols - 1;
    int leftmostCol = -1;
    
    while (row < rows && col >= 0) {
        if (get(binaryMatrix, row, col) == 1) {
            leftmostCol = col;
            col--; // Move left
        } else {
            row++; // Move down
        }
    }
    
    return leftmostCol;
}

BinaryMatrix* parseMatrix(char* input) {
    BinaryMatrix* bm = (BinaryMatrix*)malloc(sizeof(BinaryMatrix));
    bm->calls = 0;
    
    // Count rows and columns
    int rows = 0, cols = 0;
    char* temp = strdup(input);
    char* ptr = temp;
    
    // Skip initial brackets and whitespace
    while (*ptr && (*ptr == '[' || *ptr == ' ')) ptr++;
    
    // Count rows by counting '],' patterns
    char* rowPtr = ptr;
    while (*rowPtr) {
        if (*rowPtr == '[') {
            rows++;
            // Count columns in first row only
            if (rows == 1) {
                rowPtr++;
                while (*rowPtr && *rowPtr != ']') {
                    if (*rowPtr >= '0' && *rowPtr <= '9') {
                        cols++;
                        while (*rowPtr >= '0' && *rowPtr <= '9') rowPtr++;
                    } else {
                        rowPtr++;
                    }
                }
            }
        }
        rowPtr++;
    }
    free(temp);
    
    bm->rows = rows;
    bm->cols = cols;
    
    // Allocate matrix
    bm->matrix = (int**)malloc(rows * sizeof(int*));
    for (int i = 0; i < rows; i++) {
        bm->matrix[i] = (int*)malloc(cols * sizeof(int));
    }
    
    // Parse values
    ptr = input;
    while (*ptr && *ptr != '[') ptr++; // Find first [
    
    for (int i = 0; i < rows; i++) {
        while (*ptr && *ptr != '[') ptr++; // Find row start
        if (*ptr) ptr++; // Skip [
        
        for (int j = 0; j < cols; j++) {
            while (*ptr && (*ptr < '0' || *ptr > '9')) ptr++; // Skip to number
            bm->matrix[i][j] = *ptr - '0';
            ptr++;
        }
    }
    
    return bm;
}

int main() {
    char line[10000];
    fgets(line, sizeof(line), stdin);
    
    BinaryMatrix* bm = parseMatrix(line);
    printf("%d\n", solution(bm));
    
    // Cleanup
    for (int i = 0; i < bm->rows; i++) {
        free(bm->matrix[i]);
    }
    free(bm->matrix);
    free(bm);
    
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

✓ Linear Growth

Space Complexity

⚡ Linearithmic Space

67.0K Views

High Frequency

~25 min Avg. Time

1.9K 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