Leetcode2982. 找出出现至少三次的最长特殊子字符串 II

Every day a Leetcode

题目来源：2982. 找出出现至少三次的最长特殊子字符串 II

解法1：字符串分割 + 分类讨论

按照相同字母分组，每组统计相同字母连续出现的长度。例如 aaaabbbabb 把 a 分成一组，组内有长度 4 和长度 1；把 b 分成一组，组内有长度 3 和长度 2。

单独考虑每一组，按照长度从大到小排序，设长度列表为 group。

分类讨论：

1. 从最长的特殊子串（group[0]）中取三个长度均为 group[0]−2 的特殊子串。例如示例 1 的 aaaa 可以取三个 aa。
2. 从最长和次长的特殊子串（group[0]、group[1]）中取三个长度一样的特殊子串：min⁡(group[0]−1, group[1])。
3. 从最长、次长、第三长的的特殊子串（group[0]、group[1]、group[2]）中各取一个长为 group[2]的特殊子串。

这三种情况取最大值，即：max({group[0] - 2, min(group[0] - 1, group[1]), group[2]})。取每一组的最大值，即为答案。

如果答案是 0，返回 −1。

代码实现时，无需特判 group 数组长度小于 3 的情况，我们只需要在数组添加两个空串（在数组末尾加两个 0）即可。

代码：

/*
 * @lc app=leetcode.cn id=2981 lang=cpp
 *
 * [2982] 找出出现至少三次的最长特殊子字符串 II
 */

// @lc code=start
class Solution
{
public:
    int maximumLength(string s)
    {
        // 特判
        if (s.empty())
            return 0;

        vector<int> groups[26];
        int n = s.length();
        int count = 0;
        for (int i = 0; i < n; i++)
        {
            count++;
            if (i + 1 == n || s[i] != s[i + 1])
            {
                groups[s[i] - 'a'].push_back(count); // 统计连续字符长度
                count = 0;
            }
        }

        int ans = 0;
        for (vector<int> &group : groups)
        {
            if (group.empty())
                continue;
            // 降序排序
            sort(group.begin(), group.end(), greater<int>());
            // 假设还有两个空串
            group.push_back(0);
            group.push_back(0);
            ans = max({ans, group[0] - 2, min(group[0] - 1, group[1]), group[2]});
        }
        return ans == 0 ? -1 : ans;
    }
};
// @lc code=end

结果：

复杂度分析：

时间复杂度：O(nlogn)，其中 n 是字符串 s 的长度。

空间复杂度：O(n)，其中 n 是字符串 s 的长度。

解法2：字符串分割 + 枚举

代码：

// 字符串分割 + 枚举

class Solution
{
public:
    int maximumLength(string s)
    {
        // 特判
        if (s.empty())
            return 0;

        vector<int> groups[26];
        int n = s.length();
        int count = 0;
        for (int i = 0; i < n; i++)
        {
            count++;
            if (i + 1 == n || s[i] != s[i + 1])
            {
                groups[s[i] - 'a'].push_back(count); // 统计连续字符长度
                count = 0;
            }
        }

        int mx = 0;
        for (vector<int> &group : groups)
            for (int &x : group)
                mx = max(mx, x);
        // 枚举
        for (int ans = mx; ans >= mx - 2 && ans > 0; ans--)
        {
            // 枚举字母，计算该字母长度为 ans 的特殊子串有几个
            for (int i = 0; i < 26; i++)
            {
                int count = 0;
                for (int len : groups[i])
                    if (len >= ans)
                        count += len - ans + 1;
                if (count >= 3)
                    return ans;
            }
        }
        return -1;
    }
};

结果：