ICode9

精准搜索请尝试: 精确搜索
首页 > 其他分享> 文章详细

串联数字

2022-09-04 16:30:57  阅读:194  来源: 互联网

标签:串联 10 数字 int ++ leq 枚举 哈希


串联数字

给定 $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$前面的情况,其实只需要把数组翻转然后再套第一遍的做法从左到右扫描就好了.

  AC代码如下:

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 typedef long long LL;
 5 
 6 const int N = 2e5 + 10, M = 1e7 + 3;
 7 
 8 int n, m;
 9 int a[N];
10 LL h[M];
11 int cnt[M];
12 
13 int find(int r, int t) {
14     LL x = r * 100ll + t;   // r是余数,t是位数
15     int k = x % M;
16     while (h[k] != -1 && h[k] != x) {
17         if (++k == M) k = 0;
18     }
19     
20     return k;
21 }
22 
23 LL solve() {
24     LL ret = 0;
25     memset(h, -1, sizeof(h));
26     memset(cnt, 0, sizeof(cnt));
27     for (int i = 0; i < n; i++) {
28         int r = (-a[i] % m + m) % m;
29         int t = 0, x = a[i];
30         while (x) {
31             t++;
32             x /= 10;
33         }
34         ret += cnt[find(r, t)];
35         
36         for (int j = 1, x = 10; j <= 10; j++, x = x * 10ll % m) {   // 统计(a[i]*10^k)%m的出现次数
37             int t = find(1ll * a[i] * x % m , j);
38             if (h[t] == -1) h[t] = 1ll * a[i] * x % m * 100ll + j;
39             cnt[t]++;
40         }
41     }
42     
43     return ret;
44 }
45 
46 int main() {
47     scanf("%d %d", &n, &m);
48     for (int i = 0; i < n; i++) {
49         scanf("%d", a + i);
50     }
51     
52     LL ret = solve();   // 先正着求一遍
53     reverse(a, a + n);  // 反转数组
54     ret += solve();     // 再正着求一遍
55     
56     printf("%lld", ret);
57     
58     return 0;
59 }

  我当时的思路是$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代码如下:

 1 #include <bits/stdc++.h>
 2 using namespace std;
 3 
 4 typedef long long LL;
 5 
 6 const int N = 5e6 + 3;
 7 
 8 int a[N], cnt[11][N], len[N];
 9 int h[N];
10 
11 int find(int x) {
12     int k = x % N;
13     while (h[k] != -1 && h[k] != x) {
14         if (++k == N) k = 0;
15     }
16     return k;
17 }
18 
19 int main() {
20     int n, m;
21     scanf("%d %d", &n, &m);
22     memset(h, -1, sizeof(h));
23     for (int i = 0; i < n; i++) {
24         scanf("%d", a + i);
25         int t = a[i];
26         while (t) {
27             len[i]++;
28             t /= 10;
29         }
30         
31         t = (1ll * -a[i] % m + m) % m;
32         int x = find(t);
33         if (h[x] == -1) h[x] = t;
34         cnt[len[i]][x]++;
35     }
36     
37     LL ret = 0;
38     for (int i = 0; i < n; i++) {
39         LL t = a[i];
40         for (int j = 1; j <= 10; j++) {
41             t = t * 10 % m;
42             ret += cnt[j][find(t)];
43         }
44         
45         t = a[i];
46         for (int j = 0; j < len[i]; j++) {
47             t = t * 10 % m;
48         }
49         if (t == (1ll * -a[i] % m + m) % m) ret--;  // 如果有a[i]*10^t = -a[i] (mod m),这种情况下i==j,要特判掉
50     }
51     
52     printf("%lld", ret);
53     
54     return 0;
55 }

 

参考资料

  AcWing 4611. 串联数字(AcWing杯 - 周赛):https://www.acwing.com/video/4297/

标签:串联,10,数字,int,++,leq,枚举,哈希
来源: https://www.cnblogs.com/onlyblues/p/16655309.html

本站声明: 1. iCode9 技术分享网(下文简称本站)提供的所有内容,仅供技术学习、探讨和分享;
2. 关于本站的所有留言、评论、转载及引用,纯属内容发起人的个人观点,与本站观点和立场无关;
3. 关于本站的所有言论和文字,纯属内容发起人的个人观点,与本站观点和立场无关;
4. 本站文章均是网友提供,不完全保证技术分享内容的完整性、准确性、时效性、风险性和版权归属;如您发现该文章侵犯了您的权益,可联系我们第一时间进行删除;
5. 本站为非盈利性的个人网站,所有内容不会用来进行牟利,也不会利用任何形式的广告来间接获益,纯粹是为了广大技术爱好者提供技术内容和技术思想的分享性交流网站。

专注分享技术,共同学习,共同进步。侵权联系[81616952@qq.com]

Copyright (C)ICode9.com, All Rights Reserved.

ICode9版权所有