Count of N-digit numbers whose absolute difference between adjacent digits is non-increasing

Given a positive integer N, the task is to count the number of N-digit numbers having absolute difference between consecutive digits in non-increasing order.

Examples:

Input: N = 1
Output: 10
Explanation:
All numbers from 0 to 9 satisfy the given condition as there is only one digit.

Input: N = 3
Output: 495

Naive Approach: The simplest approach to solve the given problem is to iterate over all possible N-digit numbers and count those numbers whose digits are in non-increasing order. After checking for all the numbers, print the value of count as the result. 

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

Efficient Approach: The above approach can also be optimized by using Dynamic Programming because the above problem has Overlapping subproblems and Optimal substructure. The subproblems can be stored in dp[][][] table using memoization where dp[digit][prev1][prev2] stores the answer from the digit^th position till the end, when the previous digit selected, is prev1 and the second previous digit selected is prev2. Follow the steps below to solve the problem:

• Define a recursive function, say countOfNumbers(digit, prev1, prev2) by performing the following steps.
  • If the value of digit is equal to N + 1 then return 1 as a valid N-digit number is formed.
  • If the result of the state dp[digit][prev1][prev2] is already computed, return this state dp[digit][prev1][prev2].
  • If the current digit is 1, then any digit from [1, 9] can be placed. If N = 1, then 0 can be placed as well.
  • If the current digit is 2, then any digit from [0, 9] can be placed.
  • Otherwise iterate through all the numbers from i = 0 to i = 9, and check if the condition (abs(prev1 – i) <= abs(prev1 – prev2) ) holds valid or not and accordingly place satisfying ‘i’ values in the current position.
  • After making a valid placement, recursively call the countOfNumbers function for index (digit + 1).
  • Return the sum of all possible valid placements of digits as the answer.
• Print the value returned by the function countOfNumbers(1, 0, 0, N) as the result.

Below is the implementation of the above approach:

C++

// C++ program for the above approach

#include <bits/stdc++.h>
using namespace std;

int dp[100][10][10];

// Function to count N-digit numbers
// having absolute difference between
// adjacent digits in non-increasing order
int countOfNumbers(int digit, int prev1,
                   int prev2, int n)
{
    // If digit = n + 1, a valid
    // n-digit number has been formed
    if (digit == n + 1) {
        return 1;
    }

    // If the state has
    // already been computed
    int& val = dp[digit][prev1][prev2];

    if (val != -1) {
        return val;
    }
    val = 0;

    // If the current digit is 1,
    // then any digit from [1-9]
    // can be placed
    if (digit == 1) {

        for (int i = (n == 1 ? 0 : 1);
             i <= 9; ++i) {
            val += countOfNumbers(
                digit + 1, i, prev1, n);
        }
    }

    // If the current digit is 2, any
    // digit from [0-9] can be placed
    else if (digit == 2) {

        for (int i = 0; i <= 9; ++i) {

            val += countOfNumbers(
                digit + 1, i, prev1, n);
        }
    }

    // For other digits, any digit i
    // can be placed which satisfies
    // abs(prev1 - i) <= abs(prev1 - prev2)
    else {
        int diff = abs(prev2 - prev1);

        for (int i = 0; i <= 9; ++i) {

            // If absolute difference is
            // less than or equal to diff
            if (abs(prev1 - i) <= diff) {

                val += countOfNumbers(
                    digit + 1, i,
                    prev1, n);
            }
        }
    }
    return val;
}

// Function to count N-digit numbers with
// absolute difference between adjacent
// digits in non increasing order
int countNumbersUtil(int N)
{
    // Initialize dp table with -1
    memset(dp, -1, sizeof dp);

    // Function Call
    cout << countOfNumbers(1, 0, 0, N);
}

// Driver code
int main()
{
    int N = 3;
    countNumbersUtil(N);

    return 0;
}

Java

// Java program for the above approach
import java.io.*;

