文章目录
- [647. 回文子串](#647. 回文子串)
- [516. 最长回文子序列](#516. 最长回文子序列)
- 动态规划总结篇
647. 回文子串
本题作为动态规划看上去很直接，可以定义 dp[i] 为 s[:i+1] 所包含的回文子串的数量。但是这个符合直觉的 dp 数组定义却没法找到对应的递推公式，因为没有办法有效利用子问题的解。
实际上，本题的 dp 子问题记录体现在了回文 这个性质上：如果我们能够用 dp 来得到所有子串是否回文，那显然这道题就能够轻松拿下了。
想到这一点的一个思路是，回文本身就是一个和 dp 非常契合的性质。
dp - 回文的 boolean 记录
- dp 数组的下标含义：
dp[i][j]记录了s[i:j+1]是否回文（根据定义， i ≤ j i \leq j i≤j） - dp 递推公式：
- 如果
s[i] != s[j]，那么显然s[i:j+1]不可能是个回文串，dp[i][j] = False（这大概是第一次比较的元素不相等时比较容易递推） - 否则，
dp[i][j]就依赖于子问题的结果。这里的递推有一些特殊情况需要讨论：- i = j i = j i=j，实际上在讨论一个长度为 1 的子串，当然是
dp[i][j] = True - i = j − 1 i = j - 1 i=j−1，实际上在讨论一个长度为 2 的子串，当然是
dp[i][j] = True - i < j − 1 i < j-1 i<j−1，那么就无法直接得到结果了，只能进行递推：
dp[i][j] = dp[i+1][j-1]
- i = j i = j i=j，实际上在讨论一个长度为 1 的子串，当然是
- 可以看到，虽然这里是在讨论递推公式，但实际上包含一些初始化的内容（ i ≤ j − 1 i \leq j-1 i≤j−1）。如果要手动在一开始进行这些初始化，那就太麻烦了。而且这些情况的讨论也能保证 i ≤ j i \leq j i≤j 的定义在递推的时候能够保证。
- 如果
- dp 数组的初始化：全部初始化为
False即可，不会影响到后续的递推 - dp 的遍历顺序：隔了多题，遍历顺序终于再次变得复杂了起来。
- 根据递推公式，很明显
dp[i][j]是依赖于左下角的值的，所以我们需要从下往上、从左往右遍历 - 同时，我们也要在遍历时确保 i ≤ j i \leq j i≤j 的定义要求，实际上只需要数组的右上三角区域即可
- 根据递推公式，很明显
- 举例推导：
s = "abcba"
| a | b | c | b | a | |
|---|---|---|---|---|---|
| a | True | False | False | False | True |
| b | False | True | False | True | False |
| c | False | False | True | False | False |
| b | False | False | False | True | False |
| a | False | False | False | False | True |
python
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- 时间复杂度： O ( n 2 ) O(n^2) O(n2)
- 空间复杂度： O ( n 2 ) O(n^2) O(n2)
双指针
回文是一个非常巧妙而且有趣的性质，双指针也能在这里解题。
具体的思路是，遍历每一个字符，以当前字符为中心 / 以当前字符和右边相邻字符为中心，向左右同时进行扩散，记录在停止扩散（到达边缘或者发现不回文）之前有多少种回文子串。
这种解法利用了不同的回文子串必然有独特的（中心点，长度）的组合的性质，非常巧妙。
python
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- 时间复杂度： O ( n 2 ) O(n^2) O(n2)
- 空间复杂度： O ( 1 ) O(1) O(1)
- 注意，双指针的解法不仅得到了 O ( n 2 ) O(n^2) O(n2) 的时间复杂度，还比 dp 大幅优化了空间，实在是巧妙。
暴力解法
时间复杂度为 O ( n 3 ) O(n^3) O(n3) 的逆天暴力解法，跟 dp 其实完全无关（除了我自以为的 dp 命名）
python
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 True516. 最长回文子序列
本题第一眼看上去实在是要素拉满：之前的编辑问题子序列 、刚刚出现的违背直觉的回文子串，看上去实在是太难了。但有了上一题对于回文子串的处理，实际上本题反而不算很难。
-
dp 数组的下标含义：
dp[i][j]是s[i:j+1]中最长回文子序列的长度 -
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])
- 如果
-
dp 数组的初始化：由于我在递推公式中检查了 i ≤ j − 1 i\leq j-1 i≤j−1 的基础情况，所以直接全部初始化为 0 即可。
-
dp 的遍历顺序：和上一题一样，根据递推公式可以看到，
dp[i][j]依赖于左下角的值，所以从下向上、从左到右遍历 -
举例推导：
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
python
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]- 时间复杂度： O ( n 2 ) O(n^2) O(n2)
- 空间复杂度： O ( n 2 ) O(n^2) O(n2)
动态规划总结篇
神一般的动规五部曲
- 确定dp数组以及下标的含义
- 确定递推公式
3.dp数组如何初始化 - 确定遍历顺序
- 举例推导dp数组
不知不觉已经经历过了如此多的题型
- 基础：考验对于 dp 的基本理解
- 背包问题：
- 01 背包：二维的定义，滚动数组的遍历顺序
- 完全背包：滚动数组的遍历顺序大逆转
- 多重背包：不过是 01背包换皮
- 打家劫舍：现代化劫匪对于状态的记录
- 和二叉树结合的 dp 很有趣
- 股票问题：
- 子序列问题
- 子序列和子数组
- 不要被题目描述吓到
- 编辑距离问题
- 回文+子序列/字数组有没有搞头
dp 问题实在是博大精深，除了解决 dp 的思路，更重要的是能够意识到题目可以用 dp 来解决。有的题目非常经典，一眼能看出来；有的题目（例如不相交的线 ，似乎完全不像 dp）。要能做到识别+解决，方为解决 dp 的真正法器。