2023第十四届蓝桥杯Java B组个人题解

💎蓝桥杯系列文章

欢迎大家阅读蓝桥杯文章专栏🍄🍄

🔥2023第十四届蓝桥杯模拟赛第二期个人题解（Java实现）

🔥2023第十四届蓝桥杯模拟赛第三期个人题解（Java实现）

🔥蓝桥杯备赛之动态规划篇——背包问题

🔥蓝桥杯备赛之动态规划篇——涂色问题（区间DP）

🔥蓝桥杯真题——单词分析（Java实现）

💎第十四届蓝桥杯Java B组真题

• 💎蓝桥杯系列文章
• 💎前言
• 💎Part I 填空题
• • 🎯试题 A: 阶乘求和
  • • 🌞问题分析
    • 💡Java代码
    • 💯结果
    • 🎯试题 B: 幸运数字
    • • 🌞 问题分析
      • 💡Java代码
      • 💯 结果
      • 💎Part II 编程题
      • • 🎯试题 C: 数组分割
        • • 🌞问题分析
          • 💡 Java代码
          • 🎯试题 D: 矩形总面积
          • • 🌞问题分析
            • 💡 Java代码
            • 🎯试题 F: 合并区域
            • • 🌞问题分析
              • 💡 Java代码
              • 💎总结

                

                💎前言

                😘😘哈喽，大家好！今年的蓝桥杯终于落下帷幕啦！今天真的被整得怀疑人生了😭😭😭😭今年主打的就是陪伴😪赛后我重新做了这些题，写下这篇题解，跟大家交流交流！🍄

                

                🙊🙊如果我写的内容有误，欢迎大家在评论区指正👏希望这篇文章对你有帮助❤❤同时欢迎关注我呦👇👇

                

                雾霾愈让人窒息，我愈拼命争取一口清新；
                黑暗愈遮盖大地，我们的心看得就愈清晰！

                

                💎Part I 填空题

                🎯试题 A: 阶乘求和

                问题描述

                　　令 S = 1! + 2! + 3! + … + 202320232023!，求 S 的末尾 9 位数字。

                　　提示：答案首位不为 0。

                答案提交

                　　这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

                🌞问题分析

                🍒🍒这道题肯定不能按题目的要求算到 202320232023!，肯定有规律可循，所以不妨先算前50项，取最后9位看看结果。阶乘算出来的结果很大，用Long也会爆，可以用BigIneger，需要注意的是BigInteger的加减乘除需要调API实现。

                💡Java代码

                import java.math.BigInteger;
                public class 试题A_阶乘求和 {
                	public static void main(String[] args) {
                		BigInteger n=new BigInteger("1");
                		BigInteger sum=new BigInteger("0");
                		for(int i=1;i
                			n=n.multiply(new BigInteger(""+i));
                			sum=sum.add(n);
                			System.out.println("i="+i+"时，sum后九位是："+sum.mod(new BigInteger(""+1000000000)));
                		}
                	}
                }
                
                	//求一个数字字符串的数位之和
                	public static int getSum(String s) {
                		int sum=0;
                		for(int i=0;i
                			if(s.charAt(i)='a'&&s.charAt(i)
                		int count=0;
                		for(int i=1;i
                			String a2=Integer.toBinaryString(i);	//转为二进制
                			String a8=Integer.toOctalString(i);		//转为八进制
                			String a16=Integer.toHexString(i);		//转为十六进制
                			if(i%getSum(a2)==0&&i%getSum(a8)==0&&i%getSum(a16)==0&&i%getSum(""+i)==0) {
                				count++;
                				if(count==2023) {
                					System.out.println("第 2023 个幸运数字是:"+i);
                					break;
                				}
                			}	
                		}
                	}
                }
                
                	List
                		used=new boolean[nums.length];
                		backtrack(nums, 0);
                		return res;
                	}
                	// 回溯法求子集
                	void backtrack(int[] nums,int start) {
                		res.add(new LinkedList
                			//不用剪枝，可以重复
                //			if(istart&&nums[i]==nums[i-1]&&!used[i-1]))
                //				continue;
                			//选择
                			used[i]=true;
                			track.add(nums[i]);
                			//进入下一层回溯
                			backtrack(nums, i+1);
                			//撤销选择
                			track.removeLast();
                			used[i]=false;
                		}
                		
                	}
                }
                public class 试题C_数组分割 {
                	//返回一个列表的所有数字的和
                	public static int getSum(List
                		int sum=0;
                		for(int e:nums)
                			sum+=e;
                		return sum;
                	}
                	//统计满足条件的R1个数
                	public static int count(int[] A) {
                		SubSet subSet=new SubSet();
                		List
                			//将数组A转为List
                			List
                		//输入
                		Scanner sc=new Scanner(System.in);
                		int T=sc.nextInt();		//有T组数据
                		int[] res=new int[T];	//记录每组数据的结果
                		for(int i=0;i
                			int N=sc.nextInt();
                			int[] A=new int[N];	//存放每组数据
                			for(int j=0;j
                				A[j]=sc.nextInt();
                			}
                			res[i]=count(A);
                		}
                		for(int i=0;i
                			System.out.println(res[i]);
                		}
                	}
                }
                
                	public static void main(String[] args) {
                		Scanner sc=new Scanner(System.in);
                		long x1=sc.nextLong();
                		long y1=sc.nextLong();
                		long x2=sc.nextLong();
                		long y2=sc.nextLong();
                		long x3=sc.nextLong();
                		long y3=sc.nextLong();
                		long x4=sc.nextLong();
                		long y4=sc.nextLong();
                		long res=0L;
                		//R1 和 R2 没有重叠区域
                		if(x2
                			res=(x2-x1)*(y2-y1)+(x4-x3)*(y4-y3);
                			System.out.println(res);
                		}
                		//R2完全在R1内部
                		else if(x1
                			res=(x2-x1)*(y2-y1);
                			System.out.println(res);
                		}
                		//R1完全在R2内部
                		else if(x3
                			res=(x4-x3)*(y4-y3);
                			System.out.println(res);
                		}
                		//R1和R2有部分重叠
                		else {
                			long[] x= {x1,x2,x3,x4};
                			long[] y= {y1,y2,y3,y4};
                			Arrays.sort(x);
                			Arrays.sort(y);
                			//减去重复部分的面积
                			res=(x2-x1)*(y2-y1)+(x4-x3)*(y4-y3)-(x[2]-x[1])*(y[2]-y[1]);
                			System.out.println(res);
                		}
                	}
                }
                
                	// 将(x,y)所在的土地变成岩石，并返回该土地面积
                	public static int dfs(int[][] grid,int x,int y) {
                		int m=grid.length,n=grid[0].length;
                		// 超出区域边界
                		if(x
                		int m=grid.length,n=grid[0].length;
                		int res=0;
                		for(int i=0;i
                			// 将区域上边缘的土壤变成岩石，并记录土地的最大面积
                			res=Math.max(res, dfs(grid, 0, i));
                			// 将区域下边缘的土壤变成岩石，并记录土地的最大面积
                			res=Math.max(res,dfs(grid, m-1, i));
                		}
                		for(int j=0;j
                			// 将区域左边缘的土壤变成岩石，并记录土地的最大面积
                			res=Math.max(res, dfs(grid, j, 0));
                			// 将区域右边缘的土壤变成岩石，并记录土地的最大面积
                			res=Math.max(res, dfs(grid, j, n-1));
                		}
                		return res;
                	}
                	public static void main(String[] args) {
                		Scanner sc=new Scanner(System.in);
                		int N=sc.nextInt();	//区域大小
                		int[][] grid1=new int[N][N];
                		int[][] grid2=new int[N][N];
                		// 输入区域1
                		for(int i=0;i