中等

给你一个整数数组 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

难度中等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 中只有小写英文字母

中等

给你一个字符串 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 = 0Map<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]));elsemap.put(sum[i], i);}return res;}public boolean check(Character c){return c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u';}
}

困难

给你一个字符串 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++){// 字符串「不同字符出现次数」为奇数的个数 = 0if(map.containsKey(sum[i]))res = Math.max(res, i - map.get(sum[i]));// 字符串「不同字符出现次数」为奇数的个数 = 1for(int j = 0; j < 10; j++){int target = (1 << j);// a ^ b == target ==> a = target ^ bif(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;}
}

中等

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

• 例如，"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;}
}

难度中等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] = 0if(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 位减去操作次数sif(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;}
}

难度困难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;elseleft = 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;}
}