Python真题练习

参考文章：【蓝桥杯】每日一题17天冲刺国赛、蓝桥杯 蓝肽子序列 python（2020动态规划）、蓝桥杯2015年第六届真题-穿越雷区-题解（Python代码）、蓝桥杯算法提高VIP-超级玛丽-题解（Python代码）动态规划计数问题详解、蓝桥杯历届试题-数字游戏-题解(Python代码)、蓝桥杯历届试题-蚂蚁感冒-题解（Python代码）、

1.金币

k=int(input())
for i in range(3000):
  if k==1:
    print(1)
    break
  if k<=(i+1)*i/2:
    nums=i*(i-1)*(2*i-1)/6+(k-(i-1)*i/2)*i 
    print(int(nums))
    break

2.优秀的拆分

n=int(input())
if n%2==1:  #从题目上看只有偶数才有优秀的拆分，奇数有2^0,0不是正整数
  print(-1)
else:
  aset=tuple(bin(n)[2:]) #4=0b100，所以要去掉0b前两位
  length=len(aset)
  for i in range(length):
    if aset[i]=='1':
      print(2**(length-i-1),end=' ')

3.蓝肽子序列

astring=input()
bstring=input()

#将字符串拆分为单词（以大写字母开头，以下一个大写字母的前一个小写字母结尾）
#实现原理：1.将字符串转为元组（便于使用下标），并在后面加上任意一个大写字母（这里加的是'A'）
#         2.遍历元组，如果当前的下一个字符为大写字母，就确定了当前字母为上一个单词的尾部，
#           就将这个单词添加到 list 中，单词范围：i已经被确定为单词尾部，j初值为0，就是
#           首个单词的头部下标，此后 j=i+1，即为下一个单词的头部
#         3.当遍历到最后的 'A',就将最后的单词（尾部下标 = 'A'的下标-1）添加进去，就将字符串拆分完成
#         4.下面为拆分实例，在下面动规判断单词相等时使用 alist[i]==blist[j]即可 
#          LanQiaoBei
#          LanTaiXiaoQiao
#          [('L', 'a', 'n'), ('Q', 'i', 'a', 'o'), ('B', 'e', 'i')]
#          [('L', 'a', 'n'), ('T', 'a', 'i'), ('X', 'i', 'a', 'o'), ('Q', 'i', 'a', 'o')]
def split(string):
  length=len(string)
  string=tuple(string)+('A',)
  j=0
  list=[]
  for i in range(length):
    if 'A'<=string[i+1]<='Z':
      list.append(string[j:i+1])
      j=i+1
  return list

alist=split(astring)
blist=split(bstring)

alength=len(alist)
blength=len(blist)

#子序列为 有顺序的 在原序列中可以不连续 的序列，如[1,2,3]有7个子序列
#与全排列不同，全排列不求顺序，上例有6个全排列
#字串为有顺序的 且连续的序列，如[1,2,3]有5个字串，不包括子序列中的[1,3]

#动规实现：dp[i][j]表示以alist的第i个单词为尾部单词（包括前面的i-1个单词），
#                      blist的第j个单词为尾部单词的两单词组的最长公共单词的个数
#原理分析：当alist的第i个单词与blist的第j个单词相等时，显然公共单词数至少为1，求最长公共数，
#             前面还有i-1和j-1个单词，得加上它们的公共单词数，即为dp[i][j]=dp[i-1][j-1]+1
#         当不相等时，显然dp[i-1][j-1]的值对于dp[i][j]的值没有什么改变，
#             但可能存在这 alist[i]=blist[j-1] 或者 alist[i-1]=blist[j]
#                   why,reason:举个例子 astring=LanQiao bstring=ManLanQiao 这就符合情况
#             那就说明dp[i][j-1]和dp[i-1][j]对dp[i][j]的值有影响，或者说会增加此时的最长公共单词数
#             即为 dp[i][j]=max(dp[i][j-1],dp[i-1][j])
#                   上面的原因看不明白，在max()中加上dp[i-1][j-1]也无所谓，
#                   反正dp[i-1][j-1]<=dp[i][j-1],dp[i-1][j-1]<=[i-1][j]       
dp=[[0]*(blength+1) for _ in range(alength+1)]
for i in range(1,alength+1):
  for j in range(1,blength+1):
    if alist[i-1]==blist[j-1]:
      dp[i][j]=dp[i-1][j-1]+1
    else:
      dp[i][j]=max(dp[i][j-1],dp[i-1][j])
