LC-1177. 构建回文串检测（异或前缀和 + 状态压缩）

参考：一步步优化！从前缀和到前缀异或和（附题单！）

https://leetcode.cn/problems/can-make-palindrome-from-substring/solution/yi-bu-bu-you-hua-cong-qian-zhui-he-dao-q-yh5p/

1177. 构建回文串检测

难度中等113

给你一个字符串 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，可以认为每次检测都是独立的）

示例：

输入：s = "abcda", queries = [[3,3,0],[1,2,0],[0,3,1],[0,3,2],[0,4,1]]
输出：[true,false,false,true,true]
解释：
queries[0] : 子串 = "d"，回文。
queries[1] : 子串 = "bc"，不是回文。
queries[2] : 子串 = "abcd"，只替换 1 个字符是变不成回文串的。
queries[3] : 子串 = "abcd"，可以变成回文的 "abba"。 也可以变成 "baab"，先重新排序变成 "bacd"，然后把 "cd" 替换为 "ab"。
queries[4] : 子串 = "abcda"，可以变成回文的 "abcba"。

提示：

• 1 <= s.length, queries.length <= 10^5
• 0 <= queries[i][0] <= queries[i][1] < s.length
• 0 <= queries[i][2] <= s.length
• s 中只有小写英文字母

暴力（超时）

对每一次询问，都去统计字符出现次数，然后统计奇数个字符的个数进行答案比较（超时）

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        List<Boolean> ans = new ArrayList<>();
        char[] arr = s.toCharArray();
        for (int[] q : queries) {
            int left = q[0], right = q[1], k = q[2];
            if(left == right){
                ans.add(true);
                continue;
            }
            int[] cnt = new int[26];
            int diff = 0;
            for (int i = left; i <= right; i++) {
                cnt[arr[i] - 'a'] += 1;
                if (cnt[arr[i] - 'a'] == 2) {
                    diff -= 1;
                    cnt[arr[i] - 'a'] = 0;
                } else
                    diff += 1;
            }
            if (diff / 2 <= k) // 一共又diff个不同字符，需要修改diff/2个字符变成回文串
                ans.add(true);
            else
                ans.add(false);
        }
        return ans;
    }
}

最后要解决的问题是，如何快速求出子串中每种字母的个数？

可以创建 26 个前缀和数组，分别统计每种字母。以字母 a 为例，在计算前缀和时，如果 s[i]=a 就视作 1，否则视作 0

前缀和（优化前）

https://leetcode.cn/problems/can-make-palindrome-from-substring/solution/yi-bu-bu-you-hua-cong-qian-zhui-he-dao-q-yh5p/

算法（优化前）

1.预处理 s 的长为 i 的前缀中，每种字母各出现多少次。为方便后续优化，这里用 n x 26 的二维数组 sum 存储前缀和，其中 sum[i + 1][j] 表示从 s[0] 到 s[i] 中，字母表的第 j 个小写字母的出现次数。

2.对于 queries[i] ，利用前缀和计算出每种字母出现次数，统计有多少种字母出现奇数次，设为 m。如果 m/2 <= k ，那么 answer[i] 为真，反之为假

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        int n = s.length();
        int[][] sum = new int[n+1][26];
        for(int i = 0; i < n; i++){
            sum[i+1] = sum[i].clone();
            sum[i+1][s.charAt(i) - 'a']++;
        } 
        List<Boolean> ans = new ArrayList<Boolean>(queries.length); // 预分配空间
        for(int[] q : queries){
            int left = q[0], right = q[1], k = q[2];
            int m = 0;
            for(int j = 0; j < 26; j++){
                m += (sum[right+1][j] - sum[left][j]) % 2; // 奇数+1，偶数+0
            }
            ans.add(m / 2 <= k);
        }
        return ans;
    }
}

异或前缀和（一步步优化）

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

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

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

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        int n = s.length();
        int[][] sum = new int[n+1][26];
        for(int i = 0; i < n; i++){
            sum[i+1] = sum[i].clone();
            sum[i+1][s.charAt(i) - 'a']++;
            sum[i+1][s.charAt(i) - 'a'] %= 2; // 偶数是0
        } 
        List<Boolean> ans = new ArrayList<Boolean>(queries.length); // 预分配空间
        for(int[] q : queries){
            int left = q[0], right = q[1], k = q[2];
            int m = 0;
            for(int j = 0; j < 26; j++)
                m += (sum[right+1][j] != sum[left][j] ? 1 : 0);
            ans.add(m / 2 <= k);
        }
        return ans;
    }
}

由于异或运算满足 1 和 0 的结果是 1，而 0 和 0，以及 1 和 1 的结果都是 0，所以可以用异或替换上面的减法。

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        int n = s.length();
        int[][] sum = new int[n+1][26];
        for(int i = 0; i < n; i++){
            sum[i+1] = sum[i].clone();
            sum[i+1][s.charAt(i) - 'a'] ^= 1; // 奇数变偶数，偶数变奇数
        } 
        List<Boolean> ans = new ArrayList<Boolean>(queries.length); // 预分配空间
        for(int[] q : queries){
            int left = q[0], right = q[1], k = q[2];
            int m = 0;
            for(int j = 0; j < 26; j++)
                m += sum[right+1][j] ^ sum[left][j];
            ans.add(m / 2 <= k);
        }
        return ans;
    }
}

异或前缀和 + 状态压缩

由于长为 26 的数组中只存储 0 和 1，可以压缩到一个二进制数中，二进制数从低到高第 i 个比特存储着 0 和 1 的信息。

例如二进制 10010 表示 b 和 e 出现奇数次，其余字母出现偶数次。

在计算前缀和时（准确地说是异或前缀和）：

• 修改 a 出现次数的奇偶性，可以异或二进制 1；
• 修改 b 出现次数的奇偶性，可以异或二进制 10；
• 修改 c 出现次数的奇偶性，可以异或二进制 100；
• 依此类推。

此外，由于异或可以「并行计算」，对前缀和中的两个二进制数直接异或，便得到了子串中每种字母出现次数的奇偶性。再计算这个二进制数中的 1 的个数，便得到了 m。

例如 10010⊕01110=11100，说明有 3 种字母出现奇数次。

class Solution {
    public List<Boolean> canMakePaliQueries(String s, int[][] queries) {
        int n = s.length();
        int[] 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;  // 该比特对应字母的奇偶性：奇数变偶数，偶数变奇数
        } 
        List<Boolean> ans = new ArrayList<Boolean>(queries.length); // 预分配空间
        for(int[] 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;
    }
}

问：怎么想到异或的？

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

相似题目（前缀和+异或）

• 1371. 每个元音包含偶数次的最长子字符串
• 1542. 找出最长的超赞子字符串
• 1915. 最美子字符串的数目，题解

更多前缀和题目：

• 560. 和为 K 的子数组
• 974. 和可被 K 整除的子数组
• 1590. 使数组和能被 P 整除
• 523. 连续的子数组和
• 525. 连续数组