# Count of numbers upto N digits formed using digits 0 to K-1 without any adjacent 0s

Given two integers N and K, the task is to count the numbers up to N digits such that no two zeros are adjacents and the range of digits are from 0 to K-1.
Examples:

Input: N = 2, K = 3
Output:
Explanation:
There are 8 such numbers such that digits are from 0 to 2 only, without any adjacent 0s: {1, 2, 10, 11, 12, 20, 21, 22}
Input: N = 3, K = 3
Output: 22

Approach: The idea is to use Dynamic Programming to solve this problem.
Let DP[i][j] be the number of desirable numbers up to ith digit of the number, and its last digit as j.
Observations:

• The number of ways to fill a place is • As we know, zero’s can’t be adjacent. So when our last element is 0, means the previous index is filled by 1 way, that is 0. Therefore, current place can only be filled by (K-1) digits.
• If the last place is filled by (K-1) digits, Then current digit place can be filled by either 0 or (K-1) digits.

Base Case:

• If n == 1 and last == K, then we can fill this place by (K-1) digits, return (K-1)
• Else, return 1

Recurrence relation:

When last digit place is not filled by zero then When Last digit place is filled by zero then Below is the implementation of above approach:

## C++

 `// C++ implementation to count the ` `// numbers upto N digits such that ` `// no two zeros are adjacent ` ` `  `#include ` `using` `namespace` `std; ` ` `  `int` `dp; ` ` `  `// Function to count the ` `// numbers upto N digits such that ` `// no two zeros are adjacent ` `int` `solve(``int` `n, ``int` `last, ``int` `k) ` `{ ` `    ``// Condition to check if only ` `    ``// one element remains ` `    ``if` `(n == 1) { ` ` `  `        ``// If last element is non ` `        ``// zero, return K-1 ` `        ``if` `(last == k) { ` `            ``return` `(k - 1); ` `        ``} ` `        ``// If last element is 0 ` `        ``else` `{ ` `            ``return` `1; ` `        ``} ` `    ``} ` ` `  `    ``// Condition to check if value ` `    ``// calculated already ` `    ``if` `(dp[n][last]) ` `        ``return` `dp[n][last]; ` ` `  `    ``// If last element is non zero, ` `    ``// then two cases arise, ` `    ``// current element can be either ` `    ``// zero or non zero ` `    ``if` `(last == k) { ` ` `  `        ``// Memoize this case ` `        ``return` `dp[n][last] ` `               ``= (k - 1) ` `                     ``* solve(n - 1, k, k) ` `                 ``+ (k - 1) ` `                       ``* solve(n - 1, 1, k); ` `    ``} ` ` `  `    ``// If last is 0, then current ` `    ``// can only be non zero ` `    ``else` `{ ` ` `  `        ``// Memoize and return ` `        ``return` `dp[n][last] ` `               ``= solve(n - 1, k, k); ` `    ``} ` `} ` ` `  `// Driver Code ` `int` `main() ` `{ ` `    ``// Given N and K ` `    ``int` `n = 2, k = 3; ` ` `  `    ``// Function Call ` `    ``int` `x = solve(n, k, k) ` `            ``+ solve(n, 1, k); ` `    ``cout << x; ` `} `