print(dp[alength][blength])

4.穿越雷区

n=int(input())

#雷区输入，找到初始点
mine_field=[]
for i in range(n):
  mine=input().split()
  #记录初始点'A'的坐标
  if 'A' in mine:
    x=i
    y=mine.index('A')
  mine_field.append(mine)

#标记矩阵，访问过为True，初始除了初始点均为False
judge_matrix=[[False for _ in range(n)] for _ in range(n)]
judge_matrix[x][y]=True

#每一步可能走的四个位置
dx_Move=[-1,1,0,0]
dy_Move=[0,0,-1,1]

#队列记录广度优先遍历的坐标和走的步数
queue=[[x,y,0]]
while queue:
  if mine_field[queue[0][0]][queue[0][1]]=='B':
    print(queue[0][2])
    break
  for i in range(4):
    dx=queue[0][0]+dx_Move[i]
    dy=queue[0][1]+dy_Move[i]
    #保证走的位置在指定范围内
    if 0<=dx<=n-1 and 0<=dy<=n-1:
      #保证指定位置未被访问过且与上一步经过的符号不相同
      if not judge_matrix[dx][dy] and mine_field[queue[0][0]][queue[0][1]]!=mine_field[dx][dy]:
        #每次符合条件的队列元素的步数会加1
        queue.append([dx,dy,queue[0][2]+1])
        #标记访问过，以免再次访问
        judge_matrix[dx][dy]=True
  #去除队列第一个元素，
  queue.pop(0)
#队列为空，表示在循环中无新元素添加进去，表示没有符合条件的点，表示没有路径到达目的地，返回-1
if len(queue)==0:
  print(-1)

#下为输入
'''
4
- + - A
B - - +
- - + +
+ + - -

4
'''

5.超级玛丽

n,m=map(int,input().split())
trap=[int(input()) for _ in range(m)]
# print(trap)
#dp[i]表示到达位置i的总跳跃方法数
dp=[0]*(n+1)
#显然初始位置为1，到达1的方法只有一个，就是不动
dp[1]=1
for i in range(2,n+1):
  #分为5种情况 0代表可行，x代表陷阱，_代表两者皆可，依次表示的位置 i-2,i-1,i（i即为当前位置）
  # （1） _ _ x
  # （2） x x 0
  # （3） 0 x 0
  # （4） x 0 0
  # （5） 0 0 0
  #当然也有优化的办法，这里就不做优化了
  if i in trap:
    dp[i]=0
  elif (i-1 in trap) and (i-2 in trap):
    dp[i]=0
  elif (i-1 in trap) and (i-2 not in trap):
    dp[i]+=dp[i-2]
  elif (i-1 not in trap) and (i-2 in trap):
    dp[i]+=dp[i-1]
  else:
    dp[i]+=dp[i-1]+dp[i-2]
print(dp[n])

6.数字游戏

n,k,T=map(int,input().split())
ans=1
num=1
#显然除了栋栋之外的人求出其报数对结果无意义
#将结果 ans 初值设为 栋栋报的第一个数，求出栋栋报的第二个数加上去，以此类推
#那么每一次栋栋报的数是多少，报数T次，共计T-1轮，
#每轮加上 1+2+...+n  n+1+n+2+....+2n 即为 n(n+1)/2+T*n^2 （T从0开始），在取余k即可
for i in range(T-1):
  num=(num+(1+n)*n//2+i*n**2)%k
  # print(num)
  ans+=num
print(ans)

7.蚂蚁感冒

n=int(input())
alist=list(map(int,input().split()))

l=0
r=0
k=alist[0]
#这里显然剔除了比如初始感冒蚂蚁为-10，蚂蚁-5、+19单独存在时不会感冒
for i in range(1,n):
  #右边反向、左边正向均感冒
  if abs(alist[i])>abs(k) and alist[i]<0:
    r+=1
  if abs(alist[i])<abs(k) and alist[i]>0:
    l+=1
#特殊情况：感冒的蚂蚁反向，无左边正向的蚂蚁，右边反向的蚂蚁不可能感冒，
#         感冒的蚂蚁正向，无右边反向的蚂蚁，左边正向的蚂蚁不可能感冒
if k<0 and l==0:
  r=0
if k>0 and r==0:
  l=0
print(l+r+1)