第十三届蓝桥杯大赛JavaB个人赛题题解

最新推荐文章于 2023-05-22 16:47:23 发布
最新推荐文章于 2023-05-22 16:47:23 发布
阅读量566 收藏 7
点赞数 2
分类专栏： 赛题题解 文章标签： 蓝桥杯
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_54409739/article/details/124549877
版权

最近蓝桥杯出结果了，本人有幸拿到省赛一等奖前列，现在趁着五一有空，发一发个人题解，因为我们学校是线下竞赛，所以代码都在学校的比赛机，只能再根据记忆打一打，不容易，大家要是觉得有帮助就点个赞，哈哈，祝大家在接下来的国赛还有acm省赛取得好成绩。

A.星期计算

答案：

答案是7

很简单的签到题：20的22次方取模7，最后记得加上6就OK ，用（a*b）%c = ((a%c)*(b%c))%c

或者直接大数、高精度模拟也行，代码如下

package 蓝桥杯补题;

public class AAA {

	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int num = 20;
		for(int i = 1;i<=22;i++) {
			num = (num*num)%7;
		}
		System.out.println((6+num));//最后输出7
	}

}

B、山

直接找2022 ---- 2022222022中的山的数目，记住题目说的不减、不增，所以3333也是山哦。

 答案：

答案是3138
package 蓝桥杯补题;
import java.util.*;
public class BBB {

	private static boolean ok(long num) {
		String p = String.valueOf(num);
		StringBuffer p1 = new StringBuffer(p);
		StringBuffer p2 = p1.reverse();
		if(!p.equals(p2.toString())) {//判断反转后，是不是相等
			return false;
		}
		for(int i = 0;i<p.length()/2;i++) {//判断前半部分是不是非递减
			if(p.charAt(i)>p.charAt(i+1)) {
				return false;
			}
		}
		return true;
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		int ans = 0;
		for(long i = 2022;i<=2022222022;i++) {
			if(ok(i)) {
				ans++;
			}
		}
		System.out.println(ans);//3138
	}

}

接下来从编程题开始，我会用Java的快输啦（觉得太长直接看main方法就好，希望大家不要嫌弃我的代码长，呜呜）。要是大伙有疑问可以看我这篇博客：Java基础之快速输出输入篇_stu_kk的博客-CSDN博客 

C、字符统计 

 答案：

直接在输入时记录出现次数并找出最大的出现次数，最后遍历A-Z看看谁是最多次的输出就ok。

package 蓝桥杯补题;

import java.io.*;
import java.util.*;
public class CCC {
	private static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	private static class StopMsgException extends Exception{
	}
	private static int Int() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return (int)st.nval;
	}
	private static double Dou() {
		try {
			st.nextToken();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		return st.nval;
	}
	private static String Str() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return st.sval;
	}
	private static String Line() {
		String p = "";
		try {
			p = bf.readLine();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return p;
	}
	private static long Lon() {
		try {
			st.nextToken();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return (long)st.nval;
	}
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		String p = Line();
		int cnt[] = new int[10001];
		for(int i = 0;i<p.length();i++) {
			cnt[p.charAt(i)]++; 
		}
		int maxn = -1000000;
		for(int i = 'A' ;i <= 'Z';i++) {
			maxn = Math.max(maxn, cnt[i]);
		}
		for(int i = 'A' ;i <= 'Z';i++) {
			if(maxn == cnt[i]) {
				pw.print((char)i);
			}
		}
		pw.flush();
	}

}

D、最少刷题数：

 

答案：

这题的难点应该是多个数相同时，单纯二分会出错。利用两个二分查找，找出类似C++的lower_bound，upper_bound,这样就可以解决有很多个相同的数时的情况。（代码不一定对，但是试了很多极端的样例，都没问题就交了，如果有错误，希望大伙指出来）

