HDOJ 4722Good Numbers 数位DP

Good Numbers

Time Limit: 2000/1000 MS (Java/Others)    Memory Limit: 32768/32768 K (Java/Others)
Total Submission(s): 3861    Accepted Submission(s): 1229

Problem Description

If we sum up every digit of a number and the result can be exactly divided by 10, we say this number is a good number.
You are required to count the number of good numbers in the range from A to B, inclusive.

 

Input

The first line has a number T (T <= 10000) , indicating the number of test cases.
Each test case comes with a single line with two numbers A and B (0 <= A <= B <= 10 ¹⁸).

 

Output

For test case X, output "Case #X: " first, then output the number of good numbers in a single line.

 

Sample Input

  
  

   
   2
1 10
1 20
  
  

 

Sample Output

  
  

   
   Case #1: 0
Case #2: 1

   
   

    
    

     
     Hint
    
    
The answer maybe very large, we recommend you to use long long instead of int.

   
   
   
    
  
  

#include <cstdio>
#include <cstring>

typedef long long LL;
const int N = 25;
LL dp[N][N];

void init() {
    dp[0][0] = 1;
    for (int i = 0; i < 10; ++i)
        dp[1][i] = 1;
    for (int i = 2; i < N; ++i) {
        for (int j = 0; j < 10; ++j)
            for (int k = 0; k < 10; ++k)
                dp[i][(j + k) % 10] += dp[i - 1][j];
    }
}

LL solve(LL x) {
    if (x < 0) return 0;
    LL ans = 0;
    int len = 0;
    int bit[N]; 
    while (x > 0) {
        bit[++len] = x % 10;
        x /= 10;
    }
    int tt = 0;
    for (int i = len; i > 0; --i) {
        for (int j = 0; j < bit[i]; ++j)
            tt++;
    }
    int carry = 0;
    for (int i = len; i > 0; --i) {
        for (int j = 0; j < bit[i]; ++j) {
            ans += dp[i - 1][(10 - carry) % 10];
            carry = (carry + 1) % 10;
        }
    }

    if (carry % 10 == 0)
        ++ans;

    return ans;
}

int main() {
    int T;
    int cnt = 0;
    init();
    scanf("%d", &T);
    while (T--) {
        LL a, b;
        scanf("%lld%lld", &a, &b);
        printf("Case #%d: %lld\n", ++cnt, solve(b) - solve(a - 1));
    }

    return 0;
}