第十三届蓝桥杯省赛Python大学B组复盘

目录

一、试题B：寻找整数

1、题目描述

2、我的想法

3、官方题解

4、另解

二、试题E：蜂巢

1、题目描述

2、我的想法

3、官方题解

三、试题F：消除游戏

1、题目描述

2、我的想法（AC掉58.3%，剩下全超时）

3、官方题解

四、试题G：全排列的价值

1、问题描述

2、我的想法（AC掉25%，剩下全超时）

3、官方题解

五、试题H：技能升级

1、题目描述

2、我的想法（AC掉40%，剩下全超时）

3、官方题解

六、试题I：最长不下降子序列

1、题目描述

2、我的想法

3、官方题解

---

一、试题B：寻找整数

1、题目描述

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

有一个不超过 10^17 的正整数 n，知道这个数除以 2 至 49 后的余数如下表所示，求这个正整数最小是多少。

运行限制

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

2、我的想法

填空题用C++代码暴力判断，估计跑久一点也会有结果吧。但是！结果跑不出来。

3、官方题解

首先看出这是对 “中国剩余定理” 的考察，不过需要选出质数作为模数。

证明不用考虑非质数：

若x % a == b

对于非质数a，存在一个质数k，使得a == kt

x == am + b == k(tm) + b

x % k == b % k == b'

非质数的等式可以替换为质数的等式，故只需考虑质数

【中国剩余定理】

这里不探讨证明，更多证明内容见：中国剩余定理 - OI Wiki 

【求逆元yk】

• Mk*yk % mk == 1 推出 Mk*yk + mk*_ == 1
• 套用扩展欧几里得算法：yk, _ = exgcd(Mk, mk)

扩展欧几里得算法：

# 已知a, b求x, y，使得ax + by = gcd(a, b)
def exgcd(a, b):
    if b == 0: 
        return 1, 0    #显然按照题目ax+by=1的限制，当b为0了，a和x只能是1了
    y, x = exgcd(b, a % b)     #bn+(a%b)m=gcd(a,b)=d，故返回的是n,m
    return x, y - a // b * x

证明拓展欧几里得算法：

(a,b) == (b,a % b)

存在 x 和 y 使得 ax + by == gcd(a, b) == d

存在 n 和 m 使得 bn + (a%b)m == d（因为 b 和 a%b 的最大公约数也是 d）

有 bn + (a - a/b * b)m == am + b(n - a/b * m) == d

因此：

x == m

y == n - a/b * m

exgcd(b, a % b) 这一递归调用即求出 n 和 m，分别赋值给 y 和 x

补充：

• 计算两个正整数的最大公因数有两个比较常用的方法：更相减损术和辗转相除法，其中辗转相除法也叫欧几里得算法：𝑔𝑐𝑑(𝑎,𝑏)=𝑔𝑐𝑑(𝑏,𝑎%𝑏)。
• 而扩展欧几里得算法是欧几里得算法的扩展（废话），广泛应用于 RSA 加密等领域。

  定理：若 a 和 b 为正整数，则存在整数 x, y 使得 gcd(a,b)=ax+by;

  换句话说 gcd(a,b) 可以表示为 a,b 的整系数线性组合，例如：gcd(6,14)=2，而2=(-2)*6+1*14。

• 已知整数 a、b，扩展欧几里得算法可以在求得 a、b 的最大公约数的同时，能找到整数x、y（其中一个很可能是负数），使它们满足贝祖等式 ax+by=gcd(a,b)。有两个数 a,b，对它们进行辗转相除法，可得它们的最大公约数，然后，收集辗转相除法中产生的式子，倒回去，可以得到 ax+by=gcd(a,b) 的整数解。

• 欧几里德算法停止的状态是： a=gcd，b=0

• 上面的思想是以递归定义的，因为 gcd 不断的递归求解一定会有个时候 b=0，所以递归可以结束。

