蓝桥杯最后几天冲刺

数位枚举类

【问题描述】
请计算在 1 到 5000（含）的所有整数中，有多少个数字的十进制表示中不含数字 7。
例如：
68 ✔（不含 7）
172 ✘（含 7）
507 ✔（不含 7）
【答案提交】
本题为结果填空题，只需提交一个整数，多余内容无效。

python 复制代码

ans = 0
for i in range(1,5001):
    if '7' not in str(i):
        ans+=1
print(ans)

python 复制代码

ans=0

for i in range(1,5001):
    has_seven = False
    temp=i
    while temp>0:
        digit=temp%10
        if digit == 7:
            has_seven = True
            break
        temp//=10
    if not has_seven:
        ans+=1
print(ans)

【问题描述】
在 100000（含）到 599999（含）的所有六位数中，有多少个数字不存在连续相同的三
个数字？
所谓不存在连续相同的三个数字，指这个数的任意位置都不能出现类似"333"、"000"、
"777" 这样的连续三个相同数字。
例如：
112233 ✔（没有三连相同）
450007 ✔（没有三连相同）
133345 ✘（包含 "333"）
770001 ✔（没有三连相同）
【答案提交】
本题为结果填空题，只需提交一个整数作为答案，多余内容无效

python 复制代码

digit = ['000', '111', '222', '333', '444', '555', '666', '777', '888', '999']
ans=0
for i in range(100000,600000):
    s=str(i)
    ok=True
    for t in digit:#一个一个拿出来检查
        if t in s:#检查当前这个三连是否出现在数字里
            ok=False
            break
    if ok:
        ans+=1

print(ans)

python 复制代码

ans=0
for num  in range(100000,600000):
    s=str(num)
    ok=True
    for i in range(4):
        if s[i]==s[i+1] and s[i+1]==s[i+2]:
            ok=False
            break
    if ok:
        ans+=1

print(ans)

python 复制代码

total=0
num=100000
while num<=599999:
    s=str(num)
    ok=True
    idx=0
    while idx<=3:
        a=s[idx]
        b=s[idx+1]
        c=s[idx+2]
        if a==b and b==c:
            ok=False
            break
        idx+=1
    if ok==True:
        total+=1
    num+=1
print(total)

