LeetCode-Palindrome Pairs

Given a list of unique words. Find all pairs of distinct indices (i, j) in the given list, so that the concatenation of the two words, i.e. words[i] + words[j] is a palindrome.

Example 1:
Given words = ["bat", "tab", "cat"]
Return [[0, 1], [1, 0]]
The palindromes are ["battab", "tabbat"]

Example 2:
Given words = ["abcd", "dcba", "lls", "s", "sssll"]
Return [[0, 1], [1, 0], [3, 2], [2, 4]]
The palindromes are ["dcbaabcd", "abcddcba", "slls", "llssssll"]

Credits:
Special thanks to @dietpepsi for adding this problem and creating all test cases.

Analysis:

We use Trie to build a suffix tree to reduce searching range, i.e., for a word starting with 'a', we only search words ending with 'a'.

To find the pairs for each word, we need address two cases:

1. word A is word B's suffix, e.g., "cd" + "babdc". In this case, we should record that "babdc" is a palindrome, if we exclude its suffix of "dc". So we can create a list of words at any TrieNode. This list contains all words that are palindrome if excluding the suffix presented by that TrieNode.

2. word B is word A's suffix, e.g. "dcbab" + "cd". In this case, when search for "dcbab", we should check for every prefix that is also a word, e.g., "dc" of "dcbab" is the word "cd", if excluding this prefix, word A is a palindrome.

Solution:

public class Solution {
    public class TrieNode {
        TrieNode[] childs;
        int wordInd; // index of the word ending at this
        List<Integer> pList; // index list of the words which are palindrome if
                                // excluding the prefix on this.

        public TrieNode() {
            childs = new TrieNode[26];
            wordInd = -1;
            pList = new ArrayList<Integer>();
        }
    }

    public List<List<Integer>> palindromePairs(String[] words) {
        TrieNode root = new TrieNode();

        // Build the Trie
        for (int i = 0; i < words.length; i++) {
            addWord(words, i, root);
        }

        // Build result list
        List<List<Integer>> resList = new ArrayList<List<Integer>>();
        for (int i = 0; i < words.length; i++) {
            findPalindrome(words, i, root, resList);
        }
        return resList;
    }

    // Add word into Trie.
    public void addWord(String[] words, int cur, TrieNode root) {
        TrieNode curNode = root;
        String word = words[cur];
        for (int i = word.length() - 1; i >= 0; i--) {
            // if word(0,i) is a palindrome, i.e., after excluding current
            // suffix, add it into pList.
            if (isPalindrome(word, 0, i)) {
                curNode.pList.add(cur);
            }

            // Move to next char.
            char curChar = word.charAt(i);
            if (curNode.childs[curChar - 'a'] == null) {
                curNode.childs[curChar - 'a'] = new TrieNode();
            }
            curNode = curNode.childs[curChar - 'a'];
        }
        // Record the current word's index at the last TrieNode.
        curNode.wordInd = cur;
    }

    // find palindrome for words[cur].
    public void findPalindrome(String[] words, int cur, TrieNode root, List<List<Integer>> resList) {
        TrieNode curNode = root;
        String word = words[cur];
        for (int i = 0; i < word.length(); i++) {
            // If there is a word ending at current node, check whether that
            // word and current word are palindrome pair.
            if (curNode.wordInd != -1 && isPalindrome(word, i, word.length() - 1)) {
                resList.add(Arrays.asList(cur, curNode.wordInd));
            }

            // Move to next node; if no next node then return.
            char curChar = word.charAt(i);
            if (curNode.childs[curChar - 'a'] == null)
                return;
            curNode = curNode.childs[curChar - 'a'];
        }
        // For the last TrieNode, its word should not be current word.
        if (curNode.wordInd!=-1 && curNode.wordInd!=cur){
            resList.add(Arrays.asList(cur,curNode.wordInd));
        }

        // After reaching the end, further check whether there are words that
        // are palindrome if current word is a suffix.
        for (int ind : curNode.pList) {
            resList.add(Arrays.asList(cur, ind));
        }
    }

    // Returns if word is a palindrome between index i and j.
    public boolean isPalindrome(String word, int i, int j) {
        while (i < j) {
            if (word.charAt(i) == word.charAt(j)) {
                i++;
                j--;
            } else
                return false;
        }
        return true;
    }
}