第十四届蓝桥杯大赛软件赛国赛Python大学B组题解

news2025/4/13 1:32:55

文章目录

弹珠堆放
划分
偶串
交易账本
背包问题
翻转
最大阶梯
最长回文前后缀
贸易航线
困局

弹珠堆放

在这里插入图片描述

递推式 $a_i=a_{i-1}+i$ ， $n = 20230610$ 非常小，直接模拟

答案等于 $494$

划分

在这里插入图片描述

因为总和为 $1 e 6$ ，因此可以dp，就是一个存在性01背包问题
答案为 $12873625444$

偶串

在这里插入图片描述

直接一个桶记录就好
才发现，蓝桥杯oj使用exit(0)会段错误得使用sys.exit(0)

import sys
from collections import defaultdict
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())


d=defaultdict(int)
s=input()
for c in s:
    d[c]+=1

for x,y in d.items():
    if y%2==1:
        print('NO')
        sys.exit(0)

print('YES')

交易账本

在这里插入图片描述
恶心的模拟题

import sys
from collections import defaultdict
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())

def solve():
    n,m=read()
    acc=[[] for _ in range(m)]
    vis=[[] for _ in range(m)]
    ok=True
    for _ in range(m):
        s=list(read())
        idx=0
        x=s[idx]
        idx+=1
        all=0
        f=False
        while x:
            x-=1
            id,c=s[idx],s[idx+1]
            idx+=2
            if id==-1 and c==-1:
                f=True
                continue
            if c>=len(acc[id]):
                ok=False
                continue
            if vis[id][c]:
                ok=False
                continue
            vis[id][c]=True
            all+=acc[id][c]
        x=s[idx]
        idx+=1
        while x:
            x-=1
            id,c=s[idx],s[idx+1]
            idx+=2
            all-=c
            acc[_].append(c)
            vis[_].append(False)
        if not f and all!=0:
            ok=False

    print('YES' if ok else 'NO')
T=1
T=int(input())
for _ in range(T):solve()

背包问题

在这里插入图片描述

看数据应该是枚举其中一种cnt，vp过了赛后交一发t了，神奇的oj
首先枚举前面两个桶装A的数量，然后前两个桶贪心地装B
那么剩下一个桶呢？肯定是先贪心放体积更小的
复杂度 $O(cnt^2)$

import sys
from collections import defaultdict
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())

