feat: add solutions to lc problems: No.1351+ (doocs#2156)

Author: yanglbme

solution/1300-1399/1351.Count Negative Numbers in a Sorted Matrix/README.md

@@ -52,15 +52,15 @@
 
 遍历结束，返回答案。
 
-时间复杂度 $O(m + n)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数。
+时间复杂度 $O(m + n)$，其中 $m$ 和 $n$ 分别为矩阵的行数和列数。空间复杂度 $O(1)$。
 
 **方法二：二分查找**
 
 遍历每一行，二分查找每一行第一个小于 $0$ 的位置，从该位置开始往右的所有元素均为负数，累加负数个数到答案中。
 
 遍历结束，返回答案。
 
-时间复杂度 $O(m \times \log n)$。其中 $m$ 和 $n$ 分别为矩阵的行数和列数。
+时间复杂度 $O(m \times \log n)$，其中 $m$ 和 $n$ 分别为矩阵的行数和列数。空间复杂度 $O(1)$。
 
 <!-- tabs:start -->
 

solution/1300-1399/1351.Count Negative Numbers in a Sorted Matrix/README_EN.md

@@ -37,6 +37,24 @@
 
 ## Solutions
 
+**Solution 1: Start Traversing from the Bottom Left or Top Right**
+
+According to the characteristic that **both rows and columns are arranged in non-increasing order**, we can start traversing from the **bottom left corner** towards the **top right direction**.
+
+When encountering a negative number, it indicates that all elements to the right of the current position in this row are negative. We add the number of remaining elements in this row to the answer, that is, $n - j$, and move up a row, that is, $i \leftarrow i - 1$. Otherwise, move to the right column, that is, $j \leftarrow j + 1$.
+
+After the traversal is over, return the answer.
+
+The time complexity is $O(m + n)$, where $m$ and $n$ are the number of rows and columns of the matrix, respectively. The space complexity is $O(1)$.
+
+**Solution 2: Binary Search**
+
+Traverse each row, use binary search to find the first position less than $0$ in each row. All elements to the right of this position are negative, and add the number of negative numbers to the answer.
+
+After the traversal is over, return the answer.
+
+The time complexity is $O(m \times \log n)$, where $m$ and $n$ are the number of rows and columns of the matrix, respectively. The space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1300-1399/1352.Product of the Last K Numbers/README_EN.md

@@ -53,6 +53,16 @@ productOfNumbers.getProduct(2); // return 32. The product of the last 2 numbers
 
 ## Solutions
 
+**Solution 1: Prefix Product**
+
+We initialize an array $s$, where $s[i]$ represents the product of the first $i$ numbers.
+
+When calling `add(num)`, we judge whether `num` is $0$. If it is, we set $s$ to `[1]`. Otherwise, we multiply the last element of $s$ by `num` and add the result to the end of $s$.
+
+When calling `getProduct(k)`, we now judge whether the length of $s$ is less than or equal to $k$. If it is, we return $0$. Otherwise, we return the last element of $s$ divided by the $k + 1$th element from the end of $s$. That is, $s[-1] / s[-k - 1]$.
+
+The time complexity is $O(1)$, and the space complexity is $O(n)$. Where $n$ is the number of times `add` is called.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README.md

@@ -57,7 +57,7 @@
 
 然后从优先队列中取出结束时间最小的会议，即为当前时间可以参加的会议，累加答案数。如果优先队列为空，则说明当前时间没有可以参加的会议。
 
-时间复杂度 $O(m\log n)$。其中 $m$, $n$ 分别表示会议的最大结束时间，以及会议的数量。
+时间复杂度 $O(m \times \log n)$，空间复杂度 $O(n)$。其中 $m$, $n$ 分别表示会议的最大结束时间，以及会议的数量。
 
 <!-- tabs:start -->
 

solution/1300-1399/1353.Maximum Number of Events That Can Be Attended/README_EN.md

@@ -41,6 +41,16 @@ Attend the third event on day 3.
 
 ## Solutions
 
+**Solution 1: Hash Table + Greedy + Priority Queue**
+
+Define a hash table to record the start and end times of each meeting, where the key is the start time of the meeting, and the value is a list of end times.
+
+Enumerate the current time $s$, find all meetings that start at the current time, and add their end times to the priority queue (min heap). At the same time, the priority queue needs to remove all meetings that end before the current time.
+
+Then, take out the meeting with the smallest end time from the priority queue, which is the meeting that can be attended at the current time, and accumulate the answer count. If the priority queue is empty, it means that there are no meetings that can be attended at the current time.
+
+The time complexity is $O(m \times \log n)$, and the space complexity is $O(n)$. Where $m$ and $n$ represent the maximum end time of the meetings and the number of meetings, respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/1300-1399/1354.Construct Target Array With Multiple Sums/README.md

@@ -56,6 +56,14 @@
 
 <!-- 这里可写通用的实现逻辑 -->
 
+**方法一：逆向构造 + 优先队列（大根堆）**
+
+我们发现，如果从数组 $arr$ 开始正向构造目标数组 $target$，每次都不好确定选择哪个下标 $i$，问题比较复杂。而如果我们从数组 $target$ 开始逆向构造，每次构造都一定是选择当前数组中最大的元素，这样就可以保证每次构造都是唯一的，问题比较简单。
+
+因此，我们可以使用优先队列（大根堆）来存储数组 $target$ 中的元素，用一个变量 $s$ 记录数组 $target$ 中所有元素的和。每次从优先队列中取出最大的元素 $mx$，计算当前数组中除 $mx$ 以外的所有元素之和 $t$，如果 $t \lt 1$ 或者 $mx - t \lt 1$，则说明无法构造目标数组 $target$，返回 `false`。否则，我们计算 $mx \bmod t$，如果 $mx \bmod t = 0$，则令 $x = t$，否则令 $x = mx \bmod t$，将 $x$ 加入优先队列中，并更新 $s$ 的值，重复上述操作，直到优先队列中的所有元素都变为 $1$，此时返回 `true`。
+
+时间复杂度 $O(n \log n)$，空间复杂度 $O(n)$。其中 $n$ 为数组 $target$ 的长度。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -65,36 +73,138 @@
 ```python
 class Solution:
     def isPossible(self, target: List[int]) -> bool:
-        if len(target) == 1:
-            return target[0] == 1
-
-        summ = sum(target)
-        maxHeap = [-num for num in target]
-        heapq.heapify(maxHeap)
-
-        while -maxHeap[0] > 1:
-            maxi = -heapq.heappop(maxHeap)
-            restSum = summ - maxi
-            # Only occurs if n == 2.
-            if restSum == 1:
-                return True
-            updated = maxi % restSum
-            # Updated == 0 (invalid) or didn't change.
-            if updated == 0 or updated == maxi:
+        s = sum(target)
+        pq = [-x for x in target]
+        heapify(pq)
+        while -pq[0] > 1:
+            mx = -heappop(pq)
+            t = s - mx
+            if t == 0 or mx - t < 1:
                 return False
-            heapq.heappush(maxHeap, -updated)
-            summ = summ - maxi + updated
-
+            x = (mx % t) or t
+            heappush(pq, -x)
+            s = s - mx + x
         return True
-
 ```
 
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
 
 ```java
+class Solution {
+    public boolean isPossible(int[] target) {
+        PriorityQueue<Long> pq = new PriorityQueue<>(Collections.reverseOrder());
+        long s = 0;
+        for (int x : target) {
+            s += x;
+            pq.offer((long) x);
+        }
+        while (pq.peek() > 1) {
+            long mx = pq.poll();
+            long t = s - mx;
+            if (t == 0 || mx - t < 1) {
+                return false;
+            }
+            long x = mx % t;
+            if (x == 0) {
+                x = t;
+            }
+            pq.offer(x);
+            s = s - mx + x;
+        }
+        return true;
+    }
+}
+```
+
+### **C++**
+
+```cpp
+class Solution {
+public:
+    bool isPossible(vector<int>& target) {
+        priority_queue<int> pq;
+        long long s = 0;
+        for (int i = 0; i < target.size(); i++) {
+            s += target[i];
+            pq.push(target[i]);
+        }
+        while (pq.top() != 1) {
+            int mx = pq.top();
+            pq.pop();
+            long long t = s - mx;
+            if (t < 1 || mx - t < 1) {
+                return false;
+            }
+            int x = mx % t;
+            if (x == 0) {
+                x = t;
+            }
+            pq.push(x);
+            s = s - mx + x;
+        }
+        return true;
+    }
+};
+```
+
+### **Go**
+
+```go
+func isPossible(target []int) bool {
+	pq := &hp{target}
+	s := 0
+	for _, x := range target {
+		s += x
+	}
+	heap.Init(pq)
+	for target[0] > 1 {
+		mx := target[0]
+		t := s - mx
+		if t < 1 || mx-t < 1 {
+			return false
+		}
+		x := mx % t
+		if x == 0 {
+			x = t
+		}
+		target[0] = x
+		heap.Fix(pq, 0)
+		s = s - mx + x
+	}
+	return true
+}
+
+type hp struct{ sort.IntSlice }
+
+func (h hp) Less(i, j int) bool { return h.IntSlice[i] > h.IntSlice[j] }
+func (hp) Pop() (_ any)         { return }
+func (hp) Push(any)             {}
+```
 
+### **TypeScript**
+
+```ts
+function isPossible(target: number[]): boolean {
+    const pq = new MaxPriorityQueue();
+    let s = 0;
+    for (const x of target) {
+        s += x;
+        pq.enqueue(x);
+    }
+    while (pq.front().element > 1) {
+        const mx = pq.dequeue().element;
+        const t = s - mx;
+        if (t < 1 || mx - t < 1) {
+            return false;
+        }
+        const x = mx % t || t;
+        pq.enqueue(x);
+        s = s - mx + x;
+    }
+    return true;
+}
 ```
 
 ### **...**