> 文档中心 > 第四届蓝桥杯真题解析【JavaC组】

第四届蓝桥杯真题解析【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
不再需要括号,机器可以用递归的方法很方便地求解。
为了简便,我们假设:

  1. 只有 + - * 三种运算符;
  2. 每个运算数都是一个小于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]};    }

请分析代码逻辑,并推测划线处的代码,通过网页提交。
注意:仅把缺少的代码作为答案,千万不要填写多余的代码、符号或说明文字!!


分析过程:

  1. 在题目中,实际需要我们计算的只有v2的表达式,v无需考虑;
  2. 若要确定v2,我们要根据v的赋值表达式进行判断;
  3. 根据例子思考,第一步进行完后式子变为v=3-v2;
  4. 由于原式样式还未求出,所以v2也应该是一个表达式,所以推断出v2形式可能与v1类似v2 = evaluate(x.substring(?));
  5. ?处应添加相应index,又由于v1[1]表示处理过的字符数,若将index=v1[1]+1,则可以对下一个字符进行处理;
  6. 将代码代入尝试。

建议:如果不清楚什么是逆波兰表达式的话,最好去补充一下。


代码如下(示例):

//最终的答案为evaluate(x.substring(1 + v1[1]));

G:核桃的数量

问题描述


小张是软件项目经理,他带领3个开发组。工期紧,今天都在加班呢。为鼓舞士气,小张打算给每个组发一袋核桃(据传言能补脑)。他的要求是:

  1. 各组的核桃数量必须相同;
  2. 各组内必须能平分核桃(当然是不能打碎的);
  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; }    }}

总结

这一届的题目总的来说,其实难度还可以,主要是最后两题和逆波兰表达式,这些如果我们没有做过或者熟练的掌握,那么将很难完成它们。
最后,让我们努力学习吧!

唱吧电脑版