leetcode hot100 之 回文子串

给定一个字符串，请统计回文子串的数量。

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

原题链接： https://leetcode.cn/problems/palindromic-substrings/

动态规划。题目和《最长回文子串》。
如果 s[i, j] 是一个回文子串，那么 s[i+1, j-1] 也是一个回文子串。反过来，如果s[i+1, j-1] 是一个回文子串，且 s[i] == s[j]，那么 s[i, j] 也是一个回文子串。

那么我们记 dp[i, j] 表示从 i 到 j 的字符串是否为回文子串，转移方程为
dp[i, j] = dp[i+1, j-1] && s[i] == s[j]

回文子串有两种基础的情况，一种是类似于 “aba” 长度为奇数的回文串，另一种是类似于 “abba” 长度为偶数的回文串。所以初始化需要考虑两种情况：
如果子串的长度为1，那这个子串就是一个回文子串，所以可以初始化为

for (i = 0; i < n; i++):
    dp[i, i] = true

还有一种情况，则需要进行一次判断：

for (i = 0; i < n - 1; i++):
    dp[i, i+1] = true if s[i] == s[i+1] else false

如上图所示，蓝色的点为初始化的点，黄色的点表示转移方程依赖关系。
同时满足 j > i ，那么遍历的时候只需要遍历图中右上半部分即可，从下往上，从左往右。需要稍微注意一下起始坐标：

for (i = n - 3; i >= 0; i--):
    for (j = i + 2; j < n; j++):

在遍历的过程中，记录回文子串的数量。

• 复杂度分析
  • 时间复杂度 O(n^2)。
  • 空间复杂度 O(n^2)。

由于 dp[i][j] 只和 dp[i + 1][j - 1] 相关，空间复杂度可以优化到 O(n)。
这样循环就直接变成

for (i = n - 1; i >= 0; i--):
    for (j = i; j < n; j++):

然后进一步分类讨论：

1. 当 i == j 时，dp1[j] == true
2. 当 i + 1 == j 时，if (s[i] == s[j])，dp1[j] == ture
3. 其他index时，当 if (s[i] == s[j] && dp0[j - 1])，dp1[j] == true
4. 此外，所有情况都是dp1[j] == false

这样判断逻辑就清晰了。

• 复杂度分析
  • 时间复杂度 O(n^2)。
  • 空间复杂度 O(n)。

中心拓展法。
其实可以遍历一遍字符串的 index，以当前 index 为中心，然后向外拓展，如果 s[cur + x] == s[cur - x] 则满足回文条件， 如果不满足，或者遇到了边界，则直接截断返回。
这里的 index 的遍历，应该是 0.5 为步长。因为需要考虑 “aba”、“abba” 这两种回文情况。

这种方式，时间复杂度还是O(n^2)，但是不需要额外的空间。

• 复杂度分析
  • 时间复杂度 O(n^2)。
  • 空间复杂度 O(1)。

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size();
        int result = 0;
        vector> dp(n, vector(n, false));

        for (int i = 0; i < n; i++) {
            dp[i][i] = true;
            result++;
        }
        for (int i = 0; i < n - 1; i++) {
            if (s[i] == s[i + 1]) {
                dp[i][i + 1] = true;
                result++;
            }
        }     
        for (int i = n - 3; i >= 0; i--) {
            for (int j = i + 2; j < n; j++) {
                if (dp[i + 1][j - 1] && s[i] == s[j]) {
                    dp[i][j] = true;
                    result++;
                }
            }
        }
        
        return result;
    }
};

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size();
        int result = 0;
        vector dp0(n, false);
        vector dp1(n, false);

        for (int i = n - 1; i >= 0; i--) {
            dp0 = dp1;
            for (int j = i; j < n; j++) {
                if (i == j || (s[i] == s[j] && (i + 1 == j || dp0[j - 1]))) {
                    dp1[j] = true;
                    result++;
                }
                else {
                    dp1[j] = false;
                }
            }
        }
        
        return result;
    }
};

class Solution {
public:
    int countSubstrings(string s) {
        int n = s.size();
        int result = 0;
        for (int i = 0; i < 2 * n - 1; i++) {
            int left = i / 2;
            int right = (i + 1) / 2;
            while (left >= 0 && right < s.size() && s[left] == s[right]) {
                result++;
                left--;
                right++;
            }
        }
        return result;
    }
};