The chess knight has a unique movement, it may move two squares vertically and one square horizontally, or two squares horizontally and one square vertically (with both forming the shape of an L). The possible movements of chess knight are shown in this diagram:
A chess knight can move as indicated in the chess diagram below:
We have a chess knight and a phone pad as shown below, the knight can only stand on a numeric cell (i.e. blue cell).
Given an integer n, return how many distinct phone numbers of length n we can dial.
You are allowed to place the knight on any numeric cell initially and then you should perform n - 1 jumps to dial a number of length n. All jumps should be valid knight jumps.
As the answer may be very large, return the answer modulo 109 + 7.
Example 1:
Input: n = 1 Output: 10 Explanation: We need to dial a number of length 1, so placing the knight over any numeric cell of the 10 cells is sufficient.
Example 2:
Input: n = 2 Output: 20 Explanation: All the valid number we can dial are [04, 06, 16, 18, 27, 29, 34, 38, 40, 43, 49, 60, 61, 67, 72, 76, 81, 83, 92, 94]
Example 3:
Input: n = 3131 Output: 136006598 Explanation: Please take care of the mod.
Constraints:
1 <= n <= 5000In #935 Knight Dialer, you must count how many distinct phone numbers of length n can be formed by moving a chess knight on a numeric keypad. The key observation is that each digit can only move to a fixed set of digits according to knight movement rules. This makes the problem well-suited for dynamic programming.
Define a DP state where dp[i][d] represents the number of ways to end on digit d after i moves. For each step, distribute counts to all digits reachable via valid knight moves. Since the keypad graph is small (digits 0–9), transitions are constant and can be precomputed.
You can optimize space by storing only the previous step, reducing memory to O(10). All results should be computed modulo 1e9+7 to avoid overflow. The dynamic programming approach runs in O(n) time with a constant-sized state. For very large n, the problem can also be modeled as transitions in a graph and solved using matrix exponentiation.
| Approach | Time Complexity | Space Complexity |
|---|---|---|
| Dynamic Programming with Rolling Array | O(n) | O(10) |
| DP with Full Table | O(n × 10) | O(n × 10) |
| Matrix Exponentiation | O(10^3 log n) | O(10^2) |
NeetCodeIO
This approach uses dynamic programming to store and reuse the number of dialable numbers of length n starting from each digit. We maintain a 2D DP table where dp[i][j] indicates how many numbers of length i can start from digit j.
The primary idea is to iterate from i=1 to n, updating the DP table based on the moves possible from each digit in the previous state.
Time Complexity: O(n) for each of the 10 digits, resulting in O(10n) operations.
Space Complexity: O(10n) due to the DP table.
1#include <vector>
2using namespace std;
3
4class Solution {
5public:
6 int knightDialer(int n) {
7 constexpr int MOD = 1000000007;
8 vector<vector<int>> moves = {
9 {4, 6}, {6, 8}, {7, 9}, {4, 8}, {0, 3, 9},
10 {}, {0, 1, 7}, {2, 6}, {1, 3}, {2, 4}
11 };
12 vector<vector<int>> dp(n, vector<int>(10, 0));
13 for (int i = 0; i < 10; ++i) dp[0][i] = 1;
14
15 for (int i = 1; i < n; ++i) {
16 for (int j = 0; j < 10; ++j) {
17 for (int move : moves[j]) {
18 dp[i][j] = (dp[i][j] + dp[i - 1][move]) % MOD;
19 }
20 }
21 }
22
23 int result = 0;
24 for (int num : dp[n - 1]) {
25 result = (result + num) % MOD;
26 }
27
28 return result;
29 }
30};This C++ solution follows the same logic and dynamic programming approach as described. It uses a 2D vector dp to keep track of the number of possible numbers that can be formed with knight moves, starting from each digit. The final number of possible dialer numbers of length n is computed by summing the entries in the last row of dp.
This approach optimizes the dynamic programming technique by reducing space complexity. Instead of using a full 2D array, we use two 1D arrays to track only the current and the previous state, thus reducing the space required from O(n*10) to O(20).
Time Complexity: O(n) - iterating over digits with constant time calculations;
Space Complexity: O(10) as we only hold current and previous state arrays.
1#include <vector>
2#include <array>
3using namespace std;
4
class Solution {
public:
int knightDialer(int n) {
constexpr int MOD = 1000000007;
array<vector<int>, 10> moves = {
{{4, 6}}, {{6, 8}}, {{7, 9}}, {{4, 8}}, {{0, 3, 9}},
{}, {{0, 1, 7}}, {{2, 6}}, {{1, 3}}, {{2, 4}}
};
vector<int> prev(10, 1);
for (int i = 1; i < n; ++i) {
vector<int> curr(10, 0);
for (int j = 0; j < 10; ++j) {
for (int move : moves[j]) {
curr[j] = (curr[j] + prev[move]) % MOD;
}
}
prev = curr;
}
int result = 0;
for (int num : prev) {
result = (result + num) % MOD;
}
return result;
}
};Watch expert explanations and walkthroughs
Practice problems asked by these companies to ace your technical interviews.
Explore More ProblemsJot down your thoughts, approach, and key learnings
Yes, Knight Dialer is a popular dynamic programming problem often used in technical interviews. It tests graph thinking, state transitions, and DP optimization, which are common patterns in FAANG-style interviews.
The number of possible sequences grows exponentially as n increases. Using modulo 1e9+7 prevents integer overflow and keeps results within manageable limits while preserving correctness in modular arithmetic.
A small DP array of size 10 is sufficient because the keypad only contains digits 0–9. Additionally, a predefined adjacency list representing valid knight moves helps efficiently update transitions.
The optimal approach uses dynamic programming by tracking the number of ways to reach each digit at every step. Since each digit has fixed knight transitions, you repeatedly update counts for n moves. Using a rolling array reduces space to constant size.
The C++ code reduces space by using two single-dimensional arrays to store the current and previous numbers computed at each stage, instead of maintaining an entire DP table. This provides optimal space efficiency while retaining the same structure as multi-dimensional DP.