蓝桥三十一天刷题（python组）||第二十三天

长草

求解

3.26最后一个样例超时了，费解。。。等学了dfs之后再研究。。

3.28嗬，同样的代码，通过率100%了。

n,m=map(int,input().split())
mp=[[0 for _ in range(m)]for _ in range(n)]
a=[]
b=set()
for i in range(n):
    s=input()
    for j in range(m):
        mp[i][j]=s[j]
        if mp[i][j]=='g':
            b.add((i,j)) # 初始化草地方位集合
k=int(input())

dir=((-1,0),(0,-1),(1,0),(0,1))
for _ in range(k):
    a=list(b)
    b=set()
    for i in range(len(a)):
        for j in range(4):
            # 计算可能的草地位置，方便判断
            nx=a[i][0]+dir[j][0]
            ny=a[i][1]+dir[j][1]
            if nx>=0 and ny>=0 and nx<=n-1 and ny<=m-1 and mp[nx][ny]!='g':
                mp[nx][ny]='g'
                b.add((nx,ny))
            
for i in range(n):
    for j in range(m):
        print(mp[i][j],end='')
    print("")

##for i in mp:
##  print("".join(i))

蓝肽子序列

求解

通过率（80%）：

有2个案例超时，原因是每次dp都要对原始字符串每个元素进行遍历。

import sys
sys.setrecursionlimit(int(10e6))
s1=input()
s2=input()

n1,n2=0,0
upper_ind1,upper_ind2=[0],[0]

temp_ind=0
for c in s1:
    if c.isupper():
        n1+=1
        upper_ind1.append(temp_ind)
    temp_ind+=1

temp_ind=0
for c in s2:
    if c.isupper():
        n2+=1
        upper_ind2.append(temp_ind)
    temp_ind+=1

dp=[[0]*(n2+1) for _ in range(n1+1)]           

for i in range(1,n1+1):
    for j in range(1,n2+1):
        ok=1 # 假设满足转换条件
        dp[i][j]=max(dp[i-1][j],dp[i][j-1])
        if s1[upper_ind1[i]]==s2[upper_ind2[j]]:
            # 防越界
            if i+1<=n1 and j+1<=n2:
                if(upper_ind1[i+1]-upper_ind1[i])!=(upper_ind2[j+1]-upper_ind2[j]):
##                    ok=0 # 不满足转换条件
                    continue
                else:
                    len_=upper_ind1[i+1]-upper_ind1[i]
                    for k in range(1,len_):
                        if s1[upper_ind1[i]+k]!=s2[upper_ind2[j]+k]:
                            ok=0 
                            break
                        
            elif i==n1 and j+1<=n2:
                if len(s1[upper_ind1[i]:])!=(upper_ind2[j+1]-upper_ind2[j]):
    ##                        ok=0
                    continue
                else:
                    len_=upper_ind2[j+1]-upper_ind2[j]
                    for k in range(1,len_):
                        if s1[upper_ind1[i]+k]!=s2[upper_ind2[j]+k]:
                            ok=0 
                            break
            elif j==n2 and i+1<=n1:
                if len(s2[upper_ind2[j]:])!=(upper_ind1[i+1]-upper_ind1[i]):
    ##                        ok=0
                    continue
                else:
                    len_=upper_ind1[i+1]-upper_ind1[i]
                    for k in range(1,len_):
                        if s1[upper_ind1[i]+k]!=s2[upper_ind2[j]+k]:
                            ok=0 
                            break
            else:
                if len(s2[upper_ind2[j]:])!=len(s1[upper_ind1[i]:]):
##                         ok=0
                     continue
                else:
                    len_=len(s2[upper_ind2[j]:])
                    for k in range(1,len_):
                        if s1[upper_ind1[i]+k]!=s2[upper_ind2[j]+k]:
                            ok=0 
                            break
        else:
            ok=0
            
        if ok==1:
                dp[i][j]=dp[i-1][j-1]+1     

##for s in dp:
##    print("".join(str(s)))
print(dp[n1][n2])

改良（通过率：100%）：

读入字符串后拆分每个单词。每个单词是一个字符串，python中字符串是不可变类型，一样的字符串对应同一个内存空间，所以判断变快。另外，用单词遍历省了好多边界条件的判断。

import sys
sys.setrecursionlimit(int(10e6))

s1=input()
s2=input()

n1,n2=0,0
words1,words2=[0],[0]

word=''
for c in s1:
    if c.isupper():
        if  word!='':
            words1.append(word)
        n1+=1
        word=c
    else:
        word+=c
words1.append(word)

word=''
for c in s2:
    if c.isupper():
        if  word!='':
            words2.append(word)
        n2+=1
        word=c
    else:
        word+=c
words2.append(word)


dp = [[0]*(n2+1) for _ in range(n1+1)]
for i in range(1,n1+1):
    for j in range(1,n2+1):
        if words1[i] == words2[j]:
            dp[i][j] = dp[i-1][j-1]+1
        else:
            dp[i][j] = max(dp[i-1][j],dp[i][j-1])
print(dp[n1][n2])

占坑