2020年蓝桥杯国赛JavaB组部分题解

前言

开始准备2021年蓝桥杯大赛了，自然真题是最好的练手题，这里只收录有能力解出的题，而在比赛的时候没能解出的题…其中代码可能不是全部都是自己写的，但必须是全部弄明白的

B题 扩散

题目描述

小蓝在一张无限大的特殊画布上作画。
这张画布可以看成一个方格图，每个格子可以用一个二维的整数坐标表示。
小蓝在画布上首先点了一下几个点： (0; 0), (2020; 11), (11; 14), (2000; 2000)。
只有这几个格子上有黑色，其它位置都是白色的。
每过一分钟，黑色就会扩散一点。具体的，如果一个格子里面是黑色，它
就会扩散到上、下、左、右四个相邻的格子中，使得这四个格子也变成黑色
（如果原来就是黑色，则还是黑色）。
请问，经过 2020 分钟后，画布上有多少个格子是黑色的。

答案提交

这是一道结果填空的题，你只需要算出结果后提交即可。本题的结果为一个整数，在提交答案时只填写这个整数，填写多余的内容将无法得分。

解一

这个解法是直接暴力，也是我在考场的做法，无奈考场机房跑不起来，直接堆空间爆炸，但是在我自己电脑上却跑出来了，赛后我查找原因发现是因为考场的电脑是jdk1.6 ，而我电脑上的jdk是1.8，不同jdk版本的jvm大小是不一样的,我在机房实验的时候还发现同样规格的二维数组，int型会报空间，而boolean型却不会爆空间，当时我还在纳闷，后来结合所学知识一想，int和boolean所占字节大小是不同的。
我的做法是直接new一个二维数组大小是6061*6061，目的是将给出的四个点移到画布中间，从而经过2020次循环，所有的点都还在数组中。每次循环判断是否是黑点就行了，一个细节是不能重复判断，在一次循环中每个点只能判断一次，即就是有可能在前一次的扩散中使某一个点变成黑色，结果到判断这个点的时候，将其周围的点也染黑了，这样是不行，很多这类型的题都是这样，像我之前校赛模拟赛的时候，遇到一道长草的题，也是这样，总之一回合就只能变一次，要限制其不能由于上次的变化，在同一次循环中又变化从而影响其他点，当然题意不同，又得另当别论。

/**国赛题
 * @author 毛毛虫
 * @create 2020-11-16 12:50
 */
public class _2020_02 {
    public static void main(String[] args) {
        int arr [][] = new int[6061][6061];//如果堆空间爆了咋办
        arr[2020][2020] = 1;
        arr[4040][2031] = 1;
        arr[2031][2034] = 1;
        arr[4020][4020] = 1;
        int k =1;//使得每次循环的判断条件都不一样，从而在一次循环中不会误判
        while(k<=2020){
        for (int i = 0;i<arr.length;i++) {
            for (int j = 0; j < arr.length; j++) {
                if (arr[i][j] == k) {
                    if(arr[i-1][j]!=k) {
                        arr[i - 1][j] = k + 1;//将其标记为下一次判断的标记，这样在这次判断中就不会再判断到。对于上和左这两个方向没有影响，因为在判断该点是其上和其左一定是已经判断过了，但是为了不影响布局，还是将其置为k+1
                    }
                    if (arr[i+1][j]!=k) {
                        arr[i + 1][j] = k + 1;
                    }
                    if (arr[i][j-1]!=k) {
                        arr[i][j - 1] = k + 1;
                    }
                    if (arr[i][j+1]!=k) {
                        arr[i][j + 1] = k + 1;
                    }
                        arr[i][j] = k + 1;
                }
            }
        }
        k++;
        }
        int sum =0;
        for (int i =0 ;i<arr.length;i++){
            for (int j = 0;j<arr.length;j++){
                if (arr[i][j]==2021){//判断是否是黑点
                    sum++;
                }
            }
        }
        System.out.println(sum);//sum = 20312088;
    }
}

解二

