leetcode | 336回文对

给定一组 互不相同 的单词， 找出所有不同 的索引对(i, j)，使得列表中的两个单词， words[i] + words[j] ，可拼接成回文串。

示例 1：

输入：[“abcd”,“dcba”,“lls”,“s”,“sssll”]
输出：[[0,1],[1,0],[3,2],[2,4]]
解释：可拼接成的回文串为 [“dcbaabcd”,“abcddcba”,“slls”,“llssssll”]
示例 2：

输入：[“bat”,“tab”,“cat”]
输出：[[0,1],[1,0]]
解释：可拼接成的回文串为 [“battab”,“tabbat”]

来源：力扣（LeetCode）
链接：https://leetcode-cn.com/problems/palindrome-pairs

代码思路：
如果字符串的个数非常多，而字符串的长度却很小，就需要明确知道每一个字符串需要什么样的字符串可以变成回文串。然后利用hash集在整个str[]中进行快速检索，检索到以后还需要判断这个是否已经在解集中，如果不在解集中则添加进去。

例如：abadc，这样一个words[i]，我们需要判断的字符串有cdab,cd,cdaba,baba，这样四个。
其中cdab,cd,baba和abadc放置的顺序确定，cdaba有两种放置，但是如果cdaba也在words中，在检查cdaba的时候也会判断到abadc，恰好相反，于是不用特殊处理。

代码如下：

public List<List<Integer>> palindromePairs(String[] words) {
		HashMap<String,Integer> map=new HashMap<String,Integer>();
		List<List<Integer>> lists=new LinkedList<List<Integer>>();
		int curr=0;//指示当前的lists填写到第几个
		int num=0;//临时数据存储
		
		int length=words.length-1;
        StringBuilder rev = new StringBuilder();
		String str=new String();
		String rts=new String();
		String temp=new String();
		for(int i=words.length-1;i>=0;i--) {
			map.put(words[i].toString(),i);//将数据words放到哈希表中方便检索
		}
		for(int i=0;i<=length;i++) {
			str=words[i];
			rev.replace(0, rev.length(), str);
			rts=rev.reverse().toString();//rts是str的颠倒的字符串
			for(int n=1;n<=words[i].length();n++) {//从words[i]的左边开始
				temp=str.substring(0, n);//每次去words[i]的前n个字母
				if(check(temp)) {//判断这前n个字母是否是回文串,
					//如果是那么就只需要后面的words[i].length-n个字母就可以组成新的回文串
					temp=rts.substring(0,words[i].length()-n);
					//去words[i]的后words[i].length-n个字母，rts中取要方便一点
					
					
					if(map.containsKey(temp)) {//是否有需要字符串
						num=map.get(temp);
						if(num!=i) {//题目要求不能自己和自己组成
						if(!lists.contains(Arrays.asList(map.get(temp), i))) {//判断解是否在解集中重复
							lists.add(Arrays.asList(map.get(temp), i) );
							
							curr++;
						}
						}
					}
				}
			}
			for(int n=words[i].length()-1;n>=0;n--) {  
				//从words[i]的右边开始，内容与从左边开始相同只有数值不同
				temp=str.substring(n, words[i].length());
				if(check(temp)) {
					temp=rts.substring(words[i].length()-n, words[i].length());
					if(map.containsKey(temp)) {
						num=map.get(temp);
						if(num!=i) {
								if(!lists.contains(Arrays.asList(i, map.get(temp)))) {
									lists.add(Arrays.asList(i, map.get(temp)));
									
								}
						}
					}
				}
			}
			if(map.containsKey(rts)) {
				//判断words中是否有整个words[i]的颠倒串，如果有则可以拼凑成新的回文串
				num=map.get(rts);
				if(num!=i) {//不能自己和自己组成字符串
				if(!lists.contains(Arrays.asList(i, num))) {
					lists.add(Arrays.asList(i, num));
				}
				}
			}
		}
		return lists;
    }
	static public boolean check(String str) {//判断str是否是回文串
		int i=0;
		int n=str.length()-1;
		while(str.charAt(i)==str.charAt(n)) {
			i++;
			n--;
			if(i>=n)return true;
		}
		return false;
	}

代码注释感觉已经非常详细了，思路也是非常简单，就是长了一点，博主也是一个新人，代码效率写法也有很多不尽人意的地方，望多多谅解。

执行结果：

代码的评价：这个思路仅适合与words中字符串个数非常多，但是字符串长度较小的情况。如果字符串长度非常长，但是个数却很少，还不如进行O（n^2）时间的暴力搜索来的快。