【经典算法题】数字1的个数

【经典算法题】数字1的个数

1. 典型例题

AcWing 338. 计数问题

问题描述

• 问题链接：AcWing 338. 计数问题

分析

• 考点：数位DP。考点详解网址：【动态规划】数位统计DP。

• 这一题首先需要转化一下，让我们求区间[a, b]之间各个数字出现的次数，利用前缀和的思想，假设count(n, i), 0<=i<=9可以求出1~n中i出现的次数，则最终i在[a, b]中出现的次数为count(b, i) - count(a - 1, i)。

• 下面的问题就转化为如何求1~n中某个数出现的次数，以出现1的次数为例，假设我们的数据是abcdefg，如果我们现在枚举千位是1有多少种方案，需要分类讨论（假设我们考虑的数据为xxx1yyy，则必须满足1<= xxx1yyy <=abcdeg）：

  （1）xxx=000~abc-1，则此时yyy可以取000~999，因此对应$abc\times 1000$种方案；

  （2）xxx=abc，此时还需要分为三种情况讨论：

  （2.1）d<1，此时xxx1yyy一定大于abcdefg，不存在合法情况；

  （2.2）d==1，此时yyy可以取000~efg，存在efg+1种合法情况；

  （2.3）d>1，此时yyy可以取000~999，一共有1000中合法情况。

• 对于求1~n中1、2、3、4、5、6、7、8、9都可以采用上述讨论，但是对于0出现的次数我们需要重新考虑，这是因为不能有前导0。

• 因为不能存在前导0，对于abcdefg，如果最高位a的位置放置0，则不合法，我们应该从次高位开始考虑，对于每一位，分类讨论：

  （1）xxx=001~abc-1，则此时yyy可以取000~999，因此对应$abc\times 1000-1000$种方案；

  （2）xxx=abc，此时还需要分为三种情况讨论：

  （2.1）d<0，不存在这种情况情况；

  （2.2）d==0，此时yyy可以取000~efg，存在efg+1种合法情况；

  （2.3）d>0，此时yyy可以取000~999，一共有1000中合法情况。

代码

• C++

#include <iostream>
#include <vector>
#include <algorithm>

using namespace std;

int count(int n, int x) {
    
    if (n == 0) return 0;
    
    vector<int> num;
    while (n) num.push_back(n % 10), n /= 10;
    reverse(num.begin(), num.end());
    
    int res = 0;
    for (int i = 0 + !x; i < num.size(); i++) {
        int left = 0, right = 0, p = 1;
        for (int j = 0; j < i; j++) left = left * 10 + num[j];
        for (int j = i + 1; j < num.size(); j++) {
            right = right * 10 + num[j];
            p *= 10;
        }
        
        int d = num[i];  // 当前第i位的真实数据
        if (x) {
            if (d < x) res += left * p;
            else if (d == x) res += left * p + right + 1;
            else res += (left + 1) * p;
        } else {  // 此时x为0
            if (d == x) res += (left - 1) * p + right + 1;
            else res += left * p;
        }
    }
    return res;
}

int main() {
    
    int a, b;
    while (cin >> a >> b, a || b) {
        if (a > b) swap(a, b);
        
        for (int i = 0; i <= 9; i++)
            cout << count(b, i) - count(a - 1, i) << ' ';
        cout << endl;
    }
    
    return 0;
}

2. 扩展例题

Leetcode 0233 数字 1 的个数

题目描述：Leetcode 0233 数字 1 的个数

分析

• 本题的考点：数学、数位统计。

• 这一题最直观的做法，就是枚举1~n中的每个数，然后将每个数中1的个数加到res中，最后返回res。但是这种做法时间复杂度太高了。

• 另一种做法是枚举每一位上1的个数，从高位开始枚举，假设我们的数据是abcdefg，如果我们现在枚举千位是1有多少种方案，需要分类讨论：

  （1）如果d==0，则d的左边可以取0~abc-1，右边可以取0~999，此时千位取1对应的数据都小于原数，一共$abc\times 1000$种方案；

  （2）如果d==1，同样左边可以取0~abc-1，右边可以取0~999，一共$abc\times 1000$种方案；另外左边可以取abc，右边可以取0~efg，对应$efg+1$种方案，因此一共$abc\times 1000+efg+1$种方案。

  （3）如果d>1，左边可以取0~abc，右边可以取0~999，一共$(abc+1)\times 1000$种方案。

• 下面的代码中用left记录上面演示的abc，用right记录上面演示的efg。

代码

• C++

class Solution {
public:
    int countDigitOne(int n) {
        
        if (n <= 0) return 0;
        vector<int> nums;
        while (n) nums.push_back(n % 10), n /= 10;
        reverse(nums.begin(), nums.end());  // 为了让nums[0]对应最高位
        int res = 0;
        for (int i = 0; i < nums.size(); i++) {
            int d = nums[i];
            int left = 0, right = 0, p = 1;  // p存储10的次幂
            for (int j = 0; j < i; j++) left = left * 10 + nums[j];
            for (int j = i + 1; j < nums.size(); j++) {
                right = right * 10 + nums[j];
                p *= 10;
            }
            if (d == 0) res += left * p;
            else if (d == 1) res += left * p + right + 1;
            else res += (left + 1) * p;
        }
        return res;
    }
};

• Java

class Solution {
    public int countDigitOne(int n) {

        if (n <= 0) return 0;
        int[] nums = new int[10];
        int len = 0;
        while (n != 0) {
            nums[len++] = n % 10; n /= 10;
        }
        // 此时nums[0]对应最低位
        int res = 0;
        for (int i = 0; i < len; i++) {
            int d = nums[i];
            int left = 0, right = 0, p = 1;  // p存储10的次幂
            for (int j = len - 1; j > i; j--) left = left * 10 + nums[j];
            for (int j = i - 1; j >= 0; j--) {
                right = right * 10 + nums[j];
                p *= 10;
            }
            if (d == 0) res += left * p;
            else if (d == 1) res += left * p + right + 1;
            else res += (left + 1) * p;
        }
        return res;
    }
}

时空复杂度分析

• 时间复杂度：$O(lo{g}^2(n))$。其实可以优化成$O(log(n))$的，只需要预处理出left、right即可。

• 空间复杂度：$O(1)$。

剑指 Offer 43 1～n 整数中 1 出现的次数

题目描述：剑指 Offer 43 1～n 整数中 1 出现的次数

分析

• 和 Leetcode 0233 数字 1 的个数 一样。

代码

• C++

class Solution {
public:
    int countDigitOne(int n) {
        
        if (n <= 0) return 0;
        vector<int> nums;
        while (n) nums.push_back(n % 10), n /= 10;
        reverse(nums.begin(), nums.end());  // 为了让nums[0]对应最高位
        int res = 0;
        for (int i = 0; i < nums.size(); i++) {
            int d = nums[i];
            int left = 0, right = 0, p = 1;  // p存储10的次幂
            for (int j = 0; j < i; j++) left = left * 10 + nums[j];
            for (int j = i + 1; j < nums.size(); j++) {
                right = right * 10 + nums[j];
                p *= 10;
            }
            if (d == 0) res += left * p;
            else if (d == 1) res += left * p + right + 1;
            else res += (left + 1) * p;
        }
        return res;
    }
};

时空复杂度分析

• 时间复杂度：$O(lo{g}^2(n))$。其实可以优化成$O(log(n))$的，只需要预处理出left、right即可。

• 空间复杂度：$O(1)$。