第十四届蓝桥杯大赛软件赛省赛pythonB(含代码)

已于 2024-04-09 14:56:51 修改
阅读量4k 收藏 100
点赞数 19
文章标签： python 算法 数据结构 开发语言 蓝桥杯
于 2023-04-08 13:40:20 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/m0_52225681/article/details/130027962
版权
文章展示了使用Python语言解决一系列编程竞赛题目，包括数字序列分析、硬币兑换、松散子序列、管道问题、保险箱问题、树上选点和异或和问题。大部分问题采用暴力求解策略，部分题目涉及递归、动态规划和树形结构的处理。
摘要由CSDN通过智能技术生成

A.2023

在这里插入图片描述
暴力即可

import bisect
import sys
import copy
from collections import deque, defaultdict
import heapq
from itertools import accumulate, permutations, combinations
import math

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")

# INF = 0x3f3f3f3f3f3f


# sys.setrecursionlimit(100000)


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


a = 12345678
b = 98765432
cnt_all = 0
ans = 0

for num in range(a, b + 1):
    cnt_all += 1
    tmp = [int(i) for i in str(num)]
    flag_2_0 = False
    flag_0 = False
    flag_2_1 = False
    flag_3 = False
    for i in range(len(tmp)):
        if flag_2_0 == False and tmp[i] == 2:
            flag_2_0 = True
        if flag_2_0 == True and flag_0 == False and tmp[i] == 0:
            flag_0 = True
        if flag_2_0 == True and flag_0 == True and flag_2_1 == False and tmp[i] == 2:
            flag_2_1 = True
        if flag_2_0 == True and flag_0 == True and flag_2_1 == True and flag_3 == False and tmp[i] == 3:
            flag_3 = True
            ans += 1
            break
print(cnt_all - ans)
# 85959030

B.硬币兑换

在这里插入图片描述
注意，只有新币可以兑换，最后结果不论硬币新旧。
创建一个结果集列表表示:两个硬币能兑换出的所有结果，共4046种然后遍历所有情况，例如2和3兑换5，那么存入列表时就是result[2+3]=2，意思为兑换成5的情况有2次。

# 创建一个结果集表示:两个硬币能兑换出的所有结果，共4046种
res = [0] * 4047

# 遍历范围从1到2023
for i in range(1, 2024):
    # 再次遍历范围从i+1到2023
    for j in range(i + 1, 2024):
        # 将'res'列表中索引为(i+j)的元素增加i, 因为兑换的次数取决于最小的硬币数，所以加i
        res[i + j] += i

# 找出'res'列表中的最大值并打印
print(max(res))
# 682425

C.松散子序列

在这里插入图片描述

import sys

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


s = input()
n = len(s)
f = [0] * n
if s == '':
    print(0)
elif n == 1:
    print(ord(s[0]) - ord('a') + 1)
else:
    f[0] = ord(s[0]) - ord('a') + 1
    f[1] = max(f[0], ord(s[1]) - ord('a') + 1)
    for i in range(2, n):
        f[i] = max(f[i - 1], f[i - 2] + ord(s[i]) - ord('a') + 1)
    print(max(f))

D.管道

在这里插入图片描述
在这里插入图片描述
直接遍历每一个阀门，定义数组 v i s i vis_i visi​ 为第 i i i 个阀门最早感应到水流的时间。

import bisect
import sys
import copy
from collections import deque, defaultdict
import heapq
from itertools import accumulate, permutations, combinations
import math

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")

INF = int(1e12)


# sys.setrecursionlimit(100000)


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


n, len = read()
a = []
for _ in range(n):
    l, s = read()
    a.append([l, s])

vis = [INF] * (len + 1)

for i in range(n):
    l, s = a[i]
    vis[l] = min(vis[l], s)

for i in range(n):
    l, s = a[i]
    t = s + 1
    left = l - 1
    right = l + 1
    while left >= 1 and t < vis[left]:
        vis[left] = t
        t += 1
        left -= 1

    t = s + 1
    while right <= len and t < vis[right]:
        vis[right] = t
        t += 1
        right += 1


print(max(vis[1::]))

E.保险箱

在这里插入图片描述
在这里插入图片描述
写的贪心，感觉不对。

import bisect
import sys
import copy
from collections import deque, defaultdict
import heapq
from itertools import accumulate, permutations, combinations
import math

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")

# INF = 0x3f3f3f3f3f3f