## Java

 `// Java implementation to count the ` `// numbers upto N digits such that ` `// no two zeros are adjacent ` `class` `GFG{ ` `     `  `static` `int``[][] dp = ``new` `int``[``15``][``10``]; ` ` `  `// Function to count the numbers  ` `// upto N digits such that ` `// no two zeros are adjacent ` `static` `int` `solve(``int` `n, ``int` `last, ``int` `k) ` `{ ` `     `  `    ``// Condition to check if only ` `    ``// one element remains ` `    ``if` `(n == ``1``) ` `    ``{ ` `         `  `        ``// If last element is non ` `        ``// zero, return K-1 ` `        ``if` `(last == k) ` `        ``{ ` `            ``return` `(k - ``1``); ` `        ``} ` `         `  `        ``// If last element is 0 ` `        ``else`  `        ``{ ` `            ``return` `1``; ` `        ``} ` `    ``} ` ` `  `    ``// Condition to check if  ` `    ``// value calculated already ` `    ``if` `(dp[n][last] == ``1``) ` `        ``return` `dp[n][last]; ` ` `  `    ``// If last element is non zero, ` `    ``// then two cases arise, current  ` `    ``// element can be either zero  ` `    ``// or non zero ` `    ``if` `(last == k) ` `    ``{ ` `         `  `        ``// Memoize this case ` `        ``return` `dp[n][last] = (k - ``1``) * ` `                        ``solve(n - ``1``, k, k) +  ` `                             ``(k - ``1``) *  ` `                        ``solve(n - ``1``, ``1``, k); ` `    ``} ` `     `  `    ``// If last is 0, then current ` `    ``// can only be non zero ` `    ``else` `    ``{ ` ` `  `        ``// Memoize and return ` `        ``return` `dp[n][last] = solve(n - ``1``, k, k); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `main(String[] args) ` `{ ` `     `  `    ``// Given N and K ` `    ``int` `n = ``2``, k = ``3``; ` ` `  `    ``// Function Call ` `    ``int` `x = solve(n, k, k) +  ` `            ``solve(n, ``1``, k); ` `     `  `    ``System.out.print(x); ` `} ` `} ` ` `  `// This code is contributed by Ritik Bansal `

## Python3

 `# Python3 implementation to count the  ` `# numbers upto N digits such that  ` `# no two zeros are adjacent  ` `dp ``=` `[[``0``] ``*` `10` `for` `j ``in` `range``(``15``)] ` ` `  `# Function to count the numbers ` `# upto N digits such that no two ` `# zeros are adjacent  ` `def` `solve(n, last, k): ` ` `  `    ``# Condition to check if only  ` `    ``# one element remains  ` `    ``if` `(n ``=``=` `1``): ` ` `  `        ``# If last element is non  ` `        ``# zero, return K-1  ` `        ``if` `(last ``=``=` `k): ` `            ``return` `(k ``-` `1``) ` `         `  `        ``# If last element is 0  ` `        ``else``: ` `            ``return` `1` ` `  `    ``# Condition to check if value  ` `    ``# calculated already  ` `    ``if` `(dp[n][last]): ` `        ``return` `dp[n][last] ` ` `  `    ``# If last element is non zero,  ` `    ``# then two cases arise, current ` `    ``# element can be either zero or ` `    ``# non zero ` `    ``if` `(last ``=``=` `k): ` ` `  `        ``# Memoize this case ` `        ``dp[n][last] ``=` `((k ``-` `1``) ``*`  `                  ``solve(n ``-` `1``, k, k) ``+` `                       ``(k ``-` `1``) ``*`  `                  ``solve(n ``-` `1``, ``1``, k)) ` `                        `  `        ``return` `dp[n][last] ` ` `  `    ``# If last is 0, then current  ` `    ``# can only be non zero ` `    ``else``: ` ` `  `        ``# Memoize and return ` `        ``dp[n][last] ``=` `solve(n ``-` `1``, k, k) ` `        ``return` `dp[n][last] ` ` `  `# Driver code ` ` `  `# Given N and K ` `n ``=` `2` `k ``=` `3` ` `  `# Function call ` `x ``=` `solve(n, k, k) ``+` `solve(n, ``1``, k) ` ` `  `print``(x) ` ` `  `# This code is contributed by himanshu77 `

## C#

 `// C# implementation to count the ` `// numbers upto N digits such that ` `// no two zeros are adjacent ` `using` `System; ` ` `  `class` `GFG{ ` `     `  `public` `static` `int` `[,]dp = ``new` `int``[15, 10]; ` ` `  `// Function to count the numbers  ` `// upto N digits such that ` `// no two zeros are adjacent ` `public` `static` `int` `solve(``int` `n, ``int` `last, ``int` `k) ` `{ ` `     `  `    ``// Condition to check if only ` `    ``// one element remains ` `    ``if` `(n == 1) ` `    ``{ ` `         `  `        ``// If last element is non ` `        ``// zero, return K-1 ` `        ``if` `(last == k) ` `        ``{ ` `            ``return` `(k - 1); ` `        ``} ` `         `  `        ``// If last element is 0 ` `        ``else` `        ``{ ` `            ``return` `1; ` `        ``} ` `    ``} ` ` `  `    ``// Condition to check if  ` `    ``// value calculated already ` `    ``if` `(dp[n, last] == 1) ` `        ``return` `dp[n, last]; ` ` `  `    ``// If last element is non zero, ` `    ``// then two cases arise, current  ` `    ``// element can be either zero  ` `    ``// or non zero ` `    ``if` `(last == k) ` `    ``{ ` `         `  `        ``// Memoize this case ` `        ``return` `dp[n, last] = (k - 1) * ` `                        ``solve(n - 1, k, k) +  ` `                             ``(k - 1) *  ` `                        ``solve(n - 1, 1, k); ` `    ``} ` `     `  `    ``// If last is 0, then current ` `    ``// can only be non zero ` `    ``else` `    ``{ ` ` `  `        ``// Memoize and return ` `        ``return` `dp[n, last] = solve(n - 1, k, k); ` `    ``} ` `} ` ` `  `// Driver Code ` `public` `static` `void` `Main(``string``[] args) ` `{ ` `     `  `    ``// Given N and K ` `    ``int` `n = 2, k = 3; ` ` `  `    ``// Function Call ` `    ``int` `x = solve(n, k, k) +  ` `            ``solve(n, 1, k); ` `     `  `    ``Console.WriteLine(x); ` `} ` `} ` ` `  `// This code is contributed by SoumikMondal `

Output:

```8
```

Time Complexity: O(N)
Auxiliary Space: O(N*10) My Personal Notes arrow_drop_up Check out this Author's contributed articles.

If you like GeeksforGeeks and would like to contribute, you can also write an article using contribute.geeksforgeeks.org or mail your article to contribute@geeksforgeeks.org. See your article appearing on the GeeksforGeeks main page and help other Geeks.

Please Improve this article if you find anything incorrect by clicking on the "Improve Article" button below.

Be the First to upvote.

Please write to us at contribute@geeksforgeeks.org to report any issue with the above content.