- 微信
- 微博
  
  分享文章到微博
- 复制链接
  
  复制链接到剪贴板

第八届蓝桥杯决赛JavaC组真题——详细答案对照(完整版)

红目香薰发表于 2022/03/24 16:26:50 2022/03/24

【摘要】目录标题：数位和标题：数字划分标题：树形显示标题：小数第n位标题：分考场标题：合根植物标题：数位和数学家高斯很小的时候就天分过人。一次老师指定的算数题目是：1+2+...+100。高斯立即做出答案：5050!这次你的任务是类似的。但并非是把一个个的数字加起来，而是对该数字的每一个数位作累加。这样从1加到100的“和”是：901从10加到15是：21，也就是：1+0+1+1+1+2+1+...

标题：数位和

数学家高斯很小的时候就天分过人。一次老师指定的算数题目是：1+2+...+100。
高斯立即做出答案：5050!

这次你的任务是类似的。但并非是把一个个的数字加起来，而是对该数字的每一个数位作累加。
这样从1加到100的“和”是：901

从10加到15是：21，也就是：1+0+1+1+1+2+1+3+1+4+1+5，这个口算都可以出结果的。

按这样的“加法”，从1加到1000是多少呢？请通过浏览器提交该结果。

当然，我们并不期望你能像高斯一样，发现数字背后深奥的秘密，只要请计算机帮忙，一切都easy!

注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）

package action;

public class demo {
	public static void main(String[] args) {
		int sum = 0;
		String str = "";
		for (int i = 1; i <= 1000; i++) {
			str += i;
		}
		char[] arr = str.toCharArray();
		for (int i = 0; i < arr.length; i++) {
			sum += arr[i] - '0';
		}
		System.out.println(sum);
	}
}

标题：数字划分

w星球的长老交给小明一个任务：
1,2,3...16 这16个数字分为两组。
要求：
这两组数字的和相同，
并且，两组数字的平方和也相同，
并且，两组数字的立方和也相同。

请你利用计算机的强大搜索能力解决这个问题。
并提交1所在的那个分组的所有数字。

这些数字要从小到大排列，两个数字间用一个空格分开。
即类似：1 4 5 8 ... 这样的答案。

注意，只提交这一组数字，不要填写任何多余的内容。

package action;

import java.util.Vector;

public class demo {
	public static void main(String[] args) {
		for (int w = 1; w <= (1 << 16) - 1; w += 2) {// 枚举有1出现的数组的所有情况，将其表示成十进制和的形式
			Vector<Integer> group1 = new Vector<Integer>();
			Vector<Integer> group2 = new Vector<Integer>();
			int k;
			int s1[] = new int[2];// s[1]表示1所在分组的和，s[0]表示1不在分组的和
			int s2[] = new int[2];// s2[1]表示1所在组的平方和，s2[0]表示1不在组的平方和
			int s3[] = new int[2];// s3[1]表示1所在组的立方和，s3[0]表示1不在组的立方和

			// 将w十进制转为二进制
			for (int i = 0; i < 16; i++) {
				int m = 1 << i;
				if ((w & m) != 0) {// 按位与判断当前数字是否在1分组中
					k = 1;
				} else
					k = 0;
				if (k == 1)
					group1.add(i + 1);
				else
					group2.add(i + 1);
				s1[k] += i + 1;
				s2[k] += (i + 1) * (i + 1);
				s3[k] += (i + 1) * (i + 1) * (i + 1);
			}

			if (s1[0] == s1[1] && s2[0] == s2[1] && s3[0] == s3[1]) {
				for (int i = 0; i < group1.size(); i++)
					System.out.print(group1.get(i) + " ");
				System.out.println();
			}
		}
	}
}

标题：树形显示

对于分类结构可以用树形来形象地表示。比如：文件系统就是典型的例子。

树中的结点具有父子关系。我们在显示的时候，把子项向右缩进（用空格，不是tab），并添加必要的连接线，以使其层次关系更醒目。

