蓝桥杯2023JavaB组
Posted 冷兮雪
tags:
篇首语：本文由小常识网(cha138.com)小编为大家整理，主要介绍了蓝桥杯2023JavaB组相关的知识，希望对你有一定的参考价值。
目录
C: 数组分割（时间限制: 1.0s 内存限制: 512.0MB）
D、矩形总面积（时间限制: 1.0s 内存限制: 512.0MB）
E、蜗牛（时间限制: 1.0s 内存限制: 512.0MB）
F、合并区域 （时间限制: 2.0s 内存限制: 512.0MB）
G、买二赠一（时间限制: 1.0s 内存限制: 512.0MB）
H、合并石子（时间限制: 1.0s 内存限制: 512.0MB）
I、最大开支（时间限制: 1.0s 内存限制: 512.0MB ）
A、阶乘求和
【问题描述】 令 S = 1! + 2! + 3! + ... + 202320232023! ，求 S 的末尾 9 位数字。 提示：答案首位不为 0 。
Ⅰ、题目解读
一看到三个2023的巨大数字，我想大家应该都人都麻了。但是我想说这是官方的骗术，因为题目说要求末尾的9位数，其实我想告诉大家当加到40多的阶乘时，这个阶乘和后面的9位数就不会发生改变了。
Ⅱ、代码
public class Main
public static void main(String[] args)
long start=1;
String s="202320232023";
long end= Long.parseLong(s);
long sum=0;
long cj=1;
while (start<=end)
cj*=start;
cj%=1000000000;
sum+=cj;
sum%=1000000000;
start++;
if (start>40)
System.out.println(sum);
System.out.println(sum);
看运行
20940313 420940313 420940313 420940313 420940313 420940313 420940313 ...
B、幸运数字
【问题描述】 哈沙德数是指在某个固定的进位制当中，可以被各位数字之和整除的正整 数。例如 126 是十进制下的一个哈沙德数，因为 (126) 10 mod (1+2+6) = 0 ； 126 也是八进制下的哈沙德数，因为 (126) 10 = (176) 8 ， (126) 10 mod (1 + 7 + 6) = 0 ； 同时 126 也是 16 进制下的哈沙德数，因为 (126) 10 = (7 e ) 16 ， (126) 10 mod (7 + e ) = 0 。小蓝认为，如果一个整数在二进制、八进制、十进制、十六进制下均为 哈沙德数，那么这个数字就是幸运数字，第 1 至第 10 个幸运数字的十进制表示 为： 1 , 2 , 4 , 6 , 8 , 40 , 48 , 72 , 120 , 126 . . . 。现在他想知道第 2023 个幸运数 字是多少？你只需要告诉小蓝这个整数的十进制表示即可。
Ⅰ、题目解读
这题就是考察大家的进制转换，数据量也不大。直接看代码吧！
Ⅱ、代码
public class
public static void main(String[] args)
int j=0;
for (int i=1;i<10000000;i++)
if (BaseConversion(i))
j++;
if (j==2023)
System.out.println(i);//215040
break;
public static boolean BaseConversion(int n)
//十进制
int sum=0;
int x=n;
while (x!=0)
sum+=(x%10);
x/=10;
if (n%sum!=0)
return false;
//二进制
sum=0;
x=n;
while (x!=0)
sum+=(x%2);
x/=2;
if (n%sum!=0)
return false;
//八进制
sum=0;
x=n;
while (x!=0)
sum+=(x%8);
x/=8;
if (n%sum!=0)
return false;
//十六进制
int[] arr=0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15;
sum=0;
x=n;
while (x!=0)
sum+=(arr[x%16]);
x/=16;
if (n%sum!=0)
return false;
return true;
C: 数组分割（时间限制: 1.0s 内存限制: 512.0MB）
时间限制 : 1.0s 内存限制 : 512.0MB 本题总分： 10 分
【问题描述】 小蓝有一个长度为 N 的数组 A = [ A 0 , A 1 , . . . , A N − 1 ] 。现在小蓝想要从 A 对应的数组下标所构成的集合 I = 0 , 1 , 2 , . . . , N − 1 中找出一个子集 R 1 ，那么 R 1在 I 中的补集为 R 2 。记 S 1 = ∑ r ∈ R 1 A r ， S 2 = ∑ r ∈ R 2 A r，我们要求 S 1 和 S 2 均为 偶数，请问在这种情况下共有多少种不同的 R 1。当 R1 或 R 2 为空集时我们将 S 1 或 S 2 视为 0。 【输入格式】 第一行一个整数 T ，表示有 T 组数据。 接下来输入 T 组数据，每组数据包含两行：第一行一个整数 N ，表示数组 A 的长度；第二行输入 N 个整数从左至右依次为 A 0 , A 1 , . . . , A N − 1 ，相邻元素之 间用空格分隔。 【输出格式】 对于每组数据，输出一行，包含一个整数表示答案，答案可能会很大，你 需要将答案对 1000000007 进行取模后输出。 【样例输入】【样例输出】2 2 6 6 2 1 64
【样例说明】 对于第一组数据，答案为 4 。（注意：大括号内的数字表示元素在数组中的下标。） R 1 = 0 , R 2 = 1 ；此时 S 1 = A 0 = 6 为偶数 , S 2 = A 1 = 6 为偶数。 R 1 = 1 , R 2 = 0 ；此时 S 1 = A 1 = 6 为偶数 , S 2 = A 0 = 6 为偶数。 R 1 = 0 , 1 , R 2 = ；此时 S 1 = A 0 + A 1 = 12 为偶数 , S 2 = 0 为偶数。 R 1 = , R 2 = 0 , 1 ；此时 S 1 = 0 为偶数 , S 2 = A 0 + A 1 = 12 为偶数。 对于第二组数据，无论怎么选择，都不满足条件，所以答案为 0 。 【评测用例规模与约定】 对于 20 % 的评测用例， 1 ≤ N ≤ 10 。 对于 40 % 的评测用例， 1 ≤ N ≤ 10 2 。 对于 100 % 的评测用例， 1 ≤ T ≤ 10 , 1 ≤ N ≤ 10 3 , 0 ≤ A i ≤ 10 9 。
D、矩形总面积（时间限制: 1.0s 内存限制: 512.0MB）
【问题描述】 平面上有个两个矩形 R 1 和 R 2 ，它们各边都与坐标轴平行。设 ( x 1 , y 1 ) 和 (x 2 , y 2 ) 依次是 R 1 的左下角和右上角坐标， ( x 3 , y 3 ) 和 ( x 4 , y 4 ) 依次是 R 2 的左下 角和右上角坐标，请你计算 R 1 和 R 2 的总面积是多少？ 注意：如果 R 1 和 R 2 有重叠区域，重叠区域的面积只计算一次。 【输入格式】 输入只有一行，包含 8 个整数，依次是： x 1 ， y 1 ， x 2 ， y 2 ， x 3 ， y 3 ， x 4 和 y 4 。 【输出格式】 一个整数，代表答案。 【样例输入】【样例输出】2 1 7 4 5 3 8 6【样例说明】 样例中的两个矩形如图所示：22【评测用例规模与约定】 对于 20 % 的数据， R 1 和 R 2 没有重叠区域。 对于 20 % 的数据，其中一个矩形完全在另一个矩形内部。 对于 50 % 的数据，所有坐标的取值范围是 [0 , 10³ ] 。 对于 100 % 的数据，所有坐标的取值范围是 [0 , 10⁵ ]
Ⅰ、题目解读
这题有两种解法，自己数组去求，但是可能数据量过大会爆栈。第二种就是公式直接求解，这时求两个矩形相交的面积改怎么求？
矩形相交要使条件成立，即min(x2,x4)-max(x1,x3)>=0 且min(y2,y4)-max(y1,y3)>=0
如果条件成立，则相交矩形面积为：(min(x2,x4)-max(x1,x3))* (min(y2,y4)-max(y1,y3))
Ⅱ、代码
import java.util.Scanner;
public class Main
public static void main(String[] args)
Scanner sc = new Scanner(System.in);
int x1 = sc.nextInt();
int y1 = sc.nextInt();
int x2 = sc.nextInt();
int y2 = sc.nextInt();
int x3 = sc.nextInt();
int y3 = sc.nextInt();
int x4 = sc.nextInt();
int y4 = sc.nextInt();
long area1 = (long) (x2 - x1) * (y2 - y1); // 计算第一个矩形的面积
long area2 = (long) (x4 - x3) * (y4 - y3); // 计算第二个矩形的面积
long overlapArea=0;
long l = Math.min(x2, x4) - Math.max(x1, x3);
long w= Math.min(y2,y4)-Math.max(y1,y3);
if (l >=0&&w >=0)
overlapArea= l * w;
long Area = area1 + area2 - overlapArea; // 总面积
System.out.println(Area); // 输出总面积
E、蜗牛（时间限制: 1.0s 内存限制: 512.0MB）
【问题描述】 这天，一只蜗牛来到了二维坐标系的原点。 在 x 轴上长有 n 根竹竿。它们平行于 y 轴，底部纵坐标为 0 ，横坐标分别 为 x 1 , x 2 , ..., x n 。竹竿的高度均为无限高，宽度可忽略。蜗牛想要从原点走到第 n 个竹竿的底部也就是坐标 ( x n , 0) 。它只能在 x 轴上或者竹竿上爬行，在 x 轴 上爬行速度为 1 单位每秒；由于受到引力影响，蜗牛在竹竿上向上和向下爬行 的速度分别为 0 . 7 单位每秒和 1 . 3 单位每秒。 为了快速到达目的地，它施展了魔法，在第 i 和 i + 1 根竹竿之间建立了传 送门（0 < i < n ），如果蜗牛位于第 i 根竹竿的高度为 a i 的位置 ( x i , a i ) ，就可以 瞬间到达第 i + 1 根竹竿的高度为 b i +1 的位置 ( x i +1 , b i +1 )， 请计算蜗牛最少需要多少秒才能到达目的地。 【输入格式】 输入共 1 + n 行，第一行为一个正整数 n ； 第二行为 n 个正整数 x 1 , x 2 , . . . , x n ； 后面 n − 1 行，每行两个正整数 a i , b i +1 。 【输出格式】 输出共一行，一个浮点数表示答案（ 四舍五入保留两位小数 ）。 【样例输入】3 1 10 11 1 1 2 1【样例输出】
【样例说明】 蜗牛路线： (0 , 0) → (1 , 0) → (1 , 1) → (10 , 1) → (10 , 0) → (11 , 0) ，花费时间为 1 +1/ 0.7 + 0 + 1/1 .3 + 1 ≈ 4 . 20 【评测用例规模与约定】 对于 20 % 的数据，保证 n ≤ 15 ； 对于 100 % 的数据，保证 n ≤ 10⁵ ，a i , b i ≤ 10⁴ ，x i ≤ 10⁹ 。4.20
F、合并区域 （时间限制: 2.0s 内存限制: 512.0MB）
【问题描述】 小蓝在玩一款种地游戏。现在他被分配给了两块大小均为 N × N 的正方形 区域。这两块区域都按照 N × N 的规格进行了均等划分，划分成了若干块面积 相同的小区域，其中每块小区域要么是岩石，要么就是土壤，在垂直或者水平 方向上相邻的土壤可以组成一块土地。现在小蓝想要对这两块区域沿着边缘进 行合并，他想知道合并以后可以得到的最大的一块土地的面积是多少（土地的 面积就是土地中土壤小区域的块数）？ 在进行合并时，小区域之间必须对齐。可以在两块方形区域的任何一条边 上进行合并，可以对两块方形区域进行 90 度、 180 度、 270 度、 360 度的旋转， 但不可以进行上下或左右翻转，并且两块方形区域不可以发生重叠。 【输入格式】 第一行一个整数 N 表示区域大小。 接下来 N 行表示第一块区域，每行 N 个值为 0 或 1 的整数，相邻的整数 之间用空格进行分隔。值为 0 表示这块小区域是岩石，值为 1 表示这块小区域 是土壤。 再接下来 N 行表示第二块区域，每行 N 个值为 0 或 1 的整数，相邻的整 数之间用空格进行分隔。值为 0 表示这块小区域是岩石，值为 1 表示这块小区 域是土壤。 【输出格式】 一个整数表示将两块区域合并之后可以产生的最大的土地面积。 【样例输入】【样例输出】4 0 1 1 0 1 0 1 1 1 0 1 0 1 1 1 0 0 0 1 0 0 1 1 0 1 0 0 0 1 1 1 1【样例说明】15第一张图展示了样例中的两块区域的布局。第二张图展示了其中一种最佳 的合并方式，此时最大的土地面积为 15 。 【评测用例规模与约定】 对于 30 % 的数据， 1 ≤ N ≤ 5 。 对于 60 % 的数据， 1 ≤ N ≤ 15 。 对于 100 % 的数据， 1 ≤ N ≤ 50 。
Ⅰ、题目解读
题目会给你两块土地，你可以进行两块土地的“缝合”，求最大的连续的土地。 最大土地有三种情况 ①、
②、
③、（这种情况是我没想到的）
我只想到了前面两种情况，如果要算上第三种情况的话就应该直接使用暴力求解（毕竟数据量并不是很大），不断拼接，求最大连续的土地。我的代码也只是符合前面两种情况，有正确代码还请大佬给出。万分感谢。
Ⅱ、代码
import java.awt.*;
import java.util.ArrayList;
import java.util.HashSet;
import java.util.List;
import java.util.Scanner;
public class Main
static class Point
int x,y;
public Point(int x, int y)
this.x = x;
this.y = y;
public static void main(String[] args)
Scanner sc=new Scanner(System.in);
int n=sc.nextInt();
int[][] arr1=new int[n+2][n+2];//第一个矩阵
int[][] arr2=new int[n+2][n+2];//第二个矩阵
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
arr1[i][j]=sc.nextInt();
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
arr2[i][j]=sc.nextInt();
int max=0;
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
if (arr1[i][j]==1)
length(arr1,i,j);
List<Point> list=new ArrayList<>(set);
for (Point p:list)
arr1[p.x][p.y]=sum;
max=Math.max(max,sum);//防止矩阵里面是最大的
sum=0;
set.clear();
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j++)
if (arr2[i][j]==1)
length(arr2,i,j);
List<Point> list=new ArrayList<>(set);
for (Point p:list)
arr2[p.x][p.y]=sum;
max=Math.max(max,sum);//防止矩阵里面是最大的
sum=0;
set.clear();
int l=0;
int r=0;
//求四边的最大值然后拼接
//两行
for (int i=1;i<=n;i+=(n-1))
for (int j=1;j<=n;j++)
l=Math.max(l,arr1[i][j]);
r=Math.max(r,arr2[i][j]);
//两列
for (int i=1;i<=n;i++)
for (int j=1;j<=n;j+=(n-1))
l=Math.max(l,arr1[i][j]);
r=Math.max(r,arr2[i][j]);
max=Math.max(max,l+r);
System.out.println(max);
static int sum=0;
static HashSet<Point> set=new HashSet<>();
public static void length(int[][] arr, int i, int j)
sum++;
arr[i][j]=0;
Point p=new Point(i,j);
set.add(p);
if (arr[i-1][j]==1)
length(arr,i-1,j);
if (arr[i+1][j]==1)
length(arr,i+1,j);
if (arr[i][j-1]==1)
length(arr,i,j-1);
if (arr[i][j+1]==1)
length(arr,i,j+1);
G、买二赠一（时间限制: 1.0s 内存限制: 512.0MB）
【问题描述】 某商场有 N 件商品，其中第 i 件的价格是 A i 。现在该商场正在进行 “ 买二 赠一” 的优惠活动，具体规则是： 每购买 2 件商品，假设其中较便宜的价格是 P （如果两件商品价格一样， 则 P 等于其中一件商品的价格），就可以从剩余商品中任选一件价格不超过 P /2 的商品，免费获得这一件商品。可以通过反复购买 2 件商品来获得多件免费商 品，但是每件商品只能被购买或免费获得一次。 小明想知道如果要拿下所有商品（包含购买和免费获得），至少要花费多少钱？ 【输入格式】 第一行包含一个整数 N 。 第二行包含 N 个整数，代表 A 1 , A 2 , A 3 , . . . ， A N 【输出格式】 输出一个整数，代表答案。 【样例输入】7 1 4 2 8 5 7 1【样例输出】
25【样例说明】
小明可以先购买价格 4 和 8 的商品，免费获得一件价格为 1 的商品；再后 买价格为 5 和 7 的商品，免费获得价格为 2 的商品；最后单独购买剩下的一件 价格为 1 的商品。总计花费 4 + 8 + 5 + 7 + 1 = 25 。不存在花费更低的方案。 【评测用例规模与约定】 对于 30 % 的数据， 1 ≤ N ≤ 20 。 对于 100 % 的数据， 1 ≤ N ≤ 5 × 10⁵ ，1 ≤ A i ≤ 10⁹ 。
Ⅰ、题目解读
要花费最少，就要购买的商品价格高点，这样可以白嫖到更贵的商品，而不是便宜的商品。如题目所给样例：7+8（2）+4+5（1）+1=25。我认为可以使用数组储存再sort排序，然后使用二分查找到符合小于p/2的最大最大值，再将已经买完的商品变为0，然后重新上面步骤。（博主使用word打开题目，题目有问题，p/2显示的是p2，纯纯大冤种😭😭😭）。
H、合并石子（时间限制: 1.0s 内存限制: 512.0MB）
【问题描述】 在桌面从左至右横向摆放着 N 堆石子。每一堆石子都有着相同的颜色，颜 色可能是颜色 0 ，颜色 1 或者颜色 2 中的其中一种。 现在要对石子进行合并，规定每次只能选择位置相邻并且颜色相同的两堆 石子进行合并。合并后新堆的相对位置保持不变，新堆的石子数目为所选择的 两堆石子数目之和，并且新堆石子的颜色也会发生循环式的变化。具体来说： 两堆颜色 0 的石子合并后的石子堆为颜色 1 ，两堆颜色 1 的石子合并后的石子 堆为颜色 2 ，两堆颜色 2 的石子合并后的石子堆为颜色 0 。本次合并的花费为所 选择的两堆石子的数目之和。 给出 N 堆石子以及他们的初始颜色，请问最少可以将它们合并为多少堆石 子？如果有多种答案，选择其中合并总花费最小的一种，合并总花费指的是在 所有的合并操作中产生的合并花费的总和。 【输入格式】 第一行一个正整数 N 表示石子堆数。第九届蓝桥杯JavaB组(2018年)省赛题解
第九届蓝桥杯JavaB组(2018年)省赛题解
开开心心刷题，快快乐乐学习，踏踏实实工作，路漫漫其修远兮，吾将上下而求索！！！
1.第几天
热身题，注意闰年二月是29天就可以。/** * 1.第几天 * */ public class Main static int days = 0 ; static int year = 2000 ; public static void main(String[] args) for(int i=1; i<=5; i++) switch (i) case 1 : case 3 : days+= 31; break ; case 2 : days += (isLeap(year)) ? 29 : 28; break ; case 4 : days += 30 ; break; case 5 : days += 4 ; break; System.out.println(days); private static boolean isLeap(int year) if((year % 4 == 0 && year % 100 != 0) || year%400==0) return true ; return false ;2.方格计数
思想：四个象限，求出一个，然后乘以4即可。
xx+yy<=r*r为满足条件的情况。/** * 2.方格计数 * 以某个小方格顶点为圆形，画一个半径为1000的圆， * 计算出圆里面有多少个完整的小方格。 */ public class Main public static void main(String[] args) int r = 1000 ; int y = r ; int ans = 0 ; for(int x=1; x<=r; x++) while(y>0 && x*x+y*y>r*r) y -- ; ans += y ; System.out.println(ans*4);3.复数幂
思想：用到了Java的BigInteger，就是如下公式的迭代
（a+bi）* (2+3i)
实部：a * 2-b * 3
虚部：a* 3i + 2 * biimport java.math.BigInteger; public class Main static BigInteger aa, bb ; public static void main(String[] args) BigInteger a = new BigInteger("2") ; BigInteger b = new BigInteger("3") ; aa = null; bb = null ; for(int i=1; i<=123455; i++) aa = a.multiply(new BigInteger("2")).subtract(b.multiply(new BigInteger("3"))) ; bb = b.multiply(new BigInteger("2")).add(a.multiply(new BigInteger("3"))) ; a = aa ; b = bb ; System.out.println(a + "" + (b.compareTo(BigInteger.ONE)<=0 ? "" : "+") + b + "i");4.测试次数
思想：递推思想，就是动态规划，这题很容易以为是二分思想，其实和二分没有关系。
1，2，3部手机面对n层楼的最佳策略，仔细观察会发现由递推关系，可以得到递推关系式。当1部手机，n层楼，测试次数如下：
f1[n] = n
当2部手机,n层楼，测试次数如下：
f2[n]=min(for i in n (max(1+f2[n-i],1+f1[i-1]))）
当3部手机,n层楼，测试次数如下：
f3[n]=min(for i in n (max(1+f3[n-i],1+f2[i-1]))）/** * 4.测试次数 * 误区：很容易以为是二分，其实考的是动态规划 */ public class Main static int N = 1000; static int [] f1 ; static int [] f2 ; static int [] f3 ; public static void main(String[] args) f1 = new int [N+1] ; f2 = new int [N+1] ; f3 = new int [N+1] ; for(int i=1; i<=N; i++) //1部手机测试次数 f1[i] = i ; //2部手机测试次数 for(int i=1; i<=N; i++) int ans = Integer.MAX_VALUE ; for(int j=1; j<=i; j++) int max = Math.max(1+f2[i-j], 1+f1[j-1]) ; ans = Math.min(ans, max) ; f2[i] = ans ; //3部手机的测试次数 for(int i=1; i<=N; i++) int ans = Integer.MAX_VALUE ; for(int j=1; j<=i; j++) //第i层运气最差的情况 int max = Math.max(1+f3[i-j], 1+f2[j-1]) ; //每层运气最差的情况下，选个测试次数最少的 ans = Math.min(max, ans) ; f3[i] = ans ; System.out.println(f3[N]);5.代码填空：略
6.递增三元组
方法1：暴力枚举
import java.util.Scanner; /** * 6.递增三元组 */ public class Main static int N, cnt = 0 ; static int [] a ; static int [] b ; static int [] c ; public static void main(String[] args) Scanner input = new Scanner(System.in) ; N = input.nextInt() ; a = new int [N] ; b = new int [N] ; c = new int [N] ; for(int i=0; i<N; i++) a[i] = input.nextInt() ; for(int i=0; i<N; i++) b[i] = input.nextInt() ; for(int i=0; i<N; i++) c[i] = input.nextInt() ; for(int i=0; i<N;i++) for(int j=0; j<N; j++) for(int k=0; k<N; k++) if(a[i] < b[j] && a[i] < c[k] && b[j]<c[k]) cnt ++ ; System.out.println(cnt);方法2：固定b数组，查询a，c数组，查询过的不再需要扫描，节约时间
import java.util.Arrays; import java.util.Scanner; public class Main1 static int N ; static int [] a ; static int [] b ; static int [] c ; public static void main(String[] args) Scanner input = new Scanner(System.in) ; N = input.nextInt() ; a = new int [N] ; b = new int [N] ; c = new int [N] ; for(int i=0; i<N; i++) a[i] = input.nextInt() ; for(int i=0; i<N; i++) b[i] = input.nextInt() ; for(int i=0; i<N; i++) c[i] = input.nextInt() ; Arrays.sort(a) ; Arrays.sort(b) ; Arrays.sort(c) ; int j=0, k=0, ans = 0 ; /**固定b数组,查询a,c数组 * 由于所有的三个数组都已经排过序， * 所以查过的，后面不需要再次查询 */ for(int i=0; i<N; i++) while(j<N && b[i]>a[j]) j ++ ; while(k<N && b[i]>=c[k]) k ++ ; ans += j * (N - k) ; System.out.println(ans);7.螺旋直线
思想：这题十分巧妙，可以把左下角的那条线旋转90度，组成正方形，对每个个坐标先判断内部有多少正方形，求正方形的周长area = 4 * n * (n-1) ;，然后再判断坐标在水平方向还是在树枝方向，
水平方向： sum += (8*n-d1-d2) ;
竖直方向： sum += (d1+d2) ;import java.util.Scanner; /** * 7.螺旋折线 * 规律题：把所有的左下角的竖线旋转90° * 组成正方形，然后再计算(x,y)的dist(x,y) */ public class Main1 static long x, y ; public static void main(String[] args) Scanner input = new Scanner(System.in) ; x = input.nextLong() ; y = input.nextLong() ; long n = Math.max(x, y) ; //判断在哪个正方形上 long area = 4 * n * (n-1) ; //已有正方形的周长 long d1 = x + n ; long d2 = y + n ; long sum = 0 ; if(x < y) sum += (d1+d2) ; else sum += (8*n-d1-d2) ; System.out.println(sum+area);8.日志统计
方法1：数组标记法
import java.util.Iterator; import java.util.Scanner; import java.util.Set; import java.util.TreeSet; public class Main static int N, D, K, ts, id ; static long [][] a = new long [10000][10000] ; static Set<Integer> set = new TreeSet<>() ; public static void main(String[] args) Scanner input = new Scanner(System.in) ; N = input.nextInt() ; D = input.nextInt() ; K = input.nextInt() ; for(int i=0; i<N; i++) ts = input.nextInt() ; id = input.nextInt() ; for(int j=ts-D+1; j<=ts+D-1; j++) if(j>=0 && j<a[0].length && a[id][j] != 0 ) a[id][ts] ++ ; a[id][ts] ++ ; if(a[id][ts] >=K) set.add(id) ; Iterator iterator = set.iterator() ; while (iterator.hasNext()) System.out.println(iterator.next());方法2：排序后，尺取法
import java.util.*; public class Main1 static int N, D, K ; static class R int ts, id ; public static void main(String[] args) Scanner input = new Scanner(System.in) ; N = input.nextInt() ; D = input.nextInt() ; K = input.nextInt() ; R [] rs = new R[N] ; for(int i=0; i<N; i++) R r = new R() ; r.ts = input.nextInt() ; r.id 以上是关于蓝桥杯2023JavaB组的主要内容，如果未能解决你的问题，请参考以下文章蓝桥杯 穿越雷区 2015年第六届蓝桥杯JavaB组决赛第四题