Date: Sat, 4 Jan 2025 01:59:28 +0800
Subject: [PATCH 05/62] =?UTF-8?q?0018=E5=9B=9B=E6=95=B0=E4=B9=8B=E5=92=8C?=
=?UTF-8?q?=20=E4=BF=AE=E6=94=B9=E6=80=9D=E8=B7=AF=E7=AC=AC=E4=BA=8C?=
=?UTF-8?q?=E6=AE=B5=E6=9C=AB=E5=B0=BE=E6=8F=8F=E8=BF=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0018.\345\233\233\346\225\260\344\271\213\345\222\214.md" | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git "a/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md" "b/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
index 64923e41fc..fb8557fab9 100644
--- "a/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
+++ "b/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
@@ -35,7 +35,7 @@
四数之和，和[15.三数之和](https://programmercarl.com/0015.三数之和.html)是一个思路，都是使用双指针法, 基本解法就是在[15.三数之和](https://programmercarl.com/0015.三数之和.html) 的基础上再套一层for循环。
-但是有一些细节需要注意，例如： 不要判断`nums[k] > target` 就返回了，三数之和 可以通过 `nums[i] > 0` 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是`[-4, -3, -2, -1]`，`target`是`-10`，不能因为`-4 > -10`而跳过。但是我们依旧可以去做剪枝，逻辑变成`nums[i] > target && (nums[i] >=0 || target >= 0)`就可以了。
+但是有一些细节需要注意，例如： 不要判断`nums[k] > target` 就返回了，三数之和 可以通过 `nums[i] > 0` 就返回了，因为 0 已经是确定的数了，四数之和这道题目 target是任意值。比如：数组是`[-4, -3, -2, -1]`，`target`是`-10`，不能因为`-4 > -10`而跳过。但是我们依旧可以去做剪枝，逻辑变成`nums[k] > target && (nums[k] >=0 || target >= 0)`就可以了。
[15.三数之和](https://programmercarl.com/0015.三数之和.html)的双指针解法是一层for循环num[i]为确定值，然后循环内有left和right下标作为双指针，找到nums[i] + nums[left] + nums[right] == 0。
@@ -802,3 +802,4 @@ end
+
From 69bee02cf12f11cf33fbc1f86b6ae2132dde1afb Mon Sep 17 00:00:00 2001
From: aPurpleBerry <2454196228@qq.com>
Date: Sun, 5 Jan 2025 15:57:57 +0800
Subject: [PATCH 06/62] =?UTF-8?q?=E6=B7=BB=E5=8A=A0=20=E8=83=8C=E5=8C=85?=
=?UTF-8?q?=E9=97=AE=E9=A2=98=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=80=E5=AE=8C?=
=?UTF-8?q?=E5=85=A8=E8=83=8C=E5=8C=85.md=20JavaScript=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...14\345\205\250\350\203\214\345\214\205.md" | 44 +++++++++++++++++++
1 file changed, 44 insertions(+)
diff --git "a/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md" "b/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md"
index 0cc6e91592..ea658f7e51 100644
--- "a/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md"
+++ "b/problems/\350\203\214\345\214\205\351\227\256\351\242\230\347\220\206\350\256\272\345\237\272\347\241\200\345\256\214\345\205\250\350\203\214\345\214\205.md"
@@ -316,7 +316,51 @@ print(knapsack(n, bag_weight, weight, value))
### JavaScript
+```js
+const readline = require('readline').createInterface({
+ input: process.stdin,
+ output: process.stdout
+});
+
+let input = [];
+readline.on('line', (line) => {
+ input.push(line.trim());
+});
+
+readline.on('close', () => {
+ // 第一行解析 n 和 v
+ const [n, bagweight] = input[0].split(' ').map(Number);
+
+ /// 剩余 n 行解析重量和价值
+ const weight = [];
+ const value = [];
+ for (let i = 1; i <= n; i++) {
+ const [wi, vi] = input[i].split(' ').map(Number);
+ weight.push(wi);
+ value.push(vi);
+ }
+
+
+ let dp = Array.from({ length: n }, () => Array(bagweight + 1).fill(0));
+
+ for (let j = weight[0]; j <= bagweight; j++) {
+ dp[0][j] = dp[0][j-weight[0]] + value[0];
+ }
+
+ for (let i = 1; i < n; i++) {
+ for (let j = 0; j <= bagweight; j++) {
+ if (j < weight[i]) {
+ dp[i][j] = dp[i - 1][j];
+ } else {
+ dp[i][j] = Math.max(dp[i - 1][j], dp[i][j - weight[i]] + value[i]);
+ }
+ }
+ }
+ console.log(dp[n - 1][bagweight]);
+});
+
+```
From ba5e1b443f8c5b80ccf5f7a34d3ee2b89cd34d47 Mon Sep 17 00:00:00 2001
From: 1ltwo
Date: Tue, 7 Jan 2025 22:30:25 +0800
Subject: [PATCH 07/62] =?UTF-8?q?go=E7=89=88=E6=9C=AC=E8=A7=A3=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...55\344\271\260\345\234\237\345\234\260.md" | 86 +++++++++++++++++++
1 file changed, 86 insertions(+)
diff --git "a/problems/kamacoder/0044.\345\274\200\345\217\221\345\225\206\350\264\255\344\271\260\345\234\237\345\234\260.md" "b/problems/kamacoder/0044.\345\274\200\345\217\221\345\225\206\350\264\255\344\271\260\345\234\237\345\234\260.md"
index 739e2cadcb..6ef46f2109 100644
--- "a/problems/kamacoder/0044.\345\274\200\345\217\221\345\225\206\350\264\255\344\271\260\345\234\237\345\234\260.md"
+++ "b/problems/kamacoder/0044.\345\274\200\345\217\221\345\225\206\350\264\255\344\271\260\345\234\237\345\234\260.md"
@@ -526,3 +526,89 @@ int main()
}
```
+
+### Go
+
+前缀和
+
+```go
+package main
+
+import (
+ "fmt"
+ "os"
+ "bufio"
+ "strings"
+ "strconv"
+ "math"
+)
+
+func main() {
+ var n, m int
+
+ reader := bufio.NewReader(os.Stdin)
+
+ line, _ := reader.ReadString('\n')
+ line = strings.TrimSpace(line)
+ params := strings.Split(line, " ")
+
+ n, _ = strconv.Atoi(params[0])
+ m, _ = strconv.Atoi(params[1])//n和m读取完成
+
+ land := make([][]int, n)//土地矩阵初始化
+
+ for i := 0; i < n; i++ {
+ line, _ := reader.ReadString('\n')
+ line = strings.TrimSpace(line)
+ values := strings.Split(line, " ")
+ land[i] = make([]int, m)
+ for j := 0; j < m; j++ {
+ value, _ := strconv.Atoi(values[j])
+ land[i][j] = value
+ }
+ }//所有读取完成
+
+ //初始化前缀和矩阵
+ preMatrix := make([][]int, n+1)
+ for i := 0; i <= n; i++ {
+ preMatrix[i] = make([]int, m+1)
+ }
+
+ for a := 1; a < n+1; a++ {
+ for b := 1; b < m+1; b++ {
+ preMatrix[a][b] = land[a-1][b-1] + preMatrix[a-1][b] + preMatrix[a][b-1] - preMatrix[a-1][b-1]
+ }
+ }
+
+ totalSum := preMatrix[n][m]
+
+ minDiff := math.MaxInt32//初始化极大数，用于比较
+
+ //按行分割
+ for i := 1; i < n; i++ {
+ topSum := preMatrix[i][m]
+
+ bottomSum := totalSum - topSum
+
+ diff := int(math.Abs(float64(topSum - bottomSum)))
+ if diff < minDiff {
+ minDiff = diff
+ }
+ }
+
+ //按列分割
+ for j := 1; j < m; j++ {
+ topSum := preMatrix[n][j]
+
+ bottomSum := totalSum - topSum
+
+ diff := int(math.Abs(float64(topSum - bottomSum)))
+ if diff < minDiff {
+ minDiff = diff
+ }
+ }
+
+ fmt.Println(minDiff)
+}
+```
+
From d5e0827abeabbcc97b341e99231966bfbafaf7cd Mon Sep 17 00:00:00 2001
From: Jian
Date: Wed, 8 Jan 2025 01:04:07 +0800
Subject: [PATCH 08/62] =?UTF-8?q?0020=E6=9C=89=E6=95=88=E7=9A=84=E6=8B=AC?=
=?UTF-8?q?=E5=8F=B7=20Java=E6=9B=B4=E7=AE=80=E5=8D=95=E6=98=93=E6=87=82?=
=?UTF-8?q?=E7=9A=84=E6=96=B0=E8=A7=A3=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...10\347\232\204\346\213\254\345\217\267.md" | 23 +++++++++++++++++++
1 file changed, 23 insertions(+)
diff --git "a/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md" "b/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
index f2f5cdd13f..493e2871ae 100644
--- "a/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
+++ "b/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
@@ -172,6 +172,29 @@ class Solution {
}
```
+```java
+// 解法二
+// 对应的另一半一定在栈顶
+class Solution {
+ public boolean isValid(String s) {
+ Stack stack = new Stack<>();
+ for(char c : s.toCharArray()){
+ // 有对应的另一半就直接消消乐
+ if(c == ')' && !stack.isEmpty() && stack.peek() == '(')
+ stack.pop();
+ else if(c == '}' && !stack.isEmpty() && stack.peek() == '{')
+ stack.pop();
+ else if(c == ']' && !stack.isEmpty() && stack.peek() == '[')
+ stack.pop();
+ else
+ stack.push(c);// 没有匹配的就放进去
+ }
+
+ return stack.isEmpty();
+ }
+}
+```
+
### Python：
```python
From 61c04cdc433050e09f8f67aeb1fc45454a7f1e99 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Mon, 13 Jan 2025 15:47:55 +0800
Subject: [PATCH 09/62] =?UTF-8?q?=E4=BF=AE=E6=94=B90383.=E8=B5=8E=E9=87=91?=
=?UTF-8?q?=E4=BF=A1.md=E7=9A=84=E6=97=B6=E9=97=B4=E5=A4=8D=E6=9D=82?=
=?UTF-8?q?=E5=BA=A6=E5=88=86=E6=9E=90?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
"problems/0383.\350\265\216\351\207\221\344\277\241.md" | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git "a/problems/0383.\350\265\216\351\207\221\344\277\241.md" "b/problems/0383.\350\265\216\351\207\221\344\277\241.md"
index eb83d3ece9..1d7391732f 100644
--- "a/problems/0383.\350\265\216\351\207\221\344\277\241.md"
+++ "b/problems/0383.\350\265\216\351\207\221\344\277\241.md"
@@ -104,7 +104,7 @@ public:
};
```
-* 时间复杂度: O(n)
+* 时间复杂度: O(m+n)，其中m表示ransomNote的长度，n表示magazine的长度
* 空间复杂度: O(1)
@@ -470,3 +470,4 @@ bool canConstruct(char* ransomNote, char* magazine) {
+
From 13cb15cad6d548a99b4f4b427a3d57f91d5ce3b1 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Mon, 13 Jan 2025 16:33:28 +0800
Subject: [PATCH 10/62] =?UTF-8?q?=E6=B7=BB=E5=8A=A00018.=E5=9B=9B=E6=95=B0?=
=?UTF-8?q?=E4=B9=8B=E5=92=8C.md=E7=9A=84Java=E7=89=88=E6=9C=AC=E7=9A=84?=
=?UTF-8?q?=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...0018.\345\233\233\346\225\260\344\271\213\345\222\214.md" | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git "a/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md" "b/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
index 64923e41fc..acf8263c09 100644
--- "a/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
+++ "b/problems/0018.\345\233\233\346\225\260\344\271\213\345\222\214.md"
@@ -253,7 +253,7 @@ public class Solution {
for (int k = 0; k < nums.length; k++) {
// 剪枝处理
if (nums[k] > target && nums[k] >= 0) {
- break;
+ break; // 此处的break可以等价于return result;
}
// 对nums[k]去重
if (k > 0 && nums[k] == nums[k - 1]) {
@@ -262,7 +262,7 @@ public class Solution {
for (int i = k + 1; i < nums.length; i++) {
// 第二级剪枝
if (nums[k] + nums[i] > target && nums[k] + nums[i] >= 0) {
- break;
+ break; // 注意是break到上一级for循环，如果直接return result;会有遗漏
}
// 对nums[i]去重
if (i > k + 1 && nums[i] == nums[i - 1]) {
@@ -802,3 +802,4 @@ end
+
From 275efa0c70ecdb36c2c77eb2e26059b7b8b29d03 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Wed, 15 Jan 2025 15:52:42 +0800
Subject: [PATCH 11/62] =?UTF-8?q?=E6=B7=BB=E5=8A=A00459.=E9=87=8D=E5=A4=8D?=
=?UTF-8?q?=E7=9A=84=E5=AD=90=E5=AD=97=E7=AC=A6=E4=B8=B2.md=E7=9A=84Java?=
=?UTF-8?q?=E7=89=88=E6=9C=AC=E4=BA=8C=E5=89=8D=E7=BC=80=E8=A1=A8=E4=B8=8D?=
=?UTF-8?q?=E5=87=8F=E4=B8=80?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...20\345\255\227\347\254\246\344\270\262.md" | 42 ++++++++++++++++++-
1 file changed, 41 insertions(+), 1 deletion(-)
diff --git "a/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md" "b/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md"
index de0e6e4def..bdced0ef60 100644
--- "a/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md"
+++ "b/problems/0459.\351\207\215\345\244\215\347\232\204\345\255\220\345\255\227\347\254\246\344\270\262.md"
@@ -390,6 +390,8 @@ public:
### Java：
+（版本一） 前缀表 减一
+
```java
class Solution {
public boolean repeatedSubstringPattern(String s) {
@@ -420,6 +422,45 @@ class Solution {
}
```
+（版本二） 前缀表 不减一
+
+```java
+/*
+ * 充分条件：如果字符串s是由重复子串组成的，那么它的最长相等前后缀不包含的子串一定是s的最小重复子串。
+ * 必要条件：如果字符串s的最长相等前后缀不包含的子串是s的最小重复子串，那么s必然是由重复子串组成的。
+ * 推得：当字符串s的长度可以被其最长相等前后缀不包含的子串的长度整除时，不包含的子串就是s的最小重复子串。
+ *
+ * 时间复杂度：O(n)
+ * 空间复杂度：O(n)
+ */
+class Solution {
+ public boolean repeatedSubstringPattern(String s) {
+ // if (s.equals("")) return false;
+ // 边界判断（可以去掉，因为题目给定范围是1 <= s.length <= 10^4）
+ int n = s.length();
+
+ // Step 1.构建KMP算法的前缀表
+ int[] next = new int[n]; // 前缀表的值表示 以该位置结尾的字符串的最长相等前后缀的长度
+ int j = 0;
+ next[0] = 0;
+ for (int i = 1; i < n; i++) {
+ while (j > 0 && s.charAt(i) != s.charAt(j)) // 只要前缀后缀还不一致，就根据前缀表回退j直到起点为止
+ j = next[j - 1];
+ if (s.charAt(i) == s.charAt(j))
+ j++;
+ next[i] = j;
+ }
+
+ // Step 2.判断重复子字符串
+ if (next[n - 1] > 0 && n % (n - next[n - 1]) == 0) { // 当字符串s的长度可以被其最长相等前后缀不包含的子串的长度整除时
+ return true; // 不包含的子串就是s的最小重复子串
+ } else {
+ return false;
+ }
+ }
+}
+```
+
### Python：
（版本一） 前缀表 减一
@@ -930,4 +971,3 @@ bool repeatedSubstringPattern(char* s) {
-
From 1d0333f59634bc68b9c4f253f95a2ef8f7a5009e Mon Sep 17 00:00:00 2001
From: Anqi Li <103280095+iqna126@users.noreply.github.com>
Date: Wed, 15 Jan 2025 17:16:40 -0800
Subject: [PATCH 12/62] =?UTF-8?q?=E7=BB=990054.=E6=9B=BF=E6=8D=A2=E6=95=B0?=
=?UTF-8?q?=E5=AD=97.md=20=E5=8A=A0=E5=85=A5python=E8=A7=A3=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...77\346\215\242\346\225\260\345\255\227.md" | 40 +++++++++++++++++++
1 file changed, 40 insertions(+)
diff --git "a/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md" "b/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
index de0ab1a37a..e4b5c43fef 100644
--- "a/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
+++ "b/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
@@ -215,6 +215,46 @@ public class Main {
}
```
+### Python：
+```python
+class Solution(object):
+ def subsitute_numbers(self, s):
+ """
+ :type s: str
+ :rtype: str
+ """
+
+ count = sum(1 for char in s if char.isdigit()) # 统计数字的个数
+ expand_len = len(s) + (count * 5) # 计算扩充后字符串的大小， x->number， 每有一个数字就要增加五个长度
+ res = [''] * expand_len
+
+ new_index = expand_len - 1 # 指向扩充后字符串末尾
+ old_index = len(s) - 1 # 指向原字符串末尾
+
+ while old_index >= 0: # 从后往前， 遇到数字替换成“number”
+ if s[old_index].isdigit():
+ res[new_index-5:new_index+1] = "number"
+ new_index -= 6
+ else:
+ res[new_index] = s[old_index]
+ new_index -= 1
+ old_index -= 1
+
+ return "".join(res)
+
+if __name__ == "__main__":
+ solution = Solution()
+
+ while True:
+ try:
+ s = input()
+ result = solution.subsitute_numbers(s)
+ print(result)
+ except EOFError:
+ break
+
+```
+
### Go：
````go
package main
From 20385f114619bd5a1c90f0f10ebd4ed7a76b9b6a Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Fri, 17 Jan 2025 10:29:24 +0800
Subject: [PATCH 13/62] =?UTF-8?q?=E4=BF=AE=E6=94=B90020.=E6=9C=89=E6=95=88?=
=?UTF-8?q?=E7=9A=84=E6=8B=AC=E5=8F=B7.md=E7=9A=84Java=E7=89=88=E6=9C=AC?=
=?UTF-8?q?=E4=B8=80=E5=A4=84=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...234\211\346\225\210\347\232\204\346\213\254\345\217\267.md" | 3 ++-
1 file changed, 2 insertions(+), 1 deletion(-)
diff --git "a/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md" "b/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
index f2f5cdd13f..9d9168e31e 100644
--- "a/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
+++ "b/problems/0020.\346\234\211\346\225\210\347\232\204\346\213\254\345\217\267.md"
@@ -166,7 +166,7 @@ class Solution {
deque.pop();
}
}
- //最后判断栈中元素是否匹配
+ //遍历结束，如果栈为空，则括号全部匹配
return deque.isEmpty();
}
}
@@ -555,3 +555,4 @@ impl Solution {
+
From a66142cbc57e9f3fbe3d5b72689d5cab38fbc690 Mon Sep 17 00:00:00 2001
From: Jian
Date: Fri, 17 Jan 2025 19:37:21 +0800
Subject: [PATCH 14/62] =?UTF-8?q?=E4=BF=AE=E6=94=B9239=E6=BB=91=E5=8A=A8?=
=?UTF-8?q?=E7=AA=97=E5=8F=A3=E6=9C=80=E5=A4=A7=E5=80=BCjava=E4=BB=A3?=
=?UTF-8?q?=E7=A0=81=E6=B3=A8=E9=87=8A=E4=B8=A5=E9=87=8D=E9=94=99=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...2\227\345\217\243\346\234\200\345\244\247\345\200\274.md" | 5 +++--
1 file changed, 3 insertions(+), 2 deletions(-)
diff --git "a/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md" "b/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md"
index caa24d8de3..63ee3daedc 100644
--- "a/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md"
+++ "b/problems/0239.\346\273\221\345\212\250\347\252\227\345\217\243\346\234\200\345\244\247\345\200\274.md"
@@ -267,7 +267,7 @@ class Solution {
//利用双端队列手动实现单调队列
/**
* 用一个单调队列来存储对应的下标，每当窗口滑动的时候，直接取队列的头部指针对应的值放入结果集即可
- * 单调队列类似 （tail -->） 3 --> 2 --> 1 --> 0 (--> head) (右边为头结点，元素存的是下标)
+ * 单调递减队列类似 （head -->） 3 --> 2 --> 1 --> 0 (--> tail) (左边为头结点，元素存的是下标)
*/
class Solution {
public int[] maxSlidingWindow(int[] nums, int k) {
@@ -281,7 +281,7 @@ class Solution {
while(!deque.isEmpty() && deque.peek() < i - k + 1){
deque.poll();
}
- // 2.既然是单调，就要保证每次放进去的数字要比末尾的都大，否则也弹出
+ // 2.维护单调递减队列：新元素若大于队尾元素，则弹出队尾元素，直到满足单调性
while(!deque.isEmpty() && nums[deque.peekLast()] < nums[i]) {
deque.pollLast();
}
@@ -894,3 +894,4 @@ public:
+
From b764a124b71350bd8d008cddaddae3136f84c5f5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Mon, 20 Jan 2025 22:59:33 +0800
Subject: [PATCH 15/62] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=BA=8C=E5=8F=89?=
=?UTF-8?q?=E6=A0=91=E7=9A=84=E7=BB=9F=E4=B8=80=E8=BF=AD=E4=BB=A3=E6=B3=95?=
=?UTF-8?q?.md=E7=9A=84Java=E7=89=88=E6=9C=AC=E6=B3=A8=E9=87=8A=E7=AC=94?=
=?UTF-8?q?=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...37\344\270\200\350\277\255\344\273\243\346\263\225.md" | 8 ++++----
1 file changed, 4 insertions(+), 4 deletions(-)
diff --git "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md" "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
index 037cf1109b..a6d4e3ffc3 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
@@ -238,7 +238,7 @@ class Solution {
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
- st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
+ st.pop(); // 将该节点弹出，避免重复操作，下面再将右左中节点添加到栈中（前序遍历-中左右，入栈顺序右左中）
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
st.push(node); // 添加中节点
@@ -266,11 +266,10 @@ public List inorderTraversal(TreeNode root) {
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
- st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
+ st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中（中序遍历-左中右，入栈顺序右中左）
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
-
if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
@@ -294,7 +293,7 @@ class Solution {
while (!st.empty()) {
TreeNode node = st.peek();
if (node != null) {
- st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中
+ st.pop(); // 将该节点弹出，避免重复操作，下面再将中右左节点添加到栈中（后序遍历-左右中，入栈顺序中右左）
st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
@@ -975,3 +974,4 @@ public IList PostorderTraversal(TreeNode root)
+
From da742feaa3e324c9489bedaf867004cae583cc90 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Thu, 23 Jan 2025 11:47:27 +0800
Subject: [PATCH 16/62] =?UTF-8?q?=E4=BF=AE=E6=94=B90112.=E8=B7=AF=E5=BE=84?=
=?UTF-8?q?=E6=80=BB=E5=92=8C.md=E7=9A=84Java=E7=89=88=E6=9C=AC=E4=BB=A3?=
=?UTF-8?q?=E7=A0=81=E7=9A=84=E5=AD=97=E6=AF=8D=E5=B0=8F=E5=86=99=E9=97=AE?=
=?UTF-8?q?=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...57\345\276\204\346\200\273\345\222\214.md" | 59 ++++++++++---------
1 file changed, 31 insertions(+), 28 deletions(-)
diff --git "a/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md" "b/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md"
index b97013e67a..141967f593 100644
--- "a/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md"
+++ "b/problems/0112.\350\267\257\345\276\204\346\200\273\345\222\214.md"
@@ -309,25 +309,25 @@ public:
0112.路径总和
```java
-class solution {
- public boolean haspathsum(treenode root, int targetsum) {
+class Solution {
+ public boolean hasPathSum(TreeNode root, int targetSum) {
if (root == null) {
return false;
}
- targetsum -= root.val;
+ targetSum -= root.val;
// 叶子结点
if (root.left == null && root.right == null) {
- return targetsum == 0;
+ return targetSum == 0;
}
if (root.left != null) {
- boolean left = haspathsum(root.left, targetsum);
- if (left) { // 已经找到
+ boolean left = hasPathSum(root.left, targetSum);
+ if (left) { // 已经找到，提前返回
return true;
}
}
if (root.right != null) {
- boolean right = haspathsum(root.right, targetsum);
- if (right) { // 已经找到
+ boolean right = hasPathSum(root.right, targetSum);
+ if (right) { // 已经找到，提前返回
return true;
}
}
@@ -336,16 +336,16 @@ class solution {
}
// lc112 简洁方法
-class solution {
- public boolean haspathsum(treenode root, int targetsum) {
+class Solution {
+ public boolean hasPathSum(TreeNode root, int targetSum) {
if (root == null) return false; // 为空退出
// 叶子节点判断是否符合
- if (root.left == null && root.right == null) return root.val == targetsum;
+ if (root.left == null && root.right == null) return root.val == targetSum;
// 求两侧分支的路径和
- return haspathsum(root.left, targetsum - root.val) || haspathsum(root.right, targetsum - root.val);
+ return hasPathSum(root.left, targetSum - root.val) || hasPathSum(root.right, targetSum - root.val);
}
}
```
@@ -353,22 +353,22 @@ class solution {
迭代
```java
-class solution {
- public boolean haspathsum(treenode root, int targetsum) {
+class Solution {
+ public boolean hasPathSum(TreeNode root, int targetSum) {
if(root == null) return false;
- stack stack1 = new stack<>();
- stack stack2 = new stack<>();
+ Stack stack1 = new Stack<>();
+ Stack stack2 = new Stack<>();
stack1.push(root);
stack2.push(root.val);
- while(!stack1.isempty()) {
+ while(!stack1.isEmpty()) {
int size = stack1.size();
for(int i = 0; i < size; i++) {
- treenode node = stack1.pop();
+ TreeNode node = stack1.pop();
int sum = stack2.pop();
// 如果该节点是叶子节点了，同时该节点的路径数值等于sum，那么就返回true
- if(node.left == null && node.right == null && sum == targetsum) {
+ if(node.left == null && node.right == null && sum == targetSum) {
return true;
}
// 右节点，压进去一个节点的时候，将该节点的路径数值也记录下来
@@ -387,8 +387,9 @@ class solution {
}
}
```
-```Java 統一迭代法
- public boolean hasPathSum(TreeNode root, int targetSum) {
+```Java
+class Solution {
+ public boolean hasPathSum(TreeNode root, int targetSum) {
Stack treeNodeStack = new Stack<>();
Stack sumStack = new Stack<>();
@@ -422,38 +423,39 @@ class solution {
}
return false;
}
+}
```
0113.路径总和-ii
```java
-class solution {
- public List> pathsum(TreeNode root, int targetsum) {
+class Solution {
+ public List> pathSum(TreeNode root, int targetSum) {
List> res = new ArrayList<>();
if (root == null) return res; // 非空判断
List path = new LinkedList<>();
- preorderdfs(root, targetsum, res, path);
+ preOrderDfs(root, targetSum, res, path);
return res;
}
- public void preorderdfs(TreeNode root, int targetsum, List> res, List path) {
+ public void preOrderDfs(TreeNode root, int targetSum, List> res, List path) {
path.add(root.val);
// 遇到了叶子节点
if (root.left == null && root.right == null) {
// 找到了和为 targetsum 的路径
- if (targetsum - root.val == 0) {
+ if (targetSum - root.val == 0) {
res.add(new ArrayList<>(path));
}
return; // 如果和不为 targetsum，返回
}
if (root.left != null) {
- preorderdfs(root.left, targetsum - root.val, res, path);
+ preOrderDfs(root.left, targetSum - root.val, res, path);
path.remove(path.size() - 1); // 回溯
}
if (root.right != null) {
- preorderdfs(root.right, targetsum - root.val, res, path);
+ preOrderDfs(root.right, targetSum - root.val, res, path);
path.remove(path.size() - 1); // 回溯
}
}
@@ -1626,3 +1628,4 @@ public class Solution {
+
From 163c3f33d8d24735230b25ddb697d726f0d5c242 Mon Sep 17 00:00:00 2001
From: Anqi Li <103280095+iqna126@users.noreply.github.com>
Date: Thu, 23 Jan 2025 08:16:44 -0800
Subject: [PATCH 17/62] =?UTF-8?q?0054.=E6=9B=BF=E6=8D=A2=E6=95=B0=E5=AD=97?=
=?UTF-8?q?.md=20=E5=9C=A8=E8=AE=B2=E8=A7=A3=E4=B8=AD=E5=8A=A0=E5=85=A5?=
=?UTF-8?q?=E4=BA=86python=20string=E4=B9=9F=E4=B8=8D=E5=8F=AF=E5=8F=98?=
=?UTF-8?q?=E7=9A=84=E8=A7=A3=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
.../0054.\346\233\277\346\215\242\346\225\260\345\255\227.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md" "b/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
index e4b5c43fef..f788d65ba7 100644
--- "a/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
+++ "b/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
@@ -21,7 +21,7 @@
## 思路
-如果想把这道题目做到极致，就不要只用额外的辅助空间了！ （不过使用Java刷题的录友，一定要使用辅助空间，因为Java里的string不能修改）
+如果想把这道题目做到极致，就不要只用额外的辅助空间了！ （不过使用Java和Python刷题的录友，一定要使用辅助空间，因为Java和Python里的string不能修改）
首先扩充数组到每个数字字符替换成 "number" 之后的大小。
From 27718a4dfca99b25ceda3ee2946130c29261be71 Mon Sep 17 00:00:00 2001
From: asnpro <920569392@qq.com>
Date: Fri, 24 Jan 2025 22:51:46 +0800
Subject: [PATCH 18/62] =?UTF-8?q?docs:=20=E4=B8=BA=200494.=E7=9B=AE?=
=?UTF-8?q?=E6=A0=87=E5=92=8C.md=20=E5=AE=8C=E5=96=84=20JavaDoc=20?=
=?UTF-8?q?=E6=B3=A8=E9=87=8A,=20=E6=B7=BB=E5=8A=A0=E5=8A=A8=E8=A7=84?=
=?UTF-8?q?=E4=BA=94=E9=83=A8=E6=9B=B2=E6=B3=A8=E9=87=8A,=20=E8=A7=84?=
=?UTF-8?q?=E8=8C=83=E9=83=A8=E5=88=86=E4=BB=A3=E7=A0=81=E6=A0=BC=E5=BC=8F?=
=?UTF-8?q?,=20=E4=BF=AE=E6=94=B9=E9=83=A8=E5=88=86=E5=8F=98=E9=87=8F?=
=?UTF-8?q?=E5=90=8D=E4=BB=A5=E5=A2=9E=E5=BC=BA=E4=BB=A3=E7=A0=81=E8=AF=AD?=
=?UTF-8?q?=E4=B9=89=E5=8C=96?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...4.\347\233\256\346\240\207\345\222\214.md" | 61 +++++++++++++++----
1 file changed, 50 insertions(+), 11 deletions(-)
diff --git "a/problems/0494.\347\233\256\346\240\207\345\222\214.md" "b/problems/0494.\347\233\256\346\240\207\345\222\214.md"
index 4a1fc6ab9a..c38ba7e43c 100644
--- "a/problems/0494.\347\233\256\346\240\207\345\222\214.md"
+++ "b/problems/0494.\347\233\256\346\240\207\345\222\214.md"
@@ -825,30 +825,69 @@ func abs(x int) int {
### JavaScript
```javascript
+/**
+ * 题目来源: {@link https://leetcode.cn/problems/target-sum/}
+ *
+ * 题解来源: {@link https://programmercarl.com/0494.%E7%9B%AE%E6%A0%87%E5%92%8C.html#%E7%AE%97%E6%B3%95%E5%85%AC%E5%BC%80%E8%AF%BE}
+ *
+ * 时间复杂度: O(n * C), C 为数组元素总和与目标值之和的一半
+ *
+ * 空间复杂度: O(C)
+ *
+ * @param { number[] } nums
+ * @param { number } target
+ * @return { number }
+ */
const findTargetSumWays = (nums, target) => {
-
- const sum = nums.reduce((a, b) => a+b);
+ // 原题目可转化为:
+ //
+ // 将所有元素划分为 2 个集合,
+ // 一个集合中包含所有要添加 "+" 号的元素, 一个集合中包含所有要添加 "-" 号的元素
+ //
+ // 设两个集合的元素和分别为 positive 和 negative, 所有元素总和为 sum, 那么有如下等式:
+ // positive + negative = sum (1)
+ // positive - negative = target (2)
+ // (1) 与 (2) 联立可得: positive = (sum + target) / 2,
+ // 所以如果能从原数组中取出若干个元素形成 1 个元素总和为 (sum + target) / 2 的集合,
+ // 就算得到了 1 种满足题意的组合方法
+ //
+ // 因此, 所求变为: 有多少种取法, 可使得容量为 (sum + target) / 2 的背包被装满?
+
+ const sum = nums.reduce((a, b) => a + b);
- if(Math.abs(target) > sum) {
+ if (Math.abs(target) > sum) {
return 0;
}
- if((target + sum) % 2) {
+ if ((target + sum) % 2) {
return 0;
}
- const halfSum = (target + sum) / 2;
-
- let dp = new Array(halfSum+1).fill(0);
+ const bagWeight = (target + sum) / 2;
+
+ // 1. dp 数组的含义
+ // dp[j]: 装满容量为 j 的背包, 有 dp[j] 种方法
+ let dp = new Array(bagWeight + 1).fill(0);
+
+ // 2. 递推公式
+ // dp[j] = Σ(dp[j - nums[j]]), (j ∈ [0, j] 且 j >= nums[j])
+ // 因为 dp[j - nums[j]] 表示: 装满容量为 j - nums[j] 背包有 dp[j - nums[j]] 种方法
+ // 而容量为 j - nums[j] 的背包只需要再将 nums[j] 放入背包就能使得背包容量达到 j
+ // 因此, 让背包容量达到 j 有 Σ(dp[j - nums[j]]) 种方法
+
+ // 3. dp 数组如何初始化
+ // dp[0] = 1, dp[1 ~ bagWeight] = 0
dp[0] = 1;
-
- for(let i = 0; i < nums.length; i++) {
- for(let j = halfSum; j >= nums[i]; j--) {
+
+ // 4. 遍历顺序
+ // 先物品后背包, 物品从前往后遍历, 背包容量从后往前遍历
+ for (let i = 0; i < nums.length; i++) {
+ for (let j = bagWeight; j >= nums[i]; j--) {
dp[j] += dp[j - nums[i]];
}
}
- return dp[halfSum];
+ return dp[bagWeight];
};
```
From e6698cbac457714427f4a9cba6ea2a3ea9eed94c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Sat, 25 Jan 2025 11:52:09 +0800
Subject: [PATCH 19/62] =?UTF-8?q?=E4=BF=AE=E6=94=B90530.=E4=BA=8C=E5=8F=89?=
=?UTF-8?q?=E6=90=9C=E7=B4=A2=E6=A0=91=E7=9A=84=E6=9C=80=E5=B0=8F=E7=BB=9D?=
=?UTF-8?q?=E5=AF=B9=E5=B7=AE.md=E7=9A=84Java=E7=89=88=E6=9C=AC=20?=
=?UTF-8?q?=E8=BF=9B=E8=A1=8C=E4=BA=86=E4=BB=A3=E7=A0=81=E6=A0=BC=E5=BC=8F?=
=?UTF-8?q?=E5=8C=96=E5=B9=B6=E6=B7=BB=E5=8A=A0=E4=BA=86=E7=BB=9F=E4=B8=80?=
=?UTF-8?q?=E8=BF=AD=E4=BB=A3=E6=B3=95=E7=9A=84=E6=B3=A8=E9=87=8A?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...17\347\273\235\345\257\271\345\267\256.md" | 46 +++++++++++--------
1 file changed, 28 insertions(+), 18 deletions(-)
diff --git "a/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md" "b/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md"
index 2533a618ed..b6d08dbeaa 100644
--- "a/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md"
+++ "b/problems/0530.\344\272\214\345\217\211\346\220\234\347\264\242\346\240\221\347\232\204\346\234\200\345\260\217\347\273\235\345\257\271\345\267\256.md"
@@ -153,23 +153,27 @@ public:
递归
```java
class Solution {
- TreeNode pre;// 记录上一个遍历的结点
+ TreeNode pre; // 记录上一个遍历的结点
int result = Integer.MAX_VALUE;
+
public int getMinimumDifference(TreeNode root) {
- if(root==null)return 0;
- traversal(root);
- return result;
+ if (root == null)
+ return 0;
+ traversal(root);
+ return result;
}
- public void traversal(TreeNode root){
- if(root==null)return;
- //左
+
+ public void traversal(TreeNode root) {
+ if (root == null)
+ return;
+ // 左
traversal(root.left);
- //中
- if(pre!=null){
- result = Math.min(result,root.val-pre.val);
+ // 中
+ if (pre != null) {
+ result = Math.min(result, root.val - pre.val);
}
pre = root;
- //右
+ // 右
traversal(root.right);
}
}
@@ -182,22 +186,27 @@ class Solution {
TreeNode pre = null;
int result = Integer.MAX_VALUE;
- if(root != null)
+ if (root != null)
stack.add(root);
- while(!stack.isEmpty()){
+
+ // 中序遍历（左中右），由于栈先入后出，反序（右中左）
+ while (!stack.isEmpty()) {
TreeNode curr = stack.peek();
- if(curr != null){
+ if (curr != null) {
stack.pop();
- if(curr.right != null)
+ // 右
+ if (curr.right != null)
stack.add(curr.right);
+ // 中（先用null标记）
stack.add(curr);
stack.add(null);
- if(curr.left != null)
+ // 左
+ if (curr.left != null)
stack.add(curr.left);
- }else{
+ } else { // 中（遇到null再处理）
stack.pop();
TreeNode temp = stack.pop();
- if(pre != null)
+ if (pre != null)
result = Math.min(result, temp.val - pre.val);
pre = temp;
}
@@ -674,3 +683,4 @@ public class Solution
+
From 7f5ce0ac41f35e97d02ecfdf85c940f91c32d026 Mon Sep 17 00:00:00 2001
From: lewiseng <65698183+lewiseng@users.noreply.github.com>
Date: Sat, 25 Jan 2025 15:56:17 -0500
Subject: [PATCH 20/62] =?UTF-8?q?Update=200216.=E7=BB=84=E5=90=88=E6=80=BB?=
=?UTF-8?q?=E5=92=8CIII.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md" "b/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md"
index 3d7f2d0c03..04805c93f5 100644
--- "a/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md"
+++ "b/problems/0216.\347\273\204\345\220\210\346\200\273\345\222\214III.md"
@@ -367,7 +367,7 @@ class Solution:
def backtracking(self, targetSum, k, currentSum, startIndex, path, result):
if currentSum > targetSum: # 剪枝操作
- return # 如果path的长度等于k但currentSum不等于targetSum，则直接返回
+ return # 如果currentSum已经超过targetSum，则直接返回
if len(path) == k:
if currentSum == targetSum:
result.append(path[:])
From c2e95f6c25b2c3f9ff61dc0891cc08360b676bb1 Mon Sep 17 00:00:00 2001
From: dam <1782067308@qq.com>
Date: Sun, 26 Jan 2025 12:08:15 +0800
Subject: [PATCH 21/62] =?UTF-8?q?108=E5=86=97=E4=BD=99=E8=BF=9E=E6=8E=A5?=
=?UTF-8?q?=20java=E5=AE=9E=E7=8E=B0?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...27\344\275\231\350\277\236\346\216\245.md" | 75 +++++++++++++++++++
1 file changed, 75 insertions(+)
diff --git "a/problems/kamacoder/0108.\345\206\227\344\275\231\350\277\236\346\216\245.md" "b/problems/kamacoder/0108.\345\206\227\344\275\231\350\277\236\346\216\245.md"
index efbbb6d203..df3dd4deed 100644
--- "a/problems/kamacoder/0108.\345\206\227\344\275\231\350\277\236\346\216\245.md"
+++ "b/problems/kamacoder/0108.\345\206\227\344\275\231\350\277\236\346\216\245.md"
@@ -176,6 +176,81 @@ int main() {
### Java
+```java
+import java.util.Scanner;
+
+public class Main {
+ private static int[] father;
+
+ public static void main(String[] args) {
+ Scanner scanner = new Scanner(System.in);
+ int pointNum = scanner.nextInt();
+ father = new int[pointNum + 1];
+ init();
+ for (int i = 0; i < pointNum; i++) {
+ join(scanner.nextInt(), scanner.nextInt());
+ }
+ }
+
+ /**
+ * 并查集初始化
+ */
+ private static void init() {
+ for (int i = 1; i < father.length; i++) {
+ // 让每个元素指向自己
+ father[i] = i;
+ }
+ }
+
+ /**
+ * 并查集寻根
+ *
+ * @param u
+ * @return
+ */
+ private static int find(int u) {
+ // 判断 u 是否等于自己，如果是的话，直接返回自己
+ // 如果不等于自己，就寻找根，寻找的时候，反复进行路径压缩
+ return u == father[u] ? u : (father[u] = find(father[u]));
+ }
+
+ /**
+ * 判断 u 和 v 是否同根
+ *
+ * @param u
+ * @param v
+ * @return
+ */
+ private static boolean isSame(int u, int v) {
+ return find(u) == find(v);
+ }
+
+ /**
+ * 添加 边 到并查集，v 指向 u
+ *
+ * @param u
+ * @param v
+ */
+ private static void join(int u, int v) {
+ // --if-- 如果两个点已经同根，说明他们的信息已经存储到并查集中了，直接返回即可
+ // 寻找u的根
+ int uRoot = find(u);
+ // 寻找v的根
+ int vRoot = find(v);
+ if (uRoot == vRoot) {
+ // --if-- 如果u,v的根相同，说明两者已经连接了，直接输出
+ System.out.println(u + " " + v);
+ return;
+ }
+ // --if-- 将信息添加到并查集
+ father[vRoot] = uRoot;
+ }
+
+}
+```
+
+
+
### Python
```python
From 8bf4e2cdf1f69ab9a8f733e0c5693236335cff5c Mon Sep 17 00:00:00 2001
From: 1ltwo
Date: Mon, 27 Jan 2025 16:08:27 +0800
Subject: [PATCH 22/62] =?UTF-8?q?738go=E7=89=88=E6=9C=AC=E7=AD=94=E6=A1=88?=
=?UTF-8?q?=E6=9B=B4=E6=AD=A3=EF=BC=88=E5=8E=9F=E7=AD=94=E6=A1=88=E5=8A=9B?=
=?UTF-8?q?=E6=89=A3=E6=97=A0=E6=B3=95=E9=80=9A=E8=BF=87=EF=BC=89?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...36\347\232\204\346\225\260\345\255\227.md" | 31 +++++++++----------
1 file changed, 15 insertions(+), 16 deletions(-)
diff --git "a/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md" "b/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md"
index ff438e981c..f2cfee04c9 100644
--- "a/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md"
+++ "b/problems/0738.\345\215\225\350\260\203\351\200\222\345\242\236\347\232\204\346\225\260\345\255\227.md"
@@ -273,22 +273,20 @@ class Solution:
### Go
```go
func monotoneIncreasingDigits(n int) int {
- s := strconv.Itoa(N)//将数字转为字符串，方便使用下标
- ss := []byte(s)//将字符串转为byte数组，方便更改。
- n := len(ss)
- if n <= 1 {
- return n
- }
- for i := n-1; i > 0; i-- {
- if ss[i-1] > ss[i] { //前一个大于后一位,前一位减1，后面的全部置为9
- ss[i-1] -= 1
- for j := i; j < n; j++ { //后面的全部置为9
- ss[j] = '9'
- }
- }
- }
- res, _ := strconv.Atoi(string(ss))
- return res
+ s := strconv.Itoa(n)
+ // 从左到右遍历字符串，找到第一个不满足单调递增的位置
+ for i := len(s) - 2; i >= 0; i-- {
+ if s[i] > s[i+1] {
+ // 将该位置的数字减1
+ s = s[:i] + string(s[i]-1) + s[i+1:]
+ // 将该位置之后的所有数字置为9
+ for j := i + 1; j < len(s); j++ {
+ s = s[:j] + "9" + s[j+1:]
+ }
+ }
+ }
+ result, _ := strconv.Atoi(s)
+ return result
}
```
@@ -447,3 +445,4 @@ public class Solution
+
From 333099a1268544306e303fcb779ffd801c0d0c92 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Mon, 3 Feb 2025 20:13:41 +0800
Subject: [PATCH 23/62] =?UTF-8?q?=E4=BF=AE=E6=94=B9=E4=BA=8C=E5=8F=89?=
=?UTF-8?q?=E6=A0=91=E6=80=BB=E7=BB=93=E7=AF=87.md=E4=B8=80=E5=A4=84?=
=?UTF-8?q?=E5=88=97=E8=A1=A8=E7=BA=A7=E5=88=AB=E7=9A=84=E6=A0=BC=E5=BC=8F?=
=?UTF-8?q?=E9=97=AE=E9=A2=98?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\211\346\240\221\346\200\273\347\273\223\347\257\207.md" | 6 +++---
1 file changed, 3 insertions(+), 3 deletions(-)
diff --git "a/problems/\344\272\214\345\217\211\346\240\221\346\200\273\347\273\223\347\257\207.md" "b/problems/\344\272\214\345\217\211\346\240\221\346\200\273\347\273\223\347\257\207.md"
index 8db40d6560..4794233ab5 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\346\200\273\347\273\223\347\257\207.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\346\200\273\347\273\223\347\257\207.md"
@@ -92,10 +92,9 @@
* 递归：中序，双指针操作
* 迭代：模拟中序，逻辑相同
* [求二叉搜索树的众数](https://programmercarl.com/0501.二叉搜索树中的众数.html)
-
+
* 递归：中序，清空结果集的技巧，遍历一遍便可求众数集合
- * [二叉搜索树转成累加树](https://programmercarl.com/0538.把二叉搜索树转换为累加树.html)
-
+* [二叉搜索树转成累加树](https://programmercarl.com/0538.把二叉搜索树转换为累加树.html)
* 递归：中序，双指针操作累加
* 迭代：模拟中序，逻辑相同
@@ -163,3 +162,4 @@
+
From 3b2373d35f1f551826b473d019fa1f1e58966f79 Mon Sep 17 00:00:00 2001
From: buptz2b <155848478+buptz2b@users.noreply.github.com>
Date: Tue, 4 Feb 2025 22:00:18 +0800
Subject: [PATCH 24/62] =?UTF-8?q?Update=200001.=E4=B8=A4=E6=95=B0=E4=B9=8B?=
=?UTF-8?q?=E5=92=8C.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\270\244\346\225\260\344\271\213\345\222\214.md" | 13 ++++++-------
1 file changed, 6 insertions(+), 7 deletions(-)
diff --git "a/problems/0001.\344\270\244\346\225\260\344\271\213\345\222\214.md" "b/problems/0001.\344\270\244\346\225\260\344\271\213\345\222\214.md"
index e982ae129b..3c92e4dfeb 100644
--- "a/problems/0001.\344\270\244\346\225\260\344\271\213\345\222\214.md"
+++ "b/problems/0001.\344\270\244\346\225\260\344\271\213\345\222\214.md"
@@ -287,17 +287,16 @@ func twoSum(nums []int, target int) []int {
```
```go
-// 使用map方式解题，降低时间复杂度
func twoSum(nums []int, target int) []int {
m := make(map[int]int)
- for index, val := range nums {
- if preIndex, ok := m[target-val]; ok {
- return []int{preIndex, index}
- } else {
- m[val] = index
+ for i, num := range nums {
+ complement := target - num
+ if index, found := m[complement]; found {
+ return []int{index, i}
}
+ m[num] = i
}
- return []int{}
+ return nil // 返回空数组 nil 代替空切片
}
```
From 4f07f351a870de2b4fb3ba79e15ebbd090669c46 Mon Sep 17 00:00:00 2001
From: "e-peirong.li"
Date: Mon, 10 Feb 2025 15:22:19 +0800
Subject: [PATCH 25/62] =?UTF-8?q?fix:=20=E4=BF=AE=E6=94=B9=20=E6=A0=88?=
=?UTF-8?q?=E4=B8=8E=E9=98=9F=E5=88=97=E7=90=86=E8=AE=BA=E5=9F=BA=E7=A1=80?=
=?UTF-8?q?.md=20=E9=94=99=E5=88=AB=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\210\227\347\220\206\350\256\272\345\237\272\347\241\200.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/problems/\346\240\210\344\270\216\351\230\237\345\210\227\347\220\206\350\256\272\345\237\272\347\241\200.md" "b/problems/\346\240\210\344\270\216\351\230\237\345\210\227\347\220\206\350\256\272\345\237\272\347\241\200.md"
index 21c61a4c8b..3ceb8690e4 100644
--- "a/problems/\346\240\210\344\270\216\351\230\237\345\210\227\347\220\206\350\256\272\345\237\272\347\241\200.md"
+++ "b/problems/\346\240\210\344\270\216\351\230\237\345\210\227\347\220\206\350\256\272\345\237\272\347\241\200.md"
@@ -65,7 +65,7 @@ C++标准库是有多个版本的，要知道我们使用的STL是哪个版本
**我们常用的SGI STL，如果没有指定底层实现的话，默认是以deque为缺省情况下栈的底层结构。**
-deque是一个双向队列，只要封住一段，只开通另一端就可以实现栈的逻辑了。
+deque是一个双向队列，只要封住一端，只开通另一端就可以实现栈的逻辑了。
**SGI STL中 队列底层实现缺省情况下一样使用deque实现的。**
From 3176a0c828f162d7776e3e2204129780e547f421 Mon Sep 17 00:00:00 2001
From: "e-peirong.li"
Date: Mon, 10 Feb 2025 15:45:42 +0800
Subject: [PATCH 26/62] =?UTF-8?q?fix:=20=E4=BF=AE=E6=94=B9=20README.md=20?=
=?UTF-8?q?=E9=94=99=E5=88=AB=E5=AD=97?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
README.md | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git a/README.md b/README.md
index b1db51c903..b64bcea684 100644
--- a/README.md
+++ b/README.md
@@ -53,7 +53,7 @@
按照先面的排列顺序，从数组开始刷起就可以了，顺序都安排好了，按顺序刷就好。
-在刷题攻略中，每个专题开始都有理论基础篇，并不像是教科书般的理论介绍，而是从实战中归纳需要的基础知识。每个专题结束都有总结篇，最这个专题的归纳总结。
+在刷题攻略中，每个专题开始都有理论基础篇，并不像是教科书般的理论介绍，而是从实战中归纳需要的基础知识。每个专题结束都有总结篇，是这个专题的归纳总结。
如果你是算法老手，这篇攻略也是复习的最佳资料，如果把每个系列对应的总结篇，快速过一遍，整个算法知识体系以及各种解法就重现脑海了。
From 2c218d7c5a6709c25009bf2237c1c518589cf9c0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E7=8E=8B=E7=BF=94?=
Date: Thu, 13 Feb 2025 10:48:11 +0800
Subject: [PATCH 27/62] =?UTF-8?q?=E4=BF=AE=E6=94=B90209.=E9=95=BF=E5=BA=A6?=
=?UTF-8?q?=E6=9C=80=E5=B0=8F=E7=9A=84=E5=AD=90=E6=95=B0=E7=BB=84.md?=
=?UTF-8?q?=E7=AC=94=E8=AF=AF?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md" "b/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
index c6d89976d0..e163623afd 100644
--- "a/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
+++ "b/problems/0209.\351\225\277\345\272\246\346\234\200\345\260\217\347\232\204\345\255\220\346\225\260\347\273\204.md"
@@ -68,7 +68,7 @@ public:
接下来就开始介绍数组操作中另一个重要的方法：**滑动窗口**。
-所谓滑动窗口，**就是不断的调节子序列的起始位置和终止位置，从而得出我们要想的结果**。
+所谓滑动窗口，**就是不断的调节子序列的起始位置和终止位置，从而得出我们想要的结果**。
在暴力解法中，是一个for循环滑动窗口的起始位置，一个for循环为滑动窗口的终止位置，用两个for循环 完成了一个不断搜索区间的过程。
From add956a0e1581d1470bfcc18e01c2a175d7d358d Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Sun, 16 Feb 2025 14:36:05 +0800
Subject: [PATCH 28/62] Update
---
...11\345\222\214\345\255\220\351\233\206.md" | 12 +++++-----
...00\345\244\247\351\235\242\347\247\257.md" | 4 ++--
...57\350\276\276\350\267\257\345\276\204.md" | 2 +-
...60\351\207\217\345\271\277\346\220\234.md" | 2 +-
...00\345\244\247\351\235\242\347\247\257.md" | 2 +-
...04\346\200\273\351\235\242\347\247\257.md" | 15 +++++-------
...06\350\256\272\345\237\272\347\241\200.md" | 2 +-
...06\350\256\272\345\237\272\347\241\200.md" | 23 +++++++++++++++++++
8 files changed, 41 insertions(+), 21 deletions(-)
diff --git "a/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md" "b/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md"
index 55ed7ad2ff..902c022ab3 100644
--- "a/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md"
+++ "b/problems/0416.\345\210\206\345\211\262\347\255\211\345\222\214\345\255\220\351\233\206.md"
@@ -60,7 +60,7 @@
* [动态规划：关于01背包问题，你该了解这些！](https://programmercarl.com/背包理论基础01背包-1.html)
* [动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)
-### 01背包问题
+## 01背包问题
01背包问题，大家都知道，有N件物品和一个最多能背重量为W 的背包。第i件物品的重量是weight[i]，得到的价值是value[i] 。每件物品只能用一次，求解将哪些物品装入背包里物品价值总和最大。
@@ -92,7 +92,7 @@
动规五部曲分析如下：
-1. 确定dp数组以及下标的含义
+### 1. 确定dp数组以及下标的含义
01背包中，dp[j] 表示： 容量（所能装的重量）为j的背包，所背的物品价值最大可以为dp[j]。
@@ -104,7 +104,7 @@
而dp[6] 就可以等于6了，放进1 和 5，那么dp[6] == 6，说明背包装满了。
-2. 确定递推公式
+### 2. 确定递推公式
01背包的递推公式为：dp[j] = max(dp[j], dp[j - weight[i]] + value[i]);
@@ -113,7 +113,7 @@
所以递推公式：dp[j] = max(dp[j], dp[j - nums[i]] + nums[i]);
-3. dp数组如何初始化
+### 3. dp数组如何初始化
在01背包，一维dp如何初始化，已经讲过，
@@ -133,7 +133,7 @@
vector dp(10001, 0);
```
-4. 确定遍历顺序
+### 4. 确定遍历顺序
在[动态规划：关于01背包问题，你该了解这些！（滚动数组）](https://programmercarl.com/背包理论基础01背包-2.html)中就已经说明：如果使用一维dp数组，物品遍历的for循环放在外层，遍历背包的for循环放在内层，且内层for循环倒序遍历！
@@ -148,7 +148,7 @@ for(int i = 0; i < nums.size(); i++) {
}
```
-5. 举例推导dp数组
+### 5. 举例推导dp数组
dp[j]的数值一定是小于等于j的。
diff --git "a/problems/0695.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" "b/problems/0695.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md"
index 11b638d4d6..ca70420687 100644
--- "a/problems/0695.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md"
+++ "b/problems/0695.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md"
@@ -44,7 +44,7 @@
这里其实涉及到dfs的两种写法。
-写法一，dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地
+写法一，dfs处理当前节点的相邻节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地
```CPP
// 版本一
@@ -87,7 +87,7 @@ public:
};
```
-写法二，dfs处理当前节点，即即在主函数遇到岛屿就计数为0，dfs处理接下来的全部陆地
+写法二，dfs处理当前节点，即在主函数遇到岛屿就计数为0，dfs处理接下来的全部陆地
dfs
```CPP
diff --git "a/problems/kamacoder/0098.\346\211\200\346\234\211\345\217\257\350\276\276\350\267\257\345\276\204.md" "b/problems/kamacoder/0098.\346\211\200\346\234\211\345\217\257\350\276\276\350\267\257\345\276\204.md"
index 7f56f9f4dd..4df53b448f 100644
--- "a/problems/kamacoder/0098.\346\211\200\346\234\211\345\217\257\350\276\276\350\267\257\345\276\204.md"
+++ "b/problems/kamacoder/0098.\346\211\200\346\234\211\345\217\257\350\276\276\350\267\257\345\276\204.md"
@@ -7,7 +7,7 @@
【题目描述】
-给定一个有 n 个节点的有向无环图，节点编号从 1 到 n。请编写一个函数，找出并返回所有从节点 1 到节点 n 的路径。每条路径应以节点编号的列表形式表示。
+给定一个有 n 个节点的有向无环图，节点编号从 1 到 n。请编写一个程序，找出并返回所有从节点 1 到节点 n 的路径。每条路径应以节点编号的列表形式表示。
【输入描述】
diff --git "a/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md" "b/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md"
index d654e23604..f8c36a00a8 100644
--- "a/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md"
+++ "b/problems/kamacoder/0099.\345\262\233\345\261\277\347\232\204\346\225\260\351\207\217\345\271\277\346\220\234.md"
@@ -72,7 +72,7 @@
如果从队列拿出节点，再去标记这个节点走过，就会发生下图所示的结果，会导致很多节点重复加入队列。
-
+
超时写法 （从队列中取出节点再标记，注意代码注释的地方）
diff --git "a/problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md" "b/problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md"
index 4f2f9d6732..170c0917aa 100644
--- "a/problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md"
+++ "b/problems/kamacoder/0100.\345\262\233\345\261\277\347\232\204\346\234\200\345\244\247\351\235\242\347\247\257.md"
@@ -63,7 +63,7 @@
这里其实涉及到dfs的两种写法。
-写法一，dfs只处理下一个节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地
+写法一，dfs处理当前节点的相邻节点，即在主函数遇到岛屿就计数为1，dfs处理接下来的相邻陆地
```CPP
// 版本一
diff --git "a/problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md" "b/problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md"
index 123e36cec5..43ac8ec96d 100644
--- "a/problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md"
+++ "b/problems/kamacoder/0101.\345\255\244\345\262\233\347\232\204\346\200\273\351\235\242\347\247\257.md"
@@ -72,10 +72,8 @@
#include
using namespace std;
int dir[4][2] = {-1, 0, 0, -1, 1, 0, 0, 1}; // 保存四个方向
-int count; // 统计符合题目要求的陆地空格数量
void dfs(vector>& grid, int x, int y) {
grid[x][y] = 0;
- count++;
for (int i = 0; i < 4; i++) { // 向四个方向遍历
int nextx = x + dir[i][0];
int nexty = y + dir[i][1];
@@ -109,16 +107,17 @@ int main() {
if (grid[0][j] == 1) dfs(grid, 0, j);
if (grid[n - 1][j] == 1) dfs(grid, n - 1, j);
}
- count = 0;
+ int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
- if (grid[i][j] == 1) dfs(grid, i, j);
+ if (grid[i][j] == 1) count++;
}
}
cout << count << endl;
}
```
+
采用广度优先搜索的代码如下：
```CPP
@@ -126,13 +125,11 @@ int main() {
#include
#include
using namespace std;
-int count = 0;
int dir[4][2] = {0, 1, 1, 0, -1, 0, 0, -1}; // 四个方向
void bfs(vector>& grid, int x, int y) {
queue> que;
que.push({x, y});
grid[x][y] = 0; // 只要加入队列，立刻标记
- count++;
while(!que.empty()) {
pair cur = que.front(); que.pop();
int curx = cur.first;
@@ -143,7 +140,6 @@ void bfs(vector>& grid, int x, int y) {
if (nextx < 0 || nextx >= grid.size() || nexty < 0 || nexty >= grid[0].size()) continue; // 越界了，直接跳过
if (grid[nextx][nexty] == 1) {
que.push({nextx, nexty});
- count++;
grid[nextx][nexty] = 0; // 只要加入队列立刻标记
}
}
@@ -169,15 +165,16 @@ int main() {
if (grid[0][j] == 1) bfs(grid, 0, j);
if (grid[n - 1][j] == 1) bfs(grid, n - 1, j);
}
- count = 0;
+ int count = 0;
for (int i = 0; i < n; i++) {
for (int j = 0; j < m; j++) {
- if (grid[i][j] == 1) bfs(grid, i, j);
+ if (grid[i][j] == 1) count++;
}
}
cout << count << endl;
}
+
```
diff --git "a/problems/kamacoder/\345\233\276\350\256\272\346\267\261\346\220\234\347\220\206\350\256\272\345\237\272\347\241\200.md" "b/problems/kamacoder/\345\233\276\350\256\272\346\267\261\346\220\234\347\220\206\350\256\272\345\237\272\347\241\200.md"
index efe833a7e1..ce3dbbdbe7 100644
--- "a/problems/kamacoder/\345\233\276\350\256\272\346\267\261\346\220\234\347\220\206\350\256\272\345\237\272\347\241\200.md"
+++ "b/problems/kamacoder/\345\233\276\350\256\272\346\267\261\346\220\234\347\220\206\350\256\272\345\237\272\347\241\200.md"
@@ -162,7 +162,7 @@ if (终止条件) {
终止添加不仅是结束本层递归，同时也是我们收获结果的时候。
-另外，其实很多dfs写法，没有写终止条件，其实终止条件写在了， 下面dfs递归的逻辑里了，也就是不符合条件，直接不会向下递归。这里如果大家不理解的话，没关系，后面会有具体题目来讲解。
+另外，其实很多dfs写法，没有写终止条件，其实终止条件写在了， 隐藏在下面dfs递归的逻辑里了，也就是不符合条件，直接不会向下递归。这里如果大家不理解的话，没关系，后面会有具体题目来讲解。
3. 处理目前搜索节点出发的路径
diff --git "a/problems/kamacoder/\345\233\276\350\256\272\347\220\206\350\256\272\345\237\272\347\241\200.md" "b/problems/kamacoder/\345\233\276\350\256\272\347\220\206\350\256\272\345\237\272\347\241\200.md"
index 50c3615733..84f693a00b 100644
--- "a/problems/kamacoder/\345\233\276\350\256\272\347\220\206\350\256\272\345\237\272\347\241\200.md"
+++ "b/problems/kamacoder/\345\233\276\350\256\272\347\220\206\350\256\272\345\237\272\347\241\200.md"
@@ -128,6 +128,29 @@
主要是 朴素存储、邻接表和邻接矩阵。
+关于朴素存储，这是我自创的名字，因为这种存储方式，就是将所有边存下来。
+
+例如图：
+
+
+
+图中有8条边，我们就定义 8 * 2的数组，即有n条边就申请n * 2，这么大的数组：
+
+
+
+数组第一行：6 7，就表示节点6 指向 节点7，以此类推。
+
+当然可以不用数组，用map，或者用 类 到可以表示出 这种边的关系。
+
+这种表示方式的好处就是直观，把节点与节点之间关系很容易展现出来。
+
+但如果我们想知道 节点1 和 节点6 是否相连，我们就需要把存储空间都枚举一遍才行。
+
+这是明显的缺点，同时，我们在深搜和广搜的时候，都不会使用这种存储方式。
+
+因为 搜索中，需要知道 节点与其他节点的链接情况，而这种朴素存储，都需要全部枚举才知道链接情况。
+
+在图论章节的后面文章讲解中，我会举例说明的。大家先有个印象。
### 邻接矩阵
From da821733ff03cefe9a2bc150e2f9f1821793e5f8 Mon Sep 17 00:00:00 2001
From: HuangLM03 <2306725926@qq.com>
Date: Sun, 16 Feb 2025 14:48:02 +0800
Subject: [PATCH 29/62] =?UTF-8?q?=E6=9B=B4=E6=96=B0=EF=BC=9A=E6=B7=BB?=
=?UTF-8?q?=E5=8A=A0kamacoder/0058=E5=8C=BA=E9=97=B4=E5=92=8C=E7=9A=84Go?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...8.\345\214\272\351\227\264\345\222\214.md" | 51 +++++++++++++++++++
1 file changed, 51 insertions(+)
diff --git "a/problems/kamacoder/0058.\345\214\272\351\227\264\345\222\214.md" "b/problems/kamacoder/0058.\345\214\272\351\227\264\345\222\214.md"
index 23e7189a15..6f400ee433 100644
--- "a/problems/kamacoder/0058.\345\214\272\351\227\264\345\222\214.md"
+++ "b/problems/kamacoder/0058.\345\214\272\351\227\264\345\222\214.md"
@@ -357,3 +357,54 @@ int main(int argc, char *argv[])
```
+### Go
+
+```go
+package main
+
+import (
+ "fmt"
+ "bufio"
+ "strconv"
+ "os"
+)
+
+func main() {
+ // bufio中读取数据的接口，因为数据卡的比较严，导致使用fmt.Scan会超时
+ scanner := bufio.NewScanner(os.Stdin)
+
+ // 获取数组大小
+ scanner.Scan()
+ n, _ := strconv.Atoi(scanner.Text())
+
+ // 获取数组元素的同时计算前缀和，一般建议切片开大一点防止各种越界问题
+ arr := make([]int, n + 1)
+ for i := 0; i < n; i++ {
+ scanner.Scan()
+ arr[i], _ = strconv.Atoi(scanner.Text())
+ if i != 0 {
+ arr[i] += arr[i - 1]
+ }
+ }
+
+ /*
+ 区间[l, r]的和可以使用区间[0, r]和[0, l - 1]相减得到，
+ 在代码中即为arr[r]-arr[l-1]。这里需要注意l-1是否越界
+ */
+ for {
+ var l, r int
+ scanner.Scan()
+ _, err := fmt.Sscanf(scanner.Text(), "%d %d", &l, &r)
+ if err != nil {
+ return
+ }
+
+ if l > 0 {
+ fmt.Println(arr[r] - arr[l - 1])
+ } else {
+ fmt.Println(arr[r])
+ }
+ }
+}
+```
+
From f802fc7e999210c70bba081ba79f3be21b4b3a81 Mon Sep 17 00:00:00 2001
From: HuangLM03 <2306725926@qq.com>
Date: Mon, 17 Feb 2025 02:13:03 +0800
Subject: [PATCH 30/62] =?UTF-8?q?=E6=B7=BB=E5=8A=A0kamacoder/0047.?=
=?UTF-8?q?=E5=8F=82=E4=BC=9Adijkstra=E6=9C=B4=E7=B4=A0=E7=9A=84Go?=
=?UTF-8?q?=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...74\232dijkstra\346\234\264\347\264\240.md" | 120 +++++++++++++++++-
1 file changed, 114 insertions(+), 6 deletions(-)
diff --git "a/problems/kamacoder/0047.\345\217\202\344\274\232dijkstra\346\234\264\347\264\240.md" "b/problems/kamacoder/0047.\345\217\202\344\274\232dijkstra\346\234\264\347\264\240.md"
index e71e9d5374..5fd57965ad 100644
--- "a/problems/kamacoder/0047.\345\217\202\344\274\232dijkstra\346\234\264\347\264\240.md"
+++ "b/problems/kamacoder/0047.\345\217\202\344\274\232dijkstra\346\234\264\347\264\240.md"
@@ -114,7 +114,7 @@ dijkstra 算法 同样是贪心的思路，不断寻找距离 源点最近的没
### 模拟过程
------------
+-----------
0、初始化
@@ -130,7 +130,7 @@ minDist数组数值初始化为int最大值。
此时所有节点都没有被访问过，所以 visited数组都为0
----------------
+---------------
以下为dijkstra 三部曲
@@ -555,13 +555,13 @@ int main() {
那我们来看dijkstra 求解的路径是什么样的，继续dijkstra 三部曲来模拟 ：（dijkstra模拟过程上面已经详细讲过，以下只模拟重要过程，例如如何初始化就省略讲解了）
------------
+-----------
初始化：
----------------
+---------------
1、选源点到哪个节点近且该节点未被访问过
@@ -632,7 +632,7 @@ int main() {
节点5的加入，而节点5 没有链接其他节点， 所以不用更新minDist数组，仅标记节点5被访问过了
-------------
+------------
1、选源点到哪个节点近且该节点未被访问过
@@ -646,7 +646,7 @@ int main() {
---------------
+--------------
至此dijkstra的模拟过程就结束了，根据最后的minDist数组，我们求 节点1 到 节点5 的最短路径的权值总和为 3，路径： 节点1 -> 节点3 -> 节点4 -> 节点5
@@ -865,6 +865,114 @@ if __name__ == "__main__":
### Go
+```go
+package main
+
+import(
+ "fmt"
+ "os"
+ "bufio"
+ "strconv"
+ "strings"
+ "math"
+)
+
+func main() {
+ // 创建Reader从标准输入中读取数据
+ reader := bufio.NewReader(os.Stdin)
+
+ // 以字符串的形式读取一行
+ line, _ := reader.ReadString('\n')
+ // 去掉字符串前后可能存在的空格
+ line = strings.TrimSpace(line)
+ // 以空格作为分隔符分割字符串，得到数字的字符串形式
+ params := strings.Split(line, " ")
+ // 字符串转化为数字，得到n和m，其中n为汽车站数，m为公路数
+ n, _ := strconv.Atoi(params[0])
+ m, _ := strconv.Atoi(params[1])
+
+ // 存储从源点到每个节点的最短距离
+ minDist := initSliceInt(math.MaxInt32, n + 1)
+ minDist[1] = 0
+ // 记录顶点是否被访问过
+ visited := initSliceBool(false, n + 1)
+
+ // 存储每个车站之间的距离
+ grid := make([][]int, n + 1)
+ for i := 1; i <= n; i++ {
+ grid[i] = initSliceInt(math.MaxInt32, n + 1)
+ grid[i][i] = 0
+ }
+ for i := 1; i <= m; i++ {
+ line, _ = reader.ReadString('\n')
+ line = strings.TrimSpace(line)
+ params = strings.Split(line, " ")
+ a, _ := strconv.Atoi(params[0])
+ b, _ := strconv.Atoi(params[1])
+ c, _ := strconv.Atoi(params[2])
+
+ grid[a][b] = c
+ }
+
+ // Dijkstra算法
+ for i := 1; i <= n; i++ {
+ cur := -1
+ // 1、选距离源点最近且未访问过的节点
+ for j := 1; j <= n; j++ {
+ if visited[j] == false && (cur == -1 || minDist[cur] > minDist[j]) {
+ cur = j;
+ }
+ }
+
+ // 2、标记该节点已被访问
+ visited[cur] = true
+
+ /*
+ 3、更新非访问节点到源点的距离（即更新minDist数组）。实际更新时无需判断
+ 节点是否被访问过，因为1.的限制，即使更新被访问过的点也没有任何影响。
+ */
+ for j := 1; j <= n; j++ {
+ minDist[j] = min(minDist[j], minDist[cur] + grid[cur][j])
+ }
+
+ }
+
+ if minDist[n] == math.MaxInt32 {
+ // 不能到达终点
+ fmt.Print(-1)
+ } else {
+ // 到达终点最短路径
+ fmt.Print(minDist[n])
+ }
+}
+
+// 创建int类型的切片
+func initSliceInt(value int, count int) []int {
+ result := make([]int, count)
+ for i := range result {
+ result[i] = value
+ }
+ return result
+}
+
+// 创建bool类型的切片
+func initSliceBool(value bool, count int) []bool {
+ result := make([]bool, count)
+ for i := range result {
+ result[i] = value
+ }
+ return result
+}
+
+// 比较两个int类型的大小，返回较小的一个
+func min(a, b int) int {
+ if a > b {
+ return b
+ }
+ return a
+}
+```
+
### Rust
### JavaScript
From 52cbec304ec4c4530551612f4a26b7fb2a5108cd Mon Sep 17 00:00:00 2001
From: Jerry Zeng <87971517+Zzz212zzZ@users.noreply.github.com>
Date: Fri, 28 Feb 2025 00:31:03 -0500
Subject: [PATCH 31/62] =?UTF-8?q?update:=20707=E8=AE=BE=E8=AE=A1=E9=93=BE?=
=?UTF-8?q?=E8=A1=A8=E9=A2=98=E8=A7=A3=E4=B8=AD=E6=B7=BB=E5=8A=A0Javascrip?=
=?UTF-8?q?t=E5=8F=8C=E5=A4=B4=E9=93=BE=E8=A1=A8=E7=9A=84=E8=A7=A3?=
=?UTF-8?q?=E6=B3=95?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...76\350\256\241\351\223\276\350\241\250.md" | 154 ++++++++++++++++++
1 file changed, 154 insertions(+)
diff --git "a/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md" "b/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md"
index ed1726d942..5c72b05a29 100644
--- "a/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md"
+++ "b/problems/0707.\350\256\276\350\256\241\351\223\276\350\241\250.md"
@@ -1191,6 +1191,160 @@ MyLinkedList.prototype.deleteAtIndex = function(index) {
*/
```
+```js
+/**
+ 定义双头节点的结构：同时包含前指针`prev`和后指针next`
+*/
+class Node {
+ constructor(val, prev, next) {
+ this.val = val
+ this.prev = prev
+ this.next = next
+ }
+}
+
+/**
+ 双链表：维护 `head` 和 `tail` 两个哨兵节点，这样可以简化对于中间节点的操作
+ 并且维护 `size`，使得能够以O(1)时间判断操作是否合法
+*/
+var MyLinkedList = function () {
+ this.tail = new Node(-1)
+ this.head = new Node(-1)
+ this.tail.prev = this.head
+ this.head.next = this.tail
+ this.size = 0
+};
+
+/**
+ * 获取在index处节点的值
+ *
+ * @param {number} index
+ * @return {number}
+ *
+ * 时间复杂度: O(n)
+ * 空间复杂度: O(1)
+ */
+MyLinkedList.prototype.get = function (index) {
+ // 当索引超出范围时，返回-1
+ if (index > this.size) {
+ return -1
+ }
+
+ let cur = this.head
+ for (let i = 0; i <= index; i++) {
+ cur = cur.next
+ }
+
+ return cur.val
+};
+
+/**
+ * 在链表头部添加一个新节点
+ *
+ * @param {number} val
+ * @return {void}
+ *
+ * 时间复杂度: O(1)
+ * 空间复杂度: O(1)
+ */
+MyLinkedList.prototype.addAtHead = function (val) {
+ /**
+ head <-> [newNode] <-> originNode
+ */
+ this.size++
+ const originNode = this.head.next
+ // 创建新节点，并建立连接
+ const newNode = new Node(val, this.head, originNode)
+
+ // 取消原前后结点的连接
+ this.head.next = newNode
+ originNode.prev = newNode
+};
+
+/**
+ * 在链表尾部添加一个新节点
+ *
+ * @param {number} val
+ * @return {void}
+ *
+ * 时间复杂度: O(1)
+ * 空间复杂度: O(1)
+ */
+MyLinkedList.prototype.addAtTail = function (val) {
+ /**
+ originNode <-> [newNode] <-> tail
+ */
+ this.size++
+ const originNode = this.tail.prev
+
+ // 创建新节点，并建立连接
+ const newNode = new Node(val, originNode, this.tail)
+
+ // 取消原前后结点的连接
+ this.tail.prev = newNode
+ originNode.next = newNode
+};
+
+/**
+ * 在指定索引位置前添加一个新节点
+ *
+ * @param {number} index
+ * @param {number} val
+ * @return {void}
+ *
+ * 时间复杂度: O(n)
+ * 空间复杂度: O(1)
+ */
+MyLinkedList.prototype.addAtIndex = function (index, val) {
+ // 当索引超出范围时，直接返回
+ if (index > this.size) {
+ return
+ }
+ this.size++
+
+ let cur = this.head
+ for (let i = 0; i < index; i++) {
+ cur = cur.next
+ }
+
+ const new_next = cur.next
+
+ // 创建新节点，并建立连接
+ const node = new Node(val, cur, new_next)
+
+ // 取消原前后结点的连接
+ cur.next = node
+ new_next.prev = node
+};
+
+/**
+ * 删除指定索引位置的节点
+ *
+ * @param {number} index
+ * @return {void}
+ *
+ * 时间复杂度: O(n)
+ * 空间复杂度: O(1)
+ */
+MyLinkedList.prototype.deleteAtIndex = function (index) {
+ // 当索引超出范围时，直接返回
+ if (index >= this.size) {
+ return
+ }
+
+ this.size--
+ let cur = this.head
+ for (let i = 0; i < index; i++) {
+ cur = cur.next
+ }
+
+ const new_next = cur.next.next
+ // 取消原前后结点的连接
+ new_next.prev = cur
+ cur.next = new_next
+};
+```
+
### TypeScript:
```TypeScript
From a01972daad0997d57c48c28b67ff44ebf6028227 Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Mon, 3 Mar 2025 20:27:16 +0800
Subject: [PATCH 32/62] Update
---
.../0102.\346\262\211\346\262\241\345\255\244\345\262\233.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md" "b/problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md"
index a7e28df52f..5e211cd09c 100644
--- "a/problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md"
+++ "b/problems/kamacoder/0102.\346\262\211\346\262\241\345\255\244\345\262\233.md"
@@ -61,7 +61,7 @@
思路依然是从地图周边出发，将周边空格相邻的陆地都做上标记，然后在遍历一遍地图，遇到 陆地 且没做过标记的，那么都是地图中间的 陆地 ，全部改成水域就行。
-有的录友可能想，我在定义一个 visited 二维数组，单独标记周边的陆地，然后遍历地图的时候同时对 数组board 和 数组visited 进行判断，决定 陆地是否变成水域。
+有的录友可能想，我再定义一个 visited 二维数组，单独标记周边的陆地，然后遍历地图的时候同时对 地图数组 和 数组visited 进行判断，决定 陆地是否变成水域。
这样做其实就有点麻烦了，不用额外定义空间了，标记周边的陆地，可以直接改陆地为其他特殊值作为标记。
From f0767204bb09f1e95642af36a624a558a8321e5c Mon Sep 17 00:00:00 2001
From: RelishCoding <122661763+RelishCoding@users.noreply.github.com>
Date: Tue, 4 Mar 2025 16:58:38 +0800
Subject: [PATCH 33/62] =?UTF-8?q?Update=20=E4=BA=8C=E5=8F=89=E6=A0=91?=
=?UTF-8?q?=E7=9A=84=E7=BB=9F=E4=B8=80=E8=BF=AD=E4=BB=A3=E6=B3=95.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
1.为Java解法中添加迭代法的boolean标记法
2.为原有的Java解法中添加空指针标记法说明，并调整代码格式
---
...00\350\277\255\344\273\243\346\263\225.md" | 199 +++++++++++++++---
1 file changed, 171 insertions(+), 28 deletions(-)
diff --git "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md" "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
index a6d4e3ffc3..25756a9146 100644
--- "a/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
+++ "b/problems/\344\272\214\345\217\211\346\240\221\347\232\204\347\273\237\344\270\200\350\277\255\344\273\243\346\263\225.md"
@@ -227,7 +227,8 @@ public:
## 其他语言版本
### Java：
-迭代法前序遍历代码如下:
+
+迭代法前序遍历（空指针标记法）代码如下：
```java
class Solution {
@@ -239,11 +240,10 @@ class Solution {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将右左中节点添加到栈中（前序遍历-中左右，入栈顺序右左中）
- if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
- if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
- st.push(node); // 添加中节点
+ if (node.right != null) st.push(node.right); // 添加右节点（空节点不入栈）
+ if (node.left != null) st.push(node.left); // 添加左节点（空节点不入栈）
+ st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
-
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
@@ -256,34 +256,34 @@ class Solution {
}
```
-迭代法中序遍历代码如下:
+迭代法中序遍历（空指针标记法）代码如下：
```java
class Solution {
-public List inorderTraversal(TreeNode root) {
+ public List inorderTraversal(TreeNode root) {
List result = new LinkedList<>();
- Stack st = new Stack<>();
- if (root != null) st.push(root);
- while (!st.empty()) {
- TreeNode node = st.peek();
- if (node != null) {
- st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中（中序遍历-左中右，入栈顺序右中左）
- if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
- st.push(node); // 添加中节点
- st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
- if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
- } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
- st.pop(); // 将空节点弹出
- node = st.peek(); // 重新取出栈中元素
- st.pop();
- result.add(node.val); // 加入到结果集
+ Stack st = new Stack<>();
+ if (root != null) st.push(root);
+ while (!st.empty()) {
+ TreeNode node = st.peek();
+ if (node != null) {
+ st.pop(); // 将该节点弹出，避免重复操作，下面再将右中左节点添加到栈中（中序遍历-左中右，入栈顺序右中左）
+ if (node.right != null) st.push(node.right); // 添加右节点（空节点不入栈）
+ st.push(node); // 添加中节点
+ st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
+ if (node.left != null) st.push(node.left); // 添加左节点（空节点不入栈）
+ } else { // 只有遇到空节点的时候，才将下一个节点放进结果集
+ st.pop(); // 将空节点弹出
+ node = st.peek(); // 重新取出栈中元素
+ st.pop();
+ result.add(node.val); // 加入到结果集
+ }
}
+ return result;
}
- return result;
-}
}
```
-迭代法后序遍历代码如下:
+迭代法后序遍历（空指针标记法）代码如下：
```java
class Solution {
public List postorderTraversal(TreeNode root) {
@@ -294,11 +294,10 @@ class Solution {
TreeNode node = st.peek();
if (node != null) {
st.pop(); // 将该节点弹出，避免重复操作，下面再将中右左节点添加到栈中（后序遍历-左右中，入栈顺序中右左）
- st.push(node); // 添加中节点
+ st.push(node); // 添加中节点
st.push(null); // 中节点访问过，但是还没有处理，加入空节点做为标记。
if (node.right!=null) st.push(node.right); // 添加右节点（空节点不入栈）
- if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
-
+ if (node.left!=null) st.push(node.left); // 添加左节点（空节点不入栈）
} else { // 只有遇到空节点的时候，才将下一个节点放进结果集
st.pop(); // 将空节点弹出
node = st.peek(); // 重新取出栈中元素
@@ -311,6 +310,150 @@ class Solution {
}
```
+迭代法前序遍历（boolean 标记法）代码如下：
+
+```java
+// LeetCode提交时注意添加导包语句
+import java.util.AbstractMap.SimpleEntry;
+
+class Solution {
+ public List preorderTraversal(TreeNode root) {
+ List result = new ArrayList<>();
+ if (root == null)
+ return result;
+ Stack> stack = new Stack<>();
+ stack.push(new SimpleEntry<>(root, false));
+
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.peek().getKey();
+ // 多加一个visited参数，使“迭代统一写法”成为一件简单的事
+ boolean visited = stack.peek().getValue();
+ stack.pop();
+
+ // visited为True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
+ if (visited) {
+ result.add(node.val);
+ continue;
+ }
+
+ // visited当前为false, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”
+
+ // 前序遍历是'中左右'，右儿子最先入栈，最后出栈
+ if (node.right != null) {
+ stack.push(new SimpleEntry<>(node.right, false));
+ }
+
+ // 左儿子位置居中
+ if (node.left != null) {
+ stack.push(new SimpleEntry<>(node.left, false));
+ }
+
+ // 节点自己最后入栈，最先出栈
+ // 同时，设置 visited 为 true，表示下次再访问本节点时，允许收割
+ stack.push(new SimpleEntry<>(node, true));
+ }
+
+ return result;
+ }
+}
+```
+
+迭代法中序遍历（boolean 标记法）代码如下：
+
+```java
+// LeetCode提交时注意添加导包语句
+import java.util.AbstractMap.SimpleEntry;
+
+class Solution {
+ public List inorderTraversal(TreeNode root) {
+ List result = new ArrayList<>();
+ if (root == null)
+ return result;
+ Stack> stack = new Stack<>();
+ stack.push(new SimpleEntry<>(root, false));
+
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.peek().getKey();
+ // 多加一个visited参数，使“迭代统一写法”成为一件简单的事
+ boolean visited = stack.peek().getValue();
+ stack.pop();
+
+ // visited为True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
+ if (visited) {
+ result.add(node.val);
+ continue;
+ }
+
+ // visited当前为false, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”
+
+ // 中序遍历是'左中右'，右儿子最先入栈，最后出栈
+ if (node.right != null) {
+ stack.push(new SimpleEntry<>(node.right, false));
+ }
+
+ // 把自己加回到栈中，位置居中
+ // 同时，设置 visited 为 true，表示下次再访问本节点时，允许收割
+ stack.push(new SimpleEntry<>(node, true));
+
+ // 左儿子最后入栈，最先出栈
+ if (node.left != null) {
+ stack.push(new SimpleEntry<>(node.left, false));
+ }
+ }
+
+ return result;
+ }
+}
+```
+
+迭代法后序遍历（boolean 标记法）代码如下：
+
+```java
+// LeetCode提交时注意添加导包语句
+import java.util.AbstractMap.SimpleEntry;
+
+class Solution {
+ public List postorderTraversal(TreeNode root) {
+ List result = new ArrayList<>();
+ if (root == null)
+ return result;
+ Stack> stack = new Stack<>();
+ stack.push(new SimpleEntry<>(root, false));
+
+ while (!stack.isEmpty()) {
+ TreeNode node = stack.peek().getKey();
+ // 多加一个visited参数，使“迭代统一写法”成为一件简单的事
+ boolean visited = stack.peek().getValue();
+ stack.pop();
+
+ // visited为True，表示该节点和两个儿子位次之前已经安排过了，现在可以收割节点了
+ if (visited) {
+ result.add(node.val);
+ continue;
+ }
+
+ // visited当前为false, 表示初次访问本节点，此次访问的目的是“把自己和两个儿子在栈中安排好位次”
+
+ // 后序遍历是'左右中'，节点自己最先入栈，最后出栈
+ // 同时，设置 visited 为 true，表示下次再访问本节点时，允许收割
+ stack.push(new SimpleEntry<>(node, true));
+
+ // 右儿子位置居中
+ if (node.right != null) {
+ stack.push(new SimpleEntry<>(node.right, false));
+ }
+
+ // 左儿子最后入栈，最先出栈
+ if (node.left != null) {
+ stack.push(new SimpleEntry<>(node.left, false));
+ }
+ }
+
+ return result;
+ }
+}
+```
+
### Python：
> 迭代法前序遍历（空指针标记法）：
From d6e680498b4375a06bff36a37ed274ecd5cf3373 Mon Sep 17 00:00:00 2001
From: zen <43899716+zenwangzy@users.noreply.github.com>
Date: Wed, 5 Mar 2025 00:00:17 +0800
Subject: [PATCH 34/62] =?UTF-8?q?Update=200454.=E5=9B=9B=E6=95=B0=E7=9B=B8?=
=?UTF-8?q?=E5=8A=A0II.md?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
0454-四数相加，力扣函数参数更新，故更新对应题解代码
---
...5\233\233\346\225\260\347\233\270\345\212\240II.md" | 10 +++++-----
1 file changed, 5 insertions(+), 5 deletions(-)
diff --git "a/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md" "b/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md"
index af19f5f7d8..2138590c31 100644
--- "a/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md"
+++ "b/problems/0454.\345\233\233\346\225\260\347\233\270\345\212\240II.md"
@@ -62,18 +62,18 @@ C++代码:
```CPP
class Solution {
public:
- int fourSumCount(vector& A, vector& B, vector& C, vector& D) {
+ int fourSumCount(vector& nums1, vector& nums2, vector& nums3, vector& nums4) {
unordered_map umap; //key:a+b的数值，value:a+b数值出现的次数
// 遍历大A和大B数组，统计两个数组元素之和，和出现的次数，放到map中
- for (int a : A) {
- for (int b : B) {
+ for (int a : nums1) {
+ for (int b : nums2) {
umap[a + b]++;
}
}
int count = 0; // 统计a+b+c+d = 0 出现的次数
// 再遍历大C和大D数组，找到如果 0-(c+d) 在map中出现过的话，就把map中key对应的value也就是出现次数统计出来。
- for (int c : C) {
- for (int d : D) {
+ for (int c : nums3) {
+ for (int d : nums4) {
if (umap.find(0 - (c + d)) != umap.end()) {
count += umap[0 - (c + d)];
}
From 792c9dfbaa1624ce97ba8ce74d0f29b7dc44f7ff Mon Sep 17 00:00:00 2001
From: wsmh <1362384538@qq.com>
Date: Mon, 10 Mar 2025 09:41:08 +0800
Subject: [PATCH 35/62] fix sentence error
---
.../0054.\346\233\277\346\215\242\346\225\260\345\255\227.md" | 2 +-
1 file changed, 1 insertion(+), 1 deletion(-)
diff --git "a/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md" "b/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
index f788d65ba7..16b45e85a8 100644
--- "a/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
+++ "b/problems/kamacoder/0054.\346\233\277\346\215\242\346\225\260\345\255\227.md"
@@ -39,7 +39,7 @@
从前向后填充就是O(n^2)的算法了，因为每次添加元素都要将添加元素之后的所有元素整体向后移动。
-**其实很多数组填充类的问题，其做法都是先预先给数组扩容带填充后的大小，然后在从后向前进行操作。**
+**其实很多数组填充类的问题，其做法都是先预先给数组扩容到填充后的大小，然后在从后向前进行操作。**
这么做有两个好处：
From 1378685575df9a8ff76bd1cb56ecb731b00739eb Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?=E2=80=98windscape=E2=80=99?= <2462269317@qq.com>
Date: Mon, 10 Mar 2025 20:32:41 +0800
Subject: [PATCH 36/62] =?UTF-8?q?0126.=E9=AA=91=E5=A3=AB=E7=9A=84=E6=94=BB?=
=?UTF-8?q?=E5=87=BBastar.md=E6=B7=BB=E5=8A=A0Java=E7=89=88=E6=9C=AC?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit
---
...7\232\204\346\224\273\345\207\273astar.md" | 81 ++++++++++++++++++-
1 file changed, 80 insertions(+), 1 deletion(-)
diff --git "a/problems/kamacoder/0126.\351\252\221\345\243\253\347\232\204\346\224\273\345\207\273astar.md" "b/problems/kamacoder/0126.\351\252\221\345\243\253\347\232\204\346\224\273\345\207\273astar.md"
index 8ad3264433..d3aa8a114a 100644
--- "a/problems/kamacoder/0126.\351\252\221\345\243\253\347\232\204\346\224\273\345\207\273astar.md"
+++ "b/problems/kamacoder/0126.\351\252\221\345\243\253\347\232\204\346\224\273\345\207\273astar.md"
@@ -335,6 +335,86 @@ IDA * 算法 对这一空间增长问题进行了优化，关于 IDA * 算法，
### Java
+```java
+import java.util.PriorityQueue;
+import java.util.Scanner;
+
+class Knight implements Comparable {
+ int x, y;
+ int g, h, f;
+
+ public Knight(int x, int y, int g, int h, int f) {
+ this.x = x;
+ this.y = y;
+ this.g = g;
+ this.h = h;
+ this.f = f;
+ }
+
+ @Override
+ public int compareTo(Knight k) {
+ return Integer.compare(this.f, k.f);
+ }
+}
+
+public class Main {
+ static int[][] moves = new int[1001][1001];
+ static int[][] dir = { {-2, -1}, {-2, 1}, {-1, 2}, {1, 2}, {2, 1}, {2, -1}, {1, -2}, {-1, -2} };
+ static int b1, b2;
+
+ static int Heuristic(Knight k) {
+ return (k.x - b1) * (k.x - b1) + (k.y - b2) * (k.y - b2);
+ }
+
+ static void astar(Knight k) {
+ PriorityQueue que = new PriorityQueue<>();
+ que.add(k);
+ while (!que.isEmpty()) {
+ Knight cur = que.poll();
+ if (cur.x == b1 && cur.y == b2) {
+ break;
+ }
+ for (int i = 0; i < 8; i++) {
+ int nextX = cur.x + dir[i][0];
+ int nextY = cur.y + dir[i][1];
+ if (nextX < 1 || nextX > 1000 || nextY < 1 || nextY > 1000) {
+ continue;
+ }
+ if (moves[nextX][nextY] == 0) {
+ moves[nextX][nextY] = moves[cur.x][cur.y] + 1;
+ Knight next = new Knight(nextX, nextY, cur.g + 5, Heuristic(new Knight(nextX, nextY, 0, 0, 0)), 0);
+ next.f = next.g + next.h;
+ que.add(next);
+ }
+ }
+ }
+ }
+
+ public static void main(String[] args) {
+ Scanner scanner = new Scanner(System.in);
+ int n = scanner.nextInt();
+ while (n-- > 0) {
+ int a1 = scanner.nextInt();
+ int a2 = scanner.nextInt();
+ b1 = scanner.nextInt();
+ b2 = scanner.nextInt();
+ for (int i = 0; i < 1001; i++) {
+ for (int j = 0; j < 1001; j++) {
+ moves[i][j] = 0;
+ }
+ }
+ Knight start = new Knight(a1, a2, 0, Heuristic(new Knight(a1, a2, 0, 0, 0)), 0);
+ start.f = start.g + start.h;
+ astar(start);
+ System.out.println(moves[b1][b2]);
+ }
+ scanner.close();
+ }
+}
+```
+
+
+
### Python
```Python
@@ -683,4 +763,3 @@ int main() {
-
From 82c7f09b00ca0cd030f9776229b3a30df1ff5bb0 Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Wed, 12 Mar 2025 10:51:49 +0800
Subject: [PATCH 37/62] Update
---
...46\211\200\346\234\211\350\267\257\345\276\204.md" | 6 +++---
...46\263\242\351\202\243\345\245\221\346\225\260.md" | 2 +-
...46\260\264\346\265\201\351\227\256\351\242\230.md" | 11 ++++++-----
...46\234\200\345\244\247\345\262\233\345\261\277.md" | 2 +-
problems/pics/test | 0
5 files changed, 11 insertions(+), 10 deletions(-)
create mode 100644 problems/pics/test
diff --git "a/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md" "b/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
index 2d9292bc49..fdaa87f896 100644
--- "a/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
+++ "b/problems/0257.\344\272\214\345\217\211\346\240\221\347\232\204\346\211\200\346\234\211\350\267\257\345\276\204.md"
@@ -69,15 +69,15 @@ if (cur->left == NULL && cur->right == NULL) {
再来看一下终止处理的逻辑。
-这里使用vector 结构path来记录路径，所以要把vector 结构的path转为string格式，再把这个string 放进 result里。
+这里使用`vector` 结构path来记录路径，所以要把`vector` 结构的path转为string格式，再把这个string 放进 result里。
-**那么为什么使用了vector 结构来记录路径呢？** 因为在下面处理单层递归逻辑的时候，要做回溯，使用vector方便来做回溯。
+**那么为什么使用了`vector` 结构来记录路径呢？** 因为在下面处理单层递归逻辑的时候，要做回溯，使用vector方便来做回溯。
可能有的同学问了，我看有些人的代码也没有回溯啊。
**其实是有回溯的，只不过隐藏在函数调用时的参数赋值里**，下文我还会提到。
-这里我们先使用vector结构的path容器来记录路径，那么终止处理逻辑如下：
+这里我们先使用`vector`结构的path容器来记录路径，那么终止处理逻辑如下：
```CPP
if (cur->left == NULL && cur->right == NULL) { // 遇到叶子节点
diff --git "a/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md" "b/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md"
index 1c4127fcd2..ac173dbddc 100644
--- "a/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md"
+++ "b/problems/0509.\346\226\220\346\263\242\351\202\243\345\245\221\346\225\260.md"
@@ -151,7 +151,7 @@ public:
* 时间复杂度：O(2^n)
* 空间复杂度：O(n)，算上了编程语言中实现递归的系统栈所占空间
-这个递归的时间复杂度大家画一下树形图就知道了，如果不清晰的同学，可以看这篇：[通过一道面试题目，讲一讲递归算法的时间复杂度！](https://programmercarl.com/前序/通过一道面试题目，讲一讲递归算法的时间复杂度！.html)
+这个递归的时间复杂度大家画一下树形图就知道了，如果不清晰的同学，可以看这篇：[通过一道面试题目，讲一讲递归算法的时间复杂度！](./前序/递归算法的时间复杂度.md)
## 总结
diff --git "a/problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md" "b/problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md"
index 3066c99f28..31f5f1d9d4 100644
--- "a/problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md"
+++ "b/problems/kamacoder/0103.\346\260\264\346\265\201\351\227\256\351\242\230.md"
@@ -162,16 +162,17 @@ int main() {
同样从第二组边界的边上节点 逆流而上，将遍历过的节点也标记上。
-然后**两方都标记过的节点就是既可以流太平洋也可以流大西洋的节点**。
+然后**两方都标记过的节点就是既可以流向第一组边界也可以流向第二组边界的节点**。
-从第一组边界边上节点出发，如图：
+从第一组边界边上节点出发，如图： （图中并没有把所有遍历的方向都画出来，只画关键部分）
-
+
+从第二组边界上节点出发，如图： （图中并没有把所有遍历的方向都画出来，只画关键部分）
-从第二组边界上节点出发，如图：
+
-
+最后，我们得到两个方向交界的这些节点，就是我们最后要求的节点。
按照这样的逻辑，就可以写出如下遍历代码：（详细注释）
diff --git "a/problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md" "b/problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md"
index ffb6cae34d..5f091779d1 100644
--- "a/problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md"
+++ "b/problems/kamacoder/0104.\345\273\272\351\200\240\346\234\200\345\244\247\345\262\233\345\261\277.md"
@@ -72,7 +72,7 @@
-第一步，则遍历题目，并将岛屿到编号和面积上的统计，过程如图所示：
+第一步，则遍历地图，并将岛屿的编号和面积都统计好，过程如图所示：
diff --git a/problems/pics/test b/problems/pics/test
new file mode 100644
index 0000000000..e69de29bb2
From 1cfdefa3fd34abd401f9a9edc5da267b4de8ce25 Mon Sep 17 00:00:00 2001
From: programmercarl <826123027@qq.com>
Date: Wed, 12 Mar 2025 11:17:46 +0800
Subject: [PATCH 38/62] Update
---
.../\351\230\277\351\207\214\344\272\221.png" | Bin 341267 -> 0 bytes
problems/{pics => images}/test | 0
2 files changed, 0 insertions(+), 0 deletions(-)
delete mode 100644 "pics/\351\230\277\351\207\214\344\272\221.png"
rename problems/{pics => images}/test (100%)
diff --git "a/pics/\351\230\277\351\207\214\344\272\221.png" "b/pics/\351\230\277\351\207\214\344\272\221.png"
deleted file mode 100644
index 79f41d6beb9983c5945aec7cfd65bb98e1e448d6..0000000000000000000000000000000000000000
GIT binary patch
literal 0
HcmV?d00001
literal 341267
zcmeFZbyQUEzb{USAc{yzqm+c8qzoYbeF_{(mm4M(%sFF(%lR*b2sPy
z&iQ`u{MNc>-GA@bwT9Ww9v=2Q`~AG%?^iq%^hR0c!99w5XlQ5;*w{=WKZlkrx$yuD1B4%@EP2bqW?b0DA@p$Gu=6uC;;esXXQ$7&sT6I)>A<8^NQ2DR)8eO)$kVU9BD`TzTUZRfXu{1{SDt>a
zJAy(&u-{8u0di8JU7fr?
zAqyG^I}-EGheiU2r>l=HFV!`K$VxHG6T}yA6CsyzgF8)^gH%U@>t+v2Kv4820rJG9
zLdX+T84pVD=s5O^)l`c#Q7`?9=4BhjLLY=M>jTBAt%a##Vg5uUOz!JeEvBzpdrucb
zg|H>-8~gW&MN#}W+D}Az?v=8v+FKYZmP@B4GUBd_f2+F#VPaWjwEV+C%+gB8BQn{W
z^Scw@AwH#dxUXoX_wIz|bQP;(%qt2MfBVygAE?Rp<=@0z8fY&pqZkCROZkj3rEFiv
z&S00Zk~)6Gwps0Q)x745oPKH{88{;vpUU_!VsfhYh~&%VhpZ2{oYHM^{>#5*!Ct=%
zFpy%`(vjOzYRV%&Xrn%Op1k9Dt!n-q?{n3DTW|;VY3fg*g7)piw{t7JQ`X~@vpWxnGFS?-&lgnMHL!
zDUoUsUok}@zgW{@a8UFwhQ|6mVyS2H{cym{@aWC`emwHWBz{kGQ9PNNMh0RN&E~_+
zq521p9Yg{#+zzT7-o-naR~R4QSTdmA8lZjb|Dwcurb2z!GM$%V?T1nPzz@ckp^xQ5
z8NLxwey6uG&{~$+$apm?Q(^vE`?KfVc
zh4LFYO>i#lqNkn8aNx!sJ*~jkHo!Ts_<_0q?BhH9LO;yDE^1dyAA&5sH22*p{y
zV{Nm4gX`dDe@=Wy^X$&rJMy;=Cj6A%u}$Hg`67OxQ(mrB=@
z)mILr7BaR^&Z9V18IRE0-%wckCjE5YcorMxF!YS)5hTzwtTIu5(w&gU!
z;i)pvpVS-NXdci{etHF5>O#7a#Z^lej%kt1koq#
zfmVY>n(*H-_UMMbgB@fm+XoO=;e}wMmi-ms3o{JJJ9&Gii$|_s55HQsYP@Fo`S};b
zKGL3WK?(AeU-D^`TsiYqbKT3h?-D8E`igU6a|+f>l|;0J9&!xPFS`?o#ex|R<@__%
zMs!DPM_!JYs4;I+>x5W~J2MBwjCQFx;MRPu5AlrkOuYU&Co`NirFQ+Sg!qXG$b`j&
zGAqa-YD8``V@q{64}DD15+6)c5v?mDEY~36m6erclC@UAtE`aDt6iXGl{P_M1lQfS
zxZ+`^NQhTfABi7w9!j#PGKX$B)lv(8PnG7(Wq-g&?|mNdCAjsl^26@iF=AV`g#)wj`zpW~z9&cufn<7rrkv
z5?&H2ZN_aD-!#9;+!y@*cr?8G57heK%W*-
zN*>2&d6_$!AyVgF^QXqvv0*oRpRc3ncTx9lR$WY8b3+dz|L#2f+{bX4j7~fiGnJ@y
z>A_^f`_K|Ym`8=H*U{NwyvL-Q%jMLC@kQZzO$*<<&Jwb+!3#o93D5NlnlrEc^`c6SihK}t8y}jc*nMe}?(Ol4m_%HCU7p@)$
zMB((z0cFX@Lce(>X&hdxKA(&b44I`0_Lu$|?_cS^8NldYgjYvqOOi@$NV!0?MDmh8
zT_Bo(oTNtR2zxM;d2#%}z2hP@kvE$+m^6-{f@4d(T)kYV)`A`6+&2~XasT&JhwMj+
z58~{c&L%taui(|6tBpDyb+(5UP@KP7cNhfOLrT5r{&dOj;Ql`8b<*2Mhx5ezJJM&kix57WU=h+%~5Lc4$pi!n&
zh%pz7-AGh7DCRQep)moM8ke()=W6Fs!DT~Yecx%KFh=pau*Jj|Z>!~}81E4j5eRqR
z>(Y%nT1r}!k8D0?e_W;V
z%QP+<`MN$GE!OR42W)Q*hUg=r?X>BFgMvF=V_qD3i*Nq8R(5N8_A57kV}5Kk?{4;{
zQjBuli+PKy^i7rEwh*5bzd?dN^F#{)$Avz4*{ib3K50|40o%ln!e%Wg12vBvT?R4+
zdLidlK~~+t(UZsOfB2uj(0k$1(zgG!vEcbQM_j_f#R3Yhgm>s4?QatzL|SBUQlt3R
zxp=OkKK**-L(8(GXf@)^r35OvkkLk=A;DH(TA#_l*~@L{2*P%vMGSSVcG&5;(k#?8
zDKLbl)?Zoso3&^2j`8;JQpXL)g<085aOlB5L0so6@+0#bwv{G1by3b=?AzADS}3>q
z5^Y#vC-2LQkNclL(%UN7&1b75tRl7Xs(V{0PTGct{>^GJ(JE?qxD9pz<^fj!(n?=?dMZJ42Hm{Jmi05~w?rwQkBHR$-
z9WABqncnVRDqpI9X1uH@K@5GDc&>z0y6Z!J*&E&#A5akfm`2Av*4?RP82Pci(>>Xw
zf4;LULex5O&H?`Wf=FAhv!W6b3Ud3Sagj%qBajmT!F}a;Q3#usSf5&_81P7gHZ6je
z7NLesG}gzq1x*`{C5O@bS=nd9yE2@24Me;dPkQnS>I>GP?fOaiE4Fc?Q`39;ZcwACP8FlRa@Ok7h(ubM#CTk+=qjMY5Mkz2nZg{
zD6O_oiL2W27-Dm&_@G$9NAV)#IB`eE$YnFl-KW@R@8Ej9=`*T!h`TZ8*#BAz)!PmY
zHQIIEy{ygRFFs#LzUKF`>s=skn!QX#AWs5fAF5nsdoy?yUawx{Z90yv3nDHN2(HEy
z(E}FWmT#se=m!pW(M~ijcI|O#h?sH*JuyG$4(4HEA&CkG{V|sxG>5-Ki~fT_@SsVR
zuhkSU5!+)t$Nj?#F=3%^Nz%kRG<%jtJg&=6>bLiOOt8`NaD7#dkjTad2t?Wl{tONCKVAp$N`M6#*8le&W#IYdUnKCj`JMm$
zjPV2GKi`3a@dNWek1^SA-fE8h*a~>UwU^a#L_;HGym_F@sWBX&p^2f%Ns4Q@qVLS#
ztyfv2Z9d$mKI;jTm1aSNaHVT}-BBgxl9xP_zejE&sTEwxsxzHc$|&fuud0>X*JXH)
z@*D(v4_t-`R##6Vgc^!r0)uV??x=x%m$gd~81u%-=IHy^;%Mkt1Y-Y(AAWVO=`M<^
z@oX{v2X98lVn@e7cP02gjtY!b9fE~}RUNXRXnW^>GBPkM_P>Yye`^xx&Ty_hPI7l(
z72Id~Z-i>2B|Of9ktu?XOf>VnRl#T&ICQ@M`q2#b`!SlM5@29tg8Sbh%2sl*_0o~6
z+EHe@%qw|^SCj%Ll1qu=@_nzeT;#LiFe)y2c*^Czs7{^vPh;-`@or>OXL|Wy7!Szv
zz}Iu6u*7Q8Od%nTH7u!m>qDD-8(B!t8Q7{&K`!=H&|C}$$XlQE`Z^=F@G2>1&y=jSwbgk2+i9ug
z0<_d&L4Ug5!C$||Qz!M=N#Xqz5xD6?T6-UAgC^4@jLEaYh*hVe&TnxFWSl*;di)+7
zQkXm(hSm0ZU(k5WpYCjF4)V@z`j?-Z#13KM?wy#}d*8kozu9MEbj>!u|7hHvQwZsh
z#_7ka^SZp=A=P!>q^j5=E3MuLm?v1hv(#lEmN$9KVs^nWtPJ`9qeQanS=l>C
z|4l}aU@>~LTEu(x7nP{BH}bNxK8g0Y7Ikh=>fR#6HtXx<2?wu~W|cZkD7sZD>eR7H
z8$qu&r|@yZyikR|Jhn+yMa{aS*s2^)<2jo&t0PH>9eP!W+lf5ujBA80rdCv~mAL=<
z40YmkX9!yO{Er^te+C8`Mu~=)V7yrbt%tgH0?Pk`7F{z8em;LvvV(VN)Oh`giC}Ro
zi0EjxkNhkPUM~{O9AT~7*ryJqK7l=?W|vdXJQ;K26ta*$HtR_>z%KVO`lI;Rr47<0
zQRftICLbTY7)h|NK6g^v^l0zr&l0=X%ka}}&%IOUyBHVxXe75L6bRQjQy@p$a=*%v
zxSe_fXE7+y4&};qm|g=dt(MgTrvW1s?(I^
z77bp%{wT8845tF^wxs!7?-@|rd(AIPiOd3#$mro>eV!L#E7d9)#He0rJv<+F_TR3=
z`Q}Ol1(+poUCDB#*qb+R3akBk6FB7dfAltj6wBWmYE6H`7;F?2D>Q@
z!YaHCba+wPgD;(yw&K`|PrJ0r8=MIu5cN$e>OS;~UKI1+?w$5UUZTsTT_UZZiA9s}
zGLx!5UQHyUXcu+QeQ1JWn2sl7L7aY`QihQZ6$=OX4PFJC`-7fv<&MO^O4J8`G(WVG
zWt+vPw@&!Y(jQEz-&ut}7fc721`Cw-LH&yb`G(5v9Wi&L^eChBh5@zU#r>5)1qZh^BwnCg7HT^*unKbj_NA>PJn@?xGQ
zSM3XxTDBaK`SF8s<`?J`NcrrYX_L96FeKmnSuKzyu2Q(=xG>N?-&|_|`R)me&MB{`
zo^9jSP^xe=gPQ}9uj76{Z7BWib%Zm=i-CnP$7{#P|M_2u7dZM|-<+tPqc4u;{_TDu
zG=f7p^2N_MlICfaCXelS987ecEL6vuf&m%)P4QeY*oUo-&o)vO;oh5`CkmgXS_3sq
z9Ae(>QfX_7$6Ftiaucmvl89K3&THB)(=MV5tOz0P=_~n|DH)f4q}V-@YBS)^$erE$
zIW7A;{*vX9#_)2KsgnI3C1pHH*nMoB3kU1qNzE=vT7?ZgWjsezeps@6*qou1e#
z1jVZ-x66ju4iOyz-B|;({-awb2&}O1_ojCppKn40M6xYm-Pt7)R=dV(pU9!&4(ny+bnUYx&F^-kmw-;+yFW*sZ0w{y9EVaXhPr%0Jf
zc-fIeE+*$7FJv>=Vt|
zza`UXRS8hS>RxiKU)oKEUphE>my^5@@9ji*zl
zk$h4GwnszaK(*~O-zAFcKv7+c5@G$=J=ImA5oF36$p-Hh`{97H{0y9&5I!him30J7
z63KXCqJLoh@$@MgBzUQ%lO`fJs6r`i4I$`KJ9FpG9l7BIHiaXNJpI#>_iG{eyT&7n
zoJ9)L=gW8_{fc=}&(|}CYs(*{o!D21f|tKq8`Vu{cHX;nM}5VviE+Zys`?G+|Is#}
zVI1ncGfx=cDplbmhr9VC3VU0Ng?=$be%eo`Mh!T?Fm+N2N(G}s(X7boFwwb825DYE
z+}?iQ9!ib-Ef*v2_kq)Wf?f~DiE8&5hyKqG#&vh+42$F(aq)2vttatOFw_2n!dX1Z
zcqCKOe6tQ~QYhM|yz6ad`sR`8vJd^wt+_K+8gkr+!cV72u?S3QI=qYY+&`lc+oSgD
zGF5}pC&nJB-Wgv^CTT)0ThdTbv4dwSUB*jpuRl5h(K|R;foc1KE@A&%n1^r0WS&}~
z`5Ii+kG|%E>c5B98a~`ZwpFCQl2emQWC|UI-Np8Sd&%4;OX-;?%p2OrLrY_jY7TBsrAB|RPT9dn(#<%;BIx#NSusv9%b6A1RRbQgPc5U>mirF?z3<;ghH@N4F
ztzpUQ`q6GOR?UtaNYg!~Dx;!L+U?aK?dY==!}-?baZw)OYpO(y_`dIZ7EnADVs|a)!n)K}VUwit
z=$BSn+LQ)0?rZtxwdWi0K;Xy%g*l^6@9S<=k-=^mqR$7_o#cPKmKdGoRXMNNZUjH;
z_I0*N2M0nZ`7X*~<(`SQiLBo5a^J3N-?;Nx(1ql{vBN@9
z%Z}3}?;%dqFFV{t5Rk>HL~i4?`kG=TV@&%`zitQ3Zx5jSFC*yD{uwbiznT5U&a)FD
zWFlf*ST*g#RwpiDvy+}mjVZj^(F_WvQ5#*}yF)Id`xfXCp;q9~59;10kLJ%Qyl&4hiRI-;L*w<&FRVs5i8C(=~j!VdNVnH+>%>GdHDarO&
z92a!_q}!5U{G)jtkZgK6W0iIo3S(2dJHFT|K;Ai#ShpA8fvG{azMSaea>T
zQagNdK87a}cCEp)Kdg|?W4UbB8>UG;*PwUecA!nFgb?V!L?1{2vAle_+q^(ME9GM=
z<;DY3=l7g4W>J%^QvJAAheWI<)6B1KjTaPuEYhp*5|U_NjX8{2^9yjOuG}OhN^6|$
z(ad3MH_Cf@6{>!#egjGJ4SF{AqQLD|e>qWX&+MLDG7{5s?<(SXa+XJ%d#ZAGm?=-i
zfY}~<1j(~S{Zn?)_u-rDWz3=AV%^^LK}g&tEX-ltioh2e6N{BPz?(h|!DC>^14-d0
z!a9h?Wq921AuLX{*~9XS*m^dywt0fLpcv}<{CT3lyfH_hP+Y^L?V-13PO57Im~vBi
z^KO$L%U$G!1VsWn69w@iyOFasr%e9|#sHypsY?B&x1bqG@2!ps$bb62V!p0OG<*0z
zPXHOEXDpYoLbu|q#!cxxO0z1W@ajR+^TTPwA5$SBVBN#jvca0I3ZhXDnv?03&dX3%
zpJHpbN$&-=ZuP9A;$ZuELHicl6m}DNkC#1Azi^T@%sHtC{2Y1|2e!&U9e8B(u$rEd
z9UY26mzXie)SK(HEK8&NH0J9q1s&d
zk;!m8TFu`*tb!)0j!hfx$61H%{!C7s>K->}N5rs4Fv)WB)am3lY@=#Fp7veuAa
zgOZVgMjjJL+g+b+|KY{!1;oj*Zvx_GL9N&17|a@3&Ai^K#GBKhB&1ljw1Z|go*P<>
z6a_R`Htfw*t1{tJY~&Y=aIJuY+pD*_q
z^c|FOf<8Hxc-XxtaGYMAEK+wGEVONz%;V-j4s!8hkd5uqq)pZ)WR_z!knv`g5ZPfM
zYCM6|evH9QLyG%hUShvt^b#_r#%ZC??R
z7YCFZI92|qst6PN9Q@RGzVre3J!4U@9*C>Ty2|Ck`c*264oKNK+{#yq=wpE&L0SW<
zSmj0dd6<^f9Q(U?{Qb(p+r0?RZ%)6(3vk`s^IO%;*SAUxXyDhrh_^{{V*xD}$8n&1
z)IAa}kP+DS7{+fC3-rjf&R+Fm;y0MNAUtl0*?#Lct`5j5d%N|fN^4T^MXfhrJpAT!
zRFWb9?ioLGF6={D1P@vSYj}3&aByhWYpg%tYph<&1;(7=`m(emtS%qF;4yX^=z+5
zZ#CwR(hgIqc0VCOLNCw)tsb?9c-t-gj%pJ*h5Nu5L7JbNqF-4MvRr(S^GV)wov%hm
ztO49j@pkUDv&3-J_IPrI)BI@n$4+CXCXta`1%7R~UQMZEo4Y`@N7XiQQi(V>#_!W~
zKmNFFew>TMde6(~lvkc_xr8Dai(#yj5x1%xoju+S4S6S*itzU53BfoO*`H_g59Y*meBj>r!X~irl
zj{Vt*#injkID0a;;E2a7fMMg|G}0A8e9AZWIq`|A%t5~${9@OSaKc5adLU14B?25t
zrWfE<`z9siRH=^i>F%0KvP+ioOM={0w>>wvTFE@I_MiJxFHs9kMoF>WFW(U~0|dvV
zezK{pxlT!;%AW^m-!%S0#lP8Z8maNw{{Gt+=ywNycbXo^Fyy~lz9SKm>&6j3*QV!Pwzal;Zhb8Mus{s6K>u)bQ3ZdSti_)2jnOa?
zK&w~6;9b7`-V1QD)EA5T5E1?&Lk`Z_$)dxB-=M!{S%~DFrLXH%hvV!&`v4&IG?P)!
zUOFK`vp4jkJD&|h+n?vrShz$W{+jp-gY@4)2H@K0XP*e=lAnB0@zO7RT;;6Z+&iJV
zHGcfZ!N#XZj@zwnRHhi@!?xgumNzno3`K*TY%mEKI(C*fr7m3D()VXeba9>*XKR&WfEPd(zcK7S~0N0N}cL0lYY`CS|9esqL
zho3~}(KnGGc3jDXeSrQeQ!z|;BHNItF`;t2pzDe;#6U?UO^C(Du!tcIAtd3j+Os>;
z@!!zl4H1BBSf6`&Yho7Ze_0}-H|(Iu=>kbzm2F8jPVTul^S)B*X$!5h6ZqaNB}a-V
z^L(G|G5V;foV{$I0d+oASFfkbydTDKfh{-rEDPE2
z#FjJVvL?TFj}*IW4xjhxoRGVp$0e*D=W#RY4ah)}|IQhKW*CYO2nHAIZOLwBjswym
z)h^80s?*|1kT=_;-6Ft})-TX^>`FH&CJ`*1U?d?uCHGUEk6)ocKoZD1TU}9OS(g}T
zH04bcIIHtL=UM7SKiXOm$U5Uz>0aMmh|w{$@qv{Oo54=bVf*SX1+4gc3(pM{WiG~n
z)R{A+dY)A<=``*JHTK?kk_XExbE)v0s8ou@Q1o=J?NEwTeen#?B+
z-7I;7!>HC?oCzP<+C%X&-)`Sm9PM26;>Z0Y?m-f)cWG>&qBD=WFXW=3U3kuM>!+{`
znKeiPTbG|G@?fmwc8Z}RKmqk3&}U!3CG=L|sK(0n6jpSKt#z>&Ustyn%Ss+Jcku{D
z+ZR}Mv6-Xu(&alB2_3xJ@b)rp8-aOlt?0Jjw2}Z8n=nax7@K5^(0Q
zb#dt1>5)EE#$`O<=?0V&^jY&4VuPQE)_g9H;N`=c*b8|YPu@lP4dVZu<>tUQ+#lGE
zh5zfVnUFMC?E3lT$OcLyB3S?C(1b<5@w2&EMz;Ss2Pokx^ks(7IH<}ifZwuKt!=x*
ziJV*R3eN2@v-vsv)&9b-#uU(}R!!PTEj|uCRx@RYgTWa$qe9&TgbnB?_Vwc=JkGlQ
z#IXs11^KNH*tcJgtadBOUo}&=6nF5Kq*IR+u{AOH?8DX_iItktn7pt7otgw_MMr@4
zG5Uq-he=b&-VaFPs3AB0@9cDo6L5YowASUYrtq4RIF5r}TEYA?mdLDa_Uq9rvb+O_
zW{HjUtoh~^ElX6a#R!(QnH|nU?C%VTrDjzHLQtT)Ar+?mt5K)(zTwV9VJ>?Vw^joV?#ubre!dtW;BWz
zk}8o}#Qo-n9ix|7D379|zWbmfk@Qj^+1;Q4lfBg-k^bODeI56(v>l?M#nA(7wuP%7
zU(9EG%!YqNxYIgC?`uKJM6`$9VCpar=t<%$DYY!6Z2{w6l`C1GqxP84xs8tr0(~&5
z&Wwnc)0qESO}}x`A$SJs?DS`uleS%FOD}LPN0)z*IRFb)E#9g3aHi=YnnbKazRnMVC__WVwK2Ckps%S+7ifV$;_824b)=^2ZOlZ8x_XTVe7#(~L3Or+7!X64hJX;;VUa3Y;
zOZ@TWL=9jpRc5Py{Q{IofrC!kVg;{kW0uLK3xaZ
za9vTF{A4>WpSq5xP_TetxB3s3XGSzpJydyHGr$DUJI!>9MIq%yT0kL4f(#q{k4*v4|
z`<>Be@tUDK9u3?^oJ#67WS%9)nc9g!hOXfsMHD+Hk-uMv-8TS(`kO}?pNghh;^KShqFG2Om$5FEDnI@Lk?z6KMOH5kG>lK&H@xqdgQ#hMj
zs>i~;6WPdTQBD2B#dx?6;y7U8gi38q?>Fs4;3|~DYL&%0KmiMlzhQl*Y2t!`Y}|FO
z=NxF7e_=Cme_JMpE>PJm+t@-b5d?N}4szDxr5!>d%=gJ+1Xtb8+*s5Ov%U*4biTfg
zgaX@v683wUKS1HO_WD8X-RWny;_{QT67Y%3WK_mlw^>?Q0Y>8%)%LEH#_=Z3BsGxQ
z*u0ojqQ=e_DD6?paYk|TdR1LOeb=`s)^B8|op6)5K`^VV7v)xZ)_UY?vb%OhdVub<
zBPHN-7HT#Pd)+<*&U|-Bn68d%P9VAaTIG_5O|z(0Wj;*HoYc2l;%@ikd@VMWUm85|
zHPD}QPf#86yVLlieAu&CUGnQ~ip
zt@gSp@gi0Ow=4Xds-LI7QDlzN)zys(QG>5!0sFKunXL}8q(3A>o@Bu2(3CD=E=Lj3
zfDDuR@vd$z>}T1v#|?TuLDh5FcAFnF<p%op=>ec=AqC
zFTMyJ8PjNcNwR@_JR6^KRwr#Bi{Pg&
ztQ>gWNz2owoO20`1q~bShsA2~a
z#6o6wj6ziuOzz8of#;s~>;`X#B!RD&2wc;vcP!Tg0*4m~7KNfe{Og%OT!9;I+2wA3QWuL?42xD6Ba5!=)Bth;BCH$vMi7h*VoDpcP%d&BY-UYrt
zCY5@O^ULXsom*H!bF!p1f`<8qm>U<+p5WAB2Y{{}L}J_VPd~H4w+O<15&OCjW!2#<
zZvz1!zk;_?+>Uw@xP2aZ#oNjZZ$6&j(0wNQ0Hqt>m%;&h?(gE(sPA^^+UL5z^$gl%
zNC!<30dw{2+R3!tGnK#B-y!~2gap#wq?U;D#JbyN3jG^d>Ltt2K6qTpOiD(Hp9PUl
z{(fE|l}(QWR98DgBjPHitDXOh_5tmtT*AI3L5OzwsL^`HAVA}R=WYja=>*{7eQA~BQJ<@565*fW`&U1xmmieU)qiz0Z5g#tTUnlAIh@HZQ9Rd(#Lbp4Ua5n
zghjg#La&nWjKpGgcYC5M&`{W5*RsljEkancS#!PNrt0Zbxkd@8mzJMr3zm8xwz|bU
z_>gQa?JH-%Hg+1jFne^>t!jp-%@)%tkBx1O4=Lo{wQpRVo7AH3XryLEQ*gRL#$WoSztGY
zw5L|21(m1<)PyH(-dbF50%Bnsphj2El_=@GY_InevyA*q98G%x+Xlim#3l}CVZv+@
zhzp?WfH+gQKOI6gAOitNkG3I)!O#M2M;PzB~EXY#joE_DOo%!ZQ{=J
zHR2;WLlXcq!$a3VnlQ?q8|UOgj5p2{6DwtQ_=OhWrCfUa!eV5FDR6gsGpF%bG1%3^Q^)p)1U_d-HCkMKS7my;W0dyo$&;UIS*k<@-T=!k
z`NiQn?pi8X`l6vo9IYbNU5&zN?5b3dGqLYWPA$E7?rBDFft#C^AdtND*>Y
zL@qQ9YPw{w>Ck#<0CoiTj5^o|g6Cqhz?QZnmnoL9?xzk4dOM5)+3X@O;
zx#xhbVYMXZ-o?DitV@xRwq=E-jh77EhM0^^>8^XL9AtH?VS3G>dr5DygaL(v
zv}8tC*p-zir6eIk?D4)5Ka?LyO;YMs%y4n|v1X|C8nTK+NqJLeOLg^hN569y6@dLQ
z!{t7Im$3L{mSN+7_ADPZ`Rl&Gs%5r}!R+UU)=@v2Txzzii}bru4q^pgKQ6@m^5E+6
z|JH`sm8bp(imNhM>_9SZR~j+>!{{BjkCDJ(7;Ds&#^BGU5xWzCjg(miG_*L$AR-S8
z^no-%Ha)Fkr^8)X#i%Z<{zDDb#mbc^={gVOGhpwDhEPuGLF|elPv2fzTudHWB)dE{
ze{{&SyJ2yn>bmay`#IFktH^>o@#yr;rQ2_Ni~0QyZp;(&kr#`BtJ`LEjbrb-v{mgMl>R6@f0qLy>2q-p6sqJ@NhOIe0fDc|{0W4`2!V9^Tfp+ST%f$+7tn
z+t3q>qt&BW+@x2ZR)1|@ow`kz&LBKrJ)*DnOBf@LY!9DBeo3S_%T3E)$1UqYNzWtdvCDz#Bn^}jp|0dRu%XK
zkMKn&0^M`FoHJSl9Dtsm(Rf^q6;X{h-e#?LE&Q}D2^|J?vpJ3Q&^QMXSM_P!KU5&=
z#^jjlVuLbc&y$JdVvt7`7=}D@IJ@EkBsQkE?{s%A&dvjWby8jp9BRJ
z_ooB01ttCMP40P4DWl?@e8=L@%kl^+0Vi3)Bp9!Ajk$E#-9*%m7+OClV>0zb_eJvj
zUSFR2NWM!G;N;HsUGXZ8UP{*m=&X|c_tA|Z3>
zPqPrwM-_PGyFq52sF(UV&!2hud=smCdkO-#s=&NI-oeDO%*|+RkO_3J8du!{9r2`>
z_GbcxvRqYC$#$BrAAgAxTo(Sug_L?YFOiVPUQF;Xm5aKByv&rFzJ@lw6OWkZ3n>vO
zS+5slsf~HJbj>N^z7yY=&6VOtgv)UGo)7Y{E>j*dL4xyxzBK@hc*EMD3G*NubPu^_
zvN{NZ<`7K$@Q>+?kXw^+be#csst{ha@nYA$IhkM&wb=r1Be2u;jqzuiYwgW?w(I0)_hn;?h__eh@YS1lMdr+KDekpN5a=u_B*<(
zggxF)i}K*GYPaMFPlD^nZVdS#gN`s#>gTk%<}YHfCC!J!k7@@+S1j{&9-TCta|ljC
zt3EqD?TP=P&VFLKFa|2#gQ|x}Y8{bs5Wc7L-7_klpe&{<1l+C3o4O({)Vi3x*}KS5
z^&HrC7FX7JAzbgx3g7~b1~!!Z@}_-$aVe8%Q@VOxViIymWhklzP?LIoN+wnl(Odm`
zcdqe!;rj1yys(3LCv_@mEl){|qFdKkFRahCf5LJWq`XAEs^Zv_&dN^7hjy>rhTf$C
zQcSROrA!vUAB!(=XuTTA{-{+P)AvxA*g~+br8Uim@WHpPOJkaD<6_Z4$HC-K^z&q~
z(z|OxuLrTOMTS}4^Weybm|_j3r@8e9e@Mtth>s0Wa*iR+8=cZj)rNeQ4dWGKcr#4*
z{f?+o)cIXc3t<(%nfcNytf1AA0@|MOltH=HAZkX}MJtEHFyw^!d1M%qdcfu!zQT76
zhNw$9TZ|=TS~6Vxs1VJ%o^k6-M)rP$ALnlUOF`rYC~&
zvY+!BRy}8R9_hKBy+i*OqVSvLB)CBRwnJ6eOaB)|>-y%X>a
zRygrcBgdlrWUM!zDSbM5V$v6_Da~%M84W?LJme}pXCB!PNMk7a$WxwO4{LNT+5nrc
zw~%tv*1F`)Hhvk*U71r6rN1JIkrM3B=d=9-T0I%2FT@XcO5((mWS96J6aj44p&v|W
zSjaoJ-`M8(#Qqa0BM+mD8=u>0Uf)0)oRvqc?4^a)qImT6hRaU;$}pYqZ&NJF6?ZWPIb+#%xS
z@g$xq>HGV$HEl_3*FZ(g8nfbMkSW$b0yYq7Y5B9((2(?NJ&N1MXqec{km>gN1JC=>
z&9uZ$;rh#Fm*R3~om`9J?1~zs1x2^#ITXs05r(+oZ`)r
z0pNH$uy(P9k2>{P%6;#u8dcur^_3OWt18sB0MneO9(;kBsmvAw`>x1`_JoHWD>kO}
z3if0Z1)M`k%HLF|y88A5Qfg7(qczJ$TVX4KzT<55K=U3H#bw$Hab=ae_c4Yjhs@M`
zQr2?GsYP=g@3Ixh!#M+jO+`MDLc+y!Qi9BN@ob>tY_$CDdOT=Qu@bVP`%fsSDu%E)
z&A)}?tqDynxbqW*bkpY2x4d4BkDLIgR+q6seGd;}G9InjMUslFE5<<6QC>Kh5_U91`;l493pc6o%ue
zg_t*eUvOsB#;u8DDr5LQWXQ0Suit%HufJK}wa$YpQyIB9U$81Kg7UfhY0rK$ZeU>i
zvEGEQf8+xu*%np82i2+X|9H+Orapgffe?~01%2)68He}5xD_KMFNiVg*5ql39#asr
zzwh?K6nQF0I{Od$wR-eMbJ}$AJ^q&y_ASPY+nX)qiRs>95X~c{^+Jdd2n55&GC!1~
zwc2x3p@;h4xTD55M1OgxF#g)qU2h5}9t8I6X?yJYjz)9a8RGJx4y+Pln8WoP`)28V
zcdztL^C7BAb?5ffhBA+B^&7`RTai=D?_LXvGd;Wp9^t!f+qrK58Yr0NDg4LFuCL`L)aXRjk7H$TeL1*AmXW`
zIX*Jo+>_0j0Owuyvc8n9B-?9lZZF^YVWBMG3j+T4cLDq~sz>j>34
zV`cj@5Ve;bb0x~151$?}DI7S7=ZuSSHo9M$t^X@I4X_M&E{MKBH-+h-4M%eH))1U=2Uo_wVDKmCC7e+jl&7!UpYzkwW;G
zK~g@GmiE5^m*?8b%N4KBXil{$=lNRkGD>0tIZSBJ()Yz0v>sqQQ_V`^)eQ8ahStx&
znMp2uVtEB@z)a_vK}?A*QD1^*EBQw)ziVu(K9dmLvcB`@RdS_UMRY|z%@Eo1Qf!ZK~D`ZQW&~
zZ0@IG2Eo5sLpYzXG3nG{K`wgTl@1(La1}g-rzF@o$2WHK>Z0pn^_6I8JjqJ!AXxkQ
ztO;oaEbrx@Cc$#iBcSl(2uY*ygkOtqYTnufmVrjrB2T#)oQ81(&Lu6PBDZ~LL!D$O
z{$YL~xcO3rKq))yg#X&=^V7rUJ(273#$aQ
z4nb6kjqRxeIydULHBVH>QNjxJ!E9JH7z8Sl^-q9|yYxF;PQqgM73H0kR-lkf-5WAM
zaH1&g%t(5l_8jsoiAh&*dZ%GZO^&y=k^)nIpaOw_v`!dj*%aG?CfM`
z&$ZT^YhH6+S71Fdr5l&eVLZ>=Eq6Rvb=k&lyo3N&||sXV|(xE5q5HSmt=@F}Ws=%B+8`nvRDe8zVrVV!kF^}Js;8~7sY
z+~{F@zuW0mgCqSiM+nzF!aST3;ozZxFWFHO>{iZ@Uh9Z|0G{=suXXV|_Qh#!`SHF9c
zipq&(x%C6xFd?e+uAu?d)clIm*nx*ZKIdg{Im6XRv2YaTzorckYSID)qzSGRnADhsVI0go!9^mlW~`XIU0Qp&0pqM`K*u
z^V^H==V5;~yzm2cI0Ke~f0o7U{lKgVNy5~uIDzCLPk>)F_beqp%a2T*lAUlaUx}s$
z(Tm1{(Lcu1a{bOfqJ56D|y4M(StRt
z2$uPqwKDL9$1$>ZEapT~QV(g-XsD#(z3D!wqYkuopn2_%ssE
zDq`xWVXpi@Wptxv&RpT7RMDrd2BEE1;>Z0l>eCw^KFN-o-y7
zhGkBT?ib^v`yEjfTU@`~USoNZue7LtDCCqrRO#8?HCxpjF)h?(FLyN_sq~>oJsAN@
zSiS=1^m(R>x)@6Jr7EdxZmusd_33xdz+_7$=aRqha7|yq*L$V8bq7ig$e?E1^kkh6
zLfwnzXM`-f-U?Z~k4|>maoa@D2-y^4XKVciDhsuQ)%xt`J(2ucAKkRuDrjM(8E7fK
z0zc8tl|l&X9oHz9J@l^Gcr@H^yY@F$$Y#dfS59`^JY%)3d5#LNwzSw#>@Wwb6Es
zxNcn!*44Yo@K>V_&&F?P}T0VW`9PM`;X)`GCK=fp;CKRsa6io}|FN1NbF
z3`z$w8}&^k`Qj4VGCj#$3;8>S-`oz9e{)T?RKx-9cYE^HN5WbpSKkkjla5=Bmro!(
zVrYGCp4JFkae{5_CkU$9)R=S#)gx7@eu35WPquRqj<%UePesPyq=|mJ3i?B;((_8_
zrz4oHn~ZoN&-LR{*>t8C-{IPv*9=PJXf{|z4n5OHd~iSp_7QLW&@TIu9%kgGS2Ky#
z2HF+?1r=Ogp4#QvyxxX&j3b8dr9$iIpPkR%y@zl#RYajXA)$+?ui?ti-WiiV#l(AA
zj`|5)5zg8O>QDXjp7Y$FEhuXH3kQw#r}Z8^XweFQQo5{`yoFYs=GX6y_GHTGJxYj(
zC(-oL&pIlyyiDnG6(;q|ARQm&dcjr(S)lw^ngnD~p`QVPgO_hJ|KZLz71BwZO&E{Q
z_V!aZ%&B#Jl}R`$LTCuNW~Nv2FSpd}TmIao8JAwy`zfmZs-6vfP@kXks
zl9l2gYbAf-v*{x?Dz$abCw5(05Lh7`*(k_rcPClRI^CB9ocAeQ1sm}ln!u-42L{#g$w&#-}P7MymW$jlNJcp&l@gLa+5ZJ{c_2Y>j
z)aSH)8O|q7>9Q&PhS=1TYx9Exk?>6WLlt!Xu>PS%=+l}xpf%oK4L8p9G+xybcUl$a
zgQEbC*7j5URFb+pbDibRM&C^q0I=xZq+%J%NkEvbuiNoWzua={-v)#YNY7cs&pO>|
zlhYILCF?3`cBc#d7(oS4qn9_!G8C@&XHFEr3L6iZzEP#QKa$cqtW!m3!py?#$`I|}*!=?#6>X=bSYTlWXx>~Lm2W8cAkb4DF5QT<>m+LGv4A$Pr@
zUIxkUio~%Nt##JOI%w7U{u=Il(jGUqRgoq%GVbX(f_A5fDhbD{Z|l@$f3cU(nW~Y~
zhw!W~gl4|7YHm8G?iYU*z`P00qM~s
zjn-nw&?E3PgHI4Ct2M`5z!7@p&5-w)l}@;fl6*NNDzH7l*v|abJohIOSJG#ggrc4g
zRecEY8+Sxv?h)dD3|{BGRxKkPz~wgOd1bzWcbKRC^%1M^XStLybrn4L%JbxI?=iV|
zEkA<=W{`(=rhfnygd~{{s1_WLU(UfGfADmEMFc?Pt)H2&#&~VKJ$X_a5k);Uo;p2I
zO1hppFnua#w#~4$BKc0gC-^(OYsY@3zyjr2PE1(-NJYKKu)Jw{4ILe&2#;~iCeG8!
z_b7bbF-@JLBqdZ4t1K1MJ(h=>ej|k}CvGzyq7L;(%~-kHt#|I`#tC1*_GY#ZJ?1N3
z8DQraK6Hn!(WKX06y0N4>=&)+P^J9}6Ydwv_Locg4U(Ae5ItR3-yVM5FD3pydK4vb
z00ujF%sG~Nq1~AXeWL7Hxwd(e9~c9gMSkx2vbX}P7b>h^WE3gMI&jlYrqLfksj{a<
z<-+%idd9uyye?1dvFnTJ6VlYA^RMJp0gY4jKqvK4-atM?(uTX-G95E<%K@FSuQ_vU
zKCzJx`L@-$B9=~Z&_(h!JqRevJp>?6pgwT>H2mh5*ES=;McPoM(zV_V+nkM(kfhO7
zpl8VHw>TKJ2;MRTrMxTurH}`
zKu`~TH_CSquP_n~50oVneDf?NrjH3E0$o6s0$d-S)=-G@G~tu}{qo!w?KPWv{0XA5
zV8b9EfQx6snuDn0dD=3(Tz4ftT)iw~t6x37?x>`5Y~VsFwm8mk;XCQa6t?qL#+5ALiba$@Un!zD)lhIGTLi
zhNzyH&~3D0&bjEvR=#M1?As}*!}jY_Z#&kng}~NQ%s$SLSzHI!4atrG_{*zBb98IF5jKk!*npkY`^Wl~hZf|~;1nG@AxBxTmv$}yu|
zo6M{}Zr_J5#Q3ibIAv0JtDVeuTMm{z<$P$v>l2x7Zc(*6uS+acpUzVkX-Qoyd}Y!d
zz^?fFqkJfC58Wp#x90eWza#czf5f8Ky1_&89lqrJQtz4HINH=t?vVRKSHWQETiuP3
zyc%gcS!PMrFvIQFcxsETA@n^yh`x`pf6=tE6i&2By=-?K?dhk1Qun0Twmxpl2nc*R
z4@eP_NrgTm=FJne-?7a^4iUhvRv->WbGoS5p5#p3wTxm#{g}Aa$5z_scE&zSvy~Os#p_F8D-pWqD<^(
zMxE?yi}=AU{hS~=@DZeD*BgvY?6bPBqh6I6Ui>X9cry05Ma=|V)*5`2*~G@WrJD9n
zR=oHtI^21zuiYAw?P%*!mzRB9IeeLA5*Jc`R$W(SGy@Z3{h^n);yvo^j(6UP*r3|g
z6d~w@dF%#-?NRhj>>Dl>+x9@m2>k;z@9+zysym8CB#3%VoUo+5O+BvRR=>>jq)9ZdBZztgFGatZq>P1|Ss3hbRC
zdhxz1zrT_{{kX%(xK*sB%h1bJ3-EigFOw8(B8bTT%p^6um5_@L>-pMo!FpYW7H>!yUdvm?`s4peka0Jq^nzHK-fd|ovFa3PF$bv$W(JL+E
zht@Ds6Kl*P`hBT406+Rh{KklfewQ5$XwC2fH`uHdo1k`=mO>~@y+m&RNQ81|O8oAO(W&vv
z8Xc_beuBVA2^-V=SEz6Y{Phm&5If(Mj`H{gV*M50x+!Wlq4n9PBN9Kpd~F&TG=~h|
zuq<8oeD-$V=dgPf^QOT_vw)Xq?X==!m(zmbJ9Rv#b{X>cr{y0#p@E*aQ)JyU9)
z{=GToIJ)-wC!#4iR;TEoeB)DD4#}W9ievP;Ox?MSvecF}Jlo=#&Kt=anmttw-a4#d
zwFOxZ5yG6AsNYPSq4ZojR@e`&J9j2GCx`k!<0(ZHBErJv*F_+H?R!W3q0n
zvEzt)jSF^&v-?Vc-D0!9IHxT!EsR*|h4;BUcJ@g_)cJT!2V|&xNDpWwK|S>^WVHn#
z|H_odTW_R(ZF3Nyda(eTLRZKyufV9d=>YUTEc@gFj5f;WELeTM`t8MrkmaZoBls62
zYe@Wq*HJT^lGF9)TNQ>`sW5E&cMCtt0~INE{RRW0`HdN4m$j~~nh$UG
z{lAD6X?+H8dzGyz&maBzpZPUCAvXq^>*>0geULS7t}enFxNO>;5wrWEnH8~T<=)xjbwT>Fdptx`#dH>K!)slCGD{gVNMhSjR?{EkCuq~`LWOW~c
z*5#Z)b^q2`6B+~S!HL;?@&csa5(#c!*RJdPO^MnT)R$?#H=Tt0xWPNYPI30I+$wr|
zwtD`oA!~njX0;-lZ(9j4Vl@^%F@2S2aDl2p3^__9*{9GUZrdGo2rfk4evzT4AM5^D
zDn_)r#dyes)L+30h_9ajJ*%_1HR&kGf|S%QY{sqTW!T%h5(~17(pG85cfq6B_Z0dC
z+hVfJX2rKHHbpY!P-GMpl1nH>@L)I|KSq#4dv{W~EWkP=q3ry$1DyuvTrX#2Dt=k<
zR5QQp*8UvqzP^~%{yjc0U2svY-yI8ZBR>SB5eJD-=Ja_+;IsM3dYfrkt!Twpwmlkf
zFSjf|2K0FGct)|hxuw7V-m|G&MPFVf%j;$9BYJ)age2EIBJkNeaN&(8Fwd=&wM6nu
zcbz(@eJ!jwi<6VUgS~`W%0$OQS;cg8^X<;t_qHF?{JjK#CeF8Ce(T?Dq88r%-B=ZP
z!ef$iTZ>Q)hbAW(>}Qc`D~9B*pDznEoW|!1@5eFH7QpTe#PQnS0_K3NirVXskO#KY
zu6%WBA%*c?*&|;U!nq1pbMarZNGr@9jd)_W?v0PGPjAp{tT%)2m&0H+FB^hGr&05@
zV|(t|qT@%&czkG5W-~uoU+6xdl#qD(HN7&wK%3R3kh2&?J^C}U%0x*e=%+EDP1Py6
zIl(_YBz|0!HNNhI(iu~q0I(}Pofkf~w<)fJrmkI1;ny69eXe!F>0ACY0xU9tX}c)ANQ?WU713R9I5
zE71=5ce$h3N?v(`pY8Bu$0}~|r?{?nP5>f|DOUV3V+QFd
zK<8V^%^9SU)SV(D3K}&+S@5||7p}J~J7}vm-S52mT=J+)W0fsrY?0XC+X1OU!y-6Q
z?-=;el4Yo0kuUjlQMsF#G9*WBVssHtM0k+cKeUAJ|B5h8-ry+ddT}EqoV3h(;R{sE
z2%4WZ@ZB~z;Zzg)DKD~B%FK_+Aip@reQ1MM)*l}EX3KGtfTDCz{e(;SnSQ!BtVN+m
zLO3#r4tc&iZL{OpO`gA4A$Q=@e_G?>FftG+OMI54X?eoKlqdqU)BF}%ixpgZCpxAW
zNmuBbYQ?}8FaVOST_HKCw`bOs^od_TV1n2Tqs({+
zG>UZPG?E{-Nu@;3iDhcbtR1%ochami)DFoLz@nA_ovg<};i;OclgJ9<*9Sg$^@I%n
zi}+9OBP-9EwYhk8ZLb)f6u!4JT&OL`X!Q@x-q#SB(bv{DyfSYE?MNy=
z*DkumcqeiH!+U-<3k$MASI>_dn2CNY&%B)?CKi3QfF4FV**AeO`=*>re=3Onf(CY8xbq$%h_yrig?Tz9
zT(P#=-sKD_e7SHIjRbh`Rg#hbZBS3E7Y2^R_yNjLV09#|EAq*Jb8NxOX@FHywMIKm
z-PE7yDkLS9Q11Fj#l_O=gjzeKq)b>D89%DLe;{Rgsnxql5jKFgr=V0Q`C`BC;o;yOCAOyvR%I7(Hzhxif)$8V)&k6y!|M
zPI-9>rsMwvuuSw0ZTilK)M_CKEvr0w1BQ`nd`eP}V4R^9UyWkbDF)4YCDMNo9wd1l
zmSFaE$RZb_``r=6Y3X;mKI<2Csan}qrbZ`Q35Njf9Ft7)y4k^wpr&8V#+`u7n_pCc
zD+D}5T?2Q#P8qlBFzT~(JpZQ3e(tI_sF@W~<9SP(KygBpUXnOT;OF%5e=9k{URo+fQo9s;m#Z;edVoGYg3`PqULX-WAP8BC+1mQtI4Pw3Z<+>#&?cIcj=c6Qiz2r}Xz6M3f-3}YdhR^=D(20%
z(yn33K8;Dcp4G2=yZ~fL&TOcSzOxRW)lj@vPnWcL_wi>ZCT)&bv_xoAg7`orC?K9@
z&BHw-a|2&7X-`}c{;UCaI&CGyF=;WAJZ3o^EfT*hcNb%|+38rgKq2L{m@an__xvta
zZ5)i~JA%IS!p&^wa}{=No6+NNM)v{P1_4DRf3f(f-x$2dnnNF-*>+A!bVp>w)_V7t
zanGkoUx%^QuKqp$iSkcbyMT1@tyksCe9fczomQmU4gynl@?TCBq9E?{Zai6J^W1@JF5!4_AlDlQbItK!+2cZbj-*xjBeO{g#r8%0Tk(MzkeN9cZT^J
z_CRBe{0g65bD$m3j}uXHVFcto*F&4NETcT?gpX&qdJ6k>QJ;pc&$0L3lT+iyosKeE
zzP9!jPIiKiQL{iZFmk}|(Jb=v*v%nH<8sKf^7n}C{V*2MEH$4f*!oj_^sL5j*yVE+
zK)rO!ZWzvpaV-PuN==t@@-@<#g-yQAdcjK-Z1Bw0nKjmKX%_&D7l5kF9d6Um#-Tbh8Te>|--09X@gs9n~
zLv`lgbi4c{S!8mHWSh*7@2#JTwhcM`#;7OHk_Nq|Xp+_Kx5j#9itcBN%J^j72`eNg
zOup1~UDb*0wN$B_tSxI`gLkv2e4A
zfWBpgb;vh56vs#$zCSaanJ?Mv*3*CmdWwjyq+{=nIM)kF%j-^7wNMJ3p(uSmfYT1P
zsA9l(b-X&h*oKh>+)+Bb$UnZ#@udIhJ0hab%>g8|H=6?jtsmoWUwyY>^@xgEFe~?7
zW+Lau%y*YRJ^@iZenHjs5LvgpBi4K2mxt^-IC!lwIafC`gB_obgo}kV`rNh1Z_yTKuVwY;#M<-NJ
z?}8aZ_g(tvuNEIje7{4q^Vo5Qeuqg**R@Y9CT9AH#Bqq+ZQu$=oG%^vtk(hRUsZ9NT5GMaFs>>t{ch_sVFP|?l=a7;&0ZSt|IEGje)PDPj
z3*Y1DZ>Idiak_L=#Vxf#LziI}3f{3FuTIl@`QzZ1K_svZF
zW_}73GnN%aJ03=awALjhx)VN0jw0QALTbq)
zAqi0=vyG`NFqmOK+0&j`(tUt`fxQmGEYl#crmdj{H_gZBNQnkRGP8O$E)IGn%CHAC
zvZlnp8ksA-=dUr{_CR>Mp0m{|ob;zSl)kZNt87*-vg<4^?V_l>)HM^0eeBuqnodu~
zA$miFdSR+LfSr7Y{BzST`Ls>6jQ)=OtZ+a4xVf9@`m_VMPP>q<@w^V9-3?mLT^F0P
zoRK(L*poA)A|vA~vm23*WTU%YN2ClG6Vh)`@A-Ef{iqQ_cMQ6`t
zoz|0pTs2ag0<;_9G3#kY{@!#_8q_2n@ck
z>LcDrlWLW=Z-;mxTHK+Xv@slaDNTBH6VaiI3lfm>p508|gZB{i>`}s(g8GE)IeLo=
zB|xitWqZv8brN5lWw?KoTdO7)%4Ah^&YX=|6
z+nNHG7}Z)b8j}Tmz4a~Na_Ao~RS*%=Wl*zvXfh|!ZH~WQ&m{xH?ZiZTR(9Mm%q=V_
zUcRM$dD6>E@L<4cD*86}8^O0nj6`?~YVc>4<#L?;XCDya7rxHDTgneCIn$3v*gv$&
zIlpB#s$`Wwoh;i0G<&q*(cM6E#%(xB@OJ!oojBNMt4
zav%aV7@wD_aQl%zQ<;(74MCUq7$hx_q`WbLFk~fu-5?EhIeRSAZoQWx+{j8M5n*Y(
z_8LApzBmAv<*{>|VT_AZWAKnW>~C!`6i2XBQOZMj^Y0Zj?$lPk`c?D8viz6elT{Vt
zv$xMv*^9d$kCE#pH2d$9$=<}{j^Q7K?cya1Kvxf!9O~DM#qKSMEbnIC!;co|4lS&E
zP3xQg$l@S>{F;)Inij{z9z9?t4V@I
zzE-jO__|OLte!L;^%T{+=$G&ml~{5{iIuT8NRcjM?n^dWDJ6yM)QK0{6aAck(D!im
zx-J3+f8;qrCd-iiMXK?HYmr62!g78#mYA3mBr6=c{e(GmF$$%UJ(JVDTVU?<1)7kH
zz(zV=HO8%nw9+Fy+)mcT)gAArp;UBazWECLl8534{B8BQ>c5wKBn+xzINzJthq9B2
zN+Z1n9Pft{N*Q0A2s#sVJU6N`ey*1jB&Q>jn)7DDs4iAVD3VXn$=DP9a#1P)FLPgU
zB}!nPvl3?S-mSj{N?aKyF3za>)4NZk!Tx4rqi5JdA=#=hYw7r5N`B(l6VwS6x`e}Pt$@iNyIPvQneJ@
zKLugxd_TR(Dn4~>2`Hojm7cXn<}UIX-8fmuHgMLm8^Az{$TctA^g7r2u9L^z`>6+d
ztIt*363DkPcu(<<01gE6L~9ZeDw9kYb%hGaWBI>c@g_tJwuuk>B5aK^;5!(PVB;yH
zp{f~t2XA_B>6-ufYSLnrCFnqAvAONl7y|-yU@Fhy=q$#qtVzz&o5n8{K_VcyyeQDq=<<%|Go-!;ubO%gnC!|z!hUR5bc=mu;jfSR1ve5(
z5i{l|jeg_gExkK9%nw8;V&AA+pa-;^^#k3!{$|A@nOHo9`RX-aKK1*C~(tdzB0$B$Xdh9f=
zu3>(#U(9B;cEI;>)zbq$$9^AVD2=JeVhZf^#WB+O5B5l5M5WZjBYi{(dZIQ`8b(C^
z;I=@1f>RNyW4EBOUCU+43{G6&e^LBK%LpK$1%uI22{=v%!C!}Hhw1W-?5YA9vLjD}
zDY*^9kPa*6pqlxM??rL3^xc9$be;9{W0>wD)d51_oXXJEN|HpEpu$<9zRH5rm7QCY
zVuYMvX&!P%+#aZOG0HjqB4XtF70nB0ONQ#hyz29d!E4iG*%oDNVL?~A)e^mjsuUp?
zeWupwlp>#%#U}a58_#j3o+I>neia~G4ttk2@gx@a_2^)X$%T!<6H^IV?!kWWQaP6>
zz9B!PR&&Mzo)KupSk?tk3-K_fZ!L+Dm0RJ#QDAZ%hN+Vp(?-9Qf33ye2PU^^fcEz=
zU&yG~9~48t)ZleN|Vlo#LWBJ%C7YD3}sEwaS1n
zhRE-KKah&LFt6?=2eZqZ1UOBn^IvV#{mR+ey0|Z9hN(he)miQY2);i99Uzr2$XZ&(
zw!So9Wq9&xXR8A$lIo5B5P8Rv@nU^N;1?e;1bQkPd9q7xVqhipA+v78azBAp`Fp8>
zE!u9Ns*k@e_<29haFzxymvGSl;PprWEQ2`QCg>W2LCH-1F&}q_ZUZl>arP?Dq^Qel
zgQ)cHi7H#c!KAH0$Fp;yQWJ}w)wI3xxS*aQTgK{^(;^p!%EVo4pn!j235jTFt72=V
zTJw|Eg^HtK=3sUsXLpfYngRSw4{x18@BU&DjBft?oOSssT|wGnkY#ne)EEWxY$xW4
zG<-K>X<*c5QOSc97yh5T$bZNfEn;D$7c1+7ZLF
z?oSqRYaj2jH%+D;(A!P<^vCQo;jA4l$Gr#s(S_TD8ap!F@C%v6AmdYSiNT0o<8qL`
zqJhWis`F}yQ8#|}rAj+?1}`=P6^T*+*>SZ*_-RF&e0o&%eZ;2_3BRZp@^!kHxI`W=
zFbPIGtxagyGhmnf`gfcevXctaTtFAtOa7r{IWm4fQK#2i6WE+GRFvSGvQKZ5TJ8*y
zFHO2$5HAyuSCW|$j4SKgO})BK*1Kc%;zqE`G-U84I!s@oDX&}5i7-L0IU_Ly-JAu1
z)hsi+D>_X~b~>CR=P^b3%f~3+!qo^cX^3M<-~rBsIr
zp@C=Br7Uo%9Y#gk0k(v%Z2c&I{)-S5F2A2SOA8|8+XW;|<1*540XQaFkp1~$nO>`u
z#>s2_hfJRU5#ngJDfVUstBe(TLS
z4>{LY2A};AiU^~Ko%_83)H@;A`rW?8g)9W~{OK?~StBv|J@Y1YTb^(uvU@j~F`p+I
z=Cydv!YDSU^BEdmv}y|UY2RU*->nGq2AghPGS>Jdo>l7e(~-^7dh_6gzE=aNekjV+
zJPX!)0&ieENH`u{r)=y#s1N*MX##JGKSGF)#v6X;lJVI#(!am3397f)dT?nfs4CdT
z|6EyQr(^2mgMp%egoHWe99yPJ)0}J5DX#)IW#z-wSP@TgQtXA
z7|uaXCRA^q?r8P~G`X}I%N-?3w4MR~nGhyiFqOq>_AA^NdseL~5ln7LQg(hsuK$n#
z;HcU&F2qJjNZZx7xwcphNcY?=?Ze#t#TeR=zKg@mPt*?|)z2d~B?b7KBM6@JU-U)L
zRd4;QzYV=?X8rd5(Ww*58|n7>jsV4Np{9
z?N4#MsxmFKcHpQ`quyTp7S_-mgZ$$7@Qz(okHcaHs;X2bM_YhSI1kjW7?G^vx3(|F
z>1HIdE!di}Pwc}&n#1n9yFWw#S%@*4Sx#h}Et>O>mNY%5oS;
zkp6Jf(Am*#KzsG#BrcXXU45s%Zl4Pw)fFL%>gr&NMCmx3(q=BkHd8ThEYlG}P|f=x
zVj00n?F@`l4+w)qgby{&x(1eU3+2nv6pr5WN4t&hoN2}0L@C^WI)Ex0u_Nh``X(Sn
zKez`g;|YJ+qf0zACO2j9_Kso1!f92=p1hBCztXW;?8=-1JW-%QoAM}ohRXTV4~snP
zc(^k&iM+l;?a_3w0(K@{^6QW^c^1fu(eJ341!f7OIUkp{rkz33TuxfOW5qd5~MmMg_rWnQ%{1@fAIBU$%!WE5la00~F7|KOk)2?Yu
zLwLz&PkJ2tquL$PWMH#?9vLUc
z@?f{;;Y(#!FWIk$*(dGw)2Ne&GV=UCg(m*C;
zD^TH9K`t;!NQlRvjx%@=7Jq!ix};}5$ngANU)u6os6)Qe&D!D1_*D<94kZ1t>QC*;
zqmu(_bObT05q#CMr1y>8D(!T|!AN|?memiC#Ye`9Li9nM
zO26`#jbzn#PkA3C$ed;{E)7HrFR6^HN*{0ch@;MnAdd6$cwR{Jq8jA7uVl?4MJ1&$
z+{J_i1hOtWa_;>#U@6BGxuIDkJ);bp$|y5LO!KyD(IrCHN+Nu(?Ngq(Yr#rXjA6hj6j0$GxA*MKU)~8z$XjTDT2|a$JQyP`eGafC24#We#?av
zL8~6JxF1gKIT{hCMv%egA?^V-v4DW7JUf8}Y$45n(XZ;*`NOED;qI5?@#lxQHOAK%
zsTs2*-MDo8h5*y9peBy8y@FHy+%5Gqy18Us_GC=6b#}@XX#7_EHKJ{BzyF1YqWjBA
zmi7$SBSysaDud(ncKLu+Z6mJ!7xP#(NB;2Wp52f6g-li)LW3FWiEX}zT=e3ZAQ!tz
z+|gne{#!FeTSQ(2jPp3uzvEqZ}3pa`*6yiae2+5XnNu(`a{#Mc`P#Y_r{+94sJ(Sy-W?VL$Kwu{gd}
zbghl?*r(p%!fEDkBE;Xw+u01_TVj~1a^&Ve6-XwUS%p9;1!@f0!?$*Za^FNS+cPYq
z-$4eZZMUj%kKf4js#|gp@Pr#UFQzYfY+tCK>Y4Y*5SZN$3U7qYs&M``~o$0i{yESlKnbgyk>0@Dlg9fO$M_UEW3D6vT(3
zHVTNG(&jFVY$pahYmxBnRWT>qALndV$5pE}15+G1M%pZ%ZTj=J`GTny&rcCFT83cM
zqzL(R@suUfa7mCjuW^q$B@i6tT885Hs)yyRvz5FdW8gjfTI84Y61{I+seLl8ln}f;
zf0hk;tNe(i48bVkgto70`@X5049%zi7Wuhq(jzQsS>opvQo(KaLFN|I4!=y)!eq
zP)u8Eled?!?WxG?-Ys9*WyChAx9qB&?Ru=Wh%?l+SoG#9IrkKJ4CvFbZAD9a7Z>;r
zM9Z8QLEsm&G~ex#>R}QdLP6_WP&+Qd_-uh%dn4WJ5n+wv5Ss@lBFDm+RgDyNa>AHg%-JX)^n>X`Xt#hms
z?Vq<0^Dl~;3MxzYyjx{zQmqzQiibF&4j8)S(HqL
zBokhmVm7N0U3yaPbY`Ua)?*q#)OrOVO3HS?d(frm`Hiqrrb%yG`
z(5kSbw*+br$zcYZvPx!I>{J(8+(j`cDCSzbFN=Oj@zS;D;~uX4kS0sqkvAU5sN*q{
zt&|l7AbED1EjlUG%^9zeiiuyVt>I<+8y%wl4ZL>6Q)R?6@4m6jR02S!_t%+^Br7On
z^7Ap#q~+?nABnTO{TfcH;8!&5+hE9@603*z*~&IUisC=tOk9cKZBCcj4dB~CoX#i6
zxK#DM^S={OFkQzh)NJTc+j;i(t;|DN^=ayPxg
zGtAC$R3&<-^w9^l1rr3jRR&HD$FC>++c*64Z4@MfqJN{+|F$vyA5O-G28d%`
zAap_L!WRk!!?zgJ?@
z4JD4AQm#z+FlBt`NP+r)pN^m*+#p*fdDZsU!Ug;%2kzgzL3>z}^+8Y+G2y{&|J447
zkADXu&Oua-WHQ-lCc#W0dw8Z=p5|ZfgHD@hE-inUl5Rpc9}@o8&DXCykzMkF{uHD}5?tFJo-vY3`DhE-8UW4F{
zMn>h2`_}^GD+#(&CzYaRo*x%@K=9e(`pQ3xl8UfW+y?v$@iVY<{J{-kK@ndw4e4{ZbReQCn?f
z*00OIirFWDq+25{M&hqeJp+G;3E81oBxI&4ZlC^I*=-9+D@?n+T)(nn>@OP)kq
z(9J8Z=!9dFf+;{_O`N;abnAii8;K0H(U)bEQI#+GSC=so?Nzo}`MPW=)@;hw
z;ip04vgWfd+3fGcQj&5+DO{h2L^-cyA(FZ#vffdgT_%oCfSRujWL+?HZP&2*k
z6OL$#sdHV^&4q0VDvsVpnNiaCtDGYV*IFqZ*_6fR_#-Aw0_@r&YTX>!22fBk;)pd}
zxn${vL-|+0WPVNrSo+B6GxXEejo-HBy&^7i_}g~ez})=CzK#p@dvk!#$iaSi4~$DZ
z%YU7HB3F#YN^FqvRn`nOF0k7-av>|fr+sYttYq>l;)3o4fXK2kxu(0>d>!Onmc8S-AbM|s=z$v-1bti{>
zsu!l&3iF;abiu-ZidOsey=-cYl()KC&7UsuK9D^L528sGkWSSQsg9+d7_OGin}C~t
zXE!qDG;Xkymfbzqk+Zp0I=X>+>qJ1IlHI3kxn*VjjXf!o)X&5c9pNR6%^?3K>1cH_Unw{nAkLCm@hnuz!c_g`47p7xvj
z^)SzcPVcUz<1*+mO}j^{h{tnsJj?zP3?u+cx`jT)c*&auc$hT|_#V@eyuD