第十四届蓝桥杯 三十天刷题 第十二天

📢📢📢哈喽大家好，今天是第12天了，距离省赛又近了一天，好紧张好紧张。

---

1. 🍏🍏🍏0 的个数🍏🍏🍏

📋问题描述

❓思路分享

🍏这道题我们只需要将n作为字符串来判断尾部0的个数即可！So easy！

📗参考代码

import java.util.Scanner;

/**
 * @ClassName _0的个数
 * @Author @浅夜
 * @Date 2023/3/15 20:14
 * @Version 1.0
 */

public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        char[] s = (n + "").toCharArray();
        int ans = 0;
        int i = s.length - 1;
        while(s[i] == '0'){
            ans++;
            i--;
        }
        System.out.println(ans);
    }
}

---

2. 🍄🍄🍄超级质数🍄🍄🍄

📋问题描述

❓思路分享

🍄这道题目看了别人的题解，但是调了调发现这个方法还是有问题，给它加了个数位倒过来再判断的好像还是不行，简单的说，这道题前面的循环上界换成大点的数答案就不对了，如果当作字符串来判断的话会很简单，时间有点紧，先把代码贴在这里，后面我再调。

/**
 * @ClassName 超级质数
 * @Author @浅夜
 * @Date 2023/3/15 20:55
 * @Version 1.0
 */

public class Main {
    public static void main(String[] args) {
        int max = 0;
        int nr = 0;

        for (int i = 2; i < 400; i++) {
            if (isallPrime(i)&& isallPrime(reverse(i))) max = i;
        }
        System.out.println(max);

    }

    //判断n的数位是不是都为质数
    static boolean isallPrime(int n) {
        if (!isPrime(n)) return false;
        while (n > 0) {
            if (!isPrime(n % 10)) {
                return false;
            }
            n /= 10;
        }
        return true;
    }

    //将数字n的数位倒过来
    static int reverse(int n){
        int res;
        StringBuffer s = new StringBuffer(n+"");
        res = Integer.parseInt(s.reverse().toString());
        return res;
    }
    //判断n是不是质数
    static boolean isPrime(int n) {
        for (int i = 2; i <= n / i; i++) {
            if (n % i == 0) return false;
        }
        return true;
    }
}

---

3. 🌰🌰🌰卡牌🌰🌰🌰

📋问题描述

❓思路分享

🌰卡牌第三次做！二分二分二分答案！废话不多，看代码！果不其然，再写一遍还是错误百出，只过了40%，让我很疑惑，跟之前代码对了半天，最后一看居然是没开long！m最大是n方，n最大是2e5，所以m到了4e10！！！下次一定看好数据范围😭😭😭

📗参考代码

import java.io.*;

/**
 * @ClassName 卡牌
 * @Author @浅夜
 * @Date 2023/3/15 21:33
 * @Version 1.0
 */

public class Main {
    static int N = 200010;
    static long n, m;
    static int[] a = new int[N];
    static int[] b = new int[N];
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

    public static void main(String[] args) throws IOException {
        String[] v = br.readLine().split(" ");
        n = Long.parseLong(v[0]);
        m = Long.parseLong(v[1]);
        v = br.readLine().split(" ");
        for (int i = 1; i <= n; ++i) {
            a[i] = Integer.parseInt(v[i - 1]);
        }
        v = br.readLine().split(" ");
        for (int i = 1; i <= n; ++i) {
            b[i] = Integer.parseInt(v[i - 1]);
        }

        int l = 0, r = 2 * N;
        while (l < r) {
            int mid = (l + r + 1) >> 1;
            if (check(mid)) l = mid;
            else r = mid - 1;
        }
        out.println(l);
    }

    static boolean check(int x) {
        long v = m;
        for (int i = 1; i <= n; ++i) {
            if (a[i] >= x) continue;
            if (a[i] + b[i] < x) return false;
            if (a[i] + b[i] >= x && v >= (x - a[i])) v -= (x - a[i]);
            else return false;
        }
        return true;
    }
}

---

4. 🎯🎯🎯染色时间🎯🎯🎯

📋问题描述

❓思路分享

🎯看怂佬的题解写的，这道题我觉得bfs之外的东西就是对于染到某个格子的染色时间的处理，用一个b数组来保存，并且随着一轮轮染色的进行来更新染色到每个格子的时间，到最后，最大的那个时间就是染完所有格子花费的时间了。

也看到过其他的写自定义排序的题解，就是对染色时间进行排序，但是都相较于怂佬的处理复杂了，给怂佬点赞！！

💯做这道题收获有二：第一，偏移量写成两个数组的话会慢60-70毫秒，会超时一个样例；第二，二维数组找最大值如果直接暴力会超时一个样例，但如果先给每一行排序，然后从每一行的最大值当中找出数组的最大值会快40多毫秒，就会过掉所有样例。

📗参考代码

package 三十天打卡.第十二天;

import javax.swing.*;
import java.io.*;
import java.util.*;

/**
 * @ClassName 染色时间
 * @Author @浅夜
 * @Date 2023/3/15 22:06
 * @Version 1.0
 */

public class 染色时间 {
    static BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
    static int [][]d={{-1,0},{1,0},{0,-1},{0,1}};
    static int[][] a;  //保存每个格子染色需要的时间
    static int[][] b;  //
    static int n, m;

    public static void main(String[] args) throws IOException {
        String[] v = br.readLine().split(" ");
        n = Integer.parseInt(v[0]);
        m = Integer.parseInt(v[1]);
        a = new int[n][m];
        b = new int[n][m];
        for (int i = 0; i < n; i++) {
            v = br.readLine().split(" ");
            for (int j = 0; j < m; j++) {
                a[i][j] = Integer.parseInt(v[j]);
            }
        }

        b[0][0] = a[0][0];
        int max = 0;
        bfs();
        for (int i = 0; i < n; i++) {
            Arrays.sort(b[i]);
            max = Math.max(max, b[i][m-1]);
        }
//        for(int i = 0; i < n; i++){
//            for (int j = 0; j < m ; j++) {
//                if(b[i][j]>max) max = b[i][j];
//            }
//        }
//        System.out.print(max);
    }

    static void bfs() {
        Queue<int[]> queue = new LinkedList<>();
        queue.add(new int[]{0, 0});
        int newX, newY, t;
        int[] cur = new int[2];
        while (!queue.isEmpty()) {
            cur = queue.poll();
            int x = cur[0], y = cur[1];
            t = b[x][y];  //染色需要的时间
            for (int i = 0; i < 4; i++) {
                newX = x + d[i][0];
                newY = y + d[i][1];
                if (check(newX, newY, t)) {
                    queue.add(new int[]{newX,newY});
                    //当前格染色时间 = 染前面格子花费的时间 + 该格染色时间
                    b[newX][newY] = b[x][y] + a[newX][newY];  
                }
            }
        }
    }

    static boolean check(int x, int y, int t) {
        if (x >= 0 && x < n && y < m && y >= 0) {
            return t + a[x][y] < b[x][y] || b[x][y] == 0;
        }
        return false;
    }
}

---

📢📢📢今天就分享到这里啦，明天见~

大家如果学到了东西就点个赞吧~

你们的支持是我坚持的动力！😃😃😃