77. 最长公共子序列

class Solution:
    """
    @param A: A string
    @param B: A string
    @return: The length of longest common subsequence of A and B
    """
    ‘‘‘
    存在弊端：
    可能后面的匹配后面的某一个字符会更长，他只会按照前面第一个符合条件的即返回
    ‘‘‘
    def longestCommonSubsequence(self, A, B):
        #检测边界
        if not A or not B:
            return 0

        #初始条件
        l = len(A)
        d = [1] * len(A)

        max_num = 0
        #计算顺序
        for i in range(l):
            j = B.find(A[i])   
            #边界情况
            if j != -1:
                max_num = max(self.getCommonSubsequence(A[i:],B[j:],i,j),max_num)

        return max_num

    
    def getCommonSubsequence(self,A,B,i,j):
        #传入切割后的A和B进来
        p = 0
        j = 0 
        for i in range(len(A)):
            if A[i] in B[j:]:
                p += 1
                j += B[j:].find(A[i])
        return p

class Solution:
    """
    @param A: A string
    @param B: A string
    @return: The length of longest common subsequence of A and B
    """
    def longestCommonSubsequence(self, A, B):
        # write your code here
        #动态规划，匹配型
        
        #初始化
        len1, len2 = len(A), len(B)
        #存在null的情况
        dp = [[0 for _ in range(len2 + 1)] for _ in range(len1 + 1)]
        
        #计算顺序
        for i in range(1,len1 + 1):
            for j in range(1, len2 + 1):
                #如果两者不相等，只需要判断最大即可
                dp[i][j] = max(dp[i - 1][j], dp[i][j - 1])
                #如果该A和B的字符相等，则是上一个字符加1，dp[i][j]表示的是在A的前i个字符串中，匹配j的最长个数
                if (A[i - 1] == B[j -1]):
                    #毫无疑问，这里+1肯定是最大的，会一直更新，直到最后
                    dp[i][j] = dp[i - 1][j - 1] + 1 
                
        return dp[len1][len2]