2019第十届蓝桥杯Java省赛A组真题个人题解

链接：https://pan.baidu.com/s/1DuQ3CSGrkEIS7HtnW4_uHA
提取码：wog6
感受就是A组题需要很强的数学功底。。。或者说就是在考数学

试题 A: 平方和

• 【问题描述】
  小明对数位中含有 2、0、1、9 的数字很感兴趣，在 1 到 40 中这样的数包 括 1、2、9、10 至 32、39 和 40，共 28 个，他们的和是 574，平方和是 14362。 注意，平方和是指将每个数分别平方后求和。 请问，在 1 到 2019 中，所有这样的数的平方和是多少？
• 【答案提交】
  265841785

遍历时转化为String用contains方法判断是否含有2019平方累加即可
用long保存防止溢出

class Main {
	public static void main(String[] args) {
		long sum=0;
		String num;
		for(int i=1;i<=2019;i++) {
			num=String.valueOf(i);
			if(num.contains("2")||num.contains("0")||num.contains("1")||num.contains("9")) {
				sum+=Math.pow(i, 2);
			}
		}
		System.out.println(sum);
		
		
	}
}

试题 B: 数列求值

• 【问题描述】
  给定数列 1, 1, 1, 3, 5, 9, 17, …，从第 4 项开始，每项都是前 3 项的和。求 第 20190324 项的最后 4 位数字。
• 【答案提交】
  4659

类似斐波那契，题目已经暗示只需要后4位，所以每次取模就好，使用滚动数组减少开销
class Main {
	public static void main(String[] args) {
		int mod = 10000;
		int a = 1, b = 1, c = 1, temp = 1;// 前三项,当前项
		for (int i = 4; i <= 20190324; i++) {// 第四项就是<=4，所以第20190324项就是<=20190324
			temp = (a + b + c) % mod;
			a = b;
			b = c;
			c = temp;
		}
		System.out.println(temp);
	}
}

试题 C: 迷宫

【问题描述】 下图给出了一个迷宫的平面图，其中标记为 1 的为障碍，标记为 0 的为可 以通行的地方。
010000
000100
001001
110000
迷宫的入口为左上角，出口为右下角，在迷宫中，只能从一个位置走到这 个它的上、下、左、右四个方向之一。 对于上面的迷宫，从入口开始，可以按DRRURRDDDR 的顺序通过迷宫， 一共 10 步。其中 D、U、L、R 分别表示向下、向上、向左、向右走。 对于下面这个更复杂的迷宫（30 行 50 列），请找出一种通过迷宫的方式， 其使用的步数最少，在步数最少的前提下，请找出字典序最小的一个作为答案。 请注意在字典序中D<L<R<U。（如果你把以下文字复制到文本文件中，请务 必检查复制的内容是否与文档中的一致。在试题目录下有一个文件 maze.txt， 内容与下面的文本相同）

01010101001011001001010110010110100100001000101010
00001000100000101010010000100000001001100110100101
01111011010010001000001101001011100011000000010000
01000000001010100011010000101000001010101011001011
00011111000000101000010010100010100000101100000000
11001000110101000010101100011010011010101011110111
00011011010101001001001010000001000101001110000000
10100000101000100110101010111110011000010000111010
00111000001010100001100010000001000101001100001001
11000110100001110010001001010101010101010001101000
00010000100100000101001010101110100010101010000101
11100100101001001000010000010101010100100100010100
00000010000000101011001111010001100000101010100011
10101010011100001000011000010110011110110100001000
10101010100001101010100101000010100000111011101001
10000000101100010000101100101101001011100000000100
10101001000000010100100001000100000100011110101001
00101001010101101001010100011010101101110000110101
11001010000100001100000010100101000001000111000010
00001000110000110101101000000100101001001000011101
10100101000101000000001110110010110101101010100001
00101000010000110101010000100010001001000100010101
10100001000110010001000010101001010101011111010010
00000100101000000110010100101001000001000000000010
11010000001001110111001001000011101001011011101000
00000110100010001000100000001000011101000000110011
10101000101000100010001111100010101001010000001000
10000010100101001010110000000100101010001011101000
00111100001000010000000110111000000001000000001011
10000001100111010111010001000110111010101101111000

