蓝桥杯·3月份刷题集训Day05

最新推荐文章于 2024-06-16 21:24:39 发布

乌云暮年

最新推荐文章于 2024-06-16 21:24:39 发布

阅读量577

点赞数 16

分类专栏：算法刷题文章标签：蓝桥杯 java 算法数据结构 bfs

本文链接：https://blog.csdn.net/weixin_62473134/article/details/129867311

版权

算法刷题专栏收录该内容

16 篇文章 0 订阅

订阅专栏

在这里插入图片描述

本篇博客旨在记录自已打卡蓝桥杯3月份刷题集训，同时会有自己的思路及代码解答希望可以给小伙伴一些帮助。本人也是算法小白，水平有限，如果文章中有什么错误之处，希望小伙伴们可以在评论区指出来，共勉💪。

文章目录

集训A

A1、质因数分解

题目：已知正整数 n 是两个不同的质数的乘积，试求出较大的那个质数。

输入格式：

输入只有一行，包含一个正整数 n，6≤n≤2×10⁹。

输出格式：

输出只有一行，包含一个正整数 p，即较大的那个质数。

输入输出样例：

输入

输出

运行限制：

最大运行时间：1s
最大运行内存: 128M

解题代码：

测试用例过了3/5.

import java.util.Scanner;

/**
 * @Descrption  数学  质数筛法 2012  NOIP普及组
 * @version  质因数分解
 * @author QIA27
 * @date 2023年3月28日 下午4:17:45
 */
public class Main {
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        long n = sc.nextLong();
        long max = 0;
        boolean isflag = true;
        for(int i = 1; i < n/2; i++) {
            // 判断是否能被整除
            if (n % i == 0) {
                // 判断1是否为质数
                for (int j = 2; j < i; j++) {
                    if (i % j == 0) {
                        isflag = false;
                    }
                }
                // 判断2是否为质数
                for (int j = 2; j < n/i; j++) {
                    if (i % j == 0) {
                        isflag = false;
                    }
                }
                max = i;
            }
        }
        
        System.out.println(max);
        
    }
}

A2、质数

题目：给定一个正整数 N，请你输出 N 以内（不包含 N）的质数以及质数的个数。

输入格式：

输入一行，包含一个正整数 N。 1≤N≤10³

输出格式：

共两行。

第 1 行包含若干个素数，每两个素数之间用一个空格隔开，素数从小到大输出。

第 2 行包含一个整数，表示N以内质数的个数。

输入输出样例：

输入

输出

2 3 5 7
4

运行限制：

最大运行时间：1s
最大运行内存: 128M

解题代码：

import java.util.Scanner;

/**
 * @Descrption  质数筛法
 * @version 质数
 * @author QIA27
 * @date 2023年3月29日 下午2:00:51
 */

public class Main {
    public static void main(String[] args) {
        Scanner sc =  new Scanner(System.in);
        int n = sc.nextInt();
        int count = 0;
        // 判断小于n的有多少
        for(int i = 2; i < n; i++) {
            boolean isflag = true;
            for(int j = 2; j < i; j++) {
                if (i % j == 0) {
                    isflag = false;
                }
            }
            if (isflag) {
                System.out.print(i + " ");
                count++;
            }
        }
        System.out.println("\n" + count);
    }
}

A3、小数第n位

题目：我们知道，整数做除法时，有时得到有限小数，有时得到无限循环小数。

如果我们把有限小数的末尾加上无限多个 0，它们就有了统一的形式。

本题的任务是：在上面的约定下，求整数除法小数点后的第 n 位开始的 3 位数。

输入格式：

输入一行三个整数：a b n，用空格分开。a 是被除数，b 是除数，n 是所求的小数后位置（0<a,b,n<10⁹）

输出格式：

输出一行 3 位数字，表示：a 除以 b，小数后第 n 位开始的 3 位数字。

输入输出样例：

输入

1 8 1

输出

运行限制：

最大运行时间：1s
最大运行内存: 256M

import java.util.Scanner;

public class Main {
    //快速幂取模运算，返回 a^b % c 的结果
    public static long qPow(long a, long b, long c) {
        long res = 1;
        long prod = a;
        while(b > 0) {
            if((b & 1) == 1) res = (res * prod) % c;
            prod = (prod * prod) % c;
            b >>= 1;
        }
        return res;
    }
    
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int a = sc.nextInt();
        int b = sc.nextInt();
        int n = sc.nextInt();
        sc.close();
        
