周赛375（差分思想、快速幂、双指针）
文章目录
- 周赛375
-
- [2960. 统计已测试设备](https://leetcode.cn/problems/count-tested-devices-after-test-operations/)
-
- 差分思想
- [2961. 双模幂运算](https://leetcode.cn/problems/double-modular-exponentiation/)
-
- 快速幂
- [50. Pow(x, n)](https://leetcode.cn/problems/powx-n/)
- [2962. 统计最大元素出现至少 K 次的子数组](https://leetcode.cn/problems/count-subarrays-where-max-element-appears-at-least-k-times/)
-
- 双指针
- [2963. 统计好分割方案的数目](https://leetcode.cn/problems/count-the-number-of-good-partitions/)
-
- 化为合并区间问题
周赛375
2960. 统计已测试设备
简单
给你一个长度为 n 、下标从 0 开始的整数数组 batteryPercentages ，表示 n 个设备的电池百分比。
你的任务是按照顺序测试每个设备 i，执行以下测试操作：
- 如果batteryPercentages[i]大于0：
- 增加 已测试设备的计数。
- 将下标在
[i + 1, n - 1]的所有设备的电池百分比减少1，确保它们的电池百分比 不会低于0，即batteryPercentages[j] = max(0, batteryPercentages[j] - 1)。 - 移动到下一个设备。
- 否则，移动到下一个设备而不执行任何测试。
返回一个整数，表示按顺序执行测试操作后 已测试设备 的数量。
示例 1：
输入：batteryPercentages = [1,1,2,1,3]
输出：3
解释：按顺序从设备 0 开始执行测试操作：
在设备 0 上，batteryPercentages[0] > 0 ，现在有 1 个已测试设备，batteryPercentages 变为 [1,0,1,0,2] 。
在设备 1 上，batteryPercentages[1] == 0 ，移动到下一个设备而不进行测试。
在设备 2 上，batteryPercentages[2] > 0 ，现在有 2 个已测试设备，batteryPercentages 变为 [1,0,1,0,1] 。
在设备 3 上，batteryPercentages[3] == 0 ，移动到下一个设备而不进行测试。
在设备 4 上，batteryPercentages[4] > 0 ，现在有 3 个已测试设备，batteryPercentages 保持不变。
因此，答案是 3 。
示例 2：
输入：batteryPercentages = [0,1,2]
输出：2
解释：按顺序从设备 0 开始执行测试操作：
在设备 0 上，batteryPercentages[0] == 0 ，移动到下一个设备而不进行测试。
在设备 1 上，batteryPercentages[1] > 0 ，现在有 1 个已测试设备，batteryPercentages 变为 [0,1,1] 。
在设备 2 上，batteryPercentages[2] > 0 ，现在有 2 个已测试设备，batteryPercentages 保持不变。
因此，答案是 2 。
提示：
1 <= n == batteryPercentages.length <= 1000 <= batteryPercentages[i] <= 100
差分思想
class Solution {
public int countTestedDevices(int[] b) {
int res = 0;
int n = b.length, add = 0;
for(int i = 0; i < n; i++){
if(b[i]-add > 0){
res += 1;
add += 1;
}
}
return res;
}
}
2961. 双模幂运算
中等
给你一个下标从 0 开始的二维数组 variables ，其中 variables[i] = [ai, bi, ci, mi]，以及一个整数 target 。
如果满足以下公式，则下标 i 是 好下标：
0 <= i < variables.length((aibi % 10)ci) % mi == target
返回一个由 好下标 组成的数组，顺序不限 。
示例 1：
输入：variables = [[2,3,3,10],[3,3,3,1],[6,1,1,4]], target = 2
输出：[0,2]
解释：对于 variables 数组中的每个下标 i ：
1) 对于下标 0 ，variables[0] = [2,3,3,10] ，(23 % 10)3 % 10 = 2 。
2) 对于下标 1 ，variables[1] = [3,3,3,1] ，(33 % 10)3 % 1 = 0 。
3) 对于下标 2 ，variables[2] = [6,1,1,4] ，(61 % 10)1 % 4 = 2 。
因此，返回 [0,2] 作为答案。
示例 2：
输入：variables = [[39,3,1000,1000]], target = 17
输出：[]
解释：对于 variables 数组中的每个下标 i ：
1) 对于下标 0 ，variables[0] = [39,3,1000,1000] ，(393 % 10)1000 % 1000 = 1 。
因此，返回 [] 作为答案。
提示：
1 <= variables.length <= 100variables[i] == [ai, bi, ci, mi]1 <= ai, bi, ci, mi <= 1030 <= target <= 103
快速幂
class Solution {
public List<Integer> getGoodIndices(int[][] variables, int target) {
List<Integer> ans = new ArrayList<>();
for (int i = 0; i < variables.length; i++) {
int[] v = variables[i];
if (pow(pow(v[0], v[1], 10), v[2], v[3]) == target) {
ans.add(i);
}
}
return ans;
}
private long pow(long x, int n, int mod) {
long res = 1;
for (; n > 0; n /= 2) {
if (n % 2 > 0)
res = res * x % mod;
x = x * x % mod;
}
return res;
}
}
50. Pow(x, n)
中等
实现 pow(x, n) ，即计算 x 的整数 n 次幂函数（即，xn ）。
示例 1：
输入：x = 2.00000, n = 10
输出：1024.00000
示例 2：
输入：x = 2.10000, n = 3
输出：9.26100
示例 3：
输入：x = 2.00000, n = -2
输出：0.25000
解释：2-2 = 1/22 = 1/4 = 0.25
提示：
-100.0 < x < 100.0-231 <= n <= 231-1n是一个整数- 要么
x不为零，要么n > 0。 -104 <= xn <= 104
class Solution {
/** pow(x, n)
1.使用折半计算，每次把n缩小一半，这样n最终会缩小到0，任何数的0次方都为1
2.这时候我们再往回乘，
2.1如果此时n是偶数，直接把上次递归得到的值算个平方返回即可
2.2如果是奇数，则还需要乘上个x的值。
3.还有一点需要引起我们的注意的是n有可能为负数，对于n是负数的情况，
我们可以先用其绝对值计算出一个结果再取其倒数即可。
算法:
1. 我们让i初始化为n，i每次循环缩小一半，直到为0停止
2. 每次循环看i是否是2的倍数，是的话x乘以自己，否则res乘以x。
3. 最后看n的正负，如果为负，返回其倒数。
*/
public double myPow(double x, int n) {
double res = 1.0;
for(int i = n; i != 0; i = i/2){
if(i % 2 != 0) res = res*x;
x *= x;
}
return n < 0 ? 1/res : res;
}
}
2962. 统计最大元素出现至少 K 次的子数组
中等
给你一个整数数组 nums 和一个 正整数 k 。
请你统计有多少满足 「 nums 中的 最大 元素」至少出现 k 次的子数组，并返回满足这一条件的子数组的数目。
子数组是数组中的一个连续元素序列。
示例 1：
输入：nums = [1,3,2,3,3], k = 2
输出：6
解释：包含元素 3 至少 2 次的子数组为：[1,3,2,3]、[1,3,2,3,3]、[3,2,3]、[3,2,3,3]、[2,3,3] 和 [3,3] 。
示例 2：
输入：nums = [1,4,2,1], k = 3
输出：0
解释：没有子数组包含元素 4 至少 3 次。
提示：
1 <= nums.length <= 1051 <= nums[i] <= 1061 <= k <= 105
双指针
class Solution {
public long countSubarrays(int[] nums, int k) {
int mx = 0;
for(int num : nums) mx = Math.max(mx, num);
int left = 0, cnt = 0, n = nums.length;
long res = 0;
for(int right = 0; right < n; right++){
if(nums[right] == mx){
cnt += 1;
}
while(cnt >= k){
// cnt == k
// 此时从[left, n)的数组都是满足要求的
// 答案个数位 n - right个
res += n - right;
if(nums[left] == mx){
cnt -= 1;
}
left++;
}
}
return res;
}
}
2963. 统计好分割方案的数目
困难
给你一个下标从 0 开始、由 正整数 组成的数组 nums。
将数组分割成一个或多个 连续 子数组，如果不存在包含了相同数字的两个子数组，则认为是一种 好分割方案 。
返回 nums 的 好分割方案 的 数目。
由于答案可能很大，请返回答案对 109 + 7 取余 的结果。
示例 1：
输入：nums = [1,2,3,4]
输出：8
解释：有 8 种 好分割方案 ：([1], [2], [3], [4]), ([1], [2], [3,4]), ([1], [2,3], [4]), ([1], [2,3,4]), ([1,2], [3], [4]), ([1,2], [3,4]), ([1,2,3], [4]) 和 ([1,2,3,4]) 。
示例 2：
输入：nums = [1,1,1,1]
输出：1
解释：唯一的 好分割方案 是：([1,1,1,1]) 。
示例 3：
输入：nums = [1,2,1,3]
输出：2
解释：有 2 种 好分割方案 ：([1,2,1], [3]) 和 ([1,2,1,3]) 。
提示：
1 <= nums.length <= 1051 <= nums[i] <= 109
化为合并区间问题
class Solution {
/**
用哈希表记录元素第一次和最后一次出现的位置,每个元素对应这一个不可分割的区间
然后按照56. 合并区间的做法合并起来,合并区间个数m,答案就是2^(m-1)
*/
public int numberOfGoodPartitions(int[] nums) {
Map<Integer, int[]> ps = new HashMap<>();
for(int i = 0; i < nums.length; i++){
int x = nums[i];
if(ps.containsKey(x)){
ps.get(x)[1] = i;
}else{
ps.put(x, new int[]{i, i});
}
}
List<int[]> a = new ArrayList<>(ps.values());
a.sort((p, q) -> p[0] - q[0]); // 按照区间左端点排序
// 56. 合并区间
int ans = 1;
int maxR = a.get(0)[1];
for(int i = 1; i < a.size(); i++){
int[] interval = a.get(i);
int left = interval[0], right = interval[1];
if(left > maxR){ // 无法合并
ans = ans * 2 % (int)(1e9+7);
}
maxR = Math.max(maxR, right);
}
return ans;
}
}