(Java)-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:
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"]

这道题，我首先想到的是暴力破解法，每两个字符串加起来，判断是否是回文串，果然超时了。代码如下：

public class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> result = new ArrayList<List<Integer>>();
		for(int i = 0; i < words.length; i++){
			for(int j = 0; j < words.length; j++){
				if(i != j && (words[i].length() == 0 || words[j].length() == 0 || words[i].charAt(0) == words[j].charAt(words[j].length()-1))){
					if(isPalindrome(words[i]+words[j])){
						List<Integer> list = new ArrayList<Integer>();
						list.add(i);
						list.add(j);
						result.add(list);
					}
				}
			}
		}
		
		return result;
    }
	
	private boolean isPalindrome(String s){
		int left = 0;
		int right = s.length()-1;
		while(left <= right){
			if(s.charAt(left) == s.charAt(right)){
				left++;
				right--;
			}else
				return false;
		}
		return true;
	}
}

然后我看tags里有trie树，然后自己异想天开，是想建立两个trie树，第一个存放正常的字符串数组，第二个存放每个字符串都反转的字符串数组，然后对数组里的每个字符串，当其作为组成回文数的第一个数时，从前往后扫描每个字符，在逆序的trie树里查找，若找到字符串，则看看剩下的子字符串是否是回文的，若是，则成功，若不是则失败。

当其作为组成回文数的第二个数时，从后往前扫描每个字符，在正序的trie树里查找，若找到字符串，则看看剩下的子字符串是否是回文的，若是，则成功，若不是则失败。

这种算法只能找到比当前字符更短的匹配字符串，不过不会遗漏。然而这种异想天开的算法也超时了，为了纪念，代码如下所示：

public class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
    	TrieST<Integer> trieordered = new TrieST<Integer>(Alphabet.BASE64);
    	TrieST<Integer> trieunorder = new TrieST<Integer>(Alphabet.BASE64);
    	Set<List<Integer>> set = new HashSet<List<Integer>>();
    	int i = 0;
    	for(String ss: words){
    		trieordered.put(ss, i);
    		trieunorder.put(new StringBuilder(ss).reverse().toString(), i++);
    	}
    	i=0;
    	for(String ss:words){
    		List<Integer> list1 = trieordered.conPalindrome(new StringBuilder(ss).reverse().toString());
    		for(int num : list1){   
    			if(num != i){
	        		List<Integer> templist = new ArrayList<Integer>();
	    			templist.add(num);
	    			templist.add(i);
	    			set.add(templist);
    			}
    		}   		
    		List<Integer> list2 = trieunorder.conPalindrome(ss);
    		for(int num : list2){
    			if(num != i){
	        		List<Integer> templist = new ArrayList<Integer>();
	    			templist.add(i);
	    			templist.add(num);
	    			set.add(templist);
    			}
    		}
    		i++;
    	}
    	List<List<Integer>> result = new ArrayList<List<Integer>>(set);
    	return result;
    }
}

class TrieST<Value> {

	private Alphabet alpha;
	private static int R;
	private Node root;
	
	public TrieST(Alphabet alpha){
		this.alpha = alpha;
		R = alpha.R();
	}
	private static class Node{
		private Object val;
		private Node[] next = new Node[R];
	}
	
	@SuppressWarnings("unchecked")
	public Value get(String key){
		Node x = get(root, key, 0);
		if(x == null)
			return null;
		return (Value)x.val;
	}

	private Node get(Node x, String key, int d) {
		// TODO Auto-generated method stub
		if(x == null)
			return null;	
		if(d == key.length())
			return x;
		char c = key.charAt(d);
		return get(x.next[alpha.toIndex(c)],key,d+1);
	}
	
	public void put(String key, Value v){
		root = put(root, key, v, 0);
	}
	
