第十二届蓝桥杯省赛（软件类真题）

最新推荐文章于 2023-04-01 16:02:47 发布
最新推荐文章于 2023-04-01 16:02:47 发布
阅读量506 收藏
点赞数 1
分类专栏： 蓝桥杯 文章标签： 蓝桥杯 java 算法
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_45382931/article/details/123327760
版权

ASC

import java.io.IOException;
class MC {
    public void run(){
        System.out.println((int)'L');
    }
}
public class Main {
    public static void main(String[] args) throws IOException {
        new MC().run();
    }
}

卡片

在这里插入图片描述

import java.io.IOException;
class MC {
    int[] a = new int[10];
    public void run(){
        for (int i = 0; i < 10; i++) {
            a[i] = 2021;
        }
        for (int i = 1; i < Integer.MAX_VALUE; i++) {
            int x = i;
            while (x > 0){
                int t = x % 10;
                if (a[t] > 0) a[t]--;
                else{
                    System.out.println(i - 1);
                    return;
                }
                x /= 10;
            }
        }
    }
}
public class Main {
    public static void main(String[] args) throws IOException {
        new MC().run();
    }
}

直线

在这里插入图片描述

import java.io.IOException;
import java.util.Arrays;
import java.util.Comparator;
class Line{
    double k, b;
    public Line(double k, double b) {
        this.k = k;
        this.b = b;
    }
}
class MC {
    /**
     * 确定一条直线靠斜率和截距，若斜率和截距有一个不同，则为不同的直线
     * 枚举每两个点形成的斜率和截取，判断有多少个不同即可
     * 还有特殊情况，斜率不存的情况单独拿出来（x1==x2），最后加上即可
     * 20*20=400个点，假设每个都可形成不同直线，共400*400种情况
     */
    int N = 200010;
    Line[] l = new Line[N];
    int m;
    public void run(){
        for (int x1 = 0; x1 < 20; x1++) {
            for (int y1 = 0; y1 < 21; y1++) {
                for (int x2 = 0; x2 < 20; x2++) {
                    for (int y2 = 0; y2 < 21; y2++) {
                        if(x1 == x2) continue;
                        double k = (double) (y2 - y1) / (x2 - x1);
                        double b = y1 - k * x1;
                        l[m++] = new Line(k, b);
                    }
                }
            }
        }
        Arrays.sort(l, 0, m, new Comparator<Line>() {
            @Override
            public int compare(Line o1, Line o2) {
                if (o1.k == o2.k) {
                    if (o1.b < o2.b) return -1;
                    else  return 1;
                }
                if (o1.k < o2.k){
                    return -1;
                }else return 1;
            }
        });
        int res = 1;
        for (int i = 1; i < m; i++) {
            if(Math.abs(l[i - 1].k - l[i].k) > 1e-8 || Math.abs(l[i - 1].b - l[i].b) > 1e-8) res++;
        }
        System.out.println(res + 20);
    }
}
public class Main {
    public static void main(String[] args) throws IOException {
        new MC().run();
    }
}

货物摆放

范围太大不能死磕，看一下有什么特性来排除不可能的答案
在这里插入图片描述

import java.io.IOException;
import java.util.ArrayList;
import java.util.List;
class MC {
    //分解约数
    List<Long> divide(long x){
        List<Long> res = new ArrayList<>();
        for (long i = 1; i <= x / i; i++) {
            if(x % i == 0){
                res.add(i);
                if(x / i != i) res.add(x / i);
            }
        }
        return res;
    }
   public void run(){
        //先分解质因数去掉无效方案
       long li = Long.parseLong("2021041820210418");
       List<Long> list = divide(li);
       int res = 0;
       //枚举长
       for (int i = 0; i < list.size(); i++) {
           //枚举宽
           for (int j = 0; j < list.size(); j++) {
               //高也是一个整数，因此长*宽能整除总长度就是合法方案
               if (li % (list.get(i) * list.get(j)) == 0) res++;
           }
       }
       System.out.println(res);
   }
}
public class Main {
    public static void main(String[] args) throws IOException {
        new MC().run();
    }
}

