蓝桥杯练习

1. 进制复习：

N进制转十进制

加权的方法来转，例如：2022（9） ——>______（10）

将2022展开计算：2*9^3+0*9^2+2*9^1+2*9^0 = 1478

将要转换为10进制的数按位展开，分别乘他们进制数（9）的乘方。

二进制与十进制的通转

两个方法：1.除2取余法（不推荐），整数除的时候取值从下往上数

2.  8 4 2 1（整数部分） 真值表法：例如9 的可以写成1001 （8+0+0+1）

也可以返过来使用1001 转化为9。小数部分是：0.5  0.25  0.125  0.075

二进制转化为8进制和16进制

例如：二转八进制  1001 --à 001 001 补全成三位用4 2 1真值表将其转化为整数 11

二进制转16进制  11 1001 1111 --à0011 1001 1111 补全成四位 真值表将其转化为 3915  十六进制超过十（包括十）需要将数字转换为ABCDE来代替，A就是10，依次往后代替。39F

总结：任何数转10进制都可以使用加权乘进制数的次方来算

      10进制转任何进制否可以用除N取余法来算

      特别注意 8和16 进制转10进制时，使用2进制作为桥梁会方便很多。

ASCLL码表特别注意： A与a的码记住就好了：

大A在前 小a在后 相差32位。

字节单位换算   位是最小的。一个字节等于8位。其余一般是1024的差别。

蓝桥杯日期型：

完美的经典例题！

public class demo7 {
    // 枚举月份
    static int w[] = {0, 31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31};
    // 开始时间
    static int y = 2022 , m = 1, d = 1;
    // 枚举顺子
    static String s[] = {"012", "123", "234", "345", "456", "567", "678", "789"};
    public static void main(String[] args)
    {
        // 记录答案
        int ans = 0;
        // 结束时间，不包括2022-12-31这天
        while(y != 2022 || m != 12 || d != 31)
        {
            // 判断当年是否是闰年
            if(y % 4 ==0 && y % 100 != 0 || y % 400 == 0)
                w[2] = 29;
            else
                w[2] = 28;
            // 判断是否符合条件
            if(check())
            {
                ans++;
            }
            // 天数+1
            d++;
            // 如果天数大于当前月份了 天数重新赋值为1，月份＋1。
            if(d > w[m])
            {
                m++;
                d = 1;
            }
            // 如果月份大于12了年数+1，月份变为1
            if(m > 12)
            {
                y++;
                m = 1;
            }
        }
        // 再次check判断最后一天是否符合要求
        if(check())
            ans++;
        System.out.println(ans);


    }
    public static boolean check()
    {

        // 把月份转换为字符串
        String b = m + "";
        // 天数转换为字符串
        String c = d + "";
        // 如果月份小于10，就在前面拼接一个0
        if(m < 10)
        {
            b = "0" + m;
        }
        if(d < 10)
        {
            c = "0" + d;
        }
        // 拼接整体
        String a = y + b  + c;
        // 循环遍历年份字符串有没有包含连续的顺子字符串
        for(int i =0; i < s.length; i++)
        {
            if(a.contains(s[i]))
                return true;
        }
        return false;
    }

}

注意点：1.将月份用数组枚举出来，注意闰年的特殊性。

            使用y%4&&y%100 || y%400 若是润，将数组[2]=29

              反之[2]=28。

             2.注意月份和日在拼接字符串是 (月<10) (日<10 )要在月日之前拼接上 “0”+月/日

             3.当月超12 则要将年加1 月重新赋值1

               当日超过本月的天数 月[] 月加1，天数赋为1

             4.如果知道开始和截止日期,则要在之前先申明开始时间，使用while(y!=2022 || m!=12 || d!=31)

              。注意这个while判断不了2022,12,31这一天。

Java书写格式注意。

在main方法外写方法时注意：

方法加上Static-àpublic static int abc()

变量数据加上Static-à static int abc;

集合或者数组加上Static-à static Map<类型，类型> map = new Map();                static  int  a [] = {1,2,3,50}    

Static int a[10];

求最大公约数： 公约数 是两数最大的因子数。

公式：gac(a,b) = gac(b,a%b)  只有当b为零时，才可以求出最大公因数a。可以使用循环和递归求出

全排列问题使用：回溯法和邻里交换法

回溯法：是一种解决搜索问题的方法，全排列也是一种搜索问题，回溯就是类似于枚举的搜索尝试过程，在搜索过程中寻找问题的解，当发现不满足求解的条件时，就返回，尝试别的路径。

蓝桥杯之循环问题

蓝桥杯通常在前3道题目中涉及到循环知识点。

• for循环：一般能在题目里面找到循环次数。

• while循环：只知道循环条件，不知道循环次数。

在考察循环时，还会涉及到集合、字符串等知识点的应用。例如;

• 对字符串一般考察常用函数。字符串转字符数组，判断结尾等。 考试不让带纸质资料，但是可以用API文档。

• 集合一般考察特性：list：有序可重复。 set：无序不可重复 map：key-value键值对。

一：for循环和字符串的应用（已知循环次数）

2019 Java C组第一题：

小明对数位中含有2、0、1、9的数字很感兴趣，在1到40中这样的数包括1、2、9、10至32、39和40，共28个，他们的和是574。请问，在1到2019中，所有这样的数的和是多少？

• 思路分析：

  • 1.获取1-2019每个数字的千位（不为0）、百位、十位、个位。，将每一个数字和2、0、1、9这四个数字进行比较。如果存在，可以累加到变量count上。123对10取模，得到个位3 123/10再对10取模得十位2 ， 123/10/10 再对10取模得到百位1.

  • 2.将数字转成字符串。获取每一位得数字。将每一个数字和2、0、1、9这四个数字进行比较。如果存在，可以累加到变量count上。

