第五届蓝桥杯真题决赛java本科组

最新推荐文章于 2022-08-26 13:08:26 发布

海伦•

最新推荐文章于 2022-08-26 13:08:26 发布

阅读量868

点赞数

分类专栏： ==========蓝桥========== 蓝桥杯总结文章标签： java

本文链接：https://blog.csdn.net/qq_42794545/article/details/90213145

版权

==========蓝桥========== 同时被 2 个专栏收录

48 篇文章 1 订阅

订阅专栏

蓝桥杯总结

15 篇文章 1 订阅

订阅专栏

1 国王的遗产

题目

题目描述

    X国是个小国。国王K有6个儿子。在临终前，K国王立下遗嘱：国王的一批牛作为遗产要分给他的6个儿子。
    其中，大儿子分1/4，二儿子1/5，三儿子1/6，....
    直到小儿子分1/9。
    牛是活的，不能把一头牛切开分。
    最后还剩下11头牛，分给管家。
    请计算国王这批遗产中一共有多少头牛。
    这是一个整数，请通过浏览器提交答案，不要填写任何多余的内容（比如说明性的文字）

代码

/**
*@author 杨雨婷
*@date 2019年5月14日
*/
package one_国王的遗产;

//其实就是最小公倍数的计算
public class Main {

	public static void main(String[] args) {
        int a[] = {4, 5, 6, 7, 8, 9};
        int t1 = gcd(20, 42);
        int t = 20 / t1 * 42;
        t1 = gcd(t , 72);
        t = t/ t1 * 72;
        
        int flag = 0;
        while(flag == 0) {
        	if(check(t)) {
        		flag = 1;
        		System.out.println(t);
        	}
        	else {        		 
        		t = t * 2;
        	}
        }
	}

	private static boolean check(int t) {
		if((t / 4 + t /5 + t / 6 + t / 7 + t / 8 + t / 9 )  + 11== t) {
			return true;
		}
		return false;
	}

	private static int gcd(int i, int j) {
		
		return i % j == 0 ? j : gcd(j, i % j);
	}

}
//2520

答案

2520

分析

简单的求最大公约数，最后再进行检验一下就可以。这题没什么太大的陷阱。其实可以将11设置大一点，就有必要检验这一步了

2 六角幻方

题目

题目描述

把 1 2 3 ... 19 共19个整数排列成六角形状，如下：
    * * *
   * * * *
  * * * * *
   * * * *
    * * *
要求每个直线上的数字之和必须相等。共有15条直线哦！

再给点线索吧！我们预先填好了2个数字，第一行的头两个数字是：15 13，参见图【p1.png】，黄色一行为所求。

请你填写出中间一行的5个数字。数字间用空格分开。

这是一行用空格分开的整数，请通过浏览器提交答案，不要填写任何多余的内容（比如说明性的文字等）

代码

/**
*@author 杨雨婷
*@date 2019年5月15日
*/
package two_六角幻方;

