Python—天梯赛第九届L1-L2详细题解_四项全能 python-优快云博客

本文链接：https://blog.youkuaiyun.com/Ice_cream_0712/article/details/146609235

L1-1 编程解决一切

print('Problem? The Solution: Programming.')

L1-2 再进去几个人

A,B=map(int,input().split())
print(B-A)

L1-3 帮助色盲

#a 交通灯颜色 0红灯 1绿灯 2黄灯
#b 行人状态 0前方两米没有人  1有
a,b=map(int,input().split())
if a==2:
    #黄灯可以自行判断 不需要提示
    print('-')
    print('stop')
else:
    #非黄灯，无法自行判断 要看前方两米有没有同向的人
    if b==1:
        #如果有，无需提示 跟着别人走
        print('-')
        if a == 0:
            # 红灯
            print('stop')
        else:
            #绿灯
            print('move')
    else:
        #没有，需要提示
        if a==0:
            #红灯
            print('biii')
            print('stop')
        else:
            #红灯
            print('dudu')
            print('move')

L1-4 四项全能

#n 总人数 m技能项数
n,m=map(int,input().split())
#a[i] 第i个技能会的人数
a=list(map(int,input().split()))
suma=sum(a)
#假设每个人都会m-1个技能点  那么就是n*(m-1)个 但实际总共是suma个
#如果suma>n*(m-1)  那么只用让剩下的suma-n*(m-1)个人承担剩下的技能点就好了
#如果<=  是0个
ans=max(0,suma-n*(m-1))
print(ans)

L1-5 别再来这么多猫娘了！

n=int(input())
baned=[]
for i in range(n):
    baned.append(input())
k=int(input())
s=input()
cnt=0
for ss in baned:
    #计数
    cnt+=s.count(ss)
    # print(ss,s.count(ss))
    #先替换为-
    if ss in s:
        s=s.replace(ss,'-')
# print(cnt)
if cnt<k:
    #小于阈值 输出替换后的文本
    s=s.replace('-','<censored>')
    print(s)
else:
    #大于等于阈值
    print(cnt)
    print('He Xie Ni Quan Jia!')

L1-6 兰州牛肉面

n=int(input())
price=[0]+list(map(float,input().split()))
sale=[0]*(n+1)
while True:
    i,nums=map(int,input().split())
    if i==0:break
    sale[i]+=nums
for i in range(1,n+1):
    print(sale[i])
tot=sum([price[i]*sale[i] for i in range(1,n+1)])
print("{:.2f}".format(tot))

L1-7 整数的持续性

from collections import defaultdict
def f(x,length):
    if len(str(x))==1:
        return length
    ans=1
    while x:
        ans*=x%10
        x//=10
    return f(ans,length+1)

ans=0
res=defaultdict(list)
a,b=map(int,input().split())
for i in range(a,b+1):
    if f(i,0)>=ans:
        ans=f(i,0)
        res[ans].append(i)
res[ans].sort()
print(ans)
print(*res[ans])

L1-8 九宫格

n=int(input())
for i in range(n):
    flag=1
    Map=[]
    for j in range(9):
        #每一行
        row=list(map(int,input().split()))
        Map.append(row)
        if len(set(row))<9:
            flag=0
    if flag==0:
        print(0)
        continue

    #列
    for k in range(9):
        #行
        viscol=set()
        for z in range(9):
            if Map[z][k] in viscol:
                flag=0
            viscol.add(Map[z][k])
    if flag==0:
        print(0)
        continue

    #枚举宫位
    for box in range(9):
        start_row=(box//3)*3
        start_col=(box%3)*3
        # 检查每个宫位
        vis = set()
        #行
        for j in range(3):
            #列
            for k in range(3):
                row=start_row+j
                col=start_col+k
                if Map[row][col] in vis or Map[row][col]>9 or Map[row][col]<1:
                    flag=0

                vis.add(Map[row][col])
    if flag==0:
        print(0)
        continue
    else:
        print(1)

L2-1 鱼与熊掌

这道题我没找到完全通过的解，目前13/25，有三个测试点用列表超时，改用字典＋集合内存超限，真不知道还能怎么改了，希望网友们支支招！

import sys
from collections import defaultdict
input=sys.stdin.readline
n,m=map(int,input().split())
dic=defaultdict(set)
for i in range(n):
    numbers=list(map(int,input().split()))
    for num in numbers[1:]:
        dic[num].add(i)

q=int(input())
for i in range(q):
    x,y=map(int,input().split())
    print(len(dic[x]&dic[y]))

L2-2 懂蛇语

！！！这道题注意，不要使用循环拼接字符串，会超时！！！

'''
全对 坑点就是空格  原本的格式不能变 多个空格的不能消掉
'''
import sys
sys.setrecursionlimit(100000)
from collections import defaultdict
dic=defaultdict(list)
n=int(input())
for i in range(n):
    sens=input()
    sentence=sens.split()
    s=''.join([word[0] for word in sentence])
    dic[s].append(sens)
for k,v in dic.items():
    dic[k].sort()

# print(dic)
m=int(input())
for i in range(m):
    q=input()
    query=q.split()
    s = ''.join([word[0] for word in query])
    if s not in dic:
        print(q)
    else:
        print('|'.join(dic[s]))

L2-3 满树的遍历

import bisect
n=int(input())
root=0
G=[[] for i in range(n+1)]
for i in range(1,n+1):
    fa=int(input())
    if fa==0:
        root=i
    else:
        idx=bisect.bisect_right(G[fa],i)
        G[fa].insert(idx,i)
# print(G)
#前序遍历  根左右
pre=[root]
deep=0
flag=1
def dfs(u):
    for v in G[u]:
        global deep
        pre.append(v)
        if G[u]==[]:continue
        deep = max(deep, len(G[u]))
        if len(G[u])!=deep:
            global flag
            flag=0
        dfs(v)
dfs(root)
if flag:
    print(deep,'yes')
else:
    print(deep,'no')
print(*pre)

L2-4 吉利矩阵

这道题也是不能完全通过，一个测试点超时，真不知道还能怎么优化了呜呜！

import sys
sys.setrecursionlimit(1000000)
input = sys.stdin.readline
l, n = map(int, input().split())
row_sums = [0] * n
col_sums = [0] * n

def dfs(depth):
    if depth == n * n:
        if all(s == l for s in row_sums) and all(s == l for s in col_sums):
            return 1
        else:
            return 0

    x = depth // n
    y = depth % n

    # 剪枝：如果当前行或列的和已经超过l，直接返回
    if row_sums[x] > l or col_sums[y] > l:
        return 0

    #当前行还剩下几列没有填
    remaining_in_row = n - y
    #这一行能填的最大的值  或者说还需要填的值
    max_row_fill = l - row_sums[x]

    #当前列还剩下几行没有填
    remaining_in_col = n - x
    #这一列能填的最大的数，或者说还需要填的值
    max_col_fill = l - col_sums[y]
    #当前能填的最大值和最小值
    max_val = min(max_row_fill, max_col_fill)
    min_val = max(0, max_row_fill - (remaining_in_row - 1) * l,
                    max_col_fill - (remaining_in_col - 1) * l)

    cnt = 0
    for i in range(min_val, max_val + 1):
        flag=0
        # 如果已经到了最后一行 可以直接填了
        if x == n-1:
            flag=1
            i=l-col_sums[y]
        elif y==n-1:
            flag=1
            i=l-row_sums[x]
        row_sums[x] += i
        col_sums[y] += i
        cnt += dfs(depth + 1)
        row_sums[x] -= i
        col_sums[y] -= i
        if flag:break
    return cnt

print(dfs(0))