数据结构算法——字符串

概述

该博客结合leetcode原题介绍了针对字符串的常见题目。

例题

2.1 最长重复子数组

#leetcode 718. 最长重复子数组

（1）使用动态规划
时间复杂度O（N^2)
空间复杂度O（N^2)

class Solution(object):
    def findLength(self, A, B):
        """
        :type A: List[int]
        :type B: List[int]
        :rtype: int
        """
        m,n = len(A),len(B)
        dp = [[0]*(n+1) for _ in range(m+1)]
        
        for i in range(m):
            for j in range(n):
                if A[i]==B[j]:
                    dp[i+1][j+1]=dp[i][j]+1
                    
        return max(max(row) for row in dp)
                    
            

2.2 最长回文子串

（1）使用动态规划

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        if s=="":
            return ""
        max_length = 1
        ret = s[0]

        dp = [[False] * len(s) for _ in range(len(s))]  # 初始化
        for i in range(len(s)):  # 初始化
            dp[i][i] = True
        for i in range(len(s) - 1):  # 初始化
            if s[i] == s[i + 1]:
                dp[i][i + 1] = True
                if max_length<2:
                    max_length = 2
                    ret = s[i:i+2]


        for l in range(3, len(s)+1):  # 回文串长度
            for m in range(len(s)):  # 位置
                if m + l - 1 < len(s):
                    if dp[m + 1][m + l - 2] and s[m] == s[m + l - 1]:
                        dp[m][m + l - 1] = True
                        if max_length < l:
                            max_length = l
                            ret = s[m:m + l]
        return ret

(3)技巧

class Solution(object):
    def longestPalindrome(self, s):
        """
        :type s: str
        :rtype: str
        """
        max_length = 0
        start = 0

        for i in range(len(s)):
            if i-max_length>=1 and s[i-max_length-1:i+1]==s[i-max_length-1:i+1][::-1]:
                start = i-max_length-1
                max_length += 2
                continue
            if i-max_length>=0 and s[i-max_length:i+1]==s[i-max_length:i+1][::-1]:
                start = i-max_length
                max_length += 1

        return s[start:start+max_length]

2.3 正则表达式

#Leetcode 10 正则表达式
该题是让我们判断两个字符串是否匹配，其中一个为正则表达式，另一个为字符串。
（1）递归
*时间复杂度：
*空间复杂度：

class Solution(object):
    def isMatch(self, s, p):
        # 如果p为空，且s为空，返回True；如果p为空，且s不为空，返回False
        if not p:
            if not s:
                return True
            else:
                return False
        # 如果p长度为1，且s长度为1，且s==p或p是'.'，则返回True，否则返回False
        if len(p)==1:
            return len(s)==1 and (s[0]==p[0] or p[0]=='.')
        # 如果p的第二个字符不为'*'，
            # s为空则返回False；
            # s不为空则递归调用isMatch函数（当s[0]==p[0]时或者p[0]=='.'时，isMatch剩余的返回True，则总体返回True）
        if p[1]!='*':
            if not s:
                return False
            else:
                return (s[0]==p[0] or p[0]=='.') and self.isMatch(s[1:], p[1:])
        # 剩下来的可能性是：p长度大于等于2，且p[1]是'*'
        while s and (s[0]==p[0] or p[0]=='.'):
            # 由于'*'是>=0个，因此去掉p[0:2]如果和s一样的话，返回True（表示不利用p[0:2]这部分）
            if self.isMatch(s, p[2:]):
                return True
            # 不一致的话，那就是要利用p[0:2]这部分来匹配，由于s[0]和p[0]是匹配的，那么把s[0]去掉不影响匹配，继续循环
            s = s[1:]
        # 如果上述情况都不符合，那剩下来的可能性就是：（p程度大于等于2，且p[1]是'*'）或者s就是空的
        return self.isMatch(s, p[2:])

参考

[1] https://www.cnblogs.com/grandyang/p/4461713.html