路径

最小公倍数+dijkstra

import java.io.IOException;
import java.util.Arrays;
import java.util.PriorityQueue;
class PII implements Comparable<PII>{
    int first, second;
    public PII(int first, int second) {
        this.first = first;
        this.second = second;
    }
    //按照距离升序排序
    @Override
    public int compareTo(PII o) {
        return this.first - o.first;
    }
}
class MC {
    int N = (int) 1e6;
    //无向图
    int[] h = new int[N], ne = new int[N], e = new int[N], w = new int[N];
    int idx;
    int[] dist = new int[N];
    boolean[] st = new boolean[N];
    void add(int a, int b, int c){
        e[idx] = b; w[idx] = c; ne[idx] = h[a]; h[a] = idx++;
    }
    int gcd(int a, int b){
        return b > 0 ? gcd(b, a % b): a;
    }
    int lcm(int a, int b){
        return a * b / gcd(a, b);
    }
    void dijkstra(){
        PriorityQueue<PII> q = new PriorityQueue<>();
        Arrays.fill(st, false);
        Arrays.fill(dist, 0x3f3f3f3f);
        dist[1] = 0;
        q.add(new PII(0, 1));
        while (q.size() > 0){
            PII t = q.poll();
            int dis = t.first, p = t.second;
            if (st[p]) continue;
            st[p] = true;
            for (int i = h[p]; i != -1; i = ne[i]){
                int j = e[i];
                //w[i]：点i到点j的距离，dist[j]：点1到点j的距离
                if(dis + w[i] < dist[j]) {
                    dist[j] = dis + w[i];
                    q.add(new PII(dist[j], j));
                }
            }
        }
    }
   public void run(){
       //初始化邻接表
       Arrays.fill(h, -1);
       idx = 0;
       for (int i = 1; i <= 2021; i++) {
           for (int j = 1; j <= 2021; j++) {
               if (Math.abs(i - j) <= 21) {
                   add(i, j, lcm(i, j));
      
               }
           }
       }
       dijkstra();
       System.out.println(dist[2021]);
   }
}
public class Main {
    public static void main(String[] args) throws IOException {
        new MC().run();
    }
}

时间显示

在这里插入图片描述
在这里插入图片描述

import java.util.*;
class MC {
   public void run(){
       Scanner sc = new Scanner(System.in);
       long t = sc.nextLong();
       Calendar is = Calendar.getInstance();
       is.setTimeInMillis(t);
       System.out.printf("%02d:%02d:%02d", is.get(Calendar.HOUR_OF_DAY), is.get(Calendar.MINUTE), is.get(Calendar.SECOND));
   }
}
public class Main {
    public static void main(String[] args) {
        new MC().run();
    }
}

最少砝码

在这里插入图片描述
在这里插入图片描述

import java.util.Scanner;

class  MC{
    //砝码总重量不超过1e5，则m最大为1e5，因为要用到-m，所以空间要*2
    //加上偏移后下标从0开始
    int N = 110, M = (int) (2e5 + 10), base = (int) 1e5;
    boolean[][] f = new boolean[N][M];
    int[] w = new int[N];

    public void  run(){
        int n, m = 0;
        n = sc.nextInt();
        for (int i = 1; i <= n; i++) {
            w[i] = sc.nextInt();
            m += w[i];
        }

        //0个砝码称出0的重量
        //f[0][0]，base相当于0 
        f[0][base] = true;
        //循环物品
        for (int i = 1; i <= n; i++) {
            //循环体积
            for (int j = -m; j <= m; j++) {
                //不选
                f[i][j + base] = f[i - 1][j + base];
                //放左边
                if(j - w[i] >= -m) f[i][j + base] = f[i][j + base] | f[i - 1][j - w[i] + base];
                //放右边
                if(j + w[i] <= m) f[i][j + base] = f[i][j + base] | f[i - 1][j + w[i] + base];
            }
        }

        //从1开始
        int cnt = 0;
        for (int j = 1; j <= m; j++) {
            //前i个物品能否称出重量j
            if (f[n][j + base]) cnt++;
        }
        System.out.println(cnt);
    }

