Count of N-digit numbers in base K with no two consecutive zeroes

Given two integers N and K, the task is to find the count of all the integer in base K which satisfy the following conditions: 
 

1. The integers must be of exactly N digits.
2. There should be no leading 0.
3. There must not be any consecutive digit pair such that both the digits are 0.

Examples: 

Input: N = 3, K = 10 
Output: 891 
All 3-digit numbers in base 10 are from the range [100, 999] 
Out of these numbers only 100, 200, 300, 400, ..., 900 are invalid. 
Hence valid integers are 900 - 9 = 891

Input: N = 2, K = 10 
Output: 90  

Naive approach: Write a function count_numbers(int k, int n, bool flag) which will return the count of N digit numbers possible of base K and flag will tell whether the previously chosen digit was 0 or not. Call this function recursively for count_numbers(int k, int n-1, bool flag), and using the flag, the occurrence of two consecutive 0s can be avoided.

Below is the implementation of the above approach: 

891

Time Complexity: O(n²)
Auxiliary Space: O(n²)

Approach 2: Efficient

Now that the problem has been solved using recursion, a 2-D DP can be used to solve this problem dp[n + 1][2] where dp[i][0] will give the number of i digit numbers possible ending with 0 and dp[i][1] will give the number of i digit numbers possible ending with non-zero. 

The recurrence relation will be: 

dp[i][0] = dp[i - 1][1]; 
dp[i][1] = (dp[i - 1][0] + dp[i - 1][1]) * (K - 1); 

Below is the implementation of the above approach: 

891

Time Complexity: O(n)
Auxiliary Space: O(n)

Approach 3: More Efficient

Space optimize O(1)

In the previous approach, the current value dp[i] is only depend upon the previous values dp[i-1] .So to optimize the space complexity we can use variables to store current and previous computations instead of dp array of size n.

Implementation Steps:

• Initialize prev_zero to 0 and prev_nonzero to k-1.
• Loop from i=2 to i=n:
• Calculate curr_zero as prev_nonzero.
• Calculate curr_nonzero as (prev_zero + prev_nonzero) * (k-1).
• Update prev_zero to curr_zero and prev_nonzero to curr_nonzero.
• Return prev_zero + prev_nonzero.

Implementation:

Output:

891

Time complexity: O(N)
Auxiliary Space: O(1) 

Approach:

1. The code defines a function `isValid` that checks if a digit is valid based on the condition of not having a consecutive pair of zeros.

2. The `backtrack` function generates all possible combinations of digits for valid integers by recursively exploring each digit at each index, excluding leading zeros.

3. The `countValidIntegers` function initializes a count variable and calls the `backtrack` function to count the valid integers.

4. The main function initializes the values of N and K, calls `countValidIntegers`, and outputs the result.

Below is the implementation of the above approach: 

891

Time Complexity: O(K^N)

The backtrack function is called recursively for each digit at each index, excluding leading zeros. The number of recursive calls depends on the value of N and K.
The number of possible digit choices at each index is K, so the total number of recursive calls is K^N.
As a result, the time complexity of the code is O(K^N), where K is the base and N is the number of digits.

Space Complexity:O(N)

The space complexity is determined by the space used by the number vector and the recursive calls.
The number vector stores the digits of the number and requires N units of space.
The recursive calls create a call stack, which can have a maximum depth of N.
Therefore, the space complexity of the code is O(N), where N is the number of digits