647. 回文子串
题目链接:. - 力扣(LeetCode)
讲解视频:
动态规划,字符串性质决定了DP数组的定义 | LeetCode:647.回文子串
题目描述:
给你一个字符串 s
,请你统计并返回这个字符串中 回文子串 的数目。
回文字符串 是正着读和倒过来读一样的字符串。
子字符串 是字符串中的由连续字符组成的一个序列。
示例 1:
输入:s = "abc" 输出:3 解释:三个回文子串: "a", "b", "c"
解题思路:
1. 状态表示:
为了能表示出来所有的子串,我们可以创建一个 n * n 的二维 dp 表,只用到「上三角部分」
即可。其中, dp[i][j] 表示: s 字符串 [i, j] 的子串,是否是回文串。
2. 状态转移方程:
对于回文串,我们一般分析一个「区间两头」的元素:
1)当 s[i] != s[j] 的时候:不可能是回文串, dp[i][j] = 0 ;
2)当 s[i] == s[j] 的时候:根据长度分三种情况讨论:
- 长度为 1 ,也就是 i == j :此时一定是回文串, dp[i][j] = true ;
- 长度为 2 ,也就是 i + 1 == j :此时也一定是回文串, dp[i][j] = true ;
- 长度大于 2 ,此时要去看看 [i + 1, j - 1] 区间的子串是否回文: dp[i][j] = dp[i + 1][j - 1] 。
综上,状态转移方程分情况谈论即可。
3. 初始化:
因为我们的状态转移方程分析的很细致,因此无需初始化。
4. 填表顺序:
根据「状态转移方程」,我们需要「从下往上」填写每一行,每一行的顺序无所谓。
5. 返回值:
根据「状态表示和题目要求」,我们需要返回 dp 表中 true 的个数。
代码:
class Solution {
public:
int countSubstrings(string s) {
int n = s.size();
vector<vector<int>> dp(n,vector<int>(n));
int ret = 0;
for(int i = n-1; i >= 0; i--)
{
for(int j = i; j < n; j++)
{
if(s[i] != s[j]) dp[i][j] = false;
else
{
if(i == j || i + 1 == j) dp[i][j] = true;
else dp[i][j] = dp[i+1][j-1];
}
if(dp[i][j]) ret++;
}
}
return ret;
}
};
1745.回文串分割IV
题目链接:. - 力扣(LeetCode)
题目描述:
给你一个字符串 s
,如果可以将它分割成三个 非空 回文子字符串,那么返回 true
,否则返回 false
。当一个字符串正着读和反着读是一模一样的,就称其为 回文字符串 。
示例 1:
输入:s = "abcbdd" 输出:true 解释:"abcbdd" = "a" + "bcb" + "dd",三个子字符串都是回文的。
解题思路:
我们可以把它拆成「两个小问题」:
- 动态规划求解字符串中的一段非空子串是否是回文串;
- 枚举三个子串除字符串端点外的起止点,查询这三段非空子串是否是回文串。
那么这道困难题就免秒变为简单题啦,变成了一道枚举题。
代码:
class Solution {
public:
bool checkPartitioning(string s) {
int n = s.size();
vector<vector<int>> dp(n,vector<int>(n));
for(int i = n-1; i >= 0; i--)
for(int j = i; j < n; j++)
if(s[i] == s[j])
dp[i][j] = (i == j || i + 1 == j) ? true : dp[i+1][j-1];
for(int i = 1; i < n; i++)
{
for(int j = i+1; j < n; j++)
{
if(dp[0][i-1] && dp[i][j-1] && dp[j][n-1]) return true;
}
}
return false;
}
};
132.回文串分割Ⅱ
题目链接:. - 力扣(LeetCode)
题目描述:
给你一个字符串 s
,请你将 s
分割成一些子串,使每个子串都是
回文串。返回符合要求的 最少分割次数 。
示例 1:
输入:s = "aab" 输出:1 解释:只需一次分割就可将 s 分割成 ["aa","b"] 这样两个回文子串。
解题思路:
1. 状态表示:
dp[i] 表示: s 中 [0, i] 区间上的字符串,最少分割的次数。
2. 状态转移方程:
状态转移方程一般都是根据「最后一个位置」的信息来分析:设 0 <= j <= i ,那么我们可以
根据 j ~ i 位置上的子串是否是回文串分成下面两类:
1)当 [j ,i] 位置上的子串能够构成一个回文串,那么 dp[i] 就等于 [0, j - 1] 区间上最少回文串的个数 + 1,即dp[i] = dp[j - 1] + 1 ;
2)当 [j ,i] 位置上的子串不能构成一个回文串,此时 j 位置就不用考虑。由于我们要的是最小值,因此应该循环遍历一遍 j 的取值,拿到里面的最小值即可。
优化:我们在状态转移方程里面分析到,要能够快速判读字符串里面的子串是否回文。因此,我们可以先处理一个 dp 表,里面保存所有子串是否回文的信息。
3. 初始化:
为了防止求 min 操作时, 0 干扰结果。我们先把表里面的值初始化为「无穷大」。
4. 填表顺序:
毫无疑问是「从左往右」。
5. 返回值:
根据「状态表示」,应该返回 dp[n - 1] 。
代码:
class Solution {
public:
int minCut(string s) {
int n = s.size();
vector<vector<int>> dp(n,vector<int>(n));
vector<int> result(n,INT_MAX);
result[0] = 0;
for(int i = n - 1; i >= 0; i--)
for(int j = i; j < n; j++)
if(s[i] == s[j])
dp[i][j] = (i == j || i + 1 == j) ? true : dp[i+1][j-1];
for(int i = 1; i < n; i++)
if(dp[0][i]) result[i] = 0;
else
{
for(int j = i; j >= 1; j--)
if(dp[j][i]) result[i] = min(result[i],result[j-1] + 1);
}
return result[n - 1];
}
};
5.最长回文子串
题目链接:. - 力扣(LeetCode)
题目描述:
给你一个字符串 s
,找到 s
中最长的
回文子串。
示例 1:
输入:s = "babad" 输出:"bab" 解释:"aba" 同样是符合题意的答案。
解题思路:
a. 先用 dp 表统计出「所有子串是否回文」的信息
b. 然后根据 dp 表示 true 的位置,得到回文串的「起始位置」和「长度」。
那么就可以在表中找出最长回文串。
代码:
class Solution {
public:
string longestPalindrome(string s) {
int n = s.size();
vector<vector<bool>> dp(n,vector<bool>(n));
int left = 0, cnt = 0;
for(int i = n - 1; i >= 0; i--)
{
for(int j = i; j < n; j++)
{
if(s[i] == s[j])
{
dp[i][j] = (i == j || i + 1 == j) ? true : dp[i+1][j-1];
if(dp[i][j] && j - i + 1 > cnt) left = i, cnt = j - i + 1;
}
}
}
return s.substr(left,cnt);
}
};
516.最长回文子序列
题目链接:. - 力扣(LeetCode)
讲解视频:
题目描述:
给你一个字符串 s
,找出其中最长的回文子序列,并返回该序列的长度。
子序列定义为:不改变剩余字符顺序的情况下,删除某些字符或者不删除任何字符形成的一个序列。
示例 1:
输入:s = "bbbab" 输出:4 解释:一个可能的最长回文子序列为 "bbbb" 。
解题思路:
1. 状态表示:
dp[i][j] 表示:s 字符串 [i, j] 区间内的所有的子序列中,最长的回文子序列的长度。
2. 状态转移方程:
关于「回文子序列」和「回文子串」的分析方式,一般都是比较固定的,都是选择这段区域的「左右端点」的字符情况来分析。因为如果一个序列是回文串的话,「去掉首尾两个元素之后依旧是回文串」,「首尾加上两个相同的元素之后也依旧是回文串」。因为,根据「首尾元素」的不同,可以分为下面两种情况:
1)当首尾两个元素「相同」的时候,也就是 s[i] == s[j] :那么 [i, j] 区间上的最长回文子序列,应该是 [i + 1, j - 1] 区间内的那个最长回文子序列首尾填上s[i] 和 s[j] ,此时 dp[i][j] = dp[i + 1][j - 1] + 2;
2)当首尾两个元素不「相同」的时候,也就是 s[i] != s[j] :此时这两个元素就不能同
时添加在一个回文串的左右,那么我们就应该让 s[i] 单独加在一个序列的左边,或者
让 s[j] 单独放在一个序列的右边,看看这两种情况下的最大值:
- 单独加入 s[i] 后的区间在 [i, j - 1] ,此时最长的回文序列的长度就是 dp[i][j - 1] ;
- 单独加入 s[j] 后的区间在 [i + 1, j] ,此时最长的回文序列的长度就是 dp[i+ 1][j] ;
取两者的最大值,于是 dp[i][j] = max(dp[i][j - 1], dp[i + 1][j]),综上所述,状态转移方程为:
- 当 s[i] == s[j] 时: dp[i][j] = dp[i + 1][j - 1] + 2
- 当 s[i] != s[j] 时: dp[i][j] = max(dp[i][j - 1], dp[i + 1][j])
3. 初始化:
我们的初始化一般就是为了处理在状态转移的过程中,遇到的一些边界情况,因为我们需要根据状态转移方程来分析哪些位置需要初始化。
根据状态转移方程 dp[i][j] = dp[i + 1][j - 1] + 2 ,我们状态表示的时候,选取的是一段区间,因此需要要求左端点的值要小于等于右端点的值,因此会有两种边界情况:
- 当 i == j 的时候, i + 1 就会大于 j - 1 ,此时区间内只有一个字符。这个比较好分析, dp[i][j] 表示一个字符的最长回文序列,一个字符能够自己组成回文串,因此此时 dp[i][j]=1 ;
- 当 i + 1 == j 的时候, i + 1 也会大于 j - 1 ,此时区间内有两个字符。这样也好分析,当这两个字符相同的时候, dp[i][j] = 2 ;不相同的时候, d[i][j] =0 。
对于第一种边界情况,我们在填表的时候,就可以同步处理。
对于第二种边界情况, dp[i + 1][j - 1] 的值为 0 ,不会影响最终的结果,因此可以不用
考虑。
4. 填表顺序:
根据「状态转移」,我们发现,在 dp 表所表示的矩阵中, dp[i + 1] 表示下一行的位置,
dp[j - 1] 表示前一列的位置。因此我们的填表顺序应该是「从下往上填写每一行」,「每一
行从左往右」。这个与我们一般的填写顺序不太一致。
5. 返回值:
根据「状态表示」,我们需要返回 [0, n -1] 区域上的最长回文序列的长度,因此需要返回
dp[0][n - 1] 。
代码:
class Solution {
public:
int longestPalindromeSubseq(string s) {
int n = s.size();
vector<vector<int>> dp(n,vector<int>(n));
int ret = 0;
for(int i = n - 1; i >= 0; i--)
{
for(int j = i; j < n; j++)
{
if(s[i] == s[j])
{
if(i == j) dp[i][j] = 1;
else if(i + 1 == j) dp[i][j] = 2;
else dp[i][j] = dp[i+1][j-1] + 2;
}
else
dp[i][j] = max(dp[i+1][j],dp[i][j-1]);
ret = max(ret,dp[i][j]);
}
}
return ret;
}
};