蓝桥31日冲刺 第一天

蓝桥31天冲刺 第一天

第一题 纯质数

题目描述

本题为填空题，只需要算出结果后，在代码中使用输出语句将所填结果输出即可。

如果一个正整数只有 11 和它本身两个约数，则称为一个质数（又称素数）。

前几个质数是：2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37, · · ·2,3,5,7,11,13,17,19,23,29,31,37,⋅⋅⋅ 。

如果一个质数的所有十进制数位都是质数，我们称它为纯质数。例如：2,3, 5, 7, 23, 372,3,5,7,23,37 都是纯质数，而 11, 13, 17, 19, 29, 3111,13,17,19,29,31 不是纯质数。当然 1, 4, 351,4,35 也不是纯质数。

请问，在 11 到 2021060520210605 中，有多少个纯质数？

题解

public class Main{
    static boolean check(int x) {//判断十进制数位是不是符合要求
        while(x!=0) {
            if(x%10==1||x%10==4||x%10==6||x%10==8||x%10==9||x%10==0) return false;
            x/=10;
        }
        return true;
    }
    static boolean zhi(int x) {//判断是不是质数
        for(int i=2;i<x;i++) {
            if(x%i==0) return false;
        }
        return true;
    }
    public static void main(String[] args){
        int res = 0;
        for(int i=2;i<=20210605;i++) {
            if(check(i)&&zhi(i)) {
                res++;
            }
        }
        System.out.println(res);
    }
}

思路：

求解纯质数，首先要明白什么叫做纯质数，因为此题是填空题，所以推荐使用暴力解法，用两个方法分别筛选出质数和纯质数，最后将得到的结果输出即可。

第二题 最少砝码

问题描述

你有一架天平。现在你要设计一套砝码，使得利用这些砝码可以称出任意 小于等于 N 的正整数重量。

那么这套砝码最少需要包含多少个砝码？

注意砝码可以放在天平两边。

题解：

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        int N = scanner.nextInt();
        scanner.close();
        int amount = 1;
        int weight = 1;
        int maxWeight = 1;

       while (N > maxWeight){
            amount++;
            weight = weight *3;
            maxWeight = weight + maxWeight;

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

思路

最少砝码为题主要是找规律，多试几个数你就会发现，每增加一个砝码，它的重量是前一个砝码的三倍，而可以称的最大重量则是上一次的最大重量加上这一次新增砝码的重量，有了这个规律以后，可以很容易求出所需砝码的数量。

第三题 灌溉

题目描述

小蓝负责花园的灌溉工作。

花园可以看成一个 nn 行 mm 列的方格图形。中间有一部分位置上安装有出水管。

小蓝可以控制一个按钮同时打开所有的出水管，打开时，有出水管的位置可以被认为已经灌溉好。

每经过一分钟，水就会向四面扩展一个方格，被扩展到的方格可以被认为已经灌溉好。即如果前一分钟某一个方格被灌溉好，则下一分钟它上下左右的四个方格也被灌溉好。

给定花园水管的位置，请问 kk 分钟后，有多少个方格被灌溉好？

题解：

import java.util.LinkedList;
import java.util.Queue;
import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        //1、定义一个方向数组
        int[][] direction = {{0,1},{0,-1},{1,0},{-1,0}};
        //接收输入的参数
        Scanner in = new Scanner(System.in);
        int m = in.nextInt();// 花园的长
        int n = in.nextInt();// 花园的宽

        int[][] garden = new int[m][n];//定义代表花园的数组

        int tap =  in.nextInt();// 水管的数量
        for (int i = 0; i < tap; i++) {
            int r = in.nextInt();
            int c = in.nextInt();
            garden[r-1][c-1] = 1;
        }

        int time = in.nextInt();// 灌溉时间
        //调用bfs方法求解问题
        int res = watering(garden,tap,time,direction);
        System.out.println(res);
    }

    //4、定义bfs方法
    static public int watering(int[][] garden,int tap,int time,int[][] direction){
        //如果时间小于零，直接返回水龙头的数量
        if (time <= 0){
            return tap;
        }
        int count = 0;
        int n = garden.length;
        int m = garden[0].length;
        //把最初已经灌溉过的也就是水龙头所在的位置加入到队列
        //2、定义一个队列
        Queue<Node> q = new LinkedList<>();
        for (int i = 0; i < n; i++) {
            for (int j = 0; j < m; j++) {
                if (garden[i][j]==1){
                    q.add(new Node(i,j));
                }
            }
        }
        //接下来从队列里取出已经灌溉过的点，然后bfs扩散
        while (time>0){
            int size = q.size();
            for (int i = 0; i < size; i++) {
                Node node = q.poll();
                int col = node.col;
                int row = node.row;
                //利用方向数组扩散
                for (int j = 0; j < 4; j++) {
                    int dx = row + direction[j][0];
                    int dy = col + direction[j][1];
                    //判断出不出界
                    if (isArea(dx,dy,n,m)){
                        garden[dx][dy] = 1;
                        q.offer(new  Node(dx,dy));
                    }
                }
            }
            time--;
        }
        //计算灌溉了多少个方格
        for (int i = 0; i < garden.length; i++) {
            for (int j = 0; j < m; j++) {
                if (garden[i][j]==1){
                    count++;
                }
            }
        }
        return count;
    }

    //判断界限
    static public boolean isArea(int x,int y,int m,int n){
        return x>=0 && x<m && y>=0 && y<n;
    }
}
//3、定义一个类用来存储点
class Node{
        int row;
        int col;
        public Node(int row,int col){
            this.row = row;
            this.col = col;
        }
}

思路

采用bfs算法，我们可以将花园的大小定义成一个二维数组，然后利用队列来存储已经灌溉过的土地，这期间为了方便存储这些点，我们可以定义一个节点类，专门用来存储坐标，做完这些后我们用循环来遍历队列中已经灌溉过的土地，再将这些土地通过bfs向四周扩散，再将新灌溉的土地加入到队列当中去。最终我们在时间结束以后，遍历整个花园，既可得到在规定时间内灌溉了多少土地。