第十四届蓝桥杯模拟赛(第三期)(大学B组)Java组

修改了第六题余数为0时输出应为7的问题
修改了第五题和第九题可能超时的问题

文章目录

  • 前言
  • 一、求最小数
    • 思路:
    • 答案:
    • ` 2730`
    • 代码如下:
  • 二、Excel
    • 思路一:
    • 思路二:
    • 代码如下:
    • 答案:
    • `BYT`
  • 三、日期问题
    • 思路:
    • 代码如下:
    • 答案:
    • ` 70910`
  • 四、取数
    • 思路:
    • 代码如下:
    • 答案:
    • `189`
  • 五、求最小数
    • 思路:
    • 代码如下:
    • 答案:
    • `148`
  • 六 、一周中的哪天
    • 思路:
    • 代码如下:
  • 七 、信号塔问题
    • 思路:
    • 代码如下:
  • 八 、水域清理问题
    • 思路:
    • 代码如下:
  • 九 、滑行问题
    • 思路:
    • 原代码:
    • 改进后代码如下:


前言

前些天参加了第十四届蓝桥杯模拟赛(第三期),收获颇丰,自己也走了一点点弯路,记录一下自己考试中犯的一些错误。也希望在这期间可以提高一下自己的编程水平。

纯小白大佬请喷!

一、求最小数

问题描述
  请找到一个大于 2022 的最小数,这个数转换成十六进制之后,所有的数位(不含前导 0)都为字母(A 到 F)。
  请将这个数的十进制形式作为答案提交。
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

思路:

首先使用Integer.toString(i,16),直接转化为16进制,然后再使用String.contains(),找到不包含0-9的就输出。

答案:

2730

代码如下:

package com.company.test1;

public class Main1 {
    public static void main(String[] args) {
        //问题描述
        //  请找到一个大于 2022 的最小数,这个数转换成十六进制之后,所有的数位(不含前导 0)都为字母(A 到 F)。
        //  请将这个数的十进制形式作为答案提交。from djj
        for (int i = 2023; i < 2000000000; i++) {
            if (!count(i).contains("1")&&
                    !count(i).contains("2")&&
                    !count(i).contains("3")&&
                    !count(i).contains("4")&&
                    !count(i).contains("5")&&
                    !count(i).contains("6")&&
                    !count(i).contains("7")&&
                    !count(i).contains("8")&&
                    !count(i).contains("9")&&
                    !count(i).contains("0")
            ){
                System.out.println(count(i));
                System.out.println(i);
                break;
            }
        }
    }
    public static String count(int i){
        String str=Integer.toString(i,16);
        return str;
    }
}

二、Excel

问题描述
  问题描述
  在 Excel 中,列的名称使用英文字母的组合。前 26 列用一个字母,依次为 A 到 Z,接下来 26*26 列使用两个字母的组合,依次为 AA 到 ZZ。
  请问第 2022 列的名称是什么?
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个由大写字母组成的字符串,在提交答案时只填写这个字符串,填写多余的内容将无法得分。

思路一:

打开Excel

第十四届蓝桥杯模拟赛(第三期)(大学B组)Java组_第1张图片

随便新建一个表格,把第一个填1,第二个填2,然后一直往后拖,拖到2022你会发现:
在这里插入图片描述
在这里插入图片描述

思路二:

使用String[] b来“装”所有的名称,通过int 转char再转String来拼接名称

(可以直接排除一个字母和两个字母的可能性,代码会简洁一点,考试时没有考虑到hhh)

代码如下:

package com.company.test1;

public class Main2 {
    public static void main(String[] args) {
        //问题描述
        //  在 Excel 中,列的名称使用英文字母的组合。前 26 列用一个字母,依次为 A 到 Z,接下来 26*26 列使用两个字母的组合,依次为 AA 到 ZZ。
        //  请问第 2022 列的名称是什么?
        int a =2022;
        String[] b=new String[a];
        char[] c = new char[a];
        for (int j = 0; j < 26; j++) {
            int num1=j;//第一组数的下标
            c[num1]=(char)(j+65);//ASCII码中A为65
            b[num1]=String.valueOf(c[j]);
        }
        for (int j = 0; j < 26; j++) {
            for (int i = 0; i < 26; i++) {
                int num2=i*26+j+26;//第二组数的下标
                b[num2]=String.valueOf((char) (i+65))+String.valueOf((char) (j+65));
            }
        }
        for (int i = 0; i < 26; i++) {
            for (int j = 0; j < 26; j++) {
                for (int k = 0; k < 26; k++) {
                    int num3=i*26*26+j*26+k+26*26+26;//第三组数的下标
                    if (num3<a){
                        String str=String.valueOf((char) (i+65))+String.valueOf((char) (j+65))+String.valueOf((char)(k+65));
                        b[num3]=str;
                    }
                }
            }
        }
        System.out.println(b[a-1]);//第一列为b[0];
    }
}

