133、★LeetCode-647.回文子串

题目：

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

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

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

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

来源：力扣（LeetCode）
链接：https://leetcode.cn/problems/palindromic-substrings

思路：

子串是连续的，不是之前的子序列的情况！

要学习子串的枚举和回文串的判断！

1）回文中心！中心扩展法！

每个字符串，都会有特定个数的回文中心 2n - 1；只有一个字符或者两个字符的情况

不存在大于等于3个字符的回文中心，因为都可以从1个字符和2个字符的回文中心演变过来！

 2）动态规划：dp数组代表以当前i为初始，j为结尾的子串，是否为回文串

注意遍历顺序！

本题中，dp数组是一个行和列数相同的二维数组；只有对角线右上角的区域有意义！

 不会出现下标越界的情况，因为会率先通过if判断，将对角线填满！才会进行下一步的判断

3）暴力解法：

声明一个判断回文串的方法，时间复杂度为O(N);

在使用双层for循环将每一个子串枚举，同时进行回文串的判断，如果符合就加1

代码：

1）用到了回文中心的思想：答案为官方答案

class Solution {
    public int countSubstrings(String s) {
        int len = s.length();
        int res = 0;
        for(int i = 0;i < 2 * len - 1;i++){
            //拿到回文中心的坐标，进行回文子串的判断
            int l = i / 2;
            int r = i / 2 + i % 2;
            //符合回文串的判断，每判断一次都是一个新的回文串！
            //要学习回文串的内容，子串的枚举和回文串的判断
            while(l >= 0 && r < len && s.charAt(l) == s.charAt(r)){
                l--;
                r++;
                res++;
            }
        }
        return res;
    }
}

2）动态规划：时间复杂度O(N^2)

class Solution {
    public int countSubstrings(String s) {
       //动态规划
       int len = s.length();
       //此时的dp数组记录的是：以当前下标为起始和结尾的子串是否为 回文子串
       //本题，虽然题目给出的是一维的问题，但是使用二维的dp进行解决
       boolean[][] dp = new boolean[len][len];
       int res = 0;

       //根据用到的内容在dp数组中的位置，判断遍历的顺序
       //遍历顺序很重要！
       for(int i = len - 1;i >= 0;i--){
           for(int j = i;j < len;j++){
               if(s.charAt(i) != s.charAt(j)){
                   //此时肯定不是回文串
                   dp[i][j] = false;
               }
               else{
                   //此时可能是回文串
                   if(j - i < 3){
                       dp[i][j] = true;
                       res += 1;
                   }//此时是同一个字符，两个或者三个字符都是回文
                   else if(dp[i + 1][j - 1]){//此时其内层的子串也是回文串
                        dp[i][j] = true;
                        res += 1;
                   }
               }
               //对情况的优化
                //if(s.charAt(i) == s.charAt(j) && (j - i < 3 || dp[i + 1][j - 1])){
                //    dp[i][j] = true;
                //    res += 1;
                //}
           }
       }
       return res;
    }
}

3)自己的代码：暴力解法！时间复杂度为O(N^3)

class Solution {
    public int countSubstrings(String s) {
        int len = s.length();
        int[] dp = new int[len + 1];//dp数组记录，当前位置时，回文字串的数目
        //每个字母都是一个回文子串，所以每个字符串最少拥有其长度个的回文子串

        int res = 0;
        for(int i = 0;i < len;i++){
            for(int j = i;j <len;j++){
                if(isSub(s,i,j)){
                    res += 1;
                }
            }
        } 
        return res;
    }
    //判断回文串的方法
    public boolean isSub(String s,int left,int right){
        while(left <= right){
            if(s.charAt(left) != s.charAt(right)){
                return false;
            }
            else{
                left += 1;
                right -= 1;
            }
        }
        return true;
    }
}