• 【答案提交】
  DDDDRRURRRRRRDRRRRDDDLDDRDDDDDDDDDDDDRDDRRRURRUURRDDDDRDRRRRRRDRRURRDDDRRRRUURUUUUUUULULLUUUURRRRUULLLUUUULLUUULUURRURRURURRRDDRRRRRDDRRDDLLLDDRRDDRDDLDDDLLDDLLLDLDDDLDDRRRRRRRRRDDDDDDRR

import java.util.ArrayDeque;
import java.util.Scanner;

class Main {
	static int[][] map = new int[30][50];// 迷宫
	static int[][] dis = new int[30][50];// 每个位置到终点的最短路径
	static int[] dx = { 1, 0, 0, -1 }, dy = { 0, -1, 1, 0 };
	static String[] dir = { "D", "L", "R", "U" };//最小字典序

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		for (int i = 0; i < 30; i++) {
			String s = sc.nextLine();
			for (int j = 0; j < 50; j++) {
				map[i][j] = s.charAt(j) - '0';
			}
		}
		int n = 30, m = 50;
		bfs(n, m);//求出每个位置到终点的最短距离
		StringBuffer bf = new StringBuffer();//用变长字符串存储最终路径
		int x = 0, y = 0;
		while (x != n-1 || y != m-1 ) {//dfs
			for (int i = 0; i < 4; i++) {//以最小字典序探索四个方向
				int nx = x + dx[i];
				int ny = y + dy[i];
				if (nx >= 0 && nx < n && ny >= 0 && ny < m && map[nx][ny] == 0) {
					if (dis[x][y] == 1 + dis[nx][ny]) {//如果走的是最短路径
						x = nx;
						y = ny;
						bf.append(dir[i]);//把走的方向存储
						break;//跳出for循环，即走了当前方向就不走其他方向了
					}
				}
			}
		}
		System.out.println(bf);
	}

	static void bfs(int n, int m) {
		ArrayDeque<Node> q = new ArrayDeque<>();
		for (int i = 0; i < n; i++) {
			for (int j = 0; j < m; j++) {
				dis[i][j] = -1;
			}
		}
		dis[n - 1][m - 1] = 0;
		q.offer(new Node(n - 1, m - 1));
		while (!q.isEmpty()) {
			Node node = q.peek();
			q.pop();
			for (int i = 0; i < 4; i++) {
				int x = node.x + dx[i];
				int y = node.y + dy[i];
				if (x >= 0 && x < n && y >= 0 && y < m && dis[x][y] == -1 && map[x][y] == 0) {
					dis[x][y] = dis[node.x][node.y] + 1;
					q.offer(new Node(x, y));
				}
			}
		}

	}

	static class Node {
		int x;
		int y;

		public Node(int x, int y) {
			this.x = x;
			this.y = y;
		}
	}
}

试题 D: 最大降雨量

• 【问题描述】
  由于沙之国长年干旱，法师小明准备施展自己的一个神秘法术来求雨。 这个法术需要用到他手中的 49 张法术符，上面分别写着 1 至 49 这 49 个 数字。法术一共持续 7 周，每天小明都要使用一张法术符，法术符不能重复使 用。 每周，小明施展法术产生的能量为这周 7 张法术符上数字的中位数。法术 施展完 7 周后，求雨将获得成功，降雨量为 7 周能量的中位数。 由于干旱太久，小明希望这次求雨的降雨量尽可能大，请大最大值是多少？
• 【答案提交】
  34
• 数学方法是很容易求解的：
  （1）首先分成7组，每组7个数，则其中肯定有3个组的降雨量不管多小都对答案没影响，所以把最小的3 * 7=21个数字放到其中。
  （2）剩下的四组，肯定每组的前3个数尽量平均，即：将剩下的最小的3*4个数字放进四个组。
  （3）剩下的最小的数字肯定为中位数。

不用数学方法的话就是爆搜了，我这个实现复杂度爆炸，O(2^64),不用想能跑出来
import java.util.Arrays;

public class Main {
	static String flag="0000000"+"0000000"+"0000000"+"0000000"+"0000000"+"0000000"+"0000000";
		//用49位01表示1~49取或不取
	static int[] num=new int[49];//表示取数顺序,num[3],num[10]……是每周的中位数
	static int[] result=new int[7];//最终的七个中位数，result[3]是最终结果
	static int min=0;
	public static void main(String[] args){
		dfs(0);
		System.out.println(min);
	}

