[leetcode-354]Russian Doll Envelopes(java)

思路：首先最容易想到的就是暴力搜索，时间复杂度为O（n2）,因此很容易超时。
在暴力搜索的时候，我们实际上是把字符串拼接之后再去判断是否为回文。那么换种思路，一个字符串确定之后，它所能形成的回文个数其实就已经确定了，因此，换种思路就是遍历每个字符串，然后在遍历每个字符串时找到它所所需要的回文样式，假设字符串最长为K，那么所可能形成的回文最大为2K，于是我们在遍历这2K个，看看它们算法在words中。所以时间复杂度为O(NK)
对于任何一个word，既可以在它的后面添加一些称为回文，又可以在左侧添加一些称为回文。剩下的工作就是找到所需要的回文的工作。

原则其实只有一条，如果字符串S，分为两个字符串s1,s2，如果s2为回文，那么只需要一个逆序的s1附着在s2右边就变成了回文。同理，如果s1为回文，那么只需要一个逆序的s2附着在s1左边就称为了回文。

暴力搜索

public class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> res = new LinkedList<List<Integer>>();
        StringBuilder builder = new StringBuilder();

        for(int i = 0;i<words.length;i++){
            for(int j = 0;j<words.length;j++){
                if(i == j)
                    continue;
                builder.setLength(0);
                builder.append(words[i]);
                builder.append(words[j]);

                if(isPalindrome(builder)){
                    List<Integer> tmp = new LinkedList<>();
                    tmp.add(i);tmp.add(j);
                    res.add(tmp);
                }
            }
        }
        return res;
    }
    private boolean isPalindrome(StringBuilder builder){
        int length = builder.length();
        int start = 0;
        int end = length - 1;
        while(start < end){
            if(builder.charAt(start++) != builder.charAt(end--))
                return false;
        }
        return true;
    }
}

代码二：

public class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> res = new LinkedList<List<Integer>>();
        HashMap<String,Integer> invertedIndex = new HashMap<>();

        //建立索引    
        buildIndex(invertedIndex,words);
        for(int i = 0;i<words.length;i++){
            String word = words[i];
            List<String> backCandidate = findBackCandidate(word);
            for(String candidate:backCandidate){
                if(invertedIndex.containsKey(candidate)){
                    int value = invertedIndex.get(candidate);
                    if(value != i){
                        List<Integer> tmplist = new LinkedList<>();
                        tmplist.add(i);tmplist.add(value);
                        res.add(tmplist);
                    }
                }
            }

            List<String> frontCandidate = findFrontCandidate(word);
            for(String candidate:frontCandidate){
                if(invertedIndex.containsKey(candidate)){
                    int value = invertedIndex.get(candidate);
                    if(value != i){
                        List<Integer> tmplist = new LinkedList<>();
                        tmplist.add(value);tmplist.add(i);
                        res.add(tmplist);
                    }
                }
            }
        }
        return res;
    }
    void buildIndex(Map<String,Integer> map,String[] words){
        for(int i = 0;i<words.length;i++){
            map.put(words[i],i);
        }
    }
    List<String> findBackCandidate(String word){
        List<String> res = new LinkedList<>();
        char[] chars = word.toCharArray();

        for(int i = chars.length;i>=0;i--){
            if(isPalindrome(chars,i,chars.length-1)){
                 StringBuilder builder = new StringBuilder();
                 builder.append(chars,0,i);
                 res.add(builder.reverse().toString());
            }
        }
        return res;
    }
    List<String> findFrontCandidate(String word){
        List<String> res = new LinkedList<>();
        char[] chars = word.toCharArray();

        for(int i = 0;i<chars.length;i++){
            if(isPalindrome(chars,0,i)){
                 StringBuilder builder = new StringBuilder();
                 builder.append(chars,i+1,chars.length-i-1);
                 res.add(builder.reverse().toString());
            }
        }
        return res;
    }
    private boolean isPalindrome(char[] chars,int left,int right){
        if(left > right)
            return true;
        while(left <= right){
            if(chars[left++] != chars[right--])
                return false;
        }
        return true;
    }
}