第四届蓝桥杯真题解析【JavaC组】
业精于勤，荒于嬉；行成于思，毁于随。——韩愈
前言
以下是我做第四届蓝桥杯真题时的一些收获和笔记，希望对你们有帮助。
提示：以下是本篇文章正文内容，下面案例可供参考
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;
}
}
}
总结
这一届的题目总的来说，其实难度还可以，主要是最后两题和逆波兰表达式，这些如果我们没有做过或者熟练的掌握，那么将很难完成它们。
最后，让我们努力学习吧！
扫一扫
1万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
