feat: add solutions to lc problem: No.1801

No.1801.Number of Orders in the Backlog

Author: yanglbme

solution/0000-0099/0092.Reverse Linked List II/Solution.py

@@ -4,7 +4,9 @@
 #         self.val = val
 #         self.next = next
 class Solution:
-    def reverseBetween(self, head: Optional[ListNode], left: int, right: int) -> Optional[ListNode]:
+    def reverseBetween(
+        self, head: Optional[ListNode], left: int, right: int
+    ) -> Optional[ListNode]:
         if head.next is None or left == right:
             return head
         dummy = ListNode(0, head)

solution/0000-0099/0099.Recover Binary Search Tree/Solution.py

@@ -9,6 +9,7 @@ def recoverTree(self, root: Optional[TreeNode]) -> None:
         """
         Do not return anything, modify root in-place instead.
         """
+
         def dfs(root):
             if root is None:
                 return

solution/1200-1299/1297.Maximum Number of Occurrences of a Substring/Solution.py

@@ -3,7 +3,7 @@ def maxFreq(self, s: str, maxLetters: int, minSize: int, maxSize: int) -> int:
         ans = 0
         cnt = Counter()
         for i in range(len(s) - minSize + 1):
-            t = s[i: i + minSize]
+            t = s[i : i + minSize]
             ss = set(t)
             if len(ss) <= maxLetters:
                 cnt[t] += 1

solution/1800-1899/1801.Number of Orders in the Backlog/README.md

@@ -68,13 +68,15 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
-**方法一：优先队列 + 模拟**
+**方法一：优先队列（大小根堆） + 模拟**
 
-我们可以使用优先队列（大小根堆）维护当前的积压订单，优先队列中的元素为 `[price, amount]` ，表示价格为 `price` 的订单数量为 `amount` ，其中大根堆 `buy` 维护积压的采购订单，小根堆 `sell` 维护积压的销售订单。
+我们可以使用优先队列（大小根堆）维护当前的积压订单，其中大根堆 `buy` 维护积压的采购订单，小根堆 `sell` 维护积压的销售订单。堆中每个元素是一个二元组 $(price, amount)$，表示价格为 `price` 的订单数量为 `amount`。
 
-遍历订单数组 `orders` ，根据题意模拟即可。
+接下来，我们遍历订单数组 `orders` ，根据题意模拟即可。
 
-时间复杂度 $O(n\log n)$。
+遍历结束后，我们将 `buy` 和 `sell` 中的订单数量相加，即为最终的积压订单数量。注意答案可能很大，需要对 $10^9 + 7$ 取模。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 是 `orders` 的长度。
 
 <!-- tabs:start -->
 
@@ -107,12 +109,8 @@ class Solution:
                         a = 0
                 if a:
                     heappush(sell, (p, a))
-        ans, mod = 0, 10**9 + 7
-        for _, v in buy:
-            ans = (ans + v) % mod
-        for _, v in sell:
-            ans = (ans + v) % mod
-        return ans
+        mod = 10**9 + 7
+        return sum(v[1] for v in buy + sell) % mod
 ```
 
 ### **Java**
@@ -175,13 +173,12 @@ class Solution {
 ### **C++**
 
 ```cpp
