第十五届蓝桥杯JavaB组

Mercer_Su

已于 2024-05-10 16:18:21 修改

阅读量5.6k

点赞数 17

分类专栏：算法比赛文章标签：算法数据结构学习笔记 java

于 2024-05-10 13:51:08 首次发布

本文链接：https://blog.csdn.net/m0_72641755/article/details/138662779

版权

算法比赛专栏收录该内容

1 篇文章 0 订阅

订阅专栏

十五届蓝桥杯

A.报数游戏 5 分

【问题描述】

小蓝和朋友们在玩一个报数游戏。由于今年是 2024 年，他们决定要从小到大轮流报出是 20 或 24 倍数的正整数。前 10 个被报出的数是： 20, 24, 40, 48, 60, 72, 80, 96, 100, 120。请问第 202420242024 个被报出的数是多少？

【答案提交】

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

【思路】

第十个数除去第三位，又回到了20，可以得出，这是一个循环，因此循环的次数乘十，加上第几个数即为答案

【代码】

#include <iostream>

int main() {
   int tmp[10] = {20, 24, 40, 48, 60, 72, 80, 96, 100, 120};
       long long sum=202420242024;
       long long x=sum/10;
       int y=sum%10;

    printf("%lld",tmp[y-1]+120*x);
    return 0;
}

B: 类斐波那契循环数 5分

【问题描述】

对于一个有 n 位的十进制数 N = d₁ d₂ d₃ . . . d_n，可以生成一个类斐波那契数列 S，数列 S 的前 n 个数为 {S ₁ = d₁ S ₂ = d₂, S ₃ = d₃, . . . , S _n = d_n}，数列 S 的第 k(k > n) 个数为 ∑^k−1 _i=k−n S _i。如果这个数 N 会出现在对应的类斐波那契数列 S 中，那么 N 就是一个类斐波那契循环数。例如对于 197，对应的数列 S 为 {1, 9, 7, 17, 33, 57, 107, 197, . . . }，197 出现在 S 中，所以 197 是一个类斐波那契循环数。请问在 0 至 10⁷ 中，最大的类斐波那契循环数是多少？

【答案提交】

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

【思路】

把所有位数分割，然后就是把前面n位数相加然后一直推下去

【代码】

import java.util.ArrayList;


public class Main {
   static boolean flag = false;
   public static void main(String[] args) {
       int p =  10000000;
       do {
           String n = String.valueOf(p);
           int s = 0;
           ArrayList<Integer> integers = new ArrayList<>();
           for (int i = 0; i < n.length(); i++) {
               char c = n.charAt(i);
               int e = Character.getNumericValue(c);
               integers.add(e);
               s += e;
           }
           integers.add(s);
           int length = n.length();
           int idx = length+1;
           while (true) {
               if (s == p) {
                   System.out.println(s);
                   flag = true;
                   break;
               }
               if (s > p) break;
               s = 2 * s - integers.get(idx - length-1);
               integers.add(s);
               idx++;
           }
           p--;
       } while (!flag);
   }
}

C: 分布式队列

【问题描述】

小蓝最近学习了一种神奇的队列：分布式队列。简单来说，分布式队列包含 N 个节点（编号为 0 至 N − 1，其中 0 号为主节点），其中只有一个主节点，其余为副节点。主/副节点中都各自维护着一个队列，当往分布式队列中添加元素时都是由主节点完成的（每次都会添加元素到队列尾部）；副节点只负责同步主节点中的队列。可以认为主/副节点中的队列是一个长度无限的一维数组，下标为 0, 1, 2, 3 . . . ，同时副节点中的元素的同步顺序和主节点中的元素添加顺序保持一致。由于副本的同步速度各异，因此为了保障数据的一致性，元素添加到主节点后，需要同步到所有的副节点后，才具有可见性。给出一个分布式队列的运行状态，所有的操作都按输入顺序执行。你需要回答在某个时刻，队列中有多少个元素具有可见性。

【输入格式】

