Related Articles

# Count of N-digit numbers with absolute difference of adjacent digits not exceeding K

• Difficulty Level : Hard
• Last Updated : 21 Apr, 2021

Given two integers N and K, the task is to find the count of N-digit numbers such that the absolute difference of adjacent digits in the number is not greater than K.

Examples:

Input: N = 2, K = 1
Output: 26
Explanation: The numbers are 10, 11, 12, 21, 22, 23, 32, 33, 34, 43, 44, 45, 54, 55, 56, 65, 66, 67, 76, 77, 78, 87, 88, 89, 98, 99

Input: N = 3, K = 2
Output: 188

Naive Approach
The simplest approach is to iterate over all N digit numbers and check for every number if the adjacent digits have an absolute difference less than or equal to K.
Time Complexity: O(10N * N)

Efficient Approach:
To optimize the above approach, we need to use a Dynamic Programming approach along with Range Update

• Initialize a DP[][] array where dp[i][j] stores the count of numbers having i digits and ending with j.
• Iterate the array from 2 to N and check if the last digit was j, then the allowed digits for this place are in the range (max(0, j-k), min(9, j+k)). Perform a range update on this range.
• Now use Prefix Sum to get the actual answer.

Below is the implementation of the above approach:

## C++

 `// C++ implementation of``// the above approach``#include ``using` `namespace` `std;` `// Function to return count``// of N-digit numbers with``// absolute difference of``// adjacent digits not``// exceeding K``long` `long` `getCount(``int` `n, ``int` `k)``{``    ``// For 1-digit numbers,``    ``// the count is 10``    ``if` `(n == 1)``        ``return` `10;` `    ``long` `long` `dp[n + 1];` `    ``// dp[i][j] stores the number``    ``// of such i-digit numbers``    ``// ending in j``    ``for` `(``int` `i = 0; i <= n; i++) {``        ``for` `(``int` `j = 0; j < 11; j++)``            ``dp[i][j] = 0;``    ``}``    ``// Initialize count for``    ``// 1-digit numbers``    ``for` `(``int` `i = 1; i <= 9; i++)``        ``dp[i] = 1;` `    ``// Compute values for count of``    ``// digits greater than 1``    ``for` `(``int` `i = 2; i <= n; i++) {``        ``for` `(``int` `j = 0; j <= 9; j++) {` `            ``// Find the range of allowed``            ``// numbers if last digit is j``            ``int` `l = max(0, j - k);``            ``int` `r = min(9, j + k);` `            ``// Perform Range update``            ``dp[i][l] += dp[i - 1][j];``            ``dp[i][r + 1] -= dp[i - 1][j];``        ``}` `        ``// Prefix sum to find actual``        ``// values of i-digit numbers``        ``// ending in j``        ``for` `(``int` `j = 1; j <= 9; j++)``            ``dp[i][j] += dp[i][j - 1];``    ``}` `    ``// Stores the final answer``    ``long` `long` `count = 0;``    ``for` `(``int` `i = 0; i <= 9; i++)``        ``count += dp[n][i];` `    ``return` `count;``}` `// Driver Code``int` `main()``{``    ``int` `N = 2, K = 1;``    ``cout << getCount(N, K);``}`