	static void dfs(int n) {
		if(n==48) {
			for(int i=0;i<49;i+=7) {//对每周取数排序
				Arrays.sort(num,i,i+6);
			}
			for(int i=0,j=3;i<7;i++,j+=6) {
				result[i]=num[j];
			}
			Arrays.sort(result);//将7个中位数排序
			if(num[24]>min) {
				min=num[24];//记录
			}
			return;
		}
		for(int i=0;i<49;i++) {
			if(flag.charAt(i)=='0') {
				num[n]=i+1;
				dfs(n+1);
			}
		}
	}
}

试题 E: RSA 解密

• 【问题描述】
  RSA 是一种经典的加密算法。它的基本加密过程如下：
  首先生成两个质数 p, q，令 n = p·q，设 d 与 (p−1)·(q−1) 互质，则可 找到 e 使得 d·e 除 (p−1)·(q−1) 的余数为 1。
  n, d, e 组成了私钥，n, d 组成了公钥。
  当使用公钥加密一个整数 X 时（小于 n），计算 C = X^d mod n，则 C 是加 密后的密文。
  当收到密文 C 时，可使用私钥解开，计算公式为 X = C^e mod n。
  例如，当 p = 5, q = 11, d = 3 时，n = 55, e = 27。
  若加密数字 24，得 24³ mod 55 = 19。
  解密数字 19，得 19²⁷ mod 55 = 24。
  现在你知道公钥中 n = 1001733993063167141, d = 212353，同时你截获了 别人发送的密文 C = 20190324，请问，原文是多少？
• 【答案提交】
  579706994112328949

数学题，没学过数论，看的胃疼，放弃了
需要的知识：
欧几里得算法：gcd(a,b)=gcd(b,a%b)
扩展欧几里得：ax+by=gcd(a,b)
欧拉函数：phi（P * Q）=（P-1）*（Q-1）
欧拉定理：a ^ϕ(m)=1 mod m
乘法逆元：ax≡1 mod f, （≡：同余）
快速乘，快速幂

试题 F: 完全二叉树的权值

• 【问题描述】
  给定一棵包含 N 个节点的完全二叉树，树上每个节点都有一个权值，按从 上到下、从左到右的顺序依次是 A1, A2, ··· AN，如下图所示：
  
  现在小明要把相同深度的节点的权值加在一起，他想知道哪个深度的节点 权值之和最大？如果有多个深度的权值和同为最大，请你输出其中最小的深度。 注：根的深度是 1。
• 【输入格式】
  第一行包含一个整数 N。
  第二行包含 N 个整数 A1, A2, ··· AN 。
  【输出格式】
  输出一个整数代表答案。
• 【样例输入】
  7
  1 6 5 4 3 2 1
• 【样例输出】
  2

import java.util.Scanner;

public class Main {
	static int[] num;//存储结点权值
	static int[] weight;//存储每个深度的权值
	static int n;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		weight = new int[(int) Math.sqrt(n)+2];//最大节点下标平方根加2就是最大深度
		num = new int[n + 1];
		for (int i = 1; i <= n; i++) {
			num[i] = sc.nextInt();
		}
		dfs(1, 1);
		int max=1;
		for (int i = 2; i < weight.length; i++) {
			if(weight[i]>weight[max]) {
				max=i;
			}
		}
		System.out.println(max);
	}

	static void dfs(int x, int dep) {
		if (x > n)
			return;
		weight[dep] += num[x];
		dfs(x << 1, dep + 1);//遍历左支
		dfs((x << 1) + 1, dep + 1);//遍历右支

	}
}

试题 G: 外卖店优先级

• 【问题描述】
  “饱了么”外卖系统中维护着 N 家外卖店，编号 1 ∼ N。每家外卖店都有 一个优先级，初始时 (0 时刻) 优先级都为 0。 每经过 1 个时间单位，如果外卖店没有订单，则优先级会减少 1，最低减 到 0；而如果外卖店有订单，则优先级不减反加，每有一单优先级加 2。 如果某家外卖店某时刻优先级大于 5，则会被系统加入优先缓存中；如果 优先级小于等于 3，则会被清除出优先缓存。 给定 T 时刻以内的 M 条订单信息，请你计算 T 时刻时有多少外卖店在优 先缓存中。