package 蓝桥杯补题;
import java.io.*;
import java.util.*;
public class DDD {
	private static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	private static class StopMsgException extends Exception{
	}
	private static int Int() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return (int)st.nval;
	}
	private static double Dou() {
		try {
			st.nextToken();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		return st.nval;
	}
	private static String Str() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return st.sval;
	}
	private static String Line() {
		String p = "";
		try {
			p = bf.readLine();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return p;
	}
	private static long Lon() {
		try {
			st.nextToken();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return (long)st.nval;
	}
	private static int findlow(int k,int arr[]) {
		int l = 1;
		int r = n;
		while(l < r) {
			int mid = (l+r)/2;
			if(arr[mid] >= k) {
				r = mid;
			}
			else {
				l = mid+1;
			}
		}
		return l;
	}
	private static int findhigh(int k,int arr[]) {
		int l = 1;
		int r = n;
		while(l < r) {
			int mid = (l+r+1)/2;
			if(arr[mid] > k) {
				r = mid-1;
			}
			else {
				l = mid;
			}
		}
		return r;
	}
	private static int n,m,mp[],search[];
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		n = Int();
		mp = new int[n+1];
		search = new int[n+1];
		for(int i = 1;i<=n;i++) {
			int a = Int();
			mp[i] = a;
			search[i] = a;
		}
		Arrays.sort(mp,1,n+1);
		for(int i = 1;i<=n;i++) {
			int low = findlow(search[i],mp);
			int high = findhigh(search[i],mp);
			int big = n - high;
			int small = low - 1;
			if(big <= small) {
				pw.print("0 ");
			}
			else {
				if(high == low) {
					int up = big - small;
				    pw.print((mp[low+up/2] - mp[low] + 1)+" ");
				}
				else {
					int same = high - low;
					if(same + small >= big) {
						pw.print("1 ");
					}
					else {
						int up = big - same - small;
					    pw.print((mp[high+up] - mp[high] + 1)+" ");
					}
				}
			}
		}
		pw.flush();
	}

}

E、求阶乘

 

答案：

（看着5->1 10->2 15->3还想有点规矩，但是10e18的数据量太大，推dp估计也是爆内存）只能暴力拿个30的分了，把时间留给后面。直接找出数中包含10和2和5的个数，当等于k时，输出答案。

package 蓝桥杯补题;
import java.io.*;
import java.util.*;
public class EEE {
	private static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	private static class StopMsgException extends Exception{
	}
	private static int Int() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return (int)st.nval;
	}
	private static double Dou() {
		try {
			st.nextToken();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		return st.nval;
	}
	private static String Str() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return st.sval;
	}
	private static String Line() {
		String p = "";
		try {
			p = bf.readLine();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return p;
	}
	private static long Lon() {
		try {
			st.nextToken();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return (long)st.nval;
	}
	private static int n;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		n = Int();
		int cnt0 = 0;
		int cnt2 = 0;
		int cnt5 = 0;
		for(long i = 1;i<=10e18;i++) {
			long num = i;
			while(num%10 == 0 && num!=0) {
				cnt0++;
				num/=10;
			}
			while(num%5 == 0 && num!=0) {
				cnt5++;
				num/=5;
			}
			while(num%2 == 0 && num!=0) {
				cnt2++;
				num/=2;
			}
			if(cnt0 + Math.min(cnt5, cnt2) == n) {
				pw.println(i);
				pw.flush();
				break;
			}
		}
	}

}

F、最大子矩阵：

 

答案：

没办法啥好的想法，只能又一次嘎嘎暴力了。