第一行包含一个整数 N，表示节点个数。接下来包含多行输入，每一行包含一个操作，操作类型共有以下三种： add、sync 和 query，各自的输入格式如下： 1. add element：表示这是一个添加操作，将元素 element 添加到队列中； 2. sync follower_id：表示这是一个同步操作，follower_id 号副节点会从主节点中同步下一个自己缺失的元素； 3. query：查询操作，询问当前分布式队列中有多少个元素具有可见性。

【输出格式】

对于每一个 query 操作，输出一行，包含一个整数表示答案。试题C: 分布式队列 4 第十五届蓝桥杯大赛软件赛省赛 Java 大学 B 组

【样例输入】

add 1

add 2

query

add 1

sync 1

sync 2

query

sync 1

query

sync 2

sync 1

query

【样例输出】

0 1 1 3

不会

后续尝试暴力代码

import java.util.Scanner;
public class Main3 {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int n=scanner.nextInt();
        int a=0;
        int[] b=new int[n];
        while(true){
            String s=scanner.next();
            if(s.equals("add")){
                int val=scanner.nextInt();
                a++;
            }else if(s.equals("sync")){
                int val=scanner.nextInt();
                b[val]++;
            }else{
                int min=Integer.MAX_VALUE;
                for(int i=1;i<n;i++){
                    min=Math.min(min,b[i]);
                }
                System.out.println(min);
            }
        }
    }
}

D: 食堂

【问题描述】

S 学校里一共有 a₂ 个两人寝、a₃ 个三人寝，a₄ 个四人寝，而食堂里有 b₄个四人桌和 b₆ 个六人桌。学校想要安排学生们在食堂用餐，并且满足每个寝室里的同学都在同一桌就坐，请问这个食堂最多同时满足多少同学用餐？

【输入格式】

采用多组数据输入。输入共 q + 1 行。第一行为一个正整数 q 表示数据组数。后面 q 行，每行五个非负整数 a₂，a₃，a₄，b₄，b₆ 表示一组数据。

【输出格式】

输出共 q 行，每行一个整数表示对应输入数据的答案。

【样例输入】

3 0 1 0 1

0 2 2 1 1

【样例输出】

6 10

【思路】

暴力，模拟（不知道多少分，毕竟我菜）

【代码】

import java.util.Scanner;

public class Main {
	public static void main(String[] args) {
		Scanner scanner = new Scanner(System.in);
		int n = scanner.nextInt();
		while ((n--) != 0) {
			int a2 = scanner.nextInt();
			int a3 = scanner.nextInt();
			int a4 = scanner.nextInt();
			int b4 = scanner.nextInt();
			int b6 = scanner.nextInt();
			int sum = 0;

			if (b6 != 0) {
				if (a2 != 0 && b6 != 0) {
					while (a2 != 0 && b6 != 0)
						b6--;
					a2 -= 3;
					sum += 6;
				} else if (a3 != 0 && b6 != 0) {
					while (a3 != 0 && b6 != 0)
						b6--;
					a3 -= 2;
					sum += 6;
				}

				else if (a2 != 0 && a4 != 0 && b6 != 0) {
					while (a2 != 0 && a4 != 0) {
						sum += 6;
						a2--;
						a4--;
					}
				}

				else if (a3 != 0 && b6 != 0) {
					while (a3 != 0 && b6 != 0) {
						sum += 3;
						b6--;
						a3--;
					}
				}

				else if (a2 != 0) {
					while (a2 != 0 && b6 != 0) {
						sum += 2;
						b6--;
						a2--;
					}
				}

				else if (a4 != 0 && b6 != 0) {
					while (a4 != 0 && b6 != 0) {
						sum += 4;
						b6--;
						a4--;
					}
				}
			}

			if (b4 != 0) {
				if (a2 != 0 && b4 != 0) {
					while (a2 != 0 && b4 != 0) {
						b4--;
						a2 -= 2;
						sum += 4;
					}

				} 
				else if (a4 != 0 && b4 != 0) {
					while (a4 != 0 && b4 != 0) {
						sum += 4;
						b4--;
						a4--;
					}
				}

				else if (a3 != 0 && b4 != 0) {
					while (a3 != 0 && b4 != 0) {
						sum += 3;
						b4--;
						a3--;
					}
				}

			}
			System.out.println(sum);
		}

	}
}

