回文对

链接

给定一组 互不相同 的单词， 找出所有 不同 的索引对 (i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;

class Solution {

    private static boolean isPalindrome(String str) {
        if (str == null || str.length() == 0) {
            return true;
        }
        int m = str.length() / 2;

        for (int i = 0; i < m; ++i) {
            if (str.charAt(i) != str.charAt(str.length() - i - 1)) {
                return false;
            }
        }
        return true;
    }

    /**
     * O（(n^2)*k）
     *
     * @param words
     * @return
     */
    private static List<List<Integer>> solve1(String[] words) {

        List<List<Integer>> ret = new ArrayList<>();

        for (int i = 0; i < words.length; ++i) {
            for (int j = 0; j < words.length; ++j) {
                if (i == j) {
                    continue;
                }
                if (isPalindrome(words[i] + words[j])) {
                    ret.add(Arrays.asList(i, j));
                }
            }
        }

        return ret;
    }

    private static String enrich(String word) {
        StringBuffer sb = new StringBuffer();
        sb.append('$');
        for (int i = 0; i < word.length(); ++i) {
            sb.append(word.charAt(i)).append('$');
        }
        return sb.toString();
    }

    private static boolean[][] getPalindromePrefixAndSuffix(String word) {
        if (word == null || word.length() == 0) {
            return new boolean[2][0];
        }
        boolean[][] ret = new boolean[2][word.length()];
        word = enrich(word);
        int[] p = new int[word.length()];
        int c = -1;
        int r = -1;

        // 0 1 2 3 4 5 6
        // # 1 # 1 # 1 #
        for (int i = 0; i < word.length(); ++i) {
            p[i] = i > r ? 1 : Math.min(p[2 * c - i], r - i + 1);
            while (i + p[i] < word.length() && i - p[i] >= 0 && word.charAt(i + p[i]) == word.charAt(i - p[i])) {
                p[i]++;
            }
            if (i + p[i] - 1 > r) {
                r = i + p[i] - 1;
                c = i;
            }

            if (i != 0 && i != word.length() - 1) {
                if (i - p[i] + 1 == 0) {
                    ret[0][(i + p[i] - 2) >> 1] = true;
                }

                if (i + p[i] == word.length()) {
                    ret[1][(i - p[i] + 2) >> 1] = true;
                }
            }
        }
        return ret;
    }

    /**
     * O(n * m)
     *
     * @param words
     * @return
     */
    private static List<List<Integer>> solve3(String[] words) {

        List<List<Integer>> ret = new ArrayList<>();

        Trie prefixTrie = new Trie();
        Trie suffixTrie = new Trie();

        for (int i = 0; i < words.length; ++i) {
            prefixTrie.insert(words[i], i);
            suffixTrie.insert(new StringBuilder(words[i]).reverse().toString(), i);
        }

        for (int i = 0; i < words.length; ++i) {
            String word = words[i];

            boolean[][] palindromePrefixAndSuffix = getPalindromePrefixAndSuffix(word);

            boolean[] prefix = palindromePrefixAndSuffix[0];
            boolean[] suffix = palindromePrefixAndSuffix[1];

            int[] suffixIndex = suffixTrie.query(word);

            int[] prefixIndex = prefixTrie.query(new StringBuilder(word).reverse().toString());

            int m = word.length();

            /**
             * 是否存在word完全逆序的字符串
             */
            if (suffixIndex[m] != -1 && suffixIndex[m] != i) {
                ret.add(Arrays.asList(i, suffixIndex[m]));
            }

            for (int j = 0; j < m; ++j) {
                /**
                 * word字符串 [0, j] 为回文串
                 * 需要 [j+1, m) 的字符串逆序后拼接到前面
                 */
                if (prefix[j]) {
                    if (prefixIndex[m - j - 1] != -1 && prefixIndex[m - j - 1] != i) {
                        ret.add(Arrays.asList(prefixIndex[m - j - 1], i));
                    }
                }

                /**
                 * word字符串 [j, m)为回文串
                 * 需要 [0, j-1] 的字符串逆序后拼接到后面
                 */
                if (suffix[j]) {
                    if (suffixIndex[j] != -1 && suffixIndex[j] != i) {
                        ret.add(Arrays.asList(i, suffixIndex[j]));
                    }
                }
            }
        }

        return ret;
    }

    public static List<List<Integer>> palindromePairs(String[] words) {
        if (words == null || words.length == 0) {
            return new ArrayList<>(0);
        }

        return solve3(words);
    }

    public static void main(String[] args) {
        String[] words = {"a", ""};
        List<List<Integer>> ret = palindromePairs(words);
        ret.stream().forEach(item -> {
            System.out.println(item.get(0) + " " + item.get(1));
        });
    }
}

class Trie {

    private Node root;

    static class Node {
        Node[] children = new Node[26];
        int index = -1;
    }

    public Trie() {
        this.root = new Node();
    }

    public void insert(String word, int index) {
        Node p = root;
        for (int i = 0; i < word.length(); ++i) {
            int path = word.charAt(i) - 'a';
            if (p.children[path] == null) {
                p.children[path] = new Node();
            }
            p = p.children[path];
        }
        p.index = index;
    }

    public int[] query(String word) {
        Node p = root;
        int[] ret = new int[word.length() + 1];
        Arrays.fill(ret, -1);
        ret[0] = root.index;
        for (int i = 0; i < word.length(); ++i) {
            int path = word.charAt(i) - 'a';
            if (p.children[path] == null) {
                break;
            }
            p = p.children[path];
            ret[i + 1] = p.index;
        }
        return ret;
    }
}

心之所向，素履以往 生如逆旅，一苇以航