（手撕代码）360python开发

最长公共连续子串
牛牛有两个字符串（可能包含空格）,牛牛想找出其中最长的公共连续子串,希望你能帮助他,并输出其长度。
输入描述
输入为两行字符串（可能包含空格），长度均小于等于50.
输出描述
输出为一个整数，表示最长公共连续子串的长度。
示例1
输入
abcde
abgde
输出
2

手撕的时候，还不理解动态规划，面试官毙了我。
后来下面又想了一下这道题，值等于斜线前一个值加一，并存在maxnum里。

import sys
def db(s1,s2):
    maxNum = 0
    record = [[ 0 for i in range(len(s1))]for j in range(len(s2))]
    p=0
    for i in range(len(s1)):
        for j in range(len(s2)):
            if s1[i]==s2[j]:
                # 初始值
                if i==0 and j==0:
                    record[i][j]=1
                else:
                    # 等于前一行一列值加1
                    record[i][j]=record[i-1][j-1]+1
                    if record[i][j] > maxNum:
                        maxNum = record[i][j]
                        p = i+1
    return s1[p-int(maxNum):p],maxNum

if __name__ == '__main__':
    res=[]
    s = sys.stdin.readline().strip('\n')
    while s!='':
        res.append(s)
        s = sys.stdin.readline().strip('\n')

    print(db(res[0],res[1]))

附上我在b站学习的简单动态规划：
1.求数组中是否有元素之和等于某个数

import numpy as np

def rec_subnet(arr,i,s):
    """递归求解"""
#     3个出口
    if s==0:
        return True
    elif i==0:
        return arr[0]==s
    elif arr[i]>s:
        return rec_subnet(arr,i-1,s)
    else:
        A = rec_subnet(arr,i-1,s-arr[i])
        B = rec_subnet(arr,i-1,s)
        return A or B


def db_subset(arr,S):
    """动态规划"""
    subnet = np.zeros((len(arr),S+1),dtype=bool)
    # 出口

    subnet[:,0]=True #所有行的第一列，除了第一行第一个全部为true
    subnet[0,:]=False #所有列的第一行，除了[0,3]都是FALSE
    subnet[0,arr[0]]=True  # 第一行只有当S=arr[0]时才返回true
    for i in range(1,len(arr)):
        for s in range(1,S+1):
            if arr[i]>s:
                subnet[i,s]=subnet[i-1,s] #当arr[i]比s值还大时，不考虑选择的情况。直接减一
            else:
                A=subnet[i-1,s-arr[i]] # 选择
                B=subnet[i-1,s] # 不选择
                subnet[i,s]=A or B

    r,c = subnet.shape
    return subnet[r-1,c-1]

arr = [3,34,4,12,5,2]
print(db_subset(arr,9))
print(rec_subnet(arr,len(arr)-1,9))

2.选数字，要求相加的值最大，并且前提是每个数字不相邻

import numpy as np
arr = [1,2,4,1,7,8,3]

def rec_opt(arr,i):
    '''递归'''
    if i ==0:
        return arr[0]
    elif i==1:
        return max(arr[0],arr[1])
    else:
        A = rec_opt(arr,i-2)+arr[i] #选
        B = rec_opt(arr,i-1) #不选
        return max(A,B)

def dp_opt(arr):
    opt = np.zeros(len(arr))
    opt[0]=arr[0]
    opt[1]=max(arr[0],arr[1])
    for i in range(2,len(arr)):
        A = opt[i-2]+arr[i]
        B = opt[i-1]
        opt[i]=max(A,B)
    return opt[len(arr)-1]
print(dp_opt(arr))
print(rec_opt(arr,6))  # 1,4,7,3