def solve():
    B=list(read())
    cnta,cntb=read()
    va,vb=read()
    ans=0
    for i in range(min(cnta,B[0]//va)+1):
        for j in range(min(cnta-i,B[1]//va)+1):
            ra=cnta-i-j
            A=[B[0]-i*va,B[1]-j*va,B[2]]
            res=i+j
            t=min(A[0]//vb+A[1]//vb,cntb)
            rb=cntb-t
            res+=t
            if va<vb:
                tmp=min(A[2]//va,ra)
                A[2]-=tmp*va
                res+=tmp+min(A[2]//vb,rb)
            else:
                tmp=min(A[2]//vb,rb)
                A[2]-=tmp*vb
                res+=tmp+min(A[2]//va,ra)
            ans=max(ans,res)
    print(ans)


T=1+0
T=int(input())
for _ in range(T):solve()

翻转

在这里插入图片描述

很典的线性dp， $dp_{i,0/1}$ 表示当前是否翻转即可
复杂度 $O (n)$

import sys
from collections import defaultdict
from math import inf
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())

def solve():
    n=int(input())
    dp=[[inf]*2 for _ in range(n+1)]
    s=[0]*(n+1)
    for i in range(1,n+1):
        s[i]=input()
    
    dp[1][0]=dp[1][1]=2
    for i in range(2,n+1):
        for x in range(2):
            for y in range(2):
                dp[i][y]=min(dp[i][y],dp[i-1][x]+2-(s[i][y]==s[i-1][x^1]))
    
    print(min(dp[n][0],dp[n][1]))

T=1
# T=int(input())
for _ in range(T):solve()

最大阶梯

在这里插入图片描述

全场第二恶心的题
vp没想好居然旋转了45度再dp
实际上直接dp四次就行
复杂度 $O(n^2)$

import sys
from collections import defaultdict
from math import inf
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())



def solve():
    n=int(input())
    a=[[inf]*(n+2)]
    for _ in range(n):a.append([inf]+list(read())+[inf])
    a.append([inf]*(n+2))
    ans=0
    dp=[[0]*(n+10) for _ in range(n+10)]
    for i in range(1,n+1):
        for j in range(1,n+1):
            if a[i][j]==a[i-1][j]==a[i][j-1]:dp[i][j]=min(dp[i-1][j],dp[i][j-1])+1
            else:dp[i][j]=1
            ans=max(ans,dp[i][j])
    
    dp=[[0]*(n+10) for _ in range(n+10)]
    for i in range(n,0,-1):
        for j in range(1,n+1):
            if a[i][j]==a[i+1][j]==a[i][j-1]:dp[i][j]=min(dp[i+1][j],dp[i][j-1])+1
            else:dp[i][j]=1
            ans=max(ans,dp[i][j])
    
    dp=[[0]*(n+10) for _ in range(n+10)]
    for i in range(1,n+1):
        for j in range(n,0,-1):
            if a[i][j]==a[i-1][j]==a[i][j+1]:dp[i][j]=min(dp[i-1][j],dp[i][j+1])+1
            else:dp[i][j]=1
            ans=max(ans,dp[i][j])
    
    dp=[[0]*(n+10) for _ in range(n+10)]
    for i in range(n,0,-1):
        for j in range(n,0,-1):
            if a[i][j]==a[i+1][j]==a[i][j+1]:dp[i][j]=min(dp[i+1][j],dp[i][j+1])+1
            else:dp[i][j]=1
            ans=max(ans,dp[i][j])
    
    print(ans)
                


T=1
# T=int(input())
for _ in range(T):solve()

最长回文前后缀

在这里插入图片描述

也是很典的manacher问题
注意：前缀和后缀其中一个可以为0(这点题没表述清wa了一个点)，其次数据太水，为什么 $n^2$ 只是t一个点
首先最小答案为1
如果原本就是回文串，那么输出 $2 n$
如果前后缀都选的话，那么假设前缀为 $A$ ，后缀为 $B$ ，且 $\geq |B|$ ,那么 $A|=B_{rev}S$ ，因此最后的拼接字符串必定是 $BSB_{rev}$ 这种形式
用manacher预处理出 $L_i$ 表示以 $i$ 为左端点的最长回文串， $R_i$ 表示以 $i$ 为右端点的最长回文串
那么我们枚举前后缀的合法长度，假设 $S [1 : i] = S [n - i + 1 : n]$ ,然后我们看中间部分是属于前缀还是后缀即可
复杂度 $O (n)$

import sys
from collections import defaultdict
from math import inf
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())

def manacher(s):
    n=len(s)
    s='^#'+'#'.join(s)+'#$'
    id,mr=0,0
    p=[0]*(len(s))
    for i in range(1,2*n+1):
        if i<mr:p[i]=min(p[2*id-i],mr-i)
        else:p[i]=1
        while s[i+p[i]]==s[i-p[i]]:p[i]+=1
        if i+p[i]>mr:
            id=i
            mr=i+p[i]
    return p

def solve():
    s=input()
    p=manacher(s)
    # print(p)
    n=len(s)
    L=[0]*(n+1)
    R=[0]*(n+1)
    for i in range(1,2*n+1):
        if p[i]<=1:continue
        r=(p[i]-1)//2
        if i%2==0:
            L[i//2-r]=max(L[i//2-r],p[i]-1)
            R[i//2+r]=max(R[i//2+r],p[i]-1)
        else:
            L[i//2-r+1]=max(L[i//2-r+1],p[i]-1)
            R[i//2+r]=max(R[i//2+r],p[i]-1)
    Len=0
    i,j=0,n-1
    ok=0
    while i<=j:
        if s[i]!=s[j]:
            Len=i
            ok=1
            break
        i+=1
        j-=1
    
    if not ok:
        print(2*n)
        return
    if Len==0:
        print(1)
        return

    # for i in range(1,n):print(i,L[i],R[i])
    ans=0
    for l in range(1,Len+1):
        # print(l,2*l+L[l+1],2*l+R[n-l])
        ans=max(ans,l*2+L[l+1],l*2+R[n-l])
    print(ans)



T=1
# T=int(input())
for _ in range(T):solve()

贸易航线

在这里插入图片描述

思维题
关键点：每次卖出肯定是只卖一种商品更优的
因此我们每次看卖哪种商品即可
定义 $dp_i$ 为在第 $i$ 个点，刚好卖出所有物品的最大收益
定义 $mx_j$ 表示前面买入了 $j$ 物品后的最大收益
那么转移很简单，如果不卖任何商品 $dp_i=dp_{i-1}$
卖第 $j$ 个物品， $dp_{i}=mx_j+k\cdot P_{i,j}$
更新 $mx_j$ ， $mx_j=max(mx_j,dp_i-k \cdot P_{i,j})$

import sys
from collections import defaultdict
from math import inf
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())



def solve():
    n,m,k=read()
    P=[[0]*(n+1)]

    dp=[-inf]*(n+1)
    dp[0]=0
    for i in range(n):
        P.append([0]+list(read()))
    
    mx=[-inf]*(m+1)
    ans=0
    for i in range(1,n+1):
        dp[i]=max(dp[i],dp[i-1])
        for j in range(1,m+1):
            if P[i][j]==-1:continue
            dp[i]=max(dp[i],mx[j]+P[i][j]*k)
        for j in range(1,m+1):
            if P[i][j]==-1:continue
            mx[j]=max(mx[j],dp[i]-P[i][j]*k)
        ans=max(ans,dp[i])

    print(ans)
T=1
# T=int(input())
for _ in range(T):solve()

困局

在这里插入图片描述

暴力，可以拿30%
打表发现k为奇数无解

import sys
from collections import defaultdict
from math import inf
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())

MOD=998244353
n,k=read()
if k%2==1:
    print(0)
    sys.exit(0)
match=[0]*(n+1)
def check():
    x=0
    cnt=0
    vis=[0]*(n+1)
    while True:
        x+=1
        if x>n:break
        if match[x] and not vis[x]:
            vis[x]=1
            x=match[x]
            cnt+=1
    return cnt==2*k

ans=[0]
def dfs(x,st):
    if x==k+1:
        if check():
            ans[0]+=1
            # print(match[1:])
        return
    for i in range(st+1,n+1):
        if match[i]:continue
        for j in range(i+1,n+1):
            if match[j]:continue
            match[i]=j
            match[j]=i
            dfs(x+1,i)
            match[i]=0
            match[j]=0

dfs(1,0)
print(ans[0]%MOD)

发现方案只与这 $2 k$ 个位置有关，因此我们先令 $n = 2 k$ 计算出相对顺序的方案数 $an s$
vp的时候居然没想到如此简单的方法，但是官方正解好像不是这个。。
那么计算出相对顺序后，只需要在n个点选2k个即可，答案就是 $ans \cdot \binom{n}{2k}$

import sys
from collections import defaultdict
from math import inf
input=lambda:sys.stdin.readline().strip()
read=lambda:map(int,input().split())

MOD=998244353
n,k=0,0
match=[]
def check():
    x=0
    cnt=0
    vis=[0]*(n+1)
    while True:
        x+=1
        if x>n:break
        if match[x] and not vis[x]:
            vis[x]=1
            x=match[x]
            cnt+=1
    return cnt==2*k

ans=[0]
def dfs(x,st):
    if x==k+1:
        if check():
            ans[0]+=1
            # print(match[1:])
        return
    for i in range(st+1,n+1):
        if match[i]:continue
        for j in range(i+1,n+1):
            if match[j]:continue
            match[i]=j
            match[j]=i
            dfs(x+1,i)
            match[i]=0
            match[j]=0
nn,kk=read()
if kk%2:
    print(0)
    sys.exit(0)



k=kk
n=2*k
match=[0]*(n+1)
dfs(1,0)

n=nn
fac=[1]*(n+1)
inv=[0]*(n+1)
for i in range(2,n+1):
    fac[i]=fac[i-1]*i%MOD

inv[n]=pow(fac[n],MOD-2,MOD)
for i in range(n-1,-1,-1):
    inv[i]=inv[i+1]*(i+1)%MOD

def C(n,m):
    if n<m:return 0
    return fac[n]*inv[m]*inv[n-m]%MOD

print(ans[0]*C(n,2*k)%MOD)