leetcode 算法每日一题 #1

#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）。

差分数组

贪心策略