public class Main3 {
	static int a[] = {15, 13,  1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 14, 16, 17, 18, 19};
	static int n = 19;
	static int sum = 0;
	static int flag = 0;
//全排列
	public static void main(String[] args) {
		Long start = System.currentTimeMillis();
		dfs(2);
		Long end = System.currentTimeMillis();
        System.out.println("花费时间为：" + (end - start) + "ms");
	}
	private static void dfs(int ns) {
		//跳出递归
		if(flag == 1) return;
		if(ns == 3) {
			sum = a[0] + a[1] + a[2];
		}
		if(ns == 7) {
			if((a[3] + a[4] + a[5] + a[6]) != sum )return;
		}
		if(ns == 12) {
			if((a[7] + a[8] + a[9] + a[10] + a[11]) != sum)return;
			if((a[0] + a[3] + a[7]) != sum) return;
			if((a[2] + a[6] + a[11]) != sum) return;			
		}
		if(ns == 16) {
			if((a[12] + a[13] + a[14] + a[15]) != sum) return;
			if((a[1] + a[4] + a[8] + a[12]) != sum) return;
			if((a[1] + a[5] + a[10] + a[15]) != sum) return;
		}
		if(ns == n) {
			
			
			if((a[16] + a[17] + a[18]) != sum)return;
			if((a[16] + a[12] + a[7]) != sum)return;
			if((a[11] + a[15] + a[18]) != sum)return;
			if((a[3] + a[8] + a[13] + a[17]) != sum)return;
			if((a[6] + a[10] + a[14] + a[17]) != sum)return;
			
			
			if((a[0] + a[4] + a[9] + a[14] + a[18]) != sum)return;
			if((a[16] + a[2] + a[5] + a[9] + a[13]) != sum)return;
			for(int i = 7; i < 12; i ++) {
				System.out.print(a[i] + " ");
			}
			System.out.println();
			flag = 1;
			return;
		}
	 
			
		//下一跳
		for(int i = ns ; i < n; i ++) {
			swap(ns, i);
			/*for(int j = 0; j < n; j ++) {
				System.out.print(a[j] + " ");
			}
			System.out.println();*/
			dfs(ns + 1);
			swap(ns, i);
		}
		
	}
	private static void swap(int ns, int i) {
		int t = a[ns];
		a[ns] = a[i];
		a[i] = t;
	}

}

答案

9 6 5 2 16

时间耗费

9 6 5 2 16 
花费时间为：9218ms

分析

这题是考察全排列的，以前的全排列一直写的不好，都是按照深搜的暴力方法，所以就会导致不可以运行较大的深度的数。其实简化的全排列模板是这样的

参考链接：全排列模板

public class 全排列_模板1 {
 
	public static void main(String[] args) {
		dfs(0);
		System.out.println(ans);//9的全排有362880种
	}
	
	static int[] a = new int[] {1,2,3,4,5,6,7,8,9};
	
	static int n=9,ans=0;
	
	static void dfs(int m) {
		if(m>=n) {
			System.out.println("一些核心的操作 比如ans:"+ans);
			ans++;
			for(int i=0;i<n;i++)
				System.out.print(a[i]+" ");
			System.out.println();
			
			return;
		}
		
		for(int i=m;i<n;i++) {
			swap(i,m);
			dfs(m+1);
			swap(i,m);//回溯
		}
	
	
	}
	
	static void swap(int i,int j) {
		int t = a[i];
		a[i] = a[j];
		a[j] = t;
	}
 
}

3 格子放鸡蛋

题目描述
X星球的母鸡很聪明。它们把蛋直接下在一个 N * N 的格子中，每个格子只能容纳一枚鸡蛋。它们有个习惯，要求：每行，每列，以及每个斜线上都不能有超过2个鸡蛋。如果要满足这些要求，母鸡最多能下多少蛋呢，有多少种摆放方法呢？

下面的程序解决了这个问题，请仔细分析程序逻辑，推断划线处缺少的代码。

public class A
{
	static int max = 0;
	static int T = 0;
	static final int N = 6;
		
	// 只能在(r,c) 以及其右，其下放置 
	static void f(int[][] da, int r, int c)
	{	
		if(r>=N){
			int n = count(da);
			if(n>max) {
				max = n;
				T = 0;
			}
			if(n==max) T++;
			return;
		}
		
		//计算一下步放哪
		int r_next = r;
		int c_next = c + 1;
		if(c_next>=N){
			c_next = 0;
			r_next++;
		}
		
		if(____________________){  // 填空位置
			da[r][c] = 1;
			f(da, r_next, c_next); 
		}
		
		da[r][c] = 0;
		f(da, r_next, c_next);
	}
	
	static int count(int[][] da)
	{
		int n = 0;
		
		for(int i=0; i<da.length; i++)
		for(int j=0; j<da[i].length; j++) 
			if(da[i][j]==1) n++;
			
		return n;
	}
	