## Java

 `// Java Program to implement``// the above approach``import` `java.util.*;``class` `GFG {` `    ``// Function to return count of such numbers``    ``public` `static` `long` `getCount(``int` `n, ``int` `k)``    ``{``        ``// For 1-digit numbers, the count``        ``// is 10 irrespective of K``        ``if` `(n == ``1``)``            ``return` `10``;` `        ``// dp[i][j] stores the number``        ``// of such i-digit numbers``        ``// ending in j``        ``long` `dp[][]``            ``= ``new` `long``[n + ``1``][``11``];` `        ``// Initialize count for``        ``// 1-digit numbers``        ``for` `(``int` `i = ``1``; i <= ``9``; i++)``            ``dp[``1``][i] = ``1``;` `        ``// Compute values for count of``        ``// digits greater than 1``        ``for` `(``int` `i = ``2``; i <= n; i++) {``            ``for` `(``int` `j = ``0``; j <= ``9``; j++) {` `                ``// Find the range of allowed``                ``// numbers if last digit is j``                ``int` `l = Math.max(``0``, j - k);``                ``int` `r = Math.min(``9``, j + k);` `                ``// Perform Range update``                ``dp[i][l] += dp[i - ``1``][j];``                ``dp[i][r + ``1``] -= dp[i - ``1``][j];``            ``}` `            ``// Prefix sum to find actual values``            ``// of i-digit numbers ending in j``            ``for` `(``int` `j = ``1``; j <= ``9``; j++)``                ``dp[i][j] += dp[i][j - ``1``];``        ``}` `        ``// Stores the final answer``        ``long` `count = ``0``;``        ``for` `(``int` `i = ``0``; i <= ``9``; i++)``            ``count += dp[n][i];``        ``return` `count;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `main(String[] args)``    ``{``        ``int` `n = ``2``, k = ``1``;``        ``System.out.println(getCount(n, k));``    ``}``}`

## Python3

 `# Python 3 Program to implement``# the above approach` `# Function to return count``# of N-digit numbers with``# absolute difference of``# adjacent digits not``# exceeding K``def` `getCount(n, k):` `    ``# For 1-digit numbers, the``    ``# count is 10``    ``if` `n ``=``=` `1``:``        ``return` `10``    ` `    ``# dp[i][j] stores the count of``    ``# i-digit numbers ending with j       ``    ``dp ``=` `[[``0` `for` `x ``in` `range``(``11``)]``            ``for` `y ``in` `range``(n ``+` `1``)];    ``    ` `    ` `    ``# Initialize count for``    ``# 1-digit numbers``    ``for` `i ``in` `range``(``1``, ``10``):``        ``dp[``1``][i]``=` `1``    ` `    ``# Compute values for count``    ``# of digits greater than 1``    ``for` `i ``in` `range``(``2``, n ``+` `1``):``        ``for` `j ``in` `range``(``0``, ``10``):``            ` `            ``# Find the range of allowed``            ``# numbers if last digit is j``            ``l ``=` `max``(``0``, j ``-` `k)``            ``r ``=` `min``(``9``, j ``+` `k)``                ` `            ``# Perform Range update``            ``dp[i][l] ``=` `dp[i][l] ``+` `dp[i``-``1``][j]``            ``dp[i][r ``+` `1``] ``=` `dp[i][r ``+` `1``] ``-` `dp[i``-``1``][j]``            ` `        ``# Prefix sum to find count of``        ``# of i-digit numbers ending with j``        ``for` `j ``in` `range``(``1``, ``10``):``            ``dp[i][j] ``=` `dp[i][j] ``+` `dp[i][j``-``1``]``    ` `    ``# Stores the final answer``    ``count ``=` `0``    ` `    ``for` `i ``in` `range``(``0``, ``10``):``        ``count ``=` `count ``+` `dp[n][i]``    ``return` `count` `# Driver Code``n, k ``=` `2``, ``1``print``(getCount(n, k))`

## C#

 `// C# Program to implement``// the above approach``using` `System;``class` `GFG {` `    ``// Function to return the``    ``// count of N-digit numbers``    ``// with absolute difference of``    ``// adjacent digits not exceeding K``    ``static` `long` `getCount(``int` `n, ``int` `k)``    ``{``        ``// For 1-digit numbers, the``        ``// count is 10``        ``if` `(n == 1)``            ``return` `10;` `        ``// dp[i][j] stores the count of``        ``// i-digit numbers ending with j``        ``long``[, ] dp = ``new` `long``[n + 1, 11];` `        ``// Initialize count for``        ``// 1-digit numbers``        ``for` `(``int` `i = 1; i <= 9; i++)``            ``dp[1, i] = 1;` `        ``// Compute values for count of``        ``// digits greater than 1``        ``for` `(``int` `i = 2; i <= n; i++) {``            ``for` `(``int` `j = 0; j <= 9; j++) {` `                ``// Find the range of allowed``                ``// numbers with last digit j``                ``int` `l = Math.Max(0, j - k);``                ``int` `r = Math.Min(9, j + k);` `                ``// Perform Range update``                ``dp[i, l] += dp[i - 1, j];``                ``dp[i, r + 1] -= dp[i - 1, j];``            ``}` `            ``// Prefix sum to count i-digit``            ``// numbers ending in j``            ``for` `(``int` `j = 1; j <= 9; j++)``                ``dp[i, j] += dp[i, j - 1];``        ``}` `        ``// Stores the final answer``        ``long` `count = 0;``        ``for` `(``int` `i = 0; i <= 9; i++)``            ``count += dp[n, i];``        ``return` `count;``    ``}` `    ``// Driver Code``    ``public` `static` `void` `Main()``    ``{``        ``int` `n = 2, k = 1;``        ``Console.WriteLine(getCount(n, k));``    ``}``}`

## Javascript

 ``
Output:
`26`

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

Attention reader! Don’t stop learning now. Get hold of all the important mathematical concepts for competitive programming with the Essential Maths for CP Course at a student-friendly price. To complete your preparation from learning a language to DS Algo and many more,  please refer Complete Interview Preparation Course.

My Personal Notes arrow_drop_up