代码随想录——回文子串（Leetcode 647）

题目链接

我的题解（双指针）

思路：
当然，以下是对您提供的代码的解释：

class Solution {
    public int countSubstrings(String s) {
        // 初始化回文子字符串的数量
        int count = 0;
        
        // 遍历字符串的每个字符，使用索引 i
        for(int i = 0; i < s.length(); i++){
            // 初始化两个指针 left 和 right，都指向当前位置 i
            // 用于查找以 i 为中心的奇数长度回文子字符串
            int left = i, right = i;
            // 当 left 和 right 都在字符串范围内，并且 s[left] 等于 s[right] 时
            // 继续查找
            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
                // 如果找到了一个回文子字符串，增加计数
                count++;
                // 移动 left 指针向左，right 指针向右，继续查找更长的回文子字符串
                left--;
                right++;
            }
            
            // 重新初始化 left 指针到 i，right 指针到 i+1
            // 用于查找以 i 和 i+1 为中心的偶数长度回文子字符串
            left = i;
            right = i + 1;
            // 同样的逻辑，当 left 和 right 都在字符串范围内，并且 s[left] 等于 s[right] 时
            // 继续查找
            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
                // 如果找到了一个回文子字符串，增加计数
                count++;
                // 移动 left 指针向左，right 指针向右，继续查找更长的回文子字符串
                left--;
                right++;
            }
        }
        
        // 返回总共找到的回文子字符串的数量
        return count;
    }
}

详细解释：

1. int left = i, right = i; 初始化两个指针 left 和 right，都指向当前位置 i。这是为了查找以 i 为中心的奇数长度回文子字符串。
2. 第一个 while 循环：while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right))。这个循环用于检查当前位置为中心的字符是否可以扩展成回文。它检查以下条件：
   • left 指针是否仍然在字符串范围内。
   • right 指针是否仍然在字符串范围内。
   • 当前 left 和 right 指向的字符是否相同。
     如果以上条件都满足，那么 count++ 增加计数，然后 left-- 和 right++ 来检查下一个可能的回文子字符串。
3. left = i; right = i + 1; 重新初始化 left 和 right 指针，这次是为了查找以 i 和 i+1 为中心的偶数长度回文子字符串。
4. 第二个 while 循环与第一个相同，但这次检查的是偶数长度的回文子字符串。

class Solution {
    public int countSubstrings(String s) {
        int count = 0;
        for(int i = 0; i < s.length(); i++){
        	// 奇数
            int left = i, right = i;
            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
                count++;
                left--;
                right++;
            }
            // 偶数
            left = i;
            right = i + 1;
            while (left >= 0 && right < s.length() && s.charAt(left) == s.charAt(right)) {
                count++;
                left--;
                right++;
            }
        }
        return count;
    }
}

在字符串中查找回文子字符串时，区分奇数长度和偶数长度是因为它们的中心点不同：

1. 奇数长度回文子字符串：
   • 奇数长度的回文子字符串有一个中心字符。例如，在字符串 “abcba” 中，‘c’ 是中心字符，整个字符串是一个奇数长度的回文子字符串。
   • 对于每个字符 s[i]，我们可以将其视为一个潜在的中心，然后尝试向左和向右扩展，以查看是否存在一个以 s[i] 为中心的回文子字符串。
2. 偶数长度回文子字符串：
   • 偶数长度的回文子字符串没有中心字符，而是有两个中心点。例如，在字符串 “abba” 中，‘b’ 和另一个 ‘b’ 是中心点，整个字符串是一个偶数长度的回文子字符串。
   • 对于每个字符 s[i]，我们还可以检查 s[i] 和 s[i+1] 是否可以形成一对中心点，然后同样尝试向左和向右扩展，以查看是否存在一个以 s[i] 和 s[i+1] 为中心的回文子字符串。
     因此，必须分别考虑这两种情况，因为它们的扩展方式不同：

• 对于奇数长度，我们从单个字符开始，向两侧扩展。
• 对于偶数长度，我们从两个连续字符开始，向两侧扩展。

优秀题解（动态规划）

思想：
找到一种递归关系，判断一个子字符串（字符串下标范围[i,j]）是否回文，依赖于，子字符串（下标范围[i + 1, j - 1]））是否是回文。

• 1. 确定dp数组（dp table）以及下标的含义
     dp[i][j]：表示区间范围[i,j] （注意是左闭右闭）的子串是否是回文子串，如果是dp[i][j]为true，否则为false。
• 2. 确定递推公式
  • s[i] = s[j]
    - 下标i = j，例如a，是回文子串dp[i][j] = true
    - 下标j - i = 1，例如aa，是回文子串dp[i][j] = true
    - 下标j - i > 1，例如cabac，此时s[i]与s[j]已经相同了，我们看i到j区间是不是回文子串就看aba是不是回文就可以了，那么aba的区间就是 i+1 与 j-1区间，这个区间是不是回文就看dp[i + 1][j - 1]是否为true
  • s[i] != s[j]
    - 下标i ≠ j，dp[i][j] = false
• 3. dp数组如何初始化
     dp[i][j]初始化为false。
• 4. 确定遍历顺序
     情况三是dp[i + 1][j - 1]，所以一定要从下到上，从左到右遍历，这样保证dp[i + 1][j - 1]都是经过计算的。

class Solution {
    public int countSubstrings(String s) {
        int count = 0;
        boolean[][] dp = new boolean[s.length()][s.length()];
        for(int i = s.length() - 1; i >= 0; i--){
            for(int j = i; j < s.length(); j++){
                if(s.charAt(i) == s.charAt(j)){
                    if(j - i <= 1){
                        dp[i][j] = true;
                        count++;
                    }else{
                        dp[i][j] = dp[i + 1][j - 1];
                        if(dp[i][j] == true){
                            count++;
                        }
                    }
                }
                else{
                    dp[i][j] = false;
                }
            }
        }
        return count;
    }
}