# sys.setrecursionlimit(100000)


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


n = I()
x = input()
y = input()
prev = 0
ans = 0
for i in range(n-1, -1, -1):
    tmp_x = int(x[i]) + prev

    tmp_y = int(y[i])
    if tmp_x > tmp_y:
        if (tmp_x - tmp_y) - (tmp_y + 10 - tmp_x) > 1:
            ans += (tmp_y + 10 - tmp_x)
            prev = 1
        else:
            ans += tmp_x - tmp_y
            prev = 0
    elif tmp_x == tmp_y:
        prev = 0
    else:
        if (tmp_y - tmp_x) - (tmp_x + 10 - tmp_y) > 1:
            ans += (tmp_x + 10 - tmp_y)
            prev = -1
        else:
            ans += tmp_y - tmp_x
            prev = 0

print(ans)

F.树上选点

在这里插入图片描述
暴力枚举第一个点，再找第二个点。

import bisect
import sys
import copy
from collections import deque, defaultdict
import heapq
from itertools import accumulate, permutations, combinations
import math

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")


# INF = 0x3f3f3f3f3f3f


# sys.setrecursionlimit(100000)


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


def dfs_deep(u, depth):
    deep[u] = depth
    for v in g[u]:
        dfs_deep(v, depth + 1)


def dfs(u, fa, x):
    if fa == x:
        vis[u] = True
    for v in g[u]:
        if v == x:
            vis[u] = True
        dfs(v, u, x)


n = I()
g = [[] for _ in range(n + 1)]

f = list(read())

for i in range(n - 1):
    g[f[i]].append(i + 2)
value = list(read())
value = [0] + value
deep = [0] * (n + 1)
dfs_deep(1, 0)
ans = 0

for x in range(1, n + 1):
    vis = [False] * (n + 1)
    vis[0] = True
    for i in range(1, n + 1):
        if deep[i] == deep[x]:
            vis[i] = True
    dfs(1, 0, x)
    tmp = []
    maxm1 = 0
    for i in range(1, n + 1):
        if not vis[i] and i != x:
            if value[i] > maxm1:
                maxm1 = value[i]
    ans = max(ans, value[x] + maxm1)


print(ans)

G.T字消除

在这里插入图片描述
在这里插入图片描述
没做。

H.独一无二

在这里插入图片描述
在这里插入图片描述
开个cnt数组，每次dis[u]+w == dis[v]的时候+1

import bisect
import sys
import copy
from collections import deque, defaultdict
import heapq
from itertools import accumulate, permutations, combinations
import math

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")

INF = 0x3f3f3f3f3f3f


# sys.setrecursionlimit(100000)


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


class Edge:
    v = 0
    w = 0
    ne = -1


def add(a, b, c):
    global idx
    e[idx].v = b
    e[idx].w = c
    e[idx].ne = h[a]
    h[a] = idx
    idx += 1


def dijkstra(s):
    vis = [False] * (n + 1)
    dis = [INF] * (n + 1)
    cnt = [0] * (n + 1)
    dis[0] = dis[s] = 0
    vis[0] = True
    q = []
    heapq.heappush(q, [0, s])

    while q:
        _, u = heapq.heappop(q)

        if vis[u]:
            continue

        vis[u] = True

        i = h[u]
        while i != -1:
            v = e[i].v
            w = e[i].w
            i = e[i].ne

            if dis[u] + w < dis[v]:
                dis[v] = dis[u] + w
                if not vis[v]:
                    heapq.heappush(q, [dis[v], v])
            if dis[u] + w == dis[v]:
                cnt[v] += 1

    cnt[s] = 1
    for i in range(1, n + 1):
        print(cnt[i] - 1)


n, m = read()
h = [-1] * (n + 1)
idx = 0
e = [Edge() for _ in range(m)]
for _ in range(m):
    u, v, c = read()
    add(u, v, c)
dijkstra(1)

I.异或和

在这里插入图片描述
在这里插入图片描述
a维护以x为根的子树异或和, prev维护每个结点的点权。
每次change只需要向上更改贡献即可。
正解应该是 dfs序+树状数组/线段树 维护

import bisect
import sys
import copy
from collections import deque, defaultdict
import heapq
from itertools import accumulate, permutations, combinations
import math

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")


# INF = 0x3f3f3f3f3f3f


# sys.setrecursionlimit(100000)


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


