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:
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"]

思路：回文就用普通的办法：先找中心那个点，然后尝试往外扩，不过在这里不是中心点，而是一个回文的中心块，把这个中心整体当做一个中心，遇到一个合理的回文中心块，就看一下剩余的string有没有在words中出现，这里唯一的优化就是把string都先放到map中，这样查找效率会高一点

package l336;

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

/*
 * 遍历一遍words，每次都以words[i]为中心点，这样可以保证不多也不少
 * 考虑3种情况：
 * 1. 另外一个string加到words[i]前面，中心块是words[i]前面几个子串
 * 2. 另外一个string加到words[i]后面，中心块是words[i]后面几个子串
 * 3. 没有中心点
 */
public class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
    	List<List<Integer>> rst = new ArrayList<List<Integer>>();
        Map<String, Integer> map = new HashMap<String, Integer>();
        for(int i=0; i<words.length; i++) map.put(words[i], i);
        
        for(int i=0; i<words.length; i++) {
        	for(int j=1; j<words[i].length(); j++) {
        		String left = words[i].substring(0, j);
        		String right = words[i].substring(j);
        		
        		// 1. 0到j(include)整体作为中心
        		if(isPalindrome(left)) {
        			String rev = new StringBuilder(right).reverse().toString();
        			if(map.containsKey(rev) && map.get(rev) != i) {
        				List<Integer> l = new ArrayList<Integer>();
        				l.add(map.get(rev));
        				l.add(i);
        				rst.add(l);
        			}
        		}
        		
        		// 2. j..end作为中心
        		if(isPalindrome(right)) {
        			String rev = new StringBuilder(left).reverse().toString();
        			if(map.containsKey(rev) && map.get(rev) != i) {
        				List<Integer> l = new ArrayList<Integer>();
        				l.add(i);
        				l.add(map.get(rev));
        				rst.add(l);
        			}
        		}
        	}
        	
        	// 遗漏的特殊情况""
        	if(isPalindrome(words[i]) && map.containsKey("") && !"".equals(words[i])) {
        		List<Integer> l = new ArrayList<Integer>();
				l.add(i);
				l.add(map.get(""));
				rst.add(l);
				
				List<Integer> l2 = new ArrayList<Integer>();
				l2.add(map.get(""));
				l2.add(i);
				rst.add(l2);
        	}
        	
        	// 3. 没有中心
        	String rev = new StringBuilder(words[i]).reverse().toString();
        	if(map.containsKey(rev) && map.get(rev) != i) {
        		List<Integer> l = new ArrayList<Integer>();
				l.add(i);
				l.add(map.get(rev));
				rst.add(l);
			}
        }
        
        return rst;
    }

	private boolean isPalindrome(String s) {
		if("".equals(s) || s.length() == 1)	return true;
		int i=0, j=s.length()-1;
		while(i<j) {
			if(s.charAt(i)!=s.charAt(j))	return false;
			i++; j--;
		}
		return true;
	}
}

另外这个题也可以转化为字符串的比较问题，或者说字符串的前缀，后缀问题，想想怎么判断这个字符串能不能组合成回文的这个过程就清楚了，既然是字符串比较，前后缀，那就可以用Trie树

package l336;

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

/*
 * 比较2个字符串能不能组成回文，2个pointer，一个从前走，一个从右走
 * 其实就是在比较前缀和后缀（reverse的前缀）
 * 所以可以用Trie
 * 详细可见https://discuss.leetcode.com/topic/39585/o-n-k-2-java-solution-with-trie-structure-n-
 * total-number-of-words-k-average-length-of-each-word/38
 */
class TrieNode {
	TrieNode[] next;
	int index;
	List<Integer> list;	// 包含该前缀，并且
	
	public TrieNode() {
		next = new TrieNode[26];
		index = -1;
		list = new ArrayList<Integer>();
	}
}

public class Solution {
	List<List<Integer>> ret = new ArrayList<List<Integer>>();
	
    public List<List<Integer>> palindromePairs(String[] words) {
    	TrieNode root = new TrieNode();
    	
    	for(int i=0; i<words.length; i++)
    		buildTrie(root, new StringBuilder(words[i]).reverse().toString(), i);
    	
    	// Trie好像不太好用来整个遍历树，最好是有个字符串，一步步沿着Trie数走
    	for(int i=0; i<words.length; i++)
    		search(words, i, root);
    	
    	return ret;
    }

    private void buildTrie(TrieNode root, String s, int idx) {
		for(int i=0; i<s.length(); i++) {
			int j = s.charAt(i)-'a';
			if(root.next[j] == null)	root.next[j] = new TrieNode();
			if(isPalindrome(s, i, s.length()-1))	root.list.add(idx);
			root = root.next[j];
		}
		
		root.list.add(idx);
		root.index = idx;
	}
    
	private void search(String[] words, int i, TrieNode root) {
		for(int j=0; j<words[i].length(); j++) {
			if(root.index >= 0 && root.index != i && isPalindrome(words[i], j, words[i].length()-1))
				ret.add(Arrays.asList(i, root.index));
			
			root = root.next[words[i].charAt(j)-'a'];
			if(root == null)	return;
		}
		
		for(int j : root.list) {
			if(i != j)	ret.add(Arrays.asList(i, j));
		}
	}

	private boolean isPalindrome(String word, int i, int j) {
	    while (i < j) {
	    	if (word.charAt(i++) != word.charAt(j--)) return false;
	    }
	    return true;
	}
}