【题型总结】寻找满足字符出现奇数次/偶数次的子串个数或者子串最长长度

最新推荐文章于 2025-03-26 19:45:00 发布

TIkitianya

最新推荐文章于 2025-03-26 19:45:00 发布

阅读量1k

点赞数

CC 4.0 BY-SA版权

分类专栏：算法总结文章标签： java 算法

本文链接：https://blog.csdn.net/Tikitian/article/details/131227376

算法总结专栏收录该内容

17 篇文章

订阅专栏

文章介绍了如何利用前缀和、异或和哈希表来解决与字符出现次数奇偶性相关的字符串子串问题，包括寻找满足特定条件的子串个数或最长长度。具体方法包括通过前缀和计算子串中字母的奇偶性，利用位运算判断奇偶性变化，以及通过哈希表优化搜索过程，提高效率。示例题目包括构建回文串检测、最长元音偶数次子串和最美子字符串的数目等。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

寻找满足字符出现奇数次/偶数次的子串个数或者子串最长长度：前缀和+异或+哈希表

题目要求寻找某种特性的子串的数目或者最长长度，而这种特性与字符出现次数的奇偶性相关，那么可以使用前缀和+异或+哈希表解决

构建回文串检测【LC1177】

给你一个字符串 s，请你对 s 的子串进行检测。

每次检测，待检子串都可以表示为 queries[i] = [left, right, k]。我们可以 重新排列 子串 s[left], ..., s[right]，并从中选择最多 k 项替换成任何小写英文字母。

如果在上述检测过程中，子串可以变成回文形式的字符串，那么检测结果为 true，否则结果为 false。

返回答案数组 answer[]，其中 answer[i] 是第 i 个待检子串 queries[i] 的检测结果。

注意：在替换时，子串中的每个字母都必须作为 独立的 项进行计数，也就是说，如果 s[left..right] = "aaa" 且 k = 2，我们只能替换其中的两个字母。（另外，任何检测都不会修改原始字符串 s，可以认为每次检测都是独立的）

前缀和

思路

由于可以将子串重新排列，那么重新排列后能否构成回文串取决于子串中奇数个字母的数目 $n u m$
- 偶数个字母可以在回文串头尾各放一个，因此可以忽略
- 将个数为奇数的字母一半替换成其他字母，如果 $n u m$ 为奇数，剩余的一个可以放在中间，那么需要替换 $⌊num/2⌋\lfloor num/2 \rfloor$ 个字母
如果暴力求出子串中奇数个字母的数目，时间复杂度为 $O(n2)\mathcal{O}(n^2)$ 会超时，优化思路为使用前缀和数组预处理每个字母的数量，那么能快算求出子串中奇数个字母的数目

实现

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        // 怎么快速求出子串中每种字母的个数？
        // 前缀和：存储每个字母在字符串[0,i]中出现的个数
        int n = s.length();
        int[][] count = new int[n + 1][26];
        for (int i = 0; i < n; i++){
            for (int j = 0; j < 26; j++){
                count[i + 1][j] = count[i][j];
                if (j == s.charAt(i) - 'a'){
                    count[i + 1][j]++;
                }
            }
            
        }
        List<Boolean> res = new ArrayList<>();
        for (int[] q : queries){
            int l = q[0], r = q[1], k = q[2];
            int num = 0;
            for (int i = 0; i < 26; i++){
                if ((count[r + 1][i] - count[l][i]) % 2 == 1){
                    num++;
                }
            }
            if (num / 2 <= k){
                res.add(true);
            }else{
                res.add(false);
            }
        }
        return res;

    }
}

复杂度
- 时间复杂度： $O((n+q)C)\mathcal{O}((n+q)C)$
- 空间复杂度： $O(nC)\mathcal{O}(nC)$

位运算

思路

由于只关心每种字母出现次数的奇偶性，所以不需要在前缀和中存储每种字母的出现次数，只需要保存每种字母出现次数的奇偶性。

为方便计算，用 0表示出现偶数次，用 1 表示出现奇数次。

注意只有奇数减偶数，或者偶数减奇数，才能得到奇数。所以如果相减的结果不为 0（或者说相减的两个数不相等），就表示出现了奇数次—》【异或】

作者：灵茶山艾府
链接：https://leetcode.cn/problems/can-make-palindrome-from-substring/solutions/2309725/yi-bu-bu-you-hua-cong-qian-zhui-he-dao-q-yh5p/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