• 【输入格式】
  第一行包含 3 个整数 N、M 和 T。 以下 M 行每行包含两个整数 ts 和 id，表示 ts 时刻编号 id 的外卖店收到 一个订单。
• 【输出格式】
  输出一个整数代表答案。
• 【样例输入】
  2 6 6
  1 1
  5 2
  3 1
  6 2
  2 1
  6 2
• 【样例输出】
  1
• 【样例解释】
  6 时刻时，1 号店优先级降到 3，被移除出优先缓存；2 号店优先级升到 6， 加入优先缓存。所以是有 1 家店 (2 号) 在优先缓存中。

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;

public class Main {
	static class Order implements Comparable<Order> {
		int ts;
		int id;

		public Order(int ts, int id) {//订单结构体
			this.ts = ts;
			this.id = id;
		}
		@Override
		public int compareTo(Order other) {//重写比较方法，用于排序时内部调用
			if (ts == other.ts) {
				if (id > other.id) {
					return 1;
				} else if (id < other.id) {
					return -1;
				}
				return 0;
			}
			return ts > other.ts ? 1 : -1;
		}

		@Override
		public boolean equals(Object obj) {//重写比较方法，用于两个订单比较
			Order other = (Order) obj;
			return ts == other.ts && id == other.id;
		}
	}

	static Order[] orders;// 订单组
	static boolean[] priority;// 优先队列
	static int[] rank;// 每个店优先级
	static int[] last;// 每个店上次有订单的时间

	public static void main(String[] args) throws IOException {
		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
		String[] date = br.readLine().split("\\s+");
		int N = Integer.parseInt(date[0]) + 1;// 店数，因为编号是1~N
		int M = Integer.parseInt(date[1]);// 订单数
		int T = Integer.parseInt(date[2]);// 时长
		orders = new Order[M];
		priority = new boolean[N];
		rank = new int[N];
		last = new int[N];
		for (int i = 0; i < M; i++) {
			date = br.readLine().split("\\s+");
			int ts = Integer.parseInt(date[0]);
			int id = Integer.parseInt(date[1]);
			orders[i] = new Order(ts, id);

		}
		Arrays.sort(orders);//将订单按时间排序，时间相同则编号小的在前
		for (int i = 0; i < M;) {//遍历订单
			int j = i;
			while (j < M && orders[i].equals(orders[j])) {
			//查询每个编号在当前时间内的订单总数
				j++;
			}
			//当前计数的店的编号，时间，订单数
			int id = orders[i].id, ts = orders[i].ts, ans = j - i;
			i = j;
			
			//该时刻前减少的优先级
			rank[id] -= ts - last[id] - 1;
			if (rank[id] < 0)
				rank[id] = 0;
			if (rank[id] <= 3)
				priority[id] = false;

			//该时刻增加的优先级
			rank[id] += ans * 2;
			if (rank[id] > 5)
				priority[id] = true;

			//记录该店最后有订单的时间
			last[id] = ts;
		}
		
		//搜寻完订单后要再更新一次
		for (int i = 1; i < N; i++) {
			if (last[i] < T) {
				rank[i] -= T - last[i];
				if (rank[i] <= 3)
					priority[i] = false;
			}
		}

		//输出答案
		int res = 0;
		for (int i = 0; i < N; i++) {
			if (priority[i]) {
				res++;
			}
		}
		System.out.println(res);

		br.close();
	}
}

试题 H: 修改数组

• 【问题描述】
  给定一个长度为 N 的数组 A = [A1,A2,……,AN]，数组中有可能有重复出现 的整数。
  现在小明要按以下方法将其修改为没有重复整数的数组。小明会依次修改 A2,A3,··· ,AN。
  当修改 Ai 时，小明会检查 Ai 是否在 A1 ∼ Ai−1 中出现过。如果出现过，则 小明会给 Ai 加上 1 ；如果新的 Ai 仍在之前出现过，小明会持续给 Ai 加 1 ，直 到 Ai 没有在 A1 ∼ Ai−1 中出现过。
  当 AN 也经过上述修改之后，显然 A 数组中就没有重复的整数了。 现在给定初始的 A 数组，请你计算出最终的 A 数组。
• 【输入格式】
  第一行包含一个整数 N。 第二行包含 N 个整数 A1,A2,··· ,AN 。
• 【输出格式】
  输出 N 个整数，依次是最终的 A1,A2,··· ,AN。
