[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;
}
}