idx <= 3 就是 range(4)
【问题描述】
小蓝为了参加蓝桥杯，今天特意起了个大早。但是他还没有吃饭，于是他走进学校的超
市中，超市的货架上摆了 n 个面包、m 包火腿肠和 k 盒牛奶。对于小蓝而言，每件商品对他
来说都有一个非 0 的食欲。面包的食欲用数组 a 表示，火腿肠的食欲用 b 表示，牛奶的食
欲用 c 表示。
当小蓝买了第 i 个面包、第 j 包火腿肠和第 t 盒牛奶并吃完这顿早餐后，他会得到
(a**i*b**j）mod c**t的动力。
现在，小蓝想知道这顿早餐最多能得到多少动力。你能帮帮他吗？
【输入格式】
第一行为三个整数 n，m，k，含义如上所述；
第二行为 n 个整数，第 i 个整数表示第 i 个面包的食欲 a**i。
第三行为 m 个整数，第 i 个整数表示第 i 包火腿肠的食欲 bi。
第四行为 k 个整数，第 i 个整数表示第 i 盒牛奶的食欲 c**i。
【输出格式】
一行一个整数，表示小蓝最多能得到的动力。
【样例输入】
2 3 6
3 8
2 5 9
1 1 4 5 1 4
【样例输出】
3

python 复制代码

n,m,k=map(int,input().split())
a = list(map(int, input().split()))
b=list(map(int, input().split()))
c=list(map(int, input().split()))
now_max=0
for i in range(n):
    for j in range(m):
        chengji=a[i]*b[j]
        for t in range(k):
            now=chengji%c[t]
            if now>now_max:
                now_max=now
print(now_max)

python 复制代码

n,m,k=map(int,input().split())
a = list(map(int, input().split()))
b=list(map(int, input().split()))
c=list(map(int, input().split()))
now_max=0
i=0
while i<n:
    j=0
    while j<m:
        cj=a[i]*b[j]
        t=0
        while t<k:
            now=cj%c[t]

            if now>now_max:
                now_max=now
            t+=1
        j+=1
    i+=1
print(now_max)

【问题描述】
某城市冬季举办环城 25km 马拉松接力赛，每个代表队有 5 人参加比赛，比赛要求每个
代表队的每名参赛选手只能跑一次，一次至少跑 1km、最多只能跑 10km，而且每个选手所跑
的公里数必须为整数，即接力的地方在整公里处。
刘老师作为学校代表队的教练，精心选择了 5 名长跑能手，进行了训练和测试，得到了
这 5 名选手尽力连续跑 1km、2km、...、10km 的所用时间。现在他要进行一个合理的安排，
让每个选手跑合适的公里数，使学校代表队跑完 25km 所用的时间最短。根据队员的情况，
这个最短的时间是惟一的，但安排方案可能并不惟一。
根据测试情况及一般运动员的情况得知，连续跑 1km 要比连续跑 2km 速度快，连续跑
2km 又要比连续跑 3km 速度快......也就是说连续跑的路程越长，速度越慢，当然也有特殊的，
就是速度不会变慢，但是绝不可能变快。
【输入格式】
5 行数据，分别是 1 到 5 号队员的测试数据，每行的 10 个整数，表示某一个运动员尽
力连续跑 1km、2km、...、10km 所用的时间。时间为一个不超过 107 的正整数。
【输出格式】
两行，第一行是最短的时间，第二行是五个数据，分别是 1 到 5 号队员各自连续跑的公
里数。
【样例输入】
333 700 1200 1710 2240 2770 3345 3956 4778 5899
300 610 960 1370 1800 2712 3734 4834 5998 7682
298 612 990 1540 2109 2896 3790 4747 5996 7654
289 577 890 1381 1976 2734 3876 5378 6890 9876
312 633 995 1407 1845 2634 3636 4812 5999 8123
【样例输出】
9905
6 5 5 4 5

python 复制代码

#读取5名选手的数据
time=[]
for _ in range(5):
    row=list(map(int,input().split()))
    time.append(row)
#最小时间
min_total=float('inf')
#最优方案
best=[0,0,0,0,0]

#五层循遍历
for l1 in range(1,11):
    for l2 in range(1,11):
        for l3 in range(1,11):
            for l4 in range(1,11):
                for l5 in range(1,11):
                    if l1+l2+l3+l4+l5!=25:
                        continue
                    total=time[0][l1-1]+time[1][l2-1]+time[2][l3-1]+time[3][l4-1]+time[4][l5-1]
                    if total<min_total:
                        min_total=total
                        best=[l1,l2,l3,l4,l5]
print(min_total)
print(' '.join(map(str,best)))

python 复制代码

time=[] #时间数组
for _ in range(5):
    arr=list(map(int,input().split())) #每一个人的1-10时间
    time.append(arr)
min_total=float('inf') #初始化最小时间
best=[0,0,0,0,0] #初始化最优方案


def dfs(idx, dist, cost, path):  # 谁跑了多长花费了多长时间，方案
    global min_total, best
    if idx == 5:
        if dist == 25 and cost < min_total:
            min_total = cost
            best = path.copy()
        return

    for length in range(1, 11):  # 枚举当前选手的
        new_dist = dist + length
        if new_dist > 25:
            break
        path[idx] = length
        new_cost = cost + time[idx][length - 1]
        dfs(idx+1,new_dist,new_cost,path)
dfs(0,0,0,[0,0,0,0,0])
print(min_total)
print(' '.join(map(str,best)))

【问题描述】
Farmer John 的 N 头奶牛，编号为 1...N（2≤N≤105），拥有一种围绕"哞网"，一些
仅在组内互相交流却不与其他组进行交流的奶牛小组，组成的复杂的社交网络。
每头奶牛位于农场的二维地图上的不同位置(x,y)，并且我们知道有 M 对奶牛(1≤M<105)
会相互哞叫。两头相互哞叫的奶牛属于同一哞网。
为了升级他的农场，Farmer John 想要建造一个四边与 x 轴和 y 轴平行的长方形围栏。
Farmer John 想要使得至少一个哞网完全被围栏所包围（在长方形边界上的奶牛计为被包围
的）。请帮助 Farmer John 求出满足他的要求的围栏的最小可能周长。有可能出现这一围
栏宽为 0 或高为 0 的情况。
【输入格式】
输入的第一行包含 N 和 M。以下 N 行每行包含一头奶牛的 x 坐标和 y 坐标（至多 108 的
非负整数）。以下 M 行每行包含两个整数 a 和 b，表示奶牛 a 和 b 之间有哞叫关系。每头奶
牛都至少存在一个哞叫关系，并且输入中不会出现重复的哞叫关系。
【输出格式】
输出满足 Farmer John 的要求的围栏的最小周长。
【样例输入】
7 5
0 5
10 5
5 0
5 10
6 7
8 6
8 4
1 2
2 3
3 4
5 6
7 6
【样例输出】
10

python 复制代码

n,m=map(int,input().split())
x=[0]*(n+1)
y=[0]*(n+1)
for i in range(1,n+1):
    xi,yi=map(int,input().split())
    x[i]=xi
    y[i]=yi
friends=[[]for i in range(n+1)]
for _ in range(m):
    a, b = map(int, input().split())
    friends[a].append(b)
    friends[b].append(a)

visited=[False]*(n+1)
min_ans=float('inf')


def dfs(now,group):
    visited[now]=True
    group.append(now)
    for one_friends in friends[now]:
        if not visited[one_friends]:
            dfs(one_friends,group)

for i in range(1,n+1):
    if not visited[i]:
        group=[]
        dfs(i,group)

        min_x=float('inf')
        max_x=-float('inf')
        min_y=float('inf')
        max_y=-float('inf')

        for cow in group:
            cx = x[cow]
            cy = y[cow]
            if cx < min_x:
                min_x = cx
            if cx > max_x:
                max_x = cx
            if cy < min_y:
                min_y = cy
            if cy > max_y:
                max_y = cy
        w = max_x - min_x
        h = max_y - min_y
        p = 2 * (w + h)
        if p < min_ans:
            min_ans = p


print(min_ans)

【问题描述】
你正在为一些孩子举办一个聚会，并为他们准备了一个蛋糕，蛋糕的形状是一个 R 行 C
列的网格。你的助手已经开始装饰蛋糕，在每个孩子的首字母上用糖霜写在蛋糕的某一个格
子里。每个格子最多只包含一个首字母，并且没有两个孩子的首字母相同，因此每个首字母
在蛋糕上只出现一次。
每个孩子都希望得到一块包含自己首字母且不包含其他孩子首字母的矩形（与网格对
齐）蛋糕。你能否为蛋糕上的每一个空白格子分配归属，使得每个孩子都能得到满足要求的
蛋糕块？保证一定存在可行解。蛋糕不需要平均分配，甚至有的孩子可能只得到
1×1
的
小块；这将是关于不公平的宝贵人生课程。
【输入格式】
输入的第一行是测试用例数 T。接下来有 T 组测试数据。每组数据的第一行为两个整数
R 和 C。接下来 R 行，每行 C 个字符，表示蛋糕的网格。每个字符要么是一个大写英文字母
（表示你的助手已经在该格子写上了这个字母），要么是?（表示该格子为空）。
【输出格式】
对于每组测试数据，输出一行 Case #x:，其中 x 是当前测试数据的编号（从 1 开始）。
然后输出 R 行，每行 C 个字符，表示你分配后的蛋糕网格。你的输出网格必须与输入网格相
同，只不过将所有的?替换为大写英文字母，表示该格子属于哪个孩子的蛋糕块。你不能添
加输入中没有出现过的字母。在你的输出网格中，对于每个字母，所有包含该字母的格子必
须组成一个与网格对齐的矩形区域。
【样例输入】
3
3 3
G??
?C?
??J
3 4
CODE
????
?JAM
2 2
CA
KE
【样例输出】
Case #1:
GGJ
CCJ
CCJ
Case #2:
CODE
COAE
JJAMCase #3:
CA
KE

python 复制代码

T=int(input())
for case in range(1,T+1):
    R,C=map(int,input().split())
    for i in range(R):
        grid = []
        line=list(input().strip())
        grid.append()

    for i in range(R):
        for j in range(1,C):
            if grid[i][j]=='?'and grid[i][j-1]!='?':
                grid[i][j]=grid[i][j-1]
    for i in range(C):
        for j in range(1,R):
            if grid[i][j] == '?' and grid[i][j - 1] != '?':
                grid[i][j]=grid[i-1][j]
    print(f"Case#{case}:")
    for row in grid:
        print(''.join(row))

【问题描述】
本题中下标均为 1-indexed。
给定长度为 n 的字符串 s，字符集Σ={a,b,...,f}。
有 q 次操作，每次操作对 s 进行单点修改。
对于 i=1,2,...,q+1，求出：进行前(i−1)次操作后，s 中满足以下条件的非空子序列 t
的数量：
t 在 s 中出现至少两次。
由于答案可能很大，只需要求出答案对 998244353 取模后的结果。
【输入格式】
第一行，两个非负整数 n,q。
第二行，字符串 s。
接下来 q 行，第 i 行正整数 pi 和字符 ci，表示一次操作 spi←ci
。
【输出格式】
输出 (q+1) 行，第 i 行一个非负整数，表示进行前 (i−1) 次操作后的答案
对
998244353
取模后的结果。
【样例输入】
4 3
abca
1 a
4 d
2 c
【样例输出】
1
1
0
4
【样例解释】
初始字符串为 s=abca，唯一符合条件的子序列为 a。
进行 1 次操作后，字符串为 s=abca，唯一符合条件的子序列为 a。
进行前 2 次操作后，字符串为 s=abcd，无符合条件的子序列。
进行前 3 次操作后，s=accd，符合条件的子序列有 ac,cd,acd,c。

python 复制代码

MOD = 998244353
n,q=map(int,input().split())
s=list(input().strip())
def dfs(idx,now):
    if idx==n:
        if now!="":
            cnt[now]=cnt.get(now,0)+1
        return
    dfs(idx+1,now+s[idx])
    dfs(idx+1,now)
def calc():
    global cnt
    cnt=dict()
    dfs(0,"")
    res=0
    for key in cnt:
        if cnt[key]>=2:
            res=(res+1)%MOD
    return res
print(calc())

for i in range(q):
    p,c=input().split()
    p=int(p)
    s[p-1]=c
    print(calc())

【问题描述】
某年某月某日，Kiana 结识了一名爆弹虐场的少年。
Kiana 仗着自己多学了几年 OI，所以还可以勉勉强强给这位少年讲一些自己擅长的题。
具体来说，Kiana 先给这位少年灌输了 n 个毫不相干的知识点，然后再通过自己的[数据删
除]技术把这些知识点强行联系在一起。
由于这位少年有着爆弹虐场的实力，所以对于每个 Kiana 准备强行构造的联系，他都
能够自己想出来，不过会花费更多的时间。具体来说，Kiana 一共有 m 个联系，每个联系可
以把两个不相干的知识点连在一起，如果由 Kiana 直接来讲第 i 个联系，需要花费 ti 的时
间，而如果由少年自己想出来，则需要花费 Ti 的时间。
为了偷懒，Kiana 只需要自己讲的或少年想出来的联系能刚好把知识点全部直接或间接
串在一起就可以了。但为了保证教学质量，Kiana 觉得至少有 k 个联系需要少年自己想出来。
由于 Kiana 耐心有限，她希望无论是自己讲或是少年自己想，构造的联系中花费时间最长
的一个用时最短。
现在 Kiana 想知道，满足这些条件的情况下，构造的联系中耗时最长的一个的最短用
时是多少。由于她不会算，所以希望由你告诉她。
【输入格式】
输入文件包括 m+1 行。
第一行包含三个正整数 n，k 和 m，分别表示知识点的数量，Kiana 希望少年自己想出
来的联系的数量和联系的总数量。
接下来 m 行，每行包含四个正整数 a，b，Ti 和 ti，表示在知识点 a 和 b 之间可以构造
出一个联系，这个联系由少年自己想出来需要花费 Ti 的时间，而 Kiana 直接讲出来需要花
费 ti 的时间。
【输出格式】
输出文件包括一行。
第一行包含一个正整数，表示构造的联系中耗时最长的一个的最短用时。
【样例输入】
4 2 5
1 2 6 5
1 3 3 1
2 3 9 4
2 4 6 1
3 4 4 2
【样例输出】
4

python 复制代码

n, k, m = map(int, input().split())
edges = []
for _ in range(m):
    a, b, T, t = map(int, input().split())
    edges.append((a-1, b-1, T, t))  # 转成 0 下标方便处理

# 答案：最小的"最长用时"
ans = float('inf')

# ----------------------
# DFS 判断图是否连通
# ----------------------
def is_connected(selected):
    # selected 是选中的边列表
    # 建邻接表
    adj = [[] for _ in range(n)]
    for a, b in selected:
        adj[a].append(b)
        adj[b].append(a)
    
    # DFS 遍历
    vis = [False] * n
    def dfs(u):
        vis[u] = 1
        for v in adj[u]:
            if not vis[v]:
                dfs(v)
    dfs(0)
    return sum(vis) == n

# ----------------------
# 主 DFS：枚举所有选边方案
# idx：当前处理第几条边
# cnt_T：选了几条少年自己想的边
# selected：已经选中的边（存a,b）
# now_max：当前方案里最长的时间
# ----------------------
def dfs(idx, cnt_T, selected, now_max):
    global ans
    # 所有边都处理完了
    if idx == m:
        # 满足两个条件：
        # 1. 少年边 >= k
        # 2. 图连通
        # 3. 必须选够 n-1 条边（树）
        if cnt_T >= k and len(selected) == n-1 and is_connected(selected):
            if now_max < ans:
                ans = now_max
        return

    # 情况 1：不选这条边
    dfs(idx + 1, cnt_T, selected, now_max)

    a, b, T, t = edges[idx]

    # 情况 2：选【少年自己想的边】
    selected.append((a, b))
    new_max = max(now_max, T)
    dfs(idx + 1, cnt_T + 1, selected, new_max)
    selected.pop()  # 回溯

    # 情况 3：选【老师讲的边】
    selected.append((a, b))
    new_max = max(now_max, t)
    dfs(idx + 1, cnt_T, selected, new_max)
    selected.pop()  # 回溯

# ----------------------
# 开始搜索
# ----------------------
dfs(0, 0, [], 0)
print(ans)