回文对[枚举字符串前后缀 & 字典树索引 || 哈希索引]

前言

复杂的题需要前置的主干个性分析&拆解，然后再选择合适的数据结构，匹配合适的算法思想。

一、回文对

二、枚举前后缀&索引选择

1、字典树

// 回文对
public class PalindromePairs {
    /*
    字典树 | hash记录翻转字符串
    枚举前缀和后缀。
     */
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> ans = new ArrayList<>();// 装答案的容器。
        int len = words.length;

        for (int i = 0; i < len; i++) insert(words[i], i);// 将所有字符串拿来构建字典树，并设置好end节点的索引。

        for (int i = 0; i < len; i++) {
            int m = words[i].length();
            // 枚举前缀和后缀。
            for (int j = 0; j <= m; j++) {
                // 枚举后缀。
                // 可分解成 整个字符串 + 空串[m,m-1]。
                if (isPalindromePairs(words[i], j, m - 1)) {
                    // 包含空串的组合。
                    int r = findWord(words[i], 0, j - 1);
                    // 有它 且 不是自己（整个字符串是回文的情况。） 。
                    if (r != -1 && r != i) ans.add(Arrays.asList(i, r));
                }
                // 枚举前缀
                // j!=0防止空串 + 整个字符，导致重复id对，毕竟上面已经分解过空串了。
                if (j != 0 && isPalindromePairs(words[i], 0, j - 1)) {
                    int r = findWord(words[i], j, m - 1);// 前缀是回文，找后缀字符。
                    // 有它 且 不是自己（后缀为整个字符串且为回文，当然这里可省略，毕竟j != 0）
                    if (r != -1 && r != i) ans.add(Arrays.asList(r, i));
                }
            }
        }
        return ans;
    }

    // 判断一个字符串是否为回文串。
    private boolean isPalindromePairs(String word, int left, int right) {
        int len = right - left + 1 >>> 1;

        for (int i = 0; i < len; i++) {
            if (word.charAt(left + i) != word.charAt(right - i)) return false;
        }
        return true;
    }

    //新版字典树，用集合+数组存下标 代替 Node[] next；用word_index 代替 boolean isEnd & int val
    class Node {
        int[] ch = new int[26];// 26个字符，用int来存26个节点在列表中的索引。
        int word_index = -1;// 默认为-1，表示该节点不是end节点，可设置它的value，在此题中为字符串数组中的索引。
    }

    // 生成装树的集合，并查集味道。
    List<Node> tree = new ArrayList<>();

    {
        tree.add(new Node());// 先把根装进去。
    }

    // 插入字符串到字典树上。
    public void insert(String word, int word_index) {
        int len = word.length(), idx = 0;// 从根节点开始。
        // 正序插入。
        for (int i = 0; i < len; i++) {
            int x = word.charAt(i) - 'a';// 得到下一个字符在列表中的位置。
            // 没有创建过该字符节点。
            if (tree.get(idx).ch[x] == 0) {
                tree.add(new Node());// 生成节点。
                tree.get(idx).ch[x] = tree.size() - 1;// 并记录该节点的位置，到时候取这个节点，直接根据下标O(1)，有并查集味道。
            }
            // 为创建下一个节点做准备。
            idx = tree.get(idx).ch[x];
        }
        // 设置该节点的索引，同时也表示它为end节点。
        tree.get(idx).word_index = word_index;
    }

    // 寻找需要的字符串的反转字符串，用left/right一举两得，不需要substring拿到新字符串，也很容易反着寻找。
    public int findWord(String word, int left, int right) {
        int idx = 0;// 根节点位置。
        // 从根节点开始寻找。
        for (int i = right; i >= left; i--) {
            int x = word.charAt(i) - 'a';// 拿到next字符的创建状态。
            // 没有创建，就不用寻找了，没有！
            if (tree.get(idx).ch[x] == 0) return -1;
            // 该字符被创建过，拿到它在列表中add时的下标。
            idx = tree.get(idx).ch[x];
        }
        // 找到该字符串的末尾字符，看看它是否为end字符。
        return tree.get(idx).word_index;
    }
}

2、哈希表

// hash索引替代字典树索引，更快匹配。
class PalindromePairs2 {
    /*
    字典树 | hash记录翻转字符串
    枚举前缀和后缀。
     */
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> ans = new ArrayList<>();// 装答案的容器。
        int len = words.length;
        // 设置翻转字符串的hash表。
        Map<String, Integer> fx = new HashMap<>();
        for (int i = 0; i < len; i++) fx.put(new StringBuilder(words[i]).reverse().toString(), i);
        // 枚举每个字符串的前缀和后缀。
        for (int i = 0; i < len; i++) {
            int m = words[i].length();
            // 枚举前缀和后缀。
            for (int j = 0; j <= m; j++) {
                // 枚举后缀。
                // 可分解成 整个字符串 + 空串[m,m-1]。
                if (isPalindromePairs(words[i], j, m - 1)) {
                    // 包含空串的组合。
                    int r = fx.getOrDefault(words[i].substring(0, j), -1);
                    // 有它 且 不是自己（整个字符串是回文的情况。） 。
                    if (r != -1 && r != i) ans.add(Arrays.asList(i, r));
                }
                // 枚举前缀
                // j!=0防止空串 + 整个字符，导致重复id对，毕竟上面已经分解过空串了。
                if (j != 0 && isPalindromePairs(words[i], 0, j - 1)) {
                    int r = fx.getOrDefault(words[i].substring(j, m), -1);
                    // 有它 且 不是自己（后缀为整个字符串且为回文，当然这里可省略，毕竟j != 0）
                    if (r != -1 && r != i) ans.add(Arrays.asList(r, i));
                }
            }
        }
        return ans;
    }

    // 判断一个字符串是否为回文串。
    private boolean isPalindromePairs(String word, int left, int right) {
        int len = right - left + 1 >>> 1;

        for (int i = 0; i < len; i++) {
            if (word.charAt(left + i) != word.charAt(right - i)) return false;
        }
        return true;
    }
}

总结

1）往往比较复杂的题，都不是直接应用某个知识点，而是需要前置的分析，分析该题中的个性所在(比较该题的回文问题)&规律，做一些分解(比如该题的枚举前后缀)，然后选择合适数据结构(比如该题的索引选择)&相应算法思想。

2）字典树索引和哈希索引都有自己的应用场景，无特殊要求，则选择哈希的O(1)定位，但是会有更多的空间消耗。

参考文献

[1] LeetCode 回文对