214. 最短回文串

给定一个字符串 s，你可以通过在字符串前面添加字符将其转换为回文串。找到并返回可以用这种方式转换的最短回文串。

示例 1:

输入: “aacecaaa” 输出: “aaacecaaa” 示例 2:

输入: “abcd” 输出: “dcbabcd”

这个题目可以转化成找出该字符串的最长回文前缀。

暴力枚举

class Solution {
    public String shortestPalindrome(String s) {
        int low=0,high=s.length()-1;
        StringBuilder str=new StringBuilder("");
        //若要得到最短回文串，那么需要判断它的前缀0-temp是不是回文串，若是的话，那么只需要在字符串的开头添加temp+1-len的回文
        int temp=0;
        for(int i=s.length()-1;i>=0;i--){
            if(isHuiwen(s.substring(0,i+1))){
                temp=i-1;
                break;
            }
        }
        for(int i=s.length()-1;i>temp;i--){
            str=str.append(s.charAt(i));
        }
        str=str.append(s);
        return str.toString();
    }
    //判断是否是回文串
    public boolean isHuiwen(String s){
        int low=0,high=s.length()-1;
        while(low<=high&&s.charAt(low)==s.charAt(high)){
            low++;high--;
        }
        if(low<=high){
            return false;
        }else{
            return true;
        }
    }
}

通过暴力枚举时间复杂度是O($n^2$)，直接TLE了。

Rabin-Karp 字符串哈希算法

通过比较正序和反序字符串的hash值是否相等来判断两个字符串是否相等。
因为要用到哈希值，所以最好设计一个能尽可能少地产出哈希冲突的算法，这样就可以直接通过比较hash值来判断，而不需要再进行验证了。
下面的这个算法，我比较了一下验证和没验证的时间，不验证的话用了3ms，而验证用了490ms。

class Solution {
    public String shortestPalindrome(String s) {
        int len=s.length();
        long left=0,right=0,mul=1;
        int base=256,mod=1000000007;
        int best=0;
        for(int i=0;i<len;i++){
            left=(left*base+s.charAt(i))%mod;
            right=(right+s.charAt(i)*mul)%mod;
            if(left==right){
                //为了防止哈希冲突，进行验证
                // if(isHuiwen(s.substring(0,i+1)))
                    best=i;
            }
            mul=(mul*base)%mod;
        }
        StringBuilder str=new StringBuilder("");
        if(best+1<len){
            str.append(s.substring(best+1)).reverse();
        }
        str.append(s);
        return str.toString();
    }
    //判断是否是回文串
    public boolean isHuiwen(String s){
        int low=0,high=s.length()-1;
        while(low<=high&&s.charAt(low)==s.charAt(high)){
            low++;high--;
        }
        if(low<=high){
            return false;
        }else{
            return true;
        }
    }
}

该算法的时间复杂度是O(n)，空间复杂度O(n)

KMP

只需要将s作为模式串，他的逆序串作为查询串，之后就可以获得最长的回文前缀字符串。

class Solution {
    public String shortestPalindrome(String s) {
        StringBuilder str=new StringBuilder(s);
        int best=kmp(str.reverse().toString(),s);
        str=new StringBuilder("");
        return str.append(s.substring(best)).reverse().append(s).toString();
    }
    //返回最长回文前缀的最后一个字符的下标+1
    public int kmp(String t,String p){
        int pLen=p.length(),tLen=t.length();
        int[] D=new int[pLen];
        int i=1,j=0;
        while(i<pLen){
            if(p.charAt(i)==p.charAt(j)){
                D[i]=++j;
                ++i;
            }else{
                if(j==0){
                    ++i;
                }else{
                    j=D[j-1];
                }
            }
            
        }
        i=0;j=0;
        while(i<tLen){
            if(t.charAt(i)==p.charAt(j)){
                ++i;++j;
            }else{
                if(j==0){
                    ++i;
                }else{
                    j=D[j-1];
                }
            }
        }
        return j;

    }
}

时间复杂度为O(n)，空间复杂度为O(n)。