• 【样例输入】
  5
  2 1 1 3 4
• 【样例输出】
  2
  1 3 4 5

第一想法是用set判，但是超时了
改用并查集，所有访问过的元素存进一个集合，根就是最大值
import java.util.Scanner;

public class Main {
	static int N = 1000010;
	static int[] p = new int[N];

	static int find(int x) {
		if (p[x] != x)
			p[x] = find(p[x]);
		return p[x];
	}

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		for (int i = 0; i <= 1000000; i++)
			p[i] = i;

		for (int i = 0; i < n; i++) {
			int x = sc.nextInt();
			x = find(x);

			System.out.print(x + " ");

			p[x] = x + 1;
		}
	}
}

试题 I: 糖果

• 【问题描述】
  糖果店的老板一共有 M 种口味的糖果出售。为了方便描述，我们将 M 种 口味编号 1∼ M。
  小明希望能品尝到所有口味的糖果。遗憾的是老板并不单独出售糖果，而 是 K 颗一包整包出售。
  幸好糖果包装上注明了其中 K 颗糖果的口味，所以小明可以在买之前就知 道每包内的糖果口味。
  给定 N 包糖果，请你计算小明最少买几包，就可以品尝到所有口味的糖 果。
• 【输入格式】
  第一行包含三个整数 N、M 和 K。
  接下来 N 行每行 K 这整数 T1,T2,··· ,TK，代表一包糖果的口味。
• 【输出格式】
  一个整数表示答案。
  如果小明无法品尝所有口味，输出 −1。
• 【样例输入】
  6 5 3
  1 1 2
  1 2 3
  1 1 3
  2 3 5
  5 4 2
  5 1 2
• 【样例输出】
  2

import java.util.ArrayList;
import java.util.Scanner;

public class Main {
	static final int N = 100, M = 20;
	static int n, m, k;
	static int[] box = new int[N], f = new int[1 << M];
	static ArrayList<Integer>[] candy = new ArrayList[M];

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();//糖果包数
		m = sc.nextInt();//口味数
		k = sc.nextInt();//每包口味数
		for (int i = 0; i < m; i++) {
			f[1 << i] = i;//二进制状态对1所在位置的映射，比如f[100]=2
			candy[i]=new ArrayList<Integer>();//实例化，存储有i口味的糖果包
		}
		//初始化
		for(int i=0;i<n;i++) {
			box[i]=0;
			for(int j=0;j<k;j++) {
				int temp=sc.nextInt()-1;
				box[i]|=1<<temp;//将状态用二进制存储，如101就是有1 3口味
				candy[temp].add(i);
			}
		}
		
		int t;
		for (t = 0; t <= m; t++) {//搜索前t包
			if (dfs(t, 0)) {
				break;
			}
		}
		if (t > m)
			t = -1;
		System.out.println(t);
	}
	//迭代加深dfs
	private static boolean dfs(int u, int state) {
		if (u == 0 || u < h(state)) {//如果可选包数比最少包数都少
			if (state == (1 << m) - 1) {
				return true;
			}
			return false;
		}

		int c = -1;
		//要找到还没有尝的口味，可以使用lowbit操作，可以找到最后一个1
		//因为原状态0是没尝到的，所以先取反
		for (int s = (1 << m) - 1 - state; s > 0; s -= s & -s) {
			int i = f[s & -s];//lowbit：找到最后一个1的位置
			//选择可选性较小的口味，比如2口味有3包，4口味有1包
			//则选择有4口味的查看是否满足，这样遍历深度更低
			if (c == -1 || candy[c].size() > candy[i].size())
				c = i;
		}
		//遍历选取有c口味的糖果包
		for (int p : candy[c])
			if (dfs(u - 1, state | box[p]))
				return true;
		return false;
	}
	//估价函数，判断当前状态最少还要选几包
	private static int h(int state) {
		int res = 0;
		for (int s = (1 << m) - 1 - state; s > 0; s -= s & -s) {
			int i = f[s & -s];
			res++;
			//例如此时缺少3口味，把所有带3口味的糖果包全部选取，记作拿了一包
			//显然，正常的选取方法不可能有比这种拿法更少的步数
			for (int p : candy[i])
				s &= ~box[p];
		}
		return res;
	}

}

试题 J: 组合数问题

• 还是数学题，不会。