• 裴蜀定理 𝑎𝑥+𝑏𝑦=𝑔𝑐𝑑(𝑎,𝑏) 得名于法国数学家艾蒂安·裴蜀（也叫贝祖，音译问题），说明了对任何整数 𝑎、𝑏 和它们的最大公约数 𝑔𝑐𝑑(𝑎,𝑏)，关于未知数 𝑥 和 𝑦 的线性二元一次不定方程（称为裴蜀等式）：一定存在整数 𝑥, 𝑦，使 𝑎𝑥+𝑏𝑦=𝑔𝑐𝑑(𝑎,𝑏) 成立。
• 它的一个重要推论是：𝑎, 𝑏 互质的充要条件是存在整数 𝑥, 𝑦 使 𝑎𝑥+𝑏𝑦=1 。证明略去。

代码如下：

ps = {
    2:1,
    3:2,
    5:4,
    7:4,
    11:0,
    13:10,
    17:0,
    19:18,
    23:15,
    29:16,
    31:27,
    37:22,
    41:1,
    43:11,
    47:5
    }
# ax + by == gcd(a, b)
def exgcd(a, b):
    if b == 0: return 1, 0
    y, x = exgcd(b, a % b)
    return x, y - a // b * x

M = 1
ans = 0
for k in ps: M *= k
for m, r in ps.items():
    Mi = M // m
    t, _ = exgcd(Mi, m) # t是Mi关于m的逆元
    ans += r * Mi * t

print(ans % M)

4、另解

解1：

import os
import sys

# 请在此输入您的代码
dp = [(2,1),(3,2),(5,4),(7,4),(13,10),(19,18),(23,15),(29,16),(31,27),(37,22),(41,1),(47,5)]
lcm = 187
res = 187           #显然答案必定能整除11和17，故res是按11*17==187的倍数加
i = 0
while i < len(dp):
  if res % dp[i][0] == dp[i][1]:     #发现某一个187的倍数能“余”正确的数
    lcm *= dp[i][0]    #lcm就扩大为dp[i][0]位,这样res加上目前lcm就肯定能保持对应余数
    i += 1
  else:
    res += lcm
print(res)

这个模拟让我十分震惊，这个编程非常优秀。说明了一个事情，不了解题目对应算法的时候也可以解题，这时候你要尽量尝试用代码模拟一个可行的思路。（补充：这种查找为了加快时间，初步判断就必须加大步长）

解2：

s = 187
c = 0
# 该整数是187的倍数，且不能被2整除，既为奇数
for i in range(187, 10 ** 17, 374):  # 开始为187，既步长为374
    if i % 49 == 46 and i % 48 == 41 and i % 47 == 5 and i % 46 == 15 and i % 45 == 29:  # 因为需要哦的步长需要很大，所以选数量较大的数
        c += 1
        print(i)
    if c > 5:
        break
print(12590206409 - 5458460249)  # 7131746160
print(19721952569 - 12590206409)  # 7131746160  发现规律，开始满足条件的数是5458460249，以后的间隔是7131746160的倍数


mod = [(2, 1), (3, 2), (4, 1), (5, 4), (6, 5), (7, 4), (8, 1), (9, 2), (10, 9),
       (11, 0), (12, 5), (13, 10), (14, 11), (15, 14), (16, 9), (17, 0), (18, 11), (19, 18),
       (20, 9), (21, 11), (22, 11), (23, 15), (24, 17), (25, 9), (26, 23), (27, 20), (28, 25), (29, 16),
       (30, 29), (31, 27), (32, 25), (33, 11), (34, 17), (35, 4), (36, 29), (37, 22), (38, 37), (39, 23),
       (40, 9), (41, 1), (42, 11), (43, 11), (44, 33), (45, 29), (46, 15), (47, 5), (48, 41),(49,46)
       ]

for i in tqdm(range(5458460249, 10 ** 17, 7131746160)):  # 开始位置是5458460249 步长为7131746160
    for a, b in mod:
        if i % a != b:
            break
    else:
        print(i)  # for else结构，当for正常执行结束，则运行else语句
        break

