01 购物单
小明刚刚找到工作，老板人很好，只是老板夫人很爱购物。老板忙的时候经常让小明帮忙到商场代为购物。小明很厌烦，但又不好推辞。这不，XX大促销又来了！老板夫人开出了长长的购物单，都是有打折优惠的。小明也有个怪癖，不到万不得已，从不刷卡，直接现金搞定。
现在小明很心烦，请你帮他计算一下，需要从取款机上取多少现金，才能搞定这次购物。取款机只能提供100元面额的纸币。小明想尽可能少取些现金，够用就行了。
你的任务是计算出，小明最少需要取多少现金。
以下是让人头疼的购物单，为了保护隐私，物品名称被隐藏了
-----------------
180.90 88折
10.25 65折
56.14 9折
104.65 9折
100.30 88折
297.15 半价
26.75 65折
130.62 半价
240.28 58折
270.62 8折
115.87 88折
247.34 95折
73.21 9折
101.00 半价
79.54 半价
278.44 7折
199.26 半价
12.97 9折
166.30 78折
125.50 58折
84.98 9折
113.35 68折
166.57 半价
42.56 9折
81.90 95折
131.78 8折
255.89 78折
109.17 9折
146.69 68折
139.33 65折
141.16 78折
154.74 8折
59.42 8折
85.44 68折
293.70 88折
261.79 65折
11.30 88折
268.27 58折
128.29 88折
251.03 8折
208.39 75折
128.88 75折
62.06 9折
225.87 75折
12.89 75折
34.28 75折
62.16 58折
129.12 半价
218.37 半价
289.69 8折
-----------------
需要说明的是，88折指的是按标价的88%计算，而8折是按80%计算，余者类推。
特别地，半价是按50%计算。请提交小明要从取款机上提取的金额，单位是元。
答案是一个整数，类似4300的样子，结尾必然是00，不要填写任何多余的内容。特别提醒：不许携带计算器入场，也不能打开手机。
-
答案：5200
-
方法：使用excel
1、复制数据到excel后，点击 “数据”–>’‘分列’’–>“分隔符号”–>“空格”–>“完成”
2、手动把折扣换成小数，计算每个物品的折后价格；
3、求和：excel求和公式
=SUM(a:b)，为a到b的和；4、等到结果为5124.948，由于结果要取整百，故答案为5200.
02 纸牌三角形
A,2,3,4,5,6,7,8,9 共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。
下图就是一种排法：
这样的排法可能会有很多。如果考虑 旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？
请你计算并提交该数字。
注意：需要提交的是一个整数，不要提交任何多余内容。
-
答案：144
-
方法：全排列+去重（每种情况的重复有6种，故计数后
ans/6即可）public class B_02纸牌三角形 { static int[] arr = { 1, 2, 3, 4, 5, 6, 7, 8, 9 }; static int ans; public static void main(String[] args) { f(0); System.out.println(ans / 6); } private static void f(int k) { if (k == arr.length) { // 从0到8横着数三角形 int a1 = arr[0] + arr[1] + arr[3] + arr[5]; // 左侧边和 int a2 = arr[0] + arr[2] + arr[4] + arr[8]; // 右侧边和 int a3 = arr[5] + arr[6] + arr[7] + arr[8]; // 底侧边和 if (a1 == a2 && a1 == a3) { ans++; return; } } for (int i = k; i < arr.length; i++) { int t = arr[i]; arr[i] = arr[k]; arr[k] = t; f(k + 1); t = arr[i]; arr[i] = arr[k]; arr[k] = t; } } }
03 承压计算
X星球的高科技实验室中整齐地堆放着某批珍贵金属原料。
每块金属原料的外形、尺寸完全一致，但重量不同。
金属材料被严格地堆放成金字塔形。7 5 8 7 8 8 9 2 7 2 8 1 4 9 1 8 1 8 8 4 1 7 9 6 1 4 5 4 5 6 5 5 6 9 5 6 5 5 4 7 9 3 5 5 1 7 5 7 9 7 4 7 3 3 1 4 6 4 5 5 8 8 3 2 4 3 1 1 3 3 1 6 6 5 5 4 4 2 9 9 9 2 1 9 1 9 2 9 5 7 9 4 3 3 7 7 9 3 6 1 3 8 8 3 7 3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X其中的数字代表金属块的重量（计量单位较大）。最下一层的 X代表30台 极高精度的电子秤。
假设每块原料的重量都十分精确地平均落在下方的两个金属块上，
最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。
电子秤的 计量单位很小，所以显示的数字很大。工作人员发现，其中读数 最小的电子秤的示数为：2086458231
请你推算出：读数最大的电子秤的示数为多少？
注意：需要提交的是一个整数，不要填写任何多余的内容。
-
答案：72665192664
-
方法：乘2 30 放大
1、算上包含x的行总共有30行，最大列也为30，采用二维数组进行存储；
2、由上至下，每个数
a[i]\[j] * factor(2的30次方)，再除以2，计入后一行 a[i+1][j] 和 a[i+1][j+1] 中，直至最后一行；3、对a[N-1] 行进行排序，因为题中给出最小数为 2086458231，根据所给最小值查看最小值与factor之间的倍数关系，决定最大值。
import java.util.Arrays;
import java.util.Scanner;
public class B_03承压计算 {
static long[][] arr = new long[30][30];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
// 2的29次方,最后的最小值和2086458231比对后,放大2的29次方后,最小值相符
long factor = 1;
for (int i = 0; i < 29; i++)
factor <<= 1;
// 输入数据
for (int i = 0; i < 29; i++) { // 1~29行是物体重量
for (int j = 0; j <= i; j++) { //
long a = sc.nextLong();
arr[i][j] = a * factor;
}
}
// 处理
for (int i = 0; i < 29; i++) {
for (int j = 0; j <= i; j++) {
long half = arr[i][j] / 2;
arr[i + 1][j] += half;
arr[i + 1][j + 1] += half;
}
}
// 对最后一行排序
Arrays.sort(arr[29]);
System.out.println(arr[29][0]);
System.out.println(arr[29][29]);
}
}
04 魔方状态
二阶魔方就是只有2层的魔方，只由8个小块组成。
[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-YtolMXp8-1648225767807)(Java_B组2017年真题.assets/image-20220319215719299.png)]
小明很淘气，他只喜欢3种颜色，所有把家里的二阶魔方重新涂了颜色，如下：
前面：橙色
右面：绿色
上面：黄色
左面：绿色
下面：橙色
后面：黄色请你计算一下，这样的魔方被打乱后，一共有多少种不同的状态。
如果两个状态经过魔方的整体旋转后，各个面的颜色都一致，则认为是同一状态。
请提交表示状态数的整数，不要填写任何多余内容或说明文字。
-
答案：229878
-
方法：
参考视频 👉 2017-Java-B题4魔方状态
05 取数位
求1个整数的第k位数字有很多种方法。
以下的方法就是一种。public class Main{ static int len(int x){ if(x<10) return 1; return len(x/10)+1; } // 取x的第k位数字 static int f(int x, int k){ if(len(x)-k==0) return x%10; return ______________________; //填空 } public static void main(String[] args) { int x = 23513; //System.out.println(len(x)); System.out.println(f(x,3)); } }对于题目中的测试数据，应该打印5。
请仔细分析源码，并补充划线部分所缺少的代码。
注意：只提交缺失的代码，不要填写任何已有内容或说明性的文字。
-
答案：
return f(x / 10, k); // 填空
06 最大公共子串
最大公共子串长度问题就是：求两个串的所有子串中能够匹配上的最大长度是多少。
比如：“abcdkkk” 和 “baabcdadabc”，可以找到的最长的公共子串是"abcd",所以最大公共子串长度为4。
下面的程序是采用 矩阵法 进行求解的，这对串的规模不大的情况还是比较有效的解法。
请分析该解法的思路，并补全划线部分缺失的代码。
public class Main { static int f(String s1, String s2) { char[] c1 = s1.toCharArray(); char[] c2 = s2.toCharArray(); int[][] a = new int[c1.length+1][c2.length+1]; int max = 0; for(int i=1; i<a.length; i++){ for(int j=1; j<a[i].length; j++){ if(c1[i-1]==c2[j-1]) { a[i][j] = __________________; //填空 if(a[i][j] > max) max = a[i][j]; } } } return max; } public static void main(String[] args){ int n = f("abcdkkk", "baabcdadabc"); System.out.println(n); } }注意：只提交缺少的代码，不要提交已有的代码和符号。也不要提交说明性文字。
-
答案：
a[i][j] = a[i - 1][j - 1] + 1; // 填空
07 日期问题
小明正在整理一批历史文献。这些历史文献中出现了很多日期。小明知道这些日期都在1960年1月1日至2059年12月31日。令小明头疼的是，这些日期采用的格式非常不统一，有采用年/月/日的，有采用月/日/年的，还有采用日/月/年的。更加麻烦的是，年份也都省略了前两位，使得文献上的一个日期，存在很多可能的日期与其对应。
比如02/03/04，可能是2002年03月04日、2004年02月03日或2004年03月02日。给出一个文献上的日期，你能帮助小明判断有哪些可能的日期对其对应吗？
【输入】一个日期，格式是"AA/BB/CC"。 (0 <= A, B, C <= 9)
【输入】输出若干个不相同的日期，每个日期一行，格式是"yyyy-MM-dd"。多个日期按从早到晚排列。
样例输入：
02/03/04
样例输出：
2002-03-04
2004-02-03
2004-03-02
资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
-
思路：
✨ 接收输入的三个数；
✨ 编写函数 f(y, m, d) ，传入的y, m, d分别为要表示年、月、日的数，f内判断y、m、d是否符合年、月、日要求，函数返回符合要求的"yyyy-MM-dd"格式 ；
✨ 使用set对函数返回的日期进行去重；
import java.util.Scanner;
import java.util.Set;
import java.util.TreeSet;
public class B_07日期问题 {
public static void main(String[] args) {
// 接收输入的三个数,样式:02/03/04
Scanner scanner = new Scanner(System.in);
String s = scanner.next();
// 将字符串转为int型,后面才能比较
int a = 0, b = 0, c = 0;
a = (s.charAt(0) - '0') * 10 + (s.charAt(1) - '0');
b = (s.charAt(3) - '0') * 10 + (s.charAt(4) - '0');
c = (s.charAt(6) - '0') * 10 + (s.charAt(7) - '0');
// 不同的计日期方式
String s1 = f(a, b, c);
String s2 = f(c, a, b);
String s3 = f(c, b, a);
// 使用set对函数返回的日期进行去重
// TreeSet带有去重和排序的功能
Set<String> set = new TreeSet<>();
// 非空的情况放入set中
if (s1 != "")
set.add(s1);
if (s2 != "")
set.add(s2);
if (s3 != "")
set.add(s3);
// 输出
for (String string : set) {
System.out.println(string);
}
}
// d分别为要表示年、月、日的数，f内判断y、m、d是否符合年、月、日要求，函数返回符合要求的"yyyy-MM-dd"格式
// 日期范围:1960年1月1日至2059年12月31日
private static String f(int y, int m, int d) {
// 判断年是19还是20开头
if (y >= 0 && y <= 59) {
y += 2000;
} else if (y >= 60 && y <= 99) {
y += 1900;
} else {
return ""; // 无效年份表达
}
// 判断月份和日期是否合法
if (m < 1 || m > 12 || d < 1 || d > 31) {
return "";
}
// 判断大小月份的日期是否合法
boolean flag = isLeap(y);
switch (m) {
case 2:
if ((flag && d > 29) || (!flag && d > 28)) // 闰年和平年2月份日期不同
return "";
break;
case 4:
case 6:
case 9:
case 11:
if (d > 30)
return "";
break;
default:
break;
}
// 对合法的月日转为字符串型
String Y = y + "";
String M = m + "";
String D = d + "";
if (M.length() == 1)
M = "0" + M;
if (D.length() == 1)
D = "0" + D;
// 对合法的月日按要求拼接成串并返回
return Y + "-" + M + "-" + D;
}
// 判断年份是否为闰年
private static boolean isLeap(int y) {
return (y % 100 != 0 && y % 4 == 0) || y % 400 == 0;
}
}
08 包子凑数
小明几乎每天早晨都会在一家包子铺吃早餐。他发现这家包子铺 有N种蒸笼，其中第i种蒸笼恰好能放Ai个包子。每种蒸笼都有非常多笼，可以认为是无限笼。
每当有顾客想买X个包子，卖包子的大叔就会迅速选出若干笼包子来，使得这若干笼中恰好一共有X个包子。比如一共有3种蒸笼，分别能放3、4和5个包子。当顾客想买11个包子时，大叔就会选2笼3个的再加1笼5个的（也可能选出1笼3个的再加2笼4个的）。
当然有时包子大叔无论如何也凑不出顾客想买的数量。比如一共有3种蒸笼，分别能放4、5和6个包子。而顾客想买7个包子时，大叔就凑不出来了。
小明想知道一共有多少种数目是包子大叔凑不出来的。
输入
第一行包含一个整数N。(1 <= N <= 100)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100)输出
一个整数代表答案。如果凑不出的数目有无限多个，输出INF。例如：
输入：
2
4
5输出：
6输入：
2
4
6输出：
INF样例解释：
对于样例1，凑不出的数目包括：1, 2, 3, 6, 7, 11。
对于样例2，所有奇数都凑不出来，所以有无限多个。资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
提交程序时，注意选择所期望的语言类型和编译器类型。
-
相似真题：
2013年A组c++第8题:买不到的数目 -
数学知识：
对于不定方程
ax+by=C，若 a、b互质，方程一定有解且解的数目无穷；C是a、b最大公约数gcd(a,b)的倍数，方程一定有解，且有无穷多解。有解 <=> C % gcd(a，b) = 0
若a、b互质，x、y ≥ 0，方程无解的最大的
C = a * b - a - b；若a、b不互质，则不能保证C有解 <=> 有无限多个C使方程无解.
-
定理参考文档
👉 扩展欧几里得算法
-
-
思路：扩展欧几里得算法+完全背包
a0x0 + a1x1 + … + anxn = C 有解 <=> a0、a1、…、an 互质；
否则若不互质，则有无限多个C导致方程无解。
1、开辟一个数组 a[101]、f[10000]：a[101] 数组接收数据Ai，f[i]表示 C=i 是否能凑出来，能设为true，否则为false；
2、使用循环一个一个接收Ai，每接收一个判断最大公约数g；
3、判断最大公约数g后，进行完全背包的递推；
4、结束循环后，若g!=1，即a0、a1、…、an 不互质，输出INF；否则，遍历f数组进行统计，输出个数；
import java.util.Scanner;
public class B_08包子凑数 {
private static int ans, g;
private static int[] arr = new int[101];
private static boolean[] f = new boolean[10000];
public static void main(String[] args) {
f[0] = true; // 初始化0个包子为true
Scanner sc = new Scanner(System.in);
int n = sc.nextInt();
for (int i = 1; i <= n; i++) {
arr[i] = sc.nextInt();
if (i == 1)
g = arr[i]; // 初始化最大公约数
else
g = gcd(arr[i], g); // 计算当前最大公约数
// 完全背包
for (int j = 0; j < 10000 - arr[i]; j++) {
if (f[j])
f[j + arr[i]] = true;
}
}
// 若arr[i]各个数不互质
if (g != 1) {
System.out.println("INF");
return;
}
// 若arr[i]各个数互质
for (int i = 0; i < 10000; i++) {
if (!f[i]) // 不能凑出来的
ans++;
}
System.out.println(ans);
}
private static int gcd(int m, int n) {
if (n == 0)
return m;
return gcd(n, m % n);
}
}
09 分巧克力
儿童节那天有 K位小朋友 到小明家做客。小明拿出了珍藏的巧克力招待小朋友们。
小明一共有 N块巧克力，其中 第i块是Hi x Wi的方格组成的长方形。为了公平起见，小明需要从这 N 块巧克力中切出K块巧克力分给小朋友们。切出的巧克力需要满足：
- 形状是正方形，边长是整数
- 大小相同
例如一块6x5的巧克力可以切出6块2x2的巧克力或者2块3x3的巧克力。
当然小朋友们都希望得到的巧克力尽可能大，你能帮小Hi计算出最大的边长是多少么？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含两个整数Hi和Wi。(1 <= Hi, Wi <= 100000)
输入保证每位小朋友至少能获得一块1x1的巧克力。输出
输出切出的正方形巧克力最大可能的边长。样例输入：
2 10
6 5
5 6样例输出：
2资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
-
方法一：枚举
双层循环 100000 * 100000 = 10 10 ，会超时（超过1s）
import java.util.Scanner;
public class B_09分巧克力 {
public static void main(String[] args) {
// 1 <= Hi, Wi <= 100000
int[] h = new int[100000];
int[] w = new int[100000];
// 完成输入
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
for (int i = 0; i < N; i++) {
h[i] = sc.nextInt();
w[i] = sc.nextInt();
}
// len从大往小枚举
int len = 100000; // 最大为100000
while (len >= 1) {
int cnt = 0; // 记录按len能切出多少份巧克力
// 按len对每块巧克力进行切割
for (int i = 0; i < N; i++) {
cnt += (h[i] / len) * (w[i] / len);
}
if (cnt >= K) {
System.out.println(len);
return;
}
len--;
}
}
}
-
优化：
枚举中，对 len 从 100000 到 1 进行遍历，搜索适合的 len，可以改用二分法进行搜索；
当 mid = l + ((r- l) >> 1) 进行切割时：
- 若个数 cnt >= K，则长度应增大，l = mid + 1；
- 若个数 cnt < K，则长度应减小，r = mid - 1；
import java.util.Scanner;
public class B_09分巧克力 {
public static void main(String[] args) {
// 1 <= Hi, Wi <= 100000
int[] h = new int[100000];
int[] w = new int[100000];
int ans = 0;
// 完成输入
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
for (int i = 0; i < N; i++) {
h[i] = sc.nextInt();
w[i] = sc.nextInt();
}
// 二分法
int l = 1, r = 100000;
while (l <= r) {
int mid = l + ((r - l) >> 1);
int cnt = 0;
for (int i = 0; i < N; i++) {
cnt += (h[i] / mid) * (w[i] / mid);
}
if (cnt >= K) { // 中途cnt=K时,可能还有更大的mid能使cnt=K
l = mid + 1;
ans = mid;
} else {
r = mid - 1;
}
}
System.out.println(ans);
// System.out.println(r); // 或直接返回r也可以
}
}
10 k倍区间
给定一个长度为N的数列，A1, A2, … AN，如果其中一段连续的子序列Ai, Ai+1, … Aj(i <= j)之和是K的倍数，我们就称这个区间[i, j]是K倍区间。
你能求出数列中总共有多少个K倍区间吗？
输入
第一行包含两个整数N和K。(1 <= N, K <= 100000)
以下N行每行包含一个整数Ai。(1 <= Ai <= 100000)输出
输出一个整数，代表K倍区间的数目。例如:
输入：
5 2
1
2
3
4
5输出：
6资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 2000ms请严格按要求输出，不要画蛇添足地打印类似：“请您输入…” 的多余内容。
所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
不要使用package语句。不要使用jdk1.7及以上版本的特性。
主类的名字必须是：Main，否则按无效代码处理。
-
方法一：暴力枚举
三层循环，时间复杂度为 O(N 3) ，会超时。
import java.util.Scanner;
public class B_10K倍区间 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
int[] arr = new int[N];
for (int i = 0; i < N; i++) {
arr[i] = sc.nextInt(); // 1 <= Ai <= 100000
}
long ans = 0;
for (int i = 0; i < N; i++) {
for (int j = i; j < N; j++) {
long sum = 0;
for (int k = i; k <= j; k++) {
sum += arr[k];
}
if (sum % K == 0)
ans++;
}
}
System.out.println(ans);
}
}
-
方法二：前缀和
前缀和数组S，Si = a0 + a1 + … + an；
i 到 j 序列和为：sum = S j - S i-1；
时间复杂度降为 O(N 2)，只能解决 N = 10 4 规模的数据，10 5 仍然会超时。
import java.util.Scanner;
public class B_10K倍区间 {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
int[] arr = new int[N + 1];
long[] s = new long[N + 1]; // 前缀和数组
for (int i = 1; i <= N; i++) {
arr[i] = sc.nextInt(); // 1 <= Ai <= 100000
s[i] = s[i - 1] + arr[i];
}
long ans = 0;
for (int i = 1; i <= N; i++) {
for (int j = i; j <= N; j++) {
if ((s[j] - s[i - 1]) % K == 0)
ans++;
}
}
System.out.println(ans);
}
}
-
方法三：
同样使用前缀和，并且计算 S i % k 的值，其在 0~k-1 之间；
对取余后的 S i 对相同的数进行计数（同余统计），相同数之间任意挑来两个作差都是 k 的倍数；
cnt( S i % k == 0) = m 个，C m 2 = ( m * (m - 1)) / 2
cnt( S i % k == 1) = n 个，C n 2
…
cnt( S i % k == k - 1) = h 个，C h 2
sum = C m 2 + C n 2 +…+ C h 2
import java.util.HashMap;
import java.util.Map;
import java.util.Scanner;
public class B_10K倍区间 {
public static void main(String[] args) {
Map<Integer, Long> cnt = new HashMap<>(); // 同余统计
Scanner sc = new Scanner(System.in);
int N = sc.nextInt();
int K = sc.nextInt();
int[] arr = new int[N + 1];
int[] s = new int[N + 1]; // 前缀和数组
cnt.put(0, 1l); // s[0] = 0, s[0]%k=0
for (int i = 1; i <= N; i++) {
arr[i] = sc.nextInt();
s[i] = (s[i - 1] + arr[i]) % K;
if (cnt.get(s[i]) == null)
cnt.put(s[i], 1l); // 计数使用long型
else
cnt.put(s[i], cnt.get(s[i]) + 1);
}
long ans = 0;
for (int i = 0; i < K; i++) { // 余数范围在0~K-1
Long cntI = cnt.get(i);
if (cntI == null)
cntI = 0l;
ans += (cntI * (cntI - 1)) / 2;
}
System.out.println(ans);
}
}
3270
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
