LC 1763. 最长的美好子字符串

题目描述

这是 LeetCode 上的 1763. 最长的美好子字符串 ，难度为 简单。

当一个字符串 s 包含的每一种字母的大写和小写形式 同时 出现在 s 中，就称这个字符串 s 是 美好 字符串。

比方说，"abABB" 是美好字符串，因为 'A' 和 'a' 同时出现了，且 'B' 和 'b' 也同时出现了。然而，"abA" 不是美好字符串因为 'b' 出现了，而 'B' 没有出现。

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

示例 1：

1
2
3
4
5
6
输入：s = "YazaAay"

输出："aAa"

解释："aAa" 是一个美好字符串，因为这个子串中仅含一种字母，其小写形式 'a' 和大写形式 'A' 也同时出现了。
"aAa" 是最长的美好子字符串。

示例 2：
1
2
3
4
5
输入：s = "Bb"

输出："Bb"

解释："Bb" 是美好字符串，因为 'B' 和 'b' 都出现了。整个字符串也是原字符串的子字符串。

示例 3：
1
2
3
4
5
输入：s = "c"

输出：""

解释：没有美好子字符串。

示例 4：
1
2
3
4
5
6
输入：s = "dDzeE"

输出："dD"

解释："dD" 和 "eE" 都是最长美好子字符串。
由于有多个美好子字符串，返回 "dD" ，因为它出现得最早。

提示：

  • $1 <= s.length <= 100$
  • s 只包含大写和小写英文字母。

朴素解法

数据范围只有 $100$，最为简单的做法是枚举所有的子串（ 复杂度为 $O(n^2)$ ），然后对子串进行合法性检查（ 复杂度为 $O(n)$ ），整体复杂度为 $O(n^3)$，可以过。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
class Solution {
    public String longestNiceSubstring(String s) {
        int n = s.length();
        String ans = "";
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (j - i + 1 > ans.length() && check(s.substring(i, j + 1))) ans = s.substring(i, j + 1);
            }
        }
        return ans;
    }
    boolean check(String s) {
        Set<Character> set = new HashSet<>();
        for (char c : s.toCharArray()) set.add(c);
        for (char c : s.toCharArray()) {
            char a = Character.toLowerCase(c), b = Character.toUpperCase(c);
            if (!set.contains(a) || !set.contains(b)) return false;
        }
        return true;
    }
}

  • 时间复杂度：$O(n^3)$
  • 空间复杂度：$O(n)$

前缀和优化

在 check 中，我们不可避免的遍历整个子串，复杂度为 $O(n)$。

该过程可以使用前缀和思想进行优化：构建二维数组 $cnt$ 来记录子串的词频，$cnt[i]$ 为一个长度为 $128$ 的数组，用于记录字符串 s 中下标范围为 $[0, i - 1]$ 的词频。即 $cnt[i + 1][j]$ 所代表的含义为在子串 $s[0…i]$ 中字符 $j$ 的出现次数。

那么利用「容斥原理」，对于 s 的任意连续段 $[l, r]$ 所代表的子串中的任意字符 $i$ 的词频，我们可以作差算得：

这样我们在 check 实现中，只要检查 $26$ 个字母对应的大小写词频（ASCII 相差 $32$），是否同时为 $0$ 或者同时不为 $0$ 即可，复杂度为 $O(C)$。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
class Solution {
    public String longestNiceSubstring(String s) {
        int n = s.length();
        int[][] cnt = new int[n + 1][128];
        for (int i = 1; i <= n; i++) {
            char c = s.charAt(i - 1);
            cnt[i] = cnt[i - 1].clone();
            cnt[i][c - 'A']++;
        }
        int idx = -1, len = 0;
        for (int i = 0; i < n; i++) {
            for (int j = i + 1; j < n; j++) {
                if (j - i + 1 <= len) continue;
                int[] a = cnt[i], b = cnt[j + 1];
                if (check(a, b)) {
                    idx = i; len = j - i + 1;
                }
            }
        }
        return idx == -1 ? "" : s.substring(idx, idx + len);
    }
    boolean check(int[] a, int[] b) {
        for (int i = 0; i < 26; i++) {
            int low = b[i] - a[i], up = b[i + 32] - a[i + 32]; // 'A' = 65、'a' = 97
            if (low != 0 && up == 0) return false;
            if (low == 0 && up != 0) return false;
        }
        return true;
    }
}

  • 时间复杂度：令 $C$ 为字符集大小，本题固定为 $26$，构建 $cnt$ 的复杂度为 $O(n 128)$；枚举所有子串复杂度为 $O(n^2)$；check 的复杂度为 $O(C)$。整体复杂度为 $O(n^2 C)$
  • 空间复杂度：$O(n * 128)$

二进制优化

更进一步，对于某个子串而言，我们只关心大小写是否同时出现，而不关心出现次数。

因此我们无须使用二维数组来记录具体的词频，可以在枚举子串时，使用两个 int 的低 $26$ 位分别记录大小写字母的出现情况，利用枚举子串时右端点后移，维护两变量，当且仅当两变量相等时，满足 $26$ 个字母的大小写同时出现或同时不出现。

代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
class Solution {
    public String longestNiceSubstring(String s) {
        int n = s.length();
        int idx = -1, len = 0;
        for (int i = 0; i < n; i++) {
            int a = 0, b = 0;
            for (int j = i; j < n; j++) {
                char c = s.charAt(j);
                if (c >= 'a' && c <= 'z') a |= (1 << (c - 'a'));
                else b |= (1 << (c - 'A'));
                if (a == b && j - i + 1 > len) {
                    idx = i; len = j - i + 1;
                }
            }
        }
        return idx == -1 ? "" : s.substring(idx, idx + len);
    }
}

  • 时间复杂度：$O(n^2)$
  • 空间复杂度：$O(1)$

最后

这是我们「刷穿 LeetCode」系列文章的第 No.1763 篇，系列开始于 2021/01/01，截止于起始日 LeetCode 上共有 1916 道题目，部分是有锁题，我们将先把所有不带锁的题目刷完。

在这个系列文章里面，除了讲解解题思路以外，还会尽可能给出最为简洁的代码。如果涉及通解还会相应的代码模板。

为了方便各位同学能够电脑上进行调试和提交代码，我建立了相关的仓库：https://github.com/SharingSource/LogicStack-LeetCode 。

在仓库地址里，你可以看到系列文章的题解链接、系列文章的相应代码、LeetCode 原题链接和其他优选题解。