#1 ！
题目
3355. 零数组变换 I
中等
相关标签
相关企业
提示
给定一个长度为 n 的整数数组 nums 和一个二维数组 queries，其中 queries[i] = [li, ri]。
对于每个查询 queries[i]：
在 nums 的下标范围 [li, ri] 内选择一个下标 子集。
将选中的每个下标对应的元素值减 1。
零数组 是指所有元素都等于 0 的数组。
如果在按顺序处理所有查询后，可以将 nums 转换为 零数组 ，则返回 true，否则返回 false。
示例 1：
输入： nums = [1,0,1], queries = [[0,2]]
输出： true
解释：
对于 i = 0：
选择下标子集 [0, 2] 并将这些下标处的值减 1。
数组将变为 [0, 0, 0]，这是一个零数组。
示例 2：
输入： nums = [4,3,2,1], queries = [[1,3],[0,2]]
输出： false
解释：
对于 i = 0：
选择下标子集 [1, 2, 3] 并将这些下标处的值减 1。
数组将变为 [4, 2, 1, 0]。
对于 i = 1：
选择下标子集 [0, 1, 2] 并将这些下标处的值减 1。
数组将变为 [3, 1, 0, 0]，这不是一个零数组。
提示：
1 <= nums.length <= 105
0 <= nums[i] <= 105
1 <= queries.length <= 105
queries[i].length == 2
0 <= li <= ri < nums.length题目解读
题目要求判断能否通过一系列区间子集减 1 操作将数组变为零数组。关键是每个元素减少次数需等于初始值且不超过其被查询覆盖次数。用差分数组统计各位置覆盖次数，贪心从左到右分配次数，借前补后，最后检查剩余次数是否为零。
好的！我们再深入一层，从**问题本质**和**算法设计原理**的角度来拆解，帮助你彻底理解这个问题。
### **一、问题的本质：流量分配模型**
可以把每个元素的减少次数看作“流量”，每个查询的区间看作“管道”，管道可以在区间内任意分配流量（即选择子集）。我们需要确保：
1. **每个元素的总流量等于初始值**（`nums[i]`）。
2. **每个查询的管道流量总和不超过其容量**（每个查询可以分配任意流量到区间内的元素，但总流量无上限，因为可以多次选择同一元素）。
- 这里的“容量”其实是无限的，因为每个查询可以多次选择同一元素（只要在区间内）。但**每个元素的总流量不能超过其被包含在查询中的次数**（即`count[i]`）。
**核心矛盾**：元素`i`的总流量（`nums[i]`）必须 ≤ 其被包含的查询次数（`count[i]`），并且流量必须能按查询顺序分配。
### **二、差分数组的本质：区间覆盖次数统计**
为什么用差分数组？因为它能高效统计**每个元素被多少个查询区间覆盖**。
- 每个查询`[l, r]`相当于对区间`[l, r]`内的所有元素“允许增加一次流量”。
- 差分数组`diff`的作用是：
- 在`l`处标记“开始允许流量”，
- 在`r+1`处标记“结束允许流量”。
- 通过前缀和计算`count[i]`，得到每个元素被允许的总流量次数（即最多可以被减少多少次）。
**举个例子**：
查询序列`[[1,3], [0,2]]`对应差分数组操作：
```
diff[0] += 1 （允许位置0开始）
diff[3] -= 1 （位置3结束允许，即位置0-2允许）
diff[1] += 1 （允许位置1开始）
diff[4] -= 1 （位置4结束允许，即位置1-3允许）
```
计算前缀和后：
```
count[0] = 1 （被第2个查询覆盖）
count[1] = 1+1=2 （被两个查询覆盖）
count[2] = 2+0=2 （被两个查询覆盖）
count[3] = 2-1=1 （被第1个查询覆盖）
```
这表示：
- 位置0最多可被减少1次（只能在第2个查询中被选），
- 位置1和2最多可被减少2次（在两个查询中都能被选），
- 位置3最多可被减少1次（只能在第1个查询中被选）。
### **三、贪心策略的核心：顺序约束与流量传递**
为什么必须从左到右处理？因为**查询是按顺序执行的**，左边元素的流量分配会影响右边元素的可用流量。
- **左边元素的流量只能来自前面的查询**（因为后面的查询还未执行），
- **右边元素的流量可以来自前面或后面的查询**（后面的查询在顺序上更靠后，执行时可以选择右边元素）。
#### **关键变量：borrow的物理意义**
`borrow`表示**前面所有查询中，覆盖当前元素的剩余可用流量**。
- 例如，前面的查询区间包含当前元素`i`，但前面的元素`0~i-1`没有用完这些查询的流量，剩下的流量可以“借给”当前元素`i`使用。
- 注意：这里的“前面查询”指的是所有查询，而不仅仅是顺序上的前几个查询。因为差分数组统计的是所有查询的覆盖次数，`count[i]`是总和，所以`borrow`实际上是**所有查询中覆盖`i`的流量，扣除前面元素已用的部分**。
#### **贪心流程的数学表达**
对于元素`i`：
1. **先使用borrow中的流量**：
`used_borrow = min(borrow, nums[i])`
`remaining = nums[i] - used_borrow`
- 如果`borrow > nums[i]`，说明前面的剩余流量过多（后面的元素无法“归还”流量给前面），直接失败。
2. **再使用当前元素的count[i]流量**：
- 如果`remaining > count[i]`，说明总流量不足，失败。
- 否则，当前元素用完`remaining`流量，剩余的`count[i] - remaining`流量可以“借给”后面的元素（因为这些流量来自包含`i`的查询，而这些查询可能还覆盖`i+1~n-1`的元素）。
- 所以，`borrow = count[i] - remaining`。
#### **为什么borrow只能累加，不能递减？**
因为流量只能从左向右传递（前面的查询覆盖当前元素后，剩余流量可以留给后面的元素，但后面的元素无法将流量反传给前面）。例如：
- 元素`i`处理完后，剩余流量`borrow`只能来自包含`i`的查询，而这些查询必然也包含`i+1`（如果查询区间包含`i`，且右端点≥`i`，则可能包含`i+1`）。因此，`borrow`可以安全地传递给`i+1`。
### **四、错误示例分析：为什么示例2无法满足？**
#### **示例2的参数**
- `nums = [4,3,2,1]`，
- `queries = [[1,3], [0,2]]`，
- 计算`count`数组：
- 第一个查询覆盖1-3 → `diff[1] +=1`, `diff[4]-=1`，
- 第二个查询覆盖0-2 → `diff[0] +=1`, `diff[3]-=1`，
- 前缀和计算：
```
count[0] = 1（仅第二个查询），
count[1] = 1+1=2（两个查询），
count[2] = 2+0=2（两个查询），
count[3] = 2-1=1（仅第一个查询）。
```
#### **贪心流程**
- `borrow = 0`，遍历每个元素：
1. **元素0（nums[0]=4，count[0]=1）**：
- `borrow=0`，`remaining = 4-0=4`。
- `count[0]=1 < 4`，直接失败。
- **结论**：元素0需要4次流量，但只能被包含在1个查询中（第二个查询），无法满足，返回`false`。
这解释了为什么示例2失败：**元素0的初始值超过了其被包含的查询次数**，无论怎么分配都无法满足。
### **五、算法的边界条件处理**
1. **nums[i] = 0的情况**：
- 该元素不需要任何流量，其`count[i]`可以全部剩余，累加到`borrow`中。
2. **最后一个元素处理完后，borrow必须为0**：
- 因为后面没有元素可以接收剩余流量，所有流量必须被用完。例如：
- `nums = [0,1]`，`queries = [[0,1]]`，
- `count = [1,1]`，
- 元素0不需要流量，`borrow`初始为0，处理元素0后，`borrow = 1-0=1`，
- 元素1需要1次流量，用`borrow`中的1次，`count[1]=1`剩余`1-1=0`，`borrow=0`，最终成功。
3. **borrow可能为负数吗？**
- 不会。因为`remaining = max(0, nums[i] - borrow)`，当`borrow >= nums[i]`时，`remaining=0`，`borrow`只会保留`count[i]`的剩余部分（非负数）。
### **六、总结：从暴力到优化的思维路径**
#### **暴力思路（不可行）**
- 对每个查询，记录哪些元素被选中，但时间复杂度太高（`O(mn)`）。
#### **优化思路**
- **差分数组**：将区间操作转化为前缀和问题，快速得到每个元素的总可用流量次数（`count[i]`）。
- **贪心策略**：利用查询的顺序性，从左到右分配流量，确保每个元素的流量需求被满足，且剩余流量可传递给右侧元素。
#### **核心公式**
```
对于每个元素i：
1. remaining = max(0, nums[i] - borrow)
2. if remaining > count[i]: 失败
3. borrow = count[i] - remaining
最后检查borrow == 0
```
### **七、代码逐行解析（Java版本）**
```java
public boolean checkArray(int[] nums, int[][] queries) {
int n = nums.length;
int[] diff = new int[n + 1]; // 差分数组，长度n+1
// 处理每个查询，更新差分数组
for (int[] q : queries) {
int l = q[0];
int r = q[1];
diff[l]++; // 区间起点+1
diff[r + 1]--; // 区间终点+1的位置-1，确保区间[l, r]有效
}
// 计算前缀和，得到每个位置的查询次数count[i]
int[] count = new int[n];
count[0] = diff[0]; // 第一个元素的count
for (int i = 1; i < n; i++) {
count[i] = count[i - 1] + diff[i]; // 前缀和
}
long borrow = 0; // 使用long避免整数溢出
for (int i = 0; i < n; i++) {
int x = nums[i];
if (borrow > x) { // 前面剩余的流量超过当前需要，不可能
return false;
}
x -= borrow; // 先用borrow中的流量
if (x < 0) { // 防止负数（虽然borrow<=x时x不会负，但保险起见）
x = 0;
}
if (count[i] < x) { // 当前位置的流量不够
return false;
}
borrow = count[i] - x; // 剩余流量借给后面
}
return borrow == 0; // 确保所有流量用完
}
```
### **八、常见误区与解答**
#### **误区1：count[i]是每个查询中必须选i的次数**
- 错误。count[i]是**所有查询中包含i的次数总和**，每次查询可以选择是否选i。例如，count[i]=3表示i出现在3个查询的区间中，每个查询中可以选择选或不选i，总次数不超过3。
#### **误区2：borrow是前面查询剩余的次数，与当前查询无关**
- 正确。borrow是**所有查询中包含i的剩余次数**，无论这些查询在顺序上是前还是后。因为差分数组统计的是总和，贪心策略通过从左到右处理，隐式地将后面查询的次数分配给右侧元素。
#### **误区3：最后borrow可以不为0**
- 错误。如果borrow>0，说明存在未使用的流量，这些流量来自包含最后一个元素的查询，但后面没有元素可以使用它们，因此必须用完（即borrow=0）。