实现

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        int n = s.length();
        var sum = new int[n + 1];
        for (int i = 0; i < n; i++) {
            int bit = 1 << (s.charAt(i) - 'a');
            sum[i + 1] = sum[i] ^ bit; // 该比特对应字母的奇偶性：奇数变偶数，偶数变奇数
        }

        var ans = new ArrayList<Boolean>(queries.length); // 预分配空间
        for (var q : queries) {
            int left = q[0], right = q[1], k = q[2];
            int m = Integer.bitCount(sum[right + 1] ^ sum[left]);// 奇数字母的个数
            ans.add(m / 2 <= k);
        }
        return ans;
    }
}

作者：灵茶山艾府   
链接：https://leetcode.cn/problems/can-make-palindrome-from-substring/solutions/2309725/yi-bu-bu-you-hua-cong-qian-zhui-he-dao-q-yh5p/
来源：力扣（LeetCode）
著作权归作者所有。商业转载请联系作者获得授权，非商业转载请注明出处。

复杂度
- 时间复杂度： $O(n+q)\mathcal{O}(n+q)$
- 空间复杂度： $O(n)\mathcal{O}(n)$

Tips：异或可以视作「不进位加法（减法）」或者「模 222 剩余系中的加法（减法）」，所以也常常用来解决一些和奇偶性有关的问题。

每个元音包含偶数次的最长子字符串【LC1371】

给你一个字符串 s ，请你返回满足以下条件的最长子字符串的长度：每个元音字母，即 ‘a’，‘e’，‘i’，‘o’，‘u’ ，在子字符串中都恰好出现了偶数次。

前缀和+位运算+枚举

思路：

使用前缀和和位运算state记录元音字母次数的奇偶性，从大到小枚举子串长度，判断该子串是否所有元音字母都出现偶数次，如果是，那么直接返回该长度
实现

class Solution {
    public int findTheLongestSubstring(String s) {
        int n = s.length();
        int[] sum = new int[n + 1];
        for (int i = 0; i < n; i++){
            if (isVowel(s.charAt(i))){
                int bit = 1 << (s.charAt(i) - 'a');
                sum[i + 1] = sum[i] ^ bit;
            }else{
                sum[i + 1] = sum[i];
            }                  
        }
        for (int len = n ; len > 0; len--){
            for (int i = 0; i + len <= n; i++){
                if ((sum[i + len] ^ sum[i]) == 0){
                    return len;
                }
            }
        }
        return 0;
    }
    public boolean isVowel(char c){
        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
    }
}

复杂度
- 时间复杂度： $O(n2)\mathcal{O}(n^2)$
- 空间复杂度： $O(n)\mathcal{O}(n)$

前缀和+位运算+哈希表

优化：

通过哈希表进行优化，寻找以某个字符为结尾的，符合题意的最长子字符串的长度，假设当前子串 $s [0, r]$ 对应的元音字母奇偶性为state，如果子串 $s [l, r]$ 符合要求，子串 $s [0, l]$ 对应的状态码为$state \oplus 0 $。因此使用哈希表记录state的最左位置
实现

class Solution {
    public int findTheLongestSubstring(String s) {
        int n = s.length();
        Map<Integer, Integer> stateToIndex = new HashMap<>();
        stateToIndex.put(0, -1);
        int state = 0;
        int res = 0;
        for (int i = 0; i < n; i++){
            if (isVowel(s.charAt(i))){
                int bit = 1 << (s.charAt(i) - 'a');
                state = state ^ bit;
            }
            int l = stateToIndex.getOrDefault(state ^ 0, n);          
            res = Math.max(res, i - l);
            if (!stateToIndex.containsKey(state)){
                stateToIndex.put(state, i);
            }                 
        }
        return res;
    }
    public boolean isVowel(char c){
        return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
    }
}

复杂度
- 时间复杂度： $O(n)\mathcal{O}(n)$
- 空间复杂度： $O(n)\mathcal{O}(n)$

找出最长的超赞子字符串【LC1542】

给你一个字符串 s 。请返回 s 中最长的 超赞子字符串 的长度。

「超赞子字符串」需满足满足下述两个条件：

该字符串是 s 的一个非空子字符串
进行任意次数的字符交换后，该字符串可以变成一个回文字符串

前缀和+位运算+枚举【超时】

