代码随想录算法训练营Day57 | 647. 回文子串 | 516. 最长回文子序列 | 动态规划总结篇

647. 回文子串

题目链接 | 解题思路

本题作为动态规划看上去很直接，可以定义 dp[i] 为 s[:i+1] 所包含的回文子串的数量。但是这个符合直觉的 dp 数组定义却没法找到对应的递推公式，因为没有办法有效利用子问题的解。

实际上，本题的 dp 子问题记录体现在了回文这个性质上：如果我们能够用 dp 来得到所有子串是否回文，那显然这道题就能够轻松拿下了。
想到这一点的一个思路是，回文本身就是一个和 dp 非常契合的性质。

dp - 回文的 boolean 记录

1. dp 数组的下标含义：dp[i][j] 记录了 s[i:j+1] 是否回文（根据定义，$i\le j$）
2. dp 递推公式：
   • 如果 s[i] != s[j]，那么显然 s[i:j+1] 不可能是个回文串，dp[i][j] = False （这大概是第一次比较的元素不相等时比较容易递推）
   • 否则，dp[i][j] 就依赖于子问题的结果。这里的递推有一些特殊情况需要讨论：
     • $i=j$，实际上在讨论一个长度为 1 的子串，当然是 dp[i][j] = True
     • $i=j-1$，实际上在讨论一个长度为 2 的子串，当然是 dp[i][j] = True
     • $i<j-1$，那么就无法直接得到结果了，只能进行递推：dp[i][j] = dp[i+1][j-1]
   • 可以看到，虽然这里是在讨论递推公式，但实际上包含一些初始化的内容（$i\le j-1$）。如果要手动在一开始进行这些初始化，那就太麻烦了。而且这些情况的讨论也能保证 $i\le j$ 的定义在递推的时候能够保证。
3. dp 数组的初始化：全部初始化为 False 即可，不会影响到后续的递推
4. dp 的遍历顺序：隔了多题，遍历顺序终于再次变得复杂了起来。
   • 根据递推公式，很明显 dp[i][j] 是依赖于左下角的值的，所以我们需要从下往上、从左往右遍历
   • 同时，我们也要在遍历时确保 $i\le j$ 的定义要求，实际上只需要数组的右上三角区域即可
5. 举例推导：s = "abcba"

class Solution:
    def countSubstrings(self, s: str) -> int:
        dp = [[False] * len(s) for _ in range(len(s))]

        result = 0
        for i in range(len(s)-1, -1, -1):
            for j in range(i, len(s)):
                if s[i] == s[j]:
                    if i >= j - 1:
                        result += 1
                        dp[i][j] = True
                    else:
                        if dp[i+1][j-1]:
                            result += 1
                            dp[i][j] = True
        return result
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(n^2)$

双指针

回文是一个非常巧妙而且有趣的性质，双指针也能在这里解题。

具体的思路是，遍历每一个字符，以当前字符为中心 / 以当前字符和右边相邻字符为中心，向左右同时进行扩散，记录在停止扩散（到达边缘或者发现不回文）之前有多少种回文子串。
这种解法利用了不同的回文子串必然有独特的（中心点，长度）的组合的性质，非常巧妙。

class Solution:
    def countSubstrings(self, s: str) -> int:
        result = 0
        for i in range(len(s)):
            result += self.extendBothSide(s, i, i)
            result += self.extendBothSide(s, i, i+1)
        return result

    def extendBothSide(self, s: str, left: int, right: int):
        count = 0
        while (left >= 0 and right < len(s)):
            if s[left] != s[right]:
                return count
            else:
                left -= 1
                right += 1
                count += 1
        return count
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(1)$
  • 注意，双指针的解法不仅得到了 $O(n^2)$ 的时间复杂度，还比 dp 大幅优化了空间，实在是巧妙。

暴力解法

时间复杂度为 $O(n^3)$ 的逆天暴力解法，跟 dp 其实完全无关（除了我自以为的 dp 命名）

