JAVA练习-练习试用Java实现“回文对”

问题：

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

示例 1：

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

示例 2：

输入：words = ["bat","tab","cat"]
输出：[[0,1],[1,0]] 
解释：可拼接成的回文串为 
["battab","tabbat"]
示例 3：

输入：words = ["a",""]
输出：[[0,1],[1,0]]
提示：

1 <= words.length <= 5000
0 <= words[i].length <= 300
words[i] 由小写英文字母组成

解答思路：

以下是一个使用 Java 解决回文对问题的示例代码：

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

public class PalindromePairs {
    public List<List<Integer>> palindromePairs(String[] words) {
        List<List<Integer>> result = new ArrayList<>();
        Map<String, Integer> wordMap = new HashMap<>();

        // 构建单词到索引的映射
        for (int i = 0; i < words.length; i++) {
            wordMap.put(words[i], i);
        }

        // 遍历单词数组
        for (int i = 0; i < words.length; i++) {
            String word = words[i];

            // 检查单词的逆序是否存在于映射中
            String reversedWord = new StringBuilder(word).reverse().toString();
            if (wordMap.containsKey(reversedWord) && wordMap.get(reversedWord)!= i) {
                List<Integer> pair = new ArrayList<>();
                pair.add(i);
                pair.add(wordMap.get(reversedWord));
                result.add(pair);
            }

            // 检查单词是否可以通过在其前后添加其他单词来形成回文
            for (int j = 0; j < word.length(); j++) {
                String prefix = word.substring(0, j);
                String suffix = word.substring(j);

                // 检查前缀的逆序是否存在于映射中，并且后缀本身是回文
                String reversedPrefix = new StringBuilder(prefix).reverse().toString();
                if (wordMap.containsKey(reversedPrefix) && isPalindrome(suffix)) {
                    List<Integer> pair = new ArrayList<>();
                    pair.add(wordMap.get(reversedPrefix));
                    pair.add(i);
                    result.add(pair);
                }

                // 检查后缀的逆序是否存在于映射中，并且前缀本身是回文
                String reversedSuffix = new StringBuilder(suffix).reverse().toString();
                if (wordMap.containsKey(reversedSuffix) && isPalindrome(prefix)) {
                    List<Integer> pair = new ArrayList<>();
                    pair.add(i);
                    pair.add(wordMap.get(reversedSuffix));
                    result.add(pair);
                }
            }
        }

        return result;
    }

    // 判断一个字符串是否是回文
    private boolean isPalindrome(String word) {
        int left = 0;
        int right = word.length() - 1;

        while (left < right) {
            if (word.charAt(left)!= word.charAt(right)) {
                return false;
            }
            left++;
            right--;
        }

        return true;
    }

    public static void main(String[] args) {
        PalindromePairs solution = new PalindromePairs();

        String[] words1 = {"abcd", "dcba", "lls", "s", "sssll"};
        List<List<Integer>> result1 = solution.palindromePairs(words1);
        System.out.println(result1);  // [[0, 1], [1, 0], [3, 2], [2, 4]]

        String[] words2 = {"bat", "tab", "cat"};
        List<List<Integer>> result2 = solution.palindromePairs(words2);
        System.out.println(result2);  // [[0, 1], [1, 0]]

        String[] words3 = {"a", ""};
        List<List<Integer>> result3 = solution.palindromePairs(words3);
        System.out.println(result3);  // [[0, 1], [1, 0]]
    }
}

这个解决方案的主要思路是：

1. 首先，构建一个单词到索引的映射，以便快速查找单词。
2. 然后，遍历单词数组。对于每个单词，检查它的逆序是否存在于映射中。如果存在且不是当前单词本身，那么这就是一个回文对，将其添加到结果列表中。
3. 接下来，对于每个单词，检查它是否可以通过在其前后添加其他单词来形成回文。具体来说，对于单词的每个前缀和后缀，检查前缀的逆序是否存在于映射中，并且后缀本身是否是回文。如果是，那么这就是一个回文对，将其添加到结果列表中。
4. 最后，返回结果列表。

(文章为作者在学习java过程中的一些个人体会总结和借鉴，如有不当、错误的地方，请各位大佬批评指正，定当努力改正，如有侵权请联系作者删帖。)