	static int spy(int[][] da, int r, int c)
	{
		int m=0;
		
		// 该行
		int n=0;
		for(int i=0; i<N; i++) if(da[r][i]==1) n++;
		if(n>m) m = n;
 
		//该列
		n=0;
		for(int i=0; i<N; i++) if(da[i][c]==1) n++;
		if(n>m) m = n;
		
		//右斜线
		n=0;
		for(int i=0; i<N; i++){ 
			if(r-i<0 || c-i<0) break; 
			if(da[r-i][c-i]==1) n++;
		}
		for(int i=1; i<N; i++){ 
			if(r+i>=N || c+i>=N) break; 
			if(da[r+i][c+i]==1) n++;
		}
		if(n>m) m = n;
		
		//左斜线
		n=0;
		for(int i=0; i<N; i++){ 
			if(r-i<0 || c+i>=N) break; 
			if(da[r-i][c+i]==1) n++;
		}
		for(int i=1; i<N; i++){ 
			if(r+i>=N || c-i<0) break; 
			if(da[r+i][c-i]==1) n++;
		}
		if(n > m) m = n;
		
		return m;
	}
	
	public static void main(String[] args)
	{
		int[][] da = new int[N][N];
		
		f(da, 0, 0);
		
		System.out.println(max);
		System.out.println(T);
	}
}

注意：通过浏览器提交答案。只填写缺少的内容，不要填写任何多余的内容（例如：说明性文字或已有符号）。

答案

spy(da, r, c) <= 1

分析

明显代码下面的方法写着是给我们用的，重要弄清楚参数是什么，返回变量是什么就可以了

4 排列序数

题目描述

如果用a b c d这4个字母组成一个串，有4!=24种，如果把它们排个序，每个串都对应一个序号：
  abcd 0
  abdc 1
  acbd 2
  acdb 3
  adbc 4
  adcb 5
  bacd 6
  badc 7
  bcad 8
  bcda 9
  bdac 10
  bdca 11
  cabd 12
  cadb 13
  cbad 14
  cbda 15
  cdab 16
  cdba 17
  ...

    现在有不多于10个两两不同的小写字母，给出它们组成的串，你能求出该串在所有排列中的序号吗？

【输入格式】
一行，一个串。

【输出格式】
一行，一个整数，表示该串在其字母所有排列生成的串中的序号。注意：最小的序号是0。

例如：
输入：
bdca

程序应该输出：
11

再例如：
输入：
cedab

程序应该输出：
70

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

正确代码

/**
*@author 杨雨婷
*@date 2019年5月16日
*/
package four_排列序数;

import java.util.Arrays;
import java.util.Scanner;

 
public class Main {
    static char a[],b[];
    static String str;
    static int n, ns = 0;
    static int flag = 0;
    static boolean vis[];
	public static void main(String[] args) {
         Scanner sca = new Scanner(System.in);
         str = sca.next();
         a = str.toCharArray();
         Arrays.sort(a);
         n = str.length();
         vis = new boolean[n];
         b = new char[n];      
         
         Long start = System.currentTimeMillis();
         //全排列
         dfs(0);
 		 Long end = System.currentTimeMillis();
         System.out.println("花费时间为：" + (end - start) + "ms");
         System.out.println(ns);
         
	}
	private static void dfs(int k) {
		//跳出递归
		if(k == n) {
			ns ++;
			if(check()) {
				System.out.println(ns - 1);
				//flag = 1;
			}
			return;
		}
		if(flag == 1) {
			return;
		}
		
		
		//下一跳
		for(int i = 0; i < n; i ++) {
			
		   if(!vis[i]) {
			   vis[i] = true;
			   b[k] = a[i];
			   dfs(k + 1);
			   vis[i] = false;
		   }
		}
	}
	private static boolean check() {
		for(int i = 0; i < n; i ++) {
			if(str.charAt(i) != b[i]) {
				return false;
			}
		}
		return true;
	}
	 

}

