Skip to content
Related Articles
Count of numbers upto N digits formed using digits 0 to K-1 without any adjacent 0s
• Difficulty Level : Hard
• Last Updated : 29 Apr, 2021

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[15][10];` `// 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`

Javascript

 ``
Output:
`8`

Time Complexity: O(N)
Auxiliary Space: O(N*10)

Attention reader! Don’t stop learning now. Get hold of all the important DSA concepts with the DSA Self Paced Course at a student-friendly price and become industry ready.  To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

In case you wish to attend live classes with industry experts, please refer Geeks Classes Live

My Personal Notes arrow_drop_up