该解是网上的，不会爆堆空间，运用的是集合，使用set1和set2反复替换，一个boolean数组用来记录是否是黑点。in方法用于向四周扩散，并将其加入set2，然后将整个set2加入到set1中，下次循环又从set1中得到数据用来构造set2，每次循环都会在合适的时候清空set1和set2，避免影响判断。循环结束后，从set1中取出坐标到boolean数组中标记黑点，最后通过遍历boolean数组来得到黑点数

import java.util.HashSet;
public class _2020_02_2 {
    public static HashSet<Integer> set1=new HashSet<Integer>();
    public static HashSet<Integer> set2=new HashSet<Integer>();
    public static boolean center[][]=new boolean[10000][10000];
    public static void in(int n){
        int x=n/10000;
        int y=n%10000;
        center[x][y]=true;
        for(int i=-1;i<2;i++){
            for(int j=-1;j<2;j++){
                if(Math.abs(i+j)==1&&!center[x+i][y+j]){
                    set2.add((x+i)*10000+y+j);
                }
            }
        }
    }
    public static void main(String[] args) {
        set1.add(50005000);
        set1.add(70205011);
        set1.add(50115014);
        set1.add(70007000);
        for(int i=0;i<2020;i++){
            for(int x:set1){
                in(x);
            }
            set1.clear();
            set1.addAll(set2);
            set2.clear();
 
        }
        for(int n:set1){
            int x=n/10000;
            int y=n%10000;
            center[x][y]=true;
        }
        long ans=0;
        for(int i=0;i<10000;i++){
            for(int j=0;j<10000;j++){
                ans+=center[i][j]?1:0;
            }
        }
        System.err.println(ans);
    }
}

C题 阶乘约数

这道题说来惭愧，考试前几天我特意看了数论，这个题中用到的两个定理，我也学习了，到了考场上只觉得形似，却不知道怎么运用，导致我居然特傻逼地去硬算，这个代码还是我们老师给我们讲题的时候写的，我补了注解，思路过程全写在代码注解中了。

package lanqiao;
/**计算100！的约数个数，代码思路：唯一分解定理+约数个数定理
 *  100！=100*99*98*97....*1
 *  计算出每个乘数的约数个数（需要使用唯一分解定理）
 *  再将每个乘数的约数个数+1相乘得到总的约数个数（约数个数定理）
 */
class Data{

    public int num;
    public int d;

    Data()
    {
        num = 0;
        d = 0;
    }

    Data(int d)
    {
        this.d = d;
        num = 0;
    }
}
public class _2020_03 {
        public static void main(String []args)
        {
            /*先构造100内的素数表，即代码中的arr[]
            下标：0，1，2，3，4.....26
              d：0，1，2，3，5.....97
            num: 表示这个数总共用到了多少次
            */
            Data arr[] = new Data[100];
            int i,j,num,t;
            num=1;
            //打表，1-100中的素数
            for(i=2;i<=100;i++)
            {
                for(j=2;j<i;j++)
                {
                    if(i%j==0){
                        break;
                    }
                }
                if(i==j) {
                    arr[num] = new Data(i);//d中储存的是该数的大小
                    num++;
                }
            }
            num-=1;//因为num是从1开始的，此时的num为26，但实际上1-100间的素数只有25个，所以减1
            for(i=2;i<=100;i++) {//
                /*
                开始计算各个素数在100！中出现的次数或者说有多少个该素数相乘
                （因为最后总约数个数时也是要讲相同底数的指数加在一起再计算，
                所以不如从一开始的时候就直接计算出现的次数），
                而后再根据约数个数定理即可算得100！的约数个数
                 */
                j=1;
                t=i;
                while(t!=1&&j<=num)
                {
                    if(t%arr[j].d==0)
                    {   //唯一分解定理
                        t=t/arr[j].d;
                        arr[j].num++;
                        j=0;
                    }
                    j++;
                }
            }

            for(i=1;i<=num;i++)
            {
                System.out.println(arr[i].d+"|"+arr[i].num);
            }

            long tt = 1;
            System.out.println(num);
            for(i=1;i<=num;i++)
            {
                tt*=1+arr[i].num;//约数个数定理
            }
            System.out.println(tt);
        }
}