运行结果

asdfghjklz
282240
花费时间为：25ms

错误代码：

/**
*@author 杨雨婷
*@date 2019年5月16日
*/
package four_排列序数;

import java.util.Arrays;
import java.util.Scanner;

public class Main2 {
	static char a[];
    static String str;
    static int n, ns = 0;
    static int flag = 0;

	public static void main(String[] args) {
		Scanner sca = new Scanner(System.in);
        str = sca.next();
        a = str.toCharArray();
        Arrays.sort(a);
        n = str.length();
     
		Long start = System.currentTimeMillis();
		dfs(0);
		Long end = System.currentTimeMillis();
        System.out.println("1213花费时间为：" + (end - start) + "ms");
       
	}
	private static void dfs(int k) {
		//跳出递归
		if(k == n) {
			//System.out.println(String.valueOf(a));
			ns ++;
			if(check()) {
				System.out.println(ns - 1);
				flag = 1;
			}
			return;
		}
		if(flag == 1) {
			return;
		}
		
		
		//下一跳
		for(int i = k ; i < n; i ++) {
		   swap(k,i);
		   dfs(k + 1);
		   swap(k,i);
		}
	}
	private static void swap(int k, int i) {
		char t = a[i];
		a[i] = a[k];
		a[k] = t;
	}
	private static boolean check() {
		for(int i = 0; i < n; i ++) {
			if(str.charAt(i) != a[i]) {
				return false;
			}
		}
		return true;
	}
	 
}

运行结果

asdfghjklz
316646
1213花费时间为：11ms

分析

虽然都是全排列，但是第二种代码却是交换式的全排列，它的排列规则和第一种方式是不相同的。第一种的排序方式虽然效率不高，但是它的排序是依次进行的。当遇到编号（类似于本题）的情况下就是用方法一，也只能用方法一。如果没要求的话，我们可以用方法二，它的效率更高。例如上面第二题适合用交换式的全排列。

下面是方法二排序大约规则结果

abcd
abdc
acbd
acdb
adcb
adbc
bacd
badc
bcad
bcda
bdca
bdac
cbad
cbda
cabd
cadb
cdab
cdba

仔细观察可以看出差异。

5 幂一矩阵

题目描述

    天才少年的邻居 atm 最近学习了线性代数相关的理论，他对“矩阵”这个概念特别感兴趣。矩阵中有个概念叫做幂零矩阵。对于一个方阵 M ，如果存在一个正整数 k 满足 M^k = 0 ，那么 M 就是一个幂零矩阵。（^ 表示乘方）

    atm 不满足幂零矩阵，他自己设想了一个幂一矩阵：对于一个方阵 M ，如果存在一个正整数 k 满足 M^k = I ，其中 I 是单位矩阵，那么 M 就是一个幂一矩阵。

    atm 特别钟情于这样一种方阵：每行每列有且仅有一个 1 。经过 atm 不断实验，他发现这种矩阵都是幂一矩阵。

    现在，他的问题是，给定一个满足以上条件的方阵，他想求最小的 k 是多少。

【输入格式】
第一行一个正整数 n ，表示矩阵大小是 n * n 。
接下来 n 行，每行两个正整数 i j 表示方阵的第 i 行第 j 列为 1。
1 <= i, j <= n 。
行号，列号都从1开始。

【输出格式】
一行。一个正整数，即题目中所说最小的 k 。

【样例输入】
5
3 1
1 2
4 4
2 3
5 5

【样例输出】
3

【数据范围】
对于 30% 的数据满足 n <= 10
对于 60% 的数据答案不超过 10^18
对于 100% 的数据满足 n <= 10000

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 1000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

单位矩阵：https://baike.baidu.com/item/%E5%8D%95%E4%BD%8D%E7%9F%A9%E9%98%B5/8540268?fr=aladdin