def dfs(u):
    for v in g[u]:
        a[u] ^= dfs(v)
    return a[u]


def change(u, x, y):
    if u == x:
        a[x] = a[x] ^ prev[x] ^ y
        # 注意要把点权也修改了，比赛的时候忘记了。。。。
        prev[x] = y
        return prev[x] ^ y
    for v in g[u]:
        a[u] ^= change(v, x, y)
    return 0


n, m = read()
a = list(read())
a = [0] + a
prev = copy.deepcopy(a)
g = [[] for _ in range(n + 1)]
for i in range(n - 1):
    u, v = read()
    g[u].append(v)

dfs(1)

for _ in range(m):
    op = list(read())
    if op[0] == 1:
        x, y = op[1], op[2]
        change(1, x, y)
    if op[0] == 2:
        x = op[1]
        print(a[x])

J.混乱的数组

在这里插入图片描述
手算 x ≤ 10 x\le10 x≤10

import bisect
import sys
import copy
from collections import deque, defaultdict
import heapq
from itertools import accumulate, permutations, combinations
import math

input = lambda: sys.stdin.readline().rstrip("\r\n")
printf = lambda d: sys.stdout.write(str(d) + "\n")

# INF = 0x3f3f3f3f3f3f


# sys.setrecursionlimit(100000)


def read():
    line = sys.stdin.readline().strip()
    while not line:
        line = sys.stdin.readline().strip()
    return map(int, line.split())


def I():
    return int(input())


x = I()
if x == 1:
    print(2)
    print(2, 1)
if x == 2:
    print(3)
    print(2, 1, 1)
if x == 3:
    print(3)
    print(3, 2, 1)
if x == 4:
    print(4)
    print(2, 2, 1, 1)
if x == 5:
    print(4)
    print(3, 2, 1, 1)
if x == 6:
    print(4)
    print(4, 3, 2, 1)
if x == 7:
    print(5)
    print(3, 2, 2, 2, 1)
if x == 8:
    print(5)
    print(3, 3, 2, 1, 1)
if x == 9:
    print(5)
    print(4, 3, 2, 1, 1)
if x == 10:
    print(5)
    print(5, 4, 3, 2, 1)

注意

非官方题解，只是我自己的做法，如果有错误，或者有更好的做法都欢迎指正。

