力扣热题——连接两字母单词得到的最长回文串

目录

题目链接：2131. 连接两字母单词得到的最长回文串 - 力扣（LeetCode）

题目描述

解法一：

Java写法：

C++写法：

运行时间

时间复杂度和空间复杂度

​​时间复杂度​​

​​空间复杂度​​

总结

---

        该题目要求从给定双字母单词数组中构造最长回文串。

        解题思路包括：

        1）用哈希表统计单词频率；

        2）处理互为反转的非回文单词对，每对贡献4字符长度；

        3）处理自身回文单词，偶数次每对贡献4字符，奇数次可单独作为中心贡献2字符。

        算法时间复杂度O(n)，空间复杂度O(n)，其中n为单词数量。最终结果为所有配对贡献和加上可能的中心贡献。示例解法提供了Java和C++实现，通过合理配对和中心处理最大化回文串长度。

题目链接：2131. 连接两字母单词得到的最长回文串 - 力扣（LeetCode）

注：下述题目描述和示例均来自力扣

题目描述

给你一个字符串数组 words 。words 中每个元素都是一个包含 两个 小写英文字母的单词。

请你从 words 中选择一些元素并按 任意顺序 连接它们，并得到一个 尽可能长的回文串 。每个元素 至多 只能使用一次。

请你返回你能得到的最长回文串的 长度 。如果没办法得到任何一个回文串，请你返回 0 。

回文串 指的是从前往后和从后往前读一样的字符串。

示例 1：

输入：words = ["lc","cl","gg"]
输出：6
解释：一个最长的回文串为 "lc" + "gg" + "cl" = "lcggcl" ，长度为 6 。
"clgglc" 是另一个可以得到的最长回文串。

示例 2：

输入：words = ["ab","ty","yt","lc","cl","ab"]
输出：8
解释：最长回文串是 "ty" + "lc" + "cl" + "yt" = "tylcclyt" ，长度为 8 。
"lcyttycl" 是另一个可以得到的最长回文串。

示例 3：

输入：words = ["cc","ll","xx"]
输出：2
解释：最长回文串是 "cc" ，长度为 2 。
"ll" 是另一个可以得到的最长回文串。"xx" 也是。

提示：

• 1 <= words.length <=
• words[i].length == 2
• words[i] 仅包含小写英文字母。

---

解法一：

        核心点就是：合理的通过互为反转的单词对和自身回文的单词，最大化回文串的长度。具体思路是这样的：

1. ​​统计单词频率​​：我们用哈希表记录每个单词的出现次数。
2. ​​处理互为反转的非回文对​​：遍历所有单词，若存在互为反转的非回文单词对（如"lc"和"cl"），那么每对贡献4个字符的长度。但是注意了，配对后需更新哈希表中两者的计数以避免重复计算。
3. ​​处理自身回文的单词​​：统计所有自身回文的单词（如"gg"），计算他们™可以成对使用的次数（偶数每对贡献4字符）奇数次出现的自身回文单词，可额外选一个作为中心，贡献2字符长度。
4. ​​综合结果​​：将互为反转对的贡献和自身回文的贡献相加，若有中心则加2。

Java写法：

import java.util.*;

class Solution {
    public int longestPalindrome(String[] words) {
        Map<String, Integer> count = new HashMap<>();
        for (String word : words) {
            count.put(word, count.getOrDefault(word, 0) + 1);
        }
        
        int maxLength = 0;
        // 处理互为反转的非回文对
        for (String s : new ArrayList<>(count.keySet())) {
            if (s.charAt(0) == s.charAt(1)) continue; // 跳过自身回文的单词
            String rev = new StringBuilder(s).reverse().toString();
            if (count.containsKey(rev) && count.get(s) > 0) {
                int pairs = Math.min(count.get(s), count.get(rev));
                maxLength += pairs * 4;
                count.put(s, count.get(s) - pairs);
                count.put(rev, count.get(rev) - pairs);
            }
        }
        
        // 处理自身回文的单词
        boolean hasCenter = false;
        for (String s : count.keySet()) {
            if (s.charAt(0) == s.charAt(1)) {
                int cnt = count.get(s);
                maxLength += (cnt / 2) * 4;
                if (cnt % 2 == 1) {
                    hasCenter = true;
                }
            }
        }
        
        if (hasCenter) {
            maxLength += 2;
        }
        
        return maxLength;
    }
}

C++写法：

#include <vector>
#include <string>
#include <unordered_map>
#include <algorithm>
using namespace std;

class Solution {
public:
    int longestPalindrome(vector<string>& words) {
        unordered_map<string, int> count;
        for (auto& word : words) {
            count[word]++;
        }
        
        int max_length = 0;
        bool has_center = false;
        
        // 处理互为反转的非回文对
        for (auto it = count.begin(); it != count.end(); ) {
            string s = it->first;
            if (s[0] == s[1]) { // 自身回文暂不处理
                ++it;
                continue;
            }
            string rev(s.rbegin(), s.rend());
            if (count.find(rev) != count.end()) {
                int pairs = min(it->second, count[rev]);
                max_length += pairs * 4;
                count[rev] -= pairs;
                it->second -= pairs;
                if (count[rev] == 0) {
                    count.erase(rev);
                }
                if (it->second == 0) {
                    it = count.erase(it);
                } else {
                    ++it;
                }
            } else {
                ++it;
            }
        }
        
        // 处理自身回文的单词
        for (auto& [s, cnt] : count) {
            if (s[0] == s[1]) {
                max_length += (cnt / 2) * 4;
                if (cnt % 2 == 1) {
                    has_center = true;
                }
            }
        }
        
        if (has_center) {
            max_length += 2;
        }
        
        return max_length;
    }
};

运行时间

时间复杂度和空间复杂度

时间复杂度为 ​​O(n)​​，空间复杂度为 ​​O(n)​​，这里的话 n 是 words 数组的长度。

---

​​时间复杂度​​

1. ​​统计单词频率​​
   遍历所有单词并使用哈希表记录频率，时间复杂度为 ​​O(n)​​。哈希表的插入和查询操作平均为 O(1)。

2. ​​处理互为反转的单词对​​
   遍历哈希表，对每个单词检查其反转是否存在。每个单词最多被访问一次（避免重复计算），时间复杂度为 ​​O(n)​​。

3. ​​处理自身回文的单词​​
   再次遍历哈希表，统计自身回文单词的偶数和奇数次出现次数，时间复杂度为 ​​O(n)​​。

综上，总时间复杂度为 ​​O(n)​​。

---

​​空间复杂度​​

1. ​​哈希表存储单词频率​​
   最坏情况下需要存储所有单词及其出现次数，空间复杂度为 ​​O(n)​​。

2. ​​辅助变量​​
   仅使用常数空间存储中间结果（如回文长度、是否包含中心等），空间复杂度为 ​​O(1)​​。

---

---

总结

        该题目要求从给定双字母单词数组中构造最长回文串。解题思路包括：1）用哈希表统计单词频率；2）处理互为反转的非回文单词对，每对贡献4字符长度；3）处理自身回文单词，偶数次每对贡献4字符，奇数次可单独作为中心贡献2字符。算法时间复杂度O(n)，空间复杂度O(n)，其中n为单词数量。最终结果为所有配对贡献和加上可能的中心贡献。示例解法提供了Java和C++实现，通过合理配对和中心处理最大化回文串长度。