后面发现应该跟去年飞机一样的用dfs

E: 最优分组

【问题描述】

小蓝开了一家宠物店，最近有一种 X 病毒在动物之间进行传染，小蓝为了以防万一打算购买测试剂对自己的宠物进行病毒感染测试。为了减少使用的测试剂数目，小蓝想到了一个好方法：将 N 个宠物平均分为若干组，使得每组恰好有 K 只宠物，这样对同一组的宠物进行采样并混合后用一个试剂进行检测，如果测试结果为阴性则说明组内宠物都未感染 X 病毒；如果是阳性的话则需要对组内所有 K 只宠物单独检测，需要再消耗 K 支测试剂（当 K = 1 时，就没必要再次进行单独检测了，因为组内只有一只宠物，一次检测便能确认答案）。现在我们已知小蓝的宠物被感染的概率为 p，请问 K 应该取值为多少才能使得期望的测试剂的消耗数目最少？如果有多个答案输出最小的 K。

【输入格式】

第一行，一个整数 N。第二行，一个浮点数 p。

【输出格式】

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

【样例输入】

1000

0.05

【样例输出】

【思路】

数学题

【代码】

import java.util.Scanner;

public class Main {
    public static void main(String[] args) {
        Scanner scanner=new Scanner(System.in);
        int N=scanner.nextInt();
        double p= scanner.nextDouble();
        int desk=1;
        double mintext=Double.MAX_VALUE;
        for (int i = 0; i < N; i++) {
            double exct=Math.pow(1.0-p,i);
            double exctGuop=1.0+(1.0-exct)*i;
            double exctTotal=(double)N/i*exctGuop;
            if (exctTotal<mintext){
                mintext=exctTotal;
                desk=i;
            }
        }
        System.out.println(desk);

    }
}

试题 G: LITS 游戏

题目

俄罗斯方块是一款风靡全球的游戏，在游戏中有多种方格图案，我们只关
注这四个经典的方块图案：LITS，如下图所示：

在这里插入图片描述
LITS 这四种方块都是由四个相同大小的小方块组成的。
现在给出一副大小为 N × N 的格子图，每个格子上都有一个数字 0/1，如
果格子处的数字为 1 说明这个格子上有一个小方块，数字为 0 则没有。
你需要判断从这个格子图上是否可以找出 LITS 四个方块图案（每个方
块图案之间都是独立的，不存在不同的图案公用同一个小方块的情况）。其中
LITS 方块的形状旋转任意个 90 度都是合法的，但不允许翻转。

输入格式

第一行一个整数 T，表示有 T 组数据。
每组数据的第一行包含一个整数 N，表示格子图大小。
接下来输入 N 行，每行 N 个值为 0/1 的整数，表示格子布局。

输出格式

对于每组数据，输出一行包含一个字符串。如果此组数据满足题意则输出
“Yes”，否则输出 “No”。

样例输入

2
5
1 1 1 1 1
1 0 1 1 0
1 0 0 0 1
1 0 1 0 1
1 1 1 1 1
5
1 0 0 1 1
1 1 1 1 1
1 1 1 1 0
1 1 1 0 1
0 1 1 1 1

样例输出

No
Yes

不会，直接暴力

试题 H: 拼十字

问题描述

在 LQ 国神秘的古老森林，有一座被称为 “拼十字” 的神秘遗迹。据传，
“拼十字” 是由古代文明建造的，它是一个巨大的石头结构，由两个巨大的矩形
交叉叠放在一起，形成了一个庄严而神秘的十字形状。这个遗迹被认为是连接
人类和神灵之间的通道，拥有神秘的力量和能量。
在这里插入图片描述
现在给出 N 个矩形，其中第 i 个矩形的长度和宽度分别问 li，wi，并且矩
形颜色 ci 为红 (0)/黄 (1)/蓝 (2) 中的一种。现在小蓝想知道在这 N 个矩形中有
多少对矩形可以 “拼十字”？
两个矩形可以“拼十字”的充要条件是：