K 的倍数或个位是 K

题目链接

题目分析

我们需要计算在区间 [l, r] 内满足以下条件之一的整数的个数：

1. 是 k 的倍数。
2. 个位上是 k。

由于这两个条件可能有重叠（即一个数既是 k 的倍数，个位又是 k），我们需要使用容斥原理来避免重复计算。

容斥原理

设：

• A 为区间 [l, r] 内是 k 的倍数的数的集合。
• B 为区间 [l, r] 内个位是 k 的数的集合。

我们需要计算的是 |A ∪ B|，即 A 和 B 的并集的大小。根据容斥原理：
$$|A\cup B|=|A|+|B|-|A\cap B|$$

其中：

• |A| 是区间 [l, r] 内是 k 的倍数的数的个数。
• |B| 是区间 [l, r] 内个位是 k 的数的个数。
• |A ∩ B| 是区间 [l, r] 内既是 k 的倍数，个位又是 k 的数的个数。

计算方法

1. 计算 |A|：

   • 区间 [l, r] 内是 k 的倍数的数的个数为：
     $$|A|=\lfloor \frac{r}{k}\rfloor -\lfloor \frac{l-1}{k}\rfloor$$

2. 计算 |B|：

   • 个位是 k 的数可以表示为 10a + k，其中 a 是任意非负整数。
   • 区间 [l, r] 内个位是 k 的数的个数为：
     $$|B|=\lfloor \frac{r-k}{10}\rfloor -\lfloor \frac{l-1-k}{10}\rfloor +1$$

3. 计算 |A ∩ B|：

   • 既是 k 的倍数，个位又是 k 的数需要满足：
     $$10a+k\equiv 0(\mathrm{mod}k)$$
     化简得：
     $$10a\equiv -k(\mathrm{mod}k)⟹10a\equiv 0(\mathrm{mod}k)$$
     因为 10a 必须是 k 的倍数，所以 a 必须是 k / \gcd(10, k) 的倍数。
   • 设 d = \gcd(10, k)，则符合条件的数为：
     $$10\cdot \left(\frac{k}{d}\cdot t\right)+k=\frac{10k}{d}\cdot t+k$$
     这是一个等差数列，首项为 k，公差为 10k / d。
   • 区间 [l, r] 内符合条件的数的个数为：
     $$|A\cap B|=\lfloor \frac{r-k}{10k/d}\rfloor -\lfloor \frac{l-1-k}{10k/d}\rfloor +1$$

4. 最终结果：

   • 使用容斥原理计算：
     $$|A\cup B|=|A|+|B|-|A\cap B|$$

代码实现

以下是 C++ 实现代码：

#include <iostream>
#include <algorithm>
using namespace std;

// 计算最大公约数
int gcd(int a, int b) {
    return b == 0 ? a : gcd(b, a % b);
}

// 计算区间 [l, r] 内是 k 的倍数的数的个数
int countMultiples(int l, int r, int k) {
    return r / k - (l - 1) / k;
}

// 计算区间 [l, r] 内个位是 k 的数的个数
int countLastDigitK(int l, int r, int k) {
    return (r - k) / 10 - (l - 1 - k) / 10 + 1;
}

// 计算区间 [l, r] 内既是 k 的倍数，个位又是 k 的数的个数
int countBoth(int l, int r, int k) {
    int d = gcd(10, k);
    int step = 10 * k / d;
    return (r - k) / step - (l - 1 - k) / step + 1;
}

int main() {
    int n, k;
    cin >> n >> k;

    while (n--) {
        int l, r;
        cin >> l >> r;

        // 计算 |A|, |B|, |A ∩ B|
        int multiples = countMultiples(l, r, k);
        int lastDigitK = countLastDigitK(l, r, k);
        int both = countBoth(l, r, k);

        // 使用容斥原理计算 |A ∪ B|
        int result = multiples + lastDigitK - both;
        cout << result << endl;
    }

    return 0;
}

代码说明

1. gcd 函数：计算两个数的最大公约数。
2. countMultiples 函数：计算区间 [l, r] 内是 k 的倍数的数的个数。
3. countLastDigitK 函数：计算区间 [l, r] 内个位是 k 的数的个数。
4. countBoth 函数：计算区间 [l, r] 内既是 k 的倍数，个位又是 k 的数的个数。
5. 主函数：读取输入，调用上述函数计算结果，并输出。

示例运行

输入：

5 3
1 10
11 1000
111 10000
1111 100000
11111 1000000

输出：

3
396
3956
39555
395556

复杂度分析

• 时间复杂度：每个查询的时间复杂度为 $O(1)$，总复杂度为 $O(n)$。
• 空间复杂度：$O(1)$，仅使用常数空间。

希望这段代码和解释对你有帮助！