字串与子序列系列问题

目录

• 最大子串和
• 无重复字符的最长子串
• 最长递增子序列
• 编辑距离

最大子串和

最大子串和

class Solution(object):
    def maxSubArray(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        ans, pre_sum = -1e4 - 1, 0

        for i in nums:
            
            if pre_sum < 0: pre_sum = 0
            pre_sum += i
            ans = max(ans, pre_sum)
        
        return ans

无重复字符的最长子串

无重复字符的最长子串

class Solution:
    def lengthOfLongestSubstring(self, s: str) -> int:

        visit, ans, l, start = {}, 0, len(s), -1

        for i in range(l):
            
            if s[i] in visit: start = max(start, visit[s[i]])
            
            ans = max(ans, i - start)
            visit[s[i]] = i

        return ans

最长递增子序列

最长递增子序列

\(dp[i]\) 表示以 \(nums[i]\) 结尾的最长递增子序列长度为 \(dp[i]\), \(O(n^2)\) 时间复杂度度.

class Solution(object):
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dp, l = [], len(nums)
        for i in range(l):
            dp.append(1)
            for j in range(i):
                if nums[i] > nums[j]: dp[-1] = max(dp[-1], dp[j] + 1)
        
        return max(dp)

\(dp[i]\) 表示长度为 \(i\) 的最长递增子序列的最后一位的最小值情况为 \(dp[i]\), \(O(n\log n)\) 时间复杂度度.

class Solution(object):
    def lengthOfLIS(self, nums):
        """
        :type nums: List[int]
        :rtype: int
        """
        dp, l = [], len(nums)
        for i in range(l):
            if len(dp) == 0 or nums[i] > dp[-1]: dp.append(nums[i])
            else:
                l, r, loc = 0, len(dp) - 1, len(dp) - 1
                while l <= r:
                    mid = (l + r) // 2
                    if dp[mid] < nums[i]: l = mid + 1
                    else: loc, r = mid, mid - 1
                dp[loc] = nums[i]
        
        return len(dp)

编辑距离

编辑距离

对单词 A 删除一个字符和对单词 B 插入一个字符是等价的, 只考虑插入与修改两个操作即可.

class Solution(object):
    def minDistance(self, word1, word2):
        """
        :type word1: str
        :type word2: str
        :rtype: int
        """
        m, n = len(word1), len(word2)
        dp = [[505 for i in range(n + 1)] for j in range(m + 1)]

        for i in range(m + 1): dp[i][0] = i
        for i in range(n + 1): dp[0][i] = i

        for i in range(1, m + 1):
            for j in range(1, n + 1):
                if word1[i - 1] == word2[j - 1]:
                    dp[i][j] = min(dp[i][j], dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1])
                else:
                    dp[i][j] = min(dp[i][j], dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + 1)
        
        return dp[m][n]