冉宝的每日一题--8月12日--子序列有进步啦

日子一天天过去了，今天居然周四了，这周一定要好好总结一下学习内容，不能浑浑噩噩的了。
刚刚吃了一个711的培根鸡蛋三明治，真的太好吃啦！
我觉得我能吃十个！
刚看了央视新闻一个《路过人间》的视频，剪辑了很多世间可爱的场景，世间真是值得啊，早点睡，今天想看流星雨呢～

我可能就是幸运小天使吧～ 今天就说今天先给继续做子序列的题目总结一下，今天leetcode每日一题刚好就是子序列～

516、最长回文子序列

题目描述

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。

子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。
示例 1：

输入：s = "bbbab"
输出：4
解释：一个可能的最长回文子序列为 "bbbb" 。

示例 2：

输入：s = "cbbd"
输出：2
解释：一个可能的最长回文子序列为 "bb" 。

提示：

1 <= s.length <= 1000
s 仅由小写英文字母组成

思路

子序列已经明白了肯定是二维动态规划。
回文序列： 就是正反一样。
可能正常的动态规划还不行，
比如：
“bbbabb” --> 最长的是5个。但是没到最后一个b的时候也不会认为是。
根据回文字符的经验，
连续的那个做法是：从中间向两边移动，中间相同的可以直接合并连起来，然后找到以该字符为中心的回文串长度。
然后我在写这个时候发现，回文子序列是不是也可以这么思考，只是倒过来

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        n = len(s)
        dp = [[0] *(n+1) for i in range(n+1)]
        max_v = 0
        s_2 = s[::-1]
        for i in range(1,n+1):
            for j in range(1,n+2-i):
                if s[i-1] == s_2[j-1]:
                    if j == n+1-i:
                        dp[i][j] = dp[i-1][j-1] + 1
                    else:
                        dp[i][j] = dp[i-1][j-1] + 2
                else:
                    dp[i][j] = max(dp[i-1][j],dp[i][j-1])
                max_v = max(max_v,dp[i][j])
        return max_v

而且因为只用到 dp[i-1],所以可以优化成滚动数组的形式，空间复杂度o(n)

优化的结果如下：
1- 只用一层列表
2- 倒序索引s，不构建s_2

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        n = len(s)
        dp_1 = [0] *(n+1)
        
        max_v = 0
        for i in range(1,n+1):
            dp = [0] *(n+1)
            for j in range(1,n+2-i):
                if s[i-1] == s[-j]:
                    if j == n+1-i:
                        dp[j] = dp_1[j-1] + 1
                    else:
                        dp[j] = dp_1[j-1] + 2
                else:
                    dp[j] = max(dp_1[j],dp[j-1])
                max_v = max(max_v,dp[j])
            dp_1 = dp[:]
        return max_v

基础题复习：

1143. 最长公共子序列

题目描述

给定两个字符串 text1 和 text2，返回这两个字符串的最长 公共子序列 的长度。如果不存在 公共子序列 ，返回 0 。

一个字符串的 子序列 是指这样一个新的字符串：它是由原字符串在不改变字符的相对顺序的情况下删除某些字符（也可以不删除任何字符）后组成的新字符串。

例如，“ace” 是 “abcde” 的子序列，但 “aec” 不是 “abcde” 的子序列。
两个字符串的 公共子序列 是这两个字符串所共同拥有的子序列。

示例 1：

输入：text1 = "abcde", text2 = "ace" 
输出：3  
解释：最长公共子序列是 "ace" ，它的长度为 3 。

示例 2：

输入：text1 = "abc", text2 = "abc"
输出：3
解释：最长公共子序列是 "abc" ，它的长度为 3 。

示例 3：

输入：text1 = "abc", text2 = "def"
输出：0
解释：两个字符串没有公共子序列，返回 0 。

提示：
1 <= text1.length, text2.length <= 1000
text1 和 text2 仅由小写英文字符组成。

思路：

所以代码：

class Solution:
    def longestCommonSubsequence(self, text1: str, text2: str) -> int:
        if not text1 or not text2:
            return 0
        m = len(text1)
        n = len(text2)
        dp = [[0] * (m+1) for i in range(n+1)]
        
        for i in range(1, n+1):
            for j in range(1, m+1):
                if text2[i-1] == text1[j-1]:
                    dp[i][j] = dp[i - 1][j - 1] + 1
                else:
                    dp[i][j] = max(dp[i][j - 1], dp[i - 1][j])
        return dp[-1][-1]