【第十四届蓝桥杯三月真题刷题训练——第 12 天（3.15）& 0的个数 & 超级质数 & 卡牌 & 染色时间】

最新推荐文章于 2024-03-07 17:40:04 发布

SE_饼干

最新推荐文章于 2024-03-07 17:40:04 发布

阅读量169

点赞数

分类专栏：蓝桥杯文章标签：数据结构 java 算法 ide 蓝桥杯 Powered by 金山文档

本文链接：https://blog.csdn.net/m0_52201500/article/details/129548407

版权

蓝桥杯专栏收录该内容

26 篇文章 3 订阅

订阅专栏

第一题：0的个数

问题描述
给定一个正整数n 请问 n 的十进制表示中末尾总共有几个0？

输入格式
输入一行包含一个正整数n。

输出格式
输出一个整数，表示答案。

样例输入
20220000

样例输出
4

第二题：超级质数

问题描述
如果一个质数P的每位数字都是质数, 而且每两个相邻的数字组成的两位 数是质数, 而且每三位相邻的数字组成的三位数是质数,
依次类推, 如果每相邻的 k位数字组成的k位数都是质数, 则P称为超级质数。
如果把超级质数P看成一个字符串, 则这个超级质数的每个子串都是质数。
例如, 53 是一个超级质数。
请问, 最大的超级质数是多少?

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

解法：

这题能拼的数字只有2、3、5、7，所以可以拼一下或者直接打印出100000内的质素或者全排列出来。

从两位数开始找是否有符合的数，可以发现2位数最大的是73 , 3位数最大的是373，而四位数则没有符合条件的，那么再大的都不符合条件。

import java.io.IOException;

public class Main {
    
    
    public static void main(String[] args) throws IOException {
        
        System.out.println(373);
        
    }
}

解法：

将输入转换成字符串，从后往前遍历，如果是0，答案加1，否则退出。

import java.io.IOException;
import java.util.Scanner;

public class Main {
    
    public static void main(String[] args) throws IOException {
        
        Scanner s = new Scanner(System.in);
        String n = s.nextLine();
        int res = 0;
        for(int i = n.length()-1; i >= 0; i--) {
            if(n.charAt(i) != '0') break;
            res++;
        }
        System.out.println(res);
    }
}

第三题：卡牌

题目描述
这天，小明在整理他的卡牌。
他一共有 n 种卡牌，第 i 种卡牌上印有正整数数 i(i ∈ [1, n])，且第 i 种卡牌 现有 ai 张。
而如果有 n 张卡牌，其中每种卡牌各一张，那么这 n 张卡牌可以被称为一 套牌。小明为了凑出尽可能多套牌，拿出了 m 张空白牌，他可以在上面写上数 i，将其当做第 i 种牌来凑出套牌。然而小明觉得手写的牌不太美观，决定第 i 种牌最多手写 bi 张。
请问小明最多能凑出多少套牌？

输入格式
输入共 3 行，第一行为两个正整数 n, m。
第二行为 n 个正整数 a1, a2, ..., an。
第三行为 n 个正整数 b1, b2, ..., bn。 

输出格式
一行，一个整数表示答案。

样例输入
4 5
1 2 3 4
5 5 5 5

样例输出
3

提示
这 5 张空白牌中，拿 2 张写 1，拿 1 张写 2，这样每种牌的牌数就变为了 3, 3, 3, 4，可以凑出 3 套牌，剩下 2 张空白牌不能再帮助小明凑出一套。
对于 30% 的数据，保证 n ≤ 2000 ；
对于 100% 的数据，保证 n ≤ 2 × 10^5 ; ai , bi ≤ 2n; m ≤ n2 。

package codingTest2;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;

public class Main {
    
    static int N = (int)2e5+10;
    static int[] a = new int[N];
    static int[] b = new int[N];
    static long n, m;
    
    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;
    }
    
    public static void main(String[] args) throws IOException {
        
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] s = br.readLine().split(" ");
        
        n = Long.parseLong(s[0]);
        m = Long.parseLong(s[1]);
        
        s = br.readLine().split(" ");
        for(int i = 1; i <= n; i++) {
            a[i] = Integer.parseInt(s[i-1]);
        }
        
        s = br.readLine().split(" ");
        for(int i = 1; i <= n; i++) {
            b[i] = Integer.parseInt(s[i-1]);
        }
        
        int l = 0, r = 3*N;
        while(l < r) {
            int mid = (l + r + 1) >> 1;
            if(check(mid)) l = mid;
            else r = mid-1;
        }
        
        System.out.println(r);
    }
}

第四题：染色时间

问题描述
小蓝有一个 n 行 m 列的白色棋盘 , 棋盘的每一个方格都可以被染成彩色。
每个方格有一个染色时间 t ij, 不同方格的染色时间可能不同。如果一个方格被触发了染色 ，这个方格就会在 t ij 秒之后变成彩色, 然后将自己上下左右四个方向相邻的方格触发染色。每个方格只能被触发染色一次, 第一次触发之后 的触发为无效触发。
给定每个方格的染色时间, 在时刻0触发第一行第一列的方格染色, 请问多长时间后整个棋盘完成染色。

输入格式
输入的第一行包含两个整数 n,m, 分别表示棋盘的行数和列数。
接下来 n 行, 每行 m 个正整数, 相邻的整数之间用一个空格分隔, 表示每 个方格的染色时间。该部分的第 i 行第 j 个整数表示 t ij, 即第 i 行第 j 列的方格的染色时间。

输出格式
输出一行包含一个整数, 表示整个棋盘完成染色的时间。

样例输入
2 3
1 2 3
4 5 6

样例输出
12

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.Arrays;
import java.util.PriorityQueue;

public class Main {
    static int N = 510, INF = 0x3f3f3f3f;
    static int[][] g = new int[N][N];
    static int[][] dist = new int[N][N];
    static int[] dx = {0, 1, 0, -1};
    static int[] dy = {1, 0, -1, 0};
    static int n, m;
    static int res;
    
    public static void main(String[] args) throws IOException {
        BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
        String[] s = br.readLine().split(" ");
        n = Integer.parseInt(s[0]);
        m = Integer.parseInt(s[1]);
        
        for(int i = 1; i <= n; i++) {
            Arrays.fill(dist[i], INF);
            s = br.readLine().split(" ");
            for(int j = 1; j <= m; j++) {
                g[i][j] = Integer.parseInt(s[j-1]);
            }
        }
        
        
        PriorityQueue<int[]> q = new PriorityQueue<>((o1, o2)->o1[0]-o2[0]);

        res = dist[1][1] = g[1][1];
        
        q.add(new int[]{g[1][1], 1, 1});
        while(!q.isEmpty()) {
            int[] t = q.poll();
            int d = t[0];
            int x = t[1];
            int y = t[2];
            
            for(int i = 0; i < 4; i++) {
                int tX = x + dx[i], tY = y + dy[i];
                if(tX >= 1 && tX <= n && tY >= 1 && tY <= m && dist[tX][tY] == INF) {
                    dist[tX][tY] = d + g[tX][tY];
                    res = Math.max(dist[tX][tY], res);
                    q.add(new int[] {dist[tX][tY], tX, tY});
                }
            }
        }
        
        System.out.println(res);
        
    }
}