[LeetCode] 336. 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:

Input: ["abcd","dcba","lls","s","sssll"]
Output: [[0,1],[1,0],[3,2],[2,4]] 
Explanation: The palindromes are ["dcbaabcd","abcddcba","slls","llssssll"]

Example 2:

Input: ["bat","tab","cat"]
Output: [[0,1],[1,0]] 
Explanation: The palindromes are ["battab","tabbat"]

回文对。题意是给一组不重复的单词，找出所有可以组成回文的单词对。

这里我给出比较通俗的解法。创建一个isPalindrome的函数帮助判断是否是回文，同时创建一个hashmap记录每个单词和他们各自的index。遍历input中的每个单词，并且按字符一位一位地将单词断开，看单词的左半边是否是回文。若是，则在hashmap中找是否有这个回文半边的另一半，若有则加入结果集。

跑一个例子说明吧。比如第一个例子中的"sssll"，判断的时候，会发现ss是回文（当然，之前的s也是回文），所以需要去找sll的reverse -> lls是否存在于hashmap，发现存在，则把两者的index [2, 4]加入结果集。

时间O(n * k^2) - n个单词，K是单词的长度

空间O(n) - hashmap

Java实现

class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> res = new ArrayList<>();
        // corner case
        if (words == null || words.length < 2) {
            return res;
        }

        // normal case
        HashMap<String, Integer> map = new HashMap<>();
        for (int i = 0; i < words.length; i++) {
            map.put(words[i], i);
        }

        for (int i = 0; i < words.length; i++) {
            for (int j = 0; j <= words[i].length(); j++) {
                String str1 = words[i].substring(0, j);
                String str2 = words[i].substring(j);
                if (isPalindrome(str1)) {
                    String str2rvs = new StringBuilder(str2).reverse().toString();
                    if (map.containsKey(str2rvs) && map.get(str2rvs) != i) {
                        res.add(Arrays.asList(map.get(str2rvs), i));
                    }
                }
                if (str2.length() != 0 && isPalindrome(str2)) {
                    String str1rvs = new StringBuilder(str1).reverse().toString();
                    if (map.containsKey(str1rvs) && map.get(str1rvs) != i) {
                        res.add(Arrays.asList(i, map.get(str1rvs)));
                    }
                }
            }
        }
        return res;
    }

    private boolean isPalindrome(String s) {
        int left = 0;
        int right = s.length() - 1;
        while (left <= right) {
            if (s.charAt(left) != s.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }
        return true;
    }
}

JavaScript实现

/**
 * @param {string[]} words
 * @return {number[][]}
 */
var palindromePairs = function (words) {
    const map = words.reduce((acc, cur, i) => {
        acc[cur] = i;
        return acc;
    }, {});
    const output = [];
    for (const word of words) {
        for (let j = 0; j <= word.length; j++) {
            if (j < word.length && isPalindrome(word, j, word.length)) {
                const rLeft = reverseSubstring(word, 0, j);
                if (rLeft in map) {
                    output.push([map[word], map[rLeft]]);
                }
            }
            if (isPalindrome(word, 0, word.length - j)) {
                const rRight = reverseSubstring(
                    word,
                    word.length - j,
                    word.length
                );
                if (rRight in map && rRight !== word) {
                    output.push([map[rRight], map[word]]);
                }
            }
        }
    }
    return output;
};

function reverseSubstring(word, start, end) {
    let output = '';
    for (let i = end - 1; i >= start; i--) {
        output += word[i];
    }
    return output;
}

function isPalindrome(word, start, end) {
    let left = start;
    let right = end - 1;
    while (left < right) {
        if (word[left] !== word[right]) {
            return false;
        }
        left += 1;
        right -= 1;
    }
    return true;
}

LeetCode 题目总结