前缀和
前缀和可以用来求满足条件的子数组的和、个数、长度
更多前缀和题目:
560. 和为 K 的子数组
中等
给你一个整数数组 nums
和一个整数 k
,请你统计并返回 该数组中和为 k
的子数组的个数 。
子数组是数组中元素的连续非空序列。
示例 1:
输入:nums = [1,1,1], k = 2
输出:2
示例 2:
输入:nums = [1,2,3], k = 3
输出:2
提示:
1 <= nums.length <= 2 * 104
-1000 <= nums[i] <= 1000
-107 <= k <= 107
异或前缀和
参考:一步步优化!从前缀和到前缀异或和(附题单!)
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
中只有小写英文字母
一步步优化,从前缀和到异或前缀和(0x3f)
暴力(超时)
对每一次询问,都去统计字符出现次数,然后统计奇数个字符的个数进行答案比较(超时)
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. 每个元音包含偶数次的最长子字符串
中等
给你一个字符串 s
,请你返回满足以下条件的最长子字符串的长度:每个元音字母,即 ‘a’,‘e’,‘i’,‘o’,‘u’ ,在子字符串中都恰好出现了偶数次。
示例 1:
输入:s = "eleetminicoworoep"
输出:13
解释:最长子字符串是 "leetminicowor" ,它包含 e,i,o 各 2 个,以及 0 个 a,u 。
示例 2:
输入:s = "leetcodeisgreat"
输出:5
解释:最长子字符串是 "leetc" ,其中包含 2 个 e 。
示例 3:
输入:s = "bcbcbc"
输出:6
解释:这个示例中,字符串 "bcbcbc" 本身就是最长的,因为所有的元音 a,e,i,o,u 都出现了 0 次。
提示:
1 <= s.length <= 5 x 10^5
s
只包含小写英文字母。
class Solution {
public int findTheLongestSubstring(String s) {
int n = s.length();
// 用 bit位 标识对应字母奇偶性
// sum[i] 标识 s[0:i) 的子串中每种字母出现次数的奇偶性
int[] sum = new int[n+1];
for(int i = 0; i < n; i++){
int bit = 0;
// 每个元音字母,即 'a','e','i','o','u' ,在子字符串中都恰好出现了偶数次。
if(check(s.charAt(i)))
bit = 1 << (s.charAt(i) - 'a');
sum[i+1] = sum[i] ^ bit;
}
int res = 0;
// 问题化为两数之和 a ^ b = 0
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i <= n; i++){
// 注意求最长串长度,map中只保存sum第一次出现位置
if(map.containsKey(sum[i]))
res = Math.max(res, i - map.get(sum[i]));
else
map.put(sum[i], i);
}
return res;
}
public boolean check(Character c){
return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';
}
}
1542. 找出最长的超赞子字符串
困难
给你一个字符串 s
。请返回 s
中最长的 超赞子字符串 的长度。
「超赞子字符串」需满足满足下述两个条件:
- 该字符串是
s
的一个非空子字符串 - 进行任意次数的字符交换后,该字符串可以变成一个回文字符串
示例 1:
输入:s = "3242415"
输出:5
解释:"24241" 是最长的超赞子字符串,交换其中的字符后,可以得到回文 "24142"
示例 2:
输入:s = "12345678"
输出:1
示例 3:
输入:s = "213123"
输出:6
解释:"213123" 是最长的超赞子字符串,交换其中的字符后,可以得到回文 "231132"
示例 4:
输入:s = "00"
输出:2
提示:
1 <= s.length <= 10^5
s
仅由数字组成
class Solution {
/**
进行任意次数的字符交换后,该字符串可以变成一个回文字符串
==> 字符串「不同字符出现次数」为奇数的个数 <= 1
*/
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;
}
int res = 0;
// 问题转化为两数之和
// a ^ b = 1 / 10 / 100 / 1000...
Map<Integer, Integer> map = new HashMap<>();
for(int i = 0; i <= n; i++){
// 字符串「不同字符出现次数」为奇数的个数 = 0
if(map.containsKey(sum[i]))
res = Math.max(res, i - map.get(sum[i]));
// 字符串「不同字符出现次数」为奇数的个数 = 1
for(int j = 0; j < 10; j++){
int target = (1 << j);
// a ^ b == target ==> a = target ^ b
if(map.containsKey(target ^ sum[i]))
res = Math.max(res, i - map.get(target ^ sum[i]));
}
// 注意求最长串长度,map中只保存sum第一次出现位置
if(!map.containsKey(sum[i]))
map.put(sum[i], i);
}
return res;
}
}
1915. 最美子字符串的数目
中等
如果某个字符串中 至多一个 字母出现 奇数 次,则称其为 最美 字符串。
- 例如,
"ccjjc"
和"abab"
都是最美字符串,但"ab"
不是。
给你一个字符串 word
,该字符串由前十个小写英文字母组成('a'
到 'j'
)。请你返回 word
中 最美非空子字符串 的数目*。如果同样的子字符串在 word
中出现多次,那么应当对 每次出现 分别计数。*
子字符串 是字符串中的一个连续字符序列。
示例 1:
输入:word = "aba"
输出:4
解释:4 个最美子字符串如下所示:
- "aba" -> "a"
- "aba" -> "b"
- "aba" -> "a"
- "aba" -> "aba"
示例 2:
输入:word = "aabb"
输出:9
解释:9 个最美子字符串如下所示:
- "aabb" -> "a"
- "aabb" -> "aa"
- "aabb" -> "aab"
- "aabb" -> "aabb"
- "aabb" -> "a"
- "aabb" -> "abb"
- "aabb" -> "b"
- "aabb" -> "bb"
- "aabb" -> "b"
示例 3:
输入:word = "he"
输出:2
解释:2 个最美子字符串如下所示:
- "he" -> "h"
- "he" -> "e"
提示:
1 <= word.length <= 105
word
由从'a'
到'j'
的小写英文字母组成
class Solution {
public long wonderfulSubstrings(String word) {
int n = word.length();
int[] sum = new int[n+1];
for(int i = 0; i < n; i++){
int bit = (1 << (word.charAt(i) - 'a'));
sum[i+1] = sum[i] ^ bit;
}
long res = 0;
Map<Integer, Integer> map = new HashMap<>();
// 某个字符串中 至多一个 字母出现 奇数 次
for(int i = 0; i <= n; i++){
if(map.containsKey(sum[i]))
res += map.get(sum[i]);
for(int j = 0; j < 11; j++){
int target = (1 << j);
if(map.containsKey(target ^ sum[i]))
res += map.get(target ^ sum[i]);
}
map.merge(sum[i], 1, Integer::sum);
}
return res;
}
}
差分数组
1094. 拼车
中等
车上最初有 capacity
个空座位。车 只能 向一个方向行驶(也就是说,不允许掉头或改变方向)
给定整数 capacity
和一个数组 trips
, trip[i] = [numPassengersi, fromi, toi]
表示第 i
次旅行有 numPassengersi
乘客,接他们和放他们的位置分别是 fromi
和 toi
。这些位置是从汽车的初始位置向东的公里数。
当且仅当你可以在所有给定的行程中接送所有乘客时,返回 true
,否则请返回 false
。
示例 1:
输入:trips = [[2,1,5],[3,3,7]], capacity = 4
输出:false
示例 2:
输入:trips = [[2,1,5],[3,3,7]], capacity = 5
输出:true
提示:
1 <= trips.length <= 1000
trips[i].length == 3
1 <= numPassengersi <= 100
0 <= fromi < toi <= 1000
1 <= capacity <= 105
class Solution {
public boolean carPooling(int[][] trips, int capacity) {
int[] p = new int[1005];
int x = capacity, i = 0;
Arrays.sort(trips, (a, b) -> a[1] - b[1]);
for(int[] t : trips){
int passenger = t[0], from = t[1], to = t[2];
while(i <= from)
x += p[i++];
if(x < passenger) return false;
x -= passenger;
// 需要注意的是在to就下车了,所以这里加在p[to]
p[to] += passenger;
}
return true;
}
}
2772. 使数组中的所有元素都等于零
难度中等10
给你一个下标从 0 开始的整数数组 nums
和一个正整数 k
。
你可以对数组执行下述操作 任意次 :
- 从数组中选出长度为
k
的 任一 子数组,并将子数组中每个元素都 减去1
。
如果你可以使数组中的所有元素都等于 0
,返回 true
;否则,返回 false
。
子数组 是数组中的一个非空连续元素序列。
示例 1:
输入:nums = [2,2,3,1,1,0], k = 3
输出:true
解释:可以执行下述操作:
- 选出子数组 [2,2,3] ,执行操作后,数组变为 nums = [1,1,2,1,1,0] 。
- 选出子数组 [2,1,1] ,执行操作后,数组变为 nums = [1,1,1,0,0,0] 。
- 选出子数组 [1,1,1] ,执行操作后,数组变为 nums = [0,0,0,0,0,0] 。
示例 2:
输入:nums = [1,3,1,1], k = 2
输出:false
解释:无法使数组中的所有元素等于 0 。
提示:
1 <= k <= nums.length <= 105
0 <= nums[i] <= 106
差分
class Solution {
public boolean checkArray(int[] nums, int k) {
int n = nums.length;
int[] diff = new int[n + 1]; // 差分数组
int s = 0; // 第 i 位被减的次数(<0,或者说差分数组当前值 i)
for(int i = 0; i < nums.length; i++){
s += diff[i]; // 累加标记,获得差分数组当前值(被减的次数< 0)
nums[i] = nums[i] + s; // 将当前位减去 操作次数
if(nums[i] < 0) return false;
if(nums[i] > 0){ // 还需要减掉 nums[i],使得nums[i] = 0
if(i + k > n) { // 表示无法操作区间为k的子数组了
return false;
}
s -= nums[i]; // diff[i] -= nums[i],由于不会遍历diff[i]了,所以直接将影响放在s上
diff[i+k] += nums[i]; // 只操作i+k的区间,恢复
}
}
return true;
}
}
可能变一下s的意思更好理解
class Solution {
public boolean checkArray(int[] nums, int k) {
int n = nums.length;
int[] diff = new int[n+1];
int s = 0; // 定义s表示 第i位被减去的次数(>0,操作的次数)
for(int i = 0; i < n; i++){
// 恢复第 i 位的值
s += diff[i];
nums[i] -= s; // 将第 i 位减去操作次数s
if(nums[i] < 0) return false;
if(nums[i] > 0){
if(i+k > n) return false;
// 区间再减去nums[i](diff[i] -= nums[i] and diff[i+k] -= nums[i])
s += nums[i];
diff[i+k] -= nums[i];
}
}
return true;
}
}
2528. 最大化城市的最小供电站数目
难度困难28
给你一个下标从 0 开始长度为 n
的整数数组 stations
,其中 stations[i]
表示第 i
座城市的供电站数目。
每个供电站可以在一定 范围 内给所有城市提供电力。换句话说,如果给定的范围是 r
,在城市 i
处的供电站可以给所有满足 |i - j| <= r
且 0 <= i, j <= n - 1
的城市 j
供电。
|x|
表示x
的 绝对值 。比方说,|7 - 5| = 2
,|3 - 10| = 7
。
一座城市的 电量 是所有能给它供电的供电站数目。
政府批准了可以额外建造 k
座供电站,你需要决定这些供电站分别应该建在哪里,这些供电站与已经存在的供电站有相同的供电范围。
给你两个整数 r
和 k
,如果以最优策略建造额外的发电站,返回所有城市中,最小供电站数目的最大值是多少。
这 k
座供电站可以建在多个城市。
示例 1:
输入:stations = [1,2,4,5,0], r = 1, k = 2
输出:5
解释:
最优方案之一是把 2 座供电站都建在城市 1 。
每座城市的供电站数目分别为 [1,4,4,5,0] 。
- 城市 0 的供电站数目为 1 + 4 = 5 。
- 城市 1 的供电站数目为 1 + 4 + 4 = 9 。
- 城市 2 的供电站数目为 4 + 4 + 5 = 13 。
- 城市 3 的供电站数目为 5 + 4 = 9 。
- 城市 4 的供电站数目为 5 + 0 = 5 。
供电站数目最少是 5 。
无法得到更优解,所以我们返回 5 。
示例 2:
输入:stations = [4,4,4,4], r = 0, k = 3
输出:4
解释:
无论如何安排,总有一座城市的供电站数目是 4 ,所以最优解是 4 。
提示:
n == stations.length
1 <= n <= 105
0 <= stations[i] <= 105
0 <= r <= n - 1
0 <= k <= 109
class Solution {
public long maxPower(int[] stations, int r, int k) {
long left = 0, right = (long)1e15;
while (left < right) {
long mid = (left + right + 1) >> 1;
if (!check(stations, r, k, mid))
right = mid - 1;
else
left = mid;
}
return right;
}
// 将 i 位置供电站stations[i] 化为 区间[i-r, i+r] 的供电站数量,使用差分数组来维护区间更新后的值
// 查看在 至多增加k个供电站 的条件下,每个城市最小供电站数目能否>=mnpower
// 特别的,从左往右遍历,当 i-r 位置城市供电站数目 < mnpower时,则需要在 r位置 建造供电站
public boolean check(int[] stations, int r, int k, long mnpower) {
int n = stations.length;
long cnt = 0; // 额外建造供电站的数量
long[] diff = new long[n + r + 1];
for (int i = 0; i < r; i++) {
diff[0] += stations[i];
diff[i + r + 1] -= stations[i];
}
long s = 0; // 差分数组的当前值(第 i-r 位置上供电站的数目)
for (int i = r; i < n + r; i++) {
if (i < n) {
diff[i - r] += stations[i];
diff[i + r + 1] -= stations[i];
}
s += diff[i - r]; // 恢复 i-r 位置供电站数量
if (s < mnpower) {
long add = mnpower - s;
cnt += add;
if (cnt > k)
return false;
s += add;
if (i < n)
diff[i + r + 1] -= add;
}
}
return true;
}
}