答案:

BYT

三、日期问题

问题描述
  对于一个日期,我们可以计算出年份的各个数位上的数字之和,也可以分别计算月和日的各位数字之和。请问从 1900 年 1 月 1 日至 9999 年 12 月 31 日,总共有多少天,年份的数位数字之和等于月的数位数字之和加日的数位数字之和。
  例如,2022年11月13日满足要求,因为 2+0+2+2=(1+1)+(1+3) 。
  请提交满足条件的日期的总数量。
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

思路:

枚举每年的日期,通过%和/得到每个位置的数字,再相加,月和日也同理。
要注意闰年的概念:

1582年以来公历的置闰规则:
普通闰年:公历年份是4的倍数,且不是100的倍数的,为闰年(如2004年、2020年等就是闰年)。
世纪闰年:公历年份是整百数的,必须是400的倍数才是闰年(如1900年不是闰年,2000年是闰年)!!!

(我之前也单纯的以为4的倍数就是闰年 ╥﹏╥ )

代码如下:

package com.company.test1;

public class Main3 {
    //  对于一个日期,我们可以计算出年份的各个数位上的数字之和,也可以分别计算月和日的各位数字之和。请问从 1900 年 1 月 1 日至 9999 年 12 月 31 日,总共有多少天,年份的数位数字之和等于月的数位数字之和加日的数位数字之和。
    //  例如,2022年11月13日满足要求,因为 2+0+2+2=(1+1)+(1+3) 。
    //  请提交满足条件的日期的总数量。from djj
    public static void main(String[] args) {
        int count=0;
        for (int l = 1900;  l<10000; l++) {
            int year=l;
            int y1 = year/1000;// 千位
            int y2 = year%1000/100;// 百位
            int y3 = year%1000%100/10;// 十位
            int y4 = year%1000%100%10;// 个位
            int b = y1 + y2 + y3 + y4;
            for (int j = 1; j <13 ; j++) {
                if (j==1||j==3||j==5||j==7||j==8||j==10||j==12){
                    for (int k = 1; k <32; k++) {
                        if (k%10+k/10+j%10+j/10==b){
                            count++;
                        }
                    }
                }
                if (j==4||j==6||j==9||j==11){
                    for (int k = 1; k <31; k++) {
                        int x=j%10+j/10;
                        int y=k%10+k/10;
                        if (x+y==b)
                            count++;
                    }
                }
                if (j==2){
                    if (year%4==0&&year%100!=0||year%400==0){
                        for (int k = 1; k <30; k++) {
                            int x=j%10+j/10;
                            int y=k%10+k/10;
                            if (x+y==b)
                                count++;
                        }
                    }else{
                        for (int k = 1; k <29; k++) {
                            int x=j%10+j/10;
                            int y=k%10+k/10;
                            if (x+y==b)
                                count++;
                        }
                    }
                }
            }
        }
        System.out.println(count);
    }
}

答案:

70910

四、取数

问题描述
  小蓝有 30 个数,分别为:99, 22, 51, 63, 72, 61, 20, 88, 40, 21, 63, 30, 11, 18, 99, 12, 93, 16, 7, 53, 64, 9, 28, 84, 34, 96, 52, 82, 51, 77 。
  小蓝可以在这些数中取出两个序号不同的数,共有 30*29/2=435 种取法。
  请问这 435 种取法中,有多少种取法取出的两个数的乘积大于等于 2022 。
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

思路:

首先把这三十个数存到int数组里,再得出满足条件的取法。
注意共有30*29/2=435种取法,故最后结果需要除以二。

代码如下:

package com.company.test1;