在矩阵的乘法中，有一种矩阵起着特殊的作用，如同数的乘法中的1，这种矩阵被称为单位矩阵。它是个方阵，从左上角到右下角的对角线（称为主对角线）上的元素均为1。除此以外全都为0。

根据单位矩阵的特点，任何矩阵与单位矩阵相乘都等于本身，而且单位矩阵因此独特性在高等数学中也有广泛应用。

代码

/**
*@author 杨雨婷
*@date 2019年5月16日
*/
package five_幂一矩阵;

import java.math.BigInteger;
import java.util.Scanner;
 
public class Main {
	static int n, flag = 0,l[], c[];
	static long a[][],b[][],d[][];
    static BigInteger ns = new BigInteger("1");
	public static void main(String[] args) {
		Scanner sca = new Scanner(System.in);
		n = sca.nextInt();
		a = new long[n + 1][n + 1];
		b = new long[n + 1][n + 1];
		d = new long[n + 1][n + 1];
		l = new int[n + 1];
		c = new int[n + 1];
		for(int i = 0; i < n; i ++) {
			int x = sca.nextInt();
			int y = sca.nextInt();
			a[x][y] = 1;
			b[x][y] = 1;
		}
        dfs();
        
	}
	private static void dfs() {
		//剪枝
		/*System.out.println(ns);
		for(int i = 1; i <= n; i ++) {
			for(int j = 1;j <= n; j ++) {
				System.out.print(b[i][j] + " ");
			}
			System.out.println();
		}
		System.out.println();*/
		
		if(flag == 1)return;
		if(check()) {
			System.out.println(ns);
			flag = 1;
			return;
		}
	
		//下一跳
		for(int i = 1; i <= n; i ++) {
			for(int j = 1;j <= n; j ++) {
			   int sum = 0;
			   for(int k = 1; k <= n; k ++) {
				   sum += (a[i][k] * b[k][j]);		   
			   }
			   d[i][j] = sum;
			}
		}
		for(int i = 1; i <= n; i ++) {
			for(int j = 1;j <= n; j ++) {		    
			  b[i][j] = d[i][j];
			}
		}
		ns = ns.add(BigInteger.ONE);
		dfs();
	}
	private static boolean check() {
		for(int i = 1; i <= n; i ++) {
		   if(b[i][i] != 1) {
			   return false;
		   }
		} 
		return true;
	}

}

运行结果

分析

开始一直错误是误以为可以直接用动态规划并没有重新开辟空间来缓存结果矩阵，而是一味覆盖所以导致结果一直报错。那么以后遇到这种问题的之后，一定要注意之前的结果会不会对以后的结果有影响，若有影响，一定要考虑开辟新的空间。

动态规划

适用条件

任何思想方法都有一定的局限性，超出了特定条件，它就失去了作用。同样，动态规划也并不是万能的。适用动态规划的问题必须满足最优化原理和无后效性。

1.最优化原理（最优子结构性质）最优化原理可这样阐述：一个最优化策略具有这样的性质，不论过去状态和决策如何，对前面的决策所形成的状态而言，余下的诸决策必须构成最优策略。简而言之，一个最优化策略的子策略总是最优的。一个问题满足最优化原理又称其具有最优子结构性质。

2.无后效性将各阶段按照一定的次序排列好之后，对于某个给定的阶段状态，它以前各阶段的状态无法直接影响它未来的决策，而只能通过当前的这个状态。换句话说，每个状态都是过去历史的一个完整总结。这就是无后向性，又称为无后效性。

3.子问题的重叠性动态规划将原来具有指数级时间复杂度的搜索算法改进成了具有多项式时间复杂度的算法。其中的关键在于解决冗余，这是动态规划算法的根本目的。动态规划实质上是一种以空间换时间的技术，它在实现的过程中，不得不存储产生过程中的各种状态，所以它的空间复杂度要大于其它的算法。