        long mod = b * 1000;
        long res = qPow(10, n + 2, mod);
        long tem = (a % mod * res) % mod;
        System.out.println(String.format("%03d", tem / b));//3位整数形式，不足3位补0
    }
}

集训B

B1、卡片换位

题目：你玩过华容道的游戏吗？

这是个类似的，但更简单的游戏。

看下面 3 x 2 的格子

±–±–±–+

| A | * | * |

±–±–±–+

| B | | * |

±–±–±–+

在其中放 5 张牌，其中 A 代表关羽，B 代表张飞，* 代表士兵。

还有个格子是空着的。

你可以把一张牌移动到相邻的空格中去(对角不算相邻)。

游戏的目标是：关羽和张飞交换位置，其它的牌随便在哪里都可以。

输入格式：

输入两行 6 个字符表示当前的局面

输出格式：

一个整数，表示最少多少步，才能把 A B 换位（其它牌位置随意）

输入输出样例：

输入

* A
**B

输出

运行限制：

最大运行时间：1s
最大运行内存: 256M

解题代码：

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

/**
 * @Descrption  搜索  BFS  2016  省赛
 * @version 卡片换位
 * @author QIA27
 * @date 2023年3月30日 上午11:05:38
 */
public class Main {
    
    static int[] dir = {-3, -1, 1, 3};
    static int step = 0; // 步数
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        String str1 = sc.nextLine();
        String str2 = sc.nextLine();
        
        String str = str1.concat(str2);
        
        // 获取 A 和 B 的位置
        int Aindex = str.indexOf('A');
        int Bindex = str.indexOf('B');
        
        bfs(str, Aindex, Bindex);
    }
    
    private static void bfs(String str, int Aindex, int Bindex) {
        Queue<String> queue = new LinkedList<>();
        HashSet<String> set = new HashSet();
        queue.offer(str);
        set.add(str);
        while (!queue.isEmpty()) {
            int len = queue.size();
            while (len-- > 0) {
                String temp = queue.poll();
                // 出口
                if (temp.charAt(Aindex) == 'B' &&
                        temp.charAt(Bindex) == 'A') {
                    System.out.println(step);
                    return ;
                }
                // 获取空格位置
                int index = temp.indexOf(' ');
                for (int i = 0;i < 4; i++) {
                    int newIndex = index + dir[i];
                    // 判断是否越界
                    if (newIndex < 0 || newIndex > temp.length() - 1) {
                        continue;
                    }
                    // 只能上下文左右交换(即和相邻卡片交换)
                    if ((index % 3 == newIndex % 3) || (index / 3 == newIndex / 3)) {
                        // 交换
                        char[] tempChar = temp.toCharArray();
                        tempChar[index] = temp.charAt(newIndex);
                        tempChar[newIndex] = temp.charAt(index);
                        String s = new String(tempChar);
                        // 判断该场景是否重复
                        if (!set.contains(s)) {
                            set.add(s);
                            queue.offer(s);
                        }
                    }
                }
            }
            step++;
        }
    }
}

B2、最大数组

题目：给定一个正整数 N 。你可以对 N 的任意一位数字执行任意次以下 2 种操作：

将该位数字加 1 。如果该位数字已经是 9 , 加 1 之后变成 0 。
将该位数字减 1 。如果该位数字已经是 0 , 减 1 之后变成 9 。

你现在总共可以执行 1 号操作不超过 A 次, 2 号操作不超过 B 次。请问你最大可以将 N 变成多少?

输入格式：

第一行包含 3 个整数：N,A,B 。

输出格式：

一个整数代表答案。

样例输入：

123 1 2

样例输出：

样例说明：

对百位数字执行 2 次 2 号操作, 对十位数字执行 1 次 1 号操作。

评测用例规模与约定：

对于 30% 的数据, 1 ≤ N ≤ 100 ; 0 ≤ A , B ≤ 10。

对于 100% 的数据, 1≤N≤10¹⁷ ; 0≤A,B≤100

运行限制：

最大运行时间：1s
最大运行内存: 512M

