第八届蓝桥杯 2017年国赛真题（Java 大学C组）
【摘要】 蓝桥杯---Java大学C组---个人赛日常刷题【day12】
标题：数位和
题目：
数学家高斯很小的时候就天分过人。一次老师指定的算数题目是：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!
注意：你需要提交的是一个整数，不要填写任何多余的内容（比如：说明性文字）这道题就是取出来个十百位，然后相加即可。
import java.util.*;
public class Main
{
public static void main(String args[])
{
int sum=0;
for (int i = 1; i <=1000; i++) {
int a= i/100;
int b=i %100/10;
int c=i%10;
sum+=(a+b+c);
}
System.out.println(sum);
}
}答案：13510
标题：数字划分
题目：
w星球的长老交给小明一个任务：
1,2,3...16 这16个数字分为两组。
要求：
这两组数字的和相同，
并且，两组数字的平方和也相同，
并且，两组数字的立方和也相同。
请你利用计算机的强大搜索能力解决这个问题。
并提交1所在的那个分组的所有数字。
这些数字要从小到大排列，两个数字间用一个空格分开。
即类似：1 4 5 8 ... 这样的答案。
注意，只提交这一组数字，不要填写任何多余的内容。这道题直接暴力求解，能暴力解出来的题，千万别想别的方法，费脑细胞。
import java.util.*;
public class Main
{
public static void main(String args[])
{
int square=0;//保存平方和
int cube=0;//保存立方和
//建立映射 和获取square，cube
for (int i = 0; i < 16; i++) {
int x=i+1;
nums[i][0]=x*x;
square+=nums[i][0];
nums[i][1]=x*x*x;
cube+=nums[i][1];
}
square/=2;//分成两组且平方和也相同故/2
cube/=2;//分成两组且立方和也相同故/2
//暴力
for (int i = 1; i <16; i++) {
for (int j = 2; j < 16; j++) {
for (int k = 3; k < 16; k++) {
for (int l = 4; l < 16; l++) {
for (int m = 5; m < 16; m++) {
for (int n =6; n < 16; n++) {
for (int o = 7; o < 16; o++) {
int[] group= {0,i,j,k,l,m,n,o};//建立数组保存值，方便求和
int[] sums=getSum(group);//获取平方和，立方和
if (sums[0]==square&&cube==sums[1]) {//相等输出结果
for (int z:group) {
System.out.println(z+1+" ");
}
return;
}
}
}
}
}
}
}
}
}
public static int[] getSum(int[] group) {
int[] sums=new int[2];
for (int i = 0; i < group.length; i++) {
sums[0]+=nums[group[i]][0];
sums[1]+=nums[group[i]][1];
}
return sums;
}
}答案：1 4 6 7 10 11 13 16
标题：树形显示
题目：
对于分类结构可以用树形来形象地表示。比如：文件系统就是典型的例子。
树中的结节具有父子关系。我们在显示的时候，把子项向右缩进（用空格，不是tab），并添加必要的连接线，以使其层次关系更醒目。
下面的代码就是为了这个目的的，请仔细阅读源码，并填写划线部分缺少的代码。对于题目中的测试数据，输出结果:
+--root
+--dog
| +--AAdog
| | +--AAdog01
| | +--AAdog02
| +--BBdog
| +--CCdog
+--cat
| +--XXcat
| | +--XXcat-oo
| | +--XXcat-qq
| | +--XXcat-qq-hahah
| +--YYcat
| +--YYcat.hello
| +--YYcat.yes
| +--YYcat.me
+--duck
+--TTduck
+--TTduck-001
+--TTduck-002
+--TTduck-003
如有平字体对齐问题，可以参见图【p1.png】
注意，只填写划线部分缺少的代码，不要抄写已有的代码或符号。
代码：
这道题大家自行理解。。。。。。
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");
}
}填空位置：(last_child(pa)? "." : "|") + space(4) + s
标题：小数第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//java code
import java.util.Scanner;
public class Main {
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int a = sc.nextInt();
int b = sc.nextInt();
int n = sc.nextInt();
String str = "";
a=a%b;
int i=n+2;
for (;i>10;i-=7){
a=a*10000000%b;
if(a==0) break;
}//排除过多的无用数据，可减小程序运行的空间与时间
for (;i>0;i--){//循环次数，小数点后
if(i<=3){//开始截取位置
str+=a*10/b;
}
if(a==0) break;//因为到这可能跳出，所以str位数可能不够三位，所以下面要补足
a=a*10%b;
}
while(str.length()<3)
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
import java.util.Scanner;
public class fenkaochang {
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]
代码：
//java code
import java.util.HashSet;
import java.util.Scanner;
import java.util.Set;
public class Main {
static int shu[];
public static void main(String[] args) {
Scanner sc = new Scanner(System.in);
int m = sc.nextInt();
int n = sc.nextInt();
int k = sc.nextInt();
shu=new int[m*n];
for (int i = 0; i < m*n; i++) {
shu[i]=i;
}
for (int i = 0; i < k; i++) {
int a=sc.nextInt()-1;
int b=sc.nextInt()-1;
u(a,b);
}
Set<Integer> sum=new HashSet<>();
for (int i = 0; i < m*n; i++) {
sum.add(shu[f(i)]);
}
System.out.println(sum.size());
}
static void u(int a,int b){
if(f(a)==f(b))
return;
shu[f(a)]=f(b);
}
static int f(int a){
if(shu[a]==a)
return a;
return shu[a]=f(shu[a]);
}
}
国赛题是真的太难理解了，就1，2题还阔以，剩下的几道我不理解。
推荐
华为开发者空间发布
让每位开发者拥有一台云主机
【版权声明】本文为华为云社区用户原创内容，转载时必须标注文章的来源（华为云社区）、文章链接、文章作者等基本信息， 否则作者和本社区有权追究责任。如果您发现本社区中有涉嫌抄袭的内容，欢迎发送邮件进行举报，并提供相关证据，一经查实，本社区将立刻删除涉嫌侵权内容，举报邮箱：
cloudbbs@huaweicloud.com
- 点赞
- 收藏
- 关注作者
评论（0）