下面的代码就是为了这个目的的，请仔细阅读源码，并填写划线部分缺少的代码。

import java.util.*;

class MyTree
{
    private Map<String, List<String>>  map_ch = new HashMap<String, List<String>>();
    private Map<String,String> map_pa = new HashMap<String,String>();
    
    public void add(String parent, String child)
    {
        map_pa.put(child, parent);
        
        List<String> lst = map_ch.get(parent);
        if(lst==null){
            lst = new ArrayList<String>();
            map_ch.put(parent, lst);
        }
        lst.add(child);
    }
    
    public String get_parent(String me){
        return map_pa.get(me);
    }
    
    public List<String> get_child(String me){
        return map_ch.get(me);
    }
    
    private String space(int n)
    {
        String s = "";
        for(int i=0; i<n; i++) s += ' ';
        return s;
    }
    
    private boolean last_child(String x){
        String pa = map_pa.get(x);
        if(pa==null) return true;
        
        List<String> lst = map_ch.get(pa);
        return lst.get(lst.size()-1).equals(x);
    }
    
    public void show(String x){
        
        String s = "+--" + x;
        
        String pa = x;
        while(true){
            pa = map_pa.get(pa);
            if(pa==null) break;
            s = ___________________________________ ;  // 填空
        }
        
        System.out.println(s);
    }
    
    public void dfs(String x){
        show(x);
        
        List<String> lst = map_ch.get(x);
        if(lst==null) return;
                
        for(String it: lst){
            dfs(it);
        }
    }
}

public class TreeView
{
    public static void main(String[] args)
    {
        MyTree tree = new MyTree();
        tree.add("root", "dog");
        tree.add("root", "cat");
        tree.add("root", "duck");
        tree.add("dog", "AAdog");
        tree.add("dog", "BBdog");
        tree.add("dog", "CCdog");
        tree.add("AAdog", "AAdog01");
        tree.add("AAdog", "AAdog02");
        tree.add("cat", "XXcat");
        tree.add("cat", "YYcat");
        tree.add("XXcat","XXcat-oo");
        tree.add("XXcat","XXcat-qq");
        tree.add("XXcat-qq", "XXcat-qq-hahah");
        tree.add("duck", "TTduck");
        tree.add("TTduck", "TTduck-001");
        tree.add("TTduck", "TTduck-002");
        tree.add("TTduck", "TTduck-003");
        tree.add("YYcat","YYcat.hello");
        tree.add("YYcat","YYcat.yes");
        tree.add("YYcat","YYcat.me");        
        
        tree.dfs("root");
    }
}

注意，只填写划线部分缺少的代码，不要抄写已有的代码或符号。

填空内容：

s = (last_child(pa) ? " " : "|") + space(4) + s;

package action;

import java.util.*;

class MyTree {
	private Map<String, List<String>> map_ch = new HashMap<String, List<String>>();
	private Map<String, String> map_pa = new HashMap<String, String>();

	public void add(String parent, String child) {
		map_pa.put(child, parent);

		List<String> lst = map_ch.get(parent);
		if (lst == null) {
			lst = new ArrayList<String>();
			map_ch.put(parent, lst);
		}
		lst.add(child);
	}

	public String get_parent(String me) {
		return map_pa.get(me);
	}

	public List<String> get_child(String me) {
		return map_ch.get(me);
	}

	private String space(int n) {
		String s = "";
		for (int i = 0; i < n; i++)
			s += ' ';
		return s;
	}

	private boolean last_child(String x) {
		String pa = map_pa.get(x);
		if (pa == null)
			return true;

		List<String> lst = map_ch.get(pa);
		return lst.get(lst.size() - 1).equals(x);
	}

	public void show(String x) {

		String s = "+--" + x;

		String pa = x;
		while (true) {
			pa = map_pa.get(pa);
			if (pa == null)
				break;
			s = s = (last_child(pa) ? " " : "|") + space(4) + s; // 填空 s = (last_child(pa) ? " " : "|") + space(4) + s;
		}

		System.out.println(s);
	}