package 蓝桥杯补题;
import java.io.*;
import java.util.*;
public class FFF {
	private static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	private static class StopMsgException extends Exception{
	}
	private static int Int() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return (int)st.nval;
	}
	private static double Dou() {
		try {
			st.nextToken();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		return st.nval;
	}
	private static String Str() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return st.sval;
	}
	private static String Line() {
		String p = "";
		try {
			p = bf.readLine();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return p;
	}
	private static long Lon() {
		try {
			st.nextToken();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return (long)st.nval;
	}
	static int[][] arr;
	public static void main(String[] args) {
		int n = Int();
		int m = Int();
		arr=new int[n][m];
		for(int i=0;i<n;i++) {
			for(int j=0;j<m;j++) {
				arr[i][j] = Int();
			}
		}
		int limit = Int();
		int maxn = Integer.MIN_VALUE;
		for(int i=n;i>0;i--) {
			for(int j=m;j>0;j--) { // i*j的矩阵
				for(int x=0;x<=n-i;x++) {
					for(int y=0;y<=m-j;y++) {  //左上角坐标
						int max = find_max(i,j,x,y);
						int min = find_min(i,j,x,y);
						if((max-min)<=limit) {
							maxn = Math.max(maxn, i*j);
						}
					}
				}
			}
		}
		pw.println(maxn);
	}
	private static int find_min(int i, int j, int x, int y) {
		// TODO //寻找最小值
		int res = Integer.MAX_VALUE;
		for(int n=x;n<x+i;n++) {
			for(int m=y;m<y+j;m++) {
				res = Math.min(res, arr[n][m]);
			}
		}
		return res;
	}
	private static int find_max(int i, int j, int x, int y) {
		// TODO 寻找最大值
		int res = Integer.MIN_VALUE;
		for(int n=x;n<x+i;n++) {
			for(int m=y;m<y+j;m++) {
				res = Math.max(res, arr[n][m]);
			}
		}
		return res;
	}

}

G、数组切分：

 

答案：

如何判断一段数组是否连续，那就是该数组内的最大值减去最小值等于数组长度减1，用dp[i]，表示长度为i的情况。

package 蓝桥杯补题;
import java.io.*;
import java.util.*;
public class GGG {
	private static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	private static class StopMsgException extends Exception{
	}
	private static int Int() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return (int)st.nval;
	}
	private static double Dou() {
		try {
			st.nextToken();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		return st.nval;
	}
	private static String Str() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return st.sval;
	}
	private static String Line() {
		String p = "";
		try {
			p = bf.readLine();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return p;
	}
	private static long Lon() {
		try {
			st.nextToken();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return (long)st.nval;
	}
	private static int n,mod = 1000000007;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		n  =Int();
		int mp[] = new int[n+1];
		int dp[] = new int[n+1];
		for(int i = 1;i<=n;i++) {
			mp[i] = Int();
		}
		dp[0] = 1;
		for(int i = 1;i<=n;i++) {
			int minn = mp[i];
			int maxn = mp[i];
			for(int j = i;j>=1;j--) {
				minn = Math.min(minn, mp[j]);
				maxn = Math.max(maxn, mp[j]);
				if(i - j == maxn - minn) {
					dp[i] = ( dp[i]+dp[j-1] )%mod;
				}
			}
		}
		pw.println(dp[n]);
		pw.flush();
	}

}

H、会议迷宫：

 

我的做法时定义个300*300的数组，然后从[150,150]这个点开始跑路，如果跑到就标记为true，那么他就是空格，其他地方为*，记录最小、大的x和最小、大的y，用来构答案的图。因为要保证墙的数量最少，所以用dfs让连接外界的墙只要没接触到空格就清空。 （我自己写的样例都过了，就这么写）

答案：

package 蓝桥杯补题;
import java.io.*;
import java.util.*;
public class HHH {
	private static StreamTokenizer st = new StreamTokenizer(new BufferedReader(new InputStreamReader(System.in)));
	private static PrintWriter pw = new PrintWriter(new BufferedWriter(new OutputStreamWriter(System.out)));
	private static BufferedReader bf = new BufferedReader(new InputStreamReader(System.in));
	private static class StopMsgException extends Exception{
	}
	private static int Int() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return (int)st.nval;
	}
	private static double Dou() {
		try {
			st.nextToken();
		} 
		catch (IOException e) {
			e.printStackTrace();
		}
		return st.nval;
	}
	private static String Str() {
		try {
			st.nextToken();
		}
		catch(IOException e) {
			e.printStackTrace();
		}
		return st.sval;
	}
	private static String Line() {
		String p = "";
		try {
			p = bf.readLine();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return p;
	}
	private static long Lon() {
		try {
			st.nextToken();
		} catch (IOException e) {
			// TODO 自动生成的 catch 块
			e.printStackTrace();
		}
		return (long)st.nval;
	}
	private static void dfs(int x,int y) {
		if(mp[x][y] == ' ') {
			return ;
		}
		for(int i = 0;i<4;i++) {
			int nx = x+xy[i][0];
			int ny = y+xy[i][1];
			if(nx<minx-2||nx > maxx+2|| ny<miny-2 || ny>maxy+2 || is[nx][ny]) {
				return;
			}
		}
		mp[x][y] = ' ';
		for(int i = 0;i<4;i++) {
			int nx = x+xy[i][0];
			int ny = y+xy[i][1];
			if(!(nx<minx-2||nx > maxx+2|| ny<miny-2 || ny>maxy+2 || is[nx][ny])) {
				dfs(nx,ny);
			}
		}
	}
	private static int xy[][] = {{0,-1},{0,1},{1,0},{-1,0}};
	private static char mp[][];
	private static boolean is[][];
	private static int n,minx,maxx,miny,maxy;;
	public static void main(String[] args) {
		// TODO 自动生成的方法存根
		n = Integer.valueOf(Line());
		String p = Line();
		int strx = 150;
		int stry = 150;
		mp = new char[300][300];
		is = new boolean[300][300];
		for(char as[] : mp)
		Arrays.fill(as, '*');
		minx = miny = Integer.MAX_VALUE;
		maxx = maxy = Integer.MIN_VALUE;
		for(int i = 0;i<n;i++) {
			if(p.charAt(i) == 'U') {
				strx--;
			}
			else if(p.charAt(i) == 'D') {
				strx++;
			}
			else if(p.charAt(i) == 'L') {
				stry--;
			}
			else if(p.charAt(i) == 'R') {
				stry++;
			}
			maxx = Math.max(maxx, strx);
			minx = Math.min(minx, strx);
			maxy = Math.max(maxy, stry);
			miny = Math.min(miny, stry);	
			mp[strx][stry] = ' ';
			is[strx][stry] = true;
		}
		for(int i = minx-1;i<=maxx+1;i++) {
			for(int j = miny-1;j<=maxy+1;j++) {
				if(i == minx-1 || i == maxx+1 || j == miny-1 || j == maxy+1) {
					if(mp[i][j] == '*') {
						dfs(i,j);
					}
				}
			}
		}
		for(int i = minx-1;i<=maxx+1;i++) {
			for(int j = miny-1;j<=maxy+1;j++) {
				pw.print(mp[i][j]);
			}
			pw.println();
		}
		pw.flush();
	}

}

I、红路灯：

 

 难度大+最后没时间做了。

J、拉箱子：

 

  难度大+最后没时间做了。

stu_kk
关注
  • 2
    点赞
  • 踩
  • 7
    收藏
    觉得还不错? 一键收藏
  • 打赏
    打赏
  • 0
    评论
专栏目录
第十三届蓝桥杯省赛JavaB组题目
04-09
【标题】：“第十三届蓝桥杯省赛JavaB组题目”揭示了这是一场针对Java编程的竞赛，属于蓝桥杯系列赛事中的省级选拔阶段。蓝桥杯是一项旨在提升大学生和青少年编程技能的全国性比赛，它对于参赛者在Java语言的理解、...
2018年第九届蓝桥杯JAVAB组题目
04-02
【标题】"2018年第九届蓝桥杯JAVAB组题目"涉及的是一个编程竞赛，这个竞赛主要测试参赛者在Java编程语言方面的知识和技能。蓝桥杯是一项年度性的全国性软件和信息技术专业人才大赛，旨在促进高校计算机教育的改革与...
2018第九届蓝桥杯JavaB组省赛真题及详解
hyx153183740的博客
02-04 7530
2018第九届蓝桥杯JavaB组省赛真题及详解 第一题：第几天 题目描述 2000年的1月1日，是那一年的第1天。 那么，2000年的5月4日，是那一年的第几天？ 注意：需要提交的是一个整数，不要填写任何多余内容。 直接数，125 第二题：方格计数 题目描述 如图所示，在二维平面上有无数个1x1的小方格。 我们以某个小方格的一个顶点为圆心画一个半径为1000的圆。 你能计算出这个圆里有多少个完整...
【备战蓝桥杯 | 软件Java大学B组】十三届真题深刨详解（2）
小新的博客
11-01 1466
蓝桥杯全国软件和信息技术专业人才大赛是全国性的IT类学科赛事。连续三年入选中国高等教育学会发布的“全国普通高校学科竞赛排行榜”，是高校教育教学改革和创新人才培养的重要竞赛项目。十三年来，吸引北京大学、清华大学、复旦大学、上海交通大学、中国科学技术大学等1600余所高校，累计超过65万余名选手参赛。
第十三届蓝桥杯国赛JavaB组题解
weixin_51624761的博客
05-22 1828
初始的想法是保存每个数的位置，当某个数左移的时候，左边的每个数的位置都+1，右边的数不变；当某个数右移的时候，右边的每个数的位置都-1，左边的数不变，自然而然想到了差分，算出位置后，接着再根据位置输出即可。bfs求最短路，从终点一次bfs可以求得到所有点的最短距离，将所有点的最短距离相加再除以点数即可得到最短距离的数学期望。后来想到了用双链表进行求解，每次交换位置的时候要先删除再插入，在插入的时候更新元素的位置。枚举不同的时刻，判断哪些时刻秒针和分针表示的数字是相同的。，显然会超时，这种做法不可取。
【备战蓝桥杯 | 软件Java大学B组】十三届真题深刨详解（1）
小新的博客
10-18 4108
第十三届蓝桥杯大赛软件赛省赛 Java 大学 B 组 试题 A: 星期计算 试题 B: 山 试题 C: 字符统计 试题 D: 最少刷题数
第十二届蓝桥杯大赛个人赛省赛（软件类）真题-Java语言B组
WHT869706733的博客
01-11 5767
目录 1.ASC 2.卡片 1.ASC 【问题描述】 已知大写字母 A 的 ASCII 码为 65，请问大写字母 L 的 ASCII 码是多少？ 【答案提交】 这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一 个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。 import java.util.Scanner; public class Main{ public static void main(String[] args)throws Exceptio
Java第十五届蓝桥杯大赛软件JavaB组真题
04-18
【Java第十五届蓝桥杯大赛软件JavaB组真题】是针对Java编程技术的一场专业竞赛，旨在考察参赛者对Java语言的理解、应用及问题解决能力。蓝桥杯大赛作为国内知名的IT技能竞赛，其试题往往涵盖了Java的基础语法、面向...
第十三届蓝桥杯JavaB组省赛原题
05-14
- 在蓝桥杯JavaB组省赛中，参赛者需要具备扎实的Java编程基础，包括但不限于变量、数据类型、控制结构（如if-else，for，while）、函数、类和对象等。 - 主类名必须为`Main`，这是Java应用程序的入口点，程序执行...
第十三届蓝桥杯JavaB组国赛E题——迷宫 (AC)
执梗的博客
10-29 7395
第十三届蓝桥杯JavaB组国赛E题——迷宫 (AC)
第十三届蓝桥杯Java、C++、Python组国赛真题——环境治理（三语言AC）
执梗的博客
10-22 8643
第十三届蓝桥杯Java、C++、Python组国赛真题——环境治理（三语言AC）
蓝桥杯个人赛软件类历届真题及其解析
热门推荐
NOW I GOT ONE WAY
12-22 1万+
蓝桥杯个人赛软件类历届真题及其解析
十三届蓝桥杯javaB组拉箱子
qq_53654220的博客
05-04 447
有没有大神能够告诉我这道压轴题有什么更快的做法，本以为数据不大深搜加剪枝能过的，只能向网上的acm帅哥求真经了。 最后一个案例没有过去，但是有人用了200ms的做法过了，我实在想不出有什么更快的方法了，感觉这题用动态规划可变参数会特别麻烦应该不是最优做法吧（我猜的）。 先附上我超时的代码：算是记录一下。 ​ import java.util.HashSet; import java.util.Scanner; public class Main { static int ans = 0;
数组切分【Java蓝桥杯】
weixin_49456098的博客
04-11 1231
第十三届蓝桥杯大赛软件赛省赛 Java 大学 B 组 试题 G: 数组切分 时间限制: 1.0s 内存限制: 512.0MB 本题总分：20 分 题目 【问题描述】 已知一个长度为 N 的数组：A1, A2, A3, …AN 恰好是 1 ∼ N 的一个排列。 现在要求你将 A 数组切分成若干个 (最少一个，最多 N 个) 连续的子数组， 并且 每个子数组中包含的整数恰好可以组成一段连续的自然数。 例如对于 A = {1, 3, 2, 4}, 一共有 5 种切分方法： {1}{3}{2}{4}：每个单独的数
第十三届蓝桥杯省赛Java B组 A-E
小小书童的博客
04-11 238
昨天刚考完蓝桥杯，现在将几道题解析奉上。
蓝桥杯第十三届Java真题(B组)
m0_55997161的博客
04-09 947
答案：7 答案：3138
第十三届蓝桥杯JAVAB组国赛部分思路及代码
black_hole6的博客
06-19 1399
蓝桥杯解析
第十三届蓝桥杯大赛软件赛省赛（Java 大学B组）
NOW I GOT ONE WAY
04-11 3526
第十三届蓝桥杯大赛软件赛省赛 Java 大学 B 组
2022年第十三届蓝桥杯省赛Java B组真题及题解
计算机程序定制、毕业项目
03-31 2450
第十三届蓝桥杯省赛Java B组
十五届蓝桥杯javab
最新发布
06-03
十五届蓝桥杯Java B组是由中国蓝桥杯大赛组委会主办的一项全国性计算机科学比赛。本届比赛于2020年9月27日在全国范围内同时进行，共分为C、C++、Java A、Java B、Python A、Python B六个组别。其中，Java B组是面向...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

stu_kk

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值