public class Main4 {
    //99, 22, 51, 63, 72, 61, 20, 88, 40, 21, 63, 30, 11, 18, 99, 12, 93, 16, 7, 53, 64, 9, 28, 84, 34, 96, 52, 82, 51, 77
    public static void main(String[] args) {
        String str="99, 22, 51, 63, 72, 61, 20, 88, 40, 21, 63, 30, 11, 18, 99, 12, 93, 16, 7, 53, 64, 9, 28, 84, 34, 96, 52, 82, 51, 77";
        String[] strings=str.split(", ");
        int[] ints=new int[strings.length];
        for (int i = 0; i < strings.length; i++) {
            ints[i]=Integer.parseInt(strings[i]);
        }
        int count=0;
        int num=0;
        for (int i = 0; i < 30; i++) {
            for (int j = 0; j < 30; j++) {
                if (i!=j){
                    num++;
                    if (ints[i]*ints[j]>2022){
                        count++;
                    }
                }

            }
        }
        System.out.println(count/2);
    }
}

答案:

189

五、求最小数

问题描述
  小蓝有一个 30 行 60 列的数字矩阵,矩阵中的每个数都是 0 或 1 。
  110010000011111110101001001001101010111011011011101001111110
  010000000001010001101100000010010110001111100010101100011110
  001011101000100011111111111010000010010101010111001000010100
  101100001101011101101011011001000110111111010000000110110000
  010101100100010000111000100111100110001110111101010011001011
  010011011010011110111101111001001001010111110001101000100011
  101001011000110100001101011000000110110110100100110111101011
  101111000000101000111001100010110000100110001001000101011001
  001110111010001011110000001111100001010101001110011010101110
  001010101000110001011111001010111111100110000011011111101010
  011111100011001110100101001011110011000101011000100111001011
  011010001101011110011011111010111110010100101000110111010110
  001110000111100100101110001011101010001100010111110111011011
  111100001000001100010110101100111001001111100100110000001101
  001110010000000111011110000011000010101000111000000110101101
  100100011101011111001101001010011111110010111101000010000111
  110010100110101100001101111101010011000110101100000110001010
  110101101100001110000100010001001010100010110100100001000011
  100100000100001101010101001101000101101000000101111110001010
  101101011010101000111110110000110100000010011111111100110010
  101111000100000100011000010001011111001010010001010110001010
  001010001110101010000100010011101001010101101101010111100101
  001111110000101100010111111100000100101010000001011101100001
  101011110010000010010110000100001010011111100011011000110010
  011110010100011101100101111101000001011100001011010001110011
  000101000101000010010010110111000010101111001101100110011100
  100011100110011111000110011001111100001110110111001001000111
  111011000110001000110111011001011110010010010110101000011111
  011110011110110110011011001011010000100100101010110000010011
  010011110011100101010101111010001001001111101111101110011101
  如果从一个标为 1 的位置可以通过上下左右走到另一个标为 1 的位置,则称两个位置连通。与某一个标为 1 的位置连通的所有位置(包括自己)组成一个连通分块。
  请问矩阵中最大的连通分块有多大?
答案提交
  这是一道结果填空的题,你只需要算出结果后提交即可。本题的结果为一个整数,在提交答案时只填写这个整数,填写多余的内容将无法得分。

思路:

这里用的dfs(深度优先算法)也可以使用bfs概念就不赘述了 可以自行百度,或者查看博客

代码如下:

