LeetCode 3362.零数组变换 III：贪心+优先队列+差分数组——清晰题解

【LetMeFly】3362.零数组变换 III：贪心+优先队列+差分数组——清晰题解

力扣题目链接：https://leetcode.cn/problems/zero-array-transformation-iii/

给你一个长度为 n 的整数数组 nums 和一个二维数组 queries ，其中 queries[i] = [li, ri] 。

每一个 queries[i] 表示对于 nums 的以下操作：

• 将 nums 中下标在范围 [li, ri] 之间的每一个元素 最多 减少 1 。
• 坐标范围内每一个元素减少的值相互 独立 。

零数组 指的是一个数组里所有元素都等于 0 。

请你返回 最多 可以从 queries 中删除多少个元素，使得 queries 中剩下的元素仍然能将 nums 变为一个 零数组 。如果无法将 nums 变为一个 零数组 ，返回 -1 。

示例 1：

输出：1

解释：

删除 queries[2] 后，nums 仍然可以变为零数组。

• 对于 queries[0] ，将 nums[0] 和 nums[2] 减少 1 ，将 nums[1] 减少 0 。
• 对于 queries[1] ，将 nums[0] 和 nums[2] 减少 1 ，将 nums[1] 减少 0 。

示例 2：

输出：2

解释：

可以删除 queries[2] 和 queries[3] 。

示例 3：

输出：-1

解释：

nums 无法通过 queries 变成零数组。

提示：

• 1 <= nums.length <= 105
• 0 <= nums[i] <= 105
• 1 <= queries.length <= 105
• queries[i].length == 2
• 0 <= li <= ri < nums.length

解题方法：贪心+优先队列+差分数组

解题思路

我们的目标是尽可能地把每个数都减小到0，可以按nums从左到右依次处理。

对于$nums[0]$，在$nums[0]>0$时，如何选择query？当然要选择区间起点为0的query中，区间终点最靠后的那个。

假设选择了一些query后$nums[0]$变成了$0$（此时$nums[1]$可能也已经减小了一些），开始处理$nums[1]$。道理相同，有限选择区间起点为1的query中区间终点最靠后的那个。

中间过程中，一旦发生“可选的query无法将$nums[i]$减小为0的情况”，就返回-1。

具体方法

如何选择所有可选query中终点最靠后的那个？

我们可以使用一个优先队列，将所有可选(或曾经可选)的query添加到优先队列中，优先队列以query的区间终点最大为最优先。

因此可以先将query按照起点从小到大的顺序排个序，遍历$nums[i]$的过程中，将query起点为$i$的query加入优先队列。

当$nums[i]$不为$0$时，需要从优先队列中取出query，如果队首query的区间终点已经小于$i$，说明这个query已经无效，没有可以覆盖$nums[i]$的query，不取。

若$nums$可以将所有元素减小为$0$，则最终(所有query都将入队)优先队列中剩余的query个数记为答案。

取出一个query后，如何将$nums[i]$到$query[1]$这段区间整个更新（-1）？

可以先做下3355.零数组变换 I，使用差分数组即可将一段区间快速同时减1。

时空复杂度分析

• 时间复杂度$O((m+n)\log n)$，其中$m=len(nums)$，$n=len(queries)$
• 空间复杂度$O(m+n)$

AC代码

C++

/*
 * @Author: LetMeFly
 * @Date: 2025-05-24 16:04:04
 * @LastEditors: LetMeFly.xyz
 * @LastEditTime: 2025-05-24 16:06:59
 */
class Solution {
public:
    int maxRemoval(vector<int>& nums, vector<vector<int>>& queries) {
        sort(queries.begin(), queries.end());
        vector<int> diff(nums.size() + 1);
        priority_queue<int> pq;
        for (int in = 0, iq = 0, cnt = 0; in < nums.size(); in++) {
            cnt += diff[in];
            while (iq < queries.size() && queries[iq][0] == in) {
                pq.push(queries[iq++][1]);
            }
            while (cnt < nums[in] && pq.size() && pq.top() >= in) {
                cnt++;
                diff[pq.top() + 1]--;
                pq.pop();
            }
            if (cnt < nums[in]) {
                return -1;
            }
        }
        return pq.size();
    }
};

