Knight Dialer - Solution & Explanation

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.

This function uses dynamic programming to calculate the number of valid phone numbers. The moves are stored in a dictionary with each digit pointing to its possible knight moves. We initialize a 2D list dp where dp[i][j] represents the number of numbers of length i+1 starting from digit j. The result is obtained by summing up the values in the last row of the dp table.

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).

This function uses a space-efficient dynamic programming approach. Instead of maintaining a 2D table, it uses two lists: prev and curr, which track the current and previous counts of numbers of length n. The prev list is updated at each step to effectively simulate the transition from i to i+1 without maintaining an entire history.

According to the problem description, we need to calculate the number of different phone numbers of length n. Each digit can only follow certain fixed digits, which we can list as follows:

We can use a recurrence approach to calculate the number of different phone numbers of length n. Let f[i] represent the number of different phone numbers of length i. Initially, f[1] = 1. For phone numbers of length i, we can calculate them based on phone numbers of length i - 1. Therefore, we can derive the recurrence relations:

$ \begin{aligned} g[0] & = f[4] + f[6] \ g[1] & = f[6] + f[8] \ g[2] & = f[7] + f[9] \ g[3] & = f[4] + f[8] \ g[4] & = f[0] + f[3] + f[9] \ g[6] & = f[0] + f[1] + f[7] \ g[7] & = f[2] + f[6] \ g[8] & = f[1] + f[3] \ g[9] & = f[2] + f[4] \end{aligned}

Then, we update f to g and continue calculating the phone numbers of the next length until we calculate the number of phone numbers of length n.

Finally, we sum all the elements in f and take the result modulo 10^9 + 7 to get the answer.

The time complexity is O(n), where n is the length of the phone number. The space complexity is O(|\Sigma|), where \Sigma is the set of digits, and in this problem |\Sigma| = 10$.

Let's denote T(n) as a 1 times 10 matrix \begin{bmatrix} F_0 & F_1 & F_2 cdots F_9 \end{bmatrix}, where F_i represents the number of phone numbers ending with digit i. We want to derive T(n) from T(n - 1). In other words, we need a matrix base such that T(n - 1) times base = T(n), i.e.:

$ \begin{bmatrix} F_0 & F_1 & F_2 cdots F_9 \end{bmatrix} times base = \begin{bmatrix} F_0' & F_1' & F_2' cdots F_9' \end{bmatrix}

Since F_i' = sum_{j} F_j, where j is the previous digit of i, the first column of the matrix base is:

\begin{bmatrix} 0 \ 0 \ 0 \ 0 \ 1 \ 0 \ 1 \ 0 \ 0 \ 0 \end{bmatrix}

Similarly, we can derive the entire matrix base as follows:

\begin{bmatrix} 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 \ 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 & 0 \ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 1 \ 0 & 0 & 0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 \ 1 & 0 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 1 \ 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 & 0 \ 1 & 1 & 0 & 0 & 0 & 0 & 0 & 1 & 0 & 0 \ 0 & 0 & 1 & 0 & 0 & 0 & 1 & 0 & 0 & 0 \ 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 & 0 \ 0 & 0 & 1 & 0 & 1 & 0 & 0 & 0 & 0 & 0 \end{bmatrix}

We define the initial matrix res = \begin{bmatrix} 1 & 1 & 1 cdots 1 \end{bmatrix}, and multiply it by the matrix base raised to the power of n - 1 to obtain T(n). Finally, we sum all elements in T(n) and take the result modulo 10^9 + 7 to get the answer. The matrix base^{n - 1} can be computed using matrix exponentiation, which has a time complexity of O(log n).

The time complexity is O(log n), and the space complexity is O(|\Sigma|^2), where \Sigma is the set of digits, and in this problem |\Sigma| = 10$.