_wannabe
关注
第十四届蓝桥杯青少组省赛Python真题(2023年5月14日)
IT_Scratch的博客
05-14 4225
2. 如果一个上级部门参加本次活动，那么他们的直接下级部门就不能参加，而他的间接下集部门可以参加（如下图，如果部门1参加，那么部门2、3不能参加，而部门4、5、6可以参加）。接下来有N行，每行输入三个非负整数F、S和C，（0≤F≤N，1≤S≤N，F≠S，1≤C≤1000），F表示是部门S的直接上级，C表示部门S的人数，整数之间用一个空格隔开。给定两个正整数N和M (1
2023第十四届蓝桥杯大赛软件赛省赛 Python 大学 B 组记录
HP_C2H2的博客
04-08 2985
浅记录一下，无代码。 做题顺序：A→B→C→F→G→J→D→E
2021年第十二届蓝桥杯软件类省赛python组
热门推荐
蓝桥杯
05-16 2万+
目录2021年第十二届蓝桥杯软件类省赛python组1.卡片2.直线3.货物摆放4.路径5.回路计算6.时间显示7.杨辉三角8.左孩子右兄弟9.异或数列10.括号序列 2021年第十二届蓝桥杯软件类省赛python组 太菜了，现场就写了4道题，感谢蓝桥，让我知道我是个废物。 1.卡片 2.直线 3.货物摆放 4.路径 5.回路计算 6.时间显示 7.杨辉三角 8.左孩子右兄弟 9.异或数列 10.括号序列 ...
历年蓝桥杯Python青少组中/高级国赛省赛真题解析 | 2023年5月（省赛）编程题（6-11）
最新发布
COCO_gsta的博客
09-06 1252
在一个神奇空间里有N个房间，房间从1到N编号，每个房间可能有一个或多个传送门，每个传送门都有一个编号，如果相同编号的传送门同时出现在多个房间中，表示这些房间可以互通。接下来N行每行包含多个正整数（1≤正整数≤100），第2行到第N+1行依次表示1到N号房间内所有传送门的编号，正整数之间以一个英文逗号隔开。路线2：从房间1通过6号传送门进入房间3，再从房间3通过3号传送门进入房间2，共经过2个传送门；输出两个整数，分别表示N行的杨辉三角中第X行Y列对应的数，及第Y列上所有数的和，两个。
2024年备战蓝桥杯，Python B组-第十四届蓝桥杯大赛软件赛省赛真题详解
chowley的博客
01-01 5095
怀着激动地心情，马上蓝桥杯省赛结果就要发布了，大家赛场上发挥的怎么样呢？笔者是只写出了3道签到题（两填空，一编程），其他都是骗步骤分今年的难度和去年相比一下子就不同了，也是第一次选Python，发现里面数据结构的题考的很多，属于是蒙蔽了（嘻）先看一下考试题目吧。
第十四届蓝桥杯省赛 python b组
qq_55364042的博客
05-05 530
关于题解请点击每个题目下方链接，否则请等待更新。
蓝桥杯【第14届国赛】Python B组
荷碧TongZJ 的水文
06-10 1万+
倒数第二题交的时候多了一个print，只拿了国二，吐血本题解仅代表个人观点，仅供参考，欢迎各位指正。
蓝桥杯【第14届省赛】Python B组 77.00 分
荷碧TongZJ 的水文
04-08 1万+
居然是全省第二 (广东 B 组省一共 91 人，前 2.1%)，差点没把我笑死运气成分比较多，当时比赛的时候只做对了 A、C、I，然后在 D、F、J 混了点分 (本题解是赛后思考修正的)，归功于 I 的分值比较高又刚好会做哈哈。
第14届蓝桥杯Python省赛真题-大学B组
12-28
第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛真题-大学B组 第14届蓝桥杯Python省赛...
第十三届蓝桥杯大赛软件赛省赛 Python 大学 B 组
06-15
总的来说，蓝桥杯大赛的Python大学B组试题涵盖算法设计、数学应用和逻辑思维，对于参赛者来说，不仅需要扎实的编程基础，还需要具备快速解决问题的能力和良好的编程习惯。准备蓝桥杯比赛的同学应该多练习算法题，...
第14届蓝桥杯省赛、国赛(B).pdf
06-07
* 第十四届蓝桥杯省赛python第一题：该题目考查了python编程语言的基础知识，包括变量、数据类型、控制结构等。 * 第十四届蓝桥杯国赛python第二题：该题目考查了python编程语言的高级知识，包括函数、列表、字典等...
第十五届蓝桥杯大赛软件赛省赛-PB赛题
04-13
### 第十五届蓝桥杯大赛软件赛省赛-PB赛题 #### 考生须知及考试规则 - **考试流程**：参赛者需在考试开始后立即下载试题，并使用现场提供的解压密码解开试题文件。 - **考试时长**：4小时。 - **提交规则**： - ...
第十四届蓝桥杯模拟赛第一期试题与题解Java
黄小黄的博客
11-12 2961
二进制位数、晨跑、调和级数、山谷、最小矩阵、核酸日期、英文转换、充电器题目及题解
蓝桥杯2023年真题 python B组
qq_62029644的博客
04-08 8588
Python 大学 B 组。
第十四届 蓝桥杯省赛 PythonB组 个人解题思路
Aoung的博客
04-09 2181
第十四届蓝桥杯省赛 Python B组 个人思路
第十四届蓝桥杯模拟赛（Python）
KS的博客
11-12 8059
本篇题解涵盖范围为1 - 8 题，最后两题本人没能解出来使用语言为Python过样例 不确定能否AC仅供参考最后两题若有哪位兄弟会 可以评论给出你的思路 感激不尽 🙏# 直接调用转二进制函数即可# 具体用法请查官方文档s = 2022调用datetime函数，枚举每一天并判断是否符合要求ans = 0print(ans)简单模拟，大于12时输出答案idx = 1tot = 0ans = 0ans += 1idx += 1print(ans)
【python语言】第十四届蓝桥杯国赛 c/c++b组
H20211009的博客
05-04 710
持续更新中......
第十四届蓝桥杯嵌入式省赛代码解析
资源摘要信息:"第十四届蓝桥杯嵌入式代码" ...然而，如果能够访问到该文件，通过阅读代码和相关文档，我们可能会对第十四届蓝桥杯嵌入式省赛的代码有更深入的了解，并能够提供更详尽的技术知识点。
评论 9
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值