    Scanner sc = new Scanner(System.in);
}


public class Main {
    public static void main(String[] args) {
        new MC().run();
    }
}

杨辉三角形

在这里插入图片描述
N ∈ \in ∈[1,N]
第1个斜行C(N,0)
第2个斜行C(N,1)
第3个斜行C(N,2)
第n个斜行C(N,n)
C34 17大于1e9,C34 16小于1e9
我们只需枚举16斜行即可

若n在第k斜行的第l个，则对应的顺序位置为：(l + 1) * l/ 2 + l+ 1

import java.io.IOException;
import java.util.Scanner;
class MC {
    int n;
    long C(int a, int b){
        long res = 1;
        for (int i = 1, j = a; i <= b; i++, j --) {
            res = res * j / i;
        }
        return res;
    }

    boolean check(int k){
        int l = 2 * k, r = Math.max(n, l);
        while (l < r){
            //枚举N
            int mid = l + r >> 1;
            if (C(mid, k) >= n) r = mid;
            else  l = mid + 1;
        }
        if (C(l, k) != n) return false;
        System.out.println(((long) l + 1) * l / 2 + k + 1);
        return true;
    }

    public void run() {
        //第1个斜行C(N,0)
        //第2个斜行C(N,1)
        //第3个斜行C(N,2)
        //第n个斜行C(N,n)
        //C34 17大于1e9,C34 16小于1e9
        //我们只需枚举16斜行即可
       
        //若n在第k斜行的第l个，则对应的顺序位置为：(l + 1) * l/ 2 + l+ 1
   
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 16; i >= 0; i--) {
            if (check(i)) break;
        }
    }
}