二、试题E：蜂巢

1、题目描述

【问题描述】

蜂巢由大量的六边形拼接而成，定义蜂巢中的方向为：0 表示正西方向，1 表示西偏北 60 度，2 表示东偏北 60 度，3 表示正东，4 表示东偏南 60 度，5 表示西偏南 60 度。

对于给定的一点 O，我们以 O 为原点定义坐标系，如果一个点 A 由 O 点先向 d 方向走 p 步再向 (d+2) mod 6 方向 ( d 的顺时针 120 度方向 ) 走 q 步到达，则这个点的坐标定义为 (d, p, q)。在蜂窝中，一个点的坐标可能有多种。

下图给出了点 B(0, 5, 3) 和点 C(2, 3, 2) 的示意。

给定点 (d1​, p1​, q1​) 和点 (d2​, p2​, q2​)，请问他们之间最少走多少步可以到达?

【输入格式】

输入一行包含 6 个整数 d1​, p1​, q1​, d2​, p2​, q2​ 表示两个点的坐标，相邻两个整数之间使用一个空格分隔。

【输出格式】

输出一行包含一个整数表示两点之间最少走多少步可以到达。

【样例输入】

0 5 3 2 3 2

【样例输出】 

7

【评测用例规模与约定】

对于 25% 的评测用例，p1​,p2​≤10^3;

对于 50% 的评测用例，p1​,p2​≤10^5;

对于 75% 的评测用例，p1​,p2​≤10^7;

对于所有评测用例，0≤d1​,d2​≤5，0≤q1​<p1​≤10^9，0≤q2​<p2​≤10^9。

【运行限制】

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

2、我的想法

该题令我不知如何下手，一开始我是想以原点为中转计算距离，后面发现这样走需要较复杂的逆处理且算不出最短距离，遂作罢。

3、官方题解

• 本题是一道构造题，考点有两个：坐标转换、距离计算。蜂巢有 6 个方向，看起来比较复杂，但实际上走步非常简单。例如样例中从 B 走到 C，C 在 B 的右下方，B 只要一直向右向下走，且不超过 C 的行和列，不管怎么走，一定能以最小步数走到 C。
• 本题的难点是对坐标的处理。如果是简单的直角坐标系，很容易计算。本题是六角形的蜂巢，每个蜂巢的中心点是否能转为直角坐标？
• 显然是能转换成直角坐标的，我们先巧妙的构建 “蜂巢” 坐标系。

• 先计算得到起点坐标 (x1，y1)、终点坐标 (x2，y2)。
• 如何计算起点到终点的步数？下面给出一个简单巧妙的方法。(确实很巧妙，我他喵还能这么计算)

坐标之差的绝对值 dx = |x1-x2|，dy = |y1-y2|，有以下结论：（结论自己观察一下图找找规律，你会恍然大悟）

1）若 dx > dy，那么最少步数是 (dx+dy)//2，即先横着走，再斜着走

2）若 dx < dy，一直斜着走就行，最少步数是dy。

代码如下：

dx=[-2,-1,1,2,1,-1]
dy=[0,1,1,0,-1,-1]

def walk(d,p,x,y):
    x=x+dx[d]*p
    y=y+dy[d]*p
    return x,y

d1,p1,q1,d2,p2,q2=map(int,input().split())
x1,y1=walk(d1,p1,0,0)
x1,y1=walk((d1+2)%6,q1,x1,y1)
x2,y2=walk(d2,p2,0,0)
x2,y2=walk((d2+2)%6,q2,x2,y2)

ax,ay=abs(x1-x2),abs(y1-y2)
if ax<ay:
    print(ay)
