第四届蓝桥杯真题解析【JavaC组】
第四届蓝桥杯真题解析【JavaC组】
业精于勤,荒于嬉;行成于思,毁于随。——韩愈
文章目录
- ***第四届蓝桥杯真题解析【JavaC组】***
- 前言
- A:猜年龄
- B:组素数
- C:马虎的算式
- D:第39级台阶
- E:有理数类
- F:逆波兰表达式
- G:核桃的数量
- H:打印十字图
- I:买不到的数目
- J:剪格子
- 总结
前言
以下是我做第四届蓝桥杯真题时的一些收获和笔记,希望对你们有帮助。
提示:以下是本篇文章正文内容,下面案例可供参考
A:猜年龄
问题描述:
美国数学家维纳(N.Wiener)智力早熟,11岁就上了大学。他曾在1935~1936年应邀来中国清华大学讲学。
一次,他参加某个重要会议,年轻的脸孔引人注目。于是有人询问他的年龄,他回答说:
“我年龄的立方是个4位数。我年龄的4次方是个6位数。这10个数字正好包含了从0到9这10个数字,每个都恰好出现1次。”
请你推算一下,他当时到底有多年轻。
通过浏览器,直接提交他那时的年龄数字。
注意:不要提交解答过程,或其它的说明文字。
思路:
这道题的方法很简单,我们可以直接根据题目的要求写出代码。这个方法也就是模拟。
代码如下(示例):
package Past_Exam_4.C组;import org.junit.Test;import java.util.Arrays;ublic class Past1_猜年龄 { public static void guess_Age(){ for (int i = 1;i < 100;i++){ //判断i的立方是否是四位数 if(Math.pow(i, 3) < 1000 || Math.pow(i, 3) > 9999){ continue; } //判断i的四次方是否是六位数 if(Math.pow(i, 4) < 100000 || Math.pow(i, 4) > 999999){ continue; } String str = "" + (int)Math.pow(i, 3) + (int)Math.pow(i, 4); char[] tempCh = str.toCharArray(); Arrays.sort(tempCh); String temp = String.valueOf(tempCh); if (temp.equals("0123456789")) { System.out.println(i); } } } @Test public void test1(){ guess_Age(); } public static void main(String[] args) { guess_Age(); }}
B:组素数
问题描述:
素数就是不能再进行等分的数。比如:2 3 5 7 11 等。 9 = 3 * 3 说明它可以3等分,因而不是素数。
我们国家在1949年建国。如果只给你 1 9 4 9 这4个数字卡片,可以随意摆放它们的先后顺序
(但卡片不能倒着摆放啊,我们不是在脑筋急转弯!),那么,你能组成多少个4位的素数呢?
比如:1949,4919 都符合要求。
请你提交:能组成的4位素数的个数,不要罗列这些素数!!
注意:不要提交解答过程,或其它的辅助说明文字。
分析:
这首先,我们需要知道的是如何判断素数。所谓的素数其实就是除了1和本身的以外的都不能被整除的数,这个自然简单。
但重点是,我们该如何取出所有的组合(1,9,4,9),这其实可能会取到有重复出现的,这个是要考虑的。
思路:
我们先通过循环找出所有可能的组合,由于这里是通过for循环的方式来寻找的,所以就不会出现重复的。
当我们取出所有的组合后,再进行判断每个组合是否是素数,如果是,则累加1;不是,则下一个。最后,返回最终得到的数量。
代码如下(示例):
package Past_Exam_4.C组;import org.junit.Test;import java.util.Arrays;import java.util.HashSet;import java.util.Iterator;public class Past2_组素数 { public static int set_Of_Primes1(){ HashSet<String> set = new HashSet<>(); //统计数量 int count = 0; //因为题目给定了组合的数字,所以最小为1499,最大为9941 for (int i = 1499;i <= 9941;i++){ String tempStr = String.valueOf(i); char[] ch = tempStr.toCharArray(); Arrays.sort(ch); String str = String.valueOf(ch); //判断是否由1,4,9,9所组成的 if(str.equals("1499")){ set.add(tempStr); } } Iterator<String> iterator = set.iterator(); while (iterator.hasNext()){ String str = (String)iterator.next(); if(judge(Integer.valueOf(str))){ count++; } } return count; } public static boolean judge(int n){ //首先默认是素数 boolean isPrimes = true; for (int i = 2;i < n;i++){ if(n % i == 0){ isPrimes = false; break; } } return isPrimes; } @Test public void test1(){ System.out.println(set_Of_Primes1()); }}
C:马虎的算式
问题描述:
小明是个急性子,上小学的时候经常把老师写在黑板上的题目抄错了。
有一次,老师出的题目是:36 x 495 = ?
他却给抄成了:396 x 45 = ?
但结果却很戏剧性,他的答案竟然是对的!!
因为 36 * 495 = 396 * 45 = 17820
类似这样的巧合情况可能还有很多,比如:27 * 594 = 297 * 54
假设 a b c d e 代表1~9不同的5个数字(注意是各不相同的数字,且不含0)
能满足形如: ab * cde = adb * ce 这样的算式一共有多少种呢?
请你利用计算机的优势寻找所有的可能,并回答不同算式的种类数。
满足乘法交换律的算式计为不同的种类,所以答案肯定是个偶数。
答案直接通过浏览器提交。
注意:只提交一个表示最终统计种类数的数字,不要提交解答过程或其它多余的内容。
思路:
这道题是很简单的,我们可以直接使用暴力破解法来实现该题。
代码如下(示例):
package Past_Exam_4.C组;import org.junit.Test;public class Past3_马虎的算式 { public static void careless_Equation(){ //统计数量 int count = 0; for (int a = 1;a <= 9;a++){ for (int b = 1;b <= 9;b++){ for (int c = 1;c <= 9;c++){ for (int d = 1;d <= 9;d++){ for (int e = 1;e <= 9;e++){if(a != b && a != c && a != d && a != e &&b != c && b != d && b != e &&c != d && c != e &&d != e){ if((a * 10 + b) * (c * 100 + d * 10 + e) == (a * 100 + d * 10 + b) * (c * 10 + e)){ count++; }} } } } } } System.out.println(count); } @Test public void test1(){ careless_Equation(); }}
D:第39级台阶
问题描述:
小明刚刚看完电影《第39级台阶》,离开电影院的时候,他数了数礼堂前的台阶数,恰好是39级! 站在台阶前,他突然又想着一个问题:
如果我每一步只能迈上1个或2个台阶。
先迈左脚,然后左右交替,最后一步是迈右脚,也就是说一共要走偶数步。那么,上完39级台阶,有多少种不同的上法呢?
请你利用计算机的优势,帮助小明寻找答案。
要求提交的是一个整数。
注意:不要提交解答过程,或其它的辅助说明文字。
思路:
一道不算太难的题目。所使用的方法为递归。
首先,这道题和《走楼梯》是相似的,那么思路也是一样的。
我们所需要的考虑的是两个部分:奇数部分和偶数部分。
也就是说,整体阶梯将有奇数和偶数两种情况,对此要分开。
对于这两个部分,我们将其分开递归
代码如下(示例):
package Past_Exam_4.C组;import org.junit.Test;public class Past4_第39级台阶 { /** * 求奇数阶的 * @param n * @return */ public int ji(int n){ if(n == 1) return 1; if(n == 2) return 1; return ou(n - 1) + ou(n - 2); } /** * 求偶数阶的 * @param n * @return */ public int ou(int n){ if(n == 1) return 0; if(n == 2) return 1; return ji(n - 1) + ji(n - 2); } @Test public void test1(){ System.out.println(ou(39)); }}
E:有理数类
问题描述:
有理数就是可以表示为两个整数的比值的数字。一般情况下,我们用近似的小数表示。 但有些时候,不允许出现误差,必须用两个整数来表示一个有理数。 这时,我们可以建立一个“有理数类”,下面的代码初步实现了这个目标。为了简明,它只提供了加法和乘法运算。
class Rational { private long ra; private long rb; private long gcd(long a, long b){ if(b==0) return a; return gcd(b,a%b); } public Rational(long a, long b){ ra = a; rb = b; long k = gcd(ra,rb); if(k>1){ //需要约分 ra /= k; rb /= k; } } // 加法 public Rational add(Rational x){ return ______________________________________;//填写位置 } // 乘法 public Rational mul(Rational x){ return new Rational(ra*x.ra, rb*x.rb); } public String toString(){ if(rb==1) return "" + ra; return ra + "/" + rb; } }
使用该类的示例:
Rational a = new Rational(1,3);Rational b = new Rational(1,6);Rational c = a.add(b);System.out.println(a + "+" + b + "=" + c);
请分析代码逻辑,并推测划线处的代码,通过网页提交
注意:仅把缺少的代码作为答案,千万不要填写多余的代码、符号或说明文字!!
思路:
这道题只需要根据题目所给出的示例进行推算,就可以一步步推出最终的结果。
代码如下(示例):
//最终的答案为new Rational(ra * x.rb + rb * x.ra, rb * x.rb);
F:逆波兰表达式
问题描述:
正常的表达式称为中缀表达式,运算符在中间,主要是给人阅读的,机器求解并不方便。
例如:3 + 5 * (2 + 6) - 1而且,常常需要用括号来改变运算次序。
相反,如果使用逆波兰表达式(前缀表达式)表示,上面的算式则表示为:- + 3 * 5 + 2 6 1
不再需要括号,机器可以用递归的方法很方便地求解。
为了简便,我们假设:
- 只有 + - * 三种运算符;
- 每个运算数都是一个小于10的非负整数;
下面的程序对一个逆波兰表示串进行求值。
其返回值为一个数组:其中第一元素表示求值结果,第二个元素表示它已解析的字符数。
static int[] evaluate(String x) { if(x.length()==0) return new int[] {0,0}; char c = x.charAt(0); if(c>='0' && c<='9') return new int[] {c-'0',1}; int[] v1 = evaluate(x.substring(1)); int[] v2 = __________________________________________; //填空位置 int v = Integer.MAX_VALUE; if(c=='+') v = v1[0] + v2[0]; if(c=='*') v = v1[0] * v2[0]; if(c=='-') v = v1[0] - v2[0]; return new int[] {v,1+v1[1]+v2[1]}; }
请分析代码逻辑,并推测划线处的代码,通过网页提交。
注意:仅把缺少的代码作为答案,千万不要填写多余的代码、符号或说明文字!!
分析过程:
- 在题目中,实际需要我们计算的只有v2的表达式,v无需考虑;
- 若要确定v2,我们要根据v的赋值表达式进行判断;
- 根据例子思考,第一步进行完后式子变为v=3-v2;
- 由于原式样式还未求出,所以v2也应该是一个表达式,所以推断出v2形式可能与v1类似v2 = evaluate(x.substring(?));
- ?处应添加相应index,又由于v1[1]表示处理过的字符数,若将index=v1[1]+1,则可以对下一个字符进行处理;
- 将代码代入尝试。
建议:如果不清楚什么是逆波兰表达式的话,最好去补充一下。
代码如下(示例):
//最终的答案为evaluate(x.substring(1 + v1[1]));
G:核桃的数量
问题描述:
小张是软件项目经理,他带领3个开发组。工期紧,今天都在加班呢。为鼓舞士气,小张打算给每个组发一袋核桃(据传言能补脑)。他的要求是:
- 各组的核桃数量必须相同;
- 各组内必须能平分核桃(当然是不能打碎的);
- 尽量提供满足1,2条件的最小数量(节约闹革命嘛)。
程序从标准输入读入:
a b c
a,b,c都是正整数,表示每个组正在加班的人数,用空格分开(a,b,c<30)
程序输出:
一个正整数,表示每袋核桃的数量。
例如:
用户输入:
2 4 5
程序输出:
20
再例如:
用户输入:
3 1 1
程序输出:
3
资源约定:
峰值内存消耗(含虚拟机) < 64M
CPU消耗 < 1000ms
请严格按要求输出,不要画蛇添足地打印类似:“请您输入…” 的多余内容。
所有代码放在同一个源文件中,调试通过后,拷贝提交该源码。
思路:
根据题目可得,这道题其实就是一道由求三个数的最小公倍数转变的。那么,我们只需要求这
三个数的最小公倍数即可。
代码如下(示例):
package Past_Exam_4.C组;import java.util.Scanner;public class Past7_核桃的数量 { public static int walnutSum(int a, int b, int c){ int count = 0; for (int i = 1;;i++){ if(i % a == 0 && i % b == 0 && i % c == 0){ count = i; break; } } return count; } public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int a = scanner.nextInt(); int b = scanner.nextInt(); int c = scanner.nextInt(); scanner.close(); System.out.println(walnutSum(a, b, c)); }}
H:打印十字图
问题描述:
小明为某机构设计了一个十字型的徽标(并非红十字会啊),如下所示(可参见p1.jpg)
$$$$$$$$$$$$$ $ $$$$ $$$$$$$$$ $$$$ $$ $$ $$$ $$$$$ $$$ $$ $ $ $ $ $$ $ $$$ $ $$$ $ $$ $ $ $ $ $ $$ $ $ $$$$$ $ $ $$ $ $ $ $ $ $$ $ $$$ $ $$$ $ $$ $ $ $ $ $$ $$$ $$$$$ $$$ $$ $$ $$$$ $$$$$$$$$ $$$ $ $ $$$$$$$$$$$$$
对方同时也需要在电脑dos窗口中以字符的形式输出该标志,并能任意控制层数。
为了能准确比对空白的数量,程序要求对行中的空白以句点(.)代替。
输入格式:
一个正整数 n (n<30) 表示要求打印图形的层数
输出:
对应包围层数的该标志。
例如:
用户输入:
1
程序应该输出:
..$$$$$....$...$..$$$.$.$$$$...$...$$.$$$$$.$$...$...$$$$.$.$$$..$...$....$$$$$..
再例如:
用户输入:
3
程序应该输出:
..$$$$$$$$$$$$$....$...........$..$$$.$$$$$$$$$.$$$$...$.......$...$$.$$$.$$$$$.$$$.$$.$...$...$...$.$$.$.$$$.$.$$$.$.$$.$.$...$...$.$.$$.$.$.$$$$$.$.$.$$.$.$...$...$.$.$$.$.$$$.$.$$$.$.$$.$...$...$...$.$$.$$$.$$$$$.$$$.$$...$.......$...$$$$.$$$$$$$$$.$$$..$...........$....$$$$$$$$$$$$$..
请仔细观察样例,尤其要注意句点的数量和输出位置。
资源约定:
峰值内存消耗(含虚拟机) < 64M
CPU消耗 < 1000ms
思路:
这道题是有一定难度的,但是我们通过对题目中给出的示例,可以推出这个图的规律。
总的来说,这道题考的就是分析能力和细心能力。
代码如下(示例):
package Past_Exam_4.C组;import java.util.Scanner;public class Past8_打印十字图 { public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int n = scanner.nextInt(); scanner.close(); //通过分析得:每层周期的变化为5 + 4 * n int len = 5 + 4 * n; //取中心点 int mid = len / 2; char[][] result = new char[len][len]; for (int i = 0;i < len;i++){ for (int j = 0;j < len;j++){ result[i][j] = '.'; } } //打印中心的十字 for (int i = mid - 2;i <= mid + 2;i++){ result[mid][i] = '&'; result[i][mid] = '&'; } //现在从中心开始向外打印 for (int i = 1;i <= n;i++){ //控制打印几层 for (int j = mid - 2 * i;j <= mid + 2 * i;j++){ result[mid - 2 * (i + 1)][j] = '&'; //上横 result[mid + 2 * (i + 1)][j] = '&'; //下横 result[j][mid - 2 * (i + 1)] = '&'; //左侧 result[j][mid + 2 * (i + 1)] = '&'; //右侧 } //还差四个角 //左上角 result[mid - 2 * i][mid - 2 * i - 1] = '&'; result[mid - 2 * i][mid - 2 * i] = '&'; result[mid - 2 * i - 1][mid - 2 * i] = '&'; //右上角 result[mid - 2 * i][mid + 2 * i] = '&'; result[mid - 2 * i][mid + 2 * i + 1] = '&'; result[mid - 2 * i - 1][mid + 2 * i] = '&'; //左下角 result[mid + 2 * i][mid - 2 * i] = '&'; result[mid + 2 * i + 1][mid - 2 * i] = '&'; result[mid + 2 * i][mid - 2 * i - 1] = '&'; //右下角 result[mid + 2 * i][mid + 2 * i] = '&'; result[mid + 2 * i][mid + 2 * i + 1] = '&'; result[mid + 2 * i + 1][mid + 2 * i] = '&'; } for (int i = 0;i < len;i++){ for (int j = 0;j < len;j++){ System.out.print(result[i][j]); } System.out.println(); } }}
I:买不到的数目
问题描述:
小明开了一家糖果店。他别出心裁:把水果糖包成4颗一包和7颗一包的两种。糖果不能拆包卖。 小朋友来买糖的时候,他就用这两种包装来组合。当然有些糖果数目是无法组合出来的,比如要买 10 颗糖。 你可以用计算机测试一下,在这种包装情况下,最大不能买到的数量是17。大于17的任何数字都可以用4和7组合出来。 本题的要求就是在已知两个包装的数量时,求最大不能组合出的数字。
输入:
两个正整数,表示每种包装中糖的颗数(都不多于1000)
要求输出:
一个正整数,表示最大不能买到的糖数
不需要考虑无解的情况
例如:
用户输入:
4 7
程序应该输出:
17
再例如:
用户输入:
3 5
程序应该输出:
7
资源约定:
峰值内存消耗(含虚拟机) < 64M
CPU消耗 < 3000ms
思路:
这道题其实我也是半懂的状态
补充知识点:(什么是互质?)
解释:互质是公约数只有1的两个整数,叫做互质整数。公约数只有1的两个自然数,叫做互质自然数,后者是前者的特殊情形。
定义:
互质,若N个整数的最大公因数是1,则称这N个整数互质。例如,8和10的最大公约数是2,不是1,因此它们不是整数互质;
而7、11和13的最大公约数是1,因此这是整数互质。5和5不互质,因为5和5的公因数有1、5。
1和任何数都成倍数关系,但和任何数都互质。因为1的因数只有1,而互质数的原则是:只要两数的公因数只有1时,就说两数是互质数。
因为1只有一个因数所以1既不是质数(素数),也不是合数,无法再找到1和其他数的别的公因数了。1和-1与所有整数互素,而且它们是唯一与0互素的整数。
注意:这里有一个误区,认为0不与任何数互质。严格地按照互质的定义来看0与1,-1均互质,通过任意有理数的表示方式a/b(a,b互质且b为正整数),
同样可以得出0与1,-1均必须互质,否则0不是有理数。
代码如下(示例):
方法一:数学(这个方法不会,毕竟还久没学数学了)
public int cannot_Buy1(int a, int b){return a * b - a - b;}
方法二:暴力破解法
package Past_Exam_4.C组;import java.util.HashSet;import java.util.Set;public class Past9_买不到的数目 { /** * 方法二:暴力破解法 * 思路与算法: * 当x,y可以小于0时,那么买不到的数目是不存在的,所以无需考虑。 * 当x,y大于等于0时,存在一个最大的买不到的数目,且一旦超过这个最大的买不到的数目,后面的数均可以买到。 * 那么,我们就枚举所有的组合存储到集合中。然后,当c = ab时ab为最小公倍数时,c是一定有解,我们逆序枚举, * 只要是集合中第一次没有出现过的数,那就是最大的买不到的数目。 * @param a * @param b */ public void cannot_Buy2(int a, int b){ Set<Integer> set = new HashSet<>(); for (int x = 0;a * x <= a * b;x++){ for (int y = 0;a * x + b * y <= a * b;y++){ set.add(a * x + b * y); } } for (int i = a * b;i > 0;i--){ if(!set.contains(i)){ System.out.println(i); break; } } }
J:剪格子
问题描述:
如图p1.jpg所示,3 x 3 的格子中填写了一些整数。
我们沿着图中的红色线剪开,得到两个部分,每个部分的数字和都是60。
本题的要求就是请你编程判定:对给定的m x n 的格子中的整数,是否可以分割为两个部分,使得这两个区域的数字和相等。
如果存在多种解答,请输出包含左上角格子的那个区域包含的格子的最小数目。
如果无法分割,则输出 0
程序输入输出格式要求:
程序先读入两个整数 m n 用空格分割 (m,n<10)
表示表格的宽度和高度
接下来是n行,每行m个正整数,用空格分开。每个整数不大于10000
程序输出:在所有解中,包含左上角的分割区可能包含的最小的格子数目。
例如:
用户输入:
3 3
10 1 52
20 30 1
1 2 3
则程序输出:
3
再例如:
用户输入:
4 3
1 1 1 1
1 30 80 2
1 1 1 100
则程序输出:
10
(参见p2.jpg)
资源约定:
峰值内存消耗(含虚拟机) < 64M
CPU消耗 < 5000ms
思路:
这道题挺难的,我也是借鉴他人的,才完成的。
代码如下(示例):
package Past_Exam_4.C组;import java.util.Scanner;public class Past10_剪格子_暂未完全搞懂 { static int n, m; static int[][] arr; static int[] array; static boolean[][] flag; static boolean[][] visit; static int total = 0; static int result = 0; static int finalResult = Integer.MAX_VALUE; static int index = 0; /** * 以下是借鉴他人的! * 方法:DP + DFS * 思路与算法: * 一、输入m行n列,存入二维数组arr[n][m]即一位数组array[m*n]; * 二、总价为奇数时,输出0;总价为偶数时,到步骤三; * 三、用动态规划得到总和为count/2的最优解,每次得到最优解时进行步骤四的验证; * 四、将步骤三得到的最优解记录到一个flag[m][n]中,对标记在flag中的格子进行深度遍历。若连通说明符号条件,然后对未被 * 标记在flag中的格子也进行深度遍历。若连通说明格子确实被分成了两部分而不是更多的部分,这样就成功验证了。 * 五、输出步骤三中验证成功并且最终最优的那个解的格子数。 * 注意:这道题难点在于剪开的必须是“两部分”,如果其中一部分是连通的,但可能把另一部分截断,如: * 4 4 * 20 30 40 1 * 110 1 10 1 * 1 2 10 1 * 1 1 10 1 * 这种情况是不符合的,而且很难验证。本程序反过来先算值为total/2的两部分,然后分别计算连通,这种思路比较清晰。 * @param args */ public static void main(String[] args) { Scanner scanner = new Scanner(System.in); Scanner sc = new Scanner(scanner.nextLine()).useDelimiter("\\s*"); //列 m = sc.nextInt(); //行 n = sc.nextInt(); arr = new int[n][m]; array = new int[n*m]; flag = new boolean[n][m]; for (int i = 0;i < n;i++){ sc = new Scanner(scanner.nextLine()); for (int j = 0;j < m;j++){ arr[i][j] = sc.nextInt(); array[index++] = arr[i][j]; total += arr[i][j]; } } if(total % 2 != 0 || array[0] > total / 2){ //奇数不可分割 System.out.println(0); }else { flag[0][0] = true; result++; dp(total / 2 - array[0], 1); if(finalResult == Integer.MAX_VALUE) finalResult = 0; System.out.println(finalResult); } } //动态规划,找到和等于total / 2的情况并验证,取最优解 public static void dp(int count, int start){ if(count==0){//和为total/2的情况 if(confirm() && finalResult > result){ finalResult=result;//验证并取最优解 return; } } for (int i = start;i < index;i++){ if(count >= array[i]){ count -= array[i]; //访问过,标记 flag[i / m][i % m] = true; result++; //..i+1 dp(count, i + 1); //退栈时注意还原 count += array[i]; flag[i / m][i % m] = false; result--; } } } //验证是否是连通图 public static boolean confirm(){ //..打印这种情况 for (int i = 0;i < n;i++){ for (int j = 0;j < m;j++){ System.out.print(flag[i][j] + " "); } System.out.println(); } System.out.println(); int row = 0, col = 0; visit = new boolean[n][m]; //找到一个属性“另一部分”的方格 for (int i = 1;i < index;i++){ if(flag[i / m][i % m] == false){ row = i / m; col = i % m; break; } } //两部分都为连通图,则满足题意 if(dfs(0, 0, 1) == result && dfs(row, col, 0) == index - result){ return true; }else { return false; } } public static int dfs(int row, int col, int f){ int num1 = 0; int num2 = 0; int num3 = 0; int num4 = 0; //包含左上角方块的部分 if(f == 1 && flag[row][col] == true){ visit[row][col] = true; if(row + 1 < n && !visit[row + 1][col]) num1 = dfs(row + 1, col, 1); if(col + 1 < m && !visit[row][col + 1]) num2 = dfs(row, col + 1, 1); return num1 + num2 + 1; }else if (f == 0 && flag[row][col] == false){ //另外一部分 visit[row][col] = true; if(row + 1 < n && !visit[row + 1][col]) num1 = dfs(row + 1, col, 0); if(col + 1 < m && !visit[row][col + 1]) num2 = dfs(row, col + 1, 0); if(row - 1 >= 0 && !visit[row - 1][col]) num3 = dfs(row - 1, col, 0); if(col - 1 >= 0 && !visit[row][col - 1]) num4 = dfs(row, col - 1, 0); return num1 + num2 + num3 + num4 + 1; }else { return 0; } }}
总结
这一届的题目总的来说,其实难度还可以,主要是最后两题和逆波兰表达式,这些如果我们没有做过或者熟练的掌握,那么将很难完成它们。
最后,让我们努力学习吧!