class GFG{

static int dp[][][] = new int[100][10][10];

// Function to count N-digit numbers
// having absolute difference between
// adjacent digits in non-increasing order
static int countOfNumbers(int digit, int prev1,
                          int prev2, int n)
{

    // If digit = n + 1, a valid
    // n-digit number has been formed
    if (digit == n + 1)
    {
        return 1;
    }

    // If the state has
    // already been computed
    int val = dp[digit][prev1][prev2];

    if (val != -1)
    {
        return val;
    }
    val = 0;

    // If the current digit is 1,
    // then any digit from [1-9]
    // can be placed
    if (digit == 1)
    {
        for(int i = (n == 1 ? 0 : 1);
                i <= 9; ++i)
        {
            val += countOfNumbers(
                digit + 1, i, prev1, n);
        }
    }

    // If the current digit is 2, any
    // digit from [0-9] can be placed
    else if (digit == 2)
    {
        for(int i = 0; i <= 9; ++i)
        {
            val += countOfNumbers(
                digit + 1, i, prev1, n);
        }
    }

    // For other digits, any digit i
    // can be placed which satisfies
    // abs(prev1 - i) <= abs(prev1 - prev2)
    else
    {
        int diff = Math.abs(prev2 - prev1);

        for(int i = 0; i <= 9; ++i)
        {

            // If absolute difference is
            // less than or equal to diff
            if (Math.abs(prev1 - i) <= diff)
            {
                val += countOfNumbers(
                    digit + 1, i,
                    prev1, n);
            }
        }
    }
    return val;
}

// Function to count N-digit numbers with
// absolute difference between adjacent
// digits in non increasing order
static void countNumbersUtil(int N)
{

    // Initialize dp table with -1
    for(int i = 0; i < 100; i++)
    {
        for(int j = 0; j < 10; j++)
        {
            for(int k = 0; k < 10; k++)
            {
                dp[i][j][k] = -1;
            }
        }
    }

    // Function Call
    System.out.println(countOfNumbers(1, 0, 0, N));
}

// Driver code
public static void main(String[] args)
{
    int N = 3;

    countNumbersUtil(N);
}
}

// This code is contributed by Dharanendra L V.

Python3

# Python3 program for the above approach
dp = [[[0 for i in range(10)]
          for col in range(10)]
          for row in range(100)]

# Function to count N-digit numbers
# having absolute difference between
# adjacent digits in non-increasing order
def countOfNumbers(digit, prev1, prev2, n):

    # If digit = n + 1, a valid
    # n-digit number has been formed
    if (digit == n + 1):
        return 1

    # If the state has
    # already been computed
    val = dp[digit][prev1][prev2]

    if (val != -1):
        return val

    val = 0

    # If the current digit is 1,
    # then any digit from [1-9]
    # can be placed
    if (digit == 1):
        i = 1
        if n == 1:
            i = 0

        for j in range(i, 10):
            val += countOfNumbers(digit + 1, j, prev1, n)

    # If the current digit is 2, any
    # digit from [0-9] can be placed
    elif (digit == 2):
        for i in range(0, 10):
            val += countOfNumbers(digit + 1, i, prev1, n)

    # For other digits, any digit i
    # can be placed which satisfies
    # abs(prev1 - i) <= abs(prev1 - prev2)
    else:
        diff = abs(prev2 - prev1)
        for i in range(0, 10):

            # If absolute difference is
            # less than or equal to diff
            if (abs(prev1 - i) <= diff):
                val += countOfNumbers(digit + 1, i, prev1, n)
    return val

# Function to count N-digit numbers with
# absolute difference between adjacent
# digits in non increasing order
def countNumbersUtil(N):

    # Initialize dp table with -1
    for i in range(0, 100):
        for j in range(0, 10):
            for k in range(0, 10):
                dp[i][j][k] = -1

    # Function Call
    print(countOfNumbers(1, 0, 0, N))

# Driver code
N = 3

countNumbersUtil(N)

# This code is contributed by amreshkumar3

C#

// C# program for the above approach
using System;