int count=0; for(int i = 1 ; i<=2019 ;i++){ //将数字转成字符串 String j = i + ""; //将字符串转成字符数组 toCharArray() char[] cs = j.toCharArray(); for (int k =0; k<cs.length;k++){//2019 if(cs[k] == '0' || cs[k] == '1'|| cs[k] == '2'|| cs[k] == '9'){ count += i; break; } } } System.out.println(count);

2015年java C组第二题：

一些数字的立方的末尾正好是该数字本身。 比如：1,4,5,6,9,24,25,....；请你计算一下，在 10^4以内的数字中（指该数字，并非它立方后的数值），符合这个特征的正整数一共有多少个。

• 分析：已知循环次数，用for循环。可以将数字和数字得立方转成字符串。str.endsWith(str2):判断字符串str是否以字符串str2结尾。

int count=0;//计数器 for (long i =1 ; i <=10000 ; i++){ String i1 = i+""; String i2 = (iii)+""; if(i2.endsWith(i1)){ count++; } } System.out.println("满足条件得数字有:"+count);

二：while循环：已知循环条件。满足条件就一直执行

2019年Java C组第二题

小明有一些矩形的材料，他要从这些矩形材料中切割出一些正方形。当他面对一块矩形材料时，他总是从中间切割一刀，切出一块最大的正方 形，剩下一块矩形，然后再切割剩下的矩形材料，直到全部切为正方形为止。例如，对于一块两边分别为 5 和 3 的材料（记为5×3），小明会依次切出3×3、2×2、1×1、1×1 共4个正方形。

现在小明有一块矩形的材料，两边长分别是 2019 和 324。请问小明最终会切出多少个正方形？

• 分析：只知道循环终止条件，不确定循环次数。用while循环。

int length = 2019; int width= 324; int count =0;//切出正方形得个数 while (true){ if(length >width){//长》宽 count ++; length -= width; }else if(width >length){//宽》长 count++; width -= length; }else if(width ==length&& width!=0){//长==宽 count++; width -=width; length -= length; }else if(width ==0){ break; } } System.out.println(count);

18年Java C组第一题

小明被不明势力劫持。后莫名其妙被扔到 X 星站再无问津。小明得知每天都有飞船飞往地球，但需要108元的船票，而他却身无分文。他决定在 X 星战打工。好心的老板答应包食宿，第1天给他1元钱。并且，以后的每一天都比前一天多2元钱，直到他有足够的钱买票。请计算一下，小明在第几天就能凑够 108元，返回地球。

• 分析：循环次数布置，循环终止条件已知。使用while循环，终止条件：总工资>=108元。

int sum = 0;//总钱数 int i =1;//每天挣得钱数。 int day =0;//总天数 while (true){ sum+=i; //总天数加上每天挣得钱 day +=1;//天数+1 if(sum >=108){ break; } i += 2;//后一天比前一天多挣2元 } System.out.println(day);

18年Java C组第二题

5只猴子是好朋友，在海边的椰子树上睡着了。这期间，有商船把一大堆香蕉忘记在沙滩上离去。第1只猴子醒来，把香蕉均分成5堆，还剩下1个，就吃掉并把自己的一份藏起来继续睡觉。第2只猴子醒来，把香蕉均分成5堆，还剩下2个，就吃掉并把自己的一份藏起来继续睡觉。第3只猴子醒来，把香蕉均分成5堆，还剩下3个，就吃掉并把自己的一份藏起来继续睡觉。第4只猴子醒来，把香蕉均分成5堆，还剩下4，就吃掉并把自己的一份藏起来继续睡觉。

第5猴子醒来，重新把香蕉均分成5堆，哈哈，正好不剩！

请计算一开始最少有多少个香蕉。

分析：不知道香蕉得数量，设为n个。用while循环。满足下面得条件结束：

1. n%5 =1 a= (n-1)/5*4

2. a%5 =2 b= (a-2)/5*4

3. b%5 =3 c= (b-3)/5*4

4. c%5 =4 d=(c-4)/5*4

5. d%5 =0 d>0

int n= 1;//代表香蕉得数量 while(true){ if(n %5 ==1){ int a =(n-1)/54; if(a%5 ==2){ int b= (a-2)/54; if(b%5 ==3){ int c= (b-3)/54; if(c%5 ==4){ int d=(c-4)/54 ; if(d%5 ==0 && d>0){//d>0隐藏条件 break; } } } } } n++; } System.out.println(n);

三：字符串循环和集合的使用

• 对集合的考察集中在集合的特性和功能。set唯一性。list有序性。以及集合元素的个数。

2019java C组第三题

一个字符串的非空子串是指字符串中长度至少为1的连续的一段字符组成的串。例如，字符串 aaab有非空子串 a, b, aa, ab, aaa, aab, aaab一共 7个。注意在计算时，只算本质不同的串的个数。

请问，字符串 0100110001010001有多少个不同的非空子串？

分析：set的唯一性，去除重复的子串

• aaab从第一个下标开始截取: a aa aaa aaab

• 从第二个下标开始：a aa aab

• ......

• 下标0 截取的范围：[0,最大下标].

• 下标1的截取范围：[1,最大下标]

• .....

• 截取的方法：subString(i,j):截取子串

String string = "0100110001010001"; HashSet<Object> set = new HashSet<>();//去重 for (int i =0; i<string.length() ;i++){//控制从第几个下标开始截取 for (int j =i ; j<string.length() ; j++){ String s = string.substring(i, j+1); set.add(s); } } System.out.println(set.size());

2015java C组第6题

小明发现了一个奇妙的数字。它的平方和立方正好把 0 ~ 9 的 10 个数字每个用且只用了一次。你能猜出这个数字是多少吗？

1. 平方和立方通过取模求出每一位（不推荐）

2. 通过字符串操作，去求每一位，放入set，看长度是否为10

int i =1; while (true){ HashSet<Object> set = new HashSet<>(); int ping = ii; int li = ii*i; String string = ""+ping + li; if(string.length() ==10){ System.out.println(string); char[] cs = string.toCharArray(); for (int j =0 ; j<10; j++){ set.add(cs[j]); } if(set.size() ==10){//找到了 System.out.println(i); break; } } i++;

四：循环求质数

• 质数就是只能被1和它本身整除的数字。最小的质数是2.

• 如何判断一个数字n是不是质数：找一下[2,n-1]有没有能被n整除的数字，有就不是质数。

• 整除：n对数字取余为0

2019java C组第四题

我们知道第一个质数是2，第二个质数是3 ， 第三个质数是5....

请你计算第2023个质数？

分析：我们可以先去求质数，然后把求到的质数放入一个list里面。取出下标为2022的，就是第2023个质数。

ArrayList<Object> list = new ArrayList<>(); for (int i=2; i<=20000;i++){ int a =0;//记录有没有除了1和它本身之外的可以整除的数字。 for (int j =2 ; j<i;j++){ if(i%j ==0){ a++; break;//只有找到一个能被整除的就退出内层循环，提高运算效率 } } if(a==0){ list.add(i); } } System.out.println(list.get(2022));

蓝桥杯之排序与算法问题

在蓝桥杯中，算法题目是最容易拉开和竞争者的差距的，接下来我们进行算法方面的学习

一：排序

在一维数组中，排序是很重要的。下面是三种常用的排序算法：冒泡排序，插入排序，选择排序。

冒泡排序

原理：比较两个相邻的元素，将较大的值交换到右边

2 8 7 5 9 4 3

第一趟：

第一次：比较第一个和第二个： 2 和 8 ，不需要交换。

第二次：比较 8 和 7， 将8 和7 进行交换： 2 7 8 5 9 4 3

第三次：比较8 和5 ，将8 和5 交换 2 7 5 8 9 4 3

第四次：比较8 和 9 ，不需要交换

第五次：比较9 和 4 ，需要交换 2 7 5 8 4 9 3

第六次：比较9 和3 ，需要交换 2 7 5 8 4 3 9

第一趟结束后，最大的数字，出现在最后一位

第二趟：

第一次：比较2 和 7 ，不需要交换

第二次：比较7 和5 需要交换： 2 5 7 8 4 3 9

第三次：比较5 和 8 ，不需要交换

第四次：比较8 和4 ，需要交换：2 5 7 4 8 3 9

第五次：比较8 和3 ，需要交换：2 5 7 4 3 8 9

第六次：比较8 和9，不要交换（？）

第二趟，第二大的数字，出现在倒数第二位

以此类推：第三趟：2 5 4 3 7 8 9 第四趟。。。。。。直到排序完成。

简化：第一趟跑完，最大的数字在最后一位，不用参与排序，第二趟，第二大的 数字在倒数第二位，不用参与排序...

题目：排序：[10,1,35,61,89,36,55] //外层for循环控制趟，内层控制次 int a [] = {10,1,35,61,89,36,55}; for (int i =0 ; i < a.length-1 ; i++){ for (int j =0 ; j< a.length-1-i; j++){ if(a[j]>a[j+1]){//左边大于右边 int k = a[j]; a[j] = a[j+1]; a[j+1] =k; } } } for (int i =0 ; i < a.length ;i++){ System.out.print(a[i] +" "); }

选择排序：

原理：

第一次：从未排序的数据元素里面，选出一个最小的（最大的）的元素，然后和第一位元素交换位置。

第二次：选出第二小的（第二大的）的元素，然后和第二位元素交换位置。

.........

int a [] = {2,9,5,0,1,3,6,8}; int begin =0; int end = a.length-1; while (begin <end){ int min = a[begin];//min，用来存储数组中元素的最小值 int t = begin;//t 存储最小值的下标 for (int i = begin; i <=end ; i++){ if(min > a[i]){ min = a[i]; t = i; } } a[t] = a[begin]; a[begin] = min; begin++; } for (int i =0 ; i < a.length ;i++){ System.out.print(a[i] +" "); }

插入排序

原理：将数列分成两部分：排好序的数列 未排序的数列

在未排序的数列里面。挨个去元素插入到排好序的数列中

int a [] = {2,2,1,6,4,9,7,6,8}; for (int i =1 ; i < a.length ; i++){ int k = a[i];//哨兵。从数组第二位元素开始，每一循环向后移动一位存储元素， // 将这个数插入到前面排好序的数列中 int j= i-1;//排好序的数列中的最后一位 while (j >=0&& k<a[j]){//哨兵要存在左边比它小，右边比它大 a[j+1] = a[j];//给哨兵的插入腾出位置 j--;//用j记录哨兵最终插入的位置 } a[j+1] = k;//哨兵插入 } for (int i =0 ; i < a.length ;i++){ System.out.print(a[i] +" "); }

二：算法

递归

函数/方法 直接/间接 的调用本身。一般用来在数据原来的基础上加减乘除等操作。

案例：斐波那契数列：

1 1 2 3 5 8 13..... 第一个和第二个数字是1，其他的数字等于前两个数字之和。Fn=F(n-1)+F(n-2)

代码：计算第n位的斐波那契数字

//递归：代码简洁，但是涉及到的运算，会随着递归层数的增加成指数级增长。

public static int Fn(int n){ if(n ==1 || n==2){ return 1; } return Fn(n-1)+Fn(n-2); }

20年Java C组第三题：

如下图所示，小明用从 1 开始的正整数“蛇形”填充无限大的矩阵。

1 2 6 7 15 16 28 29...

3 5 8 14 17 27 30...

4 9 13 18 26 31...

10 12 19 25 32...

11 20 24 33...

21 23 34...

22 35...

容易看出矩阵第二行第二列中的数是5。请你计算矩阵中第20行第20列的数是多少？

• 分析：第20行20列处在45度这条线上。

这条线上的数字是：1 5 13 25 41 ........两数之差： 4 8 12 16...

每一个都是在前面的基础上+4.可以用递归或者循环。 第n位和n-1位差 (n-1)*4

第20行20列相当于这个数列的第20位数字。

public static void main(String[] args) { System.out.println(snack(20)); } public static int snack(int n){ if(n ==1){ return 1; } return snack(n-1)+4*(n-1); }

任务：找一道排序或者算法（简单的，学过的）相关的题目，写出代码，截图上传文件夹

问题：递归和循环的关系？

一道题，可以用递归解答，

• 那么可以换成循环解决吗？可以换

• 代码量变多。运算资源（时间复杂度）

如果发现题目用递归运行时间超出限制，那么：

• 换循环

• 加字典

  • fn(5)= f(4)+f（3） f(4) = f(3)+f(2)[将f(3)和f(2)存起来] f(3)直接得出

辗转相除法：求最大公约数

• 两个整数的最大公约数等于其中较小的数和两数相除余数的最大公约数（gcd)

• gcd(a,b) = gcd(b ,a%b) a>b :当 b的值变成0的时候，a就是要求的最大公约数

• 案例：12和4的最大公约数 = 4 和 0 4

• 10 和7 的最大公约数 = 7 和3 = 3 和 1 = 1 和0

题目：输入两个数字，求最大公约数？

//循环解法 Scanner scan = new Scanner(System.in); //a>b gcd(a,b) = gcd(b ,a%b) a>b int a = scan.nextInt(); int b = scan.nextInt(); while (b!=0){ int c = a%b; a =b; b=c; } System.out.println(a);

//递归解法 public static void main(String[] args) { Scanner scanner = new Scanner(System.in); int a = scanner.nextInt(); int b = scanner.nextInt(); int zz = zz(a, b); System.out.println(zz); } public static int zz(int a,int b){ if(b==0){ return a; } int c = a%b; return zz(b,c); }

全排列

• 求全排列：全排列值得是：n个元素中取n个元素（全部元素）的所有排列组合情况。

• 求组合：n个元素，取m个元素(m<=n)的所有组合情况

• 求子集：n个元素的所有子集（所有的组合情况）

全排列常用解决办法：邻里交换法和回溯法

回溯法

题目：输入[1,2,3]

输出1,2,3所有的不重复的排列组合：

1 ,2,3 1,3,2

2,1,3 2,3,1

3,1,2 3,2,1

回溯：一般解决搜索问题，全排列也是一种搜索问题。

• 回溯：就是类似枚举的搜索尝试过程。在搜索过程中寻找问题 的解。当发现不满足求解的条件时，就回溯返回，尝试别的路径。

全排列可以使用试探的办法列举所有的可能性。一个长度位n 的序列，所有的排列组合：n!

1.从集合中选取一个元素（n种情况）,并标记该元素已经被使用。

2.在第一步的基础上递归到下一层，从剩余的n-1 个元素中，按照第一步的方法再找到一个元素，并标记（n-1)

3.依次类推，所有的元素都被标记，将元素存起来，取对比求解的情况。

邻里交换法

回溯时试探性填充数据，给每个位置都试探性赋值。

邻里交换，也是通过递归实现，但是是一种基于交换的思路。

步骤：

• 将数组分成2个部分：暂时确定部分和未确定部分。刚开始，都是未确定部分。

• 在未确定部分中，让每一个数据都有机会和未确定部分中的第一位交换。然后第一位就变成暂时确定部分。

• 以此类推：每个数据都和未确定部分中的第二位交换（第一位数据除外）.......直到确定所有数据

• 将确定好的数据和条件对比，对比结束后，还原数据。

题目

2017年Java组c组第三题:

A,2,3,4,5,6,7,8,9共9张纸牌排成一个正三角形（A按1计算）。要求每个边的和相等。 下图就是一种排法。

图片描述这样的排法可能会有很多。

如果考虑旋转、镜像后相同的算同一种，一共有多少种不同的排法呢？请你计算并提交该数字。

• 分析：同一个三角形，旋转加镜像后会变成6种，所以最终的结果要除6

1.暴力解：

int sum = 0; for (int a = 1; a < 10; a++) { for (int b = 1; b < 10; b++) { for (int c = 1; c < 10; c++) { for (int d = 1; d < 10; d++) { for (int e = 1; e < 10; e++) { for (int f = 1; f < 10; f++) { for (int g = 1; g < 10; g++) { for (int h = 1; h < 10; h++) { for (int i = 1; i < 10; i++) { if(a==b||a==c||a==d||a==e||a==f||a==g||a==h||a==i ||b==c||b==d||b==e||b==f||b==g||b==h||b==i ||c==d||c==e||c==f||c==g||c==h||c==i ||d==e||d==f||d==g||d==h||d==i ||e==f||e==g||e==h||e==i ||f==g||f==h||f==i ||g==h||g==i ||h==i){ continue; } if(a+b+c+d==d+e+f+g && d+e+f+g==g+h+i+a){ sum++; } } } } } } } } } } System.out.println("一共有"+sum/6+"种不同的排法");//除去镜像和旋转两次，三种重复值为：总数/2/3

2.回溯：

static int num [] = new int[10];//存放数据的数组 static int count=0;//符合条件的排列组合个数 static boolean bool [] = new boolean[10]; public static void main(String[] args) { dfs(1); System.out.println(count/3/2);//要除6 } public static void dfs(int step){//初始值为1 if(step ==10){//代表9位数据已经赋值完成 递归的结束条件 if(num[1]+num[2]+num[4]+num[6] == num[6]+num[7]+num[8]+num[9] && num[1]+num[2]+num[4]+num[6] == num[1]+ num[3]+ num[5]+ num[9]){ count++; } return; } for (int i =1 ; i <10 ; i++){ if(!bool[i]){ bool[i] = true;//标记该位数字已赋值 num[step] = i;//赋值 dfs(step+1); bool[i] = false;//撤回标记 } } }

3.邻里交换法

static int count; static int a [] = {1,2,3,4,5,6,7,8,9}; public static void main(String[] args) { f(a,0); System.out.println(count/6); } public static void f(int a[], int step){ if(step == a.length-1){//step == 8 if(a[0]+a[1]+a[2]+a[3] == a[3]+a[4]+a[5]+a[6]&& a[0]+a[1]+a[2]+a[3]==a[6]+a[7]+a[8]+a[0]){ count++; } return; } for (int i =step ; i <a.length; i++){ { int x = a[i];//交换 a[i] = a[step]; a[step] = x; } f(a,step+1);//递归确定下一位 { int x = a[i];//还原 a[i] = a[step]; a[step] = x; } } }

任务：理解全排列-回溯法和全排列-邻里交换法的思路和代码逻辑

动态规划（DP）

动态规划，常用于：数学，管理科学，计算机科学，经济和生物信息学。

特征：一个问题，可以拆分成一个一个的子问题，解决子问题，顺带解决这个问题

核心思想：拆分子问题，记住过程，减少重复运算。

例子：

• 1+1+1+1+1+1=? 等于6

• 在上面式子的再加上一个“ 1+”。答案是多少？

• 直接通过以往计算过的答案，再加1

题型：青蛙跳阶问题：

1.自顶而下求解

一只青蛙，可以一次跳上1级台阶，也可以一次跳上2级台阶。求这只青蛙跳10级台阶有多少种跳法？

分析：

• 要跳到第10级台阶，要么从第8级台阶，跳2级到第10级。要么从第9级跳1步到第十级。

• 要跳到第9级：可以从第8级跳1步到达，也可以从第7级跳两步到达。

• 要跳到第8级：可以从第7级跳1步到达，也可以从第6级跳两步到达。

• ............

假设跳到第n 级台阶的跳法是 f(n)，那么：

f(10) = f(9) + f(8)

f(9) = f(8) + f(7)

f(8) = f(7) + f(6)

......

f(2) = 2:第2级可以一次跳1步，跳两次，也可以一次跳2步

f(1) = 1：只能一次跳1步

//暴力递归 自顶而下的解 public static void main(String[] args) { int ways = ways(10); System.out.println("有"+ways+"种跳法"); } public static int ways(int n){ if (n ==1){ return 1; } if (n ==2){ return 2; } return ways(n-1)+ways(n-2); }

• 时间复杂度=解决子问题的时间 * 子问题个数 （存在大量重复运算）

• 改进：通过字典存储子问题的解（数组或者map）

public static void main(String[] args) { long l = System.currentTimeMillis(); int ways = ways(40); long l1 = System.currentTimeMillis(); System.out.println("有"+ways+"种跳法"); System.out.println(l1-l); } static Map<Integer,Integer> map= new HashMap(); public static int ways(int n){ if (n ==1){ return 1; } if (n ==2){ return 2; } if(map.containsKey(n)){ return map.get(n); }else { map.put(n,(ways(n-1)+ways(n-2))); return map.get(n); } }

2.自下而上的动态规划

动态规划和带字典的递归有些不同，但解法类似。都有减少重复运算。

• 带字典的递归是从f(10)--->f(1),自顶而下。

• 动态规划，从f(1)--->f(10)，自底而上。

动态规划的特征：

• 最优子结构：f(n) = f(n-1) + f(n-2), f(n-1)和 f(n-2)就是f(n)的最优子结构。

• 状态转移方程：f(n) = f(n-1) + f(n-2)

• 边界：f(1) =1 ,f(2) = 2

• 重叠子：重复的运算：f(10) = f(9) + f(8),f(9) = f(8)+f(7). f(8)就是重叠子

public static void main(String[] args) { System.out.println(ways(10)); } public static int ways(int n){ if(n==1){ return 1; } if(n==2){ return 2; } // 1 2 1+2 2+3 3+5 5+8 int a =1; int b=2; int temp =0; for (int i =3 ; i<= n; i++){ temp = a+b; a = b; b= temp; } return temp; }

动态规划的解题思路

什么样的问题适用动态规划？

如果一个问题，可以把所有的答案穷举出来，而且存在重叠子问题，就可以考虑使用动态规划。

动态规划的经典应用场景：

• 最长递增子序列 ---20年蓝肽子问题

• 最小距离 --- 数字三角形

• 背包问题

• 凑零钱问题

• 等等等。。。

动态规划的解题思路

• 核心思想：拆分子问题，记住过程，减少重叠子运算

• 穷举分析

• 确定边界

• 找出规律，确定最优子结构

• 写出状态转移方程

• 代码实现

BFS(广度优先搜索)

2020年数字三角形

上图给出了一个数字三角形。从三角形的顶部到底部有很多条不同的路径。对于每条路径，把路径上面的数加起来可以得到一个和，你的任务就是找到最大的和。

路径上的每一步只能从一个数走到下一层和它最近的左边的那个数或者右 边的那个数。此外，向左下走的次数与向右下走的次数相差不能超过 1。（先行忽略）

输入描述:输入的第一行包含一个整数(1≤N≤100)，表示三角形的行数。下面的N行给出数字三角形。数字三角形上的数都是 0 至 100 之间的整数。

输入输出样例

5

7

3 8

8 1 0

2 7 4 4

4 5 2 6 5

27

忽略条件分析：

• 向左下走的次数与向右下走的次数相差不能超过 1。（先行忽略）

• 第一行1个数字，第二行2个数字.....

• 一次走一层：

  • 从下往上走：从第四层开始看：第四层的数字判断第五层左下和右下数字谁大，谁大，就加上谁，意味这从下面一层较大的数字走到第4层的这个数字。注意，要记住相加之后的数字！

• //向左下走的次数与向右下走的次数相差不能超过 1。（先行忽略）

Scanner scanner = new Scanner(System.in); System.out.println("请输入行数"); int n = scanner.nextInt(); int [][] array = new int[n][n]; for (int i =0 ;i<n;i++){ //将数字三角形放入二维数组 for (int j =0; j <=i ; j++){//控制第几行有几个数字 array[i][j] = scanner.nextInt(); } } //从下到上 for(int i = n-1; i > 0 ; i--){ for (int j = 0 ; j <i ; j++){ //某个数字（i,j)的左下是（i+1,j),右下是（i+1,j+1) array[i-1][j] += array[i][j] > array[i][j+1] ? array[i][j] : array[i][j+1]; } } System.out.println(array[0][0]); // 从上到下，和从下到上思路类似。

加上条件之后的分析：

• 向左下走的次数与向右下走的次数相差不能超过 1。

• 如果是奇数行，最终肯定走到最后一行中间的数字。

• 如果是偶数行，最后肯定是中间的两个数字。

Scanner scan = new Scanner(System.in); int N = scan.nextInt(); int[][] arr = new int[N + 1][N + 1]; for (int i = 1; i < N + 1; i++) { //最左行，最上列为0 for (int j = 1; j < i + 1; j++) { arr[i][j] = scan.nextInt(); arr[i][j] += Math.max(arr[i - 1][j], arr[i - 1][j - 1]); } } scan.close(); //关键点：若左右移动差值为1，那么一定在中间位置 int res = (N % 2 == 0) ? Math.max(arr[N][N/2], arr[N][N/2+1]) : arr[N][N/2+1]; System.out.println(res);

蓝桥杯之二维数组问题

蓝桥杯历来对二维数组都非常看重，每年基本会至少有2道关于二维数组的题目。

主要考察：

• 二维数组存储行、列数据，遍历，输出结果

• 二维数组的旋转

• 二维数组数据的找规律。等等

二维数组问题，不难，但是比较繁琐。需要细心、耐心。

1.二维数组的旋转问题

主要考察二维数组行和列的输出顺序。可以先将数组放入二维数组中，调整行、列的输出顺序达到旋转的目的。

19年JavaC组第六题：

图片旋转是对图片最简单的处理方式之一，在本题中，你需要对图片顺时针旋转 90 度。我们用一个n×m 的二维数组来表示一个图片，例如下面给出一个3×4的图片的例子：

1 3 5 7

9 8 7 6

3 5 9 7

这个图片顺时针旋转 90 度后的图片如下：

3 9 1

5 8 3

9 7 5

7 6 7

给定初始图片，请计算旋转后的图片。

输入的第一行包含两个整数n,m，分别表示行数和列数。

接下来n行，每行m个整数，表示给定的图片。图片中的每个元素（像素）为一个值为 0 至 255 之间的整数（包含 0 和 255）。

• 分析：

Scanner scan = new Scanner(System.in); int n = scan.nextInt();//行数 int m = scan.nextInt();//列数 int a [][] = new int [n][m]; //接收数据 for (int i =0 ; i <n ; i++){ for (int j = 0 ; j <m ;j++){ a[i][j] = scan.nextInt(); } } //关闭资源，减少浪费 scan.close(); //输出：n和m的先后先后顺序调换 ：第一行变成第一列，第一列变成最后一行 for (int i=0 ; i < m; i++){ for (int j = n-1 ; j >=0 ; j--){ System.out.print(a[j][i]+ " "); } System.out.println(); }

2.根据规律查询某行某列的数据

这种题目一般会给出小段数据，寻找规律，创建对应的二维数组，通过索引查询某行某列的数据

步骤：

• 找出数据的规律

• 创建二维数组

• 通过索引获取数据

20年JavaC组第三题：

如下图所示，小明用从 11 开始的正整数“蛇形”填充无限大的矩阵。

1 2 6 7 15 ...

3 5 8 14 ...

4 9 13 ...

10 12 ...

容易看出矩阵第二行第二列中的数是5。请你计算矩阵中第20行第20列的数是多少？

int[][]a=new int[40][]; int b=1; for (int i = 0; i <40; i++) { a[i]=new int[40-i]; for(int j=0;j <=i;j++){ if(i%2==0){ a[i-j][j]=b; }else{ a[j][i-j]=b; } b+=1; } } System.out.println(a[19][19]);

• 也可以用递归（参考蓝桥杯之排序和算法--递归部分）

3.二维数组存储大量数据

这种题目的数据量很大，让从中寻找出符合某些条件的数据。一般数据给你字符串或者给你文件。然后创建二维数组。使用循环讲数据存储道二维数组里面（注意调整格式）。然后通过遍历二维数组进行数据匹配。

步骤：

• 数据放入字符串或者文件中。

• 创建对应的二维数组。

• 使用循环或者IO流读取数据放入二维数组。

• 查询对应数据

题目

仔细寻找，会发现：在下面的8×8 的方阵中，隐藏着字母序列：LANQIAO。

SLANQIAO

ZOEXCCGB

MOAYWKHI

BCCIPLJQ

SLANQIAO

RSFWFNYA

XIFZVWAL

COAIQNAL

我们约定: 序列可以水平，垂直，或者是斜向； 并且走向不限（实际上就是有一共 8 种方向）。 上图中一共有4个满足要求的串。下面有一个更大的（100×100）的字母方阵。 你能算出其中隐藏了多少个 LANQIAO 吗？

分析：

• 方向: 水平：从左到右、从右到左 垂直：从下到上，从上到下

• 斜向：从左下到右上，从右上到左下 、 从左上到右下，从右下到左上。

import java.util.Scanner; // 1:无需package // 2: 类名必须Main, 不可修改 public class Main { public static void main(String[] args) { String string="FOAIQNALWIKEGNICJWAOSXDHTHZPOLGYELORAUHOHCZIERPTOOJUITQJCFNIYYQHSBEABBQZPNGYQTCLSKZFCYWDGOAIADKLSNGJ\r\n" + "GSOZTQKCCSDWGUWAUOZKNILGVNLMCLXQVBJENIHIVLRPVVXXFTHQUXUAVZZOFFJHYLMGTLANQIAOQQILCDCJERJASNCTLYGRMHGF\r\n" + "TSDFYTLVIBHKLJVVJUDMKGJZGNNSTPVLCKTOFMUEUFSVQIAUVHNVFTGBDDARPKYNNCUOYUAZXQJNOEEYKLFRMOEMHUKJTPETHLES\r\n" + "FKVINSLWEVGAGMKVFVIUBMYOIAFHLVNKNTYKTZWVXQWRWIGPENFXYDTKRVPKRTHMGHVYOCLDCKMEKRLGEKBYUCLOLYPAKPFSOREH\r\n" + "KWPUOLOVMOFBIXYACWRDYBINTMPASPCEOKHXQIGBQQMCEOIVULIEOPFSCSIHENAJCVDPJDOIWIIULFDNOZOFVAMCABVGKAKCOZMG\r\n" + "XWMYRTAFGFOCNHLBGNGOXPJSTWLZUNNAGIRETGXFWAQSSJPFTQAXMTQWMZWYVEPQERKSWTSCHSQOOBGXAQTBCHOEGBDVKGWJIFTG\r\n" + "ZWWJEIISPLMXIMGHOOGDRZFTGNDDWDWMNUFWJYJGULPHNUFSAQNNIUVAAFZIAZKFXXNWCEABGJAUMGYEIEFVQXVHHHEDYUITRCQB\r\n" + "XZHDPZQTOBECJVBZLACVXACZEDYOGVAVQRNWEOWGRAQYUEUESTEDQTYJUTEFOOITSHDDZHONJGBRCWNEQLZUTBNQIADKNFIOMWZR\r\n" + "EBFKCVNLURZSNPOLTISRPDTNUMCDGKTYRGIOVEPTUTSBAWQKWWEUWIWHAANUZUADGZEATZOQICWFUJTWNZDBKLQNELWVTBNDLNFH\r\n" + "PESISEATZNCDFRMXBQUKBFTIGYSFCWVHPMSUSDKPSCOMVLDOHYQVFHAJKRDTAVLIMNZBZSMLMRTLRPSLAHXDBASDMWAAYBPYVJZF\r\n" + "SCCWYHLQOUKBMCEYENQNJXFOMOOJMTKDSHJJOHDKEGATFZHGWJJAZJROWHAZUFGEQKPYXLCAAXHHQBDALPYUDWZQHBASBBCFGQCQ\r\n" + "ZKNXUBRYZVSPQHOVLAEUAUITMPWXNXJQVIBJVBCSVXKWFAFRPRWOLYVSDVTGGOFFMNQJZOBUDJLFHJTCYMPNOBHQJHGKLIKLZMLA\r\n" + "POCKVEQXUAVHERIAQLGJHYOOVOMTXQFRTBFSETOZICPCHZHFBWNESVJJLSVSVOOGYYABFESWNWDNYBGBNAKRCFQMTCUMIFTESVIN\r\n" + "JCAULIQRYUMAMAOVVWSEUTMECXSDTONRMMROQUISYEURSAYNZUVOPXLIFBDOHPXMABBLEQZGLJXQJOEYYRRRCFTEZQAOIWKRJQDL\r\n" + "ZNUUDWZXZZURPMHGXQGNQBIQWWNERZWULSAPIBODBFFQQIHEQKCKLJYQNXQUTAAYGRBXSLLQNOQPZJEWHETQHPXJANMJFOHINWOW\r\n" + "KJGAWWFSVIZHFNUWBLWYVPIWAEICCAHOEIWRADSLOZGPSVGPUBUUQAVYCHOIGINKYKJABWAQCZCXOBKTNJZQRHLUFKQLACAAOIWJ\r\n" + "SIKWLXQHKDFJVGBVXWDWJKUSFRQRTDJYQMNFOQQALHRLMHSDMCFLAOVKDMTKMTPVTLAZLYJNJXZCFRHHSDIXYUUSVIMIICLUJHFW\r\n" + "JHWUSMCFYHPIXHAPBBSHYDQCKVGQFTENLVERFVOVDCLSTQFUSEPUMTFODLZLYQXDOXAEPONIQWTDWSAWBNSZYACGSJQSHAUMIKXT\r\n" + "MVBNFXMFNPAYSODPXEAYNRKTEZJWMUACSIUYPIORUFPMXAOZZJPJXPFLNSKNIAMETMOVULZPQIJJIRCSYQXOEVRHCNACSBRHKYNW\r\n" + "KGKBTBHGWKVJYZCOVNSKUREKZEIWVLOHAMUAYKLUGHEUESICBZAHURNTJAECTHRNKSIJQFIPVZANSZYSPJWHPKHCAPEYWNXUYQSD\r\n" + "RRRFYQFIQSWYRQTSNGNUFOBMSLGAFWPJGYEHGASFKTJCCZPXFIQLSXNKNWCYVTETOAPCOZJNHEWOCCAWVDEZUQCLLAVUQJJTQCKJ\r\n" + "NMBKMUENVGXXVMQCLXPJDQIQCFWYADIFDSGINGZDJYHPUPXVRMWDIPJRWPNRYOFGYYPEAVKDEMLYRRRMNCRQXPTDSQIVKKGJWDEF\r\n" + "SBAEKIFZCKDOMIQKBDWVQGBYWPDIBOLQUGAQRXLJDAZMXVZXYSNWEWTNZKYREMBEUHOTFOCKEJSXCMUBCKXNGQXTQJRCRCLWJTOI\r\n" + "YXBFBIBRAAFNPKBLTSMCFERZURZNWHMOEHIHNQTBWXNPJGIDYDPRGEWACCBULJRACOFLANQIAOIHMYCNQHVKXSIGAMWAHUSNBBTD\r\n" + "QDGPTRONXHAZWOUPNBFJFEWAMFZUQZFDKAPNJUBQPWBPYGPZHKUDZZDLCCWHGAUKJCSLLFWGPYJKJQBNLCZESOGXXSQCVVKVRVAW\r\n" + "NXPGQOUEFLUZHHSAODIWEPZLXVQLYGVOOVCCREDJZJOMCSCFFKEIEAVCTPUZOWNOLJHGBJHJFBFFORGXOXXFOCAGBWEFCIDEKDLB\r\n" + "PTXSUINQAJURNFQPMMSPLZTQAHCIOFJUEFFZGIHTSJNIEXQLLHRQUXXLLORJEHGQJOXSLIAVFPEJNGMMVAXDDMPXLOSTRLLFLYRM\r\n" + "JQNCLENGTROIKDWBMXRNJYPGZRQOREPJJPTXKVVKPYYZENEOIQKZOPXAYGFXORXRIDGATHMZFDJIOIOKVDJBHSXQMYCBYFGXWHLH\r\n" + "CITGTILGPGBHZMNWWHXEFPGDPJUVFBJKAQWACZHPRPJYCOLGZTBDCVHNRSUAJUQAWAPMQJDQIFPZQZEONWHIYKMXDZOMVETEFJRB\r\n" + "RDOTIDCFEESOKYPYCGQQKOGPMGJRITSVTKOKDSXLRLJRRHNFRFXCMDNQMCEGZFJWHZOAFBQXXPXNBSWTSUYPAWQRHAUGLNPBRSJT\r\n" + "HOWRIUGMOQTUYIHDWJRFBWWKWYKCICSVBVKTBIIWGFSVIFCTUKIHHUUISCOTEOYRWQXTAEBXQQOLLMOALNIYVCCHNSWIKHMYYNZO\r\n" + "OFRIYYXPPSRTPAYMUJSSDILKIZAYSEIOLANQIAOVKARDPGVFCSYBSNHAPGTIKLAWTTKOEADWRLAACAAFYTBTNSGFTYLYUHJXBMMA\r\n" + "NJFTMLUIBKDPWBXQOMBVQXCZOIREHRSZCSJOIVBXWQIBUTYBQNTZRVROHGOIZYAJWXLEATLOZJIKJMIHSLGSVTCXJWIOOGWSERRQ\r\n" + "DBQJNGBLRIYFIKHBEYOZQBOAGGNIZKFDHWXCFNJLBQXVLHIQNIBZSDLTTRERHNWCMLJCVBBGGAQTPUQHIRABXPQSYGSDVMBNNDFG\r\n" + "KPLFUYXHYGOCZPPXMWCZYNKCYBCRZVKFBHQXPGPBZFTTGEPQTJMOFHAYSQQZDMQECGXOXADYHNNXUKNBXZBYHBOULXNBJZKIZREF\r\n" + "LVHAMSNXJOCVRPVGJUWXFVOCUCLCZDXRPBBDRLRAVVNLOZWOHWMXYSNMXAKJYWYGILNGUJGIPKAUDVANZLFWKUWWUSQYBRCBVDIJ\r\n" + "QCXPLOTPPGXCUZOUSSTXHVMLHVMJTUSSOPLRKEBQSGWNGVHKANVZWYQHSHLIPWSYCPKTUKPMWPLVFLLAHXZQANFXHFNYHIQVIOYN\r\n" + "ZPTJJCBHXPSUPOMNRVCKXSUFCNRCRNCPTPGIDQOEQUDFNUNMJPOEKVIMUJAJZOUKMAFSLDWYMCHTSNJYUDJAHQOIXPYSRHVAFFCR\r\n" + "DCGMEEWXWMNOSSJNIZCINRHENPPPCYVFWYCONOPKXMFZXXIHNXIGAHAMHSBRESOETGVXWDNQLGCEOUDDJXHQIVCHRNKBFFEWILGY\r\n" + "SOAIQNALXRBSGAQIDQVMVDKVZCPMJNXKXRXPFZAUVQPBHHQKTPDSQROLQTUGMFQRWGVEWCYPDYDZGNNNUFKJUEHJKPLIQNRQYXHU\r\n" + "GKGWUCJXUKAEHLRLNDFUQPSJAZTVJRXWXQVBMRJXULEMJJPDCVTOWVFDBVLSBHZRRQUVMUQYKTJCLSGGHGCPHPHMWYAECLJIZUWV\r\n" + "QQNKPQRJMSOCEAYDNKPHVEGKAGCKAPDXTGVXULHUXHJPDXCSKQTCJENVTZTMRUENCSWHBEORALSREBWAJEMQDXMRKGHJGICDHKHY\r\n" + "YNSDSWDRLBBFUFVVICMGUCGBSVDLJNXGKXNFGVLKAVBJRRRUHKRXTPBJAKIEBAVMDIOJLIUDABCGNPNJIYBCXMOOWKRPHPYSWRDC\r\n" + "BORWTNBISSLTVKBRTLWKRNCEDCNEGCIYJIPDICFAVNOISYAHWBLGMNFKXZYTTWJOBEPNMSJEJMHXVPGOJOLQQQVXFGEULANQIAOD\r\n" + "OQETOJHCZXGTUKIWGMEVVMXCURISUOFQSAWZWDMZWVYHZMPEIMWKJDGERODVVUXYRTYLCRGYQQOIOFZSSZRAIESWBQOAIQNALJNR\r\n" + "HEYWHPLLPCUEOCBAOWGAYEJZQJHLVNMVQNSQQGGUBOIMDPFLOVSQGBLYAMBRYJDVOXOQINLJAVYALAKHPKOYNKGXIISSJNGKHYMS\r\n" + "IQVRYKXCUFIRNENEXFJTMOTJWYXSMTDHHPRHWIXETWVVIXZELKLLWRWQYGBCGJNYSUQEFCOUDNIJMLJNLAWSYJGULKBCFPYVSSMW\r\n" + "WQHGWRQFWFOTGPBBSJBDUKOMBXNRPIMCGPGVZFADWTBVIEMVTBXVAFQDDMJALCOMZTXUFFKBQQZDFAMTFWEXTHBKNWRLUVITQXLN\r\n" + "OPPJQKNGHWWPENVQIABJCQNKXNPWOWRFEOKQPQLANQIAORGGOLAYCEGZBHZVLPBERWYIJNJUNXKULUQOJLTNRDZDEYWEMYCHJLLB\r\n" + "LJISOAQLXJEFXVTOZSICOLQIJEXUANJWIFSIMGUQWHBXUDWOEILYFUZTGDZDSPLZPDPXBLFAXLEFQFEPDSJQWEQMXKKHCXHMSATM\r\n" + "UMUJENPBYKZLWAJAXJKDIYCBREBPOETQHMRHLKSEZUIPRGWIZDDQLSJAPKPBWMJMPZWLNFLFCQOCDBMLIHIYCXUJLFLPZVGWBKMY\r\n" + "WHZJLKEWUPETVUREKVKCLBNYFLWCERVIPUDINNWGQTUHWXCTDVTMYATYUZLMVLOHKBOGIZCQDOWFBCWJAVUXYUEVRKPOXCKHAWZC\r\n" + "RPLNLCUHJRADHJNSDPZXIKXGUKEJZCFJQASVUBSNLXCJXVCJZXGMRYRLOBCNGPDUJQVEFKMYHNZGZOAIQNALQDHTBWJXPKJLFXJY\r\n" + "MKCEZEDAFGSOCORWJGMOKWPVVBVDYZDZHPXFWJBDELHPGOQHMBAHUUUJMGXAEKZCTQTBXNVYUIQUVZGXSKQXJWRUPSFIJDYIAORC\r\n" + "GKFKQNXPJWOPPBTUKTHUBIROSYOVFEMJBRREWICJPCIOSTWPAUSKTRQULXPWRSXHSRYBCWYCYOTCTPFSQLDIILIGMEVZKYSOYRPH\r\n" + "SFDSCSMLLNARCCGCBJOGZAEQTGNGSFAQIXLPDBSWZDTYVASYYPVBRFBTIAGGWONGSVKCJDBBLYKAIOXUATGMALZXFOHZFTXALCFU\r\n" + "CUSSTLCRYPDTFSFJFENKJWTEBOBEPLSNXLALQWCKSLVMZQDJITHZKVCCQXTEXOSVAUFYAZXJUOAPPVEEWOIIMOSZZMCOQBRUXWKG\r\n" + "PDOFSCKKJJTRYRWGLEZODQTJSIMXIAOLNMLPHBAYLPTTLPYWILSEIIQVSXNHIJEORVCNJHYXRBIZZJTADGMRTSXVRXYGVQQNUEIC\r\n" + "IHNJOQXUXTXFPALCHOELNVMWDWQTEARUKPIFWXJSMWZLMNLAODUTKNZDYRFRLGBLIBGIBXJBOYMLYLANQIAORORYKSJPOOOAMVRN\r\n" + "IWIUHLYJKTQGVJBDPROSRGZUFITDIBCDPICNEFIGHWGSROWBYKUCLCQYLJXLHLXSCTJWKDLHHMLDBZCVDKPXYYASHUUMUJMVSXAD\r\n" + "GXOYXQFEBFIEJJLHBNGSYALOUXNQBXXZAAZJXENJJVVGFVHOTKSLEGLJVSJCQHSSZFEIOGBOGWSPIRENQAAWRQFBEFEXBKGMSTRC\r\n" + "PYIANSGMNKBCDPHWDUPKICQEUDNZPNGRUJYSZIRLXGXXITAFBCANGDLVAQLDPVTJNSAUZMBBNOBBOERSHQIOLBVTSPPJKVCMXUBS\r\n" + "IKMDIYSNCJZKJKJQMTIKEPRUNAHJUSWJHSLWIVWHYAYLOIOGSZVWKQWXZDBPHWZRAIPMXDJHBIISVJWVEVZAEGAKCYYMNZARBZPC\r\n" + "DLDFVQDFDMVHYVOWEKMFKWUXLTPWIVKPRZZXOLMDAPAIQEKJHCHYAGJDBOFWDGNEGQGOOKWSKLTLREMGGTVJFHAIBCQKNZVRCZYS\r\n" + "FBQASGNCCBBGNKJHCDBTGBIIWKMPHDABKEWDEPYEAVKNMPATUZZUOEHGUGAZNECSGUCIIJPMMRAMTVADMTCRJCBWDLWWFNFOWMVZ\r\n" + "XFJFBGDAVGGAIZHAUIYENDZTRUWHPQUFWCHOXNCWYNAWVPLBLNQKQDTKQQKXNFXCTBGRWUZFHNRBDNLNKQVOLLGBBJQIYOBCEIKO\r\n" + "CURAGWXMLYBSIZLAXFONZZMQMRNNSRQKRHQGFGZUTLONAYRKSSOWAMKZBSGOOYQDPTBHGPBNQEDCZHRTOXREOFJEKJVIZXZBCJPN\r\n" + "KGYBZTZRKOGBETJRUWRNUCIFKIMCZGYTZLCZYGCGKVZRJIFZQIQPTCPPUHYWIXBOFFGSGSAIMNGKKUUROAVNJUQQNSWJRZIZEHAF\r\n" + "DDAOBVCPOVODVJFLSNPJXHWQBHILWZAHQQMTQASNADZLZNXJLJMFCOUWOZJCMVVTYCKTUBABWLCEBNYWAMOLNBQQYBRUJCQCZALE\r\n" + "TVVRPMYFIKINHIUEJBDLTCUMMUWICIUVCZNIQIUEWVAHLANQIAONMEYJWPDAFXVNOSOFDOCESSLGZPTJINBUAFWWWMPTYALZIGVD\r\n" + "DCZGKILMBFXIQQFEKJBIUDEMIFCANVGNYZAYSQFMNNQFEPZFUUVGTBKSMDXITBLANQIAOQUKTPNYPOWSQQYWWMJHSDYVFDJYXBAF\r\n" + "VGYXAMDRRZWVIHNQPZZWRNWBTROOJOLNUGXBILZKQEGIQSYGKZGODPWBJSCMRRWSSQURUFIAFQGEZLGZNOEQMNQEYUKPEQPPVAMO\r\n" + "SYSFUAJFKIPUJVQSZRWQCJYAUMLDDNOKODDXIEQIFLANQIAOZFUNKUBVDBLMJOAUTVCZVLKJRQIORQPGAVCEYVNYUZHXILHERYEC\r\n" + "GJEKWEKIJNIWUXZNVIWIAANHIOSOLATSQFSSCTAKESUTSPPYFHEHLVLIBJZEEBCOWMNHFTZMAPKFUPNFLTFFJQRVJHAKDVMGGUIX\r\n" + "KAKXXNKSOAIQNALLWKWGVACYWBQEVTFSEUCYRORQTHWFUJFLQHONWZEKPLSNPRPBOMOFFCPMKXFZBKIERBKDYFKYUEYVYRPMOAQI\r\n" + "WNICDLQKZXGTKDLIEFBGELGJOAIQNALXZLGGDQIBVEULDPBWUJNTYOKFBPGMAWRRUJPPIGYCNYURNOSQRIRBAZAGWWDUHAAZQWPT\r\n" + "KFXZQXRMKSBUXWOUVVHSJWTLKZELGXMMAIDSJIWGCJPCBWZIEKMNUPUAFHTUMOZKJWVTIAQNOHELEMWGKJHKPNJVSRVHAUFXBUOU\r\n" + "XOWCZJYQLXJRUOOYSKDLDXKWTTJBYBTLKSWRUYPOYTPBGUJXBMRWNELBWADCSZDAEEFGPVRHNNLBFDDXNPDXLKQUSJAZDEUDBMBD\r\n" + "QIKYEKMVUHGGWZDKXFVQQNECZOAWCFUBHQMEPEPKEFSDBAYJQOSGAIHRBRAUKLQRANKMTTIOJDDXAEWTQHIYSGRRMEFTNNWCLZSI\r\n" + "ZFUQAQCSFNVUQMKUQWBWFQIEQVVXPOSVIDTUOBLLTGHQKEMSUWWHWRISLGRDPPQPZBANSGDWXKNYTKMWECPMPDYSCJZXPUKPWGYI\r\n" + "CNGVLBSCBHRLJARWSRENGHYYQDKRATERCPEAOPAJZUMOYIDHVPDMQPKKHCBAMRBGEIEXXJALMCXKPUGXYVINRORFYURXAMOJCBZQ\r\n" + "YJHHAWESCLMDIHVYMLAJZQSYTDEURWYPOLJCAKIKSATGVIALBLWPPKDEGSPMRLDBQNVPPCLQXKUQLQJERMYFGAETUATEBQZUMGUN\r\n" + "NBWUBVXYDFPLPJYLIDFVTVKKGFWMXVINLJUDUPABTSBJAJENZSXIMUJQWPEZTAVDMBBHFYTJKYFXIXQTBTTQIKQXQDPWYNMXRQDJ\r\n" + "OGWLZQUBJJHAQNPVRGHGPNMMJPIDGANYEEDWYPOLKLNEPYSRTQYCJLSWFRJRRGGSNSDHIXYYSNAKKBWQDDGYYMOGPUXQEUSAPSOU\r\n" + "CLLSELRVFZUFYVTJQKCQHNICMERWQFQNPVRPIIYKHZWJYJAFCLNSZXUHSPOZWQUMJHLKKYJENVZOCSWCTPYWIZONUUCLSUROGAYS\r\n" + "AZGNIMXPLPCEPULRRBHHQOBELHJZPUQAMWUASVKDXVEWAOFMAYSJFXHCNEUXUQWUESFBRUFZQLKKWHCHKOPLECCBYSLECAEZIMMI\r\n" + "TUUEOCEBAUKWLTSYJJPLZTIARAOZXKYYWIOXBBTZZCSAULKNEJWVQXIKUWBIWVHGNTHVBAWAVPGLHSDJDLPVHHHUNVSFKXARXLVQ\r\n" + "EMVDFSLANQIAOPTLFLFRKGNUZCTXWCAXHECTZFHWUFENRGQICHTYLSHZWIEGLNVDJZOMTKAAUWOHVOVOCTUKOSINSAYIAEUYORNA\r\n" + "VGPRMLCAQZIPRFQOZMEFTQZYVOTVFNVOIQSJCIPPQXQKJIXICUIGMHAJJMSXENCBQFIJHNZXIQMWACKDKQSEWWKMLOAUPFHAZGRY\r\n" + "SQWQMRSQBGGKYKGWEZYRIHWGNXRPOUMFSFGTYDLUDWPWAVQORTMQUXWKUQVNMDPWQFIZPOIHCJATODRQGZDMQXZVNXXVEJNGWZOM\r\n" + "PVBGZSQPCELDIWDHOQWAUHILGLPYRIICTLFSOYKQZYZOCIZPTECSWOODGGBDTSGIMYGMVPJPRPEVWOOKYFWRGXHWUCRQNYJEMSYL\r\n" + "XWOFXFVDXPTHYTCEGMODCILAHYBREZVVHOUPZKCNHUEVPMKHUBNRPFMWXVQACVZCALZLYMZSBLCEASPMIEFOTGKMPGWYQADSNDPR\r\n" + "QPHAVLZDZLKIEISFLLVWXAVBZLZIJRHGROUVGXRDLUJAXNHBBZYNCVERJGSKLWZEKGJBCWMSMLYIHZFFMIOGVIMZQBSRHQWAADYN\r\n" + "MNXEGTDXCDKIUDOISQXEUJWETPELKBCYFSDNJQWNNBPYMWBUPQBAAINMYZOYCEGNLFNNHZFEMSQVXJJGWBCRAVKZFWFBKMBRVBFD\r\n" + "HKACSZIUWUXLWKFPKOCUQJEPQDZCMUJFLVCLIOQQRVKSWFIAKNHMRLNJTKGVNTGLCVPVMBLJANOBCXUGVWBJYSIXZQVAVFWILWFB\r\n" + "QWNLTPMCYHRSKVHXLONRANWKWXUTHYQLIOFKGDBMSWDRCYRKVSAGGRJMWQYQFLMUIGGCLAUQAACTYLPZEOJBHMWRKHCRXGTGRMUP\r\n" + "CPQKJRBLYDNPUGHCRBVYBAIRVCAWLBWVWCMKNBIRKJOUGYQEBQRHDSTWXDIWGRVMLIJFBWHLHCDAAVUDLZSCGQNOUXVUIVIZZZMD\r\n" + "NMHGYPFUUDWKQGTAKKGCDFJFYJFNRZVXDPGZEAMWQVQZODKTXHIYFVKJSSAWVHYCUCZMLLBPXTILDYJQEMWDRUFKISOUVPUDTYPB\r\n" + "FDAQUBXHUJYTAYNWVIJNUSQDTQDEMUAPWXRYUWONTBDZCHZOUEGPMWEZTQWWSHAYOBWVTDIMZYNVNZKUHOFCQKPHJXWNRCGUJEKO\r\n" + "WSDAUGUTVWCVHEMOIRJJGTANUWTSAIXXEVZTBDHPGSRHHVWCDZVZYRJTLONIJVXEATHQXOUKBIGZONFRSZIOGWNTYAJYLQCGEOWY"; String all = string.replaceAll("\r\n", "");//字符串去换行符 char[] cs = all.toCharArray();//字符串转成字符数组 int b=0;//字符数组的下标 char[][] array=new char[100][100];//创建100行100列二维数组 //遍历二维数组，将字符串数据放入二维数组中 for (int i = 0; i <100; i++) { for (int j = 0; j <100; j++) { array[i][j]=cs[b];//将字符数组的字符放入二维数组中 b++;//字符串下标自增 } } int count=0;//数据中LANQIAO总个数 //1.从左到右横向查找LANQIAO for (int i = 0; i <100; i++) { for (int j = 0; j <94; j++) { //因为LANQIAO七个字符，创建(i,j)到(i,j+6)七个元素的char数组 char[]cd1= {array[i][j],array[i][j+1],array[i][j+2],array[i][j+3],array[i][j+4],array[i][j+5],array[i][j+6]}; //使用char数字创建字符串 String s1=new String(cd1); //产生的字符串与”LANQIAO”进行匹配，相等则个数+1 if (s1.equals("LANQIAO")) { count++; } } } //2.从右到左横向查找LANQIAO for (int i = 0; i<100; i++) { for (int j = 99; j>=6; j--) { //因为LANQIAO七个字符，创建(i,j)到(i,j-6)七个元素的char数组 char[]cd1= {array[i][j],array[i][j-1],array[i][j-2],array[i][j-3],array[i][j-4],array[i][j-5],array[i][j-6]}; String s1=new String(cd1); if (s1.equals("LANQIAO")) { count++; } } } //3.从上到下纵向查询LIANQIAO for (int i = 0; i <94; i++) { for (int j = 0; j <100; j++) { //因为LANQIAO七个字符，创建(i,j)到(i+6,j)七个元素的char数组 char[]cd2= {array[i][j],array[i+1][j],array[i+2][j],array[i+3][j],array[i+4][j],array[i+5][j],array[i+6][j]}; String s2=new String(cd2); if (s2.equals("LANQIAO")) { count++; } } } //4.从下到上纵向查询LIANQIAO for (int i = 99; i>=6; i--) { for (int j = 0; j <100; j++) { //因为LANQIAO七个字符，创建(i,j)到(i-6,j)七个元素的char数组 char[]cd2= {array[i][j],array[i-1][j],array[i-2][j],array[i-3][j],array[i-4][j],array[i-5][j],array[i-6][j]}; String s2=new String(cd2); if (s2.equals("LANQIAO")) { count++; } } } //5.从左上到右下倾斜查询LIANQIAO //因为LANQIAO七个字符，创建(i,j)到(i+6,j+6)七个元素的char数组 for (int i = 0; i <94; i++) { for (int j = 0; j <94; j++) { char[]cd3= {array[i][j],array[i+1][j+1],array[i+2][j+2],array[i+3][j+3],array[i+4][j+4],array[i+5][j+5],array[i+6][j+6]}; String s3=new String(cd3); if (s3.equals("LANQIAO")) { count++; } } } //6.从左下到右上倾斜查询LIANQIAO for (int i = 99; i>=6; i--) { for (int j = 0; j <94; j++) { //因为LANQIAO七个字符，创建(i,j)到(i-6,j+6)七个元素的char数组 char[]cd3= {array[i][j],array[i-1][j+1],array[i-2][j+2],array[i-3][j+3],array[i-4][j+4],array[i-5][j+5],array[i-6][j+6]}; String s3=new String(cd3); if (s3.equals("LANQIAO")) { count++; } } } //7.从右上到左下倾斜查询LIANQIAO for (int i = 0; i<94; i++) { for (int j =99; j>=6; j--) { //因为LANQIAO七个字符，创建(i,j)到(i+6,j-6)七个元素的char数组 char[]cd3= {array[i][j],array[i+1][j-1],array[i+2][j-2],array[i+3][j-3],array[i+4][j-4],array[i+5][j-5],array[i+6][j-6]}; String s3=new String(cd3); if (s3.equals("LANQIAO")) { count++; } } } //8.从右下到左上倾斜查询LIANQIAO for (int i = 99; i>=6; i--) { for (int j = 99; j>=6; j--) { //因为LANQIAO七个字符，创建(i,j)到(i-6,j-6)七个元素的char数组 char[]cd1= {array[i][j],array[i-1][j-1],array[i-2][j-2],array[i-3][j-3],array[i-4][j-4],array[i-5][j-5],array[i-6][j-6]}; String s1=new String(cd1); if (s1.equals("LANQIAO")) { count++; } } } System.out.println(count); } }

• 任务：大家去熟悉和练习一下Java的IO流 Input 和 Output

小蓝有一个数字矩阵，里面只包含数字0和2。小蓝很喜欢2020，他想找 到这个数字矩阵中有多少个2020。小蓝只关注三种构成2020的方式：1.同一行里面连续四个字符从左到右构成 2020；2.在一条从左上到右下的斜线上连续四个字符；3.从左上到右下构成 2020。例如，对于下面的矩阵：....共有多少个2020

//将数据放入file文件中，使用IO流的方式读取文件数据 public static void main(String[] args) throws Exception { //1.字符流读取数据 FileReader in=new FileReader("C:\\Users\\Administrator\\Desktop\\a.txt"); //2.设置读取变量 int line=0; //3.因为有换行符的存在，先将数据放入字符串中，创建字符串s String s=""; //4.IO流读取数据 while ((line=in.read())!=-1) { //读取的整数类型数据转成字符类型 char d=(char)line; //只将0和2的数据放入字符串中 if(d=='0' || d=='2') { s+=d; } } in.close(); //5.创建字符串索引 int b=0; //6.创建对应的二维数组 char[][] cs=new char[300][300]; //7.将字符串转成字符数组 char[] array = s.toCharArray(); //8.遍历二维数组，将字符数组数据放入二维数组中 for (int i = 0; i <300; i++) { for (int j = 0; j <300; j++) { cs[i][j]=array[b]; b++; } } //设置2020的总个数变量 int count=0; //1.纵向从上到下构成 2020 for (int i = 0; i <297; i++) { for (int j = 0; j <300; j++) { //因2020有4个字符组成，创建(i,j)到(i+3,j)字符的数组 char[] cs1= {cs[i][j],cs[i+1][j],cs[i+2][j],cs[i+3][j]}; //通过char数组创建字符串 String s1=new String(cs1); //产生的字符串与”2020”进行比较，相等则总个数+1 if (s1.equals("2020")) { count++; } } } //2.在一条从左上到右下的斜线上连续四个字符 for (int i = 0; i <297; i++) { for (int j = 0; j <297; j++) { //同1 char[] cs1= {cs[i][j],cs[i+1][j+1],cs[i+2][j+2],cs[i+3][j+3]}; String s1=new String(cs1); if (s1.equals("2020")) { count++; } } } //3.横向从左到右构成 2020 for (int i = 0; i <300; i++) { for (int j = 0; j <297; j++) { //同1 char[] cs1= {cs[i][j],cs[i][j+1],cs[i][j+2],cs[i][j+3]}; String s1=new String(cs1); if (s1.equals("2020")) { count++; } } } //输出总个数count System.out.println(count); }

2017年Java组c组第四题:承压计算

X 星球的高科技实验室中整齐地堆放着某批珍贵金属原料。

每块金属原料的外形、尺寸完全一致，但重量不同。 金属材料被严格地堆放成金字塔形。

7

5 8

7 8 8

9 2 7 2

8 1 4 9 1

8 1 8 8 4 1

7 9 6 1 4 5 4

5 6 5 5 6 9 5 6

5 5 4 7 9 3 5 5 1

7 5 7 9 7 4 7 3 3 1

4 6 4 5 5 8 8 3 2 4 3

1 1 3 3 1 6 6 5 5 4 4 2

9 9 9 2 1 9 1 9 2 9 5 7 9

4 3 3 7 7 9 3 6 1 3 8 8 3 7

3 6 8 1 5 3 9 5 8 3 8 1 8 3 3

8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9

8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4

2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9

7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6

9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3

5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9

6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4

2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4

7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6

1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3

2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8

7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9

7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6

5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1

X X X X X X X X X X X X X X X X X X X X X X X X X X X X X X

其中的数字代表金属块的重量（计量单位较大）。最下一层的 XX 代表30台极高精度的电子秤。假设每块原料的重量都十分精确地平均落在下方的两个金属块上，最后，所有的金属块的重量都严格精确地平分落在最底层的电子秤上。电子秤的计量单位很小，所以显示的数字很大。工作人员发现，其中读数最小的电子秤的示数为：2086458231。请你推算出：读数最大的电子秤的示数为多少？

//又是一个明确了行和列的数据，因为换行符与空格的存在，现将数据放入字符串中，然后去除换行符与空格，然后放入二维数组中 import java.util.Scanner; import java.math.BigDecimal; public class Main { public static void main(String[] args) { //将数据放入字符串中 String s=" 7 \r\n" + " 5 8 \r\n" + " 7 8 8 \r\n" + " 9 2 7 2 \r\n" + " 8 1 4 9 1 \r\n" + " 8 1 8 8 4 1 \r\n" + " 7 9 6 1 4 5 4 \r\n" + " 5 6 5 5 6 9 5 6 \r\n" + " 5 5 4 7 9 3 5 5 1 \r\n" + " 7 5 7 9 7 4 7 3 3 1 \r\n" + " 4 6 4 5 5 8 8 3 2 4 3 \r\n" + " 1 1 3 3 1 6 6 5 5 4 4 2 \r\n" + " 9 9 9 2 1 9 1 9 2 9 5 7 9 \r\n" + " 4 3 3 7 7 9 3 6 1 3 8 8 3 7 \r\n" + " 3 6 8 1 5 3 9 5 8 3 8 1 8 3 3 \r\n" + " 8 3 2 3 3 5 5 8 5 4 2 8 6 7 6 9 \r\n" + " 8 1 8 1 8 4 6 2 2 1 7 9 4 2 3 3 4 \r\n" + " 2 8 4 2 2 9 9 2 8 3 4 9 6 3 9 4 6 9 \r\n" + " 7 9 7 4 9 7 6 6 2 8 9 4 1 8 1 7 2 1 6 \r\n" + " 9 2 8 6 4 2 7 9 5 4 1 2 5 1 7 3 9 8 3 3 \r\n" + " 5 2 1 6 7 9 3 2 8 9 5 5 6 6 6 2 1 8 7 9 9 \r\n" + " 6 7 1 8 8 7 5 3 6 5 4 7 3 4 6 7 8 1 3 2 7 4 \r\n" + " 2 2 6 3 5 3 4 9 2 4 5 7 6 6 3 2 7 2 4 8 5 5 4 \r\n" + " 7 4 4 5 8 3 3 8 1 8 6 3 2 1 6 2 6 4 6 3 8 2 9 6 \r\n" + " 1 2 4 1 3 3 5 3 4 9 6 3 8 6 5 9 1 5 3 2 6 8 8 5 3 \r\n" + " 2 2 7 9 3 3 2 8 6 9 8 4 4 9 5 8 2 6 3 4 8 4 9 3 8 8 \r\n" + " 7 7 7 9 7 5 2 7 9 2 5 1 9 2 6 5 3 9 3 5 7 3 5 4 2 8 9 \r\n" + " 7 7 6 6 8 7 5 5 8 2 4 7 7 4 7 2 6 9 2 1 8 2 9 8 5 7 3 6 \r\n" + " 5 9 4 5 5 7 5 5 6 3 5 3 9 5 8 9 5 4 1 2 6 1 4 3 5 3 2 4 1 \r\n"+ "0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0"; String all1 = s.replaceAll("\r\n", "");//字符串去掉全部的换行 String all = all1.replaceAll(" ", "");//字符串去掉全部的空格 char[] cs = all.toCharArray();//字符串转成char数组 double[][] a=new double[30][];//创建double二维数组 int b=0;//char数组的下标 for (int i = 0; i < a.length; i++) {//将字符串的数据放入二维数组中 a[i]=new double[i+1];//设置数组每一行的列数 for (int j = 0; j < a[i].length; j++) { a[i][j]=cs[b]-'0';//char类型减去'0',得到int类型的数据 b++;//cs数组下标自增 } } for (int i = 0; i < a.length; i++) { for (int j = 0; j < a[i].length; j++) { if(i==0) {//第一行第一列位置的重量值为本身 a[i][j]=a[i][j]; }else if(j==0&&i>=1) {//第一列其他位置的重量值=本身重量+前一行同一列的重量/2 a[i][j]+=(a[i-1][j]/2.0); }else if (j==i && j>=1) {//行列相同其他位置的重量值=本身重量+前一行前一列的重量/2 a[i][j]+=(a[i-1][j-1]/2.0); }else{//剩余位置重量=本身重量+前一行前一列的重量/2+前一行同一列的重量/2 a[i][j]+=(a[i-1][j-1]/2.0+a[i-1][j]/2.0); } } } double min=a[29][0];//最小值的初始值为30行第一个元素 double max=a[29][0];//最大值的初始值为30行第一个元素 for (int i = 0; i <30; i++) { if(min>a[29][i]) { min=a[29][i];//重新赋值 } if(max<a[29][i]) {//重新赋值 max=a[29][i]; } } //因为数据超出了int与long的范围，则使用BigDecimal对象获取超大数值 BigDecimal bd = new BigDecimal((2086458231/min)*max); System.out.println(bd.toString()); } }