class Solution {
    public int longestAwesome(String s) {
        int n = s.length();
        int[] sum = new int[n + 1];
        for (int i = 0; i < n; i++){
            int bit = 1 << (s.charAt(i) - '0');
            sum[i + 1] = sum[i] ^ bit;
        }
        for (int len = n; len > 0; len--){
            for (int i = 0; i + len <= n; i++){
                int odd = Integer.bitCount(sum[i + len] ^ sum[i]);
                if (odd <= 1 ){
                    return len;
                }
            }
        }
        return 0;
    }
}

复杂度
- 时间复杂度： $O(n2)\mathcal{O}(n^2)$
- 空间复杂度： $O(n)\mathcal{O}(n)$

前缀和+位运算+哈希表

class Solution {
    public int longestAwesome(String s) {
        // 最多有一个字符出现次数为奇数
        // 最多只有一位不一样，更改每一位判断哈希表是否出现过
        int n = s.length();
        Map<Integer, Integer> stateToIndex = new HashMap<>();
        stateToIndex.put(0, -1);
        int state = 0;
        int res = 0;
        for (int i = 0; i < n; i++){
            int bit = 1 << (s.charAt(i) - '0');
            state = state ^ bit;
            int l = stateToIndex.getOrDefault(state, n);
            res = Math.max(res, i - l);
            // 将某一位设置为相反
            for (int j = 0; j <= 9; j++){
                int b = (state >> j) & 1;// 第j个数位的值
                int target = state;
                if (b == 1){// 将第j位设置为0
                    target &= ~(1 << j);
                }else{// 将第i位设置为1
                    target |= 1 << j;
                }
                l = stateToIndex.getOrDefault(target, n);
                res = Math.max(res, i - l);
            }
            if (!stateToIndex.containsKey(state)){
                stateToIndex.put(state, i);
            }          
        }
        return res;
    }
}

复杂度
- 时间复杂度： $O(n)\mathcal{O}(n)$
- 空间复杂度： $O(n)\mathcal{O}(n)$

最美子字符串的数目【LC1915】

如果某个字符串中 至多一个 字母出现奇数次，则称其为最美字符串。

例如，"ccjjc" 和 "abab" 都是最美字符串，但 "ab" 不是。

给你一个字符串 word ，该字符串由前十个小写英文字母组成（'a' 到 'j'）。请你返回 word 中 最美非空子字符串 的数目*。如果同样的子字符串在 word 中出现多次，那么应当对 每次出现 分别计数。*

子字符串 是字符串中的一个连续字符序列。

前缀和+位运算+哈希表

将哈希表记录坐标改为记录数目，其他同上

class Solution {
    public long wonderfulSubstrings(String word) {
        // 只有一个字母出现奇数次->异或后最多只有一位为1->target只有一位和state不同
        int n = word.length();
        Map<Integer, Integer> stateToCount = new HashMap<>();
        stateToCount.put(0, 1);
        int state = 0;
        long res = 0L;
        for (int i = 0; i < n; i++){
            int bit = (1 << (word.charAt(i) - 'a'));
            state = state ^ bit;
            res += stateToCount.getOrDefault(state, 0);
            for (int j = 0; j <= 'j' - 'a'; j++){
                int b = (state >> j) & 1;// 第j个数位的值
                int target = state;
                if (b == 1){// 将第j位设置为0
                    target &= ~(1 << j);
                }else{// 将第i位设置为1
                    target |= 1 << j;
                }
                res += stateToCount.getOrDefault(target, 0);
            }
            stateToCount.put(state, stateToCount.getOrDefault(state, 0) + 1);
        }
        return res;

    }
}

复杂度
- 时间复杂度： $O(n)\mathcal{O}(n)$
- 空间复杂度： $O(n)\mathcal{O}(n)$

也可以枚举第 $i$ 位为奇数个时，求出是否有相应的state

class Solution {
    public long wonderfulSubstrings(String word) {
        // 只有一个字母出现奇数次->异或后最多只有一位为1->target只有一位和state不同
        int n = word.length();
        Map<Integer, Integer> stateToCount = new HashMap<>();
        stateToCount.put(0, 1);
        int state = 0;
        long res = 0L;
        for (int i = 0; i < n; i++){
            int bit = (1 << (word.charAt(i) - 'a'));
            state = state ^ bit;
            res += stateToCount.getOrDefault(state, 0);
            for (int j = 1; j < 1024; j <<= 1){
                res += stateToCount.getOrDefault(state ^ j, 0);
            }
            stateToCount.put(state, stateToCount.getOrDefault(state, 0) + 1);
        }
        return res;

    }
}