You are given an integer array nums and a list of range queries queries, where each query queries[i] = [l_i, r_i] represents an operation that can be applied at most once.

When you apply a query [l_i, r_i], you choose an integer decrement amount for each index j in the range l_i \leq j \leq r_i, and subtract that amount from nums[j]. Each chosen decrement must be non negative, and after all applied queries, every element of nums must be exactly $0$.

You may remove some queries and keep the rest. Return the maximum number of queries you can remove such that it is still possible to convert nums into a zero array using the remaining queries. If it is impossible to convert nums into a zero array even when using all queries, return $-1$.

Note: Each query provides at most $1$ unit of total decrement capacity per index in its range, and you may distribute that capacity independently across indices.

Constraints:

• $1 \leq$ nums.length $\leq 10^5$

• $0 \leq$ nums[i] $\leq 10^5$

• $1 \leq$ queries.length $\leq 10^5$

• queries[i].length $==$ $2$

• $0 \leq$ l_i $\leq$ r_i $<$ nums.length

Input: nums = [0,0,0]-List[int], queries = [[0,0],[0,2],[1,1],[2,2]]-List[List[int]]
Output: 4-int
Explanation: The array is already all zeros, so you don’t need to apply any query and can remove all 4 queries.

Input: nums = [2,1,0,3]-List[int], queries = [[0,1],[0,3],[1,3],[3,3]]-List[List[int]]
Output: 0-int
Explanation: Each query contributes at most 1 unit of decrement capacity per index it covers. To reach zero, index 0 needs 2 units, index 1 needs 1, and index 3 needs 3. Using all queries provides just enough per-index coverage, and removing any query would reduce capacity on at least one needed index, so you can remove 0 queries.

Input: nums = [1,0,2]-List[int], queries = [[0,0],[2,2]]-List[List[int]]
Output: -1-int
Explanation: Index 2 needs 2 units of decrement, but only one query covers index 2, so its maximum available capacity is 1. Even using all queries cannot make the array all zeros, so the answer is -1.

Input: nums = [3,2,1,0,2]-List[int], queries = [[0,4],[0,2],[1,3],[2,4],[0,0],[4,4]]-List[List[int]]
Output: 2-int
Explanation: A subset of queries can still provide enough per-index decrement capacity to cover the required values in nums. In an optimal choice, 4 queries suffice, so you can remove the remaining 6 - 4 = 2 queries.

Now, let’s take a moment to make sure you’ve correctly understood the problem. The quiz below helps you check if you’re solving the correct problem:

We have a game for you to play. Rearrange the logical building blocks to develop a clearer understanding of how to solve this problem.

Implement your solution in the following coding playground.