LeetCode 647 回文子串 题解

LeetCode 647 回文子串 题解

LeetCode链接

给定一个字符串，你的任务是计算这个字符串中有多少个回文子串。
具有不同开始位置或结束位置的子串，即使是由相同的字符组成，也会被视作不同的子串。
示例 1：
输入："abc"
输出：3
解释：三个回文子串: "a", "b", "c"
示例 2：
输入："aaa"
输出：6
解释：6个回文子串: "a", "a", "a", "aa", "aa", "aaa"
提示：
输入的字符串长度不会超过 1000 。

思路：见官方题解

1. 中心拓展
时间复杂度：O(n^2)。
空间复杂度：O(1)。
2. 马拉车算法改进版，链接里面有一个漫画版本的也写的很好，这个方法的最大贡献是在于将时间复杂度提升到了线性。
时间复杂度：O(n)。即 Manacher 算法的时间复杂度，由于最大回文右端点 maxRight
只会增加而不会减少，只要是比较过的，即i<maxRight的情况只要直接返回一个值，对于新的值再进行进一步比较，故中心拓展进行的比较次数最多为 O(n)
空间复杂度：O(n)【实际上是2*n+3】。
3. 动态规划
时间复杂度：O(n^2)，空间复杂度：O(n),所以其实效率还不如中心拓展法

/**
 * @author LiMin
 * @Title: CountSubstrings
 * @Description:
 * @date 2020/8/19  20:19
 */
public class CountSubstrings {
    public static void main(String[] args) {
        System.out.println(countSubstrings_2("abc"));
    }
    //中心拓展
        public static int countSubstrings_1(String s) {
            if(s==null||s.length()==0){
                return 0;
            }
            if(s.length()==1){
                return 1;
            }
            int length=s.length();
            int n=length*2-1;
            int res=0;
            for(int i=0;i<n;i++){
                int left=i/2;
                int right=left+(i&1);//i&1相当于i%2，与运算级别太低了，一定要记得加括号
                while(left>=0&&right<length&&s.charAt(left)==s.charAt(right)){
                    left--;
                    right++;
                    res++;
                }
            }
            return res;
        }
        //马拉车算法
    public static int countSubstrings_2(String s) {
        if(s==null||s.length()==0) return 0;
        if(s.length()==1)  return 1;
        StringBuilder str=new StringBuilder("$#");
        int length=s.length();
        for(int i=0;i<length;i++){
            str.append(s.charAt(i)).append('#');
        }
        str.append('!');
        int n=str.length()-1;//注意这里一定要-1，不然遍历到最后一个'!'的右边时会越界
        int[] curLen=new int[n];
        int maxRight=0,maxCenter=0,res=0;
        for(int i=1;i<n;i++){//第一个字符'$'为中心的回文串个数肯定为0
            //下面这行代码是核心，注意这里的处理是把回文核心当作长度为1，然后从左右相邻
            //开始边扩边加一
            curLen[i]=(i<maxRight)? Math.min(curLen[2*maxCenter-i],maxRight-i):1;
            //中心扩展，这里如果curLen[i]+i<maxRight的话，是不用扩展的
            while(str.charAt(i-curLen[i])==str.charAt(i+curLen[i])){
            //头尾补不同字符是为了这里不越界，到头自动退出循环
                ++curLen[i];//比curLen[i]++更高效
            }
            //查看当前右边界有没有超过maxRight
            if((i+curLen[i]-1)>maxRight){
                maxRight=i+curLen[i]-1;
                maxCenter=i;
            }
            res+=curLen[i]/2;//这里举个例子写一下就看出来了
        }
        return res;
    }
    //动态规划
    public int countSubstrings_3(String s) {
        if(s==null||s.length()==0) return 0;
        if(s.length()==1)  return 1;
        int length=s.length();
        boolean[] dp=new boolean[length];//代表前面一列的情况
        int count=0;
        //一列一列的算，还要注意方向
        for(int j=0;j<length;j++){
            for(int i=0;i<=j;i++){
                if((j-i)<=1&&s.charAt(j)==s.charAt(i)){
                    dp[i]=true;
                    count++;
                }
                else if(s.charAt(j)==s.charAt(i)&&dp[i+1]){
                    dp[i]=true;
                    count++;
                }
                else dp[i]=false;
            }
        }
        return count;
    }
    }