第五届省赛(软件类)真题—-Java大学B组答案及解析
- 正则切分
- 调和级数
- n的n次幂
- 七对数字
- 勾股定理
- 九阶数独
- G将军
一、正则切分
java中提供了对正则表达式的支持。
有的时候,恰当地使用正则,可以让我们的工作事半功倍!
如下代码用来检验一个四则运算式中数据项的数目,请填写划线部分缺少的代码。
注意:只填写缺少代码,不要写任何多余内容,例如,已有的双引号。
public class A
{
public static int f(String s)
{
return s.split("______________").length;
}
public static void main(String[] args)
{
System.out.println(f("12+35*5-2*18/9-3")); //7
System.out.println(f("354*12+3-14/7*6")); //6
}
}
答案: [-+*/]
二、调和级数
1/1 + 1/2 + 1/3 + 1/4 + … 在数学上称为调和级数。
它是发散的,也就是说,只要加上足够多的项,就可以得到任意大的数字。
但是,它发散的很慢:
前1项和达到 1.0
前4项和才超过 2.0
前83项的和才超过 5.0
那么,请你计算一下,要加多少项,才能使得和达到或超过 15.0 呢?
请填写这个整数。
注意:只需要填写一个整数,不要填写任何多余的内容。比如说明文字。
答案:1835421
public class Main {
public static void main(String[] args)
{
double sum = 0.0;
for (int i = 1; i < 10000000; i++) {
sum += 1.0/i;
if (sum >= 15.0) {
System.out.println(i);
break;
}
}
}
}
三、n的n次幂
如果x的x次幂结果为10(参见【图1.png】),你能计算出x的近似值吗?
显然,这个值是介于2和3之间的一个数字。
请把x的值计算到小数后6位(四舍五入),并填写这个小数值。
注意:只填写一个小数,不要写任何多余的符号或说明。
答案:3.162278
public class Main {
public static void main(String[] args) {
System.out.println(sqrt(10));
}
/**
* 牛顿迭代法开平方
* */
public static double sqrt(double c)
{
if(c < 0)
{
return Double.NaN;
}
double err = 1e-15;
double t = c;
while(Math.abs(t - c/t) > err*t)
{
t = (c/t + t)/2.0;
}
return t;
}
}
四、7对数组★
今有7对数字:两个1,两个2,两个3,…两个7,把它们排成一行。
要求,两个1间有1个其它数字,两个2间有2个其它数字,以此类推,两个7之间有7个其它数字。如下就是一个符合要求的排列:
17126425374635
当然,如果把它倒过来,也是符合要求的。
请你找出另一种符合要求的排列法,并且这个排列法是以74开头的。
注意:只填写这个14位的整数,不能填写任何多余的内容,比如说明注释等。
答案:74151643752362
public class Main {
public static int dfs(int[] a, int n) {
if(n == 4) {
n++;
}
if(n > 6) {
return 1;
}
for(int i = 3; i <= 14; i++) {
if(i == 7 || i == 9) {
continue;
}
if(i+n+1 <= 14 && a[i] == 0 && a[i+n+1] == 0) {
a[i] = a[i+n+1] = n;
if(dfs(a, n+1) != 0) {
return 1;
}
/*回溯*/
a[i] = a[i+n+1] = 0;
}
}
return 0;
}
public static void main(String[] args) {
int[] a = new int[]{0,7,4,0,0,0,0,4,0,7,0,0,0,0,0};
dfs(a, 1);
for(int i = 1; i <= 14; i++) {
System.out.print(a[i]);
}
}
}
五、勾股定理
勾股定理,西方称为毕达哥拉斯定理,它所对应的三角形现在称为:直角三角形。
已知直角三角形的斜边是某个整数,并且要求另外两条边也必须是整数。
求满足这个条件的不同直角三角形的个数。
【数据格式】
输入一个整数 n (0n<10000000) 表示直角三角形斜边的长度。
要求输出一个整数,表示满足条件的直角三角形个数。
例如,输入:
5
程序应该输出:
1
再例如,输入:
100
程序应该输出:
2
再例如,输入:
3
程序应该输出:
0
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
注意:不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意:主类的名字必须是:Main,否则按无效代码处理。
import java.util.Scanner;
public class Main {
static int[] s;
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
int cnt = 0;
for (int i = 1; i < Math.sqrt(Math.pow(n, 2)/2); i++) {
int j = (int) Math.sqrt(Math.pow(n, 2) - Math.pow(i, 2));
if (Math.pow(i, 2) + Math.pow(j, 2) == Math.pow(n, 2)) {
cnt++;
}
}
System.out.println(cnt);
}
}
六、九阶数独
你一定听说过“数独”游戏。
如【图1.png】,玩家需要根据9×9盘面上的已知数字,推理出所有剩余空格的数字,并满足每一行、每一列、每一个同色九宫内的数字均含1-9,不重复。
数独的答案都是唯一的,所以,多个解也称为无解。
本图的数字据说是芬兰数学家花了3个月的时间设计出来的较难的题目。但对会使用计算机编程的你来说,恐怕易如反掌了。
本题的要求就是输入数独题目,程序输出数独的唯一解。我们保证所有已知数据的格式都是合法的,并且题目有唯一的解。
格式要求,输入9行,每行9个字符,0代表未知,其它数字为已知。
输出9行,每行9个数字表示数独的解。
例如:
输入(即图中题目):
005300000
800000020
070010500
400005300
010070006
003200080
060500009
004000030
000009700
程序应该输出:
145327698
839654127
672918543
496185372
218473956
753296481
367542819
984761235
521839764
再例如,输入:
800000000
003600000
070090200
050007000
000045700
000100030
001000068
008500010
090000400
程序应该输出:
812753649
943682175
675491283
154237896
369845721
287169534
521974368
438526917
796318452
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 2000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
注意:不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意:主类的名字必须是:Main,否则按无效代码处理。
import java.util.Scanner;
public class Main {
static String[][] a = new String[9][9];
static String[] str = new String[9];
public static void main(String args[]){
//采用字符串存储,每次sc.nextLine()输入一行,通过split分隔后放入
Scanner sc = new Scanner(System.in);
for(int i = 0;i < 9;i++) {
str[i] = sc.nextLine();
a[i] = str[i].split("");
}
/*调用回溯*/
backtrace(0,0);
}
static void backtrace(int x,int y){
if(x==9) {
for(int i=0;i<9;i++) {
for(int j=0;j<9;j++) {
System.out.print(a[i][j]);
}
System.out.println();
}
} else {
if(a[x][y].equals("0")){
for(int i=1;i<=9;i++){
a[x][y]=""+i;
if(check(x,y)) {
if(y+1< 9) {
//不该换行
backtrace(x,y+1);
} else {
backtrace(x+1,0);//换行,x+1,y=0;
}
}
a[x][y]="0";
}
} else {
if(y+1< 9) {
backtrace(x,y+1);
} else {
backtrace(x+1,0);
}
}
}
}
static boolean check(int x,int y){
//列有重复
for(int i=0;i<9;i++) {
if(a[x][i].equals(a[x][y])&&i!=y) {
return false;
}
}
//行有重复
for(int i=0;i<9;i++) {
if(a[i][y].equals(a[x][y])&&i!=x) {
return false;
}
}
//九宫格有重复
int row=(x/3)*3;
int col=(y/3)*3;
for(int i=row;i<row+3;i++) {
for(int j=col;j<col+3;j++) {
if(a[i][j].equals(a[x][y])&&(i!=x||j!=y)) {
return false;
}
}
}
return true;
}
}
七、G将军★
G将军有一支训练有素的军队,这个军队除开G将军外,每名士兵都有一个直接上级(可能是其他士兵,也可能是G将军)。现在G将军将接受一个特别的任务,需要派遣一部分士兵(至少一个)组成一个敢死队,为了增加敢死队队员的独立性,要求如果一名士兵在敢死队中,他的直接上级不能在敢死队中。
请问,G将军有多少种派出敢死队的方法。注意,G将军也可以作为一个士兵进入敢死队。
输入格式
输入的第一行包含一个整数n,表示包括G将军在内的军队的人数。军队的士兵从1至n编号,G将军编号为1。
接下来n-1个数,分别表示编号为2, 3, …, n的士兵的直接上级编号,编号i的士兵的直接上级的编号小于i。
输出格式
输出一个整数,表示派出敢死队的方案数。由于数目可能很大,你只需要输出这个数除10007的余数即可。
样例输入1
3
1 1
样例输出1
4
样例说明
这四种方式分别是:
1. 选1;
2. 选2;
3. 选3;
4. 选2, 3。
样例输入2
7
1 1 2 2 3 3
样例输出2
40
数据规模与约定
对于20%的数据,n ≤ 20;
对于40%的数据,n ≤ 100;
对于100%的数据,1 ≤ n ≤ 100000。
资源约定:
峰值内存消耗(含虚拟机) < 256M
CPU消耗 < 2000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
注意:不要使用package语句。不要使用jdk1.7及以上版本的特性。
注意:主类的名字必须是:Main,否则按无效代码处理。
解析:树形DP,可以参考Anniversary party 这个题目
import java.util.ArrayList;
import java.util.Scanner;
public class Main {
static ArrayList<Integer>[] list;
static long[][] dp;
public static void main(String[] args) {
Scanner input = new Scanner(System.in);
int n = input.nextInt();
list = new ArrayList[n + 1];
for (int i = 1; i <= n; i++) {
list[i] = new ArrayList<Integer>();
}
for (int i = 2; i <= n; i++) {
int father = input.nextInt();
list[father].add(i);
}
dp = new long[n + 1][2];
dfs(1);
System.out.println((dp[1][0] + dp[1][1] - 1) % 10007);
}
private static void dfs(int u) {
/**
* 下面两个dp[][]分别表示 u去 和 u不去
* */
dp[u][0] = 1;
dp[u][1] = 1;
/**
* 当前节点下的子节点数目
* */
for (int i = 0; i < list[u].size(); i++) {
int v = list[u].get(i);
dfs(v);
dp[u][0] = dp[u][0] * (dp[v][0] + dp[v][1]) % 10007;
dp[u][1] = dp[u][1] * dp[v][0] % 10007;
}
}
}