5月26号，之前学了两天算法烦了，去学了几天鸿蒙，今天又回来看一下算法，距离6月1日国赛还有6天，哈哈真是等死咯......

一、蓝桥杯第13届国赛第1题填空题：重合次数

（半难不难，写编程难、手算就不难...）

思路：建议蓝桥杯填空题先不要从编程角度思考，直接算数学题，这题手算就行了，别编程......

什么时候分针秒针会相遇？很明显：分针指的数 = 秒针指的数，这时候会重合相遇

那么每一分钟，秒针要转1圈，就会跟分针相遇1次

那么一小时，分针只转1圈，秒针转60圈，按道理就可能会相遇60次

但是留意，在【59分】到【60分】这一分钟里，会在一分钟里分针秒针重合2次

所以实际上一小时里，分针秒针相遇次数应该是59次

那么只要把【秒针转动总圈数】-【小时数】就得出【分针秒针相遇次数】了

（还要判断一下最后的【秒针指的数】跟【分针指的数】是否一样，一样就+1，不一样就不管）

二、蓝桥杯第13届国赛第2题填空题：数数

（中等偏难）

这题我脑子卡屎，算了一下午，其实这里我陷入了几个误区，这里提出来以防大家做题时跟我一样：

（ 懒得看前面逻辑解释这些废话的，直接跳到目录下面——"多看几个例子就明白了：" ）

首先我们通过找规律能知道，一个数要求出它的质因子，就是通过不断除 “从2到这个数本身” 的数（而且要是素数才是质因子，才可以作为除数），然后每次除完的得数就是下一次计算的被除数，直到这个除法的结果是 “1” 为止，最后所有这些可以整除的除数都是质因子，例子：

260 / 2 = 130

130 / 2 = 65

65 / 2有余数、65 / 3有余数、65 / 4有余数、65 / 5 = 13

13 / 2有余数、13 / 3有余数、13 / 4有余数......直到 13 / 13 = 1

此时得数是 “1”，说明13自身就是一个质因子

因此除法到此为止，质因子是【2、2、5、13】

画图：

第一个误区

第一个误区就是来自上面的规律，质因子除数不需要每次都判断是不是素数

（因为记住【埃式筛法】和【欧拉筛法】求素数的定律：素数的倍数绝对不是素数！！！

也就是说，当我们当我们用上面的公式不断往下除的时候，被除数只会被素数的除数先除掉，因为不是素数的话早就在前面被素数分解了，不可能成为除数，例如：

260 / 2 = 130   2是素数

130 / 2 = 65     2是素数

65 / 2有余数不行，除数找下一个

65 / 3有余数不行，除数找下一个

65 / 4，4不是是素数，而且4已经被前面的两个素数“2”分解了，所以不可能让4成为除数

65 / 5 = 13      5是是素数

13 / 2有余数不行，除数找下一个

13 / 3有余数不行，除数找下一个

13 / 4，4不是是素数，而且4已经被前面的两个素数“2”分解了，所以不可能让4成为除数

......直到 13 / 13 = 1     13是素数

因此根本无需另写循环去判断这个【除数】是不是素数，之所以能作为质因子，就是因为质因子只能是素数，而通过这种不断地除法，只会自动得到素数的除数

第二个误区

不需要每次都从最小素数的2来作为当前除法公式的最小除数

因为当2除不了的时候就说明没得分解2了，只能分解下一个素数；那么下一次除法计算的除数直接拿上一次除法的除数，如果不行，再在这个除数的基础上+1，找下一个素数当除数，例子：

第三个误区

除了一直除到得数为 “ 1 ” 来求得所有质因子；还可以直接【判断当除数的平方大于被除数时，这个被除数就是最后一个可分解的质因子】

根据【埃式筛法】和【欧拉筛法】求素数的定律：素数的倍数绝对不是素数！！！

那么我们如果要在一个范围里找素数，可以先从2开始，然后把2的倍数全部筛选出去；

然后从3开始，把3的倍数全部筛选出去......

但是！注意！！以这个数为倍数进行筛选前，要判断这个数的平方是否大于当前序列最大的数，如果是，那么不用再筛选，当前序列剩下的所有数都是素数

别问为什么，我当初学的时候也不明白，你只需要记得是这么回事就行了，例子：

假设求【2 ~ 24】之间的素数，原始序列为：

2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24

以2素数为基础，筛选为2的倍数的数，2^2=4 <= 【24】，可以筛选

2  3  4  5  6  7  8  9  10  11  12  13  14  15  16  17  18  19  20  21  22  23 【24】

2  3  5  7  9  11  13  15  17  19  21【23】

然后以3素数为基础，筛选为3的倍数的数，3^2=9 <= 【23】，可以筛选

2  3  5  7  9  11  13  15  17  19  21 【23】

2  3  5  7  11  13  17  19 【23】

然后以5素数为基础，筛选为5的倍数的数，5^2=25 > 【23】，不可以筛选了！！！

所以【2 ~ 23】之间的素数是：2  3  5  7  11  13  17  19  23

那么换回到我们的题，虽然表面上看跟上面这个规则没有什么关系，但是我们细细分析，当我们不断用除法除下去，除到【当除数的平方大于被除数】的时候，就说明这个【被除数】是最后一个质因子（素数）了，就是我们上面的规则，我们还是举例说明：

假设一开始序列是：【2  3  4  5  6 ...... 260】

先判断：2^2=4 < 260

260 / 2 = 130

此时序列是：【2  3  5  ...... 130】

130 / 2 = 65

此时序列是：【2  3  5 ...... 65】

65 / 2不行，那么找下一个可整除的质因子

先判断：3^2=9 < 65

65 / 3不行，那么再找下一个可整除的质因子

先判断： 5^2=25 < 65         