public class Main {
    public static void main(String[] args) throws IOException {
        new MC().run();
    }
}
心里没有一点AC数
关注
  • 1
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
2021年4月蓝桥杯软件类省赛：题目+解析（完整版）
m0_54861649的博客
06-01 182
相关文章： 解析：首先要理清题目：从1开始，从小往大按顺序拼，所以总会有一个数字先用完（每一个数字是有限的）。根据题目中例子的提示，不够拼出11，很容易发现1是最先用完的，事实也是如此。所以本题的关键在于：找出刚好用到第2021个1的纸牌！参考代码： 代码运行输出是：3181。需要注意的是，3181中有两个1，这个时候需要自己确定一下，哪个1是第2021个1。经过判断可知，3181中的前面那个1是第2020个1，后面的那个1是第2021个1。所以3181是刚好可以拼成的，而3182不能拼成。因此最后的答案是
第十一届蓝桥杯第三场软件类省赛 C++ 题解
qq_45074215的博客
10-28 1164
试题 C: 车牌 A 市的车牌由六位组成，其中前三位可能为数字 0 至 9，或者字母 A 至 F，每位有 16 种可能。后三位只能是数字 0 至 9。为了减少攀比，车牌中不能有连续三位是相同的字符。 例如，202020 是合法的车牌，AAA202 不是合法的车牌，因为前三个字母相同。 请问，A 市有多少个合法的车牌？ 答案：4002750 思路 暴力枚举每一位的所有情况 16 * 16 * 16 * 10 * 10 * 10 = 4096000情况很少 代码 #include<iostream>
第十二届蓝桥杯嵌入式第一场省赛题目.rar
05-01
第十二届蓝桥杯嵌入式第一场省赛题目，程序题+客观
第十二届蓝桥杯大赛软件赛省赛 C/C++ 大学 B 组（第一场真题 + 部分题解）
李思成的博客
05-06 1043
前言： 本题解非官方题解，仅参考！ 题解全部由c++语言完成 填空题： 试题 A: 空间 首先要明确：1MB=1024KB，1KB=1024B，1B=8位 因此得出答案：265 * 1024 * 1024 * 8 / 32 = 67108864
蓝桥杯单片机——第十二届省赛题
热门推荐
m0_58286163的博客
04-04 1万+
蓝桥杯——单片机组第十二届省赛题目简要分析及代码分享 二、使用步骤 1.引入库 代码如下（示例）： import numpy as np import pandas as pd import matplotlib.pyplot as plt import seaborn as sns import warnings warnings.filterwarnings('ign
【蓝桥杯单片机】第十二届省赛（含题目和解答代码）
own0913的博客
03-30 8195
【代码】蓝桥杯单片机第十届省赛（含题目和解答代码）
题目 2612: 蓝桥杯2021年第十二届省赛真题-最少砝码（枚举找规律+递推）
厚积而薄发
03-21 998
文章目录QuestionIdeasCode Question 题目描述 你有一架天平。现在你要设计一套砝码，使得利用这些砝码可以称出任意小于等于 N 的正整数重量。那么这套砝码最少需要包含多少个砝码？ 注意砝码可以放在天平两边。 输入 输入包含一个正整数 N。 输出 输出一个整数代表答案。 样例输入 7 样例输出 3 提示 【样例说明】 3 个砝码重量是 1、4、6，可以称出 1 至 7 的所有重量。 1 = 1； 2 = 6 4 (天平一边放 6，另一边放 4)； 3 = 4 1； 4 = 4； 5 =
第14届蓝桥杯Python省赛真题-大学B组
12-28
第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛...
第十五届蓝桥杯嵌入式省赛真题解析
04-13
在第十五届蓝桥杯嵌入式省赛中，参赛者们可能面临的是对这类系统的理论理解与实践操作的挑战。嵌入式系统广泛应用于各个行业，如消费电子、医疗设备、工业自动化、汽车电子等，其核心在于高效、低功耗、实时性强和...
第15届蓝桥杯EDA省赛真题
04-14
【描述】"15届蓝桥杯EDA省赛真题"表明这是第十五届赛事的省级比赛阶段，试题集可能包括了各种难度级别的问题，涉及EDA工具的使用、电路设计、仿真验证、逻辑综合等多个方面。蓝桥杯的试题通常具有实际应用背景，鼓励...
最新， 十二届蓝桥杯程序设计题答案
04-23
十二届蓝桥杯 程序设计题 十二届 十二届 2021.4.18
第十二届蓝桥杯大赛软件赛省赛真题·.zip
06-08
第十二届蓝桥杯大赛软件赛省赛真题·.zip
蓝桥杯历年真题汇总（第一届到第十一届）.zip
03-31
包含从第一届到第十一届的所有真题
历届蓝桥杯真题下载（省赛）-附件资源
03-05
历届蓝桥杯真题下载（省赛）-附件资源
蓝桥杯历年真题及答案整理
04-06
官网上的答案，C版答案，C++版答案，JAVA版答案都有，数据亲测有效。 之前有人说太贵了，实属冤枉，那个积分不是我自己设置的= =
第十二届蓝桥杯省赛（软件类真题）.zip
最新发布
05-20
第十二届蓝桥杯省赛（软件类真题），分C/C++，Java，Python三个语言。 大学A\B\C组，研究生组。
2022 十三届 蓝桥杯省赛 单片机组真题（客观+程序设计）
04-09
"2022十三届蓝桥杯省赛单片机组真题（客观+程序设计）"是一场针对单片机技术和程序设计能力的竞赛，旨在检验参赛者的理论知识和实际操作技能。蓝桥杯是一项全国性的重要IT竞赛，尤其是对于计算机科学和技术、电子...
【蓝桥杯嵌入式】第十二届蓝桥杯嵌入式省赛客观题及详细题解
黑心萝卜三条杠的博客
04-01 4925
本文章主要给大家展示了第十二届蓝桥杯嵌入式省赛客观题，并且给出了详细题解。
【C++】蓝桥杯第十二届省赛（解题过程详解）
qq_58785091的博客
03-26 786
蓝桥杯第十二届省赛解题过程，含注意事项
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值