	private Node put(Node x, String key, Value val, int d){
		if(x == null)
			x = new Node();
		if(d == key.length()){
			x.val = val;
			return x;
		}
		char c = key.charAt(d);
		x.next[alpha.toIndex(c)] = put(x.next[alpha.toIndex(c)], key, val, d+1);
		return x;
	}

	
	public List<Value> conPalindrome(String str){
		List<Value> result = new ArrayList<Value>();
		Node node = root;
		int n = 0;
		if(node.val != null){
			if(isPalindrome(str.substring(n,str.length()))){
				result.add((Value)root.val);
			}
		}
		for(int i = 0 ; i < str.length(); i++){		
			n++;
			char c = str.charAt(i);
			node = node.next[alpha.toIndex(c)];
			if(node == null){
				break;
			}
			if(node.val != null){
				if(isPalindrome(str.substring(n,str.length()))){
					result.add((Value)node.val);
				}
			}

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

class Alphabet {
   public static final Alphabet BASE64 = new Alphabet("ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/");

   private char[] alphabet;     // the characters in the alphabet
   private int[] inverse;       // indices
   private int R;               // the radix of the alphabet

   public Alphabet(String alpha) {

       // check that alphabet contains no duplicate chars
       boolean[] unicode = new boolean[Character.MAX_VALUE];
       for (int i = 0; i < alpha.length(); i++) {
           char c = alpha.charAt(i);
           if (unicode[c])
               throw new IllegalArgumentException("Illegal alphabet: repeated character = '" + c + "'");
           unicode[c] = true;
       }

       alphabet = alpha.toCharArray();
       R = alpha.length();
       inverse = new int[Character.MAX_VALUE];
       for (int i = 0; i < inverse.length; i++)
           inverse[i] = -1;

       // can't use char since R can be as big as 65,536
       for (int c = 0; c < R; c++)
           inverse[alphabet[c]] = c;
   }

   public int R() {
       return R;
   }


   public int toIndex(char c) {
       if (c >= inverse.length || inverse[c] == -1) {
           throw new IllegalArgumentException("Character " + c + " not in alphabet");
       }
       return inverse[c];
   }


   public char toChar(int index) {
       if (index < 0 || index >= R) {
           throw new IndexOutOfBoundsException("Alphabet index out of bounds");
       }
       return alphabet[index];
   }
}

然后在网上看看其他人的想法，如下所示：

利用字典wmap保存单词 -> 下标的键值对

遍历单词列表words，记当前单词为word，下标为idx：

1). 若当前单词word本身为回文，且words中存在空串，则将空串下标bidx与idx加入答案

2). 若当前单词的逆序串在words中，则将逆序串下标ridx与idx加入答案

3). 将当前单词word拆分为左右两半left，right。

     3.1) 若left为回文，并且right的逆序串在words中，则将right的逆序串下标rridx与idx加入答案
     
     3.2) 若right为回文，并且left的逆序串在words中，则将left的逆序串下标idx与rlidx加入答案

O(k * n ^2)解法其中k为单词个数，n为单词的长度

其实1和2只是3的特殊情况

我最开始实现还是用trie树，不过这次内存不够用了（在字符串很长的情况下），本来trie树就是用空间换时间的嘛，于是换用了HashMap，就够了~代码如下：

public class Solution {
    public List<List<Integer>> palindromePairs(String[] words) {
    	Map<String,Integer> trieordered = new HashMap<String,Integer>();
    	Set<List<Integer>> set = new HashSet<List<Integer>>();

    	int i = 0;
    	for(String ss: words){
    		trieordered.put(ss, i++);
    	}
    	i = 0;
    	for(String ss:words){
    		int len = ss.length();
    		for(int index = 0 ; index <= len; index++ ){
    			String left = ss.substring(0, index);
    			String right = ss.substring(index,len);
    			if(isPalindrome(left)){
    				Integer temp = trieordered.get(new StringBuilder(right).reverse().toString());
    				if(temp != null && temp != i){
    					List<Integer> list = new ArrayList<Integer>();
						list.add(temp);
						list.add(i);
						set.add(list);
    				}
    			}
    			if(isPalindrome(right)){
    				Integer temp = trieordered.get(new StringBuilder(left).reverse().toString());
    				if(temp != null && temp != i){
    					List<Integer> list = new ArrayList<Integer>();
						list.add(i);
						list.add(temp);
						set.add(list);
    				}
    			}
    		}
    		i++;
    	}
    	    	List<List<Integer>> result = new ArrayList<List<Integer>>(set);
    	return result;
    }
    
    private boolean isPalindrome(String s){
		int left = 0;
		int right = s.length()-1;
		while(left <= right){
			if(s.charAt(left) == s.charAt(right)){
				left++;
				right--;
			}else
				return false;
		}
		return true;
	}
}