else:
    print((ax+ay)//2)

当然也有其他解法，这里就不另作讨论了。

• 这道题属于杂题，杂题没有用到复杂算法，不懂数据结构和算法的初学者也能做
• 题目可难可易，考核参赛者的思维和编码能力
• 杂题在蓝桥杯和其他算法竞赛中，都是常见且必不可少的题型

三、试题F：消除游戏

1、题目描述

【问题描述】

在一个字符串 S 中, 如果 Si​=S(i−1)​ 且 Si​≠S(i+1)​，则称 Si​ 和 Si+1​ 为边缘字符。如果 Si​≠Si−1​ 且 Si​=Si+1​, 则 S(i−1)​ 和 Si​ 也称为边缘字符。其它的字符都不是边缘字符。

对于一个给定的串 S，一次操作可以一次性删除该串中的所有边缘字符 (操作后可能产生新的边缘字符)。

请问经过 2^64 次操作后，字符串 S 变成了怎样的字符串, 如果结果为空则输出 EMPTY。

【输入格式】

输入一行包含一个字符串 S。

【输出格式】

输出一行包含一个字符串表示答案，如果结果为空则输出 EMPTY。

【样例输入 1】

edda

【样例输出 1】

EMPTY

【样例输入 2】

sdfhhhhcvhhxcxnnnnshh

【样例输出 2】

s

2、我的想法（AC掉58.3%，剩下全超时）

既然是一次性删除所有的边缘字符，那么我就把当前字符串的所有边缘字符先选出来，然后做好标记筛掉即可，需要注意的是，由于同一个边缘字符可能被选出2次，我就用集合进行去重。

#这个模拟题解只能过58.3%
from copy import deepcopy
s=list(input())
stop=0
while stop<2**64:
    p=set()
    for i in range(1,len(s)-1):
        if s[i]==s[i-1] and s[i]!=s[i+1]:
            p.add(i)
            p.add(i+1)
        if s[i]!=s[i-1] and s[i]==s[i+1]:
            p.add(i)
            p.add(i-1)
    if len(p)==0:           #提前结束标志
        s="".join(s)
        print(s)
        break
    s1=[]
    for i in range(len(s)):   #注意这里的范围啊，每个位置都要判断一次
        if i not in p:
            s1.append(s[i])
    s=deepcopy(s1)
    p.clear()
    if len(s)==0:
        print("EMPTY")
        break
    stop+=1

可惜没办法全部AC掉。

3、官方题解

• 当删除字符后，下一轮的边缘字符只与当前删除的字符有关，即与当前删除字符的左右字符有关，则在下一轮的判断中，就不需要再遍历一遍新字符串了，我们只需要标记住字符的左右字符，然后循环处理即可。
• 要想加快时间，就必须牺牲空间。这告诉我要学会利用空间标记信息。

代码如下：

N=10**6+10
pos=[]
l,r=[0]*N,[0]*N
st=[False]*N
s=input()
n=len(s)
s="@"+s+"@"
# 构建双向链表
for i in range(1,n+1):
    l[i]=i-1
    r[i]=i+1
# 查找所有边缘字符
def check(i):
    if s[l[i]]=="@" or s[r[i]]=="@":
        return
    if s[l[i]]==s[i] and s[r[i]]!=s[i]:
        pos.append(r[i])
        pos.append(i)
    if s[l[i]]!=s[i] and s[r[i]]==s[i]:
        pos.append(l[i])
        pos.append(i)
def remove(j):
    r[l[j]]=r[j]
    l[r[j]]=l[j]
    # 删除j结点，置为True
    st[j]=True
for i in range(1,n+1):
    check(i)
while pos:
    ne=[]          #存储左右邻居
    for p in pos:
        if st[p]:
            continue
        remove(p)。    #删除当前结点的同时要更新左边的邻居邻居、更新右边邻居的邻居
        ne.append(l[p])   
        ne.append(r[p])
    pos=[]            #清空pos
    for e in ne:      #对当前删除结点的左右邻居进行筛选判断是不是边缘字符，因为新一轮的边缘字符只能在此产生
        if not st[e]:
            check(e)
ans=""
for i in range(1,n+1):
    if not st[i]:
        ans+=s[i]
if ans:
    print(ans)
else:
    print("EMPTY")

四、试题G：全排列的价值

1、问题描述

蓝桥杯2022年第十三届省赛真题-全排列的价值 - C语言网

2、我的想法（AC掉25%，剩下全超时）

对题目的描述进行简单模拟。

from itertools import *
n=int(input())
lst=[i for i in range(1,n+1)]
cnt=0
for i in permutations(lst):
    for j in range(1,n):
        for k in range(j):
            if i[k]<i[j]:
                cnt+=1
print(cnt%998244353)

显然过不了。

3、官方题解

假定4个数排序：

• 正排序：1,2,3,4价值和为6，反排序：4,3,2,1的价值和为0
• 正排序：1,3,2,4价值和为5，反排序：4,2,3,1的价值和为1
• ……
• 依次推下去就会发现这种正排序和对应的反排序的价值和相加为一个定值6，所以4个数排序就是24种排序方式，12对排列式，价值和也就有12个6，总价值和就是72
• 所以当输入n个数时就有 n!/2 对排列式，而我们可以靠第一个正排序就能推出这个定值价值和，说白了就是 0+1+2+3，就是一个简单的等差数列求和，一对排列式的价值和就是 n(n-1)/2，那么总价值和为 n!*n(n-1)/4 后面还是错了，搜了半天才发现要边循环边取余，不然后面数太大了要占时间。

a= int(input())
s= a*(a-1)/4
for i in range(1,a+1):
    s*=i
    s%=998244353
print(int(s))

这提醒我们什么，草稿纸和笔也很重要！对于可能存在规律的题目，我们可以用纸笔举例来推测规律。

五、试题H：技能升级

1、题目描述

蓝桥杯2022年第十三届省赛真题-技能升级 - C语言网

2、我的想法（AC掉40%，剩下全超时）

模拟：每次升最大的攻击力，然后更新攻击力和减少一次更新次数。

from math import *
n,m=map(int,input().split())
p=[]
cnt=0
for _ in range(n):
    a,b=map(int,input().split())
    p.append([a,b]+[ceil(a/b)])
p.sort(key=lambda x:x[0],reverse=True)
#print(p)
for _ in range(m):
    if p[0][2]>0 and p[0][0]>0:
        cnt+=p[0][0]
        p[0][2]-=1
        p[0][0]-=p[0][1]
    p.sort(key=lambda x:x[0],reverse=True)
print(cnt)

技巧：用好列表的 sort()，同时利用数组存储同一个“关系”的信息。

3、官方题解

二分法。有一说一，这代码我也没看懂，这道题估计考试的时候拿40%我就很满足了。

def check(x):
    res = 0
    for i in range(n):
        if A[i] >= x:
            res += (A[i]-x)//B[i] + 1
    return res
        
n,m = map(int,input().split())
A = [-1]*(n+1)          #首次提升的攻击力
B = [-1]*(n+1)          #每次提升后减少的点数
for i in range(n):
    a,b = map(int,input().split())
    A[i],B[i] = a,b
    
l,r = 0,2*10**6
while l < r:
    mid = (l+r+1) >> 1 #最后一次技能加点的攻击力
    if check(mid) >= m: 
        l = mid
    else: 
        r = mid - 1
ans = 0
for i in range(n):  #遍历每一个攻击力，看每一个被减了多少次
    if A[i] >= r:
        t = (A[i]-r) // B[i] + 1  # 减了多少次
        if A[i]-(t-1)*B[i] == r : 
            t-=1
        m -= t           # m的次数减去t
        ans += (t * (2 * A[i] + - (t - 1) * B[i])) / 2

print(int(ans + m*r))

六、试题I：最长不下降子序列

1、题目描述

蓝桥杯2022年第十三届省赛真题-最长不下降子序列 - C语言网 (dotcpp.com)

2、我的想法

世上最痛苦的事情莫过于此（悲），我看着这题第一反应就是dp，第一思路如下代码所示。

n,k=map(int,input().split())
A=list(map(int,input().split()))

for i in range(n-k):      #枚举每一种更换成k的情况
    for j in range(i,i+k):
        # 1.换数
        # 2.求不下降子序列的长度
        # 3.更新最值

我卡在了 “1.换数” 这一步。该换什么数，要怎么换是我没有想清楚的。

3、官方题解

暂无找到python版很好的相关题解，其中有个C++的 "权值线段树+离散化+动态规划" 解法比较不错，待后面我复习一下相关算法内容，弄懂C++代码，再复刻一个Python代码出来。

-----------更新------------

AC代码（C++）：

#include<bits/stdc++.h>
using namespace std;

#define maxn 100010
#define maxk 100010
int n,k,a[maxn],b[maxn],ans;
int dp1[maxn],dp2[maxn];		//dp1[i]表示从前往后以a[i]结尾的最长不下降子序列的长度
								//dp2[i]表示从后往前以a[i]结尾的最长不上升子序列的长度
int tree[maxn<<2];

void build(int o,int l,int r){
    tree[o]=0;
    if(l==r)
		return;
    int mid=(l+r)>>1;
    build(o<<1,l,mid);
    build(o<<1|1,mid+1,r);
}

void update(int o,int l,int r,int x,int val){//将tree[x]更新为val,并随着更新树
    if(l==r){
        tree[o]=max(tree[o],val);
    }
    else{
        int mid=(l+r)>>1;
        if(x<=mid)
			update(o<<1,l,mid,x,val);
        else 
			update(o<<1|1,mid+1,r,x,val);
        tree[o]=max(tree[o<<1],tree[o<<1|1]);
    }
}

int query(int o,int l,int r,int L,int R){//返回[L,R]的最大的tree[o]
    if(L<=l&&r<=R)
		return tree[o];
    //if(l>R||r<L)return 0;//这种情形不可能成立
    int mid=(l+r)>>1,ret=0;
    if(mid>=L)
		ret=query(o<<1,l,mid,L,R);
    if(mid+1<=R)
		ret=max(ret,query(o<<1|1,mid+1,r,L,R));
    return ret;
}

int main(){
    scanf("%d%d",&n,&k);
    for(int i=1;i<=n;i++)
		scanf("%d",&a[i]);
    if(k+1>=n){
        printf("%d",n);
        system("pause");
        return 0;
    }
    for(int i=1;i<=n;i++)  //b是a的copy 
		b[i]=a[i];
    sort(b+1,b+1+n);  //对b进行排序 
    int tot=unique(b+1,b+1+n)-(b+1);
    for(int i=1;i<=n;i++)
		a[i]=lower_bound(b+1,b+1+tot,a[i])-b;
    build(1,1,tot);
    for(int i=1;i<=n;i++){
        dp1[i]=query(1,1,tot,1,a[i])+1;
        update(1,1,tot,a[i],dp1[i]);
    }
    build(1,1,tot);
    for(int i=n;i>k;i--){
        ans=max(ans,dp1[i-k]+k+query(1,1,tot,a[i-k],tot));
        dp2[i]=query(1,1,tot,a[i],tot)+1;
        update(1,1,tot,a[i],dp2[i]);
    }
	//最终答案的形式一定是1.  dp1[x]+k+第x+k+1到第n个元素的满足a[y]>=a[x]最大的dp2[y]
    //可以用反证来证明，假如不是，那么ans=dp1[x]+k+第x+k+?到第n个元素的满足a[y]>=a[x]最大的dp2[y],?>1
    //那么由于所有的1.的最大值显然>=ans,所以ans只能是所有的1.的最大值，所以ans是1.的形式

    printf("%d",ans);
    system("pause");
    return 0;
} 

python代码没时间复刻了，考试遇到这样的综合题也不能放弃，能骗点分就骗点分。

以上，第十三届蓝桥杯省赛Python大学B组复盘

祝好