516 最长回文子序列（区间dp）

1. 问题描述： 

给你一个字符串 s ，找出其中最长的回文子序列，并返回该序列的长度。子序列定义为：不改变剩余字符顺序的情况下，删除某些字符或者不删除任何字符形成的一个序列。

示例 1：

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

示例 2：

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

提示：

1 <= s.length <= 1000
s 仅由小写英文字母组成
来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/longest-palindromic-subsequence/

2. 思路分析：

对于子序列的相关问题我们可以尝试动态规划的思路解决，动态规划主要有两个步骤：① 状态表示 ② 状态计算。由题可知我们需要求解出整个字符串的最长回文子序列，也即求解区间 [0，len(s)] 的最长回文子序列，所以我们可以考虑区间 dp 解决，我们可以定义一个二维数组 dp（区间 dp一般定义为二维），dp[i][j] 表示区间 [i，j] 的最长回文子序列的最大长度，如何进行状态的计算呢？状态计算对应集合的划分，一般是找最后一个不同点，对于区间 [i，j] 我们可以考虑以下四种情况：① 区间 i，j 端点都包含在最长回文子序列中；② 区间端点 i 包含，端点 j 不包含在最长回文子序列中；③ 区间端点 i 不包含，端点 j 包含在最长回文子序列中；④ 区间 i，j 端点都不包含在最长回文子序列中；对于 ① 需要满足 s[i] == s[j]，所以 dp[i][j] = dp[i + 1][j - 1] + 2， 对于 ②，我们知道 dp[i][j - 1] 既包含了区间端点 i 存在的情况又包含区间端点 i 不存在的情况，所以我们是可以直接使用 dp[i][j - 1] 来计算区间 ② 的情况，对于 ③ 也是类似的，dp[i + 1][j] 既包含了区间端点 j 在又包含了区间端点 j 不在的情况，所以也是可以用 dp[i + 1][j] 来计算第 ③ 种情况（对于 ②③ 这两种情况对计算的结果是没有什么影响的），对于 ④ 可以发现是包含在 ②③ 这两种情况中的，所以我们在计算的时候只需要在 ①②③中取一个 max 即可：

3. 代码如下：

python：

class Solution:
    # 区间dp
    def longestPalindromeSubseq(self, s: str) -> int:
        n = len(s)
        dp = [[0] * n for i in range(n)]
        # 第一层枚举区间长度
        for l in range(1, n + 1):
            i = 0
            # i为区间起点, i + l - 1为区间终点
            while i + l - 1 < n:
                j = i + l - 1
                # 区间长度为1那么最长回文子序列的值为1
                if l == 1:
                    dp[i][j] = 1
                else:
                    # 区间的左右两个端点都是存在的
                    if s[i] == s[j]:
                        dp[i][j] += dp[i + 1][j - 1] + 2
                    # 计算其余两种情况, 三种情况取一个max
                    else:
                        dp[i][j] = max(dp[i][j], dp[i + 1][j], dp[i][j - 1])
                i += 1
        return dp[0][n - 1]

go：

package main

import "fmt"

func max(a, b int) int {
	if a > b {
		return a
	}
	return b
}

// 区间dp
func longestPalindromeSubseq(s string) int {
	n := len(s)
	// 初始化二维切片
	f := make([][]int, n+10)
	for i := 0; i < n+10; i++ {
		f[i] = make([]int, n+10)
	}
	// 经典的区间dp框架: 先枚举长度, 再枚举起点, 然后枚举所有以当前起点长度为l的dp值
	for l := 1; l <= n; l++ {
		i := 0
		for ; i+l-1 < n; i++ {
			j := i + l - 1
			if l == 1 {
				// 回文串的长度为1
				f[i][j] = 1
			} else {
				// 由长度较小的递推求解长度较大的当求解f[i][j]的时候那么f[i+1][j-1],f[i+1][j],f[i][j-1]肯定求解出结果了
				if s[i] == s[j] {
					f[i][j] = f[i+1][j-1] + 2
				} else {
					f[i][j] = max(f[i+1][j], f[i][j-1])
				}
			}
		}
	}
	return f[0][n-1]
}