class GFG{

static int[,,] dp = new int[100, 10, 10];

// Function to count N-digit numbers
// having absolute difference between
// adjacent digits in non-increasing order
static int countOfNumbers(int digit, int prev1,
                          int prev2, int n)
{

    // If digit = n + 1, a valid
    // n-digit number has been formed
    if (digit == n + 1)
    {
        return 1;
    }

    // If the state has
    // already been computed
    int val = dp[digit, prev1, prev2];

    if (val != -1)
    {
        return val;
    }
    val = 0;

    // If the current digit is 1,
    // then any digit from [1-9]
    // can be placed
    if (digit == 1)
    {
        for(int i = (n == 1 ? 0 : 1);
                i <= 9; ++i)
        {
            val += countOfNumbers(
                digit + 1, i, prev1, n);
        }
    }

    // If the current digit is 2, any
    // digit from [0-9] can be placed
    else if (digit == 2)
    {
        for(int i = 0; i <= 9; ++i)
        {
            val += countOfNumbers(
                digit + 1, i, prev1, n);
        }
    }

    // For other digits, any digit i
    // can be placed which satisfies
    // abs(prev1 - i) <= abs(prev1 - prev2)
    else
    {
        int diff = Math.Abs(prev2 - prev1);

        for(int i = 0; i <= 9; ++i)
        {

            // If absolute difference is
            // less than or equal to diff
            if (Math.Abs(prev1 - i) <= diff)
            {
                val += countOfNumbers(
                    digit + 1, i,
                    prev1, n);
            }
        }
    }
    return val;
}

// Function to count N-digit numbers with
// absolute difference between adjacent
// digits in non increasing order
static void countNumbersUtil(int N)
{

    // Initialize dp table with -1
    for(int i = 0; i < 100; i++)
    {
        for(int j = 0; j < 10; j++)
        {
            for(int k = 0; k < 10; k++)
            {
                dp[i, j, k] = -1;
            }
        }
    }

    // Function Call
    Console.WriteLine(countOfNumbers(1, 0, 0, N));
}

// Driver code
static public void Main()
{
    int N = 3;

    countNumbersUtil(N);
}
}

// This code is contributed by splevel62

Javascript

<script>
// javascript program for the above approach

     var dp = Array(100).fill().map(() => Array(10).fill(0).map(()=>Array(10).fill(0)));

    // Function to count N-digit numbers
    // having absolute difference between
    // adjacent digits in non-increasing order
    function countOfNumbers(digit , prev1 , prev2 , n) {

        // If digit = n + 1, a valid
        // n-digit number has been formed
        if (digit == n + 1) {
            return 1;
        }

        // If the state has
        // already been computed
        var val = dp[digit][prev1][prev2];

        if (val != -1) {
            return val;
        }
        val = 0;

        // If the current digit is 1,
        // then any digit from [1-9]
        // can be placed
        if (digit == 1) {
            for (var i = (n == 1 ? 0 : 1); i <= 9; ++i) {
                val += countOfNumbers(digit + 1, i, prev1, n);
            }
        }

        // If the current digit is 2, any
        // digit from [0-9] can be placed
        else if (digit == 2) {
            for (var i = 0; i <= 9; ++i) {
                val += countOfNumbers(digit + 1, i, prev1, n);
            }
        }

        // For other digits, any digit i
        // can be placed which satisfies
        // abs(prev1 - i) <= abs(prev1 - prev2)
        else {
            var diff = Math.abs(prev2 - prev1);

            for (var i = 0; i <= 9; ++i) {

                // If absolute difference is
                // less than or equal to diff
                if (Math.abs(prev1 - i) <= diff) {
                    val += countOfNumbers(digit + 1, i, prev1, n);
                }
            }
        }
        return val;
    }

    // Function to count N-digit numbers with
    // absolute difference between adjacent
    // digits in non increasing order
    function countNumbersUtil(N) {

        // Initialize dp table with -1
        for (var i = 0; i < 100; i++) {
            for (var j = 0; j < 10; j++) {
                for (var k = 0; k < 10; k++) {
                    dp[i][j][k] = -1;
                }
            }
        }

        // Function Call
        document.write(countOfNumbers(1, 0, 0, N));
    }

    // Driver code
        var N = 3;
        countNumbersUtil(N);

// This code is contributed by gauravrajput1
</script>

Output

495

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