解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
  static long n,m;
    static String str;
    static long sum = 0;
    public static void main(String[] args) {
        Scanner scan = new Scanner(System.in);
        str = scan.next(); //一个正整数
    n = scan.nextLong(); //1号操作n次
    m = scan.nextLong(); //2号操作m次
    dfs(0,n,m,0);
    System.out.println(sum);
    }
    public static void dfs(int i,long n,long m,long v) { 
    if(i<str.length()) {
        long x = (long)(str.charAt(i)-'0');//将字符串转化为long型，比如‘2’转换为2.000
        long t = Math.min(n, 9-x);//执行操作的最小次数
        dfs(i+1,n-t,m,v*10L+x+t);//
        //考虑2号操作是否能够使用
        if(m>x) {
            dfs(i+1,n,m-x-1L,v*10L+9);
        }
    }else {
        sum = Math.max(sum, v);
    }
}
}

集训C

C1、最短路

题目：

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

如下图所示，G 是一个无向图，其中蓝色边的长度是 11、橘色边的长度是 22、绿色边的长度是 33。

图片描述

则从 A 到 S 的最短距离是多少？

运行限制：

最大运行时间：1s
最大运行内存: 128M

解题代码：

import java.util.Scanner;
// 1:无需package
// 2: 类名必须Main, 不可修改

public class Main {
    public static void main(String[] args) {
        System.out.println("6");
    }
}

C2、左移右移

题目：小蓝有一个长度为 N 的数组, 初始时从左到右依次是 1,2,3,…N 。

之后小蓝对这个数组进行了 M 次操作, 每次操作可能是以下 2 种之一:

左移 x, 即把 x 移动到最左边。
右移 x, 即把 x 移动到最右边。

请你回答经过 M 次操作之后, 数组从左到右每个数是多少?

输入格式：

第一行包含 2 个整数, N 和 M 。

以下 M 行每行一个操作, 其中 “L_x "表示左移 x,"R*_x* "表示右移 x 。

输出格式：

输出 N 个数, 代表操作后的数组。

样例输入：

样例输出：

2 3 4 5 1

样例说明：

样例中的数组变化如下:

[1,2,3,4,5]→[3,1,2,4,5]→[2,3,1,4,5]→[2,3,4,5,1]

评测用例规模与约定：

对于 50% 的评测用例, 1 ≤ N,M ≤ 10000.

对于 100% 的评测用例, 1 ≤ N , M ≤ 200000 , 1 ≤ x ≤ N.

运行限制：

最大运行时间：3s
最大运行内存: 512M

解题代码：

import java.util.Arrays;
import java.util.Scanner;

/**
 * @Descrption  
 * @version 
 * @author QIA27
 * @date 2023年3月30日 下午6:04:59
 */
public class Main {
    // 附着数 + 排序 -> 巧妙
    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        int n = sc.nextInt();
        int m = sc.nextInt();
        // 二维数组 -> 附着数 -> 排序 -> 真实妙啊
        int[][] a = new int[n+1][2];
        for (int i = 1; i < n + 1; i++) {
            // 二维数组的初始化
            a[i][0] = a[i][1] = i;
        }
        int min = 1, max = n;
        while (m-- != 0) {
            // m次接收数据
            char s = sc.next().charAt(0);
            int x = sc.nextInt();
            //  对附着数重新赋值 -> 用于后期排序
            a[x][1] = s == 'L' ? --min: ++max;
        }
        // 从[1, n]升序排序
        Arrays.sort(a, 1, n + 1, (o1,o2) -> o1[1] - o2[1]);
        String s = "";
        for (int i = 1; i < n + 1; i++) {
            System.out.print(a[i][0] + " ");
        }
    }
}

最后

有帮助的话，希望可以点赞❤️+收藏⭐，谢谢各位大佬~~🙌🙌🙌

乌云暮年

关注

16
点赞
踩
11

收藏

觉得还不错? 一键收藏
打赏
11
评论
蓝桥杯·3月份刷题集训Day05

：已知正整数 n 是两个不同的质数的乘积，试求出较大的那个质数。输入格式：输入只有一行，包含一个正整数 n，6≤n≤2×109。输出格式：输出只有一行，包含一个正整数 p，即较大的那个质数。输入输出样例：运行限制：解题代码：测试用例过了3/5.A2、质数：给定一个正整数 N，请你输出 N 以内（不包含 N）的质数以及质数的个数。输入格式：输入一行，包含一个正整数 N。 1≤N≤103输出格式：共两行。第 1 行包含若干个素数，每两个素数之间用一个空格隔开，素数从小到大输出。第 2 行包含一个整数，
复制链接

扫一扫