65 / 5 = 13         

此时序列是：【2  3  5 ...... 13】

13 / 5不行         

先判断：5^2=25 > 13

那么就不用往下分解了

那么就可以理解为，照这样求质因子的除法除下去，会在筛选出素数的同时缩小最大数的范围

先以2为素数基础，筛选出2的倍数的数，同时把最大数范围不断缩小到65

再以5为素数基础，筛选出5的倍数的数，再把最大数的范围缩小到13

然后此时可暂时理解为【从2到......13的范围】筛选素数，但是5^2=25 > 13最大数，那就不用再筛选了

（当然我只是为了结合之前【埃式筛法】和【欧拉筛法】求素数的规则才这么说的，实际上【2到13】的素数是【2 3 5 7 13】，但是质因子是【2 2 5 13】）

总结：

当然你不愿意按照上面这么多废话来理解，那你就记住这三句话：

1、分解一个数的质因子，就从2开始不断往下除，每次除法中，可以整除的素数除数都是质因子

2、第一种情况是：一直除，除到最后得数是 “ 1 ”，那么这个 (被除数or除数) 就是最后一个质因子

3、第二种情况是：（除了1）当除数的平方大于被除数的时候，这个被除数就是这个序列最后一个质因子。

多看几个例子就明白了：

完整代码：（含详细注释）

public class 国赛_数数 {
    public static void main(String[] args){
        //这是统计一个数有几个质因子
        int count = 0;
        //这是统计【2333333 ~ 23333333】之间有几个数的质因子是12个
        int ans = 0;

        for (int i = 2333333; i <= 23333333; i++) {
            //首先让【2333333 ~ 23333333】的每一个数是“分解质因子的除法公式”的初始“被除数”
            int beichushu = i;
            //除数就从第一个最小的素数2开始
            int chushu = 2;

            //记得每次分解完一个数的质因子，要把count归零
            count = 0;

            //还要判断这个数的质因子是否超过12个了，超过去就舍弃、不要再循环下去
            boolean flag = true;

            //注意！注意！注意！外层循环这两个条件的意思是：
            //1、beichushu!=1，【除数 != 被除数】，就是还没除完
            // 当【除数 == 被除数】了，被除数 / 除数 = 1，那就除完了结束了（前面所有可以整除的除数都是质因子）
            //2、chushu*chushu <= beichushu，【除数的平方 <= 被除数】，就是除数还可以递增找下一个合适的质因子
            // 当【除数的平方 > 被除数】时，除数就不要递增了（因为这个被除数就是最后一个质因子了，它已经没有质因子了）
            while ( beichushu!=1  &&  chushu*chushu <= beichushu ){
                
                //然后这个循环才是【真正】进行除法公式分解质因子的循环
                //只要当前这个【除数】可以【整除被除数】的时候，就会一直除下去
                //直到这个【除数】不可以【整除被除数】时，退出循环，找下一个合适质因子作除数
                while ( beichushu%chushu==0 ){
                    count++;//符合一切条件，又可以整除，就统计+1质因子
                    //但是题目要的是12个质因子，多了就不符合要求
                    if(count > 12){
                        flag = false;
                        break;
                    }
                    //除法公式分解质因子
                    beichushu /= chushu;
                }
                
                //这里留意，超出12个质因子不符题意时，不只是退出里层的除法循环
                //而是要退出两层循环，直接排除这个数，i遍历下一个数
                if(!flag){
                    break;
                }
                
                //当这个【除数】不可以【整除被除数】时，就找下一个合适质因子作除数
                chushu++;
            }
            
            //如果是第一种情况，那么就是因为因为上面循环的条件，除法公式没有除完
            //但是其实它不用分解，因为它自己本身就是最后一个质因子,所以得加上它
            if(beichushu != 1){
                count++;//那就加上它
            }
            
            //当i遍历【2333333 ~ 23333333】内的这个数分解出了12个质因子
            //那就把【含12个质因子】的统计数+1
            if (count == 12){
                ans++;
            }

        }
        System.out.println(ans);
    }
}

（简略无注释版）

三、蓝桥杯第13届国赛编程第1题（简单）

我做烦了，就直接暴力搜索排列，【不确定】能否过大范围数据的循环，有好办法或者觉得有问题的可以私信我，这里我就直接放暴力搜索了，没什么好讲解的，大不了不要这几分了

import java.util.ArrayList;
import java.util.List;
import java.util.Scanner;

//输入样例：
//5 3
//L 3
//L 2
//R 1
//输出样例：
//2 3 4 5 1 


public class test {
    public static void main(String[] args){
        Scanner in = new Scanner(System.in);
        int N = in.nextInt();
        int M = in.nextInt();
        List<Integer> list = new ArrayList<>();
        for (int i = 0; i < N; i++) {
            list.add(i+1);
        }
        in.nextLine();
        for (int i = 0; i < M; i++) {
            String s = in.nextLine();
            String number = s.substring(2);
            int num = Integer.parseInt(number);
            //数字放左边开头，那就数组右移
            if(s.charAt(0)=='L'){
                for (int j = 0; j < list.size(); j++) {
                    if(list.get(j) == num){
                        for (int k = j; k > 0; k--) {
                            list.set(k,list.get(k-1));
                        }
                        break;
                    }
                }
                list.set(0,num);
            }else{//放右边开头，那就数组左移
                for (int j = 0; j < list.size(); j++) {
                    if(list.get(j) == num){
                        for (int k = j; k < list.size()-1; k++) {
                            list.set(k,list.get(k+1));
                        }
                        break;
                    }
                }
                list.set(list.size()-1,num);
            }
        }

        for (Integer integer : list) {
            System.out.print(integer + " ");
        }
    }
}

过两天更新下面的题，太多逼事了