To myself: 二写和一写几乎一模一样

Python

'''
Author: LetMeFly
Date: 2025-05-23 23:35:45
LastEditors: LetMeFly.xyz
LastEditTime: 2025-05-23 23:52:09
'''
from typing import List
import heapq

class Solution:
    def maxRemoval(self, nums: List[int], queries: List[List[int]]) -> int:
        queries.sort()
        diff = [0] * (len(nums) + 1)
        cnt = iq = 0
        pq = []
        for inum in range(len(nums)):
            cnt += diff[inum]
            while iq < len(queries) and queries[iq][0] <= inum:
                heapq.heappush(pq, -queries[iq][1])
                iq += 1
            while cnt < nums[inum] and len(pq) and -pq[0] >= inum:
                cnt += 1
                diff[-heapq.heappop(pq) + 1] -= 1
            if cnt < nums[inum]:
                return -1
        return len(pq)

Java

/*
 * @Author: LetMeFly
 * @Date: 2025-05-23 23:35:45
 * @LastEditors: LetMeFly.xyz
 * @LastEditTime: 2025-05-23 23:57:57
 */
import java.util.Arrays;
import java.util.PriorityQueue;

class Solution {
    public int maxRemoval(int[] nums, int[][] queries) {
        Arrays.sort(queries, (a, b) -> a[0] - b[0]);
        int[] diff = new int[nums.length + 1];
        PriorityQueue<Integer> pq = new PriorityQueue<>((a, b) -> b - a);
        for (int in = 0, iq = 0, cnt = 0; in < nums.length; in++) {
            cnt += diff[in];
            while (iq < queries.length && queries[iq][0] <= in) {
                pq.add(queries[iq++][1]);
            }
            while (cnt < nums[in] && !pq.isEmpty() && pq.peek() >= in) {
                cnt++;
                diff[pq.poll() + 1]--;
            }
            if (cnt < nums[in]) {
                return -1;
            }
        }
        return pq.size();
    }
}

Go

/*
 * @Author: LetMeFly
 * @Date: 2025-05-23 23:35:45
 * @LastEditors: LetMeFly.xyz
 * @LastEditTime: 2025-05-24 00:22:47
 */
package main

import (
    "slices"
    "container/heap"
)

func maxRemoval(nums []int, queries [][]int) int {
    slices.SortFunc(queries, func(a, b []int) int {
        return a[0] - b[0]
    })
    diff := make([]int, len(nums) + 1)
    pq := &pq3362{}
    for in, iq, cnt := 0, 0, 0; in < len(nums); in++ {
        cnt += diff[in]
        for iq < len(queries) && queries[iq][0] <= in {
            heap.Push(pq, queries[iq][1])
            iq++
        }
        for cnt < nums[in] && len(*pq) > 0 && (*pq)[0] >= in {
            cnt++
            diff[heap.Pop(pq).(int) + 1]--
        }
        if cnt < nums[in] {
            return -1
        }
    }
    return len(*pq)
}

type pq3362 []int
func (pq *pq3362) Push(a any)         {(*pq) = append((*pq), a.(int))}
func (pq pq3362)  Len() int           {return len(pq)}
func (pq pq3362)  Less(i, j int) bool {return pq[i] > pq[j]}
func (pq pq3362)  Swap(i, j int)      {pq[i], pq[j] = pq[j], pq[i]}
func (pq *pq3362) Pop() any           {a := (*pq)[len(*pq)-1]; (*pq) = (*pq)[:len(*pq)-1]; return a}

同步发文于CSDN和我的个人博客，原创不易，转载经作者同意后请附上原文链接哦~

千篇源码题解已开源