给定一个范围[L，R]以及两个正整数N和M。任务是对仅包含非零数字范围内的数字进行计数，这些数字的总和等于N且该数字可被M整除。
例子：
Input: L = 1, R = 100, N = 8, M = 2
Output: 4
Only 8, 26, 44 and 62 are valid numbers
Input: L = 1, R = 200, N = 4, M = 11
Output: 2
Only 22 and 121 are valid numbers
先决条件： Digit DP
方法：首先，如果我们能够计算所需的数字，直到R，即在[0，R]范围内，则可以通过求解从零到R的值，然后减去，可以很容易地在[L，R]范围内得出答案。从零到L – 1求解后得到的答案。现在，我们需要定义DP状态。
DP州：
- 既然我们可以考虑我们的号码作为数字序列，一个状态是，我们目前的位置，这个位置可以有值从0到18，如果我们用数字处理高达10 18。在每个递归调用中，我们尝试通过从0到9放置一个数字来从左到右构建序列。
- 第二个状态是到目前为止我们放置的数字的总和。
- 第三个状态是余数，它定义了到目前为止我们取模M的模数。
- 另一个状态是布尔变量tight ，它指示我们要构建的数字已经小于R，因此在接下来的递归调用中，我们可以将0到9之间的任何数字放置。如果数字没有变小，则为最大限制我们可以放置的位数是R中当前位置的位数。
对于仅具有非零数字的数字，我们维护一个变量nonz ，如果1告诉我们放置的数字中的第一个数字为非零数字，则其值将为nz ，因此，现在我们不能在即将到来的数字中放置任何零数字电话。否则，我们可以将零数字放在前导零处，以使当前数字中的数字数小于上限数。
下面是上述方法的实现：
C++
// C++ implementation of the approach
#include
using namespace std;
const int M = 20;
// states - position, sum, rem, tight
// sum can have values upto 162, if we
// are dealing with numbers upto 10^18
// when all 18 digits are 9, then sum
// is 18 * 9 = 162
int dp[M][165][M][2];
// n is the sum of digits and number should
// be divisible by m
int n, m;
// Function to return the count of
// required numbers from 0 to num
int count(int pos, int sum, int rem, int tight,
int nonz, vector num)
{
// Last position
if (pos == num.size()) {
if (rem == 0 && sum == n)
return 1;
return 0;
}
// If this result is already computed
// simply return it
if (dp[pos][sum][rem][tight] != -1)
return dp[pos][sum][rem][tight];
int ans = 0;
// Maximum limit upto which we can place
// digit. If tight is 1, means number has
// already become smaller so we can place
// any digit, otherwise num[pos]
int limit = (tight ? 9 : num[pos]);
for (int d = 0; d <= limit; d++) {
// If the current digit is zero
// and nonz is 1, we can't place it
if (d == 0 && nonz)
continue;
int currSum = sum + d;
int currRem = (rem * 10 + d) % m;
int currF = tight || (d < num[pos]);
ans += count(pos + 1, currSum, currRem,
currF, nonz || d, num);
}
return dp[pos][sum][rem][tight] = ans;
}
// Function to convert x into its digit vector
// and uses count() function to return the
// required count
int solve(int x)
{
vector num;
while (x) {
num.push_back(x % 10);
x /= 10;
}
reverse(num.begin(), num.end());
// Initialize dp
memset(dp, -1, sizeof(dp));
return count(0, 0, 0, 0, 0, num);
}
// Driver code
int main()
{
int L = 1, R = 100;
n = 8, m = 2;
cout << solve(R) - solve(L);
return 0;
} Java
// Java implementation of the approach
import java.util.*;
class GFG
{
static int M = 20;
// states - position, sum, rem, tight
// sum can have values upto 162, if we
// are dealing with numbers upto 10^18
// when all 18 digits are 9, then sum
// is 18 * 9 = 162
static int dp[][][][] = new int [M][165][M][2];
// n is the sum of digits and number should
// be divisible by m
static int n, m;
// Function to return the count of
// required numbers from 0 to num
static int count(int pos, int sum, int rem, int tight,
int nonz, Vector num)
{
// Last position
if (pos == num.size())
{
if (rem == 0 && sum == n)
return 1;
return 0;
}
// If this result is already computed
// simply return it
if (dp[pos][sum][rem][tight] != -1)
return dp[pos][sum][rem][tight];
int ans = 0;
// Maximum limit upto which we can place
// digit. If tight is 1, means number has
// already become smaller so we can place
// any digit, otherwise num[pos]
int limit = (tight != 0 ? 9 : num.get(pos));
for (int d = 0; d <= limit; d++)
{
// If the current digit is zero
// and nonz is 1, we can't place it
if (d == 0 && nonz != 0)
continue;
int currSum = sum + d;
int currRem = (rem * 10 + d) % m;
int currF = (tight != 0 || (d < num.get(pos))) ? 1 : 0;
ans += count(pos + 1, currSum, currRem,
currF, (nonz != 0 || d != 0) ? 1 : 0, num);
}
return dp[pos][sum][rem][tight] = ans;
}
// Function to convert x into its digit vector
// and uses count() function to return the
// required count
static int solve(int x)
{
Vector num = new Vector();
while (x != 0)
{
num.add(x % 10);
x /= 10;
}
Collections.reverse(num);
// Initialize dp
for(int i = 0; i < M; i++)
for(int j = 0; j < 165; j++)
for(int k = 0; k < M; k++)
for(int l = 0; l < 2; l++)
dp[i][j][k][l]=-1;
return count(0, 0, 0, 0, 0, num);
}
// Driver code
public static void main(String args[])
{
int L = 1, R = 100;
n = 8; m = 2;
System.out.print( solve(R) - solve(L));
}
}
// This code is contributed by Arnab Kundu Python3
# Python3 implementation of the approach
# Function to return the count of
# required numbers from 0 to num
def count(pos, Sum, rem, tight, nonz, num):
# Last position
if pos == len(num):
if rem == 0 and Sum == n:
return 1
return 0
# If this result is already computed
# simply return it
if dp[pos][Sum][rem][tight] != -1:
return dp[pos][Sum][rem][tight]
ans = 0
# Maximum limit upto which we can place
# digit. If tight is 1, means number has
# already become smaller so we can place
# any digit, otherwise num[pos]
if tight:
limit = 9
else:
limit = num[pos]
for d in range(0, limit + 1):
# If the current digit is zero
# and nonz is 1, we can't place it
if d == 0 and nonz:
continue
currSum = Sum + d
currRem = (rem * 10 + d) % m
currF = int(tight or (d < num[pos]))
ans += count(pos + 1, currSum, currRem,
currF, nonz or d, num)
dp[pos][Sum][rem][tight] = ans
return ans
# Function to convert x into its digit
# vector and uses count() function to
# return the required count
def solve(x):
num = []
global dp
while x > 0:
num.append(x % 10)
x //= 10
num.reverse()
# Initialize dp
dp = [[[[-1, -1] for i in range(M)]
for j in range(165)]
for k in range(M)]
return count(0, 0, 0, 0, 0, num)
# Driver code
if __name__ == "__main__":
L, R = 1, 100
# n is the sum of digits and number
# should be divisible by m
n, m, M = 8, 2, 20
# States - position, sum, rem, tight
# sum can have values upto 162, if we
# are dealing with numbers upto 10^18
# when all 18 digits are 9, then sum
# is 18 * 9 = 162
dp = []
print(solve(R) - solve(L))
# This code is contributed by Rituraj JainC#
// C# implementation of the approach
using System;
using System.Collections.Generic;
class GFG
{
static int M = 20;
// states - position, sum, rem, tight
// sum can have values upto 162, if we
// are dealing with numbers upto 10^18
// when all 18 digits are 9, then sum
// is 18 * 9 = 162
static int [,,,]dp = new int [M, 165, M, 2];
// n is the sum of digits and number should
// be divisible by m
static int n, m;
// Function to return the count of
// required numbers from 0 to num
static int count(int pos, int sum, int rem, int tight,
int nonz, List num)
{
// Last position
if (pos == num.Count)
{
if (rem == 0 && sum == n)
return 1;
return 0;
}
// If this result is already computed
// simply return it
if (dp[pos,sum,rem,tight] != -1)
return dp[pos,sum,rem,tight];
int ans = 0;
// Maximum limit upto which we can place
// digit. If tight is 1, means number has
// already become smaller so we can place
// any digit, otherwise num[pos]
int limit = (tight != 0 ? 9 : num[pos]);
for (int d = 0; d <= limit; d++)
{
// If the current digit is zero
// and nonz is 1, we can't place it
if (d == 0 && nonz != 0)
continue;
int currSum = sum + d;
int currRem = (rem * 10 + d) % m;
int currF = (tight != 0 || (d < num[pos])) ? 1 : 0;
ans += count(pos + 1, currSum, currRem,
currF, (nonz != 0 || d != 0) ? 1 : 0, num);
}
return dp[pos, sum, rem, tight] = ans;
}
// Function to convert x into its digit vector
// and uses count() function to return the
// required count
static int solve(int x)
{
List num = new List();
while (x != 0)
{
num.Add(x % 10);
x /= 10;
}
num.Reverse();
// Initialize dp
for(int i = 0; i < M; i++)
for(int j = 0; j < 165; j++)
for(int k = 0; k < M; k++)
for(int l = 0; l < 2; l++)
dp[i, j, k, l] = -1;
return count(0, 0, 0, 0, 0, num);
}
// Driver code
public static void Main(String []args)
{
int L = 1, R = 100;
n = 8; m = 2;
Console.Write( solve(R) - solve(L));
}
}
// This code has been contributed by 29AjayKumar Python3
# User Input
l, r, n, m = 1, 100, 8, 2
# Initialize Result
output = []
# Traverse through all numbers
for x in range(l, r+1):
# Check for all conditions in every number
if sum([int(k) for k in str(x)]) == n and x % m == 0 and '0' not in str(x): # Check conditions
output.append(x)
print(len(output))
# This code is contributed by mailprakashindia输出：
4
简短的Python实现：
Python3
# User Input
l, r, n, m = 1, 100, 8, 2
# Initialize Result
output = []
# Traverse through all numbers
for x in range(l, r+1):
# Check for all conditions in every number
if sum([int(k) for k in str(x)]) == n and x % m == 0 and '0' not in str(x): # Check conditions
output.append(x)
print(len(output))
# This code is contributed by mailprakashindia
如果您希望与行业专家一起参加现场课程，请参阅《 Geeks现场课程》和《 Geeks现场课程美国》。