Leetcode：647. 回文子串、516. 最长回文子序列（C++）

目录

647. 回文子串

题目描述：

实现代码与解析：

动态规划

原理思路:

简洁代码

516. 最长回文子序列

题目描述：

实现代码与解析：

动态规划

原理思路：

---

647. 回文子串

题目描述：

        给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。        

示例 1：

输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"

示例 2：

输入：s = "aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

提示：

• 1 <= s.length <= 1000
• s 由小写英文字母组成

实现代码与解析：

动态规划

class Solution {
public:
    int countSubstrings(string s) 
    {
vector<vector<int>> f(s.size(), vector<int>(s.size(), 0));
	int res = 0;
	
	// 初始化长度为1的 
	for (int i = 0; i < s.size(); i++)
		for (int j = 0; j < s.size(); j++)
			if (i == j)
			{
				f[i][j] = 1;
				res++;
			}

	// 初始化长度为2的 
	for (int i = 0; i + 2 - 1 < s.size(); i++)
	{
		int j = i + 2 - 1;
		if (s[i] == s[j]) 
		{
			f[i][j] = 1;
			res++;	
		} 
	} 

    for (int len = 3; len <= s.size(); len++)
    {
         for (int i = 0; i + len - 1 < s.size(); i++)
         {
            int j = i + len - 1;
            if (s[i] == s[j] && f[i + 1][j - 1] == 1)
            {
            	f[i][j] = 1;
            	res++;
			}
            else f[i][j] = 0;
         }
    }
	return res;	     
    }
};

原理思路:

        有点像区间dp。

        这里最好先遍历len也就是长度，这样就不用考虑后面遍历向前，向后的问题了。

        dp[i][j]数组的含义是下标 i 到下标 j 的子串是否为回文，若回文则为1，不回文为0。

        显然，单个字符的子串肯定为回文串，初始化为1。

        当不为单个子串时，若子串两侧字符相同，并且去掉两侧的字符中间子串也为回文，则整个子串为回文的，很容易写出：

if (s[i] == s[j] && f[i + 1][j - 1] == 1)
{
    f[i][j] = 1;
    res++;
}

        但是这样有一个问题，就是当子串长度为2时，子串两侧字符相等就不在适用了，因为i + 1，j -1 后就错开了，所以我们单独写长度为2时的递推式。 

	// 初始化长度为2的 
	for (int i = 0; i + 2 - 1 < s.size(); i++)
	{
		int j = i + 2 - 1;
		if (s[i] == s[j]) 
		{
			f[i][j] = 1;
			res++;	
		} 
	} 

        当然我们也可以判断一下长度，来执行不同的代码来让代码简短一点。

简洁代码

class Solution {
public:
    int countSubstrings(string s) 
    {
        vector<vector<int>> f(s.size(), vector<int>(s.size(), 0));
        int res = 0;

        for (int len = 1; len <= s.size(); len++)
        {
            for (int i = 0; i + len - 1 < s.size(); i++)
            {
                int j = i + len - 1;
                if (s[i] == s[j] && j - i <= 1)
                {
                    f[i][j] = 1;
                    res++;
                }
                else if (s[i] == s[j] && f[i + 1][j - 1] == 1 && j - i > 1)
                {
                    f[i][j] = 1;
                    res++;
                }
                else f[i][j] = 0;
            }
        }
        return res;	     
    }
};

516. 最长回文子序列

题目描述：

        给你一个字符串 s ，请你统计并返回这个字符串中 回文子串 的数目。

回文字符串 是正着读和倒过来读一样的字符串。

子字符串 是字符串中的由连续字符组成的一个序列。

具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。

示例 1：

输入：s = "abc"
输出：3
解释：三个回文子串: "a", "b", "c"

示例 2：

输入：s = "aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"

提示：

• 1 <= s.length <= 1000
• s 由小写英文字母组成

实现代码与解析：

动态规划

class Solution {
public:
    int longestPalindromeSubseq(string s) {
	    vector<vector<int>> f(s.size(), vector<int>(s.size(), 0));
	        //先遍历长度
        for (int len = 1; len <= s.size(); len++)
            for (int i = 0; i + len - 1 < s.size(); i++)
            {
                int j = i + len - 1; // 右端点
                if (s[i] == s[j] && j - i > 1) f[i][j] = f[i + 1][j - 1] + 2;
                else if (s[i] == s[j] && j - i <= 1) f[i][j] = j - i + 1;
                else f[i][j] = max(f[i + 1][j], f[i][j - 1]);
            }
        return f[0][s.size() - 1];
    }
};

原理思路：

        与上一题像似，我这里就直接写简洁的代码了。

        dp[ i ][ j ]数组的含义为下标为 i ， j 的子串其最长的回文子序列长度。

        递推式分为2部分：

        一：长度大于2，那么若两侧字符相同，则此最长的回文子序列为去掉两侧的子串的最长回文子序列长度 + 2（也就是加上两侧的两个字符）。否则（不相等），最长的回文子序列为去掉左侧字符和去掉右侧字符中的max，这里可能会有人问为什么加上去掉两侧的状态，然后再从这三个状态中取最大呢，因为其实去掉其中一侧的状态就已经包含了去掉两侧的状态了，不用再单独写出。  

if (s[i] == s[j] && j - i > 1) f[i][j] = f[i + 1][j - 1] + 2;
else f[i][j] = max(f[i + 1][j], f[i][j - 1]);

        二：长度小于2，和上一题一样，上面的表达也不再适用了。两侧字符相等时，子串长度为2的话，显然就是回文串，长度为2。子串长度为1时，显然长度就为1。我们根据结果和 i， j 的关系，写出递推式f[i][j] = j - i + 1，两侧字符不相等，和第一种情况一样，取最大。

else if (s[i] == s[j] && j - i <= 1) f[i][j] = j - i + 1;
else f[i][j] = max(f[i + 1][j], f[i][j - 1]);

        当然还是要先遍历长度最为合适和好写。