串联数字

串联数字

给定 $n$ 个正整数 $a_1,a_2, \dots ,a_n$。

我们规定将正整数 $a_i$ 和 $a_j$ 串联是指将 $a_j$ 直接接在 $a_i$ 后面构成一个新整数。

例如，$12$ 和 $34$ 串联得到 $1234$，$34$ 和 $12$ 串联得到 $3412$。

现在，给定一个正整数 $k$，请你计算有多少个有序数对 $(i,j)(i \ne j)$ 满足，$a_i$ 和 $a_j$ 串联得到的整数能够被 $k$ 整除。

输入格式

第一行包含两个整数 $n,k$。

第二行包含 $n$ 个正整数 $a_1,a_2, \dots ,a_n$。

输出格式

一个整数，表示满足条件的有序数对的数量。

数据范围

前 $6$ 个测试点满足 $1 \leq n \leq 6$。
所有测试点满足 $1 \leq n \leq 2 \times {10}^{5}$，$2 \leq k \leq {10}^{9}$，$1 \leq a_i \leq {10}^{9}$。

输入样例1：

6 11
45 1 10 12 11 7

输出样例1：

7

输入样例2：

4 2
2 78 4 10

输出样例2：

12

输入样例3：

5 2
3 7 19 3 3

输出样例3：

0

 

解题思路

　　这题之前有做过：整数拼接。不过$k$的取值范围扩大到了${10}^{9}$，而且也不能用unordered_map，否则会TLE，必须要手写哈希表。因此完全可以按照那题的思路来做，只不过哈希表要自己手写实现。

　　讲一下y总思路。如果我们枚举到了$a_i$，现在看一下前面有多少个$a_j,~ (0 \leq j < i)$满足$k \mid \overline{a_{j}a_{i}}$，关键就在于如何快速判断前面有多少个$a_j$能够满足这个条件。

　　$k \mid \overline{a_{j}a_{i}}$等价于$a_{j} \times {10}^{t} + a_{i} \equiv 0 ~~(mod~k)$，即$a_{j} \times {10}^{t} \equiv -a_{i} ~~(mod~k)$，其中$t$是$a_i$在十进制下的位数。当枚举到$a_i$时，$t$就是个定值，因此问题就变成了前面有多少个$a_j$乘${10}^{t}$后模$k$为$-a_{i}$。可以想到用哈希表来记录之前出现过的$a_j \times {10}^{t} ~mod~ k$。$t$的范围很小，为$1 \sim 10$，因此每次枚举完$a_i$后，存一下$a_i$乘${10}^{1}, {10}^{2}, \dots, {10}^{10}$模$k$的值，在哈希表中该值出现的次数加$1$。因此当枚举到$a_i$时，求一下$a_i$的位数$t$，然后直接查哈希表得到前面有多少个数乘${10}^{t}$模$k$为$-a_i$。哈希表有两个关键字，一个是余数$r$，一个是位数$t$，为了方便把这个两个数组合成一个long long，即$r \times 100 + t$来作为关键字。

　　还有一点就是这题要枚举到$a_i$在$a_j$后面和前面两种情况，上面的做法只枚举到$a_i$在$a_j$后面，第一遍求完后还需要从后往前枚举来求$a_i$在$a_j$前面的情况，其实只需要把数组翻转然后再套第一遍的做法从左到右扫描就好了。

　　更新：补充对$a_{j} \times {10}^{t} \equiv -a_{i} ~~(mod~k)$的理解，这里的$t$是$a_i$的位数。当枚举到$a_i$时，此时$a_i$是定值，$t$也是定值。这时我们本来是要枚举所有的$a_j,~ (j \ne i)$，看看有多少个$a_j$满足$a_{j} \times {10}^{t} \equiv -a_{i} ~~(mod~k)$，但我们发现一开始可以使用哈希表来预处理统计，使得判断满足条件的时间复杂度为$O(1)$。那么预处理统计什么东西呢？对于判断条件。此次就只有$a_j$是一个变量，其他都是常量，即需要看有多少个$a_j$在乘上${10}^{t}$模$k$后的值恰好为${-a}_{i} \% k$。因此一开始需要预处理统计出数组的每个数乘上${10}^{t}$模$k$后的值的出现次数。虽然说在枚举到$a_i$时$t$是个定值，但不同的$a_i$的位数会不同，而$t$的取值范围是$1 \sim 10$，因此预处理时每个数都要乘上$10$的若干个次方。然后在枚举到$a_i$时，$cnt[t][-a_i \% k]$就是答案（当然还需要进行特判）。

