LeetCode336回文对

这道题按照左神的做法思路就是将传入的string数组中的所有string存入参数
1.首先我们得判断string是否本身就是回文子串并且map中存在空字符串
2.判断string的是否存在前缀回文包含string的第一个字符，并且string除前缀回文外的逆序在map中存在
3.判断string是否存在后缀回文包含string的最后一个字符，并且string除前缀回文外的逆序在map中存在

具体求前后缀回文长度是manachar算法不懂的可以搜一下复杂度O(N)
代码如下

public class Palindrome_Pairs {
    public static void main(String[] args) {
        String[]strs=new String[]{"12134","43"};
       List<List<Integer>> res=palindromePairs(strs);
       for(List<Integer>list:res)
       {
           for(Integer s:list)

           {
               System.out.println(s);
           }

       }
    }
    public static List<List<Integer>> palindromePairs(String[] words) {
        HashMap<String, Integer> wordset = new HashMap<>();
        for (int i = 0; i < words.length; i++) {
            wordset.put(words[i], i);
        }
        List<List<Integer>> res = new ArrayList<>();
        for (int i = 0; i < words.length; i++) {
            res.addAll(findAll(words[i], i, wordset));
        }
        return res;
    }

    public static List<List<Integer>> findAll(String word, int index, HashMap<String, Integer> words) {
        List<List<Integer>> res = new ArrayList<>();
        int[] rs = manacherrs(word);
        String reverse = reverse(word);
        Integer rest = words.get("");
        if (rest != null && rest != index && word.equals(reverse)) {
            addRecord(res, rest, index);
            addRecord(res, index, rest);
        }
        int mid = rs.length >> 1;
        for (int i = 1; i < mid; i++) {
            if (i - rs[i] == -1) {
                rest = words.get(reverse.substring(0, mid - i));
                if (rest != null && rest != index) {
                    addRecord(res, rest, index);
                }
            }
        }
        for (int i = mid + 1; i < rs.length; i++) {
            if (i + rs[i] == rs.length) {
                rest = words.get(reverse.substring((mid << 1) - i));
                if (rest != null && rest != index) {
                    addRecord(res, index, rest);
                }
            }
        }
        return res;
    }

    public static void addRecord(List<List<Integer>> res, int left, int right) {
        List<Integer> newr = new ArrayList<>();
        newr.add(left);
        newr.add(right);
        res.add(newr);
    }

    public static int[] manacherrs(String word) {
        char[] mchs = manachercs(word);
        int[] rs = new int[mchs.length];
        int center = -1;
        int pr = -1;
        for (int i = 0; i != mchs.length; i++) {
            rs[i] = pr > i ? Math.min(rs[(center << 1) - i], pr - i) : 1;
            while (i + rs[i] < mchs.length && i - rs[i] > -1) {
                if (mchs[i + rs[i]] != mchs[i - rs[i]]) {
                    break;
                }
                rs[i]++;
            }
            if (i + rs[i] > pr) {
                pr = i + rs[i];
                center = i;
            }
        }
        return rs;
    }

    public static char[] manachercs(String word) {
        char[] chs = word.toCharArray();
        char[] mchs = new char[chs.length * 2 + 1];
        int index = 0;
        for (int i = 0; i != mchs.length; i++) {
            mchs[i] = (i & 1) == 0 ? '#' : chs[index++];
        }
        return mchs;
    }

    public static String reverse(String str) {
        char[] chs = str.toCharArray();
        int l = 0;
        int r = chs.length - 1;
        while (l < r) {
            chs[l] ^= chs[r];
            chs[r] ^= chs[l];
            chs[l++] ^= chs[r--];
        }
        return String.valueOf(chs);
    }

}

中间代码有几点需要去解释的，弄了半天才明白
首先用manachar算法求得string中以各字符为中心或者两个字符为中心的回文子串的长度
findAll函数中有这样一段代码

rs[]为string处理后的以各字符为中心的最长回文串长度+1的数组
一.为什么i-r[i]=-1则表示到达前缀回文串包含了第一个字符？
首先当回文串为奇串

有

(i-1)/2为未处理前奇串的中心位置的索引,而如果想波及到第一个字符则需要索引这么长的数,即最终回文串长度减一的一半距离

如果回文串为偶串

i/2为原未处理前对应偶串的中间位置的下一个字符则其波及到第一个字符所需要的长度也是i/2那因为是偶串所以等式都右边分子不需要减一了结果和上面一样
所以最终有下式成立

二.为什么下式的rest即是除回文串以外的后缀逆序？

首先由上式成立则可以将i代换成下式

则我们可知mid就是未处理字符串的长度,则mid-回文串长度即是除回文串以外的后缀逆序长度

下文同理只是求是后缀回文串是否波及到string最后一个字符

,其中有一点需要注意

这里mid<<1并不是rs.length而是rs.length-1因为处理后string长度恒定为奇数，别的和上面证明方法一样就不说了

md，真麻烦艹了