题源：LeetCode

LeetCode月徽章每日一题

1763. 最长的美好子字符串

当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是美好字符串。比方说，“abABB” 是美好字符串，因为 ‘A’ 和 ‘a’ 同时出现了，且 ‘B’ 和 ‘b’ 也同时出现了。然而，“abA” 不是美好字符串因为 ‘b’ 出现了，而 ‘B’ 没有出现。

给你一个字符串 s ，请你返回 s 最长的 美好子字符串 。如果有多个答案，请你返回 最早 出现的一个。如果不存在美好子字符串，请你返回一个空字符串。

提示：
1 <= s.length <= 100
s 只包含大写和小写英文字母。

方法一：滑动窗口
|Σ∣ 为字符集的大小。
枚举最长子串中的字符种类数目，它最小为 11，最大为∣Σ∣/2 ，其中同一个字符的大小写形式视为同一种字符。
对于给定的字符种类数量typeNum，我们维护滑动窗口的左右边界l、r，滑动窗口内部大小字符出现的次数upperCnt，lowerCnt，以及滑动窗口内的字符种类数目total。
当total>typeNum时，我们不断地右移左边界l，并对应地更新upperCnt，lowerCnt以及total，直到total<=typeNum为止。这样，对于任何一个右边界r，我们都能找到最小的l，记为lmin，使得s[lmin…r]之间的字符种类数目不多于typeNum。

完美字符串定义为所有的字符同时出现大写和小写形式，最长的完美字符串一定出现在某个窗口中。对于任何一组lmin，r而言，我们需要判断当前s[lmin…r]是否为完美字符串，检测方法如下：

• 当前字符串中字符种类数量为typeNum，当前字符串中同时出现大小写的字符的种类数量为cnt，只有满足cnt等于typeNum时，我们可以判定字符串为完美字符串。
• 遍历upperCnt，lowerCnt两个数组，第i个字符同时满足upperCnt[i] > 0, lowerCnt[i] > 0时，则认为第i个字符的大小写形式同时出现。

根据上面的结论，当限定字符种类数目为typeNum时，满足题意的最长子串，就一定出自某个s[lmin…r]。因此，在滑动窗口的维护过程中，就可以直接得到最长子串的大小。
最后，还剩下一个细节：如何在滑动窗口的同时高效地维护total和cnt。
- 右移右边界r时，假设s[r]对应的字符的索引为idx，当满足upperCnt[r] + lowerCnt[r] = 1时，则我们认为此时新增了一种字符，将total加1。
- 右移右边界r时，假设s[r]对应的字符的索引为idx，如果s[r]为小写字母，右移右边界后，当满足lowerCnt[idx] = 1且 upperCnt[idx] > 0时，则我们认为此时新增了一种大小写同时存在的字符，将cnt加1；如果s[r]为大写字母，右移右边界后，当满足upperCnt[idx] = 1且 lowerCnt[idx] > 0时，则我们认为此时新增了一种大小写同时存在的字符，将cnt加1；如果s[r]为大写字母，右移右边界后，当满足upperCnt[idx] = 1且lowerCnt[idx] > 0 时，则我们认为此时新增了一种大小写同时存在的字符，将cnt加1。
- 右移左边界l时，假设s[l]对应的字符的索引为idx，当满足upperCnt[idx] + lowerCnt[idx] = 1时，右移左边界后则我们认为此时将减少一种字符，将total - 1。
- 右移左边界l时，假设s[l]对应的字符的索引为idx，如果s[l]为小写字母，右移左边界后，当满足lowerCnt[idx] = 0且 upperCnt[idx] > 0时，则我们认为此时减少了一种大小写同时存在的字符，将cnt - 1；如果s[l]为大写字母，右移左边界后，当满足upperCnt[idx] = 0且 lowerCnt[idx] > 0时，则我们认为此时减少了一种大小写同时存在的字符，将cnt - 1。

class Solution {
public:
    string longestNiceSubstring(string s) {
        int maxPos = 0, maxLen = 0;
        auto check = [&](int typeNum) {
            vector<int> lowerCnt(26);
            vector<int> upperCnt(26);
            int cnt = 0;
            for (int l = 0, r = 0, total = 0; r < s.size(); ++r) {
                int idx = tolower(s[r]) - 'a';
                if (islower(s[r])) {
                    ++lowerCnt[idx];
                    if (lowerCnt[idx] == 1 && upperCnt[idx] > 0) {
                        ++cnt;
                    }
                } else {
                    ++upperCnt[idx];
                    if (upperCnt[idx] == 1 && lowerCnt[idx] > 0) {
                        ++cnt;
                    }
                }
                total += (lowerCnt[idx] + upperCnt[idx]) == 1 ? 1 : 0;

                while (total > typeNum) {
                    idx = tolower(s[l]) - 'a';
                    total -= (lowerCnt[idx] + upperCnt[idx]) == 1 ? 1 : 0;
                    if (islower(s[l])) {
                        --lowerCnt[idx];
                        if (lowerCnt[idx] == 0 && upperCnt[idx] > 0) {
                            --cnt;
                        }
                    } else {
                        --upperCnt[idx];
                        if (upperCnt[idx] == 0 && lowerCnt[idx] > 0) {
                            --cnt;
                        }
                    }
                    ++l;
                }
                if (cnt == typeNum && r - l + 1 > maxLen) {
                    maxPos = l;
                    maxLen = r - l + 1;
                }
            }
        };

        int mask = 0;
        for (char & ch : s) {
            mask |= 1 << (tolower(ch) - 'a');
        }
        int types = __builtin_popcount(mask);
        for (int i = 1; i <= types; ++i) {
            check(i);
        }
        return s.substr(maxPos, maxLen);
    }
};