代码随想录算法训练营Day57 | 647. 回文子串、516. 最长回文子序列

647. 回文子串

这题重点是DP数组的定义，注意与编辑距离类型题目的差别

1、DP数组定义： dp[i][j] 为bool，表示区间 [i, j] 的子串是否是回文串

2、DP数组初始化：初始化为true或false都可以，只是后面写法不一样

3、递推公式：

        · 当 s[i] != s[j] 时，头尾不相等肯定不是回文串：

                        dp[i][j] = false

        · 当s[i] == s[j] 时，分以下情况：

                情况1：i == j，只有一个字符的字符串是回文串

                情况2：i是j前一位，是回文串

                情况3：j - i > 1，是否是回文串依赖[i + 1, j - 1]子串是否是回文串

                （情况1、2都是为了情况3顺利递推做的铺垫）

4、遍历顺序：i 依赖 i + 1，j 依赖 j - 1，所以从下向上、从左向右遍历

int countSubstrings(string s) {
	// dp[i][j]表示[i, j]子串是否是回文串
	vector<vector<bool>> dp(s.size(), vector<bool>(s.size(), true));

	int ans = 0;
	// i从后向前遍历，j从前向后遍历
	for (int i = s.size() - 1; i >= 0; --i) {
		for (int j = i; j < s.size(); ++j) {
			// 头尾不相等肯定不是回文串
			if (s[i] != s[j])
				dp[i][j] = false;
			// 头尾相等则分情况讨论
			else {
				// 情况1：i == j，是回文串
				if (i == j)
					++ans;
				// 情况2：i是j前一位，是回文串
				else if (i == j - 1)
					++ans;
				// 其余情况：是否是回文串依赖[i + 1, j - 1]子串是否是回文串
				else {
					dp[i][j] = dp[i + 1][j - 1];
					if (dp[i][j]) ++ans;
				}
			}
		}
	}
	return ans;
}

---

 516. 最长回文子序列 

 掌握了上一题的DP数组定义这题还是蛮简单的

1、DP数组定义： dp[i][j] 为bool，表示区间 [i, j] 内的最长回文子序列长度

2、DP数组初始化：可以初始化为1，也可以不初始化，后面写法稍微不同而已

3、递推公式：

        · 当 s[i] != s[j] 时：不取s[i]、不取s[j]、s[i]与s[j]都不取，三种情况中取最大（前两种情况包含了第三种情况，所以实际只有两种）

                        dp[i][j] = max(dp[i + 1][j], dp[i][j - 1])

        · 当s[i] == s[j] 时，分以下情况：

                情况1：j - i <= 1，子串就是回文串，dp[i][j]等于子串长度，即 ：

              （dp数组初始化为1时可省略这种情况）

                                dp[i][j] = j - i + 1

                情况2：在 [i + 1, j - 1] 区间的基础上加上左右两个字符，即：

                                dp[i][j] = dp[i + 1][j - 1] + 2

4、遍历顺序：i 依赖 i + 1，j 依赖 j - 1，所以从下向上、从左向右遍历

int longestPalindromeSubseq(string s) {
	vector<vector<int>> dp(s.size(), vector<int>(s.size(), 0));

	for (int i = s.size() - 1; i >= 0; --i) {
		for (int j = i; j < s.size(); ++j) {
			// 不相等时：不取s[i]、不取s[j]、s[i]与s[j]都不取，三种情况中取最大
			// （前两种情况包含了第三种情况，所以实际只有两种）
			if (s[i] != s[j])
				dp[i][j] = std::max(dp[i + 1][j], dp[i][j - 1]);
			else {
				if (j - i <= 1)
					dp[i][j] = j - i + 1;
				else
					dp[i][j] = dp[i + 1][j - 1] + 2;		
			}
		}
	}
	// 返回整个字符串中的最长回文子序列
	return dp[0][s.size() - 1];
}

---

动态规划章节完结撒花！！！！！