纯暴力,两重循环,合并后判断是否是回文,时间复杂度O(N^2K)
class Solution {
public List<List<Integer>> palindromePairs(String[] words) {
List<List<Integer>> res = new ArrayList<>();
for(int i=0;i<words.length;i++){
for(int j=0;j<words.length;j++){
if(i!=j){
if(isPalindrome(words[i]+words[j])){
List<Integer> list = new ArrayList<>();
list.add(i);list.add(j);
res.add(list);
}
}
}
}
return res;
}
private boolean isPalindrome(String s){
int i = 0, j = s.length()-1;
while(i<j){
if(s.charAt(i)!=s.charAt(j)) return false;
i++;
j--;
}
return true;
}
}
如何优化?我们来看两个数拼接的情况
枚举每个字符串的前缀和后缀,判断是否是回文,如果是,再去hash表里去找是否存在逆序。这样字符串数组只用遍历一次。
有一些边界问题,注意处理
class Solution {
List<String> wordsRev = new ArrayList<String>();
Map<String, Integer> indices = new HashMap<String, Integer>();
public List<List<Integer>> palindromePairs(String[] words) {
int n = words.length;
for (String word: words) {
wordsRev.add(new StringBuffer(word).reverse().toString());
}
for (int i = 0; i < n; ++i) {
indices.put(wordsRev.get(i), i);
}
List<List<Integer>> ret = new ArrayList<List<Integer>>();
for (int i = 0; i < n; i++) {
String word = words[i];
int m = words[i].length();
if (m == 0) {
continue;
}
for (int j = 0; j <= m; j++) {
if (isPalindrome(word, j, m - 1)) {
int leftId = findWord(word, 0, j - 1);
if (leftId != -1 && leftId != i) {
ret.add(Arrays.asList(i, leftId));
}
}
if (j != 0 && isPalindrome(word, 0, j - 1)) {
int rightId = findWord(word, j, m - 1);
if (rightId != -1 && rightId != i) {
ret.add(Arrays.asList(rightId, i));
}
}
}
}
return ret;
}
public boolean isPalindrome(String s, int left, int right) {
while(left<right){
if(s.charAt(left)!=s.charAt(right)) return false;
left++;right--;
}
return true;
}
public int findWord(String s, int left, int right) {
return indices.getOrDefault(s.substring(left, right + 1), -1);
}
}