feat: update solutions to lc problems: No.2580,2581

* No.2580.Count Ways to Group Overlapping Ranges
* No.2581.Count Number of Possible Root Nodes

Author: yanglbme

solution/0700-0799/0716.Max Stack/Solution.py

@@ -37,7 +37,6 @@ def peek(self):
 
 
 class MaxStack:
-
     def __init__(self):
         self.stk = DoubleLinkedList()
         self.sl = SortedList(key=lambda x: x.val)
@@ -62,6 +61,7 @@ def popMax(self) -> int:
         DoubleLinkedList.remove(node)
         return node.val
 
+
 # Your MaxStack object will be instantiated and called as such:
 # obj = MaxStack()
 # obj.push(x)

solution/0900-0999/0980.Unique Paths III/Solution.py

@@ -13,8 +13,7 @@ def dfs(i, j, k):
             return ans
 
         m, n = len(grid), len(grid[0])
-        start = next((i, j) for i in range(m)
-                     for j in range(n) if grid[i][j] == 1)
+        start = next((i, j) for i in range(m) for j in range(n) if grid[i][j] == 1)
         dirs = (-1, 0, 1, 0, -1)
         cnt = sum(grid[i][j] == 0 for i in range(m) for j in range(n))
         vis = {start}

solution/0900-0999/0981.Time Based Key-Value Store/Solution.py

@@ -1,5 +1,4 @@
 class TimeMap:
-
     def __init__(self):
         self.ktv = defaultdict(list)
 

solution/1100-1199/1134.Armstrong Number/Solution.py

@@ -3,6 +3,6 @@ def isArmstrong(self, n: int) -> bool:
         k = len(str(n))
         s, x = 0, n
         while x:
-            s += (x % 10)**k
+            s += (x % 10) ** k
             x //= 10
         return s == n

solution/1500-1599/1518.Water Bottles/Solution.py

@@ -2,6 +2,6 @@ class Solution:
     def numWaterBottles(self, numBottles: int, numExchange: int) -> int:
         ans = numBottles
         while numBottles >= numExchange:
-            numBottles -= (numExchange - 1)
+            numBottles -= numExchange - 1
             ans += 1
         return ans

solution/1500-1599/1573.Number of Ways to Split a String/Solution.py

@@ -6,6 +6,7 @@ def find(x):
                 t += int(c == '1')
                 if t == x:
                     return i
+
         cnt, m = divmod(sum(c == '1' for c in s), 3)
         if m:
             return 0

solution/1800-1899/1845.Seat Reservation Manager/Solution.py

@@ -1,5 +1,4 @@
 class SeatManager:
-
     def __init__(self, n: int):
         self.q = list(range(1, n + 1))
         heapify(self.q)

solution/2500-2599/2578.Split With Minimum Sum/README.md

@@ -10,13 +10,11 @@
 
 <ul>
 	<li><code>num1</code> 和&nbsp;<code>num2</code>&nbsp;直接连起来，得到&nbsp;<code>num</code>&nbsp;各数位的一个排列。
-
     <ul>
     	<li>换句话说，<code>num1</code> 和&nbsp;<code>num2</code>&nbsp;中所有数字出现的次数之和等于&nbsp;<code>num</code>&nbsp;中所有数字出现的次数。</li>
     </ul>
     </li>
     <li><code>num1</code> 和&nbsp;<code>num2</code>&nbsp;可以包含前导 0 。</li>
-
 </ul>
 
 <p>请你返回&nbsp;<code>num1</code> 和 <code>num2</code>&nbsp;可以得到的和的 <strong>最小</strong> 值。</p>
@@ -66,6 +64,12 @@
 
 时间复杂度 $O(n)$，空间复杂度 $O(C)$。其中 $n$ 为 $num$ 的位数；而 $C$ 为 $num$ 中不同数字的个数，本题中 $C \leq 10$。
 