	public void dfs(String x) {
		show(x);

		List<String> lst = map_ch.get(x);
		if (lst == null)
			return;

		for (String it : lst) {
			dfs(it);
		}
	}
}

public class TreeView {
	public static void main(String[] args) {
		MyTree tree = new MyTree();
		tree.add("root", "dog");
		tree.add("root", "cat");
		tree.add("root", "duck");
		tree.add("dog", "AAdog");
		tree.add("dog", "BBdog");
		tree.add("dog", "CCdog");
		tree.add("AAdog", "AAdog01");
		tree.add("AAdog", "AAdog02");
		tree.add("cat", "XXcat");
		tree.add("cat", "YYcat");
		tree.add("XXcat", "XXcat-oo");
		tree.add("XXcat", "XXcat-qq");
		tree.add("XXcat-qq", "XXcat-qq-hahah");
		tree.add("duck", "TTduck");
		tree.add("TTduck", "TTduck-001");
		tree.add("TTduck", "TTduck-002");
		tree.add("TTduck", "TTduck-003");
		tree.add("YYcat", "YYcat.hello");
		tree.add("YYcat", "YYcat.yes");
		tree.add("YYcat", "YYcat.me");

		tree.dfs("root");
	}
}

输出效果：

标题：小数第n位

我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。
如果我们把有限小数的末尾加上无限多个0，它们就有了统一的形式。

本题的任务是：在上面的约定下，求整数除法小数点后的第n位开始的3位数。

输入：
一行三个整数：a b n，用空格分开。a是被除数，b是除数，n是所求的小数后位置（0<a,b,n<1000000000）
输出：
一行3位数字，表示：a除以b，小数后第n位开始的3位数字。

比如：
输入：
1 8 1

程序应该输出：
125

再比如：
输入：
1 8 3

程序应该输出：
500

再比如：
输入：
282866 999000 6

程序应该输出：
914

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

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

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

package action;

import java.util.*;

public class demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int a = sc.nextInt();
		int b = sc.nextInt();
		int len = sc.nextInt();
		sc.close();
		a = a % b;
		String str = "";
		int i = len + 2;
		// 遍历掉大量的无用数据
		for (; i > 10; i -= 7) {
			a = a * 10000000 % b;
			if (a == 0) { // 如果整除则直接跳出
				break;
			}
		}
		for (; i > 0; i--) {
			if (i <= 3) {
				str = str + a * 10 / b; // 最后三位使用字符串保存
			}
			if (a == 0) { // 如果整除则直接跳出
				break;
			}
			a = a * 10 % b;
		}
		while (str.length() < 3) { // 将字符串的长度补到3
			str = str + "0";
		}
		System.out.println(str);
	}
}

标题：分考场

n个人参加某项特殊考试。
为了公平，要求任何两个认识的人不能分在同一个考场。
求是少需要分几个考场才能满足条件。

输入格式：
第一行，一个整数n(1<n<100)，表示参加考试的人数。
第二行，一个整数m，表示接下来有m行数据
以下m行每行的格式为：两个整数a，b，用空格分开 (1<=a,b<=n) 表示第a个人与第b个人认识。

输出格式：
一行一个整数，表示最少分几个考场。

例如：
输入：
5
8
1 2
1 3
1 4
2 3
2 4
2 5
3 4
4 5

程序应该输出：
4

再比如：
输入：
5
10
1 2
1 3
1 4
1 5
2 3
2 4
2 5
3 4
3 5
4 5

则程序应该输出：
5

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 1000ms

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

package action;

import java.util.*;

