Count number of integers in given range with adjacent digits different and sum of digits equal to M

// Java code to implement the approach
import java.io.*;
import java.util.*;

class GFG {

  static final int MOD = (int)1e9 + 7;
  static int dp[][][][];

  // Dp table initialized with -1
  static void memset(int[][][][] dp)
  {
    for (int i = 0; i < 21; i++) {
      dp[i] = new int[21][10][190];
      for (int j = 0; j < 21; j++) {
        for (int k = 0; k < 10; k++) {
          Arrays.fill(dp[i][j][k], -1);
        }
      }
    }
  }

  // Recursive Function to find numbers in the range A to
  // B such that adjacent digits are different and their
  // sum is equal to T
  static int recur(int i, int j, int k, int sum, int T,
                   char a[])
  {
    // Base case
    if (i == a.length) {

      // If current sum is equal to T
      if (sum == T) {
        return 1;
      }

      // If not equal to T
      else {
        return 0;
      }
    }

    // If answer for current state is already calculated
    // then just return dp[i][j][k][sum]
    if (dp[i][j][k][sum] != -1) {
      return dp[i][j][k][sum];
    }

    // Answer initialized with zero
    int ans = 0;

    // Choosing first value
    if (i == 0) {

      // Iterating from 0 to maxvalue
      // of digit current position
      // can have
      for (int l = 0; l <= (a[j] - '0'); l++) {

        // l is maximum value of digit
        if (l == (a[j] - '0')) {

          // Calling recursive function
          // for selecting last max digit
          // for current position
          ans += recur(i + 1, j + 1, l, sum + l,
                       T, a);
        }
        else {

          // Calling recursive function
          // for selecting l as current
          // digit and its not max digit
          ans += recur(i + 1, j, l, sum + l, T,
                       a);
        }
      }
    }
    else {

      // Digits taken till now were
      // all zero
      if (sum == 0) {

        // All digits can be possible
        // from 0 to 9
        for (int l = 0; l <= 9; l++) {

          // Calling recursive function
          // for all digits from 0 to 9
          ans += recur(i + 1, j, l, sum + l, T,
                       a);
        }
      }

      // Already non zero digits are taken
      else {

        // Iterating from 0 to 9
        for (int l = 0; l <= 9; l++) {

          // If max digit was taken
          // last time
          if (j == i) {

            // If current digit
            // is different
            if (l <= (a[j] - '0') && l != k) {

              // max digit taken calling
              // recursive function
              if (l == (a[j] - '0')) {
                ans += recur(i + 1, j + 1,
                             l, sum + l, T,
                             a);
              }

              // Calling recursive
              // function for non
              // max digit
              else {
                ans += recur(i + 1, j, l,
                             sum + l, T, a);
              }
            }
          }

          // If max digit was not taken
          else if (l != k) {
            ans += recur(i + 1, j, l, sum + l,
                         T, a);
          }
        }
      }
    }

    // Save and return dp value
    return dp[i][j][k][sum] = ans;
  }

  // Function to find numbers
  // in the range A to B such that adjacent
  // digits are different and their sum is
  // equal to T
  static int countInRange(int T, int A, int B)
  {
    dp = new int[21][21][10][190];

    // Initializing dp array with - 1
    memset(dp);
    String L = Integer.toString(A - 1);
    String R = Integer.toString(B);

    // Numbers with sum of digits T from
    // 1 to L - 1
    int ans1 = recur(0, 0, 0, 0, T, L.toCharArray());

    // Initializing dp array with - 1
    memset(dp);

    // Numbers with sum of digits T in
    // the range 1 to R
    int ans2 = recur(0, 0, 0, 0, T, R.toCharArray());

    // Difference of ans2 and ans1
    // will generate answer for
    // required range
    return ans2 - ans1;
  }

  public static void main(String[] args)
  {
    // Input 1
    int T = 5, A = 1, B = 100;

    // Function Call
    System.out.println(countInRange(T, A, B));

    // Input 2
    int T1 = 5, A1 = 1, B1 = 100000000;

    // Function Call
    System.out.println(countInRange(T1, A1, B1));
  }
}

// This code is contributed by lokeshmvs21.