public class Main {
    public static int[][] ints={{1,0},{-1,0},{0,1},{0,-1}};
    public static int num=0;
    static boolean[][] booleans;
    static char[][] maze;
    public static void main(String[] args) {
        //如果从一个标为 1 的位置可以通过上下左右走到另一个标为 1 的位置,则称两个位置连通。与某一个标为 1 的位置连通的所有位置(包括自己)组成一个连通分块。
        //  请问矩阵中最大的连通分块有多大? FROMDJJ
        String string="110010000011111110101001001001101010111011011011101001111110" +
                ",010000000001010001101100000010010110001111100010101100011110" +
                ",001011101000100011111111111010000010010101010111001000010100" +
                ",101100001101011101101011011001000110111111010000000110110000" +
                ",010101100100010000111000100111100110001110111101010011001011" +
                ",010011011010011110111101111001001001010111110001101000100011" +
                ",101001011000110100001101011000000110110110100100110111101011" +
                ",101111000000101000111001100010110000100110001001000101011001" +
                ",001110111010001011110000001111100001010101001110011010101110" +
                ",001010101000110001011111001010111111100110000011011111101010" +
                ",011111100011001110100101001011110011000101011000100111001011" +
                ",011010001101011110011011111010111110010100101000110111010110" +
                ",001110000111100100101110001011101010001100010111110111011011" +
                ",111100001000001100010110101100111001001111100100110000001101" +
                ",001110010000000111011110000011000010101000111000000110101101" +
                ",100100011101011111001101001010011111110010111101000010000111" +
                ",110010100110101100001101111101010011000110101100000110001010" +
                ",110101101100001110000100010001001010100010110100100001000011" +
                ",100100000100001101010101001101000101101000000101111110001010" +
                ",101101011010101000111110110000110100000010011111111100110010" +
                ",101111000100000100011000010001011111001010010001010110001010" +
                ",001010001110101010000100010011101001010101101101010111100101" +
                ",001111110000101100010111111100000100101010000001011101100001" +
                ",101011110010000010010110000100001010011111100011011000110010" +
                ",011110010100011101100101111101000001011100001011010001110011" +
                ",000101000101000010010010110111000010101111001101100110011100" +
                ",100011100110011111000110011001111100001110110111001001000111" +
                ",111011000110001000110111011001011110010010010110101000011111" +
                ",011110011110110110011011001011010000100100101010110000010011" +
                ",010011110011100101010101111010001001001111101111101110011101";

        maze=new char[30][60];
        booleans=new boolean[30][60];
        for (int i = 0; i < 30; i++) {
            String[] strings = string.split(",");
            for (int j = 0; j < 60; j++) {
                maze[i]=strings[i].toCharArray();
            }
        }
        int count=0;
        for (int i = 0; i < 30; i++) {
            for (int j = 0; j < 60; j++) {
                if (maze[i][j]=='1' && booleans[i][j]==false){
                    num=1;
                    dfs(i,j);
                    booleans=new boolean[30][60];
                    if (num>count)
                        count=num;
                }
            }
        }
        System.out.println(count);
    }
    public static void dfs(int i,int j){
        booleans[i][j]=true;
        for (int k = 0; k < 4; k++) {
            int newI=i+ints[k][0];
            int newJ=j+ints[k][1];
            if (newI >= 0 && newI < 30 && newJ >= 0 && newJ <60 &&maze[newI][newJ]=='1' && booleans[newI][newJ] == false){
                num++;
                dfs(newI,newJ);
            }
        }
    }
}

答案:

148

六 、一周中的哪天

问题描述
  问题描述
  给定一天是一周中的哪天,请问 n 天后是一周中的哪天?
输入格式
  输入第一行包含一个整数 w,表示给定的天是一周中的哪天,w 为 1 到 6 分别表示周一到周六,w 为 7 表示周日。
  第二行包含一个整数 n。
输出格式
  输出一行包含一个整数,表示 n 天后是一周中的哪天,1 到 6 分别表示周一到周六,7 表示周日。
样例输入
6
10
样例输出
2
评测用例规模与约定
  对于所有评测用例,1 <= n <= 1000000。

思路:

该题较简单直接循环即可。

代码如下:

package com.company.test1;

import java.util.Scanner;

public class Main6 {
    public static void main(String[] args) {
        //问题描述
        //  给定一天是一周中的哪天,请问 n 天后是一周中的哪天?
        //输入格式
        //  输入第一行包含一个整数 w,表示给定的天是一周中的哪天,w 为 1 到 6 分别表示周一到周六,w 为 7 表示周日。
        //  第二行包含一个整数 n。
        //输出格式
        //  输出一行包含一个整数,表示 n 天后是一周中的哪天,1 到 6 分别表示周一到周六,7 表示周日。
        //样例输入
        //6
        //10
        //样例输出
        //2
        Scanner scanner =new Scanner(System.in);
        int w=scanner.nextInt();
        int n=scanner.nextInt();
        int b=w+n%7;
        int a=b%7;
        System.out.println(a==0?7:a);
    }
}

七 、信号塔问题