然而在这一题他是有后效性的，所以很不适用哦。

6 供水设施

题目描述

    X星球的居民点很多。Pear决定修建一个浩大的水利工程，以解决他管辖的N个居民点的供水问题。现在一共有N个水塔，同时也有N个居民点，居民点在北侧从1号到N号自西向东排成一排；水塔在南侧也从1号到N号自西向东排成一排。

    N条单向输水线（有水泵动力），将水从南侧的水塔引到北侧对应的居民点。

    我们不妨将居民点和水塔都看做平面上的点，居民点坐标为(1,K)~(N,K)，水塔为(1,0)~(N,0)。

    除了N条纵向输水线以外，还有M条单向的横向输水线，连接(Xi,Yi)和(Xi,(Yi)+1)或者(Xi,Yi)和(Xi,(Yi)-1)。前者被称为向右的水路，而后者是向左的。不会有两条水路重叠，即便它们方向不同。

    布局的示意图如：【p1.png】所示。

    显然，每个水塔的水都可以到达若干个居民点（而不仅仅是对应的那个）。例如上图中，4号水塔可以到达3、4、5、6四个居民点。

    现在Pear决定在此基础上，再修建一条横向单项输水线。为了方便考虑，Pear认为这条水路应当是自左向右的，也就是连接了一个点和它右侧的点（例如上图中连接5和6两个纵线的横向水路）。

    Pear的目标是，修建了这条水路之后，能有尽可能多对水塔和居民点之间能到达。换句话说，设修建之后第i个水塔能到达Ai个点，你要最大化A1+A2+...+An。

    根据定义，这条路必须和X轴平行，但Y坐标不一定要是整数。注意：虽然输入中没有重叠的水路，但是你的方案可以将新修的输水线路与已有的水路重叠。

【输入数据】
    输入第一行包含三个正整数N，M，K，含义如题面所述：N是纵向线数，M横向线数，K是居民点纵坐标。

    接下来M行，每行三个整数。前两个正整数Xi Yi表示水路的起点坐标；
    1<=Xi<=N,0<Yi<K。
    接下来一个数0或者1，如果是0表示这条水路向左，否则向右。
    保证水路都是合法的，也就是不会流向没有定义的地方。

【输出数据】
输出一行。是一个正整数，即：题目中要求的最大化的A1+A2+...+An。

【输入样例1】
4 3 2
1 1 1
3 1 0
3 1 1
【输出样例1】
11

【输入样例2】
7 9 4
2 3 0
7 2 0
6 3 1
6 1 0
2 1 1
3 3 1
5 2 0
2 2 1
7 1 0
【输出样例2】
21

【数据范围】
对于20%的数据，N,K<=20，M<=100
对于40%的数据，N,K<=100，M<=1000
对于60%的数据，N,K<=1000，M<=100000
对于100%的数据，N,K<=50000，M<=100000

资源约定：
峰值内存消耗（含虚拟机） < 256M
CPU消耗 < 5000ms

请严格按要求输出，不要画蛇添足地打印类似：“请您输入...” 的多余内容。

所有代码放在同一个源文件中，调试通过后，拷贝提交该源码。
注意：不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意：主类的名字必须是：Main，否则按无效代码处理。

海伦•

关注

0
点赞
踩
2

收藏

觉得还不错? 一键收藏
0
评论
第五届蓝桥杯真题决赛java本科组

1 国王的遗产题目题目描述X国是个小国。国王K有6个儿子。在临终前，K国王立下遗嘱：国王的一批牛作为遗产要分给他的6个儿子。其中，大儿子分1/4，二儿子1/5，三儿子1/6，....直到小儿子分1/9。牛是活的，不能把一头牛切开分。最后还剩下11头牛，分给管家。请计算国王这批遗产中一共有多少头牛。这是一个整数，请通过...
复制链接

扫一扫