public class demo {
	public static int n = 0, m = 0, min = 1000;
	public static boolean[][] know;
	public static int[][] kaochang;

	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		n = sc.nextInt();
		m = sc.nextInt();
		know = new boolean[n + 1][n + 1];
		kaochang = new int[n + 1][n + 1];
		for (int i = 0; i < m; i++) {
			int c = sc.nextInt();
			int d = sc.nextInt();
			know[c][d] = true;
			know[d][c] = true;
		}
		sc.close();
		f(1, 1);
		System.out.println(min);
	}

	public static void f(int a, int b) {// a是考场b是人
		if (b >= n + 1) {
			min = Math.min(a, min);
			return;
		}
		if (a >= min) {
			return;
		}
		A: for (int i = 1; i <= a; i++) {
			int j;
			for (j = 1; j < b; j++) {
				if (kaochang[i][j] != 0) {
					if (know[b][j]) {
						continue A;
					}
				}
			}
			if (j == b) {
				kaochang[i][b] = b;
				f(a, b + 1);
				kaochang[i][b] = 0;
			}
		}
		kaochang[a + 1][b] = b;
		f(a + 1, b + 1);
		kaochang[a + 1][b] = 0;
	}
}

标题：合根植物

w星球的一个种植园，被分成 m * n 个小格子（东西方向m行，南北方向n列）。每个格子里种了一株合根植物。
这种植物有个特点，它的根可能会沿着南北或东西方向伸展，从而与另一个格子的植物合成为一体。

如果我们告诉你哪些小格子间出现了连根现象，你能说出这个园中一共有多少株合根植物吗？

输入格式：
第一行，两个整数m，n，用空格分开，表示格子的行数、列数（1<m,n<1000）。
接下来一行，一个整数k，表示下面还有k行数据(0<k<100000)
接下来k行，第行两个整数a，b，表示编号为a的小格子和编号为b的小格子合根了。

格子的编号一行一行，从上到下，从左到右编号。
比如：5 * 4 的小格子，编号：
1 2 3 4
5 6 7 8
9 10 11 12
13 14 15 16
17 18 19 20

样例输入：
5 4
16
2 3
1 5
5 9
4 8
7 8
9 10
10 11
11 12
10 14
12 16
14 18
17 18
15 19
19 20
9 13
13 17

样例输出：
5

其合根情况参考图[p1.png]

资源约定：
峰值内存消耗 < 256M
CPU消耗 < 2000ms

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

package action;

import java.util.*;

public class demo {
	public static void main(String[] args) {
		Scanner sc = new Scanner(System.in);
		int n = sc.nextInt();
		int m = sc.nextInt();
		int a, b, c, d;
		int[] shu = new int[m * n + 1];
		int[][] num = new int[n][m];
		int k = sc.nextInt();
		for (int i = 0; i < shu.length; i++) {
			shu[i] = i;
		}
		for (int i = 0; i < k; i++) {
			c = sc.nextInt();
			d = sc.nextInt();
			a = Math.min(c, d);
			b = Math.max(c, d);
			if (shu[b] == b) {
				shu[b] = shu[a];
			} else {
				shu[a] = shu[b];
			}
		}
		int count = 0;
		for (int i = 1; i < shu.length; i++) {
			if (shu[i] == i) {
				count++;
			}
		}
		System.out.println(count);
	}
}

点赞
收藏
关注作者

0/1000

抱歉，系统识别当前为高风险访问，暂不支持该操作

全部回复

上滑加载中

设置昵称

在此一键设置昵称，即可参与社区互动！

*长度不超过10个汉字或20个英文字符，设置后3个月内不可修改。

确认取消

加入云驻计划，成为创作者

华为云周边好礼
免费体验产品
特殊身份标识
线下官方门票
内部专家零距离
与10000+优质创作者共同成长

立即加入

第八届蓝桥杯决赛JavaC组真题——详细答案对照(完整版)

标题：数位和

标题：数字划分

标题：树形显示

标题： 小数第n位

​ 标题：分考场

标题：合根植物

全部回复

设置昵称

关于作者

目录

加入云驻计划，成为创作者

推荐阅读

相关产品

标题：小数第n位

标题：分考场