数位动态规划：计数问题

题目描述

给定两个整数 a 和 b，求 a 和 b 之间的所有数字中0~9的出现次数。例如，a=1024，b=1032，则 a 和 b 之间共有9个数如下：

1024 1025 1026 1027 1028 1029 1030 1031 1032

其中‘0’出现10次，‘1’出现10次，‘2’出现7次，‘3’出现3次等等…

输入格式

输入包含多组测试数据。

每组测试数据占一行，包含两个整数 a 和 b。

当读入一行为0 0时，表示输入终止，且该行不作处理。

输出格式

每组数据输出一个结果，每个结果占一行。

每个结果包含十个用空格隔开的数字，第一个数字表示‘0’出现的次数，第二个数字表示‘1’出现的次数，以此类推。

数据范围

$0<a,b<100000000$

输入样例

1 10
44 497
346 542
1199 1748
1496 1403
1004 503
1714 190
1317 854
1976 494
1001 1960
0 0

输出样例

1 2 1 1 1 1 1 1 1 1
85 185 185 185 190 96 96 96 95 93
40 40 40 93 136 82 40 40 40 40
115 666 215 215 214 205 205 154 105 106
16 113 19 20 114 20 20 19 19 16
107 105 100 101 101 197 200 200 200 200
413 1133 503 503 503 502 502 417 402 412
196 512 186 104 87 93 97 97 142 196
398 1375 398 398 405 499 499 495 488 471
294 1256 296 296 296 296 287 286 286 247

算法思想（数位DP）

根据题目描述，要求的一段区间$[a,b]$范围内每个数字中$0-9$出现的次数，分析数据范围（$0<a,b<100000000$）可以发现，如果暴力枚举的话，一定会TLE。因此这里采用对数字每一位分情况讨论的思想，即数位DP。

定义函数count(n, x)求$1-n$中数字x出现的次数，那么$[a,b]$中x出现的次数，可以利用前缀和的思想求得：count(b, x) - count(a - 1, x)。

对于函数count(n, x)，可以分别求出x在数字$1-n$中每一位上出现的次数，枚举每一位进行累加即可。

因为计算每个数字的过程类似，不妨以x = 1为例，设n的值为abcdefg，那么$1-abcdefg$中第4位为1的数字xxx1yyy（1 <= xxx1yyy <= abcdefg），其总个数可以根据前3位xxx的大小分为2种情况进行统计：

• （1）xxx < abc，即0 <= xxx < abc - 1，有abc种方案（注意：如果统计的是 0 出现的次数时，那么 xxx 只有 1 ~ abc - 1，共 abc - 1 种方案）。那么后3位yyy可以随便取，即000 <= yyy <= 999，总方案数为abc * 1000。
• （2）xxx = abc，那么根据d值的不同继续细分
  • （2.1）d < 1， 那么abc1yyy一定大于abc0efg，所以方案数为0
  • （2.2）d = 1，后3位0 <= yyy <= efg，总方案数为efg + 1
  • （2.3）d > 1，那么后3位yyy可以随便取，即0 <= yyy <= 999，方案总数为1000

将所有情况累加起来，就是$[1,abcdefg]$中，第$4$位为1的所有方案数

例如，求1在$[1,1111]$中第3位（十位）上出现的次数：

• （1）xx < 11，0 <= xx <= 11，有12种方案；个位y可以随便取，即0 <= y <= 9，有10种方案，总方案数为110。
• （2）xx = 11，
  • （2.2） d = 1，最后1位0 <= y <= 1，一共2种方案

将所有情况累加起来，就是$[1,1111]$中、第$3$位为1的所有方案数112。

时间复杂度

函数count(n, x)采用分类讨论的方式计算$1-n$的中每一个数字中x出现的次数，其时间复杂度为n的位数相关。n在整数范围内，所以count(n, x)时间复杂度为$O(9^2)$。总的时间复杂度为$O(q\times 81)$，其中$q$为询问次数。

代码实现

#include <iostream>
#include <vector>

using namespace std;

//获取v中第l位到r位的数
int get(vector<int> v, int l, int r){
    int res = 0;
    for(int i = l; i >= r; i--)
        res = res * 10 + v[i];
    return res;
}

//求10的x次幂
int pow10(int x){
    int res = 1;
    while(x--) res *= 10;
    return res;
}

//求[1...n]中数x的出现个数
int count(int n, int x){
    if(n == 0) return 0; 
    vector<int> v; //v保存n的每一位
    while(n){
        v.push_back(n % 10);
        n /= 10;
    }
    n = v.size(); //n表示原数字位数
    int res = 0; //x的出现个数
    //从最高位开始遍历
    //如果统计的是0出现的次数，则从次高位开始遍历，去掉前导0的情况
    for(int i = n - 1 - !x; i >= 0; i-- ){
        //第1种情况：当xxx < abc时，那么 xxx 有 0 ~ abc - 1，共abc种选择，yyy有10^i种选择，总方案数为 abc × 10^i
        //当计算最高位时，第 1 种情况abc是不存在的，相当于从 000 ~ -1，
        //所以只累加其它位的第1种情况
        if(i < n - 1){
            // a   b   c   d   e   f   g   f
            //n-1          i
            //i 前面[n - 1 ... i + 1]
            //i 后面[i - 1 ... 0]，一共有i为
            res += get(v, n - 1, i + 1) * pow10(i);
            if(!x) //如果统计的是 0 出现的次数时，那么 xxx 只有 001 ~ abc - 1，共 abc - 1 种方案
                res -= pow10(i);
        }
        //第2种情况：当xxx = abc时，分情况讨论 abcdefg 中 d 的情况
        if(v[i] == x) //当 d = x 时，yyy 有 000 ~ efg 种选择，总方案数是 efg + 1
            res += get(v, i - 1, 0) + 1;
        else if(v[i] > x) //d > x时，yyy 有 10^i 种选择
            res += pow10(i);
    }
    return res;
}

int main(){
    int a, b;
    while(cin>>a>>b, a || b){ //a、b不同时为0
        if(a > b) swap(a, b);
        for(int i = 0; i < 10; i++)
            cout<<count(b, i) - count(a - 1, i)<<' ';
        cout<<endl;
    }
    return 0;
}