问题描述
  小蓝负责一块区域的信号塔安装,整块区域是一个长方形区域,建立坐标轴后,西南角坐标为 (0, 0), 东南角坐标为 (W, 0), 西北角坐标为 (0, H), 东北角坐标为 (W, H)。其中 W, H 都是整数。
  他在 n 个位置设置了信号塔,每个信号塔可以覆盖以自己为圆心,半径为 R 的圆形(包括边缘)。
  为了对信号覆盖的情况进行检查,小蓝打算在区域内的所有横纵坐标为整数的点进行测试,检查信号状态。其中横坐标范围为 0 到 W,纵坐标范围为 0 到 H,总共测试 (W+1) * (H+1) 个点。
  给定信号塔的位置,请问这 (W+1)*(H+1) 个点中有多少个点被信号覆盖。
输入格式
  输入第一行包含四个整数 W, H, n, R,相邻整数之间使用一个空格分隔。
  接下来 n 行,每行包含两个整数 x, y,表示一个信号塔的坐标。信号塔可能重合,表示两个信号发射器装在了同一个位置。
输出格式
  输出一行包含一个整数,表示答案。
样例输入
10 10 2 5
0 0
7 0
样例输出
57
评测用例规模与约定
  对于所有评测用例,1 <= W, H <= 100,1 <= n <= 100, 1 <= R <= 100, 0 <= x <= W, 0 <= y <= H。

思路:

此题可直接使用三个for循环直接求解。

代码如下:

package com.company.test1;

import java.util.Scanner;

public class Main7 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int W=scanner.nextInt();
        int H=scanner.nextInt();
        int n=scanner.nextInt();
        int R=scanner.nextInt();
        int[][] ints=new int[n][2];
        for (int i = 0; i < n; i++) {
            ints[i][0]=scanner.nextInt();
            ints[i][1]=scanner.nextInt();
        }
        int count=0;
        for (int i = 0; i < W+1; i++) {
            for (int j = 0; j < H+1; j++) {
                int num=0;
                for (int k = 0; k < n; k++) {
                    if ((i-ints[k][0])*(i-ints[k][0])+(j-ints[k][1])*(j-ints[k][1])<=R*R){
                        num++;
                    }
                }
                if(num!=0){
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}

八 、水域清理问题

问题描述
  小蓝有一个 n * m 大小的矩形水域,小蓝将这个水域划分为 n 行 m 列,行数从 1 到 n 标号,列数从 1 到 m 标号。每行和每列的宽度都是单位 1 。
  现在,这个水域长满了水草,小蓝要清理水草。
  每次,小蓝可以清理一块矩形的区域,从第 r1 行(含)到第 r2 行(含)的第 c1 列(含)到 c2 列(含)。
  经过一段时间清理后,请问还有多少地方没有被清理过。
输入格式
  输入第一行包含两个整数 n, m,用一个空格分隔。
  第二行包含一个整数 t ,表示清理的次数。
  接下来 t 行,每行四个整数 r1, c1, r2, c2,相邻整数之间用一个空格分隔,表示一次清理。请注意输入的顺序。
输出格式
  输出一行包含一个整数,表示没有被清理过的面积。
样例输入
2 3
2
1 1 1 3
1 2 2 2
样例输出
2
样例输入
30 20
2
5 5 10 15
6 7 15 9
样例输出
519
评测用例规模与约定
  对于所有评测用例,1 <= r1 <= r2 <= n <= 100, 1 <= c1 <= c2 <= m <= 100, 0 <= t <= 100。

思路:

可以用bfs求解,也可直接暴力四个for循环。

代码如下:

package com.company.test1;

import java.util.Scanner;

public class Main8 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int m=scanner.nextInt();
        int n=scanner.nextInt();
        int t=scanner.nextInt();
        int[][] ints=new int[t][4];
        for (int i = 0; i < t; i++) {
            ints[i][0]=scanner.nextInt();
            ints[i][1]=scanner.nextInt();
            ints[i][2]=scanner.nextInt();
            ints[i][3]=scanner.nextInt();
        }
        int count=0;
        for (int i = 1; i < m+1; i++){
            for (int j = 1; j < n+1; j++) {
                int num=0;
                for (int k = 0; k < t; k++) {
                    for (int l = 0; l < 4; l++) {
                        if (i>=ints[k][0]&&i<=ints[k][2]&&j>=ints[k][1]&&j<=ints[k][3]){
                            num++;
                        }
                    }
                }
                if (num==0){
                    count++;
                }
            }
        }
        System.out.println(count);
    }
}

九 、滑行问题

