Knight Dialer - Practice Coding Problems

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

Understanding the Visualization

Map the Moves

First, identify all valid knight moves from each digit on the phone pad

Build the Cache

Use dynamic programming to store results for each (digit, moves_left) combination

Count Paths

Sum up all possible paths from each starting digit to get the final answer

Key Takeaway

🎯 Key Insight: Instead of exploring every possible path (exponential), we count the number of ways to reach each digit after exactly k moves, building up the solution incrementally using dynamic programming.

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

Approach	Time	Space	Notes
✓ Dynamic Programming with Memoization (Optimal)	O(n)	O(n)	Cache results of subproblems to avoid recomputation using top-down DP
Recursive Brute Force	O(3^n)	O(n)	Try all possible knight moves recursively from each starting position

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Create a memoization cache (digit, remaining_moves) -> count
Define recursive function with memoization
For each (digit, moves) pair, check cache first
If not cached, calculate recursively and store result
Sum results from all starting digits

Visualization

Tap to expand

Step-by-Step Walkthrough

Check cache

Before computing, check if result is already cached

Compute once

If not cached, compute the result recursively

Store result

Cache the computed result for future use

Reuse cached

Subsequent calls return cached result instantly

Code -

solution.c — C

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

#define MOD 1000000007
#define MAX_N 5000

int moves[10][4] = {
    {4, 6, -1, -1},     // 0
    {6, 8, -1, -1},     // 1
    {7, 9, -1, -1},     // 2
    {4, 8, -1, -1},     // 3
    {0, 3, 9, -1},      // 4
    {-1, -1, -1, -1},   // 5
    {0, 1, 7, -1},      // 6
    {2, 6, -1, -1},     // 7
    {1, 3, -1, -1},     // 8
    {2, 4, -1, -1}      // 9
};

long long memo[10][MAX_N];
int initialized[10][MAX_N];

long long dp(int digit, int remainingMoves) {
    if (remainingMoves == 0) {
        return 1;
    }
    
    if (initialized[digit][remainingMoves]) {
        return memo[digit][remainingMoves];
    }
    
    long long total = 0;
    for (int i = 0; i < 4 && moves[digit][i] != -1; i++) {
        total = (total + dp(moves[digit][i], remainingMoves - 1)) % MOD;
    }
    
    memo[digit][remainingMoves] = total;
    initialized[digit][remainingMoves] = 1;
    return total;
}

int knightDialer(int n) {
    memset(initialized, 0, sizeof(initialized));
    long long result = 0;
    for (int startDigit = 0; startDigit < 10; startDigit++) {
        result = (result + dp(startDigit, n - 1)) % MOD;
    }
    return (int)result;
}

int main() {
    int n;
    scanf("%d", &n);
    printf("%d\n", knightDialer(n));
    return 0;
}

Time & Space Complexity

Time Complexity

⏱️

O(n)

Each (digit, remaining_moves) pair is calculated once, and there are at most 10*n such pairs

✓ Linear Growth

Space Complexity

O(n)

Memoization table stores at most 10*n entries plus recursion stack

⚡ 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

Input & Output

Constraints

Visualization

Related Problems

Common Approaches

Dynamic Programming with Memoization (Optimal) — Algorithm Steps

Visualization

Code -

Time & Space Complexity

Select Compiler