+**方法二：排序 + 贪心**
+
+我们可以将 $num$ 转换成字符串或者字符数组，然后对其进行排序，接下来将排序后的数组中的数字按照从小到大的顺序交替地分配给 $num1$ 和 $num2$，最后返回 $num1$ 和 $num2$ 的和即可。
+
+时间复杂度 $O(n \times \log n)$，空间复杂度 $O(n)$。其中 $n$ 为 $num$ 的位数。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -91,6 +95,13 @@ class Solution:
         return sum(ans)
 ```
 
+```python
+class Solution:
+    def splitNum(self, num: int) -> int:
+        s = sorted(str(num))
+        return int(''.join(s[::2])) + int(''.join(s[1::2]))
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -117,6 +128,20 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int splitNum(int num) {
+        char[] s = (num + "").toCharArray();
+        Arrays.sort(s);
+        int[] ans = new int[2];
+        for (int i = 0; i < s.length; ++i) {
+            ans[i & 1] = ans[i & 1] * 10 + s[i] - '0';
+        }
+        return ans[0] + ans[1];
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -142,6 +167,21 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int splitNum(int num) {
+        string s = to_string(num);
+        sort(s.begin(), s.end());
+        int ans[2]{};
+        for (int i = 0; i < s.size(); ++i) {
+            ans[i & 1] = ans[i & 1] * 10 + s[i] - '0';
+        }
+        return ans[0] + ans[1];
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -164,6 +204,18 @@ func splitNum(num int) int {
 }
 ```
 
+```go
+func splitNum(num int) int {
+	s := []byte(strconv.Itoa(num))
+	sort.Slice(s, func(i, j int) bool { return s[i] < s[j] })
+	ans := [2]int{}
+	for i, c := range s {
+		ans[i&1] = ans[i&1]*10 + int(c-'0')
+	}
+	return ans[0] + ans[1]
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2578.Split With Minimum Sum/README_EN.md

@@ -8,13 +8,11 @@
 
 <ul>
 	<li>The concatenation of <code>num1</code> and <code>num2</code> is a permutation of <code>num</code>.
-
     <ul>
     	<li>In other words, the sum of the number of occurrences of each digit in <code>num1</code> and <code>num2</code> is equal to the number of occurrences of that digit in <code>num</code>.</li>
     </ul>
     </li>
     <li><code>num1</code> and <code>num2</code> can contain leading zeros.</li>
-
 </ul>
 
 <p>Return <em>the <strong>minimum</strong> possible sum of</em> <code>num1</code> <em>and</em> <code>num2</code>.</p>
@@ -75,6 +73,13 @@ class Solution:
         return sum(ans)
 ```
 
+```python
+class Solution:
+    def splitNum(self, num: int) -> int:
+        s = sorted(str(num))
+        return int(''.join(s[::2])) + int(''.join(s[1::2]))
+```
+
 ### **Java**
 
 ```java
@@ -99,6 +104,20 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int splitNum(int num) {
+        char[] s = (num + "").toCharArray();
+        Arrays.sort(s);
+        int[] ans = new int[2];
+        for (int i = 0; i < s.length; ++i) {
+            ans[i & 1] = ans[i & 1] * 10 + s[i] - '0';
+        }
+        return ans[0] + ans[1];
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -124,6 +143,21 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int splitNum(int num) {
+        string s = to_string(num);
+        sort(s.begin(), s.end());
+        int ans[2]{};
+        for (int i = 0; i < s.size(); ++i) {
+            ans[i & 1] = ans[i & 1] * 10 + s[i] - '0';
+        }
+        return ans[0] + ans[1];
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -146,6 +180,18 @@ func splitNum(num int) int {
 }
 ```
 
+```go
+func splitNum(num int) int {
+	s := []byte(strconv.Itoa(num))
+	sort.Slice(s, func(i, j int) bool { return s[i] < s[j] })
+	ans := [2]int{}
+	for i, c := range s {
+		ans[i&1] = ans[i&1]*10 + int(c-'0')
+	}
+	return ans[0] + ans[1]
+}
+```
+
 ### **...**
 
 ```

solution/2500-2599/2580.Count Ways to Group Overlapping Ranges/README.md

@@ -72,6 +72,8 @@
 
 时间复杂度 $O(n \times \log n)$，空间复杂度 $O(\log n)$。其中 $n$ 为区间个数。
 
+我们也可以不使用快速幂，一旦发现有新的不相交的区间，就将方案数乘 $2$ 后对 $10^9 + 7$ 取模。
+
 <!-- tabs:start -->
 
 ### **Python3**
@@ -91,6 +93,20 @@ class Solution:
         return pow(2, cnt, mod)
 ```
 
+```python
+class Solution:
+    def countWays(self, ranges: List[List[int]]) -> int:
+        ranges.sort()
+        mx = -1
+        mod = 10**9 + 7
+        ans = 1
+        for start, end in ranges:
+            if start > mx:
+                ans = ans * 2 % mod
+            mx = max(mx, end)
+        return ans
+```
+
 ### **Java**
 
 <!-- 这里可写当前语言的特殊实现逻辑 -->
@@ -123,6 +139,24 @@ class Solution {
 }
 ```
 
+```java
+class Solution {
+    public int countWays(int[][] ranges) {
+        Arrays.sort(ranges, (a, b) -> a[0] - b[0]);
+        int mx = -1;
+        int ans = 1;
+        final int mod = (int) 1e9 + 7;
+        for (int[] e : ranges) {
+            if (e[0] > mx) {
+                ans = ans * 2 % mod;
+            }
+            mx = Math.max(mx, e[1]);
+        }
+        return ans;
+    }
+}
+```
+
 ### **C++**
 
 ```cpp
@@ -152,6 +186,24 @@ public:
 };
 ```
 
+```cpp
+class Solution {
+public:
+    int countWays(vector<vector<int>>& ranges) {
+        sort(ranges.begin(), ranges.end());
+        int ans = 1, mx = -1;
+        const int mod = 1e9 + 7;
+        for (auto& e : ranges) {
+            if (e[0] > mx) {
+                ans = ans * 2 % mod;
+            }
+            mx = max(mx, e[1]);
+        }
+        return ans;
+    }
+};
+```
+
 ### **Go**
 
 ```go
@@ -182,6 +234,23 @@ func qmi(a, k, p int) int {
 }
 ```
 
+```go
+func countWays(ranges [][]int) int {
+	sort.Slice(ranges, func(i, j int) bool { return ranges[i][0] < ranges[j][0] })
+	ans, mx := 1, -1
+	const mod = 1e9 + 7
+	for _, e := range ranges {
+		if e[0] > mx {
+			ans = ans * 2 % mod
+		}
+		if mx < e[1] {
+			mx = e[1]
+		}
+	}
+	return ans
+}
+```
+
 ### **...**
 
 ```