第十届蓝桥杯java省赛部分题解（适合新手）

以下题解只是个人的理解，如果发现答案有误或者有更简洁方式，望大家及时指出！！  部分题解自己还没有想到更好的方式去解答，如果有更好的解题方式会及时更新。

试题A ：组队------ 答案 490

 

这道题没有必要使用代码进行解题，本题的坑主要在于一个人只能选择一次，只要认真审题，就可以解答出来。

试题B ：不同子串

	public static void main(String[] args) {
		String num[] = new String[150];
		String str = "0100110001010001";
		int k = 0;
		for (int i = 0; i <= str.length(); i++) {
			for (int j = i + 1; j <= str.length(); j++) {
				String s = str.substring(i, j);
				int c = 0;
				for (int z = 0; z < k; z++) {
					if (num[z].equals(s)) {
						c = -1;
						break;
					}
				}
				if (c == 0) {
					num[k] = s;
					k++;
				}
			}
		}
		System.out.println(k);
	}

解题思路：本题主要运用了字符串的subString方法，如果不理解subString方式，请自行查阅API文档或百度。创建一个num数组，来储存截取出来的字符串，因为现在还不知道结果是多少，所以声明数组长度时，我声明了150个长度。接下来使用subString方法将字符串截取，截取出一个字符串之后放到num中，放入num数组时，进行判断，如果当前数组已经有了和当前截取出的字符串相等的，则跳过，如果num数组中没有和当前截取出的字符串相等的，就放入num数组中。最后k的值就是不同子串的个数。注意：这里需要注意一下，比较字符串是否相等时需要使用a.equals(b)方法，不能使用==进行判断。因为String重写equals（）方法。对于字符串的比较时，equals比较的是内容是否相等，而==比较的引用地址。所以，一般在比较字符串时，建议使用equals方法进行比较。当然，如果学了集合的同学，没有比较这么麻烦使用数组进行判断，可以根据set集合的无序不可重复性，当遍历完成之后，直接获取set集合的size即可。

试题C:数列求和

	public static void main(String[] args) {
		int a = 1;
		int b = 1;
		int c = 1;
		int sum = 0;
		for (int i = 3; i < 20190324; i++) {
			sum = (a + b + c) % 10000;
			a = b;
			b = c;
			c = sum;
		}
		System.out.println(c);
	}

解题思路：这个题的思路比较简单，有一个坑，不能直接算出20190324的和在对结果取后四位，因为20190324的结果已经超过了int的最大值，在java中如果对int的最大值2147483647  +1，它会变成-2147483648。所以直接计算会导致计算结果不准确。

试题F：特别数的和

	public static void main(String[] args) {
		int sum = 0;
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		for (int i = 1; i <= n; i++) {
			String j = i + "";
			if (j.indexOf("0") == -1 && j.indexOf("2") == -1 && j.indexOf("1") == -1 && j.indexOf("9") == -1) {
				continue;
			}
		}
		System.out.println(sum);

	}

这里使用了数组的indexOf方法，可以利用这个方法，判断其中有没有2019， 如果没有则会返回-1。

试题G: 外面优先级

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt(); // n家店
		int m = s.nextInt(); // m个数据
		int t = s.nextInt(); // t时刻
		int a[][] = new int[m][2]; // 保存用户输入
		for (int i = 0; i < m; i++) {
			a[i][0] = s.nextInt();
			a[i][1] = s.nextInt();
		}
		int b[] = new int[n]; // 保存优先级 索引为0 表示第一家店的优先级
		int c[] = new int[n]; // 保存优先缓存
		int count = 0; // 默认优先缓存为0
		// 接下来就可以判断，如果当前时刻有订单 ，则优先级+2，没有则优先级-1
		int k = 1; // k表示当前时间
		// 循环a数组，查找当前时间是否有订单
		for (; k <= t; k++) {
			for (int i = 0; i < m; i++) {
				if (a[i][0] == k) {
					// 表示k时刻时 有外卖订单
					for (int j = 0; j < n; j++) { // j+1 表示店
//						当 j+1 等于 a[i][1] 表示当前店有订单 有订单+2    没有订单-1
						if (a[i][1] == j + 1) {
							b[j] += 2;
						} else {
							if (b[j] != 0)
								b[j]--;
						}
						// 当优先级大于5时，加入优先缓存
						if (b[j] > 5) {
							c[count++] = j + 1; // 保存店名
						}
						// 当优先级小于等于3 ，删除缓存
						if (b[j] <= 3) {
							for (int l = 0; l < n; l++) {
								if (c[l] == j + 1) {
									c[l] = -1;
									count--;
								}
							}
						}
					}
				}

			}
		}

		System.out.println(count);
	}