-using pii = pair<int, int>;
-
 class Solution {
 public:
     const int mod = 1e9 + 7;
 
     int getNumberOfBacklogOrders(vector<vector<int>>& orders) {
+        using pii = pair<int, int>;
         priority_queue<pii, vector<pii>, greater<pii>> sell;
         priority_queue<pii> buy;
         for (auto& e : orders) {
@@ -235,7 +232,7 @@ public:
 ### **Go**
 
 ```go
-func getNumberOfBacklogOrders(orders [][]int) int {
+func getNumberOfBacklogOrders(orders [][]int) (ans int) {
 	sell := hp{}
 	buy := hp{}
 	for _, e := range orders {
@@ -270,17 +267,14 @@ func getNumberOfBacklogOrders(orders [][]int) int {
 			}
 		}
 	}
-	mod := int(1e9) + 7
-	ans := 0
+	const mod int = 1e9 + 7
 	for len(buy) > 0 {
 		ans += heap.Pop(&buy).(pair).a
-		ans %= mod
 	}
 	for len(sell) > 0 {
 		ans += heap.Pop(&sell).(pair).a
-		ans %= mod
 	}
-	return ans
+	return ans % mod
 }
 
 type pair struct{ p, a int }

solution/1800-1899/1801.Number of Orders in the Backlog/README_EN.md

@@ -7,23 +7,17 @@
 <p>You are given a 2D integer array <code>orders</code>, where each <code>orders[i] = [price<sub>i</sub>, amount<sub>i</sub>, orderType<sub>i</sub>]</code> denotes that <code>amount<sub>i</sub></code><sub> </sub>orders have been placed of type <code>orderType<sub>i</sub></code> at the price <code>price<sub>i</sub></code>. The <code>orderType<sub>i</sub></code> is:</p>
 
 <ul>
-
     <li><code>0</code> if it is a batch of <code>buy</code> orders, or</li>
-
     <li><code>1</code> if it is a batch of <code>sell</code> orders.</li>
-
 </ul>
 
 <p>Note that <code>orders[i]</code> represents a batch of <code>amount<sub>i</sub></code> independent orders with the same price and order type. All orders represented by <code>orders[i]</code> will be placed before all orders represented by <code>orders[i+1]</code> for all valid <code>i</code>.</p>
 
 <p>There is a <strong>backlog</strong> that consists of orders that have not been executed. The backlog is initially empty. When an order is placed, the following happens:</p>
 
 <ul>
-
     <li>If the order is a <code>buy</code> order, you look at the <code>sell</code> order with the <strong>smallest</strong> price in the backlog. If that <code>sell</code> order&#39;s price is <strong>smaller than or equal to</strong> the current <code>buy</code> order&#39;s price, they will match and be executed, and that <code>sell</code> order will be removed from the backlog. Else, the <code>buy</code> order is added to the backlog.</li>
-
     <li>Vice versa, if the order is a <code>sell</code> order, you look at the <code>buy</code> order with the <strong>largest</strong> price in the backlog. If that <code>buy</code> order&#39;s price is <strong>larger than or equal to</strong> the current <code>sell</code> order&#39;s price, they will match and be executed, and that <code>buy</code> order will be removed from the backlog. Else, the <code>sell</code> order is added to the backlog.</li>
-
 </ul>
 
 <p>Return <em>the total <strong>amount</strong> of orders in the backlog after placing all the orders from the input</em>. Since this number can be large, return it <strong>modulo</strong> <code>10<sup>9</sup> + 7</code>.</p>
@@ -83,15 +77,10 @@ Finally, the backlog has (1000000000-3) sell orders with price 7, and (999999995
 <p><strong>Constraints:</strong></p>
 
 <ul>
-
     <li><code>1 &lt;= orders.length &lt;= 10<sup>5</sup></code></li>
-
     <li><code>orders[i].length == 3</code></li>
-
     <li><code>1 &lt;= price<sub>i</sub>, amount<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
-
     <li><code>orderType<sub>i</sub></code> is either <code>0</code> or <code>1</code>.</li>
-
 </ul>
 
 ## Solutions
@@ -191,13 +180,12 @@ class Solution {
 ### **C++**
 
 ```cpp
-using pii = pair<int, int>;
-
 class Solution {
 public:
     const int mod = 1e9 + 7;
 
     int getNumberOfBacklogOrders(vector<vector<int>>& orders) {
+        using pii = pair<int, int>;
         priority_queue<pii, vector<pii>, greater<pii>> sell;
         priority_queue<pii> buy;
         for (auto& e : orders) {
@@ -251,7 +239,7 @@ public:
 ### **Go**
 
 ```go
-func getNumberOfBacklogOrders(orders [][]int) int {
+func getNumberOfBacklogOrders(orders [][]int) (ans int) {
 	sell := hp{}
 	buy := hp{}
 	for _, e := range orders {
@@ -286,17 +274,14 @@ func getNumberOfBacklogOrders(orders [][]int) int {
 			}
 		}
 	}
-	mod := int(1e9) + 7
-	ans := 0
+	const mod int = 1e9 + 7
 	for len(buy) > 0 {
 		ans += heap.Pop(&buy).(pair).a
-		ans %= mod
 	}
 	for len(sell) > 0 {
 		ans += heap.Pop(&sell).(pair).a
-		ans %= mod
 	}
-	return ans
+	return ans % mod
 }
 
 type pair struct{ p, a int }

solution/1800-1899/1801.Number of Orders in the Backlog/Solution.cpp

@@ -1,10 +1,9 @@
-using pii = pair<int, int>;
-
 class Solution {
 public:
     const int mod = 1e9 + 7;
 
     int getNumberOfBacklogOrders(vector<vector<int>>& orders) {
+        using pii = pair<int, int>;
         priority_queue<pii, vector<pii>, greater<pii>> sell;
         priority_queue<pii> buy;
         for (auto& e : orders) {

solution/1800-1899/1801.Number of Orders in the Backlog/Solution.go

@@ -1,4 +1,4 @@
-func getNumberOfBacklogOrders(orders [][]int) int {
+func getNumberOfBacklogOrders(orders [][]int) (ans int) {
 	sell := hp{}
 	buy := hp{}
 	for _, e := range orders {
@@ -33,17 +33,14 @@ func getNumberOfBacklogOrders(orders [][]int) int {
 			}
 		}
 	}
-	mod := int(1e9) + 7
-	ans := 0
+	const mod int = 1e9 + 7
 	for len(buy) > 0 {
 		ans += heap.Pop(&buy).(pair).a
-		ans %= mod
 	}
 	for len(sell) > 0 {
 		ans += heap.Pop(&sell).(pair).a
-		ans %= mod
 	}
-	return ans
+	return ans % mod
 }
 
 type pair struct{ p, a int }

solution/1800-1899/1801.Number of Orders in the Backlog/Solution.py

@@ -22,9 +22,5 @@ def getNumberOfBacklogOrders(self, orders: List[List[int]]) -> int:
                         a = 0
                 if a:
                     heappush(sell, (p, a))
-        ans, mod = 0, 10**9 + 7
-        for _, v in buy:
-            ans = (ans + v) % mod
-        for _, v in sell:
-            ans = (ans + v) % mod
-        return ans
+        mod = 10**9 + 7
+        return sum(v[1] for v in buy + sell) % mod