　　同理$a_{i} \times {10}^{t} \equiv -a_{j} ~~(mod~k)$，看成$-a_{j} \equiv a_{i} \times {10}^{t} ~~(mod~k)$，一开始预处理统计每个数$x$的$-x \% k$的出现次数。

　　关键点就是预处理变量的部分，之前一直不是很理解。

　　AC代码如下：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 2e5 + 10, M = 1e7 + 3;

int n, m;
int a[N];
LL h[M];
int cnt[M];

int find(int r, int t) {
    LL x = r * 100ll + t;   // r是余数，t是位数
    int k = x % M;
    while (h[k] != -1 && h[k] != x) {
        if (++k == M) k = 0;
    }
    
    return k;
}

LL solve() {
    LL ret = 0;
    memset(h, -1, sizeof(h));
    memset(cnt, 0, sizeof(cnt));
    for (int i = 0; i < n; i++) {
        int r = (-a[i] % m + m) % m;
        int t = 0, x = a[i];
        while (x) {
            t++;
            x /= 10;
        }
        ret += cnt[find(r, t)];
        
        for (int j = 1, x = 10; j <= 10; j++, x = x * 10ll % m) {   // 统计(a[i]*10^k)%m的出现次数
            int t = find(1ll * a[i] * x % m , j);
            if (h[t] == -1) h[t] = 1ll * a[i] * x % m * 100ll + j;
            cnt[t]++;
        }
    }
    
    return ret;
}

int main() {
    scanf("%d %d", &n, &m);
    for (int i = 0; i < n; i++) {
        scanf("%d", a + i);
    }
    
    LL ret = solve();   // 先正着求一遍
    reverse(a, a + n);  // 反转数组
    ret += solve();     // 再正着求一遍
    
    printf("%lld", ret);
    
    return 0;
}

　　我当时的思路是$a_i$在前面而$a_j$在后面，对于一个$a_i$，本质是枚举所有$a_j,~ (i \ne j)$，求有多少个$a_j$满足$a_{i} \times {10}^{t} \equiv -a_{j} ~~(mod~m)$，其中这里的$t$是$a_j$的数位。因此可以预处理用哈希表来统计每个$-a_i \% k$出现的次数。然后枚举$a_i$，对于每个$a_i$，$k$都从$1$开始枚举到$10$，查哈希表统计$a_i \times {10}^k \% m$出现的次数，也就是$a_j$（数位为$k$）的满足条件个数。

　　AC代码如下：

#include <bits/stdc++.h>
using namespace std;

typedef long long LL;

const int N = 5e6 + 3;

int a[N], cnt[11][N], len[N];
int h[N];

int find(int x) {
    int k = x % N;
    while (h[k] != -1 && h[k] != x) {
        if (++k == N) k = 0;
    }
    return k;
}

int main() {
    int n, m;
    scanf("%d %d", &n, &m);
    memset(h, -1, sizeof(h));
    for (int i = 0; i < n; i++) {
        scanf("%d", a + i);
        int t = a[i];
        while (t) {
            len[i]++;
            t /= 10;
        }
        
        t = (1ll * -a[i] % m + m) % m;
        int x = find(t);
        if (h[x] == -1) h[x] = t;
        cnt[len[i]][x]++;
    }
    
    LL ret = 0;
    for (int i = 0; i < n; i++) {
        LL t = a[i];
        for (int j = 1; j <= 10; j++) {
            t = t * 10 % m;
            ret += cnt[j][find(t)];
        }
        
        t = a[i];
        for (int j = 0; j < len[i]; j++) {
            t = t * 10 % m;
        }
        if (t == (1ll * -a[i] % m + m) % m) ret--;  // 如果有a[i]*10^t = -a[i] (mod m)，这种情况下i==j，要特判掉
    }
    
    printf("%lld", ret);
    
    return 0;
}

 

参考资料

　　AcWing 4611. 串联数字（AcWing杯 - 周赛）：https://www.acwing.com/video/4297/