问题描述
  小蓝准备在一个空旷的场地里面滑行,这个场地的高度不一,小蓝用一个 n 行 m 列的矩阵来表示场地,矩阵中的数值表示场地的高度。
  如果小蓝在某个位置,而他上、下、左、右中有一个位置的高度(严格)低于当前的高度,小蓝就可以滑过去,滑动距离为 1 。
  如果小蓝在某个位置,而他上、下、左、右中所有位置的高度都大于等于当前的高度,小蓝的滑行就结束了。
  小蓝不能滑出矩阵所表示的场地。
  小蓝可以任意选择一个位置开始滑行,请问小蓝最多能滑行多远距离。
输入格式
  输入第一行包含两个整数 n, m,用一个空格分隔。
  接下来 n 行,每行包含 m 个整数,相邻整数之间用一个空格分隔,依次表示每个位置的高度。
输出格式
  输出一行包含一个整数,表示答案。
样例输入
4 5
1 4 6 3 1
11 8 7 3 1
9 4 5 2 1
1 3 2 2 1
样例输出
7
样例说明
  滑行的位置一次为 (2, 1), (2, 2), (2, 3), (3, 3), (3, 2), (4, 2), (4, 3)。
评测用例规模与约定
  对于 30% 评测用例,1 <= n <= 20,1 <= m <= 20,0 <= 高度 <= 100。
  对于所有评测用例,1 <= n <= 100,1 <= m <= 100,0 <= 高度 <= 10000。

思路:

直接使用用dfs求解。注意在回溯时num - 1;
如果直接使用dfs求解,对于30%的测试用例是足够的,
但是如果在n,m值较大时会出现超时的情况,所以这里如果想要不超时就得用到动态规划算法
(递归的时候存在大量的重复运算)
这里用到了记忆化搜索。
实测改进后可通过所有案例!

原代码:

import java.util.Scanner;

public class Main9 {
    public static int[][] ints2={{1,0},{-1,0},{0,1},{0,-1}};
    public static int num=0;
    public static int n=0;
    public static int m=0;
    public static int count=0;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        n=scanner.nextInt();
        m=scanner.nextInt();
        int[][] ints=new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ints[i][j]=scanner.nextInt();
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                    num=1;
                    dfs(ints,i,j);
            }
        }
        System.out.println(count);
    }
    public static void dfs(int[][] ints,int x,int y){
        for (int i = 0; i < 4; i++) {
            int newX=x+ints2[i][0];
            int newY=y+ints2[i][1];
            if (newX>=0 && newX < n && newY>=0 && newY<m &&ints[newX][newY]<ints[x][y]){
                num++;
                count=Math.max(count,num);
                dfs(ints,newX,newY);
                num--;
            }
        }
    }
}

改进后代码如下:

import java.util.Scanner;

public class Main9 {
    public static int[][] ints2={{1,0},{-1,0},{0,1},{0,-1}};
//    public static int num=0;
    static int n;
    static int m;
    public static int count=0;
    static int[][] ints;
    static int[][] maze;
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        n=scanner.nextInt();
        m=scanner.nextInt();
        ints=new int[n][m];
        maze=new int[n][m];
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                ints[i][j]=scanner.nextInt();
            }
        }
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
//                    num=1;
                    count=Math.max(dfs(i,j),count);
            }
        }
        System.out.println(count);
    }
    public static int dfs(int x,int y){
        if (maze[x][y]!=0){
            return maze[x][y];
        }
        int[] result = new int[4];

        for (int i = 0; i < 4; i++) {
            int newX=x+ints2[i][0];
            int newY=y+ints2[i][1];
            if (newX<0 || newX >= n || newY<0 || newY>=m){
                result[i]=0;
                continue;
            }
            if (ints[newX][newY]<ints[x][y]){
                result[i]=dfs(newX,newY);
            }else {
                result[i]=0;
            }
//            if (newX>=0 && newX < n && newY>=0 && newY
//                num++;
//                count=Math.max(count,num);
//                dfs(newX,newY);
//                num--;
//            }
        }
        int max = result[0];
        for (int i = 1; i < 4; i++) {
            if (result[i] > max){
                max = result[i];
            }
        }
        maze[x][y]=max+1;
        return max+1;

    }
}



你可能感兴趣的:(java,蓝桥杯,开发语言)