解题思路：a数组来保存用户输入，b数组保存店家的优先级，b[0] 保存了第一家店的优先级，b[1]保存了第二家店的优先级，以此类推。c数组来保存优先级缓存，当满足条件时，会被添加到c数组中。然后进行判断就可以了。

试题H:人物相关性

	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int k = s.nextInt();
		s.nextLine();
		String str = s.nextLine();
		String a = "Alice";
		String a1 = "Alice.";
		String b = "Bob";
		String b1 = "Bob.";
		int count = 0;
		int num = 0;
//		按照空格分隔
		String str1[] = str.split(" ");
//		寻找Alice  -> Bob
		for (int i = 0; i < str1.length; i++) {
			if (str1[i].equals(a) || str1[i].equals(a1)) {
				if (str1[i].equals(a1)) {
					num = 1;
				}
				for (int j = i + 1; j < str1.length; j++) {
					num += str1[j].length();
					if (str1[j].equals(b) || str1[j].equals(b1)) {
						num = num + j - i;
						if (str1[j].equals(b1)) {
							num = num - 4;
						} else {
							num = num - 3;
						}
						if (num > k)
							break;
						count++;
						num = 0;
					}
				}
			}

		}

//		寻找Bob -> Alice
		for (int i = 0; i < str1.length; i++) {
			if (str1[i].equals(b) || str1[i].equals(b1)) {
				if (str1[i].equals(b1)) {
					num = 1;
				}
				for (int j = i + 1; j < str1.length; j++) {
					num += str1[j].length();
					if (str1[j].equals(a) || str1[j].equals(a1)) {
						num = num + j - i;
						if (str1[j].equals(a1)) {
							num = num - 6;
						} else {
							num = num - 5;
						}
						if (num > k)
							break;
						count++;
						num = 0;
					}
				}
			}

		}
		System.out.println(count);
	}

解题思路: 首先注意，输入带有空格的字符串的时候，只能使用nextLine方法，但是如果nextLine在nextint之后时，会将输入nextInt的回车当作输入的值，所以要想在nextInt之后正确的使用nextLine，需要多添加一个nextLine方法。将输入的字符串按照空格分隔存入一个数组中，这样每个单词就成了单独的元素。接下来开始遍历寻找Alice或Alice. ，找到后，开始向后寻找Bob或Bob. 如果找到，只需要判断他们之间的距离是否满足条件，但是怎么才能高效的找出他们 之间的距离呢？ 我想到的方式是，他们之间的距离，就是Alice和Bob之间每个单词的长度，但是光有长度时不够的，因为还要算上空格，他们之间空格的个数就是Bob当前的索引j减去Alice当前的索引i，这样就可以计算出他们之间的距离，就可以判断是否满足条件了。无法确定Alice开头还是Bob开头，所以写了两个for循环。

试题I：后缀表达式

	/**
	 * 输入N 个+ M个-
	 * 
	 * @param args
	 */
	public static void main(String[] args) {
		Scanner s = new Scanner(System.in);
		int n = s.nextInt();
		int m = s.nextInt();
		int a[] = new int[n + m + 1];
		for (int i = 0; i < a.length; i++) {
			a[i] = s.nextInt();
		}
		int b = 0;
		int c = 0;
		Arrays.sort(a);
		System.out.println(Arrays.toString(a));
		for (int i = a.length - 1; i >= 0; i--) {
			if (c <= n) {
				c++;
				b += a[i];
			} else {
				b -= a[i];
			}
		}
		System.out.println(b);
	}

解题思路：要计算他们的最大值，只需要将大值加起来，减去小值就可以了。使用sort将输入的排序，将前面大的值加起来，减去后面小的值就是计算的最大结果

拿到算法题之后，先不要着急敲代码，先把自己的思路写到纸上，然后把思路弄好之后，在敲也不迟。遇到一些复杂的问题，先将问题简化，一步步来。 如果这篇文章对你有帮助，记得点赞吖。