class Solution:
    def countSubstrings(self, s: str) -> int:
        # dp[i] represents the number of palindromes in s[:i+1] 
        dp = [0] * len(s)
        dp[0] = 1

        for i in range(1, len(s)):
            dp[i] = dp[i-1]
            for j in range(i+1):
                if self.isPalindrome(s, j, i):
                    dp[i] += 1
        
        return dp[-1]

    def isPalindrome(self, s: str, start: int, end: int):
        while (start <= end):
            if s[start] != s[end]:
                return False
            start += 1
            end -= 1
        return True
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21

516. 最长回文子序列

题目链接 | 解题思路

本题第一眼看上去实在是要素拉满：之前的编辑问题子序列、刚刚出现的违背直觉的回文子串，看上去实在是太难了。但有了上一题对于回文子串的处理，实际上本题反而不算很难。

1. dp 数组的下标含义：dp[i][j] 是 s[i:j+1] 中最长回文子序列的长度

2. dp 递推公式：

   • 如果 s[i] == s[j]，那么可以直接利用子问题的解直接获得一个更长的回文子序列：dp[i][j] = dp[i+1][j-1] + 2
     • 这个步骤代表了问题中回文的部分，即利用回文直接进行递推
     • 在这里，我依然像上一题一样分类讨论了当前子序列的长度问题，这样更符合回文的基础状态
   • 否则，我们就要考虑删除首尾元素中的一个
     • 这个步骤代表了问题中子序列的部分，需要我们进行当前序列的编辑
     • 取子问题的最佳解，dp[i][j] = max(dp[i+1][j], dp[i][j-1])

3. dp 数组的初始化：由于我在递推公式中检查了 $i\le j-1$ 的基础情况，所以直接全部初始化为 0 即可。

4. dp 的遍历顺序：和上一题一样，根据递推公式可以看到，dp[i][j] 依赖于左下角的值，所以从下向上、从左到右遍历

5. 举例推导：s = "cbbd"

   	c	b	b	d
   c	1	1	2	2
   b	0	1	2	2
   b	0	0	1	1
   d	0	0	0	1

class Solution:
    def longestPalindromeSubseq(self, s: str) -> int:
        # dp[i][j] represents the max length of the palindrome inside s[i:j+1]
        dp = [[0] * len(s) for _ in range(len(s))]

        for i in range(len(s)-1, -1, -1):
            for j in range(i, len(s)):
                if s[i] == s[j]:
                    if i >= j - 1:
                        dp[i][j] = j - i + 1
                    else:
                        dp[i][j] = dp[i+1][j-1] + 2
                else:
                    dp[i][j] = max(dp[i+1][j], dp[i][j-1])
        
        return dp[0][-1]
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16

• 时间复杂度：$O(n^2)$
• 空间复杂度：$O(n^2)$

动态规划总结篇

动态规划总结

神一般的动规五部曲

1. 确定dp数组以及下标的含义
2. 确定递推公式
   3.dp数组如何初始化
3. 确定遍历顺序
4. 举例推导dp数组

不知不觉已经经历过了如此多的题型

• 基础：考验对于 dp 的基本理解
• 背包问题：
  • 01 背包：二维的定义，滚动数组的遍历顺序
  • 完全背包：滚动数组的遍历顺序大逆转
  • 多重背包：不过是 01背包换皮
• 打家劫舍：现代化劫匪对于状态的记录
  • 和二叉树结合的 dp 很有趣
• 股票问题：
  • 记录之前的操作状态！dp 不再是结果的直接递推，而需要检查状态
  • 状态再多也不怕
  • 冷冻期：状态有的是点有的是段
• 子序列问题
  • 子序列和子数组
  • 不要被题目描述吓到
  • 编辑距离问题
  • 回文+子序列/字数组有没有搞头

dp 问题实在是博大精深，除了解决 dp 的思路，更重要的是能够意识到题目可以用 dp 来解决。有的题目非常经典，一眼能看出来；有的题目（例如不相交的线 ，似乎完全不像 dp）。要能做到识别+解决，方为解决 dp 的真正法器。