From 3634454987ecd1e94901ca166b2bc488f749749b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 16:03:34 +0800
Subject: [PATCH 0001/1712] modify code

---
 src/class147/Code01_Catalan.java | 118 +++++++++++++++++++++++++++++++
 src/class147/Code02_Pancake.java |  71 +++++++++++++++++++
 src/class147/Code03_Skyline.java |  54 ++++++++++++++
 3 files changed, 243 insertions(+)
 create mode 100644 src/class147/Code01_Catalan.java
 create mode 100644 src/class147/Code02_Pancake.java
 create mode 100644 src/class147/Code03_Skyline.java

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
new file mode 100644
index 000000000..5d8ff345a
--- /dev/null
+++ b/src/class147/Code01_Catalan.java
@@ -0,0 +1,118 @@
+package class147;
+
+// 卡特兰数
+// 测试的题目数据量很小，请根据数据量可能很大的情况进行实现
+// 答案对 1000000007 取余
+// 测试链接 : https://www.luogu.com.cn/problem/P1044
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_Catalan {
+
+	public static int MOD = 1000000007;
+
+	public static int MAXN = 1000001;
+
+	// 阶乘余数表
+	public static long[] fac = new long[MAXN];
+
+	// 阶乘逆元表
+	public static long[] inv1 = new long[MAXN];
+
+	// 数字逆元表
+	public static long[] inv2 = new long[MAXN];
+
+	// 来自讲解讲解099，题目3，生成阶乘余数表、阶乘逆元表
+	public static void build1(int n) {
+		fac[0] = inv1[0] = 1;
+		fac[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			fac[i] = ((long) i * fac[i - 1]) % MOD;
+		}
+		inv1[n] = power(fac[n], MOD - 2);
+		for (int i = n - 1; i >= 1; i--) {
+			inv1[i] = ((long) (i + 1) * inv1[i + 1]) % MOD;
+		}
+	}
+
+	// 来自讲解讲解099，题目2，生成数字的逆元表
+	public static void build2(int n) {
+		inv2[1] = 1;
+		for (int i = 2; i <= n + 1; i++) {
+			inv2[i] = MOD - inv2[MOD % i] * (MOD / i) % MOD;
+		}
+	}
+
+	public static long power(long x, long p) {
+		long ans = 1;
+		while (p > 0) {
+			if ((p & 1) == 1) {
+				ans = (ans * x) % MOD;
+			}
+			x = (x * x) % MOD;
+			p >>= 1;
+		}
+		return ans;
+	}
+
+	public static long c(int n, int k) {
+		return (((fac[n] * inv1[k]) % MOD) * inv1[n - k]) % MOD;
+	}
+
+	// 公式1
+	public static long compute1(int n) {
+		build1(2 * n);
+		return (c(2 * n, n) - c(2 * n, n - 1) + MOD) % MOD;
+	}
+
+	// 公式2
+	public static long compute2(int n) {
+		build1(2 * n);
+		return c(2 * n, n) * power(n + 1, MOD - 2) % MOD;
+	}
+
+	// 公式3
+	public static long compute3(int n) {
+		build2(n);
+		long[] catalan = new long[n + 1];
+		catalan[0] = catalan[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			catalan[i] = catalan[i - 1] * (4 * i - 2) % MOD * inv2[i + 1] % MOD;
+		}
+		return catalan[n];
+	}
+
+	// 公式4
+	public static long compute4(int n) {
+		long[] catalan = new long[n + 1];
+		catalan[0] = catalan[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			for (int l = 0, r = i - 1; l < i; l++, r--) {
+				catalan[i] = (catalan[i] + catalan[l] * catalan[r] % MOD) % MOD;
+			}
+		}
+		return catalan[n];
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		out.println(compute1(n));
+//		out.println(compute2(n));
+//		out.println(compute3(n));
+//		out.println(compute4(n));
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class147/Code02_Pancake.java b/src/class147/Code02_Pancake.java
new file mode 100644
index 000000000..6c6616c2e
--- /dev/null
+++ b/src/class147/Code02_Pancake.java
@@ -0,0 +1,71 @@
+package class147;
+
+// 鸡蛋饼
+// 注意！答案不对 10^9 + 7 取余！而是对 10^8 + 7 取余！
+// 测试链接 : https://www.luogu.com.cn/problem/P1976
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_Pancake {
+
+	public static int MOD = 100000007;
+
+	public static int MAXN = 1000001;
+
+	public static long[] fac = new long[MAXN];
+
+	public static long[] inv = new long[MAXN];
+
+	public static void build(int n) {
+		fac[0] = inv[0] = 1;
+		fac[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			fac[i] = ((long) i * fac[i - 1]) % MOD;
+		}
+		inv[n] = power(fac[n], MOD - 2);
+		for (int i = n - 1; i >= 1; i--) {
+			inv[i] = ((long) (i + 1) * inv[i + 1]) % MOD;
+		}
+	}
+
+	public static long power(long x, long p) {
+		long ans = 1;
+		while (p > 0) {
+			if ((p & 1) == 1) {
+				ans = (ans * x) % MOD;
+			}
+			x = (x * x) % MOD;
+			p >>= 1;
+		}
+		return ans;
+	}
+
+	public static long c(int n, int k) {
+		return (((fac[n] * inv[k]) % MOD) * inv[n - k]) % MOD;
+	}
+
+	// 这里用公式1
+	public static long compute(int n) {
+		build(2 * n);
+		return (c(2 * n, n) - c(2 * n, n - 1) + MOD) % MOD;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		out.println(compute(n));
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class147/Code03_Skyline.java b/src/class147/Code03_Skyline.java
new file mode 100644
index 000000000..280a63591
--- /dev/null
+++ b/src/class147/Code03_Skyline.java
@@ -0,0 +1,54 @@
+package class147;
+
+// 卡特兰数天际线
+// 答案对 1000000 取余
+// 1 <= n <= 1000
+// 测试链接 : https://www.luogu.com.cn/problem/SP7897
+// 测试链接 : https://www.spoj.com/problems/SKYLINE
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code03_Skyline {
+
+	public static int MOD = 1000000;
+
+	public static int MAXN = 1001;
+
+	public static long[] catalan = new long[MAXN];
+
+	// 因为取余的数字含有很多因子
+	// 无法用费马小定理或者扩展欧几里得求逆元
+	// 所以使用公式4
+	public static void build() {
+		catalan[0] = catalan[1] = 1;
+		for (int i = 2; i < MAXN; i++) {
+			for (int l = 0, r = i - 1; l < i; l++, r--) {
+				catalan[i] = (catalan[i] + catalan[l] * catalan[r] % MOD) % MOD;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		build();
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			int n = (int) in.nval;
+			if (n == 0) {
+				break;
+			}
+			out.println(catalan[n]);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 8694435804e9103bfdeb201a7f11c08cb6d62162 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 16:29:09 +0800
Subject: [PATCH 0002/1712] modify code

---
 src/class147/Code01_Catalan.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index 5d8ff345a..b8d5f1f7c 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -28,7 +28,7 @@ public class Code01_Catalan {
 	// 数字逆元表
 	public static long[] inv2 = new long[MAXN];
 
-	// 来自讲解讲解099，题目3，生成阶乘余数表、阶乘逆元表
+	// 来自讲解099，题目3，生成阶乘余数表、阶乘逆元表
 	public static void build1(int n) {
 		fac[0] = inv1[0] = 1;
 		fac[1] = 1;
@@ -41,7 +41,7 @@ public static void build1(int n) {
 		}
 	}
 
-	// 来自讲解讲解099，题目2，生成数字的逆元表
+	// 来自讲解099，题目2，生成数字的逆元表
 	public static void build2(int n) {
 		inv2[1] = 1;
 		for (int i = 2; i <= n + 1; i++) {

From 6dddb0491c0c52105f92602885661738ecf892d2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 16:29:51 +0800
Subject: [PATCH 0003/1712] modify code

---
 src/class147/Code01_Catalan.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index b8d5f1f7c..ec62fd990 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -41,7 +41,7 @@ public static void build1(int n) {
 		}
 	}
 
-	// 来自讲解099，题目2，生成数字的逆元表
+	// 来自讲解099，题目2，生成连续数字的逆元表
 	public static void build2(int n) {
 		inv2[1] = 1;
 		for (int i = 2; i <= n + 1; i++) {

From 584a85113edb28bfd87a09900786ae40cd9fb22f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 20:15:41 +0800
Subject: [PATCH 0004/1712] modify code

---
 src/class147/Code02_RedMore.java              | 45 +++++++++++++++++++
 ...02_Pancake.java => Code03_CircleLine.java} |  4 +-
 ...Skyline.java => Code04_SplitTriangle.java} |  4 +-
 3 files changed, 49 insertions(+), 4 deletions(-)
 create mode 100644 src/class147/Code02_RedMore.java
 rename src/class147/{Code02_Pancake.java => Code03_CircleLine.java} (97%)
 rename src/class147/{Code03_Skyline.java => Code04_SplitTriangle.java} (96%)

diff --git a/src/class147/Code02_RedMore.java b/src/class147/Code02_RedMore.java
new file mode 100644
index 000000000..064738005
--- /dev/null
+++ b/src/class147/Code02_RedMore.java
@@ -0,0 +1,45 @@
+package class147;
+
+// 任意前缀上红大于黑
+// 答案对 100 取余
+// 测试链接 : https://www.luogu.com.cn/problem/P1722
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_RedMore {
+
+	public static int MOD = 100;
+
+	// 因为取余的数字含有很多因子
+	// 无法用费马小定理或者扩展欧几里得求逆元
+	// 所以使用公式4
+	public static long compute(int n) {
+		long[] catalan = new long[n + 1];
+		catalan[0] = catalan[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			for (int l = 0, r = i - 1; l < i; l++, r--) {
+				catalan[i] = (catalan[i] + catalan[l] * catalan[r] % MOD) % MOD;
+			}
+		}
+		return catalan[n];
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		out.println(compute(n));
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class147/Code02_Pancake.java b/src/class147/Code03_CircleLine.java
similarity index 97%
rename from src/class147/Code02_Pancake.java
rename to src/class147/Code03_CircleLine.java
index 6c6616c2e..89e135a46 100644
--- a/src/class147/Code02_Pancake.java
+++ b/src/class147/Code03_CircleLine.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 鸡蛋饼
+// 圆上连线
 // 注意！答案不对 10^9 + 7 取余！而是对 10^8 + 7 取余！
 // 测试链接 : https://www.luogu.com.cn/problem/P1976
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_Pancake {
+public class Code03_CircleLine {
 
 	public static int MOD = 100000007;
 
diff --git a/src/class147/Code03_Skyline.java b/src/class147/Code04_SplitTriangle.java
similarity index 96%
rename from src/class147/Code03_Skyline.java
rename to src/class147/Code04_SplitTriangle.java
index 280a63591..09251a44b 100644
--- a/src/class147/Code03_Skyline.java
+++ b/src/class147/Code04_SplitTriangle.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 卡特兰数天际线
+// 划分三角形
 // 答案对 1000000 取余
 // 1 <= n <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/SP7897
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_Skyline {
+public class Code04_SplitTriangle {
 
 	public static int MOD = 1000000;
 

From beb84fc20f8f26b96c7a8e7ead52128118e1e167 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 20:39:49 +0800
Subject: [PATCH 0005/1712] modify code

---
 src/class147/Code05_treeHouseLadder.java | 55 ++++++++++++++++++++++++
 1 file changed, 55 insertions(+)
 create mode 100644 src/class147/Code05_treeHouseLadder.java

diff --git a/src/class147/Code05_treeHouseLadder.java b/src/class147/Code05_treeHouseLadder.java
new file mode 100644
index 000000000..822c414d0
--- /dev/null
+++ b/src/class147/Code05_treeHouseLadder.java
@@ -0,0 +1,55 @@
+package class147;
+
+// 树屋阶梯
+// 测试链接 : https://www.luogu.com.cn/problem/P2532
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.math.BigInteger;
+
+public class Code05_treeHouseLadder {
+
+	// 这里用公式1
+	// java同学使用BigInteger即可
+	// C++同学需要自己实现高精度乘法了
+	public static BigInteger compute(int n) {
+		BigInteger a = new BigInteger("1");
+		BigInteger b = new BigInteger("1");
+		BigInteger c = new BigInteger("1");
+		BigInteger d = new BigInteger("1");
+		BigInteger cur;
+		for (int i = 1; i <= 2 * n; i++) {
+			cur = new BigInteger(String.valueOf(i));
+			a = a.multiply(cur);
+			if (i <= n) {
+				b = b.multiply(cur);
+			}
+			if (i <= n - 1) {
+				c = c.multiply(cur);
+			}
+			if (i <= n + 1) {
+				d = d.multiply(cur);
+			}
+		}
+		return a.divide(b.multiply(b)).subtract(a.divide(c.multiply(d)));
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		BigInteger ans = compute(n);
+		out.println(ans.toString());
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 6a7165ba0cbd1eccc886b95ea0cffc2f726b4731 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 20:40:21 +0800
Subject: [PATCH 0006/1712] modify code

---
 ...{Code05_treeHouseLadder.java => Code05_TreehouseLadder.java} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/class147/{Code05_treeHouseLadder.java => Code05_TreehouseLadder.java} (97%)

diff --git a/src/class147/Code05_treeHouseLadder.java b/src/class147/Code05_TreehouseLadder.java
similarity index 97%
rename from src/class147/Code05_treeHouseLadder.java
rename to src/class147/Code05_TreehouseLadder.java
index 822c414d0..620d8d61d 100644
--- a/src/class147/Code05_treeHouseLadder.java
+++ b/src/class147/Code05_TreehouseLadder.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.math.BigInteger;
 
-public class Code05_treeHouseLadder {
+public class Code05_TreehouseLadder {
 
 	// 这里用公式1
 	// java同学使用BigInteger即可

From e9876dd8e8e4a92b386368cf2929ce690e0e6fc7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 20:43:04 +0800
Subject: [PATCH 0007/1712] modify code

---
 src/class147/Code05_TreehouseLadder.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class147/Code05_TreehouseLadder.java b/src/class147/Code05_TreehouseLadder.java
index 620d8d61d..b3b299506 100644
--- a/src/class147/Code05_TreehouseLadder.java
+++ b/src/class147/Code05_TreehouseLadder.java
@@ -16,7 +16,7 @@ public class Code05_TreehouseLadder {
 
 	// 这里用公式1
 	// java同学使用BigInteger即可
-	// C++同学需要自己实现高精度乘法了
+	// C++同学需要自己实现高精度乘法
 	public static BigInteger compute(int n) {
 		BigInteger a = new BigInteger("1");
 		BigInteger b = new BigInteger("1");

From 7495e04612594fb0e5f98a4c791e28924c2a062c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 21:16:02 +0800
Subject: [PATCH 0008/1712] modify code

---
 src/class147/Code05_TreehouseLadder.java      | 12 ++---------
 .../Code06_UniqueBinarySearchTrees.java       | 21 +++++++++++++++++++
 2 files changed, 23 insertions(+), 10 deletions(-)
 create mode 100644 src/class147/Code06_UniqueBinarySearchTrees.java

diff --git a/src/class147/Code05_TreehouseLadder.java b/src/class147/Code05_TreehouseLadder.java
index b3b299506..983103dc5 100644
--- a/src/class147/Code05_TreehouseLadder.java
+++ b/src/class147/Code05_TreehouseLadder.java
@@ -14,14 +14,12 @@
 
 public class Code05_TreehouseLadder {
 
-	// 这里用公式1
+	// 这里用公式2
 	// java同学使用BigInteger即可
 	// C++同学需要自己实现高精度乘法
 	public static BigInteger compute(int n) {
 		BigInteger a = new BigInteger("1");
 		BigInteger b = new BigInteger("1");
-		BigInteger c = new BigInteger("1");
-		BigInteger d = new BigInteger("1");
 		BigInteger cur;
 		for (int i = 1; i <= 2 * n; i++) {
 			cur = new BigInteger(String.valueOf(i));
@@ -29,14 +27,8 @@ public static BigInteger compute(int n) {
 			if (i <= n) {
 				b = b.multiply(cur);
 			}
-			if (i <= n - 1) {
-				c = c.multiply(cur);
-			}
-			if (i <= n + 1) {
-				d = d.multiply(cur);
-			}
 		}
-		return a.divide(b.multiply(b)).subtract(a.divide(c.multiply(d)));
+		return a.divide(b.multiply(b)).divide(new BigInteger(String.valueOf(n + 1)));
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class147/Code06_UniqueBinarySearchTrees.java b/src/class147/Code06_UniqueBinarySearchTrees.java
new file mode 100644
index 000000000..1c2b42cc3
--- /dev/null
+++ b/src/class147/Code06_UniqueBinarySearchTrees.java
@@ -0,0 +1,21 @@
+package class147;
+
+// 不同的二叉搜索树
+// 测试链接 : https://leetcode.cn/problems/unique-binary-search-trees/
+public class Code06_UniqueBinarySearchTrees {
+
+	// 数据量小用哪个公式都可以
+	// 不用考虑溢出、取余等问题
+	// 这里用公式4
+	public static int numTrees(int n) {
+		int[] catalan = new int[n + 1];
+		catalan[0] = catalan[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			for (int l = 0, r = i - 1; l < i; l++, r--) {
+				catalan[i] += catalan[l] * catalan[r];
+			}
+		}
+		return catalan[n];
+	}
+
+}

From b27506a3df9dd54defc7d2eaca23b40551a2d61c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 21:23:51 +0800
Subject: [PATCH 0009/1712] modify code

---
 src/class147/Code07_LeafExpectation.java | 28 ++++++++++++++++++++++++
 1 file changed, 28 insertions(+)
 create mode 100644 src/class147/Code07_LeafExpectation.java

diff --git a/src/class147/Code07_LeafExpectation.java b/src/class147/Code07_LeafExpectation.java
new file mode 100644
index 000000000..c493e63e3
--- /dev/null
+++ b/src/class147/Code07_LeafExpectation.java
@@ -0,0 +1,28 @@
+package class147;
+
+// 叶子节点数的期望
+// 测试链接 : https://www.luogu.com.cn/problem/P3978
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code07_LeafExpectation {
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		double n = in.nval;
+		out.printf("%.12f", n * (n + 1) / (2 * (2 * n - 1)));
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From b6505d42646470066fdf66480a83f132b9e59dfe Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Oct 2024 21:30:01 +0800
Subject: [PATCH 0010/1712] modify code

---
 src/class147/Code01_Catalan.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index ec62fd990..bba4e278b 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -1,8 +1,7 @@
 package class147;
 
 // 卡特兰数
-// 测试的题目数据量很小，请根据数据量可能很大的情况进行实现
-// 答案对 1000000007 取余
+// 测试题目的数据量虽然很小，但请假设数据量很大来实现，答案对 1000000007 取余
 // 测试链接 : https://www.luogu.com.cn/problem/P1044
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From caa641233333d14ae468658c7593fc8e026651b7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 11:24:52 +0800
Subject: [PATCH 0011/1712] modify code

---
 src/class147/Code08_GenerateString.java | 71 +++++++++++++++++++++++++
 1 file changed, 71 insertions(+)
 create mode 100644 src/class147/Code08_GenerateString.java

diff --git a/src/class147/Code08_GenerateString.java b/src/class147/Code08_GenerateString.java
new file mode 100644
index 000000000..6a2ab114e
--- /dev/null
+++ b/src/class147/Code08_GenerateString.java
@@ -0,0 +1,71 @@
+package class147;
+
+// 生成字符串
+// 测试链接 : https://www.luogu.com.cn/problem/P1641
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code08_GenerateString {
+
+	public static int MOD = 20100403;
+
+	public static int MAXN = 2000001;
+
+	public static long[] fac = new long[MAXN];
+
+	public static long[] inv = new long[MAXN];
+
+	public static void build(int n) {
+		fac[0] = inv[0] = 1;
+		fac[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			fac[i] = ((long) i * fac[i - 1]) % MOD;
+		}
+		inv[n] = power(fac[n], MOD - 2);
+		for (int i = n - 1; i >= 1; i--) {
+			inv[i] = ((long) (i + 1) * inv[i + 1]) % MOD;
+		}
+	}
+
+	public static long power(long x, long p) {
+		long ans = 1;
+		while (p > 0) {
+			if ((p & 1) == 1) {
+				ans = (ans * x) % MOD;
+			}
+			x = (x * x) % MOD;
+			p >>= 1;
+		}
+		return ans;
+	}
+
+	public static long c(int n, int k) {
+		return (((fac[n] * inv[k]) % MOD) * inv[n - k]) % MOD;
+	}
+
+	public static long compute(int n, int m) {
+		build(n + m);
+		return (c(n + m, m) - c(n + m, m - 1) + MOD) % MOD;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		out.println(compute(n, m));
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 1d6c6c28ada8b066eaffe4019a9a443ecde9a8d9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 11:25:27 +0800
Subject: [PATCH 0012/1712] modify code

---
 ...e06_UniqueBinarySearchTrees.java => Code06_UniqueTrees.java} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/class147/{Code06_UniqueBinarySearchTrees.java => Code06_UniqueTrees.java} (91%)

diff --git a/src/class147/Code06_UniqueBinarySearchTrees.java b/src/class147/Code06_UniqueTrees.java
similarity index 91%
rename from src/class147/Code06_UniqueBinarySearchTrees.java
rename to src/class147/Code06_UniqueTrees.java
index 1c2b42cc3..2d6be350d 100644
--- a/src/class147/Code06_UniqueBinarySearchTrees.java
+++ b/src/class147/Code06_UniqueTrees.java
@@ -2,7 +2,7 @@
 
 // 不同的二叉搜索树
 // 测试链接 : https://leetcode.cn/problems/unique-binary-search-trees/
-public class Code06_UniqueBinarySearchTrees {
+public class Code06_UniqueTrees {
 
 	// 数据量小用哪个公式都可以
 	// 不用考虑溢出、取余等问题

From ff8aebf4a416e7b3e3c06938b6e4d3064bd9bd37 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 11:27:35 +0800
Subject: [PATCH 0013/1712] modify code

---
 .../{Code08_GenerateString.java => Code06_GenerateString.java}  | 2 +-
 .../{Code06_UniqueTrees.java => Code07_UniqueTrees.java}        | 2 +-
 ...{Code07_LeafExpectation.java => Code08_LeafExpectation.java} | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class147/{Code08_GenerateString.java => Code06_GenerateString.java} (97%)
 rename src/class147/{Code06_UniqueTrees.java => Code07_UniqueTrees.java} (93%)
 rename src/class147/{Code07_LeafExpectation.java => Code08_LeafExpectation.java} (95%)

diff --git a/src/class147/Code08_GenerateString.java b/src/class147/Code06_GenerateString.java
similarity index 97%
rename from src/class147/Code08_GenerateString.java
rename to src/class147/Code06_GenerateString.java
index 6a2ab114e..e9bb375e0 100644
--- a/src/class147/Code08_GenerateString.java
+++ b/src/class147/Code06_GenerateString.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code08_GenerateString {
+public class Code06_GenerateString {
 
 	public static int MOD = 20100403;
 
diff --git a/src/class147/Code06_UniqueTrees.java b/src/class147/Code07_UniqueTrees.java
similarity index 93%
rename from src/class147/Code06_UniqueTrees.java
rename to src/class147/Code07_UniqueTrees.java
index 2d6be350d..da01c02b8 100644
--- a/src/class147/Code06_UniqueTrees.java
+++ b/src/class147/Code07_UniqueTrees.java
@@ -2,7 +2,7 @@
 
 // 不同的二叉搜索树
 // 测试链接 : https://leetcode.cn/problems/unique-binary-search-trees/
-public class Code06_UniqueTrees {
+public class Code07_UniqueTrees {
 
 	// 数据量小用哪个公式都可以
 	// 不用考虑溢出、取余等问题
diff --git a/src/class147/Code07_LeafExpectation.java b/src/class147/Code08_LeafExpectation.java
similarity index 95%
rename from src/class147/Code07_LeafExpectation.java
rename to src/class147/Code08_LeafExpectation.java
index c493e63e3..1a6114ea4 100644
--- a/src/class147/Code07_LeafExpectation.java
+++ b/src/class147/Code08_LeafExpectation.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code07_LeafExpectation {
+public class Code08_LeafExpectation {
 
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

From 7e2f6faedc8a622d37f69f679f972082c9a027de Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 11:49:32 +0800
Subject: [PATCH 0014/1712] modify code

---
 src/class041/Code02_NthMagicalNumber.java                   | 2 +-
 src/class042/Code04_RedPalindromeGoodStrings.java           | 2 +-
 src/class066/Code08_DistinctSubsequencesII.java             | 2 +-
 src/class068/Code01_DistinctSubsequences.java               | 2 +-
 src/class068/Code04_FillCellsUseAllColorsWays.java          | 2 +-
 src/class069/Code04_PathsDivisibleByK.java                  | 2 +-
 .../Code06_CountDifferentPalindromicSubsequences.java       | 2 +-
 src/class081/Code01_NumberOfWaysWearDifferentHats.java      | 2 +-
 src/class081/Code03_TheNumberOfGoodSubsets.java             | 2 +-
 src/class082/Code07_DiSequence.java                         | 2 +-
 src/class083/Code02_KInversePairsArray.java                 | 2 +-
 src/class084/Code03_CountOfIntegers.java                    | 2 +-
 src/class090/Code01_CuttingBamboo.java                      | 2 +-
 src/class090/Code02_MaximumProduct.java                     | 2 +-
 src/class101/Code04_FindAllGoodStrings.java                 | 2 +-
 src/class126/Code02_GridPainting.java                       | 2 +-
 src/class127/Code05_WaysOfArrangePlates.java                | 6 +++---
 src/class130/Code06_SumOfTotalStrength.java                 | 2 +-
 src/class132/Code03_WaysOfRevert1.java                      | 2 +-
 src/class132/Code03_WaysOfRevert2.java                      | 2 +-
 src/class134/Code01_GaussEor.java                           | 2 +-
 src/class136/Code04_Lanterns.java                           | 2 +-
 src/class144/Code04_SplitWays1.java                         | 2 +-
 src/class145/Code02_SetCounting.java                        | 2 +-
 src/class145/Code03_DistributeSpecialties.java              | 2 +-
 src/class145/Code04_NothingFear.java                        | 2 +-
 src/class145/Code05_Game1.java                              | 2 +-
 src/class145/Code05_Game2.java                              | 2 +-
 src/class147/Code01_Catalan.java                            | 2 +-
 src/class147/Code02_RedMore.java                            | 4 ++--
 src/class147/Code03_CircleLine.java                         | 2 +-
 src/class147/Code04_SplitTriangle.java                      | 4 ++--
 src/class147/Code07_UniqueTrees.java                        | 2 +-
 33 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/src/class041/Code02_NthMagicalNumber.java b/src/class041/Code02_NthMagicalNumber.java
index 56435c0de..8ffd52f4b 100644
--- a/src/class041/Code02_NthMagicalNumber.java
+++ b/src/class041/Code02_NthMagicalNumber.java
@@ -2,7 +2,7 @@
 
 // 一个正整数如果能被 a 或 b 整除，那么它是神奇的。
 // 给定三个整数 n , a , b ，返回第 n 个神奇的数字。
-// 因为答案可能很大，所以返回答案 对 10^9 + 7 取模 后的值。
+// 因为答案可能很大，所以返回答案 对 10^9 + 7 取模
 // 测试链接 : https://leetcode.cn/problems/nth-magical-number/
 public class Code02_NthMagicalNumber {
 
diff --git a/src/class042/Code04_RedPalindromeGoodStrings.java b/src/class042/Code04_RedPalindromeGoodStrings.java
index eab0efa08..47b2fba1f 100644
--- a/src/class042/Code04_RedPalindromeGoodStrings.java
+++ b/src/class042/Code04_RedPalindromeGoodStrings.java
@@ -3,7 +3,7 @@
 // 可以用r、e、d三种字符拼接字符串，如果拼出来的字符串中
 // 有且仅有1个长度>=2的回文子串，那么这个字符串定义为"好串"
 // 返回长度为n的所有可能的字符串中，好串有多少个
-// 结果对1000000007取模， 1 <= n <= 10^9
+// 结果对 1000000007 取模， 1 <= n <= 10^9
 // 示例：
 // n = 1, 输出0
 // n = 2, 输出3
diff --git a/src/class066/Code08_DistinctSubsequencesII.java b/src/class066/Code08_DistinctSubsequencesII.java
index 81fe3d57d..bd02e1935 100644
--- a/src/class066/Code08_DistinctSubsequencesII.java
+++ b/src/class066/Code08_DistinctSubsequencesII.java
@@ -2,7 +2,7 @@
 
 // 不同的子序列 II
 // 给定一个字符串 s，计算 s 的 不同非空子序列 的个数
-// 因为结果可能很大，所以返回答案需要对 10^9 + 7 取余
+// 因为结果可能很大，所以返回答案需要对 10^9 + 7 取模
 // 字符串的 子序列 是经由原字符串删除一些（也可能不删除）
 // 字符但不改变剩余字符相对位置的一个新字符串
 // 例如，"ace" 是 "abcde" 的一个子序列，但 "aec" 不是
diff --git a/src/class068/Code01_DistinctSubsequences.java b/src/class068/Code01_DistinctSubsequences.java
index 462ef5dda..55b1a4b08 100644
--- a/src/class068/Code01_DistinctSubsequences.java
+++ b/src/class068/Code01_DistinctSubsequences.java
@@ -2,7 +2,7 @@
 
 // 不同的子序列
 // 给你两个字符串s和t ，统计并返回在s的子序列中t出现的个数
-// 答案对1000000007取余
+// 答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/distinct-subsequences/
 public class Code01_DistinctSubsequences {
 
diff --git a/src/class068/Code04_FillCellsUseAllColorsWays.java b/src/class068/Code04_FillCellsUseAllColorsWays.java
index 97051c007..9d2b87914 100644
--- a/src/class068/Code04_FillCellsUseAllColorsWays.java
+++ b/src/class068/Code04_FillCellsUseAllColorsWays.java
@@ -97,7 +97,7 @@ public static void main(String[] args) {
 		long start = System.currentTimeMillis();
 		int ans = ways2(n, m);
 		long end = System.currentTimeMillis();
-		System.out.println("取余之后的结果 : " + ans);
+		System.out.println("取模之后的结果 : " + ans);
 		System.out.println("运行时间 : " + (end - start) + " 毫秒");
 		System.out.println("性能测试结束");
 	}
diff --git a/src/class069/Code04_PathsDivisibleByK.java b/src/class069/Code04_PathsDivisibleByK.java
index fd4005247..10dead148 100644
--- a/src/class069/Code04_PathsDivisibleByK.java
+++ b/src/class069/Code04_PathsDivisibleByK.java
@@ -4,7 +4,7 @@
 // 给一个下标从0开始的 n * m 整数矩阵 grid 和一个整数 k
 // 从起点(0,0)出发，每步只能往下或者往右，你想要到达终点(m-1, n-1)
 // 请你返回路径和能被 k 整除的路径数目
-// 由于答案可能很大，返回答案对10^9+7取余的结果
+// 答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/paths-in-matrix-whose-sum-is-divisible-by-k/
 public class Code04_PathsDivisibleByK {
 
diff --git a/src/class077/Code06_CountDifferentPalindromicSubsequences.java b/src/class077/Code06_CountDifferentPalindromicSubsequences.java
index c7f18fd52..0443142dc 100644
--- a/src/class077/Code06_CountDifferentPalindromicSubsequences.java
+++ b/src/class077/Code06_CountDifferentPalindromicSubsequences.java
@@ -4,7 +4,7 @@
 
 // 统计不同回文子序列
 // 给你一个字符串s，返回s中不同的非空回文子序列个数
-// 由于答案可能很大，请你将答案对10^9+7取余后返回
+// 由于答案可能很大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/count-different-palindromic-subsequences/
 public class Code06_CountDifferentPalindromicSubsequences {
 
diff --git a/src/class081/Code01_NumberOfWaysWearDifferentHats.java b/src/class081/Code01_NumberOfWaysWearDifferentHats.java
index 06240781d..dc1292797 100644
--- a/src/class081/Code01_NumberOfWaysWearDifferentHats.java
+++ b/src/class081/Code01_NumberOfWaysWearDifferentHats.java
@@ -7,7 +7,7 @@
 // 总共有 n 个人和 40 种不同的帽子，帽子编号从 1 到 40
 // 给你一个整数列表的列表 hats ，其中 hats[i] 是第 i 个人所有喜欢帽子的列表
 // 请你给每个人安排一顶他喜欢的帽子，确保每个人戴的帽子跟别人都不一样，并返回方案数
-// 由于答案可能很大，请返回它对10^9+7取余后的结果
+// 由于答案可能很大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/number-of-ways-to-wear-different-hats-to-each-other
 public class Code01_NumberOfWaysWearDifferentHats {
 
diff --git a/src/class081/Code03_TheNumberOfGoodSubsets.java b/src/class081/Code03_TheNumberOfGoodSubsets.java
index 33ed732de..8db9e17b5 100644
--- a/src/class081/Code03_TheNumberOfGoodSubsets.java
+++ b/src/class081/Code03_TheNumberOfGoodSubsets.java
@@ -9,7 +9,7 @@
 // [2, 3]，[1, 2, 3]，[1, 3] 是好子集
 // 乘积分别为6=2*3，6=2*3，3=3
 // [1, 4]和[4]不是好子集，因为乘积分别为4=2*2和4=2*2
-// 请你返回nums中不同的好子集的数目对10^9+7取余的结果
+// 返回nums中不同的好子集的数目，答案对 1000000007 取模
 // 如果两个子集删除的下标不同，那么它们被视为不同的子集
 // 测试链接 : https://leetcode.cn/problems/the-number-of-good-subsets/
 public class Code03_TheNumberOfGoodSubsets {
diff --git a/src/class082/Code07_DiSequence.java b/src/class082/Code07_DiSequence.java
index c4b0e87fb..c326a7bfa 100644
--- a/src/class082/Code07_DiSequence.java
+++ b/src/class082/Code07_DiSequence.java
@@ -7,7 +7,7 @@
 // 如果 s[i] == 'D'，那么 perm[i] > perm[i+1]
 // 如果 s[i] == 'I'，那么 perm[i] < perm[i+1]
 // 返回有效排列的perm的数量
-// 因为答案可能很大，所以请返回你的答案对10^9+7取余
+// 因为答案可能很大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/valid-permutations-for-di-sequence/
 public class Code07_DiSequence {
 
diff --git a/src/class083/Code02_KInversePairsArray.java b/src/class083/Code02_KInversePairsArray.java
index f47145223..dede7494e 100644
--- a/src/class083/Code02_KInversePairsArray.java
+++ b/src/class083/Code02_KInversePairsArray.java
@@ -6,7 +6,7 @@
 // 如果满足0<=i<j<nums.length 且 nums[i]>nums[j]，则为一个逆序对
 // 给你两个整数n和k，找出所有包含从1到n的数字
 // 且恰好拥有k个逆序对的不同的数组的个数
-// 由于答案可能很大，只需要返回对10^9+7取余的结果
+// 由于答案可能很大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/k-inverse-pairs-array/
 public class Code02_KInversePairsArray {
 
diff --git a/src/class084/Code03_CountOfIntegers.java b/src/class084/Code03_CountOfIntegers.java
index 04566df81..f05731a18 100644
--- a/src/class084/Code03_CountOfIntegers.java
+++ b/src/class084/Code03_CountOfIntegers.java
@@ -6,7 +6,7 @@
 // num1 <= x <= num2
 // min_sum <= digit_sum(x) <= max_sum
 // 请你返回好整数的数目
-// 答案可能很大请返回答案对10^9 + 7 取余后的结果
+// 答案可能很大，答案对 1000000007 取模
 // 注意，digit_sum(x)表示x各位数字之和
 // 测试链接 : https://leetcode.cn/problems/count-of-integers/
 public class Code03_CountOfIntegers {
diff --git a/src/class090/Code01_CuttingBamboo.java b/src/class090/Code01_CuttingBamboo.java
index 44d8744ea..9c54d24d6 100644
--- a/src/class090/Code01_CuttingBamboo.java
+++ b/src/class090/Code01_CuttingBamboo.java
@@ -4,7 +4,7 @@
 // 现需要将一根长为正整数bamboo_len的竹子砍为若干段
 // 每段长度均为正整数
 // 请返回每段竹子长度的最大乘积是多少
-// 答案需要对1000000007取模
+// 答案需要对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/jian-sheng-zi-ii-lcof/
 public class Code01_CuttingBamboo {
 
diff --git a/src/class090/Code02_MaximumProduct.java b/src/class090/Code02_MaximumProduct.java
index 870171deb..ff0510a1a 100644
--- a/src/class090/Code02_MaximumProduct.java
+++ b/src/class090/Code02_MaximumProduct.java
@@ -3,7 +3,7 @@
 // 分成k份的最大乘积
 // 一个数字n一定要分成k份，得到的乘积尽量大是多少
 // 数字n和k，可能非常大，到达10^12规模
-// 结果可能更大，所以返回结果对1000000007取模
+// 结果可能更大，所以返回结果对 1000000007 取模
 // 来自真实大厂笔试，没有在线测试，对数器验证
 public class Code02_MaximumProduct {
 
diff --git a/src/class101/Code04_FindAllGoodStrings.java b/src/class101/Code04_FindAllGoodStrings.java
index 0519fc130..51aad4dfd 100644
--- a/src/class101/Code04_FindAllGoodStrings.java
+++ b/src/class101/Code04_FindAllGoodStrings.java
@@ -4,7 +4,7 @@
 // 给你两个长度为n的字符串s1和s2，以及一个字符串evil
 // 好字符串的定义为 : 长度为n，字典序大于等于s1，字典序小于等于s2，且不包含evil字符串
 // 返回好字符串的数量
-// 由于答案很大返回对1000000007取余的结果
+// 由于答案可能很大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/find-all-good-strings/
 public class Code04_FindAllGoodStrings {
 
diff --git a/src/class126/Code02_GridPainting.java b/src/class126/Code02_GridPainting.java
index 9de5f5d7e..af330035f 100644
--- a/src/class126/Code02_GridPainting.java
+++ b/src/class126/Code02_GridPainting.java
@@ -4,7 +4,7 @@
 // 给你两个整数m和n，表示m*n的网格，其中每个单元格最开始是白色
 // 请你用红、绿、蓝三种颜色为每个单元格涂色，所有单元格都需要被涂色
 // 要求相邻单元格的颜色一定要不同
-// 返回网格涂色的方法数，答案对1000000007取余
+// 返回网格涂色的方法数，答案对 1000000007 取模
 // 1 <= m <= 5
 // 1 <= n <= 1000
 // 测试链接 : https://leetcode.cn/problems/painting-a-grid-with-three-different-colors/
diff --git a/src/class127/Code05_WaysOfArrangePlates.java b/src/class127/Code05_WaysOfArrangePlates.java
index fbbdd6efb..a85140137 100644
--- a/src/class127/Code05_WaysOfArrangePlates.java
+++ b/src/class127/Code05_WaysOfArrangePlates.java
@@ -3,7 +3,7 @@
 // 摆盘子的方法
 // 一共有n个盘子k种菜，所有盘子排成一排，每个盘子只能放一种菜
 // 要求最多连续两个盘子菜品一样，更长的重复出现是不允许的
-// 返回摆盘的方法数，答案可能很大，对1000000007取余
+// 返回摆盘的方法数，答案对 1000000007 取模
 // 1 <= n <= 1000
 // 1 <= k <= 1000
 // 来自真实大厂笔试，对数器验证
@@ -150,12 +150,12 @@ public static void main(String[] args) {
 
 		long start, end;
 		start = System.currentTimeMillis();
-		System.out.println("dp2方法结果(已经取余) : " + dp2(n, k));
+		System.out.println("dp2方法结果(已经取模) : " + dp2(n, k));
 		end = System.currentTimeMillis();
 		System.out.println("dp2方法用时(毫秒) : " + (end - start));
 
 		start = System.currentTimeMillis();
-		System.out.println("dp3方法结果(已经取余) : " + dp3(n, k));
+		System.out.println("dp3方法结果(已经取模) : " + dp3(n, k));
 		end = System.currentTimeMillis();
 		System.out.println("dp3方法用时(毫秒) : " + (end - start));
 		System.out.println("性能测试结束");
diff --git a/src/class130/Code06_SumOfTotalStrength.java b/src/class130/Code06_SumOfTotalStrength.java
index 0429da81d..f18c146bf 100644
--- a/src/class130/Code06_SumOfTotalStrength.java
+++ b/src/class130/Code06_SumOfTotalStrength.java
@@ -4,7 +4,7 @@
 // 题目可以简化为如下的描述
 // 给定一个长度为n的数组arr，下标从0开始
 // 任何一个子数组的指标为，子数组累加和 * 子数组中最小值
-// 返回arr中所有子数组指标的累加和，答案对1000000007取余
+// 返回arr中所有子数组指标的累加和，答案对 1000000007 取模
 // 1 <= n <= 10^5
 // 1 <= arr[i] <= 10^9
 // 测试链接 : https://leetcode.cn/problems/sum-of-total-strength-of-wizards/
diff --git a/src/class132/Code03_WaysOfRevert1.java b/src/class132/Code03_WaysOfRevert1.java
index e30ff1055..ea4f7d521 100644
--- a/src/class132/Code03_WaysOfRevert1.java
+++ b/src/class132/Code03_WaysOfRevert1.java
@@ -5,7 +5,7 @@
 // 并且任意i位置的数字都满足 : arr[i] <= max(arr[i-1], arr[i+1])
 // 特别的，arr[1] <= arr[2]，arr[n] <= arr[n-1]
 // 但是输入的arr中有些数字丢失了，丢失的数字用0表示
-// 返回还原成不违规的arr有多少种方法，答案很大需要对998244353取余
+// 返回还原成不违规的arr有多少种方法，答案对 998244353 取模
 // 3 <= n <= 10^4
 // 测试链接 : https://www.nowcoder.com/practice/49c5284278974cbda474ec13d8bd86a9
 // 提交以下的code，提交时请把类名改成"Main"，无法通过所有测试用例
diff --git a/src/class132/Code03_WaysOfRevert2.java b/src/class132/Code03_WaysOfRevert2.java
index 49c65e24b..8fef80c7e 100644
--- a/src/class132/Code03_WaysOfRevert2.java
+++ b/src/class132/Code03_WaysOfRevert2.java
@@ -5,7 +5,7 @@
 // 并且任意i位置的数字都满足 : arr[i] <= max(arr[i-1], arr[i+1])
 // 特别的，arr[1] <= arr[2]，arr[n] <= arr[n-1]
 // 但是输入的arr中有些数字丢失了，丢失的数字用0表示
-// 返回还原成不违规的arr有多少种方法，答案很大需要对998244353取余
+// 返回还原成不违规的arr有多少种方法，答案对 998244353 取模
 // 3 <= n <= 10^4
 // 测试链接 : https://www.nowcoder.com/practice/49c5284278974cbda474ec13d8bd86a9
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class134/Code01_GaussEor.java b/src/class134/Code01_GaussEor.java
index 758887dcc..4779adaac 100644
--- a/src/class134/Code01_GaussEor.java
+++ b/src/class134/Code01_GaussEor.java
@@ -5,7 +5,7 @@
 // 每个数拥有的质数因子一定不超过2000，每个数最多挑选一次
 // 在至少要选一个数的情况下，你可以随意挑选数字乘起来
 // 乘得的结果需要是完全平方数，请问有几种挑选数字的方法
-// 方法数可能很大，结果对1000000007取余
+// 方法数可能很大，答案对 1000000007 取模
 // 1 <= n <= 300
 // 1 <= arr[i] <= 10^18
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5833
diff --git a/src/class136/Code04_Lanterns.java b/src/class136/Code04_Lanterns.java
index 307eb1956..22766856d 100644
--- a/src/class136/Code04_Lanterns.java
+++ b/src/class136/Code04_Lanterns.java
@@ -5,7 +5,7 @@
 // 每个开关能改变若干灯泡的状态，改变是指，亮变不亮、不亮变亮
 // 比如n=5，某个开关为XXOOO，表示这个开关只能改变后3个灯泡的状态
 // 可以随意使用开关，返回有多少种亮灯的组合，全不亮也算一种组合
-// 结果可能很大对2008取余
+// 答案可能很大，对 2008 取模
 // 1 <= n <= 50
 // 1 <= m <= 50
 // 测试链接 : https://www.luogu.com.cn/problem/P3857
diff --git a/src/class144/Code04_SplitWays1.java b/src/class144/Code04_SplitWays1.java
index 32e57f25a..768764733 100644
--- a/src/class144/Code04_SplitWays1.java
+++ b/src/class144/Code04_SplitWays1.java
@@ -8,7 +8,7 @@
 // 返回有多少种有效的划分方式
 // 1 <= n <= 10^7
 // 1 <= A[i] <= 10^7
-// 最终结果可能很大，对1000000007取余
+// 最终结果可能很大，答案对 1000000007 取模
 // 来自真实大厂笔试题，该实现为对数器版本
 // 有同学找到了测试链接，就是Code04_SplitWays2文件
 public class Code04_SplitWays1 {
diff --git a/src/class145/Code02_SetCounting.java b/src/class145/Code02_SetCounting.java
index 877a95ed6..9ea689b33 100644
--- a/src/class145/Code02_SetCounting.java
+++ b/src/class145/Code02_SetCounting.java
@@ -4,7 +4,7 @@
 // 一共有n个不同的数，能构成2^n个不同集合
 // 在2^n个集合中挑出若干个集合，至少挑一个
 // 希望这若干个集合的交集，正好有k个数
-// 返回挑选集合的方案数，答案对 1000000007 取余
+// 返回挑选集合的方案数，答案对 1000000007 取模
 // 1 <= n <= 10^6
 // 0 <= k <= n
 // 测试链接 : https://www.luogu.com.cn/problem/P10596
diff --git a/src/class145/Code03_DistributeSpecialties.java b/src/class145/Code03_DistributeSpecialties.java
index d183dc169..9d106b160 100644
--- a/src/class145/Code03_DistributeSpecialties.java
+++ b/src/class145/Code03_DistributeSpecialties.java
@@ -3,7 +3,7 @@
 // 分特产
 // 一共有m种特产，arr[i]表示i种特产有几个
 // 一共有n个同学，每个同学至少要得到一个特产
-// 返回分配特产的方法数，答案对 1000000007 取余
+// 返回分配特产的方法数，答案对 1000000007 取模
 // 0 <= n、m <= 1000
 // 0 <= arr[i] <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/P5505
diff --git a/src/class145/Code04_NothingFear.java b/src/class145/Code04_NothingFear.java
index 8230a27cb..7230cdf41 100644
--- a/src/class145/Code04_NothingFear.java
+++ b/src/class145/Code04_NothingFear.java
@@ -6,7 +6,7 @@
 // 如果配对之后，糖果能量 > 药片能量，称为糖果大的配对
 // 如果配对之后，糖果能量 < 药片能量，称为药片大的配对
 // 希望做到，糖果大的配对数量 = 药片大的配对数量 + k
-// 返回配对方法数，答案对 1000000009 取余
+// 返回配对方法数，答案对 1000000009 取模
 // 举例，a = [5, 35, 15, 45]，b = [40, 20, 10, 30]，k = 2，返回4，因为有4种配对方法
 // (5-40，35-20，15-10，45-30)、(5-40，35-30，15-10，45-20)
 // (5-20，35-30，15-10，45-40)、(5-30，35-20，15-10，45-40)
diff --git a/src/class145/Code05_Game1.java b/src/class145/Code05_Game1.java
index 2f591f447..779c318e7 100644
--- a/src/class145/Code05_Game1.java
+++ b/src/class145/Code05_Game1.java
@@ -6,7 +6,7 @@
 // 给定长度为n的数组arr，arr[i]的值表示i号节点由谁拥有，0为小A拥有，1为小B拥有
 // 游戏有m回合，每回合都有胜负，两人需要选择一个自己拥有、但之前没选过的点，作为本回合当前点
 // 小A当前点的子树里有小B当前点，则小A胜；小B当前点的子树里有小A当前点，则小B胜；否则平局
-// 返回m回合里能出现k次非平局的游戏方法数，打印k=0..m时的所有答案，对 998244353 取余
+// 返回m回合里能出现k次非平局的游戏方法数，打印k=0..m时的所有答案，对 998244353 取模
 // 两场游戏视为不同的定义：当且仅当存在小A拥有的点x，小B在小A选择x的那个回合所选择的点不同
 // 测试链接 : https://www.luogu.com.cn/problem/P6478
 // 提交以下的code，提交时请把类名改成"Main"，注意dfs是递归函数
diff --git a/src/class145/Code05_Game2.java b/src/class145/Code05_Game2.java
index fd26afc74..05cd69977 100644
--- a/src/class145/Code05_Game2.java
+++ b/src/class145/Code05_Game2.java
@@ -6,7 +6,7 @@
 // 给定长度为n的数组arr，arr[i]的值表示i号节点由谁拥有，0为小A拥有，1为小B拥有
 // 游戏有m回合，每回合都有胜负，两人需要选择一个自己拥有、但之前没选过的点，作为本回合当前点
 // 小A当前点的子树里有小B当前点，则小A胜；小B当前点的子树里有小A当前点，则小B胜；否则平局
-// 返回m回合里能出现k次非平局的游戏方法数，打印k=0..m时的所有答案，对 998244353 取余
+// 返回m回合里能出现k次非平局的游戏方法数，打印k=0..m时的所有答案，对 998244353 取模
 // 两场游戏视为不同的定义：当且仅当存在小A拥有的点x，小B在小A选择x的那个回合所选择的点不同
 // 测试链接 : https://www.luogu.com.cn/problem/P6478
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index bba4e278b..afe105f83 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -1,7 +1,7 @@
 package class147;
 
 // 卡特兰数
-// 测试题目的数据量虽然很小，但请假设数据量很大来实现，答案对 1000000007 取余
+// 测试题目的数据量虽然很小，但请假设数据量很大来实现，答案对 1000000007 取模
 // 测试链接 : https://www.luogu.com.cn/problem/P1044
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class147/Code02_RedMore.java b/src/class147/Code02_RedMore.java
index 064738005..d0b5946a8 100644
--- a/src/class147/Code02_RedMore.java
+++ b/src/class147/Code02_RedMore.java
@@ -1,7 +1,7 @@
 package class147;
 
 // 任意前缀上红大于黑
-// 答案对 100 取余
+// 答案对 100 取模
 // 测试链接 : https://www.luogu.com.cn/problem/P1722
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -16,7 +16,7 @@ public class Code02_RedMore {
 
 	public static int MOD = 100;
 
-	// 因为取余的数字含有很多因子
+	// 因为取模的数字含有很多因子
 	// 无法用费马小定理或者扩展欧几里得求逆元
 	// 所以使用公式4
 	public static long compute(int n) {
diff --git a/src/class147/Code03_CircleLine.java b/src/class147/Code03_CircleLine.java
index 89e135a46..becfc2935 100644
--- a/src/class147/Code03_CircleLine.java
+++ b/src/class147/Code03_CircleLine.java
@@ -1,7 +1,7 @@
 package class147;
 
 // 圆上连线
-// 注意！答案不对 10^9 + 7 取余！而是对 10^8 + 7 取余！
+// 注意！答案不对 10^9 + 7 取模！而是对 10^8 + 7 取模！
 // 测试链接 : https://www.luogu.com.cn/problem/P1976
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class147/Code04_SplitTriangle.java b/src/class147/Code04_SplitTriangle.java
index 09251a44b..02c1feb15 100644
--- a/src/class147/Code04_SplitTriangle.java
+++ b/src/class147/Code04_SplitTriangle.java
@@ -1,7 +1,7 @@
 package class147;
 
 // 划分三角形
-// 答案对 1000000 取余
+// 答案对 1000000 取模
 // 1 <= n <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/SP7897
 // 测试链接 : https://www.spoj.com/problems/SKYLINE
@@ -22,7 +22,7 @@ public class Code04_SplitTriangle {
 
 	public static long[] catalan = new long[MAXN];
 
-	// 因为取余的数字含有很多因子
+	// 因为取模的数字含有很多因子
 	// 无法用费马小定理或者扩展欧几里得求逆元
 	// 所以使用公式4
 	public static void build() {
diff --git a/src/class147/Code07_UniqueTrees.java b/src/class147/Code07_UniqueTrees.java
index da01c02b8..30d1cdf7f 100644
--- a/src/class147/Code07_UniqueTrees.java
+++ b/src/class147/Code07_UniqueTrees.java
@@ -5,7 +5,7 @@
 public class Code07_UniqueTrees {
 
 	// 数据量小用哪个公式都可以
-	// 不用考虑溢出、取余等问题
+	// 不用考虑溢出、取模等问题
 	// 这里用公式4
 	public static int numTrees(int n) {
 		int[] catalan = new int[n + 1];

From 279dbcd48552b3b1fb49097245e9ea9c3bd73034 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 11:57:43 +0800
Subject: [PATCH 0015/1712] modify code

---
 src/class041/Code02_NthMagicalNumber.java       | 2 +-
 src/class052/Code03_SumOfSubarrayMinimums.java  | 2 +-
 src/class066/Code04_DecodeWaysII.java           | 2 +-
 src/class066/Code08_DistinctSubsequencesII.java | 2 +-
 src/class069/Code02_ProfitableSchemes.java      | 2 +-
 5 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class041/Code02_NthMagicalNumber.java b/src/class041/Code02_NthMagicalNumber.java
index 8ffd52f4b..7eedd6037 100644
--- a/src/class041/Code02_NthMagicalNumber.java
+++ b/src/class041/Code02_NthMagicalNumber.java
@@ -2,7 +2,7 @@
 
 // 一个正整数如果能被 a 或 b 整除，那么它是神奇的。
 // 给定三个整数 n , a , b ，返回第 n 个神奇的数字。
-// 因为答案可能很大，所以返回答案 对 10^9 + 7 取模
+// 因为答案可能很大，所以返回答案 对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/nth-magical-number/
 public class Code02_NthMagicalNumber {
 
diff --git a/src/class052/Code03_SumOfSubarrayMinimums.java b/src/class052/Code03_SumOfSubarrayMinimums.java
index f959beb22..15ccfa5d9 100644
--- a/src/class052/Code03_SumOfSubarrayMinimums.java
+++ b/src/class052/Code03_SumOfSubarrayMinimums.java
@@ -2,7 +2,7 @@
 
 // 子数组的最小值之和
 // 给定一个整数数组 arr，找到 min(b) 的总和，其中 b 的范围为 arr 的每个（连续）子数组。
-// 由于答案可能很大，因此 返回答案模 10^9 + 7
+// 由于答案可能很大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/sum-of-subarray-minimums/
 public class Code03_SumOfSubarrayMinimums {
 
diff --git a/src/class066/Code04_DecodeWaysII.java b/src/class066/Code04_DecodeWaysII.java
index d3be45084..bd61f62cd 100644
--- a/src/class066/Code04_DecodeWaysII.java
+++ b/src/class066/Code04_DecodeWaysII.java
@@ -17,7 +17,7 @@
 // 例如，"1*" 可以表示 "11"、"12"、"13"、"14"、"15"、"16"、"17"、"18" 或 "19"
 // 对 "1*" 进行解码，相当于解码该字符串可以表示的任何编码消息
 // 给你一个字符串 s ，由数字和 '*' 字符组成，返回 解码 该字符串的方法 数目
-// 由于答案数目可能非常大，返回10^9 + 7的模
+// 由于答案数目可能非常大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/decode-ways-ii/
 public class Code04_DecodeWaysII {
 
diff --git a/src/class066/Code08_DistinctSubsequencesII.java b/src/class066/Code08_DistinctSubsequencesII.java
index bd02e1935..e73ef5f81 100644
--- a/src/class066/Code08_DistinctSubsequencesII.java
+++ b/src/class066/Code08_DistinctSubsequencesII.java
@@ -2,7 +2,7 @@
 
 // 不同的子序列 II
 // 给定一个字符串 s，计算 s 的 不同非空子序列 的个数
-// 因为结果可能很大，所以返回答案需要对 10^9 + 7 取模
+// 因为结果可能很大，答案对 1000000007 取模
 // 字符串的 子序列 是经由原字符串删除一些（也可能不删除）
 // 字符但不改变剩余字符相对位置的一个新字符串
 // 例如，"ace" 是 "abcde" 的一个子序列，但 "aec" 不是
diff --git a/src/class069/Code02_ProfitableSchemes.java b/src/class069/Code02_ProfitableSchemes.java
index 84039c143..e10d05277 100644
--- a/src/class069/Code02_ProfitableSchemes.java
+++ b/src/class069/Code02_ProfitableSchemes.java
@@ -6,7 +6,7 @@
 // 如果成员参与了其中一项工作，就不能参与另一项工作
 // 工作的任何至少产生 minProfit 利润的子集称为 盈利计划
 // 并且工作的成员总数最多为 n
-// 有多少种计划可以选择？因为答案很大，所以 返回结果模 10^9 + 7 的值。
+// 有多少种计划可以选择？因为答案很大，答案对 1000000007 取模
 // 测试链接 : https://leetcode.cn/problems/profitable-schemes/
 public class Code02_ProfitableSchemes {
 

From 316ba1d66d764887872c659308b4ab25e269c215 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 16:48:57 +0800
Subject: [PATCH 0016/1712] modify code

---
 src/class147/Code02_RedMore.java              |  2 +-
 src/class147/Code03_FunnySequence.java        | 96 +++++++++++++++++++
 ...CircleLine.java => Code04_CircleLine.java} |  2 +-
 ...riangle.java => Code05_SplitTriangle.java} |  4 +-
 ...adder.java => Code06_TreehouseLadder.java} |  2 +-
 ...String.java => Code07_GenerateString.java} |  2 +-
 ...iqueTrees.java => Code08_UniqueTrees.java} |  4 +-
 ...ation.java => Code09_LeafExpectation.java} |  2 +-
 8 files changed, 105 insertions(+), 9 deletions(-)
 create mode 100644 src/class147/Code03_FunnySequence.java
 rename src/class147/{Code03_CircleLine.java => Code04_CircleLine.java} (98%)
 rename src/class147/{Code04_SplitTriangle.java => Code05_SplitTriangle.java} (93%)
 rename src/class147/{Code05_TreehouseLadder.java => Code06_TreehouseLadder.java} (97%)
 rename src/class147/{Code06_GenerateString.java => Code07_GenerateString.java} (97%)
 rename src/class147/{Code07_UniqueTrees.java => Code08_UniqueTrees.java} (83%)
 rename src/class147/{Code08_LeafExpectation.java => Code09_LeafExpectation.java} (95%)

diff --git a/src/class147/Code02_RedMore.java b/src/class147/Code02_RedMore.java
index d0b5946a8..4ed514011 100644
--- a/src/class147/Code02_RedMore.java
+++ b/src/class147/Code02_RedMore.java
@@ -18,7 +18,7 @@ public class Code02_RedMore {
 
 	// 因为取模的数字含有很多因子
 	// 无法用费马小定理或者扩展欧几里得求逆元
-	// 所以使用公式4
+	// 同时注意到n的范围并不大，直接使用公式4
 	public static long compute(int n) {
 		long[] catalan = new long[n + 1];
 		catalan[0] = catalan[1] = 1;
diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code03_FunnySequence.java
new file mode 100644
index 000000000..15d4846d2
--- /dev/null
+++ b/src/class147/Code03_FunnySequence.java
@@ -0,0 +1,96 @@
+package class147;
+
+// 有趣的数列(重要！质因子计数法)
+// 测试链接 : https://www.luogu.com.cn/problem/P3200
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_FunnySequence {
+
+	public static int MAXN = 2000001;
+
+	public static boolean[] visit = new boolean[MAXN];
+
+	public static int[] prime = new int[MAXN];
+
+	public static int cnt;
+
+	public static int[] minpf = new int[MAXN];
+
+	public static int[] counts = new int[MAXN];
+
+	// 来自讲解097，欧拉筛，时间复杂度O(n)
+	public static void euler(int n) {
+		Arrays.fill(visit, 1, n, false);
+		cnt = 0;
+		for (int i = 2; i <= n; i++) {
+			if (!visit[i]) {
+				prime[++cnt] = i;
+			}
+			for (int j = 1; j <= cnt; j++) {
+				if (i * prime[j] > n) {
+					break;
+				}
+				visit[i * prime[j]] = true;
+				minpf[i * prime[j]] = prime[j];
+				if (i % prime[j] == 0) {
+					break;
+				}
+			}
+		}
+	}
+
+	public static long power(long x, long p, int mod) {
+		long ans = 1;
+		while (p > 0) {
+			if ((p & 1) == 1) {
+				ans = (ans * x) % mod;
+			}
+			x = (x * x) % mod;
+			p >>= 1;
+		}
+		return ans;
+	}
+
+	// 使用的是公式2 + 质因子计数法
+	public static int compute(int n, int mod) {
+		euler(2 * n);
+		Arrays.fill(counts, 2, n + 1, -1);
+		Arrays.fill(counts, n + 2, 2 * n + 1, 1);
+		for (int i = 2 * n; i >= 2; i--) {
+			if (minpf[i] != 0) {
+				counts[minpf[i]] += counts[i];
+				counts[i / minpf[i]] += counts[i];
+			}
+		}
+		long ans = 1;
+		for (int i = 2; i <= 2 * n; i++) {
+			if (minpf[i] == 0) {
+				ans = ans * power(i, counts[i], mod) % mod;
+			}
+		}
+		return (int) ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int mod = (int) in.nval;
+		out.println(compute(n, mod));
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class147/Code03_CircleLine.java b/src/class147/Code04_CircleLine.java
similarity index 98%
rename from src/class147/Code03_CircleLine.java
rename to src/class147/Code04_CircleLine.java
index becfc2935..af5e1268c 100644
--- a/src/class147/Code03_CircleLine.java
+++ b/src/class147/Code04_CircleLine.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_CircleLine {
+public class Code04_CircleLine {
 
 	public static int MOD = 100000007;
 
diff --git a/src/class147/Code04_SplitTriangle.java b/src/class147/Code05_SplitTriangle.java
similarity index 93%
rename from src/class147/Code04_SplitTriangle.java
rename to src/class147/Code05_SplitTriangle.java
index 02c1feb15..83dd21f31 100644
--- a/src/class147/Code04_SplitTriangle.java
+++ b/src/class147/Code05_SplitTriangle.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_SplitTriangle {
+public class Code05_SplitTriangle {
 
 	public static int MOD = 1000000;
 
@@ -24,7 +24,7 @@ public class Code04_SplitTriangle {
 
 	// 因为取模的数字含有很多因子
 	// 无法用费马小定理或者扩展欧几里得求逆元
-	// 所以使用公式4
+	// 同时注意到n的范围并不大，直接使用公式4
 	public static void build() {
 		catalan[0] = catalan[1] = 1;
 		for (int i = 2; i < MAXN; i++) {
diff --git a/src/class147/Code05_TreehouseLadder.java b/src/class147/Code06_TreehouseLadder.java
similarity index 97%
rename from src/class147/Code05_TreehouseLadder.java
rename to src/class147/Code06_TreehouseLadder.java
index 983103dc5..3fb214369 100644
--- a/src/class147/Code05_TreehouseLadder.java
+++ b/src/class147/Code06_TreehouseLadder.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.math.BigInteger;
 
-public class Code05_TreehouseLadder {
+public class Code06_TreehouseLadder {
 
 	// 这里用公式2
 	// java同学使用BigInteger即可
diff --git a/src/class147/Code06_GenerateString.java b/src/class147/Code07_GenerateString.java
similarity index 97%
rename from src/class147/Code06_GenerateString.java
rename to src/class147/Code07_GenerateString.java
index e9bb375e0..75199734b 100644
--- a/src/class147/Code06_GenerateString.java
+++ b/src/class147/Code07_GenerateString.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_GenerateString {
+public class Code07_GenerateString {
 
 	public static int MOD = 20100403;
 
diff --git a/src/class147/Code07_UniqueTrees.java b/src/class147/Code08_UniqueTrees.java
similarity index 83%
rename from src/class147/Code07_UniqueTrees.java
rename to src/class147/Code08_UniqueTrees.java
index 30d1cdf7f..3ae2045f8 100644
--- a/src/class147/Code07_UniqueTrees.java
+++ b/src/class147/Code08_UniqueTrees.java
@@ -2,11 +2,11 @@
 
 // 不同的二叉搜索树
 // 测试链接 : https://leetcode.cn/problems/unique-binary-search-trees/
-public class Code07_UniqueTrees {
+public class Code08_UniqueTrees {
 
 	// 数据量小用哪个公式都可以
 	// 不用考虑溢出、取模等问题
-	// 这里用公式4
+	// 同时注意到n的范围并不大，直接使用公式4
 	public static int numTrees(int n) {
 		int[] catalan = new int[n + 1];
 		catalan[0] = catalan[1] = 1;
diff --git a/src/class147/Code08_LeafExpectation.java b/src/class147/Code09_LeafExpectation.java
similarity index 95%
rename from src/class147/Code08_LeafExpectation.java
rename to src/class147/Code09_LeafExpectation.java
index 1a6114ea4..2e4b3d158 100644
--- a/src/class147/Code08_LeafExpectation.java
+++ b/src/class147/Code09_LeafExpectation.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code08_LeafExpectation {
+public class Code09_LeafExpectation {
 
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));

From a35b331ea82fd4412b1d9a315346027123bfef84 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 19:01:22 +0800
Subject: [PATCH 0017/1712] modify code

---
 src/class147/Code03_FunnySequence.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code03_FunnySequence.java
index 15d4846d2..6709c92ad 100644
--- a/src/class147/Code03_FunnySequence.java
+++ b/src/class147/Code03_FunnySequence.java
@@ -68,11 +68,12 @@ public static int compute(int n, int mod) {
 			if (minpf[i] != 0) {
 				counts[minpf[i]] += counts[i];
 				counts[i / minpf[i]] += counts[i];
+				counts[i] = 0;
 			}
 		}
 		long ans = 1;
 		for (int i = 2; i <= 2 * n; i++) {
-			if (minpf[i] == 0) {
+			if (counts[i] != 0) {
 				ans = ans * power(i, counts[i], mod) % mod;
 			}
 		}

From fa009ccf8483003cee3179499acd84bec5f70d24 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 19:07:18 +0800
Subject: [PATCH 0018/1712] modify code

---
 src/class147/Code03_FunnySequence.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code03_FunnySequence.java
index 6709c92ad..207816cde 100644
--- a/src/class147/Code03_FunnySequence.java
+++ b/src/class147/Code03_FunnySequence.java
@@ -22,6 +22,8 @@ public class Code03_FunnySequence {
 
 	public static int cnt;
 
+	// 如果minpf[i] == 0，代表i是质数
+	// 如果minpf[i] != 0，代表i的最小质因子是minpf[i]
 	public static int[] minpf = new int[MAXN];
 
 	public static int[] counts = new int[MAXN];
@@ -39,6 +41,8 @@ public static void euler(int n) {
 					break;
 				}
 				visit[i * prime[j]] = true;
+				// 讲解097重点解释了欧拉筛的过程，看完必懂
+				// 此时可以收集(i * prime[j])这个数的最小质因子为prime[j]
 				minpf[i * prime[j]] = prime[j];
 				if (i % prime[j] == 0) {
 					break;

From 19a2827705515a4b6ac81dc94915932b81f49b47 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Oct 2024 19:25:24 +0800
Subject: [PATCH 0019/1712] modify code

---
 src/class147/Code03_FunnySequence.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code03_FunnySequence.java
index 207816cde..86a0ae780 100644
--- a/src/class147/Code03_FunnySequence.java
+++ b/src/class147/Code03_FunnySequence.java
@@ -34,15 +34,15 @@ public static void euler(int n) {
 		cnt = 0;
 		for (int i = 2; i <= n; i++) {
 			if (!visit[i]) {
-				prime[++cnt] = i;
+				prime[cnt++] = i;
 			}
-			for (int j = 1; j <= cnt; j++) {
+			for (int j = 0; j < cnt; j++) {
 				if (i * prime[j] > n) {
 					break;
 				}
 				visit[i * prime[j]] = true;
-				// 讲解097重点解释了欧拉筛的过程，看完必懂
-				// 此时可以收集(i * prime[j])这个数的最小质因子为prime[j]
+				// 此时收集(i * prime[j])这个数的最小质因子为prime[j]
+				// 讲解097欧拉筛的部分重点解释了这个过程，看完必懂
 				minpf[i * prime[j]] = prime[j];
 				if (i % prime[j] == 0) {
 					break;

From 2070ae14dca61a86985bdc490c34edf43ae9ba1c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Oct 2024 10:38:39 +0800
Subject: [PATCH 0020/1712] modify code

---
 src/class147/Code03_FunnySequence.java | 20 +++++++++++---------
 1 file changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code03_FunnySequence.java
index 86a0ae780..0ea03bb36 100644
--- a/src/class147/Code03_FunnySequence.java
+++ b/src/class147/Code03_FunnySequence.java
@@ -16,33 +16,35 @@ public class Code03_FunnySequence {
 
 	public static int MAXN = 2000001;
 
-	public static boolean[] visit = new boolean[MAXN];
+	// 如果minpf[i] == 0，代表i是质数
+	// 如果minpf[i] != 0，代表i是合数，并且最小质因子是minpf[i]
+	public static int[] minpf = new int[MAXN];
 
+	// 质数表
 	public static int[] prime = new int[MAXN];
 
 	public static int cnt;
 
-	// 如果minpf[i] == 0，代表i是质数
-	// 如果minpf[i] != 0，代表i的最小质因子是minpf[i]
-	public static int[] minpf = new int[MAXN];
-
+	// 因子计数
 	public static int[] counts = new int[MAXN];
 
 	// 来自讲解097，欧拉筛，时间复杂度O(n)
 	public static void euler(int n) {
-		Arrays.fill(visit, 1, n, false);
+		Arrays.fill(minpf, 2, n, 0);
 		cnt = 0;
 		for (int i = 2; i <= n; i++) {
-			if (!visit[i]) {
+			// minpf[i] == 0代表i为质数，收集进质数表
+			// minpf数组替代了讲解097中visit数组的作用
+			if (minpf[i] == 0) {
 				prime[cnt++] = i;
 			}
 			for (int j = 0; j < cnt; j++) {
 				if (i * prime[j] > n) {
 					break;
 				}
-				visit[i * prime[j]] = true;
 				// 此时收集(i * prime[j])这个数的最小质因子为prime[j]
-				// 讲解097欧拉筛的部分重点解释了这个过程，看完必懂
+				// minpf[i * prime[j]] != 0，也标记了(i * prime[j])不是质数
+				// 讲解097欧拉筛的部分，重点解释了这个过程，看完必懂
 				minpf[i * prime[j]] = prime[j];
 				if (i % prime[j] == 0) {
 					break;

From 9bee637930ea819c2a7a1e8e7730ce3fca0e19ea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Oct 2024 10:40:43 +0800
Subject: [PATCH 0021/1712] modify code

---
 src/class147/Code03_FunnySequence.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code03_FunnySequence.java
index 0ea03bb36..6c5b68850 100644
--- a/src/class147/Code03_FunnySequence.java
+++ b/src/class147/Code03_FunnySequence.java
@@ -23,6 +23,7 @@ public class Code03_FunnySequence {
 	// 质数表
 	public static int[] prime = new int[MAXN];
 
+	// 质数表大小
 	public static int cnt;
 
 	// 因子计数
@@ -43,7 +44,7 @@ public static void euler(int n) {
 					break;
 				}
 				// 此时收集(i * prime[j])这个数的最小质因子为prime[j]
-				// minpf[i * prime[j]] != 0，也标记了(i * prime[j])不是质数
+				// minpf[i * prime[j]] != 0，也标记了(i * prime[j])是合数
 				// 讲解097欧拉筛的部分，重点解释了这个过程，看完必懂
 				minpf[i * prime[j]] = prime[j];
 				if (i % prime[j] == 0) {

From 8606a744302a7ac493d650be1558be295fa5875d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Oct 2024 10:52:25 +0800
Subject: [PATCH 0022/1712] modify code

---
 src/class147/Code03_FunnySequence.java | 9 +++++++++
 1 file changed, 9 insertions(+)

diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code03_FunnySequence.java
index 6c5b68850..3d7fd783c 100644
--- a/src/class147/Code03_FunnySequence.java
+++ b/src/class147/Code03_FunnySequence.java
@@ -68,9 +68,17 @@ public static long power(long x, long p, int mod) {
 
 	// 使用的是公式2 + 质因子计数法
 	public static int compute(int n, int mod) {
+		// 利用欧拉筛生成[2 ~ 2*n]范围上所有数的最小质因子
+		// 如果x为质数，minpf[x] == 0
+		// 如果x为合数，x的最小质因子为minpf[x]
 		euler(2 * n);
+		// 分母每个因子设置计数
 		Arrays.fill(counts, 2, n + 1, -1);
+		// 分子每个因子设置计数
 		Arrays.fill(counts, n + 2, 2 * n + 1, 1);
+		// 从大到小的每个数统计计数
+		// 合数根据最小质因子来分解，变成更小数字的计数
+		// 质数无法分解，计数确定，最后快速幂计算乘积
 		for (int i = 2 * n; i >= 2; i--) {
 			if (minpf[i] != 0) {
 				counts[minpf[i]] += counts[i];
@@ -78,6 +86,7 @@ public static int compute(int n, int mod) {
 				counts[i] = 0;
 			}
 		}
+		// 每个质数的幂，都乘起来，就是最后答案
 		long ans = 1;
 		for (int i = 2; i <= 2 * n; i++) {
 			if (counts[i] != 0) {

From e9e26c398534641196412d0ba297222a94c86472 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Oct 2024 11:46:44 +0800
Subject: [PATCH 0023/1712] modify code

---
 ...{Code06_TreehouseLadder.java => Code04_TreehouseLadder.java} | 2 +-
 .../{Code07_GenerateString.java => Code05_GenerateString.java}  | 2 +-
 src/class147/{Code04_CircleLine.java => Code06_CircleLine.java} | 2 +-
 .../{Code05_SplitTriangle.java => Code07_SplitTriangle.java}    | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class147/{Code06_TreehouseLadder.java => Code04_TreehouseLadder.java} (97%)
 rename src/class147/{Code07_GenerateString.java => Code05_GenerateString.java} (97%)
 rename src/class147/{Code04_CircleLine.java => Code06_CircleLine.java} (98%)
 rename src/class147/{Code05_SplitTriangle.java => Code07_SplitTriangle.java} (97%)

diff --git a/src/class147/Code06_TreehouseLadder.java b/src/class147/Code04_TreehouseLadder.java
similarity index 97%
rename from src/class147/Code06_TreehouseLadder.java
rename to src/class147/Code04_TreehouseLadder.java
index 3fb214369..a0200dbbd 100644
--- a/src/class147/Code06_TreehouseLadder.java
+++ b/src/class147/Code04_TreehouseLadder.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.math.BigInteger;
 
-public class Code06_TreehouseLadder {
+public class Code04_TreehouseLadder {
 
 	// 这里用公式2
 	// java同学使用BigInteger即可
diff --git a/src/class147/Code07_GenerateString.java b/src/class147/Code05_GenerateString.java
similarity index 97%
rename from src/class147/Code07_GenerateString.java
rename to src/class147/Code05_GenerateString.java
index 75199734b..6c1474fda 100644
--- a/src/class147/Code07_GenerateString.java
+++ b/src/class147/Code05_GenerateString.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code07_GenerateString {
+public class Code05_GenerateString {
 
 	public static int MOD = 20100403;
 
diff --git a/src/class147/Code04_CircleLine.java b/src/class147/Code06_CircleLine.java
similarity index 98%
rename from src/class147/Code04_CircleLine.java
rename to src/class147/Code06_CircleLine.java
index af5e1268c..8dcbb7253 100644
--- a/src/class147/Code04_CircleLine.java
+++ b/src/class147/Code06_CircleLine.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_CircleLine {
+public class Code06_CircleLine {
 
 	public static int MOD = 100000007;
 
diff --git a/src/class147/Code05_SplitTriangle.java b/src/class147/Code07_SplitTriangle.java
similarity index 97%
rename from src/class147/Code05_SplitTriangle.java
rename to src/class147/Code07_SplitTriangle.java
index 83dd21f31..7a66e5d4f 100644
--- a/src/class147/Code05_SplitTriangle.java
+++ b/src/class147/Code07_SplitTriangle.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_SplitTriangle {
+public class Code07_SplitTriangle {
 
 	public static int MOD = 1000000;
 

From 7fc6f61d55bf3e99962c1d03b81bcf3b1e4a0ad5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Oct 2024 16:28:04 +0800
Subject: [PATCH 0024/1712] modify code

---
 src/class147/Code01_Catalan.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index afe105f83..d3b8ac2fc 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 卡特兰数
+// 卡特兰数模版
 // 测试题目的数据量虽然很小，但请假设数据量很大来实现，答案对 1000000007 取模
 // 测试链接 : https://www.luogu.com.cn/problem/P1044
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From b431b398de1a43a9daf27bfb22121576764a1795 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Oct 2024 17:53:05 +0800
Subject: [PATCH 0025/1712] modify code

---
 src/class147/{Code06_CircleLine.java => Code02_CircleLine.java} | 2 +-
 src/class147/{Code02_RedMore.java => Code03_RedMore.java}       | 2 +-
 .../{Code03_FunnySequence.java => Code04_FunnySequence.java}    | 2 +-
 .../{Code07_SplitTriangle.java => Code06_SplitTriangle.java}    | 2 +-
 .../{Code08_UniqueTrees.java => Code07_UniqueTrees.java}        | 2 +-
 ...{Code04_TreehouseLadder.java => Code08_TreehouseLadder.java} | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)
 rename src/class147/{Code06_CircleLine.java => Code02_CircleLine.java} (98%)
 rename src/class147/{Code02_RedMore.java => Code03_RedMore.java} (97%)
 rename src/class147/{Code03_FunnySequence.java => Code04_FunnySequence.java} (98%)
 rename src/class147/{Code07_SplitTriangle.java => Code06_SplitTriangle.java} (97%)
 rename src/class147/{Code08_UniqueTrees.java => Code07_UniqueTrees.java} (93%)
 rename src/class147/{Code04_TreehouseLadder.java => Code08_TreehouseLadder.java} (97%)

diff --git a/src/class147/Code06_CircleLine.java b/src/class147/Code02_CircleLine.java
similarity index 98%
rename from src/class147/Code06_CircleLine.java
rename to src/class147/Code02_CircleLine.java
index 8dcbb7253..93ecc7ddc 100644
--- a/src/class147/Code06_CircleLine.java
+++ b/src/class147/Code02_CircleLine.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_CircleLine {
+public class Code02_CircleLine {
 
 	public static int MOD = 100000007;
 
diff --git a/src/class147/Code02_RedMore.java b/src/class147/Code03_RedMore.java
similarity index 97%
rename from src/class147/Code02_RedMore.java
rename to src/class147/Code03_RedMore.java
index 4ed514011..d421732b7 100644
--- a/src/class147/Code02_RedMore.java
+++ b/src/class147/Code03_RedMore.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_RedMore {
+public class Code03_RedMore {
 
 	public static int MOD = 100;
 
diff --git a/src/class147/Code03_FunnySequence.java b/src/class147/Code04_FunnySequence.java
similarity index 98%
rename from src/class147/Code03_FunnySequence.java
rename to src/class147/Code04_FunnySequence.java
index 3d7fd783c..6233ecc23 100644
--- a/src/class147/Code03_FunnySequence.java
+++ b/src/class147/Code04_FunnySequence.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_FunnySequence {
+public class Code04_FunnySequence {
 
 	public static int MAXN = 2000001;
 
diff --git a/src/class147/Code07_SplitTriangle.java b/src/class147/Code06_SplitTriangle.java
similarity index 97%
rename from src/class147/Code07_SplitTriangle.java
rename to src/class147/Code06_SplitTriangle.java
index 7a66e5d4f..1bb22077a 100644
--- a/src/class147/Code07_SplitTriangle.java
+++ b/src/class147/Code06_SplitTriangle.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code07_SplitTriangle {
+public class Code06_SplitTriangle {
 
 	public static int MOD = 1000000;
 
diff --git a/src/class147/Code08_UniqueTrees.java b/src/class147/Code07_UniqueTrees.java
similarity index 93%
rename from src/class147/Code08_UniqueTrees.java
rename to src/class147/Code07_UniqueTrees.java
index 3ae2045f8..6cb2c1a48 100644
--- a/src/class147/Code08_UniqueTrees.java
+++ b/src/class147/Code07_UniqueTrees.java
@@ -2,7 +2,7 @@
 
 // 不同的二叉搜索树
 // 测试链接 : https://leetcode.cn/problems/unique-binary-search-trees/
-public class Code08_UniqueTrees {
+public class Code07_UniqueTrees {
 
 	// 数据量小用哪个公式都可以
 	// 不用考虑溢出、取模等问题
diff --git a/src/class147/Code04_TreehouseLadder.java b/src/class147/Code08_TreehouseLadder.java
similarity index 97%
rename from src/class147/Code04_TreehouseLadder.java
rename to src/class147/Code08_TreehouseLadder.java
index a0200dbbd..fcd4040c8 100644
--- a/src/class147/Code04_TreehouseLadder.java
+++ b/src/class147/Code08_TreehouseLadder.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.math.BigInteger;
 
-public class Code04_TreehouseLadder {
+public class Code08_TreehouseLadder {
 
 	// 这里用公式2
 	// java同学使用BigInteger即可

From 3db7fe2f863950e74d6cfb79ab79762eaaa3bfcf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Oct 2024 02:15:26 +0800
Subject: [PATCH 0026/1712] modify code

---
 src/class147/Code01_Catalan.java                 | 16 ++++++++--------
 src/class147/Code03_RedMore.java                 |  8 ++++----
 ...tTriangle.java => Code06_CatalanSkyline.java} | 12 ++++++------
 src/class147/Code07_UniqueTrees.java             |  8 ++++----
 4 files changed, 22 insertions(+), 22 deletions(-)
 rename src/class147/{Code06_SplitTriangle.java => Code06_CatalanSkyline.java} (84%)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index d3b8ac2fc..55bbf9dab 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -79,24 +79,24 @@ public static long compute2(int n) {
 	// 公式3
 	public static long compute3(int n) {
 		build2(n);
-		long[] catalan = new long[n + 1];
-		catalan[0] = catalan[1] = 1;
+		long[] f = new long[n + 1];
+		f[0] = f[1] = 1;
 		for (int i = 2; i <= n; i++) {
-			catalan[i] = catalan[i - 1] * (4 * i - 2) % MOD * inv2[i + 1] % MOD;
+			f[i] = f[i - 1] * (4 * i - 2) % MOD * inv2[i + 1] % MOD;
 		}
-		return catalan[n];
+		return f[n];
 	}
 
 	// 公式4
 	public static long compute4(int n) {
-		long[] catalan = new long[n + 1];
-		catalan[0] = catalan[1] = 1;
+		long[] f = new long[n + 1];
+		f[0] = f[1] = 1;
 		for (int i = 2; i <= n; i++) {
 			for (int l = 0, r = i - 1; l < i; l++, r--) {
-				catalan[i] = (catalan[i] + catalan[l] * catalan[r] % MOD) % MOD;
+				f[i] = (f[i] + f[l] * f[r] % MOD) % MOD;
 			}
 		}
-		return catalan[n];
+		return f[n];
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class147/Code03_RedMore.java b/src/class147/Code03_RedMore.java
index d421732b7..c204b041b 100644
--- a/src/class147/Code03_RedMore.java
+++ b/src/class147/Code03_RedMore.java
@@ -20,14 +20,14 @@ public class Code03_RedMore {
 	// 无法用费马小定理或者扩展欧几里得求逆元
 	// 同时注意到n的范围并不大，直接使用公式4
 	public static long compute(int n) {
-		long[] catalan = new long[n + 1];
-		catalan[0] = catalan[1] = 1;
+		long[] f = new long[n + 1];
+		f[0] = f[1] = 1;
 		for (int i = 2; i <= n; i++) {
 			for (int l = 0, r = i - 1; l < i; l++, r--) {
-				catalan[i] = (catalan[i] + catalan[l] * catalan[r] % MOD) % MOD;
+				f[i] = (f[i] + f[l] * f[r] % MOD) % MOD;
 			}
 		}
-		return catalan[n];
+		return f[n];
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class147/Code06_SplitTriangle.java b/src/class147/Code06_CatalanSkyline.java
similarity index 84%
rename from src/class147/Code06_SplitTriangle.java
rename to src/class147/Code06_CatalanSkyline.java
index 1bb22077a..32bb483f2 100644
--- a/src/class147/Code06_SplitTriangle.java
+++ b/src/class147/Code06_CatalanSkyline.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 划分三角形
+// 卡特兰数天际线
 // 答案对 1000000 取模
 // 1 <= n <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/SP7897
@@ -14,22 +14,22 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_SplitTriangle {
+public class Code06_CatalanSkyline {
 
 	public static int MOD = 1000000;
 
 	public static int MAXN = 1001;
 
-	public static long[] catalan = new long[MAXN];
+	public static long[] f = new long[MAXN];
 
 	// 因为取模的数字含有很多因子
 	// 无法用费马小定理或者扩展欧几里得求逆元
 	// 同时注意到n的范围并不大，直接使用公式4
 	public static void build() {
-		catalan[0] = catalan[1] = 1;
+		f[0] = f[1] = 1;
 		for (int i = 2; i < MAXN; i++) {
 			for (int l = 0, r = i - 1; l < i; l++, r--) {
-				catalan[i] = (catalan[i] + catalan[l] * catalan[r] % MOD) % MOD;
+				f[i] = (f[i] + f[l] * f[r] % MOD) % MOD;
 			}
 		}
 	}
@@ -44,7 +44,7 @@ public static void main(String[] args) throws IOException {
 			if (n == 0) {
 				break;
 			}
-			out.println(catalan[n]);
+			out.println(f[n]);
 		}
 		out.flush();
 		out.close();
diff --git a/src/class147/Code07_UniqueTrees.java b/src/class147/Code07_UniqueTrees.java
index 6cb2c1a48..fae553484 100644
--- a/src/class147/Code07_UniqueTrees.java
+++ b/src/class147/Code07_UniqueTrees.java
@@ -8,14 +8,14 @@ public class Code07_UniqueTrees {
 	// 不用考虑溢出、取模等问题
 	// 同时注意到n的范围并不大，直接使用公式4
 	public static int numTrees(int n) {
-		int[] catalan = new int[n + 1];
-		catalan[0] = catalan[1] = 1;
+		int[] f = new int[n + 1];
+		f[0] = f[1] = 1;
 		for (int i = 2; i <= n; i++) {
 			for (int l = 0, r = i - 1; l < i; l++, r--) {
-				catalan[i] += catalan[l] * catalan[r];
+				f[i] += f[l] * f[r];
 			}
 		}
-		return catalan[n];
+		return f[n];
 	}
 
 }

From 17d7b03abc504ce62668d0fb038d71d931578884 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Oct 2024 12:01:21 +0800
Subject: [PATCH 0027/1712] modify code

---
 src/class147/Code01_Catalan.java       | 4 ++--
 src/class147/Code04_FunnySequence.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index 55bbf9dab..8a31a53f0 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -24,7 +24,7 @@ public class Code01_Catalan {
 	// 阶乘逆元表
 	public static long[] inv1 = new long[MAXN];
 
-	// 数字逆元表
+	// 连续数逆元表
 	public static long[] inv2 = new long[MAXN];
 
 	// 来自讲解099，题目3，生成阶乘余数表、阶乘逆元表
@@ -40,7 +40,7 @@ public static void build1(int n) {
 		}
 	}
 
-	// 来自讲解099，题目2，生成连续数字的逆元表
+	// 来自讲解099，题目2，生成连续数逆元表
 	public static void build2(int n) {
 		inv2[1] = 1;
 		for (int i = 2; i <= n + 1; i++) {
diff --git a/src/class147/Code04_FunnySequence.java b/src/class147/Code04_FunnySequence.java
index 6233ecc23..d4e2e9876 100644
--- a/src/class147/Code04_FunnySequence.java
+++ b/src/class147/Code04_FunnySequence.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 有趣的数列(重要！质因子计数法)
+// 有趣的数列(重要！因子计数法)
 // 测试链接 : https://www.luogu.com.cn/problem/P3200
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From be818f2b228d53272885c25edbe4cc194d037c59 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Oct 2024 14:37:25 +0800
Subject: [PATCH 0028/1712] modify code

---
 src/class147/Code01_Catalan.java                           | 1 +
 src/class147/Code02_CircleLine.java                        | 2 ++
 src/class147/Code03_RedMore.java                           | 4 +++-
 .../{Code07_UniqueTrees.java => Code04_UniqueTrees.java}   | 4 +++-
 ...Code04_FunnySequence.java => Code05_FunnySequence.java} | 6 +++++-
 ...de05_GenerateString.java => Code06_GenerateString.java} | 5 ++++-
 .../{Code06_CatalanSkyline.java => Code07_Skyline.java}    | 7 ++++---
 src/class147/Code08_TreehouseLadder.java                   | 4 ++++
 src/class147/Code09_LeafExpectation.java                   | 4 ++++
 9 files changed, 30 insertions(+), 7 deletions(-)
 rename src/class147/{Code07_UniqueTrees.java => Code04_UniqueTrees.java} (75%)
 rename src/class147/{Code04_FunnySequence.java => Code05_FunnySequence.java} (95%)
 rename src/class147/{Code05_GenerateString.java => Code06_GenerateString.java} (88%)
 rename src/class147/{Code06_CatalanSkyline.java => Code07_Skyline.java} (84%)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index 8a31a53f0..1fb81c9df 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -1,6 +1,7 @@
 package class147;
 
 // 卡特兰数模版
+// 进栈顺序规定为1、2、3..n，返回有多少种不同的出栈顺序
 // 测试题目的数据量虽然很小，但请假设数据量很大来实现，答案对 1000000007 取模
 // 测试链接 : https://www.luogu.com.cn/problem/P1044
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class147/Code02_CircleLine.java b/src/class147/Code02_CircleLine.java
index 93ecc7ddc..4866d6651 100644
--- a/src/class147/Code02_CircleLine.java
+++ b/src/class147/Code02_CircleLine.java
@@ -1,7 +1,9 @@
 package class147;
 
 // 圆上连线
+// 圆上有2n个点，这些点成对连接起来，形成n条线段，任意两条线段不能相交，返回连接的方法数
 // 注意！答案不对 10^9 + 7 取模！而是对 10^8 + 7 取模！
+// 1 <= n <= 2999
 // 测试链接 : https://www.luogu.com.cn/problem/P1976
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class147/Code03_RedMore.java b/src/class147/Code03_RedMore.java
index c204b041b..1c3bcfd43 100644
--- a/src/class147/Code03_RedMore.java
+++ b/src/class147/Code03_RedMore.java
@@ -1,7 +1,9 @@
 package class147;
 
 // 任意前缀上红大于黑
-// 答案对 100 取模
+// 有n个红和n个黑，要组成2n长度的数列，保证任意前缀上，红的数量 >= 黑的数量
+// 返回有多少种排列方法，答案对 100 取模
+// 1 <= n <= 100
 // 测试链接 : https://www.luogu.com.cn/problem/P1722
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class147/Code07_UniqueTrees.java b/src/class147/Code04_UniqueTrees.java
similarity index 75%
rename from src/class147/Code07_UniqueTrees.java
rename to src/class147/Code04_UniqueTrees.java
index fae553484..8deaff1fc 100644
--- a/src/class147/Code07_UniqueTrees.java
+++ b/src/class147/Code04_UniqueTrees.java
@@ -1,8 +1,10 @@
 package class147;
 
 // 不同的二叉搜索树
+// 一共有n个节点，认为节点之间无差别，返回能形成多少种不同结构的二叉树
+// 1 <= n <= 19
 // 测试链接 : https://leetcode.cn/problems/unique-binary-search-trees/
-public class Code07_UniqueTrees {
+public class Code04_UniqueTrees {
 
 	// 数据量小用哪个公式都可以
 	// 不用考虑溢出、取模等问题
diff --git a/src/class147/Code04_FunnySequence.java b/src/class147/Code05_FunnySequence.java
similarity index 95%
rename from src/class147/Code04_FunnySequence.java
rename to src/class147/Code05_FunnySequence.java
index d4e2e9876..c5b9dc122 100644
--- a/src/class147/Code04_FunnySequence.java
+++ b/src/class147/Code05_FunnySequence.java
@@ -1,6 +1,10 @@
 package class147;
 
 // 有趣的数列(重要！因子计数法)
+// 求第n项卡特兰数，要求答案对p取模
+// 1 <= n <= 10^6
+// 1 <= p <= 10^9
+// p可能不为质数
 // 测试链接 : https://www.luogu.com.cn/problem/P3200
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +16,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_FunnySequence {
+public class Code05_FunnySequence {
 
 	public static int MAXN = 2000001;
 
diff --git a/src/class147/Code05_GenerateString.java b/src/class147/Code06_GenerateString.java
similarity index 88%
rename from src/class147/Code05_GenerateString.java
rename to src/class147/Code06_GenerateString.java
index 6c1474fda..c2bf50568 100644
--- a/src/class147/Code05_GenerateString.java
+++ b/src/class147/Code06_GenerateString.java
@@ -1,6 +1,9 @@
 package class147;
 
 // 生成字符串
+// 有n个1和m个0，要组成n+m长度的数列，保证任意前缀上，1的数量 >= 0的数量
+// 返回有多少种排列方法，答案对 20100403 取模
+// 1 <= m <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P1641
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -11,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_GenerateString {
+public class Code06_GenerateString {
 
 	public static int MOD = 20100403;
 
diff --git a/src/class147/Code06_CatalanSkyline.java b/src/class147/Code07_Skyline.java
similarity index 84%
rename from src/class147/Code06_CatalanSkyline.java
rename to src/class147/Code07_Skyline.java
index 32bb483f2..faf1f242f 100644
--- a/src/class147/Code06_CatalanSkyline.java
+++ b/src/class147/Code07_Skyline.java
@@ -1,7 +1,8 @@
 package class147;
 
-// 卡特兰数天际线
-// 答案对 1000000 取模
+// 不含递增三元组的排列方法数
+// 数字从1到n，可以形成很多排列，要求任意从左往右的三个位置，不能出现依次递增的样子
+// 返回排列的方法数，答案对 1000000 取模
 // 1 <= n <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/SP7897
 // 测试链接 : https://www.spoj.com/problems/SKYLINE
@@ -14,7 +15,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_CatalanSkyline {
+public class Code07_Skyline {
 
 	public static int MOD = 1000000;
 
diff --git a/src/class147/Code08_TreehouseLadder.java b/src/class147/Code08_TreehouseLadder.java
index fcd4040c8..f6bbd7bc8 100644
--- a/src/class147/Code08_TreehouseLadder.java
+++ b/src/class147/Code08_TreehouseLadder.java
@@ -1,6 +1,10 @@
 package class147;
 
 // 树屋阶梯
+// 地面高度是0，想搭建一个阶梯，要求每一个台阶上升1的高度，最终到达高度n
+// 阶梯的样子可以打开测试链接查看，你有无穷多的任意规格的长方形材料
+// 返回搭建阶梯的不同方法数，答案可能很大，不取模！就打印真实答案
+// 1 <= n <= 500
 // 测试链接 : https://www.luogu.com.cn/problem/P2532
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class147/Code09_LeafExpectation.java b/src/class147/Code09_LeafExpectation.java
index 2e4b3d158..c21ab326e 100644
--- a/src/class147/Code09_LeafExpectation.java
+++ b/src/class147/Code09_LeafExpectation.java
@@ -1,6 +1,10 @@
 package class147;
 
 // 叶子节点数的期望
+// 一共有n个节点，认为节点之间无差别，能形成很多不同结构的二叉树
+// 每一种二叉树都有若干叶子节点，返回叶子节点数的期望
+// 1 <= n <= 10^9
+// 答案误差小于10的-9次方
 // 测试链接 : https://www.luogu.com.cn/problem/P3978
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From ebb8af3ecf21f9d1edfb88919f6ca491bfd3ad80 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Oct 2024 14:44:50 +0800
Subject: [PATCH 0029/1712] modify code

---
 src/class147/Code05_FunnySequence.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class147/Code05_FunnySequence.java b/src/class147/Code05_FunnySequence.java
index c5b9dc122..ec7506648 100644
--- a/src/class147/Code05_FunnySequence.java
+++ b/src/class147/Code05_FunnySequence.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 有趣的数列(重要！因子计数法)
+// 有趣的数列(重要! 因子计数法)
 // 求第n项卡特兰数，要求答案对p取模
 // 1 <= n <= 10^6
 // 1 <= p <= 10^9

From 48f33b40053c7fcedcbbd493cc59c60380b43635 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Oct 2024 15:00:38 +0800
Subject: [PATCH 0030/1712] modify code

---
 src/class147/Code08_TreehouseLadder.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class147/Code08_TreehouseLadder.java b/src/class147/Code08_TreehouseLadder.java
index f6bbd7bc8..f304aee0a 100644
--- a/src/class147/Code08_TreehouseLadder.java
+++ b/src/class147/Code08_TreehouseLadder.java
@@ -2,7 +2,7 @@
 
 // 树屋阶梯
 // 地面高度是0，想搭建一个阶梯，要求每一个台阶上升1的高度，最终到达高度n
-// 阶梯的样子可以打开测试链接查看，你有无穷多的任意规格的长方形材料
+// 你有无穷多的任意规格的长方形材料，希望能搭建出阶梯的样子
 // 返回搭建阶梯的不同方法数，答案可能很大，不取模！就打印真实答案
 // 1 <= n <= 500
 // 测试链接 : https://www.luogu.com.cn/problem/P2532

From 22fa35c5318ce9017268cac17a57c05ac8a23d58 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Oct 2024 15:04:23 +0800
Subject: [PATCH 0031/1712] modify code

---
 src/class147/Code03_RedMore.java     | 2 +-
 src/class147/Code04_UniqueTrees.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class147/Code03_RedMore.java b/src/class147/Code03_RedMore.java
index 1c3bcfd43..81d159791 100644
--- a/src/class147/Code03_RedMore.java
+++ b/src/class147/Code03_RedMore.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 任意前缀上红大于黑
+// 任意前缀上红多于黑
 // 有n个红和n个黑，要组成2n长度的数列，保证任意前缀上，红的数量 >= 黑的数量
 // 返回有多少种排列方法，答案对 100 取模
 // 1 <= n <= 100
diff --git a/src/class147/Code04_UniqueTrees.java b/src/class147/Code04_UniqueTrees.java
index 8deaff1fc..820fb9ce8 100644
--- a/src/class147/Code04_UniqueTrees.java
+++ b/src/class147/Code04_UniqueTrees.java
@@ -1,6 +1,6 @@
 package class147;
 
-// 不同的二叉搜索树
+// 不同结构的二叉树数量
 // 一共有n个节点，认为节点之间无差别，返回能形成多少种不同结构的二叉树
 // 1 <= n <= 19
 // 测试链接 : https://leetcode.cn/problems/unique-binary-search-trees/

From f1b56cadea2ad9ba88cea0b6a9911996326e9137 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Oct 2024 11:26:43 +0800
Subject: [PATCH 0032/1712] modify code

---
 src/class147/Code01_Catalan.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index 1fb81c9df..1307fd6f4 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -2,7 +2,8 @@
 
 // 卡特兰数模版
 // 进栈顺序规定为1、2、3..n，返回有多少种不同的出栈顺序
-// 测试题目的数据量虽然很小，但请假设数据量很大来实现，答案对 1000000007 取模
+// 测试题目的数据量很小，得到的卡特兰数没有多大
+// 但是请假设，当n比较大时，卡特兰数是很大的，答案对 1000000007 取模
 // 测试链接 : https://www.luogu.com.cn/problem/P1044
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 00587843cc91698f4893de16cc2e68ac6ef80805 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Oct 2024 12:11:04 +0800
Subject: [PATCH 0033/1712] modify code

---
 src/class147/Code01_Catalan.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class147/Code01_Catalan.java b/src/class147/Code01_Catalan.java
index 1307fd6f4..4eedcb360 100644
--- a/src/class147/Code01_Catalan.java
+++ b/src/class147/Code01_Catalan.java
@@ -2,7 +2,7 @@
 
 // 卡特兰数模版
 // 进栈顺序规定为1、2、3..n，返回有多少种不同的出栈顺序
-// 测试题目的数据量很小，得到的卡特兰数没有多大
+// 测试题目的数据量很小，得到的卡特兰数没有多大，不需要取模处理
 // 但是请假设，当n比较大时，卡特兰数是很大的，答案对 1000000007 取模
 // 测试链接 : https://www.luogu.com.cn/problem/P1044
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From 02c3b176cda307873b3a314d3beb27a29cf93863 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Oct 2024 17:46:08 +0800
Subject: [PATCH 0034/1712] modify code

---
 src/class147/Code09_LeafExpectation.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class147/Code09_LeafExpectation.java b/src/class147/Code09_LeafExpectation.java
index c21ab326e..1555ce4b0 100644
--- a/src/class147/Code09_LeafExpectation.java
+++ b/src/class147/Code09_LeafExpectation.java
@@ -23,7 +23,7 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		in.nextToken();
 		double n = in.nval;
-		out.printf("%.12f", n * (n + 1) / (2 * (2 * n - 1)));
+		out.printf("%.9f", n * (n + 1) / (2 * (2 * n - 1)));
 		out.flush();
 		out.close();
 		br.close();

From 250a1c6847a7114653a514924717fd57d0b00244 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Oct 2024 18:06:43 +0800
Subject: [PATCH 0035/1712] modify code

---
 src/class147/Code08_TreehouseLadder.java | 2 +-
 src/class147/Code09_LeafExpectation.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class147/Code08_TreehouseLadder.java b/src/class147/Code08_TreehouseLadder.java
index f304aee0a..5a832a853 100644
--- a/src/class147/Code08_TreehouseLadder.java
+++ b/src/class147/Code08_TreehouseLadder.java
@@ -2,7 +2,7 @@
 
 // 树屋阶梯
 // 地面高度是0，想搭建一个阶梯，要求每一个台阶上升1的高度，最终到达高度n
-// 你有无穷多的任意规格的长方形材料，希望能搭建出阶梯的样子
+// 有无穷多任意规格的矩形材料，但是必须选择n个矩形，希望能搭建出阶梯的样子
 // 返回搭建阶梯的不同方法数，答案可能很大，不取模！就打印真实答案
 // 1 <= n <= 500
 // 测试链接 : https://www.luogu.com.cn/problem/P2532
diff --git a/src/class147/Code09_LeafExpectation.java b/src/class147/Code09_LeafExpectation.java
index 1555ce4b0..aacd77940 100644
--- a/src/class147/Code09_LeafExpectation.java
+++ b/src/class147/Code09_LeafExpectation.java
@@ -2,7 +2,7 @@
 
 // 叶子节点数的期望
 // 一共有n个节点，认为节点之间无差别，能形成很多不同结构的二叉树
-// 每一种二叉树都有若干叶子节点，返回叶子节点数的期望
+// 假设不同结构的二叉树，等概率出现一棵，返回叶子节点的期望是多少
 // 1 <= n <= 10^9
 // 答案误差小于10的-9次方
 // 测试链接 : https://www.luogu.com.cn/problem/P3978

From af06e14cf9d2373751e44ac98d9efacfa5370e4a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Oct 2024 18:55:43 +0800
Subject: [PATCH 0036/1712] modify code

---
 ...26\346\250\241\345\244\204\347\220\206.pdf" | Bin 0 -> 171881 bytes
 src/class147/Code09_LeafExpectation.java       |   4 ++--
 2 files changed, 2 insertions(+), 2 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243147\343\200\220\346\211\251\345\261\225\343\200\221\345\215\241\347\211\271\345\205\260\346\225\260\351\242\230\345\236\213\350\257\246\350\247\243\345\222\214\345\217\226\346\250\241\345\244\204\347\220\206.pdf"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243147\343\200\220\346\211\251\345\261\225\343\200\221\345\215\241\347\211\271\345\205\260\346\225\260\351\242\230\345\236\213\350\257\246\350\247\243\345\222\214\345\217\226\346\250\241\345\244\204\347\220\206.pdf" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243147\343\200\220\346\211\251\345\261\225\343\200\221\345\215\241\347\211\271\345\205\260\346\225\260\351\242\230\345\236\213\350\257\246\350\247\243\345\222\214\345\217\226\346\250\241\345\244\204\347\220\206.pdf"
new file mode 100644
index 0000000000000000000000000000000000000000..ee71c2edac1cd7d373a9f78f7b62b38099f3382c
GIT binary patch
literal 171881
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

literal 0
HcmV?d00001

diff --git a/src/class147/Code09_LeafExpectation.java b/src/class147/Code09_LeafExpectation.java
index aacd77940..f21c5fc0b 100644
--- a/src/class147/Code09_LeafExpectation.java
+++ b/src/class147/Code09_LeafExpectation.java
@@ -2,7 +2,7 @@
 
 // 叶子节点数的期望
 // 一共有n个节点，认为节点之间无差别，能形成很多不同结构的二叉树
-// 假设不同结构的二叉树，等概率出现一棵，返回叶子节点的期望是多少
+// 假设所有不同结构的二叉树，等概率出现一棵，返回叶子节点的期望
 // 1 <= n <= 10^9
 // 答案误差小于10的-9次方
 // 测试链接 : https://www.luogu.com.cn/problem/P3978
@@ -23,7 +23,7 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		in.nextToken();
 		double n = in.nval;
-		out.printf("%.9f", n * (n + 1) / (2 * (2 * n - 1)));
+		out.printf("%.9f", n * (n + 1) / ((2 * n - 1) * 2));
 		out.flush();
 		out.close();
 		br.close();

From bb0b175e6750aefe0cd9e4bd86c9045892b2ebb3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 19 Oct 2024 03:05:07 +0800
Subject: [PATCH 0037/1712] modify code

---
 ...6\346\250\241\345\244\204\347\220\206.pdf" | Bin 171881 -> 178704 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243147\343\200\220\346\211\251\345\261\225\343\200\221\345\215\241\347\211\271\345\205\260\346\225\260\351\242\230\345\236\213\350\257\246\350\247\243\345\222\214\345\217\226\346\250\241\345\244\204\347\220\206.pdf" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243147\343\200\220\346\211\251\345\261\225\343\200\221\345\215\241\347\211\271\345\205\260\346\225\260\351\242\230\345\236\213\350\257\246\350\247\243\345\222\214\345\217\226\346\250\241\345\244\204\347\220\206.pdf"
index ee71c2edac1cd7d373a9f78f7b62b38099f3382c..050c9a7c11eb7b5bccc8a438d1bcde44272398c7 100644
GIT binary patch
delta 62817
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
KC98Uw^8Wy^&=x}g

delta 56044
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
ZA#n+_;=&{B6lSGjG_(8o3=A4%|35LSv26eV


From c8b33da0dd66dc4ca24fe21274236800c968abf6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 22 Oct 2024 15:44:22 +0800
Subject: [PATCH 0038/1712] modify code

---
 src/class148/AVL.java      | 243 +++++++++++++++++++++++++++++++++++++
 src/class149/SkipList.java |  71 +++++++++++
 2 files changed, 314 insertions(+)
 create mode 100644 src/class148/AVL.java
 create mode 100644 src/class149/SkipList.java

diff --git a/src/class148/AVL.java b/src/class148/AVL.java
new file mode 100644
index 000000000..91da391ee
--- /dev/null
+++ b/src/class148/AVL.java
@@ -0,0 +1,243 @@
+package class148;
+
+// AVL树的实现
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class AVL {
+
+	public static int MAXN = 100001;
+
+	public static int cnt;
+
+	public static int head;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] count = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] height = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static void build() {
+		cnt = head = 0;
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		height[i] = Math.max(height[left[i]], height[right[i]]) + 1;
+	}
+
+	public static int leftRotate(int i) {
+		int r = right[i];
+		right[i] = left[r];
+		left[r] = i;
+		up(i);
+		up(r);
+		return r;
+	}
+
+	public static int rightRotate(int i) {
+		int l = left[i];
+		left[i] = right[l];
+		right[l] = i;
+		up(i);
+		up(l);
+		return l;
+	}
+
+	public static int maintain(int i) {
+		int lh = height[left[i]];
+		int rh = height[right[i]];
+		if (lh - rh > 1) {
+			int llh = height[left[left[i]]];
+			int lrh = height[right[left[i]]];
+			if (llh >= lrh) {
+				i = rightRotate(i);
+			} else {
+				left[i] = leftRotate(left[i]);
+				i = rightRotate(i);
+			}
+		} else if (rh - lh > 1) {
+			int rrh = height[right[right[i]]];
+			int rlh = height[left[right[i]]];
+			if (rrh >= rlh) {
+				i = leftRotate(i);
+			} else {
+				right[i] = rightRotate(right[i]);
+				i = leftRotate(i);
+			}
+		}
+		return i;
+	}
+
+	public static void add(int k) {
+		head = add(head, k);
+	}
+
+	public static int add(int i, int k) {
+		if (i == 0) {
+			key[++cnt] = k;
+			count[cnt] = size[cnt] = height[cnt] = 1;
+			return cnt;
+		}
+		if (key[i] == k) {
+			count[i]++;
+		} else if (key[i] > k) {
+			left[i] = add(left[i], k);
+		} else {
+			right[i] = add(right[i], k);
+		}
+		up(i);
+		return maintain(i);
+	}
+
+	public static void remove(int k) {
+		if (rank(k) != rank(k + 1)) {
+			head = remove(head, k);
+		}
+	}
+
+	public static int remove(int i, int k) {
+		if (key[i] < k) {
+			right[i] = remove(right[i], k);
+		} else if (key[i] > k) {
+			left[i] = remove(left[i], k);
+		} else {
+			if (count[i] > 1) {
+				count[i]--;
+			} else {
+				if (left[i] == 0 && right[i] == 0) {
+					return 0;
+				} else if (left[i] != 0 && right[i] == 0) {
+					i = left[i];
+				} else if (left[i] == 0 && right[i] != 0) {
+					i = right[i];
+				} else {
+					int replace = right[i];
+					while (left[replace] != 0) {
+						replace = left[replace];
+					}
+					right[i] = removeMostLeft(right[i], replace);
+					left[replace] = left[i];
+					right[replace] = right[i];
+					i = replace;
+				}
+			}
+		}
+		up(i);
+		return maintain(i);
+	}
+
+	public static int removeMostLeft(int i, int mostLeft) {
+		if (i == mostLeft) {
+			return right[i];
+		} else {
+			left[i] = removeMostLeft(left[i], mostLeft);
+			up(i);
+			return maintain(i);
+		}
+	}
+
+	public static int rank(int k) {
+		return small(head, k) + 1;
+	}
+
+	public static int small(int i, int k) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= k) {
+			return small(left[i], k);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], k);
+		}
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int pre(int k) {
+		return pre(head, k);
+	}
+
+	public static int pre(int i, int k) {
+		if (i == 0) {
+			return Integer.MIN_VALUE;
+		}
+		if (key[i] >= k) {
+			return pre(left[i], k);
+		} else {
+			return Math.max(key[i], pre(right[i], k));
+		}
+	}
+
+	public static int post(int k) {
+		return post(head, k);
+	}
+
+	public static int post(int i, int k) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= k) {
+			return post(right[i], k);
+		} else {
+			return Math.min(key[i], post(left[i], k));
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		build();
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1, op, x; i <= n; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				out.println(rank(x));
+			} else if (op == 4) {
+				out.println(index(x));
+			} else if (op == 5) {
+				out.println(pre(x));
+			} else {
+				out.println(post(x));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class149/SkipList.java b/src/class149/SkipList.java
new file mode 100644
index 000000000..08480c2f3
--- /dev/null
+++ b/src/class149/SkipList.java
@@ -0,0 +1,71 @@
+package class149;
+
+// 跳表的实现
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+// 待实现
+public class SkipList {
+
+	public static void add(int k) {
+
+	}
+
+	public static void remove(int k) {
+
+	}
+
+	public static int rank(int k) {
+		return 0;
+	}
+
+	public static int index(int x) {
+		return 0;
+	}
+
+	public static int pre(int x) {
+		return 0;
+	}
+
+	public static int post(int x) {
+		return 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1, op, x; i <= n; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				out.println(rank(x));
+			} else if (op == 4) {
+				out.println(index(x));
+			} else if (op == 5) {
+				out.println(pre(x));
+			} else {
+				out.println(post(x));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From fec1e23c25e6236eeeadb1f3f925f691b512bf50 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 22 Oct 2024 15:49:12 +0800
Subject: [PATCH 0039/1712] modify code

---
 src/class148/AVL.java | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class148/AVL.java b/src/class148/AVL.java
index 91da391ee..815faf0f6 100644
--- a/src/class148/AVL.java
+++ b/src/class148/AVL.java
@@ -126,14 +126,14 @@ public static int remove(int i, int k) {
 				} else if (left[i] == 0 && right[i] != 0) {
 					i = right[i];
 				} else {
-					int replace = right[i];
-					while (left[replace] != 0) {
-						replace = left[replace];
+					int mostLeft = right[i];
+					while (left[mostLeft] != 0) {
+						mostLeft = left[mostLeft];
 					}
-					right[i] = removeMostLeft(right[i], replace);
-					left[replace] = left[i];
-					right[replace] = right[i];
-					i = replace;
+					right[i] = removeMostLeft(right[i], mostLeft);
+					left[mostLeft] = left[i];
+					right[mostLeft] = right[i];
+					i = mostLeft;
 				}
 			}
 		}

From a08ed31185d47673543262a2f6a2d07e31d7f940 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 23 Oct 2024 12:50:36 +0800
Subject: [PATCH 0040/1712] modify code

---
 src/class148/{AVL.java => Code01_AVL.java}   |  24 ++--
 src/class148/Code02_ReconstructionQueue.java | 134 +++++++++++++++++++
 2 files changed, 150 insertions(+), 8 deletions(-)
 rename src/class148/{AVL.java => Code01_AVL.java} (92%)
 create mode 100644 src/class148/Code02_ReconstructionQueue.java

diff --git a/src/class148/AVL.java b/src/class148/Code01_AVL.java
similarity index 92%
rename from src/class148/AVL.java
rename to src/class148/Code01_AVL.java
index 815faf0f6..7506d2fb1 100644
--- a/src/class148/AVL.java
+++ b/src/class148/Code01_AVL.java
@@ -10,14 +10,15 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
+import java.util.Arrays;
 
-public class AVL {
+public class Code01_AVL {
 
 	public static int MAXN = 100001;
 
-	public static int cnt;
+	public static int cnt = 0;
 
-	public static int head;
+	public static int head = 0;
 
 	public static int[] key = new int[MAXN];
 
@@ -31,10 +32,6 @@ public class AVL {
 
 	public static int[] right = new int[MAXN];
 
-	public static void build() {
-		cnt = head = 0;
-	}
-
 	public static void up(int i) {
 		size[i] = size[left[i]] + size[right[i]] + count[i];
 		height[i] = Math.max(height[left[i]], height[right[i]]) + 1;
@@ -209,8 +206,18 @@ public static int post(int i, int k) {
 		}
 	}
 
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(height, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
 	public static void main(String[] args) throws IOException {
-		build();
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -235,6 +242,7 @@ public static void main(String[] args) throws IOException {
 				out.println(post(x));
 			}
 		}
+		clear();
 		out.flush();
 		out.close();
 		br.close();
diff --git a/src/class148/Code02_ReconstructionQueue.java b/src/class148/Code02_ReconstructionQueue.java
new file mode 100644
index 000000000..5b27ace60
--- /dev/null
+++ b/src/class148/Code02_ReconstructionQueue.java
@@ -0,0 +1,134 @@
+package class148;
+
+import java.util.Arrays;
+
+// 根据身高重建队列(最优复杂度)
+// 时间复杂度做到O(n * log n)
+// 测试链接 : https://leetcode.cn/problems/queue-reconstruction-by-height/
+public class Code02_ReconstructionQueue {
+
+	public static int[][] reconstructQueue(int[][] people) {
+		Arrays.sort(people, (a, b) -> a[0] != b[0] ? (b[0] - a[0]) : (a[1] - b[1]));
+		for (int[] p : people) {
+			add(p[0], p[1]);
+		}
+		fill(people);
+		clear();
+		return people;
+	}
+
+	public static int MAXN = 2001;
+
+	public static int cnt = 0;
+
+	public static int head = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] value = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] height = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+		height[i] = Math.max(height[left[i]], height[right[i]]) + 1;
+	}
+
+	public static int leftRotate(int i) {
+		int r = right[i];
+		right[i] = left[r];
+		left[r] = i;
+		up(i);
+		up(r);
+		return r;
+	}
+
+	public static int rightRotate(int i) {
+		int l = left[i];
+		left[i] = right[l];
+		right[l] = i;
+		up(i);
+		up(l);
+		return l;
+	}
+
+	public static int maintain(int i) {
+		int lh = height[left[i]];
+		int rh = height[right[i]];
+		if (lh - rh > 1) {
+			int llh = height[left[left[i]]];
+			int lrh = height[right[left[i]]];
+			if (llh >= lrh) {
+				i = rightRotate(i);
+			} else {
+				left[i] = leftRotate(left[i]);
+				i = rightRotate(i);
+			}
+		} else if (rh - lh > 1) {
+			int rrh = height[right[right[i]]];
+			int rlh = height[left[right[i]]];
+			if (rrh >= rlh) {
+				i = leftRotate(i);
+			} else {
+				right[i] = rightRotate(right[i]);
+				i = leftRotate(i);
+			}
+		}
+		return i;
+	}
+
+	public static void add(int num, int index) {
+		head = add(head, index + 1, num, index);
+	}
+
+	public static int add(int i, int rank, int num, int index) {
+		if (i == 0) {
+			key[++cnt] = num;
+			value[cnt] = index;
+			size[cnt] = height[cnt] = 1;
+			return cnt;
+		}
+		if (size[left[i]] + 1 >= rank) {
+			left[i] = add(left[i], rank, num, index);
+		} else {
+			right[i] = add(right[i], rank - size[left[i]] - 1, num, index);
+		}
+		up(i);
+		return maintain(i);
+	}
+
+	public static void fill(int[][] ans) {
+		fi = 0;
+		inOrder(ans, head);
+	}
+
+	public static int fi;
+
+	public static void inOrder(int[][] ans, int i) {
+		if (i == 0) {
+			return;
+		}
+		inOrder(ans, left[i]);
+		ans[fi][0] = key[i];
+		ans[fi++][1] = value[i];
+		inOrder(ans, right[i]);
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(value, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(height, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+}

From bbca6f0f7f004a537e6edb6d5f741e0f8d88dc73 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 23 Oct 2024 22:59:05 +0800
Subject: [PATCH 0041/1712] modify code

---
 src/class148/Code01_AVL.java |  68 +++++------
 src/class149/SkipList.java   | 216 +++++++++++++++++++++++++++++++++--
 2 files changed, 240 insertions(+), 44 deletions(-)

diff --git a/src/class148/Code01_AVL.java b/src/class148/Code01_AVL.java
index 7506d2fb1..3516b4a2a 100644
--- a/src/class148/Code01_AVL.java
+++ b/src/class148/Code01_AVL.java
@@ -80,38 +80,38 @@ public static int maintain(int i) {
 		return i;
 	}
 
-	public static void add(int k) {
-		head = add(head, k);
+	public static void add(int num) {
+		head = add(head, num);
 	}
 
-	public static int add(int i, int k) {
+	public static int add(int i, int num) {
 		if (i == 0) {
-			key[++cnt] = k;
+			key[++cnt] = num;
 			count[cnt] = size[cnt] = height[cnt] = 1;
 			return cnt;
 		}
-		if (key[i] == k) {
+		if (key[i] == num) {
 			count[i]++;
-		} else if (key[i] > k) {
-			left[i] = add(left[i], k);
+		} else if (key[i] > num) {
+			left[i] = add(left[i], num);
 		} else {
-			right[i] = add(right[i], k);
+			right[i] = add(right[i], num);
 		}
 		up(i);
 		return maintain(i);
 	}
 
-	public static void remove(int k) {
-		if (rank(k) != rank(k + 1)) {
-			head = remove(head, k);
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			head = remove(head, num);
 		}
 	}
 
-	public static int remove(int i, int k) {
-		if (key[i] < k) {
-			right[i] = remove(right[i], k);
-		} else if (key[i] > k) {
-			left[i] = remove(left[i], k);
+	public static int remove(int i, int num) {
+		if (key[i] < num) {
+			right[i] = remove(right[i], num);
+		} else if (key[i] > num) {
+			left[i] = remove(left[i], num);
 		} else {
 			if (count[i] > 1) {
 				count[i]--;
@@ -148,18 +148,18 @@ public static int removeMostLeft(int i, int mostLeft) {
 		}
 	}
 
-	public static int rank(int k) {
-		return small(head, k) + 1;
+	public static int rank(int num) {
+		return small(head, num) + 1;
 	}
 
-	public static int small(int i, int k) {
+	public static int small(int i, int num) {
 		if (i == 0) {
 			return 0;
 		}
-		if (key[i] >= k) {
-			return small(left[i], k);
+		if (key[i] >= num) {
+			return small(left[i], num);
 		} else {
-			return size[left[i]] + count[i] + small(right[i], k);
+			return size[left[i]] + count[i] + small(right[i], num);
 		}
 	}
 
@@ -176,33 +176,33 @@ public static int index(int i, int x) {
 		return key[i];
 	}
 
-	public static int pre(int k) {
-		return pre(head, k);
+	public static int pre(int num) {
+		return pre(head, num);
 	}
 
-	public static int pre(int i, int k) {
+	public static int pre(int i, int num) {
 		if (i == 0) {
 			return Integer.MIN_VALUE;
 		}
-		if (key[i] >= k) {
-			return pre(left[i], k);
+		if (key[i] >= num) {
+			return pre(left[i], num);
 		} else {
-			return Math.max(key[i], pre(right[i], k));
+			return Math.max(key[i], pre(right[i], num));
 		}
 	}
 
-	public static int post(int k) {
-		return post(head, k);
+	public static int post(int num) {
+		return post(head, num);
 	}
 
-	public static int post(int i, int k) {
+	public static int post(int i, int num) {
 		if (i == 0) {
 			return Integer.MAX_VALUE;
 		}
-		if (key[i] <= k) {
-			return post(right[i], k);
+		if (key[i] <= num) {
+			return post(right[i], num);
 		} else {
-			return Math.min(key[i], post(left[i], k));
+			return Math.min(key[i], post(left[i], num));
 		}
 	}
 
diff --git a/src/class149/SkipList.java b/src/class149/SkipList.java
index 08480c2f3..d89a7af20 100644
--- a/src/class149/SkipList.java
+++ b/src/class149/SkipList.java
@@ -10,35 +10,230 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
+import java.util.Arrays;
 
-// 待实现
 public class SkipList {
 
-	public static void add(int k) {
+	public static int MAXL = 17;
 
+	public static int MAXN = 100001;
+
+	public static int cnt;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] count = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[][] next = new int[MAXN][MAXL + 1];
+
+	public static int[][] len = new int[MAXN][MAXL + 1];
+
+	public static void build() {
+		cnt = 1;
+		key[cnt] = Integer.MIN_VALUE;
+		size[cnt] = MAXL;
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		for (int i = 1; i <= cnt; i++) {
+			Arrays.fill(next[i], 0);
+			Arrays.fill(len[i], 0);
+		}
+		cnt = 0;
+	}
+
+	public static int random() {
+		int ans = 1;
+		while (Math.random() < 0.5) {
+			ans++;
+		}
+		return Math.min(ans, MAXL);
+	}
+
+	public static int find(int i, int h, int num) {
+		while (next[i][h] != 0 && key[next[i][h]] < num) {
+			i = next[i][h];
+		}
+		if (h == 1) {
+			if (next[i][h] != 0 && key[next[i][h]] == num) {
+				return next[i][h];
+			} else {
+				return 0;
+			}
+		}
+		return find(i, h - 1, num);
+	}
+
+	public static void add(int num) {
+		if (find(1, MAXL, num) != 0) {
+			addCount(1, MAXL, num);
+		} else {
+			key[++cnt] = num;
+			count[cnt] = 1;
+			size[cnt] = random();
+			addNode(1, MAXL, cnt);
+		}
 	}
 
-	public static void remove(int k) {
+	public static void addCount(int i, int h, int num) {
+		while (next[i][h] != 0 && key[next[i][h]] < num) {
+			i = next[i][h];
+		}
+		if (h == 1) {
+			count[next[i][h]]++;
+		} else {
+			addCount(i, h - 1, num);
+		}
+		len[i][h]++;
+	}
 
+	public static int addNode(int i, int h, int j) {
+		int rightCnt = 0;
+		while (next[i][h] != 0 && key[next[i][h]] < key[j]) {
+			rightCnt += len[i][h];
+			i = next[i][h];
+		}
+		if (h == 1) {
+			next[j][h] = next[i][h];
+			next[i][h] = j;
+			len[j][h] = count[next[j][h]];
+			len[i][h] = count[next[i][h]];
+			return rightCnt;
+		} else {
+			int downCnt = addNode(i, h - 1, j);
+			if (h > size[j]) {
+				len[i][h]++;
+			} else {
+				next[j][h] = next[i][h];
+				next[i][h] = j;
+				len[j][h] = len[i][h] + 1 - downCnt - count[j];
+				len[i][h] = downCnt + count[j];
+			}
+			return rightCnt + downCnt;
+		}
 	}
 
-	public static int rank(int k) {
-		return 0;
+	public static void remove(int num) {
+		int j = find(1, MAXL, num);
+		if (j != 0) {
+			if (count[j] > 1) {
+				removeCount(1, MAXL, num);
+			} else {
+				removeNode(1, MAXL, j);
+			}
+		}
+	}
+
+	public static void removeCount(int i, int h, int num) {
+		while (next[i][h] != 0 && key[next[i][h]] < num) {
+			i = next[i][h];
+		}
+		if (h == 1) {
+			count[next[i][h]]--;
+		} else {
+			removeCount(i, h - 1, num);
+		}
+		len[i][h]--;
+	}
+
+	public static void removeNode(int i, int h, int j) {
+		if (h < 1) {
+			return;
+		}
+		while (next[i][h] != 0 && key[next[i][h]] < key[j]) {
+			i = next[i][h];
+		}
+		if (h > size[j]) {
+			len[i][h]--;
+		} else {
+			next[i][h] = next[j][h];
+			len[i][h] += len[j][h] - 1;
+		}
+		removeNode(i, h - 1, j);
+	}
+
+	public static int rank(int num) {
+		return rank(1, MAXL, num) + 1;
+	}
+
+	public static int rank(int i, int h, int num) {
+		int rightCnt = 0;
+		while (next[i][h] != 0 && key[next[i][h]] < num) {
+			rightCnt += len[i][h];
+			i = next[i][h];
+		}
+		if (h == 1) {
+			return rightCnt;
+		} else {
+			return rightCnt + rank(i, h - 1, num);
+		}
 	}
 
 	public static int index(int x) {
-		return 0;
+		return index(1, MAXL, x);
 	}
 
-	public static int pre(int x) {
-		return 0;
+	public static int index(int i, int h, int x) {
+		int c = 0;
+		while (next[i][h] != 0 && c + len[i][h] < x) {
+			c += len[i][h];
+			i = next[i][h];
+		}
+		if (h == 1) {
+			return key[next[i][h]];
+		} else {
+			return index(i, h - 1, x - c);
+		}
+	}
+
+	public static int pre(int num) {
+		return pre(1, MAXL, num);
+	}
+
+	public static int pre(int i, int h, int num) {
+		while (next[i][h] != 0 && key[next[i][h]] < num) {
+			i = next[i][h];
+		}
+		if (h == 1) {
+			return i == 1 ? Integer.MIN_VALUE : key[i];
+		} else {
+			return pre(i, h - 1, num);
+		}
 	}
 
-	public static int post(int x) {
-		return 0;
+	public static int post(int num) {
+		return post(1, MAXL, num);
+	}
+
+	public static int post(int i, int h, int num) {
+		while (next[i][h] != 0 && key[next[i][h]] < num) {
+			i = next[i][h];
+		}
+		if (h == 1) {
+			if (next[i][h] == 0) {
+				return Integer.MAX_VALUE;
+			}
+			if (key[next[i][h]] > num) {
+				return key[next[i][h]];
+			}
+			i = next[i][h];
+			if (next[i][h] == 0) {
+				return Integer.MAX_VALUE;
+			} else {
+				return key[next[i][h]];
+			}
+		} else {
+			return post(i, h - 1, num);
+		}
 	}
 
 	public static void main(String[] args) throws IOException {
+		build();
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -63,6 +258,7 @@ public static void main(String[] args) throws IOException {
 				out.println(post(x));
 			}
 		}
+		clear();
 		out.flush();
 		out.close();
 		br.close();

From 9f22b05c53395eb4942b083ce632bdc535d66a6b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 23 Oct 2024 23:03:44 +0800
Subject: [PATCH 0042/1712] modify code

---
 src/class149/SkipList.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class149/SkipList.java b/src/class149/SkipList.java
index d89a7af20..20c22f1b2 100644
--- a/src/class149/SkipList.java
+++ b/src/class149/SkipList.java
@@ -14,7 +14,7 @@
 
 public class SkipList {
 
-	public static int MAXL = 17;
+	public static int MAXL = 20;
 
 	public static int MAXN = 100001;
 

From 88f200bbea42029fad6f9644f0d84f5854cb2f6c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 23 Oct 2024 23:04:47 +0800
Subject: [PATCH 0043/1712] modify code

---
 src/class148/Code01_AVL.java | 2 +-
 src/class149/SkipList.java   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class148/Code01_AVL.java b/src/class148/Code01_AVL.java
index 3516b4a2a..92e1a3698 100644
--- a/src/class148/Code01_AVL.java
+++ b/src/class148/Code01_AVL.java
@@ -1,6 +1,6 @@
 package class148;
 
-// AVL树的实现
+// AVL树的实现(静态数组实现)
 // 测试链接 : https://www.luogu.com.cn/problem/P3369
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class149/SkipList.java b/src/class149/SkipList.java
index 20c22f1b2..08cc67d5d 100644
--- a/src/class149/SkipList.java
+++ b/src/class149/SkipList.java
@@ -1,6 +1,6 @@
 package class149;
 
-// 跳表的实现
+// 跳表的实现(静态数组实现)
 // 测试链接 : https://www.luogu.com.cn/problem/P3369
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 5a8ef3019d093190e87a4344c1d9f7bf00425a9d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Oct 2024 14:25:40 +0800
Subject: [PATCH 0044/1712] modify code

---
 src/class148/Code01_AVL.java                 | 12 +++++++++++-
 src/class148/Code02_ReconstructionQueue.java |  9 +++++++--
 src/class149/SkipList.java                   | 11 ++++++++++-
 3 files changed, 28 insertions(+), 4 deletions(-)

diff --git a/src/class148/Code01_AVL.java b/src/class148/Code01_AVL.java
index 92e1a3698..05cd64f1b 100644
--- a/src/class148/Code01_AVL.java
+++ b/src/class148/Code01_AVL.java
@@ -1,6 +1,15 @@
 package class148;
 
-// AVL树的实现(静态数组实现)
+// AVL树的实现
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加一个x，支持重复加入
+// 2，删除一个x，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P3369
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,6 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
+
 public class Code01_AVL {
 
 	public static int MAXN = 100001;
diff --git a/src/class148/Code02_ReconstructionQueue.java b/src/class148/Code02_ReconstructionQueue.java
index 5b27ace60..67ad884c7 100644
--- a/src/class148/Code02_ReconstructionQueue.java
+++ b/src/class148/Code02_ReconstructionQueue.java
@@ -2,8 +2,13 @@
 
 import java.util.Arrays;
 
-// 根据身高重建队列(最优复杂度)
-// 时间复杂度做到O(n * log n)
+// 重建队列(做到最优时间复杂度)
+// 一共n个人，每个人有(a, b)两个数据，数据a表示该人的身高
+// 数据b表示该人的要求，站在自己左边的人中，正好有b个人的身高大于等于自己的身高
+// 请你把n个人从左到右进行排列，要求每个人的要求都可以满足
+// 返回其中一种排列即可
+// 本题输入的数据一定存在这样的排列
+// 题解中的绝大多数方法，时间复杂度O(n平方)，但是时间复杂度能做到O(n * log n)
 // 测试链接 : https://leetcode.cn/problems/queue-reconstruction-by-height/
 public class Code02_ReconstructionQueue {
 
diff --git a/src/class149/SkipList.java b/src/class149/SkipList.java
index 08cc67d5d..96a519eb3 100644
--- a/src/class149/SkipList.java
+++ b/src/class149/SkipList.java
@@ -1,6 +1,15 @@
 package class149;
 
-// 跳表的实现(静态数组实现)
+// 跳表的实现
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加一个x，支持重复加入
+// 2，删除一个x，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P3369
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 81e36739cdd0ab58c7779e3047c4afdd37ef2b2b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Oct 2024 14:28:17 +0800
Subject: [PATCH 0045/1712] modify code

---
 src/class148/Code02_ReconstructionQueue.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/class148/Code02_ReconstructionQueue.java b/src/class148/Code02_ReconstructionQueue.java
index 67ad884c7..ed58ca0df 100644
--- a/src/class148/Code02_ReconstructionQueue.java
+++ b/src/class148/Code02_ReconstructionQueue.java
@@ -6,8 +6,7 @@
 // 一共n个人，每个人有(a, b)两个数据，数据a表示该人的身高
 // 数据b表示该人的要求，站在自己左边的人中，正好有b个人的身高大于等于自己的身高
 // 请你把n个人从左到右进行排列，要求每个人的要求都可以满足
-// 返回其中一种排列即可
-// 本题输入的数据一定存在这样的排列
+// 返回其中一种排列即可，本题的数据保证一定存在这样的排列
 // 题解中的绝大多数方法，时间复杂度O(n平方)，但是时间复杂度能做到O(n * log n)
 // 测试链接 : https://leetcode.cn/problems/queue-reconstruction-by-height/
 public class Code02_ReconstructionQueue {

From 9a850de4ec8ceca719cdde12cee39197d2e19e81 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Oct 2024 15:27:54 +0800
Subject: [PATCH 0046/1712] modify code

---
 src/class148/Code01_AVL.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class148/Code01_AVL.java b/src/class148/Code01_AVL.java
index 05cd64f1b..23f9c723f 100644
--- a/src/class148/Code01_AVL.java
+++ b/src/class148/Code01_AVL.java
@@ -21,7 +21,6 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-
 public class Code01_AVL {
 
 	public static int MAXN = 100001;

From 9ce3078d740d11716f8a3ef4ba3ce1e7beec227f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Oct 2024 16:01:13 +0800
Subject: [PATCH 0047/1712] modify code

---
 src/class148/{Code01_AVL.java => AVL1.java}   |   2 +-
 src/class148/AVL2.java                        | 241 ++++++++++++++++
 ...ionQueue.java => ReconstructionQueue.java} |   2 +-
 .../{SkipList.java => SkipList1.java}         |   2 +-
 src/class149/SkipList2.java                   | 260 ++++++++++++++++++
 5 files changed, 504 insertions(+), 3 deletions(-)
 rename src/class148/{Code01_AVL.java => AVL1.java} (99%)
 create mode 100644 src/class148/AVL2.java
 rename src/class148/{Code02_ReconstructionQueue.java => ReconstructionQueue.java} (98%)
 rename src/class149/{SkipList.java => SkipList1.java} (99%)
 create mode 100644 src/class149/SkipList2.java

diff --git a/src/class148/Code01_AVL.java b/src/class148/AVL1.java
similarity index 99%
rename from src/class148/Code01_AVL.java
rename to src/class148/AVL1.java
index 23f9c723f..491ddcb5d 100644
--- a/src/class148/Code01_AVL.java
+++ b/src/class148/AVL1.java
@@ -21,7 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code01_AVL {
+public class AVL1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class148/AVL2.java b/src/class148/AVL2.java
new file mode 100644
index 000000000..15b6571dd
--- /dev/null
+++ b/src/class148/AVL2.java
@@ -0,0 +1,241 @@
+package class148;
+
+// AVL树的实现
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加一个x，支持重复加入
+// 2，删除一个x，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <algorithm>
+//#include <climits>
+//#include <cstring>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//
+//int cnt = 0;
+//int head = 0;
+//int key[MAXN];
+//int key_count[MAXN];
+//int size[MAXN];
+//int height[MAXN];
+//int leftChild[MAXN];
+//int rightChild[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[leftChild[i]] + size[rightChild[i]] + key_count[i];
+//    height[i] = max(height[leftChild[i]], height[rightChild[i]]) + 1;
+//}
+//
+//int leftRotate(int i) {
+//    int r = rightChild[i];
+//    rightChild[i] = leftChild[r];
+//    leftChild[r] = i;
+//    up(i);
+//    up(r);
+//    return r;
+//}
+//
+//int rightRotate(int i) {
+//    int l = leftChild[i];
+//    leftChild[i] = rightChild[l];
+//    rightChild[l] = i;
+//    up(i);
+//    up(l);
+//    return l;
+//}
+//
+//int maintain(int i) {
+//    int lh = height[leftChild[i]];
+//    int rh = height[rightChild[i]];
+//    if (lh - rh > 1) {
+//        int llh = height[leftChild[leftChild[i]]];
+//        int lrh = height[rightChild[leftChild[i]]];
+//        if (llh >= lrh) {
+//            i = rightRotate(i);
+//        } else {
+//            leftChild[i] = leftRotate(leftChild[i]);
+//            i = rightRotate(i);
+//        }
+//    } else if (rh - lh > 1) {
+//        int rrh = height[rightChild[rightChild[i]]];
+//        int rlh = height[leftChild[rightChild[i]]];
+//        if (rrh >= rlh) {
+//            i = leftRotate(i);
+//        } else {
+//            rightChild[i] = rightRotate(rightChild[i]);
+//            i = leftRotate(i);
+//        }
+//    }
+//    return i;
+//}
+//
+//int addNode(int i, int num) {
+//    if (i == 0) {
+//        key[++cnt] = num;
+//        key_count[cnt] = size[cnt] = height[cnt] = 1;
+//        return cnt;
+//    }
+//    if (key[i] == num) {
+//        key_count[i]++;
+//    } else if (key[i] > num) {
+//        leftChild[i] = addNode(leftChild[i], num);
+//    } else {
+//        rightChild[i] = addNode(rightChild[i], num);
+//    }
+//    up(i);
+//    return maintain(i);
+//}
+//
+//void add(int num) {
+//    head = addNode(head, num);
+//}
+//
+//int getRank(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return getRank(leftChild[i], num);
+//    } else {
+//        return size[leftChild[i]] + key_count[i] + getRank(rightChild[i], num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return getRank(head, num) + 1;
+//}
+//
+//int removeMostLeft(int i, int mostLeft) {
+//    if (i == mostLeft) {
+//        return rightChild[i];
+//    } else {
+//        leftChild[i] = removeMostLeft(leftChild[i], mostLeft);
+//        up(i);
+//        return maintain(i);
+//    }
+//}
+//
+//int removeNode(int i, int num) {
+//    if (key[i] < num) {
+//        rightChild[i] = removeNode(rightChild[i], num);
+//    } else if (key[i] > num) {
+//        leftChild[i] = removeNode(leftChild[i], num);
+//    } else {
+//        if (key_count[i] > 1) {
+//            key_count[i]--;
+//        } else {
+//            if (leftChild[i] == 0 && rightChild[i] == 0) {
+//                return 0;
+//            } else if (leftChild[i] != 0 && rightChild[i] == 0) {
+//                i = leftChild[i];
+//            } else if (leftChild[i] == 0 && rightChild[i] != 0) {
+//                i = rightChild[i];
+//            } else {
+//                int mostLeft = rightChild[i];
+//                while (leftChild[mostLeft] != 0) {
+//                    mostLeft = leftChild[mostLeft];
+//                }
+//                rightChild[i] = removeMostLeft(rightChild[i], mostLeft);
+//                leftChild[mostLeft] = leftChild[i];
+//                rightChild[mostLeft] = rightChild[i];
+//                i = mostLeft;
+//            }
+//        }
+//    }
+//    up(i);
+//    return maintain(i);
+//}
+//
+//void remove(int num) {
+//    if (getRank(num) != getRank(num + 1)) {
+//        head = removeNode(head, num);
+//    }
+//}
+//
+//int getIndex(int i, int x) {
+//    if (size[leftChild[i]] >= x) {
+//        return getIndex(leftChild[i], x);
+//    } else if (size[leftChild[i]] + key_count[i] < x) {
+//        return getIndex(rightChild[i], x - size[leftChild[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int getIndex(int x) {
+//    return getIndex(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(leftChild[i], num);
+//    } else {
+//        return max(key[i], pre(rightChild[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rightChild[i], num);
+//    } else {
+//        return min(key[i], post(leftChild[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//void clear() {
+//    memset(key + 1, 0, cnt * sizeof(int));
+//    memset(key_count + 1, 0, cnt * sizeof(int));
+//    memset(size + 1, 0, cnt * sizeof(int));
+//    memset(height + 1, 0, cnt * sizeof(int));
+//    memset(leftChild + 1, 0, cnt * sizeof(int));
+//    memset(rightChild + 1, 0, cnt * sizeof(int));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    int n;
+//    cin >> n;
+//    for (int i = 1, op, x; i <= n; i++) {
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << endl;
+//        } else if (op == 4) {
+//            cout << getIndex(x) << endl;
+//        } else if (op == 5) {
+//            cout << pre(x) << endl;
+//        } else {
+//            cout << post(x) << endl;
+//        }
+//    }
+//    clear();
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class148/Code02_ReconstructionQueue.java b/src/class148/ReconstructionQueue.java
similarity index 98%
rename from src/class148/Code02_ReconstructionQueue.java
rename to src/class148/ReconstructionQueue.java
index ed58ca0df..4c864fe71 100644
--- a/src/class148/Code02_ReconstructionQueue.java
+++ b/src/class148/ReconstructionQueue.java
@@ -9,7 +9,7 @@
 // 返回其中一种排列即可，本题的数据保证一定存在这样的排列
 // 题解中的绝大多数方法，时间复杂度O(n平方)，但是时间复杂度能做到O(n * log n)
 // 测试链接 : https://leetcode.cn/problems/queue-reconstruction-by-height/
-public class Code02_ReconstructionQueue {
+public class ReconstructionQueue {
 
 	public static int[][] reconstructQueue(int[][] people) {
 		Arrays.sort(people, (a, b) -> a[0] != b[0] ? (b[0] - a[0]) : (a[1] - b[1]));
diff --git a/src/class149/SkipList.java b/src/class149/SkipList1.java
similarity index 99%
rename from src/class149/SkipList.java
rename to src/class149/SkipList1.java
index 96a519eb3..26a1c2e2b 100644
--- a/src/class149/SkipList.java
+++ b/src/class149/SkipList1.java
@@ -21,7 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class SkipList {
+public class SkipList1 {
 
 	public static int MAXL = 20;
 
diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
new file mode 100644
index 000000000..fbba35f66
--- /dev/null
+++ b/src/class149/SkipList2.java
@@ -0,0 +1,260 @@
+package class149;
+
+// 跳表的实现
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加一个x，支持重复加入
+// 2，删除一个x，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <climits>
+//#include <cstdlib>
+//#include <cstring>
+//
+//using namespace std;
+//
+//const int MAXL = 20;
+//const int MAXN = 100001;
+//
+//int cnt;
+//int key[MAXN];
+//int key_count[MAXN];
+//int size[MAXN];
+//int next_node[MAXN][MAXL + 1];
+//int len[MAXN][MAXL + 1];
+//
+//void build() {
+//    cnt = 1;
+//    key[cnt] = INT_MIN;
+//    size[cnt] = MAXL;
+//}
+//
+//void clear() {
+//    memset(key + 1, 0, cnt * sizeof(int));
+//    memset(key_count + 1, 0, cnt * sizeof(int));
+//    memset(size + 1, 0, cnt * sizeof(int));
+//    for (int i = 1; i <= cnt; i++) {
+//        memset(next_node[i], 0, (MAXL + 1) * sizeof(int));
+//        memset(len[i], 0, (MAXL + 1) * sizeof(int));
+//    }
+//    cnt = 0;
+//}
+//
+//int randomLevel() {
+//    int ans = 1;
+//    while ((std::rand() / double(RAND_MAX)) < 0.5) {
+//        ans++;
+//    }
+//    return min(ans, MAXL);
+//}
+//
+//int find(int i, int h, int num) {
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < num) {
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        if (next_node[i][h] != 0 && key[next_node[i][h]] == num) {
+//            return next_node[i][h];
+//        } else {
+//            return 0;
+//        }
+//    }
+//    return find(i, h - 1, num);
+//}
+//
+//void addCount(int i, int h, int num) {
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < num) {
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        key_count[next_node[i][h]]++;
+//    } else {
+//        addCount(i, h - 1, num);
+//    }
+//    len[i][h]++;
+//}
+//
+//int addNode(int i, int h, int j) {
+//    int rightCnt = 0;
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < key[j]) {
+//        rightCnt += len[i][h];
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        next_node[j][h] = next_node[i][h];
+//        next_node[i][h] = j;
+//        len[j][h] = key_count[next_node[j][h]];
+//        len[i][h] = key_count[next_node[i][h]];
+//        return rightCnt;
+//    } else {
+//        int downCnt = addNode(i, h - 1, j);
+//        if (h > size[j]) {
+//            len[i][h]++;
+//        } else {
+//            next_node[j][h] = next_node[i][h];
+//            next_node[i][h] = j;
+//            len[j][h] = len[i][h] + 1 - downCnt - key_count[j];
+//            len[i][h] = downCnt + key_count[j];
+//        }
+//        return rightCnt + downCnt;
+//    }
+//}
+//
+//void add(int num) {
+//    if (find(1, MAXL, num) != 0) {
+//        addCount(1, MAXL, num);
+//    } else {
+//        key[++cnt] = num;
+//        key_count[cnt] = 1;
+//        size[cnt] = randomLevel();
+//        addNode(1, MAXL, cnt);
+//    }
+//}
+//
+//void removeCount(int i, int h, int num) {
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < num) {
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        key_count[next_node[i][h]]--;
+//    } else {
+//        removeCount(i, h - 1, num);
+//    }
+//    len[i][h]--;
+//}
+//
+//void removeNode(int i, int h, int j) {
+//    if (h < 1) {
+//        return;
+//    }
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < key[j]) {
+//        i = next_node[i][h];
+//    }
+//    if (h > size[j]) {
+//        len[i][h]--;
+//    } else {
+//        next_node[i][h] = next_node[j][h];
+//        len[i][h] += len[j][h] - 1;
+//    }
+//    removeNode(i, h - 1, j);
+//}
+//
+//void remove(int num) {
+//    int j = find(1, MAXL, num);
+//    if (j != 0) {
+//        if (key_count[j] > 1) {
+//            removeCount(1, MAXL, num);
+//        } else {
+//            removeNode(1, MAXL, j);
+//        }
+//    }
+//}
+//
+//int getRank(int i, int h, int num) {
+//    int rightCnt = 0;
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < num) {
+//        rightCnt += len[i][h];
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        return rightCnt;
+//    } else {
+//        return rightCnt + getRank(i, h - 1, num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return getRank(1, MAXL, num) + 1;
+//}
+//
+//int index(int i, int h, int x) {
+//    int c = 0;
+//    while (next_node[i][h] != 0 && c + len[i][h] < x) {
+//        c += len[i][h];
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        return key[next_node[i][h]];
+//    } else {
+//        return index(i, h - 1, x - c);
+//    }
+//}
+//
+//int index(int x) {
+//    return index(1, MAXL, x);
+//}
+//
+//int pre(int i, int h, int num) {
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < num) {
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        return i == 1 ? INT_MIN : key[i];
+//    } else {
+//        return pre(i, h - 1, num);
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(1, MAXL, num);
+//}
+//
+//int post(int i, int h, int num) {
+//    while (next_node[i][h] != 0 && key[next_node[i][h]] < num) {
+//        i = next_node[i][h];
+//    }
+//    if (h == 1) {
+//        if (next_node[i][h] == 0) {
+//            return INT_MAX;
+//        }
+//        if (key[next_node[i][h]] > num) {
+//            return key[next_node[i][h]];
+//        }
+//        i = next_node[i][h];
+//        if (next_node[i][h] == 0) {
+//            return INT_MAX;
+//        } else {
+//            return key[next_node[i][h]];
+//        }
+//    } else {
+//        return post(i, h - 1, num);
+//    }
+//}
+//
+//int post(int num) {
+//    return post(1, MAXL, num);
+//}
+//
+//int main() {
+//    build();
+//    int n;
+//    cin >> n;
+//    for (int i = 1, op, x; i <= n; i++) {
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << endl;
+//        } else if (op == 4) {
+//            cout << index(x) << endl;
+//        } else if (op == 5) {
+//            cout << pre(x) << endl;
+//        } else {
+//            cout << post(x) << endl;
+//        }
+//    }
+//    clear();
+//    return 0;
+//}
\ No newline at end of file

From dac5cd19cb5af592f3d697c6f594ce4ba1ac4d9c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Oct 2024 16:02:54 +0800
Subject: [PATCH 0048/1712] modify code

---
 src/class148/AVL1.java      | 2 +-
 src/class148/AVL2.java      | 2 +-
 src/class149/SkipList1.java | 2 +-
 src/class149/SkipList2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class148/AVL1.java b/src/class148/AVL1.java
index 491ddcb5d..42814a02e 100644
--- a/src/class148/AVL1.java
+++ b/src/class148/AVL1.java
@@ -1,6 +1,6 @@
 package class148;
 
-// AVL树的实现
+// AVL树的实现(java版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加一个x，支持重复加入
 // 2，删除一个x，只删掉一个
diff --git a/src/class148/AVL2.java b/src/class148/AVL2.java
index 15b6571dd..df966d202 100644
--- a/src/class148/AVL2.java
+++ b/src/class148/AVL2.java
@@ -1,6 +1,6 @@
 package class148;
 
-// AVL树的实现
+// AVL树的实现(C++版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加一个x，支持重复加入
 // 2，删除一个x，只删掉一个
diff --git a/src/class149/SkipList1.java b/src/class149/SkipList1.java
index 26a1c2e2b..4a2ab0c1f 100644
--- a/src/class149/SkipList1.java
+++ b/src/class149/SkipList1.java
@@ -1,6 +1,6 @@
 package class149;
 
-// 跳表的实现
+// 跳表的实现(java版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加一个x，支持重复加入
 // 2，删除一个x，只删掉一个
diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
index fbba35f66..cb25c1cf8 100644
--- a/src/class149/SkipList2.java
+++ b/src/class149/SkipList2.java
@@ -1,6 +1,6 @@
 package class149;
 
-// 跳表的实现
+// 跳表的实现(C++版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加一个x，支持重复加入
 // 2，删除一个x，只删掉一个

From eee9655d399e2bb0238341f63abbf522ea6b6fb8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 25 Oct 2024 13:21:38 +0800
Subject: [PATCH 0049/1712] modify code

---
 src/class148/AVL1.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/class148/AVL1.java b/src/class148/AVL1.java
index 42814a02e..4a1c15ea4 100644
--- a/src/class148/AVL1.java
+++ b/src/class148/AVL1.java
@@ -25,20 +25,28 @@ public class AVL1 {
 
 	public static int MAXN = 100001;
 
+	// 空间使用计数
 	public static int cnt = 0;
 
+	// 整棵树的头节点编号
 	public static int head = 0;
 
+	// 节点的key
 	public static int[] key = new int[MAXN];
 
+	// 节点key的计数
 	public static int[] count = new int[MAXN];
 
+	// 子树的数字总数
 	public static int[] size = new int[MAXN];
 
+	// 子树高度
 	public static int[] height = new int[MAXN];
 
+	// 左孩子
 	public static int[] left = new int[MAXN];
 
+	// 右孩子
 	public static int[] right = new int[MAXN];
 
 	public static void up(int i) {

From f5e8a33b4b04ce8a8222ea3566a74d9752a22480 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 25 Oct 2024 13:31:31 +0800
Subject: [PATCH 0050/1712] modify code

---
 src/class148/AVL1.java                | 16 ++++++++--------
 src/class148/AVL2.java                |  8 ++++----
 src/class148/ReconstructionQueue.java | 12 ++++++------
 3 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/class148/AVL1.java b/src/class148/AVL1.java
index 4a1c15ea4..6a6c0b607 100644
--- a/src/class148/AVL1.java
+++ b/src/class148/AVL1.java
@@ -34,12 +34,6 @@ public class AVL1 {
 	// 节点的key
 	public static int[] key = new int[MAXN];
 
-	// 节点key的计数
-	public static int[] count = new int[MAXN];
-
-	// 子树的数字总数
-	public static int[] size = new int[MAXN];
-
 	// 子树高度
 	public static int[] height = new int[MAXN];
 
@@ -49,6 +43,12 @@ public class AVL1 {
 	// 右孩子
 	public static int[] right = new int[MAXN];
 
+	// 节点key的计数
+	public static int[] count = new int[MAXN];
+
+	// 子树的数字总数
+	public static int[] size = new int[MAXN];
+
 	public static void up(int i) {
 		size[i] = size[left[i]] + size[right[i]] + count[i];
 		height[i] = Math.max(height[left[i]], height[right[i]]) + 1;
@@ -225,11 +225,11 @@ public static int post(int i, int num) {
 
 	public static void clear() {
 		Arrays.fill(key, 1, cnt + 1, 0);
-		Arrays.fill(count, 1, cnt + 1, 0);
-		Arrays.fill(size, 1, cnt + 1, 0);
 		Arrays.fill(height, 1, cnt + 1, 0);
 		Arrays.fill(left, 1, cnt + 1, 0);
 		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
 		cnt = 0;
 		head = 0;
 	}
diff --git a/src/class148/AVL2.java b/src/class148/AVL2.java
index df966d202..6d4fa546d 100644
--- a/src/class148/AVL2.java
+++ b/src/class148/AVL2.java
@@ -26,11 +26,11 @@
 //int cnt = 0;
 //int head = 0;
 //int key[MAXN];
-//int key_count[MAXN];
-//int size[MAXN];
 //int height[MAXN];
 //int leftChild[MAXN];
 //int rightChild[MAXN];
+//int key_count[MAXN];
+//int size[MAXN];
 //
 //void up(int i) {
 //    size[i] = size[leftChild[i]] + size[rightChild[i]] + key_count[i];
@@ -208,11 +208,11 @@
 //
 //void clear() {
 //    memset(key + 1, 0, cnt * sizeof(int));
-//    memset(key_count + 1, 0, cnt * sizeof(int));
-//    memset(size + 1, 0, cnt * sizeof(int));
 //    memset(height + 1, 0, cnt * sizeof(int));
 //    memset(leftChild + 1, 0, cnt * sizeof(int));
 //    memset(rightChild + 1, 0, cnt * sizeof(int));
+//    memset(key_count + 1, 0, cnt * sizeof(int));
+//    memset(size + 1, 0, cnt * sizeof(int));
 //    cnt = 0;
 //    head = 0;
 //}
diff --git a/src/class148/ReconstructionQueue.java b/src/class148/ReconstructionQueue.java
index 4c864fe71..d5909eb5b 100644
--- a/src/class148/ReconstructionQueue.java
+++ b/src/class148/ReconstructionQueue.java
@@ -29,15 +29,15 @@ public static int[][] reconstructQueue(int[][] people) {
 
 	public static int[] key = new int[MAXN];
 
-	public static int[] value = new int[MAXN];
-
-	public static int[] size = new int[MAXN];
-
 	public static int[] height = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
+	
+	public static int[] value = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
 
 	public static void up(int i) {
 		size[i] = size[left[i]] + size[right[i]] + 1;
@@ -126,11 +126,11 @@ public static void inOrder(int[][] ans, int i) {
 
 	public static void clear() {
 		Arrays.fill(key, 1, cnt + 1, 0);
-		Arrays.fill(value, 1, cnt + 1, 0);
-		Arrays.fill(size, 1, cnt + 1, 0);
 		Arrays.fill(height, 1, cnt + 1, 0);
 		Arrays.fill(left, 1, cnt + 1, 0);
 		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(value, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
 		cnt = 0;
 		head = 0;
 	}

From db1aba746471767c048dc39c4937fb0aa042d588 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 25 Oct 2024 13:36:24 +0800
Subject: [PATCH 0051/1712] modify code

---
 src/class148/AVL1.java                | 8 ++------
 src/class148/AVL2.java                | 8 ++------
 src/class148/ReconstructionQueue.java | 8 ++------
 3 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/src/class148/AVL1.java b/src/class148/AVL1.java
index 6a6c0b607..3219d7f8e 100644
--- a/src/class148/AVL1.java
+++ b/src/class148/AVL1.java
@@ -76,18 +76,14 @@ public static int maintain(int i) {
 		int lh = height[left[i]];
 		int rh = height[right[i]];
 		if (lh - rh > 1) {
-			int llh = height[left[left[i]]];
-			int lrh = height[right[left[i]]];
-			if (llh >= lrh) {
+			if (height[left[left[i]]] >= height[right[left[i]]]) {
 				i = rightRotate(i);
 			} else {
 				left[i] = leftRotate(left[i]);
 				i = rightRotate(i);
 			}
 		} else if (rh - lh > 1) {
-			int rrh = height[right[right[i]]];
-			int rlh = height[left[right[i]]];
-			if (rrh >= rlh) {
+			if (height[right[right[i]]] >= height[left[right[i]]]) {
 				i = leftRotate(i);
 			} else {
 				right[i] = rightRotate(right[i]);
diff --git a/src/class148/AVL2.java b/src/class148/AVL2.java
index 6d4fa546d..91fde331a 100644
--- a/src/class148/AVL2.java
+++ b/src/class148/AVL2.java
@@ -59,18 +59,14 @@
 //    int lh = height[leftChild[i]];
 //    int rh = height[rightChild[i]];
 //    if (lh - rh > 1) {
-//        int llh = height[leftChild[leftChild[i]]];
-//        int lrh = height[rightChild[leftChild[i]]];
-//        if (llh >= lrh) {
+//        if (height[leftChild[leftChild[i]]] >= height[rightChild[leftChild[i]]]) {
 //            i = rightRotate(i);
 //        } else {
 //            leftChild[i] = leftRotate(leftChild[i]);
 //            i = rightRotate(i);
 //        }
 //    } else if (rh - lh > 1) {
-//        int rrh = height[rightChild[rightChild[i]]];
-//        int rlh = height[leftChild[rightChild[i]]];
-//        if (rrh >= rlh) {
+//        if (height[rightChild[rightChild[i]]] >= height[leftChild[rightChild[i]]]) {
 //            i = leftRotate(i);
 //        } else {
 //            rightChild[i] = rightRotate(rightChild[i]);
diff --git a/src/class148/ReconstructionQueue.java b/src/class148/ReconstructionQueue.java
index d5909eb5b..e3715645a 100644
--- a/src/class148/ReconstructionQueue.java
+++ b/src/class148/ReconstructionQueue.java
@@ -66,18 +66,14 @@ public static int maintain(int i) {
 		int lh = height[left[i]];
 		int rh = height[right[i]];
 		if (lh - rh > 1) {
-			int llh = height[left[left[i]]];
-			int lrh = height[right[left[i]]];
-			if (llh >= lrh) {
+			if (height[left[left[i]]] >= height[right[left[i]]]) {
 				i = rightRotate(i);
 			} else {
 				left[i] = leftRotate(left[i]);
 				i = rightRotate(i);
 			}
 		} else if (rh - lh > 1) {
-			int rrh = height[right[right[i]]];
-			int rlh = height[left[right[i]]];
-			if (rrh >= rlh) {
+			if (height[right[right[i]]] >= height[left[right[i]]]) {
 				i = leftRotate(i);
 			} else {
 				right[i] = rightRotate(right[i]);

From 771b907dd12e6e7931905cd0005c50e9a19eae8d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 25 Oct 2024 13:43:43 +0800
Subject: [PATCH 0052/1712] modify code

---
 src/class148/AVL1.java      | 4 ++--
 src/class148/AVL2.java      | 4 ++--
 src/class149/SkipList1.java | 4 ++--
 src/class149/SkipList2.java | 4 ++--
 4 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class148/AVL1.java b/src/class148/AVL1.java
index 3219d7f8e..1ea42eb08 100644
--- a/src/class148/AVL1.java
+++ b/src/class148/AVL1.java
@@ -2,8 +2,8 @@
 
 // AVL树的实现(java版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
-// 1，增加一个x，支持重复加入
-// 2，删除一个x，只删掉一个
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
 // 3，查询x的排名，x的排名为，比x小的数的个数+1
 // 4，查询数据中排名为x的数
 // 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
diff --git a/src/class148/AVL2.java b/src/class148/AVL2.java
index 91fde331a..748bb2712 100644
--- a/src/class148/AVL2.java
+++ b/src/class148/AVL2.java
@@ -2,8 +2,8 @@
 
 // AVL树的实现(C++版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
-// 1，增加一个x，支持重复加入
-// 2，删除一个x，只删掉一个
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
 // 3，查询x的排名，x的排名为，比x小的数的个数+1
 // 4，查询数据中排名为x的数
 // 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
diff --git a/src/class149/SkipList1.java b/src/class149/SkipList1.java
index 4a2ab0c1f..b728d5982 100644
--- a/src/class149/SkipList1.java
+++ b/src/class149/SkipList1.java
@@ -2,8 +2,8 @@
 
 // 跳表的实现(java版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
-// 1，增加一个x，支持重复加入
-// 2，删除一个x，只删掉一个
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
 // 3，查询x的排名，x的排名为，比x小的数的个数+1
 // 4，查询数据中排名为x的数
 // 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
index cb25c1cf8..4805b3611 100644
--- a/src/class149/SkipList2.java
+++ b/src/class149/SkipList2.java
@@ -2,8 +2,8 @@
 
 // 跳表的实现(C++版)
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
-// 1，增加一个x，支持重复加入
-// 2，删除一个x，只删掉一个
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
 // 3，查询x的排名，x的排名为，比x小的数的个数+1
 // 4，查询数据中排名为x的数
 // 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值

From 203bf337239a886497ac6ba5a8e0cf9851b7a826 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 25 Oct 2024 22:16:28 +0800
Subject: [PATCH 0053/1712] modify code

---
 src/class148/AVL1.java | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

diff --git a/src/class148/AVL1.java b/src/class148/AVL1.java
index 1ea42eb08..c186fc0cc 100644
--- a/src/class148/AVL1.java
+++ b/src/class148/AVL1.java
@@ -49,11 +49,13 @@ public class AVL1 {
 	// 子树的数字总数
 	public static int[] size = new int[MAXN];
 
+	// 修正信息
 	public static void up(int i) {
 		size[i] = size[left[i]] + size[right[i]] + count[i];
 		height[i] = Math.max(height[left[i]], height[right[i]]) + 1;
 	}
 
+	// i节点为头的树左旋，返回左旋后头节点的空间编号
 	public static int leftRotate(int i) {
 		int r = right[i];
 		right[i] = left[r];
@@ -63,6 +65,7 @@ public static int leftRotate(int i) {
 		return r;
 	}
 
+	// i节点为头的树右旋，返回右旋后头节点的空间编号
 	public static int rightRotate(int i) {
 		int l = left[i];
 		left[i] = right[l];
@@ -72,6 +75,9 @@ public static int rightRotate(int i) {
 		return l;
 	}
 
+	// 检查i节点为头的树是否违规
+	// 如果命中了某种违规情况，就进行相应调整
+	// 返回树的头节点的空间编号
 	public static int maintain(int i) {
 		int lh = height[left[i]];
 		int rh = height[right[i]];
@@ -93,10 +99,13 @@ public static int maintain(int i) {
 		return i;
 	}
 
+	// 增加数字num，重复加入算多个词频
 	public static void add(int num) {
 		head = add(head, num);
 	}
 
+	// 当前来到i号节点，num这个数字一定会加入以i为头的树
+	// 树结构有可能变化，返回头节点编号
 	public static int add(int i, int num) {
 		if (i == 0) {
 			key[++cnt] = num;
@@ -114,12 +123,15 @@ public static int add(int i, int num) {
 		return maintain(i);
 	}
 
+	// 删除数字num，如果有多个，只删掉一个
 	public static void remove(int num) {
 		if (rank(num) != rank(num + 1)) {
 			head = remove(head, num);
 		}
 	}
 
+	// 当前来到i号节点，以i为头的树一定会减少1个num
+	// 树结构有可能变化，返回头节点编号
 	public static int remove(int i, int num) {
 		if (key[i] < num) {
 			right[i] = remove(right[i], num);
@@ -151,6 +163,8 @@ public static int remove(int i, int num) {
 		return maintain(i);
 	}
 
+	// 以i号节点为头的树上，最左节点的编号一定是mostLeft
+	// 删掉这个节点，并保证树的平衡性，返回头节点的编号
 	public static int removeMostLeft(int i, int mostLeft) {
 		if (i == mostLeft) {
 			return right[i];
@@ -161,10 +175,12 @@ public static int removeMostLeft(int i, int mostLeft) {
 		}
 	}
 
+	// 查询num的排名，比num小的数字个数+1，就是num的排名
 	public static int rank(int num) {
 		return small(head, num) + 1;
 	}
 
+	// 以i为头的树上，比num小的数字有几个
 	public static int small(int i, int num) {
 		if (i == 0) {
 			return 0;

From a1cb1f978dc11c6d5549081cbcf005539ef000b1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 25 Oct 2024 23:36:55 +0800
Subject: [PATCH 0054/1712] modify code

---
 ...4\270\223\351\242\2301-AVL\346\240\221.pptx" | Bin 0 -> 47576 bytes
 src/class148/ReconstructionQueue.java           |   4 ++--
 2 files changed, 2 insertions(+), 2 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243148\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2301-AVL\346\240\221.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243148\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2301-AVL\346\240\221.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243148\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2301-AVL\346\240\221.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..94efe887ee1802770952b721ad977b89faccce46
GIT binary patch
literal 47576
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
YX{1L9d<{n+6oH2h@TESW<j1@J0R{kyJOBUy

literal 0
HcmV?d00001

diff --git a/src/class148/ReconstructionQueue.java b/src/class148/ReconstructionQueue.java
index e3715645a..df7a2da78 100644
--- a/src/class148/ReconstructionQueue.java
+++ b/src/class148/ReconstructionQueue.java
@@ -84,7 +84,7 @@ public static int maintain(int i) {
 	}
 
 	public static void add(int num, int index) {
-		head = add(head, index + 1, num, index);
+		head = add(head, index, num, index);
 	}
 
 	public static int add(int i, int rank, int num, int index) {
@@ -94,7 +94,7 @@ public static int add(int i, int rank, int num, int index) {
 			size[cnt] = height[cnt] = 1;
 			return cnt;
 		}
-		if (size[left[i]] + 1 >= rank) {
+		if (size[left[i]] >= rank) {
 			left[i] = add(left[i], rank, num, index);
 		} else {
 			right[i] = add(right[i], rank - size[left[i]] - 1, num, index);

From b9db0c2daf8154241fbb8f09c3455b676e916596 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 28 Oct 2024 13:37:56 +0800
Subject: [PATCH 0055/1712] modify code

---
 src/class149/SkipList1.java | 12 ++++++------
 src/class149/SkipList2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class149/SkipList1.java b/src/class149/SkipList1.java
index b728d5982..7e8f53ede 100644
--- a/src/class149/SkipList1.java
+++ b/src/class149/SkipList1.java
@@ -33,7 +33,7 @@ public class SkipList1 {
 
 	public static int[] count = new int[MAXN];
 
-	public static int[] size = new int[MAXN];
+	public static int[] level = new int[MAXN];
 
 	public static int[][] next = new int[MAXN][MAXL + 1];
 
@@ -42,13 +42,13 @@ public class SkipList1 {
 	public static void build() {
 		cnt = 1;
 		key[cnt] = Integer.MIN_VALUE;
-		size[cnt] = MAXL;
+		level[cnt] = MAXL;
 	}
 
 	public static void clear() {
 		Arrays.fill(key, 1, cnt + 1, 0);
 		Arrays.fill(count, 1, cnt + 1, 0);
-		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(level, 1, cnt + 1, 0);
 		for (int i = 1; i <= cnt; i++) {
 			Arrays.fill(next[i], 0);
 			Arrays.fill(len[i], 0);
@@ -84,7 +84,7 @@ public static void add(int num) {
 		} else {
 			key[++cnt] = num;
 			count[cnt] = 1;
-			size[cnt] = random();
+			level[cnt] = random();
 			addNode(1, MAXL, cnt);
 		}
 	}
@@ -115,7 +115,7 @@ public static int addNode(int i, int h, int j) {
 			return rightCnt;
 		} else {
 			int downCnt = addNode(i, h - 1, j);
-			if (h > size[j]) {
+			if (h > level[j]) {
 				len[i][h]++;
 			} else {
 				next[j][h] = next[i][h];
@@ -157,7 +157,7 @@ public static void removeNode(int i, int h, int j) {
 		while (next[i][h] != 0 && key[next[i][h]] < key[j]) {
 			i = next[i][h];
 		}
-		if (h > size[j]) {
+		if (h > level[j]) {
 			len[i][h]--;
 		} else {
 			next[i][h] = next[j][h];
diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
index 4805b3611..cff16d44e 100644
--- a/src/class149/SkipList2.java
+++ b/src/class149/SkipList2.java
@@ -29,20 +29,20 @@
 //int cnt;
 //int key[MAXN];
 //int key_count[MAXN];
-//int size[MAXN];
+//int level[MAXN];
 //int next_node[MAXN][MAXL + 1];
 //int len[MAXN][MAXL + 1];
 //
 //void build() {
 //    cnt = 1;
 //    key[cnt] = INT_MIN;
-//    size[cnt] = MAXL;
+//    level[cnt] = MAXL;
 //}
 //
 //void clear() {
 //    memset(key + 1, 0, cnt * sizeof(int));
 //    memset(key_count + 1, 0, cnt * sizeof(int));
-//    memset(size + 1, 0, cnt * sizeof(int));
+//    memset(level + 1, 0, cnt * sizeof(int));
 //    for (int i = 1; i <= cnt; i++) {
 //        memset(next_node[i], 0, (MAXL + 1) * sizeof(int));
 //        memset(len[i], 0, (MAXL + 1) * sizeof(int));
@@ -98,7 +98,7 @@
 //        return rightCnt;
 //    } else {
 //        int downCnt = addNode(i, h - 1, j);
-//        if (h > size[j]) {
+//        if (h > level[j]) {
 //            len[i][h]++;
 //        } else {
 //            next_node[j][h] = next_node[i][h];
@@ -116,7 +116,7 @@
 //    } else {
 //        key[++cnt] = num;
 //        key_count[cnt] = 1;
-//        size[cnt] = randomLevel();
+//        level[cnt] = randomLevel();
 //        addNode(1, MAXL, cnt);
 //    }
 //}
@@ -140,7 +140,7 @@
 //    while (next_node[i][h] != 0 && key[next_node[i][h]] < key[j]) {
 //        i = next_node[i][h];
 //    }
-//    if (h > size[j]) {
+//    if (h > level[j]) {
 //        len[i][h]--;
 //    } else {
 //        next_node[i][h] = next_node[j][h];

From ff99a049e80e218da9040d33929b520924f0e619 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 28 Oct 2024 18:25:40 +0800
Subject: [PATCH 0056/1712] modify code

---
 src/class149/SkipList1.java | 25 +++++++++++++++++++++++++
 1 file changed, 25 insertions(+)

diff --git a/src/class149/SkipList1.java b/src/class149/SkipList1.java
index 7e8f53ede..6e684f49b 100644
--- a/src/class149/SkipList1.java
+++ b/src/class149/SkipList1.java
@@ -23,28 +23,37 @@
 
 public class SkipList1 {
 
+	// 跳表最大层的限制
 	public static int MAXL = 20;
 
 	public static int MAXN = 100001;
 
+	// 空间使用计数
 	public static int cnt;
 
+	// 节点的key
 	public static int[] key = new int[MAXN];
 
+	// 节点key的计数
 	public static int[] count = new int[MAXN];
 
+	// 节点拥有多少层指针
 	public static int[] level = new int[MAXN];
 
+	// 节点每一层指针指向哪个节点
 	public static int[][] next = new int[MAXN][MAXL + 1];
 
+	// 节点每一层指针的长度(底层跨过多少数，左开右闭)
 	public static int[][] len = new int[MAXN][MAXL + 1];
 
+	// 建立跳表
 	public static void build() {
 		cnt = 1;
 		key[cnt] = Integer.MIN_VALUE;
 		level[cnt] = MAXL;
 	}
 
+	// 使用多少空间一律清空
 	public static void clear() {
 		Arrays.fill(key, 1, cnt + 1, 0);
 		Arrays.fill(count, 1, cnt + 1, 0);
@@ -56,6 +65,7 @@ public static void clear() {
 		cnt = 0;
 	}
 
+	// 扔骰子决定节点的层数
 	public static int random() {
 		int ans = 1;
 		while (Math.random() < 0.5) {
@@ -64,6 +74,7 @@ public static int random() {
 		return Math.min(ans, MAXL);
 	}
 
+	// 当前在i号节点的h层，返回key为num的节点，空间编号是多少
 	public static int find(int i, int h, int num) {
 		while (next[i][h] != 0 && key[next[i][h]] < num) {
 			i = next[i][h];
@@ -78,6 +89,7 @@ public static int find(int i, int h, int num) {
 		return find(i, h - 1, num);
 	}
 
+	// 增加num，重复加入算多个词频
 	public static void add(int num) {
 		if (find(1, MAXL, num) != 0) {
 			addCount(1, MAXL, num);
@@ -89,6 +101,7 @@ public static void add(int num) {
 		}
 	}
 
+	// 当前在i号节点的h层，num增加一个词频
 	public static void addCount(int i, int h, int num) {
 		while (next[i][h] != 0 && key[next[i][h]] < num) {
 			i = next[i][h];
@@ -101,6 +114,9 @@ public static void addCount(int i, int h, int num) {
 		len[i][h]++;
 	}
 
+	// 当前在i号节点的h层，插入空间编号为j的节点
+	// 返回值：从i号节点出发，直到把空间编号为j的节点插入，总共跨过多少数字
+	// 返回值很重要，因为上游需要这个信息来改动指针长度
 	public static int addNode(int i, int h, int j) {
 		int rightCnt = 0;
 		while (next[i][h] != 0 && key[next[i][h]] < key[j]) {
@@ -127,6 +143,7 @@ public static int addNode(int i, int h, int j) {
 		}
 	}
 
+	// 删除x，如果有多个，只删掉一个
 	public static void remove(int num) {
 		int j = find(1, MAXL, num);
 		if (j != 0) {
@@ -138,6 +155,7 @@ public static void remove(int num) {
 		}
 	}
 
+	// 当前在i号节点的h层，num减少一个词频
 	public static void removeCount(int i, int h, int num) {
 		while (next[i][h] != 0 && key[next[i][h]] < num) {
 			i = next[i][h];
@@ -150,6 +168,7 @@ public static void removeCount(int i, int h, int num) {
 		len[i][h]--;
 	}
 
+	// 当前在i号节点的h层，删除空间编号为j的节点
 	public static void removeNode(int i, int h, int j) {
 		if (h < 1) {
 			return;
@@ -166,10 +185,12 @@ public static void removeNode(int i, int h, int j) {
 		removeNode(i, h - 1, j);
 	}
 
+	// 查询num的排名
 	public static int rank(int num) {
 		return rank(1, MAXL, num) + 1;
 	}
 
+	// 当前在i号节点的h层，查询有多少个数字比num小
 	public static int rank(int i, int h, int num) {
 		int rightCnt = 0;
 		while (next[i][h] != 0 && key[next[i][h]] < num) {
@@ -183,10 +204,12 @@ public static int rank(int i, int h, int num) {
 		}
 	}
 
+	// 查询排名第x的key是什么
 	public static int index(int x) {
 		return index(1, MAXL, x);
 	}
 
+	// 当前在i号节点的h层，查询排名第x的key是什么
 	public static int index(int i, int h, int x) {
 		int c = 0;
 		while (next[i][h] != 0 && c + len[i][h] < x) {
@@ -200,6 +223,7 @@ public static int index(int i, int h, int x) {
 		}
 	}
 
+	// 查询num的前驱
 	public static int pre(int num) {
 		return pre(1, MAXL, num);
 	}
@@ -215,6 +239,7 @@ public static int pre(int i, int h, int num) {
 		}
 	}
 
+	// 查询num的后继
 	public static int post(int num) {
 		return post(1, MAXL, num);
 	}

From e2090f665c4c3eaf284f1ba53847b765e597807b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 28 Oct 2024 18:27:43 +0800
Subject: [PATCH 0057/1712] modify code

---
 src/class149/SkipList1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class149/SkipList1.java b/src/class149/SkipList1.java
index 6e684f49b..8cba53b6b 100644
--- a/src/class149/SkipList1.java
+++ b/src/class149/SkipList1.java
@@ -115,8 +115,8 @@ public static void addCount(int i, int h, int num) {
 	}
 
 	// 当前在i号节点的h层，插入空间编号为j的节点
-	// 返回值：从i号节点出发，直到把空间编号为j的节点插入，总共跨过多少数字
-	// 返回值很重要，因为上游需要这个信息来改动指针长度
+	// 返回值：从i号节点出发，直到把空间编号为j的节点插入，底层总共跨过多少数字
+	// 返回值很重要，因为上游需要这个信息来改动指针的长度信息
 	public static int addNode(int i, int h, int j) {
 		int rightCnt = 0;
 		while (next[i][h] != 0 && key[next[i][h]] < key[j]) {

From 2a4a2b203ca0503d6dc57dd633e79cd6e8c38a2e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 28 Oct 2024 22:32:05 +0800
Subject: [PATCH 0058/1712] modify code

---
 ...\351\242\2302-\350\267\263\350\241\250.pptx" | Bin 0 -> 39635 bytes
 src/class149/SkipList1.java                     |   8 ++++----
 src/class149/SkipList2.java                     |   6 +++---
 3 files changed, 7 insertions(+), 7 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243149\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2302-\350\267\263\350\241\250.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243149\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2302-\350\267\263\350\241\250.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243149\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2302-\350\267\263\350\241\250.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..2e146bd9a1e79d8e365d06408d3bf81da5436ef0
GIT binary patch
literal 39635
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

literal 0
HcmV?d00001

diff --git a/src/class149/SkipList1.java b/src/class149/SkipList1.java
index 8cba53b6b..089e0d386 100644
--- a/src/class149/SkipList1.java
+++ b/src/class149/SkipList1.java
@@ -115,7 +115,7 @@ public static void addCount(int i, int h, int num) {
 	}
 
 	// 当前在i号节点的h层，插入空间编号为j的节点
-	// 返回值：从i号节点出发，直到把空间编号为j的节点插入，底层总共跨过多少数字
+	// 返回值：从i号节点出发，直到把空间编号为j的节点插入，底层总共有多少数字比key[j]小
 	// 返回值很重要，因为上游需要这个信息来改动指针的长度信息
 	public static int addNode(int i, int h, int j) {
 		int rightCnt = 0;
@@ -187,11 +187,11 @@ public static void removeNode(int i, int h, int j) {
 
 	// 查询num的排名
 	public static int rank(int num) {
-		return rank(1, MAXL, num) + 1;
+		return small(1, MAXL, num) + 1;
 	}
 
 	// 当前在i号节点的h层，查询有多少个数字比num小
-	public static int rank(int i, int h, int num) {
+	public static int small(int i, int h, int num) {
 		int rightCnt = 0;
 		while (next[i][h] != 0 && key[next[i][h]] < num) {
 			rightCnt += len[i][h];
@@ -200,7 +200,7 @@ public static int rank(int i, int h, int num) {
 		if (h == 1) {
 			return rightCnt;
 		} else {
-			return rightCnt + rank(i, h - 1, num);
+			return rightCnt + small(i, h - 1, num);
 		}
 	}
 
diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
index cff16d44e..fc69395e1 100644
--- a/src/class149/SkipList2.java
+++ b/src/class149/SkipList2.java
@@ -160,7 +160,7 @@
 //    }
 //}
 //
-//int getRank(int i, int h, int num) {
+//int small(int i, int h, int num) {
 //    int rightCnt = 0;
 //    while (next_node[i][h] != 0 && key[next_node[i][h]] < num) {
 //        rightCnt += len[i][h];
@@ -169,12 +169,12 @@
 //    if (h == 1) {
 //        return rightCnt;
 //    } else {
-//        return rightCnt + getRank(i, h - 1, num);
+//        return rightCnt + small(i, h - 1, num);
 //    }
 //}
 //
 //int getRank(int num) {
-//    return getRank(1, MAXL, num) + 1;
+//    return small(1, MAXL, num) + 1;
 //}
 //
 //int index(int i, int h, int x) {

From 6ef1d37415c98b9ab90285f093f496f44931ee6c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 4 Nov 2024 17:05:38 +0800
Subject: [PATCH 0059/1712] modify code

---
 src/class150/ScapeGoat1.java | 225 +++++++++++++++++++++++++++++++++++
 src/class150/ScapeGoat2.java | 204 +++++++++++++++++++++++++++++++
 2 files changed, 429 insertions(+)
 create mode 100644 src/class150/ScapeGoat1.java
 create mode 100644 src/class150/ScapeGoat2.java

diff --git a/src/class150/ScapeGoat1.java b/src/class150/ScapeGoat1.java
new file mode 100644
index 000000000..269cd07ad
--- /dev/null
+++ b/src/class150/ScapeGoat1.java
@@ -0,0 +1,225 @@
+package class150;
+
+// 替罪羊树的实现(java版)
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class ScapeGoat1 {
+
+	public static int MAXN = 100001;
+
+	public static double ALPHA = 0.7;
+
+	// 整棵树的头节点编号
+	public static int head = 0;
+
+	// 节点的key值
+	public static int[] key = new int[MAXN];
+
+	// 节点key的计数
+	public static int[] count = new int[MAXN];
+
+	// 左孩子
+	public static int[] left = new int[MAXN];
+
+	// 右孩子
+	public static int[] right = new int[MAXN];
+
+	// 数字总数
+	public static int[] size = new int[MAXN];
+
+	// 节点总数
+	public static int[] diff = new int[MAXN];
+
+	public static int[] order = new int[MAXN];
+
+	public static int[] stack = new int[MAXN];
+
+	public static int orderSize, stackSize;
+
+	public static void prepare(int n) {
+		stackSize = 0;
+		for (int i = n; i >= 1; i--) {
+			stack[++stackSize] = i;
+		}
+	}
+
+	public static void inorder(int i) {
+		if (i != 0) {
+			inorder(left[i]);
+			if (count[i] > 0) {
+				order[++orderSize] = i;
+			} else {
+				stack[++stackSize] = i;
+			}
+			inorder(right[i]);
+		}
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
+	}
+
+	public static int build(int l, int r) {
+		if (l > r) {
+			return 0;
+		}
+		int m = (l + r) / 2;
+		int h = order[m];
+		left[h] = build(l, m - 1);
+		right[h] = build(m + 1, r);
+		up(h);
+		return h;
+	}
+
+	public static int rebuild(int i) {
+		orderSize = 0;
+		inorder(i);
+		if (orderSize > 0) {
+			return build(1, orderSize);
+		} else {
+			return 0;
+		}
+	}
+
+	public static boolean balance(int i) {
+		return ALPHA * diff[i] > Math.max(diff[left[i]], diff[right[i]]);
+	}
+
+	public static void add(int num) {
+		head = add(head, num);
+	}
+
+	public static int add(int i, int num) {
+		if (i == 0) {
+			i = stack[stackSize--];
+			key[i] = num;
+			left[i] = right[i] = 0;
+			count[i] = size[i] = diff[i] = 1;
+			return i;
+		} else {
+			if (key[i] == num) {
+				count[i]++;
+			} else if (key[i] > num) {
+				left[i] = add(left[i], num);
+			} else {
+				right[i] = add(right[i], num);
+			}
+			up(i);
+			return balance(i) ? i : rebuild(i);
+		}
+	}
+
+	public static int rank(int num) {
+		return small(head, num) + 1;
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], num);
+		}
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int pre(int num) {
+		int kth = rank(num);
+		if (kth == 1) {
+			return Integer.MIN_VALUE;
+		} else {
+			return index(kth - 1);
+		}
+	}
+
+	public static int post(int num) {
+		int kth = rank(num + 1);
+		if (kth == size[head] + 1) {
+			return Integer.MAX_VALUE;
+		} else {
+			return index(kth);
+		}
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			head = remove(head, num);
+		}
+	}
+
+	public static int remove(int i, int num) {
+		if (key[i] == num) {
+			count[i]--;
+		} else if (key[i] > num) {
+			left[i] = remove(left[i], num);
+		} else {
+			right[i] = remove(right[i], num);
+		}
+		up(i);
+		return balance(i) ? i : rebuild(i);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		prepare(n);
+		for (int i = 1, op, x; i <= n; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				out.println(rank(x));
+			} else if (op == 4) {
+				out.println(index(x));
+			} else if (op == 5) {
+				out.println(pre(x));
+			} else {
+				out.println(post(x));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class150/ScapeGoat2.java b/src/class150/ScapeGoat2.java
new file mode 100644
index 000000000..4a58fa64f
--- /dev/null
+++ b/src/class150/ScapeGoat2.java
@@ -0,0 +1,204 @@
+package class150;
+
+// 替罪羊树的实现(C++版)
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <cmath>
+//#include <climits>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//
+//const double ALPHA = 0.7;
+//
+//int head = 0;
+//int key[MAXN];
+//int key_count[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//int diff[MAXN];
+//int order[MAXN];
+//int stack[MAXN];
+//int orderSize, stackSize;
+//
+//void prepare(int n) {
+//    stackSize = 0;
+//    for (int i = n; i >= 1; --i) {
+//        stack[++stackSize] = i;
+//    }
+//}
+//
+//void inorder(int i) {
+//    if (i != 0) {
+//        inorder(ls[i]);
+//        if (key_count[i] > 0) {
+//            order[++orderSize] = i;
+//        } else {
+//            stack[++stackSize] = i;
+//        }
+//        inorder(rs[i]);
+//    }
+//}
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    diff[i] = diff[ls[i]] + diff[rs[i]] + (key_count[i] > 0 ? 1 : 0);
+//}
+//
+//int build(int l, int r) {
+//    if (l > r) {
+//        return 0;
+//    }
+//    int m = (l + r) / 2;
+//    int h = order[m];
+//    ls[h] = build(l, m - 1);
+//    rs[h] = build(m + 1, r);
+//    up(h);
+//    return h;
+//}
+//
+//int rebuild(int i) {
+//    orderSize = 0;
+//    inorder(i);
+//    if (orderSize > 0) {
+//        return build(1, orderSize);
+//    } else {
+//        return 0;
+//    }
+//}
+//
+//bool balance(int i) {
+//    return ALPHA * diff[i] > max(diff[ls[i]], diff[rs[i]]);
+//}
+//
+//int add(int i, int num) {
+//    if (i == 0) {
+//        i = stack[stackSize--];
+//        key[i] = num;
+//        ls[i] = rs[i] = 0;
+//        key_count[i] = size[i] = diff[i] = 1;
+//        return i;
+//    } else {
+//        if (key[i] == num) {
+//            key_count[i]++;
+//        } else if (key[i] > num) {
+//            ls[i] = add(ls[i], num);
+//        } else {
+//            rs[i] = add(rs[i], num);
+//        }
+//        up(i);
+//        return balance(i) ? i : rebuild(i);
+//    }
+//}
+//
+//int add(int num) {
+//    head = add(head, num);
+//    return head;
+//}
+//
+//int small(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return small(ls[i], num);
+//    } else {
+//        return size[ls[i]] + key_count[i] + small(rs[i], num); // 使用 key_count
+//    }
+//}
+//
+//int getRank(int num) {
+//    return small(head, num) + 1;
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int num) {
+//    int kth = getRank(num);
+//    if (kth == 1) {
+//        return INT_MIN;
+//    } else {
+//        return index(kth - 1);
+//    }
+//}
+//
+//int post(int num) {
+//    int kth = getRank(num + 1);
+//    if (kth == size[head] + 1) {
+//        return INT_MAX;
+//    } else {
+//        return index(kth);
+//    }
+//}
+//
+//int remove(int i, int num) {
+//    if (key[i] == num) {
+//        key_count[i]--;
+//    } else if (key[i] > num) {
+//        ls[i] = remove(ls[i], num);
+//    } else {
+//        rs[i] = remove(rs[i], num);
+//    }
+//    up(i);
+//    return balance(i) ? i : rebuild(i);
+//}
+//
+//int remove(int num) {
+//    if (getRank(num) != getRank(num + 1)) {
+//        head = remove(head, num);
+//    }
+//    return head;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n;
+//    cin >> n;
+//    prepare(n);
+//    for (int i = 0; i < n; ++i) {
+//        int op, x;
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << "\n";
+//        } else if (op == 4) {
+//            cout << index(x) << "\n";
+//        } else if (op == 5) {
+//            cout << pre(x) << "\n";
+//        } else {
+//            cout << post(x) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 8d39d3dc2db2911f1e4adcf115d919b62e81751c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Nov 2024 13:24:49 +0800
Subject: [PATCH 0060/1712] modify code

---
 src/class150/ScapeGoat1.java | 50 ++++++++++++++++++---------------
 src/class150/ScapeGoat2.java | 54 ++++++++++++++++++------------------
 2 files changed, 54 insertions(+), 50 deletions(-)

diff --git a/src/class150/ScapeGoat1.java b/src/class150/ScapeGoat1.java
index 269cd07ad..5f8a2cb69 100644
--- a/src/class150/ScapeGoat1.java
+++ b/src/class150/ScapeGoat1.java
@@ -19,6 +19,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
+import java.util.Arrays;
 
 public class ScapeGoat1 {
 
@@ -29,6 +30,9 @@ public class ScapeGoat1 {
 	// 整棵树的头节点编号
 	public static int head = 0;
 
+	// 空间使用编号
+	public static int cnt = 0;
+
 	// 节点的key值
 	public static int[] key = new int[MAXN];
 
@@ -47,26 +51,16 @@ public class ScapeGoat1 {
 	// 节点总数
 	public static int[] diff = new int[MAXN];
 
-	public static int[] order = new int[MAXN];
-
-	public static int[] stack = new int[MAXN];
-
-	public static int orderSize, stackSize;
+	// 中序遍历收集节点
+	public static int[] collect = new int[MAXN];
 
-	public static void prepare(int n) {
-		stackSize = 0;
-		for (int i = n; i >= 1; i--) {
-			stack[++stackSize] = i;
-		}
-	}
+	public static int ci;
 
 	public static void inorder(int i) {
 		if (i != 0) {
 			inorder(left[i]);
 			if (count[i] > 0) {
-				order[++orderSize] = i;
-			} else {
-				stack[++stackSize] = i;
+				collect[++ci] = i;
 			}
 			inorder(right[i]);
 		}
@@ -82,7 +76,7 @@ public static int build(int l, int r) {
 			return 0;
 		}
 		int m = (l + r) / 2;
-		int h = order[m];
+		int h = collect[m];
 		left[h] = build(l, m - 1);
 		right[h] = build(m + 1, r);
 		up(h);
@@ -90,10 +84,10 @@ public static int build(int l, int r) {
 	}
 
 	public static int rebuild(int i) {
-		orderSize = 0;
+		ci = 0;
 		inorder(i);
-		if (orderSize > 0) {
-			return build(1, orderSize);
+		if (ci > 0) {
+			return build(1, ci);
 		} else {
 			return 0;
 		}
@@ -109,11 +103,10 @@ public static void add(int num) {
 
 	public static int add(int i, int num) {
 		if (i == 0) {
-			i = stack[stackSize--];
+			i = ++cnt;
 			key[i] = num;
 			left[i] = right[i] = 0;
 			count[i] = size[i] = diff[i] = 1;
-			return i;
 		} else {
 			if (key[i] == num) {
 				count[i]++;
@@ -122,9 +115,9 @@ public static int add(int i, int num) {
 			} else {
 				right[i] = add(right[i], num);
 			}
-			up(i);
-			return balance(i) ? i : rebuild(i);
 		}
+		up(i);
+		return balance(i) ? i : rebuild(i);
 	}
 
 	public static int rank(int num) {
@@ -191,13 +184,23 @@ public static int remove(int i, int num) {
 		return balance(i) ? i : rebuild(i);
 	}
 
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(diff, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		in.nextToken();
 		int n = (int) in.nval;
-		prepare(n);
 		for (int i = 1, op, x; i <= n; i++) {
 			in.nextToken();
 			op = (int) in.nval;
@@ -217,6 +220,7 @@ public static void main(String[] args) throws IOException {
 				out.println(post(x));
 			}
 		}
+		clear();
 		out.flush();
 		out.close();
 		br.close();
diff --git a/src/class150/ScapeGoat2.java b/src/class150/ScapeGoat2.java
index 4a58fa64f..04696091f 100644
--- a/src/class150/ScapeGoat2.java
+++ b/src/class150/ScapeGoat2.java
@@ -19,6 +19,7 @@
 //#include <algorithm>
 //#include <cmath>
 //#include <climits>
+//#include <cstring>
 //
 //using namespace std;
 //
@@ -27,30 +28,21 @@
 //const double ALPHA = 0.7;
 //
 //int head = 0;
+//int cnt = 0;
 //int key[MAXN];
 //int key_count[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int size[MAXN];
 //int diff[MAXN];
-//int order[MAXN];
-//int stack[MAXN];
-//int orderSize, stackSize;
-//
-//void prepare(int n) {
-//    stackSize = 0;
-//    for (int i = n; i >= 1; --i) {
-//        stack[++stackSize] = i;
-//    }
-//}
+//int collect[MAXN];
+//int ci;
 //
 //void inorder(int i) {
 //    if (i != 0) {
 //        inorder(ls[i]);
 //        if (key_count[i] > 0) {
-//            order[++orderSize] = i;
-//        } else {
-//            stack[++stackSize] = i;
+//            collect[++ci] = i;
 //        }
 //        inorder(rs[i]);
 //    }
@@ -66,7 +58,7 @@
 //        return 0;
 //    }
 //    int m = (l + r) / 2;
-//    int h = order[m];
+//    int h = collect[m];
 //    ls[h] = build(l, m - 1);
 //    rs[h] = build(m + 1, r);
 //    up(h);
@@ -74,10 +66,10 @@
 //}
 //
 //int rebuild(int i) {
-//    orderSize = 0;
+//    ci = 0;
 //    inorder(i);
-//    if (orderSize > 0) {
-//        return build(1, orderSize);
+//    if (ci > 0) {
+//        return build(1, ci);
 //    } else {
 //        return 0;
 //    }
@@ -89,11 +81,10 @@
 //
 //int add(int i, int num) {
 //    if (i == 0) {
-//        i = stack[stackSize--];
+//        i = ++cnt;
 //        key[i] = num;
 //        ls[i] = rs[i] = 0;
 //        key_count[i] = size[i] = diff[i] = 1;
-//        return i;
 //    } else {
 //        if (key[i] == num) {
 //            key_count[i]++;
@@ -102,14 +93,13 @@
 //        } else {
 //            rs[i] = add(rs[i], num);
 //        }
-//        up(i);
-//        return balance(i) ? i : rebuild(i);
 //    }
+//    up(i);
+//    return balance(i) ? i : rebuild(i);
 //}
 //
-//int add(int num) {
+//void add(int num) {
 //    head = add(head, num);
-//    return head;
 //}
 //
 //int small(int i, int num) {
@@ -119,7 +109,7 @@
 //    if (key[i] >= num) {
 //        return small(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + small(rs[i], num); // 使用 key_count
+//        return size[ls[i]] + key_count[i] + small(rs[i], num);
 //    }
 //}
 //
@@ -170,11 +160,21 @@
 //    return balance(i) ? i : rebuild(i);
 //}
 //
-//int remove(int num) {
+//void remove(int num) {
 //    if (getRank(num) != getRank(num + 1)) {
 //        head = remove(head, num);
 //    }
-//    return head;
+//}
+//
+//void clear() {
+//    memset(key, 0, sizeof(key));
+//    memset(key_count, 0, sizeof(key_count));
+//    memset(ls, 0, sizeof(ls));
+//    memset(rs, 0, sizeof(rs));
+//    memset(size, 0, sizeof(size));
+//    memset(diff, 0, sizeof(diff));
+//    cnt = 0;
+//    head = 0;
 //}
 //
 //int main() {
@@ -182,7 +182,6 @@
 //    cin.tie(nullptr);
 //    int n;
 //    cin >> n;
-//    prepare(n);
 //    for (int i = 0; i < n; ++i) {
 //        int op, x;
 //        cin >> op >> x;
@@ -200,5 +199,6 @@
 //            cout << post(x) << "\n";
 //        }
 //    }
+//    clear();
 //    return 0;
 //}
\ No newline at end of file

From c099a3b60e30682b9e2b51218c1651d13e975702 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Nov 2024 14:09:16 +0800
Subject: [PATCH 0061/1712] modify code

---
 src/class150/ShowDetails.java | 209 ++++++++++++++++++++++++++++++++++
 1 file changed, 209 insertions(+)
 create mode 100644 src/class150/ShowDetails.java

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
new file mode 100644
index 000000000..6a40f125a
--- /dev/null
+++ b/src/class150/ShowDetails.java
@@ -0,0 +1,209 @@
+package class150;
+
+// 不同的平衡因子对替罪羊树产生的影响
+// 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
+// 平衡因子不能小于0.5，不能大于1.0，因为无意义
+// 当平衡因子等于0.5时树最平衡，即树高最小，此时查询效率高，但是重构的节点最多
+// 当平衡因子等于1.0时树为线状，即树高最大，此时查询效率低，但是重构几乎不发生
+// 为了保证查询效率高，同时重构的节点也不多，需要设置合适的平衡因子，一般为0.7
+// 当平衡因子为0.7左右时，树高几乎是O(log n)，这保证了查询效率
+// 同时重构触发时机合适，重构的节点不会特别多，均摊下来，单次代价认为是O(log n)
+
+import java.util.Arrays;
+
+public class ShowDetails {
+
+	public static int MAXN = 100001;
+
+	public static double ALPHA = 0.7;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] count = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] diff = new int[MAXN];
+
+	public static int[] collect = new int[MAXN];
+
+	public static int ci;
+
+	public static void inorder(int i) {
+		if (i != 0) {
+			inorder(left[i]);
+			if (count[i] > 0) {
+				collect[++ci] = i;
+			}
+			inorder(right[i]);
+		}
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
+	}
+
+	public static int build(int l, int r) {
+		if (l > r) {
+			return 0;
+		}
+		int m = (l + r) / 2;
+		int h = collect[m];
+		left[h] = build(l, m - 1);
+		right[h] = build(m + 1, r);
+		up(h);
+		return h;
+	}
+
+	public static int rebuild(int i) {
+		ci = 0;
+		inorder(i);
+		if (ci > 0) {
+			return build(1, ci);
+		} else {
+			return 0;
+		}
+	}
+
+	// 一旦判断不平衡，接下来必然重构，所以统计总共有多少节点会重构
+	public static boolean balance(int i) {
+		if (ALPHA * diff[i] > Math.max(diff[left[i]], diff[right[i]])) {
+			return true;
+		} else {
+			cost += diff[i];
+			return false;
+		}
+	}
+
+	public static void add(int num) {
+		head = add(head, num);
+	}
+
+	public static int add(int i, int num) {
+		if (i == 0) {
+			i = ++cnt;
+			key[i] = num;
+			left[i] = right[i] = 0;
+			count[i] = size[i] = diff[i] = 1;
+		} else {
+			if (key[i] == num) {
+				count[i]++;
+			} else if (key[i] > num) {
+				left[i] = add(left[i], num);
+			} else {
+				right[i] = add(right[i], num);
+			}
+		}
+		up(i);
+		return balance(i) ? i : rebuild(i);
+	}
+
+	public static int rank(int num) {
+		return small(head, num) + 1;
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], num);
+		}
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int pre(int num) {
+		int kth = rank(num);
+		if (kth == 1) {
+			return Integer.MIN_VALUE;
+		} else {
+			return index(kth - 1);
+		}
+	}
+
+	public static int post(int num) {
+		int kth = rank(num + 1);
+		if (kth == size[head] + 1) {
+			return Integer.MAX_VALUE;
+		} else {
+			return index(kth);
+		}
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			head = remove(head, num);
+		}
+	}
+
+	public static int remove(int i, int num) {
+		if (key[i] == num) {
+			count[i]--;
+		} else if (key[i] > num) {
+			left[i] = remove(left[i], num);
+		} else {
+			right[i] = remove(right[i], num);
+		}
+		up(i);
+		return balance(i) ? i : rebuild(i);
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(diff, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static int deep(int i) {
+		if (i == 0) {
+			return 0;
+		}
+		return Math.max(deep(left[i]), deep(right[i])) + 1;
+	}
+
+	public static int max, cost;
+
+	public static void main(String[] args) {
+		System.out.println("测试开始");
+		ALPHA = 0.7; // 设置不同的平衡因子
+		max = 10000; // 设置插入范围
+		cost = 0; // 清空重构节点计数
+		for (int num = 1; num <= max; num++) {
+			add(num);
+		}
+		System.out.println("依次插入从 1 到 " + max + " 的所有数字");
+		System.out.println("平衡因子 : " + ALPHA);
+		System.out.println("重构节点总数 : " + cost);
+		System.out.println("树高 : " + deep(head));
+		System.out.println("测试结束");
+	}
+
+}

From 582fb28516825eed78af6e3e2995c52422a5689d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Nov 2024 14:14:07 +0800
Subject: [PATCH 0062/1712] modify code

---
 src/class150/ShowDetails.java | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 6a40f125a..9145536d3 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -192,14 +192,17 @@ public static int deep(int i) {
 	public static int max, cost;
 
 	public static void main(String[] args) {
+		// 设置平衡因子
+		ALPHA = 0.7;
+		// 设置插入范围
+		max = 10000;
+		// 清空重构节点计数
+		cost = 0;
 		System.out.println("测试开始");
-		ALPHA = 0.7; // 设置不同的平衡因子
-		max = 10000; // 设置插入范围
-		cost = 0; // 清空重构节点计数
 		for (int num = 1; num <= max; num++) {
 			add(num);
 		}
-		System.out.println("依次插入从 1 到 " + max + " 的所有数字");
+		System.out.println("依次插入 1 到 " + max);
 		System.out.println("平衡因子 : " + ALPHA);
 		System.out.println("重构节点总数 : " + cost);
 		System.out.println("树高 : " + deep(head));

From 324eddff1e029ef5b1d047ce865bb5efd5bb2334 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Nov 2024 14:16:24 +0800
Subject: [PATCH 0063/1712] modify code

---
 src/class150/ShowDetails.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 9145536d3..1f967eddf 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -5,7 +5,7 @@
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
 // 当平衡因子等于0.5时树最平衡，即树高最小，此时查询效率高，但是重构的节点最多
 // 当平衡因子等于1.0时树为线状，即树高最大，此时查询效率低，但是重构几乎不发生
-// 为了保证查询效率高，同时重构的节点也不多，需要设置合适的平衡因子，一般为0.7
+// 为了保证查询效率，同时重构节点也不多，需要设置合适的平衡因子，一般0.7最常用
 // 当平衡因子为0.7左右时，树高几乎是O(log n)，这保证了查询效率
 // 同时重构触发时机合适，重构的节点不会特别多，均摊下来，单次代价认为是O(log n)
 

From 7d50966b4ee40a438b3139300523ae03bf07a1be Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Nov 2024 14:17:22 +0800
Subject: [PATCH 0064/1712] modify code

---
 src/class150/ShowDetails.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 1f967eddf..a6333bdf2 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -7,7 +7,7 @@
 // 当平衡因子等于1.0时树为线状，即树高最大，此时查询效率低，但是重构几乎不发生
 // 为了保证查询效率，同时重构节点也不多，需要设置合适的平衡因子，一般0.7最常用
 // 当平衡因子为0.7左右时，树高几乎是O(log n)，这保证了查询效率
-// 同时重构触发时机合适，重构的节点不会特别多，均摊下来，单次代价认为是O(log n)
+// 同时重构的触发时机合适，重构节点不会特别多，均摊下来单次代价认为是O(log n)
 
 import java.util.Arrays;
 

From 10a6201763adceeeba11602c50851a6555d057f0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 14:31:27 +0800
Subject: [PATCH 0065/1712] modify code

---
 src/class150/ScapeGoat1.java  | 119 ++++++++++++++++++++++-----------
 src/class150/ScapeGoat2.java  |  87 ++++++++++++++++--------
 src/class150/ShowDetails.java | 122 +++++++++++++++++++++-------------
 3 files changed, 214 insertions(+), 114 deletions(-)

diff --git a/src/class150/ScapeGoat1.java b/src/class150/ScapeGoat1.java
index 5f8a2cb69..6467c1b83 100644
--- a/src/class150/ScapeGoat1.java
+++ b/src/class150/ScapeGoat1.java
@@ -51,11 +51,34 @@ public class ScapeGoat1 {
 	// 节点总数
 	public static int[] diff = new int[MAXN];
 
-	// 中序遍历收集节点
+	// 中序收集节点的数组
 	public static int[] collect = new int[MAXN];
 
+	// 中序收集节点的计数
 	public static int ci;
 
+	// 最上方不平衡的节点
+	public static int child;
+
+	// 最上方不平衡节点的父节点
+	public static int father;
+
+	// 最上方不平衡的节点是其父节点的什么孩子
+	// 0代表左孩子，1代表右孩子
+	public static int side;
+
+	public static int init(int num) {
+		key[++cnt] = num;
+		left[cnt] = right[cnt] = 0;
+		count[cnt] = size[cnt] = diff[cnt] = 1;
+		return cnt;
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
+	}
+
 	public static void inorder(int i) {
 		if (i != 0) {
 			inorder(left[i]);
@@ -66,11 +89,6 @@ public static void inorder(int i) {
 		}
 	}
 
-	public static void up(int i) {
-		size[i] = size[left[i]] + size[right[i]] + count[i];
-		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
-	}
-
 	public static int build(int l, int r) {
 		if (l > r) {
 			return 0;
@@ -83,13 +101,19 @@ public static int build(int l, int r) {
 		return h;
 	}
 
-	public static int rebuild(int i) {
-		ci = 0;
-		inorder(i);
-		if (ci > 0) {
-			return build(1, ci);
-		} else {
-			return 0;
+	public static void rebuild() {
+		if (child != -1) {
+			ci = 0;
+			inorder(child);
+			if (ci > 0) {
+				if (father == 0) {
+					head = build(1, ci);
+				} else if (side == 0) {
+					left[father] = build(1, ci);
+				} else {
+					right[father] = build(1, ci);
+				}
+			}
 		}
 	}
 
@@ -97,31 +121,36 @@ public static boolean balance(int i) {
 		return ALPHA * diff[i] > Math.max(diff[left[i]], diff[right[i]]);
 	}
 
-	public static void add(int num) {
-		head = add(head, num);
-	}
-
-	public static int add(int i, int num) {
+	public static void add(int i, int f, int s, int num) {
 		if (i == 0) {
-			i = ++cnt;
-			key[i] = num;
-			left[i] = right[i] = 0;
-			count[i] = size[i] = diff[i] = 1;
+			if (f == 0) {
+				head = init(num);
+			} else if (s == 0) {
+				left[f] = init(num);
+			} else {
+				right[f] = init(num);
+			}
 		} else {
 			if (key[i] == num) {
 				count[i]++;
 			} else if (key[i] > num) {
-				left[i] = add(left[i], num);
+				add(left[i], i, 0, num);
 			} else {
-				right[i] = add(right[i], num);
+				add(right[i], i, 1, num);
+			}
+			up(i);
+			if (!balance(i)) {
+				father = f;
+				child = i;
+				side = s;
 			}
 		}
-		up(i);
-		return balance(i) ? i : rebuild(i);
 	}
 
-	public static int rank(int num) {
-		return small(head, num) + 1;
+	public static void add(int num) {
+		child = father = side = -1;
+		add(head, 0, 0, num);
+		rebuild();
 	}
 
 	public static int small(int i, int num) {
@@ -135,8 +164,8 @@ public static int small(int i, int num) {
 		}
 	}
 
-	public static int index(int x) {
-		return index(head, x);
+	public static int rank(int num) {
+		return small(head, num) + 1;
 	}
 
 	public static int index(int i, int x) {
@@ -148,6 +177,10 @@ public static int index(int i, int x) {
 		return key[i];
 	}
 
+	public static int index(int x) {
+		return index(head, x);
+	}
+
 	public static int pre(int num) {
 		int kth = rank(num);
 		if (kth == 1) {
@@ -166,22 +199,28 @@ public static int post(int num) {
 		}
 	}
 
-	public static void remove(int num) {
-		if (rank(num) != rank(num + 1)) {
-			head = remove(head, num);
-		}
-	}
-
-	public static int remove(int i, int num) {
+	public static void remove(int i, int f, int s, int num) {
 		if (key[i] == num) {
 			count[i]--;
 		} else if (key[i] > num) {
-			left[i] = remove(left[i], num);
+			remove(left[i], i, 0, num);
 		} else {
-			right[i] = remove(right[i], num);
+			remove(right[i], i, 1, num);
 		}
 		up(i);
-		return balance(i) ? i : rebuild(i);
+		if (!balance(i)) {
+			child = i;
+			father = f;
+			side = s;
+		}
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			child = father = side = -1;
+			remove(head, 0, 0, num);
+			rebuild();
+		}
 	}
 
 	public static void clear() {
diff --git a/src/class150/ScapeGoat2.java b/src/class150/ScapeGoat2.java
index 04696091f..15f120fe8 100644
--- a/src/class150/ScapeGoat2.java
+++ b/src/class150/ScapeGoat2.java
@@ -37,6 +37,21 @@
 //int diff[MAXN];
 //int collect[MAXN];
 //int ci;
+//int child;
+//int father;
+//int side;
+//
+//int init(int num) {
+//    key[++cnt] = num;
+//    ls[cnt] = rs[cnt] = 0;
+//    key_count[cnt] = size[cnt] = diff[cnt] = 1;
+//    return cnt;
+//}
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    diff[i] = diff[ls[i]] + diff[rs[i]] + (key_count[i] > 0 ? 1 : 0);
+//}
 //
 //void inorder(int i) {
 //    if (i != 0) {
@@ -48,11 +63,6 @@
 //    }
 //}
 //
-//void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
-//    diff[i] = diff[ls[i]] + diff[rs[i]] + (key_count[i] > 0 ? 1 : 0);
-//}
-//
 //int build(int l, int r) {
 //    if (l > r) {
 //        return 0;
@@ -65,13 +75,19 @@
 //    return h;
 //}
 //
-//int rebuild(int i) {
-//    ci = 0;
-//    inorder(i);
-//    if (ci > 0) {
-//        return build(1, ci);
-//    } else {
-//        return 0;
+//void rebuild() {
+//    if (child != -1) {
+//        ci = 0;
+//        inorder(child);
+//        if (ci > 0) {
+//            if (father == 0) {
+//                head = build(1, ci);
+//            } else if (side == 0) {
+//                ls[father] = build(1, ci);
+//            } else {
+//                rs[father] = build(1, ci);
+//            }
+//        }
 //    }
 //}
 //
@@ -79,27 +95,36 @@
 //    return ALPHA * diff[i] > max(diff[ls[i]], diff[rs[i]]);
 //}
 //
-//int add(int i, int num) {
+//void add(int i, int f, int s, int num) {
 //    if (i == 0) {
-//        i = ++cnt;
-//        key[i] = num;
-//        ls[i] = rs[i] = 0;
-//        key_count[i] = size[i] = diff[i] = 1;
+//        if (f == 0) {
+//            head = init(num);
+//        } else if (s == 0) {
+//            ls[f] = init(num);
+//        } else {
+//            rs[f] = init(num);
+//        }
 //    } else {
 //        if (key[i] == num) {
 //            key_count[i]++;
 //        } else if (key[i] > num) {
-//            ls[i] = add(ls[i], num);
+//            add(ls[i], i, 0, num);
 //        } else {
-//            rs[i] = add(rs[i], num);
+//            add(rs[i], i, 1, num);
+//        }
+//        up(i);
+//        if (!balance(i)) {
+//            father = f;
+//            child = i;
+//            side = s;
 //        }
 //    }
-//    up(i);
-//    return balance(i) ? i : rebuild(i);
 //}
 //
 //void add(int num) {
-//    head = add(head, num);
+//    child = father = side = -1;
+//    add(head, 0, 0, num);
+//    rebuild();
 //}
 //
 //int small(int i, int num) {
@@ -148,21 +173,27 @@
 //    }
 //}
 //
-//int remove(int i, int num) {
+//void remove(int i, int f, int s, int num) {
 //    if (key[i] == num) {
 //        key_count[i]--;
 //    } else if (key[i] > num) {
-//        ls[i] = remove(ls[i], num);
+//        remove(ls[i], i, 0, num);
 //    } else {
-//        rs[i] = remove(rs[i], num);
+//        remove(rs[i], i, 1, num);
 //    }
 //    up(i);
-//    return balance(i) ? i : rebuild(i);
+//    if (!balance(i)) {
+//        child = i;
+//        father = f;
+//        side = s;
+//    }
 //}
 //
 //void remove(int num) {
 //    if (getRank(num) != getRank(num + 1)) {
-//        head = remove(head, num);
+//        child = father = side = -1;
+//        remove(head, 0, 0, num);
+//        rebuild();
 //    }
 //}
 //
@@ -182,7 +213,7 @@
 //    cin.tie(nullptr);
 //    int n;
 //    cin >> n;
-//    for (int i = 0; i < n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        int op, x;
 //        cin >> op >> x;
 //        if (op == 1) {
diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index a6333bdf2..6980a1508 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -37,6 +37,24 @@ public class ShowDetails {
 
 	public static int ci;
 
+	public static int child;
+
+	public static int father;
+
+	public static int side;
+
+	public static int init(int num) {
+		key[++cnt] = num;
+		left[cnt] = right[cnt] = 0;
+		count[cnt] = size[cnt] = diff[cnt] = 1;
+		return cnt;
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
+	}
+
 	public static void inorder(int i) {
 		if (i != 0) {
 			inorder(left[i]);
@@ -47,11 +65,6 @@ public static void inorder(int i) {
 		}
 	}
 
-	public static void up(int i) {
-		size[i] = size[left[i]] + size[right[i]] + count[i];
-		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
-	}
-
 	public static int build(int l, int r) {
 		if (l > r) {
 			return 0;
@@ -64,51 +77,58 @@ public static int build(int l, int r) {
 		return h;
 	}
 
-	public static int rebuild(int i) {
-		ci = 0;
-		inorder(i);
-		if (ci > 0) {
-			return build(1, ci);
-		} else {
-			return 0;
+	public static void rebuild() {
+		if (child != -1) {
+			ci = 0;
+			inorder(child);
+			if (ci > 0) {
+				// 统计重构节点的计数
+				cost += ci;
+				if (father == 0) {
+					head = build(1, ci);
+				} else if (side == 0) {
+					left[father] = build(1, ci);
+				} else {
+					right[father] = build(1, ci);
+				}
+			}
 		}
 	}
 
-	// 一旦判断不平衡，接下来必然重构，所以统计总共有多少节点会重构
 	public static boolean balance(int i) {
-		if (ALPHA * diff[i] > Math.max(diff[left[i]], diff[right[i]])) {
-			return true;
-		} else {
-			cost += diff[i];
-			return false;
-		}
-	}
-
-	public static void add(int num) {
-		head = add(head, num);
+		return ALPHA * diff[i] > Math.max(diff[left[i]], diff[right[i]]);
 	}
 
-	public static int add(int i, int num) {
+	public static void add(int i, int f, int s, int num) {
 		if (i == 0) {
-			i = ++cnt;
-			key[i] = num;
-			left[i] = right[i] = 0;
-			count[i] = size[i] = diff[i] = 1;
+			if (f == 0) {
+				head = init(num);
+			} else if (s == 0) {
+				left[f] = init(num);
+			} else {
+				right[f] = init(num);
+			}
 		} else {
 			if (key[i] == num) {
 				count[i]++;
 			} else if (key[i] > num) {
-				left[i] = add(left[i], num);
+				add(left[i], i, 0, num);
 			} else {
-				right[i] = add(right[i], num);
+				add(right[i], i, 1, num);
+			}
+			up(i);
+			if (!balance(i)) {
+				father = f;
+				child = i;
+				side = s;
 			}
 		}
-		up(i);
-		return balance(i) ? i : rebuild(i);
 	}
 
-	public static int rank(int num) {
-		return small(head, num) + 1;
+	public static void add(int num) {
+		child = father = side = -1;
+		add(head, 0, 0, num);
+		rebuild();
 	}
 
 	public static int small(int i, int num) {
@@ -122,8 +142,8 @@ public static int small(int i, int num) {
 		}
 	}
 
-	public static int index(int x) {
-		return index(head, x);
+	public static int rank(int num) {
+		return small(head, num) + 1;
 	}
 
 	public static int index(int i, int x) {
@@ -135,6 +155,10 @@ public static int index(int i, int x) {
 		return key[i];
 	}
 
+	public static int index(int x) {
+		return index(head, x);
+	}
+
 	public static int pre(int num) {
 		int kth = rank(num);
 		if (kth == 1) {
@@ -153,22 +177,28 @@ public static int post(int num) {
 		}
 	}
 
-	public static void remove(int num) {
-		if (rank(num) != rank(num + 1)) {
-			head = remove(head, num);
-		}
-	}
-
-	public static int remove(int i, int num) {
+	public static void remove(int i, int f, int s, int num) {
 		if (key[i] == num) {
 			count[i]--;
 		} else if (key[i] > num) {
-			left[i] = remove(left[i], num);
+			remove(left[i], i, 0, num);
 		} else {
-			right[i] = remove(right[i], num);
+			remove(right[i], i, 1, num);
 		}
 		up(i);
-		return balance(i) ? i : rebuild(i);
+		if (!balance(i)) {
+			child = i;
+			father = f;
+			side = s;
+		}
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			child = father = side = -1;
+			remove(head, 0, 0, num);
+			rebuild();
+		}
 	}
 
 	public static void clear() {

From 5176085d54eb938a21c703750ad1f4078e63c242 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 14:49:06 +0800
Subject: [PATCH 0066/1712] modify code

---
 src/class150/ShowDetails.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 6980a1508..6b6d3d9cc 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -1,6 +1,6 @@
 package class150;
 
-// 不同的平衡因子对替罪羊树产生的影响
+// 不同平衡因子对替罪羊树的影响实验
 // 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
 // 当平衡因子等于0.5时树最平衡，即树高最小，此时查询效率高，但是重构的节点最多

From 363bcf9c57a4215441cb48b346e78a45e1a17b08 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 15:44:25 +0800
Subject: [PATCH 0067/1712] modify code

---
 src/class150/ShowDetails.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 6b6d3d9cc..2b9e1406d 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -212,6 +212,7 @@ public static void clear() {
 		head = 0;
 	}
 
+	// 统计树高
 	public static int deep(int i) {
 		if (i == 0) {
 			return 0;
@@ -219,16 +220,17 @@ public static int deep(int i) {
 		return Math.max(deep(left[i]), deep(right[i])) + 1;
 	}
 
-	public static int max, cost;
+	public static int max;
+
+	public static int cost;
 
 	public static void main(String[] args) {
 		// 设置平衡因子
 		ALPHA = 0.7;
 		// 设置插入范围
 		max = 10000;
-		// 清空重构节点计数
-		cost = 0;
 		System.out.println("测试开始");
+		cost = 0; // 清空重构节点计数
 		for (int num = 1; num <= max; num++) {
 			add(num);
 		}

From 51056c04d78c706ca60b9d07403b4c7740c1375b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 15:47:49 +0800
Subject: [PATCH 0068/1712] modify code

---
 src/class150/ShowDetails.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 2b9e1406d..cd997855e 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -1,6 +1,6 @@
 package class150;
 
-// 不同平衡因子对替罪羊树的影响实验
+// 平衡因子对替罪羊树影响的实验
 // 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
 // 当平衡因子等于0.5时树最平衡，即树高最小，此时查询效率高，但是重构的节点最多

From 7feaa91b2b2d7b524f55ed425f22be73b5c8d987 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 15:48:38 +0800
Subject: [PATCH 0069/1712] modify code

---
 src/class150/ShowDetails.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index cd997855e..3dda65a69 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -1,6 +1,6 @@
 package class150;
 
-// 平衡因子对替罪羊树影响的实验
+// 平衡因子影响替罪羊树的实验
 // 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
 // 当平衡因子等于0.5时树最平衡，即树高最小，此时查询效率高，但是重构的节点最多

From bacf4c6b6970aca6b4b9472fb4739f7ef58da41d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 15:50:32 +0800
Subject: [PATCH 0070/1712] modify code

---
 src/class150/ShowDetails.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 3dda65a69..d31f4fd2b 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -4,10 +4,10 @@
 // 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
 // 当平衡因子等于0.5时树最平衡，即树高最小，此时查询效率高，但是重构的节点最多
-// 当平衡因子等于1.0时树为线状，即树高最大，此时查询效率低，但是重构几乎不发生
+// 当平衡因子等于1.0时树为线状，即树高最大，此时查询效率低，但是重构不发生
 // 为了保证查询效率，同时重构节点也不多，需要设置合适的平衡因子，一般0.7最常用
 // 当平衡因子为0.7左右时，树高几乎是O(log n)，这保证了查询效率
-// 同时重构的触发时机合适，重构节点不会特别多，均摊下来单次代价认为是O(log n)
+// 同时重构的触发时机合适，重构节点不多，均摊下来，单次代价为O(log n)
 
 import java.util.Arrays;
 

From 2da5f75cbf25b4bc8aeb037f8b4eaf216fe36e09 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 15:52:43 +0800
Subject: [PATCH 0071/1712] modify code

---
 src/class150/ShowDetails.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index d31f4fd2b..bd24c537c 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -3,11 +3,11 @@
 // 平衡因子影响替罪羊树的实验
 // 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
-// 当平衡因子等于0.5时树最平衡，即树高最小，此时查询效率高，但是重构的节点最多
-// 当平衡因子等于1.0时树为线状，即树高最大，此时查询效率低，但是重构不发生
-// 为了保证查询效率，同时重构节点也不多，需要设置合适的平衡因子，一般0.7最常用
-// 当平衡因子为0.7左右时，树高几乎是O(log n)，这保证了查询效率
-// 同时重构的触发时机合适，重构节点不多，均摊下来，单次代价为O(log n)
+// 当平衡因子等于0.5时，树最平衡，树高最小，此时查询效率高，但是重构的节点最多
+// 当平衡因子等于1.0时，树为线状，树高最大，此时查询效率低，但是重构不发生
+// 保证查询效率，同时保证重构节点不多，需要设置合适的平衡因子，最常用为0.7
+// 平衡因子为0.7左右，树高几乎是O(log n)，这保证了查询效率
+// 同时重构触发的时机合适，重构节点不多，均摊下来，单次代价为O(log n)
 
 import java.util.Arrays;
 

From e03055c0c6e2dbb743840c74dc34fa06b157060e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 16:04:28 +0800
Subject: [PATCH 0072/1712] modify code

---
 src/class150/ScapeGoat1.java  |  6 +++--
 src/class150/ScapeGoat2.java  |  4 +---
 src/class150/ShowDetails.java | 44 +++++++++++++++++------------------
 3 files changed, 27 insertions(+), 27 deletions(-)

diff --git a/src/class150/ScapeGoat1.java b/src/class150/ScapeGoat1.java
index 6467c1b83..05bb0e75f 100644
--- a/src/class150/ScapeGoat1.java
+++ b/src/class150/ScapeGoat1.java
@@ -23,10 +23,12 @@
 
 public class ScapeGoat1 {
 
-	public static int MAXN = 100001;
-
+	// 平衡因子
 	public static double ALPHA = 0.7;
 
+	// 空间的最大使用量
+	public static int MAXN = 100001;
+
 	// 整棵树的头节点编号
 	public static int head = 0;
 
diff --git a/src/class150/ScapeGoat2.java b/src/class150/ScapeGoat2.java
index 15f120fe8..8f7c55603 100644
--- a/src/class150/ScapeGoat2.java
+++ b/src/class150/ScapeGoat2.java
@@ -23,10 +23,8 @@
 //
 //using namespace std;
 //
-//const int MAXN = 100001;
-//
 //const double ALPHA = 0.7;
-//
+//const int MAXN = 100001;
 //int head = 0;
 //int cnt = 0;
 //int key[MAXN];
diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index bd24c537c..1a534ea56 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -13,10 +13,31 @@
 
 public class ShowDetails {
 
-	public static int MAXN = 100001;
+	public static void main(String[] args) {
+		// 设置平衡因子
+		ALPHA = 0.7;
+		// 设置插入范围
+		max = 10000;
+		System.out.println("测试开始");
+		cost = 0; // 清空重构节点计数
+		for (int num = 1; num <= max; num++) {
+			add(num);
+		}
+		System.out.println("依次插入 1 到 " + max);
+		System.out.println("平衡因子 : " + ALPHA);
+		System.out.println("重构节点总数 : " + cost);
+		System.out.println("树高 : " + deep(head));
+		System.out.println("测试结束");
+	}
 
 	public static double ALPHA = 0.7;
 
+	public static int max;
+
+	public static int cost;
+
+	public static int MAXN = 100001;
+
 	public static int head = 0;
 
 	public static int cnt = 0;
@@ -220,25 +241,4 @@ public static int deep(int i) {
 		return Math.max(deep(left[i]), deep(right[i])) + 1;
 	}
 
-	public static int max;
-
-	public static int cost;
-
-	public static void main(String[] args) {
-		// 设置平衡因子
-		ALPHA = 0.7;
-		// 设置插入范围
-		max = 10000;
-		System.out.println("测试开始");
-		cost = 0; // 清空重构节点计数
-		for (int num = 1; num <= max; num++) {
-			add(num);
-		}
-		System.out.println("依次插入 1 到 " + max);
-		System.out.println("平衡因子 : " + ALPHA);
-		System.out.println("重构节点总数 : " + cost);
-		System.out.println("树高 : " + deep(head));
-		System.out.println("测试结束");
-	}
-
 }

From c62c5f16d41782a389d0418f0e39dc56010aae6f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 16:36:24 +0800
Subject: [PATCH 0073/1712] modify code

---
 src/class150/ShowDetails.java | 31 ++++++++++++++-----------------
 1 file changed, 14 insertions(+), 17 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 1a534ea56..433f8d0cd 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -14,10 +14,8 @@
 public class ShowDetails {
 
 	public static void main(String[] args) {
-		// 设置平衡因子
-		ALPHA = 0.7;
-		// 设置插入范围
-		max = 10000;
+		ALPHA = 0.7; // 设置平衡因子
+		max = 10000; // 设置插入范围
 		System.out.println("测试开始");
 		cost = 0; // 清空重构节点计数
 		for (int num = 1; num <= max; num++) {
@@ -25,17 +23,25 @@ public static void main(String[] args) {
 		}
 		System.out.println("依次插入 1 到 " + max);
 		System.out.println("平衡因子 : " + ALPHA);
-		System.out.println("重构节点总数 : " + cost);
-		System.out.println("树高 : " + deep(head));
+		System.out.println("树的高度 : " + deep(head));
+		System.out.println("重构节点 : " + cost);
 		System.out.println("测试结束");
 	}
 
-	public static double ALPHA = 0.7;
+	// 统计树高
+	public static int deep(int i) {
+		if (i == 0) {
+			return 0;
+		}
+		return Math.max(deep(left[i]), deep(right[i])) + 1;
+	}
 
 	public static int max;
 
 	public static int cost;
 
+	public static double ALPHA = 0.7;
+
 	public static int MAXN = 100001;
 
 	public static int head = 0;
@@ -103,8 +109,7 @@ public static void rebuild() {
 			ci = 0;
 			inorder(child);
 			if (ci > 0) {
-				// 统计重构节点的计数
-				cost += ci;
+				cost += ci; // 统计重构节点的计数
 				if (father == 0) {
 					head = build(1, ci);
 				} else if (side == 0) {
@@ -233,12 +238,4 @@ public static void clear() {
 		head = 0;
 	}
 
-	// 统计树高
-	public static int deep(int i) {
-		if (i == 0) {
-			return 0;
-		}
-		return Math.max(deep(left[i]), deep(right[i])) + 1;
-	}
-
 }

From 46191c5451994c6506ca3a498732f4a30d66729e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Nov 2024 16:39:38 +0800
Subject: [PATCH 0074/1712] modify code

---
 src/class150/ShowDetails.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 433f8d0cd..32bac6348 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -3,9 +3,9 @@
 // 平衡因子影响替罪羊树的实验
 // 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
-// 当平衡因子等于0.5时，树最平衡，树高最小，此时查询效率高，但是重构的节点最多
-// 当平衡因子等于1.0时，树为线状，树高最大，此时查询效率低，但是重构不发生
-// 保证查询效率，同时保证重构节点不多，需要设置合适的平衡因子，最常用为0.7
+// 平衡因子等于0.5时，树最平衡，树高最小，此时查询效率高，但是重构的节点最多
+// 平衡因子等于1.0时，树为线状，树高最大，此时查询效率低，但是重构不发生
+// 保证查询效率，同时保证重构节点不多，需要设置合适的平衡因子，0.7最常用
 // 平衡因子为0.7左右，树高几乎是O(log n)，这保证了查询效率
 // 同时重构触发的时机合适，重构节点不多，均摊下来，单次代价为O(log n)
 
@@ -21,7 +21,7 @@ public static void main(String[] args) {
 		for (int num = 1; num <= max; num++) {
 			add(num);
 		}
-		System.out.println("依次插入 1 到 " + max);
+		System.out.println("插入数字 : " + "1 ~ " + max);
 		System.out.println("平衡因子 : " + ALPHA);
 		System.out.println("树的高度 : " + deep(head));
 		System.out.println("重构节点 : " + cost);

From 2e2ede5df33f3b5b8c518c00f9b84e003d48501b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 13:47:31 +0800
Subject: [PATCH 0075/1712] modify code

---
 src/class150/ScapeGoat1.java  | 33 ++++++++++++++++-----------------
 src/class150/ScapeGoat2.java  | 26 +++++++++++++-------------
 src/class150/ShowDetails.java | 31 ++++++++++++++++---------------
 3 files changed, 45 insertions(+), 45 deletions(-)

diff --git a/src/class150/ScapeGoat1.java b/src/class150/ScapeGoat1.java
index 05bb0e75f..5b1c3fff8 100644
--- a/src/class150/ScapeGoat1.java
+++ b/src/class150/ScapeGoat1.java
@@ -59,14 +59,13 @@ public class ScapeGoat1 {
 	// 中序收集节点的计数
 	public static int ci;
 
-	// 最上方不平衡的节点
-	public static int child;
+	// 最上方的不平衡节点
+	public static int top;
 
-	// 最上方不平衡节点的父节点
+	// top的父节点
 	public static int father;
 
-	// 最上方不平衡的节点是其父节点的什么孩子
-	// 0代表左孩子，1代表右孩子
+	// top是父节点的什么孩子，1代表左孩子，2代表右孩子
 	public static int side;
 
 	public static int init(int num) {
@@ -104,13 +103,13 @@ public static int build(int l, int r) {
 	}
 
 	public static void rebuild() {
-		if (child != -1) {
+		if (top != 0) {
 			ci = 0;
-			inorder(child);
+			inorder(top);
 			if (ci > 0) {
 				if (father == 0) {
 					head = build(1, ci);
-				} else if (side == 0) {
+				} else if (side == 1) {
 					left[father] = build(1, ci);
 				} else {
 					right[father] = build(1, ci);
@@ -127,7 +126,7 @@ public static void add(int i, int f, int s, int num) {
 		if (i == 0) {
 			if (f == 0) {
 				head = init(num);
-			} else if (s == 0) {
+			} else if (s == 1) {
 				left[f] = init(num);
 			} else {
 				right[f] = init(num);
@@ -136,21 +135,21 @@ public static void add(int i, int f, int s, int num) {
 			if (key[i] == num) {
 				count[i]++;
 			} else if (key[i] > num) {
-				add(left[i], i, 0, num);
+				add(left[i], i, 1, num);
 			} else {
-				add(right[i], i, 1, num);
+				add(right[i], i, 2, num);
 			}
 			up(i);
 			if (!balance(i)) {
+				top = i;
 				father = f;
-				child = i;
 				side = s;
 			}
 		}
 	}
 
 	public static void add(int num) {
-		child = father = side = -1;
+		top = father = side = 0;
 		add(head, 0, 0, num);
 		rebuild();
 	}
@@ -205,13 +204,13 @@ public static void remove(int i, int f, int s, int num) {
 		if (key[i] == num) {
 			count[i]--;
 		} else if (key[i] > num) {
-			remove(left[i], i, 0, num);
+			remove(left[i], i, 1, num);
 		} else {
-			remove(right[i], i, 1, num);
+			remove(right[i], i, 2, num);
 		}
 		up(i);
 		if (!balance(i)) {
-			child = i;
+			top = i;
 			father = f;
 			side = s;
 		}
@@ -219,7 +218,7 @@ public static void remove(int i, int f, int s, int num) {
 
 	public static void remove(int num) {
 		if (rank(num) != rank(num + 1)) {
-			child = father = side = -1;
+			top = father = side = 0;
 			remove(head, 0, 0, num);
 			rebuild();
 		}
diff --git a/src/class150/ScapeGoat2.java b/src/class150/ScapeGoat2.java
index 8f7c55603..d0a9f3dd6 100644
--- a/src/class150/ScapeGoat2.java
+++ b/src/class150/ScapeGoat2.java
@@ -35,7 +35,7 @@
 //int diff[MAXN];
 //int collect[MAXN];
 //int ci;
-//int child;
+//int top;
 //int father;
 //int side;
 //
@@ -74,13 +74,13 @@
 //}
 //
 //void rebuild() {
-//    if (child != -1) {
+//    if (top != 0) {
 //        ci = 0;
-//        inorder(child);
+//        inorder(top);
 //        if (ci > 0) {
 //            if (father == 0) {
 //                head = build(1, ci);
-//            } else if (side == 0) {
+//            } else if (side == 1) {
 //                ls[father] = build(1, ci);
 //            } else {
 //                rs[father] = build(1, ci);
@@ -97,7 +97,7 @@
 //    if (i == 0) {
 //        if (f == 0) {
 //            head = init(num);
-//        } else if (s == 0) {
+//        } else if (s == 1) {
 //            ls[f] = init(num);
 //        } else {
 //            rs[f] = init(num);
@@ -106,21 +106,21 @@
 //        if (key[i] == num) {
 //            key_count[i]++;
 //        } else if (key[i] > num) {
-//            add(ls[i], i, 0, num);
+//            add(ls[i], i, 1, num);
 //        } else {
-//            add(rs[i], i, 1, num);
+//            add(rs[i], i, 2, num);
 //        }
 //        up(i);
 //        if (!balance(i)) {
+//            top = i;
 //            father = f;
-//            child = i;
 //            side = s;
 //        }
 //    }
 //}
 //
 //void add(int num) {
-//    child = father = side = -1;
+//    top = father = side = 0;
 //    add(head, 0, 0, num);
 //    rebuild();
 //}
@@ -175,13 +175,13 @@
 //    if (key[i] == num) {
 //        key_count[i]--;
 //    } else if (key[i] > num) {
-//        remove(ls[i], i, 0, num);
+//        remove(ls[i], i, 1, num);
 //    } else {
-//        remove(rs[i], i, 1, num);
+//        remove(rs[i], i, 2, num);
 //    }
 //    up(i);
 //    if (!balance(i)) {
-//        child = i;
+//        top = i;
 //        father = f;
 //        side = s;
 //    }
@@ -189,7 +189,7 @@
 //
 //void remove(int num) {
 //    if (getRank(num) != getRank(num + 1)) {
-//        child = father = side = -1;
+//        top = father = side = 0;
 //        remove(head, 0, 0, num);
 //        rebuild();
 //    }
diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 32bac6348..eeb6d8d2f 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -26,6 +26,7 @@ public static void main(String[] args) {
 		System.out.println("树的高度 : " + deep(head));
 		System.out.println("重构节点 : " + cost);
 		System.out.println("测试结束");
+		clear();
 	}
 
 	// 统计树高
@@ -64,7 +65,7 @@ public static int deep(int i) {
 
 	public static int ci;
 
-	public static int child;
+	public static int top;
 
 	public static int father;
 
@@ -105,14 +106,14 @@ public static int build(int l, int r) {
 	}
 
 	public static void rebuild() {
-		if (child != -1) {
+		if (top != 0) {
 			ci = 0;
-			inorder(child);
+			inorder(top);
 			if (ci > 0) {
-				cost += ci; // 统计重构节点的计数
+				cost += ci; // 统计重构节点数
 				if (father == 0) {
 					head = build(1, ci);
-				} else if (side == 0) {
+				} else if (side == 1) {
 					left[father] = build(1, ci);
 				} else {
 					right[father] = build(1, ci);
@@ -129,7 +130,7 @@ public static void add(int i, int f, int s, int num) {
 		if (i == 0) {
 			if (f == 0) {
 				head = init(num);
-			} else if (s == 0) {
+			} else if (s == 1) {
 				left[f] = init(num);
 			} else {
 				right[f] = init(num);
@@ -138,21 +139,21 @@ public static void add(int i, int f, int s, int num) {
 			if (key[i] == num) {
 				count[i]++;
 			} else if (key[i] > num) {
-				add(left[i], i, 0, num);
+				add(left[i], i, 1, num);
 			} else {
-				add(right[i], i, 1, num);
+				add(right[i], i, 2, num);
 			}
 			up(i);
 			if (!balance(i)) {
+				top = i;
 				father = f;
-				child = i;
 				side = s;
 			}
 		}
 	}
 
 	public static void add(int num) {
-		child = father = side = -1;
+		top = father = side = 0;
 		add(head, 0, 0, num);
 		rebuild();
 	}
@@ -207,13 +208,13 @@ public static void remove(int i, int f, int s, int num) {
 		if (key[i] == num) {
 			count[i]--;
 		} else if (key[i] > num) {
-			remove(left[i], i, 0, num);
+			remove(left[i], i, 1, num);
 		} else {
-			remove(right[i], i, 1, num);
+			remove(right[i], i, 2, num);
 		}
 		up(i);
 		if (!balance(i)) {
-			child = i;
+			top = i;
 			father = f;
 			side = s;
 		}
@@ -221,7 +222,7 @@ public static void remove(int i, int f, int s, int num) {
 
 	public static void remove(int num) {
 		if (rank(num) != rank(num + 1)) {
-			child = father = side = -1;
+			top = father = side = 0;
 			remove(head, 0, 0, num);
 			rebuild();
 		}
@@ -238,4 +239,4 @@ public static void clear() {
 		head = 0;
 	}
 
-}
+}
\ No newline at end of file

From d3ca2c522b78e7c522faf77bf8bc63eb3579ccba Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 13:49:50 +0800
Subject: [PATCH 0076/1712] modify code

---
 src/class150/ShowDetails.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index eeb6d8d2f..c58bfcf06 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -21,7 +21,7 @@ public static void main(String[] args) {
 		for (int num = 1; num <= max; num++) {
 			add(num);
 		}
-		System.out.println("插入数字 : " + "1 ~ " + max);
+		System.out.println("插入数字 : " + "1~" + max);
 		System.out.println("平衡因子 : " + ALPHA);
 		System.out.println("树的高度 : " + deep(head));
 		System.out.println("重构节点 : " + cost);

From 3172f2a770f986502501ba891702700257dd8210 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 15:51:35 +0800
Subject: [PATCH 0077/1712] modify code

---
 src/class150/ScapeGoat1.java  | 2 +-
 src/class150/ScapeGoat2.java  | 2 +-
 src/class150/ShowDetails.java | 4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class150/ScapeGoat1.java b/src/class150/ScapeGoat1.java
index 5b1c3fff8..71a5e5b21 100644
--- a/src/class150/ScapeGoat1.java
+++ b/src/class150/ScapeGoat1.java
@@ -119,7 +119,7 @@ public static void rebuild() {
 	}
 
 	public static boolean balance(int i) {
-		return ALPHA * diff[i] > Math.max(diff[left[i]], diff[right[i]]);
+		return ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
 	}
 
 	public static void add(int i, int f, int s, int num) {
diff --git a/src/class150/ScapeGoat2.java b/src/class150/ScapeGoat2.java
index d0a9f3dd6..16bfe5f75 100644
--- a/src/class150/ScapeGoat2.java
+++ b/src/class150/ScapeGoat2.java
@@ -90,7 +90,7 @@
 //}
 //
 //bool balance(int i) {
-//    return ALPHA * diff[i] > max(diff[ls[i]], diff[rs[i]]);
+//    return ALPHA * diff[i] >= max(diff[ls[i]], diff[rs[i]]);
 //}
 //
 //void add(int i, int f, int s, int num) {
diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index c58bfcf06..a972e7ac6 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -1,7 +1,7 @@
 package class150;
 
 // 平衡因子影响替罪羊树的实验
-// 一旦， max(左树节点数，右树节点数) / 整树节点数 >= 平衡因子，就会发生重构
+// 一旦，max(左树节点数，右树节点数) > 平衡因子 * 整树节点数，就会发生重构
 // 平衡因子不能小于0.5，不能大于1.0，因为无意义
 // 平衡因子等于0.5时，树最平衡，树高最小，此时查询效率高，但是重构的节点最多
 // 平衡因子等于1.0时，树为线状，树高最大，此时查询效率低，但是重构不发生
@@ -123,7 +123,7 @@ public static void rebuild() {
 	}
 
 	public static boolean balance(int i) {
-		return ALPHA * diff[i] > Math.max(diff[left[i]], diff[right[i]]);
+		return ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
 	}
 
 	public static void add(int i, int f, int s, int num) {

From 82a3704a6e95e4b088591db2d6a6c8a0aed29f21 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 15:54:35 +0800
Subject: [PATCH 0078/1712] modify code

---
 src/class150/ShowDetails.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index a972e7ac6..a70c57d4c 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -2,9 +2,9 @@
 
 // 平衡因子影响替罪羊树的实验
 // 一旦，max(左树节点数，右树节点数) > 平衡因子 * 整树节点数，就会发生重构
-// 平衡因子不能小于0.5，不能大于1.0，因为无意义
-// 平衡因子等于0.5时，树最平衡，树高最小，此时查询效率高，但是重构的节点最多
-// 平衡因子等于1.0时，树为线状，树高最大，此时查询效率低，但是重构不发生
+// 平衡因子范围是(0.5, 1.0)，否则无意义
+// 平衡因子等于0.5时，树最平衡，树高很小，查询效率高，但是重构发生很频繁
+// 平衡因子等于1.0时，树为线状，树高很大，重构完全不发生，但是查询效率低
 // 保证查询效率，同时保证重构节点不多，需要设置合适的平衡因子，0.7最常用
 // 平衡因子为0.7左右，树高几乎是O(log n)，这保证了查询效率
 // 同时重构触发的时机合适，重构节点不多，均摊下来，单次代价为O(log n)

From a2719becc9b419b3c2097886343a0753595a32a4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 15:56:15 +0800
Subject: [PATCH 0079/1712] modify code

---
 src/class150/ShowDetails.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index a70c57d4c..4d99f3a0d 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -3,9 +3,9 @@
 // 平衡因子影响替罪羊树的实验
 // 一旦，max(左树节点数，右树节点数) > 平衡因子 * 整树节点数，就会发生重构
 // 平衡因子范围是(0.5, 1.0)，否则无意义
-// 平衡因子等于0.5时，树最平衡，树高很小，查询效率高，但是重构发生很频繁
-// 平衡因子等于1.0时，树为线状，树高很大，重构完全不发生，但是查询效率低
-// 保证查询效率，同时保证重构节点不多，需要设置合适的平衡因子，0.7最常用
+// 平衡因子等于0.5时，树高很小，查询效率高，但是重构发生很频繁
+// 平衡因子等于1.0时，树高很大，重构完全不发生，但是查询效率低
+// 保证查询效率、同时保证重构节点总数不多，0.7为最常用的平衡因子
 // 平衡因子为0.7左右，树高几乎是O(log n)，这保证了查询效率
 // 同时重构触发的时机合适，重构节点不多，均摊下来，单次代价为O(log n)
 

From 18d0b87cbc81d2064ef55e174e547018af2803c0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 15:59:44 +0800
Subject: [PATCH 0080/1712] modify code

---
 src/class150/ShowDetails.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class150/ShowDetails.java b/src/class150/ShowDetails.java
index 4d99f3a0d..546b884a2 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/ShowDetails.java
@@ -4,10 +4,10 @@
 // 一旦，max(左树节点数，右树节点数) > 平衡因子 * 整树节点数，就会发生重构
 // 平衡因子范围是(0.5, 1.0)，否则无意义
 // 平衡因子等于0.5时，树高很小，查询效率高，但是重构发生很频繁
-// 平衡因子等于1.0时，树高很大，重构完全不发生，但是查询效率低
-// 保证查询效率、同时保证重构节点总数不多，0.7为最常用的平衡因子
-// 平衡因子为0.7左右，树高几乎是O(log n)，这保证了查询效率
-// 同时重构触发的时机合适，重构节点不多，均摊下来，单次代价为O(log n)
+// 平衡因子等于1.0时，重构完全不发生，但是树高很大，查询效率低
+// 保证查询效率、同时保证重构的节点总数不多，0.7为最常用的平衡因子
+// 这保证了查询效率，因为树高几乎是O(log n)
+// 同时重构触发的时机合适，单次调整的均摊代价为O(log n)
 
 import java.util.Arrays;
 

From f214392353ec96ed15b74915d55139790dd7d702 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 16:25:01 +0800
Subject: [PATCH 0081/1712] modify code

---
 src/class150/ScapeGoat1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class150/ScapeGoat1.java b/src/class150/ScapeGoat1.java
index 71a5e5b21..e69f3bec3 100644
--- a/src/class150/ScapeGoat1.java
+++ b/src/class150/ScapeGoat1.java
@@ -32,7 +32,7 @@ public class ScapeGoat1 {
 	// 整棵树的头节点编号
 	public static int head = 0;
 
-	// 空间使用编号
+	// 空间使用计数
 	public static int cnt = 0;
 
 	// 节点的key值

From 2f701839248d4e0e90f6c13c83ce49130e46ba89 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Nov 2024 18:01:01 +0800
Subject: [PATCH 0082/1712] modify code

---
 ...77\347\275\252\347\276\212\346\240\221.pptx" | Bin 0 -> 39862 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243150\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2303-\346\233\277\347\275\252\347\276\212\346\240\221.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243150\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2303-\346\233\277\347\275\252\347\276\212\346\240\221.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243150\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2303-\346\233\277\347\275\252\347\276\212\346\240\221.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..2dcf48a2f82d308ef1bf6a4c2e148da7cb1928db
GIT binary patch
literal 39862
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
L^_>#(>(l=M0oGs(

literal 0
HcmV?d00001


From 5cd83c2a4974a169daa9441bbc7487580069850b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 8 Nov 2024 14:51:13 +0800
Subject: [PATCH 0083/1712] modify code

---
 src/class073/Code03_TargetSum.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class073/Code03_TargetSum.java b/src/class073/Code03_TargetSum.java
index 5b72c2caf..86d0c4698 100644
--- a/src/class073/Code03_TargetSum.java
+++ b/src/class073/Code03_TargetSum.java
@@ -122,7 +122,7 @@ public static int findTargetSumWays3(int[] nums, int target) {
 	// 那么就一定对应一种target的方式
 	// 比如非负数组nums，target = 1, nums所有数累加和是11
 	// 求有多少方法组成1，其实就是求，有多少种子集累加和达到6的方法，(1+11)/2=6
-	// 因为，子集累加和6 - 另一半的子集累加和5 = 1（target)
+	// 因为，子集累加和6 - 另一半的子集累加和5 = 1(target)
 	// 所以有多少个累加和为6的不同集合，就代表有多少个target==1的表达式数量
 	// 至此已经转化为01背包问题了
 	public static int findTargetSumWays4(int[] nums, int target) {

From 6c715ac12b3a5758733e97dd90613e63873d9a92 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 11 Nov 2024 13:20:45 +0800
Subject: [PATCH 0084/1712] modify code

---
 src/class151/Code01_DescartesTree1.java | 71 +++++++++++++++++++++++++
 src/class151/Code01_DescartesTree2.java | 58 ++++++++++++++++++++
 2 files changed, 129 insertions(+)
 create mode 100644 src/class151/Code01_DescartesTree1.java
 create mode 100644 src/class151/Code01_DescartesTree2.java

diff --git a/src/class151/Code01_DescartesTree1.java b/src/class151/Code01_DescartesTree1.java
new file mode 100644
index 000000000..4e3713bcb
--- /dev/null
+++ b/src/class151/Code01_DescartesTree1.java
@@ -0,0 +1,71 @@
+package class151;
+
+// 笛卡尔树模版(java版)
+// 测试链接 : https://www.luogu.com.cn/problem/P5854
+// 如下实现是正确的，但java的版本无法通过所有测试用例
+// 这是洛谷平台没有照顾各种语言的实现所导致的
+// C++版本是Code01_DescartesTree2文件
+// C++版本和java版本逻辑完全一样，可以通过所有测试用例
+// 在真正笔试、比赛时，一定是兼顾各种语言的，该实现是一定正确的
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_DescartesTree1 {
+
+	public static int MAXN = 10000001;
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] stack = new int[MAXN];
+
+	public static int n;
+
+	public static void build() {
+		for (int i = 1, top = 0, pos = 0; i <= n; i++) {
+			pos = top;
+			while (pos > 0 && arr[stack[pos]] > arr[i]) {
+				pos--;
+			}
+			if (pos > 0) {
+				right[stack[pos]] = i;
+			}
+			if (pos < top) {
+				left[i] = stack[pos + 1];
+			}
+			stack[++pos] = i;
+			top = pos;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		build();
+		long ans1 = 0, ans2 = 0;
+		for (int i = 1; i <= n; i++) {
+			ans1 ^= (long) i * (left[i] + 1);
+			ans2 ^= (long) i * (right[i] + 1);
+		}
+		out.println(ans1 + " " + ans2);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class151/Code01_DescartesTree2.java b/src/class151/Code01_DescartesTree2.java
new file mode 100644
index 000000000..78e1b335d
--- /dev/null
+++ b/src/class151/Code01_DescartesTree2.java
@@ -0,0 +1,58 @@
+package class151;
+
+// 笛卡尔树模版(java版)
+// 测试链接 : https://www.luogu.com.cn/problem/P5854
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <stack>
+//#include <cstdio>
+//
+//#define LL long long
+//
+//using namespace std;
+//
+//const int MAXN = 10000001;
+//
+//int arr[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int sta[MAXN];
+//int n;
+//
+//void build() {
+//    int top = 0;
+//    for (int i = 1; i <= n; i++) {
+//        int pos = top;
+//        while (pos > 0 && arr[sta[pos]] > arr[i]) {
+//            pos--;
+//        }
+//        if (pos > 0) {
+//            rs[sta[pos]] = i;
+//        }
+//        if (pos < top) {
+//            ls[i] = sta[pos + 1];
+//        }
+//        sta[++pos] = i;
+//        top = pos;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    build();
+//    long long ans1 = 0, ans2 = 0;
+//    for (int i = 1; i <= n; i++) {
+//        ans1 ^= 1LL * i * (ls[i] + 1);
+//        ans2 ^= 1LL * i * (rs[i] + 1);
+//    }
+//    cout << ans1 << " " << ans2 << endl;
+//    return 0;
+//}
\ No newline at end of file

From 8eb59f96bb579a1bf4562710e28ebc29ff6d897e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 11 Nov 2024 13:46:59 +0800
Subject: [PATCH 0085/1712] modify code

---
 src/class151/Code01_DescartesTree2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class151/Code01_DescartesTree2.java b/src/class151/Code01_DescartesTree2.java
index 78e1b335d..c338c8699 100644
--- a/src/class151/Code01_DescartesTree2.java
+++ b/src/class151/Code01_DescartesTree2.java
@@ -1,6 +1,6 @@
 package class151;
 
-// 笛卡尔树模版(java版)
+// 笛卡尔树模版(C++版)
 // 测试链接 : https://www.luogu.com.cn/problem/P5854
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 2f7a431140c54c468550c52d46534871634a49fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 11 Nov 2024 16:02:44 +0800
Subject: [PATCH 0086/1712] modify code

---
 src/class151/Code02_TreeOrder.java | 80 ++++++++++++++++++++++++++++++
 1 file changed, 80 insertions(+)
 create mode 100644 src/class151/Code02_TreeOrder.java

diff --git a/src/class151/Code02_TreeOrder.java b/src/class151/Code02_TreeOrder.java
new file mode 100644
index 000000000..a38e4611e
--- /dev/null
+++ b/src/class151/Code02_TreeOrder.java
@@ -0,0 +1,80 @@
+package class151;
+
+// 树的序
+// 测试链接 : https://www.luogu.com.cn/problem/P1377
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_TreeOrder {
+
+	public static int MAXN = 100001;
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] stack = new int[MAXN];
+
+	public static int n;
+
+	public static void build() {
+		for (int i = 1, top = 0, pos = 0; i <= n; i++) {
+			pos = top;
+			while (pos > 0 && arr[stack[pos]] > arr[i]) {
+				pos--;
+			}
+			if (pos > 0) {
+				right[stack[pos]] = i;
+			}
+			if (pos < top) {
+				left[i] = stack[pos + 1];
+			}
+			stack[++pos] = i;
+			top = pos;
+		}
+	}
+
+	// 防止递归爆栈用迭代的方式实现先序遍历
+	public static void pre() {
+		int size = 1, i = 0, cur;
+		while (size > 0) {
+			cur = stack[size--];
+			arr[++i] = cur;
+			if (right[cur] != 0) {
+				stack[++size] = right[cur];
+			}
+			if (left[cur] != 0) {
+				stack[++size] = left[cur];
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[(int) in.nval] = i;
+		}
+		build();
+		pre();
+		for (int i = 1; i <= n; i++) {
+			out.print(arr[i] + " ");
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From d79da2d0aae909e014d547b3b30441ba9a2376be Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 11 Nov 2024 17:37:19 +0800
Subject: [PATCH 0087/1712] modify code

---
 src/class151/Code03_CountingProblem.java | 105 +++++++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 src/class151/Code03_CountingProblem.java

diff --git a/src/class151/Code03_CountingProblem.java b/src/class151/Code03_CountingProblem.java
new file mode 100644
index 000000000..437b19470
--- /dev/null
+++ b/src/class151/Code03_CountingProblem.java
@@ -0,0 +1,105 @@
+package class151;
+
+// 序列计数
+// 测试链接 : https://www.luogu.com.cn/problem/CF1748E
+// 测试链接 : https://codeforces.com/problemset/problem/1748/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_CountingProblem {
+
+	public static int MAXN = 1000001;
+
+	public static int MOD = 1000000007;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] stack = new int[MAXN];
+
+	public static int n, m;
+
+	public static void build() {
+		for (int i = 1, top = 0, pos; i <= n; i++) {
+			pos = top;
+			while (pos > 0 && arr[stack[pos]] < arr[i]) {
+				pos--;
+			}
+			if (pos > 0) {
+				right[stack[pos]] = i;
+			}
+			if (pos < top) {
+				left[i] = stack[pos + 1];
+			}
+			stack[++pos] = i;
+			top = pos;
+		}
+	}
+
+	public static long compute() {
+		long[][] dp = new long[n + 1][m + 1];
+		dfs(stack[1], dp);
+		return dp[stack[1]][m];
+	}
+
+	public static void dfs(int i, long[][] dp) {
+		for (int j = 1; j <= m; j++) {
+			dp[i][j] = 1;
+		}
+		if (left[i] != 0) {
+			dfs(left[i], dp);
+			for (int j = 1; j <= m; j++) {
+				dp[i][j] = dp[i][j] * dp[left[i]][j - 1] % MOD;
+			}
+		}
+		if (right[i] != 0) {
+			dfs(right[i], dp);
+			for (int j = 1; j <= m; j++) {
+				dp[i][j] = dp[i][j] * dp[right[i]][j] % MOD;
+			}
+		}
+		for (int j = 2; j <= m; j++) {
+			dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD;
+		}
+	}
+
+	public static void clear() {
+		Arrays.fill(left, 1, n + 1, 0);
+		Arrays.fill(right, 1, n + 1, 0);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int cases = (int) in.nval;
+		for (int t = 1; t <= cases; t++) {
+			in.nextToken();
+			n = (int) in.nval;
+			in.nextToken();
+			m = (int) in.nval;
+			for (int i = 1; i <= n; i++) {
+				in.nextToken();
+				arr[i] = (int) in.nval;
+			}
+			build();
+			out.println(compute());
+			clear();
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 75e3a5918a950e549d0fea0e007ce60d9c836541 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 14:32:02 +0800
Subject: [PATCH 0088/1712] modify code

---
 src/class043/Code02_SuperPalindromes.java     |  1 +
 src/class043/Code02_SuperPalindromesCPP1.java | 85 +++++++++++++++++++
 src/class043/Code02_SuperPalindromesCPP2.java | 66 ++++++++++++++
 3 files changed, 152 insertions(+)
 create mode 100644 src/class043/Code02_SuperPalindromesCPP1.java
 create mode 100644 src/class043/Code02_SuperPalindromesCPP2.java

diff --git a/src/class043/Code02_SuperPalindromes.java b/src/class043/Code02_SuperPalindromes.java
index 482449445..53adf94cb 100644
--- a/src/class043/Code02_SuperPalindromes.java
+++ b/src/class043/Code02_SuperPalindromes.java
@@ -3,6 +3,7 @@
 import java.util.ArrayList;
 import java.util.List;
 
+// 超级回文数(java版)
 // 如果一个正整数自身是回文数，而且它也是一个回文数的平方，那么我们称这个数为超级回文数。
 // 现在，给定两个正整数 L 和 R （以字符串形式表示），
 // 返回包含在范围 [L, R] 中的超级回文数的数目。
diff --git a/src/class043/Code02_SuperPalindromesCPP1.java b/src/class043/Code02_SuperPalindromesCPP1.java
new file mode 100644
index 000000000..6547fafcf
--- /dev/null
+++ b/src/class043/Code02_SuperPalindromesCPP1.java
@@ -0,0 +1,85 @@
+package class043;
+
+// 超级回文数(superpalindromesInRange1方法C++版本)
+// 如果一个正整数自身是回文数，而且它也是一个回文数的平方，那么我们称这个数为超级回文数。
+// 现在，给定两个正整数 L 和 R （以字符串形式表示），
+// 返回包含在范围 [L, R] 中的超级回文数的数目。
+// 1 <= len(L) <= 18
+// 1 <= len(R) <= 18
+// L 和 R 是表示 [1, 10^18) 范围的整数的字符串
+// 测试链接 : https://leetcode.cn/problems/super-palindromes/
+// 如下实现是课上讲的superpalindromesInRange1方法的C++版本，提交如下代码可以直接通过
+
+//#include <string>
+//#include <cmath>
+//#include <limits>
+//
+//using namespace std;
+//
+//class Solution {
+//public:
+//    int superpalindromesInRange(string left, string right) {
+//        long long l = stoll(left);
+//        long long r = stoll(right);
+//        long long limit = static_cast<long long>(sqrt(r));
+//        long long seed = 1;
+//        long long num = 0;
+//        int ans = 0;
+//        do {
+//            num = evenEnlarge(seed);
+//            if (num <= limit && safeSquare(num) && check(num * num, l, r)) {
+//                ans++;
+//            }
+//            num = oddEnlarge(seed);
+//            if (num <= limit && safeSquare(num) && check(num * num, l, r)) {
+//                ans++;
+//            }
+//            seed++;
+//        } while (num < limit);
+//
+//        return ans;
+//    }
+//
+//private:
+//    bool safeSquare(long long num) {
+//        return num <= static_cast<long long>(sqrt(numeric_limits<long long>::max()));
+//    }
+//
+//    long long evenEnlarge(long long seed) {
+//        long long ans = seed;
+//        while (seed != 0) {
+//            ans = ans * 10 + seed % 10;
+//            seed /= 10;
+//        }
+//        return ans;
+//    }
+//
+//    long long oddEnlarge(long long seed) {
+//        long long ans = seed;
+//        seed /= 10;
+//        while (seed != 0) {
+//            ans = ans * 10 + seed % 10;
+//            seed /= 10;
+//        }
+//        return ans;
+//    }
+//
+//    bool check(long long ans, long long l, long long r) {
+//        return ans >= l && ans <= r && isPalindrome(ans);
+//    }
+//
+//    bool isPalindrome(long long num) {
+//        long long offset = 1;
+//        while (num / offset >= 10) {
+//            offset *= 10;
+//        }
+//        while (num != 0) {
+//            if (num / offset != num % 10) {
+//                return false;
+//            }
+//            num = (num % offset) / 10;
+//            offset /= 100;
+//        }
+//        return true;
+//    }
+//};
diff --git a/src/class043/Code02_SuperPalindromesCPP2.java b/src/class043/Code02_SuperPalindromesCPP2.java
new file mode 100644
index 000000000..de746458c
--- /dev/null
+++ b/src/class043/Code02_SuperPalindromesCPP2.java
@@ -0,0 +1,66 @@
+package class043;
+
+// 超级回文数(superpalindromesInRange2方法C++版本)
+// 如果一个正整数自身是回文数，而且它也是一个回文数的平方，那么我们称这个数为超级回文数。
+// 现在，给定两个正整数 L 和 R （以字符串形式表示），
+// 返回包含在范围 [L, R] 中的超级回文数的数目。
+// 1 <= len(L) <= 18
+// 1 <= len(R) <= 18
+// L 和 R 是表示 [1, 10^18) 范围的整数的字符串
+// 测试链接 : https://leetcode.cn/problems/super-palindromes/
+// 如下实现是课上讲的superpalindromesInRange2方法的C++版本，提交如下代码可以直接通过
+
+//#include <string>
+//#include <vector>
+//
+//using namespace std;
+//
+//class Solution {
+//public:
+//    int superpalindromesInRange(string left, string right) {
+//        long long l = stoll(left);
+//        long long r = stoll(right);
+//        int i = 0;
+//        
+//        // 找到第一个 >= l 的位置
+//        while (i < record.size() && record[i] < l) {
+//            i++;
+//        }
+//        
+//        int j = record.size() - 1;
+//        // 找到最后一个 <= r 的位置
+//        while (j >= 0 && record[j] > r) {
+//            j--;
+//        }
+//        
+//        return (j >= i) ? (j - i + 1) : 0;
+//    }
+//
+//private:
+//    // 打表记录的超级回文数
+//    const vector<long long> record = {
+//        1L, 4L, 9L, 121L, 484L, 10201L, 12321L, 14641L, 40804L, 44944L,
+//        1002001L, 1234321L, 4008004L, 100020001L, 102030201L, 104060401L,
+//        121242121L, 123454321L, 125686521L, 400080004L, 404090404L,
+//        10000200001L, 10221412201L, 12102420121L, 12345654321L,
+//        40000800004L, 1000002000001L, 1002003002001L, 1004006004001L,
+//        1020304030201L, 1022325232201L, 1024348434201L, 1210024200121L,
+//        1212225222121L, 1214428244121L, 1232346432321L, 1234567654321L,
+//        4000008000004L, 4004009004004L, 100000020000001L, 100220141022001L,
+//        102012040210201L, 102234363432201L, 121000242000121L,
+//        121242363242121L, 123212464212321L, 123456787654321L,
+//        400000080000004L, 10000000200000001L, 10002000300020001L,
+//        10004000600040001L, 10020210401202001L, 10022212521222001L,
+//        10024214841242001L, 10201020402010201L, 10203040504030201L,
+//        10205060806050201L, 10221432623412201L, 10223454745432201L,
+//        12100002420000121L, 12102202520220121L, 12104402820440121L,
+//        12122232623222121L, 12124434743442121L, 12321024642012321L,
+//        12323244744232321L, 12343456865434321L, 12345678987654321L,
+//        40000000800000004L, 40004000900040004L, 1000000002000000001L,
+//        1000220014100220001L, 1002003004003002001L, 1002223236323222001L,
+//        1020100204020010201L, 1020322416142230201L, 1022123226223212201L,
+//        1022345658565432201L, 1210000024200000121L, 1210242036302420121L,
+//        1212203226223022121L, 1212445458545442121L, 1232100246420012321L,
+//        1232344458544432321L, 1234323468643234321L, 4000000008000000004L
+//    };
+//};

From 1c13bde04cc24a52fbe40e471b42e43d8f1d52b4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 14:35:20 +0800
Subject: [PATCH 0089/1712] modify code

---
 src/class043/Code02_SuperPalindromesCPP2.java | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/class043/Code02_SuperPalindromesCPP2.java b/src/class043/Code02_SuperPalindromesCPP2.java
index de746458c..39f157ce3 100644
--- a/src/class043/Code02_SuperPalindromesCPP2.java
+++ b/src/class043/Code02_SuperPalindromesCPP2.java
@@ -21,23 +21,17 @@
 //        long long l = stoll(left);
 //        long long r = stoll(right);
 //        int i = 0;
-//        
-//        // 找到第一个 >= l 的位置
 //        while (i < record.size() && record[i] < l) {
 //            i++;
 //        }
-//        
 //        int j = record.size() - 1;
-//        // 找到最后一个 <= r 的位置
 //        while (j >= 0 && record[j] > r) {
 //            j--;
 //        }
-//        
 //        return (j >= i) ? (j - i + 1) : 0;
 //    }
 //
 //private:
-//    // 打表记录的超级回文数
 //    const vector<long long> record = {
 //        1L, 4L, 9L, 121L, 484L, 10201L, 12321L, 14641L, 40804L, 44944L,
 //        1002001L, 1234321L, 4008004L, 100020001L, 102030201L, 104060401L,

From 2126055efbaa932696d68388dcca2776eb8d55a9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 15:04:35 +0800
Subject: [PATCH 0090/1712] modify code

---
 src/class151/Code04_RemovingBlocks.java | 70 +++++++++++++++++++++++++
 1 file changed, 70 insertions(+)
 create mode 100644 src/class151/Code04_RemovingBlocks.java

diff --git a/src/class151/Code04_RemovingBlocks.java b/src/class151/Code04_RemovingBlocks.java
new file mode 100644
index 000000000..c4cb292ed
--- /dev/null
+++ b/src/class151/Code04_RemovingBlocks.java
@@ -0,0 +1,70 @@
+package class151;
+
+// 消除砖头
+// 测试链接 : https://www.luogu.com.cn/problem/AT_agc028_b
+// 测试链接 : https://atcoder.jp/contests/agc028/tasks/agc028_b
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_RemovingBlocks {
+
+	public static int MAXN = 100001;
+
+	public static int MOD = 1000000007;
+
+	// 所有数字
+	public static int[] arr = new int[MAXN];
+
+	// 连续数字逆元表
+	public static int[] inv = new int[MAXN];
+
+	// sum[i] = (1/1 + 1/2 + 1/3 + ... + 1/i)，%MOD意义下的余数
+	public static int[] sum = new int[MAXN];
+
+	public static int n;
+
+	public static void build() {
+		inv[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			inv[i] = (int) (MOD - (long) inv[MOD % i] * (MOD / i) % MOD);
+		}
+		for (int i = 1; i <= n; i++) {
+			sum[i] = (sum[i - 1] + inv[i]) % MOD;
+		}
+	}
+
+	public static long compute() {
+		build();
+		long ans = 0;
+		for (int i = 1; i <= n; i++) {
+			ans = (ans + (long) (sum[i] + sum[n - i + 1] - 1) * arr[i]) % MOD;
+		}
+		for (int i = 1; i <= n; ++i) {
+			ans = ans * i % MOD;
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		out.println(compute());
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From d0f694e5ba32ac886160d19612ca9941c400e712 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 16:24:23 +0800
Subject: [PATCH 0091/1712] modify code

---
 src/class151/Code01_DescartesTree1.java  |   4 +-
 src/class151/Code02_TreeOrder.java       |   4 +-
 src/class151/Code03_CountingProblem.java |   4 +-
 src/class151/Code04_RemovingBlocks.java  |   4 +-
 src/class151/Code05_Periodni.java        | 130 +++++++++++++++++++++++
 5 files changed, 138 insertions(+), 8 deletions(-)
 create mode 100644 src/class151/Code05_Periodni.java

diff --git a/src/class151/Code01_DescartesTree1.java b/src/class151/Code01_DescartesTree1.java
index 4e3713bcb..422f22d80 100644
--- a/src/class151/Code01_DescartesTree1.java
+++ b/src/class151/Code01_DescartesTree1.java
@@ -18,13 +18,13 @@
 public class Code01_DescartesTree1 {
 
 	public static int MAXN = 10000001;
+	
+	public static int[] arr = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
-	public static int[] arr = new int[MAXN];
-
 	public static int[] stack = new int[MAXN];
 
 	public static int n;
diff --git a/src/class151/Code02_TreeOrder.java b/src/class151/Code02_TreeOrder.java
index a38e4611e..6e6359a90 100644
--- a/src/class151/Code02_TreeOrder.java
+++ b/src/class151/Code02_TreeOrder.java
@@ -14,13 +14,13 @@
 public class Code02_TreeOrder {
 
 	public static int MAXN = 100001;
+	
+	public static int[] arr = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
-	public static int[] arr = new int[MAXN];
-
 	public static int[] stack = new int[MAXN];
 
 	public static int n;
diff --git a/src/class151/Code03_CountingProblem.java b/src/class151/Code03_CountingProblem.java
index 437b19470..6b771e649 100644
--- a/src/class151/Code03_CountingProblem.java
+++ b/src/class151/Code03_CountingProblem.java
@@ -14,11 +14,11 @@
 import java.util.Arrays;
 
 public class Code03_CountingProblem {
+	
+	public static int MOD = 1000000007;
 
 	public static int MAXN = 1000001;
 
-	public static int MOD = 1000000007;
-
 	public static int[] arr = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
diff --git a/src/class151/Code04_RemovingBlocks.java b/src/class151/Code04_RemovingBlocks.java
index c4cb292ed..98bbe778e 100644
--- a/src/class151/Code04_RemovingBlocks.java
+++ b/src/class151/Code04_RemovingBlocks.java
@@ -14,10 +14,10 @@
 
 public class Code04_RemovingBlocks {
 
-	public static int MAXN = 100001;
-
 	public static int MOD = 1000000007;
 
+	public static int MAXN = 100001;
+
 	// 所有数字
 	public static int[] arr = new int[MAXN];
 
diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
new file mode 100644
index 000000000..f7bedba53
--- /dev/null
+++ b/src/class151/Code05_Periodni.java
@@ -0,0 +1,130 @@
+package class151;
+
+// 表格填数
+// 测试链接 : https://www.luogu.com.cn/problem/P6453
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code05_Periodni {
+
+	public static int MOD = 1000000007;
+
+	public static int MAXN = 501;
+
+	public static int MAXH = 1000000;
+
+	public static int[] fac = new int[MAXH + 1];
+
+	public static int[] inv = new int[MAXH + 1];
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] stack = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[][] dp = new int[MAXN][MAXN];
+
+	public static int n, k;
+
+	public static int power(long x, long p) {
+		long ans = 1;
+		while (p > 0) {
+			if ((p & 1) == 1) {
+				ans = (ans * x) % MOD;
+			}
+			x = (x * x) % MOD;
+			p >>= 1;
+		}
+		return (int) ans;
+	}
+
+	public static int c(int n, int k) {
+		return (int) ((long) fac[n] * inv[k] % MOD * inv[n - k] % MOD);
+	}
+
+	public static void build() {
+		fac[0] = fac[1] = inv[0] = 1;
+		for (int i = 2; i <= MAXH; i++) {
+			fac[i] = (int) ((long) fac[i - 1] * i % MOD);
+		}
+		inv[MAXH] = power(fac[MAXH], MOD - 2);
+		for (int i = MAXH - 1; i >= 1; i--) {
+			inv[i] = (int) ((long) inv[i + 1] * (i + 1) % MOD);
+		}
+		for (int i = 1, top = 0, pos; i <= n; i++) {
+			pos = top;
+			while (pos > 0 && arr[stack[pos]] > arr[i]) {
+				pos--;
+			}
+			if (pos > 0) {
+				right[stack[pos]] = i;
+			}
+			if (pos < top) {
+				left[i] = stack[pos + 1];
+			}
+			stack[++pos] = i;
+			top = pos;
+		}
+	}
+
+	public static void dfs(int u, int f) {
+		dp[u][0] = size[u] = 1;
+		if (left[u] != 0) {
+			dfs(left[u], u);
+			size[u] += size[left[u]];
+			for (int i = Math.min(size[u], k); i >= 0; i--) {
+				for (int j = 1; j <= Math.min(size[left[u]], i); j++) {
+					dp[u][i] = (int) ((dp[u][i] + (long) dp[left[u]][j] * dp[u][i - j] % MOD) % MOD);
+				}
+			}
+		}
+		if (right[u] != 0) {
+			dfs(right[u], u);
+			size[u] += size[right[u]];
+			for (int i = Math.min(size[u], k); i >= 0; i--) {
+				for (int j = 1; j <= Math.min(size[right[u]], i); j++) {
+					dp[u][i] = (int) ((dp[u][i] + (long) dp[right[u]][j] * dp[u][i - j] % MOD) % MOD);
+				}
+			}
+		}
+		int val = arr[u] - arr[f];
+		for (int i = Math.min(size[u], k); i >= 0; i--) {
+			for (int j = 1; j <= Math.min(val, i); j++) {
+				dp[u][i] = (int) ((dp[u][i]
+						+ (long) fac[j] * dp[u][i - j] % MOD * c(val, j) % MOD * c(size[u] - i + j, j)) % MOD);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		build();
+		dfs(stack[1], 0);
+		out.println(dp[stack[1]][k]);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From d230336aae94000c17b2638a5b92d5173b0ed698 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 17:04:16 +0800
Subject: [PATCH 0092/1712] modify code

---
 src/class151/Code05_Periodni.java | 48 +++++++++++++++----------------
 1 file changed, 23 insertions(+), 25 deletions(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index f7bedba53..b6efa487a 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -35,6 +35,8 @@ public class Code05_Periodni {
 
 	public static int[][] dp = new int[MAXN][MAXN];
 
+	public static int[][] tmp = new int[MAXN][MAXN];
+
 	public static int n, k;
 
 	public static int power(long x, long p) {
@@ -50,7 +52,7 @@ public static int power(long x, long p) {
 	}
 
 	public static int c(int n, int k) {
-		return (int) ((long) fac[n] * inv[k] % MOD * inv[n - k] % MOD);
+		return k > n ? 0 : (int) ((long) fac[n] * inv[k] % MOD * inv[n - k] % MOD);
 	}
 
 	public static void build() {
@@ -78,35 +80,33 @@ public static void build() {
 		}
 	}
 
-	public static void dfs(int u, int f) {
-		dp[u][0] = size[u] = 1;
-		if (left[u] != 0) {
+	public static void dfs(int u, int fa) {
+		if (u == 0) {
+			dp[u][0] = 1;
+		} else {
 			dfs(left[u], u);
-			size[u] += size[left[u]];
-			for (int i = Math.min(size[u], k); i >= 0; i--) {
-				for (int j = 1; j <= Math.min(size[left[u]], i); j++) {
-					dp[u][i] = (int) ((dp[u][i] + (long) dp[left[u]][j] * dp[u][i - j] % MOD) % MOD);
-				}
-			}
-		}
-		if (right[u] != 0) {
 			dfs(right[u], u);
-			size[u] += size[right[u]];
-			for (int i = Math.min(size[u], k); i >= 0; i--) {
-				for (int j = 1; j <= Math.min(size[right[u]], i); j++) {
-					dp[u][i] = (int) ((dp[u][i] + (long) dp[right[u]][j] * dp[u][i - j] % MOD) % MOD);
+			size[u] = size[left[u]] + size[right[u]] + 1;
+			for (int i = 0; i <= size[left[u]]; i++) {
+				for (int j = 0; j <= size[right[u]]; j++) {
+					tmp[u][i + j] = (int) (tmp[u][i + j] + (long) dp[left[u]][i] * dp[right[u]][j] % MOD) % MOD;
 				}
 			}
-		}
-		int val = arr[u] - arr[f];
-		for (int i = Math.min(size[u], k); i >= 0; i--) {
-			for (int j = 1; j <= Math.min(val, i); j++) {
-				dp[u][i] = (int) ((dp[u][i]
-						+ (long) fac[j] * dp[u][i - j] % MOD * c(val, j) % MOD * c(size[u] - i + j, j)) % MOD);
+			for (int i = 0; i <= size[u]; i++) {
+				for (int j = 0; j <= i; j++) {
+					dp[u][i] = (int) (dp[u][i] + (long) tmp[u][j] * fac[i - j] % MOD * c(size[u] - j, i - j) % MOD
+							* c(arr[u] - arr[fa], i - j) % MOD) % MOD;
+				}
 			}
 		}
 	}
 
+	public static int compute() {
+		build();
+		dfs(stack[1], 0);
+		return dp[stack[1]][k];
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -119,9 +119,7 @@ public static void main(String[] args) throws IOException {
 			in.nextToken();
 			arr[i] = (int) in.nval;
 		}
-		build();
-		dfs(stack[1], 0);
-		out.println(dp[stack[1]][k]);
+		out.println(compute());
 		out.flush();
 		out.close();
 		br.close();

From 74734e8a1b94eba18342268463b3a288e57ed8ca Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 17:17:25 +0800
Subject: [PATCH 0093/1712] modify code

---
 src/class151/{Code02_TreeOrder.java => Code03_TreeOrder.java}   | 2 +-
 ...{Code03_CountingProblem.java => Code04_CountingProblem.java} | 2 +-
 .../{Code04_RemovingBlocks.java => Code05_RemovingBlocks.java}  | 2 +-
 src/class151/{Code05_Periodni.java => Code06_Periodni.java}     | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class151/{Code02_TreeOrder.java => Code03_TreeOrder.java} (98%)
 rename src/class151/{Code03_CountingProblem.java => Code04_CountingProblem.java} (98%)
 rename src/class151/{Code04_RemovingBlocks.java => Code05_RemovingBlocks.java} (97%)
 rename src/class151/{Code05_Periodni.java => Code06_Periodni.java} (98%)

diff --git a/src/class151/Code02_TreeOrder.java b/src/class151/Code03_TreeOrder.java
similarity index 98%
rename from src/class151/Code02_TreeOrder.java
rename to src/class151/Code03_TreeOrder.java
index 6e6359a90..ee972a72e 100644
--- a/src/class151/Code02_TreeOrder.java
+++ b/src/class151/Code03_TreeOrder.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_TreeOrder {
+public class Code03_TreeOrder {
 
 	public static int MAXN = 100001;
 	
diff --git a/src/class151/Code03_CountingProblem.java b/src/class151/Code04_CountingProblem.java
similarity index 98%
rename from src/class151/Code03_CountingProblem.java
rename to src/class151/Code04_CountingProblem.java
index 6b771e649..779d2c6f8 100644
--- a/src/class151/Code03_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -13,7 +13,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_CountingProblem {
+public class Code04_CountingProblem {
 	
 	public static int MOD = 1000000007;
 
diff --git a/src/class151/Code04_RemovingBlocks.java b/src/class151/Code05_RemovingBlocks.java
similarity index 97%
rename from src/class151/Code04_RemovingBlocks.java
rename to src/class151/Code05_RemovingBlocks.java
index 98bbe778e..14cdb3033 100644
--- a/src/class151/Code04_RemovingBlocks.java
+++ b/src/class151/Code05_RemovingBlocks.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_RemovingBlocks {
+public class Code05_RemovingBlocks {
 
 	public static int MOD = 1000000007;
 
diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code06_Periodni.java
similarity index 98%
rename from src/class151/Code05_Periodni.java
rename to src/class151/Code06_Periodni.java
index b6efa487a..0f6707318 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code06_Periodni.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_Periodni {
+public class Code06_Periodni {
 
 	public static int MOD = 1000000007;
 

From 0a68151c2f37275e3f11a27665ff0308f86d25a4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 21:07:24 +0800
Subject: [PATCH 0094/1712] modify code

---
 src/class151/Code04_CountingProblem.java | 18 +++++++++---------
 src/class151/Code06_Periodni.java        |  9 +++++++--
 2 files changed, 16 insertions(+), 11 deletions(-)

diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index 779d2c6f8..38be4ca4d 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -14,7 +14,7 @@
 import java.util.Arrays;
 
 public class Code04_CountingProblem {
-	
+
 	public static int MOD = 1000000007;
 
 	public static int MAXN = 1000001;
@@ -46,12 +46,6 @@ public static void build() {
 		}
 	}
 
-	public static long compute() {
-		long[][] dp = new long[n + 1][m + 1];
-		dfs(stack[1], dp);
-		return dp[stack[1]][m];
-	}
-
 	public static void dfs(int i, long[][] dp) {
 		for (int j = 1; j <= m; j++) {
 			dp[i][j] = 1;
@@ -78,6 +72,14 @@ public static void clear() {
 		Arrays.fill(right, 1, n + 1, 0);
 	}
 
+	public static long compute() {
+		build();
+		long[][] dp = new long[n + 1][m + 1];
+		dfs(stack[1], dp);
+		clear();
+		return dp[stack[1]][m];
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -93,9 +95,7 @@ public static void main(String[] args) throws IOException {
 				in.nextToken();
 				arr[i] = (int) in.nval;
 			}
-			build();
 			out.println(compute());
-			clear();
 		}
 		out.flush();
 		out.close();
diff --git a/src/class151/Code06_Periodni.java b/src/class151/Code06_Periodni.java
index 0f6707318..79529918a 100644
--- a/src/class151/Code06_Periodni.java
+++ b/src/class151/Code06_Periodni.java
@@ -19,18 +19,23 @@ public class Code06_Periodni {
 
 	public static int MAXH = 1000000;
 
+	// 所有数字
+	public static int[] arr = new int[MAXN];
+
+	// 阶乘余数表
 	public static int[] fac = new int[MAXH + 1];
 
+	// 阶乘逆元表
 	public static int[] inv = new int[MAXH + 1];
 
-	public static int[] arr = new int[MAXN];
-
+	// 笛卡尔树需要
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
 	public static int[] stack = new int[MAXN];
 
+	// dfs需要
 	public static int[] size = new int[MAXN];
 
 	public static int[][] dp = new int[MAXN][MAXN];

From 1b8f37a0fda4d7f230bd83d77cf626e3fa164997 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Nov 2024 21:11:49 +0800
Subject: [PATCH 0095/1712] modify code

---
 src/class151/Code06_Periodni.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class151/Code06_Periodni.java b/src/class151/Code06_Periodni.java
index 79529918a..8a86e64d5 100644
--- a/src/class151/Code06_Periodni.java
+++ b/src/class151/Code06_Periodni.java
@@ -2,6 +2,7 @@
 
 // 表格填数
 // 测试链接 : https://www.luogu.com.cn/problem/P6453
+// 因为本题给定的可用空间很少，所以数组为int类型，不用long类型
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedReader;

From 276c65a80eb2d4323c71f8ccf98efdeb4f27ffc5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 12:59:17 +0800
Subject: [PATCH 0096/1712] modify code

---
 src/class148/AVL2.java          |  98 ++++++-------
 src/class151/Code02_Treap1.java | 238 ++++++++++++++++++++++++++++++++
 src/class151/Code02_Treap2.java | 212 ++++++++++++++++++++++++++++
 3 files changed, 499 insertions(+), 49 deletions(-)
 create mode 100644 src/class151/Code02_Treap1.java
 create mode 100644 src/class151/Code02_Treap2.java

diff --git a/src/class148/AVL2.java b/src/class148/AVL2.java
index 748bb2712..475836d59 100644
--- a/src/class148/AVL2.java
+++ b/src/class148/AVL2.java
@@ -27,56 +27,56 @@
 //int head = 0;
 //int key[MAXN];
 //int height[MAXN];
-//int leftChild[MAXN];
-//int rightChild[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
 //int key_count[MAXN];
 //int size[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[leftChild[i]] + size[rightChild[i]] + key_count[i];
-//    height[i] = max(height[leftChild[i]], height[rightChild[i]]) + 1;
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    height[i] = max(height[ls[i]], height[rs[i]]) + 1;
 //}
 //
 //int leftRotate(int i) {
-//    int r = rightChild[i];
-//    rightChild[i] = leftChild[r];
-//    leftChild[r] = i;
+//    int r = rs[i];
+//    rs[i] = ls[r];
+//    ls[r] = i;
 //    up(i);
 //    up(r);
 //    return r;
 //}
 //
 //int rightRotate(int i) {
-//    int l = leftChild[i];
-//    leftChild[i] = rightChild[l];
-//    rightChild[l] = i;
+//    int l = ls[i];
+//    ls[i] = rs[l];
+//    rs[l] = i;
 //    up(i);
 //    up(l);
 //    return l;
 //}
 //
 //int maintain(int i) {
-//    int lh = height[leftChild[i]];
-//    int rh = height[rightChild[i]];
+//    int lh = height[ls[i]];
+//    int rh = height[rs[i]];
 //    if (lh - rh > 1) {
-//        if (height[leftChild[leftChild[i]]] >= height[rightChild[leftChild[i]]]) {
+//        if (height[ls[ls[i]]] >= height[rs[ls[i]]]) {
 //            i = rightRotate(i);
 //        } else {
-//            leftChild[i] = leftRotate(leftChild[i]);
+//            ls[i] = leftRotate(ls[i]);
 //            i = rightRotate(i);
 //        }
 //    } else if (rh - lh > 1) {
-//        if (height[rightChild[rightChild[i]]] >= height[leftChild[rightChild[i]]]) {
+//        if (height[rs[rs[i]]] >= height[ls[rs[i]]]) {
 //            i = leftRotate(i);
 //        } else {
-//            rightChild[i] = rightRotate(rightChild[i]);
+//            rs[i] = rightRotate(rs[i]);
 //            i = leftRotate(i);
 //        }
 //    }
 //    return i;
 //}
 //
-//int addNode(int i, int num) {
+//int add(int i, int num) {
 //    if (i == 0) {
 //        key[++cnt] = num;
 //        key_count[cnt] = size[cnt] = height[cnt] = 1;
@@ -85,16 +85,16 @@
 //    if (key[i] == num) {
 //        key_count[i]++;
 //    } else if (key[i] > num) {
-//        leftChild[i] = addNode(leftChild[i], num);
+//        ls[i] = add(ls[i], num);
 //    } else {
-//        rightChild[i] = addNode(rightChild[i], num);
+//        rs[i] = add(rs[i], num);
 //    }
 //    up(i);
 //    return maintain(i);
 //}
 //
 //void add(int num) {
-//    head = addNode(head, num);
+//    head = add(head, num);
 //}
 //
 //int getRank(int i, int num) {
@@ -102,9 +102,9 @@
 //        return 0;
 //    }
 //    if (key[i] >= num) {
-//        return getRank(leftChild[i], num);
+//        return getRank(ls[i], num);
 //    } else {
-//        return size[leftChild[i]] + key_count[i] + getRank(rightChild[i], num);
+//        return size[ls[i]] + key_count[i] + getRank(rs[i], num);
 //    }
 //}
 //
@@ -114,37 +114,37 @@
 //
 //int removeMostLeft(int i, int mostLeft) {
 //    if (i == mostLeft) {
-//        return rightChild[i];
+//        return rs[i];
 //    } else {
-//        leftChild[i] = removeMostLeft(leftChild[i], mostLeft);
+//        ls[i] = removeMostLeft(ls[i], mostLeft);
 //        up(i);
 //        return maintain(i);
 //    }
 //}
 //
-//int removeNode(int i, int num) {
+//int remove(int i, int num) {
 //    if (key[i] < num) {
-//        rightChild[i] = removeNode(rightChild[i], num);
+//        rs[i] = remove(rs[i], num);
 //    } else if (key[i] > num) {
-//        leftChild[i] = removeNode(leftChild[i], num);
+//        ls[i] = remove(ls[i], num);
 //    } else {
 //        if (key_count[i] > 1) {
 //            key_count[i]--;
 //        } else {
-//            if (leftChild[i] == 0 && rightChild[i] == 0) {
+//            if (ls[i] == 0 && rs[i] == 0) {
 //                return 0;
-//            } else if (leftChild[i] != 0 && rightChild[i] == 0) {
-//                i = leftChild[i];
-//            } else if (leftChild[i] == 0 && rightChild[i] != 0) {
-//                i = rightChild[i];
+//            } else if (ls[i] != 0 && rs[i] == 0) {
+//                i = ls[i];
+//            } else if (ls[i] == 0 && rs[i] != 0) {
+//                i = rs[i];
 //            } else {
-//                int mostLeft = rightChild[i];
-//                while (leftChild[mostLeft] != 0) {
-//                    mostLeft = leftChild[mostLeft];
+//                int mostLeft = rs[i];
+//                while (ls[mostLeft] != 0) {
+//                    mostLeft = ls[mostLeft];
 //                }
-//                rightChild[i] = removeMostLeft(rightChild[i], mostLeft);
-//                leftChild[mostLeft] = leftChild[i];
-//                rightChild[mostLeft] = rightChild[i];
+//                rs[i] = removeMostLeft(rs[i], mostLeft);
+//                ls[mostLeft] = ls[i];
+//                rs[mostLeft] = rs[i];
 //                i = mostLeft;
 //            }
 //        }
@@ -155,15 +155,15 @@
 //
 //void remove(int num) {
 //    if (getRank(num) != getRank(num + 1)) {
-//        head = removeNode(head, num);
+//        head = remove(head, num);
 //    }
 //}
 //
 //int getIndex(int i, int x) {
-//    if (size[leftChild[i]] >= x) {
-//        return getIndex(leftChild[i], x);
-//    } else if (size[leftChild[i]] + key_count[i] < x) {
-//        return getIndex(rightChild[i], x - size[leftChild[i]] - key_count[i]);
+//    if (size[ls[i]] >= x) {
+//        return getIndex(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return getIndex(rs[i], x - size[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
@@ -177,9 +177,9 @@
 //        return INT_MIN;
 //    }
 //    if (key[i] >= num) {
-//        return pre(leftChild[i], num);
+//        return pre(ls[i], num);
 //    } else {
-//        return max(key[i], pre(rightChild[i], num));
+//        return max(key[i], pre(rs[i], num));
 //    }
 //}
 //
@@ -192,9 +192,9 @@
 //        return INT_MAX;
 //    }
 //    if (key[i] <= num) {
-//        return post(rightChild[i], num);
+//        return post(rs[i], num);
 //    } else {
-//        return min(key[i], post(leftChild[i], num));
+//        return min(key[i], post(ls[i], num));
 //    }
 //}
 //
@@ -205,8 +205,8 @@
 //void clear() {
 //    memset(key + 1, 0, cnt * sizeof(int));
 //    memset(height + 1, 0, cnt * sizeof(int));
-//    memset(leftChild + 1, 0, cnt * sizeof(int));
-//    memset(rightChild + 1, 0, cnt * sizeof(int));
+//    memset(ls + 1, 0, cnt * sizeof(int));
+//    memset(rs + 1, 0, cnt * sizeof(int));
 //    memset(key_count + 1, 0, cnt * sizeof(int));
 //    memset(size + 1, 0, cnt * sizeof(int));
 //    cnt = 0;
diff --git a/src/class151/Code02_Treap1.java b/src/class151/Code02_Treap1.java
new file mode 100644
index 000000000..b40aa7c00
--- /dev/null
+++ b/src/class151/Code02_Treap1.java
@@ -0,0 +1,238 @@
+package class151;
+
+// Treap树的实现(java版)
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code02_Treap1 {
+
+	public static int MAXN = 100001;
+
+	// 整棵树的头节点编号
+	public static int head = 0;
+
+	// 空间使用计数
+	public static int cnt = 0;
+
+	// 节点的key值
+	public static int[] key = new int[MAXN];
+
+	// 节点key的计数
+	public static int[] count = new int[MAXN];
+
+	// 左孩子
+	public static int[] left = new int[MAXN];
+
+	// 右孩子
+	public static int[] right = new int[MAXN];
+
+	// 数字总数
+	public static int[] size = new int[MAXN];
+
+	// 节点优先级
+	public static double[] priority = new double[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+	}
+
+	public static int leftRotate(int i) {
+		int r = right[i];
+		right[i] = left[r];
+		left[r] = i;
+		up(i);
+		up(r);
+		return r;
+	}
+
+	public static int rightRotate(int i) {
+		int l = left[i];
+		left[i] = right[l];
+		right[l] = i;
+		up(i);
+		up(l);
+		return l;
+	}
+
+	public static int add(int i, int num) {
+		if (i == 0) {
+			key[++cnt] = num;
+			count[cnt] = size[cnt] = 1;
+			priority[cnt] = Math.random();
+			return cnt;
+		}
+		if (key[i] == num) {
+			count[i]++;
+		} else if (key[i] > num) {
+			left[i] = add(left[i], num);
+		} else {
+			right[i] = add(right[i], num);
+		}
+		up(i);
+		if (left[i] != 0 && priority[left[i]] > priority[i]) {
+			return rightRotate(i);
+		}
+		if (right[i] != 0 && priority[right[i]] > priority[i]) {
+			return leftRotate(i);
+		}
+		return i;
+	}
+
+	public static void add(int num) {
+		head = add(head, num);
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], num);
+		}
+	}
+
+	public static int rank(int num) {
+		return small(head, num) + 1;
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int pre(int i, int num) {
+		if (i == 0) {
+			return Integer.MIN_VALUE;
+		}
+		if (key[i] >= num) {
+			return pre(left[i], num);
+		} else {
+			return Math.max(key[i], pre(right[i], num));
+		}
+	}
+
+	public static int pre(int num) {
+		return pre(head, num);
+	}
+
+	public static int post(int i, int num) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= num) {
+			return post(right[i], num);
+		} else {
+			return Math.min(key[i], post(left[i], num));
+		}
+	}
+
+	public static int post(int num) {
+		return post(head, num);
+	}
+
+	public static int remove(int i, int num) {
+		if (key[i] < num) {
+			right[i] = remove(right[i], num);
+		} else if (key[i] > num) {
+			left[i] = remove(left[i], num);
+		} else {
+			if (count[i] > 1) {
+				count[i]--;
+			} else {
+				if (left[i] == 0 && right[i] == 0) {
+					return 0;
+				} else if (left[i] != 0 && right[i] == 0) {
+					i = left[i];
+				} else if (left[i] == 0 && right[i] != 0) {
+					i = right[i];
+				} else {
+					if (priority[left[i]] >= priority[right[i]]) {
+						i = rightRotate(i);
+						right[i] = remove(right[i], num);
+					} else {
+						i = leftRotate(i);
+						left[i] = remove(left[i], num);
+					}
+				}
+			}
+		}
+		up(i);
+		return i;
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			head = remove(head, num);
+		}
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(priority, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1, op, x; i <= n; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				out.println(rank(x));
+			} else if (op == 4) {
+				out.println(index(x));
+			} else if (op == 5) {
+				out.println(pre(x));
+			} else {
+				out.println(post(x));
+			}
+		}
+		clear();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class151/Code02_Treap2.java b/src/class151/Code02_Treap2.java
new file mode 100644
index 000000000..12b5a4145
--- /dev/null
+++ b/src/class151/Code02_Treap2.java
@@ -0,0 +1,212 @@
+package class151;
+
+// Treap树的实现(C++版)
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <algorithm>
+//#include <cstring>
+//#include <random>
+//#include <climits>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//
+//int cnt = 0;
+//int head = 0;
+//int key[MAXN];
+//int key_count[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//}
+//
+//int leftRotate(int i) {
+//    int r = rs[i];
+//    rs[i] = ls[r];
+//    ls[r] = i;
+//    up(i);
+//    up(r);
+//    return r;
+//}
+//
+//int rightRotate(int i) {
+//    int l = ls[i];
+//    ls[i] = rs[l];
+//    rs[l] = i;
+//    up(i);
+//    up(l);
+//    return l;
+//}
+//
+//int add(int i, int num) {
+//    if (i == 0) {
+//        key[++cnt] = num;
+//        key_count[cnt] = size[cnt] = 1;
+//        priority[cnt] = static_cast<double>(rand()) / RAND_MAX;
+//        return cnt;
+//    }
+//    if (key[i] == num) {
+//        key_count[i]++;
+//    } else if (key[i] > num) {
+//        ls[i] = add(ls[i], num);
+//    } else {
+//        rs[i] = add(rs[i], num);
+//    }
+//    up(i);
+//    if (ls[i] != 0 && priority[ls[i]] > priority[i]) {
+//        return rightRotate(i);
+//    }
+//    if (rs[i] != 0 && priority[rs[i]] > priority[i]) {
+//        return leftRotate(i);
+//    }
+//    return i;
+//}
+//
+//void add(int num) {
+//    head = add(head, num);
+//}
+//
+//int small(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return small(ls[i], num);
+//    } else {
+//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return small(head, num) + 1;
+//}
+//
+//int getIndex(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return getIndex(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return getIndex(rs[i], x - size[ls[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int getIndex(int x) {
+//    return getIndex(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//int remove(int i, int num) {
+//    if (key[i] < num) {
+//        rs[i] = remove(rs[i], num);
+//    } else if (key[i] > num) {
+//        ls[i] = remove(ls[i], num);
+//    } else {
+//        if (key_count[i] > 1) {
+//            key_count[i]--;
+//        } else {
+//            if (ls[i] == 0 && rs[i] == 0) {
+//                return 0;
+//            } else if (ls[i] != 0 && rs[i] == 0) {
+//                i = ls[i];
+//            } else if (ls[i] == 0 && rs[i] != 0) {
+//                i = rs[i];
+//            } else {
+//                if (priority[ls[i]] >= priority[rs[i]]) {
+//                    i = rightRotate(i);
+//                    rs[i] = remove(rs[i], num);
+//                } else {
+//                    i = leftRotate(i);
+//                    ls[i] = remove(ls[i], num);
+//                }
+//            }
+//        }
+//    }
+//    up(i);
+//    return i;
+//}
+//
+//void remove(int num) {
+//    if (getRank(num) != getRank(num + 1)) {
+//        head = remove(head, num);
+//    }
+//}
+//
+//void clear() {
+//    fill(key + 1, key + cnt + 1, 0);
+//    fill(key_count + 1, key_count + cnt + 1, 0);
+//    fill(ls + 1, ls + cnt + 1, 0);
+//    fill(rs + 1, rs + cnt + 1, 0);
+//    fill(size + 1, size + cnt + 1, 0);
+//    fill(priority + 1, priority + cnt + 1, 0);
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    int n;
+//    cin >> n;
+//    for (int i = 1, op, x; i <= n; i++) {
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << endl;
+//        } else if (op == 4) {
+//            cout << getIndex(x) << endl;
+//        } else if (op == 5) {
+//            cout << pre(x) << endl;
+//        } else {
+//            cout << post(x) << endl;
+//        }
+//    }
+//    clear();
+//    return 0;
+//}
\ No newline at end of file

From 33a8e901902986a33b158bd61a80bb15ec593b5f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 13:01:24 +0800
Subject: [PATCH 0097/1712] modify code

---
 src/class151/{Code06_Periodni.java => Code05_Periodni.java}     | 2 +-
 .../{Code05_RemovingBlocks.java => Code06_RemovingBlocks.java}  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class151/{Code06_Periodni.java => Code05_Periodni.java} (99%)
 rename src/class151/{Code05_RemovingBlocks.java => Code06_RemovingBlocks.java} (97%)

diff --git a/src/class151/Code06_Periodni.java b/src/class151/Code05_Periodni.java
similarity index 99%
rename from src/class151/Code06_Periodni.java
rename to src/class151/Code05_Periodni.java
index 8a86e64d5..c78496fb3 100644
--- a/src/class151/Code06_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_Periodni {
+public class Code05_Periodni {
 
 	public static int MOD = 1000000007;
 
diff --git a/src/class151/Code05_RemovingBlocks.java b/src/class151/Code06_RemovingBlocks.java
similarity index 97%
rename from src/class151/Code05_RemovingBlocks.java
rename to src/class151/Code06_RemovingBlocks.java
index 14cdb3033..c0664600a 100644
--- a/src/class151/Code05_RemovingBlocks.java
+++ b/src/class151/Code06_RemovingBlocks.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_RemovingBlocks {
+public class Code06_RemovingBlocks {
 
 	public static int MOD = 1000000007;
 

From 7d52807c7644b00590ab79d4bf802fd184512102 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 13:09:41 +0800
Subject: [PATCH 0098/1712] modify code

---
 src/class151/Code06_RemovingBlocks.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class151/Code06_RemovingBlocks.java b/src/class151/Code06_RemovingBlocks.java
index c0664600a..eb2ac681b 100644
--- a/src/class151/Code06_RemovingBlocks.java
+++ b/src/class151/Code06_RemovingBlocks.java
@@ -1,6 +1,6 @@
 package class151;
 
-// 消除砖头
+// 砖头消除
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc028_b
 // 测试链接 : https://atcoder.jp/contests/agc028/tasks/agc028_b
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From e1ed5fc5577f1705f84c8935b445b9ddea1b5075 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 14:58:14 +0800
Subject: [PATCH 0099/1712] modify code

---
 src/class151/Code01_DescartesTree1.java  |  8 +++++++-
 src/class151/Code01_DescartesTree2.java  |  6 ++++++
 src/class151/Code03_TreeOrder.java       |  6 +++++-
 src/class151/Code04_CountingProblem.java |  7 +++++++
 src/class151/Code05_Periodni.java        |  7 +++++++
 src/class151/Code06_RemovingBlocks.java  | 10 +++++++++-
 6 files changed, 41 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code01_DescartesTree1.java b/src/class151/Code01_DescartesTree1.java
index 422f22d80..ebf4e49e3 100644
--- a/src/class151/Code01_DescartesTree1.java
+++ b/src/class151/Code01_DescartesTree1.java
@@ -1,6 +1,12 @@
 package class151;
 
 // 笛卡尔树模版(java版)
+// 给定一个长度为n的数组arr，下标从1开始
+// 构建一棵二叉树，下标按照搜索二叉树组织，值按照小根堆组织
+// 建好树的过程要求时间复杂度O(n)
+// 建好树之后，为了验证
+// 打印，i * (left[i] + 1)，所有信息异或起来的值
+// 打印，i * (right[i] + 1)，所有信息异或起来的值
 // 测试链接 : https://www.luogu.com.cn/problem/P5854
 // 如下实现是正确的，但java的版本无法通过所有测试用例
 // 这是洛谷平台没有照顾各种语言的实现所导致的
@@ -18,7 +24,7 @@
 public class Code01_DescartesTree1 {
 
 	public static int MAXN = 10000001;
-	
+
 	public static int[] arr = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
diff --git a/src/class151/Code01_DescartesTree2.java b/src/class151/Code01_DescartesTree2.java
index c338c8699..6e65a0fad 100644
--- a/src/class151/Code01_DescartesTree2.java
+++ b/src/class151/Code01_DescartesTree2.java
@@ -1,6 +1,12 @@
 package class151;
 
 // 笛卡尔树模版(C++版)
+// 给定一个长度为n的数组arr，下标从1开始
+// 构建一棵二叉树，下标按照搜索二叉树组织，值按照小根堆组织
+// 建好树的过程要求时间复杂度O(n)
+// 建好树之后，为了验证
+// 打印，i * (left[i] + 1)，所有信息异或起来的值
+// 打印，i * (right[i] + 1)，所有信息异或起来的值
 // 测试链接 : https://www.luogu.com.cn/problem/P5854
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class151/Code03_TreeOrder.java b/src/class151/Code03_TreeOrder.java
index ee972a72e..82775039b 100644
--- a/src/class151/Code03_TreeOrder.java
+++ b/src/class151/Code03_TreeOrder.java
@@ -1,6 +1,10 @@
 package class151;
 
 // 树的序
+// 给定一个长度为n的数组arr，表示依次插入数值，会形成一棵搜索二叉树
+// 也许同样的一个序列，依次插入数组后，也能形成同样形态的搜索二叉树
+// 请返回字典序尽量小的结果
+// 1 <= n <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P1377
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,7 +18,7 @@
 public class Code03_TreeOrder {
 
 	public static int MAXN = 100001;
-	
+
 	public static int[] arr = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index 38be4ca4d..258fd1f48 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -1,6 +1,13 @@
 package class151;
 
 // 序列计数
+// 有一个概念叫，最左端最大值位置，表示一段范围上
+// 如果最大值有一个，那么最大值所在的位置，就是最左端最大值位置
+// 如果最大值有多个，最左的那个所在的位置，就是最左端最大值位置
+// 给定一个长度为n的数组A，那么必然存在等长的数组B
+// 两者在任意范围上，最左端最大值位置是相同的，不仅存在数组B，而且是无限多的
+// 现在要求，数组B中的每个值都在[1,m]范围，返回有多少个这样的数组，答案对 1000000007 取模
+// 2 <= n, m <= 2 * 10^5    1 <= A[i] <= m    n * m <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1748E
 // 测试链接 : https://codeforces.com/problemset/problem/1748/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index c78496fb3..c064fabe1 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -1,6 +1,13 @@
 package class151;
 
 // 表格填数
+// 给定一个长度为n的数组arr，arr[i]表示i位置上方的正方形格子数量
+// 那么从1位置到n位置，每个位置就是一个直方图，所有的直方图认为拼在一起
+// 在这片区域中，有k个相同的数字要放进去，不能有任意两个数在同一行或者同一列
+// 注意在直方图中，如果同一行中间断开了，让两个数字无法在这一行联通，则不算违规
+// 返回填入数字的方法数，答案对 1000000007 取模
+// 1 <= n，k <= 500
+// 0 <= arr[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P6453
 // 因为本题给定的可用空间很少，所以数组为int类型，不用long类型
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class151/Code06_RemovingBlocks.java b/src/class151/Code06_RemovingBlocks.java
index eb2ac681b..aedf04cc5 100644
--- a/src/class151/Code06_RemovingBlocks.java
+++ b/src/class151/Code06_RemovingBlocks.java
@@ -1,6 +1,14 @@
 package class151;
 
-// 砖头消除
+// 砖块消除
+// 给定一个长度为n的数组arr，arr[i]为i号砖块的重量
+// 选择一个没有消除的砖块进行消除，收益为消除砖块联通区域的重量之和，比如arr = {3,5,2,1}
+// 如果先消除5，那么获得3+5+2+1的收益，arr = {3,X,2,1}
+// 如果再消除1，那么获得2+1的收益，arr = {3,X,2,X}
+// 如果再消除2，那么获得2的收益，arr = {3,X,X,X}
+// 如果再消除3，那么获得3的收益，arr = {X,X,X,X}
+// 很明显一共有n!种消除方案，返回所有消除方案的收益之和，答案对 1000000007 取模
+// 1 <= n <= 10^5 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc028_b
 // 测试链接 : https://atcoder.jp/contests/agc028/tasks/agc028_b
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From 10542ca2054503f6fa3cff84f83dcd8d3b679704 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 15:06:01 +0800
Subject: [PATCH 0100/1712] modify code

---
 src/class151/Code06_RemovingBlocks.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class151/Code06_RemovingBlocks.java b/src/class151/Code06_RemovingBlocks.java
index aedf04cc5..7b6b3aa77 100644
--- a/src/class151/Code06_RemovingBlocks.java
+++ b/src/class151/Code06_RemovingBlocks.java
@@ -7,7 +7,7 @@
 // 如果再消除1，那么获得2+1的收益，arr = {3,X,2,X}
 // 如果再消除2，那么获得2的收益，arr = {3,X,X,X}
 // 如果再消除3，那么获得3的收益，arr = {X,X,X,X}
-// 很明显一共有n!种消除方案，返回所有消除方案的收益之和，答案对 1000000007 取模
+// 一共有n!种消除方案，返回所有消除方案的收益之和，答案对 1000000007 取模
 // 1 <= n <= 10^5 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc028_b
 // 测试链接 : https://atcoder.jp/contests/agc028/tasks/agc028_b

From b77cc91569129e9f86cdd4050ce833df08d75961 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 15:07:52 +0800
Subject: [PATCH 0101/1712] modify code

---
 src/class151/Code05_Periodni.java       | 3 +--
 src/class151/Code06_RemovingBlocks.java | 2 +-
 2 files changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index c064fabe1..022a90523 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -6,8 +6,7 @@
 // 在这片区域中，有k个相同的数字要放进去，不能有任意两个数在同一行或者同一列
 // 注意在直方图中，如果同一行中间断开了，让两个数字无法在这一行联通，则不算违规
 // 返回填入数字的方法数，答案对 1000000007 取模
-// 1 <= n，k <= 500
-// 0 <= arr[i] <= 10^6
+// 1 <= n，k <= 500    0 <= arr[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P6453
 // 因为本题给定的可用空间很少，所以数组为int类型，不用long类型
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class151/Code06_RemovingBlocks.java b/src/class151/Code06_RemovingBlocks.java
index 7b6b3aa77..b5740af1c 100644
--- a/src/class151/Code06_RemovingBlocks.java
+++ b/src/class151/Code06_RemovingBlocks.java
@@ -8,7 +8,7 @@
 // 如果再消除2，那么获得2的收益，arr = {3,X,X,X}
 // 如果再消除3，那么获得3的收益，arr = {X,X,X,X}
 // 一共有n!种消除方案，返回所有消除方案的收益之和，答案对 1000000007 取模
-// 1 <= n <= 10^5 1 <= arr[i] <= 10^9
+// 1 <= n <= 10^5    1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc028_b
 // 测试链接 : https://atcoder.jp/contests/agc028/tasks/agc028_b
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From 135b78f4233902f9656b2b7490a29eed1ccba57a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 15:22:08 +0800
Subject: [PATCH 0102/1712] modify code

---
 src/class151/Code01_DescartesTree1.java  | 4 ++--
 src/class151/Code01_DescartesTree2.java  | 4 ++--
 src/class151/Code04_CountingProblem.java | 2 +-
 src/class151/Code05_Periodni.java        | 2 +-
 4 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class151/Code01_DescartesTree1.java b/src/class151/Code01_DescartesTree1.java
index ebf4e49e3..4765f62a3 100644
--- a/src/class151/Code01_DescartesTree1.java
+++ b/src/class151/Code01_DescartesTree1.java
@@ -3,8 +3,8 @@
 // 笛卡尔树模版(java版)
 // 给定一个长度为n的数组arr，下标从1开始
 // 构建一棵二叉树，下标按照搜索二叉树组织，值按照小根堆组织
-// 建好树的过程要求时间复杂度O(n)
-// 建好树之后，为了验证
+// 建树的过程要求时间复杂度O(n)
+// 建树之后，为了验证
 // 打印，i * (left[i] + 1)，所有信息异或起来的值
 // 打印，i * (right[i] + 1)，所有信息异或起来的值
 // 测试链接 : https://www.luogu.com.cn/problem/P5854
diff --git a/src/class151/Code01_DescartesTree2.java b/src/class151/Code01_DescartesTree2.java
index 6e65a0fad..4183984c3 100644
--- a/src/class151/Code01_DescartesTree2.java
+++ b/src/class151/Code01_DescartesTree2.java
@@ -3,8 +3,8 @@
 // 笛卡尔树模版(C++版)
 // 给定一个长度为n的数组arr，下标从1开始
 // 构建一棵二叉树，下标按照搜索二叉树组织，值按照小根堆组织
-// 建好树的过程要求时间复杂度O(n)
-// 建好树之后，为了验证
+// 建树的过程要求时间复杂度O(n)
+// 建树之后，为了验证
 // 打印，i * (left[i] + 1)，所有信息异或起来的值
 // 打印，i * (right[i] + 1)，所有信息异或起来的值
 // 测试链接 : https://www.luogu.com.cn/problem/P5854
diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index 258fd1f48..35b014977 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -7,7 +7,7 @@
 // 给定一个长度为n的数组A，那么必然存在等长的数组B
 // 两者在任意范围上，最左端最大值位置是相同的，不仅存在数组B，而且是无限多的
 // 现在要求，数组B中的每个值都在[1,m]范围，返回有多少个这样的数组，答案对 1000000007 取模
-// 2 <= n, m <= 2 * 10^5    1 <= A[i] <= m    n * m <= 10^6
+// 2 <= n、m <= 2 * 10^5    1 <= A[i] <= m    n * m <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1748E
 // 测试链接 : https://codeforces.com/problemset/problem/1748/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 022a90523..2e901231e 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -6,7 +6,7 @@
 // 在这片区域中，有k个相同的数字要放进去，不能有任意两个数在同一行或者同一列
 // 注意在直方图中，如果同一行中间断开了，让两个数字无法在这一行联通，则不算违规
 // 返回填入数字的方法数，答案对 1000000007 取模
-// 1 <= n，k <= 500    0 <= arr[i] <= 10^6
+// 1 <= n、k <= 500    0 <= arr[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P6453
 // 因为本题给定的可用空间很少，所以数组为int类型，不用long类型
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From da6674e4c02dfbe936e8af4dbb198631cb6b4cbb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 16:09:05 +0800
Subject: [PATCH 0103/1712] modify code

---
 src/class151/Code05_Periodni.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 2e901231e..aee169a54 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -99,12 +99,12 @@ public static void dfs(int u, int fa) {
 			dfs(left[u], u);
 			dfs(right[u], u);
 			size[u] = size[left[u]] + size[right[u]] + 1;
-			for (int i = 0; i <= size[left[u]]; i++) {
-				for (int j = 0; j <= size[right[u]]; j++) {
+			for (int i = 0; i <= Math.min(size[left[u]], k); i++) {
+				for (int j = 0; j <= Math.min(size[right[u]], k - i); j++) {
 					tmp[u][i + j] = (int) (tmp[u][i + j] + (long) dp[left[u]][i] * dp[right[u]][j] % MOD) % MOD;
 				}
 			}
-			for (int i = 0; i <= size[u]; i++) {
+			for (int i = 0; i <= Math.min(size[u], k); i++) {
 				for (int j = 0; j <= i; j++) {
 					dp[u][i] = (int) (dp[u][i] + (long) tmp[u][j] * fac[i - j] % MOD * c(size[u] - j, i - j) % MOD
 							* c(arr[u] - arr[fa], i - j) % MOD) % MOD;

From 1b5479f5ddfb8f00cca36a0097ade8aa505335e6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Nov 2024 16:15:17 +0800
Subject: [PATCH 0104/1712] modify code

---
 src/class151/Code05_Periodni.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index aee169a54..5cad6f4b9 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -99,11 +99,13 @@ public static void dfs(int u, int fa) {
 			dfs(left[u], u);
 			dfs(right[u], u);
 			size[u] = size[left[u]] + size[right[u]] + 1;
+			// 所有dfs过程都算上，这一部分的总复杂度O(n^2)
 			for (int i = 0; i <= Math.min(size[left[u]], k); i++) {
 				for (int j = 0; j <= Math.min(size[right[u]], k - i); j++) {
 					tmp[u][i + j] = (int) (tmp[u][i + j] + (long) dp[left[u]][i] * dp[right[u]][j] % MOD) % MOD;
 				}
 			}
+			// 所有dfs过程都算上，这一部分的总复杂度O(min(n的3次方, n * k平方))
 			for (int i = 0; i <= Math.min(size[u], k); i++) {
 				for (int j = 0; j <= i; j++) {
 					dp[u][i] = (int) (dp[u][i] + (long) tmp[u][j] * fac[i - j] % MOD * c(size[u] - j, i - j) % MOD

From 39fa37bcc5a5e030e7f4207b5c17c0975c942cb3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 14 Nov 2024 17:35:39 +0800
Subject: [PATCH 0105/1712] modify code

---
 src/class151/Code01_DescartesTree1.java | 1 +
 src/class151/Code01_DescartesTree2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class151/Code01_DescartesTree1.java b/src/class151/Code01_DescartesTree1.java
index 4765f62a3..98d5e5d22 100644
--- a/src/class151/Code01_DescartesTree1.java
+++ b/src/class151/Code01_DescartesTree1.java
@@ -7,6 +7,7 @@
 // 建树之后，为了验证
 // 打印，i * (left[i] + 1)，所有信息异或起来的值
 // 打印，i * (right[i] + 1)，所有信息异或起来的值
+// 1 <= n <= 10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P5854
 // 如下实现是正确的，但java的版本无法通过所有测试用例
 // 这是洛谷平台没有照顾各种语言的实现所导致的
diff --git a/src/class151/Code01_DescartesTree2.java b/src/class151/Code01_DescartesTree2.java
index 4183984c3..d79a3c5ee 100644
--- a/src/class151/Code01_DescartesTree2.java
+++ b/src/class151/Code01_DescartesTree2.java
@@ -7,6 +7,7 @@
 // 建树之后，为了验证
 // 打印，i * (left[i] + 1)，所有信息异或起来的值
 // 打印，i * (right[i] + 1)，所有信息异或起来的值
+// 1 <= n <= 10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P5854
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 692169b08c91f2cb6789383a75ee3fd004651639 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 14 Nov 2024 17:58:58 +0800
Subject: [PATCH 0106/1712] modify code

---
 src/class151/Code04_CountingProblem.java | 4 ++--
 src/class151/Code05_Periodni.java        | 8 ++++----
 src/class151/Code06_RemovingBlocks.java  | 4 ++--
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index 35b014977..cec21b01d 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -4,8 +4,8 @@
 // 有一个概念叫，最左端最大值位置，表示一段范围上
 // 如果最大值有一个，那么最大值所在的位置，就是最左端最大值位置
 // 如果最大值有多个，最左的那个所在的位置，就是最左端最大值位置
-// 给定一个长度为n的数组A，那么必然存在等长的数组B
-// 两者在任意范围上，最左端最大值位置是相同的，不仅存在数组B，而且是无限多的
+// 给定一个长度为n的数组A，那么必然存在等长的数组B，当选择同样的子范围时
+// 两者在这段范围上，最左端最大值位置是相同的，不仅存在这样的数组B，而且数量无限多
 // 现在要求，数组B中的每个值都在[1,m]范围，返回有多少个这样的数组，答案对 1000000007 取模
 // 2 <= n、m <= 2 * 10^5    1 <= A[i] <= m    n * m <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1748E
diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 5cad6f4b9..998c5c563 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -2,10 +2,10 @@
 
 // 表格填数
 // 给定一个长度为n的数组arr，arr[i]表示i位置上方的正方形格子数量
-// 那么从1位置到n位置，每个位置就是一个直方图，所有的直方图认为拼在一起
-// 在这片区域中，有k个相同的数字要放进去，不能有任意两个数在同一行或者同一列
-// 注意在直方图中，如果同一行中间断开了，让两个数字无法在这一行联通，则不算违规
-// 返回填入数字的方法数，答案对 1000000007 取模
+// 那么从1位置到n位置，每个位置就是一个直方图，所有的直方图紧靠在一起
+// 在这片区域中，你要放入k个石头，不能有任意两个石头在同一行或者同一列
+// 注意在这片区域中，如果某一行中间断开了，使得两个石头无法在这一行连通，则不算违规
+// 返回填入石头的方法数，答案对 1000000007 取模
 // 1 <= n、k <= 500    0 <= arr[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P6453
 // 因为本题给定的可用空间很少，所以数组为int类型，不用long类型
diff --git a/src/class151/Code06_RemovingBlocks.java b/src/class151/Code06_RemovingBlocks.java
index b5740af1c..346fda77e 100644
--- a/src/class151/Code06_RemovingBlocks.java
+++ b/src/class151/Code06_RemovingBlocks.java
@@ -2,12 +2,12 @@
 
 // 砖块消除
 // 给定一个长度为n的数组arr，arr[i]为i号砖块的重量
-// 选择一个没有消除的砖块进行消除，收益为消除砖块联通区域的重量之和，比如arr = {3,5,2,1}
+// 选择一个没有消除的砖块进行消除，收益为被消除砖块联通区域的重量之和，比如arr = {3,5,2,1}
 // 如果先消除5，那么获得3+5+2+1的收益，arr = {3,X,2,1}
 // 如果再消除1，那么获得2+1的收益，arr = {3,X,2,X}
 // 如果再消除2，那么获得2的收益，arr = {3,X,X,X}
 // 如果再消除3，那么获得3的收益，arr = {X,X,X,X}
-// 一共有n!种消除方案，返回所有消除方案的收益之和，答案对 1000000007 取模
+// 一共有n!种消除方案，返回所有消除方案的收益总和，答案对 1000000007 取模
 // 1 <= n <= 10^5    1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc028_b
 // 测试链接 : https://atcoder.jp/contests/agc028/tasks/agc028_b

From af6fab1acdfe076e3db0ddab1ef25191899c4b44 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 14 Nov 2024 18:00:44 +0800
Subject: [PATCH 0107/1712] modify code

---
 src/class151/Code05_Periodni.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 998c5c563..dbc98b42e 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -3,9 +3,9 @@
 // 表格填数
 // 给定一个长度为n的数组arr，arr[i]表示i位置上方的正方形格子数量
 // 那么从1位置到n位置，每个位置就是一个直方图，所有的直方图紧靠在一起
-// 在这片区域中，你要放入k个石头，不能有任意两个石头在同一行或者同一列
-// 注意在这片区域中，如果某一行中间断开了，使得两个石头无法在这一行连通，则不算违规
-// 返回填入石头的方法数，答案对 1000000007 取模
+// 在这片区域中，你要放入k个相同数字，不能有任意两个数字在同一行或者同一列
+// 注意在这片区域中，如果某一行中间断开了，使得两个数字无法在这一行连通，则不算违规
+// 返回填入数字的方法数，答案对 1000000007 取模
 // 1 <= n、k <= 500    0 <= arr[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P6453
 // 因为本题给定的可用空间很少，所以数组为int类型，不用long类型

From cec2eefeb62588c7ecbb7d3fd3f3cfab827ed077 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 14 Nov 2024 22:06:38 +0800
Subject: [PATCH 0108/1712] modify code

---
 src/class151/Code03_TreeOrder.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class151/Code03_TreeOrder.java b/src/class151/Code03_TreeOrder.java
index 82775039b..eb1e7a5ef 100644
--- a/src/class151/Code03_TreeOrder.java
+++ b/src/class151/Code03_TreeOrder.java
@@ -1,8 +1,8 @@
 package class151;
 
 // 树的序
-// 给定一个长度为n的数组arr，表示依次插入数值，会形成一棵搜索二叉树
-// 也许同样的一个序列，依次插入数组后，也能形成同样形态的搜索二叉树
+// 给定一个长度为n的数组arr，表示依次插入数字，会形成一棵搜索二叉树
+// 也许同样的一个序列，依次插入数字后，也能形成同样形态的搜索二叉树
 // 请返回字典序尽量小的结果
 // 1 <= n <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P1377

From 516d2b45585e0c53f77d0253c34fa4678c602733 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 17:16:11 +0800
Subject: [PATCH 0109/1712] modify code

---
 src/class151/Code05_Periodni.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index dbc98b42e..be8696fec 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -108,8 +108,8 @@ public static void dfs(int u, int fa) {
 			// 所有dfs过程都算上，这一部分的总复杂度O(min(n的3次方, n * k平方))
 			for (int i = 0; i <= Math.min(size[u], k); i++) {
 				for (int j = 0; j <= i; j++) {
-					dp[u][i] = (int) (dp[u][i] + (long) tmp[u][j] * fac[i - j] % MOD * c(size[u] - j, i - j) % MOD
-							* c(arr[u] - arr[fa], i - j) % MOD) % MOD;
+					dp[u][i] = (int) (dp[u][i] + (long) c(size[u] - j, i - j) * c(arr[u] - arr[fa], i - j) % MOD
+							* fac[i - j] % MOD * tmp[u][j] % MOD) % MOD;
 				}
 			}
 		}
@@ -139,4 +139,4 @@ public static void main(String[] args) throws IOException {
 		br.close();
 	}
 
-}
+}
\ No newline at end of file

From c6c66dd5cdd62653ebc82ef036cef204494776c6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 18:01:05 +0800
Subject: [PATCH 0110/1712] modify code

---
 src/class151/Code04_CountingProblem.java | 43 +++++++++++++++---------
 1 file changed, 27 insertions(+), 16 deletions(-)

diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index cec21b01d..6fec1b727 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -26,14 +26,19 @@ public class Code04_CountingProblem {
 
 	public static int MAXN = 1000001;
 
+	// 所有数字
 	public static int[] arr = new int[MAXN];
 
+	// 笛卡尔树需要
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
 	public static int[] stack = new int[MAXN];
 
+	// tmp是动态规划的临时结果
+	public static long[] tmp = new long[MAXN];
+
 	public static int n, m;
 
 	public static void build() {
@@ -53,24 +58,21 @@ public static void build() {
 		}
 	}
 
-	public static void dfs(int i, long[][] dp) {
-		for (int j = 1; j <= m; j++) {
-			dp[i][j] = 1;
+	public static void dfs(int i, int[][] dp) {
+		if (i == 0) {
+			return;
 		}
-		if (left[i] != 0) {
-			dfs(left[i], dp);
-			for (int j = 1; j <= m; j++) {
-				dp[i][j] = dp[i][j] * dp[left[i]][j - 1] % MOD;
-			}
+		dfs(left[i], dp);
+		dfs(right[i], dp);
+		Arrays.fill(tmp, 1, m + 1, 1);
+		for (int j = 1; j <= m; j++) {
+			tmp[j] = tmp[j] * dp[left[i]][j - 1] % MOD;
 		}
-		if (right[i] != 0) {
-			dfs(right[i], dp);
-			for (int j = 1; j <= m; j++) {
-				dp[i][j] = dp[i][j] * dp[right[i]][j] % MOD;
-			}
+		for (int j = 1; j <= m; j++) {
+			tmp[j] = tmp[j] * dp[right[i]][j] % MOD;
 		}
-		for (int j = 2; j <= m; j++) {
-			dp[i][j] = (dp[i][j] + dp[i][j - 1]) % MOD;
+		for (int j = 1; j <= m; j++) {
+			dp[i][j] = (int) ((dp[i][j - 1] + tmp[j]) % MOD);
 		}
 	}
 
@@ -81,7 +83,16 @@ public static void clear() {
 
 	public static long compute() {
 		build();
-		long[][] dp = new long[n + 1][m + 1];
+		// 虽然n * m <= 10^6，但是n和m，单独都有可能到达10^6规模
+		// 如果提前准备固定大小的动态规划表，那就只能准备10^6 * 10^6规模的表了
+		// 这是不可能的，空间根本接受不了
+		// 所以根据此时具体的n和m的大小，临时申请动态规划表
+		int[][] dp = new int[n + 1][m + 1];
+		// 没有节点时，不管要求节点值是什么，都默认有1种形态
+		// 因为没有节点时，根本不影响任何决策
+		for (int j = 0; j <= m; j++) {
+			dp[0][j] = 1;
+		}
 		dfs(stack[1], dp);
 		clear();
 		return dp[stack[1]][m];

From fe7e49fe3697c757a146a58a62a75d291c055199 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 18:02:45 +0800
Subject: [PATCH 0111/1712] modify code

---
 src/class151/Code04_CountingProblem.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index 6fec1b727..c7b7edc8a 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -86,11 +86,11 @@ public static long compute() {
 		// 虽然n * m <= 10^6，但是n和m，单独都有可能到达10^6规模
 		// 如果提前准备固定大小的动态规划表，那就只能准备10^6 * 10^6规模的表了
 		// 这是不可能的，空间根本接受不了
-		// 所以根据此时具体的n和m的大小，临时申请动态规划表
+		// 所以根据此时具体的n和m的大小，临时申请动态规划表，总大小不超过10^6
 		int[][] dp = new int[n + 1][m + 1];
-		// 没有节点时，不管要求节点值是什么，都默认有1种形态
-		// 因为没有节点时，根本不影响任何决策
 		for (int j = 0; j <= m; j++) {
+			// 没有节点时，不管要求节点值是什么，都默认有1种形态
+			// 因为没有节点时，根本不影响任何决策
 			dp[0][j] = 1;
 		}
 		dfs(stack[1], dp);

From d27864fa82b27147837e365954010a01b98b9e48 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 18:06:47 +0800
Subject: [PATCH 0112/1712] modify code

---
 src/class151/Code05_Periodni.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index be8696fec..bb78506a8 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -45,8 +45,10 @@ public class Code05_Periodni {
 	// dfs需要
 	public static int[] size = new int[MAXN];
 
+	// dp是动态规划表
 	public static int[][] dp = new int[MAXN][MAXN];
 
+	// tmp是动态规划的临时结果
 	public static int[][] tmp = new int[MAXN][MAXN];
 
 	public static int n, k;

From 0ae21f713c73f03f2963ae5b0d8aa113a1ce27ab Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 20:02:04 +0800
Subject: [PATCH 0113/1712] modify code

---
 src/class151/Code04_CountingProblem.java |  6 +---
 src/class151/Code05_Periodni.java        | 36 ++++++++++++------------
 2 files changed, 19 insertions(+), 23 deletions(-)

diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index c7b7edc8a..d1c2ba048 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -64,12 +64,8 @@ public static void dfs(int i, int[][] dp) {
 		}
 		dfs(left[i], dp);
 		dfs(right[i], dp);
-		Arrays.fill(tmp, 1, m + 1, 1);
 		for (int j = 1; j <= m; j++) {
-			tmp[j] = tmp[j] * dp[left[i]][j - 1] % MOD;
-		}
-		for (int j = 1; j <= m; j++) {
-			tmp[j] = tmp[j] * dp[right[i]][j] % MOD;
+			tmp[j] = (long) dp[left[i]][j - 1] * dp[right[i]][j] % MOD;
 		}
 		for (int j = 1; j <= m; j++) {
 			dp[i][j] = (int) ((dp[i][j - 1] + tmp[j]) % MOD);
diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index bb78506a8..2f8e6963a 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -94,31 +94,31 @@ public static void build() {
 		}
 	}
 
-	public static void dfs(int u, int fa) {
-		if (u == 0) {
-			dp[u][0] = 1;
-		} else {
-			dfs(left[u], u);
-			dfs(right[u], u);
-			size[u] = size[left[u]] + size[right[u]] + 1;
-			// 所有dfs过程都算上，这一部分的总复杂度O(n^2)
-			for (int i = 0; i <= Math.min(size[left[u]], k); i++) {
-				for (int j = 0; j <= Math.min(size[right[u]], k - i); j++) {
-					tmp[u][i + j] = (int) (tmp[u][i + j] + (long) dp[left[u]][i] * dp[right[u]][j] % MOD) % MOD;
-				}
+	public static void dfs(int i, int fa) {
+		if (i == 0) {
+			return;
+		}
+		dfs(left[i], i);
+		dfs(right[i], i);
+		size[i] = size[left[i]] + size[right[i]] + 1;
+		// 所有dfs过程都算上，这一部分的总复杂度O(n^2)
+		for (int l = 0; l <= Math.min(size[left[i]], k); l++) {
+			for (int r = 0; r <= Math.min(size[right[i]], k - l); r++) {
+				tmp[i][l + r] = (int) (tmp[i][l + r] + (long) dp[left[i]][l] * dp[right[i]][r] % MOD) % MOD;
 			}
-			// 所有dfs过程都算上，这一部分的总复杂度O(min(n的3次方, n * k平方))
-			for (int i = 0; i <= Math.min(size[u], k); i++) {
-				for (int j = 0; j <= i; j++) {
-					dp[u][i] = (int) (dp[u][i] + (long) c(size[u] - j, i - j) * c(arr[u] - arr[fa], i - j) % MOD
-							* fac[i - j] % MOD * tmp[u][j] % MOD) % MOD;
-				}
+		}
+		// 所有dfs过程都算上，这一部分的总复杂度O(min(n的3次方, n * k平方))
+		for (int a = 0; a <= Math.min(size[i], k); a++) {
+			for (int b = 0; b <= a; b++) {
+				dp[i][a] = (int) (dp[i][a] + (long) c(size[i] - b, a - b) * c(arr[i] - arr[fa], a - b) % MOD
+						* fac[a - b] % MOD * tmp[i][b] % MOD) % MOD;
 			}
 		}
 	}
 
 	public static int compute() {
 		build();
+		dp[0][0] = 1;
 		dfs(stack[1], 0);
 		return dp[stack[1]][k];
 	}

From 54d3cdebdbadea0e8ff151593f28b75c7482ebb8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 20:03:22 +0800
Subject: [PATCH 0114/1712] modify code

---
 src/class151/Code04_CountingProblem.java | 12 ++++++------
 src/class151/Code05_Periodni.java        | 24 ++++++++++++------------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index d1c2ba048..405780b53 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -58,17 +58,17 @@ public static void build() {
 		}
 	}
 
-	public static void dfs(int i, int[][] dp) {
-		if (i == 0) {
+	public static void dfs(int u, int[][] dp) {
+		if (u == 0) {
 			return;
 		}
-		dfs(left[i], dp);
-		dfs(right[i], dp);
+		dfs(left[u], dp);
+		dfs(right[u], dp);
 		for (int j = 1; j <= m; j++) {
-			tmp[j] = (long) dp[left[i]][j - 1] * dp[right[i]][j] % MOD;
+			tmp[j] = (long) dp[left[u]][j - 1] * dp[right[u]][j] % MOD;
 		}
 		for (int j = 1; j <= m; j++) {
-			dp[i][j] = (int) ((dp[i][j - 1] + tmp[j]) % MOD);
+			dp[u][j] = (int) ((dp[u][j - 1] + tmp[j]) % MOD);
 		}
 	}
 
diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 2f8e6963a..5e2246524 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -94,24 +94,24 @@ public static void build() {
 		}
 	}
 
-	public static void dfs(int i, int fa) {
-		if (i == 0) {
+	public static void dfs(int u, int fa) {
+		if (u == 0) {
 			return;
 		}
-		dfs(left[i], i);
-		dfs(right[i], i);
-		size[i] = size[left[i]] + size[right[i]] + 1;
+		dfs(left[u], u);
+		dfs(right[u], u);
+		size[u] = size[left[u]] + size[right[u]] + 1;
 		// 所有dfs过程都算上，这一部分的总复杂度O(n^2)
-		for (int l = 0; l <= Math.min(size[left[i]], k); l++) {
-			for (int r = 0; r <= Math.min(size[right[i]], k - l); r++) {
-				tmp[i][l + r] = (int) (tmp[i][l + r] + (long) dp[left[i]][l] * dp[right[i]][r] % MOD) % MOD;
+		for (int i = 0; i <= Math.min(size[left[u]], k); i++) {
+			for (int j = 0; j <= Math.min(size[right[u]], k - i); j++) {
+				tmp[u][i + j] = (int) (tmp[u][i + j] + (long) dp[left[u]][i] * dp[right[u]][j] % MOD) % MOD;
 			}
 		}
 		// 所有dfs过程都算上，这一部分的总复杂度O(min(n的3次方, n * k平方))
-		for (int a = 0; a <= Math.min(size[i], k); a++) {
-			for (int b = 0; b <= a; b++) {
-				dp[i][a] = (int) (dp[i][a] + (long) c(size[i] - b, a - b) * c(arr[i] - arr[fa], a - b) % MOD
-						* fac[a - b] % MOD * tmp[i][b] % MOD) % MOD;
+		for (int i = 0; i <= Math.min(size[u], k); i++) {
+			for (int j = 0; j <= i; j++) {
+				dp[u][i] = (int) (dp[u][i] + (long) c(size[u] - j, i - j) * c(arr[u] - arr[fa], i - j) % MOD
+						* fac[i - j] % MOD * tmp[u][j] % MOD) % MOD;
 			}
 		}
 	}

From 96f24463fbf7f492290e8b800cfc2f61c71146c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 20:15:12 +0800
Subject: [PATCH 0115/1712] modify code

---
 src/class151/Code04_CountingProblem.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code04_CountingProblem.java b/src/class151/Code04_CountingProblem.java
index 405780b53..60fbc5238 100644
--- a/src/class151/Code04_CountingProblem.java
+++ b/src/class151/Code04_CountingProblem.java
@@ -79,9 +79,8 @@ public static void clear() {
 
 	public static long compute() {
 		build();
-		// 虽然n * m <= 10^6，但是n和m，单独都有可能到达10^6规模
-		// 如果提前准备固定大小的动态规划表，那就只能准备10^6 * 10^6规模的表了
-		// 这是不可能的，空间根本接受不了
+		// 虽然n * m <= 10^6，但是n和m，单独都是2 * 10^5规模
+		// 所以提前准备固定大小的表是不可能的，空间根本接受不了
 		// 所以根据此时具体的n和m的大小，临时申请动态规划表，总大小不超过10^6
 		int[][] dp = new int[n + 1][m + 1];
 		for (int j = 0; j <= m; j++) {

From d4025f53165c11916a0763e515d515c62e3fa97f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 20:31:03 +0800
Subject: [PATCH 0116/1712] modify code

---
 src/class151/Code05_Periodni.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 5e2246524..5df2cc432 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -66,7 +66,7 @@ public static int power(long x, long p) {
 	}
 
 	public static int c(int n, int k) {
-		return k > n ? 0 : (int) ((long) fac[n] * inv[k] % MOD * inv[n - k] % MOD);
+		return n < k ? 0 : (int) ((long) fac[n] * inv[k] % MOD * inv[n - k] % MOD);
 	}
 
 	public static void build() {

From c26fb822ee9cd6d9ab0ff1b5c213c48855abbf88 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 23:25:40 +0800
Subject: [PATCH 0117/1712] modify code

---
 src/class151/Code05_Periodni.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 5df2cc432..641a8a966 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -102,16 +102,16 @@ public static void dfs(int u, int fa) {
 		dfs(right[u], u);
 		size[u] = size[left[u]] + size[right[u]] + 1;
 		// 所有dfs过程都算上，这一部分的总复杂度O(n^2)
-		for (int i = 0; i <= Math.min(size[left[u]], k); i++) {
-			for (int j = 0; j <= Math.min(size[right[u]], k - i); j++) {
-				tmp[u][i + j] = (int) (tmp[u][i + j] + (long) dp[left[u]][i] * dp[right[u]][j] % MOD) % MOD;
+		for (int l = 0; l <= Math.min(size[left[u]], k); l++) {
+			for (int r = 0; r <= Math.min(size[right[u]], k - l); r++) {
+				tmp[u][l + r] = (int) (tmp[u][l + r] + (long) dp[left[u]][l] * dp[right[u]][r] % MOD) % MOD;
 			}
 		}
 		// 所有dfs过程都算上，这一部分的总复杂度O(min(n的3次方, n * k平方))
 		for (int i = 0; i <= Math.min(size[u], k); i++) {
-			for (int j = 0; j <= i; j++) {
-				dp[u][i] = (int) (dp[u][i] + (long) c(size[u] - j, i - j) * c(arr[u] - arr[fa], i - j) % MOD
-						* fac[i - j] % MOD * tmp[u][j] % MOD) % MOD;
+			for (int p = 0; p <= i; p++) {
+				dp[u][i] = (int) (dp[u][i] + (long) c(size[u] - p, i - p) * c(arr[u] - arr[fa], i - p) % MOD
+						* fac[i - p] % MOD * tmp[u][p] % MOD) % MOD;
 			}
 		}
 	}

From d55fbbe8830a5b5d43d32dafeee65709a6005063 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Nov 2024 23:43:13 +0800
Subject: [PATCH 0118/1712] modify code

---
 src/class151/Code05_Periodni.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/class151/Code05_Periodni.java b/src/class151/Code05_Periodni.java
index 641a8a966..31cab91f3 100644
--- a/src/class151/Code05_Periodni.java
+++ b/src/class151/Code05_Periodni.java
@@ -17,6 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
+import java.util.Arrays;
 
 public class Code05_Periodni {
 
@@ -49,7 +50,7 @@ public class Code05_Periodni {
 	public static int[][] dp = new int[MAXN][MAXN];
 
 	// tmp是动态规划的临时结果
-	public static int[][] tmp = new int[MAXN][MAXN];
+	public static int[] tmp = new int[MAXN];
 
 	public static int n, k;
 
@@ -101,17 +102,18 @@ public static void dfs(int u, int fa) {
 		dfs(left[u], u);
 		dfs(right[u], u);
 		size[u] = size[left[u]] + size[right[u]] + 1;
+		Arrays.fill(tmp, 0, k + 1, 0);
 		// 所有dfs过程都算上，这一部分的总复杂度O(n^2)
 		for (int l = 0; l <= Math.min(size[left[u]], k); l++) {
 			for (int r = 0; r <= Math.min(size[right[u]], k - l); r++) {
-				tmp[u][l + r] = (int) (tmp[u][l + r] + (long) dp[left[u]][l] * dp[right[u]][r] % MOD) % MOD;
+				tmp[l + r] = (int) (tmp[l + r] + (long) dp[left[u]][l] * dp[right[u]][r] % MOD) % MOD;
 			}
 		}
 		// 所有dfs过程都算上，这一部分的总复杂度O(min(n的3次方, n * k平方))
 		for (int i = 0; i <= Math.min(size[u], k); i++) {
 			for (int p = 0; p <= i; p++) {
 				dp[u][i] = (int) (dp[u][i] + (long) c(size[u] - p, i - p) * c(arr[u] - arr[fa], i - p) % MOD
-						* fac[i - p] % MOD * tmp[u][p] % MOD) % MOD;
+						* fac[i - p] % MOD * tmp[p] % MOD) % MOD;
 			}
 		}
 	}

From 9e0c41eab73de8b2d18ce04189cd6b53b8f4856d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 16 Nov 2024 01:38:08 +0800
Subject: [PATCH 0119/1712] modify code

---
 ...6\240\221\343\200\201Treap\346\240\221.pptx" | Bin 0 -> 54297 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243151\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2304-\347\254\233\345\215\241\345\260\224\346\240\221\343\200\201Treap\346\240\221.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243151\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2304-\347\254\233\345\215\241\345\260\224\346\240\221\343\200\201Treap\346\240\221.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243151\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2304-\347\254\233\345\215\241\345\260\224\346\240\221\343\200\201Treap\346\240\221.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..a80149fcfda0df91ab86c24c82bc161b86b2c28e
GIT binary patch
literal 54297
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

literal 0
HcmV?d00001


From ef4e7e9ba5ed4cdc3f1747eafced0c55dcdcf22b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 18 Nov 2024 15:13:02 +0800
Subject: [PATCH 0120/1712] modify code

---
 src/class152/Code01_FHQTreap1.java | 241 +++++++++++++++++++++++++++++
 src/class152/Code01_FHQTreap2.java | 214 +++++++++++++++++++++++++
 2 files changed, 455 insertions(+)
 create mode 100644 src/class152/Code01_FHQTreap1.java
 create mode 100644 src/class152/Code01_FHQTreap2.java

diff --git a/src/class152/Code01_FHQTreap1.java b/src/class152/Code01_FHQTreap1.java
new file mode 100644
index 000000000..4cc6d4889
--- /dev/null
+++ b/src/class152/Code01_FHQTreap1.java
@@ -0,0 +1,241 @@
+package class152;
+
+// FHQ-Treap实现普通有序表(java版)
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code01_FHQTreap1 {
+
+	public static int MAXN = 100001;
+
+	// 整棵树的头节点编号
+	public static int head = 0;
+
+	// 空间使用计数
+	public static int cnt = 0;
+
+	// 节点的key值
+	public static int[] key = new int[MAXN];
+
+	// 节点key的计数
+	public static int[] count = new int[MAXN];
+
+	// 左孩子
+	public static int[] left = new int[MAXN];
+
+	// 右孩子
+	public static int[] right = new int[MAXN];
+
+	// 数字总数
+	public static int[] size = new int[MAXN];
+
+	// 节点优先级
+	public static double[] priority = new double[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+	}
+
+	public static void split(int l, int r, int i, int num) {
+		if (i == 0) {
+			right[l] = left[r] = 0;
+		} else {
+			if (key[i] <= num) {
+				right[l] = i;
+				split(i, r, right[i], num);
+			} else {
+				left[r] = i;
+				split(l, i, left[i], num);
+			}
+			up(i);
+		}
+	}
+
+	public static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			right[l] = merge(right[l], r);
+			up(l);
+			return l;
+		} else {
+			left[r] = merge(l, left[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	public static int find(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] == num) {
+			return i;
+		} else if (key[i] > num) {
+			return find(left[i], num);
+		} else {
+			return find(right[i], num);
+		}
+	}
+
+	public static void changeCount(int i, int num, int change) {
+		if (key[i] == num) {
+			count[i] += change;
+		} else if (key[i] > num) {
+			changeCount(left[i], num, change);
+		} else {
+			changeCount(right[i], num, change);
+		}
+		up(i);
+	}
+
+	public static void add(int num) {
+		if (find(head, num) != 0) {
+			changeCount(head, num, 1);
+		} else {
+			key[++cnt] = num;
+			count[cnt] = size[cnt] = 1;
+			priority[cnt] = Math.random();
+			split(0, 0, head, num);
+			head = merge(merge(right[0], cnt), left[0]);
+			left[0] = right[0] = 0;
+		}
+	}
+
+	public static void remove(int num) {
+		int i = find(head, num);
+		if (i != 0) {
+			if (count[i] > 1) {
+				changeCount(head, num, -1);
+			} else {
+				split(0, 0, head, num);
+				int lm = right[0];
+				int r = left[0];
+				left[0] = right[0] = 0;
+				split(0, 0, lm, num - 1);
+				int l = right[0];
+				left[0] = right[0] = 0;
+				head = merge(l, r);
+			}
+		}
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], num);
+		}
+	}
+
+	public static int rank(int num) {
+		return small(head, num) + 1;
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int pre(int i, int num) {
+		if (i == 0) {
+			return Integer.MIN_VALUE;
+		}
+		if (key[i] >= num) {
+			return pre(left[i], num);
+		} else {
+			return Math.max(key[i], pre(right[i], num));
+		}
+	}
+
+	public static int pre(int num) {
+		return pre(head, num);
+	}
+
+	public static int post(int i, int num) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= num) {
+			return post(right[i], num);
+		} else {
+			return Math.min(key[i], post(left[i], num));
+		}
+	}
+
+	public static int post(int num) {
+		return post(head, num);
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(priority, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1, op, x; i <= n; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				out.println(rank(x));
+			} else if (op == 4) {
+				out.println(index(x));
+			} else if (op == 5) {
+				out.println(pre(x));
+			} else {
+				out.println(post(x));
+			}
+		}
+		clear();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code01_FHQTreap2.java
new file mode 100644
index 000000000..50ed4688a
--- /dev/null
+++ b/src/class152/Code01_FHQTreap2.java
@@ -0,0 +1,214 @@
+package class152;
+
+// FHQ-Treap实现普通有序表(C++版)
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <cstdlib>
+//#include <cstring>
+//#include <algorithm>
+//#include <climits>
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int key_count[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//}
+//
+//void split(int l, int r, int i, int num) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        if (key[i] <= num) {
+//            rs[l] = i;
+//            split(i, r, rs[i], num);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], num);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//int find(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] == num) {
+//        return i;
+//    } else if (key[i] > num) {
+//        return find(ls[i], num);
+//    } else {
+//        return find(rs[i], num);
+//    }
+//}
+//
+//void changeCount(int i, int num, int change) {
+//    if (key[i] == num) {
+//        key_count[i] += change;
+//    } else if (key[i] > num) {
+//        changeCount(ls[i], num, change);
+//    } else {
+//        changeCount(rs[i], num, change);
+//    }
+//    up(i);
+//}
+//
+//void add(int num) {
+//    if (find(head, num) != 0) {
+//        changeCount(head, num, 1);
+//    } else {
+//        key[++cnt] = num;
+//        key_count[cnt] = size[cnt] = 1;
+//        priority[cnt] = (double)rand() / RAND_MAX;
+//        split(0, 0, head, num);
+//        head = merge(merge(rs[0], cnt), ls[0]);
+//        ls[0] = rs[0] = 0;
+//    }
+//}
+//
+//void remove(int num) {
+//    int i = find(head, num);
+//    if (i != 0) {
+//        if (key_count[i] > 1) {
+//            changeCount(head, num, -1);
+//        } else {
+//            split(0, 0, head, num);
+//            int lm = rs[0];
+//            int r = ls[0];
+//            ls[0] = rs[0] = 0;
+//            split(0, 0, lm, num - 1);
+//            int l = rs[0];
+//            ls[0] = rs[0] = 0;
+//            head = merge(l, r);
+//        }
+//    }
+//}
+//
+//int small(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return small(ls[i], num);
+//    } else {
+//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return small(head, num) + 1;
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//void clear() {
+//    memset(key, 0, sizeof(key));
+//    memset(key_count, 0, sizeof(key_count));
+//    memset(ls, 0, sizeof(ls));
+//    memset(rs, 0, sizeof(rs));
+//    memset(size, 0, sizeof(size));
+//    memset(priority, 0, sizeof(priority));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    int n;
+//    cin >> n;
+//    for (int i = 1, op, x; i <= n; i++) {
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << endl;
+//        } else if (op == 4) {
+//            cout << index(x) << endl;
+//        } else if (op == 5) {
+//            cout << pre(x) << endl;
+//        } else {
+//            cout << post(x) << endl;
+//        }
+//    }
+//    clear();
+//    return 0;
+//}

From 8dfd74bd1fa281cee95fd320a31ab48034f7b6a1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 18 Nov 2024 16:22:44 +0800
Subject: [PATCH 0121/1712] modify code

---
 src/class152/Code01_FHQTreap1.java  |   2 +-
 src/class152/Code01_FHQTreap2.java  | 387 +++++++++++++---------------
 src/class152/Code01_FHQTreap3.java  | 214 +++++++++++++++
 src/class152/Code01_FHQTreap4.java  | 172 +++++++++++++
 src/class152/Code02_TextEditor.java |   7 +
 5 files changed, 579 insertions(+), 203 deletions(-)
 create mode 100644 src/class152/Code01_FHQTreap3.java
 create mode 100644 src/class152/Code01_FHQTreap4.java
 create mode 100644 src/class152/Code02_TextEditor.java

diff --git a/src/class152/Code01_FHQTreap1.java b/src/class152/Code01_FHQTreap1.java
index 4cc6d4889..67b5832e9 100644
--- a/src/class152/Code01_FHQTreap1.java
+++ b/src/class152/Code01_FHQTreap1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap实现普通有序表(java版)
+// FHQ-Treap，保持无重复的key，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code01_FHQTreap2.java
index 50ed4688a..1a31a7077 100644
--- a/src/class152/Code01_FHQTreap2.java
+++ b/src/class152/Code01_FHQTreap2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap实现普通有序表(C++版)
+// FHQ-Treap，允许有重复的key，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
@@ -11,204 +11,187 @@
 // 所有操作的次数 <= 10^5
 // -10^7 <= x <= +10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P3369
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <iostream>
-//#include <cstdio>
-//#include <cstdlib>
-//#include <cstring>
-//#include <algorithm>
-//#include <climits>
-//using namespace std;
-//
-//const int MAXN = 100001;
-//int head = 0;
-//int cnt = 0;
-//int key[MAXN];
-//int key_count[MAXN];
-//int ls[MAXN];
-//int rs[MAXN];
-//int size[MAXN];
-//double priority[MAXN];
-//
-//void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
-//}
-//
-//void split(int l, int r, int i, int num) {
-//    if (i == 0) {
-//        rs[l] = ls[r] = 0;
-//    } else {
-//        if (key[i] <= num) {
-//            rs[l] = i;
-//            split(i, r, rs[i], num);
-//        } else {
-//            ls[r] = i;
-//            split(l, i, ls[i], num);
-//        }
-//        up(i);
-//    }
-//}
-//
-//int merge(int l, int r) {
-//    if (l == 0 || r == 0) {
-//        return l + r;
-//    }
-//    if (priority[l] >= priority[r]) {
-//        rs[l] = merge(rs[l], r);
-//        up(l);
-//        return l;
-//    } else {
-//        ls[r] = merge(l, ls[r]);
-//        up(r);
-//        return r;
-//    }
-//}
-//
-//int find(int i, int num) {
-//    if (i == 0) {
-//        return 0;
-//    }
-//    if (key[i] == num) {
-//        return i;
-//    } else if (key[i] > num) {
-//        return find(ls[i], num);
-//    } else {
-//        return find(rs[i], num);
-//    }
-//}
-//
-//void changeCount(int i, int num, int change) {
-//    if (key[i] == num) {
-//        key_count[i] += change;
-//    } else if (key[i] > num) {
-//        changeCount(ls[i], num, change);
-//    } else {
-//        changeCount(rs[i], num, change);
-//    }
-//    up(i);
-//}
-//
-//void add(int num) {
-//    if (find(head, num) != 0) {
-//        changeCount(head, num, 1);
-//    } else {
-//        key[++cnt] = num;
-//        key_count[cnt] = size[cnt] = 1;
-//        priority[cnt] = (double)rand() / RAND_MAX;
-//        split(0, 0, head, num);
-//        head = merge(merge(rs[0], cnt), ls[0]);
-//        ls[0] = rs[0] = 0;
-//    }
-//}
-//
-//void remove(int num) {
-//    int i = find(head, num);
-//    if (i != 0) {
-//        if (key_count[i] > 1) {
-//            changeCount(head, num, -1);
-//        } else {
-//            split(0, 0, head, num);
-//            int lm = rs[0];
-//            int r = ls[0];
-//            ls[0] = rs[0] = 0;
-//            split(0, 0, lm, num - 1);
-//            int l = rs[0];
-//            ls[0] = rs[0] = 0;
-//            head = merge(l, r);
-//        }
-//    }
-//}
-//
-//int small(int i, int num) {
-//    if (i == 0) {
-//        return 0;
-//    }
-//    if (key[i] >= num) {
-//        return small(ls[i], num);
-//    } else {
-//        return size[ls[i]] + key_count[i] + small(rs[i], num);
-//    }
-//}
-//
-//int getRank(int num) {
-//    return small(head, num) + 1;
-//}
-//
-//int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
-//        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
-//    }
-//    return key[i];
-//}
-//
-//int index(int x) {
-//    return index(head, x);
-//}
-//
-//int pre(int i, int num) {
-//    if (i == 0) {
-//        return INT_MIN;
-//    }
-//    if (key[i] >= num) {
-//        return pre(ls[i], num);
-//    } else {
-//        return max(key[i], pre(rs[i], num));
-//    }
-//}
-//
-//int pre(int num) {
-//    return pre(head, num);
-//}
-//
-//int post(int i, int num) {
-//    if (i == 0) {
-//        return INT_MAX;
-//    }
-//    if (key[i] <= num) {
-//        return post(rs[i], num);
-//    } else {
-//        return min(key[i], post(ls[i], num));
-//    }
-//}
-//
-//int post(int num) {
-//    return post(head, num);
-//}
-//
-//void clear() {
-//    memset(key, 0, sizeof(key));
-//    memset(key_count, 0, sizeof(key_count));
-//    memset(ls, 0, sizeof(ls));
-//    memset(rs, 0, sizeof(rs));
-//    memset(size, 0, sizeof(size));
-//    memset(priority, 0, sizeof(priority));
-//    cnt = 0;
-//    head = 0;
-//}
-//
-//int main() {
-//    int n;
-//    cin >> n;
-//    for (int i = 1, op, x; i <= n; i++) {
-//        cin >> op >> x;
-//        if (op == 1) {
-//            add(x);
-//        } else if (op == 2) {
-//            remove(x);
-//        } else if (op == 3) {
-//            cout << getRank(x) << endl;
-//        } else if (op == 4) {
-//            cout << index(x) << endl;
-//        } else if (op == 5) {
-//            cout << pre(x) << endl;
-//        } else {
-//            cout << post(x) << endl;
-//        }
-//    }
-//    clear();
-//    return 0;
-//}
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code01_FHQTreap2 {
+
+	public static int MAXN = 100001;
+
+	// 整棵树的头节点编号
+	public static int head = 0;
+
+	// 空间使用计数
+	public static int cnt = 0;
+
+	// 节点的key值
+	public static int[] key = new int[MAXN];
+
+	// 左孩子
+	public static int[] left = new int[MAXN];
+
+	// 右孩子
+	public static int[] right = new int[MAXN];
+
+	// 数字总数
+	public static int[] size = new int[MAXN];
+
+	// 节点优先级
+	public static double[] priority = new double[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static void split(int l, int r, int i, int num) {
+		if (i == 0) {
+			right[l] = left[r] = 0;
+		} else {
+			if (key[i] <= num) {
+				right[l] = i;
+				split(i, r, right[i], num);
+			} else {
+				left[r] = i;
+				split(l, i, left[i], num);
+			}
+			up(i);
+		}
+	}
+
+	public static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			right[l] = merge(right[l], r);
+			up(l);
+			return l;
+		} else {
+			left[r] = merge(l, left[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	public static void add(int num) {
+		key[++cnt] = num;
+		size[cnt] = 1;
+		priority[cnt] = Math.random();
+		split(0, 0, head, num);
+		head = merge(merge(right[0], cnt), left[0]);
+		left[0] = right[0] = 0;
+	}
+
+	public static void remove(int num) {
+		split(0, 0, head, num);
+		int lm = right[0];
+		int r = left[0];
+		left[0] = right[0] = 0;
+		split(0, 0, lm, num - 1);
+		int m = left[0];
+		int l = right[0];
+		left[0] = right[0] = 0;
+		head = merge(merge(l, merge(left[m], right[m])), r);
+	}
+
+	public static int rank(int num) {
+		split(0, 0, head, num - 1);
+		int ans = size[right[0]] + 1;
+		head = merge(right[0], left[0]);
+		left[0] = right[0] = 0;
+		return ans;
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + 1 < x) {
+			return index(right[i], x - size[left[i]] - 1);
+		} else {
+			return key[i];
+		}
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int pre(int i, int num) {
+		if (i == 0) {
+			return Integer.MIN_VALUE;
+		}
+		if (key[i] >= num) {
+			return pre(left[i], num);
+		} else {
+			return Math.max(key[i], pre(right[i], num));
+		}
+	}
+
+	public static int pre(int num) {
+		return pre(head, num);
+	}
+
+	public static int post(int i, int num) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= num) {
+			return post(right[i], num);
+		} else {
+			return Math.min(key[i], post(left[i], num));
+		}
+	}
+
+	public static int post(int num) {
+		return post(head, num);
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(priority, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1, op, x; i <= n; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				out.println(rank(x));
+			} else if (op == 4) {
+				out.println(index(x));
+			} else if (op == 5) {
+				out.println(pre(x));
+			} else {
+				out.println(post(x));
+			}
+		}
+		clear();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class152/Code01_FHQTreap3.java b/src/class152/Code01_FHQTreap3.java
new file mode 100644
index 000000000..1c7a6fabb
--- /dev/null
+++ b/src/class152/Code01_FHQTreap3.java
@@ -0,0 +1,214 @@
+package class152;
+
+// FHQ-Treap，保持无重复的key，C++版
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <cstdlib>
+//#include <cstring>
+//#include <algorithm>
+//#include <climits>
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int key_count[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//}
+//
+//void split(int l, int r, int i, int num) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        if (key[i] <= num) {
+//            rs[l] = i;
+//            split(i, r, rs[i], num);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], num);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//int find(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] == num) {
+//        return i;
+//    } else if (key[i] > num) {
+//        return find(ls[i], num);
+//    } else {
+//        return find(rs[i], num);
+//    }
+//}
+//
+//void changeCount(int i, int num, int change) {
+//    if (key[i] == num) {
+//        key_count[i] += change;
+//    } else if (key[i] > num) {
+//        changeCount(ls[i], num, change);
+//    } else {
+//        changeCount(rs[i], num, change);
+//    }
+//    up(i);
+//}
+//
+//void add(int num) {
+//    if (find(head, num) != 0) {
+//        changeCount(head, num, 1);
+//    } else {
+//        key[++cnt] = num;
+//        key_count[cnt] = size[cnt] = 1;
+//        priority[cnt] = (double)rand() / RAND_MAX;
+//        split(0, 0, head, num);
+//        head = merge(merge(rs[0], cnt), ls[0]);
+//        ls[0] = rs[0] = 0;
+//    }
+//}
+//
+//void remove(int num) {
+//    int i = find(head, num);
+//    if (i != 0) {
+//        if (key_count[i] > 1) {
+//            changeCount(head, num, -1);
+//        } else {
+//            split(0, 0, head, num);
+//            int lm = rs[0];
+//            int r = ls[0];
+//            ls[0] = rs[0] = 0;
+//            split(0, 0, lm, num - 1);
+//            int l = rs[0];
+//            ls[0] = rs[0] = 0;
+//            head = merge(l, r);
+//        }
+//    }
+//}
+//
+//int small(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return small(ls[i], num);
+//    } else {
+//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return small(head, num) + 1;
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//void clear() {
+//    memset(key, 0, sizeof(key));
+//    memset(key_count, 0, sizeof(key_count));
+//    memset(ls, 0, sizeof(ls));
+//    memset(rs, 0, sizeof(rs));
+//    memset(size, 0, sizeof(size));
+//    memset(priority, 0, sizeof(priority));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    int n;
+//    cin >> n;
+//    for (int i = 1, op, x; i <= n; i++) {
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << endl;
+//        } else if (op == 4) {
+//            cout << index(x) << endl;
+//        } else if (op == 5) {
+//            cout << pre(x) << endl;
+//        } else {
+//            cout << post(x) << endl;
+//        }
+//    }
+//    clear();
+//    return 0;
+//}
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code01_FHQTreap4.java
new file mode 100644
index 000000000..f2425fa09
--- /dev/null
+++ b/src/class152/Code01_FHQTreap4.java
@@ -0,0 +1,172 @@
+package class152;
+
+// FHQ-Treap，允许有重复的key，C++版
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <cstdlib>
+//#include <cstring>
+//#include <algorithm>
+//#include <climits>
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//void split(int l, int r, int i, int num) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        if (key[i] <= num) {
+//            rs[l] = i;
+//            split(i, r, rs[i], num);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], num);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//void add(int num) {
+//    key[++cnt] = num;
+//    size[cnt] = 1;
+//    priority[cnt] = (double)rand() / RAND_MAX;
+//    split(0, 0, head, num);
+//    head = merge(merge(rs[0], cnt), ls[0]);
+//    ls[0] = rs[0] = 0;
+//}
+//
+//void remove(int num) {
+//    split(0, 0, head, num);
+//    int lm = rs[0];
+//    int r = ls[0];
+//    ls[0] = rs[0] = 0;
+//    split(0, 0, lm, num - 1);
+//    int m = ls[0];
+//    int l = rs[0];
+//    ls[0] = rs[0] = 0;
+//    head = merge(merge(l, merge(ls[m], rs[m])), r);
+//}
+//
+//int getRank(int num) {
+//    split(0, 0, head, num - 1);
+//    int ans = size[rs[0]] + 1;
+//    head = merge(rs[0], ls[0]);
+//    ls[0] = rs[0] = 0;
+//    return ans;
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + 1 < x) {
+//        return index(rs[i], x - size[ls[i]] - 1);
+//    } else {
+//        return key[i];
+//    }
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//void clear() {
+//    memset(key, 0, sizeof(key));
+//    memset(ls, 0, sizeof(ls));
+//    memset(rs, 0, sizeof(rs));
+//    memset(size, 0, sizeof(size));
+//    memset(priority, 0, sizeof(priority));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    int n;
+//    cin >> n;
+//    for (int i = 1, op, x; i <= n; i++) {
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << endl;
+//        } else if (op == 4) {
+//            cout << index(x) << endl;
+//        } else if (op == 5) {
+//            cout << pre(x) << endl;
+//        } else {
+//            cout << post(x) << endl;
+//        }
+//    }
+//    clear();
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class152/Code02_TextEditor.java b/src/class152/Code02_TextEditor.java
new file mode 100644
index 000000000..33dd1205f
--- /dev/null
+++ b/src/class152/Code02_TextEditor.java
@@ -0,0 +1,7 @@
+package class152;
+
+// 文本编辑器
+// 测试链接 : https://www.luogu.com.cn/problem/P4008
+public class Code02_TextEditor {
+
+}

From d2911882eb11ebb5d0986c831851e5983a5bca6e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 18 Nov 2024 16:23:56 +0800
Subject: [PATCH 0122/1712] modify code

---
 src/class152/Code01_FHQTreap1.java | 2 +-
 src/class152/Code01_FHQTreap2.java | 2 +-
 src/class152/Code01_FHQTreap3.java | 2 +-
 src/class152/Code01_FHQTreap4.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class152/Code01_FHQTreap1.java b/src/class152/Code01_FHQTreap1.java
index 67b5832e9..7e6d43946 100644
--- a/src/class152/Code01_FHQTreap1.java
+++ b/src/class152/Code01_FHQTreap1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，保持无重复的key，java版
+// FHQ-Treap，树上无重复key，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code01_FHQTreap2.java
index 1a31a7077..fad671ca3 100644
--- a/src/class152/Code01_FHQTreap2.java
+++ b/src/class152/Code01_FHQTreap2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，允许有重复的key，java版
+// FHQ-Treap，树上有重复key，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreap3.java b/src/class152/Code01_FHQTreap3.java
index 1c7a6fabb..60b7c967c 100644
--- a/src/class152/Code01_FHQTreap3.java
+++ b/src/class152/Code01_FHQTreap3.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，保持无重复的key，C++版
+// FHQ-Treap，树上无重复key，C++版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code01_FHQTreap4.java
index f2425fa09..233ca23f2 100644
--- a/src/class152/Code01_FHQTreap4.java
+++ b/src/class152/Code01_FHQTreap4.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，允许有重复的key，C++版
+// FHQ-Treap，树上有重复key，C++版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个

From 4dcddf3e8af06fed5d312515e1c65eb02d618ff2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 18 Nov 2024 16:29:10 +0800
Subject: [PATCH 0123/1712] modify code

---
 src/class152/Code01_FHQTreap1.java | 2 +-
 src/class152/Code01_FHQTreap2.java | 2 +-
 src/class152/Code01_FHQTreap3.java | 2 +-
 src/class152/Code01_FHQTreap4.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class152/Code01_FHQTreap1.java b/src/class152/Code01_FHQTreap1.java
index 7e6d43946..b3f4b2534 100644
--- a/src/class152/Code01_FHQTreap1.java
+++ b/src/class152/Code01_FHQTreap1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，树上无重复key，java版
+// FHQ-Treap，使用词频统计，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code01_FHQTreap2.java
index fad671ca3..b4e7790e6 100644
--- a/src/class152/Code01_FHQTreap2.java
+++ b/src/class152/Code01_FHQTreap2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，树上有重复key，java版
+// FHQ-Treap，不用词频统计，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreap3.java b/src/class152/Code01_FHQTreap3.java
index 60b7c967c..f4ae6c52a 100644
--- a/src/class152/Code01_FHQTreap3.java
+++ b/src/class152/Code01_FHQTreap3.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，树上无重复key，C++版
+// FHQ-Treap，使用词频统计，C++版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code01_FHQTreap4.java
index 233ca23f2..04a81cb41 100644
--- a/src/class152/Code01_FHQTreap4.java
+++ b/src/class152/Code01_FHQTreap4.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，树上有重复key，C++版
+// FHQ-Treap，不用词频统计，C++版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个

From f5e556399c63155b3f99f3818b1bd0a171391585 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 13:09:57 +0800
Subject: [PATCH 0124/1712] modify code

---
 src/class149/SkipList2.java          |   1 +
 src/class151/Code02_Treap2.java      |   1 +
 src/class152/Code01_FHQTreap3.java   |   1 +
 src/class152/Code01_FHQTreap4.java   |   1 +
 src/class152/Code02_TextEditor.java  |   7 --
 src/class152/Code02_TextEditor1.java | 170 +++++++++++++++++++++++++++
 src/class152/Code02_TextEditor2.java | 138 ++++++++++++++++++++++
 7 files changed, 312 insertions(+), 7 deletions(-)
 delete mode 100644 src/class152/Code02_TextEditor.java
 create mode 100644 src/class152/Code02_TextEditor1.java
 create mode 100644 src/class152/Code02_TextEditor2.java

diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
index fc69395e1..8a041123c 100644
--- a/src/class149/SkipList2.java
+++ b/src/class149/SkipList2.java
@@ -236,6 +236,7 @@
 //}
 //
 //int main() {
+//    srand(time(0));
 //    build();
 //    int n;
 //    cin >> n;
diff --git a/src/class151/Code02_Treap2.java b/src/class151/Code02_Treap2.java
index 12b5a4145..748ea7bcf 100644
--- a/src/class151/Code02_Treap2.java
+++ b/src/class151/Code02_Treap2.java
@@ -189,6 +189,7 @@
 //}
 //
 //int main() {
+//    srand(time(0));
 //    int n;
 //    cin >> n;
 //    for (int i = 1, op, x; i <= n; i++) {
diff --git a/src/class152/Code01_FHQTreap3.java b/src/class152/Code01_FHQTreap3.java
index f4ae6c52a..66d7a2343 100644
--- a/src/class152/Code01_FHQTreap3.java
+++ b/src/class152/Code01_FHQTreap3.java
@@ -191,6 +191,7 @@
 //}
 //
 //int main() {
+//    srand(time(0));
 //    int n;
 //    cin >> n;
 //    for (int i = 1, op, x; i <= n; i++) {
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code01_FHQTreap4.java
index 04a81cb41..b167e1214 100644
--- a/src/class152/Code01_FHQTreap4.java
+++ b/src/class152/Code01_FHQTreap4.java
@@ -149,6 +149,7 @@
 //}
 //
 //int main() {
+//    srand(time(0));
 //    int n;
 //    cin >> n;
 //    for (int i = 1, op, x; i <= n; i++) {
diff --git a/src/class152/Code02_TextEditor.java b/src/class152/Code02_TextEditor.java
deleted file mode 100644
index 33dd1205f..000000000
--- a/src/class152/Code02_TextEditor.java
+++ /dev/null
@@ -1,7 +0,0 @@
-package class152;
-
-// 文本编辑器
-// 测试链接 : https://www.luogu.com.cn/problem/P4008
-public class Code02_TextEditor {
-
-}
diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code02_TextEditor1.java
new file mode 100644
index 000000000..bf484c63e
--- /dev/null
+++ b/src/class152/Code02_TextEditor1.java
@@ -0,0 +1,170 @@
+package class152;
+
+// 文本编辑器(java版本)
+// 测试链接 : https://www.luogu.com.cn/problem/P4008
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_TextEditor1 {
+
+	public static int MAXN = 2000001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static char[] key = new char[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static double[] priority = new double[MAXN];
+
+	public static char[] ans = new char[MAXN];
+
+	public static int ansi;
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static void split(int l, int r, int i, int rank) {
+		if (i == 0) {
+			right[l] = left[r] = 0;
+		} else {
+			if (size[left[i]] + 1 <= rank) {
+				right[l] = i;
+				split(i, r, right[i], rank - size[left[i]] - 1);
+			} else {
+				left[r] = i;
+				split(l, i, left[i], rank);
+			}
+			up(i);
+		}
+	}
+
+	public static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			right[l] = merge(right[l], r);
+			up(l);
+			return l;
+		} else {
+			left[r] = merge(l, left[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	public static void inorder(int i) {
+		if (i != 0) {
+			inorder(left[i]);
+			ans[++ansi] = key[i];
+			inorder(right[i]);
+		}
+	}
+
+	public static void clear() {
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(priority, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		int n = Integer.parseInt(in.readLine());
+		int pos = 0, len;
+		String[] input = getInput(in);
+		String str;
+		String[] part;
+		String op;
+		int l, m, lm, r;
+		for (int i = 1, inputIndex = 0; i <= n; i++) {
+			str = input[inputIndex++].trim();
+			if (str.equals("Prev")) {
+				pos--;
+			} else if (str.equals("Next")) {
+				pos++;
+			} else {
+				part = str.split(" ");
+				op = part[0];
+				len = Integer.parseInt(part[1]);
+				if (op.equals("Move")) {
+					pos = len;
+				} else if (op.equals("Insert")) {
+					split(0, 0, head, pos);
+					l = right[0];
+					r = left[0];
+					left[0] = right[0] = 0;
+					for (int j = 1; j <= len;) {
+						for (char c : input[inputIndex++].toCharArray()) {
+							if (c >= 32 && c <= 126) {
+								key[++cnt] = c;
+								size[cnt] = 1;
+								priority[cnt] = Math.random();
+								l = merge(l, cnt);
+								j++;
+							}
+						}
+					}
+					head = merge(l, r);
+				} else if (op.equals("Delete")) {
+					split(0, 0, head, pos + len);
+					r = left[0];
+					lm = right[0];
+					left[0] = right[0] = 0;
+					split(0, 0, lm, pos);
+					l = right[0];
+					left[0] = right[0] = 0;
+					head = merge(l, r);
+				} else {
+					split(0, 0, head, pos + len);
+					r = left[0];
+					lm = right[0];
+					left[0] = right[0] = 0;
+					split(0, 0, lm, pos);
+					l = right[0];
+					m = left[0];
+					left[0] = right[0] = 0;
+					ansi = 0;
+					inorder(m);
+					head = merge(merge(l, m), r);
+					for (int j = 1; j <= ansi; j++) {
+						out.print(ans[j]);
+					}
+					out.println();
+				}
+			}
+		}
+		clear();
+		out.flush();
+		out.close();
+		in.close();
+	}
+
+	public static String[] getInput(BufferedReader in) throws IOException {
+		StringBuilder inputBuffer = new StringBuilder();
+		char[] tempBuffer = new char[8192];
+		int bytesRead;
+		while ((bytesRead = in.read(tempBuffer)) != -1) {
+			inputBuffer.append(tempBuffer, 0, bytesRead);
+		}
+		String[] input = inputBuffer.toString().split("\n");
+		return input;
+	}
+
+}
diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code02_TextEditor2.java
new file mode 100644
index 000000000..34bd06fed
--- /dev/null
+++ b/src/class152/Code02_TextEditor2.java
@@ -0,0 +1,138 @@
+package class152;
+
+// 文本编辑器(C++版本)
+// 测试链接 : https://www.luogu.com.cn/problem/P4008
+
+//#include <iostream>
+//#include <vector>
+//#include <cstdlib>
+//#include <cstring>
+//#include <algorithm>
+//using namespace std;
+//
+//const int MAXN = 2000001;
+//
+//int head = 0;
+//int cnt = 0;
+//char key[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//char ans[MAXN];
+//int ansi;
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//void split(int l, int r, int i, int rank) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        if (size[ls[i]] + 1 <= rank) {
+//            rs[l] = i;
+//            split(i, r, rs[i], rank - size[ls[i]] - 1);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], rank);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//void inorder(int i) {
+//    if (i != 0) {
+//        inorder(ls[i]);
+//        ans[++ansi] = key[i];
+//        inorder(rs[i]);
+//    }
+//}
+//
+//void clear() {
+//    memset(ls, 0, sizeof(int) * (cnt + 1));
+//    memset(rs, 0, sizeof(int) * (cnt + 1));
+//    memset(size, 0, sizeof(int) * (cnt + 1));
+//    memset(priority, 0, sizeof(double) * (cnt + 1));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//	srand(time(0));
+//    int pos = 0, len, l, m, lm, r;
+//    int n;
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        char op[10];
+//        cin >> op;
+//        if (op[0] == 'P') {
+//            pos--;
+//        } else if (op[0] == 'N') {
+//            pos++;
+//        } else if (op[0] == 'M') {
+//            cin >> pos;
+//        } else if (op[0] == 'I') {
+//            cin >> len;
+//            split(0, 0, head, pos);
+//            l = rs[0];
+//            r = ls[0];
+//            ls[0] = rs[0] = 0;
+//            for (int j = 1; j <= len; j++) {
+//                char ch = getchar();
+//                while (ch < 32 || ch > 126) {
+//                    ch = getchar();
+//                }
+//                key[++cnt] = ch;
+//                size[cnt] = 1;
+//                priority[cnt] = (double)rand() / RAND_MAX;
+//                l = merge(l, cnt);
+//            }
+//            head = merge(l, r);
+//        } else if (op[0] == 'D') {
+//            cin >> len;
+//            split(0, 0, head, pos + len);
+//            r = ls[0];
+//            lm = rs[0];
+//            ls[0] = rs[0] = 0;
+//            split(0, 0, lm, pos);
+//            l = rs[0];
+//            ls[0] = rs[0] = 0;
+//            head = merge(l, r);
+//        } else {
+//            cin >> len;
+//            split(0, 0, head, pos + len);
+//            r = ls[0];
+//            lm = rs[0];
+//            ls[0] = rs[0] = 0;
+//            split(0, 0, lm, pos);
+//            l = rs[0];
+//            m = ls[0];
+//            ls[0] = rs[0] = 0;
+//            ansi = 0;
+//            inorder(m);
+//            head = merge(merge(l, m), r);
+//            for (int j = 1; j <= ansi; j++) {
+//                cout << ans[j];
+//            }
+//            cout << '\n';
+//        }
+//    }
+//    clear();
+//    return 0;
+//}
\ No newline at end of file

From 59b9ff85ecfd77a8bb31559246af44d7e6e3e88e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 13:13:25 +0800
Subject: [PATCH 0125/1712] modify code

---
 src/class152/Code02_TextEditor1.java | 5 +++++
 src/class152/Code02_TextEditor2.java | 2 ++
 2 files changed, 7 insertions(+)

diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code02_TextEditor1.java
index bf484c63e..3e02dbcbe 100644
--- a/src/class152/Code02_TextEditor1.java
+++ b/src/class152/Code02_TextEditor1.java
@@ -2,6 +2,11 @@
 
 // 文本编辑器(java版本)
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
+// 如下实现是正确的，但java的版本无法通过所有测试用例
+// 这是洛谷平台没有照顾各种语言的实现所导致的
+// java的实现，空间就是无法达标，C++的实现，完全一样的逻辑，就是可以达标
+// C++版本是Code02_TextEditor2文件，可以通过所有测试用例
+// 在真正笔试、比赛时，一定是兼顾各种语言的，该实现是一定正确的
 
 import java.io.BufferedReader;
 import java.io.IOException;
diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code02_TextEditor2.java
index 34bd06fed..ae4472f51 100644
--- a/src/class152/Code02_TextEditor2.java
+++ b/src/class152/Code02_TextEditor2.java
@@ -2,6 +2,8 @@
 
 // 文本编辑器(C++版本)
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
 
 //#include <iostream>
 //#include <vector>

From a96f5bc691585470fc4843101df49aca80b5ca92 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 13:16:00 +0800
Subject: [PATCH 0126/1712] modify code

---
 src/class152/Code02_TextEditor1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code02_TextEditor1.java
index 3e02dbcbe..eab8a4138 100644
--- a/src/class152/Code02_TextEditor1.java
+++ b/src/class152/Code02_TextEditor1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 如下实现是正确的，但java的版本无法通过所有测试用例
 // 这是洛谷平台没有照顾各种语言的实现所导致的
-// java的实现，空间就是无法达标，C++的实现，完全一样的逻辑，就是可以达标
+// java的实现空间就是无法达标，C++的实现完全一样的逻辑，就是可以达标
 // C++版本是Code02_TextEditor2文件，可以通过所有测试用例
 // 在真正笔试、比赛时，一定是兼顾各种语言的，该实现是一定正确的
 

From 06207f565276651e4db893f7b17949f9e84aaff3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 13:18:14 +0800
Subject: [PATCH 0127/1712] modify code

---
 src/class152/Code02_TextEditor1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code02_TextEditor1.java
index eab8a4138..24c9a1b97 100644
--- a/src/class152/Code02_TextEditor1.java
+++ b/src/class152/Code02_TextEditor1.java
@@ -88,6 +88,9 @@ public static void clear() {
 		head = 0;
 	}
 
+	// 我写了很多个版本的IO实现，空间都无法达标
+	// 以下风格只是其中一种，无所谓了，逻辑是对的
+	// 想通过这个题看C++版本吧，完全一样的逻辑
 	public static void main(String[] args) throws IOException {
 		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));

From 50d5e870c3e699e7fafaf1782903bae3e6e03352 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 15:58:24 +0800
Subject: [PATCH 0128/1712] modify code

---
 src/class152/Code02_TextEditor2.java          |   2 +-
 .../Code03_LiteraryBalancedTree1.java         | 149 ++++++++++++++++++
 .../Code03_LiteraryBalancedTree2.java         | 127 +++++++++++++++
 3 files changed, 277 insertions(+), 1 deletion(-)
 create mode 100644 src/class152/Code03_LiteraryBalancedTree1.java
 create mode 100644 src/class152/Code03_LiteraryBalancedTree2.java

diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code02_TextEditor2.java
index ae4472f51..f8d967de9 100644
--- a/src/class152/Code02_TextEditor2.java
+++ b/src/class152/Code02_TextEditor2.java
@@ -76,7 +76,7 @@
 //}
 //
 //int main() {
-//	srand(time(0));
+//	  srand(time(0));
 //    int pos = 0, len, l, m, lm, r;
 //    int n;
 //    cin >> n;
diff --git a/src/class152/Code03_LiteraryBalancedTree1.java b/src/class152/Code03_LiteraryBalancedTree1.java
new file mode 100644
index 000000000..ec718bd80
--- /dev/null
+++ b/src/class152/Code03_LiteraryBalancedTree1.java
@@ -0,0 +1,149 @@
+package class152;
+
+// 文艺平衡树(java版)
+// 测试链接 : https://www.luogu.com.cn/problem/P3391
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_LiteraryBalancedTree1 {
+
+	public static int MAXN = 100001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static double[] priority = new double[MAXN];
+
+	public static boolean[] reverse = new boolean[MAXN];
+
+	public static int[] ans = new int[MAXN];
+
+	public static int ansi;
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static void down(int i) {
+		if (reverse[i]) {
+			int tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+			reverse[left[i]] = !reverse[left[i]];
+			reverse[right[i]] = !reverse[right[i]];
+			reverse[i] = false;
+		}
+	}
+
+	public static void split(int l, int r, int i, int rank) {
+		if (i == 0) {
+			right[l] = left[r] = 0;
+		} else {
+			down(i);
+			if (size[left[i]] + 1 <= rank) {
+				right[l] = i;
+				split(i, r, right[i], rank - size[left[i]] - 1);
+			} else {
+				left[r] = i;
+				split(l, i, left[i], rank);
+			}
+			up(i);
+		}
+	}
+
+	public static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			down(l);
+			right[l] = merge(right[l], r);
+			up(l);
+			return l;
+		} else {
+			down(r);
+			left[r] = merge(l, left[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	public static void inorder(int i) {
+		if (i != 0) {
+			down(i);
+			inorder(left[i]);
+			ans[++ansi] = key[i];
+			inorder(right[i]);
+		}
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(priority, 1, cnt + 1, 0);
+		Arrays.fill(reverse, 1, cnt + 1, false);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int k = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			key[++cnt] = i;
+			size[cnt] = 1;
+			priority[cnt] = Math.random();
+			head = merge(head, cnt);
+		}
+		for (int i = 1, x, y, l, m, lm, r; i <= k; i++) {
+			in.nextToken();
+			x = (int) in.nval;
+			in.nextToken();
+			y = (int) in.nval;
+			split(0, 0, head, y);
+			r = left[0];
+			lm = right[0];
+			left[0] = right[0] = 0;
+			split(0, 0, lm, x - 1);
+			l = right[0];
+			m = left[0];
+			left[0] = right[0] = 0;
+			reverse[m] = !reverse[m];
+			head = merge(merge(l, m), r);
+		}
+		ansi = 0;
+		inorder(head);
+		for (int i = 1; i <= ansi; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		clear();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class152/Code03_LiteraryBalancedTree2.java b/src/class152/Code03_LiteraryBalancedTree2.java
new file mode 100644
index 000000000..aa5dd7f03
--- /dev/null
+++ b/src/class152/Code03_LiteraryBalancedTree2.java
@@ -0,0 +1,127 @@
+package class152;
+
+// 文艺平衡树(C++版)
+// 测试链接 : https://www.luogu.com.cn/problem/P3391
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <cstdlib>
+//#include <cmath>
+//#include <ctime>
+//#include <cstring>
+//#include <algorithm>
+//using namespace std;
+//
+//const int MAXN = 100001;
+//
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//bool rev[MAXN];
+//int ans[MAXN];
+//int ansi;
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//void down(int i) {
+//    if (rev[i]) {
+//        swap(ls[i], rs[i]);
+//        rev[ls[i]] ^= 1;
+//        rev[rs[i]] ^= 1;
+//        rev[i] = false;
+//    }
+//}
+//
+//void split(int l, int r, int i, int rank) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        down(i);
+//        if (size[ls[i]] + 1 <= rank) {
+//            rs[l] = i;
+//            split(i, r, rs[i], rank - size[ls[i]] - 1);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], rank);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        down(l);
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        down(r);
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//void inorder(int i) {
+//    if (i != 0) {
+//        down(i);
+//        inorder(ls[i]);
+//        ans[++ansi] = key[i];
+//        inorder(rs[i]);
+//    }
+//}
+//
+//void clear() {
+//    memset(key, 0, sizeof(key));
+//    memset(ls, 0, sizeof(ls));
+//    memset(rs, 0, sizeof(rs));
+//    memset(size, 0, sizeof(size));
+//    memset(priority, 0, sizeof(priority));
+//    memset(rev, 0, sizeof(rev));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//	  srand(time(0));
+//    int n, k;
+//    cin >> n >> k;
+//    for (int i = 1; i <= n; i++) {
+//        key[++cnt] = i;
+//        size[cnt] = 1;
+//        priority[cnt] = (double)rand() / RAND_MAX;
+//        head = merge(head, cnt);
+//    }
+//    for (int i = 1, x, y, l, m, lm, r; i <= k; i++) {
+//        cin >> x >> y;
+//        split(0, 0, head, y);
+//        r = ls[0];
+//        lm = rs[0];
+//        ls[0] = rs[0] = 0;
+//        split(0, 0, lm, x - 1);
+//        l = rs[0];
+//        m = ls[0];
+//        ls[0] = rs[0] = 0;
+//        rev[m] ^= 1;
+//        head = merge(merge(l, m), r);
+//    }
+//    ansi = 0;
+//    inorder(head);
+//    for (int i = 1; i <= ansi; i++) {
+//        cout << ans[i] << " ";
+//    }
+//    cout << endl;
+//    clear();
+//    return 0;
+//}
\ No newline at end of file

From aed65dd798250963563922e7a1a70566e8dec21b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 16:02:12 +0800
Subject: [PATCH 0129/1712] modify code

---
 ...e03_LiteraryBalancedTree1.java => Code03_LiteraryTree1.java} | 2 +-
 ...e03_LiteraryBalancedTree2.java => Code03_LiteraryTree2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class152/{Code03_LiteraryBalancedTree1.java => Code03_LiteraryTree1.java} (98%)
 rename src/class152/{Code03_LiteraryBalancedTree2.java => Code03_LiteraryTree2.java} (100%)

diff --git a/src/class152/Code03_LiteraryBalancedTree1.java b/src/class152/Code03_LiteraryTree1.java
similarity index 98%
rename from src/class152/Code03_LiteraryBalancedTree1.java
rename to src/class152/Code03_LiteraryTree1.java
index ec718bd80..183e8b119 100644
--- a/src/class152/Code03_LiteraryBalancedTree1.java
+++ b/src/class152/Code03_LiteraryTree1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_LiteraryBalancedTree1 {
+public class Code03_LiteraryTree1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class152/Code03_LiteraryBalancedTree2.java b/src/class152/Code03_LiteraryTree2.java
similarity index 100%
rename from src/class152/Code03_LiteraryBalancedTree2.java
rename to src/class152/Code03_LiteraryTree2.java

From 32bb0afb1f3dc4f799b953c9fefa2fec90fb3243 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 18:59:29 +0800
Subject: [PATCH 0130/1712] modify code

---
 src/class152/Code01_FHQTreap1.java           |  15 +-
 src/class152/Code01_FHQTreap2.java           |  14 +-
 src/class152/Code01_FHQTreap3.java           |  14 +-
 src/class152/Code01_FHQTreap4.java           |  13 +-
 src/class152/Code02_TextEditor1.java         |  11 --
 src/class152/Code02_TextEditor2.java         |  10 --
 src/class152/Code03_LiteraryTree1.java       |  13 --
 src/class152/Code03_LiteraryTree2.java       |  12 --
 src/class152/Code04_FHQTreapPersistent1.java | 175 +++++++++++++++++++
 src/class152/Code04_FHQTreapPersistent2.java | 162 +++++++++++++++++
 10 files changed, 341 insertions(+), 98 deletions(-)
 create mode 100644 src/class152/Code04_FHQTreapPersistent1.java
 create mode 100644 src/class152/Code04_FHQTreapPersistent2.java

diff --git a/src/class152/Code01_FHQTreap1.java b/src/class152/Code01_FHQTreap1.java
index b3f4b2534..dc84530f7 100644
--- a/src/class152/Code01_FHQTreap1.java
+++ b/src/class152/Code01_FHQTreap1.java
@@ -19,7 +19,6 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
-import java.util.Arrays;
 
 public class Code01_FHQTreap1 {
 
@@ -111,10 +110,10 @@ public static void add(int num) {
 		if (find(head, num) != 0) {
 			changeCount(head, num, 1);
 		} else {
+			split(0, 0, head, num);
 			key[++cnt] = num;
 			count[cnt] = size[cnt] = 1;
 			priority[cnt] = Math.random();
-			split(0, 0, head, num);
 			head = merge(merge(right[0], cnt), left[0]);
 			left[0] = right[0] = 0;
 		}
@@ -196,17 +195,6 @@ public static int post(int num) {
 		return post(head, num);
 	}
 
-	public static void clear() {
-		Arrays.fill(key, 1, cnt + 1, 0);
-		Arrays.fill(count, 1, cnt + 1, 0);
-		Arrays.fill(left, 1, cnt + 1, 0);
-		Arrays.fill(right, 1, cnt + 1, 0);
-		Arrays.fill(size, 1, cnt + 1, 0);
-		Arrays.fill(priority, 1, cnt + 1, 0);
-		cnt = 0;
-		head = 0;
-	}
-
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -232,7 +220,6 @@ public static void main(String[] args) throws IOException {
 				out.println(post(x));
 			}
 		}
-		clear();
 		out.flush();
 		out.close();
 		br.close();
diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code01_FHQTreap2.java
index b4e7790e6..89e935783 100644
--- a/src/class152/Code01_FHQTreap2.java
+++ b/src/class152/Code01_FHQTreap2.java
@@ -19,7 +19,6 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
-import java.util.Arrays;
 
 public class Code01_FHQTreap2 {
 
@@ -81,10 +80,10 @@ public static int merge(int l, int r) {
 	}
 
 	public static void add(int num) {
+		split(0, 0, head, num);
 		key[++cnt] = num;
 		size[cnt] = 1;
 		priority[cnt] = Math.random();
-		split(0, 0, head, num);
 		head = merge(merge(right[0], cnt), left[0]);
 		left[0] = right[0] = 0;
 	}
@@ -153,16 +152,6 @@ public static int post(int num) {
 		return post(head, num);
 	}
 
-	public static void clear() {
-		Arrays.fill(key, 1, cnt + 1, 0);
-		Arrays.fill(left, 1, cnt + 1, 0);
-		Arrays.fill(right, 1, cnt + 1, 0);
-		Arrays.fill(size, 1, cnt + 1, 0);
-		Arrays.fill(priority, 1, cnt + 1, 0);
-		cnt = 0;
-		head = 0;
-	}
-
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -188,7 +177,6 @@ public static void main(String[] args) throws IOException {
 				out.println(post(x));
 			}
 		}
-		clear();
 		out.flush();
 		out.close();
 		br.close();
diff --git a/src/class152/Code01_FHQTreap3.java b/src/class152/Code01_FHQTreap3.java
index 66d7a2343..526d8fcff 100644
--- a/src/class152/Code01_FHQTreap3.java
+++ b/src/class152/Code01_FHQTreap3.java
@@ -94,10 +94,10 @@
 //    if (find(head, num) != 0) {
 //        changeCount(head, num, 1);
 //    } else {
+//        split(0, 0, head, num);
 //        key[++cnt] = num;
 //        key_count[cnt] = size[cnt] = 1;
 //        priority[cnt] = (double)rand() / RAND_MAX;
-//        split(0, 0, head, num);
 //        head = merge(merge(rs[0], cnt), ls[0]);
 //        ls[0] = rs[0] = 0;
 //    }
@@ -179,17 +179,6 @@
 //    return post(head, num);
 //}
 //
-//void clear() {
-//    memset(key, 0, sizeof(key));
-//    memset(key_count, 0, sizeof(key_count));
-//    memset(ls, 0, sizeof(ls));
-//    memset(rs, 0, sizeof(rs));
-//    memset(size, 0, sizeof(size));
-//    memset(priority, 0, sizeof(priority));
-//    cnt = 0;
-//    head = 0;
-//}
-//
 //int main() {
 //    srand(time(0));
 //    int n;
@@ -210,6 +199,5 @@
 //            cout << post(x) << endl;
 //        }
 //    }
-//    clear();
 //    return 0;
 //}
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code01_FHQTreap4.java
index b167e1214..736b17b65 100644
--- a/src/class152/Code01_FHQTreap4.java
+++ b/src/class152/Code01_FHQTreap4.java
@@ -66,10 +66,10 @@
 //}
 //
 //void add(int num) {
+//    split(0, 0, head, num);
 //    key[++cnt] = num;
 //    size[cnt] = 1;
 //    priority[cnt] = (double)rand() / RAND_MAX;
-//    split(0, 0, head, num);
 //    head = merge(merge(rs[0], cnt), ls[0]);
 //    ls[0] = rs[0] = 0;
 //}
@@ -138,16 +138,6 @@
 //    return post(head, num);
 //}
 //
-//void clear() {
-//    memset(key, 0, sizeof(key));
-//    memset(ls, 0, sizeof(ls));
-//    memset(rs, 0, sizeof(rs));
-//    memset(size, 0, sizeof(size));
-//    memset(priority, 0, sizeof(priority));
-//    cnt = 0;
-//    head = 0;
-//}
-//
 //int main() {
 //    srand(time(0));
 //    int n;
@@ -168,6 +158,5 @@
 //            cout << post(x) << endl;
 //        }
 //    }
-//    clear();
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code02_TextEditor1.java
index 24c9a1b97..323f14cb1 100644
--- a/src/class152/Code02_TextEditor1.java
+++ b/src/class152/Code02_TextEditor1.java
@@ -13,7 +13,6 @@
 import java.io.InputStreamReader;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.util.Arrays;
 
 public class Code02_TextEditor1 {
 
@@ -79,15 +78,6 @@ public static void inorder(int i) {
 		}
 	}
 
-	public static void clear() {
-		Arrays.fill(left, 1, cnt + 1, 0);
-		Arrays.fill(right, 1, cnt + 1, 0);
-		Arrays.fill(size, 1, cnt + 1, 0);
-		Arrays.fill(priority, 1, cnt + 1, 0);
-		cnt = 0;
-		head = 0;
-	}
-
 	// 我写了很多个版本的IO实现，空间都无法达标
 	// 以下风格只是其中一种，无所谓了，逻辑是对的
 	// 想通过这个题看C++版本吧，完全一样的逻辑
@@ -158,7 +148,6 @@ public static void main(String[] args) throws IOException {
 				}
 			}
 		}
-		clear();
 		out.flush();
 		out.close();
 		in.close();
diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code02_TextEditor2.java
index f8d967de9..e91f0e8e6 100644
--- a/src/class152/Code02_TextEditor2.java
+++ b/src/class152/Code02_TextEditor2.java
@@ -66,15 +66,6 @@
 //    }
 //}
 //
-//void clear() {
-//    memset(ls, 0, sizeof(int) * (cnt + 1));
-//    memset(rs, 0, sizeof(int) * (cnt + 1));
-//    memset(size, 0, sizeof(int) * (cnt + 1));
-//    memset(priority, 0, sizeof(double) * (cnt + 1));
-//    cnt = 0;
-//    head = 0;
-//}
-//
 //int main() {
 //	  srand(time(0));
 //    int pos = 0, len, l, m, lm, r;
@@ -135,6 +126,5 @@
 //            cout << '\n';
 //        }
 //    }
-//    clear();
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class152/Code03_LiteraryTree1.java b/src/class152/Code03_LiteraryTree1.java
index 183e8b119..53e158574 100644
--- a/src/class152/Code03_LiteraryTree1.java
+++ b/src/class152/Code03_LiteraryTree1.java
@@ -10,7 +10,6 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
-import java.util.Arrays;
 
 public class Code03_LiteraryTree1 {
 
@@ -93,17 +92,6 @@ public static void inorder(int i) {
 		}
 	}
 
-	public static void clear() {
-		Arrays.fill(key, 1, cnt + 1, 0);
-		Arrays.fill(left, 1, cnt + 1, 0);
-		Arrays.fill(right, 1, cnt + 1, 0);
-		Arrays.fill(size, 1, cnt + 1, 0);
-		Arrays.fill(priority, 1, cnt + 1, 0);
-		Arrays.fill(reverse, 1, cnt + 1, false);
-		cnt = 0;
-		head = 0;
-	}
-
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -140,7 +128,6 @@ public static void main(String[] args) throws IOException {
 			out.print(ans[i] + " ");
 		}
 		out.println();
-		clear();
 		out.flush();
 		out.close();
 		br.close();
diff --git a/src/class152/Code03_LiteraryTree2.java b/src/class152/Code03_LiteraryTree2.java
index aa5dd7f03..7d96bd419 100644
--- a/src/class152/Code03_LiteraryTree2.java
+++ b/src/class152/Code03_LiteraryTree2.java
@@ -82,17 +82,6 @@
 //    }
 //}
 //
-//void clear() {
-//    memset(key, 0, sizeof(key));
-//    memset(ls, 0, sizeof(ls));
-//    memset(rs, 0, sizeof(rs));
-//    memset(size, 0, sizeof(size));
-//    memset(priority, 0, sizeof(priority));
-//    memset(rev, 0, sizeof(rev));
-//    cnt = 0;
-//    head = 0;
-//}
-//
 //int main() {
 //	  srand(time(0));
 //    int n, k;
@@ -122,6 +111,5 @@
 //        cout << ans[i] << " ";
 //    }
 //    cout << endl;
-//    clear();
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class152/Code04_FHQTreapPersistent1.java b/src/class152/Code04_FHQTreapPersistent1.java
new file mode 100644
index 000000000..975750e04
--- /dev/null
+++ b/src/class152/Code04_FHQTreapPersistent1.java
@@ -0,0 +1,175 @@
+package class152;
+
+// 可持久化有序表，FHQ-Treap实现，不用词频统计，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3835
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_FHQTreapPersistent1 {
+
+	public static int MAXN = 500001;
+
+	public static int cnt = 0;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] key = new int[MAXN * 50];
+
+	public static int[] left = new int[MAXN * 50];
+
+	public static int[] right = new int[MAXN * 50];
+
+	public static int[] size = new int[MAXN * 50];
+
+	public static double[] priority = new double[MAXN * 50];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int copy(int i) {
+		key[++cnt] = key[i];
+		left[cnt] = left[i];
+		right[cnt] = right[i];
+		size[cnt] = size[i];
+		priority[cnt] = priority[i];
+		return cnt;
+	}
+
+	public static void split(int l, int r, int i, int num) {
+		if (i == 0) {
+			right[l] = left[r] = 0;
+		} else {
+			i = copy(i);
+			if (key[i] <= num) {
+				right[l] = i;
+				split(i, r, right[i], num);
+			} else {
+				left[r] = i;
+				split(l, i, left[i], num);
+			}
+			up(i);
+		}
+	}
+
+	public static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			l = copy(l);
+			right[l] = merge(right[l], r);
+			up(l);
+			return l;
+		} else {
+			r = copy(r);
+			left[r] = merge(l, left[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	public static void add(int v, int i, int num) {
+		split(0, 0, i, num);
+		key[++cnt] = num;
+		size[cnt] = 1;
+		priority[cnt] = Math.random();
+		head[v] = merge(merge(right[0], cnt), left[0]);
+		left[0] = right[0] = 0;
+	}
+
+	public static void remove(int v, int i, int num) {
+		split(0, 0, i, num);
+		int lm = right[0];
+		int r = left[0];
+		left[0] = right[0] = 0;
+		split(0, 0, lm, num - 1);
+		int m = left[0];
+		int l = right[0];
+		left[0] = right[0] = 0;
+		head[v] = merge(merge(l, merge(left[m], right[m])), r);
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + 1 + small(right[i], num);
+		}
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + 1 < x) {
+			return index(right[i], x - size[left[i]] - 1);
+		} else {
+			return key[i];
+		}
+	}
+
+	public static int pre(int i, int num) {
+		if (i == 0) {
+			return Integer.MIN_VALUE + 1;
+		}
+		if (key[i] >= num) {
+			return pre(left[i], num);
+		} else {
+			return Math.max(key[i], pre(right[i], num));
+		}
+	}
+
+	public static int post(int i, int num) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= num) {
+			return post(right[i], num);
+		} else {
+			return Math.min(key[i], post(left[i], num));
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1, version, op, x; i <= n; i++) {
+			in.nextToken();
+			version = (int) in.nval;
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			head[i] = head[version];
+			if (op == 1) {
+				add(i, head[i], x);
+			} else if (op == 2) {
+				remove(i, head[i], x);
+			} else if (op == 3) {
+				out.println(small(head[i], x) + 1);
+			} else if (op == 4) {
+				out.println(index(head[i], x));
+			} else if (op == 5) {
+				out.println(pre(head[i], x));
+			} else {
+				out.println(post(head[i], x));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class152/Code04_FHQTreapPersistent2.java b/src/class152/Code04_FHQTreapPersistent2.java
new file mode 100644
index 000000000..ac445dd40
--- /dev/null
+++ b/src/class152/Code04_FHQTreapPersistent2.java
@@ -0,0 +1,162 @@
+package class152;
+
+// 可持久化有序表，FHQ-Treap实现，不用词频统计，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3835
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <cstdlib>
+//#include <cstring>
+//#include <algorithm>
+//#include <climits>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//
+//int cnt = 0;
+//int head[MAXN];
+//int key[MAXN * 50];
+//int ls[MAXN * 50];
+//int rs[MAXN * 50];
+//int size[MAXN * 50];
+//double priority[MAXN * 50];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//int copy(int i) {
+//    ++cnt;
+//    key[cnt] = key[i];
+//    ls[cnt] = ls[i];
+//    rs[cnt] = rs[i];
+//    size[cnt] = size[i];
+//    priority[cnt] = priority[i];
+//    return cnt;
+//}
+//
+//void split(int l, int r, int i, int num) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        i = copy(i);
+//        if (key[i] <= num) {
+//            rs[l] = i;
+//            split(i, r, rs[i], num);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], num);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        l = copy(l);
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        r = copy(r);
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//void add(int v, int i, int num) {
+//    split(0, 0, i, num);
+//    ++cnt;
+//    key[cnt] = num;
+//    size[cnt] = 1;
+//    priority[cnt] = (double)rand() / RAND_MAX;
+//    head[v] = merge(merge(rs[0], cnt), ls[0]);
+//    ls[0] = rs[0] = 0;
+//}
+//
+//void remove(int v, int i, int num) {
+//    split(0, 0, i, num);
+//    int lm = rs[0];
+//    int r = ls[0];
+//    ls[0] = rs[0] = 0;
+//    split(0, 0, lm, num - 1);
+//    int m = ls[0];
+//    int l = rs[0];
+//    ls[0] = rs[0] = 0;
+//    head[v] = merge(merge(l, merge(ls[m], rs[m])), r);
+//}
+//
+//int small(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return small(ls[i], num);
+//    } else {
+//        return size[ls[i]] + 1 + small(rs[i], num);
+//    }
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + 1 < x) {
+//        return index(rs[i], x - size[ls[i]] - 1);
+//    } else {
+//        return key[i];
+//    }
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN + 1;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int main() {
+//	srand(time(0));
+//    int n;
+//    cin >> n;
+//    for (int i = 1; i <= n; ++i) {
+//        int version, op, x;
+//        cin >> version >> op >> x;
+//        head[i] = head[version];
+//        if (op == 1) {
+//            add(i, head[i], x);
+//        } else if (op == 2) {
+//            remove(i, head[i], x);
+//        } else if (op == 3) {
+//            cout << small(head[i], x) + 1 << "\n";
+//        } else if (op == 4) {
+//            cout << index(head[i], x) << "\n";
+//        } else if (op == 5) {
+//            cout << pre(head[i], x) << "\n";
+//        } else if (op == 6) {
+//            cout << post(head[i], x) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From aa216495507c0d2b149ace3758d33639eaba94de Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Nov 2024 19:05:42 +0800
Subject: [PATCH 0131/1712] modify code

---
 src/class152/Code04_FHQTreapPersistent1.java | 2 +-
 src/class152/Code04_FHQTreapPersistent2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class152/Code04_FHQTreapPersistent1.java b/src/class152/Code04_FHQTreapPersistent1.java
index 975750e04..bfedbffd9 100644
--- a/src/class152/Code04_FHQTreapPersistent1.java
+++ b/src/class152/Code04_FHQTreapPersistent1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 可持久化有序表，FHQ-Treap实现，不用词频统计，java版
+// 可持久化平衡树，FHQ-Treap实现，不用词频统计，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3835
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class152/Code04_FHQTreapPersistent2.java b/src/class152/Code04_FHQTreapPersistent2.java
index ac445dd40..b8313e70e 100644
--- a/src/class152/Code04_FHQTreapPersistent2.java
+++ b/src/class152/Code04_FHQTreapPersistent2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 可持久化有序表，FHQ-Treap实现，不用词频统计，C++版
+// 可持久化平衡树，FHQ-Treap实现，不用词频统计，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3835
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 4c60e6f67f423c79456677cd66313e0209ae2850 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Nov 2024 13:16:00 +0800
Subject: [PATCH 0132/1712] modify code

---
 src/class019/Code06_FastReaderWriter.java    | 256 ++++++++++++++++++
 src/class152/Code01_FHQTreap1.java           |   3 -
 src/class152/Code01_FHQTreap2.java           |   4 -
 src/class152/Code01_FHQTreap3.java           |   3 -
 src/class152/Code01_FHQTreap4.java           |   4 -
 src/class152/Code02_TextEditor1.java         |   5 -
 src/class152/Code02_TextEditor2.java         |   5 -
 src/class152/Code03_LiteraryTree1.java       |   2 -
 src/class152/Code03_LiteraryTree2.java       |   2 -
 src/class152/Code04_FHQTreapPersistent1.java | 264 +++++++++++++++++--
 src/class152/Code04_FHQTreapPersistent2.java |   5 +-
 11 files changed, 503 insertions(+), 50 deletions(-)
 create mode 100644 src/class019/Code06_FastReaderWriter.java

diff --git a/src/class019/Code06_FastReaderWriter.java b/src/class019/Code06_FastReaderWriter.java
new file mode 100644
index 000000000..de275d37b
--- /dev/null
+++ b/src/class019/Code06_FastReaderWriter.java
@@ -0,0 +1,256 @@
+package class019;
+
+// 本文件课上没有讲
+// java同学可以使用FastReader进行快读，可以使用FastWriter进行快写，速度是很快的
+// 如何使用可以参考main函数
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.InputMismatchException;
+
+public class Code06_FastReaderWriter {
+
+	public static void main(String[] args) {
+		FastReader reader = new FastReader(System.in);
+		FastWriter writer = new FastWriter(System.out);
+		System.out.println("输入一个字符：");
+		int cha = reader.readByte(); // reader会读到字符的ASCII码
+		System.out.println("输入一个int类型的数字：");
+		int num1 = reader.readInt(); // reader会读到该数字
+		System.out.println("输入一个long类型的数字：");
+		long num2 = reader.readLong(); // reader会读到该数字
+		System.out.println("打印结果:");
+		writer.println(cha);
+		writer.println(num1);
+		writer.println(num2);
+		writer.close();// close方法包含flush，会把结果刷出去
+	}
+
+	// 快读
+	public static class FastReader {
+		InputStream is;
+		private byte[] inbuf = new byte[1024];
+		public int lenbuf = 0;
+		public int ptrbuf = 0;
+
+		public FastReader(final InputStream is) {
+			this.is = is;
+		}
+
+		public int readByte() {
+			if (lenbuf == -1) {
+				throw new InputMismatchException();
+			}
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++];
+		}
+
+		public int readInt() {
+			return (int) readLong();
+		}
+
+		public long readLong() {
+			long num = 0;
+			int b;
+			boolean minus = false;
+			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+				;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (true) {
+				if (b >= '0' && b <= '9') {
+					num = num * 10 + (b - '0');
+				} else {
+					return minus ? -num : num;
+				}
+				b = readByte();
+			}
+		}
+	}
+
+	// 快写
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private OutputStream out;
+		private Writer writer;
+		private int ptr = 0;
+
+		public FastWriter(Writer writer) {
+			this.writer = new BufferedWriter(writer);
+			out = new ByteArrayOutputStream();
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("FastWriter");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE) {
+				innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE) {
+					innerflush();
+				}
+			});
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L) {
+				return 19;
+			}
+			if (l >= 100000000000000000L) {
+				return 18;
+			}
+			if (l >= 10000000000000000L) {
+				return 17;
+			}
+			if (l >= 1000000000000000L) {
+				return 16;
+			}
+			if (l >= 100000000000000L) {
+				return 15;
+			}
+			if (l >= 10000000000000L) {
+				return 14;
+			}
+			if (l >= 1000000000000L) {
+				return 13;
+			}
+			if (l >= 100000000000L) {
+				return 12;
+			}
+			if (l >= 10000000000L) {
+				return 11;
+			}
+			if (l >= 1000000000L) {
+				return 10;
+			}
+			if (l >= 100000000L) {
+				return 9;
+			}
+			if (l >= 10000000L) {
+				return 8;
+			}
+			if (l >= 1000000L) {
+				return 7;
+			}
+			if (l >= 100000L) {
+				return 6;
+			}
+			if (l >= 10000L) {
+				return 5;
+			}
+			if (l >= 1000L) {
+				return 4;
+			}
+			if (l >= 100L) {
+				return 3;
+			}
+			if (l >= 10L) {
+				return 2;
+			}
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE) {
+				innerflush();
+			}
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException("innerflush");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				if (writer != null) {
+					writer.write(((ByteArrayOutputStream) out).toString());
+					out = new ByteArrayOutputStream();
+					writer.flush();
+				} else {
+					out.flush();
+				}
+			} catch (IOException e) {
+				throw new RuntimeException("flush");
+			}
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public void close() {
+			flush();
+			try {
+				out.close();
+			} catch (Exception e) {
+			}
+		}
+
+	}
+
+}
diff --git a/src/class152/Code01_FHQTreap1.java b/src/class152/Code01_FHQTreap1.java
index dc84530f7..11c38186a 100644
--- a/src/class152/Code01_FHQTreap1.java
+++ b/src/class152/Code01_FHQTreap1.java
@@ -115,7 +115,6 @@ public static void add(int num) {
 			count[cnt] = size[cnt] = 1;
 			priority[cnt] = Math.random();
 			head = merge(merge(right[0], cnt), left[0]);
-			left[0] = right[0] = 0;
 		}
 	}
 
@@ -128,10 +127,8 @@ public static void remove(int num) {
 				split(0, 0, head, num);
 				int lm = right[0];
 				int r = left[0];
-				left[0] = right[0] = 0;
 				split(0, 0, lm, num - 1);
 				int l = right[0];
-				left[0] = right[0] = 0;
 				head = merge(l, r);
 			}
 		}
diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code01_FHQTreap2.java
index 89e935783..d8ea68ae4 100644
--- a/src/class152/Code01_FHQTreap2.java
+++ b/src/class152/Code01_FHQTreap2.java
@@ -85,18 +85,15 @@ public static void add(int num) {
 		size[cnt] = 1;
 		priority[cnt] = Math.random();
 		head = merge(merge(right[0], cnt), left[0]);
-		left[0] = right[0] = 0;
 	}
 
 	public static void remove(int num) {
 		split(0, 0, head, num);
 		int lm = right[0];
 		int r = left[0];
-		left[0] = right[0] = 0;
 		split(0, 0, lm, num - 1);
 		int m = left[0];
 		int l = right[0];
-		left[0] = right[0] = 0;
 		head = merge(merge(l, merge(left[m], right[m])), r);
 	}
 
@@ -104,7 +101,6 @@ public static int rank(int num) {
 		split(0, 0, head, num - 1);
 		int ans = size[right[0]] + 1;
 		head = merge(right[0], left[0]);
-		left[0] = right[0] = 0;
 		return ans;
 	}
 
diff --git a/src/class152/Code01_FHQTreap3.java b/src/class152/Code01_FHQTreap3.java
index 526d8fcff..21a720263 100644
--- a/src/class152/Code01_FHQTreap3.java
+++ b/src/class152/Code01_FHQTreap3.java
@@ -99,7 +99,6 @@
 //        key_count[cnt] = size[cnt] = 1;
 //        priority[cnt] = (double)rand() / RAND_MAX;
 //        head = merge(merge(rs[0], cnt), ls[0]);
-//        ls[0] = rs[0] = 0;
 //    }
 //}
 //
@@ -112,10 +111,8 @@
 //            split(0, 0, head, num);
 //            int lm = rs[0];
 //            int r = ls[0];
-//            ls[0] = rs[0] = 0;
 //            split(0, 0, lm, num - 1);
 //            int l = rs[0];
-//            ls[0] = rs[0] = 0;
 //            head = merge(l, r);
 //        }
 //    }
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code01_FHQTreap4.java
index 736b17b65..ae8dc0992 100644
--- a/src/class152/Code01_FHQTreap4.java
+++ b/src/class152/Code01_FHQTreap4.java
@@ -71,18 +71,15 @@
 //    size[cnt] = 1;
 //    priority[cnt] = (double)rand() / RAND_MAX;
 //    head = merge(merge(rs[0], cnt), ls[0]);
-//    ls[0] = rs[0] = 0;
 //}
 //
 //void remove(int num) {
 //    split(0, 0, head, num);
 //    int lm = rs[0];
 //    int r = ls[0];
-//    ls[0] = rs[0] = 0;
 //    split(0, 0, lm, num - 1);
 //    int m = ls[0];
 //    int l = rs[0];
-//    ls[0] = rs[0] = 0;
 //    head = merge(merge(l, merge(ls[m], rs[m])), r);
 //}
 //
@@ -90,7 +87,6 @@
 //    split(0, 0, head, num - 1);
 //    int ans = size[rs[0]] + 1;
 //    head = merge(rs[0], ls[0]);
-//    ls[0] = rs[0] = 0;
 //    return ans;
 //}
 //
diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code02_TextEditor1.java
index 323f14cb1..8dcdad557 100644
--- a/src/class152/Code02_TextEditor1.java
+++ b/src/class152/Code02_TextEditor1.java
@@ -107,7 +107,6 @@ public static void main(String[] args) throws IOException {
 					split(0, 0, head, pos);
 					l = right[0];
 					r = left[0];
-					left[0] = right[0] = 0;
 					for (int j = 1; j <= len;) {
 						for (char c : input[inputIndex++].toCharArray()) {
 							if (c >= 32 && c <= 126) {
@@ -124,20 +123,16 @@ public static void main(String[] args) throws IOException {
 					split(0, 0, head, pos + len);
 					r = left[0];
 					lm = right[0];
-					left[0] = right[0] = 0;
 					split(0, 0, lm, pos);
 					l = right[0];
-					left[0] = right[0] = 0;
 					head = merge(l, r);
 				} else {
 					split(0, 0, head, pos + len);
 					r = left[0];
 					lm = right[0];
-					left[0] = right[0] = 0;
 					split(0, 0, lm, pos);
 					l = right[0];
 					m = left[0];
-					left[0] = right[0] = 0;
 					ansi = 0;
 					inorder(m);
 					head = merge(merge(l, m), r);
diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code02_TextEditor2.java
index e91f0e8e6..173090afe 100644
--- a/src/class152/Code02_TextEditor2.java
+++ b/src/class152/Code02_TextEditor2.java
@@ -85,7 +85,6 @@
 //            split(0, 0, head, pos);
 //            l = rs[0];
 //            r = ls[0];
-//            ls[0] = rs[0] = 0;
 //            for (int j = 1; j <= len; j++) {
 //                char ch = getchar();
 //                while (ch < 32 || ch > 126) {
@@ -102,21 +101,17 @@
 //            split(0, 0, head, pos + len);
 //            r = ls[0];
 //            lm = rs[0];
-//            ls[0] = rs[0] = 0;
 //            split(0, 0, lm, pos);
 //            l = rs[0];
-//            ls[0] = rs[0] = 0;
 //            head = merge(l, r);
 //        } else {
 //            cin >> len;
 //            split(0, 0, head, pos + len);
 //            r = ls[0];
 //            lm = rs[0];
-//            ls[0] = rs[0] = 0;
 //            split(0, 0, lm, pos);
 //            l = rs[0];
 //            m = ls[0];
-//            ls[0] = rs[0] = 0;
 //            ansi = 0;
 //            inorder(m);
 //            head = merge(merge(l, m), r);
diff --git a/src/class152/Code03_LiteraryTree1.java b/src/class152/Code03_LiteraryTree1.java
index 53e158574..f30902d0e 100644
--- a/src/class152/Code03_LiteraryTree1.java
+++ b/src/class152/Code03_LiteraryTree1.java
@@ -114,11 +114,9 @@ public static void main(String[] args) throws IOException {
 			split(0, 0, head, y);
 			r = left[0];
 			lm = right[0];
-			left[0] = right[0] = 0;
 			split(0, 0, lm, x - 1);
 			l = right[0];
 			m = left[0];
-			left[0] = right[0] = 0;
 			reverse[m] = !reverse[m];
 			head = merge(merge(l, m), r);
 		}
diff --git a/src/class152/Code03_LiteraryTree2.java b/src/class152/Code03_LiteraryTree2.java
index 7d96bd419..4ccdbc811 100644
--- a/src/class152/Code03_LiteraryTree2.java
+++ b/src/class152/Code03_LiteraryTree2.java
@@ -97,11 +97,9 @@
 //        split(0, 0, head, y);
 //        r = ls[0];
 //        lm = rs[0];
-//        ls[0] = rs[0] = 0;
 //        split(0, 0, lm, x - 1);
 //        l = rs[0];
 //        m = ls[0];
-//        ls[0] = rs[0] = 0;
 //        rev[m] ^= 1;
 //        head = merge(merge(l, m), r);
 //    }
diff --git a/src/class152/Code04_FHQTreapPersistent1.java b/src/class152/Code04_FHQTreapPersistent1.java
index bfedbffd9..908815d11 100644
--- a/src/class152/Code04_FHQTreapPersistent1.java
+++ b/src/class152/Code04_FHQTreapPersistent1.java
@@ -4,12 +4,15 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3835
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-import java.io.BufferedReader;
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.StreamTokenizer;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.InputMismatchException;
 
 public class Code04_FHQTreapPersistent1 {
 
@@ -80,18 +83,23 @@ public static void add(int v, int i, int num) {
 		key[++cnt] = num;
 		size[cnt] = 1;
 		priority[cnt] = Math.random();
-		head[v] = merge(merge(right[0], cnt), left[0]);
+		int l = right[0];
+		int r = left[0];
+		// 后续可能基于0版本，去生成新版本的树
+		// 所以这里一定要清空，保证0版本的树正确
 		left[0] = right[0] = 0;
+		head[v] = merge(merge(l, cnt), r);
 	}
 
 	public static void remove(int v, int i, int num) {
 		split(0, 0, i, num);
 		int lm = right[0];
 		int r = left[0];
-		left[0] = right[0] = 0;
 		split(0, 0, lm, num - 1);
 		int m = left[0];
 		int l = right[0];
+		// 后续可能基于0版本，去生成新版本的树
+		// 所以这里一定要清空，保证0版本的树正确
 		left[0] = right[0] = 0;
 		head[v] = merge(merge(l, merge(left[m], right[m])), r);
 	}
@@ -139,19 +147,14 @@ public static int post(int i, int num) {
 		}
 	}
 
-	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		int n = (int) in.nval;
+	public static void main(String[] args) {
+		FastReader in = new FastReader(System.in);
+		FastWriter out = new FastWriter(System.out);
+		int n = in.readInt();
 		for (int i = 1, version, op, x; i <= n; i++) {
-			in.nextToken();
-			version = (int) in.nval;
-			in.nextToken();
-			op = (int) in.nval;
-			in.nextToken();
-			x = (int) in.nval;
+			version = in.readInt();
+			op = in.readInt();
+			x = in.readInt();
 			head[i] = head[version];
 			if (op == 1) {
 				add(i, head[i], x);
@@ -169,7 +172,228 @@ public static void main(String[] args) throws IOException {
 		}
 		out.flush();
 		out.close();
-		br.close();
+	}
+
+	// 快读
+	public static class FastReader {
+		InputStream is;
+		private byte[] inbuf = new byte[1024];
+		public int lenbuf = 0;
+		public int ptrbuf = 0;
+
+		public FastReader(final InputStream is) {
+			this.is = is;
+		}
+
+		public int readByte() {
+			if (lenbuf == -1) {
+				throw new InputMismatchException();
+			}
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++];
+		}
+
+		public int readInt() {
+			return (int) readLong();
+		}
+
+		public long readLong() {
+			long num = 0;
+			int b;
+			boolean minus = false;
+			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+				;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+
+			while (true) {
+				if (b >= '0' && b <= '9') {
+					num = num * 10 + (b - '0');
+				} else {
+					return minus ? -num : num;
+				}
+				b = readByte();
+			}
+		}
+	}
+
+	// 快写
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private OutputStream out;
+		private Writer writer;
+		private int ptr = 0;
+
+		public FastWriter(Writer writer) {
+			this.writer = new BufferedWriter(writer);
+			out = new ByteArrayOutputStream();
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("FastWriter");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE) {
+				innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE) {
+					innerflush();
+				}
+			});
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L) {
+				return 19;
+			}
+			if (l >= 100000000000000000L) {
+				return 18;
+			}
+			if (l >= 10000000000000000L) {
+				return 17;
+			}
+			if (l >= 1000000000000000L) {
+				return 16;
+			}
+			if (l >= 100000000000000L) {
+				return 15;
+			}
+			if (l >= 10000000000000L) {
+				return 14;
+			}
+			if (l >= 1000000000000L) {
+				return 13;
+			}
+			if (l >= 100000000000L) {
+				return 12;
+			}
+			if (l >= 10000000000L) {
+				return 11;
+			}
+			if (l >= 1000000000L) {
+				return 10;
+			}
+			if (l >= 100000000L) {
+				return 9;
+			}
+			if (l >= 10000000L) {
+				return 8;
+			}
+			if (l >= 1000000L) {
+				return 7;
+			}
+			if (l >= 100000L) {
+				return 6;
+			}
+			if (l >= 10000L) {
+				return 5;
+			}
+			if (l >= 1000L) {
+				return 4;
+			}
+			if (l >= 100L) {
+				return 3;
+			}
+			if (l >= 10L) {
+				return 2;
+			}
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE) {
+				innerflush();
+			}
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException("innerflush");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				if (writer != null) {
+					writer.write(((ByteArrayOutputStream) out).toString());
+					out = new ByteArrayOutputStream();
+					writer.flush();
+				} else {
+					out.flush();
+				}
+			} catch (IOException e) {
+				throw new RuntimeException("flush");
+			}
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public void close() {
+			flush();
+			try {
+				out.close();
+			} catch (Exception e) {
+			}
+		}
+
 	}
 
 }
diff --git a/src/class152/Code04_FHQTreapPersistent2.java b/src/class152/Code04_FHQTreapPersistent2.java
index b8313e70e..e20934e20 100644
--- a/src/class152/Code04_FHQTreapPersistent2.java
+++ b/src/class152/Code04_FHQTreapPersistent2.java
@@ -77,15 +77,16 @@
 //    key[cnt] = num;
 //    size[cnt] = 1;
 //    priority[cnt] = (double)rand() / RAND_MAX;
-//    head[v] = merge(merge(rs[0], cnt), ls[0]);
+//    int l = rs[0];
+//    int r = ls[0];
 //    ls[0] = rs[0] = 0;
+//    head[v] = merge(merge(l, cnt), r);
 //}
 //
 //void remove(int v, int i, int num) {
 //    split(0, 0, i, num);
 //    int lm = rs[0];
 //    int r = ls[0];
-//    ls[0] = rs[0] = 0;
 //    split(0, 0, lm, num - 1);
 //    int m = ls[0];
 //    int l = rs[0];

From ddfd55a7ed56965dfe6f1accaab89963fd0876d0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Nov 2024 13:31:27 +0800
Subject: [PATCH 0133/1712] modify code

---
 src/class152/Code02_TextEditor2.java         | 2 +-
 src/class152/Code03_LiteraryTree2.java       | 2 +-
 src/class152/Code04_FHQTreapPersistent2.java | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code02_TextEditor2.java
index 173090afe..338025753 100644
--- a/src/class152/Code02_TextEditor2.java
+++ b/src/class152/Code02_TextEditor2.java
@@ -67,7 +67,7 @@
 //}
 //
 //int main() {
-//	  srand(time(0));
+//    srand(time(0));
 //    int pos = 0, len, l, m, lm, r;
 //    int n;
 //    cin >> n;
diff --git a/src/class152/Code03_LiteraryTree2.java b/src/class152/Code03_LiteraryTree2.java
index 4ccdbc811..b62d73139 100644
--- a/src/class152/Code03_LiteraryTree2.java
+++ b/src/class152/Code03_LiteraryTree2.java
@@ -83,7 +83,7 @@
 //}
 //
 //int main() {
-//	  srand(time(0));
+//    srand(time(0));
 //    int n, k;
 //    cin >> n >> k;
 //    for (int i = 1; i <= n; i++) {
diff --git a/src/class152/Code04_FHQTreapPersistent2.java b/src/class152/Code04_FHQTreapPersistent2.java
index e20934e20..a26a709d2 100644
--- a/src/class152/Code04_FHQTreapPersistent2.java
+++ b/src/class152/Code04_FHQTreapPersistent2.java
@@ -138,7 +138,7 @@
 //}
 //
 //int main() {
-//	srand(time(0));
+//    srand(time(0));
 //    int n;
 //    cin >> n;
 //    for (int i = 1; i <= n; ++i) {

From dccedaade79098f881abe03bac40a4bc4d4dde5b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Nov 2024 16:52:10 +0800
Subject: [PATCH 0134/1712] modify code

---
 src/class152/Code04_FHQTreapPersistent1.java | 6 ++----
 src/class152/Code05.java                     | 5 +++++
 2 files changed, 7 insertions(+), 4 deletions(-)
 create mode 100644 src/class152/Code05.java

diff --git a/src/class152/Code04_FHQTreapPersistent1.java b/src/class152/Code04_FHQTreapPersistent1.java
index 908815d11..f485775e9 100644
--- a/src/class152/Code04_FHQTreapPersistent1.java
+++ b/src/class152/Code04_FHQTreapPersistent1.java
@@ -85,8 +85,7 @@ public static void add(int v, int i, int num) {
 		priority[cnt] = Math.random();
 		int l = right[0];
 		int r = left[0];
-		// 后续可能基于0版本，去生成新版本的树
-		// 所以这里一定要清空，保证0版本的树正确
+		// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 		left[0] = right[0] = 0;
 		head[v] = merge(merge(l, cnt), r);
 	}
@@ -98,8 +97,7 @@ public static void remove(int v, int i, int num) {
 		split(0, 0, lm, num - 1);
 		int m = left[0];
 		int l = right[0];
-		// 后续可能基于0版本，去生成新版本的树
-		// 所以这里一定要清空，保证0版本的树正确
+		// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 		left[0] = right[0] = 0;
 		head[v] = merge(merge(l, merge(left[m], right[m])), r);
 	}
diff --git a/src/class152/Code05.java b/src/class152/Code05.java
new file mode 100644
index 000000000..2c60f0da2
--- /dev/null
+++ b/src/class152/Code05.java
@@ -0,0 +1,5 @@
+package class152;
+
+public class Code05 {
+
+}

From bca566b192c9fd4e705ba49c2718cc9c0a091f4d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Nov 2024 19:40:56 +0800
Subject: [PATCH 0135/1712] modify code

---
 src/class152/Code01_FHQTreap2.java            |   2 +-
 src/class152/Code01_FHQTreap4.java            |   2 +-
 src/class152/Code02_TextEditor1.java          |   4 +-
 src/class152/Code02_TextEditor2.java          |   4 +-
 src/class152/Code03_LiteraryTree1.java        |   2 +-
 src/class152/Code03_LiteraryTree2.java        |   2 +-
 src/class152/Code04_FHQTreapPersistent1.java  |  31 ++--
 src/class152/Code04_FHQTreapPersistent2.java  |  27 +--
 src/class152/Code05.java                      |   5 -
 .../Code05_LiteraryTreePersistent1.java       | 172 ++++++++++++++++++
 .../Code05_LiteraryTreePersistent2.java       | 152 ++++++++++++++++
 11 files changed, 364 insertions(+), 39 deletions(-)
 delete mode 100644 src/class152/Code05.java
 create mode 100644 src/class152/Code05_LiteraryTreePersistent1.java
 create mode 100644 src/class152/Code05_LiteraryTreePersistent2.java

diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code01_FHQTreap2.java
index d8ea68ae4..a9c15859a 100644
--- a/src/class152/Code01_FHQTreap2.java
+++ b/src/class152/Code01_FHQTreap2.java
@@ -92,8 +92,8 @@ public static void remove(int num) {
 		int lm = right[0];
 		int r = left[0];
 		split(0, 0, lm, num - 1);
-		int m = left[0];
 		int l = right[0];
+		int m = left[0];
 		head = merge(merge(l, merge(left[m], right[m])), r);
 	}
 
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code01_FHQTreap4.java
index ae8dc0992..031e4bc73 100644
--- a/src/class152/Code01_FHQTreap4.java
+++ b/src/class152/Code01_FHQTreap4.java
@@ -78,8 +78,8 @@
 //    int lm = rs[0];
 //    int r = ls[0];
 //    split(0, 0, lm, num - 1);
-//    int m = ls[0];
 //    int l = rs[0];
+//    int m = ls[0];
 //    head = merge(merge(l, merge(ls[m], rs[m])), r);
 //}
 //
diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code02_TextEditor1.java
index 8dcdad557..ef22988f9 100644
--- a/src/class152/Code02_TextEditor1.java
+++ b/src/class152/Code02_TextEditor1.java
@@ -121,15 +121,15 @@ public static void main(String[] args) throws IOException {
 					head = merge(l, r);
 				} else if (op.equals("Delete")) {
 					split(0, 0, head, pos + len);
-					r = left[0];
 					lm = right[0];
+					r = left[0];
 					split(0, 0, lm, pos);
 					l = right[0];
 					head = merge(l, r);
 				} else {
 					split(0, 0, head, pos + len);
-					r = left[0];
 					lm = right[0];
+					r = left[0];
 					split(0, 0, lm, pos);
 					l = right[0];
 					m = left[0];
diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code02_TextEditor2.java
index 338025753..e202f3012 100644
--- a/src/class152/Code02_TextEditor2.java
+++ b/src/class152/Code02_TextEditor2.java
@@ -99,16 +99,16 @@
 //        } else if (op[0] == 'D') {
 //            cin >> len;
 //            split(0, 0, head, pos + len);
-//            r = ls[0];
 //            lm = rs[0];
+//            r = ls[0];
 //            split(0, 0, lm, pos);
 //            l = rs[0];
 //            head = merge(l, r);
 //        } else {
 //            cin >> len;
 //            split(0, 0, head, pos + len);
-//            r = ls[0];
 //            lm = rs[0];
+//            r = ls[0];
 //            split(0, 0, lm, pos);
 //            l = rs[0];
 //            m = ls[0];
diff --git a/src/class152/Code03_LiteraryTree1.java b/src/class152/Code03_LiteraryTree1.java
index f30902d0e..0a0cecf12 100644
--- a/src/class152/Code03_LiteraryTree1.java
+++ b/src/class152/Code03_LiteraryTree1.java
@@ -112,8 +112,8 @@ public static void main(String[] args) throws IOException {
 			in.nextToken();
 			y = (int) in.nval;
 			split(0, 0, head, y);
-			r = left[0];
 			lm = right[0];
+			r = left[0];
 			split(0, 0, lm, x - 1);
 			l = right[0];
 			m = left[0];
diff --git a/src/class152/Code03_LiteraryTree2.java b/src/class152/Code03_LiteraryTree2.java
index b62d73139..762c78823 100644
--- a/src/class152/Code03_LiteraryTree2.java
+++ b/src/class152/Code03_LiteraryTree2.java
@@ -95,8 +95,8 @@
 //    for (int i = 1, x, y, l, m, lm, r; i <= k; i++) {
 //        cin >> x >> y;
 //        split(0, 0, head, y);
-//        r = ls[0];
 //        lm = rs[0];
+//        r = ls[0];
 //        split(0, 0, lm, x - 1);
 //        l = rs[0];
 //        m = ls[0];
diff --git a/src/class152/Code04_FHQTreapPersistent1.java b/src/class152/Code04_FHQTreapPersistent1.java
index f485775e9..48215e8cf 100644
--- a/src/class152/Code04_FHQTreapPersistent1.java
+++ b/src/class152/Code04_FHQTreapPersistent1.java
@@ -18,23 +18,21 @@ public class Code04_FHQTreapPersistent1 {
 
 	public static int MAXN = 500001;
 
+	public static int MAXM = MAXN * 50;
+
 	public static int cnt = 0;
 
 	public static int[] head = new int[MAXN];
 
-	public static int[] key = new int[MAXN * 50];
-
-	public static int[] left = new int[MAXN * 50];
+	public static int[] key = new int[MAXM];
 
-	public static int[] right = new int[MAXN * 50];
+	public static int[] left = new int[MAXM];
 
-	public static int[] size = new int[MAXN * 50];
+	public static int[] right = new int[MAXM];
 
-	public static double[] priority = new double[MAXN * 50];
+	public static int[] size = new int[MAXM];
 
-	public static void up(int i) {
-		size[i] = size[left[i]] + size[right[i]] + 1;
-	}
+	public static double[] priority = new double[MAXM];
 
 	public static int copy(int i) {
 		key[++cnt] = key[i];
@@ -45,6 +43,10 @@ public static int copy(int i) {
 		return cnt;
 	}
 
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
 	public static void split(int l, int r, int i, int num) {
 		if (i == 0) {
 			right[l] = left[r] = 0;
@@ -80,13 +82,15 @@ public static int merge(int l, int r) {
 
 	public static void add(int v, int i, int num) {
 		split(0, 0, i, num);
-		key[++cnt] = num;
-		size[cnt] = 1;
-		priority[cnt] = Math.random();
 		int l = right[0];
 		int r = left[0];
 		// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 		left[0] = right[0] = 0;
+		// 建立新节点
+		key[++cnt] = num;
+		size[cnt] = 1;
+		priority[cnt] = Math.random();
+		// 新节点，与其他范围合并
 		head[v] = merge(merge(l, cnt), r);
 	}
 
@@ -95,10 +99,11 @@ public static void remove(int v, int i, int num) {
 		int lm = right[0];
 		int r = left[0];
 		split(0, 0, lm, num - 1);
-		int m = left[0];
 		int l = right[0];
+		int m = left[0];
 		// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 		left[0] = right[0] = 0;
+		// 去掉m号节点，其他范围合并
 		head[v] = merge(merge(l, merge(left[m], right[m])), r);
 	}
 
diff --git a/src/class152/Code04_FHQTreapPersistent2.java b/src/class152/Code04_FHQTreapPersistent2.java
index a26a709d2..5967fc0d0 100644
--- a/src/class152/Code04_FHQTreapPersistent2.java
+++ b/src/class152/Code04_FHQTreapPersistent2.java
@@ -15,18 +15,15 @@
 //using namespace std;
 //
 //const int MAXN = 500001;
+//const int MAXM = MAXN * 50;
 //
 //int cnt = 0;
 //int head[MAXN];
-//int key[MAXN * 50];
-//int ls[MAXN * 50];
-//int rs[MAXN * 50];
-//int size[MAXN * 50];
-//double priority[MAXN * 50];
-//
-//void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
-//}
+//int key[MAXM];
+//int ls[MAXM];
+//int rs[MAXM];
+//int size[MAXM];
+//double priority[MAXM];
 //
 //int copy(int i) {
 //    ++cnt;
@@ -38,6 +35,10 @@
 //    return cnt;
 //}
 //
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
 //void split(int l, int r, int i, int num) {
 //    if (i == 0) {
 //        rs[l] = ls[r] = 0;
@@ -73,13 +74,13 @@
 //
 //void add(int v, int i, int num) {
 //    split(0, 0, i, num);
+//    int l = rs[0];
+//    int r = ls[0];
+//    ls[0] = rs[0] = 0;
 //    ++cnt;
 //    key[cnt] = num;
 //    size[cnt] = 1;
 //    priority[cnt] = (double)rand() / RAND_MAX;
-//    int l = rs[0];
-//    int r = ls[0];
-//    ls[0] = rs[0] = 0;
 //    head[v] = merge(merge(l, cnt), r);
 //}
 //
@@ -88,8 +89,8 @@
 //    int lm = rs[0];
 //    int r = ls[0];
 //    split(0, 0, lm, num - 1);
-//    int m = ls[0];
 //    int l = rs[0];
+//    int m = ls[0];
 //    ls[0] = rs[0] = 0;
 //    head[v] = merge(merge(l, merge(ls[m], rs[m])), r);
 //}
diff --git a/src/class152/Code05.java b/src/class152/Code05.java
deleted file mode 100644
index 2c60f0da2..000000000
--- a/src/class152/Code05.java
+++ /dev/null
@@ -1,5 +0,0 @@
-package class152;
-
-public class Code05 {
-
-}
diff --git a/src/class152/Code05_LiteraryTreePersistent1.java b/src/class152/Code05_LiteraryTreePersistent1.java
new file mode 100644
index 000000000..f9561286d
--- /dev/null
+++ b/src/class152/Code05_LiteraryTreePersistent1.java
@@ -0,0 +1,172 @@
+package class152;
+
+// 可持久化文艺平衡树(java版)
+// 测试链接 : https://www.luogu.com.cn/problem/P5055
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code05_LiteraryTreePersistent1 {
+
+	public static int MAXN = 200001;
+
+	public static int MAXM = MAXN * 80;
+
+	public static int cnt = 0;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] key = new int[MAXM];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	public static int[] size = new int[MAXM];
+
+	public static boolean[] reverse = new boolean[MAXM];
+
+	public static long[] sum = new long[MAXM];
+
+	public static double[] priority = new double[MAXM];
+
+	public static int copy(int i) {
+		key[++cnt] = key[i];
+		left[cnt] = left[i];
+		right[cnt] = right[i];
+		size[cnt] = size[i];
+		reverse[cnt] = reverse[i];
+		sum[cnt] = sum[i];
+		priority[cnt] = priority[i];
+		return cnt;
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+		sum[i] = sum[left[i]] + sum[right[i]] + key[i];
+	}
+
+	public static void down(int i) {
+		if (reverse[i]) {
+			if (left[i] != 0) {
+				left[i] = copy(left[i]);
+				reverse[left[i]] = !reverse[left[i]];
+			}
+			if (right[i] != 0) {
+				right[i] = copy(right[i]);
+				reverse[right[i]] = !reverse[right[i]];
+			}
+			int tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+			reverse[i] = false;
+		}
+	}
+
+	public static void split(int l, int r, int i, int rank) {
+		if (i == 0) {
+			right[l] = left[r] = 0;
+		} else {
+			down(i);
+			i = copy(i);
+			if (size[left[i]] + 1 <= rank) {
+				right[l] = i;
+				split(i, r, right[i], rank - size[left[i]] - 1);
+			} else {
+				left[r] = i;
+				split(l, i, left[i], rank);
+			}
+			up(i);
+		}
+	}
+
+	public static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			down(l);
+			l = copy(l);
+			right[l] = merge(right[l], r);
+			up(l);
+			return l;
+		} else {
+			down(r);
+			r = copy(r);
+			left[r] = merge(l, left[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		long lastAns = 0;
+		for (int i = 1, version, op, x = 0, y = 0, l, m, lm, r; i <= n; i++) {
+			in.nextToken();
+			version = (int) in.nval;
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) ((long) in.nval ^ lastAns);
+			if (op != 2) {
+				in.nextToken();
+				y = (int) ((long) in.nval ^ lastAns);
+			}
+			if (op == 1) {
+				split(0, 0, head[version], x);
+				l = right[0];
+				r = left[0];
+				left[0] = right[0] = 0;
+				key[++cnt] = (int) y;
+				size[cnt] = 1;
+				sum[cnt] = y;
+				priority[cnt] = Math.random();
+				head[i] = merge(merge(l, cnt), r);
+			} else if (op == 2) {
+				split(0, 0, head[version], x);
+				lm = right[0];
+				r = left[0];
+				split(0, 0, lm, x - 1);
+				l = right[0];
+				m = left[0];
+				left[0] = right[0] = 0;
+				head[i] = merge(l, r);
+			} else if (op == 3) {
+				split(0, 0, head[version], y);
+				lm = right[0];
+				r = left[0];
+				split(0, 0, lm, x - 1);
+				l = right[0];
+				m = left[0];
+				left[0] = right[0] = 0;
+				reverse[m] = !reverse[m];
+				head[i] = merge(merge(l, m), r);
+			} else {
+				split(0, 0, head[version], y);
+				lm = right[0];
+				r = left[0];
+				split(0, 0, lm, x - 1);
+				l = right[0];
+				m = left[0];
+				lastAns = sum[m];
+				left[0] = right[0] = 0;
+				out.println(lastAns);
+				head[i] = merge(merge(l, m), r);
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class152/Code05_LiteraryTreePersistent2.java b/src/class152/Code05_LiteraryTreePersistent2.java
new file mode 100644
index 000000000..abb0e11b4
--- /dev/null
+++ b/src/class152/Code05_LiteraryTreePersistent2.java
@@ -0,0 +1,152 @@
+package class152;
+
+// 可持久化文艺平衡树(C++版)
+// 测试链接 : https://www.luogu.com.cn/problem/P5055
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <cstdlib>
+//#include <ctime>
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXM = MAXN * 80;
+//
+//int cnt = 0;
+//int head[MAXN];
+//int key[MAXM];
+//int ls[MAXM];
+//int rs[MAXM];
+//int size[MAXM];
+//bool rev[MAXM];
+//long long sum[MAXM];
+//double priority[MAXM];
+//
+//int copy(int i) {
+//    key[++cnt] = key[i];
+//    ls[cnt] = ls[i];
+//    rs[cnt] = rs[i];
+//    size[cnt] = size[i];
+//    rev[cnt] = rev[i];
+//    sum[cnt] = sum[i];
+//    priority[cnt] = priority[i];
+//    return cnt;
+//}
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    sum[i] = sum[ls[i]] + sum[rs[i]] + key[i];
+//}
+//
+//void down(int i) {
+//    if (rev[i]) {
+//        if (ls[i] != 0) {
+//            ls[i] = copy(ls[i]);
+//            rev[ls[i]] ^= 1;
+//        }
+//        if (rs[i] != 0) {
+//            rs[i] = copy(rs[i]);
+//            rev[rs[i]] ^= 1;
+//        }
+//        swap(ls[i], rs[i]);
+//        rev[i] = false;
+//    }
+//}
+//
+//void split(int l, int r, int i, int rank) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        down(i);
+//        i = copy(i);
+//        if (size[ls[i]] + 1 <= rank) {
+//            rs[l] = i;
+//            split(i, r, rs[i], rank - size[ls[i]] - 1);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], rank);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        down(l);
+//        l = copy(l);
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        down(r);
+//        r = copy(r);
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//int main() {
+//    srand(time(0));
+//    int n;
+//    cin >> n;
+//    long long lastAns = 0;
+//    for (int i = 1; i <= n; i++) {
+//        int version, op;
+//        long long x, y = 0;
+//        cin >> version >> op >> x;
+//        x ^= lastAns;
+//        if (op != 2) {
+//            cin >> y;
+//            y ^= lastAns;
+//        }
+//        int l, m, lm, r;
+//        if (op == 1) {
+//            split(0, 0, head[version], x);
+//            l = rs[0];
+//            r = ls[0];
+//            ls[0] = rs[0] = 0;
+//            key[++cnt] = y;
+//            size[cnt] = 1;
+//            sum[cnt] = y;
+//            priority[cnt] = (double)rand() / RAND_MAX;
+//            head[i] = merge(merge(l, cnt), r);
+//        } else if (op == 2) {
+//            split(0, 0, head[version], x);
+//            lm = rs[0];
+//            r = ls[0];
+//            split(0, 0, lm, x - 1);
+//            l = rs[0];
+//            m = ls[0];
+//            ls[0] = rs[0] = 0;
+//            head[i] = merge(l, r);
+//        } else if (op == 3) {
+//            split(0, 0, head[version], y);
+//            lm = rs[0];
+//            r = ls[0];
+//            split(0, 0, lm, x - 1);
+//            l = rs[0];
+//            m = ls[0];
+//            ls[0] = rs[0] = 0;
+//            rev[m] ^= 1;
+//            head[i] = merge(merge(l, m), r);
+//        } else {
+//            split(0, 0, head[version], y);
+//            lm = rs[0];
+//            r = ls[0];
+//            split(0, 0, lm, x - 1);
+//            l = rs[0];
+//            m = ls[0];
+//            lastAns = sum[m];
+//            ls[0] = rs[0] = 0;
+//            cout << lastAns << endl;
+//            head[i] = merge(merge(l, m), r);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From abd15815cd0628c35da2904843d8a8cd07d7050a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Nov 2024 19:48:49 +0800
Subject: [PATCH 0136/1712] modify code

---
 src/class152/Code04_FHQTreapPersistent1.java     | 3 ---
 src/class152/Code05_LiteraryTreePersistent1.java | 6 +++++-
 src/class152/Code05_LiteraryTreePersistent2.java | 2 +-
 3 files changed, 6 insertions(+), 5 deletions(-)

diff --git a/src/class152/Code04_FHQTreapPersistent1.java b/src/class152/Code04_FHQTreapPersistent1.java
index 48215e8cf..0bfb6375e 100644
--- a/src/class152/Code04_FHQTreapPersistent1.java
+++ b/src/class152/Code04_FHQTreapPersistent1.java
@@ -86,11 +86,9 @@ public static void add(int v, int i, int num) {
 		int r = left[0];
 		// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 		left[0] = right[0] = 0;
-		// 建立新节点
 		key[++cnt] = num;
 		size[cnt] = 1;
 		priority[cnt] = Math.random();
-		// 新节点，与其他范围合并
 		head[v] = merge(merge(l, cnt), r);
 	}
 
@@ -103,7 +101,6 @@ public static void remove(int v, int i, int num) {
 		int m = left[0];
 		// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 		left[0] = right[0] = 0;
-		// 去掉m号节点，其他范围合并
 		head[v] = merge(merge(l, merge(left[m], right[m])), r);
 	}
 
diff --git a/src/class152/Code05_LiteraryTreePersistent1.java b/src/class152/Code05_LiteraryTreePersistent1.java
index f9561286d..984264bf9 100644
--- a/src/class152/Code05_LiteraryTreePersistent1.java
+++ b/src/class152/Code05_LiteraryTreePersistent1.java
@@ -126,6 +126,7 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, head[version], x);
 				l = right[0];
 				r = left[0];
+				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 				left[0] = right[0] = 0;
 				key[++cnt] = (int) y;
 				size[cnt] = 1;
@@ -139,6 +140,7 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, lm, x - 1);
 				l = right[0];
 				m = left[0];
+				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 				left[0] = right[0] = 0;
 				head[i] = merge(l, r);
 			} else if (op == 3) {
@@ -148,6 +150,7 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, lm, x - 1);
 				l = right[0];
 				m = left[0];
+				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 				left[0] = right[0] = 0;
 				reverse[m] = !reverse[m];
 				head[i] = merge(merge(l, m), r);
@@ -158,8 +161,9 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, lm, x - 1);
 				l = right[0];
 				m = left[0];
-				lastAns = sum[m];
+				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
 				left[0] = right[0] = 0;
+				lastAns = sum[m];
 				out.println(lastAns);
 				head[i] = merge(merge(l, m), r);
 			}
diff --git a/src/class152/Code05_LiteraryTreePersistent2.java b/src/class152/Code05_LiteraryTreePersistent2.java
index abb0e11b4..57dfe9d6c 100644
--- a/src/class152/Code05_LiteraryTreePersistent2.java
+++ b/src/class152/Code05_LiteraryTreePersistent2.java
@@ -142,8 +142,8 @@
 //            split(0, 0, lm, x - 1);
 //            l = rs[0];
 //            m = ls[0];
-//            lastAns = sum[m];
 //            ls[0] = rs[0] = 0;
+//            lastAns = sum[m];
 //            cout << lastAns << endl;
 //            head[i] = merge(merge(l, m), r);
 //        }

From 1069ae294cc3c9bc84899bf832576b72d45c1784 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Nov 2024 19:52:43 +0800
Subject: [PATCH 0137/1712] modify code

---
 ...FHQTreapPersistent1.java => Code04_PersistentFHQTreap1.java} | 2 +-
 ...FHQTreapPersistent2.java => Code04_PersistentFHQTreap2.java} | 0
 ...TreePersistent1.java => Code05_PersistentLiteraryTree1.java} | 2 +-
 ...TreePersistent2.java => Code05_PersistentLiteraryTree2.java} | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class152/{Code04_FHQTreapPersistent1.java => Code04_PersistentFHQTreap1.java} (99%)
 rename src/class152/{Code04_FHQTreapPersistent2.java => Code04_PersistentFHQTreap2.java} (100%)
 rename src/class152/{Code05_LiteraryTreePersistent1.java => Code05_PersistentLiteraryTree1.java} (98%)
 rename src/class152/{Code05_LiteraryTreePersistent2.java => Code05_PersistentLiteraryTree2.java} (100%)

diff --git a/src/class152/Code04_FHQTreapPersistent1.java b/src/class152/Code04_PersistentFHQTreap1.java
similarity index 99%
rename from src/class152/Code04_FHQTreapPersistent1.java
rename to src/class152/Code04_PersistentFHQTreap1.java
index 0bfb6375e..b8ba7deaa 100644
--- a/src/class152/Code04_FHQTreapPersistent1.java
+++ b/src/class152/Code04_PersistentFHQTreap1.java
@@ -14,7 +14,7 @@
 import java.io.Writer;
 import java.util.InputMismatchException;
 
-public class Code04_FHQTreapPersistent1 {
+public class Code04_PersistentFHQTreap1 {
 
 	public static int MAXN = 500001;
 
diff --git a/src/class152/Code04_FHQTreapPersistent2.java b/src/class152/Code04_PersistentFHQTreap2.java
similarity index 100%
rename from src/class152/Code04_FHQTreapPersistent2.java
rename to src/class152/Code04_PersistentFHQTreap2.java
diff --git a/src/class152/Code05_LiteraryTreePersistent1.java b/src/class152/Code05_PersistentLiteraryTree1.java
similarity index 98%
rename from src/class152/Code05_LiteraryTreePersistent1.java
rename to src/class152/Code05_PersistentLiteraryTree1.java
index 984264bf9..b64f34db8 100644
--- a/src/class152/Code05_LiteraryTreePersistent1.java
+++ b/src/class152/Code05_PersistentLiteraryTree1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_LiteraryTreePersistent1 {
+public class Code05_PersistentLiteraryTree1 {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class152/Code05_LiteraryTreePersistent2.java b/src/class152/Code05_PersistentLiteraryTree2.java
similarity index 100%
rename from src/class152/Code05_LiteraryTreePersistent2.java
rename to src/class152/Code05_PersistentLiteraryTree2.java

From 1f2ccb129c3ac5d480ae958f25b2b40892d006db Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 13:02:33 +0800
Subject: [PATCH 0138/1712] modify code

---
 .../{Code01_FHQTreap1.java => Code01_FHQTreapWithCount1.java} | 2 +-
 .../{Code01_FHQTreap3.java => Code01_FHQTreapWithCount2.java} | 0
 ...ode01_FHQTreap2.java => Code02_FHQTreapWithoutCount1.java} | 2 +-
 ...ode01_FHQTreap4.java => Code02_FHQTreapWithoutCount2.java} | 0
 .../{Code02_TextEditor1.java => Code03_TextEditor1.java}      | 4 ++--
 .../{Code02_TextEditor2.java => Code03_TextEditor2.java}      | 0
 .../{Code03_LiteraryTree1.java => Code04_LiteraryTree1.java}  | 2 +-
 .../{Code03_LiteraryTree2.java => Code04_LiteraryTree2.java}  | 0
 ...rsistentFHQTreap1.java => Code05_PersistentFHQTreap1.java} | 2 +-
 ...rsistentFHQTreap2.java => Code05_PersistentFHQTreap2.java} | 0
 ...LiteraryTree1.java => Code06_PersistentLiteraryTree1.java} | 2 +-
 ...LiteraryTree2.java => Code06_PersistentLiteraryTree2.java} | 0
 12 files changed, 7 insertions(+), 7 deletions(-)
 rename src/class152/{Code01_FHQTreap1.java => Code01_FHQTreapWithCount1.java} (99%)
 rename src/class152/{Code01_FHQTreap3.java => Code01_FHQTreapWithCount2.java} (100%)
 rename src/class152/{Code01_FHQTreap2.java => Code02_FHQTreapWithoutCount1.java} (98%)
 rename src/class152/{Code01_FHQTreap4.java => Code02_FHQTreapWithoutCount2.java} (100%)
 rename src/class152/{Code02_TextEditor1.java => Code03_TextEditor1.java} (97%)
 rename src/class152/{Code02_TextEditor2.java => Code03_TextEditor2.java} (100%)
 rename src/class152/{Code03_LiteraryTree1.java => Code04_LiteraryTree1.java} (98%)
 rename src/class152/{Code03_LiteraryTree2.java => Code04_LiteraryTree2.java} (100%)
 rename src/class152/{Code04_PersistentFHQTreap1.java => Code05_PersistentFHQTreap1.java} (99%)
 rename src/class152/{Code04_PersistentFHQTreap2.java => Code05_PersistentFHQTreap2.java} (100%)
 rename src/class152/{Code05_PersistentLiteraryTree1.java => Code06_PersistentLiteraryTree1.java} (98%)
 rename src/class152/{Code05_PersistentLiteraryTree2.java => Code06_PersistentLiteraryTree2.java} (100%)

diff --git a/src/class152/Code01_FHQTreap1.java b/src/class152/Code01_FHQTreapWithCount1.java
similarity index 99%
rename from src/class152/Code01_FHQTreap1.java
rename to src/class152/Code01_FHQTreapWithCount1.java
index 11c38186a..5f1706631 100644
--- a/src/class152/Code01_FHQTreap1.java
+++ b/src/class152/Code01_FHQTreapWithCount1.java
@@ -20,7 +20,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code01_FHQTreap1 {
+public class Code01_FHQTreapWithCount1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class152/Code01_FHQTreap3.java b/src/class152/Code01_FHQTreapWithCount2.java
similarity index 100%
rename from src/class152/Code01_FHQTreap3.java
rename to src/class152/Code01_FHQTreapWithCount2.java
diff --git a/src/class152/Code01_FHQTreap2.java b/src/class152/Code02_FHQTreapWithoutCount1.java
similarity index 98%
rename from src/class152/Code01_FHQTreap2.java
rename to src/class152/Code02_FHQTreapWithoutCount1.java
index a9c15859a..339d8c331 100644
--- a/src/class152/Code01_FHQTreap2.java
+++ b/src/class152/Code02_FHQTreapWithoutCount1.java
@@ -20,7 +20,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code01_FHQTreap2 {
+public class Code02_FHQTreapWithoutCount1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class152/Code01_FHQTreap4.java b/src/class152/Code02_FHQTreapWithoutCount2.java
similarity index 100%
rename from src/class152/Code01_FHQTreap4.java
rename to src/class152/Code02_FHQTreapWithoutCount2.java
diff --git a/src/class152/Code02_TextEditor1.java b/src/class152/Code03_TextEditor1.java
similarity index 97%
rename from src/class152/Code02_TextEditor1.java
rename to src/class152/Code03_TextEditor1.java
index ef22988f9..84758367f 100644
--- a/src/class152/Code02_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -5,7 +5,7 @@
 // 如下实现是正确的，但java的版本无法通过所有测试用例
 // 这是洛谷平台没有照顾各种语言的实现所导致的
 // java的实现空间就是无法达标，C++的实现完全一样的逻辑，就是可以达标
-// C++版本是Code02_TextEditor2文件，可以通过所有测试用例
+// C++版本是Code03_TextEditor2文件，可以通过所有测试用例
 // 在真正笔试、比赛时，一定是兼顾各种语言的，该实现是一定正确的
 
 import java.io.BufferedReader;
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_TextEditor1 {
+public class Code03_TextEditor1 {
 
 	public static int MAXN = 2000001;
 
diff --git a/src/class152/Code02_TextEditor2.java b/src/class152/Code03_TextEditor2.java
similarity index 100%
rename from src/class152/Code02_TextEditor2.java
rename to src/class152/Code03_TextEditor2.java
diff --git a/src/class152/Code03_LiteraryTree1.java b/src/class152/Code04_LiteraryTree1.java
similarity index 98%
rename from src/class152/Code03_LiteraryTree1.java
rename to src/class152/Code04_LiteraryTree1.java
index 0a0cecf12..0b32fcf4e 100644
--- a/src/class152/Code03_LiteraryTree1.java
+++ b/src/class152/Code04_LiteraryTree1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_LiteraryTree1 {
+public class Code04_LiteraryTree1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class152/Code03_LiteraryTree2.java b/src/class152/Code04_LiteraryTree2.java
similarity index 100%
rename from src/class152/Code03_LiteraryTree2.java
rename to src/class152/Code04_LiteraryTree2.java
diff --git a/src/class152/Code04_PersistentFHQTreap1.java b/src/class152/Code05_PersistentFHQTreap1.java
similarity index 99%
rename from src/class152/Code04_PersistentFHQTreap1.java
rename to src/class152/Code05_PersistentFHQTreap1.java
index b8ba7deaa..80013bbb0 100644
--- a/src/class152/Code04_PersistentFHQTreap1.java
+++ b/src/class152/Code05_PersistentFHQTreap1.java
@@ -14,7 +14,7 @@
 import java.io.Writer;
 import java.util.InputMismatchException;
 
-public class Code04_PersistentFHQTreap1 {
+public class Code05_PersistentFHQTreap1 {
 
 	public static int MAXN = 500001;
 
diff --git a/src/class152/Code04_PersistentFHQTreap2.java b/src/class152/Code05_PersistentFHQTreap2.java
similarity index 100%
rename from src/class152/Code04_PersistentFHQTreap2.java
rename to src/class152/Code05_PersistentFHQTreap2.java
diff --git a/src/class152/Code05_PersistentLiteraryTree1.java b/src/class152/Code06_PersistentLiteraryTree1.java
similarity index 98%
rename from src/class152/Code05_PersistentLiteraryTree1.java
rename to src/class152/Code06_PersistentLiteraryTree1.java
index b64f34db8..04c65387c 100644
--- a/src/class152/Code05_PersistentLiteraryTree1.java
+++ b/src/class152/Code06_PersistentLiteraryTree1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_PersistentLiteraryTree1 {
+public class Code06_PersistentLiteraryTree1 {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class152/Code05_PersistentLiteraryTree2.java b/src/class152/Code06_PersistentLiteraryTree2.java
similarity index 100%
rename from src/class152/Code05_PersistentLiteraryTree2.java
rename to src/class152/Code06_PersistentLiteraryTree2.java

From 5f20d01f4eb2769fdc5346a70d74b81f2193efce Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 13:14:24 +0800
Subject: [PATCH 0139/1712] modify code

---
 src/class152/Code01_FHQTreapWithCount1.java    | 2 +-
 src/class152/Code01_FHQTreapWithCount2.java    | 2 +-
 src/class152/Code02_FHQTreapWithoutCount1.java | 2 +-
 src/class152/Code02_FHQTreapWithoutCount2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class152/Code01_FHQTreapWithCount1.java b/src/class152/Code01_FHQTreapWithCount1.java
index 5f1706631..86656c283 100644
--- a/src/class152/Code01_FHQTreapWithCount1.java
+++ b/src/class152/Code01_FHQTreapWithCount1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，使用词频统计，java版
+// FHQ-Treap，使用词频压缩，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code01_FHQTreapWithCount2.java b/src/class152/Code01_FHQTreapWithCount2.java
index 21a720263..3b46fdbab 100644
--- a/src/class152/Code01_FHQTreapWithCount2.java
+++ b/src/class152/Code01_FHQTreapWithCount2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，使用词频统计，C++版
+// FHQ-Treap，使用词频压缩，C++版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code02_FHQTreapWithoutCount1.java b/src/class152/Code02_FHQTreapWithoutCount1.java
index 339d8c331..412faa172 100644
--- a/src/class152/Code02_FHQTreapWithoutCount1.java
+++ b/src/class152/Code02_FHQTreapWithoutCount1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，不用词频统计，java版
+// FHQ-Treap，不用词频压缩，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code02_FHQTreapWithoutCount2.java b/src/class152/Code02_FHQTreapWithoutCount2.java
index 031e4bc73..97948a497 100644
--- a/src/class152/Code02_FHQTreapWithoutCount2.java
+++ b/src/class152/Code02_FHQTreapWithoutCount2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，不用词频统计，C++版
+// FHQ-Treap，不用词频压缩，C++版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个

From 00b35418d92e204e25b82b8c5b23c7170c1e3002 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 15:01:20 +0800
Subject: [PATCH 0140/1712] modify code

---
 src/class152/Code03_TextEditor1.java             |  9 +++++++++
 src/class152/Code03_TextEditor2.java             |  9 +++++++++
 src/class152/Code04_LiteraryTree1.java           |  4 ++++
 src/class152/Code04_LiteraryTree2.java           |  4 ++++
 src/class152/Code05_PersistentFHQTreap1.java     | 13 ++++++++++++-
 src/class152/Code05_PersistentFHQTreap2.java     | 13 ++++++++++++-
 src/class152/Code06_PersistentLiteraryTree1.java | 13 +++++++++++--
 src/class152/Code06_PersistentLiteraryTree2.java |  9 +++++++++
 8 files changed, 70 insertions(+), 4 deletions(-)

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index 84758367f..88b3d3b6b 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -1,6 +1,15 @@
 package class152;
 
 // 文本编辑器(java版本)
+// 一开始文本为空，光标在文本开头，也就是0位置，请实现如下6种操作
+// Move k     : 将光标移动到第k个字符之后，如果k=0将光标移到文本开头
+// Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
+// Delete n   : 删除光标后的n个字符，光标位置不变
+// Get n      : 输出光标后的n个字符，光标位置不变
+// Prev       : 光标前移一个字符
+// Next       : 光标后移一个字符
+// Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
+// Delete、Get操作执行时光标后有足够的字符，Move、Prev、Next保证光标不会到非法位置
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 如下实现是正确的，但java的版本无法通过所有测试用例
 // 这是洛谷平台没有照顾各种语言的实现所导致的
diff --git a/src/class152/Code03_TextEditor2.java b/src/class152/Code03_TextEditor2.java
index e202f3012..e844d7a39 100644
--- a/src/class152/Code03_TextEditor2.java
+++ b/src/class152/Code03_TextEditor2.java
@@ -1,6 +1,15 @@
 package class152;
 
 // 文本编辑器(C++版本)
+// 一开始文本为空，光标在文本开头，也就是0位置，请实现如下6种操作
+// Move k     : 将光标移动到第k个字符之后，如果k=0将光标移到文本开头
+// Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
+// Delete n   : 删除光标后的n个字符，光标位置不变
+// Get n      : 输出光标后的n个字符，光标位置不变
+// Prev       : 光标前移一个字符
+// Next       : 光标后移一个字符
+// Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
+// Delete、Get操作执行时光标后有足够的字符，Move、Prev、Next保证光标不会到非法位置
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class152/Code04_LiteraryTree1.java b/src/class152/Code04_LiteraryTree1.java
index 0b32fcf4e..7aa068a29 100644
--- a/src/class152/Code04_LiteraryTree1.java
+++ b/src/class152/Code04_LiteraryTree1.java
@@ -1,6 +1,10 @@
 package class152;
 
 // 文艺平衡树(java版)
+// 长度为n的序列，下标从1开始，一开始序列为1, 2, ..., n
+// 接下来会有k个操作，每个操作给定l，r，表示从l到r范围上的所有数字翻转
+// 做完k次操作后，从左到右打印所有数字
+// 1 <= n, k <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3391
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class152/Code04_LiteraryTree2.java b/src/class152/Code04_LiteraryTree2.java
index 762c78823..6f8c82189 100644
--- a/src/class152/Code04_LiteraryTree2.java
+++ b/src/class152/Code04_LiteraryTree2.java
@@ -1,6 +1,10 @@
 package class152;
 
 // 文艺平衡树(C++版)
+// 长度为n的序列，下标从1开始，一开始序列为1, 2, ..., n
+// 接下来会有k个操作，每个操作给定l，r，表示从l到r范围上的所有数字翻转
+// 做完k次操作后，从左到右打印所有数字
+// 1 <= n, k <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3391
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class152/Code05_PersistentFHQTreap1.java b/src/class152/Code05_PersistentFHQTreap1.java
index 80013bbb0..b4c16be6a 100644
--- a/src/class152/Code05_PersistentFHQTreap1.java
+++ b/src/class152/Code05_PersistentFHQTreap1.java
@@ -1,6 +1,17 @@
 package class152;
 
-// 可持久化平衡树，FHQ-Treap实现，不用词频统计，java版
+// 可持久化平衡树，FHQ-Treap实现，不用词频压缩，java版
+// 认为一开始是0版本的树，为空树，实现如下操作，操作一共发生n次
+// v 1 x : 基于v版本的树，增加一个x，生成新版本的树
+// v 2 x : 基于v版本的树，删除一个x，生成新版本的树
+// v 3 x : 基于v版本的树，查询x的排名，生成新版本的树=v版本
+// v 4 x : 基于v版本的树，查询数据中排名为x的数，生成新版本的树=v版本
+// v 5 x : 基于v版本的树，查询x的前驱，生成新版本的树=v版本
+// v 6 x : 基于v版本的树，查询x的后继，生成新版本的树=v版本
+// 不管什么操作，都基于某个v版本，操作完成后得到新版本的树，但v版本不会变化
+// 如果x的前驱不存在，返回-2^31 + 1，如果x的后继不存在，返回+2^31 - 1
+// 1 <= n <= 5 * 10^5
+// -10^9 <= x <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3835
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class152/Code05_PersistentFHQTreap2.java b/src/class152/Code05_PersistentFHQTreap2.java
index 5967fc0d0..588956c3e 100644
--- a/src/class152/Code05_PersistentFHQTreap2.java
+++ b/src/class152/Code05_PersistentFHQTreap2.java
@@ -1,6 +1,17 @@
 package class152;
 
-// 可持久化平衡树，FHQ-Treap实现，不用词频统计，C++版
+// 可持久化平衡树，FHQ-Treap实现，不用词频压缩，C++版
+// 认为一开始是0版本的树，为空树，实现如下操作，操作一共发生n次
+// v 1 x : 基于v版本的树，增加一个x，生成新版本的树
+// v 2 x : 基于v版本的树，删除一个x，生成新版本的树
+// v 3 x : 基于v版本的树，查询x的排名，生成新版本的树=v版本
+// v 4 x : 基于v版本的树，查询数据中排名为x的数，生成新版本的树=v版本
+// v 5 x : 基于v版本的树，查询x的前驱，生成新版本的树=v版本
+// v 6 x : 基于v版本的树，查询x的后继，生成新版本的树=v版本
+// 不管什么操作，都基于某个v版本，操作完成后得到新版本的树，但v版本不会变化
+// 如果x的前驱不存在，返回-2^31 + 1，如果x的后继不存在，返回+2^31 - 1
+// 1 <= n <= 5 * 10^5
+// -10^9 <= x <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3835
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class152/Code06_PersistentLiteraryTree1.java b/src/class152/Code06_PersistentLiteraryTree1.java
index 04c65387c..74e5f1cb3 100644
--- a/src/class152/Code06_PersistentLiteraryTree1.java
+++ b/src/class152/Code06_PersistentLiteraryTree1.java
@@ -1,6 +1,15 @@
 package class152;
 
 // 可持久化文艺平衡树(java版)
+// 一开始序列为空，实现如下操作，操作一共发生n次
+// v 1 x y : 基于v版本的序列，在第x个数后插入y，生成新版本的序列
+// v 2 x   : 基于v版本的序列，删除第x个数，生成新版本的序列
+// v 3 x y : 基于v版本的序列，范围[x,y]所有数字翻转，生成新版本的序列
+// v 4 x y : 基于v版本的序列，查询范围[x,y]所有数字的和，生成新版本的序列=v版本
+// 不管什么操作，都基于某个v版本，操作完成后得到新版本的序列，但v版本不会变化
+// 每种操作给定的参数都是有效的，插入数字的范围[-10^6, +10^6]
+// 1 <= n <= 2 * 10^5
+// 本题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5055
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -117,10 +126,10 @@ public static void main(String[] args) throws IOException {
 			in.nextToken();
 			op = (int) in.nval;
 			in.nextToken();
-			x = (int) ((long) in.nval ^ lastAns);
+			x = (int) ((long) in.nval ^ lastAns); // 强制在线的规则
 			if (op != 2) {
 				in.nextToken();
-				y = (int) ((long) in.nval ^ lastAns);
+				y = (int) ((long) in.nval ^ lastAns); // 强制在线的规则
 			}
 			if (op == 1) {
 				split(0, 0, head[version], x);
diff --git a/src/class152/Code06_PersistentLiteraryTree2.java b/src/class152/Code06_PersistentLiteraryTree2.java
index 57dfe9d6c..e7516a542 100644
--- a/src/class152/Code06_PersistentLiteraryTree2.java
+++ b/src/class152/Code06_PersistentLiteraryTree2.java
@@ -1,6 +1,15 @@
 package class152;
 
 // 可持久化文艺平衡树(C++版)
+// 一开始序列为空，实现如下操作，操作一共发生n次
+// v 1 x y : 基于v版本的序列，在第x个数后插入y，生成新版本的序列
+// v 2 x   : 基于v版本的序列，删除第x个数，生成新版本的序列
+// v 3 x y : 基于v版本的序列，范围[x,y]所有数字翻转，生成新版本的序列
+// v 4 x y : 基于v版本的序列，查询范围[x,y]所有数字的和，生成新版本的序列=v版本
+// 不管什么操作，都基于某个v版本，操作完成后得到新版本的序列，但v版本不会变化
+// 每种操作给定的参数都是有效的，插入数字的范围[-10^6, +10^6]
+// 1 <= n <= 2 * 10^5
+// 本题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5055
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 7704050476556565a34d308e34f24bc1fc7ac631 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 15:19:59 +0800
Subject: [PATCH 0141/1712] modify code

---
 src/class152/Code03_TextEditor1.java   | 2 +-
 src/class152/Code03_TextEditor2.java   | 2 +-
 src/class152/Code04_LiteraryTree1.java | 2 +-
 src/class152/Code04_LiteraryTree2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index 88b3d3b6b..733afc6d8 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 文本编辑器(java版本)
+// 文本编辑器，FHQ-Treap实现区间移动，java版本
 // 一开始文本为空，光标在文本开头，也就是0位置，请实现如下6种操作
 // Move k     : 将光标移动到第k个字符之后，如果k=0将光标移到文本开头
 // Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
diff --git a/src/class152/Code03_TextEditor2.java b/src/class152/Code03_TextEditor2.java
index e844d7a39..06d22e765 100644
--- a/src/class152/Code03_TextEditor2.java
+++ b/src/class152/Code03_TextEditor2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 文本编辑器(C++版本)
+// 文本编辑器，FHQ-Treap实现区间移动，C++版本
 // 一开始文本为空，光标在文本开头，也就是0位置，请实现如下6种操作
 // Move k     : 将光标移动到第k个字符之后，如果k=0将光标移到文本开头
 // Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
diff --git a/src/class152/Code04_LiteraryTree1.java b/src/class152/Code04_LiteraryTree1.java
index 7aa068a29..72b220f0b 100644
--- a/src/class152/Code04_LiteraryTree1.java
+++ b/src/class152/Code04_LiteraryTree1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 文艺平衡树(java版)
+// 文艺平衡树，FHQ-Treap实现范围翻转，java版本
 // 长度为n的序列，下标从1开始，一开始序列为1, 2, ..., n
 // 接下来会有k个操作，每个操作给定l，r，表示从l到r范围上的所有数字翻转
 // 做完k次操作后，从左到右打印所有数字
diff --git a/src/class152/Code04_LiteraryTree2.java b/src/class152/Code04_LiteraryTree2.java
index 6f8c82189..a4f915d83 100644
--- a/src/class152/Code04_LiteraryTree2.java
+++ b/src/class152/Code04_LiteraryTree2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 文艺平衡树(C++版)
+// 文艺平衡树，FHQ-Treap实现范围翻转，C++版本
 // 长度为n的序列，下标从1开始，一开始序列为1, 2, ..., n
 // 接下来会有k个操作，每个操作给定l，r，表示从l到r范围上的所有数字翻转
 // 做完k次操作后，从左到右打印所有数字

From 10b74f3a351e65c8591eb8f1d6f8c5c7dc39550c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 15:23:43 +0800
Subject: [PATCH 0142/1712] modify code

---
 src/class152/Code02_FHQTreapWithoutCount1.java   | 2 +-
 src/class152/Code02_FHQTreapWithoutCount2.java   | 2 +-
 src/class152/Code06_PersistentLiteraryTree1.java | 2 +-
 src/class152/Code06_PersistentLiteraryTree2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class152/Code02_FHQTreapWithoutCount1.java b/src/class152/Code02_FHQTreapWithoutCount1.java
index 412faa172..4fb6e6a44 100644
--- a/src/class152/Code02_FHQTreapWithoutCount1.java
+++ b/src/class152/Code02_FHQTreapWithoutCount1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，不用词频压缩，java版
+// FHQ-Treap，不用词频压缩，FHQ-Treap最常规的实现，java版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code02_FHQTreapWithoutCount2.java b/src/class152/Code02_FHQTreapWithoutCount2.java
index 97948a497..75da7c2ac 100644
--- a/src/class152/Code02_FHQTreapWithoutCount2.java
+++ b/src/class152/Code02_FHQTreapWithoutCount2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// FHQ-Treap，不用词频压缩，C++版
+// FHQ-Treap，不用词频压缩，FHQ-Treap最常规的实现，C++版
 // 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
 // 1，增加x，重复加入算多个词频
 // 2，删除x，如果有多个，只删掉一个
diff --git a/src/class152/Code06_PersistentLiteraryTree1.java b/src/class152/Code06_PersistentLiteraryTree1.java
index 74e5f1cb3..a7cbebc10 100644
--- a/src/class152/Code06_PersistentLiteraryTree1.java
+++ b/src/class152/Code06_PersistentLiteraryTree1.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 可持久化文艺平衡树(java版)
+// 可持久化文艺平衡树，FHQ-Treap实现，java版
 // 一开始序列为空，实现如下操作，操作一共发生n次
 // v 1 x y : 基于v版本的序列，在第x个数后插入y，生成新版本的序列
 // v 2 x   : 基于v版本的序列，删除第x个数，生成新版本的序列
diff --git a/src/class152/Code06_PersistentLiteraryTree2.java b/src/class152/Code06_PersistentLiteraryTree2.java
index e7516a542..3ed2ec2fa 100644
--- a/src/class152/Code06_PersistentLiteraryTree2.java
+++ b/src/class152/Code06_PersistentLiteraryTree2.java
@@ -1,6 +1,6 @@
 package class152;
 
-// 可持久化文艺平衡树(C++版)
+// 可持久化文艺平衡树，FHQ-Treap实现，C++版
 // 一开始序列为空，实现如下操作，操作一共发生n次
 // v 1 x y : 基于v版本的序列，在第x个数后插入y，生成新版本的序列
 // v 2 x   : 基于v版本的序列，删除第x个数，生成新版本的序列

From 9889485ffac0df7aaf2845e2f4bfbd61b1d26967 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 15:34:25 +0800
Subject: [PATCH 0143/1712] modify code

---
 src/class152/Code03_TextEditor1.java | 13 ++++++-------
 src/class152/Code03_TextEditor2.java | 13 ++++++-------
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index 733afc6d8..90caace1f 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -1,15 +1,14 @@
 package class152;
 
 // 文本编辑器，FHQ-Treap实现区间移动，java版本
-// 一开始文本为空，光标在文本开头，也就是0位置，请实现如下6种操作
-// Move k     : 将光标移动到第k个字符之后，如果k=0将光标移到文本开头
+// 一开始文本为空，光标在文本开头，也就是1位置，请实现如下6种操作
+// Move k     : 将光标移动到第k个字符之后，操作保证光标不会到非法位置
 // Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
-// Delete n   : 删除光标后的n个字符，光标位置不变
-// Get n      : 输出光标后的n个字符，光标位置不变
-// Prev       : 光标前移一个字符
-// Next       : 光标后移一个字符
+// Delete n   : 删除光标后的n个字符，光标位置不变，操作保证有足够字符
+// Get n      : 输出光标后的n个字符，光标位置不变，操作保证有足够字符
+// Prev       : 光标前移一个字符，操作保证光标不会到非法位置
+// Next       : 光标后移一个字符，操作保证光标不会到非法位置
 // Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
-// Delete、Get操作执行时光标后有足够的字符，Move、Prev、Next保证光标不会到非法位置
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 如下实现是正确的，但java的版本无法通过所有测试用例
 // 这是洛谷平台没有照顾各种语言的实现所导致的
diff --git a/src/class152/Code03_TextEditor2.java b/src/class152/Code03_TextEditor2.java
index 06d22e765..cb3bd74ef 100644
--- a/src/class152/Code03_TextEditor2.java
+++ b/src/class152/Code03_TextEditor2.java
@@ -1,15 +1,14 @@
 package class152;
 
 // 文本编辑器，FHQ-Treap实现区间移动，C++版本
-// 一开始文本为空，光标在文本开头，也就是0位置，请实现如下6种操作
-// Move k     : 将光标移动到第k个字符之后，如果k=0将光标移到文本开头
+// 一开始文本为空，光标在文本开头，也就是1位置，请实现如下6种操作
+// Move k     : 将光标移动到第k个字符之后，操作保证光标不会到非法位置
 // Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
-// Delete n   : 删除光标后的n个字符，光标位置不变
-// Get n      : 输出光标后的n个字符，光标位置不变
-// Prev       : 光标前移一个字符
-// Next       : 光标后移一个字符
+// Delete n   : 删除光标后的n个字符，光标位置不变，操作保证有足够字符
+// Get n      : 输出光标后的n个字符，光标位置不变，操作保证有足够字符
+// Prev       : 光标前移一个字符，操作保证光标不会到非法位置
+// Next       : 光标后移一个字符，操作保证光标不会到非法位置
 // Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
-// Delete、Get操作执行时光标后有足够的字符，Move、Prev、Next保证光标不会到非法位置
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 5420d992bb69f60fe6ce85c3356a0950cdc7f195 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 16:10:31 +0800
Subject: [PATCH 0144/1712] modify code

---
 src/class152/Code06_PersistentLiteraryTree1.java | 12 ++++--------
 1 file changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/class152/Code06_PersistentLiteraryTree1.java b/src/class152/Code06_PersistentLiteraryTree1.java
index a7cbebc10..374e1dc94 100644
--- a/src/class152/Code06_PersistentLiteraryTree1.java
+++ b/src/class152/Code06_PersistentLiteraryTree1.java
@@ -135,8 +135,7 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, head[version], x);
 				l = right[0];
 				r = left[0];
-				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
-				left[0] = right[0] = 0;
+				left[0] = right[0] = 0; // 保证0版本始终是空树
 				key[++cnt] = (int) y;
 				size[cnt] = 1;
 				sum[cnt] = y;
@@ -149,8 +148,7 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, lm, x - 1);
 				l = right[0];
 				m = left[0];
-				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
-				left[0] = right[0] = 0;
+				left[0] = right[0] = 0; // 保证0版本始终是空树
 				head[i] = merge(l, r);
 			} else if (op == 3) {
 				split(0, 0, head[version], y);
@@ -159,8 +157,7 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, lm, x - 1);
 				l = right[0];
 				m = left[0];
-				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
-				left[0] = right[0] = 0;
+				left[0] = right[0] = 0; // 保证0版本始终是空树
 				reverse[m] = !reverse[m];
 				head[i] = merge(merge(l, m), r);
 			} else {
@@ -170,8 +167,7 @@ public static void main(String[] args) throws IOException {
 				split(0, 0, lm, x - 1);
 				l = right[0];
 				m = left[0];
-				// 后续可能基于0版本，去生成新版本的树，所以一定要清空，保证0版本始终是空树
-				left[0] = right[0] = 0;
+				left[0] = right[0] = 0; // 保证0版本始终是空树
 				lastAns = sum[m];
 				out.println(lastAns);
 				head[i] = merge(merge(l, m), r);

From 67489752fa3c8c94b3718e3045745384a0d59d75 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Nov 2024 21:38:23 +0800
Subject: [PATCH 0145/1712] modify code

---
 src/class152/Code02_FHQTreapWithoutCount1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class152/Code02_FHQTreapWithoutCount1.java b/src/class152/Code02_FHQTreapWithoutCount1.java
index 4fb6e6a44..cc294bbbd 100644
--- a/src/class152/Code02_FHQTreapWithoutCount1.java
+++ b/src/class152/Code02_FHQTreapWithoutCount1.java
@@ -39,7 +39,7 @@ public class Code02_FHQTreapWithoutCount1 {
 	// 右孩子
 	public static int[] right = new int[MAXN];
 
-	// 数字总数
+	// 节点总数
 	public static int[] size = new int[MAXN];
 
 	// 节点优先级

From 2c8c3a0dda0cd2ead267a6ca7fa821e92a989a52 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 22 Nov 2024 15:52:32 +0800
Subject: [PATCH 0146/1712] modify code

---
 src/class152/Code05_PersistentFHQTreap1.java     | 8 ++++----
 src/class152/Code05_PersistentFHQTreap2.java     | 8 ++++----
 src/class152/Code06_PersistentLiteraryTree1.java | 2 +-
 src/class152/Code06_PersistentLiteraryTree2.java | 2 +-
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class152/Code05_PersistentFHQTreap1.java b/src/class152/Code05_PersistentFHQTreap1.java
index b4c16be6a..b276873b6 100644
--- a/src/class152/Code05_PersistentFHQTreap1.java
+++ b/src/class152/Code05_PersistentFHQTreap1.java
@@ -4,10 +4,10 @@
 // 认为一开始是0版本的树，为空树，实现如下操作，操作一共发生n次
 // v 1 x : 基于v版本的树，增加一个x，生成新版本的树
 // v 2 x : 基于v版本的树，删除一个x，生成新版本的树
-// v 3 x : 基于v版本的树，查询x的排名，生成新版本的树=v版本
-// v 4 x : 基于v版本的树，查询数据中排名为x的数，生成新版本的树=v版本
-// v 5 x : 基于v版本的树，查询x的前驱，生成新版本的树=v版本
-// v 6 x : 基于v版本的树，查询x的后继，生成新版本的树=v版本
+// v 3 x : 基于v版本的树，查询x的排名，生成新版本的树状况=v版本状况
+// v 4 x : 基于v版本的树，查询数据中排名为x的数，生成新版本的树状况=v版本状况
+// v 5 x : 基于v版本的树，查询x的前驱，生成新版本的树状况=v版本状况
+// v 6 x : 基于v版本的树，查询x的后继，生成新版本的树状况=v版本状况
 // 不管什么操作，都基于某个v版本，操作完成后得到新版本的树，但v版本不会变化
 // 如果x的前驱不存在，返回-2^31 + 1，如果x的后继不存在，返回+2^31 - 1
 // 1 <= n <= 5 * 10^5
diff --git a/src/class152/Code05_PersistentFHQTreap2.java b/src/class152/Code05_PersistentFHQTreap2.java
index 588956c3e..a7772dc58 100644
--- a/src/class152/Code05_PersistentFHQTreap2.java
+++ b/src/class152/Code05_PersistentFHQTreap2.java
@@ -4,10 +4,10 @@
 // 认为一开始是0版本的树，为空树，实现如下操作，操作一共发生n次
 // v 1 x : 基于v版本的树，增加一个x，生成新版本的树
 // v 2 x : 基于v版本的树，删除一个x，生成新版本的树
-// v 3 x : 基于v版本的树，查询x的排名，生成新版本的树=v版本
-// v 4 x : 基于v版本的树，查询数据中排名为x的数，生成新版本的树=v版本
-// v 5 x : 基于v版本的树，查询x的前驱，生成新版本的树=v版本
-// v 6 x : 基于v版本的树，查询x的后继，生成新版本的树=v版本
+// v 3 x : 基于v版本的树，查询x的排名，生成新版本的树状况=v版本状况
+// v 4 x : 基于v版本的树，查询数据中排名为x的数，生成新版本的树状况=v版本状况
+// v 5 x : 基于v版本的树，查询x的前驱，生成新版本的树状况=v版本状况
+// v 6 x : 基于v版本的树，查询x的后继，生成新版本的树状况=v版本状况
 // 不管什么操作，都基于某个v版本，操作完成后得到新版本的树，但v版本不会变化
 // 如果x的前驱不存在，返回-2^31 + 1，如果x的后继不存在，返回+2^31 - 1
 // 1 <= n <= 5 * 10^5
diff --git a/src/class152/Code06_PersistentLiteraryTree1.java b/src/class152/Code06_PersistentLiteraryTree1.java
index 374e1dc94..bc2e0325d 100644
--- a/src/class152/Code06_PersistentLiteraryTree1.java
+++ b/src/class152/Code06_PersistentLiteraryTree1.java
@@ -5,7 +5,7 @@
 // v 1 x y : 基于v版本的序列，在第x个数后插入y，生成新版本的序列
 // v 2 x   : 基于v版本的序列，删除第x个数，生成新版本的序列
 // v 3 x y : 基于v版本的序列，范围[x,y]所有数字翻转，生成新版本的序列
-// v 4 x y : 基于v版本的序列，查询范围[x,y]所有数字的和，生成新版本的序列=v版本
+// v 4 x y : 基于v版本的序列，查询范围[x,y]所有数字的和，生成新版本的序列状况=v版本状况
 // 不管什么操作，都基于某个v版本，操作完成后得到新版本的序列，但v版本不会变化
 // 每种操作给定的参数都是有效的，插入数字的范围[-10^6, +10^6]
 // 1 <= n <= 2 * 10^5
diff --git a/src/class152/Code06_PersistentLiteraryTree2.java b/src/class152/Code06_PersistentLiteraryTree2.java
index 3ed2ec2fa..8961064ee 100644
--- a/src/class152/Code06_PersistentLiteraryTree2.java
+++ b/src/class152/Code06_PersistentLiteraryTree2.java
@@ -5,7 +5,7 @@
 // v 1 x y : 基于v版本的序列，在第x个数后插入y，生成新版本的序列
 // v 2 x   : 基于v版本的序列，删除第x个数，生成新版本的序列
 // v 3 x y : 基于v版本的序列，范围[x,y]所有数字翻转，生成新版本的序列
-// v 4 x y : 基于v版本的序列，查询范围[x,y]所有数字的和，生成新版本的序列=v版本
+// v 4 x y : 基于v版本的序列，查询范围[x,y]所有数字的和，生成新版本的序列状况=v版本状况
 // 不管什么操作，都基于某个v版本，操作完成后得到新版本的序列，但v版本不会变化
 // 每种操作给定的参数都是有效的，插入数字的范围[-10^6, +10^6]
 // 1 <= n <= 2 * 10^5

From b36a3510a1c84377fc65a12f7bf09d35b06a557d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 22 Nov 2024 16:11:59 +0800
Subject: [PATCH 0147/1712] modify code

---
 src/class152/Code05_PersistentFHQTreap1.java | 22 ++++++++++--------
 src/class152/Code05_PersistentFHQTreap2.java | 24 +++++++++++---------
 2 files changed, 25 insertions(+), 21 deletions(-)

diff --git a/src/class152/Code05_PersistentFHQTreap1.java b/src/class152/Code05_PersistentFHQTreap1.java
index b276873b6..f1ade670a 100644
--- a/src/class152/Code05_PersistentFHQTreap1.java
+++ b/src/class152/Code05_PersistentFHQTreap1.java
@@ -166,19 +166,21 @@ public static void main(String[] args) {
 			version = in.readInt();
 			op = in.readInt();
 			x = in.readInt();
-			head[i] = head[version];
 			if (op == 1) {
-				add(i, head[i], x);
+				add(i, head[version], x);
 			} else if (op == 2) {
-				remove(i, head[i], x);
-			} else if (op == 3) {
-				out.println(small(head[i], x) + 1);
-			} else if (op == 4) {
-				out.println(index(head[i], x));
-			} else if (op == 5) {
-				out.println(pre(head[i], x));
+				remove(i, head[version], x);
 			} else {
-				out.println(post(head[i], x));
+				head[i] = head[version];
+				if (op == 3) {
+					out.println(small(head[i], x) + 1);
+				} else if (op == 4) {
+					out.println(index(head[i], x));
+				} else if (op == 5) {
+					out.println(pre(head[i], x));
+				} else {
+					out.println(post(head[i], x));
+				}
 			}
 		}
 		out.flush();
diff --git a/src/class152/Code05_PersistentFHQTreap2.java b/src/class152/Code05_PersistentFHQTreap2.java
index a7772dc58..7381c13d1 100644
--- a/src/class152/Code05_PersistentFHQTreap2.java
+++ b/src/class152/Code05_PersistentFHQTreap2.java
@@ -156,19 +156,21 @@
 //    for (int i = 1; i <= n; ++i) {
 //        int version, op, x;
 //        cin >> version >> op >> x;
-//        head[i] = head[version];
 //        if (op == 1) {
-//            add(i, head[i], x);
+//            add(i, head[version], x);
 //        } else if (op == 2) {
-//            remove(i, head[i], x);
-//        } else if (op == 3) {
-//            cout << small(head[i], x) + 1 << "\n";
-//        } else if (op == 4) {
-//            cout << index(head[i], x) << "\n";
-//        } else if (op == 5) {
-//            cout << pre(head[i], x) << "\n";
-//        } else if (op == 6) {
-//            cout << post(head[i], x) << "\n";
+//            remove(i, head[version], x);
+//        } else {
+//            head[i] = head[version];
+//            if (op == 3) {
+//                cout << small(head[i], x) + 1 << "\n";
+//            } else if (op == 4) {
+//                cout << index(head[i], x) << "\n";
+//            } else if (op == 5) {
+//                cout << pre(head[i], x) << "\n";
+//            } else {
+//                cout << post(head[i], x) << "\n";
+//            }
 //        }
 //    }
 //    return 0;

From a2394832662835703878d4e1a7ffb1015cfd3cfc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 22 Nov 2024 16:14:22 +0800
Subject: [PATCH 0148/1712] modify code

---
 src/class152/Code05_PersistentFHQTreap1.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/class152/Code05_PersistentFHQTreap1.java b/src/class152/Code05_PersistentFHQTreap1.java
index f1ade670a..f060e7c15 100644
--- a/src/class152/Code05_PersistentFHQTreap1.java
+++ b/src/class152/Code05_PersistentFHQTreap1.java
@@ -91,6 +91,9 @@ public static int merge(int l, int r) {
 		}
 	}
 
+	// v : 新生成的版本编号
+	// i : 基于的历史版本，树的头节点编号
+	// num : 加入的数字
 	public static void add(int v, int i, int num) {
 		split(0, 0, i, num);
 		int l = right[0];
@@ -103,6 +106,9 @@ public static void add(int v, int i, int num) {
 		head[v] = merge(merge(l, cnt), r);
 	}
 
+	// v : 新生成的版本编号
+	// i : 基于的历史版本，树的头节点编号
+	// num : 加入的数字
 	public static void remove(int v, int i, int num) {
 		split(0, 0, i, num);
 		int lm = right[0];

From 91458b13ffc0921b11ff41fd268c4fb4a8070255 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 22 Nov 2024 16:32:12 +0800
Subject: [PATCH 0149/1712] modify code

---
 src/class152/Code06_PersistentLiteraryTree1.java | 8 ++++----
 src/class152/Code06_PersistentLiteraryTree2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class152/Code06_PersistentLiteraryTree1.java b/src/class152/Code06_PersistentLiteraryTree1.java
index bc2e0325d..9f2056a5e 100644
--- a/src/class152/Code06_PersistentLiteraryTree1.java
+++ b/src/class152/Code06_PersistentLiteraryTree1.java
@@ -24,7 +24,7 @@ public class Code06_PersistentLiteraryTree1 {
 
 	public static int MAXN = 200001;
 
-	public static int MAXM = MAXN * 80;
+	public static int MAXM = MAXN * 100;
 
 	public static int cnt = 0;
 
@@ -81,8 +81,8 @@ public static void split(int l, int r, int i, int rank) {
 		if (i == 0) {
 			right[l] = left[r] = 0;
 		} else {
-			down(i);
 			i = copy(i);
+			down(i);
 			if (size[left[i]] + 1 <= rank) {
 				right[l] = i;
 				split(i, r, right[i], rank - size[left[i]] - 1);
@@ -99,14 +99,14 @@ public static int merge(int l, int r) {
 			return l + r;
 		}
 		if (priority[l] >= priority[r]) {
-			down(l);
 			l = copy(l);
+			down(l);
 			right[l] = merge(right[l], r);
 			up(l);
 			return l;
 		} else {
-			down(r);
 			r = copy(r);
+			down(r);
 			left[r] = merge(l, left[r]);
 			up(r);
 			return r;
diff --git a/src/class152/Code06_PersistentLiteraryTree2.java b/src/class152/Code06_PersistentLiteraryTree2.java
index 8961064ee..142051f9b 100644
--- a/src/class152/Code06_PersistentLiteraryTree2.java
+++ b/src/class152/Code06_PersistentLiteraryTree2.java
@@ -21,7 +21,7 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//const int MAXM = MAXN * 80;
+//const int MAXM = MAXN * 100;
 //
 //int cnt = 0;
 //int head[MAXN];
@@ -68,8 +68,8 @@
 //    if (i == 0) {
 //        rs[l] = ls[r] = 0;
 //    } else {
-//        down(i);
 //        i = copy(i);
+//        down(i);
 //        if (size[ls[i]] + 1 <= rank) {
 //            rs[l] = i;
 //            split(i, r, rs[i], rank - size[ls[i]] - 1);
@@ -86,14 +86,14 @@
 //        return l + r;
 //    }
 //    if (priority[l] >= priority[r]) {
-//        down(l);
 //        l = copy(l);
+//        down(l);
 //        rs[l] = merge(rs[l], r);
 //        up(l);
 //        return l;
 //    } else {
-//        down(r);
 //        r = copy(r);
+//        down(r);
 //        ls[r] = merge(l, ls[r]);
 //        up(r);
 //        return r;

From 3964d4e958ca696aa356027e945d35d1f352caf1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 22 Nov 2024 17:16:45 +0800
Subject: [PATCH 0150/1712] modify code

---
 ...250\344\270\223\351\242\2305-FHQ Treap.pptx" | Bin 0 -> 54362 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243152\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2305-FHQ Treap.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243152\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2305-FHQ Treap.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243152\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2305-FHQ Treap.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..0de3a278288c95610a8f78fe1b351310ec59950a
GIT binary patch
literal 54362
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
P!22h#ULyJC*SG%%!ca?H

literal 0
HcmV?d00001


From f61143e59bedd2155ce27abc29897782b2be32d4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Nov 2024 13:36:57 +0800
Subject: [PATCH 0151/1712] modify code

---
 src/class148/{AVL1.java => Code01_AVL1.java}  |   2 +-
 src/class148/{AVL2.java => Code01_AVL2.java}  |  12 +-
 ...e.java => Code02_ReconstructionQueue.java} |   2 +-
 src/class148/Code03_Followup1.java            | 263 ++++++++++++++++++
 src/class148/Code03_Followup2.java            | 241 ++++++++++++++++
 ...owDetails.java => Code01_ShowDetails.java} |   2 +-
 ...ScapeGoat1.java => Code02_ScapeGoat1.java} |   2 +-
 ...ScapeGoat2.java => Code02_ScapeGoat2.java} |   2 -
 src/class150/Code03_Followup1.java            | 261 +++++++++++++++++
 src/class150/Code03_Followup2.java            | 234 ++++++++++++++++
 10 files changed, 1009 insertions(+), 12 deletions(-)
 rename src/class148/{AVL1.java => Code01_AVL1.java} (99%)
 rename src/class148/{AVL2.java => Code01_AVL2.java} (96%)
 rename src/class148/{ReconstructionQueue.java => Code02_ReconstructionQueue.java} (98%)
 create mode 100644 src/class148/Code03_Followup1.java
 create mode 100644 src/class148/Code03_Followup2.java
 rename src/class150/{ShowDetails.java => Code01_ShowDetails.java} (99%)
 rename src/class150/{ScapeGoat1.java => Code02_ScapeGoat1.java} (99%)
 rename src/class150/{ScapeGoat2.java => Code02_ScapeGoat2.java} (98%)
 create mode 100644 src/class150/Code03_Followup1.java
 create mode 100644 src/class150/Code03_Followup2.java

diff --git a/src/class148/AVL1.java b/src/class148/Code01_AVL1.java
similarity index 99%
rename from src/class148/AVL1.java
rename to src/class148/Code01_AVL1.java
index c186fc0cc..9e3b64f94 100644
--- a/src/class148/AVL1.java
+++ b/src/class148/Code01_AVL1.java
@@ -21,7 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class AVL1 {
+public class Code01_AVL1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class148/AVL2.java b/src/class148/Code01_AVL2.java
similarity index 96%
rename from src/class148/AVL2.java
rename to src/class148/Code01_AVL2.java
index 475836d59..9b046a864 100644
--- a/src/class148/AVL2.java
+++ b/src/class148/Code01_AVL2.java
@@ -159,17 +159,17 @@
 //    }
 //}
 //
-//int getIndex(int i, int x) {
+//int index(int i, int x) {
 //    if (size[ls[i]] >= x) {
-//        return getIndex(ls[i], x);
+//        return index(ls[i], x);
 //    } else if (size[ls[i]] + key_count[i] < x) {
-//        return getIndex(rs[i], x - size[ls[i]] - key_count[i]);
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
 //
-//int getIndex(int x) {
-//    return getIndex(head, x);
+//int index(int x) {
+//    return index(head, x);
 //}
 //
 //int pre(int i, int num) {
@@ -225,7 +225,7 @@
 //        } else if (op == 3) {
 //            cout << getRank(x) << endl;
 //        } else if (op == 4) {
-//            cout << getIndex(x) << endl;
+//            cout << index(x) << endl;
 //        } else if (op == 5) {
 //            cout << pre(x) << endl;
 //        } else {
diff --git a/src/class148/ReconstructionQueue.java b/src/class148/Code02_ReconstructionQueue.java
similarity index 98%
rename from src/class148/ReconstructionQueue.java
rename to src/class148/Code02_ReconstructionQueue.java
index df7a2da78..45917ee8f 100644
--- a/src/class148/ReconstructionQueue.java
+++ b/src/class148/Code02_ReconstructionQueue.java
@@ -9,7 +9,7 @@
 // 返回其中一种排列即可，本题的数据保证一定存在这样的排列
 // 题解中的绝大多数方法，时间复杂度O(n平方)，但是时间复杂度能做到O(n * log n)
 // 测试链接 : https://leetcode.cn/problems/queue-reconstruction-by-height/
-public class ReconstructionQueue {
+public class Code02_ReconstructionQueue {
 
 	public static int[][] reconstructQueue(int[][] people) {
 		Arrays.sort(people, (a, b) -> a[0] != b[0] ? (b[0] - a[0]) : (a[1] - b[1]));
diff --git a/src/class148/Code03_Followup1.java b/src/class148/Code03_Followup1.java
new file mode 100644
index 000000000..69df83e92
--- /dev/null
+++ b/src/class148/Code03_Followup1.java
@@ -0,0 +1,263 @@
+package class148;
+
+// AVL实现普通有序表，数据加强的测试，java版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_Followup1 {
+
+	public static int MAXN = 2000001;
+
+	public static int cnt = 0;
+
+	public static int head = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] height = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] count = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		height[i] = Math.max(height[left[i]], height[right[i]]) + 1;
+	}
+
+	public static int leftRotate(int i) {
+		int r = right[i];
+		right[i] = left[r];
+		left[r] = i;
+		up(i);
+		up(r);
+		return r;
+	}
+
+	public static int rightRotate(int i) {
+		int l = left[i];
+		left[i] = right[l];
+		right[l] = i;
+		up(i);
+		up(l);
+		return l;
+	}
+
+	public static int maintain(int i) {
+		int lh = height[left[i]];
+		int rh = height[right[i]];
+		if (lh - rh > 1) {
+			if (height[left[left[i]]] >= height[right[left[i]]]) {
+				i = rightRotate(i);
+			} else {
+				left[i] = leftRotate(left[i]);
+				i = rightRotate(i);
+			}
+		} else if (rh - lh > 1) {
+			if (height[right[right[i]]] >= height[left[right[i]]]) {
+				i = leftRotate(i);
+			} else {
+				right[i] = rightRotate(right[i]);
+				i = leftRotate(i);
+			}
+		}
+		return i;
+	}
+
+	public static void add(int num) {
+		head = add(head, num);
+	}
+
+	public static int add(int i, int num) {
+		if (i == 0) {
+			key[++cnt] = num;
+			count[cnt] = size[cnt] = height[cnt] = 1;
+			return cnt;
+		}
+		if (key[i] == num) {
+			count[i]++;
+		} else if (key[i] > num) {
+			left[i] = add(left[i], num);
+		} else {
+			right[i] = add(right[i], num);
+		}
+		up(i);
+		return maintain(i);
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			head = remove(head, num);
+		}
+	}
+
+	public static int remove(int i, int num) {
+		if (key[i] < num) {
+			right[i] = remove(right[i], num);
+		} else if (key[i] > num) {
+			left[i] = remove(left[i], num);
+		} else {
+			if (count[i] > 1) {
+				count[i]--;
+			} else {
+				if (left[i] == 0 && right[i] == 0) {
+					return 0;
+				} else if (left[i] != 0 && right[i] == 0) {
+					i = left[i];
+				} else if (left[i] == 0 && right[i] != 0) {
+					i = right[i];
+				} else {
+					int mostLeft = right[i];
+					while (left[mostLeft] != 0) {
+						mostLeft = left[mostLeft];
+					}
+					right[i] = removeMostLeft(right[i], mostLeft);
+					left[mostLeft] = left[i];
+					right[mostLeft] = right[i];
+					i = mostLeft;
+				}
+			}
+		}
+		up(i);
+		return maintain(i);
+	}
+
+	public static int removeMostLeft(int i, int mostLeft) {
+		if (i == mostLeft) {
+			return right[i];
+		} else {
+			left[i] = removeMostLeft(left[i], mostLeft);
+			up(i);
+			return maintain(i);
+		}
+	}
+
+	public static int rank(int num) {
+		return small(head, num) + 1;
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], num);
+		}
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int pre(int num) {
+		return pre(head, num);
+	}
+
+	public static int pre(int i, int num) {
+		if (i == 0) {
+			return Integer.MIN_VALUE;
+		}
+		if (key[i] >= num) {
+			return pre(left[i], num);
+		} else {
+			return Math.max(key[i], pre(right[i], num));
+		}
+	}
+
+	public static int post(int num) {
+		return post(head, num);
+	}
+
+	public static int post(int i, int num) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= num) {
+			return post(right[i], num);
+		} else {
+			return Math.min(key[i], post(left[i], num));
+		}
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(height, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		for (int i = 1, num; i <= n; i++) {
+			in.nextToken();
+			num = (int) in.nval;
+			add(num);
+		}
+		int lastAns = 0;
+		int ans = 0;
+		for (int i = 1, op, x; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval ^ lastAns;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				lastAns = rank(x);
+				ans ^= lastAns;
+			} else if (op == 4) {
+				lastAns = index(x);
+				ans ^= lastAns;
+			} else if (op == 5) {
+				lastAns = pre(x);
+				ans ^= lastAns;
+			} else {
+				lastAns = post(x);
+				ans ^= lastAns;
+			}
+		}
+		out.println(ans);
+		clear();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class148/Code03_Followup2.java b/src/class148/Code03_Followup2.java
new file mode 100644
index 000000000..ac3848565
--- /dev/null
+++ b/src/class148/Code03_Followup2.java
@@ -0,0 +1,241 @@
+package class148;
+
+// AVL实现普通有序表，数据加强的测试，C++版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <algorithm>
+//#include <climits>
+//#include <cstring>
+//
+//using namespace std;
+//
+//const int MAXN = 2000001;
+//
+//int cnt = 0;
+//int head = 0;
+//int key[MAXN];
+//int height[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int key_count[MAXN];
+//int size[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    height[i] = max(height[ls[i]], height[rs[i]]) + 1;
+//}
+//
+//int leftRotate(int i) {
+//    int r = rs[i];
+//    rs[i] = ls[r];
+//    ls[r] = i;
+//    up(i);
+//    up(r);
+//    return r;
+//}
+//
+//int rightRotate(int i) {
+//    int l = ls[i];
+//    ls[i] = rs[l];
+//    rs[l] = i;
+//    up(i);
+//    up(l);
+//    return l;
+//}
+//
+//int maintain(int i) {
+//    int lh = height[ls[i]];
+//    int rh = height[rs[i]];
+//    if (lh - rh > 1) {
+//        if (height[ls[ls[i]]] >= height[rs[ls[i]]]) {
+//            i = rightRotate(i);
+//        } else {
+//            ls[i] = leftRotate(ls[i]);
+//            i = rightRotate(i);
+//        }
+//    } else if (rh - lh > 1) {
+//        if (height[rs[rs[i]]] >= height[ls[rs[i]]]) {
+//            i = leftRotate(i);
+//        } else {
+//            rs[i] = rightRotate(rs[i]);
+//            i = leftRotate(i);
+//        }
+//    }
+//    return i;
+//}
+//
+//int add(int i, int num) {
+//    if (i == 0) {
+//        key[++cnt] = num;
+//        key_count[cnt] = size[cnt] = height[cnt] = 1;
+//        return cnt;
+//    }
+//    if (key[i] == num) {
+//        key_count[i]++;
+//    } else if (key[i] > num) {
+//        ls[i] = add(ls[i], num);
+//    } else {
+//        rs[i] = add(rs[i], num);
+//    }
+//    up(i);
+//    return maintain(i);
+//}
+//
+//void add(int num) {
+//    head = add(head, num);
+//}
+//
+//int getRank(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return getRank(ls[i], num);
+//    } else {
+//        return size[ls[i]] + key_count[i] + getRank(rs[i], num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return getRank(head, num) + 1;
+//}
+//
+//int removeMostLeft(int i, int mostLeft) {
+//    if (i == mostLeft) {
+//        return rs[i];
+//    } else {
+//        ls[i] = removeMostLeft(ls[i], mostLeft);
+//        up(i);
+//        return maintain(i);
+//    }
+//}
+//
+//int remove(int i, int num) {
+//    if (key[i] < num) {
+//        rs[i] = remove(rs[i], num);
+//    } else if (key[i] > num) {
+//        ls[i] = remove(ls[i], num);
+//    } else {
+//        if (key_count[i] > 1) {
+//            key_count[i]--;
+//        } else {
+//            if (ls[i] == 0 && rs[i] == 0) {
+//                return 0;
+//            } else if (ls[i] != 0 && rs[i] == 0) {
+//                i = ls[i];
+//            } else if (ls[i] == 0 && rs[i] != 0) {
+//                i = rs[i];
+//            } else {
+//                int mostLeft = rs[i];
+//                while (ls[mostLeft] != 0) {
+//                    mostLeft = ls[mostLeft];
+//                }
+//                rs[i] = removeMostLeft(rs[i], mostLeft);
+//                ls[mostLeft] = ls[i];
+//                rs[mostLeft] = rs[i];
+//                i = mostLeft;
+//            }
+//        }
+//    }
+//    up(i);
+//    return maintain(i);
+//}
+//
+//void remove(int num) {
+//    if (getRank(num) != getRank(num + 1)) {
+//        head = remove(head, num);
+//    }
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//void clear() {
+//    memset(key + 1, 0, cnt * sizeof(int));
+//    memset(height + 1, 0, cnt * sizeof(int));
+//    memset(ls + 1, 0, cnt * sizeof(int));
+//    memset(rs + 1, 0, cnt * sizeof(int));
+//    memset(key_count + 1, 0, cnt * sizeof(int));
+//    memset(size + 1, 0, cnt * sizeof(int));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    int n, m, lastAns = 0, ans = 0;
+//    cin >> n;
+//    cin >> m;
+//    for (int i = 1, num; i <= n; i++) {
+//        cin >> num;
+//        add(num);
+//    }
+//    for (int i = 1, op, x; i <= m; i++) {
+//        cin >> op >> x;
+//        x ^= lastAns;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            lastAns = getRank(x);
+//            ans ^= lastAns;
+//        } else if (op == 4) {
+//            lastAns = index(x);
+//            ans ^= lastAns;
+//        } else if (op == 5) {
+//            lastAns = pre(x);
+//            ans ^= lastAns;
+//        } else {
+//            lastAns = post(x);
+//            ans ^= lastAns;
+//        }
+//    }
+//    cout << ans << endl;
+//    clear();
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class150/ShowDetails.java b/src/class150/Code01_ShowDetails.java
similarity index 99%
rename from src/class150/ShowDetails.java
rename to src/class150/Code01_ShowDetails.java
index 546b884a2..fd049538e 100644
--- a/src/class150/ShowDetails.java
+++ b/src/class150/Code01_ShowDetails.java
@@ -11,7 +11,7 @@
 
 import java.util.Arrays;
 
-public class ShowDetails {
+public class Code01_ShowDetails {
 
 	public static void main(String[] args) {
 		ALPHA = 0.7; // 设置平衡因子
diff --git a/src/class150/ScapeGoat1.java b/src/class150/Code02_ScapeGoat1.java
similarity index 99%
rename from src/class150/ScapeGoat1.java
rename to src/class150/Code02_ScapeGoat1.java
index e69f3bec3..f4d4712da 100644
--- a/src/class150/ScapeGoat1.java
+++ b/src/class150/Code02_ScapeGoat1.java
@@ -21,7 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class ScapeGoat1 {
+public class Code02_ScapeGoat1 {
 
 	// 平衡因子
 	public static double ALPHA = 0.7;
diff --git a/src/class150/ScapeGoat2.java b/src/class150/Code02_ScapeGoat2.java
similarity index 98%
rename from src/class150/ScapeGoat2.java
rename to src/class150/Code02_ScapeGoat2.java
index 16bfe5f75..73f0ed757 100644
--- a/src/class150/ScapeGoat2.java
+++ b/src/class150/Code02_ScapeGoat2.java
@@ -207,8 +207,6 @@
 //}
 //
 //int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
 //    int n;
 //    cin >> n;
 //    for (int i = 1; i <= n; i++) {
diff --git a/src/class150/Code03_Followup1.java b/src/class150/Code03_Followup1.java
new file mode 100644
index 000000000..f002f71f5
--- /dev/null
+++ b/src/class150/Code03_Followup1.java
@@ -0,0 +1,261 @@
+package class150;
+
+// 替罪羊树实现普通有序表，数据加强的测试，java版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_Followup1 {
+
+	public static double ALPHA = 0.7;
+
+	public static int MAXN = 2000001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] count = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] diff = new int[MAXN];
+
+	public static int[] collect = new int[MAXN];
+
+	public static int ci;
+
+	public static int top;
+
+	public static int father;
+
+	public static int side;
+
+	public static int init(int num) {
+		key[++cnt] = num;
+		left[cnt] = right[cnt] = 0;
+		count[cnt] = size[cnt] = diff[cnt] = 1;
+		return cnt;
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
+	}
+
+	public static void inorder(int i) {
+		if (i != 0) {
+			inorder(left[i]);
+			if (count[i] > 0) {
+				collect[++ci] = i;
+			}
+			inorder(right[i]);
+		}
+	}
+
+	public static int build(int l, int r) {
+		if (l > r) {
+			return 0;
+		}
+		int m = (l + r) / 2;
+		int h = collect[m];
+		left[h] = build(l, m - 1);
+		right[h] = build(m + 1, r);
+		up(h);
+		return h;
+	}
+
+	public static void rebuild() {
+		if (top != 0) {
+			ci = 0;
+			inorder(top);
+			if (ci > 0) {
+				if (father == 0) {
+					head = build(1, ci);
+				} else if (side == 1) {
+					left[father] = build(1, ci);
+				} else {
+					right[father] = build(1, ci);
+				}
+			}
+		}
+	}
+
+	public static boolean balance(int i) {
+		return ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
+	}
+
+	public static void add(int i, int f, int s, int num) {
+		if (i == 0) {
+			if (f == 0) {
+				head = init(num);
+			} else if (s == 1) {
+				left[f] = init(num);
+			} else {
+				right[f] = init(num);
+			}
+		} else {
+			if (key[i] == num) {
+				count[i]++;
+			} else if (key[i] > num) {
+				add(left[i], i, 1, num);
+			} else {
+				add(right[i], i, 2, num);
+			}
+			up(i);
+			if (!balance(i)) {
+				top = i;
+				father = f;
+				side = s;
+			}
+		}
+	}
+
+	public static void add(int num) {
+		top = father = side = 0;
+		add(head, 0, 0, num);
+		rebuild();
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], num);
+		}
+	}
+
+	public static int rank(int num) {
+		return small(head, num) + 1;
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int pre(int num) {
+		int kth = rank(num);
+		if (kth == 1) {
+			return Integer.MIN_VALUE;
+		} else {
+			return index(kth - 1);
+		}
+	}
+
+	public static int post(int num) {
+		int kth = rank(num + 1);
+		if (kth == size[head] + 1) {
+			return Integer.MAX_VALUE;
+		} else {
+			return index(kth);
+		}
+	}
+
+	public static void remove(int i, int f, int s, int num) {
+		if (key[i] == num) {
+			count[i]--;
+		} else if (key[i] > num) {
+			remove(left[i], i, 1, num);
+		} else {
+			remove(right[i], i, 2, num);
+		}
+		up(i);
+		if (!balance(i)) {
+			top = i;
+			father = f;
+			side = s;
+		}
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			top = father = side = 0;
+			remove(head, 0, 0, num);
+			rebuild();
+		}
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(diff, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		for (int i = 1, num; i <= n; i++) {
+			in.nextToken();
+			num = (int) in.nval;
+			add(num);
+		}
+		int lastAns = 0;
+		int ans = 0;
+		for (int i = 1, op, x; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval ^ lastAns;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				lastAns = rank(x);
+				ans ^= lastAns;
+			} else if (op == 4) {
+				lastAns = index(x);
+				ans ^= lastAns;
+			} else if (op == 5) {
+				lastAns = pre(x);
+				ans ^= lastAns;
+			} else {
+				lastAns = post(x);
+				ans ^= lastAns;
+			}
+		}
+		out.println(ans);
+		clear();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class150/Code03_Followup2.java b/src/class150/Code03_Followup2.java
new file mode 100644
index 000000000..9f6ade08e
--- /dev/null
+++ b/src/class150/Code03_Followup2.java
@@ -0,0 +1,234 @@
+package class150;
+
+// 替罪羊树实现普通有序表，数据加强的测试，C++版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <cmath>
+//#include <climits>
+//#include <cstring>
+//
+//using namespace std;
+//
+//const double ALPHA = 0.7;
+//const int MAXN = 2000001;
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int key_count[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//int diff[MAXN];
+//int collect[MAXN];
+//int ci;
+//int top;
+//int father;
+//int side;
+//
+//int init(int num) {
+//    key[++cnt] = num;
+//    ls[cnt] = rs[cnt] = 0;
+//    key_count[cnt] = size[cnt] = diff[cnt] = 1;
+//    return cnt;
+//}
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    diff[i] = diff[ls[i]] + diff[rs[i]] + (key_count[i] > 0 ? 1 : 0);
+//}
+//
+//void inorder(int i) {
+//    if (i != 0) {
+//        inorder(ls[i]);
+//        if (key_count[i] > 0) {
+//            collect[++ci] = i;
+//        }
+//        inorder(rs[i]);
+//    }
+//}
+//
+//int build(int l, int r) {
+//    if (l > r) {
+//        return 0;
+//    }
+//    int m = (l + r) / 2;
+//    int h = collect[m];
+//    ls[h] = build(l, m - 1);
+//    rs[h] = build(m + 1, r);
+//    up(h);
+//    return h;
+//}
+//
+//void rebuild() {
+//    if (top != 0) {
+//        ci = 0;
+//        inorder(top);
+//        if (ci > 0) {
+//            if (father == 0) {
+//                head = build(1, ci);
+//            } else if (side == 1) {
+//                ls[father] = build(1, ci);
+//            } else {
+//                rs[father] = build(1, ci);
+//            }
+//        }
+//    }
+//}
+//
+//bool balance(int i) {
+//    return ALPHA * diff[i] >= max(diff[ls[i]], diff[rs[i]]);
+//}
+//
+//void add(int i, int f, int s, int num) {
+//    if (i == 0) {
+//        if (f == 0) {
+//            head = init(num);
+//        } else if (s == 1) {
+//            ls[f] = init(num);
+//        } else {
+//            rs[f] = init(num);
+//        }
+//    } else {
+//        if (key[i] == num) {
+//            key_count[i]++;
+//        } else if (key[i] > num) {
+//            add(ls[i], i, 1, num);
+//        } else {
+//            add(rs[i], i, 2, num);
+//        }
+//        up(i);
+//        if (!balance(i)) {
+//            top = i;
+//            father = f;
+//            side = s;
+//        }
+//    }
+//}
+//
+//void add(int num) {
+//    top = father = side = 0;
+//    add(head, 0, 0, num);
+//    rebuild();
+//}
+//
+//int small(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return small(ls[i], num);
+//    } else {
+//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return small(head, num) + 1;
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int num) {
+//    int kth = getRank(num);
+//    if (kth == 1) {
+//        return INT_MIN;
+//    } else {
+//        return index(kth - 1);
+//    }
+//}
+//
+//int post(int num) {
+//    int kth = getRank(num + 1);
+//    if (kth == size[head] + 1) {
+//        return INT_MAX;
+//    } else {
+//        return index(kth);
+//    }
+//}
+//
+//void remove(int i, int f, int s, int num) {
+//    if (key[i] == num) {
+//        key_count[i]--;
+//    } else if (key[i] > num) {
+//        remove(ls[i], i, 1, num);
+//    } else {
+//        remove(rs[i], i, 2, num);
+//    }
+//    up(i);
+//    if (!balance(i)) {
+//        top = i;
+//        father = f;
+//        side = s;
+//    }
+//}
+//
+//void remove(int num) {
+//    if (getRank(num) != getRank(num + 1)) {
+//        top = father = side = 0;
+//        remove(head, 0, 0, num);
+//        rebuild();
+//    }
+//}
+//
+//void clear() {
+//    memset(key, 0, sizeof(key));
+//    memset(key_count, 0, sizeof(key_count));
+//    memset(ls, 0, sizeof(ls));
+//    memset(rs, 0, sizeof(rs));
+//    memset(size, 0, sizeof(size));
+//    memset(diff, 0, sizeof(diff));
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    int n, m, lastAns = 0, ans = 0;
+//    cin >> n;
+//    cin >> m;
+//    for (int i = 1, num; i <= n; i++) {
+//        cin >> num;
+//        add(num);
+//    }
+//    for (int i = 1, op, x; i <= m; i++) {
+//        cin >> op >> x;
+//        x ^= lastAns;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            lastAns = getRank(x);
+//            ans ^= lastAns;
+//        } else if (op == 4) {
+//            lastAns = index(x);
+//            ans ^= lastAns;
+//        } else if (op == 5) {
+//            lastAns = pre(x);
+//            ans ^= lastAns;
+//        } else {
+//            lastAns = post(x);
+//            ans ^= lastAns;
+//        }
+//    }
+//    cout << ans << endl;
+//    clear();
+//    return 0;
+//}
\ No newline at end of file

From 2bef8f7981b66776b2b69607e15de5a1c510a06d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Nov 2024 13:54:28 +0800
Subject: [PATCH 0152/1712] modify code

---
 .../{Code03_Followup1.java => FollowUp1.java} |   2 +-
 .../{Code03_Followup2.java => FollowUp2.java} |   0
 .../{Code03_Followup1.java => FollowUp1.java} |   2 +-
 .../{Code03_Followup2.java => FollowUp2.java} |   0
 src/class151/Code02_Treap2.java               |  12 +-
 src/class151/FollowUp1.java                   | 237 ++++++++++++++++++
 src/class151/FollowUp2.java                   | 217 ++++++++++++++++
 7 files changed, 462 insertions(+), 8 deletions(-)
 rename src/class148/{Code03_Followup1.java => FollowUp1.java} (99%)
 rename src/class148/{Code03_Followup2.java => FollowUp2.java} (100%)
 rename src/class150/{Code03_Followup1.java => FollowUp1.java} (99%)
 rename src/class150/{Code03_Followup2.java => FollowUp2.java} (100%)
 create mode 100644 src/class151/FollowUp1.java
 create mode 100644 src/class151/FollowUp2.java

diff --git a/src/class148/Code03_Followup1.java b/src/class148/FollowUp1.java
similarity index 99%
rename from src/class148/Code03_Followup1.java
rename to src/class148/FollowUp1.java
index 69df83e92..4ab38ccfa 100644
--- a/src/class148/Code03_Followup1.java
+++ b/src/class148/FollowUp1.java
@@ -14,7 +14,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_Followup1 {
+public class FollowUp1 {
 
 	public static int MAXN = 2000001;
 
diff --git a/src/class148/Code03_Followup2.java b/src/class148/FollowUp2.java
similarity index 100%
rename from src/class148/Code03_Followup2.java
rename to src/class148/FollowUp2.java
diff --git a/src/class150/Code03_Followup1.java b/src/class150/FollowUp1.java
similarity index 99%
rename from src/class150/Code03_Followup1.java
rename to src/class150/FollowUp1.java
index f002f71f5..3a74f0472 100644
--- a/src/class150/Code03_Followup1.java
+++ b/src/class150/FollowUp1.java
@@ -14,7 +14,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_Followup1 {
+public class FollowUp1 {
 
 	public static double ALPHA = 0.7;
 
diff --git a/src/class150/Code03_Followup2.java b/src/class150/FollowUp2.java
similarity index 100%
rename from src/class150/Code03_Followup2.java
rename to src/class150/FollowUp2.java
diff --git a/src/class151/Code02_Treap2.java b/src/class151/Code02_Treap2.java
index 748ea7bcf..118eb1c71 100644
--- a/src/class151/Code02_Treap2.java
+++ b/src/class151/Code02_Treap2.java
@@ -98,17 +98,17 @@
 //    return small(head, num) + 1;
 //}
 //
-//int getIndex(int i, int x) {
+//int index(int i, int x) {
 //    if (size[ls[i]] >= x) {
-//        return getIndex(ls[i], x);
+//        return index(ls[i], x);
 //    } else if (size[ls[i]] + key_count[i] < x) {
-//        return getIndex(rs[i], x - size[ls[i]] - key_count[i]);
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
 //
-//int getIndex(int x) {
-//    return getIndex(head, x);
+//int index(int x) {
+//    return index(head, x);
 //}
 //
 //int pre(int i, int num) {
@@ -201,7 +201,7 @@
 //        } else if (op == 3) {
 //            cout << getRank(x) << endl;
 //        } else if (op == 4) {
-//            cout << getIndex(x) << endl;
+//            cout << index(x) << endl;
 //        } else if (op == 5) {
 //            cout << pre(x) << endl;
 //        } else {
diff --git a/src/class151/FollowUp1.java b/src/class151/FollowUp1.java
new file mode 100644
index 000000000..d8ef068b2
--- /dev/null
+++ b/src/class151/FollowUp1.java
@@ -0,0 +1,237 @@
+package class151;
+
+// Treap树实现普通有序表，数据加强的测试，java版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class FollowUp1 {
+
+	public static int MAXN = 2000001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] count = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static double[] priority = new double[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+	}
+
+	public static int leftRotate(int i) {
+		int r = right[i];
+		right[i] = left[r];
+		left[r] = i;
+		up(i);
+		up(r);
+		return r;
+	}
+
+	public static int rightRotate(int i) {
+		int l = left[i];
+		left[i] = right[l];
+		right[l] = i;
+		up(i);
+		up(l);
+		return l;
+	}
+
+	public static int add(int i, int num) {
+		if (i == 0) {
+			key[++cnt] = num;
+			count[cnt] = size[cnt] = 1;
+			priority[cnt] = Math.random();
+			return cnt;
+		}
+		if (key[i] == num) {
+			count[i]++;
+		} else if (key[i] > num) {
+			left[i] = add(left[i], num);
+		} else {
+			right[i] = add(right[i], num);
+		}
+		up(i);
+		if (left[i] != 0 && priority[left[i]] > priority[i]) {
+			return rightRotate(i);
+		}
+		if (right[i] != 0 && priority[right[i]] > priority[i]) {
+			return leftRotate(i);
+		}
+		return i;
+	}
+
+	public static void add(int num) {
+		head = add(head, num);
+	}
+
+	public static int small(int i, int num) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return small(left[i], num);
+		} else {
+			return size[left[i]] + count[i] + small(right[i], num);
+		}
+	}
+
+	public static int rank(int num) {
+		return small(head, num) + 1;
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + count[i] < x) {
+			return index(right[i], x - size[left[i]] - count[i]);
+		}
+		return key[i];
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int pre(int i, int num) {
+		if (i == 0) {
+			return Integer.MIN_VALUE;
+		}
+		if (key[i] >= num) {
+			return pre(left[i], num);
+		} else {
+			return Math.max(key[i], pre(right[i], num));
+		}
+	}
+
+	public static int pre(int num) {
+		return pre(head, num);
+	}
+
+	public static int post(int i, int num) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= num) {
+			return post(right[i], num);
+		} else {
+			return Math.min(key[i], post(left[i], num));
+		}
+	}
+
+	public static int post(int num) {
+		return post(head, num);
+	}
+
+	public static int remove(int i, int num) {
+		if (key[i] < num) {
+			right[i] = remove(right[i], num);
+		} else if (key[i] > num) {
+			left[i] = remove(left[i], num);
+		} else {
+			if (count[i] > 1) {
+				count[i]--;
+			} else {
+				if (left[i] == 0 && right[i] == 0) {
+					return 0;
+				} else if (left[i] != 0 && right[i] == 0) {
+					i = left[i];
+				} else if (left[i] == 0 && right[i] != 0) {
+					i = right[i];
+				} else {
+					if (priority[left[i]] >= priority[right[i]]) {
+						i = rightRotate(i);
+						right[i] = remove(right[i], num);
+					} else {
+						i = leftRotate(i);
+						left[i] = remove(left[i], num);
+					}
+				}
+			}
+		}
+		up(i);
+		return i;
+	}
+
+	public static void remove(int num) {
+		if (rank(num) != rank(num + 1)) {
+			head = remove(head, num);
+		}
+	}
+
+	public static void clear() {
+		Arrays.fill(key, 1, cnt + 1, 0);
+		Arrays.fill(count, 1, cnt + 1, 0);
+		Arrays.fill(left, 1, cnt + 1, 0);
+		Arrays.fill(right, 1, cnt + 1, 0);
+		Arrays.fill(size, 1, cnt + 1, 0);
+		Arrays.fill(priority, 1, cnt + 1, 0);
+		cnt = 0;
+		head = 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		for (int i = 1, num; i <= n; i++) {
+			in.nextToken();
+			num = (int) in.nval;
+			add(num);
+		}
+		int lastAns = 0;
+		int ans = 0;
+		for (int i = 1, op, x; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval ^ lastAns;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				lastAns = rank(x);
+				ans ^= lastAns;
+			} else if (op == 4) {
+				lastAns = index(x);
+				ans ^= lastAns;
+			} else if (op == 5) {
+				lastAns = pre(x);
+				ans ^= lastAns;
+			} else {
+				lastAns = post(x);
+				ans ^= lastAns;
+			}
+		}
+		out.println(ans);
+		clear();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class151/FollowUp2.java b/src/class151/FollowUp2.java
new file mode 100644
index 000000000..b7c79d79f
--- /dev/null
+++ b/src/class151/FollowUp2.java
@@ -0,0 +1,217 @@
+package class151;
+
+// Treap树实现普通有序表，数据加强的测试，C++版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <algorithm>
+//#include <cstring>
+//#include <random>
+//#include <climits>
+//
+//using namespace std;
+//
+//const int MAXN = 2000001;
+//
+//int cnt = 0;
+//int head = 0;
+//int key[MAXN];
+//int key_count[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//}
+//
+//int leftRotate(int i) {
+//    int r = rs[i];
+//    rs[i] = ls[r];
+//    ls[r] = i;
+//    up(i);
+//    up(r);
+//    return r;
+//}
+//
+//int rightRotate(int i) {
+//    int l = ls[i];
+//    ls[i] = rs[l];
+//    rs[l] = i;
+//    up(i);
+//    up(l);
+//    return l;
+//}
+//
+//int add(int i, int num) {
+//    if (i == 0) {
+//        key[++cnt] = num;
+//        key_count[cnt] = size[cnt] = 1;
+//        priority[cnt] = static_cast<double>(rand()) / RAND_MAX;
+//        return cnt;
+//    }
+//    if (key[i] == num) {
+//        key_count[i]++;
+//    } else if (key[i] > num) {
+//        ls[i] = add(ls[i], num);
+//    } else {
+//        rs[i] = add(rs[i], num);
+//    }
+//    up(i);
+//    if (ls[i] != 0 && priority[ls[i]] > priority[i]) {
+//        return rightRotate(i);
+//    }
+//    if (rs[i] != 0 && priority[rs[i]] > priority[i]) {
+//        return leftRotate(i);
+//    }
+//    return i;
+//}
+//
+//void add(int num) {
+//    head = add(head, num);
+//}
+//
+//int small(int i, int num) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (key[i] >= num) {
+//        return small(ls[i], num);
+//    } else {
+//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//    }
+//}
+//
+//int getRank(int num) {
+//    return small(head, num) + 1;
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    }
+//    return key[i];
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//int remove(int i, int num) {
+//    if (key[i] < num) {
+//        rs[i] = remove(rs[i], num);
+//    } else if (key[i] > num) {
+//        ls[i] = remove(ls[i], num);
+//    } else {
+//        if (key_count[i] > 1) {
+//            key_count[i]--;
+//        } else {
+//            if (ls[i] == 0 && rs[i] == 0) {
+//                return 0;
+//            } else if (ls[i] != 0 && rs[i] == 0) {
+//                i = ls[i];
+//            } else if (ls[i] == 0 && rs[i] != 0) {
+//                i = rs[i];
+//            } else {
+//                if (priority[ls[i]] >= priority[rs[i]]) {
+//                    i = rightRotate(i);
+//                    rs[i] = remove(rs[i], num);
+//                } else {
+//                    i = leftRotate(i);
+//                    ls[i] = remove(ls[i], num);
+//                }
+//            }
+//        }
+//    }
+//    up(i);
+//    return i;
+//}
+//
+//void remove(int num) {
+//    if (getRank(num) != getRank(num + 1)) {
+//        head = remove(head, num);
+//    }
+//}
+//
+//void clear() {
+//    fill(key + 1, key + cnt + 1, 0);
+//    fill(key_count + 1, key_count + cnt + 1, 0);
+//    fill(ls + 1, ls + cnt + 1, 0);
+//    fill(rs + 1, rs + cnt + 1, 0);
+//    fill(size + 1, size + cnt + 1, 0);
+//    fill(priority + 1, priority + cnt + 1, 0);
+//    cnt = 0;
+//    head = 0;
+//}
+//
+//int main() {
+//    srand(time(0));
+//    int n, m, lastAns = 0, ans = 0;
+//    cin >> n;
+//    cin >> m;
+//    for (int i = 1, num; i <= n; i++) {
+//        cin >> num;
+//        add(num);
+//    }
+//    for (int i = 1, op, x; i <= m; i++) {
+//        cin >> op >> x;
+//        x ^= lastAns;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            lastAns = getRank(x);
+//            ans ^= lastAns;
+//        } else if (op == 4) {
+//            lastAns = index(x);
+//            ans ^= lastAns;
+//        } else if (op == 5) {
+//            lastAns = pre(x);
+//            ans ^= lastAns;
+//        } else {
+//            lastAns = post(x);
+//            ans ^= lastAns;
+//        }
+//    }
+//    cout << ans << endl;
+//    clear();
+//    return 0;
+//}
\ No newline at end of file

From eadf27ab941a08a5d49cc344239d7be45fe4f3a9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Nov 2024 14:02:17 +0800
Subject: [PATCH 0153/1712] modify code

---
 src/class152/FollowUp1.java | 181 ++++++++++++++++++++++++++++++++++++
 src/class152/FollowUp2.java | 162 ++++++++++++++++++++++++++++++++
 2 files changed, 343 insertions(+)
 create mode 100644 src/class152/FollowUp1.java
 create mode 100644 src/class152/FollowUp2.java

diff --git a/src/class152/FollowUp1.java b/src/class152/FollowUp1.java
new file mode 100644
index 000000000..2b3f5818b
--- /dev/null
+++ b/src/class152/FollowUp1.java
@@ -0,0 +1,181 @@
+package class152;
+
+// FHQ-Treap实现普通有序表，不用词频压缩，数据加强的测试，java版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class FollowUp1 {
+
+	public static int MAXN = 2000001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static double[] priority = new double[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static void split(int l, int r, int i, int num) {
+		if (i == 0) {
+			right[l] = left[r] = 0;
+		} else {
+			if (key[i] <= num) {
+				right[l] = i;
+				split(i, r, right[i], num);
+			} else {
+				left[r] = i;
+				split(l, i, left[i], num);
+			}
+			up(i);
+		}
+	}
+
+	public static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			right[l] = merge(right[l], r);
+			up(l);
+			return l;
+		} else {
+			left[r] = merge(l, left[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	public static void add(int num) {
+		split(0, 0, head, num);
+		key[++cnt] = num;
+		size[cnt] = 1;
+		priority[cnt] = Math.random();
+		head = merge(merge(right[0], cnt), left[0]);
+	}
+
+	public static void remove(int num) {
+		split(0, 0, head, num);
+		int lm = right[0];
+		int r = left[0];
+		split(0, 0, lm, num - 1);
+		int l = right[0];
+		int m = left[0];
+		head = merge(merge(l, merge(left[m], right[m])), r);
+	}
+
+	public static int rank(int num) {
+		split(0, 0, head, num - 1);
+		int ans = size[right[0]] + 1;
+		head = merge(right[0], left[0]);
+		return ans;
+	}
+
+	public static int index(int i, int x) {
+		if (size[left[i]] >= x) {
+			return index(left[i], x);
+		} else if (size[left[i]] + 1 < x) {
+			return index(right[i], x - size[left[i]] - 1);
+		} else {
+			return key[i];
+		}
+	}
+
+	public static int index(int x) {
+		return index(head, x);
+	}
+
+	public static int pre(int i, int num) {
+		if (i == 0) {
+			return Integer.MIN_VALUE;
+		}
+		if (key[i] >= num) {
+			return pre(left[i], num);
+		} else {
+			return Math.max(key[i], pre(right[i], num));
+		}
+	}
+
+	public static int pre(int num) {
+		return pre(head, num);
+	}
+
+	public static int post(int i, int num) {
+		if (i == 0) {
+			return Integer.MAX_VALUE;
+		}
+		if (key[i] <= num) {
+			return post(right[i], num);
+		} else {
+			return Math.min(key[i], post(left[i], num));
+		}
+	}
+
+	public static int post(int num) {
+		return post(head, num);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		for (int i = 1, num; i <= n; i++) {
+			in.nextToken();
+			num = (int) in.nval;
+			add(num);
+		}
+		int lastAns = 0;
+		int ans = 0;
+		for (int i = 1, op, x; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval ^ lastAns;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				lastAns = rank(x);
+				ans ^= lastAns;
+			} else if (op == 4) {
+				lastAns = index(x);
+				ans ^= lastAns;
+			} else if (op == 5) {
+				lastAns = pre(x);
+				ans ^= lastAns;
+			} else {
+				lastAns = post(x);
+				ans ^= lastAns;
+			}
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class152/FollowUp2.java b/src/class152/FollowUp2.java
new file mode 100644
index 000000000..4aa697f88
--- /dev/null
+++ b/src/class152/FollowUp2.java
@@ -0,0 +1,162 @@
+package class152;
+
+// FHQ-Treap实现普通有序表，不用词频压缩，数据加强的测试，C++版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <cstdlib>
+//#include <cstring>
+//#include <algorithm>
+//#include <climits>
+//using namespace std;
+//
+//const int MAXN = 2000001;
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//double priority[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//void split(int l, int r, int i, int num) {
+//    if (i == 0) {
+//        rs[l] = ls[r] = 0;
+//    } else {
+//        if (key[i] <= num) {
+//            rs[l] = i;
+//            split(i, r, rs[i], num);
+//        } else {
+//            ls[r] = i;
+//            split(l, i, ls[i], num);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int merge(int l, int r) {
+//    if (l == 0 || r == 0) {
+//        return l + r;
+//    }
+//    if (priority[l] >= priority[r]) {
+//        rs[l] = merge(rs[l], r);
+//        up(l);
+//        return l;
+//    } else {
+//        ls[r] = merge(l, ls[r]);
+//        up(r);
+//        return r;
+//    }
+//}
+//
+//void add(int num) {
+//    split(0, 0, head, num);
+//    key[++cnt] = num;
+//    size[cnt] = 1;
+//    priority[cnt] = (double)rand() / RAND_MAX;
+//    head = merge(merge(rs[0], cnt), ls[0]);
+//}
+//
+//void remove(int num) {
+//    split(0, 0, head, num);
+//    int lm = rs[0];
+//    int r = ls[0];
+//    split(0, 0, lm, num - 1);
+//    int l = rs[0];
+//    int m = ls[0];
+//    head = merge(merge(l, merge(ls[m], rs[m])), r);
+//}
+//
+//int getRank(int num) {
+//    split(0, 0, head, num - 1);
+//    int ans = size[rs[0]] + 1;
+//    head = merge(rs[0], ls[0]);
+//    return ans;
+//}
+//
+//int index(int i, int x) {
+//    if (size[ls[i]] >= x) {
+//        return index(ls[i], x);
+//    } else if (size[ls[i]] + 1 < x) {
+//        return index(rs[i], x - size[ls[i]] - 1);
+//    } else {
+//        return key[i];
+//    }
+//}
+//
+//int index(int x) {
+//    return index(head, x);
+//}
+//
+//int pre(int i, int num) {
+//    if (i == 0) {
+//        return INT_MIN;
+//    }
+//    if (key[i] >= num) {
+//        return pre(ls[i], num);
+//    } else {
+//        return max(key[i], pre(rs[i], num));
+//    }
+//}
+//
+//int pre(int num) {
+//    return pre(head, num);
+//}
+//
+//int post(int i, int num) {
+//    if (i == 0) {
+//        return INT_MAX;
+//    }
+//    if (key[i] <= num) {
+//        return post(rs[i], num);
+//    } else {
+//        return min(key[i], post(ls[i], num));
+//    }
+//}
+//
+//int post(int num) {
+//    return post(head, num);
+//}
+//
+//int main() {
+//    srand(time(0));
+//    int n, m, lastAns = 0, ans = 0;
+//    cin >> n;
+//    cin >> m;
+//    for (int i = 1, num; i <= n; i++) {
+//        cin >> num;
+//        add(num);
+//    }
+//    for (int i = 1, op, x; i <= m; i++) {
+//        cin >> op >> x;
+//        x ^= lastAns;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            lastAns = getRank(x);
+//            ans ^= lastAns;
+//        } else if (op == 4) {
+//            lastAns = index(x);
+//            ans ^= lastAns;
+//        } else if (op == 5) {
+//            lastAns = pre(x);
+//            ans ^= lastAns;
+//        } else {
+//            lastAns = post(x);
+//            ans ^= lastAns;
+//        }
+//    }
+//    cout << ans << endl;
+//    return 0;
+//}
\ No newline at end of file

From 2d024b2d89274442a629e95909dfa4e46846d90e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Nov 2024 23:24:25 +0800
Subject: [PATCH 0154/1712] modify code

---
 src/class153/Code01_Splay1.java | 255 +++++++++++++++++++++++++++++++
 src/class153/Code01_Splay2.java | 239 +++++++++++++++++++++++++++++
 src/class153/FollowUp1.java     | 262 ++++++++++++++++++++++++++++++++
 src/class153/FollowUp2.java     | 243 +++++++++++++++++++++++++++++
 4 files changed, 999 insertions(+)
 create mode 100644 src/class153/Code01_Splay1.java
 create mode 100644 src/class153/Code01_Splay2.java
 create mode 100644 src/class153/FollowUp1.java
 create mode 100644 src/class153/FollowUp2.java

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
new file mode 100644
index 000000000..3829067db
--- /dev/null
+++ b/src/class153/Code01_Splay1.java
@@ -0,0 +1,255 @@
+package class153;
+
+// Splay树的实现，不用词频压缩，java版
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_Splay1 {
+
+	public static int MAXN = 100001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int leftOrRight(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void upRotate(int i) {
+		int f = father[i], g = father[f], son = leftOrRight(i);
+		if (son == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		father[f] = i;
+		father[i] = g;
+		if (g != 0) {
+			if (right[g] == f) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (leftOrRight(i) == leftOrRight(f)) {
+					upRotate(f);
+				} else {
+					upRotate(i);
+				}
+			}
+			upRotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	// 返回以i为头的树上第rank名的节点编号
+	public static int find(int i, int rank) {
+		while (i != 0) {
+			if (size[left[i]] + 1 == rank) {
+				return i;
+			} else if (size[left[i]] >= rank) {
+				i = left[i];
+			} else {
+				rank -= size[left[i]] + 1;
+				i = right[i];
+			}
+		}
+		return 0;
+	}
+
+	public static void add(int num) {
+		key[++cnt] = num;
+		size[cnt] = 1;
+		if (head == 0) {
+			head = cnt;
+		} else {
+			int f = 0, i = head, son = 0;
+			while (i != 0) {
+				size[i]++;
+				f = i;
+				if (key[i] <= num) {
+					son = 1;
+					i = right[i];
+				} else {
+					son = 0;
+					i = left[i];
+				}
+			}
+			if (son == 1) {
+				right[f] = cnt;
+			} else {
+				left[f] = cnt;
+			}
+			father[cnt] = f;
+			splay(cnt, 0);
+		}
+	}
+
+	public static int rank(int num) {
+		int i = head, last = head;
+		int ans = 0;
+		while (i != 0) {
+			last = i;
+			if (key[i] >= num) {
+				i = left[i];
+			} else {
+				ans += size[left[i]] + 1;
+				i = right[i];
+			}
+		}
+		splay(last, 0);
+		return ans + 1;
+	}
+
+	public static int index(int x) {
+		int i = head, last = head;
+		while (i != 0) {
+			last = i;
+			if (size[left[i]] >= x) {
+				i = left[i];
+			} else if (size[left[i]] + 1 < x) {
+				x -= size[left[i]] + 1;
+				i = right[i];
+			} else {
+				i = 0;
+			}
+		}
+		splay(last, 0);
+		return key[last];
+	}
+
+	public static int pre(int num) {
+		int i = head, last = head;
+		int ans = Integer.MIN_VALUE;
+		while (i != 0) {
+			last = i;
+			if (key[i] >= num) {
+				i = left[i];
+			} else {
+				ans = Math.max(ans, key[i]);
+				i = right[i];
+			}
+		}
+		splay(last, 0);
+		return ans;
+	}
+
+	public static int post(int num) {
+		int i = head, last = head;
+		int ans = Integer.MAX_VALUE;
+		while (i != 0) {
+			last = i;
+			if (key[i] <= num) {
+				i = right[i];
+			} else {
+				ans = Math.min(ans, key[i]);
+				i = left[i];
+			}
+		}
+		splay(last, 0);
+		return ans;
+	}
+
+	public static void remove(int num) {
+		int kth = rank(num);
+		if (kth != rank(num + 1)) {
+			int i = find(head, kth);
+			splay(i, 0);
+			if (left[i] == 0) {
+				head = right[i];
+			} else if (right[i] == 0) {
+				head = left[i];
+			} else {
+				int j = find(right[i], 1);
+				splay(j, i);
+				left[j] = left[i];
+				father[left[j]] = j;
+				up(j);
+				head = j;
+			}
+			father[head] = 0;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1, op, x; i <= n; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				out.println(rank(x));
+			} else if (op == 4) {
+				out.println(index(x));
+			} else if (op == 5) {
+				out.println(pre(x));
+			} else {
+				out.println(post(x));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
\ No newline at end of file
diff --git a/src/class153/Code01_Splay2.java b/src/class153/Code01_Splay2.java
new file mode 100644
index 000000000..695f9802a
--- /dev/null
+++ b/src/class153/Code01_Splay2.java
@@ -0,0 +1,239 @@
+package class153;
+
+// Splay树的实现，不用词频压缩，C++版
+// 实现一种结构，支持如下操作，要求单次调用的时间复杂度O(log n)
+// 1，增加x，重复加入算多个词频
+// 2，删除x，如果有多个，只删掉一个
+// 3，查询x的排名，x的排名为，比x小的数的个数+1
+// 4，查询数据中排名为x的数
+// 5，查询x的前驱，x的前驱为，小于x的数中最大的数，不存在返回整数最小值
+// 6，查询x的后继，x的后继为，大于x的数中最小的数，不存在返回整数最大值
+// 所有操作的次数 <= 10^5
+// -10^7 <= x <= +10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3369
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <climits>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//int leftOrRight(int i) {
+//    return rs[fa[i]] == i ? 1 : 0;
+//}
+//
+//void upRotate(int i) {
+//    int f = fa[i], g = fa[f], son = leftOrRight(i);
+//    if (son == 1) {
+//        rs[f] = ls[i];
+//        if (rs[f] != 0) {
+//            fa[rs[f]] = f;
+//        }
+//        ls[i] = f;
+//    } else {
+//        ls[f] = rs[i];
+//        if (ls[f] != 0) {
+//            fa[ls[f]] = f;
+//        }
+//        rs[i] = f;
+//    }
+//    fa[f] = i;
+//    fa[i] = g;
+//    if (g != 0) {
+//        if (rs[g] == f) {
+//            rs[g] = i;
+//        } else {
+//            ls[g] = i;
+//        }
+//    }
+//    up(f);
+//    up(i);
+//}
+//
+//void splay(int i, int goal) {
+//    int f = fa[i], g = fa[f];
+//    while (f != goal) {
+//        if (g != goal) {
+//            if (leftOrRight(i) == leftOrRight(f)) {
+//                upRotate(f);
+//            } else {
+//                upRotate(i);
+//            }
+//        }
+//        upRotate(i);
+//        f = fa[i];
+//        g = fa[f];
+//    }
+//    if (goal == 0) {
+//        head = i;
+//    }
+//}
+//
+//int find(int i, int rank) {
+//    while (i != 0) {
+//        if (size[ls[i]] + 1 == rank) {
+//            return i;
+//        } else if (size[ls[i]] >= rank) {
+//            i = ls[i];
+//        } else {
+//            rank -= size[ls[i]] + 1;
+//            i = rs[i];
+//        }
+//    }
+//    return 0;
+//}
+//
+//void add(int num) {
+//    key[++cnt] = num;
+//    size[cnt] = 1;
+//    if (head == 0) {
+//        head = cnt;
+//    } else {
+//        int f = 0, i = head, son = 0;
+//        while (i != 0) {
+//            size[i]++;
+//            f = i;
+//            if (key[i] <= num) {
+//                son = 1;
+//                i = rs[i];
+//            } else {
+//                son = 0;
+//                i = ls[i];
+//            }
+//        }
+//        if (son == 1) {
+//            rs[f] = cnt;
+//        } else {
+//            ls[f] = cnt;
+//        }
+//        fa[cnt] = f;
+//        splay(cnt, 0);
+//    }
+//}
+//
+//int getRank(int num) {
+//    int i = head, last = head;
+//    int ans = 0;
+//    while (i != 0) {
+//        last = i;
+//        if (key[i] >= num) {
+//            i = ls[i];
+//        } else {
+//            ans += size[ls[i]] + 1;
+//            i = rs[i];
+//        }
+//    }
+//    splay(last, 0);
+//    return ans + 1;
+//}
+//
+//int index(int x) {
+//    int i = head, last = head;
+//    while (i != 0) {
+//        last = i;
+//        if (size[ls[i]] >= x) {
+//            i = ls[i];
+//        } else if (size[ls[i]] + 1 < x) {
+//            x -= size[ls[i]] + 1;
+//            i = rs[i];
+//        } else {
+//            i = 0;
+//        }
+//    }
+//    splay(last, 0);
+//    return key[last];
+//}
+//
+//int pre(int num) {
+//    int i = head, last = head;
+//    int ans = INT_MIN;
+//    while (i != 0) {
+//        last = i;
+//        if (key[i] >= num) {
+//            i = ls[i];
+//        } else {
+//            ans = max(ans, key[i]);
+//            i = rs[i];
+//        }
+//    }
+//    splay(last, 0);
+//    return ans;
+//}
+//
+//int post(int num) {
+//    int i = head, last = head;
+//    int ans = INT_MAX;
+//    while (i != 0) {
+//        last = i;
+//        if (key[i] <= num) {
+//            i = rs[i];
+//        } else {
+//            ans = min(ans, key[i]);
+//            i = ls[i];
+//        }
+//    }
+//    splay(last, 0);
+//    return ans;
+//}
+//
+//void remove(int num) {
+//    int kth = getRank(num);
+//    if (kth != getRank(num + 1)) {
+//        int i = find(head, kth);
+//        splay(i, 0);
+//        if (ls[i] == 0) {
+//            head = rs[i];
+//        } else if (rs[i] == 0) {
+//            head = ls[i];
+//        } else {
+//            int j = find(rs[i], 1);
+//            splay(j, i);
+//            ls[j] = ls[i];
+//            fa[ls[j]] = j;
+//            up(j);
+//            head = j;
+//        }
+//        if (head != 0) {
+//            fa[head] = 0;
+//        }
+//    }
+//}
+//
+//int main() {
+//    int n;
+//    cin >> n;
+//    for (int i = 0, op, x; i < n; i++) {
+//        cin >> op >> x;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            cout << getRank(x) << endl;
+//        } else if (op == 4) {
+//            cout << index(x) << endl;
+//        } else if (op == 5) {
+//            cout << pre(x) << endl;
+//        } else {
+//            cout << post(x) << endl;
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
new file mode 100644
index 000000000..be32d1152
--- /dev/null
+++ b/src/class153/FollowUp1.java
@@ -0,0 +1,262 @@
+package class153;
+
+// Splay树实现普通有序表，不用词频压缩，数据加强的测试，java版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class FollowUp1 {
+
+	public static int MAXN = 2000001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int leftOrRight(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void upRotate(int i) {
+		int f = father[i], g = father[f], son = leftOrRight(i);
+		if (son == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		father[f] = i;
+		father[i] = g;
+		if (g != 0) {
+			if (right[g] == f) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (leftOrRight(i) == leftOrRight(f)) {
+					upRotate(f);
+				} else {
+					upRotate(i);
+				}
+			}
+			upRotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	// 返回以i为头的树上第rank名的节点编号
+	public static int find(int i, int rank) {
+		while (i != 0) {
+			if (size[left[i]] + 1 == rank) {
+				return i;
+			} else if (size[left[i]] >= rank) {
+				i = left[i];
+			} else {
+				rank -= size[left[i]] + 1;
+				i = right[i];
+			}
+		}
+		return 0;
+	}
+
+	public static void add(int num) {
+		key[++cnt] = num;
+		size[cnt] = 1;
+		if (head == 0) {
+			head = cnt;
+		} else {
+			int f = 0, i = head, son = 0;
+			while (i != 0) {
+				size[i]++;
+				f = i;
+				if (key[i] <= num) {
+					son = 1;
+					i = right[i];
+				} else {
+					son = 0;
+					i = left[i];
+				}
+			}
+			if (son == 1) {
+				right[f] = cnt;
+			} else {
+				left[f] = cnt;
+			}
+			father[cnt] = f;
+			splay(cnt, 0);
+		}
+	}
+
+	public static int rank(int num) {
+		int i = head, last = head;
+		int ans = 0;
+		while (i != 0) {
+			last = i;
+			if (key[i] >= num) {
+				i = left[i];
+			} else {
+				ans += size[left[i]] + 1;
+				i = right[i];
+			}
+		}
+		splay(last, 0);
+		return ans + 1;
+	}
+
+	public static int index(int x) {
+		int i = head, last = head;
+		while (i != 0) {
+			last = i;
+			if (size[left[i]] >= x) {
+				i = left[i];
+			} else if (size[left[i]] + 1 < x) {
+				x -= size[left[i]] + 1;
+				i = right[i];
+			} else {
+				i = 0;
+			}
+		}
+		splay(last, 0);
+		return key[last];
+	}
+
+	public static int pre(int num) {
+		int i = head, last = head;
+		int ans = Integer.MIN_VALUE;
+		while (i != 0) {
+			last = i;
+			if (key[i] >= num) {
+				i = left[i];
+			} else {
+				ans = Math.max(ans, key[i]);
+				i = right[i];
+			}
+		}
+		splay(last, 0);
+		return ans;
+	}
+
+	public static int post(int num) {
+		int i = head, last = head;
+		int ans = Integer.MAX_VALUE;
+		while (i != 0) {
+			last = i;
+			if (key[i] <= num) {
+				i = right[i];
+			} else {
+				ans = Math.min(ans, key[i]);
+				i = left[i];
+			}
+		}
+		splay(last, 0);
+		return ans;
+	}
+
+	public static void remove(int num) {
+		int kth = rank(num);
+		if (kth != rank(num + 1)) {
+			int i = find(head, kth);
+			splay(i, 0);
+			if (left[i] == 0) {
+				head = right[i];
+			} else if (right[i] == 0) {
+				head = left[i];
+			} else {
+				int j = find(right[i], 1);
+				splay(j, i);
+				left[j] = left[i];
+				father[left[j]] = j;
+				up(j);
+				head = j;
+			}
+			father[head] = 0;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		for (int i = 1, num; i <= n; i++) {
+			in.nextToken();
+			num = (int) in.nval;
+			add(num);
+		}
+		int lastAns = 0;
+		int ans = 0;
+		for (int i = 1, op, x; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval ^ lastAns;
+			if (op == 1) {
+				add(x);
+			} else if (op == 2) {
+				remove(x);
+			} else if (op == 3) {
+				lastAns = rank(x);
+				ans ^= lastAns;
+			} else if (op == 4) {
+				lastAns = index(x);
+				ans ^= lastAns;
+			} else if (op == 5) {
+				lastAns = pre(x);
+				ans ^= lastAns;
+			} else {
+				lastAns = post(x);
+				ans ^= lastAns;
+			}
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
\ No newline at end of file
diff --git a/src/class153/FollowUp2.java b/src/class153/FollowUp2.java
new file mode 100644
index 000000000..f47800023
--- /dev/null
+++ b/src/class153/FollowUp2.java
@@ -0,0 +1,243 @@
+package class153;
+
+// Splay树实现普通有序表，不用词频压缩，数据加强的测试，C++版
+// 这个文件课上没有讲，测试数据加强了，而且有强制在线的要求
+// 基本功能要求都是不变的，可以打开测试链接查看
+// 测试链接 : https://www.luogu.com.cn/problem/P6136
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <climits>
+//
+//using namespace std;
+//
+//const int MAXN = 2000001;
+//
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//int leftOrRight(int i) {
+//    return rs[fa[i]] == i ? 1 : 0;
+//}
+//
+//void upRotate(int i) {
+//    int f = fa[i], g = fa[f], son = leftOrRight(i);
+//    if (son == 1) {
+//        rs[f] = ls[i];
+//        if (rs[f] != 0) {
+//            fa[rs[f]] = f;
+//        }
+//        ls[i] = f;
+//    } else {
+//        ls[f] = rs[i];
+//        if (ls[f] != 0) {
+//            fa[ls[f]] = f;
+//        }
+//        rs[i] = f;
+//    }
+//    fa[f] = i;
+//    fa[i] = g;
+//    if (g != 0) {
+//        if (rs[g] == f) {
+//            rs[g] = i;
+//        } else {
+//            ls[g] = i;
+//        }
+//    }
+//    up(f);
+//    up(i);
+//}
+//
+//void splay(int i, int goal) {
+//    int f = fa[i], g = fa[f];
+//    while (f != goal) {
+//        if (g != goal) {
+//            if (leftOrRight(i) == leftOrRight(f)) {
+//                upRotate(f);
+//            } else {
+//                upRotate(i);
+//            }
+//        }
+//        upRotate(i);
+//        f = fa[i];
+//        g = fa[f];
+//    }
+//    if (goal == 0) {
+//        head = i;
+//    }
+//}
+//
+//int find(int i, int rank) {
+//    while (i != 0) {
+//        if (size[ls[i]] + 1 == rank) {
+//            return i;
+//        } else if (size[ls[i]] >= rank) {
+//            i = ls[i];
+//        } else {
+//            rank -= size[ls[i]] + 1;
+//            i = rs[i];
+//        }
+//    }
+//    return 0;
+//}
+//
+//void add(int num) {
+//    key[++cnt] = num;
+//    size[cnt] = 1;
+//    if (head == 0) {
+//        head = cnt;
+//    } else {
+//        int f = 0, i = head, son = 0;
+//        while (i != 0) {
+//            size[i]++;
+//            f = i;
+//            if (key[i] <= num) {
+//                son = 1;
+//                i = rs[i];
+//            } else {
+//                son = 0;
+//                i = ls[i];
+//            }
+//        }
+//        if (son == 1) {
+//            rs[f] = cnt;
+//        } else {
+//            ls[f] = cnt;
+//        }
+//        fa[cnt] = f;
+//        splay(cnt, 0);
+//    }
+//}
+//
+//int getRank(int num) {
+//    int i = head, last = head;
+//    int ans = 0;
+//    while (i != 0) {
+//        last = i;
+//        if (key[i] >= num) {
+//            i = ls[i];
+//        } else {
+//            ans += size[ls[i]] + 1;
+//            i = rs[i];
+//        }
+//    }
+//    splay(last, 0);
+//    return ans + 1;
+//}
+//
+//int index(int x) {
+//    int i = head, last = head;
+//    while (i != 0) {
+//        last = i;
+//        if (size[ls[i]] >= x) {
+//            i = ls[i];
+//        } else if (size[ls[i]] + 1 < x) {
+//            x -= size[ls[i]] + 1;
+//            i = rs[i];
+//        } else {
+//            i = 0;
+//        }
+//    }
+//    splay(last, 0);
+//    return key[last];
+//}
+//
+//int pre(int num) {
+//    int i = head, last = head;
+//    int ans = INT_MIN;
+//    while (i != 0) {
+//        last = i;
+//        if (key[i] >= num) {
+//            i = ls[i];
+//        } else {
+//            ans = max(ans, key[i]);
+//            i = rs[i];
+//        }
+//    }
+//    splay(last, 0);
+//    return ans;
+//}
+//
+//int post(int num) {
+//    int i = head, last = head;
+//    int ans = INT_MAX;
+//    while (i != 0) {
+//        last = i;
+//        if (key[i] <= num) {
+//            i = rs[i];
+//        } else {
+//            ans = min(ans, key[i]);
+//            i = ls[i];
+//        }
+//    }
+//    splay(last, 0);
+//    return ans;
+//}
+//
+//void remove(int num) {
+//    int kth = getRank(num);
+//    if (kth != getRank(num + 1)) {
+//        int i = find(head, kth);
+//        splay(i, 0);
+//        if (ls[i] == 0) {
+//            head = rs[i];
+//        } else if (rs[i] == 0) {
+//            head = ls[i];
+//        } else {
+//            int j = find(rs[i], 1);
+//            splay(j, i);
+//            ls[j] = ls[i];
+//            fa[ls[j]] = j;
+//            up(j);
+//            head = j;
+//        }
+//        if (head != 0) {
+//            fa[head] = 0;
+//        }
+//    }
+//}
+//
+//int main() {
+//    int n, m, lastAns = 0, ans = 0;
+//    cin >> n;
+//    cin >> m;
+//    for (int i = 1, num; i <= n; i++) {
+//        cin >> num;
+//        add(num);
+//    }
+//    for (int i = 1, op, x; i <= m; i++) {
+//        cin >> op >> x;
+//        x ^= lastAns;
+//        if (op == 1) {
+//            add(x);
+//        } else if (op == 2) {
+//            remove(x);
+//        } else if (op == 3) {
+//            lastAns = getRank(x);
+//            ans ^= lastAns;
+//        } else if (op == 4) {
+//            lastAns = index(x);
+//            ans ^= lastAns;
+//        } else if (op == 5) {
+//            lastAns = pre(x);
+//            ans ^= lastAns;
+//        } else {
+//            lastAns = post(x);
+//            ans ^= lastAns;
+//        }
+//    }
+//    cout << ans << endl;
+//    return 0;
+//}
\ No newline at end of file

From bbc5fdab592e8e21ba3d58a48d394d37f8e4ee74 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 13:14:59 +0800
Subject: [PATCH 0155/1712] modify code

---
 src/class148/Code01_AVL2.java                    |  2 ++
 src/class148/FollowUp2.java                      |  2 ++
 src/class149/SkipList2.java                      |  2 ++
 src/class150/Code02_ScapeGoat2.java              |  2 ++
 src/class150/FollowUp2.java                      |  2 ++
 src/class151/Code02_Treap2.java                  |  2 ++
 src/class151/FollowUp2.java                      |  2 ++
 src/class152/Code01_FHQTreapWithCount2.java      |  2 ++
 src/class152/Code02_FHQTreapWithoutCount2.java   |  2 ++
 src/class152/Code04_LiteraryTree2.java           |  2 ++
 src/class152/Code05_PersistentFHQTreap2.java     |  2 ++
 src/class152/Code06_PersistentLiteraryTree2.java |  2 ++
 src/class152/FollowUp2.java                      |  2 ++
 src/class153/Code01_Splay1.java                  | 14 +++++++-------
 src/class153/Code01_Splay2.java                  | 16 +++++++++-------
 src/class153/FollowUp1.java                      | 14 +++++++-------
 src/class153/FollowUp2.java                      | 16 +++++++++-------
 17 files changed, 58 insertions(+), 28 deletions(-)

diff --git a/src/class148/Code01_AVL2.java b/src/class148/Code01_AVL2.java
index 9b046a864..4202633de 100644
--- a/src/class148/Code01_AVL2.java
+++ b/src/class148/Code01_AVL2.java
@@ -214,6 +214,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    int n;
 //    cin >> n;
 //    for (int i = 1, op, x; i <= n; i++) {
diff --git a/src/class148/FollowUp2.java b/src/class148/FollowUp2.java
index ac3848565..eb9844f80 100644
--- a/src/class148/FollowUp2.java
+++ b/src/class148/FollowUp2.java
@@ -207,6 +207,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    int n, m, lastAns = 0, ans = 0;
 //    cin >> n;
 //    cin >> m;
diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
index 8a041123c..29dab5a16 100644
--- a/src/class149/SkipList2.java
+++ b/src/class149/SkipList2.java
@@ -236,6 +236,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    build();
 //    int n;
diff --git a/src/class150/Code02_ScapeGoat2.java b/src/class150/Code02_ScapeGoat2.java
index 73f0ed757..16bfe5f75 100644
--- a/src/class150/Code02_ScapeGoat2.java
+++ b/src/class150/Code02_ScapeGoat2.java
@@ -207,6 +207,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    int n;
 //    cin >> n;
 //    for (int i = 1; i <= n; i++) {
diff --git a/src/class150/FollowUp2.java b/src/class150/FollowUp2.java
index 9f6ade08e..8fe8f4e6f 100644
--- a/src/class150/FollowUp2.java
+++ b/src/class150/FollowUp2.java
@@ -200,6 +200,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    int n, m, lastAns = 0, ans = 0;
 //    cin >> n;
 //    cin >> m;
diff --git a/src/class151/Code02_Treap2.java b/src/class151/Code02_Treap2.java
index 118eb1c71..ef8b276da 100644
--- a/src/class151/Code02_Treap2.java
+++ b/src/class151/Code02_Treap2.java
@@ -189,6 +189,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n;
 //    cin >> n;
diff --git a/src/class151/FollowUp2.java b/src/class151/FollowUp2.java
index b7c79d79f..6c8793e42 100644
--- a/src/class151/FollowUp2.java
+++ b/src/class151/FollowUp2.java
@@ -182,6 +182,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n, m, lastAns = 0, ans = 0;
 //    cin >> n;
diff --git a/src/class152/Code01_FHQTreapWithCount2.java b/src/class152/Code01_FHQTreapWithCount2.java
index 3b46fdbab..dc5804004 100644
--- a/src/class152/Code01_FHQTreapWithCount2.java
+++ b/src/class152/Code01_FHQTreapWithCount2.java
@@ -177,6 +177,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n;
 //    cin >> n;
diff --git a/src/class152/Code02_FHQTreapWithoutCount2.java b/src/class152/Code02_FHQTreapWithoutCount2.java
index 75da7c2ac..9655a7fd3 100644
--- a/src/class152/Code02_FHQTreapWithoutCount2.java
+++ b/src/class152/Code02_FHQTreapWithoutCount2.java
@@ -135,6 +135,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n;
 //    cin >> n;
diff --git a/src/class152/Code04_LiteraryTree2.java b/src/class152/Code04_LiteraryTree2.java
index a4f915d83..ce492e41e 100644
--- a/src/class152/Code04_LiteraryTree2.java
+++ b/src/class152/Code04_LiteraryTree2.java
@@ -87,6 +87,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n, k;
 //    cin >> n >> k;
diff --git a/src/class152/Code05_PersistentFHQTreap2.java b/src/class152/Code05_PersistentFHQTreap2.java
index 7381c13d1..04e262a99 100644
--- a/src/class152/Code05_PersistentFHQTreap2.java
+++ b/src/class152/Code05_PersistentFHQTreap2.java
@@ -150,6 +150,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n;
 //    cin >> n;
diff --git a/src/class152/Code06_PersistentLiteraryTree2.java b/src/class152/Code06_PersistentLiteraryTree2.java
index 142051f9b..80a34595f 100644
--- a/src/class152/Code06_PersistentLiteraryTree2.java
+++ b/src/class152/Code06_PersistentLiteraryTree2.java
@@ -101,6 +101,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n;
 //    cin >> n;
diff --git a/src/class152/FollowUp2.java b/src/class152/FollowUp2.java
index 4aa697f88..1ac7e8b72 100644
--- a/src/class152/FollowUp2.java
+++ b/src/class152/FollowUp2.java
@@ -128,6 +128,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    srand(time(0));
 //    int n, m, lastAns = 0, ans = 0;
 //    cin >> n;
diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index 3829067db..a11d84c58 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -42,13 +42,13 @@ public static void up(int i) {
 		size[i] = size[left[i]] + size[right[i]] + 1;
 	}
 
-	public static int leftOrRight(int i) {
+	public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
 	public static void upRotate(int i) {
-		int f = father[i], g = father[f], son = leftOrRight(i);
-		if (son == 1) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
 			right[f] = left[i];
 			if (right[f] != 0) {
 				father[right[f]] = f;
@@ -61,15 +61,15 @@ public static void upRotate(int i) {
 			}
 			right[i] = f;
 		}
-		father[f] = i;
-		father[i] = g;
 		if (g != 0) {
-			if (right[g] == f) {
+			if (sonf == 1) {
 				right[g] = i;
 			} else {
 				left[g] = i;
 			}
 		}
+		father[f] = i;
+		father[i] = g;
 		up(f);
 		up(i);
 	}
@@ -78,7 +78,7 @@ public static void splay(int i, int goal) {
 		int f = father[i], g = father[f];
 		while (f != goal) {
 			if (g != goal) {
-				if (leftOrRight(i) == leftOrRight(f)) {
+				if (lr(i) == lr(f)) {
 					upRotate(f);
 				} else {
 					upRotate(i);
diff --git a/src/class153/Code01_Splay2.java b/src/class153/Code01_Splay2.java
index 695f9802a..596b78485 100644
--- a/src/class153/Code01_Splay2.java
+++ b/src/class153/Code01_Splay2.java
@@ -35,13 +35,13 @@
 //    size[i] = size[ls[i]] + size[rs[i]] + 1;
 //}
 //
-//int leftOrRight(int i) {
+//int lr(int i) {
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
 //void upRotate(int i) {
-//    int f = fa[i], g = fa[f], son = leftOrRight(i);
-//    if (son == 1) {
+//    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
+//    if (soni == 1) {
 //        rs[f] = ls[i];
 //        if (rs[f] != 0) {
 //            fa[rs[f]] = f;
@@ -54,15 +54,15 @@
 //        }
 //        rs[i] = f;
 //    }
-//    fa[f] = i;
-//    fa[i] = g;
 //    if (g != 0) {
-//        if (rs[g] == f) {
+//        if (sonf == 1) {
 //            rs[g] = i;
 //        } else {
 //            ls[g] = i;
 //        }
 //    }
+//    fa[f] = i;
+//    fa[i] = g;
 //    up(f);
 //    up(i);
 //}
@@ -71,7 +71,7 @@
 //    int f = fa[i], g = fa[f];
 //    while (f != goal) {
 //        if (g != goal) {
-//            if (leftOrRight(i) == leftOrRight(f)) {
+//            if (lr(i) == lr(f)) {
 //                upRotate(f);
 //            } else {
 //                upRotate(i);
@@ -217,6 +217,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    int n;
 //    cin >> n;
 //    for (int i = 0, op, x; i < n; i++) {
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index be32d1152..09931bdc4 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -35,13 +35,13 @@ public static void up(int i) {
 		size[i] = size[left[i]] + size[right[i]] + 1;
 	}
 
-	public static int leftOrRight(int i) {
+	public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
 	public static void upRotate(int i) {
-		int f = father[i], g = father[f], son = leftOrRight(i);
-		if (son == 1) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
 			right[f] = left[i];
 			if (right[f] != 0) {
 				father[right[f]] = f;
@@ -54,15 +54,15 @@ public static void upRotate(int i) {
 			}
 			right[i] = f;
 		}
-		father[f] = i;
-		father[i] = g;
 		if (g != 0) {
-			if (right[g] == f) {
+			if (sonf == 1) {
 				right[g] = i;
 			} else {
 				left[g] = i;
 			}
 		}
+		father[f] = i;
+		father[i] = g;
 		up(f);
 		up(i);
 	}
@@ -71,7 +71,7 @@ public static void splay(int i, int goal) {
 		int f = father[i], g = father[f];
 		while (f != goal) {
 			if (g != goal) {
-				if (leftOrRight(i) == leftOrRight(f)) {
+				if (lr(i) == lr(f)) {
 					upRotate(f);
 				} else {
 					upRotate(i);
diff --git a/src/class153/FollowUp2.java b/src/class153/FollowUp2.java
index f47800023..6c3122cb2 100644
--- a/src/class153/FollowUp2.java
+++ b/src/class153/FollowUp2.java
@@ -28,13 +28,13 @@
 //    size[i] = size[ls[i]] + size[rs[i]] + 1;
 //}
 //
-//int leftOrRight(int i) {
+//int lr(int i) {
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
 //void upRotate(int i) {
-//    int f = fa[i], g = fa[f], son = leftOrRight(i);
-//    if (son == 1) {
+//    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
+//    if (soni == 1) {
 //        rs[f] = ls[i];
 //        if (rs[f] != 0) {
 //            fa[rs[f]] = f;
@@ -47,15 +47,15 @@
 //        }
 //        rs[i] = f;
 //    }
-//    fa[f] = i;
-//    fa[i] = g;
 //    if (g != 0) {
-//        if (rs[g] == f) {
+//        if (sonf == 1) {
 //            rs[g] = i;
 //        } else {
 //            ls[g] = i;
 //        }
 //    }
+//    fa[f] = i;
+//    fa[i] = g;
 //    up(f);
 //    up(i);
 //}
@@ -64,7 +64,7 @@
 //    int f = fa[i], g = fa[f];
 //    while (f != goal) {
 //        if (g != goal) {
-//            if (leftOrRight(i) == leftOrRight(f)) {
+//            if (lr(i) == lr(f)) {
 //                upRotate(f);
 //            } else {
 //                upRotate(i);
@@ -210,6 +210,8 @@
 //}
 //
 //int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
 //    int n, m, lastAns = 0, ans = 0;
 //    cin >> n;
 //    cin >> m;

From 0873df497bf215467dbeac0542a8611cd83ca558 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 14:30:40 +0800
Subject: [PATCH 0156/1712] modify code

---
 src/class153/Code02_LiteraryTree1.java | 225 +++++++++++++++++++++++++
 src/class153/Code02_LiteraryTree2.java | 197 ++++++++++++++++++++++
 2 files changed, 422 insertions(+)
 create mode 100644 src/class153/Code02_LiteraryTree1.java
 create mode 100644 src/class153/Code02_LiteraryTree2.java

diff --git a/src/class153/Code02_LiteraryTree1.java b/src/class153/Code02_LiteraryTree1.java
new file mode 100644
index 000000000..401a05938
--- /dev/null
+++ b/src/class153/Code02_LiteraryTree1.java
@@ -0,0 +1,225 @@
+package class153;
+
+// 文艺平衡树，Splay实现范围翻转，java版本
+// 长度为n的序列，下标从1开始，一开始序列为1, 2, ..., n
+// 接下来会有k个操作，每个操作给定l，r，表示从l到r范围上的所有数字翻转
+// 做完k次操作后，从左到右打印所有数字
+// 1 <= n, k <= 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P3391
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_LiteraryTree1 {
+
+	public static int MAXN = 100005;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static boolean[] reverse = new boolean[MAXN];
+
+	public static int[] stack = new int[MAXN];
+
+	public static int si;
+
+	public static int[] ans = new int[MAXN];
+
+	public static int ai;
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int lr(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void upRotate(int i) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		if (g != 0) {
+			if (sonf == 1) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		father[f] = i;
+		father[i] = g;
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (lr(i) == lr(f)) {
+					upRotate(f);
+				} else {
+					upRotate(i);
+				}
+			}
+			upRotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	public static void down(int i) {
+		if (reverse[i]) {
+			reverse[left[i]] = !reverse[left[i]];
+			reverse[right[i]] = !reverse[right[i]];
+			int tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+			reverse[i] = false;
+		}
+	}
+
+	public static int find(int i, int rank) {
+		while (i != 0) {
+			down(i);
+			if (size[left[i]] + 1 == rank) {
+				return i;
+			} else if (size[left[i]] >= rank) {
+				i = left[i];
+			} else {
+				rank -= size[left[i]] + 1;
+				i = right[i];
+			}
+		}
+		return 0;
+	}
+
+	public static void add(int num) {
+		key[++cnt] = num;
+		size[cnt] = 1;
+		if (head == 0) {
+			head = cnt;
+		} else {
+			int f = 0, i = head, son = 0;
+			while (i != 0) {
+				size[i]++;
+				f = i;
+				if (key[i] <= num) {
+					son = 1;
+					i = right[i];
+				} else {
+					son = 0;
+					i = left[i];
+				}
+			}
+			if (son == 1) {
+				right[f] = cnt;
+			} else {
+				left[f] = cnt;
+			}
+			father[cnt] = f;
+			splay(cnt, 0);
+		}
+	}
+
+	public static void reverse(int l, int r) {
+		int i = find(head, l - 1);
+		int j = find(head, r + 1);
+		splay(i, 0);
+		splay(j, i);
+		reverse[left[right[head]]] = !reverse[left[right[head]]];
+	}
+
+	// 递归方式实现二叉树中序遍历
+	// 对本题来说，递归不会爆栈，但其实是有风险的
+	public static void inorder(int i) {
+		if (i != 0) {
+			down(i);
+			inorder(left[i]);
+			ans[++ai] = key[i];
+			inorder(right[i]);
+		}
+	}
+
+	// 迭代方式实现二叉树中序遍历，防止递归爆栈
+	// 不懂的话，看讲解018，迭代方式实现二叉树中序遍历
+	// 遍历时候懒更新任务也要下发
+	public static void inorder() {
+		si = 0;
+		int i = head;
+		while (si != 0 || i != 0) {
+			if (i != 0) {
+				down(i);
+				stack[++si] = i;
+				i = left[i];
+			} else {
+				i = stack[si--];
+				ans[++ai] = key[i];
+				i = right[i];
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		add(Integer.MIN_VALUE);
+		add(Integer.MAX_VALUE);
+		for (int i = 1; i <= n; i++) {
+			add(i);
+		}
+		for (int i = 1, x, y; i <= m; i++) {
+			in.nextToken();
+			x = (int) in.nval;
+			in.nextToken();
+			y = (int) in.nval;
+			reverse(x + 1, y + 1);
+		}
+		ai = 0;
+//		inorder(head);
+		inorder();
+		for (int i = 2; i < ai; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class153/Code02_LiteraryTree2.java b/src/class153/Code02_LiteraryTree2.java
new file mode 100644
index 000000000..25589ea4b
--- /dev/null
+++ b/src/class153/Code02_LiteraryTree2.java
@@ -0,0 +1,197 @@
+package class153;
+
+// 文艺平衡树，Splay实现范围翻转，C++版本
+// 长度为n的序列，下标从1开始，一开始序列为1, 2, ..., n
+// 接下来会有k个操作，每个操作给定l，r，表示从l到r范围上的所有数字翻转
+// 做完k次操作后，从左到右打印所有数字
+// 1 <= n, k <= 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P3391
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <stack>
+//#include <climits>
+//using namespace std;
+//
+//const int MAXN = 100005;
+//
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//bool rev[MAXN];
+//int sta[MAXN];
+//int si;
+//int ans[MAXN];
+//int ai;
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//int lr(int i) {
+//    return rs[fa[i]] == i ? 1 : 0;
+//}
+//
+//void upRotate(int i) {
+//    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
+//    if (soni == 1) {
+//        rs[f] = ls[i];
+//        if (rs[f] != 0) {
+//            fa[rs[f]] = f;
+//        }
+//        ls[i] = f;
+//    } else {
+//        ls[f] = rs[i];
+//        if (ls[f] != 0) {
+//            fa[ls[f]] = f;
+//        }
+//        rs[i] = f;
+//    }
+//    if (g != 0) {
+//        if (sonf == 1) {
+//            rs[g] = i;
+//        } else {
+//            ls[g] = i;
+//        }
+//    }
+//    fa[f] = i;
+//    fa[i] = g;
+//    up(f);
+//    up(i);
+//}
+//
+//void splay(int i, int goal) {
+//    int f = fa[i], g = fa[f];
+//    while (f != goal) {
+//        if (g != goal) {
+//            if (lr(i) == lr(f)) {
+//                upRotate(f);
+//            } else {
+//                upRotate(i);
+//            }
+//        }
+//        upRotate(i);
+//        f = fa[i];
+//        g = fa[f];
+//    }
+//    if (goal == 0) {
+//        head = i;
+//    }
+//}
+//
+//void down(int i) {
+//    if (rev[i]) {
+//        rev[ls[i]] = !rev[ls[i]];
+//        rev[rs[i]] = !rev[rs[i]];
+//        int tmp = ls[i];
+//        ls[i] = rs[i];
+//        rs[i] = tmp;
+//        rev[i] = false;
+//    }
+//}
+//
+//int find(int i, int rank) {
+//    while (i != 0) {
+//        down(i);
+//        if (size[ls[i]] + 1 == rank) {
+//            return i;
+//        } else if (size[ls[i]] >= rank) {
+//            i = ls[i];
+//        } else {
+//            rank -= size[ls[i]] + 1;
+//            i = rs[i];
+//        }
+//    }
+//    return 0;
+//}
+//
+//void add(int num) {
+//    key[++cnt] = num;
+//    size[cnt] = 1;
+//    if (head == 0) {
+//        head = cnt;
+//    } else {
+//        int f = 0, i = head, son = 0;
+//        while (i != 0) {
+//            size[i]++;
+//            f = i;
+//            if (key[i] <= num) {
+//                son = 1;
+//                i = rs[i];
+//            } else {
+//                son = 0;
+//                i = ls[i];
+//            }
+//        }
+//        if (son == 1) {
+//            rs[f] = cnt;
+//        } else {
+//            ls[f] = cnt;
+//        }
+//        fa[cnt] = f;
+//        splay(cnt, 0);
+//    }
+//}
+//
+//void reverse(int l, int r) {
+//    int i = find(head, l - 1);
+//    int j = find(head, r + 1);
+//    splay(i, 0);
+//    splay(j, i);
+//    rev[ls[rs[head]]] = !rev[ls[rs[head]]];
+//}
+//
+//void inorder(int i) {
+//    if (i != 0) {
+//        down(i);
+//        inorder(ls[i]);
+//        ans[++ai] = key[i];
+//        inorder(rs[i]);
+//    }
+//}
+//
+//void inorder() {
+//    si = 0;
+//    int i = head;
+//    while (si != 0 || i != 0) {
+//        if (i != 0) {
+//            down(i);
+//            sta[++si] = i;
+//            i = ls[i];
+//        } else {
+//            i = sta[si--];
+//            ans[++ai] = key[i];
+//            i = rs[i];
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n, m;
+//    cin >> n >> m;
+//    add(INT_MIN);
+//    add(INT_MAX);
+//    for (int i = 1; i <= n; i++) {
+//        add(i);
+//    }
+//    for (int i = 1, x, y; i <= m; i++) {
+//        cin >> x >> y;
+//        reverse(x + 1, y + 1);
+//    }
+//    ai = 0;
+//    // inorder(head);
+//    inorder();
+//    for (int i = 2; i < ai; i++) {
+//        cout << ans[i] << " ";
+//    }
+//    cout << endl;
+//    return 0;
+//}
\ No newline at end of file

From 82007fd7b7f5694c586cc31eb47798c159a37c26 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 16:24:25 +0800
Subject: [PATCH 0157/1712] modify code

---
 src/class153/Code03_FrustratedCashier.java | 235 +++++++++++++++++++++
 1 file changed, 235 insertions(+)
 create mode 100644 src/class153/Code03_FrustratedCashier.java

diff --git a/src/class153/Code03_FrustratedCashier.java b/src/class153/Code03_FrustratedCashier.java
new file mode 100644
index 000000000..46dd980f7
--- /dev/null
+++ b/src/class153/Code03_FrustratedCashier.java
@@ -0,0 +1,235 @@
+package class153;
+
+// 郁闷的出纳员
+// 测试链接 : https://www.luogu.com.cn/problem/P1486
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code03_FrustratedCashier {
+
+	public static int MAXN = 300001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int limit;
+
+	public static int change = 0;
+
+	public static int enter = 0;
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int lr(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void upRotate(int i) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		if (g != 0) {
+			if (sonf == 1) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		father[f] = i;
+		father[i] = g;
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (lr(i) == lr(f)) {
+					upRotate(f);
+				} else {
+					upRotate(i);
+				}
+			}
+			upRotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	public static void add(int num) {
+		key[++cnt] = num;
+		size[cnt] = 1;
+		if (head == 0) {
+			head = cnt;
+		} else {
+			int f = 0, i = head, son = 0;
+			while (i != 0) {
+				size[i]++;
+				f = i;
+				if (key[i] <= num) {
+					son = 1;
+					i = right[i];
+				} else {
+					son = 0;
+					i = left[i];
+				}
+			}
+			if (son == 1) {
+				right[f] = cnt;
+			} else {
+				left[f] = cnt;
+			}
+			father[cnt] = f;
+			splay(cnt, 0);
+		}
+	}
+
+	public static int index(int x) {
+		int i = head, last = head;
+		while (i != 0) {
+			last = i;
+			if (size[left[i]] >= x) {
+				i = left[i];
+			} else if (size[left[i]] + 1 < x) {
+				x -= size[left[i]] + 1;
+				i = right[i];
+			} else {
+				i = 0;
+			}
+		}
+		splay(last, 0);
+		return key[last];
+	}
+
+	public static void departure() {
+		int num = limit - change - 1;
+		int i = head, ans = 0;
+		while (i != 0) {
+			if (key[i] <= num) {
+				ans = i;
+				i = right[i];
+			} else {
+				i = left[i];
+			}
+		}
+		if (ans == 0) {
+			return;
+		}
+		splay(ans, 0);
+		head = right[head];
+		father[head] = 0;
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		int n = io.nextInt();
+		limit = io.nextInt();
+		String op;
+		int x;
+		for (int i = 1; i <= n; i++) {
+			op = io.next();
+			x = io.nextInt();
+			if (op.equals("I")) {
+				if (x >= limit) {
+					enter++;
+					add(x - change);
+				}
+			} else if (op.equals("A")) {
+				change += x;
+			} else if (op.equals("S")) {
+				change -= x;
+				departure();
+			} else {
+				if (x > size[head]) {
+					io.println(-1);
+				} else {
+					io.println(index(size[head] - x + 1) + change);
+				}
+			}
+		}
+		io.println(enter - size[head]);
+		io.flush();
+		io.close();
+	}
+
+	// Kattio类IO效率很好，但还是不如StreamTokenizer
+	// 只有StreamTokenizer无法正确处理时，才考虑使用这个类
+	// 参考链接 : https://oi-wiki.org/lang/java-pro/
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}

From b4128f8882da3848ba46e4bbb38a44b24f2abb8c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 18:46:50 +0800
Subject: [PATCH 0158/1712] modify code

---
 ...er.java => Code03_FrustratedCashier1.java} |   4 +-
 src/class153/Code03_FrustratedCashier2.java   | 173 ++++++++++++++++++
 src/class153/Code05_MaintainSequence.java     |  69 +++++++
 3 files changed, 244 insertions(+), 2 deletions(-)
 rename src/class153/{Code03_FrustratedCashier.java => Code03_FrustratedCashier1.java} (98%)
 create mode 100644 src/class153/Code03_FrustratedCashier2.java
 create mode 100644 src/class153/Code05_MaintainSequence.java

diff --git a/src/class153/Code03_FrustratedCashier.java b/src/class153/Code03_FrustratedCashier1.java
similarity index 98%
rename from src/class153/Code03_FrustratedCashier.java
rename to src/class153/Code03_FrustratedCashier1.java
index 46dd980f7..c84147375 100644
--- a/src/class153/Code03_FrustratedCashier.java
+++ b/src/class153/Code03_FrustratedCashier1.java
@@ -1,6 +1,6 @@
 package class153;
 
-// 郁闷的出纳员
+// 郁闷的出纳员(java版)
 // 测试链接 : https://www.luogu.com.cn/problem/P1486
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code03_FrustratedCashier {
+public class Code03_FrustratedCashier1 {
 
 	public static int MAXN = 300001;
 
diff --git a/src/class153/Code03_FrustratedCashier2.java b/src/class153/Code03_FrustratedCashier2.java
new file mode 100644
index 000000000..edb54a585
--- /dev/null
+++ b/src/class153/Code03_FrustratedCashier2.java
@@ -0,0 +1,173 @@
+package class153;
+
+// 郁闷的出纳员(C++版)
+// 测试链接 : https://www.luogu.com.cn/problem/P1486
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstring>
+//#include <algorithm>
+//using namespace std;
+//
+//const int MAXN = 300001;
+//
+//int head = 0;
+//int cnt = 0;
+//int key[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//int limit;
+//int change = 0;
+//int enter = 0;
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//int lr(int i) {
+//    return rs[fa[i]] == i ? 1 : 0;
+//}
+//
+//void upRotate(int i) {
+//    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
+//    if (soni == 1) {
+//        rs[f] = ls[i];
+//        if (rs[f] != 0) {
+//            fa[rs[f]] = f;
+//        }
+//        ls[i] = f;
+//    } else {
+//        ls[f] = rs[i];
+//        if (ls[f] != 0) {
+//            fa[ls[f]] = f;
+//        }
+//        rs[i] = f;
+//    }
+//    if (g != 0) {
+//        if (sonf == 1) {
+//            rs[g] = i;
+//        } else {
+//            ls[g] = i;
+//        }
+//    }
+//    fa[f] = i;
+//    fa[i] = g;
+//    up(f);
+//    up(i);
+//}
+//
+//void splay(int i, int goal) {
+//    int f = fa[i], g = fa[f];
+//    while (f != goal) {
+//        if (g != goal) {
+//            if (lr(i) == lr(f)) {
+//                upRotate(f);
+//            } else {
+//                upRotate(i);
+//            }
+//        }
+//        upRotate(i);
+//        f = fa[i];
+//        g = fa[f];
+//    }
+//    if (goal == 0) {
+//        head = i;
+//    }
+//}
+//
+//void add(int num) {
+//    key[++cnt] = num;
+//    size[cnt] = 1;
+//    if (head == 0) {
+//        head = cnt;
+//    } else {
+//        int f = 0, i = head, son = 0;
+//        while (i != 0) {
+//            size[i]++;
+//            f = i;
+//            if (key[i] <= num) {
+//                son = 1;
+//                i = rs[i];
+//            } else {
+//                son = 0;
+//                i = ls[i];
+//            }
+//        }
+//        if (son == 1) {
+//            rs[f] = cnt;
+//        } else {
+//            ls[f] = cnt;
+//        }
+//        fa[cnt] = f;
+//        splay(cnt, 0);
+//    }
+//}
+//
+//int index(int x) {
+//    int i = head, last = head;
+//    while (i != 0) {
+//        last = i;
+//        if (size[ls[i]] >= x) {
+//            i = ls[i];
+//        } else if (size[ls[i]] + 1 < x) {
+//            x -= size[ls[i]] + 1;
+//            i = rs[i];
+//        } else {
+//            i = 0;
+//        }
+//    }
+//    splay(last, 0);
+//    return key[last];
+//}
+//
+//void departure() {
+//    int num = limit - change - 1;
+//    int i = head, ans = 0;
+//    while (i != 0) {
+//        if (key[i] <= num) {
+//            ans = i;
+//            i = rs[i];
+//        } else {
+//            i = ls[i];
+//        }
+//    }
+//    if (ans == 0) {
+//        return;
+//    }
+//    splay(ans, 0);
+//    head = rs[head];
+//    fa[head] = 0;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n, x;
+//    char op;
+//    cin >> n >> limit;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> op >> x;
+//        if (op == 'I') {
+//            if (x >= limit) {
+//                enter++;
+//                add(x - change);
+//            }
+//        } else if (op == 'A') {
+//            change += x;
+//        } else if (op == 'S') {
+//            change -= x;
+//            departure();
+//        } else if (op == 'F') {
+//            if (x > size[head]) {
+//                cout << -1 << endl;
+//            } else {
+//                cout << index(size[head] - x + 1) + change << endl;
+//            }
+//        }
+//    }
+//    cout << enter - size[head] << endl;
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class153/Code05_MaintainSequence.java b/src/class153/Code05_MaintainSequence.java
new file mode 100644
index 000000000..00d5c8de7
--- /dev/null
+++ b/src/class153/Code05_MaintainSequence.java
@@ -0,0 +1,69 @@
+package class153;
+
+// 维护数列
+// 测试链接 : https://www.luogu.com.cn/problem/P2042
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code05_MaintainSequence {
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+
+		io.flush();
+		io.close();
+	}
+
+	// Kattio类IO效率很好，但还是不如StreamTokenizer
+	// 只有StreamTokenizer无法正确处理时，才考虑使用这个类
+	// 参考链接 : https://oi-wiki.org/lang/java-pro/
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}

From a176c37e00132c1780817126c6b73469dc660158 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 18:51:30 +0800
Subject: [PATCH 0159/1712] modify code

---
 src/class153/Code04_Bookcase1.java            | 69 +++++++++++++++++++
 ...nce.java => Code05_MaintainSequence1.java} |  4 +-
 2 files changed, 71 insertions(+), 2 deletions(-)
 create mode 100644 src/class153/Code04_Bookcase1.java
 rename src/class153/{Code05_MaintainSequence.java => Code05_MaintainSequence1.java} (95%)

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
new file mode 100644
index 000000000..df8a43b71
--- /dev/null
+++ b/src/class153/Code04_Bookcase1.java
@@ -0,0 +1,69 @@
+package class153;
+
+// 书架(java版)
+// 测试链接 : https://www.luogu.com.cn/problem/P2596
+// s提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code04_Bookcase1 {
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+
+		io.flush();
+		io.close();
+	}
+
+	// Kattio类IO效率很好，但还是不如StreamTokenizer
+	// 只有StreamTokenizer无法正确处理时，才考虑使用这个类
+	// 参考链接 : https://oi-wiki.org/lang/java-pro/
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class153/Code05_MaintainSequence.java b/src/class153/Code05_MaintainSequence1.java
similarity index 95%
rename from src/class153/Code05_MaintainSequence.java
rename to src/class153/Code05_MaintainSequence1.java
index 00d5c8de7..83e9bccf7 100644
--- a/src/class153/Code05_MaintainSequence.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -1,6 +1,6 @@
 package class153;
 
-// 维护数列
+// 维护数列(java版)
 // 测试链接 : https://www.luogu.com.cn/problem/P2042
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code05_MaintainSequence {
+public class Code05_MaintainSequence1 {
 
 	public static void main(String[] args) {
 		Kattio io = new Kattio();

From 2a5c2a22ba9e5d6515a807bf1997d1015334e638 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 23:04:35 +0800
Subject: [PATCH 0160/1712] modify code

---
 src/class153/Code01_Splay1.java             |   1 -
 src/class153/Code01_Splay2.java             |   1 -
 src/class153/Code02_LiteraryTree1.java      |  32 +---
 src/class153/Code02_LiteraryTree2.java      |  32 +---
 src/class153/Code03_FrustratedCashier1.java |   1 -
 src/class153/Code03_FrustratedCashier2.java |   1 -
 src/class153/Code04_Bookcase1.java          | 194 ++++++++++++++++++-
 src/class153/Code04_Bookcase2.java          | 197 ++++++++++++++++++++
 src/class153/FollowUp1.java                 |   1 -
 src/class153/FollowUp2.java                 |   1 -
 10 files changed, 405 insertions(+), 56 deletions(-)
 create mode 100644 src/class153/Code04_Bookcase2.java

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index a11d84c58..cbf372795 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -116,7 +116,6 @@ public static void add(int num) {
 		} else {
 			int f = 0, i = head, son = 0;
 			while (i != 0) {
-				size[i]++;
 				f = i;
 				if (key[i] <= num) {
 					son = 1;
diff --git a/src/class153/Code01_Splay2.java b/src/class153/Code01_Splay2.java
index 596b78485..6d2630084 100644
--- a/src/class153/Code01_Splay2.java
+++ b/src/class153/Code01_Splay2.java
@@ -108,7 +108,6 @@
 //    } else {
 //        int f = 0, i = head, son = 0;
 //        while (i != 0) {
-//            size[i]++;
 //            f = i;
 //            if (key[i] <= num) {
 //                son = 1;
diff --git a/src/class153/Code02_LiteraryTree1.java b/src/class153/Code02_LiteraryTree1.java
index 401a05938..5f992966b 100644
--- a/src/class153/Code02_LiteraryTree1.java
+++ b/src/class153/Code02_LiteraryTree1.java
@@ -125,31 +125,15 @@ public static int find(int i, int rank) {
 	}
 
 	public static void add(int num) {
+		int i = head;
+		while (right[i] != 0) {
+			i = right[i];
+		}
 		key[++cnt] = num;
 		size[cnt] = 1;
-		if (head == 0) {
-			head = cnt;
-		} else {
-			int f = 0, i = head, son = 0;
-			while (i != 0) {
-				size[i]++;
-				f = i;
-				if (key[i] <= num) {
-					son = 1;
-					i = right[i];
-				} else {
-					son = 0;
-					i = left[i];
-				}
-			}
-			if (son == 1) {
-				right[f] = cnt;
-			} else {
-				left[f] = cnt;
-			}
-			father[cnt] = f;
-			splay(cnt, 0);
-		}
+		father[cnt] = i;
+		right[i] = cnt;
+		splay(cnt, 0);
 	}
 
 	public static void reverse(int l, int r) {
@@ -199,10 +183,10 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		int m = (int) in.nval;
 		add(Integer.MIN_VALUE);
-		add(Integer.MAX_VALUE);
 		for (int i = 1; i <= n; i++) {
 			add(i);
 		}
+		add(Integer.MAX_VALUE);
 		for (int i = 1, x, y; i <= m; i++) {
 			in.nextToken();
 			x = (int) in.nval;
diff --git a/src/class153/Code02_LiteraryTree2.java b/src/class153/Code02_LiteraryTree2.java
index 25589ea4b..856d94966 100644
--- a/src/class153/Code02_LiteraryTree2.java
+++ b/src/class153/Code02_LiteraryTree2.java
@@ -112,31 +112,15 @@
 //}
 //
 //void add(int num) {
+//    int i = head;
+//    while (rs[i] != 0) {
+//        i = rs[i];
+//    }
 //    key[++cnt] = num;
 //    size[cnt] = 1;
-//    if (head == 0) {
-//        head = cnt;
-//    } else {
-//        int f = 0, i = head, son = 0;
-//        while (i != 0) {
-//            size[i]++;
-//            f = i;
-//            if (key[i] <= num) {
-//                son = 1;
-//                i = rs[i];
-//            } else {
-//                son = 0;
-//                i = ls[i];
-//            }
-//        }
-//        if (son == 1) {
-//            rs[f] = cnt;
-//        } else {
-//            ls[f] = cnt;
-//        }
-//        fa[cnt] = f;
-//        splay(cnt, 0);
-//    }
+//    fa[cnt] = i;
+//    rs[i] = cnt;
+//    splay(cnt, 0);
 //}
 //
 //void reverse(int l, int r) {
@@ -178,10 +162,10 @@
 //    int n, m;
 //    cin >> n >> m;
 //    add(INT_MIN);
-//    add(INT_MAX);
 //    for (int i = 1; i <= n; i++) {
 //        add(i);
 //    }
+//    add(INT_MAX);
 //    for (int i = 1, x, y; i <= m; i++) {
 //        cin >> x >> y;
 //        reverse(x + 1, y + 1);
diff --git a/src/class153/Code03_FrustratedCashier1.java b/src/class153/Code03_FrustratedCashier1.java
index c84147375..01c353724 100644
--- a/src/class153/Code03_FrustratedCashier1.java
+++ b/src/class153/Code03_FrustratedCashier1.java
@@ -100,7 +100,6 @@ public static void add(int num) {
 		} else {
 			int f = 0, i = head, son = 0;
 			while (i != 0) {
-				size[i]++;
 				f = i;
 				if (key[i] <= num) {
 					son = 1;
diff --git a/src/class153/Code03_FrustratedCashier2.java b/src/class153/Code03_FrustratedCashier2.java
index edb54a585..7446e729e 100644
--- a/src/class153/Code03_FrustratedCashier2.java
+++ b/src/class153/Code03_FrustratedCashier2.java
@@ -86,7 +86,6 @@
 //    } else {
 //        int f = 0, i = head, son = 0;
 //        while (i != 0) {
-//            size[i]++;
 //            f = i;
 //            if (key[i] <= num) {
 //                son = 1;
diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index df8a43b71..2c9bf8485 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -2,7 +2,7 @@
 
 // 书架(java版)
 // 测试链接 : https://www.luogu.com.cn/problem/P2596
-// s提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedReader;
 import java.io.FileReader;
@@ -15,9 +15,199 @@
 
 public class Code04_Bookcase1 {
 
+	public static int MAXN = 80001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] num = new int[MAXN];
+
+	public static int[] pos = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int n, m;
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int lr(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void upRotate(int i) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		if (g != 0) {
+			if (sonf == 1) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		father[f] = i;
+		father[i] = g;
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (lr(i) == lr(f)) {
+					upRotate(f);
+				} else {
+					upRotate(i);
+				}
+			}
+			upRotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	// 返回排名为rank的节点编号
+	public static int find(int rank) {
+		int i = head, ans = 0;
+		while (i != 0) {
+			if (size[left[i]] + 1 == rank) {
+				ans = i;
+				break;
+			} else if (size[left[i]] >= rank) {
+				i = left[i];
+			} else {
+				rank -= size[left[i]] + 1;
+				i = right[i];
+			}
+		}
+		splay(ans, 0);
+		return ans;
+	}
+
+	public static void add(int s) {
+		int i = head;
+		while (right[i] != 0) {
+			i = right[i];
+		}
+		num[++cnt] = s;
+		pos[s] = cnt;
+		size[cnt] = 1;
+		father[cnt] = i;
+		right[i] = cnt;
+		splay(cnt, 0);
+	}
+
+	public static int ask(int s) {
+		int i = pos[s];
+		splay(i, 0);
+		return size[left[i]];
+	}
+
+	public static int query(int s) {
+		return num[find(s)];
+	}
+
+	// 节点编号为i的节点，已知排名是rank，结构上把该节点分离出来
+	public static void disconnect(int i, int rank) {
+		splay(i, 0);
+		if (rank == 1) {
+			head = right[head];
+			father[head] = 0;
+		} else if (rank == n) {
+			head = left[head];
+			father[head] = 0;
+		} else {
+			int l = find(rank - 1);
+			splay(l, 0);
+			splay(i, l);
+			right[l] = right[i];
+			father[right[l]] = l;
+			up(l);
+		}
+		father[i] = left[i] = right[i] = 0;
+	}
+
+	// 节点编号为i的节点已经分离出来了，插入回结构中，让其排名为rank
+	public static void connect(int i, int rank) {
+		if (rank == 1) {
+			right[i] = head;
+			father[right[i]] = i;
+			head = i;
+			up(i);
+		} else if (rank == n) {
+			left[i] = head;
+			father[left[i]] = i;
+			head = i;
+			up(i);
+		} else {
+			int r = find(rank - 1);
+			int next = find(rank);
+			splay(r, 0);
+			splay(next, r);
+			right[r] = i;
+			father[i] = r;
+			right[i] = next;
+			father[next] = i;
+			up(i);
+			up(r);
+		}
+	}
+
+	// 节点编号为i的节点，现在排名from，移动到排名to的位置
+	public static void move(int i, int from, int to) {
+		disconnect(i, from);
+		connect(i, to);
+	}
+
 	public static void main(String[] args) {
 		Kattio io = new Kattio();
-
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1; i <= n; i++) {
+			add(io.nextInt());
+		}
+		String op;
+		for (int i = 1, s, t, small; i <= m; i++) {
+			op = io.next();
+			s = io.nextInt();
+			small = ask(s);
+			if (op.equals("Top")) {
+				move(pos[s], small + 1, 1);
+			} else if (op.equals("Bottom")) {
+				move(pos[s], small + 1, n);
+			} else if (op.equals("Insert")) {
+				t = io.nextInt();
+				move(pos[s], small + 1, ask(s) + t + 1);
+			} else if (op.equals("Ask")) {
+				io.println(small);
+			} else {
+				io.println(query(s));
+			}
+		}
 		io.flush();
 		io.close();
 	}
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
new file mode 100644
index 000000000..95402f143
--- /dev/null
+++ b/src/class153/Code04_Bookcase2.java
@@ -0,0 +1,197 @@
+package class153;
+
+// 书架(C++版)
+// 测试链接 : https://www.luogu.com.cn/problem/P2596
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <string>
+//using namespace std;
+//
+//const int MAXN = 80001;
+//
+//int head = 0;
+//int cnt = 0;
+//int num[MAXN];
+//int pos[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//int n, m;
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//}
+//
+//int lr(int i) {
+//    return rs[fa[i]] == i ? 1 : 0;
+//}
+//
+//void upRotate(int i) {
+//    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
+//    if (soni == 1) {
+//        rs[f] = ls[i];
+//        if (rs[f] != 0) {
+//            fa[rs[f]] = f;
+//        }
+//        ls[i] = f;
+//    } else {
+//        ls[f] = rs[i];
+//        if (ls[f] != 0) {
+//            fa[ls[f]] = f;
+//        }
+//        rs[i] = f;
+//    }
+//    if (g != 0) {
+//        if (sonf == 1) {
+//            rs[g] = i;
+//        } else {
+//            ls[g] = i;
+//        }
+//    }
+//    fa[f] = i;
+//    fa[i] = g;
+//    up(f);
+//    up(i);
+//}
+//
+//void splay(int i, int goal) {
+//    int f = fa[i], g = fa[f];
+//    while (f != goal) {
+//        if (g != goal) {
+//            if (lr(i) == lr(f)) {
+//                upRotate(f);
+//            } else {
+//                upRotate(i);
+//            }
+//        }
+//        upRotate(i);
+//        f = fa[i];
+//        g = fa[f];
+//    }
+//    if (goal == 0) {
+//        head = i;
+//    }
+//}
+//
+//int find(int rank) {
+//    int i = head, ans = 0;
+//    while (i != 0) {
+//        if (size[ls[i]] + 1 == rank) {
+//            ans = i;
+//            break;
+//        } else if (size[ls[i]] >= rank) {
+//            i = ls[i];
+//        } else {
+//            rank -= size[ls[i]] + 1;
+//            i = rs[i];
+//        }
+//    }
+//    splay(ans, 0);
+//    return ans;
+//}
+//
+//void add(int s) {
+//    int i = head;
+//    while (rs[i] != 0) {
+//        i = rs[i];
+//    }
+//    num[++cnt] = s;
+//    pos[s] = cnt;
+//    size[cnt] = 1;
+//    fa[cnt] = i;
+//    rs[i] = cnt;
+//    splay(cnt, 0);
+//}
+//
+//int ask(int s) {
+//    int i = pos[s];
+//    splay(i, 0);
+//    return size[ls[i]];
+//}
+//
+//int query(int s) {
+//    return num[find(s)];
+//}
+//
+//void disconnect(int i, int rank) {
+//    splay(i, 0);
+//    if (rank == 1) {
+//        head = rs[head];
+//        fa[head] = 0;
+//    } else if (rank == n) {
+//        head = ls[head];
+//        fa[head] = 0;
+//    } else {
+//        int l = find(rank - 1);
+//        splay(l, 0);
+//        splay(i, l);
+//        rs[l] = rs[i];
+//        fa[rs[l]] = l;
+//        up(l);
+//    }
+//    fa[i] = ls[i] = rs[i] = 0;
+//}
+//
+//void connect(int i, int rank) {
+//    if (rank == 1) {
+//        rs[i] = head;
+//        fa[rs[i]] = i;
+//        head = i;
+//        up(i);
+//    } else if (rank == n) {
+//        ls[i] = head;
+//        fa[ls[i]] = i;
+//        head = i;
+//        up(i);
+//    } else {
+//        int r = find(rank - 1);
+//        int next = find(rank);
+//        splay(r, 0);
+//        splay(next, r);
+//        rs[r] = i;
+//        fa[i] = r;
+//        rs[i] = next;
+//        fa[next] = i;
+//        up(i);
+//        up(r);
+//    }
+//}
+//
+//void move(int i, int from, int to) {
+//    disconnect(i, from);
+//    connect(i, to);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        int x;
+//        cin >> x;
+//        add(x);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        string op;
+//        int s, t, small;
+//        cin >> op >> s;
+//        small = ask(s);
+//        if (op == "Top") {
+//            move(pos[s], small + 1, 1);
+//        } else if (op == "Bottom") {
+//            move(pos[s], small + 1, n);
+//        } else if (op == "Insert") {
+//            cin >> t;
+//            move(pos[s], small + 1, ask(s) + t + 1);
+//        } else if (op == "Ask") {
+//            cout << small << endl;
+//        } else {
+//            cout << query(s) << endl;
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index 09931bdc4..6389d659d 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -109,7 +109,6 @@ public static void add(int num) {
 		} else {
 			int f = 0, i = head, son = 0;
 			while (i != 0) {
-				size[i]++;
 				f = i;
 				if (key[i] <= num) {
 					son = 1;
diff --git a/src/class153/FollowUp2.java b/src/class153/FollowUp2.java
index 6c3122cb2..bda072b72 100644
--- a/src/class153/FollowUp2.java
+++ b/src/class153/FollowUp2.java
@@ -101,7 +101,6 @@
 //    } else {
 //        int f = 0, i = head, son = 0;
 //        while (i != 0) {
-//            size[i]++;
 //            f = i;
 //            if (key[i] <= num) {
 //                son = 1;

From ae6c65fe335ef3a3004a17eb0d2b58211b1bb052 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 23:06:48 +0800
Subject: [PATCH 0161/1712] modify code

---
 src/class153/Code04_Bookcase1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index 2c9bf8485..5b8ba89e6 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -151,7 +151,7 @@ public static void disconnect(int i, int rank) {
 		father[i] = left[i] = right[i] = 0;
 	}
 
-	// 节点编号为i的节点已经分离出来了，插入回结构中，让其排名为rank
+	// 节点编号为i的节点已经分离出来了，加入回结构中，让其排名为rank
 	public static void connect(int i, int rank) {
 		if (rank == 1) {
 			right[i] = head;
@@ -178,6 +178,7 @@ public static void connect(int i, int rank) {
 	}
 
 	// 节点编号为i的节点，现在排名from，移动到排名to的位置
+	// 本题不需要做到这个功能，但这种扩展性可能是其他题目需要的
 	public static void move(int i, int from, int to) {
 		disconnect(i, from);
 		connect(i, to);

From 4855188ae7db516ee1019103da15a239039e22ac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Nov 2024 23:08:22 +0800
Subject: [PATCH 0162/1712] modify code

---
 src/class153/Code04_Bookcase1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index 5b8ba89e6..c18f3b7d2 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -178,7 +178,7 @@ public static void connect(int i, int rank) {
 	}
 
 	// 节点编号为i的节点，现在排名from，移动到排名to的位置
-	// 本题不需要做到这个功能，但这种扩展性可能是其他题目需要的
+	// 本题不需要做到这个程度，但这种扩展性可能是其他题目需要的
 	public static void move(int i, int from, int to) {
 		disconnect(i, from);
 		connect(i, to);

From 897fcc1b9629edf55f6bf810739f18acbcc23269 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 10:21:10 +0800
Subject: [PATCH 0163/1712] modify code

---
 src/class153/Code04_Bookcase1.java | 21 +++++++++++----------
 src/class153/Code04_Bookcase2.java | 13 +++++++------
 2 files changed, 18 insertions(+), 16 deletions(-)

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index c18f3b7d2..65505a0c5 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -90,7 +90,7 @@ public static void splay(int i, int goal) {
 		}
 	}
 
-	// 返回排名为rank的节点编号
+	// 返回中序排名为rank的节点编号
 	public static int find(int rank) {
 		int i = head, ans = 0;
 		while (i != 0) {
@@ -131,7 +131,7 @@ public static int query(int s) {
 		return num[find(s)];
 	}
 
-	// 节点编号为i的节点，已知排名是rank，结构上把该节点分离出来
+	// 节点编号为i的节点，已知中序排名是rank，结构上把该节点分离出来
 	public static void disconnect(int i, int rank) {
 		splay(i, 0);
 		if (rank == 1) {
@@ -151,7 +151,7 @@ public static void disconnect(int i, int rank) {
 		father[i] = left[i] = right[i] = 0;
 	}
 
-	// 节点编号为i的节点已经分离出来了，加入回结构中，让其排名为rank
+	// 节点编号为i的节点已经分离出来了，加入回结构中，让其中序排名为rank
 	public static void connect(int i, int rank) {
 		if (rank == 1) {
 			right[i] = head;
@@ -177,11 +177,12 @@ public static void connect(int i, int rank) {
 		}
 	}
 
-	// 节点编号为i的节点，现在排名from，移动到排名to的位置
+	// 中序排名为a的节点，移动到中序排名为b的位置
 	// 本题不需要做到这个程度，但这种扩展性可能是其他题目需要的
-	public static void move(int i, int from, int to) {
-		disconnect(i, from);
-		connect(i, to);
+	public static void move(int a, int b) {
+		int i = find(a);
+		disconnect(i, a);
+		connect(i, b);
 	}
 
 	public static void main(String[] args) {
@@ -197,12 +198,12 @@ public static void main(String[] args) {
 			s = io.nextInt();
 			small = ask(s);
 			if (op.equals("Top")) {
-				move(pos[s], small + 1, 1);
+				move(small + 1, 1);
 			} else if (op.equals("Bottom")) {
-				move(pos[s], small + 1, n);
+				move(small + 1, n);
 			} else if (op.equals("Insert")) {
 				t = io.nextInt();
-				move(pos[s], small + 1, ask(s) + t + 1);
+				move(small + 1, small + t + 1);
 			} else if (op.equals("Ask")) {
 				io.println(small);
 			} else {
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index 95402f143..fa85a1cd7 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -161,9 +161,10 @@
 //    }
 //}
 //
-//void move(int i, int from, int to) {
-//    disconnect(i, from);
-//    connect(i, to);
+//void move(int a, int b) {
+//    int i = find(a);
+//    disconnect(i, a);
+//    connect(i, b);
 //}
 //
 //int main() {
@@ -181,12 +182,12 @@
 //        cin >> op >> s;
 //        small = ask(s);
 //        if (op == "Top") {
-//            move(pos[s], small + 1, 1);
+//            move(small + 1, 1);
 //        } else if (op == "Bottom") {
-//            move(pos[s], small + 1, n);
+//            move(small + 1, n);
 //        } else if (op == "Insert") {
 //            cin >> t;
-//            move(pos[s], small + 1, ask(s) + t + 1);
+//            move(small + 1, small + t + 1);
 //        } else if (op == "Ask") {
 //            cout << small << endl;
 //        } else {

From 28eaa87c300a9806caa8eba144a8cf87002aa836 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 12:28:37 +0800
Subject: [PATCH 0164/1712] modify code

---
 src/class153/Code02_LiteraryTree1.java     | 14 ++--
 src/class153/Code02_LiteraryTree2.java     | 18 ++---
 src/class153/Code04_Bookcase1.java         | 87 ++++++++-------------
 src/class153/Code04_Bookcase2.java         | 90 ++++++++--------------
 src/class153/Code05_MaintainSequence1.java | 69 -----------------
 5 files changed, 76 insertions(+), 202 deletions(-)
 delete mode 100644 src/class153/Code05_MaintainSequence1.java

diff --git a/src/class153/Code02_LiteraryTree1.java b/src/class153/Code02_LiteraryTree1.java
index 5f992966b..511403a2c 100644
--- a/src/class153/Code02_LiteraryTree1.java
+++ b/src/class153/Code02_LiteraryTree1.java
@@ -23,7 +23,7 @@ public class Code02_LiteraryTree1 {
 
 	public static int cnt = 0;
 
-	public static int[] key = new int[MAXN];
+	public static int[] num = new int[MAXN];
 
 	public static int[] father = new int[MAXN];
 
@@ -124,12 +124,12 @@ public static int find(int i, int rank) {
 		return 0;
 	}
 
-	public static void add(int num) {
+	public static void add(int x) {
 		int i = head;
 		while (right[i] != 0) {
 			i = right[i];
 		}
-		key[++cnt] = num;
+		num[++cnt] = x;
 		size[cnt] = 1;
 		father[cnt] = i;
 		right[i] = cnt;
@@ -150,7 +150,7 @@ public static void inorder(int i) {
 		if (i != 0) {
 			down(i);
 			inorder(left[i]);
-			ans[++ai] = key[i];
+			ans[++ai] = num[i];
 			inorder(right[i]);
 		}
 	}
@@ -168,7 +168,7 @@ public static void inorder() {
 				i = left[i];
 			} else {
 				i = stack[si--];
-				ans[++ai] = key[i];
+				ans[++ai] = num[i];
 				i = right[i];
 			}
 		}
@@ -182,11 +182,11 @@ public static void main(String[] args) throws IOException {
 		int n = (int) in.nval;
 		in.nextToken();
 		int m = (int) in.nval;
-		add(Integer.MIN_VALUE);
+		add(0);
 		for (int i = 1; i <= n; i++) {
 			add(i);
 		}
-		add(Integer.MAX_VALUE);
+		add(0);
 		for (int i = 1, x, y; i <= m; i++) {
 			in.nextToken();
 			x = (int) in.nval;
diff --git a/src/class153/Code02_LiteraryTree2.java b/src/class153/Code02_LiteraryTree2.java
index 856d94966..3f236a181 100644
--- a/src/class153/Code02_LiteraryTree2.java
+++ b/src/class153/Code02_LiteraryTree2.java
@@ -10,16 +10,14 @@
 // 提交如下代码，可以通过所有测试用例
 
 //#include <iostream>
-//#include <vector>
-//#include <stack>
-//#include <climits>
+//
 //using namespace std;
 //
 //const int MAXN = 100005;
 //
 //int head = 0;
 //int cnt = 0;
-//int key[MAXN];
+//int num[MAXN];
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
@@ -111,12 +109,12 @@
 //    return 0;
 //}
 //
-//void add(int num) {
+//void add(int x) {
 //    int i = head;
 //    while (rs[i] != 0) {
 //        i = rs[i];
 //    }
-//    key[++cnt] = num;
+//    num[++cnt] = x;
 //    size[cnt] = 1;
 //    fa[cnt] = i;
 //    rs[i] = cnt;
@@ -135,7 +133,7 @@
 //    if (i != 0) {
 //        down(i);
 //        inorder(ls[i]);
-//        ans[++ai] = key[i];
+//        ans[++ai] = num[i];
 //        inorder(rs[i]);
 //    }
 //}
@@ -150,7 +148,7 @@
 //            i = ls[i];
 //        } else {
 //            i = sta[si--];
-//            ans[++ai] = key[i];
+//            ans[++ai] = num[i];
 //            i = rs[i];
 //        }
 //    }
@@ -161,11 +159,11 @@
 //    cin.tie(nullptr);
 //    int n, m;
 //    cin >> n >> m;
-//    add(INT_MIN);
+//    add(0);
 //    for (int i = 1; i <= n; i++) {
 //        add(i);
 //    }
-//    add(INT_MAX);
+//    add(0);
 //    for (int i = 1, x, y; i <= m; i++) {
 //        cin >> x >> y;
 //        reverse(x + 1, y + 1);
diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index 65505a0c5..e8cc8c205 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -15,7 +15,7 @@
 
 public class Code04_Bookcase1 {
 
-	public static int MAXN = 80001;
+	public static int MAXN = 80005;
 
 	public static int head = 0;
 
@@ -131,83 +131,56 @@ public static int query(int s) {
 		return num[find(s)];
 	}
 
-	// 节点编号为i的节点，已知中序排名是rank，结构上把该节点分离出来
-	public static void disconnect(int i, int rank) {
-		splay(i, 0);
-		if (rank == 1) {
-			head = right[head];
-			father[head] = 0;
-		} else if (rank == n) {
-			head = left[head];
-			father[head] = 0;
-		} else {
-			int l = find(rank - 1);
-			splay(l, 0);
-			splay(i, l);
-			right[l] = right[i];
-			father[right[l]] = l;
-			up(l);
-		}
-		father[i] = left[i] = right[i] = 0;
-	}
-
-	// 节点编号为i的节点已经分离出来了，加入回结构中，让其中序排名为rank
-	public static void connect(int i, int rank) {
-		if (rank == 1) {
-			right[i] = head;
-			father[right[i]] = i;
-			head = i;
-			up(i);
-		} else if (rank == n) {
-			left[i] = head;
-			father[left[i]] = i;
-			head = i;
-			up(i);
-		} else {
-			int r = find(rank - 1);
-			int next = find(rank);
-			splay(r, 0);
-			splay(next, r);
-			right[r] = i;
-			father[i] = r;
-			right[i] = next;
-			father[next] = i;
-			up(i);
-			up(r);
-		}
-	}
-
 	// 中序排名为a的节点，移动到中序排名为b的位置
-	// 本题不需要做到这个程度，但这种扩展性可能是其他题目需要的
+	// 注意a不会是1和n位置，b也如此
+	// 因为1位置和n位置提前加入了预备值
 	public static void move(int a, int b) {
 		int i = find(a);
-		disconnect(i, a);
-		connect(i, b);
+		int l = find(a - 1);
+		splay(l, 0);
+		splay(i, l);
+		right[l] = right[i];
+		father[right[l]] = l;
+		up(l);
+		left[i] = right[i] = 0;
+		int r = find(b - 1);
+		int next = find(b);
+		splay(r, 0);
+		splay(next, r);
+		right[r] = i;
+		father[i] = r;
+		right[i] = next;
+		father[next] = i;
+		up(i);
+		up(r);
 	}
 
 	public static void main(String[] args) {
 		Kattio io = new Kattio();
 		n = io.nextInt();
 		m = io.nextInt();
+		add(0);
 		for (int i = 1; i <= n; i++) {
 			add(io.nextInt());
 		}
+		add(n + 1);
+		n = n + 2;
 		String op;
-		for (int i = 1, s, t, small; i <= m; i++) {
+		for (int i = 1, s, t, rank; i <= m; i++) {
 			op = io.next();
 			s = io.nextInt();
-			small = ask(s);
+			rank = ask(s) + 1;
 			if (op.equals("Top")) {
-				move(small + 1, 1);
+				move(rank, 2);
 			} else if (op.equals("Bottom")) {
-				move(small + 1, n);
+				move(rank, n - 1);
 			} else if (op.equals("Insert")) {
 				t = io.nextInt();
-				move(small + 1, small + t + 1);
+				move(rank, rank + t);
 			} else if (op.equals("Ask")) {
-				io.println(small);
+				io.println(rank - 2);
 			} else {
-				io.println(query(s));
+				io.println(query(s + 1));
 			}
 		}
 		io.flush();
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index fa85a1cd7..89149b525 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -6,11 +6,11 @@
 // 提交如下代码，可以通过所有测试用例
 
 //#include <iostream>
-//#include <cstdio>
 //#include <string>
+//
 //using namespace std;
 //
-//const int MAXN = 80001;
+//const int MAXN = 80005;
 //
 //int head = 0;
 //int cnt = 0;
@@ -20,7 +20,6 @@
 //int ls[MAXN];
 //int rs[MAXN];
 //int size[MAXN];
-//int n, m;
 //
 //void up(int i) {
 //    size[i] = size[ls[i]] + size[rs[i]] + 1;
@@ -117,81 +116,54 @@
 //    return num[find(s)];
 //}
 //
-//void disconnect(int i, int rank) {
-//    splay(i, 0);
-//    if (rank == 1) {
-//        head = rs[head];
-//        fa[head] = 0;
-//    } else if (rank == n) {
-//        head = ls[head];
-//        fa[head] = 0;
-//    } else {
-//        int l = find(rank - 1);
-//        splay(l, 0);
-//        splay(i, l);
-//        rs[l] = rs[i];
-//        fa[rs[l]] = l;
-//        up(l);
-//    }
-//    fa[i] = ls[i] = rs[i] = 0;
-//}
-//
-//void connect(int i, int rank) {
-//    if (rank == 1) {
-//        rs[i] = head;
-//        fa[rs[i]] = i;
-//        head = i;
-//        up(i);
-//    } else if (rank == n) {
-//        ls[i] = head;
-//        fa[ls[i]] = i;
-//        head = i;
-//        up(i);
-//    } else {
-//        int r = find(rank - 1);
-//        int next = find(rank);
-//        splay(r, 0);
-//        splay(next, r);
-//        rs[r] = i;
-//        fa[i] = r;
-//        rs[i] = next;
-//        fa[next] = i;
-//        up(i);
-//        up(r);
-//    }
-//}
-//
 //void move(int a, int b) {
 //    int i = find(a);
-//    disconnect(i, a);
-//    connect(i, b);
+//    int l = find(a - 1);
+//    splay(l, 0);
+//    splay(i, l);
+//    rs[l] = rs[i];
+//    fa[rs[l]] = l;
+//    up(l);
+//    ls[i] = rs[i] = 0;
+//    int r = find(b - 1);
+//    int next = find(b);
+//    splay(r, 0);
+//    splay(next, r);
+//    rs[r] = i;
+//    fa[i] = r;
+//    rs[i] = next;
+//    fa[next] = i;
+//    up(i);
+//    up(r);
 //}
 //
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
+//    int n, m;
 //    cin >> n >> m;
-//    for (int i = 1; i <= n; i++) {
-//        int x;
+//    add(0);
+//    for (int i = 1, x; i <= n; i++) {
 //        cin >> x;
 //        add(x);
 //    }
-//    for (int i = 1; i <= m; i++) {
+//    add(n + 1);
+//    n = n + 2;
+//    for (int i = 1, s, t, rank; i <= m; i++) {
 //        string op;
-//        int s, t, small;
 //        cin >> op >> s;
-//        small = ask(s);
+//        rank = ask(s) + 1;
 //        if (op == "Top") {
-//            move(small + 1, 1);
+//            move(rank, 2);
 //        } else if (op == "Bottom") {
-//            move(small + 1, n);
+//            move(rank, n - 1);
 //        } else if (op == "Insert") {
 //            cin >> t;
-//            move(small + 1, small + t + 1);
+//            move(rank, rank + t);
 //        } else if (op == "Ask") {
-//            cout << small << endl;
+//            cout << rank - 2 << endl;
 //        } else {
-//            cout << query(s) << endl;
+//            cout << query(s + 1) << endl;
 //        }
 //    }
 //    return 0;
diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
deleted file mode 100644
index 83e9bccf7..000000000
--- a/src/class153/Code05_MaintainSequence1.java
+++ /dev/null
@@ -1,69 +0,0 @@
-package class153;
-
-// 维护数列(java版)
-// 测试链接 : https://www.luogu.com.cn/problem/P2042
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-import java.io.BufferedReader;
-import java.io.FileReader;
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.InputStreamReader;
-import java.io.OutputStream;
-import java.io.PrintWriter;
-import java.util.StringTokenizer;
-
-public class Code05_MaintainSequence1 {
-
-	public static void main(String[] args) {
-		Kattio io = new Kattio();
-
-		io.flush();
-		io.close();
-	}
-
-	// Kattio类IO效率很好，但还是不如StreamTokenizer
-	// 只有StreamTokenizer无法正确处理时，才考虑使用这个类
-	// 参考链接 : https://oi-wiki.org/lang/java-pro/
-	public static class Kattio extends PrintWriter {
-		private BufferedReader r;
-		private StringTokenizer st;
-
-		public Kattio() {
-			this(System.in, System.out);
-		}
-
-		public Kattio(InputStream i, OutputStream o) {
-			super(o);
-			r = new BufferedReader(new InputStreamReader(i));
-		}
-
-		public Kattio(String intput, String output) throws IOException {
-			super(output);
-			r = new BufferedReader(new FileReader(intput));
-		}
-
-		public String next() {
-			try {
-				while (st == null || !st.hasMoreTokens())
-					st = new StringTokenizer(r.readLine());
-				return st.nextToken();
-			} catch (Exception e) {
-			}
-			return null;
-		}
-
-		public int nextInt() {
-			return Integer.parseInt(next());
-		}
-
-		public double nextDouble() {
-			return Double.parseDouble(next());
-		}
-
-		public long nextLong() {
-			return Long.parseLong(next());
-		}
-	}
-
-}

From 70b5398e49a9c9998c2f22a5a763216305645a68 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 12:32:38 +0800
Subject: [PATCH 0165/1712] modify code

---
 src/class153/Code02_LiteraryTree1.java | 2 ++
 src/class153/Code04_Bookcase1.java     | 2 +-
 2 files changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/class153/Code02_LiteraryTree1.java b/src/class153/Code02_LiteraryTree1.java
index 511403a2c..3c0b37650 100644
--- a/src/class153/Code02_LiteraryTree1.java
+++ b/src/class153/Code02_LiteraryTree1.java
@@ -136,6 +136,8 @@ public static void add(int x) {
 		splay(cnt, 0);
 	}
 
+	// 注意l永远不会是最左位置，r永远不会是最右位置
+	// 因为最左和最右位置提前加入了预备值，永远不会修改
 	public static void reverse(int l, int r) {
 		int i = find(head, l - 1);
 		int j = find(head, r + 1);
diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index e8cc8c205..926f61607 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -133,7 +133,7 @@ public static int query(int s) {
 
 	// 中序排名为a的节点，移动到中序排名为b的位置
 	// 注意a不会是1和n位置，b也如此
-	// 因为1位置和n位置提前加入了预备值
+	// 因为1位置和n位置提前加入了预备值，永远不会修改
 	public static void move(int a, int b) {
 		int i = find(a);
 		int l = find(a - 1);

From 27cda55ee7cdaf2f12cc491492ba902122496fea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 19:27:11 +0800
Subject: [PATCH 0166/1712] modify code

---
 src/class153/Code04_Bookcase1.java         |  19 +-
 src/class153/Code04_Bookcase2.java         |  12 +-
 src/class153/Code05_MaintainSequence1.java | 545 +++++++++++++++++++++
 src/class153/Code05_MaintainSequence2.java | 268 ++++++++++
 4 files changed, 832 insertions(+), 12 deletions(-)
 create mode 100644 src/class153/Code05_MaintainSequence1.java
 create mode 100644 src/class153/Code05_MaintainSequence2.java

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index 926f61607..5c14f6613 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -92,11 +92,10 @@ public static void splay(int i, int goal) {
 
 	// 返回中序排名为rank的节点编号
 	public static int find(int rank) {
-		int i = head, ans = 0;
+		int i = head;
 		while (i != 0) {
 			if (size[left[i]] + 1 == rank) {
-				ans = i;
-				break;
+				return i;
 			} else if (size[left[i]] >= rank) {
 				i = left[i];
 			} else {
@@ -104,8 +103,7 @@ public static int find(int rank) {
 				i = right[i];
 			}
 		}
-		splay(ans, 0);
-		return ans;
+		return 0;
 	}
 
 	public static void add(int s) {
@@ -128,7 +126,9 @@ public static int ask(int s) {
 	}
 
 	public static int query(int s) {
-		return num[find(s)];
+		int i = find(s);
+		splay(i, 0);
+		return num[i];
 	}
 
 	// 中序排名为a的节点，移动到中序排名为b的位置
@@ -164,6 +164,8 @@ public static void main(String[] args) {
 			add(io.nextInt());
 		}
 		add(n + 1);
+		// 注意在最左插入了0，最右插入了n+1，作为准备值，所以一共n+2个数
+		// 下面操作时，不要忘了最左是0，最右是n+1，并且永远不修改
 		n = n + 2;
 		String op;
 		for (int i = 1, s, t, rank; i <= m; i++) {
@@ -171,15 +173,20 @@ public static void main(String[] args) {
 			s = io.nextInt();
 			rank = ask(s) + 1;
 			if (op.equals("Top")) {
+				// 因为有最左侧的准备值，所以开头是中序排名2的位置
 				move(rank, 2);
 			} else if (op.equals("Bottom")) {
+				// 因为有最右侧的准备值，所以结尾是中序排名n-1的位置
 				move(rank, n - 1);
 			} else if (op.equals("Insert")) {
 				t = io.nextInt();
 				move(rank, rank + t);
 			} else if (op.equals("Ask")) {
+				// rank代表当前数字的排名，因为有最左侧的准备值
+				// 所以排名其实是rank-1，题目要返回小于的数量，所以是rank - 2
 				io.println(rank - 2);
 			} else {
+				// 因为有最左侧的准备值，所以查s+1名的数字
 				io.println(query(s + 1));
 			}
 		}
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index 89149b525..23072d50e 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -77,11 +77,10 @@
 //}
 //
 //int find(int rank) {
-//    int i = head, ans = 0;
+//    int i = head;
 //    while (i != 0) {
 //        if (size[ls[i]] + 1 == rank) {
-//            ans = i;
-//            break;
+//            return i;
 //        } else if (size[ls[i]] >= rank) {
 //            i = ls[i];
 //        } else {
@@ -89,8 +88,7 @@
 //            i = rs[i];
 //        }
 //    }
-//    splay(ans, 0);
-//    return ans;
+//    return 0;
 //}
 //
 //void add(int s) {
@@ -113,7 +111,9 @@
 //}
 //
 //int query(int s) {
-//    return num[find(s)];
+//    int i = find(s);
+//    splay(i, 0);
+//    return num[i];
 //}
 //
 //void move(int a, int b) {
diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
new file mode 100644
index 000000000..96f08251c
--- /dev/null
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -0,0 +1,545 @@
+package class153;
+
+// 维护数列(java版)
+// 测试链接 : https://www.luogu.com.cn/problem/P2042
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.InputMismatchException;
+
+public class Code05_MaintainSequence1 {
+
+	public static int MAXN = 500005;
+
+	public static int INF = 1000000001;
+
+	public static int head = 0;
+
+	public static int[] space = new int[MAXN];
+
+	public static int si;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] num = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] sum = new int[MAXN];
+
+	// 整体子数组最大累加和，不能空
+	public static int[] all = new int[MAXN];
+
+	// 前缀子数组最大累加和，可以空
+	public static int[] pre = new int[MAXN];
+
+	// 后缀子数组最大累加和，可以空
+	public static int[] suf = new int[MAXN];
+
+	public static boolean[] update = new boolean[MAXN];
+
+	public static int[] change = new int[MAXN];
+
+	public static boolean[] reverse = new boolean[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+		sum[i] = sum[left[i]] + sum[right[i]] + num[i];
+		all[i] = Math.max(Math.max(all[left[i]], all[right[i]]), suf[left[i]] + num[i] + pre[right[i]]);
+		pre[i] = Math.max(pre[left[i]], sum[left[i]] + num[i] + pre[right[i]]);
+		suf[i] = Math.max(suf[right[i]], suf[left[i]] + num[i] + sum[right[i]]);
+	}
+
+	public static int lr(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void upRotate(int i) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		if (g != 0) {
+			if (sonf == 1) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		father[f] = i;
+		father[i] = g;
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (lr(i) == lr(f)) {
+					upRotate(f);
+				} else {
+					upRotate(i);
+				}
+			}
+			upRotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	public static void setValue(int i, int val) {
+		if (i != 0) {
+			update[i] = true;
+			change[i] = val;
+			num[i] = val;
+			sum[i] = size[i] * val;
+			all[i] = Math.max(sum[i], val);
+			pre[i] = Math.max(sum[i], 0);
+			suf[i] = Math.max(sum[i], 0);
+		}
+	}
+
+	public static void setReverse(int i) {
+		if (i != 0) {
+			int tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+			tmp = pre[i];
+			pre[i] = suf[i];
+			suf[i] = tmp;
+			reverse[i] = !reverse[i];
+		}
+	}
+
+	public static void down(int i) {
+		if (update[i]) {
+			setValue(left[i], change[i]);
+			setValue(right[i], change[i]);
+			update[i] = false;
+		}
+		if (reverse[i]) {
+			setReverse(left[i]);
+			setReverse(right[i]);
+			reverse[i] = false;
+		}
+	}
+
+	public static int init(int val) {
+		int i = space[si--];
+		size[i] = 1;
+		num[i] = sum[i] = all[i] = val;
+		pre[i] = suf[i] = Math.max(val, 0);
+		father[i] = left[i] = right[i] = 0;
+		update[i] = reverse[i] = false;
+		return i;
+	}
+
+	public static int build(int l, int r) {
+		int mid = (l + r) / 2;
+		int root = init(arr[mid]);
+		if (l < mid) {
+			left[root] = build(l, mid - 1);
+			father[left[root]] = root;
+		}
+		if (mid < r) {
+			right[root] = build(mid + 1, r);
+			father[right[root]] = root;
+		}
+		up(root);
+		return root;
+	}
+
+	public static int find(int rank) {
+		int i = head;
+		while (i != 0) {
+			down(i);
+			if (size[left[i]] + 1 == rank) {
+				return i;
+			} else if (size[left[i]] >= rank) {
+				i = left[i];
+			} else {
+				rank -= size[left[i]] + 1;
+				i = right[i];
+			}
+		}
+		return 0;
+	}
+
+	public static void insert(int rank, int n) {
+		if (rank == 0) {
+			head = build(1, n);
+		} else {
+			int l = find(rank);
+			int r = find(rank + 1);
+			splay(l, 0);
+			splay(r, l);
+			left[r] = build(1, n);
+			father[left[r]] = r;
+			up(r);
+			up(l);
+		}
+	}
+
+	public static void recycle(int i) {
+		if (i != 0) {
+			space[++si] = i;
+			recycle(left[i]);
+			recycle(right[i]);
+		}
+	}
+
+	public static void delete(int rank, int n) {
+		int l = find(rank - 1);
+		int r = find(rank + n);
+		splay(l, 0);
+		splay(r, l);
+		recycle(left[r]);
+		left[r] = 0;
+		up(r);
+		up(l);
+	}
+
+	public static void update(int rank, int n, int val) {
+		int l = find(rank - 1);
+		int r = find(rank + n);
+		splay(l, 0);
+		splay(r, l);
+		setValue(left[r], val);
+		up(r);
+		up(l);
+	}
+
+	public static void reverse(int rank, int n) {
+		int l = find(rank - 1);
+		int r = find(rank + n);
+		splay(l, 0);
+		splay(r, l);
+		setReverse(left[r]);
+		up(r);
+		up(l);
+	}
+
+	public static int querySum(int rank, int n) {
+		int l = find(rank - 1);
+		int r = find(rank + n);
+		splay(l, 0);
+		splay(r, l);
+		return sum[left[r]];
+	}
+
+	public static int queryMax() {
+		return all[head];
+	}
+
+	public static void main(String[] args) {
+		FastReader in = new FastReader(System.in);
+		FastWriter out = new FastWriter(System.out);
+		int n = in.readInt();
+		int m = in.readInt();
+		// 所有可用空间编号，进入space数组
+		si = MAXN - 1;
+		for (int i = 1; i <= si; i++) {
+			space[i] = i;
+		}
+		// 这里很重要，一方面准备好最左和最右的准备值
+		// 另一方面设置all[0] = 极小值
+		// 表示没有范围时，子数组最大累加和为极小值，因为不能为空
+		arr[1] = arr[n + 2] = all[0] = -INF;
+		for (int i = 1, j = 2; i <= n; i++, j++) {
+			arr[j] = in.readInt();
+		}
+		// 建立初始树
+		insert(0, n + 2);
+		String op;
+		for (int i = 1, posi, tot, c; i <= m; i++) {
+			op = in.readWord();
+			if (op.equals("MAX-SUM")) {
+				out.println(queryMax());
+			} else {
+				// 因为有最左的准备值，所以位置要右移一位
+				posi = in.readInt() + 1;
+				tot = in.readInt();
+				if (op.equals("INSERT")) {
+					for (int j = 1; j <= tot; j++) {
+						arr[j] = in.readInt();
+					}
+					insert(posi, tot);
+				} else if (op.equals("DELETE")) {
+					delete(posi, tot);
+				} else if (op.equals("MAKE-SAME")) {
+					c = in.readInt();
+					update(posi, tot, c);
+				} else if (op.equals("REVERSE")) {
+					reverse(posi, tot);
+				} else {
+					out.println(querySum(posi, tot));
+				}
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 快读
+	public static class FastReader {
+		InputStream is;
+		private byte[] inbuf = new byte[1024];
+		public int lenbuf = 0;
+		public int ptrbuf = 0;
+
+		public FastReader(final InputStream is) {
+			this.is = is;
+		}
+
+		public String readWord() {
+			char cur;
+			do {
+				cur = (char) readByte();
+			} while (cur == ' ' || cur == '\n');
+			StringBuilder builder = new StringBuilder();
+			while (cur != ' ' && cur != '\n') {
+				builder.append(cur);
+				cur = (char) readByte();
+			}
+			return builder.toString();
+		}
+
+		public int readByte() {
+			if (lenbuf == -1) {
+				throw new InputMismatchException();
+			}
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++];
+		}
+
+		public int readInt() {
+			return (int) readLong();
+		}
+
+		public long readLong() {
+			long num = 0;
+			int b;
+			boolean minus = false;
+			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+				;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+
+			while (true) {
+				if (b >= '0' && b <= '9') {
+					num = num * 10 + (b - '0');
+				} else {
+					return minus ? -num : num;
+				}
+				b = readByte();
+			}
+		}
+	}
+
+	// 快写
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private OutputStream out;
+		private Writer writer;
+		private int ptr = 0;
+
+		public FastWriter(Writer writer) {
+			this.writer = new BufferedWriter(writer);
+			out = new ByteArrayOutputStream();
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("FastWriter");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE) {
+				innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE) {
+					innerflush();
+				}
+			});
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L) {
+				return 19;
+			}
+			if (l >= 100000000000000000L) {
+				return 18;
+			}
+			if (l >= 10000000000000000L) {
+				return 17;
+			}
+			if (l >= 1000000000000000L) {
+				return 16;
+			}
+			if (l >= 100000000000000L) {
+				return 15;
+			}
+			if (l >= 10000000000000L) {
+				return 14;
+			}
+			if (l >= 1000000000000L) {
+				return 13;
+			}
+			if (l >= 100000000000L) {
+				return 12;
+			}
+			if (l >= 10000000000L) {
+				return 11;
+			}
+			if (l >= 1000000000L) {
+				return 10;
+			}
+			if (l >= 100000000L) {
+				return 9;
+			}
+			if (l >= 10000000L) {
+				return 8;
+			}
+			if (l >= 1000000L) {
+				return 7;
+			}
+			if (l >= 100000L) {
+				return 6;
+			}
+			if (l >= 10000L) {
+				return 5;
+			}
+			if (l >= 1000L) {
+				return 4;
+			}
+			if (l >= 100L) {
+				return 3;
+			}
+			if (l >= 10L) {
+				return 2;
+			}
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE) {
+				innerflush();
+			}
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException("innerflush");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				if (writer != null) {
+					writer.write(((ByteArrayOutputStream) out).toString());
+					out = new ByteArrayOutputStream();
+					writer.flush();
+				} else {
+					out.flush();
+				}
+			} catch (IOException e) {
+				throw new RuntimeException("flush");
+			}
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public void close() {
+			flush();
+			try {
+				out.close();
+			} catch (Exception e) {
+			}
+		}
+
+	}
+
+}
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
new file mode 100644
index 000000000..5f89ddc82
--- /dev/null
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -0,0 +1,268 @@
+package class153;
+
+// 维护数列(C++版)
+// 测试链接 : https://www.luogu.com.cn/problem/P2042
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//using namespace std;
+//
+//const int MAXN = 500005;
+//const int INF = 1000000001;
+//
+//int head = 0;
+//int space[MAXN], si;
+//int arr[MAXN];
+//int num[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int size[MAXN];
+//int sum[MAXN];
+//int all[MAXN];
+//int pre[MAXN];
+//int suf[MAXN];
+//bool update[MAXN];
+//int change[MAXN];
+//bool rev[MAXN];
+//
+//void up(int i) {
+//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    sum[i] = sum[ls[i]] + sum[rs[i]] + num[i];
+//    all[i] = max({all[ls[i]], all[rs[i]], suf[ls[i]] + num[i] + pre[rs[i]]});
+//    pre[i] = max(pre[ls[i]], sum[ls[i]] + num[i] + pre[rs[i]]);
+//    suf[i] = max(suf[rs[i]], suf[ls[i]] + num[i] + sum[rs[i]]);
+//}
+//
+//int lr(int i) {
+//    return rs[fa[i]] == i ? 1 : 0;
+//}
+//
+//void upRotate(int i) {
+//    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
+//    if (soni == 1) {
+//        rs[f] = ls[i];
+//        if (rs[f] != 0) {
+//            fa[rs[f]] = f;
+//        }
+//        ls[i] = f;
+//    } else {
+//        ls[f] = rs[i];
+//        if (ls[f] != 0) {
+//            fa[ls[f]] = f;
+//        }
+//        rs[i] = f;
+//    }
+//    if (g != 0) {
+//        if (sonf == 1) {
+//            rs[g] = i;
+//        } else {
+//            ls[g] = i;
+//        }
+//    }
+//    fa[f] = i;
+//    fa[i] = g;
+//    up(f);
+//    up(i);
+//}
+//
+//void splay(int i, int goal) {
+//    while (fa[i] != goal) {
+//        int f = fa[i], g = fa[f];
+//        if (g != goal) {
+//            if (lr(i) == lr(f)) {
+//                upRotate(f);
+//            } else {
+//                upRotate(i);
+//            }
+//        }
+//        upRotate(i);
+//    }
+//    if (goal == 0) {
+//        head = i;
+//    }
+//}
+//
+//void setValue(int i, int val) {
+//    if (i != 0) {
+//        update[i] = true;
+//        change[i] = val;
+//        num[i] = val;
+//        sum[i] = size[i] * val;
+//        all[i] = max(sum[i], val);
+//        pre[i] = max(sum[i], 0);
+//        suf[i] = max(sum[i], 0);
+//    }
+//}
+//
+//void setReverse(int i) {
+//    if (i != 0) {
+//        swap(ls[i], rs[i]);
+//        swap(pre[i], suf[i]);
+//        rev[i] ^= 1;
+//    }
+//}
+//
+//void down(int i) {
+//    if (update[i]) {
+//        setValue(ls[i], change[i]);
+//        setValue(rs[i], change[i]);
+//        update[i] = false;
+//    }
+//    if (rev[i]) {
+//        setReverse(ls[i]);
+//        setReverse(rs[i]);
+//        rev[i] = false;
+//    }
+//}
+//
+//int init(int val) {
+//    int i = space[si--];
+//    size[i] = 1;
+//    num[i] = sum[i] = all[i] = val;
+//    pre[i] = suf[i] = max(val, 0);
+//    fa[i] = ls[i] = rs[i] = 0;
+//    update[i] = rev[i] = false;
+//    return i;
+//}
+//
+//int build(int l, int r) {
+//    int mid = (l + r) / 2;
+//    int root = init(arr[mid]);
+//    if (l < mid) {
+//        ls[root] = build(l, mid - 1);
+//        fa[ls[root]] = root;
+//    }
+//    if (mid < r) {
+//        rs[root] = build(mid + 1, r);
+//        fa[rs[root]] = root;
+//    }
+//    up(root);
+//    return root;
+//}
+//
+//int find(int rank) {
+//    int i = head;
+//    while (i != 0) {
+//        down(i);
+//        if (size[ls[i]] + 1 == rank) {
+//            return i;
+//        } else if (size[ls[i]] >= rank) {
+//            i = ls[i];
+//        } else {
+//            rank -= size[ls[i]] + 1;
+//            i = rs[i];
+//        }
+//    }
+//    return 0;
+//}
+//
+//void insert(int rank, int n) {
+//    if (rank == 0) {
+//        head = build(1, n);
+//    } else {
+//        int l = find(rank);
+//        int r = find(rank + 1);
+//        splay(l, 0);
+//        splay(r, l);
+//        ls[r] = build(1, n);
+//        fa[ls[r]] = r;
+//        up(r);
+//        up(l);
+//    }
+//}
+//
+//void recycle(int i) {
+//    if (i != 0) {
+//        space[++si] = i;
+//        recycle(ls[i]);
+//        recycle(rs[i]);
+//    }
+//}
+//
+//void remove(int rank, int n) {
+//    int l = find(rank - 1);
+//    int r = find(rank + n);
+//    splay(l, 0);
+//    splay(r, l);
+//    recycle(ls[r]);
+//    ls[r] = 0;
+//    up(r);
+//    up(l);
+//}
+//
+//void updateValue(int rank, int n, int val) {
+//    int l = find(rank - 1);
+//    int r = find(rank + n);
+//    splay(l, 0);
+//    splay(r, l);
+//    setValue(ls[r], val);
+//    up(r);
+//    up(l);
+//}
+//
+//void reverseRange(int rank, int n) {
+//    int l = find(rank - 1);
+//    int r = find(rank + n);
+//    splay(l, 0);
+//    splay(r, l);
+//    setReverse(ls[r]);
+//    up(r);
+//    up(l);
+//}
+//
+//int querySum(int rank, int n) {
+//    int l = find(rank - 1);
+//    int r = find(rank + n);
+//    splay(l, 0);
+//    splay(r, l);
+//    return sum[ls[r]];
+//}
+//
+//int queryMax() {
+//    return all[head];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n, m;
+//    cin >> n >> m;
+//    si = MAXN - 1;
+//    for (int i = 1; i <= si; i++) {
+//        space[i] = i;
+//    }
+//    arr[1] = arr[n + 2] = all[0] = -INF;
+//    for (int i = 1, j = 2; i <= n; i++, j++) {
+//        cin >> arr[j];
+//    }
+//    insert(0, n + 2);
+//    string op;
+//    for (int i = 0; i < m; i++) {
+//        cin >> op;
+//        if (op == "MAX-SUM") {
+//            cout << queryMax() << endl;
+//        } else {
+//            int pos, len, c;
+//            cin >> pos >> len;
+//            pos++;
+//            if (op == "INSERT") {
+//                for (int j = 1; j <= len; j++) {
+//                    cin >> arr[j];
+//                }
+//                insert(pos, len);
+//            } else if (op == "DELETE") {
+//                remove(pos, len);
+//            } else if (op == "MAKE-SAME") {
+//                cin >> c;
+//                updateValue(pos, len, c);
+//            } else if (op == "REVERSE") {
+//                reverseRange(pos, len);
+//            } else if (op == "GET-SUM") {
+//                cout << querySum(pos, len) << endl;
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 4c241311070300f6916f439887dfe829802b835e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 20:15:37 +0800
Subject: [PATCH 0167/1712] modify code

---
 src/class153/Code05_MaintainSequence1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index 96f08251c..6f761de84 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -279,7 +279,7 @@ public static void main(String[] args) {
 		insert(0, n + 2);
 		String op;
 		for (int i = 1, posi, tot, c; i <= m; i++) {
-			op = in.readWord();
+			op = in.readString();
 			if (op.equals("MAX-SUM")) {
 				out.println(queryMax());
 			} else {
@@ -318,7 +318,7 @@ public FastReader(final InputStream is) {
 			this.is = is;
 		}
 
-		public String readWord() {
+		public String readString() {
 			char cur;
 			do {
 				cur = (char) readByte();

From b3fd99cc7d5783ca609696858d23ee7659eda4fd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 21:38:27 +0800
Subject: [PATCH 0168/1712] modify code

---
 src/class153/Code01_Splay1.java             |  8 ++++----
 src/class153/Code01_Splay2.java             |  8 ++++----
 src/class153/Code02_LiteraryTree1.java      |  8 ++++----
 src/class153/Code02_LiteraryTree2.java      |  8 ++++----
 src/class153/Code03_FrustratedCashier1.java |  8 ++++----
 src/class153/Code03_FrustratedCashier2.java |  8 ++++----
 src/class153/Code04_Bookcase1.java          |  8 ++++----
 src/class153/Code04_Bookcase2.java          |  8 ++++----
 src/class153/Code05_MaintainSequence1.java  | 14 +++++++-------
 src/class153/Code05_MaintainSequence2.java  | 16 ++++++++--------
 src/class153/FollowUp1.java                 |  8 ++++----
 src/class153/FollowUp2.java                 |  8 ++++----
 12 files changed, 55 insertions(+), 55 deletions(-)

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index cbf372795..d424174eb 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -46,7 +46,7 @@ public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
-	public static void upRotate(int i) {
+	public static void rotate(int i) {
 		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
 		if (soni == 1) {
 			right[f] = left[i];
@@ -79,12 +79,12 @@ public static void splay(int i, int goal) {
 		while (f != goal) {
 			if (g != goal) {
 				if (lr(i) == lr(f)) {
-					upRotate(f);
+					rotate(f);
 				} else {
-					upRotate(i);
+					rotate(i);
 				}
 			}
-			upRotate(i);
+			rotate(i);
 			f = father[i];
 			g = father[f];
 		}
diff --git a/src/class153/Code01_Splay2.java b/src/class153/Code01_Splay2.java
index 6d2630084..5bbfb69b8 100644
--- a/src/class153/Code01_Splay2.java
+++ b/src/class153/Code01_Splay2.java
@@ -39,7 +39,7 @@
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
-//void upRotate(int i) {
+//void rotate(int i) {
 //    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
 //    if (soni == 1) {
 //        rs[f] = ls[i];
@@ -72,12 +72,12 @@
 //    while (f != goal) {
 //        if (g != goal) {
 //            if (lr(i) == lr(f)) {
-//                upRotate(f);
+//                rotate(f);
 //            } else {
-//                upRotate(i);
+//                rotate(i);
 //            }
 //        }
-//        upRotate(i);
+//        rotate(i);
 //        f = fa[i];
 //        g = fa[f];
 //    }
diff --git a/src/class153/Code02_LiteraryTree1.java b/src/class153/Code02_LiteraryTree1.java
index 3c0b37650..9542498c3 100644
--- a/src/class153/Code02_LiteraryTree1.java
+++ b/src/class153/Code02_LiteraryTree1.java
@@ -51,7 +51,7 @@ public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
-	public static void upRotate(int i) {
+	public static void rotate(int i) {
 		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
 		if (soni == 1) {
 			right[f] = left[i];
@@ -84,12 +84,12 @@ public static void splay(int i, int goal) {
 		while (f != goal) {
 			if (g != goal) {
 				if (lr(i) == lr(f)) {
-					upRotate(f);
+					rotate(f);
 				} else {
-					upRotate(i);
+					rotate(i);
 				}
 			}
-			upRotate(i);
+			rotate(i);
 			f = father[i];
 			g = father[f];
 		}
diff --git a/src/class153/Code02_LiteraryTree2.java b/src/class153/Code02_LiteraryTree2.java
index 3f236a181..60d243d20 100644
--- a/src/class153/Code02_LiteraryTree2.java
+++ b/src/class153/Code02_LiteraryTree2.java
@@ -36,7 +36,7 @@
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
-//void upRotate(int i) {
+//void rotate(int i) {
 //    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
 //    if (soni == 1) {
 //        rs[f] = ls[i];
@@ -69,12 +69,12 @@
 //    while (f != goal) {
 //        if (g != goal) {
 //            if (lr(i) == lr(f)) {
-//                upRotate(f);
+//                rotate(f);
 //            } else {
-//                upRotate(i);
+//                rotate(i);
 //            }
 //        }
-//        upRotate(i);
+//        rotate(i);
 //        f = fa[i];
 //        g = fa[f];
 //    }
diff --git a/src/class153/Code03_FrustratedCashier1.java b/src/class153/Code03_FrustratedCashier1.java
index 01c353724..3cf96ba4e 100644
--- a/src/class153/Code03_FrustratedCashier1.java
+++ b/src/class153/Code03_FrustratedCashier1.java
@@ -45,7 +45,7 @@ public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
-	public static void upRotate(int i) {
+	public static void rotate(int i) {
 		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
 		if (soni == 1) {
 			right[f] = left[i];
@@ -78,12 +78,12 @@ public static void splay(int i, int goal) {
 		while (f != goal) {
 			if (g != goal) {
 				if (lr(i) == lr(f)) {
-					upRotate(f);
+					rotate(f);
 				} else {
-					upRotate(i);
+					rotate(i);
 				}
 			}
-			upRotate(i);
+			rotate(i);
 			f = father[i];
 			g = father[f];
 		}
diff --git a/src/class153/Code03_FrustratedCashier2.java b/src/class153/Code03_FrustratedCashier2.java
index 7446e729e..f7f23814a 100644
--- a/src/class153/Code03_FrustratedCashier2.java
+++ b/src/class153/Code03_FrustratedCashier2.java
@@ -31,7 +31,7 @@
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
-//void upRotate(int i) {
+//void rotate(int i) {
 //    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
 //    if (soni == 1) {
 //        rs[f] = ls[i];
@@ -64,12 +64,12 @@
 //    while (f != goal) {
 //        if (g != goal) {
 //            if (lr(i) == lr(f)) {
-//                upRotate(f);
+//                rotate(f);
 //            } else {
-//                upRotate(i);
+//                rotate(i);
 //            }
 //        }
-//        upRotate(i);
+//        rotate(i);
 //        f = fa[i];
 //        g = fa[f];
 //    }
diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index 5c14f6613..a867af698 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -43,7 +43,7 @@ public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
-	public static void upRotate(int i) {
+	public static void rotate(int i) {
 		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
 		if (soni == 1) {
 			right[f] = left[i];
@@ -76,12 +76,12 @@ public static void splay(int i, int goal) {
 		while (f != goal) {
 			if (g != goal) {
 				if (lr(i) == lr(f)) {
-					upRotate(f);
+					rotate(f);
 				} else {
-					upRotate(i);
+					rotate(i);
 				}
 			}
-			upRotate(i);
+			rotate(i);
 			f = father[i];
 			g = father[f];
 		}
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index 23072d50e..897b6d2ca 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -29,7 +29,7 @@
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
-//void upRotate(int i) {
+//void rotate(int i) {
 //    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
 //    if (soni == 1) {
 //        rs[f] = ls[i];
@@ -62,12 +62,12 @@
 //    while (f != goal) {
 //        if (g != goal) {
 //            if (lr(i) == lr(f)) {
-//                upRotate(f);
+//                rotate(f);
 //            } else {
-//                upRotate(i);
+//                rotate(i);
 //            }
 //        }
-//        upRotate(i);
+//        rotate(i);
 //        f = fa[i];
 //        g = fa[f];
 //    }
diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index 6f761de84..f31d005d7 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -67,7 +67,7 @@ public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
-	public static void upRotate(int i) {
+	public static void rotate(int i) {
 		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
 		if (soni == 1) {
 			right[f] = left[i];
@@ -100,12 +100,12 @@ public static void splay(int i, int goal) {
 		while (f != goal) {
 			if (g != goal) {
 				if (lr(i) == lr(f)) {
-					upRotate(f);
+					rotate(f);
 				} else {
-					upRotate(i);
+					rotate(i);
 				}
 			}
-			upRotate(i);
+			rotate(i);
 			f = father[i];
 			g = father[f];
 		}
@@ -226,7 +226,7 @@ public static void delete(int rank, int n) {
 		up(l);
 	}
 
-	public static void update(int rank, int n, int val) {
+	public static void reset(int rank, int n, int val) {
 		int l = find(rank - 1);
 		int r = find(rank + n);
 		splay(l, 0);
@@ -283,7 +283,7 @@ public static void main(String[] args) {
 			if (op.equals("MAX-SUM")) {
 				out.println(queryMax());
 			} else {
-				// 因为有最左的准备值，所以位置要右移一位
+				// 因为有最左的准备值，所以位置要后移一位
 				posi = in.readInt() + 1;
 				tot = in.readInt();
 				if (op.equals("INSERT")) {
@@ -295,7 +295,7 @@ public static void main(String[] args) {
 					delete(posi, tot);
 				} else if (op.equals("MAKE-SAME")) {
 					c = in.readInt();
-					update(posi, tot, c);
+					reset(posi, tot, c);
 				} else if (op.equals("REVERSE")) {
 					reverse(posi, tot);
 				} else {
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index 5f89ddc82..74ac2eea6 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -39,7 +39,7 @@
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
-//void upRotate(int i) {
+//void rotate(int i) {
 //    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
 //    if (soni == 1) {
 //        rs[f] = ls[i];
@@ -72,12 +72,12 @@
 //        int f = fa[i], g = fa[f];
 //        if (g != goal) {
 //            if (lr(i) == lr(f)) {
-//                upRotate(f);
+//                rotate(f);
 //            } else {
-//                upRotate(i);
+//                rotate(i);
 //            }
 //        }
-//        upRotate(i);
+//        rotate(i);
 //    }
 //    if (goal == 0) {
 //        head = i;
@@ -192,7 +192,7 @@
 //    up(l);
 //}
 //
-//void updateValue(int rank, int n, int val) {
+//void reset(int rank, int n, int val) {
 //    int l = find(rank - 1);
 //    int r = find(rank + n);
 //    splay(l, 0);
@@ -202,7 +202,7 @@
 //    up(l);
 //}
 //
-//void reverseRange(int rank, int n) {
+//void reverse(int rank, int n) {
 //    int l = find(rank - 1);
 //    int r = find(rank + n);
 //    splay(l, 0);
@@ -256,9 +256,9 @@
 //                remove(pos, len);
 //            } else if (op == "MAKE-SAME") {
 //                cin >> c;
-//                updateValue(pos, len, c);
+//                reset(pos, len, c);
 //            } else if (op == "REVERSE") {
-//                reverseRange(pos, len);
+//                reverse(pos, len);
 //            } else if (op == "GET-SUM") {
 //                cout << querySum(pos, len) << endl;
 //            }
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index 6389d659d..6570d9d4b 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -39,7 +39,7 @@ public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
-	public static void upRotate(int i) {
+	public static void rotate(int i) {
 		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
 		if (soni == 1) {
 			right[f] = left[i];
@@ -72,12 +72,12 @@ public static void splay(int i, int goal) {
 		while (f != goal) {
 			if (g != goal) {
 				if (lr(i) == lr(f)) {
-					upRotate(f);
+					rotate(f);
 				} else {
-					upRotate(i);
+					rotate(i);
 				}
 			}
-			upRotate(i);
+			rotate(i);
 			f = father[i];
 			g = father[f];
 		}
diff --git a/src/class153/FollowUp2.java b/src/class153/FollowUp2.java
index bda072b72..bdbd03932 100644
--- a/src/class153/FollowUp2.java
+++ b/src/class153/FollowUp2.java
@@ -32,7 +32,7 @@
 //    return rs[fa[i]] == i ? 1 : 0;
 //}
 //
-//void upRotate(int i) {
+//void rotate(int i) {
 //    int f = fa[i], g = fa[f], soni = lr(i), sonf = lr(f);
 //    if (soni == 1) {
 //        rs[f] = ls[i];
@@ -65,12 +65,12 @@
 //    while (f != goal) {
 //        if (g != goal) {
 //            if (lr(i) == lr(f)) {
-//                upRotate(f);
+//                rotate(f);
 //            } else {
-//                upRotate(i);
+//                rotate(i);
 //            }
 //        }
-//        upRotate(i);
+//        rotate(i);
 //        f = fa[i];
 //        g = fa[f];
 //    }

From 572146effdf7278118af92dc24f28e91c1a3c363 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 23:56:03 +0800
Subject: [PATCH 0169/1712] modify code

---
 ...r1.java => Code02_FrustratedCashier1.java} |  8 ++++-
 ...r2.java => Code02_FrustratedCashier2.java} |  6 ++++
 ...ryTree1.java => Code03_LiteraryTree1.java} |  2 +-
 ...ryTree2.java => Code03_LiteraryTree2.java} |  0
 src/class153/Code04_Bookcase1.java            | 31 +++++++++++--------
 src/class153/Code04_Bookcase2.java            | 31 +++++++++++--------
 src/class153/Code05_MaintainSequence1.java    |  9 ++++++
 src/class153/Code05_MaintainSequence2.java    |  9 ++++++
 8 files changed, 68 insertions(+), 28 deletions(-)
 rename src/class153/{Code03_FrustratedCashier1.java => Code02_FrustratedCashier1.java} (89%)
 rename src/class153/{Code03_FrustratedCashier2.java => Code02_FrustratedCashier2.java} (88%)
 rename src/class153/{Code02_LiteraryTree1.java => Code03_LiteraryTree1.java} (99%)
 rename src/class153/{Code02_LiteraryTree2.java => Code03_LiteraryTree2.java} (100%)

diff --git a/src/class153/Code03_FrustratedCashier1.java b/src/class153/Code02_FrustratedCashier1.java
similarity index 89%
rename from src/class153/Code03_FrustratedCashier1.java
rename to src/class153/Code02_FrustratedCashier1.java
index 3cf96ba4e..ab47e92e9 100644
--- a/src/class153/Code03_FrustratedCashier1.java
+++ b/src/class153/Code02_FrustratedCashier1.java
@@ -1,6 +1,12 @@
 package class153;
 
 // 郁闷的出纳员(java版)
+// 最低薪水为limit，一旦员工薪水低于limit，员工会离职，实现如下四种操作
+// I x : 新来员工初始薪水是x，如果x低于limit，该员工不会入职当然也不算离职
+// A x : 所有员工的薪水都加上x
+// S x : 所有员工的薪水都减去x，一旦有员工低于limit那么就会离职
+// F x : 查询第k多的工资，如果x大于当前员工数量，打印-1
+// 所有操作完成后，打印有多少员工在操作期间离开了公司
 // 测试链接 : https://www.luogu.com.cn/problem/P1486
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -13,7 +19,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code03_FrustratedCashier1 {
+public class Code02_FrustratedCashier1 {
 
 	public static int MAXN = 300001;
 
diff --git a/src/class153/Code03_FrustratedCashier2.java b/src/class153/Code02_FrustratedCashier2.java
similarity index 88%
rename from src/class153/Code03_FrustratedCashier2.java
rename to src/class153/Code02_FrustratedCashier2.java
index f7f23814a..0ab6be31f 100644
--- a/src/class153/Code03_FrustratedCashier2.java
+++ b/src/class153/Code02_FrustratedCashier2.java
@@ -1,6 +1,12 @@
 package class153;
 
 // 郁闷的出纳员(C++版)
+// 最低薪水为limit，一旦员工薪水低于limit，员工会离职，实现如下四种操作
+// I x : 新来员工初始薪水是x，如果x低于limit，该员工不会入职当然也不算离职
+// A x : 所有员工的薪水都加上x
+// S x : 所有员工的薪水都减去x，一旦有员工低于limit那么就会离职
+// F x : 查询第k多的工资，如果x大于当前员工数量，打印-1
+// 所有操作完成后，打印有多少员工在操作期间离开了公司
 // 测试链接 : https://www.luogu.com.cn/problem/P1486
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class153/Code02_LiteraryTree1.java b/src/class153/Code03_LiteraryTree1.java
similarity index 99%
rename from src/class153/Code02_LiteraryTree1.java
rename to src/class153/Code03_LiteraryTree1.java
index 9542498c3..7e700f59a 100644
--- a/src/class153/Code02_LiteraryTree1.java
+++ b/src/class153/Code03_LiteraryTree1.java
@@ -15,7 +15,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_LiteraryTree1 {
+public class Code03_LiteraryTree1 {
 
 	public static int MAXN = 100005;
 
diff --git a/src/class153/Code02_LiteraryTree2.java b/src/class153/Code03_LiteraryTree2.java
similarity index 100%
rename from src/class153/Code02_LiteraryTree2.java
rename to src/class153/Code03_LiteraryTree2.java
diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index a867af698..2970bd7c3 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -1,6 +1,13 @@
 package class153;
 
 // 书架(java版)
+// 给定一个长度为n的排列，由数字1、2、3...n组成，实现如下五种操作
+// Top s      : 数字s移动到最左边
+// Bottom s   : 数字s移动到最右边
+// Insert s t : 数字s位置假设为rank，现在移动到rank+t位置
+// Ask s      : 查询数字s左边有多少数字
+// Query s    : 查询从左往右第s位的数字
+// 所有操作保证都是合法的
 // 测试链接 : https://www.luogu.com.cn/problem/P2596
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -135,24 +142,22 @@ public static int query(int s) {
 	// 注意a不会是1和n位置，b也如此
 	// 因为1位置和n位置提前加入了预备值，永远不会修改
 	public static void move(int a, int b) {
-		int i = find(a);
 		int l = find(a - 1);
+		int r = find(a + 1);
 		splay(l, 0);
-		splay(i, l);
-		right[l] = right[i];
-		father[right[l]] = l;
+		splay(r, l);
+		int i = left[r];
+		left[r] = 0;
+		up(r);
 		up(l);
-		left[i] = right[i] = 0;
-		int r = find(b - 1);
-		int next = find(b);
-		splay(r, 0);
-		splay(next, r);
-		right[r] = i;
+		l = find(b - 1);
+		r = find(b);
+		splay(l, 0);
+		splay(r, l);
+		left[r] = i;
 		father[i] = r;
-		right[i] = next;
-		father[next] = i;
-		up(i);
 		up(r);
+		up(l);
 	}
 
 	public static void main(String[] args) {
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index 897b6d2ca..87b04fd86 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -1,6 +1,13 @@
 package class153;
 
 // 书架(C++版)
+// 给定一个长度为n的排列，由数字1、2、3...n组成，实现如下五种操作
+// Top s      : 数字s移动到最左边
+// Bottom s   : 数字s移动到最右边
+// Insert s t : 数字s位置假设为rank，现在移动到rank+t位置
+// Ask s      : 查询数字s左边有多少数字
+// Query s    : 查询从左往右第s位的数字
+// 所有操作保证都是合法的
 // 测试链接 : https://www.luogu.com.cn/problem/P2596
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -117,24 +124,22 @@
 //}
 //
 //void move(int a, int b) {
-//    int i = find(a);
 //    int l = find(a - 1);
+//    int r = find(a + 1);
 //    splay(l, 0);
-//    splay(i, l);
-//    rs[l] = rs[i];
-//    fa[rs[l]] = l;
+//    splay(r, l);
+//    int i = ls[r];
+//    ls[r] = 0;
+//    up(r);
 //    up(l);
-//    ls[i] = rs[i] = 0;
-//    int r = find(b - 1);
-//    int next = find(b);
-//    splay(r, 0);
-//    splay(next, r);
-//    rs[r] = i;
+//    l = find(b - 1);
+//    r = find(b);
+//    splay(l, 0);
+//    splay(r, l);
+//    ls[r] = i;
 //    fa[i] = r;
-//    rs[i] = next;
-//    fa[next] = i;
-//    up(i);
 //    up(r);
+//    up(l);
 //}
 //
 //int main() {
diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index f31d005d7..f923cfa99 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -1,6 +1,15 @@
 package class153;
 
 // 维护数列(java版)
+// 初始时给定一个数列，实现如下六种操作
+// INSERT posi tot ...  : 在第posi个数字之后，插入长度为tot的数组，由...代表
+// DELETE posi tot      : 从第posi个数字开始，删除长度为tot的部分
+// MAKE-SAME posi tot c : 从第posi个数字开始，长度为tot的部分，值都设置成c
+// REVERSE posi tot     : 从第posi个数字开始，翻转长度为tot的部分
+// GET-SUM posi tot     : 从第posi个数字开始，查询长度为tot的部分的累加和
+// MAX-SUM              : 查询整个数列中，子数组的最大累加和，子数组不能为空
+// 任何时刻输入保证至少有一个数字在数列中，并且所有操作都合法
+// 插入数字总数可能很多，但是任何时刻数列中最多有5 * 10^5个数，总空间请和这个数量有关
 // 测试链接 : https://www.luogu.com.cn/problem/P2042
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index 74ac2eea6..356ed637c 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -1,6 +1,15 @@
 package class153;
 
 // 维护数列(C++版)
+// 初始时给定一个数列，实现如下六种操作
+// INSERT posi tot ...  : 在第posi个数字之后，插入长度为tot的数组，由...代表
+// DELETE posi tot      : 从第posi个数字开始，删除长度为tot的部分
+// MAKE-SAME posi tot c : 从第posi个数字开始，长度为tot的部分，值都设置成c
+// REVERSE posi tot     : 从第posi个数字开始，翻转长度为tot的部分
+// GET-SUM posi tot     : 从第posi个数字开始，查询长度为tot的部分的累加和
+// MAX-SUM              : 查询整个数列中，子数组的最大累加和，子数组不能为空
+// 任何时刻输入保证至少有一个数字在数列中，并且所有操作都合法
+// 插入数字总数可能很多，但是任何时刻数列中最多有5 * 10^5个数，总空间请和这个数量有关
 // 测试链接 : https://www.luogu.com.cn/problem/P2042
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 8cc7e7080cc68839f6c6ac8a1dda9f04a9effed3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 28 Nov 2024 23:59:22 +0800
Subject: [PATCH 0170/1712] modify code

---
 src/class153/Code05_MaintainSequence1.java | 2 +-
 src/class153/Code05_MaintainSequence2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index f923cfa99..6780ce9f8 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -9,7 +9,7 @@
 // GET-SUM posi tot     : 从第posi个数字开始，查询长度为tot的部分的累加和
 // MAX-SUM              : 查询整个数列中，子数组的最大累加和，子数组不能为空
 // 任何时刻输入保证至少有一个数字在数列中，并且所有操作都合法
-// 插入数字总数可能很多，但是任何时刻数列中最多有5 * 10^5个数，总空间请和这个数量有关
+// 插入数字总数很多，但是任何时刻数列中最多有5 * 10^5个数，使用总空间要和该数量有关
 // 测试链接 : https://www.luogu.com.cn/problem/P2042
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index 356ed637c..f53fa459b 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -9,7 +9,7 @@
 // GET-SUM posi tot     : 从第posi个数字开始，查询长度为tot的部分的累加和
 // MAX-SUM              : 查询整个数列中，子数组的最大累加和，子数组不能为空
 // 任何时刻输入保证至少有一个数字在数列中，并且所有操作都合法
-// 插入数字总数可能很多，但是任何时刻数列中最多有5 * 10^5个数，总空间请和这个数量有关
+// 插入数字总数很多，但是任何时刻数列中最多有5 * 10^5个数，使用总空间要和该数量有关
 // 测试链接 : https://www.luogu.com.cn/problem/P2042
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From a3be83a6d028fdccd36d2976d0c64b432cf266ab Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Nov 2024 00:00:33 +0800
Subject: [PATCH 0171/1712] modify code

---
 src/class153/Code05_MaintainSequence1.java | 2 +-
 src/class153/Code05_MaintainSequence2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index 6780ce9f8..ec21f5d4a 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -7,7 +7,7 @@
 // MAKE-SAME posi tot c : 从第posi个数字开始，长度为tot的部分，值都设置成c
 // REVERSE posi tot     : 从第posi个数字开始，翻转长度为tot的部分
 // GET-SUM posi tot     : 从第posi个数字开始，查询长度为tot的部分的累加和
-// MAX-SUM              : 查询整个数列中，子数组的最大累加和，子数组不能为空
+// MAX-SUM              : 查询整个数列中，非空子数组的最大累加和
 // 任何时刻输入保证至少有一个数字在数列中，并且所有操作都合法
 // 插入数字总数很多，但是任何时刻数列中最多有5 * 10^5个数，使用总空间要和该数量有关
 // 测试链接 : https://www.luogu.com.cn/problem/P2042
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index f53fa459b..3087dd7b4 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -7,7 +7,7 @@
 // MAKE-SAME posi tot c : 从第posi个数字开始，长度为tot的部分，值都设置成c
 // REVERSE posi tot     : 从第posi个数字开始，翻转长度为tot的部分
 // GET-SUM posi tot     : 从第posi个数字开始，查询长度为tot的部分的累加和
-// MAX-SUM              : 查询整个数列中，子数组的最大累加和，子数组不能为空
+// MAX-SUM              : 查询整个数列中，非空子数组的最大累加和
 // 任何时刻输入保证至少有一个数字在数列中，并且所有操作都合法
 // 插入数字总数很多，但是任何时刻数列中最多有5 * 10^5个数，使用总空间要和该数量有关
 // 测试链接 : https://www.luogu.com.cn/problem/P2042

From 8da159ca467f12a88e37691007a410d1ea909eaa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Nov 2024 01:21:05 +0800
Subject: [PATCH 0172/1712] modify code

---
 src/class153/Code01_Splay1.java        | 24 +++++++-----------------
 src/class153/Code01_Splay2.java        | 24 +++++++-----------------
 src/class153/Code03_LiteraryTree1.java |  7 ++++---
 src/class153/Code03_LiteraryTree2.java |  7 ++++---
 src/class153/FollowUp1.java            | 24 +++++++-----------------
 src/class153/FollowUp2.java            | 24 +++++++-----------------
 6 files changed, 36 insertions(+), 74 deletions(-)

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index d424174eb..188fe9631 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -94,7 +94,8 @@ public static void splay(int i, int goal) {
 	}
 
 	// 返回以i为头的树上第rank名的节点编号
-	public static int find(int i, int rank) {
+	public static int find(int rank) {
+		int i = head;
 		while (i != 0) {
 			if (size[left[i]] + 1 == rank) {
 				return i;
@@ -152,20 +153,9 @@ public static int rank(int num) {
 	}
 
 	public static int index(int x) {
-		int i = head, last = head;
-		while (i != 0) {
-			last = i;
-			if (size[left[i]] >= x) {
-				i = left[i];
-			} else if (size[left[i]] + 1 < x) {
-				x -= size[left[i]] + 1;
-				i = right[i];
-			} else {
-				i = 0;
-			}
-		}
-		splay(last, 0);
-		return key[last];
+		int i = find(x);
+		splay(i, 0);
+		return key[i];
 	}
 
 	public static int pre(int num) {
@@ -203,14 +193,14 @@ public static int post(int num) {
 	public static void remove(int num) {
 		int kth = rank(num);
 		if (kth != rank(num + 1)) {
-			int i = find(head, kth);
+			int i = find(kth);
 			splay(i, 0);
 			if (left[i] == 0) {
 				head = right[i];
 			} else if (right[i] == 0) {
 				head = left[i];
 			} else {
-				int j = find(right[i], 1);
+				int j = find(kth + 1);
 				splay(j, i);
 				left[j] = left[i];
 				father[left[j]] = j;
diff --git a/src/class153/Code01_Splay2.java b/src/class153/Code01_Splay2.java
index 5bbfb69b8..b00ee7ba7 100644
--- a/src/class153/Code01_Splay2.java
+++ b/src/class153/Code01_Splay2.java
@@ -86,7 +86,8 @@
 //    }
 //}
 //
-//int find(int i, int rank) {
+//int find(int rank) {
+//    int i = head;
 //    while (i != 0) {
 //        if (size[ls[i]] + 1 == rank) {
 //            return i;
@@ -144,20 +145,9 @@
 //}
 //
 //int index(int x) {
-//    int i = head, last = head;
-//    while (i != 0) {
-//        last = i;
-//        if (size[ls[i]] >= x) {
-//            i = ls[i];
-//        } else if (size[ls[i]] + 1 < x) {
-//            x -= size[ls[i]] + 1;
-//            i = rs[i];
-//        } else {
-//            i = 0;
-//        }
-//    }
-//    splay(last, 0);
-//    return key[last];
+//    int i = find(x);
+//    splay(i, 0);
+//    return key[i];
 //}
 //
 //int pre(int num) {
@@ -195,14 +185,14 @@
 //void remove(int num) {
 //    int kth = getRank(num);
 //    if (kth != getRank(num + 1)) {
-//        int i = find(head, kth);
+//        int i = find(kth);
 //        splay(i, 0);
 //        if (ls[i] == 0) {
 //            head = rs[i];
 //        } else if (rs[i] == 0) {
 //            head = ls[i];
 //        } else {
-//            int j = find(rs[i], 1);
+//            int j = find(kth + 1);
 //            splay(j, i);
 //            ls[j] = ls[i];
 //            fa[ls[j]] = j;
diff --git a/src/class153/Code03_LiteraryTree1.java b/src/class153/Code03_LiteraryTree1.java
index 7e700f59a..d2c78e47a 100644
--- a/src/class153/Code03_LiteraryTree1.java
+++ b/src/class153/Code03_LiteraryTree1.java
@@ -109,7 +109,8 @@ public static void down(int i) {
 		}
 	}
 
-	public static int find(int i, int rank) {
+	public static int find(int rank) {
+		int i = head;
 		while (i != 0) {
 			down(i);
 			if (size[left[i]] + 1 == rank) {
@@ -139,8 +140,8 @@ public static void add(int x) {
 	// 注意l永远不会是最左位置，r永远不会是最右位置
 	// 因为最左和最右位置提前加入了预备值，永远不会修改
 	public static void reverse(int l, int r) {
-		int i = find(head, l - 1);
-		int j = find(head, r + 1);
+		int i = find(l - 1);
+		int j = find(r + 1);
 		splay(i, 0);
 		splay(j, i);
 		reverse[left[right[head]]] = !reverse[left[right[head]]];
diff --git a/src/class153/Code03_LiteraryTree2.java b/src/class153/Code03_LiteraryTree2.java
index 60d243d20..96e362fb1 100644
--- a/src/class153/Code03_LiteraryTree2.java
+++ b/src/class153/Code03_LiteraryTree2.java
@@ -94,7 +94,8 @@
 //    }
 //}
 //
-//int find(int i, int rank) {
+//int find(int rank) {
+//    int i = head;
 //    while (i != 0) {
 //        down(i);
 //        if (size[ls[i]] + 1 == rank) {
@@ -122,8 +123,8 @@
 //}
 //
 //void reverse(int l, int r) {
-//    int i = find(head, l - 1);
-//    int j = find(head, r + 1);
+//    int i = find(l - 1);
+//    int j = find(r + 1);
 //    splay(i, 0);
 //    splay(j, i);
 //    rev[ls[rs[head]]] = !rev[ls[rs[head]]];
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index 6570d9d4b..47c72b942 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -87,7 +87,8 @@ public static void splay(int i, int goal) {
 	}
 
 	// 返回以i为头的树上第rank名的节点编号
-	public static int find(int i, int rank) {
+	public static int find(int rank) {
+		int i = head;
 		while (i != 0) {
 			if (size[left[i]] + 1 == rank) {
 				return i;
@@ -145,20 +146,9 @@ public static int rank(int num) {
 	}
 
 	public static int index(int x) {
-		int i = head, last = head;
-		while (i != 0) {
-			last = i;
-			if (size[left[i]] >= x) {
-				i = left[i];
-			} else if (size[left[i]] + 1 < x) {
-				x -= size[left[i]] + 1;
-				i = right[i];
-			} else {
-				i = 0;
-			}
-		}
-		splay(last, 0);
-		return key[last];
+		int i = find(x);
+		splay(i, 0);
+		return key[i];
 	}
 
 	public static int pre(int num) {
@@ -196,14 +186,14 @@ public static int post(int num) {
 	public static void remove(int num) {
 		int kth = rank(num);
 		if (kth != rank(num + 1)) {
-			int i = find(head, kth);
+			int i = find(kth);
 			splay(i, 0);
 			if (left[i] == 0) {
 				head = right[i];
 			} else if (right[i] == 0) {
 				head = left[i];
 			} else {
-				int j = find(right[i], 1);
+				int j = find(kth + 1);
 				splay(j, i);
 				left[j] = left[i];
 				father[left[j]] = j;
diff --git a/src/class153/FollowUp2.java b/src/class153/FollowUp2.java
index bdbd03932..13f127ab1 100644
--- a/src/class153/FollowUp2.java
+++ b/src/class153/FollowUp2.java
@@ -79,7 +79,8 @@
 //    }
 //}
 //
-//int find(int i, int rank) {
+//int find(int rank) {
+//    int i = head;
 //    while (i != 0) {
 //        if (size[ls[i]] + 1 == rank) {
 //            return i;
@@ -137,20 +138,9 @@
 //}
 //
 //int index(int x) {
-//    int i = head, last = head;
-//    while (i != 0) {
-//        last = i;
-//        if (size[ls[i]] >= x) {
-//            i = ls[i];
-//        } else if (size[ls[i]] + 1 < x) {
-//            x -= size[ls[i]] + 1;
-//            i = rs[i];
-//        } else {
-//            i = 0;
-//        }
-//    }
-//    splay(last, 0);
-//    return key[last];
+//    int i = find(x);
+//    splay(i, 0);
+//    return key[i];
 //}
 //
 //int pre(int num) {
@@ -188,14 +178,14 @@
 //void remove(int num) {
 //    int kth = getRank(num);
 //    if (kth != getRank(num + 1)) {
-//        int i = find(head, kth);
+//        int i = find(kth);
 //        splay(i, 0);
 //        if (ls[i] == 0) {
 //            head = rs[i];
 //        } else if (rs[i] == 0) {
 //            head = ls[i];
 //        } else {
-//            int j = find(rs[i], 1);
+//            int j = find(kth + 1);
 //            splay(j, i);
 //            ls[j] = ls[i];
 //            fa[ls[j]] = j;

From 1ff822797a4dafb1f5e773bad746548edeb9b9ea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Nov 2024 10:40:11 +0800
Subject: [PATCH 0173/1712] modify code

---
 src/class152/Code03_TextEditor1.java | 74 +++++++++++++---------------
 1 file changed, 34 insertions(+), 40 deletions(-)

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index 90caace1f..929823b3c 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -86,66 +86,71 @@ public static void inorder(int i) {
 		}
 	}
 
-	// 我写了很多个版本的IO实现，空间都无法达标
+	// 我做了很多个版本的IO尝试，空间都无法达标
 	// 以下风格只是其中一种，无所谓了，逻辑是对的
 	// 想通过这个题看C++版本吧，完全一样的逻辑
 	public static void main(String[] args) throws IOException {
 		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		int n = Integer.parseInt(in.readLine());
-		int pos = 0, len;
-		String[] input = getInput(in);
+		int n = Integer.valueOf(in.readLine());
+		int pos = 0;
 		String str;
-		String[] part;
 		String op;
-		int l, m, lm, r;
-		for (int i = 1, inputIndex = 0; i <= n; i++) {
-			str = input[inputIndex++].trim();
+		int x;
+		for (int i = 1; i <= n; i++) {
+			str = in.readLine();
 			if (str.equals("Prev")) {
 				pos--;
 			} else if (str.equals("Next")) {
 				pos++;
 			} else {
-				part = str.split(" ");
-				op = part[0];
-				len = Integer.parseInt(part[1]);
+				String[] input = str.split(" ");
+				op = input[0];
+				x = Integer.valueOf(input[1]);
 				if (op.equals("Move")) {
-					pos = len;
+					pos = x;
 				} else if (op.equals("Insert")) {
 					split(0, 0, head, pos);
-					l = right[0];
-					r = left[0];
-					for (int j = 1; j <= len;) {
-						for (char c : input[inputIndex++].toCharArray()) {
-							if (c >= 32 && c <= 126) {
-								key[++cnt] = c;
+					int l = right[0];
+					int r = left[0];
+					left[0] = right[0] = 0;
+					int add = 0;
+					while (add < x) {
+						char[] insert = in.readLine().toCharArray();
+						for (int j = 0; j < insert.length; j++) {
+							if (insert[j] >= 32 && insert[j] <= 126) {
+								key[++cnt] = insert[j];
 								size[cnt] = 1;
 								priority[cnt] = Math.random();
 								l = merge(l, cnt);
-								j++;
+								add++;
 							}
 						}
 					}
 					head = merge(l, r);
 				} else if (op.equals("Delete")) {
-					split(0, 0, head, pos + len);
-					lm = right[0];
-					r = left[0];
+					split(0, 0, head, pos + x);
+					int r = left[0];
+					int lm = right[0];
+					left[0] = right[0] = 0;
 					split(0, 0, lm, pos);
-					l = right[0];
+					int l = right[0];
+					left[0] = right[0] = 0;
 					head = merge(l, r);
 				} else {
-					split(0, 0, head, pos + len);
-					lm = right[0];
-					r = left[0];
+					split(0, 0, head, pos + x);
+					int r = left[0];
+					int lm = right[0];
+					left[0] = right[0] = 0;
 					split(0, 0, lm, pos);
-					l = right[0];
-					m = left[0];
+					int l = right[0];
+					int m = left[0];
+					left[0] = right[0] = 0;
 					ansi = 0;
 					inorder(m);
 					head = merge(merge(l, m), r);
 					for (int j = 1; j <= ansi; j++) {
-						out.print(ans[j]);
+						out.print((char) ans[j]);
 					}
 					out.println();
 				}
@@ -156,15 +161,4 @@ public static void main(String[] args) throws IOException {
 		in.close();
 	}
 
-	public static String[] getInput(BufferedReader in) throws IOException {
-		StringBuilder inputBuffer = new StringBuilder();
-		char[] tempBuffer = new char[8192];
-		int bytesRead;
-		while ((bytesRead = in.read(tempBuffer)) != -1) {
-			inputBuffer.append(tempBuffer, 0, bytesRead);
-		}
-		String[] input = inputBuffer.toString().split("\n");
-		return input;
-	}
-
 }

From db1c53a6d76e9e99d23ccd2cd6f0ddc776d05fe1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Nov 2024 11:17:57 +0800
Subject: [PATCH 0174/1712] modify code

---
 ...TwoDimensionIntervalAddIntervalQuery1.java | 47 ++++++++++---------
 src/class140/Code01_DiophantineEquation2.java |  1 -
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/class108/Code05_TwoDimensionIntervalAddIntervalQuery1.java b/src/class108/Code05_TwoDimensionIntervalAddIntervalQuery1.java
index a4a712448..6cc18e57a 100644
--- a/src/class108/Code05_TwoDimensionIntervalAddIntervalQuery1.java
+++ b/src/class108/Code05_TwoDimensionIntervalAddIntervalQuery1.java
@@ -2,18 +2,11 @@
 
 // 二维数组上范围增加、范围查询，使用树状数组的模版(java)
 // 测试链接 : https://www.luogu.com.cn/problem/P4514
-// 如下实现是正确的，但是洛谷平台对空间卡的很严，只有使用C++能全部通过
-// java的版本就是无法完全通过的，空间会超过限制，主要是IO空间占用大
-// 这是洛谷平台没有照顾各种语言的实现所导致的
-// 在真正笔试、比赛时，一定是兼顾各种语言的，该实现是一定正确的
-// C++版本就是Code05_TwoDimensionIntervalAddIntervalQuery2文件
-// C++版本和java版本逻辑完全一样，但只有C++版本可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedReader;
 import java.io.IOException;
 import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
 public class Code05_TwoDimensionIntervalAddIntervalQuery1 {
@@ -80,31 +73,39 @@ public static int range(int a, int b, int c, int d) {
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		String op;
 		int a, b, c, d, v;
 		while (in.nextToken() != StreamTokenizer.TT_EOF) {
 			op = in.sval;
 			if (op.equals("X")) {
-				in.nextToken(); n = (int) in.nval;
-				in.nextToken(); m = (int) in.nval;
+				in.nextToken();
+				n = (int) in.nval;
+				in.nextToken();
+				m = (int) in.nval;
 			} else if (op.equals("L")) {
-				in.nextToken(); a = (int) in.nval;
-				in.nextToken(); b = (int) in.nval;
-				in.nextToken(); c = (int) in.nval;
-				in.nextToken(); d = (int) in.nval;
-				in.nextToken(); v = (int) in.nval;
+				in.nextToken();
+				a = (int) in.nval;
+				in.nextToken();
+				b = (int) in.nval;
+				in.nextToken();
+				c = (int) in.nval;
+				in.nextToken();
+				d = (int) in.nval;
+				in.nextToken();
+				v = (int) in.nval;
 				add(a, b, c, d, v);
 			} else {
-				in.nextToken(); a = (int) in.nval;
-				in.nextToken(); b = (int) in.nval;
-				in.nextToken(); c = (int) in.nval;
-				in.nextToken(); d = (int) in.nval;
-				out.println(range(a, b, c, d));
+				in.nextToken();
+				a = (int) in.nval;
+				in.nextToken();
+				b = (int) in.nval;
+				in.nextToken();
+				c = (int) in.nval;
+				in.nextToken();
+				d = (int) in.nval;
+				System.out.println(range(a, b, c, d)); // 改用System.out.println可以通过了
 			}
 		}
-		out.flush();
-		out.close();
 		br.close();
 	}
 
diff --git a/src/class140/Code01_DiophantineEquation2.java b/src/class140/Code01_DiophantineEquation2.java
index 74bad0de5..0b6e4855f 100644
--- a/src/class140/Code01_DiophantineEquation2.java
+++ b/src/class140/Code01_DiophantineEquation2.java
@@ -13,7 +13,6 @@
 // 提交如下代码，可以通过所有测试用例
 
 //#include <iostream>
-//
 //#include <cstdio>
 //
 //using namespace std;

From 187c183341d9daf644401dd278c1eefb4d06585d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Nov 2024 16:36:25 +0800
Subject: [PATCH 0175/1712] modify code

---
 src/class153/ShowDetail.java | 140 +++++++++++++++++++++++++++++++++++
 1 file changed, 140 insertions(+)
 create mode 100644 src/class153/ShowDetail.java

diff --git a/src/class153/ShowDetail.java b/src/class153/ShowDetail.java
new file mode 100644
index 000000000..d3cfbd6a8
--- /dev/null
+++ b/src/class153/ShowDetail.java
@@ -0,0 +1,140 @@
+package class153;
+
+// splay处理长链的效果实验
+// 分别去生成一字型长链和之字型长链
+// 每一种长链都让最下方节点splay上去
+// 然后看看长链的高度变化
+public class ShowDetail {
+
+	public static int MAXN = 100001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int lr(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void rotate(int i) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		if (g != 0) {
+			if (sonf == 1) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		father[f] = i;
+		father[i] = g;
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (lr(i) == lr(f)) {
+					rotate(f);
+				} else {
+					rotate(i);
+				}
+			}
+			rotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	public static int build1(int l, int r) {
+		int h = cnt + 1;
+		for (int i = l, last = 0; i <= r; i++, last = cnt) {
+			key[++cnt] = i;
+			father[cnt] = last;
+			left[cnt] = right[cnt] = 0;
+			size[cnt] = r - i + 1;
+			if (last != 0) {
+				right[last] = cnt;
+			}
+		}
+		return h;
+	}
+
+	public static int build2(int l, int r, int fa) {
+		if (l > r) {
+			return 0;
+		}
+		key[++cnt] = l;
+		father[cnt] = fa;
+		left[cnt] = right[cnt] = 0;
+		int h = cnt;
+		if (l < r) {
+			key[++cnt] = r;
+			father[cnt] = h;
+			left[cnt] = right[cnt] = 0;
+			int c = cnt;
+			right[h] = c;
+			left[c] = build2(l + 1, r - 1, c);
+			up(c);
+		}
+		up(h);
+		return h;
+	}
+
+	public static int height(int i) {
+		if (i == 0) {
+			return 0;
+		}
+		return Math.max(height(left[i]), height(right[i])) + 1;
+	}
+
+	public static void main(String[] args) {
+		System.out.println("构建一字型长链");
+		System.out.println("最下方节点执行splay，观察高度变化");
+		head = build1(1, 1000);
+		System.out.println("splay之前的链长度 : " + height(head));
+		splay(cnt, 0);
+		System.out.println("splay之后的链长度 : " + height(head));
+
+		System.out.println("==================");
+
+		System.out.println("构建之字型长链");
+		System.out.println("最下方节点执行splay，观察高度变化");
+		head = build2(1, 1000, 0);
+		System.out.println("splay之前的链长度 : " + height(head));
+		splay(cnt, 0);
+		System.out.println("splay之后的链长度 : " + height(head));
+	}
+
+}

From a62ed16746603ce4eee6645d87d73af6de8be556 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 2 Dec 2024 15:35:46 +0800
Subject: [PATCH 0176/1712] modify code

---
 .../{ShowDetail.java => ShowDetail1.java}     |   6 +-
 src/class153/ShowDetail2.java                 | 157 ++++++++++++++++++
 2 files changed, 160 insertions(+), 3 deletions(-)
 rename src/class153/{ShowDetail.java => ShowDetail1.java} (95%)
 create mode 100644 src/class153/ShowDetail2.java

diff --git a/src/class153/ShowDetail.java b/src/class153/ShowDetail1.java
similarity index 95%
rename from src/class153/ShowDetail.java
rename to src/class153/ShowDetail1.java
index d3cfbd6a8..6b067973a 100644
--- a/src/class153/ShowDetail.java
+++ b/src/class153/ShowDetail1.java
@@ -1,10 +1,10 @@
 package class153;
 
-// splay处理长链的效果实验
+// 底层节点提根操作后长链高度变化的实验
 // 分别去生成一字型长链和之字型长链
-// 每一种长链都让最下方节点splay上去
+// 每一种长链都让最下方节点提根上去
 // 然后看看长链的高度变化
-public class ShowDetail {
+public class ShowDetail1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class153/ShowDetail2.java b/src/class153/ShowDetail2.java
new file mode 100644
index 000000000..a10e4ffb6
--- /dev/null
+++ b/src/class153/ShowDetail2.java
@@ -0,0 +1,157 @@
+package class153;
+
+// 底层节点提根操作后子树大小变化的实验
+// 分别去生成一字型长链和之字型长链
+// 每一种长链都让最下方节点提根上去
+// 然后看看每个节点子树大小的变化并统计数量
+public class ShowDetail2 {
+
+	public static int MAXN = 100001;
+
+	public static int head = 0;
+
+	public static int cnt = 0;
+
+	public static int[] key = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] before = new int[MAXN];
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + 1;
+	}
+
+	public static int lr(int i) {
+		return right[father[i]] == i ? 1 : 0;
+	}
+
+	public static void rotate(int i) {
+		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
+		if (soni == 1) {
+			right[f] = left[i];
+			if (right[f] != 0) {
+				father[right[f]] = f;
+			}
+			left[i] = f;
+		} else {
+			left[f] = right[i];
+			if (left[f] != 0) {
+				father[left[f]] = f;
+			}
+			right[i] = f;
+		}
+		if (g != 0) {
+			if (sonf == 1) {
+				right[g] = i;
+			} else {
+				left[g] = i;
+			}
+		}
+		father[f] = i;
+		father[i] = g;
+		up(f);
+		up(i);
+	}
+
+	public static void splay(int i, int goal) {
+		int f = father[i], g = father[f];
+		while (f != goal) {
+			if (g != goal) {
+				if (lr(i) == lr(f)) {
+					rotate(f);
+				} else {
+					rotate(i);
+				}
+			}
+			rotate(i);
+			f = father[i];
+			g = father[f];
+		}
+		if (goal == 0) {
+			head = i;
+		}
+	}
+
+	public static int build1(int l, int r) {
+		int h = cnt + 1;
+		for (int i = l, last = 0; i <= r; i++, last = cnt) {
+			key[++cnt] = i;
+			father[cnt] = last;
+			left[cnt] = right[cnt] = 0;
+			size[cnt] = r - i + 1;
+			if (last != 0) {
+				right[last] = cnt;
+			}
+		}
+		return h;
+	}
+
+	public static int build2(int l, int r, int fa) {
+		if (l > r) {
+			return 0;
+		}
+		key[++cnt] = l;
+		father[cnt] = fa;
+		left[cnt] = right[cnt] = 0;
+		int h = cnt;
+		if (l < r) {
+			key[++cnt] = r;
+			father[cnt] = h;
+			left[cnt] = right[cnt] = 0;
+			int c = cnt;
+			right[h] = c;
+			left[c] = build2(l + 1, r - 1, c);
+			up(c);
+		}
+		up(h);
+		return h;
+	}
+
+	public static void experiment(int top, int bottom) {
+		for (int i = top; i <= bottom; i++) {
+			before[i] = size[i];
+		}
+		int all = bottom - top + 1;
+		splay(bottom, 0);
+		int half = 0;
+		int beyond = 0;
+		int other = 0;
+		for (int i = top; i <= bottom; i++) {
+			if (size[i] <= before[i] / 2) {
+				half++;
+			} else if (size[i] > before[i]) {
+				beyond++;
+			} else {
+				other++;
+			}
+		}
+		System.out.println("子树总数 : " + all);
+		System.out.println("子树大小至少减半的数量 : " + half);
+		System.out.println("子树大小得到增长的数量 : " + beyond);
+		System.out.println("其他子树的数量 : " + other);
+	}
+
+	public static void main(String[] args) {
+		System.out.println("构建一字型长链");
+		head = build1(1, 1000);
+		System.out.println("实验开始");
+		experiment(head, cnt);
+		System.out.println("实验结束");
+
+		System.out.println();
+
+		System.out.println("构建之字型长链");
+		System.out.println("实验开始");
+		head = build2(1, 1000, 0);
+		experiment(head, cnt);
+		System.out.println("实验结束");
+	}
+
+}

From 6b75879dd0d04cb99a7764e11548cce56e72d6df Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 2 Dec 2024 20:13:20 +0800
Subject: [PATCH 0177/1712] modify code

---
 .../{ShowDetail1.java => ShowDetail.java}     |   2 +-
 src/class153/ShowDetail2.java                 | 157 ------------------
 2 files changed, 1 insertion(+), 158 deletions(-)
 rename src/class153/{ShowDetail1.java => ShowDetail.java} (99%)
 delete mode 100644 src/class153/ShowDetail2.java

diff --git a/src/class153/ShowDetail1.java b/src/class153/ShowDetail.java
similarity index 99%
rename from src/class153/ShowDetail1.java
rename to src/class153/ShowDetail.java
index 6b067973a..335c4bedf 100644
--- a/src/class153/ShowDetail1.java
+++ b/src/class153/ShowDetail.java
@@ -4,7 +4,7 @@
 // 分别去生成一字型长链和之字型长链
 // 每一种长链都让最下方节点提根上去
 // 然后看看长链的高度变化
-public class ShowDetail1 {
+public class ShowDetail {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class153/ShowDetail2.java b/src/class153/ShowDetail2.java
deleted file mode 100644
index a10e4ffb6..000000000
--- a/src/class153/ShowDetail2.java
+++ /dev/null
@@ -1,157 +0,0 @@
-package class153;
-
-// 底层节点提根操作后子树大小变化的实验
-// 分别去生成一字型长链和之字型长链
-// 每一种长链都让最下方节点提根上去
-// 然后看看每个节点子树大小的变化并统计数量
-public class ShowDetail2 {
-
-	public static int MAXN = 100001;
-
-	public static int head = 0;
-
-	public static int cnt = 0;
-
-	public static int[] key = new int[MAXN];
-
-	public static int[] father = new int[MAXN];
-
-	public static int[] left = new int[MAXN];
-
-	public static int[] right = new int[MAXN];
-
-	public static int[] size = new int[MAXN];
-
-	public static int[] before = new int[MAXN];
-
-	public static void up(int i) {
-		size[i] = size[left[i]] + size[right[i]] + 1;
-	}
-
-	public static int lr(int i) {
-		return right[father[i]] == i ? 1 : 0;
-	}
-
-	public static void rotate(int i) {
-		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
-		if (soni == 1) {
-			right[f] = left[i];
-			if (right[f] != 0) {
-				father[right[f]] = f;
-			}
-			left[i] = f;
-		} else {
-			left[f] = right[i];
-			if (left[f] != 0) {
-				father[left[f]] = f;
-			}
-			right[i] = f;
-		}
-		if (g != 0) {
-			if (sonf == 1) {
-				right[g] = i;
-			} else {
-				left[g] = i;
-			}
-		}
-		father[f] = i;
-		father[i] = g;
-		up(f);
-		up(i);
-	}
-
-	public static void splay(int i, int goal) {
-		int f = father[i], g = father[f];
-		while (f != goal) {
-			if (g != goal) {
-				if (lr(i) == lr(f)) {
-					rotate(f);
-				} else {
-					rotate(i);
-				}
-			}
-			rotate(i);
-			f = father[i];
-			g = father[f];
-		}
-		if (goal == 0) {
-			head = i;
-		}
-	}
-
-	public static int build1(int l, int r) {
-		int h = cnt + 1;
-		for (int i = l, last = 0; i <= r; i++, last = cnt) {
-			key[++cnt] = i;
-			father[cnt] = last;
-			left[cnt] = right[cnt] = 0;
-			size[cnt] = r - i + 1;
-			if (last != 0) {
-				right[last] = cnt;
-			}
-		}
-		return h;
-	}
-
-	public static int build2(int l, int r, int fa) {
-		if (l > r) {
-			return 0;
-		}
-		key[++cnt] = l;
-		father[cnt] = fa;
-		left[cnt] = right[cnt] = 0;
-		int h = cnt;
-		if (l < r) {
-			key[++cnt] = r;
-			father[cnt] = h;
-			left[cnt] = right[cnt] = 0;
-			int c = cnt;
-			right[h] = c;
-			left[c] = build2(l + 1, r - 1, c);
-			up(c);
-		}
-		up(h);
-		return h;
-	}
-
-	public static void experiment(int top, int bottom) {
-		for (int i = top; i <= bottom; i++) {
-			before[i] = size[i];
-		}
-		int all = bottom - top + 1;
-		splay(bottom, 0);
-		int half = 0;
-		int beyond = 0;
-		int other = 0;
-		for (int i = top; i <= bottom; i++) {
-			if (size[i] <= before[i] / 2) {
-				half++;
-			} else if (size[i] > before[i]) {
-				beyond++;
-			} else {
-				other++;
-			}
-		}
-		System.out.println("子树总数 : " + all);
-		System.out.println("子树大小至少减半的数量 : " + half);
-		System.out.println("子树大小得到增长的数量 : " + beyond);
-		System.out.println("其他子树的数量 : " + other);
-	}
-
-	public static void main(String[] args) {
-		System.out.println("构建一字型长链");
-		head = build1(1, 1000);
-		System.out.println("实验开始");
-		experiment(head, cnt);
-		System.out.println("实验结束");
-
-		System.out.println();
-
-		System.out.println("构建之字型长链");
-		System.out.println("实验开始");
-		head = build2(1, 1000, 0);
-		experiment(head, cnt);
-		System.out.println("实验结束");
-	}
-
-}

From 9becc4c987f55ce799471fc244c62cf7e2fc4477 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Dec 2024 15:36:56 +0800
Subject: [PATCH 0178/1712] modify code

---
 src/class153/Code01_Splay1.java | 2 ++
 src/class153/FollowUp1.java     | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index 188fe9631..fc12cb20e 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -94,6 +94,8 @@ public static void splay(int i, int goal) {
 	}
 
 	// 返回以i为头的树上第rank名的节点编号
+	// 这个方法查询后没有splay操作
+	// 因为remove方法使用该方法时，要求find不能提根！
 	public static int find(int rank) {
 		int i = head;
 		while (i != 0) {
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index 47c72b942..2bdd0a453 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -87,6 +87,8 @@ public static void splay(int i, int goal) {
 	}
 
 	// 返回以i为头的树上第rank名的节点编号
+	// 这个方法查询后没有splay操作
+	// 因为remove方法使用该方法时，要求find不能提根！
 	public static int find(int rank) {
 		int i = head;
 		while (i != 0) {

From 324ae2f03bc437b37b31485ee46ec819acc82ca1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Dec 2024 15:38:57 +0800
Subject: [PATCH 0179/1712] modify code

---
 src/class153/Code01_Splay1.java | 3 ++-
 src/class153/FollowUp1.java     | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index fc12cb20e..778566baf 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -94,7 +94,8 @@ public static void splay(int i, int goal) {
 	}
 
 	// 返回以i为头的树上第rank名的节点编号
-	// 这个方法查询后没有splay操作
+	// 这个方法不是题目要求的查询操作，作为内部方法使用
+	// 为什么该方法不进行提根操作？
 	// 因为remove方法使用该方法时，要求find不能提根！
 	public static int find(int rank) {
 		int i = head;
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index 2bdd0a453..d52b3121f 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -87,7 +87,8 @@ public static void splay(int i, int goal) {
 	}
 
 	// 返回以i为头的树上第rank名的节点编号
-	// 这个方法查询后没有splay操作
+	// 这个方法不是题目要求的查询操作，作为内部方法使用
+	// 为什么该方法不进行提根操作？
 	// 因为remove方法使用该方法时，要求find不能提根！
 	public static int find(int rank) {
 		int i = head;

From 896779d04e9a919ce671fbda4fc9468545c97753 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Dec 2024 19:36:18 +0800
Subject: [PATCH 0180/1712] modify code

---
 src/class153/ShowDetail.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class153/ShowDetail.java b/src/class153/ShowDetail.java
index 335c4bedf..9edf5ce16 100644
--- a/src/class153/ShowDetail.java
+++ b/src/class153/ShowDetail.java
@@ -1,6 +1,6 @@
 package class153;
 
-// 底层节点提根操作后长链高度变化的实验
+// 提根操作的代码 + 长链高度变化的实验
 // 分别去生成一字型长链和之字型长链
 // 每一种长链都让最下方节点提根上去
 // 然后看看长链的高度变化

From 2377b24d6e6d1b3e8915f6cef0d7670c13c83668 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 4 Dec 2024 14:16:24 +0800
Subject: [PATCH 0181/1712] modify code

---
 src/class153/ShowDetail.java | 15 +++++++++++++++
 1 file changed, 15 insertions(+)

diff --git a/src/class153/ShowDetail.java b/src/class153/ShowDetail.java
index 9edf5ce16..1777672ce 100644
--- a/src/class153/ShowDetail.java
+++ b/src/class153/ShowDetail.java
@@ -8,28 +8,38 @@ public class ShowDetail {
 
 	public static int MAXN = 100001;
 
+	// 整棵树的头节点编号
 	public static int head = 0;
 
+	// 分配了多少节点编号
 	public static int cnt = 0;
 
+	// key[i] : 编号为i的节点的key
 	public static int[] key = new int[MAXN];
 
+	// father[i] : 编号为i的节点的父节点编号
 	public static int[] father = new int[MAXN];
 
+	// left[i] : 编号为i的节点的左孩子编号
 	public static int[] left = new int[MAXN];
 
+	// right[i] : 编号为i的节点的右孩子编号
 	public static int[] right = new int[MAXN];
 
+	// size[i] : 以编号为i的节点做头的子树上，一共有多少个节点
 	public static int[] size = new int[MAXN];
 
 	public static void up(int i) {
 		size[i] = size[left[i]] + size[right[i]] + 1;
 	}
 
+	// 判断编号为i的节点，是其父亲的什么儿子
+	// 0代表左儿子，1代表右儿子
 	public static int lr(int i) {
 		return right[father[i]] == i ? 1 : 0;
 	}
 
+	// 编号为i的节点上升一步，在结构上做调整
 	public static void rotate(int i) {
 		int f = father[i], g = father[f], soni = lr(i), sonf = lr(f);
 		if (soni == 1) {
@@ -58,6 +68,8 @@ public static void rotate(int i) {
 		up(i);
 	}
 
+	// 编号为i的节点提根，变成编号为goal的节点的儿子
+	// 如果goal == 0，表示把编号为i的节点变成整棵树的头
 	public static void splay(int i, int goal) {
 		int f = father[i], g = father[f];
 		while (f != goal) {
@@ -77,6 +89,7 @@ public static void splay(int i, int goal) {
 		}
 	}
 
+	// 构建一字型长链
 	public static int build1(int l, int r) {
 		int h = cnt + 1;
 		for (int i = l, last = 0; i <= r; i++, last = cnt) {
@@ -91,6 +104,7 @@ public static int build1(int l, int r) {
 		return h;
 	}
 
+	// 构建之字形长链
 	public static int build2(int l, int r, int fa) {
 		if (l > r) {
 			return 0;
@@ -112,6 +126,7 @@ public static int build2(int l, int r, int fa) {
 		return h;
 	}
 
+	// 返回以i为头的树的高度
 	public static int height(int i) {
 		if (i == 0) {
 			return 0;

From 669e802796746d50555b4bd6f9708db6ca49c90c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 4 Dec 2024 14:19:11 +0800
Subject: [PATCH 0182/1712] modify code

---
 src/class153/ShowDetail.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class153/ShowDetail.java b/src/class153/ShowDetail.java
index 1777672ce..f8b8d59d3 100644
--- a/src/class153/ShowDetail.java
+++ b/src/class153/ShowDetail.java
@@ -27,6 +27,7 @@ public class ShowDetail {
 	public static int[] right = new int[MAXN];
 
 	// size[i] : 以编号为i的节点做头的子树上，一共有多少个节点
+	//           这个数组和具体要实现的功能有关，属于常用信息
 	public static int[] size = new int[MAXN];
 
 	public static void up(int i) {

From 986121fd07336cc80d29a4b29e87aad0fb87d1f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 4 Dec 2024 14:22:45 +0800
Subject: [PATCH 0183/1712] modify code

---
 src/class153/ShowDetail.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class153/ShowDetail.java b/src/class153/ShowDetail.java
index f8b8d59d3..33b071a20 100644
--- a/src/class153/ShowDetail.java
+++ b/src/class153/ShowDetail.java
@@ -14,20 +14,20 @@ public class ShowDetail {
 	// 分配了多少节点编号
 	public static int cnt = 0;
 
-	// key[i] : 编号为i的节点的key
+	// key[i]    : 编号为i的节点的key
 	public static int[] key = new int[MAXN];
 
 	// father[i] : 编号为i的节点的父节点编号
 	public static int[] father = new int[MAXN];
 
-	// left[i] : 编号为i的节点的左孩子编号
+	// left[i]   : 编号为i的节点的左孩子编号
 	public static int[] left = new int[MAXN];
 
-	// right[i] : 编号为i的节点的右孩子编号
+	// right[i]  : 编号为i的节点的右孩子编号
 	public static int[] right = new int[MAXN];
 
-	// size[i] : 以编号为i的节点做头的子树上，一共有多少个节点
-	//           这个数组和具体要实现的功能有关，属于常用信息
+	// size[i]   : 以编号为i的节点做头的子树，一共有多少个节点
+	//             这个数组和具体要实现的功能有关，属于常用信息
 	public static int[] size = new int[MAXN];
 
 	public static void up(int i) {

From 08a0e4238aba9141bc43c2a35570ed76d5261252 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 4 Dec 2024 15:25:47 +0800
Subject: [PATCH 0184/1712] modify code

---
 src/class153/Code01_Splay1.java | 2 +-
 src/class153/FollowUp1.java     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index 778566baf..189062abb 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -93,7 +93,7 @@ public static void splay(int i, int goal) {
 		}
 	}
 
-	// 返回以i为头的树上第rank名的节点编号
+	// 树上找到中序排名为rank的节点，返回节点编号
 	// 这个方法不是题目要求的查询操作，作为内部方法使用
 	// 为什么该方法不进行提根操作？
 	// 因为remove方法使用该方法时，要求find不能提根！
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index d52b3121f..a62a146b5 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -86,7 +86,7 @@ public static void splay(int i, int goal) {
 		}
 	}
 
-	// 返回以i为头的树上第rank名的节点编号
+	// 树上找到中序排名为rank的节点，返回节点编号
 	// 这个方法不是题目要求的查询操作，作为内部方法使用
 	// 为什么该方法不进行提根操作？
 	// 因为remove方法使用该方法时，要求find不能提根！

From 23ae1899e84503ed74eb24664b20c8f5a1617d84 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 4 Dec 2024 15:27:35 +0800
Subject: [PATCH 0185/1712] modify code

---
 src/class153/Code01_Splay1.java | 2 +-
 src/class153/FollowUp1.java     | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class153/Code01_Splay1.java b/src/class153/Code01_Splay1.java
index 189062abb..4fe607544 100644
--- a/src/class153/Code01_Splay1.java
+++ b/src/class153/Code01_Splay1.java
@@ -93,7 +93,7 @@ public static void splay(int i, int goal) {
 		}
 	}
 
-	// 树上找到中序排名为rank的节点，返回节点编号
+	// 整棵树上找到中序排名为rank的节点，返回节点编号
 	// 这个方法不是题目要求的查询操作，作为内部方法使用
 	// 为什么该方法不进行提根操作？
 	// 因为remove方法使用该方法时，要求find不能提根！
diff --git a/src/class153/FollowUp1.java b/src/class153/FollowUp1.java
index a62a146b5..81df6b3fb 100644
--- a/src/class153/FollowUp1.java
+++ b/src/class153/FollowUp1.java
@@ -86,7 +86,7 @@ public static void splay(int i, int goal) {
 		}
 	}
 
-	// 树上找到中序排名为rank的节点，返回节点编号
+	// 整棵树上找到中序排名为rank的节点，返回节点编号
 	// 这个方法不是题目要求的查询操作，作为内部方法使用
 	// 为什么该方法不进行提根操作？
 	// 因为remove方法使用该方法时，要求find不能提根！

From 44140efb4d544ce8752641699fca4c8680996a7d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 12:28:39 +0800
Subject: [PATCH 0186/1712] modify code

---
 src/class153/Code02_FrustratedCashier1.java | 15 ++++++++-------
 src/class153/Code02_FrustratedCashier2.java | 15 ++++++++-------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/class153/Code02_FrustratedCashier1.java b/src/class153/Code02_FrustratedCashier1.java
index ab47e92e9..576a62a76 100644
--- a/src/class153/Code02_FrustratedCashier1.java
+++ b/src/class153/Code02_FrustratedCashier1.java
@@ -146,19 +146,20 @@ public static void departure() {
 		int num = limit - change - 1;
 		int i = head, ans = 0;
 		while (i != 0) {
-			if (key[i] <= num) {
+			if (key[i] > num) {
 				ans = i;
-				i = right[i];
-			} else {
 				i = left[i];
+			} else {
+				i = right[i];
 			}
 		}
 		if (ans == 0) {
-			return;
+			head = 0;
+		} else {
+			splay(ans, 0);
+			left[head] = 0;
+			up(head);
 		}
-		splay(ans, 0);
-		head = right[head];
-		father[head] = 0;
 	}
 
 	public static void main(String[] args) {
diff --git a/src/class153/Code02_FrustratedCashier2.java b/src/class153/Code02_FrustratedCashier2.java
index 0ab6be31f..e371c8352 100644
--- a/src/class153/Code02_FrustratedCashier2.java
+++ b/src/class153/Code02_FrustratedCashier2.java
@@ -132,19 +132,20 @@
 //    int num = limit - change - 1;
 //    int i = head, ans = 0;
 //    while (i != 0) {
-//        if (key[i] <= num) {
+//        if (key[i] > num) {
 //            ans = i;
-//            i = rs[i];
-//        } else {
 //            i = ls[i];
+//        } else {
+//            i = rs[i];
 //        }
 //    }
 //    if (ans == 0) {
-//        return;
+//        head = 0;
+//    } else {
+//        splay(ans, 0);
+//        ls[head] = 0;
+//        up(head);
 //    }
-//    splay(ans, 0);
-//    head = rs[head];
-//    fa[head] = 0;
 //}
 //
 //int main() {

From 11c5ef217bb3913ce55fea182ce59d4efbb5d992 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 13:49:40 +0800
Subject: [PATCH 0187/1712] modify code

---
 src/class153/Code02_FrustratedCashier1.java | 2 +-
 src/class153/Code02_FrustratedCashier2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class153/Code02_FrustratedCashier1.java b/src/class153/Code02_FrustratedCashier1.java
index 576a62a76..c068be723 100644
--- a/src/class153/Code02_FrustratedCashier1.java
+++ b/src/class153/Code02_FrustratedCashier1.java
@@ -5,7 +5,7 @@
 // I x : 新来员工初始薪水是x，如果x低于limit，该员工不会入职当然也不算离职
 // A x : 所有员工的薪水都加上x
 // S x : 所有员工的薪水都减去x，一旦有员工低于limit那么就会离职
-// F x : 查询第k多的工资，如果x大于当前员工数量，打印-1
+// F x : 查询第x多的工资，如果x大于当前员工数量，打印-1
 // 所有操作完成后，打印有多少员工在操作期间离开了公司
 // 测试链接 : https://www.luogu.com.cn/problem/P1486
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class153/Code02_FrustratedCashier2.java b/src/class153/Code02_FrustratedCashier2.java
index e371c8352..00850dfc5 100644
--- a/src/class153/Code02_FrustratedCashier2.java
+++ b/src/class153/Code02_FrustratedCashier2.java
@@ -5,7 +5,7 @@
 // I x : 新来员工初始薪水是x，如果x低于limit，该员工不会入职当然也不算离职
 // A x : 所有员工的薪水都加上x
 // S x : 所有员工的薪水都减去x，一旦有员工低于limit那么就会离职
-// F x : 查询第k多的工资，如果x大于当前员工数量，打印-1
+// F x : 查询第x多的工资，如果x大于当前员工数量，打印-1
 // 所有操作完成后，打印有多少员工在操作期间离开了公司
 // 测试链接 : https://www.luogu.com.cn/problem/P1486
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 3e688e1fd25b6ae9a39578cbedcee1caae535002 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 15:40:42 +0800
Subject: [PATCH 0188/1712] modify code

---
 src/class153/Code03_LiteraryTree1.java | 8 ++------
 src/class153/Code03_LiteraryTree2.java | 8 ++------
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/class153/Code03_LiteraryTree1.java b/src/class153/Code03_LiteraryTree1.java
index d2c78e47a..b939a5aa1 100644
--- a/src/class153/Code03_LiteraryTree1.java
+++ b/src/class153/Code03_LiteraryTree1.java
@@ -126,14 +126,10 @@ public static int find(int rank) {
 	}
 
 	public static void add(int x) {
-		int i = head;
-		while (right[i] != 0) {
-			i = right[i];
-		}
 		num[++cnt] = x;
 		size[cnt] = 1;
-		father[cnt] = i;
-		right[i] = cnt;
+		father[cnt] = head;
+		right[head] = cnt;
 		splay(cnt, 0);
 	}
 
diff --git a/src/class153/Code03_LiteraryTree2.java b/src/class153/Code03_LiteraryTree2.java
index 96e362fb1..e1fc072c0 100644
--- a/src/class153/Code03_LiteraryTree2.java
+++ b/src/class153/Code03_LiteraryTree2.java
@@ -111,14 +111,10 @@
 //}
 //
 //void add(int x) {
-//    int i = head;
-//    while (rs[i] != 0) {
-//        i = rs[i];
-//    }
 //    num[++cnt] = x;
 //    size[cnt] = 1;
-//    fa[cnt] = i;
-//    rs[i] = cnt;
+//    fa[cnt] = head;
+//    rs[head] = cnt;
 //    splay(cnt, 0);
 //}
 //

From 8cb4e941e52fee8ac394eb711a95360c35519e6b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 15:53:13 +0800
Subject: [PATCH 0189/1712] modify code

---
 src/class153/Code04_Bookcase1.java | 5 +++--
 src/class153/Code04_Bookcase2.java | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index 2970bd7c3..f169cdc92 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -30,8 +30,6 @@ public class Code04_Bookcase1 {
 
 	public static int[] num = new int[MAXN];
 
-	public static int[] pos = new int[MAXN];
-
 	public static int[] father = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
@@ -40,6 +38,9 @@ public class Code04_Bookcase1 {
 
 	public static int[] size = new int[MAXN];
 
+	// pos[i] : 数字i是中序遍历的第几位，相当于rank
+	public static int[] pos = new int[MAXN];
+
 	public static int n, m;
 
 	public static void up(int i) {
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index 87b04fd86..abc94a648 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -22,11 +22,11 @@
 //int head = 0;
 //int cnt = 0;
 //int num[MAXN];
-//int pos[MAXN];
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int size[MAXN];
+//int pos[MAXN];
 //
 //void up(int i) {
 //    size[i] = size[ls[i]] + size[rs[i]] + 1;

From ebc8f36c316f5159b010da50fe7f07bad17d3e9f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 15:55:52 +0800
Subject: [PATCH 0190/1712] modify code

---
 src/class153/Code04_Bookcase1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index f169cdc92..caab32027 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -38,7 +38,7 @@ public class Code04_Bookcase1 {
 
 	public static int[] size = new int[MAXN];
 
-	// pos[i] : 数字i是中序遍历的第几位，相当于rank
+	// pos[num] : 数字num所在节点的编号
 	public static int[] pos = new int[MAXN];
 
 	public static int n, m;

From 5ee52ca822a948cb7f6c4f3b57eaac89bddd1195 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 16:22:47 +0800
Subject: [PATCH 0191/1712] modify code

---
 src/class153/Code04_Bookcase1.java | 8 ++------
 src/class153/Code04_Bookcase2.java | 8 ++------
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/class153/Code04_Bookcase1.java b/src/class153/Code04_Bookcase1.java
index caab32027..82098eb7a 100644
--- a/src/class153/Code04_Bookcase1.java
+++ b/src/class153/Code04_Bookcase1.java
@@ -115,15 +115,11 @@ public static int find(int rank) {
 	}
 
 	public static void add(int s) {
-		int i = head;
-		while (right[i] != 0) {
-			i = right[i];
-		}
 		num[++cnt] = s;
 		pos[s] = cnt;
 		size[cnt] = 1;
-		father[cnt] = i;
-		right[i] = cnt;
+		father[cnt] = head;
+		right[head] = cnt;
 		splay(cnt, 0);
 	}
 
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index abc94a648..d9a81bb32 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -99,15 +99,11 @@
 //}
 //
 //void add(int s) {
-//    int i = head;
-//    while (rs[i] != 0) {
-//        i = rs[i];
-//    }
 //    num[++cnt] = s;
 //    pos[s] = cnt;
 //    size[cnt] = 1;
-//    fa[cnt] = i;
-//    rs[i] = cnt;
+//    fa[cnt] = head;
+//    rs[head] = cnt;
 //    splay(cnt, 0);
 //}
 //

From 56c60e5b8d48ec65cec58c6f4517cf996b4316f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 16:47:57 +0800
Subject: [PATCH 0192/1712] modify code

---
 src/class153/Code05_MaintainSequence1.java | 19 ++++++++++++-------
 src/class153/Code05_MaintainSequence2.java |  2 +-
 2 files changed, 13 insertions(+), 8 deletions(-)

diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index ec21f5d4a..a597cda35 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -31,10 +31,6 @@ public class Code05_MaintainSequence1 {
 
 	public static int head = 0;
 
-	public static int[] space = new int[MAXN];
-
-	public static int si;
-
 	public static int[] arr = new int[MAXN];
 
 	public static int[] num = new int[MAXN];
@@ -47,21 +43,30 @@ public class Code05_MaintainSequence1 {
 
 	public static int[] size = new int[MAXN];
 
+	// 这个数组里拿空间编号
+	public static int[] space = new int[MAXN];
+
+	public static int si;
+
+	// 维护区间累加和信息
 	public static int[] sum = new int[MAXN];
 
-	// 整体子数组最大累加和，不能空
+	// 维护区间子数组最大累加和信息，要求不能为空
 	public static int[] all = new int[MAXN];
 
-	// 前缀子数组最大累加和，可以空
+	// 维护区间前缀最大累加和信息，可以空
 	public static int[] pre = new int[MAXN];
 
-	// 后缀子数组最大累加和，可以空
+	// 维护区间后缀最大累加和信息，可以空
 	public static int[] suf = new int[MAXN];
 
+	// 懒更新信息，区间是否重新设了值
 	public static boolean[] update = new boolean[MAXN];
 
+	// 懒更新信息，如果区间重新设了值，设置成了什么
 	public static int[] change = new int[MAXN];
 
+	// 懒更新信息，区间是否发生了翻转
 	public static boolean[] reverse = new boolean[MAXN];
 
 	public static void up(int i) {
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index 3087dd7b4..076cc19d8 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -21,13 +21,13 @@
 //const int INF = 1000000001;
 //
 //int head = 0;
-//int space[MAXN], si;
 //int arr[MAXN];
 //int num[MAXN];
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int size[MAXN];
+//int space[MAXN], si;
 //int sum[MAXN];
 //int all[MAXN];
 //int pre[MAXN];

From ff333a79f20556ce7e89aad4bd67f328e5b005b3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 17:30:24 +0800
Subject: [PATCH 0193/1712] modify code

---
 src/class153/Code05_MaintainSequence1.java | 11 ++++++-----
 src/class153/Code05_MaintainSequence2.java | 12 +++++++-----
 2 files changed, 13 insertions(+), 10 deletions(-)

diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index a597cda35..cb5d040d1 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -70,11 +70,12 @@ public class Code05_MaintainSequence1 {
 	public static boolean[] reverse = new boolean[MAXN];
 
 	public static void up(int i) {
-		size[i] = size[left[i]] + size[right[i]] + 1;
-		sum[i] = sum[left[i]] + sum[right[i]] + num[i];
-		all[i] = Math.max(Math.max(all[left[i]], all[right[i]]), suf[left[i]] + num[i] + pre[right[i]]);
-		pre[i] = Math.max(pre[left[i]], sum[left[i]] + num[i] + pre[right[i]]);
-		suf[i] = Math.max(suf[right[i]], suf[left[i]] + num[i] + sum[right[i]]);
+		int l = left[i], r = right[i];
+		size[i] = size[l] + size[r] + 1;
+		sum[i] = sum[l] + sum[r] + num[i];
+		all[i] = Math.max(Math.max(all[l], all[r]), suf[l] + num[i] + pre[r]);
+		pre[i] = Math.max(pre[l], sum[l] + num[i] + pre[r]);
+		suf[i] = Math.max(suf[r], suf[l] + num[i] + sum[r]);
 	}
 
 	public static int lr(int i) {
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index 076cc19d8..13848996d 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -15,6 +15,7 @@
 // 提交如下代码，可以通过所有测试用例
 
 //#include <bits/stdc++.h>
+//
 //using namespace std;
 //
 //const int MAXN = 500005;
@@ -37,11 +38,12 @@
 //bool rev[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
-//    sum[i] = sum[ls[i]] + sum[rs[i]] + num[i];
-//    all[i] = max({all[ls[i]], all[rs[i]], suf[ls[i]] + num[i] + pre[rs[i]]});
-//    pre[i] = max(pre[ls[i]], sum[ls[i]] + num[i] + pre[rs[i]]);
-//    suf[i] = max(suf[rs[i]], suf[ls[i]] + num[i] + sum[rs[i]]);
+//    int l = ls[i], r = rs[i];
+//    size[i] = size[l] + size[r] + 1;
+//    sum[i] = sum[l] + sum[r] + num[i];
+//    all[i] = max(max(all[l], all[r]), suf[l] + num[i] + pre[r]);
+//    pre[i] = max(pre[l], sum[l] + num[i] + pre[r]);
+//    suf[i] = max(suf[r], suf[l] + num[i] + sum[r]);
 //}
 //
 //int lr(int i) {

From 25a695b30d4b093d9f28c04a5d7d4c026656e62a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 18:03:01 +0800
Subject: [PATCH 0194/1712] modify code

---
 src/class153/Code05_MaintainSequence1.java | 8 ++++----
 src/class153/Code05_MaintainSequence2.java | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class153/Code05_MaintainSequence1.java b/src/class153/Code05_MaintainSequence1.java
index cb5d040d1..e8694c647 100644
--- a/src/class153/Code05_MaintainSequence1.java
+++ b/src/class153/Code05_MaintainSequence1.java
@@ -143,10 +143,7 @@ public static void setValue(int i, int val) {
 
 	public static void setReverse(int i) {
 		if (i != 0) {
-			int tmp = left[i];
-			left[i] = right[i];
-			right[i] = tmp;
-			tmp = pre[i];
+			int tmp = pre[i];
 			pre[i] = suf[i];
 			suf[i] = tmp;
 			reverse[i] = !reverse[i];
@@ -160,6 +157,9 @@ public static void down(int i) {
 			update[i] = false;
 		}
 		if (reverse[i]) {
+			int tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
 			setReverse(left[i]);
 			setReverse(right[i]);
 			reverse[i] = false;
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index 13848996d..8c4255941 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -109,7 +109,6 @@
 //
 //void setReverse(int i) {
 //    if (i != 0) {
-//        swap(ls[i], rs[i]);
 //        swap(pre[i], suf[i]);
 //        rev[i] ^= 1;
 //    }
@@ -122,6 +121,7 @@
 //        update[i] = false;
 //    }
 //    if (rev[i]) {
+//        swap(ls[i], rs[i]);
 //        setReverse(ls[i]);
 //        setReverse(rs[i]);
 //        rev[i] = false;

From 1a6a8eccc6e582ece6e6610a3767ebbff12fa185 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Dec 2024 18:33:20 +0800
Subject: [PATCH 0195/1712] modify code

---
 ...270\223\351\242\2306-Splay\346\240\221.pdf" | Bin 0 -> 325745 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243153\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2306-Splay\346\240\221.pdf"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243153\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2306-Splay\346\240\221.pdf" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243153\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2306-Splay\346\240\221.pdf"
new file mode 100644
index 0000000000000000000000000000000000000000..b7ba9cf170a12103ae84293da1e457052aa81e08
GIT binary patch
literal 325745
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

literal 0
HcmV?d00001


From 0890e47a885ab58b9c686ecfe7afe222f49bc114 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Dec 2024 15:25:48 +0800
Subject: [PATCH 0196/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 114 ++++++++++++++++++++++++++
 src/class154/Code01_LeftistTree2.java |  89 ++++++++++++++++++++
 2 files changed, 203 insertions(+)
 create mode 100644 src/class154/Code01_LeftistTree1.java
 create mode 100644 src/class154/Code01_LeftistTree2.java

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
new file mode 100644
index 000000000..6e4d863cb
--- /dev/null
+++ b/src/class154/Code01_LeftistTree1.java
@@ -0,0 +1,114 @@
+package class154;
+
+// 左偏树模版，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3377
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_LeftistTree1 {
+
+	public static int MAXN = 100001;
+
+	public static int INF = 1000000001;
+
+	public static int[] num = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int find(int i) {
+		if (father[i] != i) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (num[i] > num[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[i] = father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static void pop(int i) {
+		num[i] = -INF;
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		// 下面这一句的功能
+		// 因为有路径压缩，所以i下方的某个节点x，可能有father[x] = i
+		// 但是现在堆要去掉i了，所以x一直往上找到i是无效的
+		// 为了i能再往上找到正确的头，所以有下面这句
+		father[i] = merge(left[i], right[i]);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			in.nextToken();
+			num[i] = (int) in.nval;
+		}
+		for (int i = 1, op, x, y; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			if (op == 1) {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				if (num[x] != -INF && num[y] != -INF) {
+					int l = find(x);
+					int r = find(y);
+					if (l != r) {
+						father[l] = father[r] = merge(l, r);
+					}
+				}
+			} else {
+				in.nextToken();
+				x = (int) in.nval;
+				if (num[x] == -INF) {
+					out.println(-1);
+				} else {
+					int ans = find(x);
+					out.println(num[ans]);
+					pop(ans);
+				}
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
new file mode 100644
index 000000000..685fd8767
--- /dev/null
+++ b/src/class154/Code01_LeftistTree2.java
@@ -0,0 +1,89 @@
+package class154;
+
+// 左偏树模版，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3377
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int INF = 1000000001;
+//int num[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//
+//int find(int i) {
+//    if (fa[i] != i) {
+//        fa[i] = find(fa[i]);
+//    }
+//    return fa[i];
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    if (num[i] > num[j]) {
+//        int tmp = i;
+//        i = j;
+//        j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        int tmp = ls[i];
+//        ls[i] = rs[i];
+//        rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    return i;
+//}
+//
+//void pop(int i) {
+//    num[i] = -INF;
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    fa[i] = merge(ls[i], rs[i]);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n, m;
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        fa[i] = i;
+//        cin >> num[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        int op;
+//        cin >> op;
+//        if (op == 1) {
+//            int x, y;
+//            cin >> x >> y;
+//            if (num[x] != -INF && num[y] != -INF) {
+//                int l = find(x);
+//                int r = find(y);
+//                if (l != r) {
+//                    fa[l] = fa[r] = merge(l, r);
+//                }
+//            }
+//        } else {
+//            int x;
+//            cin >> x;
+//            if (num[x] == -INF) {
+//                cout << -1 << "\n";
+//            } else {
+//                int ans = find(x);
+//                cout << num[ans] << "\n";
+//                pop(ans);
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 62f4fee4c4521e864c62c6e00ce3905a6fb12a68 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Dec 2024 19:27:35 +0800
Subject: [PATCH 0197/1712] modify code

---
 src/class154/Code02_RomanGame1.java | 344 ++++++++++++++++++++++++++++
 src/class154/Code02_RomanGame2.java |  87 +++++++
 2 files changed, 431 insertions(+)
 create mode 100644 src/class154/Code02_RomanGame1.java
 create mode 100644 src/class154/Code02_RomanGame2.java

diff --git a/src/class154/Code02_RomanGame1.java b/src/class154/Code02_RomanGame1.java
new file mode 100644
index 000000000..4bdcf6c2d
--- /dev/null
+++ b/src/class154/Code02_RomanGame1.java
@@ -0,0 +1,344 @@
+package class154;
+
+// 罗马游戏，左偏树模版，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2713
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.InputMismatchException;
+
+public class Code02_RomanGame1 {
+
+	public static int MAXN = 1000001;
+
+	public static int INF = 1000000001;
+
+	public static int[] num = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int find(int i) {
+		if (father[i] != i) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (num[i] > num[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[i] = father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static void pop(int i) {
+		num[i] = -INF;
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		// 下面这一句的功能
+		// 因为有路径压缩，所以i下方的某个节点x，可能有father[x] = i
+		// 但是现在堆要去掉i了，所以x一直往上找到i是无效的
+		// 为了i能再往上找到正确的头，所以有下面这句
+		father[i] = merge(left[i], right[i]);
+	}
+
+	public static void main(String[] args) {
+		FastReader in = new FastReader(System.in);
+		FastWriter out = new FastWriter(System.out);
+		int n = in.readInt();
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			num[i] = in.readInt();
+		}
+		int m = in.readInt();
+		String op;
+		for (int i = 1, x, y; i <= m; i++) {
+			op = in.readString();
+			if (op.equals("M")) {
+				x = in.readInt();
+				y = in.readInt();
+				if (num[x] != -INF && num[y] != -INF) {
+					int l = find(x);
+					int r = find(y);
+					if (l != r) {
+						father[l] = father[r] = merge(l, r);
+					}
+				}
+			} else {
+				x = in.readInt();
+				if (num[x] == -INF) {
+					out.println(0);
+				} else {
+					int ans = find(x);
+					out.println(num[ans]);
+					pop(ans);
+				}
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 快读
+	public static class FastReader {
+		InputStream is;
+		private byte[] inbuf = new byte[1024];
+		public int lenbuf = 0;
+		public int ptrbuf = 0;
+
+		public FastReader(final InputStream is) {
+			this.is = is;
+		}
+
+		public String readString() {
+			char cur;
+			do {
+				cur = (char) readByte();
+			} while (cur == ' ' || cur == '\n');
+			StringBuilder builder = new StringBuilder();
+			while (cur != ' ' && cur != '\n') {
+				builder.append(cur);
+				cur = (char) readByte();
+			}
+			return builder.toString();
+		}
+
+		public int readByte() {
+			if (lenbuf == -1) {
+				throw new InputMismatchException();
+			}
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++];
+		}
+
+		public int readInt() {
+			return (int) readLong();
+		}
+
+		public long readLong() {
+			long num = 0;
+			int b;
+			boolean minus = false;
+			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+				;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+
+			while (true) {
+				if (b >= '0' && b <= '9') {
+					num = num * 10 + (b - '0');
+				} else {
+					return minus ? -num : num;
+				}
+				b = readByte();
+			}
+		}
+	}
+
+	// 快写
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private OutputStream out;
+		private Writer writer;
+		private int ptr = 0;
+
+		public FastWriter(Writer writer) {
+			this.writer = new BufferedWriter(writer);
+			out = new ByteArrayOutputStream();
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("FastWriter");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE) {
+				innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE) {
+					innerflush();
+				}
+			});
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L) {
+				return 19;
+			}
+			if (l >= 100000000000000000L) {
+				return 18;
+			}
+			if (l >= 10000000000000000L) {
+				return 17;
+			}
+			if (l >= 1000000000000000L) {
+				return 16;
+			}
+			if (l >= 100000000000000L) {
+				return 15;
+			}
+			if (l >= 10000000000000L) {
+				return 14;
+			}
+			if (l >= 1000000000000L) {
+				return 13;
+			}
+			if (l >= 100000000000L) {
+				return 12;
+			}
+			if (l >= 10000000000L) {
+				return 11;
+			}
+			if (l >= 1000000000L) {
+				return 10;
+			}
+			if (l >= 100000000L) {
+				return 9;
+			}
+			if (l >= 10000000L) {
+				return 8;
+			}
+			if (l >= 1000000L) {
+				return 7;
+			}
+			if (l >= 100000L) {
+				return 6;
+			}
+			if (l >= 10000L) {
+				return 5;
+			}
+			if (l >= 1000L) {
+				return 4;
+			}
+			if (l >= 100L) {
+				return 3;
+			}
+			if (l >= 10L) {
+				return 2;
+			}
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE) {
+				innerflush();
+			}
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException("innerflush");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				if (writer != null) {
+					writer.write(((ByteArrayOutputStream) out).toString());
+					out = new ByteArrayOutputStream();
+					writer.flush();
+				} else {
+					out.flush();
+				}
+			} catch (IOException e) {
+				throw new RuntimeException("flush");
+			}
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public void close() {
+			flush();
+			try {
+				out.close();
+			} catch (Exception e) {
+			}
+		}
+
+	}
+
+}
diff --git a/src/class154/Code02_RomanGame2.java b/src/class154/Code02_RomanGame2.java
new file mode 100644
index 000000000..87ee06b37
--- /dev/null
+++ b/src/class154/Code02_RomanGame2.java
@@ -0,0 +1,87 @@
+package class154;
+
+// 罗马游戏，左偏树模版，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2713
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//const int INF = 1000000001;
+//int num[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//
+//int find(int i) {
+//    if (fa[i] != i) {
+//        fa[i] = find(fa[i]);
+//    }
+//    return fa[i];
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    if (num[i] > num[j]) {
+//        int tmp = i;
+//        i = j;
+//        j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        int tmp = ls[i];
+//        ls[i] = rs[i];
+//        rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    return i;
+//}
+//
+//void pop(int i) {
+//    num[i] = -INF;
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    fa[i] = merge(ls[i], rs[i]);
+//}
+//
+//int main() {
+//    ios_base::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n; cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        fa[i] = i;
+//        cin >> num[i];
+//    }
+//    int m; cin >> m;
+//    for (int i = 1; i <= m; i++) {
+//        string op; cin >> op;
+//        if (op == "M") {
+//            int x, y; cin >> x >> y;
+//            if (num[x] != -INF && num[y] != -INF) {
+//                int l = find(x);
+//                int r = find(y);
+//                if (l != r) {
+//                    int rt = merge(l, r);
+//                    fa[l] = fa[r] = rt;
+//                }
+//            }
+//        } else {
+//            int x; cin >> x;
+//            if (num[x] == -INF) {
+//                cout << 0 << endl;
+//            } else {
+//                int ans = find(x);
+//                cout << num[ans] << endl;
+//                pop(ans);
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From afe62773f5666b2088ba5368634abf2dde2f8ec9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Dec 2024 19:29:23 +0800
Subject: [PATCH 0198/1712] modify code

---
 src/class154/Code02_RomanGame1.java | 2 +-
 src/class154/Code02_RomanGame2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class154/Code02_RomanGame1.java b/src/class154/Code02_RomanGame1.java
index 4bdcf6c2d..5c0a76cc6 100644
--- a/src/class154/Code02_RomanGame1.java
+++ b/src/class154/Code02_RomanGame1.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 罗马游戏，左偏树模版，java版
+// 罗马游戏，依然是左偏树模版，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class154/Code02_RomanGame2.java b/src/class154/Code02_RomanGame2.java
index 87ee06b37..3073ebf6a 100644
--- a/src/class154/Code02_RomanGame2.java
+++ b/src/class154/Code02_RomanGame2.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 罗马游戏，左偏树模版，C++版
+// 罗马游戏，依然是左偏树模版，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From d966b968daafd0defa853faeb406ee12177a5348 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Dec 2024 22:19:19 +0800
Subject: [PATCH 0199/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 16 ++---
 src/class154/Code01_LeftistTree2.java | 15 ++--
 src/class154/Code02_RomanGame1.java   | 20 +++---
 src/class154/Code02_RomanGame2.java   | 16 ++---
 src/class154/Code03_MonkeyKing1.java  | 99 +++++++++++++++++++++++++++
 src/class154/Code03_MonkeyKing2.java  | 80 ++++++++++++++++++++++
 6 files changed, 211 insertions(+), 35 deletions(-)
 create mode 100644 src/class154/Code03_MonkeyKing1.java
 create mode 100644 src/class154/Code03_MonkeyKing2.java

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index 6e4d863cb..a8f8027fc 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 左偏树模版，java版
+// 左偏树模版题1，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3377
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -15,8 +15,6 @@ public class Code01_LeftistTree1 {
 
 	public static int MAXN = 100001;
 
-	public static int INF = 1000000001;
-
 	public static int[] num = new int[MAXN];
 
 	public static int[] father = new int[MAXN];
@@ -55,8 +53,7 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
-	public static void pop(int i) {
-		num[i] = -INF;
+	public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		// 下面这一句的功能
@@ -64,6 +61,9 @@ public static void pop(int i) {
 		// 但是现在堆要去掉i了，所以x一直往上找到i是无效的
 		// 为了i能再往上找到正确的头，所以有下面这句
 		father[i] = merge(left[i], right[i]);
+		num[i] = -1;
+		left[i] = right[i] = 0;
+		return father[i];
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -87,17 +87,17 @@ public static void main(String[] args) throws IOException {
 				x = (int) in.nval;
 				in.nextToken();
 				y = (int) in.nval;
-				if (num[x] != -INF && num[y] != -INF) {
+				if (num[x] != -1 && num[y] != -1) {
 					int l = find(x);
 					int r = find(y);
 					if (l != r) {
-						father[l] = father[r] = merge(l, r);
+						merge(l, r);
 					}
 				}
 			} else {
 				in.nextToken();
 				x = (int) in.nval;
-				if (num[x] == -INF) {
+				if (num[x] == -1) {
 					out.println(-1);
 				} else {
 					int ans = find(x);
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index 685fd8767..ce54fd8c9 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 左偏树模版，C++版
+// 左偏树模版题1，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3377
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -10,7 +10,6 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
-//const int INF = 1000000001;
 //int num[MAXN];
 //int fa[MAXN];
 //int ls[MAXN];
@@ -44,11 +43,13 @@
 //    return i;
 //}
 //
-//void pop(int i) {
-//    num[i] = -INF;
+//int pop(int i) {
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
+//    num[i] = -1;
+//    ls[i] = rs[i] = 0;
+//    return fa[i];
 //}
 //
 //int main() {
@@ -66,17 +67,17 @@
 //        if (op == 1) {
 //            int x, y;
 //            cin >> x >> y;
-//            if (num[x] != -INF && num[y] != -INF) {
+//            if (num[x] != -1 && num[y] != -1) {
 //                int l = find(x);
 //                int r = find(y);
 //                if (l != r) {
-//                    fa[l] = fa[r] = merge(l, r);
+//                    merge(l, r);
 //                }
 //            }
 //        } else {
 //            int x;
 //            cin >> x;
-//            if (num[x] == -INF) {
+//            if (num[x] == -1) {
 //                cout << -1 << "\n";
 //            } else {
 //                int ans = find(x);
diff --git a/src/class154/Code02_RomanGame1.java b/src/class154/Code02_RomanGame1.java
index 5c0a76cc6..8023d0b22 100644
--- a/src/class154/Code02_RomanGame1.java
+++ b/src/class154/Code02_RomanGame1.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 罗马游戏，依然是左偏树模版，java版
+// 罗马游戏，左偏树模版题2，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -18,8 +18,6 @@ public class Code02_RomanGame1 {
 
 	public static int MAXN = 1000001;
 
-	public static int INF = 1000000001;
-
 	public static int[] num = new int[MAXN];
 
 	public static int[] father = new int[MAXN];
@@ -58,15 +56,13 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
-	public static void pop(int i) {
-		num[i] = -INF;
+	public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
-		// 下面这一句的功能
-		// 因为有路径压缩，所以i下方的某个节点x，可能有father[x] = i
-		// 但是现在堆要去掉i了，所以x一直往上找到i是无效的
-		// 为了i能再往上找到正确的头，所以有下面这句
 		father[i] = merge(left[i], right[i]);
+		num[i] = -1;
+		left[i] = right[i] = 0;
+		return father[i];
 	}
 
 	public static void main(String[] args) {
@@ -84,16 +80,16 @@ public static void main(String[] args) {
 			if (op.equals("M")) {
 				x = in.readInt();
 				y = in.readInt();
-				if (num[x] != -INF && num[y] != -INF) {
+				if (num[x] != -1 && num[y] != -1) {
 					int l = find(x);
 					int r = find(y);
 					if (l != r) {
-						father[l] = father[r] = merge(l, r);
+						merge(l, r);
 					}
 				}
 			} else {
 				x = in.readInt();
-				if (num[x] == -INF) {
+				if (num[x] == -1) {
 					out.println(0);
 				} else {
 					int ans = find(x);
diff --git a/src/class154/Code02_RomanGame2.java b/src/class154/Code02_RomanGame2.java
index 3073ebf6a..0e0a12f4e 100644
--- a/src/class154/Code02_RomanGame2.java
+++ b/src/class154/Code02_RomanGame2.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 罗马游戏，依然是左偏树模版，C++版
+// 罗马游戏，左偏树模版题2，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -10,7 +10,6 @@
 //using namespace std;
 //
 //const int MAXN = 1000001;
-//const int INF = 1000000001;
 //int num[MAXN];
 //int fa[MAXN];
 //int ls[MAXN];
@@ -44,11 +43,13 @@
 //    return i;
 //}
 //
-//void pop(int i) {
-//    num[i] = -INF;
+//int pop(int i) {
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
+//    num[i] = -1;
+//    ls[i] = rs[i] = 0;
+//    return fa[i];
 //}
 //
 //int main() {
@@ -64,17 +65,16 @@
 //        string op; cin >> op;
 //        if (op == "M") {
 //            int x, y; cin >> x >> y;
-//            if (num[x] != -INF && num[y] != -INF) {
+//            if (num[x] != -1 && num[y] != -1) {
 //                int l = find(x);
 //                int r = find(y);
 //                if (l != r) {
-//                    int rt = merge(l, r);
-//                    fa[l] = fa[r] = rt;
+//                    merge(l, r);
 //                }
 //            }
 //        } else {
 //            int x; cin >> x;
-//            if (num[x] == -INF) {
+//            if (num[x] == -1) {
 //                cout << 0 << endl;
 //            } else {
 //                int ans = find(x);
diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
new file mode 100644
index 000000000..8dda6c6a5
--- /dev/null
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -0,0 +1,99 @@
+package class154;
+
+// 猴王，左偏树模版题3，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1456
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code03_MonkeyKing1 {
+
+	public static int MAXN = 100001;
+
+	public static int[] num = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int find(int i) {
+		if (father[i] != i) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		// 本题是维护大根堆
+		if (num[i] < num[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[i] = father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static int pop(int i) {
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		father[i] = merge(left[i], right[i]);
+		num[i] /= 2; // 根据题目要求，这里是除以2
+		left[i] = right[i] = 0;
+		return father[i];
+	}
+
+	public static int fight(int x, int y) {
+		int l = find(x);
+		int r = find(y);
+		return l == r ? -1 : num[merge(merge(pop(l), l), merge(pop(r), r))];
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			int n = (int) in.nval;
+			for (int i = 1; i <= n; i++) {
+				father[i] = i;
+				left[i] = right[i] = dist[i] = 0;
+				in.nextToken();
+				num[i] = (int) in.nval;
+			}
+			in.nextToken();
+			int m = (int) in.nval;
+			for (int i = 1, x, y; i <= m; i++) {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				System.out.println(fight(x, y));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
new file mode 100644
index 000000000..15454ebcd
--- /dev/null
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -0,0 +1,80 @@
+package class154;
+
+// 猴王，左偏树模版题3，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P1456
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int num[MAXN];
+//int fa[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//
+//int find(int i) {
+//    if (fa[i] != i) {
+//        fa[i] = find(fa[i]);
+//    }
+//    return fa[i];
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    int tmp;
+//    if (num[i] < num[j]) {
+//        tmp = i;
+//        i = j;
+//        j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        tmp = ls[i];
+//        ls[i] = rs[i];
+//        rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    return i;
+//}
+//
+//int pop(int i) {
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    fa[i] = merge(ls[i], rs[i]);
+//    num[i] /= 2;
+//    ls[i] = rs[i] = 0;
+//    return fa[i];
+//}
+//
+//int fight(int x, int y) {
+//    int l = find(x);
+//    int r = find(y);
+//    return l == r ? -1 : num[merge(merge(pop(l), l), merge(pop(r), r))];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n, m;
+//    while (cin >> n) {
+//        for (int i = 1; i <= n; i++) {
+//            fa[i] = i;
+//            ls[i] = rs[i] = dist[i] = 0;
+//            cin >> num[i];
+//        }
+//        cin >> m;
+//        for (int i = 1; i <= m; i++) {
+//            int x, y;
+//            cin >> x >> y;
+//            cout << fight(x, y) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 239073167f2d18bf5a88d81c83873cad1340fd6e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Dec 2024 22:44:02 +0800
Subject: [PATCH 0200/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 6 ++++--
 src/class154/Code01_LeftistTree2.java | 2 +-
 src/class154/Code02_RomanGame1.java   | 4 ++--
 src/class154/Code02_RomanGame2.java   | 2 +-
 src/class154/Code03_MonkeyKing1.java  | 4 ++--
 src/class154/Code03_MonkeyKing2.java  | 2 +-
 6 files changed, 11 insertions(+), 9 deletions(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index a8f8027fc..397ad3c28 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -15,16 +15,18 @@ public class Code01_LeftistTree1 {
 
 	public static int MAXN = 100001;
 
+	// 左偏树需要
 	public static int[] num = new int[MAXN];
 
-	public static int[] father = new int[MAXN];
-
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
 	public static int[] dist = new int[MAXN];
 
+	// 并查集需要
+	public static int[] father = new int[MAXN];
+
 	public static int find(int i) {
 		if (father[i] != i) {
 			father[i] = find(father[i]);
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index ce54fd8c9..27b2f6717 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -11,10 +11,10 @@
 //
 //const int MAXN = 100001;
 //int num[MAXN];
-//int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int dist[MAXN];
+//int fa[MAXN];
 //
 //int find(int i) {
 //    if (fa[i] != i) {
diff --git a/src/class154/Code02_RomanGame1.java b/src/class154/Code02_RomanGame1.java
index 8023d0b22..0362351f9 100644
--- a/src/class154/Code02_RomanGame1.java
+++ b/src/class154/Code02_RomanGame1.java
@@ -20,14 +20,14 @@ public class Code02_RomanGame1 {
 
 	public static int[] num = new int[MAXN];
 
-	public static int[] father = new int[MAXN];
-
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
 	public static int[] dist = new int[MAXN];
 
+	public static int[] father = new int[MAXN];
+
 	public static int find(int i) {
 		if (father[i] != i) {
 			father[i] = find(father[i]);
diff --git a/src/class154/Code02_RomanGame2.java b/src/class154/Code02_RomanGame2.java
index 0e0a12f4e..d82302d70 100644
--- a/src/class154/Code02_RomanGame2.java
+++ b/src/class154/Code02_RomanGame2.java
@@ -11,10 +11,10 @@
 //
 //const int MAXN = 1000001;
 //int num[MAXN];
-//int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int dist[MAXN];
+//int fa[MAXN];
 //
 //int find(int i) {
 //    if (fa[i] != i) {
diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
index 8dda6c6a5..f2f7429cb 100644
--- a/src/class154/Code03_MonkeyKing1.java
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -17,14 +17,14 @@ public class Code03_MonkeyKing1 {
 
 	public static int[] num = new int[MAXN];
 
-	public static int[] father = new int[MAXN];
-
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
 	public static int[] dist = new int[MAXN];
 
+	public static int[] father = new int[MAXN];
+
 	public static int find(int i) {
 		if (father[i] != i) {
 			father[i] = find(father[i]);
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
index 15454ebcd..2007b68c4 100644
--- a/src/class154/Code03_MonkeyKing2.java
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -11,10 +11,10 @@
 //
 //const int MAXN = 100001;
 //int num[MAXN];
-//int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int dist[MAXN];
+//int fa[MAXN];
 //
 //int find(int i) {
 //    if (fa[i] != i) {

From 1d6e4e9361b0db726c4f0a4a8eb6d4a361244a53 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 10 Dec 2024 17:42:29 +0800
Subject: [PATCH 0201/1712] modify code

---
 src/class154/Code04_Dispatch1.java | 169 ++++++++++++++++++++++++++
 src/class154/Code04_Dispatch2.java | 188 +++++++++++++++++++++++++++++
 src/class154/Code04_Dispatch3.java | 124 +++++++++++++++++++
 3 files changed, 481 insertions(+)
 create mode 100644 src/class154/Code04_Dispatch1.java
 create mode 100644 src/class154/Code04_Dispatch2.java
 create mode 100644 src/class154/Code04_Dispatch3.java

diff --git a/src/class154/Code04_Dispatch1.java b/src/class154/Code04_Dispatch1.java
new file mode 100644
index 000000000..410cba3fe
--- /dev/null
+++ b/src/class154/Code04_Dispatch1.java
@@ -0,0 +1,169 @@
+package class154;
+
+// 派遣，dfs用递归实现，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1552
+// 提交以下的code，提交时请把类名改成"Main"，会有一些测试用例通过不了
+// 这是因为java语言用递归方式实现dfs，递归会爆栈
+// 需要把dfs实现成迭代版，才能全部通过，就是Code04_Dispatch2文件
+// 但是C++语言用递归方式实现，可以直接通过，就是Code04_Dispatch3文件
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_Dispatch1 {
+
+	public static int MAXN = 100001;
+
+	public static int n, m;
+
+	public static long ans;
+
+	// 链式前向星需要
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN];
+
+	public static int[] to = new int[MAXN];
+
+	public static int cnt;
+
+	// 薪水
+	public static long[] cost = new long[MAXN];
+
+	// 领导力
+	public static long[] lead = new long[MAXN];
+
+	// 左孩子
+	public static int[] left = new int[MAXN];
+
+	// 右孩子
+	public static int[] right = new int[MAXN];
+
+	// 距离
+	public static int[] dist = new int[MAXN];
+
+	// 寻找堆顶需要
+	public static int[] father = new int[MAXN];
+
+	// 堆的大小
+	public static int[] size = new int[MAXN];
+
+	// 堆的费用和
+	public static long[] sum = new long[MAXN];
+
+	public static void prepare() {
+		ans = 0;
+		cnt = 1;
+		for (int i = 1; i <= n; i++) {
+			head[i] = left[i] = right[i] = dist[i] = size[i] = 0;
+			sum[i] = 0;
+			father[i] = i;
+		}
+	}
+
+	public static void addEdge(int u, int v) {
+		next[cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt++;
+	}
+
+	public static int find(int i) {
+		if (father[i] != i) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		// 本题是维护大根堆
+		if (cost[i] < cost[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[i] = father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static int pop(int i) {
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		father[i] = merge(left[i], right[i]);
+		left[i] = right[i] = 0;
+		return father[i];
+	}
+
+	// dfs用递归实现
+	public static void dfs(int u) {
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			dfs(to[ei]);
+		}
+		int usize = 1;
+		long usum = cost[u];
+		for (int ei = head[u], v, l, r; ei > 0; ei = next[ei]) {
+			v = to[ei];
+			l = find(u);
+			r = find(v);
+			usize += size[r];
+			usum += sum[r];
+			merge(l, r);
+		}
+		int i;
+		while (usum > m) {
+			i = find(u);
+			usize--;
+			usum -= cost[i];
+			pop(i);
+		}
+		i = find(u);
+		size[i] = usize;
+		sum[i] = usum;
+		ans = Math.max(ans, (long) usize * lead[u]);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		prepare();
+		int root = 0;
+		for (int i = 1, f; i <= n; i++) {
+			in.nextToken();
+			f = (int) in.nval;
+			in.nextToken();
+			cost[i] = (int) in.nval;
+			in.nextToken();
+			lead[i] = (int) in.nval;
+			if (f == 0) {
+				root = i;
+			} else {
+				addEdge(f, i);
+			}
+		}
+		dfs(root);
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class154/Code04_Dispatch2.java b/src/class154/Code04_Dispatch2.java
new file mode 100644
index 000000000..6e871b31a
--- /dev/null
+++ b/src/class154/Code04_Dispatch2.java
@@ -0,0 +1,188 @@
+package class154;
+
+// 派遣，dfs用迭代实现，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1552
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_Dispatch2 {
+
+	public static int MAXN = 100001;
+
+	public static int n, m;
+
+	public static long ans;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN];
+
+	public static int[] to = new int[MAXN];
+
+	public static int cnt;
+
+	public static long[] cost = new long[MAXN];
+
+	public static long[] lead = new long[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static long[] sum = new long[MAXN];
+
+	public static void prepare() {
+		ans = 0;
+		cnt = 1;
+		for (int i = 1; i <= n; i++) {
+			head[i] = left[i] = right[i] = dist[i] = size[i] = 0;
+			sum[i] = 0;
+			father[i] = i;
+		}
+	}
+
+	public static void addEdge(int u, int v) {
+		next[cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt++;
+	}
+
+	public static int find(int i) {
+		if (father[i] != i) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (cost[i] < cost[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[i] = father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static int pop(int i) {
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		father[i] = merge(left[i], right[i]);
+		left[i] = right[i] = 0;
+		return father[i];
+	}
+
+	// dfs从递归版改成迭代版，不会看讲解118
+	// 重点讲了树上问题从递归改成迭代版的方法
+	public static int[][] ue = new int[MAXN][2];
+
+	public static int u, ei;
+
+	public static int ssize;
+
+	public static void push(int u, int ei) {
+		ue[ssize][0] = u;
+		ue[ssize][1] = ei;
+		ssize++;
+	}
+
+	public static void pop() {
+		--ssize;
+		u = ue[ssize][0];
+		ei = ue[ssize][1];
+	}
+
+	// dfs用迭代实现
+	public static void dfs(int root) {
+		ssize = 0;
+		push(root, -1);
+		while (ssize > 0) {
+			pop();
+			if (ei == -1) {
+				ei = head[u];
+			} else {
+				ei = next[ei];
+			}
+			if (ei > 0) {
+				push(u, ei);
+				push(to[ei], -1);
+			} else {
+				int usize = 1;
+				long usum = cost[u];
+				for (int ei = head[u], v, l, r; ei > 0; ei = next[ei]) {
+					v = to[ei];
+					l = find(u);
+					r = find(v);
+					usize += size[r];
+					usum += sum[r];
+					merge(l, r);
+				}
+				int i;
+				while (usum > m) {
+					i = find(u);
+					usize--;
+					usum -= cost[i];
+					pop(i);
+				}
+				i = find(u);
+				size[i] = usize;
+				sum[i] = usum;
+				ans = Math.max(ans, (long) usize * lead[u]);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		prepare();
+		int root = 0;
+		for (int i = 1, f; i <= n; i++) {
+			in.nextToken();
+			f = (int) in.nval;
+			in.nextToken();
+			cost[i] = (int) in.nval;
+			in.nextToken();
+			lead[i] = (int) in.nval;
+			if (f == 0) {
+				root = i;
+			} else {
+				addEdge(f, i);
+			}
+		}
+		dfs(root);
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class154/Code04_Dispatch3.java b/src/class154/Code04_Dispatch3.java
new file mode 100644
index 000000000..15d117938
--- /dev/null
+++ b/src/class154/Code04_Dispatch3.java
@@ -0,0 +1,124 @@
+package class154;
+
+// 派遣，dfs用递归实现，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P1552
+// 逻辑和java的递归版完全一样，java的递归版就过不了，C++的递归版就能过
+// 这是洛谷没有考虑其他语言导致的，提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//long long ans;
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cnt;
+//long long cost[MAXN];
+//long long lead[MAXN];
+//int ls[MAXN];  
+//int rs[MAXN];  
+//int dist[MAXN];
+//int father[MAXN];
+//int siz[MAXN];  
+//long long sum[MAXN]; 
+//
+//void prepare() {
+//    ans = 0;
+//    cnt = 1;
+//    for (int i = 1; i <= n; i++) {
+//        head[i] = ls[i] = rs[i] = dist[i] = siz[i] = 0;
+//        sum[i] = 0;
+//        father[i] = i;
+//    }
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt++;
+//}
+//
+//int find(int i) {
+//    if (father[i] != i) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    if (cost[i] < cost[j]) {
+//        int tmp = i;
+//        i = j;
+//        j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        int tmp = ls[i];
+//        ls[i] = rs[i];
+//        rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    father[i] = father[ls[i]] = father[rs[i]] = i;
+//    return i;
+//}
+//
+//int pop(int i) {
+//    father[ls[i]] = ls[i];
+//    father[rs[i]] = rs[i];
+//    father[i] = merge(ls[i], rs[i]);
+//    ls[i] = rs[i] = 0;
+//    return father[i];
+//}
+//
+//void dfs(int u) {
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+//        dfs(to[ei]);
+//    }
+//    int usize = 1;
+//    long long usum = cost[u];
+//    for (int ei = head[u], v, l, r; ei > 0; ei = nxt[ei]) {
+//        v = to[ei];
+//        l = find(u);
+//        r = find(v);
+//        usize += siz[r];
+//        usum += sum[r];
+//        merge(l, r);
+//    }
+//    int i;
+//    while (usum > m) {
+//        i = find(u);
+//        usize--;
+//        usum -= cost[i];
+//        pop(i);
+//    }
+//    i = find(u);
+//    siz[i] = usize;
+//    sum[i] = usum;
+//    ans = max(ans, (long long)usize * lead[u]);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    prepare();
+//    int root = 0;
+//    for (int i = 1; i <= n; i++) {
+//        int f;
+//        cin >> f >> cost[i] >> lead[i];
+//        if (f == 0) {
+//            root = i;
+//        } else {
+//            addEdge(f, i);
+//        }
+//    }
+//    dfs(root);
+//    cout << ans << endl;
+//    return 0;
+//}
\ No newline at end of file

From 7c7d18d7a4c57ba3f25798f42c525f7f54982978 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 11 Dec 2024 10:07:13 +0800
Subject: [PATCH 0202/1712] modify code

---
 src/class154/Code04_Dispatch2.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class154/Code04_Dispatch2.java b/src/class154/Code04_Dispatch2.java
index 6e871b31a..4588627ef 100644
--- a/src/class154/Code04_Dispatch2.java
+++ b/src/class154/Code04_Dispatch2.java
@@ -95,8 +95,8 @@ public static int pop(int i) {
 		return father[i];
 	}
 
-	// dfs从递归版改成迭代版，不会看讲解118
-	// 重点讲了树上问题从递归改成迭代版的方法
+	// dfs从递归版改成迭代版，不会的话，看讲解118
+	// 重点讲了树上问题从递归版改成迭代版的方法
 	public static int[][] ue = new int[MAXN][2];
 
 	public static int u, ei;

From 706dae3ab601b76a1847c55521e4bf377ec9f521 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 11 Dec 2024 13:57:53 +0800
Subject: [PATCH 0203/1712] modify code

---
 src/class154/Code05_CityCapture1.java | 405 ++++++++++++++++++++++++++
 src/class154/Code05_CityCapture2.java | 156 ++++++++++
 2 files changed, 561 insertions(+)
 create mode 100644 src/class154/Code05_CityCapture1.java
 create mode 100644 src/class154/Code05_CityCapture2.java

diff --git a/src/class154/Code05_CityCapture1.java b/src/class154/Code05_CityCapture1.java
new file mode 100644
index 000000000..a40e33355
--- /dev/null
+++ b/src/class154/Code05_CityCapture1.java
@@ -0,0 +1,405 @@
+package class154;
+
+// 城池攻占，java版
+// 不和并查集结合，和懒更新结合，
+// 输入保证，如果城市a管辖城市b，必有a < b
+// 测试链接 : https://www.luogu.com.cn/problem/P3261
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.InputMismatchException;
+
+public class Code05_CityCapture1 {
+
+	public static int MAXN = 300001;
+
+	public static int n, m;
+
+	public static long[] defend = new long[MAXN];
+
+	public static int[] belong = new int[MAXN];
+
+	public static int[] op = new int[MAXN];
+
+	public static long[] gain = new long[MAXN];
+
+	public static int[] deep = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static int[] sacrifice = new int[MAXN];
+
+	public static long[] attack = new long[MAXN];
+
+	public static int[] born = new int[MAXN];
+
+	public static int[] die = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static long[] mul = new long[MAXN];
+
+	public static long[] add = new long[MAXN];
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sacrifice[i] = top[i] = 0;
+		}
+		for (int i = 1; i <= m; i++) {
+			left[i] = right[i] = dist[i] = 0;
+			mul[i] = 1;
+			add[i] = 0;
+		}
+	}
+
+	public static void down(int i) {
+		if (mul[i] != 1 || add[i] != 0) {
+			int l = left[i];
+			int r = right[i];
+			if (l != 0) {
+				attack[l] = attack[l] * mul[i] + add[i];
+				mul[l] *= mul[i];
+				add[l] = add[l] * mul[i] + add[i];
+			}
+			if (r != 0) {
+				attack[r] = attack[r] * mul[i] + add[i];
+				mul[r] *= mul[i];
+				add[r] = add[r] * mul[i] + add[i];
+			}
+			mul[i] = 1;
+			add[i] = 0;
+		}
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (attack[i] > attack[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		down(i);
+		down(j);
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		return i;
+	}
+
+	public static int pop(int i) {
+		down(i);
+		int ans = merge(left[i], right[i]);
+		left[i] = right[i] = 0;
+		return ans;
+	}
+
+	public static void upgrade(int i, int t, long v) {
+		if (t == 0) {
+			add[i] += v;
+			attack[i] += v;
+		} else {
+			mul[i] *= v;
+			add[i] *= v;
+			attack[i] *= v;
+		}
+	}
+
+	public static void compute() {
+		deep[1] = 1;
+		for (int i = 2; i <= n; i++) {
+			deep[i] = deep[belong[i]] + 1;
+		}
+		for (int i = 1; i <= m; i++) {
+			if (top[born[i]] == 0) {
+				top[born[i]] = i;
+			} else {
+				top[born[i]] = merge(top[born[i]], i);
+			}
+		}
+		for (int i = n; i >= 1; i--) {
+			while (top[i] != 0 && attack[top[i]] < defend[i]) {
+				die[top[i]] = i;
+				sacrifice[i]++;
+				top[i] = pop(top[i]);
+			}
+			if (top[i] != 0) {
+				upgrade(top[i], op[i], gain[i]);
+				if (top[belong[i]] == 0) {
+					top[belong[i]] = top[i];
+				} else {
+					top[belong[i]] = merge(top[belong[i]], top[i]);
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		FastReader in = new FastReader(System.in);
+		FastWriter out = new FastWriter(System.out);
+		n = in.readInt();
+		m = in.readInt();
+		prepare();
+		for (int i = 1; i <= n; i++) {
+			defend[i] = in.readLong();
+		}
+		for (int i = 2; i <= n; i++) {
+			belong[i] = in.readInt();
+			op[i] = in.readInt();
+			gain[i] = in.readLong();
+		}
+		for (int i = 1; i <= m; i++) {
+			attack[i] = in.readLong();
+			born[i] = in.readInt();
+		}
+		compute();
+		for (int i = 1; i <= n; i++) {
+			out.println(sacrifice[i]);
+		}
+		for (int i = 1; i <= m; i++) {
+			out.println(deep[born[i]] - deep[die[i]]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 快读
+	public static class FastReader {
+		InputStream is;
+		private byte[] inbuf = new byte[1024];
+		public int lenbuf = 0;
+		public int ptrbuf = 0;
+
+		public FastReader(final InputStream is) {
+			this.is = is;
+		}
+
+		public int readByte() {
+			if (lenbuf == -1) {
+				throw new InputMismatchException();
+			}
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++];
+		}
+
+		public int readInt() {
+			return (int) readLong();
+		}
+
+		public long readLong() {
+			long num = 0;
+			int b;
+			boolean minus = false;
+			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+				;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+
+			while (true) {
+				if (b >= '0' && b <= '9') {
+					num = num * 10 + (b - '0');
+				} else {
+					return minus ? -num : num;
+				}
+				b = readByte();
+			}
+		}
+	}
+
+	// 快写
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private OutputStream out;
+		private Writer writer;
+		private int ptr = 0;
+
+		public FastWriter(Writer writer) {
+			this.writer = new BufferedWriter(writer);
+			out = new ByteArrayOutputStream();
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("FastWriter");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE) {
+				innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE) {
+					innerflush();
+				}
+			});
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L) {
+				return 19;
+			}
+			if (l >= 100000000000000000L) {
+				return 18;
+			}
+			if (l >= 10000000000000000L) {
+				return 17;
+			}
+			if (l >= 1000000000000000L) {
+				return 16;
+			}
+			if (l >= 100000000000000L) {
+				return 15;
+			}
+			if (l >= 10000000000000L) {
+				return 14;
+			}
+			if (l >= 1000000000000L) {
+				return 13;
+			}
+			if (l >= 100000000000L) {
+				return 12;
+			}
+			if (l >= 10000000000L) {
+				return 11;
+			}
+			if (l >= 1000000000L) {
+				return 10;
+			}
+			if (l >= 100000000L) {
+				return 9;
+			}
+			if (l >= 10000000L) {
+				return 8;
+			}
+			if (l >= 1000000L) {
+				return 7;
+			}
+			if (l >= 100000L) {
+				return 6;
+			}
+			if (l >= 10000L) {
+				return 5;
+			}
+			if (l >= 1000L) {
+				return 4;
+			}
+			if (l >= 100L) {
+				return 3;
+			}
+			if (l >= 10L) {
+				return 2;
+			}
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE) {
+				innerflush();
+			}
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException("innerflush");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				if (writer != null) {
+					writer.write(((ByteArrayOutputStream) out).toString());
+					out = new ByteArrayOutputStream();
+					writer.flush();
+				} else {
+					out.flush();
+				}
+			} catch (IOException e) {
+				throw new RuntimeException("flush");
+			}
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public void close() {
+			flush();
+			try {
+				out.close();
+			} catch (Exception e) {
+			}
+		}
+
+	}
+
+}
diff --git a/src/class154/Code05_CityCapture2.java b/src/class154/Code05_CityCapture2.java
new file mode 100644
index 000000000..57862e49a
--- /dev/null
+++ b/src/class154/Code05_CityCapture2.java
@@ -0,0 +1,156 @@
+package class154;
+
+// 城池攻占，C++版
+// 输入保证，如果城市a管辖城市b，必有a < b
+// 测试链接 : https://www.luogu.com.cn/problem/P3261
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//int n, m;
+//long long defend[MAXN];
+//int belong[MAXN];
+//int op[MAXN];       
+//long long gain[MAXN];
+//int deep[MAXN];
+//int top[MAXN];
+//int sacrifice[MAXN];
+//long long attack[MAXN];
+//int born[MAXN];
+//int die[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//long long mul[MAXN];
+//long long add[MAXN];
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sacrifice[i] = 0;
+//        top[i] = 0;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        ls[i] = 0;
+//        rs[i] = 0;
+//        dist[i] = 0;
+//        mul[i] = 1;
+//        add[i] = 0;
+//    }
+//}
+//
+//void down(int i) {
+//    if (mul[i] != 1 || add[i] != 0) {
+//        int l = ls[i];
+//        int r = rs[i];
+//        if (l != 0) {
+//            attack[l] = attack[l] * mul[i] + add[i];
+//            mul[l] *= mul[i];
+//            add[l] = add[l] * mul[i] + add[i];
+//        }
+//        if (r != 0) {
+//            attack[r] = attack[r] * mul[i] + add[i];
+//            mul[r] *= mul[i];
+//            add[r] = add[r] * mul[i] + add[i];
+//        }
+//        mul[i] = 1;
+//        add[i] = 0;
+//    }
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    int tmp;
+//    if (attack[i] > attack[j]) {
+//        tmp = i;
+//        i = j;
+//        j = tmp;
+//    }
+//    down(i);
+//    down(j);
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        tmp = ls[i];
+//        ls[i] = rs[i];
+//        rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    return i;
+//}
+//
+//int pop(int i) {
+//    down(i);
+//    int ans = merge(ls[i], rs[i]);
+//    ls[i] = 0;
+//    rs[i] = 0;
+//    return ans;
+//}
+//
+//void upgrade(int i, int t, long long v) {
+//    if (t == 0) {
+//        add[i] += v;
+//        attack[i] += v;
+//    } else {
+//        mul[i] *= v;
+//        add[i] = add[i] * v;
+//        attack[i] = attack[i] * v;
+//    }
+//}
+//
+//void compute() {
+//    deep[1] = 1;
+//    for (int i = 2; i <= n; i++) {
+//        deep[i] = deep[belong[i]] + 1;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (top[born[i]] == 0) {
+//            top[born[i]] = i;
+//        } else {
+//            top[born[i]] = merge(top[born[i]], i);
+//        }
+//    }
+//    for (int i = n; i >= 1; i--) {
+//        while (top[i] != 0 && attack[top[i]] < defend[i]) {
+//            die[top[i]] = i;
+//            sacrifice[i]++;
+//            top[i] = pop(top[i]);
+//        }
+//        if (top[i] != 0) {
+//            upgrade(top[i], op[i], gain[i]);
+//            if (top[belong[i]] == 0) {
+//                top[belong[i]] = top[i];
+//            } else {
+//                top[belong[i]] = merge(top[belong[i]], top[i]);
+//            }
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    prepare();
+//    for (int i = 1; i <= n; i++) {
+//        cin >> defend[i];
+//    }
+//    for (int i = 2; i <= n; i++) {
+//        cin >> belong[i] >> op[i] >> gain[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> attack[i] >> born[i];
+//    }
+//    compute();
+//    for (int i = 1; i <= n; i++) {
+//        cout << sacrifice[i] << "\n";
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cout << deep[born[i]] - deep[die[i]] << endl;
+//    }
+//    return 0;
+//}
\ No newline at end of file

From c433c487acf1511ca5c6189b97b2d355d24a49d5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 11 Dec 2024 19:19:00 +0800
Subject: [PATCH 0204/1712] modify code

---
 src/class154/Code03_MonkeyKing1.java                      | 2 +-
 src/class154/Code03_MonkeyKing2.java                      | 2 +-
 src/class154/Code04_Convict1.java                         | 8 ++++++++
 src/class154/Code05_NumberSequence1.java                  | 8 ++++++++
 .../{Code04_Dispatch1.java => Code06_Dispatch1.java}      | 6 +++---
 .../{Code04_Dispatch2.java => Code06_Dispatch2.java}      | 2 +-
 .../{Code04_Dispatch3.java => Code06_Dispatch3.java}      | 0
 .../Code01_CityCapture1.java}                             | 4 ++--
 .../Code01_CityCapture2.java}                             | 2 +-
 9 files changed, 25 insertions(+), 9 deletions(-)
 create mode 100644 src/class154/Code04_Convict1.java
 create mode 100644 src/class154/Code05_NumberSequence1.java
 rename src/class154/{Code04_Dispatch1.java => Code06_Dispatch1.java} (97%)
 rename src/class154/{Code04_Dispatch2.java => Code06_Dispatch2.java} (99%)
 rename src/class154/{Code04_Dispatch3.java => Code06_Dispatch3.java} (100%)
 rename src/{class154/Code05_CityCapture1.java => class155/Code01_CityCapture1.java} (99%)
 rename src/{class154/Code05_CityCapture2.java => class155/Code01_CityCapture2.java} (99%)

diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
index f2f7429cb..c267c7f11 100644
--- a/src/class154/Code03_MonkeyKing1.java
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 猴王，左偏树模版题3，java版
+// 猴王，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P1456
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
index 2007b68c4..a6f63ef62 100644
--- a/src/class154/Code03_MonkeyKing2.java
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 猴王，左偏树模版题3，C++版
+// 猴王，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P1456
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class154/Code04_Convict1.java b/src/class154/Code04_Convict1.java
new file mode 100644
index 000000000..8c32cbda3
--- /dev/null
+++ b/src/class154/Code04_Convict1.java
@@ -0,0 +1,8 @@
+package class154;
+
+// 断罪者，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4971
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+public class Code04_Convict1 {
+
+}
diff --git a/src/class154/Code05_NumberSequence1.java b/src/class154/Code05_NumberSequence1.java
new file mode 100644
index 000000000..e2a8a9026
--- /dev/null
+++ b/src/class154/Code05_NumberSequence1.java
@@ -0,0 +1,8 @@
+package class154;
+
+// 数字序列，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4331
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+public class Code05_NumberSequence1 {
+
+}
diff --git a/src/class154/Code04_Dispatch1.java b/src/class154/Code06_Dispatch1.java
similarity index 97%
rename from src/class154/Code04_Dispatch1.java
rename to src/class154/Code06_Dispatch1.java
index 410cba3fe..1e4fea156 100644
--- a/src/class154/Code04_Dispatch1.java
+++ b/src/class154/Code06_Dispatch1.java
@@ -4,8 +4,8 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
 // 提交以下的code，提交时请把类名改成"Main"，会有一些测试用例通过不了
 // 这是因为java语言用递归方式实现dfs，递归会爆栈
-// 需要把dfs实现成迭代版，才能全部通过，就是Code04_Dispatch2文件
-// 但是C++语言用递归方式实现，可以直接通过，就是Code04_Dispatch3文件
+// 需要把dfs实现成迭代版，才能全部通过，就是Code06_Dispatch2文件
+// 但是C++语言用递归方式实现，可以直接通过，就是Code06_Dispatch3文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_Dispatch1 {
+public class Code06_Dispatch1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code04_Dispatch2.java b/src/class154/Code06_Dispatch2.java
similarity index 99%
rename from src/class154/Code04_Dispatch2.java
rename to src/class154/Code06_Dispatch2.java
index 4588627ef..07edd9e46 100644
--- a/src/class154/Code04_Dispatch2.java
+++ b/src/class154/Code06_Dispatch2.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_Dispatch2 {
+public class Code06_Dispatch2 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code04_Dispatch3.java b/src/class154/Code06_Dispatch3.java
similarity index 100%
rename from src/class154/Code04_Dispatch3.java
rename to src/class154/Code06_Dispatch3.java
diff --git a/src/class154/Code05_CityCapture1.java b/src/class155/Code01_CityCapture1.java
similarity index 99%
rename from src/class154/Code05_CityCapture1.java
rename to src/class155/Code01_CityCapture1.java
index a40e33355..a6c27f09f 100644
--- a/src/class154/Code05_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -1,4 +1,4 @@
-package class154;
+package class155;
 
 // 城池攻占，java版
 // 不和并查集结合，和懒更新结合，
@@ -16,7 +16,7 @@
 import java.io.Writer;
 import java.util.InputMismatchException;
 
-public class Code05_CityCapture1 {
+public class Code01_CityCapture1 {
 
 	public static int MAXN = 300001;
 
diff --git a/src/class154/Code05_CityCapture2.java b/src/class155/Code01_CityCapture2.java
similarity index 99%
rename from src/class154/Code05_CityCapture2.java
rename to src/class155/Code01_CityCapture2.java
index 57862e49a..697df738b 100644
--- a/src/class154/Code05_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -1,4 +1,4 @@
-package class154;
+package class155;
 
 // 城池攻占，C++版
 // 输入保证，如果城市a管辖城市b，必有a < b

From 16ca6aa93bcb07e5af950f53937901f925b7cc8d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 11 Dec 2024 19:20:14 +0800
Subject: [PATCH 0205/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index a6c27f09f..a11093864 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -1,7 +1,6 @@
 package class155;
 
 // 城池攻占，java版
-// 不和并查集结合，和懒更新结合，
 // 输入保证，如果城市a管辖城市b，必有a < b
 // 测试链接 : https://www.luogu.com.cn/problem/P3261
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From 28e1683b0401d872aaaef9c22c047814ec46daa9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 11 Dec 2024 23:08:01 +0800
Subject: [PATCH 0206/1712] modify code

---
 ...6_Dispatch1.java => Code05_Dispatch1.java} |   8 +-
 ...6_Dispatch2.java => Code05_Dispatch2.java} |   2 +-
 ...6_Dispatch3.java => Code05_Dispatch3.java} |   2 +-
 src/class154/Code05_NumberSequence1.java      |   8 -
 src/class154/Code06_NumberSequence1.java      | 364 ++++++++++++++++++
 src/class154/Code06_NumberSequence2.java      | 114 ++++++
 6 files changed, 484 insertions(+), 14 deletions(-)
 rename src/class154/{Code06_Dispatch1.java => Code05_Dispatch1.java} (93%)
 rename src/class154/{Code06_Dispatch2.java => Code05_Dispatch2.java} (99%)
 rename src/class154/{Code06_Dispatch3.java => Code05_Dispatch3.java} (96%)
 delete mode 100644 src/class154/Code05_NumberSequence1.java
 create mode 100644 src/class154/Code06_NumberSequence1.java
 create mode 100644 src/class154/Code06_NumberSequence2.java

diff --git a/src/class154/Code06_Dispatch1.java b/src/class154/Code05_Dispatch1.java
similarity index 93%
rename from src/class154/Code06_Dispatch1.java
rename to src/class154/Code05_Dispatch1.java
index 1e4fea156..31844a897 100644
--- a/src/class154/Code06_Dispatch1.java
+++ b/src/class154/Code05_Dispatch1.java
@@ -2,10 +2,10 @@
 
 // 派遣，dfs用递归实现，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
-// 提交以下的code，提交时请把类名改成"Main"，会有一些测试用例通过不了
+// 提交以下的code，提交时请把类名改成"Main"，一些测试用例通过不了
 // 这是因为java语言用递归方式实现dfs，递归会爆栈
-// 需要把dfs实现成迭代版，才能全部通过，就是Code06_Dispatch2文件
-// 但是C++语言用递归方式实现，可以直接通过，就是Code06_Dispatch3文件
+// 需要把dfs实现成迭代版，才能全部通过，就是Code05_Dispatch2文件
+// C++语言用递归方式实现，可以直接通过，就是Code05_Dispatch3文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_Dispatch1 {
+public class Code05_Dispatch1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code06_Dispatch2.java b/src/class154/Code05_Dispatch2.java
similarity index 99%
rename from src/class154/Code06_Dispatch2.java
rename to src/class154/Code05_Dispatch2.java
index 07edd9e46..a6296b121 100644
--- a/src/class154/Code06_Dispatch2.java
+++ b/src/class154/Code05_Dispatch2.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_Dispatch2 {
+public class Code05_Dispatch2 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code06_Dispatch3.java b/src/class154/Code05_Dispatch3.java
similarity index 96%
rename from src/class154/Code06_Dispatch3.java
rename to src/class154/Code05_Dispatch3.java
index 15d117938..4c1b8423b 100644
--- a/src/class154/Code06_Dispatch3.java
+++ b/src/class154/Code05_Dispatch3.java
@@ -2,7 +2,7 @@
 
 // 派遣，dfs用递归实现，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
-// 逻辑和java的递归版完全一样，java的递归版就过不了，C++的递归版就能过
+// 逻辑和java的递归版完全一样，java必须改迭代版才能通过，C++的递归版就能通过
 // 这是洛谷没有考虑其他语言导致的，提交如下代码，可以通过所有测试用例
 
 //#include <bits/stdc++.h>
diff --git a/src/class154/Code05_NumberSequence1.java b/src/class154/Code05_NumberSequence1.java
deleted file mode 100644
index e2a8a9026..000000000
--- a/src/class154/Code05_NumberSequence1.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package class154;
-
-// 数字序列，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P4331
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-public class Code05_NumberSequence1 {
-
-}
diff --git a/src/class154/Code06_NumberSequence1.java b/src/class154/Code06_NumberSequence1.java
new file mode 100644
index 000000000..e3aa5120b
--- /dev/null
+++ b/src/class154/Code06_NumberSequence1.java
@@ -0,0 +1,364 @@
+package class154;
+
+// 数字序列，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4331
+// 提交以下的code，提交时请把类名改成"Main"，一些测试用例通过不了，空间超了
+// 这是洛谷平台没有考虑其他语言导致的，同样的逻辑，C++实现就能完全通过
+// C++实现的版本，就是Code06_NumberSequence2文件
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.InputMismatchException;
+
+public class Code06_NumberSequence1 {
+
+	public static int MAXN = 1000001;
+
+	public static int n;
+
+	public static long[] arr = new long[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] from = new int[MAXN];
+
+	public static int[] to = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] stack = new int[MAXN];
+
+	public static long[] ans = new long[MAXN];
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			left[i] = right[i] = dist[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		if (father[i] != i) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (arr[i] < arr[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[i] = father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static int pop(int i) {
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		father[i] = merge(left[i], right[i]);
+		left[i] = right[i] = 0;
+		return father[i];
+	}
+
+	public static long compute() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = from[i] = to[i] = i;
+			size[i] = 1;
+		}
+		int stackSize = 0;
+		for (int i = 1, pre, cur, s; i <= n; i++) {
+			while (stackSize > 0) {
+				pre = find(stack[stackSize]);
+				cur = find(i);
+				if (arr[pre] <= arr[cur]) {
+					break;
+				}
+				s = size[pre] + size[cur];
+				cur = merge(pre, cur);
+				while (s > (i - from[pre] + 1 + 2) / 2) {
+					cur = pop(cur);
+					s--;
+				}
+				from[cur] = from[pre];
+				to[cur] = i;
+				size[cur] = s;
+				stackSize--;
+			}
+			stack[++stackSize] = i;
+		}
+		long sum = 0;
+		for (int i = 1, cur; i <= stackSize; i++) {
+			cur = find(stack[i]);
+			for (int j = from[cur]; j <= to[cur]; j++) {
+				ans[j] = arr[cur];
+				sum += Math.abs(ans[j] - arr[j]);
+			}
+		}
+		return sum;
+	}
+
+	public static void main(String[] args) {
+		FastReader in = new FastReader(System.in);
+		FastWriter out = new FastWriter(System.out);
+		n = in.readInt();
+		prepare();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.readLong() - i;
+		}
+		out.println(compute());
+		for (int i = 1; i <= n; i++) {
+			out.write((ans[i] + i));
+			out.write(" ");
+		}
+		out.writeln();
+		out.flush();
+		out.close();
+	}
+
+	// 快读
+	public static class FastReader {
+		InputStream is;
+		private byte[] inbuf = new byte[1024];
+		public int lenbuf = 0;
+		public int ptrbuf = 0;
+
+		public FastReader(final InputStream is) {
+			this.is = is;
+		}
+
+		public int readByte() {
+			if (lenbuf == -1) {
+				throw new InputMismatchException();
+			}
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++];
+		}
+
+		public int readInt() {
+			return (int) readLong();
+		}
+
+		public long readLong() {
+			long num = 0;
+			int b;
+			boolean minus = false;
+			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+				;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+
+			while (true) {
+				if (b >= '0' && b <= '9') {
+					num = num * 10 + (b - '0');
+				} else {
+					return minus ? -num : num;
+				}
+				b = readByte();
+			}
+		}
+	}
+
+	// 快写
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private OutputStream out;
+		private Writer writer;
+		private int ptr = 0;
+
+		public FastWriter(Writer writer) {
+			this.writer = new BufferedWriter(writer);
+			out = new ByteArrayOutputStream();
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("FastWriter");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE) {
+				innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE) {
+					innerflush();
+				}
+			});
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L) {
+				return 19;
+			}
+			if (l >= 100000000000000000L) {
+				return 18;
+			}
+			if (l >= 10000000000000000L) {
+				return 17;
+			}
+			if (l >= 1000000000000000L) {
+				return 16;
+			}
+			if (l >= 100000000000000L) {
+				return 15;
+			}
+			if (l >= 10000000000000L) {
+				return 14;
+			}
+			if (l >= 1000000000000L) {
+				return 13;
+			}
+			if (l >= 100000000000L) {
+				return 12;
+			}
+			if (l >= 10000000000L) {
+				return 11;
+			}
+			if (l >= 1000000000L) {
+				return 10;
+			}
+			if (l >= 100000000L) {
+				return 9;
+			}
+			if (l >= 10000000L) {
+				return 8;
+			}
+			if (l >= 1000000L) {
+				return 7;
+			}
+			if (l >= 100000L) {
+				return 6;
+			}
+			if (l >= 10000L) {
+				return 5;
+			}
+			if (l >= 1000L) {
+				return 4;
+			}
+			if (l >= 100L) {
+				return 3;
+			}
+			if (l >= 10L) {
+				return 2;
+			}
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE) {
+				innerflush();
+			}
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException("innerflush");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				if (writer != null) {
+					writer.write(((ByteArrayOutputStream) out).toString());
+					out = new ByteArrayOutputStream();
+					writer.flush();
+				} else {
+					out.flush();
+				}
+			} catch (IOException e) {
+				throw new RuntimeException("flush");
+			}
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public void close() {
+			flush();
+			try {
+				out.close();
+			} catch (Exception e) {
+			}
+		}
+
+	}
+
+}
diff --git a/src/class154/Code06_NumberSequence2.java b/src/class154/Code06_NumberSequence2.java
new file mode 100644
index 000000000..7dda16fe4
--- /dev/null
+++ b/src/class154/Code06_NumberSequence2.java
@@ -0,0 +1,114 @@
+package class154;
+
+// 数字序列，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4331
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//int n;
+//long long arr[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//int fa[MAXN];
+//int from[MAXN];
+//int to[MAXN];
+//int siz[MAXN];
+//int stk[MAXN];
+//long long ans[MAXN];
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        ls[i] = rs[i] = dist[i] = 0;
+//    }
+//}
+//
+//int find(int i) {
+//    if (fa[i] != i) {
+//        fa[i] = find(fa[i]);
+//    }
+//    return fa[i];
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) return i + j;
+//    int tmp;
+//    if (arr[i] < arr[j]) {
+//        tmp = i; i = j; j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    return i;
+//}
+//
+//int pop(int i) {
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    fa[i] = merge(ls[i], rs[i]);
+//    ls[i] = rs[i] = 0;
+//    return fa[i];
+//}
+//
+//long long compute() {
+//    for (int i = 1; i <= n; i++) {
+//        fa[i] = from[i] = to[i] = i;
+//        siz[i] = 1;
+//    }
+//    int stackSize = 0;
+//    for (int i = 1, pre, cur, s; i <= n; i++) {
+//        while (stackSize > 0) {
+//            pre = find(stk[stackSize]);
+//            cur = find(i);
+//            if (arr[pre] <= arr[cur]) {
+//                break;
+//            }
+//            s = siz[pre] + siz[cur];
+//            cur = merge(pre, cur);
+//            while (s > ((i - from[pre] + 1 + 2) / 2)) {
+//                cur = pop(cur);
+//                s--;
+//            }
+//            from[cur] = from[pre];
+//            to[cur] = i;
+//            siz[cur] = s;
+//            stackSize--;
+//        }
+//        stk[++stackSize] = i;
+//    }
+//    long long sum = 0;
+//    for (int i = 1, cur; i <= stackSize; i++) {
+//        cur = find(stk[i]);
+//        for (int j = from[cur]; j <= to[cur]; j++) {
+//            ans[j] = arr[cur];
+//            sum += llabs(ans[j] - arr[j]);
+//        }
+//    }
+//    return sum;
+//}
+//
+//int main() {
+//    ios_base::sync_with_stdio(false);
+//    cin.tie(NULL);
+//    cin >> n;
+//    prepare();
+//    long long x;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> x;
+//        arr[i] = x - i;
+//    }
+//    long long res = compute();
+//    cout << res << "\n";
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] + i << (i == n ? '\n' : ' ');
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 9186d62de93f52765b0fdaa1d2aea4400776610e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 11 Dec 2024 23:55:35 +0800
Subject: [PATCH 0207/1712] modify code

---
 src/class154/Code06_NumberSequence1.java | 2 +-
 src/class154/Code06_NumberSequence2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class154/Code06_NumberSequence1.java b/src/class154/Code06_NumberSequence1.java
index e3aa5120b..b4ff57022 100644
--- a/src/class154/Code06_NumberSequence1.java
+++ b/src/class154/Code06_NumberSequence1.java
@@ -99,7 +99,7 @@ public static long compute() {
 				}
 				s = size[pre] + size[cur];
 				cur = merge(pre, cur);
-				while (s > (i - from[pre] + 1 + 2) / 2) {
+				while (s > (i - from[pre] + 1 + 1) / 2) {
 					cur = pop(cur);
 					s--;
 				}
diff --git a/src/class154/Code06_NumberSequence2.java b/src/class154/Code06_NumberSequence2.java
index 7dda16fe4..17ba24fb6 100644
--- a/src/class154/Code06_NumberSequence2.java
+++ b/src/class154/Code06_NumberSequence2.java
@@ -73,7 +73,7 @@
 //            }
 //            s = siz[pre] + siz[cur];
 //            cur = merge(pre, cur);
-//            while (s > ((i - from[pre] + 1 + 2) / 2)) {
+//            while (s > ((i - from[pre] + 1 + 1) / 2)) {
 //                cur = pop(cur);
 //                s--;
 //            }

From df5943e4fcb29567ca866308c0fd456cde279c80 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Dec 2024 18:47:49 +0800
Subject: [PATCH 0208/1712] modify code

---
 src/class154/Code01_LeftistTree1.java    |   8 +-
 src/class154/Code01_LeftistTree2.java    |   8 +-
 src/class154/Code02_RomanGame1.java      |   8 +-
 src/class154/Code02_RomanGame2.java      |   8 +-
 src/class154/Code03_MonkeyKing1.java     |  14 +-
 src/class154/Code03_MonkeyKing2.java     |  14 +-
 src/class154/Code04_Convict1.java        | 355 ++++++++++++++++++++++-
 src/class154/Code04_Convict2.java        | 112 +++++++
 src/class154/Code05_Dispatch1.java       |   8 +-
 src/class154/Code05_Dispatch2.java       |   8 +-
 src/class154/Code05_Dispatch3.java       |  22 +-
 src/class154/Code06_NumberSequence1.java |   8 +-
 src/class154/Code06_NumberSequence2.java |   8 +-
 src/class155/Code01_CityCapture1.java    |   2 +-
 src/class155/Code01_CityCapture2.java    |   3 +-
 15 files changed, 518 insertions(+), 68 deletions(-)
 create mode 100644 src/class154/Code04_Convict2.java

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index 397ad3c28..32af34f91 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -28,9 +28,7 @@ public class Code01_LeftistTree1 {
 	public static int[] father = new int[MAXN];
 
 	public static int find(int i) {
-		if (father[i] != i) {
-			father[i] = find(father[i]);
-		}
+		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
 	}
 
@@ -51,7 +49,7 @@ public static int merge(int i, int j) {
 			right[i] = tmp;
 		}
 		dist[i] = dist[right[i]] + 1;
-		father[i] = father[left[i]] = father[right[i]] = i;
+		father[left[i]] = father[right[i]] = i;
 		return i;
 	}
 
@@ -64,7 +62,7 @@ public static int pop(int i) {
 		// 为了i能再往上找到正确的头，所以有下面这句
 		father[i] = merge(left[i], right[i]);
 		num[i] = -1;
-		left[i] = right[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
 
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index 27b2f6717..d1e22167b 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -17,9 +17,7 @@
 //int fa[MAXN];
 //
 //int find(int i) {
-//    if (fa[i] != i) {
-//        fa[i] = find(fa[i]);
-//    }
+//    fa[i] = fa[i] == i ? i : find(fa[i]);
 //    return fa[i];
 //}
 //
@@ -39,7 +37,7 @@
 //        rs[i] = tmp;
 //    }
 //    dist[i] = dist[rs[i]] + 1;
-//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    fa[ls[i]] = fa[rs[i]] = i;
 //    return i;
 //}
 //
@@ -48,7 +46,7 @@
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
 //    num[i] = -1;
-//    ls[i] = rs[i] = 0;
+//    ls[i] = rs[i] = dist[i] = 0;
 //    return fa[i];
 //}
 //
diff --git a/src/class154/Code02_RomanGame1.java b/src/class154/Code02_RomanGame1.java
index 0362351f9..1f6db36f2 100644
--- a/src/class154/Code02_RomanGame1.java
+++ b/src/class154/Code02_RomanGame1.java
@@ -29,9 +29,7 @@ public class Code02_RomanGame1 {
 	public static int[] father = new int[MAXN];
 
 	public static int find(int i) {
-		if (father[i] != i) {
-			father[i] = find(father[i]);
-		}
+		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
 	}
 
@@ -52,7 +50,7 @@ public static int merge(int i, int j) {
 			right[i] = tmp;
 		}
 		dist[i] = dist[right[i]] + 1;
-		father[i] = father[left[i]] = father[right[i]] = i;
+		father[left[i]] = father[right[i]] = i;
 		return i;
 	}
 
@@ -61,7 +59,7 @@ public static int pop(int i) {
 		father[right[i]] = right[i];
 		father[i] = merge(left[i], right[i]);
 		num[i] = -1;
-		left[i] = right[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
 
diff --git a/src/class154/Code02_RomanGame2.java b/src/class154/Code02_RomanGame2.java
index d82302d70..11f9f7dea 100644
--- a/src/class154/Code02_RomanGame2.java
+++ b/src/class154/Code02_RomanGame2.java
@@ -17,9 +17,7 @@
 //int fa[MAXN];
 //
 //int find(int i) {
-//    if (fa[i] != i) {
-//        fa[i] = find(fa[i]);
-//    }
+//    fa[i] = fa[i] == i ? i : find(fa[i]);
 //    return fa[i];
 //}
 //
@@ -39,7 +37,7 @@
 //        rs[i] = tmp;
 //    }
 //    dist[i] = dist[rs[i]] + 1;
-//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    fa[ls[i]] = fa[rs[i]] = i;
 //    return i;
 //}
 //
@@ -48,7 +46,7 @@
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
 //    num[i] = -1;
-//    ls[i] = rs[i] = 0;
+//    ls[i] = rs[i] = dist[i] = 0;
 //    return fa[i];
 //}
 //
diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
index c267c7f11..0b9a9c954 100644
--- a/src/class154/Code03_MonkeyKing1.java
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -26,9 +26,7 @@ public class Code03_MonkeyKing1 {
 	public static int[] father = new int[MAXN];
 
 	public static int find(int i) {
-		if (father[i] != i) {
-			father[i] = find(father[i]);
-		}
+		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
 	}
 
@@ -50,7 +48,7 @@ public static int merge(int i, int j) {
 			right[i] = tmp;
 		}
 		dist[i] = dist[right[i]] + 1;
-		father[i] = father[left[i]] = father[right[i]] = i;
+		father[left[i]] = father[right[i]] = i;
 		return i;
 	}
 
@@ -59,14 +57,18 @@ public static int pop(int i) {
 		father[right[i]] = right[i];
 		father[i] = merge(left[i], right[i]);
 		num[i] /= 2; // 根据题目要求，这里是除以2
-		left[i] = right[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
 
 	public static int fight(int x, int y) {
 		int l = find(x);
 		int r = find(y);
-		return l == r ? -1 : num[merge(merge(pop(l), l), merge(pop(r), r))];
+		if (l == r) {
+			return -1;
+		}
+		father[l] = father[r] = merge(merge(pop(l), l), merge(pop(r), r));
+		return num[father[l]];
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
index a6f63ef62..17766aa27 100644
--- a/src/class154/Code03_MonkeyKing2.java
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -17,9 +17,7 @@
 //int fa[MAXN];
 //
 //int find(int i) {
-//    if (fa[i] != i) {
-//        fa[i] = find(fa[i]);
-//    }
+//    fa[i] = fa[i] == i ? i : find(fa[i]);
 //    return fa[i];
 //}
 //
@@ -40,7 +38,7 @@
 //        rs[i] = tmp;
 //    }
 //    dist[i] = dist[rs[i]] + 1;
-//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    fa[ls[i]] = fa[rs[i]] = i;
 //    return i;
 //}
 //
@@ -49,14 +47,18 @@
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
 //    num[i] /= 2;
-//    ls[i] = rs[i] = 0;
+//    ls[i] = rs[i] = dist[i] = 0;
 //    return fa[i];
 //}
 //
 //int fight(int x, int y) {
 //    int l = find(x);
 //    int r = find(y);
-//    return l == r ? -1 : num[merge(merge(pop(l), l), merge(pop(r), r))];
+//    if (l == r) {
+//        return -1;
+//    }
+//    fa[l] = fa[r] = merge(merge(pop(l), l), merge(pop(r), r));
+//    return num[fa[l]];
 //}
 //
 //int main() {
diff --git a/src/class154/Code04_Convict1.java b/src/class154/Code04_Convict1.java
index 8c32cbda3..02fa32a72 100644
--- a/src/class154/Code04_Convict1.java
+++ b/src/class154/Code04_Convict1.java
@@ -3,6 +3,359 @@
 // 断罪者，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4971
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedWriter;
+import java.io.ByteArrayOutputStream;
+import java.io.FileNotFoundException;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.Writer;
+import java.util.InputMismatchException;
+
 public class Code04_Convict1 {
 
-}
+	public static int MAXN = 2000001;
+
+	public static long[] num = new long[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int t, w, n, m;
+
+	public static long k;
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			left[i] = right[i] = dist[i] = 0;
+			father[i] = i;
+		}
+	}
+
+	public static int find(int i) {
+		father[i] = father[i] == i ? i : find(father[i]);
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (num[i] < num[j] || (num[i] == num[j] && i > j)) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static void reduce(int i, long v) {
+		num[i] = Math.max(num[i] - v, 0);
+		int l = find(i);
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		int r = merge(left[i], right[i]);
+		left[i] = right[i] = dist[i] = 0;
+		father[i] = merge(l, r);
+	}
+
+	public static long compute() {
+		long ans = 0;
+		long max = 0;
+		for (int i = 1; i <= n; i++) {
+			if (father[i] == i) {
+				ans += num[i];
+				max = Math.max(max, num[i]);
+			}
+		}
+		if (w == 2) {
+			ans -= max;
+		} else if (w == 3) {
+			ans += max;
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		FastReader in = new FastReader(System.in);
+		FastWriter out = new FastWriter(System.out);
+		t = in.readInt();
+		w = in.readInt();
+		k = in.readLong();
+		for (int i = 1; i <= t; i++) {
+			n = in.readInt();
+			m = in.readInt();
+			prepare();
+			for (int j = 1; j <= n; j++) {
+				num[j] = in.readLong();
+			}
+			for (int j = 1, op, a, b; j <= m; j++) {
+				op = in.readInt();
+				a = in.readInt();
+				if (op == 2) {
+					reduce(a, num[a]);
+				} else if (op == 3) {
+					b = in.readInt();
+					reduce(find(a), b);
+				} else {
+					b = in.readInt();
+					int l = find(a);
+					int r = find(b);
+					if (l != r) {
+						merge(l, r);
+					}
+				}
+			}
+			long ans = compute();
+			if (ans == 0) {
+				out.write("Gensokyo ");
+			} else if (ans > k) {
+				out.write("Hell ");
+			} else {
+				out.write("Heaven ");
+			}
+			out.println(ans);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 快读
+	public static class FastReader {
+		InputStream is;
+		private byte[] inbuf = new byte[1024];
+		public int lenbuf = 0;
+		public int ptrbuf = 0;
+
+		public FastReader(final InputStream is) {
+			this.is = is;
+		}
+
+		public int readByte() {
+			if (lenbuf == -1) {
+				throw new InputMismatchException();
+			}
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new InputMismatchException();
+				}
+				if (lenbuf <= 0) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++];
+		}
+
+		public int readInt() {
+			return (int) readLong();
+		}
+
+		public long readLong() {
+			long num = 0;
+			int b;
+			boolean minus = false;
+			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+				;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+
+			while (true) {
+				if (b >= '0' && b <= '9') {
+					num = num * 10 + (b - '0');
+				} else {
+					return minus ? -num : num;
+				}
+				b = readByte();
+			}
+		}
+	}
+
+	// 快写
+	public static class FastWriter {
+		private static final int BUF_SIZE = 1 << 13;
+		private final byte[] buf = new byte[BUF_SIZE];
+		private OutputStream out;
+		private Writer writer;
+		private int ptr = 0;
+
+		public FastWriter(Writer writer) {
+			this.writer = new BufferedWriter(writer);
+			out = new ByteArrayOutputStream();
+		}
+
+		public FastWriter(OutputStream os) {
+			this.out = os;
+		}
+
+		public FastWriter(String path) {
+			try {
+				this.out = new FileOutputStream(path);
+			} catch (FileNotFoundException e) {
+				throw new RuntimeException("FastWriter");
+			}
+		}
+
+		public FastWriter write(byte b) {
+			buf[ptr++] = b;
+			if (ptr == BUF_SIZE) {
+				innerflush();
+			}
+			return this;
+		}
+
+		public FastWriter write(String s) {
+			s.chars().forEach(c -> {
+				buf[ptr++] = (byte) c;
+				if (ptr == BUF_SIZE) {
+					innerflush();
+				}
+			});
+			return this;
+		}
+
+		private static int countDigits(long l) {
+			if (l >= 1000000000000000000L) {
+				return 19;
+			}
+			if (l >= 100000000000000000L) {
+				return 18;
+			}
+			if (l >= 10000000000000000L) {
+				return 17;
+			}
+			if (l >= 1000000000000000L) {
+				return 16;
+			}
+			if (l >= 100000000000000L) {
+				return 15;
+			}
+			if (l >= 10000000000000L) {
+				return 14;
+			}
+			if (l >= 1000000000000L) {
+				return 13;
+			}
+			if (l >= 100000000000L) {
+				return 12;
+			}
+			if (l >= 10000000000L) {
+				return 11;
+			}
+			if (l >= 1000000000L) {
+				return 10;
+			}
+			if (l >= 100000000L) {
+				return 9;
+			}
+			if (l >= 10000000L) {
+				return 8;
+			}
+			if (l >= 1000000L) {
+				return 7;
+			}
+			if (l >= 100000L) {
+				return 6;
+			}
+			if (l >= 10000L) {
+				return 5;
+			}
+			if (l >= 1000L) {
+				return 4;
+			}
+			if (l >= 100L) {
+				return 3;
+			}
+			if (l >= 10L) {
+				return 2;
+			}
+			return 1;
+		}
+
+		public FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (ptr + 21 >= BUF_SIZE) {
+				innerflush();
+			}
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = ptr + d - 1; i >= ptr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			ptr += d;
+			return this;
+		}
+
+		public FastWriter writeln(long x) {
+			return write(x).writeln();
+		}
+
+		public FastWriter writeln() {
+			return write((byte) '\n');
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, ptr);
+				ptr = 0;
+			} catch (IOException e) {
+				throw new RuntimeException("innerflush");
+			}
+		}
+
+		public void flush() {
+			innerflush();
+			try {
+				if (writer != null) {
+					writer.write(((ByteArrayOutputStream) out).toString());
+					out = new ByteArrayOutputStream();
+					writer.flush();
+				} else {
+					out.flush();
+				}
+			} catch (IOException e) {
+				throw new RuntimeException("flush");
+			}
+		}
+
+		public FastWriter println(long x) {
+			return writeln(x);
+		}
+
+		public void close() {
+			flush();
+			try {
+				out.close();
+			} catch (Exception e) {
+			}
+		}
+
+	}
+
+}
\ No newline at end of file
diff --git a/src/class154/Code04_Convict2.java b/src/class154/Code04_Convict2.java
new file mode 100644
index 000000000..079d62bd1
--- /dev/null
+++ b/src/class154/Code04_Convict2.java
@@ -0,0 +1,112 @@
+package class154;
+
+// 断罪者，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4971
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 2000001;
+//int t, w, n, m;
+//long long k;
+//long long num[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//int fa[MAXN];
+//
+//int find(int i) {
+//    return fa[i] == i ? i : (fa[i] = find(fa[i]));
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    int tmp;
+//    if (num[i] < num[j] || (num[i] == num[j] && i > j)) {
+//        tmp = i; i = j; j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    fa[ls[i]] = fa[rs[i]] = i;
+//    return i;
+//}
+//
+//void reduce(int i, long long v) {
+//    num[i] = max(num[i] - v, 0LL);
+//    int l = find(i);
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    int r = merge(ls[i], rs[i]);
+//    ls[i] = rs[i] = dist[i] = 0;
+//    fa[i] = merge(l, r);
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        ls[i] = rs[i] = dist[i] = 0;
+//        fa[i] = i;
+//    }
+//}
+//
+//long long compute() {
+//    long long ans = 0;
+//    long long mx = 0;
+//    for (int i = 1; i <= n; i++) {
+//        if (fa[i] == i) {
+//            ans += num[i];
+//            if (num[i] > mx) mx = num[i];
+//        }
+//    }
+//    if (w == 2) {
+//        ans -= mx;
+//    } else if (w == 3) {
+//        ans += mx;
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(NULL);
+//    cin >> t >> w >> k;
+//    for(int i = 1; i <= t; i++) {
+//        cin >> n >> m;
+//        prepare();
+//        for (int j = 1; j <= n; j++) {
+//            cin >> num[j];
+//        }
+//        for (int j = 1, op, a, b; j <= m; j++) {
+//            cin >> op >> a;
+//            if (op == 2) {
+//                reduce(a, num[a]);
+//            } else if (op == 3) {
+//                cin >> b;
+//                reduce(find(a), b);
+//            } else {
+//                cin >> b;
+//                int l = find(a);
+//                int r = find(b);
+//                if (l != r) {
+//                    merge(l, r);
+//                }
+//            }
+//        }
+//        long long ans = compute();
+//        if (ans == 0) {
+//            cout << "Gensokyo " << ans << endl;
+//        } else if (ans > k) {
+//            cout << "Hell " << ans << endl;
+//        } else {
+//            cout << "Heaven " << ans << endl;
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class154/Code05_Dispatch1.java b/src/class154/Code05_Dispatch1.java
index 31844a897..32d4314e1 100644
--- a/src/class154/Code05_Dispatch1.java
+++ b/src/class154/Code05_Dispatch1.java
@@ -72,9 +72,7 @@ public static void addEdge(int u, int v) {
 	}
 
 	public static int find(int i) {
-		if (father[i] != i) {
-			father[i] = find(father[i]);
-		}
+		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
 	}
 
@@ -96,7 +94,7 @@ public static int merge(int i, int j) {
 			right[i] = tmp;
 		}
 		dist[i] = dist[right[i]] + 1;
-		father[i] = father[left[i]] = father[right[i]] = i;
+		father[left[i]] = father[right[i]] = i;
 		return i;
 	}
 
@@ -104,7 +102,7 @@ public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		father[i] = merge(left[i], right[i]);
-		left[i] = right[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
 
diff --git a/src/class154/Code05_Dispatch2.java b/src/class154/Code05_Dispatch2.java
index a6296b121..fa7cd13f4 100644
--- a/src/class154/Code05_Dispatch2.java
+++ b/src/class154/Code05_Dispatch2.java
@@ -60,9 +60,7 @@ public static void addEdge(int u, int v) {
 	}
 
 	public static int find(int i) {
-		if (father[i] != i) {
-			father[i] = find(father[i]);
-		}
+		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
 	}
 
@@ -83,7 +81,7 @@ public static int merge(int i, int j) {
 			right[i] = tmp;
 		}
 		dist[i] = dist[right[i]] + 1;
-		father[i] = father[left[i]] = father[right[i]] = i;
+		father[left[i]] = father[right[i]] = i;
 		return i;
 	}
 
@@ -91,7 +89,7 @@ public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		father[i] = merge(left[i], right[i]);
-		left[i] = right[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
 
diff --git a/src/class154/Code05_Dispatch3.java b/src/class154/Code05_Dispatch3.java
index 4c1b8423b..7fae7c264 100644
--- a/src/class154/Code05_Dispatch3.java
+++ b/src/class154/Code05_Dispatch3.java
@@ -21,7 +21,7 @@
 //int ls[MAXN];  
 //int rs[MAXN];  
 //int dist[MAXN];
-//int father[MAXN];
+//int fa[MAXN];
 //int siz[MAXN];  
 //long long sum[MAXN]; 
 //
@@ -31,7 +31,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        head[i] = ls[i] = rs[i] = dist[i] = siz[i] = 0;
 //        sum[i] = 0;
-//        father[i] = i;
+//        fa[i] = i;
 //    }
 //}
 //
@@ -42,10 +42,8 @@
 //}
 //
 //int find(int i) {
-//    if (father[i] != i) {
-//        father[i] = find(father[i]);
-//    }
-//    return father[i];
+//    fa[i] = fa[i] == i ? i : find(fa[i]);
+//    return fa[i];
 //}
 //
 //int merge(int i, int j) {
@@ -64,16 +62,16 @@
 //        rs[i] = tmp;
 //    }
 //    dist[i] = dist[rs[i]] + 1;
-//    father[i] = father[ls[i]] = father[rs[i]] = i;
+//    fa[ls[i]] = fa[rs[i]] = i;
 //    return i;
 //}
 //
 //int pop(int i) {
-//    father[ls[i]] = ls[i];
-//    father[rs[i]] = rs[i];
-//    father[i] = merge(ls[i], rs[i]);
-//    ls[i] = rs[i] = 0;
-//    return father[i];
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    fa[i] = merge(ls[i], rs[i]);
+//    ls[i] = rs[i] = dist[i] = 0;
+//    return fa[i];
 //}
 //
 //void dfs(int u) {
diff --git a/src/class154/Code06_NumberSequence1.java b/src/class154/Code06_NumberSequence1.java
index b4ff57022..53bc868dc 100644
--- a/src/class154/Code06_NumberSequence1.java
+++ b/src/class154/Code06_NumberSequence1.java
@@ -49,9 +49,7 @@ public static void prepare() {
 	}
 
 	public static int find(int i) {
-		if (father[i] != i) {
-			father[i] = find(father[i]);
-		}
+		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
 	}
 
@@ -72,7 +70,7 @@ public static int merge(int i, int j) {
 			right[i] = tmp;
 		}
 		dist[i] = dist[right[i]] + 1;
-		father[i] = father[left[i]] = father[right[i]] = i;
+		father[left[i]] = father[right[i]] = i;
 		return i;
 	}
 
@@ -80,7 +78,7 @@ public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		father[i] = merge(left[i], right[i]);
-		left[i] = right[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
 
diff --git a/src/class154/Code06_NumberSequence2.java b/src/class154/Code06_NumberSequence2.java
index 17ba24fb6..792e6f37e 100644
--- a/src/class154/Code06_NumberSequence2.java
+++ b/src/class154/Code06_NumberSequence2.java
@@ -29,9 +29,7 @@
 //}
 //
 //int find(int i) {
-//    if (fa[i] != i) {
-//        fa[i] = find(fa[i]);
-//    }
+//    fa[i] = fa[i] == i ? i : find(fa[i]);
 //    return fa[i];
 //}
 //
@@ -46,7 +44,7 @@
 //        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
 //    }
 //    dist[i] = dist[rs[i]] + 1;
-//    fa[i] = fa[ls[i]] = fa[rs[i]] = i;
+//    fa[ls[i]] = fa[rs[i]] = i;
 //    return i;
 //}
 //
@@ -54,7 +52,7 @@
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
-//    ls[i] = rs[i] = 0;
+//    ls[i] = rs[i] = dist[i] = 0;
 //    return fa[i];
 //}
 //
diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index a11093864..82a34031b 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -106,7 +106,7 @@ public static int merge(int i, int j) {
 	public static int pop(int i) {
 		down(i);
 		int ans = merge(left[i], right[i]);
-		left[i] = right[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		return ans;
 	}
 
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 697df738b..a08e83f00 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -86,8 +86,7 @@
 //int pop(int i) {
 //    down(i);
 //    int ans = merge(ls[i], rs[i]);
-//    ls[i] = 0;
-//    rs[i] = 0;
+//    ls[i] = rs[i] = dist[i] = 0;
 //    return ans;
 //}
 //

From 940ab12dadbcd0287048e7d3bb4229d190c5ea62 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Dec 2024 18:50:49 +0800
Subject: [PATCH 0209/1712] modify code

---
 src/class154/Code04_Convict1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class154/Code04_Convict1.java b/src/class154/Code04_Convict1.java
index 02fa32a72..8fa8371cd 100644
--- a/src/class154/Code04_Convict1.java
+++ b/src/class154/Code04_Convict1.java
@@ -65,6 +65,8 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
+	// reduce过程中不用关心每个节点的dist是否更新正确
+	// 错误也只是略微影响平衡性，而且随着新节点的加入，平衡性会逐渐恢复
 	public static void reduce(int i, long v) {
 		num[i] = Math.max(num[i] - v, 0);
 		int l = find(i);

From 7d95e47b035e7114914f7ccf44c19e31637c521b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Dec 2024 22:09:34 +0800
Subject: [PATCH 0210/1712] modify code

---
 src/class154/Code01_LeftistTree1.java    | 18 ++++++++++++++----
 src/class154/Code01_LeftistTree2.java    | 14 +++++++++++---
 src/class154/Code02_RomanGame1.java      | 18 ++++++++++++++----
 src/class154/Code02_RomanGame2.java      | 17 +++++++++++++----
 src/class154/Code03_MonkeyKing1.java     | 17 +++++++++++++----
 src/class154/Code03_MonkeyKing2.java     | 11 ++++++++++-
 src/class154/Code04_Convict1.java        |  1 +
 src/class154/Code04_Convict2.java        |  1 +
 src/class154/Code05_Dispatch1.java       |  1 +
 src/class154/Code05_Dispatch2.java       |  1 +
 src/class154/Code05_Dispatch3.java       |  1 +
 src/class154/Code06_NumberSequence1.java |  1 +
 src/class154/Code06_NumberSequence2.java |  1 +
 src/class155/Code01_CityCapture1.java    |  7 ++++---
 src/class155/Code01_CityCapture2.java    | 12 +++++-------
 15 files changed, 91 insertions(+), 30 deletions(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index 32af34f91..037e57a03 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -15,6 +15,8 @@ public class Code01_LeftistTree1 {
 
 	public static int MAXN = 100001;
 
+	public static int n, m;
+
 	// 左偏树需要
 	public static int[] num = new int[MAXN];
 
@@ -27,6 +29,14 @@ public class Code01_LeftistTree1 {
 	// 并查集需要
 	public static int[] father = new int[MAXN];
 
+	public static void prepare() {
+		dist[0] = -1;
+		for (int i = 1; i <= n; i++) {
+			left[i] = right[i] = dist[i] = 0;
+			father[i] = i;
+		}
+	}
+
 	public static int find(int i) {
 		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
@@ -37,7 +47,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
-		if (num[i] > num[j]) {
+		if (num[i] > num[j] || (num[i] == num[j] && i > j)) {
 			tmp = i;
 			i = j;
 			j = tmp;
@@ -71,11 +81,11 @@ public static void main(String[] args) throws IOException {
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		in.nextToken();
-		int n = (int) in.nval;
+		n = (int) in.nval;
 		in.nextToken();
-		int m = (int) in.nval;
+		m = (int) in.nval;
+		prepare();
 		for (int i = 1; i <= n; i++) {
-			father[i] = i;
 			in.nextToken();
 			num[i] = (int) in.nval;
 		}
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index d1e22167b..3b0ae7681 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -10,12 +10,21 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
+//int n, m;
 //int num[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int dist[MAXN];
 //int fa[MAXN];
 //
+//void prepare() {
+//    dist[0] = -1;
+//    for(int i = 1; i <= n; i++) {
+//        ls[i] = rs[i] = dist[i] = 0;
+//        fa[i] = i;
+//    }
+//}
+//
 //int find(int i) {
 //    fa[i] = fa[i] == i ? i : find(fa[i]);
 //    return fa[i];
@@ -25,7 +34,7 @@
 //    if (i == 0 || j == 0) {
 //        return i + j;
 //    }
-//    if (num[i] > num[j]) {
+//    if (num[i] > num[j] || (num[i] == num[j] && i > j)) {
 //        int tmp = i;
 //        i = j;
 //        j = tmp;
@@ -53,10 +62,9 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    int n, m;
 //    cin >> n >> m;
+//    prepare();
 //    for (int i = 1; i <= n; i++) {
-//        fa[i] = i;
 //        cin >> num[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
diff --git a/src/class154/Code02_RomanGame1.java b/src/class154/Code02_RomanGame1.java
index 1f6db36f2..5feeb1723 100644
--- a/src/class154/Code02_RomanGame1.java
+++ b/src/class154/Code02_RomanGame1.java
@@ -18,6 +18,8 @@ public class Code02_RomanGame1 {
 
 	public static int MAXN = 1000001;
 
+	public static int n, m;
+
 	public static int[] num = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
@@ -28,6 +30,14 @@ public class Code02_RomanGame1 {
 
 	public static int[] father = new int[MAXN];
 
+	public static void prepare() {
+		dist[0] = -1;
+		for (int i = 1; i <= n; i++) {
+			left[i] = right[i] = dist[i] = 0;
+			father[i] = i;
+		}
+	}
+
 	public static int find(int i) {
 		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
@@ -38,7 +48,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
-		if (num[i] > num[j]) {
+		if (num[i] > num[j] || (num[i] == num[j] && i > j)) {
 			tmp = i;
 			i = j;
 			j = tmp;
@@ -66,12 +76,12 @@ public static int pop(int i) {
 	public static void main(String[] args) {
 		FastReader in = new FastReader(System.in);
 		FastWriter out = new FastWriter(System.out);
-		int n = in.readInt();
+		n = in.readInt();
+		prepare();
 		for (int i = 1; i <= n; i++) {
-			father[i] = i;
 			num[i] = in.readInt();
 		}
-		int m = in.readInt();
+		m = in.readInt();
 		String op;
 		for (int i = 1, x, y; i <= m; i++) {
 			op = in.readString();
diff --git a/src/class154/Code02_RomanGame2.java b/src/class154/Code02_RomanGame2.java
index 11f9f7dea..8eca8aadb 100644
--- a/src/class154/Code02_RomanGame2.java
+++ b/src/class154/Code02_RomanGame2.java
@@ -10,12 +10,21 @@
 //using namespace std;
 //
 //const int MAXN = 1000001;
+//int n, m;
 //int num[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int dist[MAXN];
 //int fa[MAXN];
 //
+//void prepare() {
+//    dist[0] = -1;
+//    for(int i = 1; i <= n; i++) {
+//        ls[i] = rs[i] = dist[i] = 0;
+//        fa[i] = i;
+//    }
+//}
+//
 //int find(int i) {
 //    fa[i] = fa[i] == i ? i : find(fa[i]);
 //    return fa[i];
@@ -25,7 +34,7 @@
 //    if (i == 0 || j == 0) {
 //        return i + j;
 //    }
-//    if (num[i] > num[j]) {
+//    if (num[i] > num[j] || (num[i] == num[j] && i > j)) {
 //        int tmp = i;
 //        i = j;
 //        j = tmp;
@@ -53,12 +62,12 @@
 //int main() {
 //    ios_base::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    int n; cin >> n;
+//    cin >> n;
+//    prepare();
 //    for (int i = 1; i <= n; i++) {
-//        fa[i] = i;
 //        cin >> num[i];
 //    }
-//    int m; cin >> m;
+//    cin >> m;
 //    for (int i = 1; i <= m; i++) {
 //        string op; cin >> op;
 //        if (op == "M") {
diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
index 0b9a9c954..f7b7c04a9 100644
--- a/src/class154/Code03_MonkeyKing1.java
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -15,6 +15,8 @@ public class Code03_MonkeyKing1 {
 
 	public static int MAXN = 100001;
 
+	public static int n, m;
+
 	public static int[] num = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
@@ -25,6 +27,14 @@ public class Code03_MonkeyKing1 {
 
 	public static int[] father = new int[MAXN];
 
+	public static void prepare() {
+		dist[0] = -1;
+		for (int i = 1; i <= n; i++) {
+			left[i] = right[i] = dist[i] = 0;
+			father[i] = i;
+		}
+	}
+
 	public static int find(int i) {
 		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
@@ -76,15 +86,14 @@ public static void main(String[] args) throws IOException {
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		while (in.nextToken() != StreamTokenizer.TT_EOF) {
-			int n = (int) in.nval;
+			n = (int) in.nval;
+			prepare();
 			for (int i = 1; i <= n; i++) {
-				father[i] = i;
-				left[i] = right[i] = dist[i] = 0;
 				in.nextToken();
 				num[i] = (int) in.nval;
 			}
 			in.nextToken();
-			int m = (int) in.nval;
+			m = (int) in.nval;
 			for (int i = 1, x, y; i <= m; i++) {
 				in.nextToken();
 				x = (int) in.nval;
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
index 17766aa27..ed3f20a84 100644
--- a/src/class154/Code03_MonkeyKing2.java
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -10,12 +10,21 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
+//int n, m;
 //int num[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int dist[MAXN];
 //int fa[MAXN];
 //
+//void prepare() {
+//    dist[0] = -1;
+//    for(int i = 1; i <= n; i++) {
+//        ls[i] = rs[i] = dist[i] = 0;
+//        fa[i] = i;
+//    }
+//}
+//
 //int find(int i) {
 //    fa[i] = fa[i] == i ? i : find(fa[i]);
 //    return fa[i];
@@ -64,8 +73,8 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    int n, m;
 //    while (cin >> n) {
+//        prepare();
 //        for (int i = 1; i <= n; i++) {
 //            fa[i] = i;
 //            ls[i] = rs[i] = dist[i] = 0;
diff --git a/src/class154/Code04_Convict1.java b/src/class154/Code04_Convict1.java
index 8fa8371cd..c8a6bd82f 100644
--- a/src/class154/Code04_Convict1.java
+++ b/src/class154/Code04_Convict1.java
@@ -33,6 +33,7 @@ public class Code04_Convict1 {
 	public static long k;
 
 	public static void prepare() {
+		dist[0] = -1;
 		for (int i = 1; i <= n; i++) {
 			left[i] = right[i] = dist[i] = 0;
 			father[i] = i;
diff --git a/src/class154/Code04_Convict2.java b/src/class154/Code04_Convict2.java
index 079d62bd1..e9e0e6d53 100644
--- a/src/class154/Code04_Convict2.java
+++ b/src/class154/Code04_Convict2.java
@@ -50,6 +50,7 @@
 //}
 //
 //void prepare() {
+//    dist[0] = -1;
 //    for (int i = 1; i <= n; i++) {
 //        ls[i] = rs[i] = dist[i] = 0;
 //        fa[i] = i;
diff --git a/src/class154/Code05_Dispatch1.java b/src/class154/Code05_Dispatch1.java
index 32d4314e1..ef788f207 100644
--- a/src/class154/Code05_Dispatch1.java
+++ b/src/class154/Code05_Dispatch1.java
@@ -58,6 +58,7 @@ public class Code05_Dispatch1 {
 	public static void prepare() {
 		ans = 0;
 		cnt = 1;
+		dist[0] = -1;
 		for (int i = 1; i <= n; i++) {
 			head[i] = left[i] = right[i] = dist[i] = size[i] = 0;
 			sum[i] = 0;
diff --git a/src/class154/Code05_Dispatch2.java b/src/class154/Code05_Dispatch2.java
index fa7cd13f4..92f50e348 100644
--- a/src/class154/Code05_Dispatch2.java
+++ b/src/class154/Code05_Dispatch2.java
@@ -46,6 +46,7 @@ public class Code05_Dispatch2 {
 	public static void prepare() {
 		ans = 0;
 		cnt = 1;
+		dist[0] = -1;
 		for (int i = 1; i <= n; i++) {
 			head[i] = left[i] = right[i] = dist[i] = size[i] = 0;
 			sum[i] = 0;
diff --git a/src/class154/Code05_Dispatch3.java b/src/class154/Code05_Dispatch3.java
index 7fae7c264..353666609 100644
--- a/src/class154/Code05_Dispatch3.java
+++ b/src/class154/Code05_Dispatch3.java
@@ -28,6 +28,7 @@
 //void prepare() {
 //    ans = 0;
 //    cnt = 1;
+//    dist[0] = -1;
 //    for (int i = 1; i <= n; i++) {
 //        head[i] = ls[i] = rs[i] = dist[i] = siz[i] = 0;
 //        sum[i] = 0;
diff --git a/src/class154/Code06_NumberSequence1.java b/src/class154/Code06_NumberSequence1.java
index 53bc868dc..89a46074c 100644
--- a/src/class154/Code06_NumberSequence1.java
+++ b/src/class154/Code06_NumberSequence1.java
@@ -43,6 +43,7 @@ public class Code06_NumberSequence1 {
 	public static long[] ans = new long[MAXN];
 
 	public static void prepare() {
+		dist[0] = -1;
 		for (int i = 1; i <= n; i++) {
 			left[i] = right[i] = dist[i] = 0;
 		}
diff --git a/src/class154/Code06_NumberSequence2.java b/src/class154/Code06_NumberSequence2.java
index 792e6f37e..7c0dae7bb 100644
--- a/src/class154/Code06_NumberSequence2.java
+++ b/src/class154/Code06_NumberSequence2.java
@@ -23,6 +23,7 @@
 //long long ans[MAXN];
 //
 //void prepare() {
+//    dist[0] = -1;
 //    for (int i = 1; i <= n; i++) {
 //        ls[i] = rs[i] = dist[i] = 0;
 //    }
diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index 82a34031b..8e120f52d 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -52,14 +52,15 @@ public class Code01_CityCapture1 {
 	public static long[] add = new long[MAXN];
 
 	public static void prepare() {
-		for (int i = 1; i <= n; i++) {
-			sacrifice[i] = top[i] = 0;
-		}
+		dist[0] = -1;
 		for (int i = 1; i <= m; i++) {
 			left[i] = right[i] = dist[i] = 0;
 			mul[i] = 1;
 			add[i] = 0;
 		}
+		for (int i = 1; i <= n; i++) {
+			sacrifice[i] = top[i] = 0;
+		}
 	}
 
 	public static void down(int i) {
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index a08e83f00..d3978d4e9 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -29,17 +29,15 @@
 //long long add[MAXN];
 //
 //void prepare() {
-//    for (int i = 1; i <= n; i++) {
-//        sacrifice[i] = 0;
-//        top[i] = 0;
-//    }
+//    dist[0] = -1;
 //    for (int i = 1; i <= m; i++) {
-//        ls[i] = 0;
-//        rs[i] = 0;
-//        dist[i] = 0;
+//        ls[i] = rs[i] = dist[i] = 0;
 //        mul[i] = 1;
 //        add[i] = 0;
 //    }
+//    for (int i = 1; i <= n; i++) {
+//        sacrifice[i] = top[i] = 0;
+//    }
 //}
 //
 //void down(int i) {

From 50b9edcf015d0b693b25afb780c54252cdb0e0aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Dec 2024 22:12:41 +0800
Subject: [PATCH 0211/1712] modify code

---
 src/class154/Code03_MonkeyKing2.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
index ed3f20a84..eb3a8edbe 100644
--- a/src/class154/Code03_MonkeyKing2.java
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -76,8 +76,6 @@
 //    while (cin >> n) {
 //        prepare();
 //        for (int i = 1; i <= n; i++) {
-//            fa[i] = i;
-//            ls[i] = rs[i] = dist[i] = 0;
 //            cin >> num[i];
 //        }
 //        cin >> m;

From 90f59a0a507d0f35830758fa36060a06babaa0b1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 13 Dec 2024 15:49:06 +0800
Subject: [PATCH 0212/1712] modify code

---
 src/class154/Code04_Convict1.java | 2 +-
 src/class154/Code04_Convict2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class154/Code04_Convict1.java b/src/class154/Code04_Convict1.java
index c8a6bd82f..06b0033dd 100644
--- a/src/class154/Code04_Convict1.java
+++ b/src/class154/Code04_Convict1.java
@@ -69,11 +69,11 @@ public static int merge(int i, int j) {
 	// reduce过程中不用关心每个节点的dist是否更新正确
 	// 错误也只是略微影响平衡性，而且随着新节点的加入，平衡性会逐渐恢复
 	public static void reduce(int i, long v) {
-		num[i] = Math.max(num[i] - v, 0);
 		int l = find(i);
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		int r = merge(left[i], right[i]);
+		num[i] = Math.max(num[i] - v, 0);
 		left[i] = right[i] = dist[i] = 0;
 		father[i] = merge(l, r);
 	}
diff --git a/src/class154/Code04_Convict2.java b/src/class154/Code04_Convict2.java
index e9e0e6d53..e14a7c889 100644
--- a/src/class154/Code04_Convict2.java
+++ b/src/class154/Code04_Convict2.java
@@ -40,11 +40,11 @@
 //}
 //
 //void reduce(int i, long long v) {
-//    num[i] = max(num[i] - v, 0LL);
 //    int l = find(i);
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    int r = merge(ls[i], rs[i]);
+//    num[i] = max(num[i] - v, 0LL);
 //    ls[i] = rs[i] = dist[i] = 0;
 //    fa[i] = merge(l, r);
 //}

From 33986c9f869fb65c58d4c3dfdfae0ad480f73057 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 13 Dec 2024 15:57:51 +0800
Subject: [PATCH 0213/1712] modify code

---
 .../{Code02_RomanGame1.java => Code01_LeftistTree3.java}    | 4 ++--
 .../{Code02_RomanGame2.java => Code01_LeftistTree4.java}    | 2 +-
 .../{Code03_MonkeyKing1.java => Code02_MonkeyKing1.java}    | 2 +-
 .../{Code03_MonkeyKing2.java => Code02_MonkeyKing2.java}    | 0
 src/class154/{Code04_Convict1.java => Code03_Convict1.java} | 2 +-
 src/class154/{Code04_Convict2.java => Code03_Convict2.java} | 0
 .../{Code05_Dispatch1.java => Code04_Dispatch1.java}        | 6 +++---
 .../{Code05_Dispatch2.java => Code04_Dispatch2.java}        | 2 +-
 .../{Code05_Dispatch3.java => Code04_Dispatch3.java}        | 0
 ...e06_NumberSequence1.java => Code05_NumberSequence1.java} | 4 ++--
 ...e06_NumberSequence2.java => Code05_NumberSequence2.java} | 0
 11 files changed, 11 insertions(+), 11 deletions(-)
 rename src/class154/{Code02_RomanGame1.java => Code01_LeftistTree3.java} (98%)
 rename src/class154/{Code02_RomanGame2.java => Code01_LeftistTree4.java} (97%)
 rename src/class154/{Code03_MonkeyKing1.java => Code02_MonkeyKing1.java} (98%)
 rename src/class154/{Code03_MonkeyKing2.java => Code02_MonkeyKing2.java} (100%)
 rename src/class154/{Code04_Convict1.java => Code03_Convict1.java} (99%)
 rename src/class154/{Code04_Convict2.java => Code03_Convict2.java} (100%)
 rename src/class154/{Code05_Dispatch1.java => Code04_Dispatch1.java} (97%)
 rename src/class154/{Code05_Dispatch2.java => Code04_Dispatch2.java} (99%)
 rename src/class154/{Code05_Dispatch3.java => Code04_Dispatch3.java} (100%)
 rename src/class154/{Code06_NumberSequence1.java => Code05_NumberSequence1.java} (98%)
 rename src/class154/{Code06_NumberSequence2.java => Code05_NumberSequence2.java} (100%)

diff --git a/src/class154/Code02_RomanGame1.java b/src/class154/Code01_LeftistTree3.java
similarity index 98%
rename from src/class154/Code02_RomanGame1.java
rename to src/class154/Code01_LeftistTree3.java
index 5feeb1723..1ce69d248 100644
--- a/src/class154/Code02_RomanGame1.java
+++ b/src/class154/Code01_LeftistTree3.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 罗马游戏，左偏树模版题2，java版
+// 左偏树模版题2，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,7 +14,7 @@
 import java.io.Writer;
 import java.util.InputMismatchException;
 
-public class Code02_RomanGame1 {
+public class Code01_LeftistTree3 {
 
 	public static int MAXN = 1000001;
 
diff --git a/src/class154/Code02_RomanGame2.java b/src/class154/Code01_LeftistTree4.java
similarity index 97%
rename from src/class154/Code02_RomanGame2.java
rename to src/class154/Code01_LeftistTree4.java
index 8eca8aadb..1cbb18c46 100644
--- a/src/class154/Code02_RomanGame2.java
+++ b/src/class154/Code01_LeftistTree4.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 罗马游戏，左偏树模版题2，C++版
+// 左偏树模版题2，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code02_MonkeyKing1.java
similarity index 98%
rename from src/class154/Code03_MonkeyKing1.java
rename to src/class154/Code02_MonkeyKing1.java
index f7b7c04a9..118e66302 100644
--- a/src/class154/Code03_MonkeyKing1.java
+++ b/src/class154/Code02_MonkeyKing1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_MonkeyKing1 {
+public class Code02_MonkeyKing1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code02_MonkeyKing2.java
similarity index 100%
rename from src/class154/Code03_MonkeyKing2.java
rename to src/class154/Code02_MonkeyKing2.java
diff --git a/src/class154/Code04_Convict1.java b/src/class154/Code03_Convict1.java
similarity index 99%
rename from src/class154/Code04_Convict1.java
rename to src/class154/Code03_Convict1.java
index 06b0033dd..14b6fd1c7 100644
--- a/src/class154/Code04_Convict1.java
+++ b/src/class154/Code03_Convict1.java
@@ -14,7 +14,7 @@
 import java.io.Writer;
 import java.util.InputMismatchException;
 
-public class Code04_Convict1 {
+public class Code03_Convict1 {
 
 	public static int MAXN = 2000001;
 
diff --git a/src/class154/Code04_Convict2.java b/src/class154/Code03_Convict2.java
similarity index 100%
rename from src/class154/Code04_Convict2.java
rename to src/class154/Code03_Convict2.java
diff --git a/src/class154/Code05_Dispatch1.java b/src/class154/Code04_Dispatch1.java
similarity index 97%
rename from src/class154/Code05_Dispatch1.java
rename to src/class154/Code04_Dispatch1.java
index ef788f207..bc7853589 100644
--- a/src/class154/Code05_Dispatch1.java
+++ b/src/class154/Code04_Dispatch1.java
@@ -4,8 +4,8 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
 // 提交以下的code，提交时请把类名改成"Main"，一些测试用例通过不了
 // 这是因为java语言用递归方式实现dfs，递归会爆栈
-// 需要把dfs实现成迭代版，才能全部通过，就是Code05_Dispatch2文件
-// C++语言用递归方式实现，可以直接通过，就是Code05_Dispatch3文件
+// 需要把dfs实现成迭代版，才能全部通过，就是Code04_Dispatch2文件
+// C++语言用递归方式实现，可以直接通过，就是Code04_Dispatch3文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_Dispatch1 {
+public class Code04_Dispatch1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code05_Dispatch2.java b/src/class154/Code04_Dispatch2.java
similarity index 99%
rename from src/class154/Code05_Dispatch2.java
rename to src/class154/Code04_Dispatch2.java
index 92f50e348..06bf6f46f 100644
--- a/src/class154/Code05_Dispatch2.java
+++ b/src/class154/Code04_Dispatch2.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_Dispatch2 {
+public class Code04_Dispatch2 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code05_Dispatch3.java b/src/class154/Code04_Dispatch3.java
similarity index 100%
rename from src/class154/Code05_Dispatch3.java
rename to src/class154/Code04_Dispatch3.java
diff --git a/src/class154/Code06_NumberSequence1.java b/src/class154/Code05_NumberSequence1.java
similarity index 98%
rename from src/class154/Code06_NumberSequence1.java
rename to src/class154/Code05_NumberSequence1.java
index 89a46074c..4835846be 100644
--- a/src/class154/Code06_NumberSequence1.java
+++ b/src/class154/Code05_NumberSequence1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4331
 // 提交以下的code，提交时请把类名改成"Main"，一些测试用例通过不了，空间超了
 // 这是洛谷平台没有考虑其他语言导致的，同样的逻辑，C++实现就能完全通过
-// C++实现的版本，就是Code06_NumberSequence2文件
+// C++实现的版本，就是Code05_NumberSequence2文件
 
 import java.io.BufferedWriter;
 import java.io.ByteArrayOutputStream;
@@ -16,7 +16,7 @@
 import java.io.Writer;
 import java.util.InputMismatchException;
 
-public class Code06_NumberSequence1 {
+public class Code05_NumberSequence1 {
 
 	public static int MAXN = 1000001;
 
diff --git a/src/class154/Code06_NumberSequence2.java b/src/class154/Code05_NumberSequence2.java
similarity index 100%
rename from src/class154/Code06_NumberSequence2.java
rename to src/class154/Code05_NumberSequence2.java

From 29ea9177eb5ac9996eb5321cf23afe38efdf7669 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 13 Dec 2024 18:04:38 +0800
Subject: [PATCH 0214/1712] modify code

---
 src/class154/Code01_LeftistTree1.java    |  8 ++++++++
 src/class154/Code01_LeftistTree2.java    |  8 ++++++++
 src/class154/Code01_LeftistTree3.java    | 11 ++++++++++-
 src/class154/Code01_LeftistTree4.java    | 11 ++++++++++-
 src/class154/Code02_MonkeyKing1.java     | 11 ++++++++++-
 src/class154/Code02_MonkeyKing2.java     | 11 ++++++++++-
 src/class154/Code03_Convict1.java        | 21 +++++++++++++++++++++
 src/class154/Code03_Convict2.java        | 21 +++++++++++++++++++++
 src/class154/Code04_Dispatch1.java       |  8 ++++++++
 src/class154/Code04_Dispatch2.java       |  8 ++++++++
 src/class154/Code04_Dispatch3.java       |  8 ++++++++
 src/class154/Code05_NumberSequence1.java |  5 +++++
 src/class154/Code05_NumberSequence2.java |  5 +++++
 13 files changed, 132 insertions(+), 4 deletions(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index 037e57a03..aa7e43d72 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -1,6 +1,14 @@
 package class154;
 
 // 左偏树模版题1，java版
+// 依次给定n个非负数字，表示有n个小根堆，每个堆只有一个数
+// 实现如下两种操作，操作一共调用m次
+// 1 x y : 第x个数字所在的堆和第y个数字所在的堆合并
+//         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
+// 2 x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
+//         如果第x个数字已经被删除，也就是找不到所在的堆，打印-1
+//         若有多个最小值，优先删除顺序靠前的
+// 1 <= n, m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3377
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index 3b0ae7681..f05253d3f 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -1,6 +1,14 @@
 package class154;
 
 // 左偏树模版题1，C++版
+// 依次给定n个非负数字，表示有n个小根堆，每个堆只有一个数
+// 实现如下两种操作，操作一共调用m次
+// 1 x y : 第x个数字所在的堆和第y个数字所在的堆合并
+//         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
+// 2 x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
+//         如果第x个数字已经被删除，也就是找不到所在的堆，打印-1
+//         若有多个最小值，优先删除顺序靠前的
+// 1 <= n, m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3377
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class154/Code01_LeftistTree3.java b/src/class154/Code01_LeftistTree3.java
index 1ce69d248..485d20191 100644
--- a/src/class154/Code01_LeftistTree3.java
+++ b/src/class154/Code01_LeftistTree3.java
@@ -1,6 +1,15 @@
 package class154;
 
-// 左偏树模版题2，java版
+// 左偏树模版题2，数据量增强，java版
+// 依次给定n个非负数字，表示有n个小根堆，每个堆只有一个数
+// 实现如下两种操作，操作一共调用m次
+// M x y : 第x个数字所在的堆和第y个数字所在的堆合并
+//         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
+// K x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
+//         如果第x个数字已经被删除，也就是找不到所在的堆，打印0
+//         若有多个最小值，优先删除顺序靠前的
+// 1 <= n <= 10^6
+// 1 <= m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class154/Code01_LeftistTree4.java b/src/class154/Code01_LeftistTree4.java
index 1cbb18c46..bf8e07c9a 100644
--- a/src/class154/Code01_LeftistTree4.java
+++ b/src/class154/Code01_LeftistTree4.java
@@ -1,6 +1,15 @@
 package class154;
 
-// 左偏树模版题2，C++版
+// 左偏树模版题2，数据量增强，C++版
+// 依次给定n个非负数字，表示有n个小根堆，每个堆只有一个数
+// 实现如下两种操作，操作一共调用m次
+// M x y : 第x个数字所在的堆和第y个数字所在的堆合并
+//         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
+// K x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
+//         如果第x个数字已经被删除，也就是找不到所在的堆，打印0
+//         若有多个最小值，优先删除顺序靠前的
+// 1 <= n <= 10^6
+// 1 <= m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class154/Code02_MonkeyKing1.java b/src/class154/Code02_MonkeyKing1.java
index 118e66302..7b6108dd9 100644
--- a/src/class154/Code02_MonkeyKing1.java
+++ b/src/class154/Code02_MonkeyKing1.java
@@ -1,6 +1,15 @@
 package class154;
 
 // 猴王，java版
+// 给定n只猴子的战斗力，一开始每个猴子都是独立的阵营
+// 一共有m次冲突，每次冲突给定两只猴子的编号x、y
+// 如果x和y在同一阵营，这次冲突停止，打印-1
+// 如果x和y在不同阵营，x所在阵营的最强猴子会和y所在阵营的最强猴子进行打斗
+// 打斗的结果是，两个各自阵营的最强猴子，战斗力都减半，向下取整，其他猴子战力不变
+// 然后两个阵营合并，打印合并后的阵营最大战斗力
+// 题目可能有多组数据，需要监控输入流直到结束
+// 1 <= n, m <= 10^5
+// 0 <= 猴子战斗力 <= 32768
 // 测试链接 : https://www.luogu.com.cn/problem/P1456
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -99,7 +108,7 @@ public static void main(String[] args) throws IOException {
 				x = (int) in.nval;
 				in.nextToken();
 				y = (int) in.nval;
-				System.out.println(fight(x, y));
+				out.println(fight(x, y));
 			}
 		}
 		out.flush();
diff --git a/src/class154/Code02_MonkeyKing2.java b/src/class154/Code02_MonkeyKing2.java
index eb3a8edbe..7380b7973 100644
--- a/src/class154/Code02_MonkeyKing2.java
+++ b/src/class154/Code02_MonkeyKing2.java
@@ -1,6 +1,15 @@
 package class154;
 
 // 猴王，C++版
+// 给定n只猴子的战斗力，一开始每个猴子都是独立的阵营
+// 一共有m次冲突，每次冲突给定两只猴子的编号x、y
+// 如果x和y在同一阵营，这次冲突停止，打印-1
+// 如果x和y在不同阵营，x所在阵营的最强猴子会和y所在阵营的最强猴子进行打斗
+// 打斗的结果是，两个各自阵营的最强猴子，战斗力都减半，向下取整，其他猴子战力不变
+// 然后两个阵营合并，打印合并后的阵营最大战斗力
+// 题目可能有多组数据，需要监控输入流直到结束
+// 1 <= n, m <= 10^5
+// 0 <= 猴子战斗力 <= 32768
 // 测试链接 : https://www.luogu.com.cn/problem/P1456
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -82,7 +91,7 @@
 //        for (int i = 1; i <= m; i++) {
 //            int x, y;
 //            cin >> x >> y;
-//            cout << fight(x, y) << "\n";
+//            cout << fight(x, y) << endl;
 //        }
 //    }
 //    return 0;
diff --git a/src/class154/Code03_Convict1.java b/src/class154/Code03_Convict1.java
index 14b6fd1c7..da7fbf386 100644
--- a/src/class154/Code03_Convict1.java
+++ b/src/class154/Code03_Convict1.java
@@ -1,6 +1,27 @@
 package class154;
 
 // 断罪者，java版
+// 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
+// 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
+// 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下
+// 2 a   : 第a件错事的罪恶值变成0
+// 3 a b : 第a件错事所在的集合中，最大罪恶值的错事，罪恶值减少b
+//         如果减少后罪恶值变成负数，认为这件错事的罪恶值变为0
+//         如果集合中，两件错事都是最大的罪恶值，取编号较小的错事
+// 4 a b : 第a件错事所在的集合与第b件错事所在的集合合并
+// 一个错事集合的罪恶值 = 这个集合中的最大罪恶值，只取一个
+// 一个人的罪恶值 = 这个人所有错事集合的罪恶值累加起来
+// 然后根据死亡方式w，对每个人的罪恶值做最后调整，然后打印这个人的下场
+// 如果w==1，不调整
+// 如果w==2，人的罪恶值 -= 错事集合的罪恶值中的最大值
+// 如果w==3，人的罪恶值 += 错事集合的罪恶值中的最大值
+// 如果一个人的罪恶值 == 0，打印"Gensokyo 0"
+// 如果一个人的罪恶值  > k，打印"Hell "，然后打印罪恶值
+// 如果一个人的罪恶值 <= k，打印"Heaven "，然后打印罪恶值
+// 一共有t个人，所以最终会有t次打印
+// 1 <= t <= 30
+// 1 <= n <= 2 * 10^6
+// 错事罪恶值可能很大，输入保证每个人的罪恶值用long类型不溢出
 // 测试链接 : https://www.luogu.com.cn/problem/P4971
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class154/Code03_Convict2.java b/src/class154/Code03_Convict2.java
index e14a7c889..24adf6a5a 100644
--- a/src/class154/Code03_Convict2.java
+++ b/src/class154/Code03_Convict2.java
@@ -1,6 +1,27 @@
 package class154;
 
 // 断罪者，C++版
+// 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
+// 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
+// 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下
+// 2 a   : 第a件错事的罪恶值变成0
+// 3 a b : 第a件错事所在的集合中，最大罪恶值的错事，罪恶值减少b
+//         如果减少后罪恶值变成负数，认为这件错事的罪恶值变为0
+//         如果集合中，两件错事都是最大的罪恶值，取编号较小的错事
+// 4 a b : 第a件错事所在的集合与第b件错事所在的集合合并
+// 一个错事集合的罪恶值 = 这个集合中的最大罪恶值，只取一个
+// 一个人的罪恶值 = 这个人所有错事集合的罪恶值累加起来
+// 然后根据死亡方式w，对每个人的罪恶值做最后调整，然后打印这个人的下场
+// 如果w==1，不调整
+// 如果w==2，人的罪恶值 -= 错事集合的罪恶值中的最大值
+// 如果w==3，人的罪恶值 += 错事集合的罪恶值中的最大值
+// 如果一个人的罪恶值 == 0，打印"Gensokyo 0"
+// 如果一个人的罪恶值  > k，打印"Hell "，然后打印罪恶值
+// 如果一个人的罪恶值 <= k，打印"Heaven "，然后打印罪恶值
+// 一共有t个人，所以最终会有t次打印
+// 1 <= t <= 30
+// 1 <= n <= 2 * 10^6
+// 错事罪恶值可能很大，输入保证每个人的罪恶值用long类型不溢出
 // 测试链接 : https://www.luogu.com.cn/problem/P4971
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class154/Code04_Dispatch1.java b/src/class154/Code04_Dispatch1.java
index bc7853589..960eae742 100644
--- a/src/class154/Code04_Dispatch1.java
+++ b/src/class154/Code04_Dispatch1.java
@@ -1,6 +1,14 @@
 package class154;
 
 // 派遣，dfs用递归实现，java版
+// 一共有n个忍者，每个忍者有工资、领导力、上级编号，三个属性
+// 如果某个忍者的上级编号为0，那么他是整棵忍者树的头
+// 你一共有m的预算，可以在忍者树上随意选一棵子树，然后在这棵子树上挑选忍者
+// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，你就可以随意选择子树上的忍者
+// 最终收益 = 雇佣人数 * 子树头忍者的领导力，返回能取得的最大收益是多少
+// 输入保证，任何忍者的编号 > 该忍者上级的编号
+// 1 <= n <= 10^5           1 <= m <= 10^9
+// 1 <= 每个忍者工资 <= m     1 <= 每个忍者领导力 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
 // 提交以下的code，提交时请把类名改成"Main"，一些测试用例通过不了
 // 这是因为java语言用递归方式实现dfs，递归会爆栈
diff --git a/src/class154/Code04_Dispatch2.java b/src/class154/Code04_Dispatch2.java
index 06bf6f46f..44cf4b6fe 100644
--- a/src/class154/Code04_Dispatch2.java
+++ b/src/class154/Code04_Dispatch2.java
@@ -1,6 +1,14 @@
 package class154;
 
 // 派遣，dfs用迭代实现，java版
+// 一共有n个忍者，每个忍者有工资、领导力、上级编号，三个属性
+// 如果某个忍者的上级编号为0，那么他是整棵忍者树的头
+// 你一共有m的预算，可以在忍者树上随意选一棵子树，然后在这棵子树上挑选忍者
+// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，你就可以随意选择子树上的忍者
+// 最终收益 = 雇佣人数 * 子树头忍者的领导力，返回能取得的最大收益是多少
+// 输入保证，任何忍者的编号 > 该忍者上级的编号
+// 1 <= n <= 10^5           1 <= m <= 10^9
+// 1 <= 每个忍者工资 <= m     1 <= 每个忍者领导力 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class154/Code04_Dispatch3.java b/src/class154/Code04_Dispatch3.java
index 353666609..dc89d3175 100644
--- a/src/class154/Code04_Dispatch3.java
+++ b/src/class154/Code04_Dispatch3.java
@@ -1,6 +1,14 @@
 package class154;
 
 // 派遣，dfs用递归实现，C++版
+// 一共有n个忍者，每个忍者有工资、领导力、上级编号，三个属性
+// 如果某个忍者的上级编号为0，那么他是整棵忍者树的头
+// 你一共有m的预算，可以在忍者树上随意选一棵子树，然后在这棵子树上挑选忍者
+// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，你就可以随意选择子树上的忍者
+// 最终收益 = 雇佣人数 * 子树头忍者的领导力，返回能取得的最大收益是多少
+// 输入保证，任何忍者的编号 > 该忍者上级的编号
+// 1 <= n <= 10^5           1 <= m <= 10^9
+// 1 <= 每个忍者工资 <= m     1 <= 每个忍者领导力 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
 // 逻辑和java的递归版完全一样，java必须改迭代版才能通过，C++的递归版就能通过
 // 这是洛谷没有考虑其他语言导致的，提交如下代码，可以通过所有测试用例
diff --git a/src/class154/Code05_NumberSequence1.java b/src/class154/Code05_NumberSequence1.java
index 4835846be..9e7a3f8ce 100644
--- a/src/class154/Code05_NumberSequence1.java
+++ b/src/class154/Code05_NumberSequence1.java
@@ -1,6 +1,11 @@
 package class154;
 
 // 数字序列，java版
+// 给定一个长度为n的数组A，要求构造出一个长度为n的递增数组B
+// 希望 |A[1] - B[1]| + |A[2] - B[2]| + ... + |A[n] - B[n]| 最小
+// 打印这个最小值，然后打印数组B，如果有多个方案，只打印其中的一个
+// 1 <= n <= 10^6
+// 0 <= A[i] <= 2^32 - 1
 // 测试链接 : https://www.luogu.com.cn/problem/P4331
 // 提交以下的code，提交时请把类名改成"Main"，一些测试用例通过不了，空间超了
 // 这是洛谷平台没有考虑其他语言导致的，同样的逻辑，C++实现就能完全通过
diff --git a/src/class154/Code05_NumberSequence2.java b/src/class154/Code05_NumberSequence2.java
index 7c0dae7bb..28219c27c 100644
--- a/src/class154/Code05_NumberSequence2.java
+++ b/src/class154/Code05_NumberSequence2.java
@@ -1,6 +1,11 @@
 package class154;
 
 // 数字序列，C++版
+// 给定一个长度为n的数组A，要求构造出一个长度为n的递增数组B
+// 希望 |A[1] - B[1]| + |A[2] - B[2]| + ... + |A[n] - B[n]| 最小
+// 打印这个最小值，然后打印数组B，如果有多个方案，只打印其中的一个
+// 1 <= n <= 10^6
+// 0 <= A[i] <= 2^32 - 1
 // 测试链接 : https://www.luogu.com.cn/problem/P4331
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From e0443cb38a71b349abc3dc87550e6afbbb333fa4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 16:31:02 +0800
Subject: [PATCH 0215/1712] modify code

---
 src/class154/Code03_Convict1.java | 37 +++++++++++++++++++++++++------
 src/class154/Code03_Convict2.java | 34 +++++++++++++++++++++++-----
 2 files changed, 59 insertions(+), 12 deletions(-)

diff --git a/src/class154/Code03_Convict1.java b/src/class154/Code03_Convict1.java
index da7fbf386..60367fa07 100644
--- a/src/class154/Code03_Convict1.java
+++ b/src/class154/Code03_Convict1.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 断罪者，java版
+// 断罪者，删除任意编号节点，java版
 // 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
 // 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
 // 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下
@@ -41,6 +41,8 @@ public class Code03_Convict1 {
 
 	public static long[] num = new long[MAXN];
 
+	public static int[] up = new int[MAXN];
+
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
@@ -77,6 +79,7 @@ public static int merge(int i, int j) {
 			j = tmp;
 		}
 		right[i] = merge(right[i], j);
+		up[right[i]] = i;
 		if (dist[left[i]] < dist[right[i]]) {
 			tmp = left[i];
 			left[i] = right[i];
@@ -87,16 +90,36 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
-	// reduce过程中不用关心每个节点的dist是否更新正确
-	// 错误也只是略微影响平衡性，而且随着新节点的加入，平衡性会逐渐恢复
-	public static void reduce(int i, long v) {
+	public static int remove(int i) {
 		int l = find(i);
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		int r = merge(left[i], right[i]);
-		num[i] = Math.max(num[i] - v, 0);
-		left[i] = right[i] = dist[i] = 0;
-		father[i] = merge(l, r);
+		up[r] = 0;
+		num[i] = left[i] = right[i] = dist[i] = 0;
+		if (l == i) {
+			father[i] = r;
+		} else {
+			int h = up[i];
+			if (left[h] == i) {
+				left[h] = 0;
+			} else {
+				right[h] = 0;
+			}
+			up[i] = 0;
+			for (int d = -1; dist[h] > d + 1; h = up[h], d++) {
+				dist[h] = d + 1;
+			}
+			father[i] = merge(l, r);
+		}
+		return father[i];
+	}
+
+	public static void reduce(int i, long v) {
+		long tmp = num[i];
+		int l = remove(i);
+		num[i] = Math.max(tmp - v, 0);
+		father[l] = father[i] = merge(l, i);
 	}
 
 	public static long compute() {
diff --git a/src/class154/Code03_Convict2.java b/src/class154/Code03_Convict2.java
index 24adf6a5a..7ab69d630 100644
--- a/src/class154/Code03_Convict2.java
+++ b/src/class154/Code03_Convict2.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 断罪者，C++版
+// 断罪者，删除任意编号节点，C++版
 // 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
 // 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
 // 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下
@@ -34,6 +34,7 @@
 //int t, w, n, m;
 //long long k;
 //long long num[MAXN];
+//int up[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
 //int dist[MAXN];
@@ -52,6 +53,7 @@
 //        tmp = i; i = j; j = tmp;
 //    }
 //    rs[i] = merge(rs[i], j);
+//    up[rs[i]] = i;
 //    if (dist[ls[i]] < dist[rs[i]]) {
 //        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
 //    }
@@ -60,14 +62,36 @@
 //    return i;
 //}
 //
-//void reduce(int i, long long v) {
+//int remove(int i) {
 //    int l = find(i);
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    int r = merge(ls[i], rs[i]);
-//    num[i] = max(num[i] - v, 0LL);
-//    ls[i] = rs[i] = dist[i] = 0;
-//    fa[i] = merge(l, r);
+//    up[r] = 0;
+//    num[i] = ls[i] = rs[i] = dist[i] = 0;
+//    if (l == i) {
+//        fa[i] = r;
+//    } else {
+//        int h = up[i];
+//        if (ls[h] == i) {
+//            ls[h] = 0;
+//        } else {
+//            rs[h] = 0;
+//        }
+//        up[i] = 0;
+//        for (int d = -1; dist[h] > d + 1; h = up[h], d++) {
+//            dist[h] = d + 1;
+//        }
+//        fa[i] = merge(l, r);
+//    }
+//    return fa[i];
+//}
+//
+//void reduce(int i, long long v) {
+//    long tmp = num[i];
+//    int l = remove(i);
+//    num[i] = max(tmp - v, 0LL);
+//    fa[l] = fa[i] = merge(l, i);
 //}
 //
 //void prepare() {

From 3fb20c8bb5ff0116ac49fb34389631a490c2e198 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 16:32:25 +0800
Subject: [PATCH 0216/1712] modify code

---
 src/class154/Code03_Convict1.java | 2 +-
 src/class154/Code03_Convict2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class154/Code03_Convict1.java b/src/class154/Code03_Convict1.java
index 60367fa07..aedcfce8e 100644
--- a/src/class154/Code03_Convict1.java
+++ b/src/class154/Code03_Convict1.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 断罪者，删除任意编号节点，java版
+// 断罪者，指定编号删除节点，java版
 // 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
 // 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
 // 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下
diff --git a/src/class154/Code03_Convict2.java b/src/class154/Code03_Convict2.java
index 7ab69d630..7c5c6681b 100644
--- a/src/class154/Code03_Convict2.java
+++ b/src/class154/Code03_Convict2.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 断罪者，删除任意编号节点，C++版
+// 断罪者，指定编号删除节点，C++版
 // 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
 // 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
 // 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下

From 7fc473c76194a5ebd350e38986aa2d09b234e205 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 16:59:07 +0800
Subject: [PATCH 0217/1712] modify code

---
 src/class154/{Code03_Convict1.java => Code02_Convict1.java}   | 4 ++--
 src/class154/{Code03_Convict2.java => Code02_Convict2.java}   | 2 +-
 .../{Code02_MonkeyKing1.java => Code03_MonkeyKing1.java}      | 2 +-
 .../{Code02_MonkeyKing2.java => Code03_MonkeyKing2.java}      | 0
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class154/{Code03_Convict1.java => Code02_Convict1.java} (99%)
 rename src/class154/{Code03_Convict2.java => Code02_Convict2.java} (98%)
 rename src/class154/{Code02_MonkeyKing1.java => Code03_MonkeyKing1.java} (98%)
 rename src/class154/{Code02_MonkeyKing2.java => Code03_MonkeyKing2.java} (100%)

diff --git a/src/class154/Code03_Convict1.java b/src/class154/Code02_Convict1.java
similarity index 99%
rename from src/class154/Code03_Convict1.java
rename to src/class154/Code02_Convict1.java
index aedcfce8e..898826e79 100644
--- a/src/class154/Code03_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 断罪者，指定编号删除节点，java版
+// 断罪者，删除任意编号节点，java版
 // 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
 // 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
 // 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下
@@ -35,7 +35,7 @@
 import java.io.Writer;
 import java.util.InputMismatchException;
 
-public class Code03_Convict1 {
+public class Code02_Convict1 {
 
 	public static int MAXN = 2000001;
 
diff --git a/src/class154/Code03_Convict2.java b/src/class154/Code02_Convict2.java
similarity index 98%
rename from src/class154/Code03_Convict2.java
rename to src/class154/Code02_Convict2.java
index 7c5c6681b..7ab69d630 100644
--- a/src/class154/Code03_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -1,6 +1,6 @@
 package class154;
 
-// 断罪者，指定编号删除节点，C++版
+// 断罪者，删除任意编号节点，C++版
 // 给定t，w，k，表示一共有t个人，死亡方式都为w，地狱阈值都为k，w和k含义稍后解释
 // 每个人都给定n和m，表示这人一生有n件错事，有m次领悟
 // 这个人的n件错事，给定对应的n个罪恶值，然后给定m次领悟，领悟类型如下
diff --git a/src/class154/Code02_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
similarity index 98%
rename from src/class154/Code02_MonkeyKing1.java
rename to src/class154/Code03_MonkeyKing1.java
index 7b6108dd9..74f853061 100644
--- a/src/class154/Code02_MonkeyKing1.java
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -20,7 +20,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_MonkeyKing1 {
+public class Code03_MonkeyKing1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class154/Code02_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
similarity index 100%
rename from src/class154/Code02_MonkeyKing2.java
rename to src/class154/Code03_MonkeyKing2.java

From 467089626e8aac3a320664949ecc369865a8eb74 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 17:10:55 +0800
Subject: [PATCH 0218/1712] modify code

---
 src/class154/Code02_Convict1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 898826e79..5ec22565a 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -73,6 +73,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
+		// 这里是维护大根堆，如果值一样，编号小的节点设为头
 		if (num[i] < num[j] || (num[i] == num[j] && i > j)) {
 			tmp = i;
 			i = j;

From fc21f1c45d607cbb4a7b8fdce219895ed67eb9ed Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 17:16:41 +0800
Subject: [PATCH 0219/1712] modify code

---
 src/class154/Code02_Convict1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 5ec22565a..493d0cf7d 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -91,6 +91,7 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
+	// 左偏树上删除编号为i的节点，返回删除操作后整棵树的头节点编号
 	public static int remove(int i) {
 		int l = find(i);
 		father[left[i]] = left[i];

From 38b6fcc7b8d9135854411f78b46298c667e8e158 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 17:25:03 +0800
Subject: [PATCH 0220/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 2 +-
 src/class154/Code01_LeftistTree2.java | 2 +-
 src/class154/Code01_LeftistTree3.java | 2 +-
 src/class154/Code01_LeftistTree4.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index aa7e43d72..bfc63ee2f 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -7,7 +7,7 @@
 //         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
 // 2 x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
 //         如果第x个数字已经被删除，也就是找不到所在的堆，打印-1
-//         若有多个最小值，优先删除顺序靠前的
+//         若有多个最小值，优先删除编号小的
 // 1 <= n, m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3377
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index f05253d3f..9d01051de 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -7,7 +7,7 @@
 //         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
 // 2 x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
 //         如果第x个数字已经被删除，也就是找不到所在的堆，打印-1
-//         若有多个最小值，优先删除顺序靠前的
+//         若有多个最小值，优先删除编号小的
 // 1 <= n, m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3377
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class154/Code01_LeftistTree3.java b/src/class154/Code01_LeftistTree3.java
index 485d20191..3cec14680 100644
--- a/src/class154/Code01_LeftistTree3.java
+++ b/src/class154/Code01_LeftistTree3.java
@@ -7,7 +7,7 @@
 //         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
 // K x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
 //         如果第x个数字已经被删除，也就是找不到所在的堆，打印0
-//         若有多个最小值，优先删除顺序靠前的
+//         若有多个最小值，优先删除编号小的
 // 1 <= n <= 10^6
 // 1 <= m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2713
diff --git a/src/class154/Code01_LeftistTree4.java b/src/class154/Code01_LeftistTree4.java
index bf8e07c9a..fb65c26f8 100644
--- a/src/class154/Code01_LeftistTree4.java
+++ b/src/class154/Code01_LeftistTree4.java
@@ -7,7 +7,7 @@
 //         如果两个数字已经在一个堆或者某个数字已经删除，不进行合并
 // K x   : 打印第x个数字所在堆的最小值，并且在堆里删掉这个最小值
 //         如果第x个数字已经被删除，也就是找不到所在的堆，打印0
-//         若有多个最小值，优先删除顺序靠前的
+//         若有多个最小值，优先删除编号小的
 // 1 <= n <= 10^6
 // 1 <= m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2713

From 361f69d3b343648a115943d2951fd20891a5cf0f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 17:41:47 +0800
Subject: [PATCH 0221/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index bfc63ee2f..a9dc07dd4 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -74,10 +74,9 @@ public static int merge(int i, int j) {
 	public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
-		// 下面这一句的功能
-		// 因为有路径压缩，所以i下方的某个节点x，可能有father[x] = i
-		// 但是现在堆要去掉i了，所以x一直往上找到i是无效的
-		// 为了i能再往上找到正确的头，所以有下面这句
+		// 并查集有路径压缩，所以i下方的某个节点x，可能有father[x] = i
+		// 现在要删掉i了，所以x往上会找不到正确的头节点
+		// 为了任何节点往上都能找到正确的头，所以要有下面这句
 		father[i] = merge(left[i], right[i]);
 		num[i] = -1;
 		left[i] = right[i] = dist[i] = 0;

From 317679ab3d26a7a11c3eb61745ec8b19a5ee69e9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 17:58:14 +0800
Subject: [PATCH 0222/1712] modify code

---
 src/class154/Code01_LeftistTree1.java    | 1 +
 src/class154/Code02_Convict1.java        | 2 +-
 src/class154/Code03_MonkeyKing1.java     | 2 +-
 src/class154/Code04_Dispatch1.java       | 2 +-
 src/class154/Code05_NumberSequence1.java | 1 +
 5 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index a9dc07dd4..14676e46b 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -55,6 +55,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
+		// 维护小根堆，如果值一样，编号小的节点做头
 		if (num[i] > num[j] || (num[i] == num[j] && i > j)) {
 			tmp = i;
 			i = j;
diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 493d0cf7d..f3e3f9f49 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -73,7 +73,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
-		// 这里是维护大根堆，如果值一样，编号小的节点设为头
+		// 维护大根堆，如果值一样，编号小的节点做头
 		if (num[i] < num[j] || (num[i] == num[j] && i > j)) {
 			tmp = i;
 			i = j;
diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
index 74f853061..5a4e71df8 100644
--- a/src/class154/Code03_MonkeyKing1.java
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -54,7 +54,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
-		// 本题是维护大根堆
+		// 维护大根堆
 		if (num[i] < num[j]) {
 			tmp = i;
 			i = j;
diff --git a/src/class154/Code04_Dispatch1.java b/src/class154/Code04_Dispatch1.java
index 960eae742..8f49de9c2 100644
--- a/src/class154/Code04_Dispatch1.java
+++ b/src/class154/Code04_Dispatch1.java
@@ -90,7 +90,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
-		// 本题是维护大根堆
+		// 维护大根堆
 		if (cost[i] < cost[j]) {
 			tmp = i;
 			i = j;
diff --git a/src/class154/Code05_NumberSequence1.java b/src/class154/Code05_NumberSequence1.java
index 9e7a3f8ce..a0a1b4d44 100644
--- a/src/class154/Code05_NumberSequence1.java
+++ b/src/class154/Code05_NumberSequence1.java
@@ -64,6 +64,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
+		// 维护大根堆
 		if (arr[i] < arr[j]) {
 			tmp = i;
 			i = j;

From d2e4dc7d66c9df6de0ca42f24c4d3e46e107a683 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 18:01:34 +0800
Subject: [PATCH 0223/1712] modify code

---
 src/class154/Code02_Convict1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index f3e3f9f49..a49e67845 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -91,7 +91,7 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
-	// 左偏树上删除编号为i的节点，返回删除操作后整棵树的头节点编号
+	// 左偏树上删除编号为i的节点，返回删除后整棵树的头节点编号
 	public static int remove(int i) {
 		int l = find(i);
 		father[left[i]] = left[i];

From 775227b69a5614b0e6569647c41f681306fa227a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 18:20:47 +0800
Subject: [PATCH 0224/1712] modify code

---
 src/class154/Code03_MonkeyKing1.java | 15 +++++++++------
 src/class154/Code03_MonkeyKing2.java | 15 +++++++++------
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/class154/Code03_MonkeyKing1.java b/src/class154/Code03_MonkeyKing1.java
index 5a4e71df8..2c0080eb9 100644
--- a/src/class154/Code03_MonkeyKing1.java
+++ b/src/class154/Code03_MonkeyKing1.java
@@ -75,19 +75,22 @@ public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		father[i] = merge(left[i], right[i]);
-		num[i] /= 2; // 根据题目要求，这里是除以2
 		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
 
 	public static int fight(int x, int y) {
-		int l = find(x);
-		int r = find(y);
-		if (l == r) {
+		int a = find(x);
+		int b = find(y);
+		if (a == b) {
 			return -1;
 		}
-		father[l] = father[r] = merge(merge(pop(l), l), merge(pop(r), r));
-		return num[father[l]];
+		int l = pop(a);
+		int r = pop(b);
+		num[a] /= 2;
+		num[b] /= 2;
+		father[a] = father[b] = father[l] = father[r] = merge(merge(l, a), merge(r, b));
+		return num[father[a]];
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
index 7380b7973..0b10ccada 100644
--- a/src/class154/Code03_MonkeyKing2.java
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -64,19 +64,22 @@
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
-//    num[i] /= 2;
 //    ls[i] = rs[i] = dist[i] = 0;
 //    return fa[i];
 //}
 //
 //int fight(int x, int y) {
-//    int l = find(x);
-//    int r = find(y);
-//    if (l == r) {
+//    int a = find(x);
+//    int b = find(y);
+//    if (a == b) {
 //        return -1;
 //    }
-//    fa[l] = fa[r] = merge(merge(pop(l), l), merge(pop(r), r));
-//    return num[fa[l]];
+//    int l = pop(a);
+//    int r = pop(b);
+//    num[a] /= 2;
+//    num[b] /= 2;
+//    fa[a] = fa[b] = fa[l] = fa[r] = merge(merge(l, a), merge(r, b));
+//    return num[fa[a]];
 //}
 //
 //int main() {

From 142fe4f1fad91bb52a3e810115c460d48524f50f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 18:50:32 +0800
Subject: [PATCH 0225/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 2 +-
 src/class154/Code01_LeftistTree2.java | 2 +-
 src/class154/Code01_LeftistTree3.java | 2 +-
 src/class154/Code01_LeftistTree4.java | 2 +-
 src/class154/Code02_Convict1.java     | 5 ++---
 src/class154/Code02_Convict2.java     | 5 ++---
 6 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index 14676e46b..8d7cdd8be 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -79,7 +79,6 @@ public static int pop(int i) {
 		// 现在要删掉i了，所以x往上会找不到正确的头节点
 		// 为了任何节点往上都能找到正确的头，所以要有下面这句
 		father[i] = merge(left[i], right[i]);
-		num[i] = -1;
 		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
@@ -121,6 +120,7 @@ public static void main(String[] args) throws IOException {
 					int ans = find(x);
 					out.println(num[ans]);
 					pop(ans);
+					num[ans] = -1;
 				}
 			}
 		}
diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index 9d01051de..01857ea29 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -62,7 +62,6 @@
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
-//    num[i] = -1;
 //    ls[i] = rs[i] = dist[i] = 0;
 //    return fa[i];
 //}
@@ -97,6 +96,7 @@
 //                int ans = find(x);
 //                cout << num[ans] << "\n";
 //                pop(ans);
+//                num[ans] = -1;
 //            }
 //        }
 //    }
diff --git a/src/class154/Code01_LeftistTree3.java b/src/class154/Code01_LeftistTree3.java
index 3cec14680..ff018d6ed 100644
--- a/src/class154/Code01_LeftistTree3.java
+++ b/src/class154/Code01_LeftistTree3.java
@@ -77,7 +77,6 @@ public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		father[i] = merge(left[i], right[i]);
-		num[i] = -1;
 		left[i] = right[i] = dist[i] = 0;
 		return father[i];
 	}
@@ -112,6 +111,7 @@ public static void main(String[] args) {
 					int ans = find(x);
 					out.println(num[ans]);
 					pop(ans);
+					num[ans] = -1;
 				}
 			}
 		}
diff --git a/src/class154/Code01_LeftistTree4.java b/src/class154/Code01_LeftistTree4.java
index fb65c26f8..6d7cbcb40 100644
--- a/src/class154/Code01_LeftistTree4.java
+++ b/src/class154/Code01_LeftistTree4.java
@@ -63,7 +63,6 @@
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    fa[i] = merge(ls[i], rs[i]);
-//    num[i] = -1;
 //    ls[i] = rs[i] = dist[i] = 0;
 //    return fa[i];
 //}
@@ -96,6 +95,7 @@
 //                int ans = find(x);
 //                cout << num[ans] << endl;
 //                pop(ans);
+//                num[ans] = -1;
 //            }
 //        }
 //    }
diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index a49e67845..13f02ea46 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -98,7 +98,7 @@ public static int remove(int i) {
 		father[right[i]] = right[i];
 		int r = merge(left[i], right[i]);
 		up[r] = 0;
-		num[i] = left[i] = right[i] = dist[i] = 0;
+		left[i] = right[i] = dist[i] = 0;
 		if (l == i) {
 			father[i] = r;
 		} else {
@@ -118,9 +118,8 @@ public static int remove(int i) {
 	}
 
 	public static void reduce(int i, long v) {
-		long tmp = num[i];
 		int l = remove(i);
-		num[i] = Math.max(tmp - v, 0);
+		num[i] = Math.max(num[i] - v, 0);
 		father[l] = father[i] = merge(l, i);
 	}
 
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index 7ab69d630..a33eae6ea 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -68,7 +68,7 @@
 //    fa[rs[i]] = rs[i];
 //    int r = merge(ls[i], rs[i]);
 //    up[r] = 0;
-//    num[i] = ls[i] = rs[i] = dist[i] = 0;
+//    ls[i] = rs[i] = dist[i] = 0;
 //    if (l == i) {
 //        fa[i] = r;
 //    } else {
@@ -88,9 +88,8 @@
 //}
 //
 //void reduce(int i, long long v) {
-//    long tmp = num[i];
 //    int l = remove(i);
-//    num[i] = max(tmp - v, 0LL);
+//    num[i] = max(num[i] - v, 0LL);
 //    fa[l] = fa[i] = merge(l, i);
 //}
 //

From bca8909f99a2956720efca13bbda997a4f6f748b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 20:49:54 +0800
Subject: [PATCH 0226/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index 8d7cdd8be..342c13902 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -34,7 +34,10 @@ public class Code01_LeftistTree1 {
 
 	public static int[] dist = new int[MAXN];
 
-	// 并查集需要
+	// 并查集需要father数组，方便快速找到树的头
+	// father[i]不代表i在树上的父亲节点
+	// father是并查集找代表节点的路径信息
+	// 需要保证，并查集最终的代表节点 = 树的头节点
 	public static int[] father = new int[MAXN];
 
 	public static void prepare() {

From 5843fb8187207f4df24c6322d2d0021da5355955 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 21:47:19 +0800
Subject: [PATCH 0227/1712] modify code

---
 src/class154/Code01_LeftistTree1.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/class154/Code01_LeftistTree1.java b/src/class154/Code01_LeftistTree1.java
index 342c13902..bcd75f87d 100644
--- a/src/class154/Code01_LeftistTree1.java
+++ b/src/class154/Code01_LeftistTree1.java
@@ -37,7 +37,7 @@ public class Code01_LeftistTree1 {
 	// 并查集需要father数组，方便快速找到树的头
 	// father[i]不代表i在树上的父亲节点
 	// father是并查集找代表节点的路径信息
-	// 需要保证，并查集最终的代表节点 = 树的头节点
+	// 需要保证，并查集最上方的代表节点 = 树的头节点
 	public static int[] father = new int[MAXN];
 
 	public static void prepare() {
@@ -53,6 +53,7 @@ public static int find(int i) {
 		return father[i];
 	}
 
+	// 编号为i的左偏树 与 编号为j的左偏树合并，返回新树的头节点编号
 	public static int merge(int i, int j) {
 		if (i == 0 || j == 0) {
 			return i + j;
@@ -75,6 +76,7 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
+	// 节点i一定是左偏树的头，在左偏树上删掉节点i，返回新树的头节点编号
 	public static int pop(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];

From d6a17248f82f9ea629446c812505da4ffa331be4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 22:06:02 +0800
Subject: [PATCH 0228/1712] modify code

---
 src/class154/Code02_Convict1.java | 28 +++++++++++++++-------------
 src/class154/Code02_Convict2.java | 24 ++++++++++++------------
 2 files changed, 27 insertions(+), 25 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 13f02ea46..63e367db1 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -91,28 +91,30 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
-	// 左偏树上删除编号为i的节点，返回删除后整棵树的头节点编号
+	// 不保证节点i是左偏树的头节点
+	// 左偏树上删除编号为i的节点
+	// 返回删除后整棵树的头节点编号
 	public static int remove(int i) {
-		int l = find(i);
+		int h = find(i);
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
-		int r = merge(left[i], right[i]);
-		up[r] = 0;
+		int s = merge(left[i], right[i]);
+		up[s] = 0;
 		left[i] = right[i] = dist[i] = 0;
-		if (l == i) {
-			father[i] = r;
+		if (h == i) {
+			father[i] = s;
 		} else {
-			int h = up[i];
-			if (left[h] == i) {
-				left[h] = 0;
+			int f = up[i];
+			if (left[f] == i) {
+				left[f] = 0;
 			} else {
-				right[h] = 0;
+				right[f] = 0;
 			}
 			up[i] = 0;
-			for (int d = -1; dist[h] > d + 1; h = up[h], d++) {
-				dist[h] = d + 1;
+			for (int d = -1; dist[f] > d + 1; f = up[f], d++) {
+				dist[f] = d + 1;
 			}
-			father[i] = merge(l, r);
+			father[i] = merge(h, s);
 		}
 		return father[i];
 	}
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index a33eae6ea..ec8db177a 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -63,26 +63,26 @@
 //}
 //
 //int remove(int i) {
-//    int l = find(i);
+//    int h = find(i);
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
-//    int r = merge(ls[i], rs[i]);
-//    up[r] = 0;
+//    int s = merge(ls[i], rs[i]);
+//    up[s] = 0;
 //    ls[i] = rs[i] = dist[i] = 0;
-//    if (l == i) {
-//        fa[i] = r;
+//    if (h == i) {
+//        fa[i] = s;
 //    } else {
-//        int h = up[i];
-//        if (ls[h] == i) {
-//            ls[h] = 0;
+//        int f = up[i];
+//        if (ls[f] == i) {
+//            ls[f] = 0;
 //        } else {
-//            rs[h] = 0;
+//            rs[f] = 0;
 //        }
 //        up[i] = 0;
-//        for (int d = -1; dist[h] > d + 1; h = up[h], d++) {
-//            dist[h] = d + 1;
+//        for (int d = -1; dist[f] > d + 1; f = up[f], d++) {
+//            dist[f] = d + 1;
 //        }
-//        fa[i] = merge(l, r);
+//        fa[i] = merge(h, s);
 //    }
 //    return fa[i];
 //}

From 436cffc188163195ca48d0af883f38a806f9d1d0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 22:13:18 +0800
Subject: [PATCH 0229/1712] modify code

---
 src/class154/Code02_Convict1.java | 16 ++++++++--------
 src/class154/Code02_Convict2.java | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 63e367db1..d2d2fda17 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -39,8 +39,13 @@ public class Code02_Convict1 {
 
 	public static int MAXN = 2000001;
 
+	public static int t, w, n, m;
+
+	public static long k;
+
 	public static long[] num = new long[MAXN];
 
+	// up[i]表示节点i在左偏树结构上的父亲节点
 	public static int[] up = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
@@ -49,16 +54,13 @@ public class Code02_Convict1 {
 
 	public static int[] dist = new int[MAXN];
 
+	// father[i]表示并查集里节点i的路径信息
 	public static int[] father = new int[MAXN];
 
-	public static int t, w, n, m;
-
-	public static long k;
-
 	public static void prepare() {
 		dist[0] = -1;
 		for (int i = 1; i <= n; i++) {
-			left[i] = right[i] = dist[i] = 0;
+			up[i] = left[i] = right[i] = dist[i] = 0;
 			father[i] = i;
 		}
 	}
@@ -91,9 +93,7 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
-	// 不保证节点i是左偏树的头节点
-	// 左偏树上删除编号为i的节点
-	// 返回删除后整棵树的头节点编号
+	// 节点i是所在左偏树的任意节点，删除节点i，返回整棵树的头节点编号
 	public static int remove(int i) {
 		int h = find(i);
 		father[left[i]] = left[i];
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index ec8db177a..1a41a6214 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -40,6 +40,14 @@
 //int dist[MAXN];
 //int fa[MAXN];
 //
+//void prepare() {
+//    dist[0] = -1;
+//    for (int i = 1; i <= n; i++) {
+//        up[i] = ls[i] = rs[i] = dist[i] = 0;
+//        fa[i] = i;
+//    }
+//}
+//
 //int find(int i) {
 //    return fa[i] == i ? i : (fa[i] = find(fa[i]));
 //}
@@ -93,14 +101,6 @@
 //    fa[l] = fa[i] = merge(l, i);
 //}
 //
-//void prepare() {
-//    dist[0] = -1;
-//    for (int i = 1; i <= n; i++) {
-//        ls[i] = rs[i] = dist[i] = 0;
-//        fa[i] = i;
-//    }
-//}
-//
 //long long compute() {
 //    long long ans = 0;
 //    long long mx = 0;

From f4fbecbc649259a58f6b8ccac8b33b854345399e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Dec 2024 22:57:10 +0800
Subject: [PATCH 0230/1712] modify code

---
 src/class154/Code02_Convict1.java | 7 ++++++-
 src/class154/Code02_Convict2.java | 7 ++++++-
 2 files changed, 12 insertions(+), 2 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index d2d2fda17..92d7937c9 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -111,8 +111,13 @@ public static int remove(int i) {
 				right[f] = 0;
 			}
 			up[i] = 0;
-			for (int d = -1; dist[f] > d + 1; f = up[f], d++) {
+			for (int d = -1, tmp; dist[f] > d + 1; f = up[f], d++) {
 				dist[f] = d + 1;
+				if (dist[left[f]] < dist[right[f]]) {
+					tmp = left[f];
+					left[f] = right[f];
+					right[f] = tmp;
+				}
 			}
 			father[i] = merge(h, s);
 		}
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index 1a41a6214..a598acc36 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -87,8 +87,13 @@
 //            rs[f] = 0;
 //        }
 //        up[i] = 0;
-//        for (int d = -1; dist[f] > d + 1; f = up[f], d++) {
+//        for (int d = -1, tmp; dist[f] > d + 1; f = up[f], d++) {
 //            dist[f] = d + 1;
+//            if (dist[ls[f]] < dist[rs[f]]) {
+//                tmp = ls[f];
+//                ls[f] = rs[f];
+//                rs[f] = tmp;
+//            }
 //        }
 //        fa[i] = merge(h, s);
 //    }

From 88bb3efcbb8440a141f4eae43e8856dc62573541 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 00:22:05 +0800
Subject: [PATCH 0231/1712] modify code

---
 src/class154/Code02_Convict1.java | 22 ++++++++++------------
 src/class154/Code02_Convict2.java | 22 ++++++++++------------
 2 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 92d7937c9..2328ae384 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -99,19 +99,17 @@ public static int remove(int i) {
 		father[left[i]] = left[i];
 		father[right[i]] = right[i];
 		int s = merge(left[i], right[i]);
-		up[s] = 0;
-		left[i] = right[i] = dist[i] = 0;
-		if (h == i) {
-			father[i] = s;
-		} else {
-			int f = up[i];
+		int f = up[i];
+		father[i] = s;
+		up[s] = f;
+		if (h != i) {
+			father[s] = h;
 			if (left[f] == i) {
-				left[f] = 0;
+				left[f] = s;
 			} else {
-				right[f] = 0;
+				right[f] = s;
 			}
-			up[i] = 0;
-			for (int d = -1, tmp; dist[f] > d + 1; f = up[f], d++) {
+			for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
 				dist[f] = d + 1;
 				if (dist[left[f]] < dist[right[f]]) {
 					tmp = left[f];
@@ -119,9 +117,9 @@ public static int remove(int i) {
 					right[f] = tmp;
 				}
 			}
-			father[i] = merge(h, s);
 		}
-		return father[i];
+		up[i] = left[i] = right[i] = dist[i] = 0;
+		return father[s];
 	}
 
 	public static void reduce(int i, long v) {
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index a598acc36..c582e2707 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -75,19 +75,17 @@
 //    fa[ls[i]] = ls[i];
 //    fa[rs[i]] = rs[i];
 //    int s = merge(ls[i], rs[i]);
-//    up[s] = 0;
-//    ls[i] = rs[i] = dist[i] = 0;
-//    if (h == i) {
-//        fa[i] = s;
-//    } else {
-//        int f = up[i];
+//    int f = up[i];
+//    fa[i] = s;
+//    up[s] = f;
+//    if (h != i) {
+//        fa[s] = h;
 //        if (ls[f] == i) {
-//            ls[f] = 0;
+//            ls[f] = s;
 //        } else {
-//            rs[f] = 0;
+//            rs[f] = s;
 //        }
-//        up[i] = 0;
-//        for (int d = -1, tmp; dist[f] > d + 1; f = up[f], d++) {
+//        for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
 //            dist[f] = d + 1;
 //            if (dist[ls[f]] < dist[rs[f]]) {
 //                tmp = ls[f];
@@ -95,9 +93,9 @@
 //                rs[f] = tmp;
 //            }
 //        }
-//        fa[i] = merge(h, s);
 //    }
-//    return fa[i];
+//    up[i] = ls[i] = rs[i] = dist[i] = 0;
+//    return fa[s];
 //}
 //
 //void reduce(int i, long long v) {

From 307b9edd622574aa8fa6bb7c59235924afdd5fae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 00:23:29 +0800
Subject: [PATCH 0232/1712] modify code

---
 src/class154/Code02_Convict1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 2328ae384..6e850d5f8 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -82,6 +82,7 @@ public static int merge(int i, int j) {
 			j = tmp;
 		}
 		right[i] = merge(right[i], j);
+		// 设置up信息
 		up[right[i]] = i;
 		if (dist[left[i]] < dist[right[i]]) {
 			tmp = left[i];

From d44c5faa2f330ba7f8a59400e87e32fa472fb4ff Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 11:18:37 +0800
Subject: [PATCH 0233/1712] modify code

---
 src/class154/Code02_Convict1.java | 4 ++--
 src/class154/Code02_Convict2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 6e850d5f8..e8eda3952 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -124,9 +124,9 @@ public static int remove(int i) {
 	}
 
 	public static void reduce(int i, long v) {
-		int l = remove(i);
+		int h = remove(i);
 		num[i] = Math.max(num[i] - v, 0);
-		father[l] = father[i] = merge(l, i);
+		father[h] = father[i] = merge(h, i);
 	}
 
 	public static long compute() {
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index c582e2707..790e6fa41 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -99,9 +99,9 @@
 //}
 //
 //void reduce(int i, long long v) {
-//    int l = remove(i);
+//    int h = remove(i);
 //    num[i] = max(num[i] - v, 0LL);
-//    fa[l] = fa[i] = merge(l, i);
+//    fa[h] = fa[i] = merge(h, i);
 //}
 //
 //long long compute() {

From faea33f5cc14facaa3b6a083b791ec8d2eb495a7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 11:28:35 +0800
Subject: [PATCH 0234/1712] modify code

---
 src/class154/Code02_Convict1.java | 4 +---
 src/class154/Code02_Convict2.java | 4 +---
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index e8eda3952..84310f66b 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -113,9 +113,7 @@ public static int remove(int i) {
 			for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
 				dist[f] = d + 1;
 				if (dist[left[f]] < dist[right[f]]) {
-					tmp = left[f];
-					left[f] = right[f];
-					right[f] = tmp;
+					tmp = left[f]; left[f] = right[f]; right[f] = tmp;
 				}
 			}
 		}
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index 790e6fa41..0e21f1f31 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -88,9 +88,7 @@
 //        for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
 //            dist[f] = d + 1;
 //            if (dist[ls[f]] < dist[rs[f]]) {
-//                tmp = ls[f];
-//                ls[f] = rs[f];
-//                rs[f] = tmp;
+//                tmp = ls[f]; ls[f] = rs[f]; rs[f] = tmp;
 //            }
 //        }
 //    }

From bf7b8edf9d878b2cbf1e797fa063d9f6f940eedc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 15:24:23 +0800
Subject: [PATCH 0235/1712] modify code

---
 src/class154/Code04_Dispatch1.java | 111 +++++------
 src/class154/Code04_Dispatch2.java | 293 ++++++++++-------------------
 src/class154/Code04_Dispatch3.java | 131 -------------
 3 files changed, 146 insertions(+), 389 deletions(-)
 delete mode 100644 src/class154/Code04_Dispatch3.java

diff --git a/src/class154/Code04_Dispatch1.java b/src/class154/Code04_Dispatch1.java
index 8f49de9c2..73a5cabec 100644
--- a/src/class154/Code04_Dispatch1.java
+++ b/src/class154/Code04_Dispatch1.java
@@ -1,19 +1,15 @@
 package class154;
 
-// 派遣，dfs用递归实现，java版
-// 一共有n个忍者，每个忍者有工资、领导力、上级编号，三个属性
-// 如果某个忍者的上级编号为0，那么他是整棵忍者树的头
+// 派遣，java版
+// 一共有n个忍者，每个忍者有上级编号、工资、能力，三个属性
+// 输入保证，任何忍者的上级编号 < 这名忍者的编号，1号忍者是整棵忍者树的头
 // 你一共有m的预算，可以在忍者树上随意选一棵子树，然后在这棵子树上挑选忍者
-// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，你就可以随意选择子树上的忍者
-// 最终收益 = 雇佣人数 * 子树头忍者的领导力，返回能取得的最大收益是多少
-// 输入保证，任何忍者的编号 > 该忍者上级的编号
+// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，可以随意选择子树上的忍者
+// 最终收益 = 雇佣人数 * 子树头忍者的能力，返回能取得的最大收益是多少
 // 1 <= n <= 10^5           1 <= m <= 10^9
 // 1 <= 每个忍者工资 <= m     1 <= 每个忍者领导力 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
-// 提交以下的code，提交时请把类名改成"Main"，一些测试用例通过不了
-// 这是因为java语言用递归方式实现dfs，递归会爆栈
-// 需要把dfs实现成迭代版，才能全部通过，就是Code04_Dispatch2文件
-// C++语言用递归方式实现，可以直接通过，就是Code04_Dispatch3文件
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -28,22 +24,14 @@ public class Code04_Dispatch1 {
 
 	public static int n, m;
 
-	public static long ans;
-
-	// 链式前向星需要
-	public static int[] head = new int[MAXN];
-
-	public static int[] next = new int[MAXN];
-
-	public static int[] to = new int[MAXN];
-
-	public static int cnt;
+	// 上级
+	public static int[] leader = new int[MAXN];
 
 	// 薪水
 	public static long[] cost = new long[MAXN];
 
-	// 领导力
-	public static long[] lead = new long[MAXN];
+	// 能力
+	public static long[] ability = new long[MAXN];
 
 	// 左孩子
 	public static int[] left = new int[MAXN];
@@ -64,22 +52,15 @@ public class Code04_Dispatch1 {
 	public static long[] sum = new long[MAXN];
 
 	public static void prepare() {
-		ans = 0;
-		cnt = 1;
 		dist[0] = -1;
 		for (int i = 1; i <= n; i++) {
-			head[i] = left[i] = right[i] = dist[i] = size[i] = 0;
-			sum[i] = 0;
+			left[i] = right[i] = dist[i] = 0;
+			size[i] = 1;
+			sum[i] = cost[i];
 			father[i] = i;
 		}
 	}
 
-	public static void addEdge(int u, int v) {
-		next[cnt] = head[u];
-		to[cnt] = v;
-		head[u] = cnt++;
-	}
-
 	public static int find(int i) {
 		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
@@ -115,32 +96,31 @@ public static int pop(int i) {
 		return father[i];
 	}
 
-	// dfs用递归实现
-	public static void dfs(int u) {
-		for (int ei = head[u]; ei > 0; ei = next[ei]) {
-			dfs(to[ei]);
-		}
-		int usize = 1;
-		long usum = cost[u];
-		for (int ei = head[u], v, l, r; ei > 0; ei = next[ei]) {
-			v = to[ei];
-			l = find(u);
-			r = find(v);
-			usize += size[r];
-			usum += sum[r];
-			merge(l, r);
-		}
-		int i;
-		while (usum > m) {
-			i = find(u);
-			usize--;
-			usum -= cost[i];
-			pop(i);
+	public static long compute() {
+		long ans = 0;
+		int p, psize, h, hsize;
+		long hsum, psum;
+		for (int i = n; i >= 1; i--) {
+			h = find(i);
+			hsize = size[h];
+			hsum = sum[h];
+			while (hsum > m) {
+				pop(h);
+				hsize--;
+				hsum -= cost[h];
+				h = find(i);
+			}
+			ans = Math.max(ans, (long) hsize * ability[i]);
+			if (i > 1) {
+				p = find(leader[i]);
+				psize = size[p];
+				psum = sum[p];
+				father[p] = father[h] = merge(p, h);
+				size[father[p]] = psize + hsize;
+				sum[father[p]] = psum + hsum;
+			}
 		}
-		i = find(u);
-		size[i] = usize;
-		sum[i] = usum;
-		ans = Math.max(ans, (long) usize * lead[u]);
+		return ans;
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -151,23 +131,16 @@ public static void main(String[] args) throws IOException {
 		n = (int) in.nval;
 		in.nextToken();
 		m = (int) in.nval;
-		prepare();
-		int root = 0;
-		for (int i = 1, f; i <= n; i++) {
+		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			f = (int) in.nval;
+			leader[i] = (int) in.nval;
 			in.nextToken();
 			cost[i] = (int) in.nval;
 			in.nextToken();
-			lead[i] = (int) in.nval;
-			if (f == 0) {
-				root = i;
-			} else {
-				addEdge(f, i);
-			}
+			ability[i] = (int) in.nval;
 		}
-		dfs(root);
-		out.println(ans);
+		prepare();
+		out.println(compute());
 		out.flush();
 		out.close();
 		br.close();
diff --git a/src/class154/Code04_Dispatch2.java b/src/class154/Code04_Dispatch2.java
index 44cf4b6fe..c80580a56 100644
--- a/src/class154/Code04_Dispatch2.java
+++ b/src/class154/Code04_Dispatch2.java
@@ -1,195 +1,110 @@
 package class154;
 
-// 派遣，dfs用迭代实现，java版
-// 一共有n个忍者，每个忍者有工资、领导力、上级编号，三个属性
-// 如果某个忍者的上级编号为0，那么他是整棵忍者树的头
+// 派遣，C++版
+// 一共有n个忍者，每个忍者有上级编号、工资、能力，三个属性
+// 输入保证，任何忍者的上级编号 < 这名忍者的编号，1号忍者是整棵忍者树的头
 // 你一共有m的预算，可以在忍者树上随意选一棵子树，然后在这棵子树上挑选忍者
-// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，你就可以随意选择子树上的忍者
-// 最终收益 = 雇佣人数 * 子树头忍者的领导力，返回能取得的最大收益是多少
-// 输入保证，任何忍者的编号 > 该忍者上级的编号
+// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，可以随意选择子树上的忍者
+// 最终收益 = 雇佣人数 * 子树头忍者的能力，返回能取得的最大收益是多少
 // 1 <= n <= 10^5           1 <= m <= 10^9
 // 1 <= 每个忍者工资 <= m     1 <= 每个忍者领导力 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1552
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.StreamTokenizer;
-
-public class Code04_Dispatch2 {
-
-	public static int MAXN = 100001;
-
-	public static int n, m;
-
-	public static long ans;
-
-	public static int[] head = new int[MAXN];
-
-	public static int[] next = new int[MAXN];
-
-	public static int[] to = new int[MAXN];
-
-	public static int cnt;
-
-	public static long[] cost = new long[MAXN];
-
-	public static long[] lead = new long[MAXN];
-
-	public static int[] left = new int[MAXN];
-
-	public static int[] right = new int[MAXN];
-
-	public static int[] dist = new int[MAXN];
-
-	public static int[] father = new int[MAXN];
-
-	public static int[] size = new int[MAXN];
-
-	public static long[] sum = new long[MAXN];
-
-	public static void prepare() {
-		ans = 0;
-		cnt = 1;
-		dist[0] = -1;
-		for (int i = 1; i <= n; i++) {
-			head[i] = left[i] = right[i] = dist[i] = size[i] = 0;
-			sum[i] = 0;
-			father[i] = i;
-		}
-	}
-
-	public static void addEdge(int u, int v) {
-		next[cnt] = head[u];
-		to[cnt] = v;
-		head[u] = cnt++;
-	}
-
-	public static int find(int i) {
-		father[i] = father[i] == i ? i : find(father[i]);
-		return father[i];
-	}
-
-	public static int merge(int i, int j) {
-		if (i == 0 || j == 0) {
-			return i + j;
-		}
-		int tmp;
-		if (cost[i] < cost[j]) {
-			tmp = i;
-			i = j;
-			j = tmp;
-		}
-		right[i] = merge(right[i], j);
-		if (dist[left[i]] < dist[right[i]]) {
-			tmp = left[i];
-			left[i] = right[i];
-			right[i] = tmp;
-		}
-		dist[i] = dist[right[i]] + 1;
-		father[left[i]] = father[right[i]] = i;
-		return i;
-	}
-
-	public static int pop(int i) {
-		father[left[i]] = left[i];
-		father[right[i]] = right[i];
-		father[i] = merge(left[i], right[i]);
-		left[i] = right[i] = dist[i] = 0;
-		return father[i];
-	}
-
-	// dfs从递归版改成迭代版，不会的话，看讲解118
-	// 重点讲了树上问题从递归版改成迭代版的方法
-	public static int[][] ue = new int[MAXN][2];
-
-	public static int u, ei;
-
-	public static int ssize;
-
-	public static void push(int u, int ei) {
-		ue[ssize][0] = u;
-		ue[ssize][1] = ei;
-		ssize++;
-	}
-
-	public static void pop() {
-		--ssize;
-		u = ue[ssize][0];
-		ei = ue[ssize][1];
-	}
-
-	// dfs用迭代实现
-	public static void dfs(int root) {
-		ssize = 0;
-		push(root, -1);
-		while (ssize > 0) {
-			pop();
-			if (ei == -1) {
-				ei = head[u];
-			} else {
-				ei = next[ei];
-			}
-			if (ei > 0) {
-				push(u, ei);
-				push(to[ei], -1);
-			} else {
-				int usize = 1;
-				long usum = cost[u];
-				for (int ei = head[u], v, l, r; ei > 0; ei = next[ei]) {
-					v = to[ei];
-					l = find(u);
-					r = find(v);
-					usize += size[r];
-					usum += sum[r];
-					merge(l, r);
-				}
-				int i;
-				while (usum > m) {
-					i = find(u);
-					usize--;
-					usum -= cost[i];
-					pop(i);
-				}
-				i = find(u);
-				size[i] = usize;
-				sum[i] = usum;
-				ans = Math.max(ans, (long) usize * lead[u]);
-			}
-		}
-	}
-
-	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		n = (int) in.nval;
-		in.nextToken();
-		m = (int) in.nval;
-		prepare();
-		int root = 0;
-		for (int i = 1, f; i <= n; i++) {
-			in.nextToken();
-			f = (int) in.nval;
-			in.nextToken();
-			cost[i] = (int) in.nval;
-			in.nextToken();
-			lead[i] = (int) in.nval;
-			if (f == 0) {
-				root = i;
-			} else {
-				addEdge(f, i);
-			}
-		}
-		dfs(root);
-		out.println(ans);
-		out.flush();
-		out.close();
-		br.close();
-	}
-
-}
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//int leader[MAXN];
+//long long cost[MAXN];
+//long long ability[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//int fa[MAXN];
+//int siz[MAXN];
+//long long sum[MAXN];
+//
+//int find(int i) {
+//    return fa[i] = (fa[i] == i ? i : find(fa[i]));
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    int tmp;
+//    if (cost[i] < cost[j]) {
+//        tmp = i;
+//        i = j;
+//        j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        tmp = ls[i];
+//        ls[i] = rs[i];
+//        rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    fa[ls[i]] = fa[rs[i]] = i;
+//    return i;
+//}
+//
+//int pop(int i) {
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    fa[i] = merge(ls[i], rs[i]);
+//    ls[i] = rs[i] = dist[i] = 0;
+//    return fa[i];
+//}
+//
+//void prepare() {
+//    dist[0] = -1;
+//    for (int i = 1; i <= n; i++) {
+//        ls[i] = rs[i] = dist[i] = 0;
+//        siz[i] = 1;
+//        sum[i] = cost[i];
+//        fa[i] = i;
+//    }
+//}
+//
+//long long compute() {
+//    long long ans = 0;
+//    int p, psize, h, hsize;
+//    long long hsum, psum;
+//    for (int i = n; i >= 1; i--) {
+//        h = find(i);
+//        hsize = siz[h];
+//        hsum = sum[h];
+//        while (hsum > m) {
+//            pop(h);
+//            hsize--;
+//            hsum -= cost[h];
+//            h = find(i);
+//        }
+//        ans = max(ans, (long long)hsize * ability[i]);
+//        if (i > 1) {
+//            p = find(leader[i]);
+//            psize = siz[p];
+//            psum = sum[p];
+//            fa[p] = fa[h] = merge(p, h);
+//            siz[fa[p]] = psize + hsize;
+//            sum[fa[p]] = psum + hsum;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> leader[i] >> cost[i] >> ability[i];
+//    }
+//    prepare();
+//    cout << compute() << endl;
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class154/Code04_Dispatch3.java b/src/class154/Code04_Dispatch3.java
deleted file mode 100644
index dc89d3175..000000000
--- a/src/class154/Code04_Dispatch3.java
+++ /dev/null
@@ -1,131 +0,0 @@
-package class154;
-
-// 派遣，dfs用递归实现，C++版
-// 一共有n个忍者，每个忍者有工资、领导力、上级编号，三个属性
-// 如果某个忍者的上级编号为0，那么他是整棵忍者树的头
-// 你一共有m的预算，可以在忍者树上随意选一棵子树，然后在这棵子树上挑选忍者
-// 你选择某棵子树之后，不一定要选子树头的忍者，只要不超过m的预算，你就可以随意选择子树上的忍者
-// 最终收益 = 雇佣人数 * 子树头忍者的领导力，返回能取得的最大收益是多少
-// 输入保证，任何忍者的编号 > 该忍者上级的编号
-// 1 <= n <= 10^5           1 <= m <= 10^9
-// 1 <= 每个忍者工资 <= m     1 <= 每个忍者领导力 <= 10^9
-// 测试链接 : https://www.luogu.com.cn/problem/P1552
-// 逻辑和java的递归版完全一样，java必须改迭代版才能通过，C++的递归版就能通过
-// 这是洛谷没有考虑其他语言导致的，提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//const int MAXN = 100001;
-//int n, m;
-//long long ans;
-//int head[MAXN];
-//int nxt[MAXN];
-//int to[MAXN];
-//int cnt;
-//long long cost[MAXN];
-//long long lead[MAXN];
-//int ls[MAXN];  
-//int rs[MAXN];  
-//int dist[MAXN];
-//int fa[MAXN];
-//int siz[MAXN];  
-//long long sum[MAXN]; 
-//
-//void prepare() {
-//    ans = 0;
-//    cnt = 1;
-//    dist[0] = -1;
-//    for (int i = 1; i <= n; i++) {
-//        head[i] = ls[i] = rs[i] = dist[i] = siz[i] = 0;
-//        sum[i] = 0;
-//        fa[i] = i;
-//    }
-//}
-//
-//void addEdge(int u, int v) {
-//    nxt[cnt] = head[u];
-//    to[cnt] = v;
-//    head[u] = cnt++;
-//}
-//
-//int find(int i) {
-//    fa[i] = fa[i] == i ? i : find(fa[i]);
-//    return fa[i];
-//}
-//
-//int merge(int i, int j) {
-//    if (i == 0 || j == 0) {
-//        return i + j;
-//    }
-//    if (cost[i] < cost[j]) {
-//        int tmp = i;
-//        i = j;
-//        j = tmp;
-//    }
-//    rs[i] = merge(rs[i], j);
-//    if (dist[ls[i]] < dist[rs[i]]) {
-//        int tmp = ls[i];
-//        ls[i] = rs[i];
-//        rs[i] = tmp;
-//    }
-//    dist[i] = dist[rs[i]] + 1;
-//    fa[ls[i]] = fa[rs[i]] = i;
-//    return i;
-//}
-//
-//int pop(int i) {
-//    fa[ls[i]] = ls[i];
-//    fa[rs[i]] = rs[i];
-//    fa[i] = merge(ls[i], rs[i]);
-//    ls[i] = rs[i] = dist[i] = 0;
-//    return fa[i];
-//}
-//
-//void dfs(int u) {
-//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
-//        dfs(to[ei]);
-//    }
-//    int usize = 1;
-//    long long usum = cost[u];
-//    for (int ei = head[u], v, l, r; ei > 0; ei = nxt[ei]) {
-//        v = to[ei];
-//        l = find(u);
-//        r = find(v);
-//        usize += siz[r];
-//        usum += sum[r];
-//        merge(l, r);
-//    }
-//    int i;
-//    while (usum > m) {
-//        i = find(u);
-//        usize--;
-//        usum -= cost[i];
-//        pop(i);
-//    }
-//    i = find(u);
-//    siz[i] = usize;
-//    sum[i] = usum;
-//    ans = max(ans, (long long)usize * lead[u]);
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n >> m;
-//    prepare();
-//    int root = 0;
-//    for (int i = 1; i <= n; i++) {
-//        int f;
-//        cin >> f >> cost[i] >> lead[i];
-//        if (f == 0) {
-//            root = i;
-//        } else {
-//            addEdge(f, i);
-//        }
-//    }
-//    dfs(root);
-//    cout << ans << endl;
-//    return 0;
-//}
\ No newline at end of file

From 12bf39aa3555be3dc7af14f0694bcf14cbeb508b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 16:12:11 +0800
Subject: [PATCH 0236/1712] modify code

---
 src/class154/Code05_NumberSequence1.java |  7 +++----
 src/class154/Code05_NumberSequence2.java | 10 +++++-----
 2 files changed, 8 insertions(+), 9 deletions(-)

diff --git a/src/class154/Code05_NumberSequence1.java b/src/class154/Code05_NumberSequence1.java
index a0a1b4d44..1c18573d2 100644
--- a/src/class154/Code05_NumberSequence1.java
+++ b/src/class154/Code05_NumberSequence1.java
@@ -51,6 +51,8 @@ public static void prepare() {
 		dist[0] = -1;
 		for (int i = 1; i <= n; i++) {
 			left[i] = right[i] = dist[i] = 0;
+			father[i] = from[i] = to[i] = i;
+			size[i] = 1;
 		}
 	}
 
@@ -90,10 +92,6 @@ public static int pop(int i) {
 	}
 
 	public static long compute() {
-		for (int i = 1; i <= n; i++) {
-			father[i] = from[i] = to[i] = i;
-			size[i] = 1;
-		}
 		int stackSize = 0;
 		for (int i = 1, pre, cur, s; i <= n; i++) {
 			while (stackSize > 0) {
@@ -104,6 +102,7 @@ public static long compute() {
 				}
 				s = size[pre] + size[cur];
 				cur = merge(pre, cur);
+				// 大根堆只保留到上中位数
 				while (s > (i - from[pre] + 1 + 1) / 2) {
 					cur = pop(cur);
 					s--;
diff --git a/src/class154/Code05_NumberSequence2.java b/src/class154/Code05_NumberSequence2.java
index 28219c27c..82d0f00f9 100644
--- a/src/class154/Code05_NumberSequence2.java
+++ b/src/class154/Code05_NumberSequence2.java
@@ -31,6 +31,8 @@
 //    dist[0] = -1;
 //    for (int i = 1; i <= n; i++) {
 //        ls[i] = rs[i] = dist[i] = 0;
+//        fa[i] = from[i] = to[i] = i;
+//        siz[i] = 1;
 //    }
 //}
 //
@@ -40,7 +42,9 @@
 //}
 //
 //int merge(int i, int j) {
-//    if (i == 0 || j == 0) return i + j;
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
 //    int tmp;
 //    if (arr[i] < arr[j]) {
 //        tmp = i; i = j; j = tmp;
@@ -63,10 +67,6 @@
 //}
 //
 //long long compute() {
-//    for (int i = 1; i <= n; i++) {
-//        fa[i] = from[i] = to[i] = i;
-//        siz[i] = 1;
-//    }
 //    int stackSize = 0;
 //    for (int i = 1, pre, cur, s; i <= n; i++) {
 //        while (stackSize > 0) {

From a347aec38eefdecfc9ccb8c2a89b384a4736b994 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 17:48:39 +0800
Subject: [PATCH 0237/1712] modify code

---
 ...70\345\205\263\351\242\230\347\233\256.pptx" | Bin 0 -> 53867 bytes
 src/class154/Code05_NumberSequence1.java        |   7 +++++++
 2 files changed, 7 insertions(+)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243154\343\200\220\346\214\272\351\232\276\343\200\221\345\267\246\345\201\217\346\240\221\347\232\204\345\216\237\347\220\206\343\200\201\344\273\243\347\240\201\343\200\201\347\233\270\345\205\263\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243154\343\200\220\346\214\272\351\232\276\343\200\221\345\267\246\345\201\217\346\240\221\347\232\204\345\216\237\347\220\206\343\200\201\344\273\243\347\240\201\343\200\201\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243154\343\200\220\346\214\272\351\232\276\343\200\221\345\267\246\345\201\217\346\240\221\347\232\204\345\216\237\347\220\206\343\200\201\344\273\243\347\240\201\343\200\201\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..0e14d1b3c9b36720de62d75fffd332d918a5d6b7
GIT binary patch
literal 53867
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

literal 0
HcmV?d00001

diff --git a/src/class154/Code05_NumberSequence1.java b/src/class154/Code05_NumberSequence1.java
index 1c18573d2..d0ec590b0 100644
--- a/src/class154/Code05_NumberSequence1.java
+++ b/src/class154/Code05_NumberSequence1.java
@@ -29,22 +29,29 @@ public class Code05_NumberSequence1 {
 
 	public static long[] arr = new long[MAXN];
 
+	// 左偏树需要
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
 	public static int[] dist = new int[MAXN];
 
+	// 并查集向上的路径
 	public static int[] father = new int[MAXN];
 
+	// 集合表达区域的左下标
 	public static int[] from = new int[MAXN];
 
+	// 集合表达区域的右下标
 	public static int[] to = new int[MAXN];
 
+	// 集合里有几个数字
 	public static int[] size = new int[MAXN];
 
+	// 单调栈
 	public static int[] stack = new int[MAXN];
 
+	// 构造的数组
 	public static long[] ans = new long[MAXN];
 
 	public static void prepare() {

From 7b802f4f63540d98b89f408efa4a779513e7a076 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Dec 2024 19:57:42 +0800
Subject: [PATCH 0238/1712] modify code

---
 ...70\223\351\242\2306-Splay\346\240\221.pdf" | Bin 325745 -> 325003 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243153\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2306-Splay\346\240\221.pdf" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243153\343\200\220\346\211\251\345\261\225\343\200\221\346\234\211\345\272\217\350\241\250\344\270\223\351\242\2306-Splay\346\240\221.pdf"
index b7ba9cf170a12103ae84293da1e457052aa81e08..030f1a1ed9e3048441289db10770f9f05227368d 100644
GIT binary patch
delta 89028
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%0Dgc8LU@Ez8
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
O;~E-SS~_`7Hu@V=0uRCf

delta 89785
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
E7q7mjrT_o{


From e32ce77c7bf0db68a3e79b6d047374f072b60604 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Dec 2024 11:10:27 +0800
Subject: [PATCH 0239/1712] modify code

---
 src/class154/Code02_Convict1.java | 6 ++++--
 src/class154/Code02_Convict2.java | 5 +++--
 2 files changed, 7 insertions(+), 4 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 84310f66b..c1bf3cfa9 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -117,8 +117,10 @@ public static int remove(int i) {
 				}
 			}
 		}
-		up[i] = left[i] = right[i] = dist[i] = 0;
-		return father[s];
+		int ans = father[s];
+		// 节点s有可能是0号节点，为了安全，节点i信息清空，节点0的up、father清空
+		up[i] = left[i] = right[i] = dist[i] = up[0] = father[0] = 0;
+		return ans;
 	}
 
 	public static void reduce(int i, long v) {
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index 0e21f1f31..087e87366 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -92,8 +92,9 @@
 //            }
 //        }
 //    }
-//    up[i] = ls[i] = rs[i] = dist[i] = 0;
-//    return fa[s];
+//    int ans = fa[s];
+//    up[i] = ls[i] = rs[i] = dist[i] = up[0] = fa[0] = 0;
+//    return ans;
 //}
 //
 //void reduce(int i, long long v) {

From 3ceed36b621d8ecb79d85c2292f404817d20a9ff Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Dec 2024 11:13:24 +0800
Subject: [PATCH 0240/1712] modify code

---
 src/class154/Code02_Convict1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index c1bf3cfa9..2cd3aa2af 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -118,7 +118,7 @@ public static int remove(int i) {
 			}
 		}
 		int ans = father[s];
-		// 节点s有可能是0号节点，为了安全，节点i信息清空，节点0的up、father清空
+		// s可能是0号节点，所以为了安全，节点i信息清空，0号节点的up、father也清空
 		up[i] = left[i] = right[i] = dist[i] = up[0] = father[0] = 0;
 		return ans;
 	}

From 2ff28eb996517d01cf94c2f2f88304e0abd74d08 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Dec 2024 11:24:21 +0800
Subject: [PATCH 0241/1712] modify code

---
 src/class154/Code02_Convict1.java | 6 ++----
 src/class154/Code02_Convict2.java | 5 ++---
 2 files changed, 4 insertions(+), 7 deletions(-)

diff --git a/src/class154/Code02_Convict1.java b/src/class154/Code02_Convict1.java
index 2cd3aa2af..84310f66b 100644
--- a/src/class154/Code02_Convict1.java
+++ b/src/class154/Code02_Convict1.java
@@ -117,10 +117,8 @@ public static int remove(int i) {
 				}
 			}
 		}
-		int ans = father[s];
-		// s可能是0号节点，所以为了安全，节点i信息清空，0号节点的up、father也清空
-		up[i] = left[i] = right[i] = dist[i] = up[0] = father[0] = 0;
-		return ans;
+		up[i] = left[i] = right[i] = dist[i] = 0;
+		return father[s];
 	}
 
 	public static void reduce(int i, long v) {
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index 087e87366..0e21f1f31 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -92,9 +92,8 @@
 //            }
 //        }
 //    }
-//    int ans = fa[s];
-//    up[i] = ls[i] = rs[i] = dist[i] = up[0] = fa[0] = 0;
-//    return ans;
+//    up[i] = ls[i] = rs[i] = dist[i] = 0;
+//    return fa[s];
 //}
 //
 //void reduce(int i, long long v) {

From 30f61798da0a28c05adb6470466667cbdcef56bb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Dec 2024 16:09:37 +0800
Subject: [PATCH 0242/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 365 ++++++++++++++++++++++
 src/class155/Code02_TrickyOperation2.java | 207 ++++++++++++
 2 files changed, 572 insertions(+)
 create mode 100644 src/class155/Code02_TrickyOperation1.java
 create mode 100644 src/class155/Code02_TrickyOperation2.java

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
new file mode 100644
index 000000000..884a6f35e
--- /dev/null
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -0,0 +1,365 @@
+package class155;
+
+// 棘手的操作，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3273
+
+import java.io.IOException;
+import java.io.PrintWriter;
+import java.util.TreeMap;
+
+public class Code02_TrickyOperation1 {
+
+	public static int MAXN = 300001;
+
+	public static int[] num = new int[MAXN];
+
+	public static int[] up = new int[MAXN];
+
+	public static int[] left = new int[MAXN];
+
+	public static int[] right = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] add = new int[MAXN];
+
+	public static TreeMap<Integer, Integer> heads = new TreeMap<>();
+
+	public static int addAll = 0;
+
+	public static int[] stack = new int[MAXN];
+
+	public static int n, m;
+
+	public static void minusHead(int h) {
+		if (h != 0) {
+			int hnum = num[h] + add[h];
+			if (heads.get(hnum) == 1) {
+				heads.remove(hnum);
+			} else {
+				heads.put(hnum, heads.get(hnum) - 1);
+			}
+		}
+	}
+
+	public static void addHead(int h) {
+		if (h != 0) {
+			int hnum = num[h] + add[h];
+			heads.put(hnum, heads.getOrDefault(hnum, 0) + 1);
+		}
+	}
+
+	public static void prepare() {
+		dist[0] = -1;
+		heads.clear();
+		for (int i = 1; i <= n; i++) {
+			up[i] = left[i] = right[i] = dist[i] = 0;
+			father[i] = i;
+			size[i] = 1;
+			add[i] = 0;
+			addHead(i);
+		}
+		addAll = 0;
+	}
+
+	public static int find(int i) {
+		father[i] = father[i] == i ? i : find(father[i]);
+		return father[i];
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (num[i] < num[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		right[i] = merge(right[i], j);
+		up[right[i]] = i;
+		if (dist[left[i]] < dist[right[i]]) {
+			tmp = left[i];
+			left[i] = right[i];
+			right[i] = tmp;
+		}
+		dist[i] = dist[right[i]] + 1;
+		father[left[i]] = father[right[i]] = i;
+		return i;
+	}
+
+	public static int remove(int i) {
+		int h = find(i);
+		father[left[i]] = left[i];
+		father[right[i]] = right[i];
+		int s = merge(left[i], right[i]);
+		int f = up[i];
+		father[i] = s;
+		up[s] = f;
+		if (h != i) {
+			father[s] = h;
+			if (left[f] == i) {
+				left[f] = s;
+			} else {
+				right[f] = s;
+			}
+			for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
+				dist[f] = d + 1;
+				if (dist[left[f]] < dist[right[f]]) {
+					tmp = left[f];
+					left[f] = right[f];
+					right[f] = tmp;
+				}
+			}
+		}
+		up[i] = left[i] = right[i] = dist[i] = 0;
+		return father[s];
+	}
+
+	public static void down(int i, int v) {
+		if (i != 0) {
+			add[i] = 0;
+			int size = 0;
+			stack[++size] = i;
+			while (size > 0) {
+				i = stack[size--];
+				num[i] += v;
+				if (right[i] != 0) {
+					stack[++size] = right[i];
+				}
+				if (left[i] != 0) {
+					stack[++size] = left[i];
+				}
+			}
+		}
+	}
+
+	public static void u(int i, int j) {
+		int l = find(i);
+		int r = find(j);
+		if (l == r) {
+			return;
+		}
+		int lsize = size[l];
+		minusHead(l);
+		int rsize = size[r];
+		minusHead(r);
+		int addTag;
+		if (lsize <= rsize) {
+			down(l, add[l] - add[r]);
+			addTag = add[r];
+		} else {
+			down(r, add[r] - add[l]);
+			addTag = add[l];
+		}
+		int h = merge(l, r);
+		size[h] = lsize + rsize;
+		add[h] = addTag;
+		addHead(h);
+	}
+
+	public static void a1(int i, int v) {
+		int h = find(i);
+		minusHead(h);
+		int l = remove(i);
+		if (l != 0) {
+			size[l] = size[h] - 1;
+			add[l] = add[h];
+			addHead(l);
+		}
+		num[i] = num[i] + add[h] + v;
+		father[i] = i;
+		size[i] = 1;
+		add[i] = 0;
+		addHead(i);
+		u(l, i);
+	}
+
+	public static void a2(int i, int v) {
+		int h = find(i);
+		minusHead(h);
+		add[h] += v;
+		addHead(h);
+	}
+
+	public static void a3(int v) {
+		addAll += v;
+	}
+
+	public static int f1(int i) {
+		return num[i] + add[find(i)] + addAll;
+	}
+
+	public static int f2(int i) {
+		int h = find(i);
+		return num[h] + add[h] + addAll;
+	}
+
+	public static int f3() {
+		return heads.lastKey() + addAll;
+	}
+
+	public static void main(String[] args) {
+		ReaderWriter io = new ReaderWriter();
+		n = io.nextInt();
+		for (int i = 1; i <= n; i++) {
+			num[i] = io.nextInt();
+		}
+		prepare();
+		m = io.nextInt();
+		String op;
+		for (int i = 1, x, y; i <= m; i++) {
+			op = io.next();
+			if (op.equals("F3")) {
+				io.println(f3());
+			} else {
+				x = io.nextInt();
+				if (op.equals("U")) {
+					y = io.nextInt();
+					u(x, y);
+				} else if (op.equals("A1")) {
+					y = io.nextInt();
+					a1(x, y);
+				} else if (op.equals("A2")) {
+					y = io.nextInt();
+					a2(x, y);
+				} else if (op.equals("A3")) {
+					a3(x);
+				} else if (op.equals("F1")) {
+					io.println(f1(x));
+				} else {
+					io.println(f2(x));
+				}
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// ReaderWriter处理读写
+	public static class ReaderWriter extends PrintWriter {
+		byte[] buf = new byte[1 << 15];
+		int bId = 0, bSize = 0;
+		boolean eof = false;
+
+		public ReaderWriter() {
+			super(System.out);
+		}
+
+		private byte getByte() {
+			if (bId >= bSize) {
+				try {
+					bSize = System.in.read(buf);
+				} catch (IOException e) {
+					e.printStackTrace();
+				}
+				if (bSize == -1)
+					eof = true;
+				bId = 0;
+			}
+			return buf[bId++];
+		}
+
+		byte c;
+
+		public boolean hasNext() {
+			if (eof)
+				return false;
+			while ((c = getByte()) <= 32 && !eof)
+				;
+			if (eof)
+				return false;
+			bId--;
+			return true;
+		}
+
+		public String next() {
+			if (!hasNext())
+				return null;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			StringBuilder sb = new StringBuilder();
+			while (c > 32) {
+				sb.append((char) c);
+				c = getByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() {
+			if (!hasNext())
+				return Integer.MIN_VALUE;
+			int sign = 1;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			if (c == '-') {
+				sign = -1;
+				c = getByte();
+			}
+			int val = 0;
+			while (c >= '0' && c <= '9') {
+				val = val * 10 + (c - '0');
+				c = getByte();
+			}
+			bId--;
+			return val * sign;
+		}
+
+		public long nextLong() {
+			if (!hasNext())
+				return Long.MIN_VALUE;
+			int sign = 1;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			if (c == '-') {
+				sign = -1;
+				c = getByte();
+			}
+			long val = 0;
+			while (c >= '0' && c <= '9') {
+				val = val * 10 + (c - '0');
+				c = getByte();
+			}
+			bId--;
+			return val * sign;
+		}
+
+		public double nextDouble() {
+			if (!hasNext())
+				return Double.NaN;
+			int sign = 1;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			if (c == '-') {
+				sign = -1;
+				c = getByte();
+			}
+			double val = 0;
+			while (c >= '0' && c <= '9') {
+				val = val * 10 + (c - '0');
+				c = getByte();
+			}
+			if (c == '.') {
+				double mul = 1;
+				c = getByte();
+				while (c >= '0' && c <= '9') {
+					mul *= 0.1;
+					val += (c - '0') * mul;
+					c = getByte();
+				}
+			}
+			bId--;
+			return val * sign;
+		}
+	}
+
+}
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
new file mode 100644
index 000000000..0700f36b5
--- /dev/null
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -0,0 +1,207 @@
+package class155;
+
+// 棘手的操作，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3273
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//int num[MAXN];
+//int up[MAXN];
+//int ls[MAXN];
+//int rs[MAXN];
+//int dist[MAXN];
+//int fa[MAXN];
+//int siz[MAXN]; 
+//int add[MAXN];
+//int sta[MAXN];
+//multiset<int> heads;
+//int addAll = 0;
+//int n, m;
+//
+//void minusHead(int h) {
+//    if (h != 0) {
+//        heads.erase(heads.find(num[h] + add[h]));
+//    }
+//}
+//
+//void addHead(int h) {
+//    if (h != 0) {
+//        heads.insert(num[h] + add[h]);
+//    }
+//}
+//
+//void prepare() {
+//    dist[0] = -1;
+//    heads.clear();
+//    for (int i = 1; i <= n; i++) {
+//        up[i] = ls[i] = rs[i] = dist[i] = 0;
+//        fa[i] = i;
+//        siz[i] = 1;
+//        add[i] = 0;
+//        addHead(i);
+//    }
+//    addAll = 0;
+//}
+//
+//int find(int i) {
+//    fa[i] = fa[i] == i ? i : find(fa[i]);
+//    return fa[i];
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) return i + j;
+//    int tmp;
+//    if (num[i] < num[j]) {
+//        tmp = i; i = j; j = tmp;
+//    }
+//    rs[i] = merge(rs[i], j);
+//    up[rs[i]] = i;
+//    if (dist[ls[i]] < dist[rs[i]]) {
+//        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
+//    }
+//    dist[i] = dist[rs[i]] + 1;
+//    fa[ls[i]] = i;
+//    fa[rs[i]] = i;
+//    return i;
+//}
+//
+//int remove(int i) {
+//    int h = find(i);
+//    fa[ls[i]] = ls[i];
+//    fa[rs[i]] = rs[i];
+//    int s = merge(ls[i], rs[i]);
+//    int f = up[i];
+//    fa[i] = s;
+//    up[s] = f;
+//    if (h != i) {
+//        fa[s] = h;
+//        if (ls[f] == i) {
+//            ls[f] = s;
+//        } else {
+//            rs[f] = s;
+//        }
+//        for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
+//            dist[f] = d + 1;
+//            if (dist[ls[f]] < dist[rs[f]]) {
+//                tmp = ls[f]; ls[f] = rs[f]; rs[f] = tmp;
+//            }
+//        }
+//    }
+//    up[i] = ls[i] = rs[i] = dist[i] = 0;
+//    return fa[s];
+//}
+//
+//void down(int i, int v) {
+//    if (i != 0) {
+//        add[i] = 0;
+//        int size = 0;
+//        sta[++size] = i;
+//        while (size > 0) {
+//            i = sta[size--];
+//            num[i] += v;
+//            if (rs[i] != 0) sta[++size] = rs[i];
+//            if (ls[i] != 0) sta[++size] = ls[i];
+//        }
+//    }
+//}
+//
+//void u(int i, int j) {
+//    int l = find(i);
+//    int r = find(j);
+//    if (l == r) return;
+//    int lsize = siz[l];
+//    minusHead(l);
+//    int rsize = siz[r];
+//    minusHead(r);
+//    int addTag;
+//    if (lsize <= rsize) {
+//        down(l, add[l] - add[r]);
+//        addTag = add[r];
+//    } else {
+//        down(r, add[r] - add[l]);
+//        addTag = add[l];
+//    }
+//    int h = merge(l, r);
+//    siz[h] = lsize + rsize;
+//    add[h] = addTag;
+//    addHead(h);
+//}
+//
+//void a1(int i, int v) {
+//    int h = find(i);
+//    minusHead(h);
+//    int l = remove(i);
+//    if (l != 0) {
+//        siz[l] = siz[h] - 1;
+//        add[l] = add[h];
+//        addHead(l);
+//    }
+//    num[i] = num[i] + add[h] + v;
+//    fa[i] = i;
+//    siz[i] = 1;
+//    add[i] = 0;
+//    addHead(i);
+//    u(l, i);
+//}
+//
+//void a2(int i, int v) {
+//    int h = find(i);
+//    minusHead(h);
+//    add[h] += v;
+//    addHead(h);
+//}
+//
+//void a3(int v) {
+//    addAll += v;
+//}
+//
+//int f1(int i) {
+//    return num[i] + add[find(i)] + addAll;
+//}
+//
+//int f2(int i) {
+//    int h = find(i);
+//    return num[h] + add[h] + addAll;
+//}
+//
+//int f3() {
+//    return (*heads.rbegin()) + addAll;
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) cin >> num[i];
+//    prepare();
+//    cin >> m;
+//    for (int i = 1; i <= m; i++) {
+//        string op; 
+//        cin >> op;
+//        if (op == "F3") {
+//            cout << f3() << "\n";
+//        } else {
+//            int x; cin >> x;
+//            if (op == "U") {
+//                int y; cin >> y;
+//                u(x, y);
+//            } else if (op == "A1") {
+//                int y; cin >> y;
+//                a1(x, y);
+//            } else if (op == "A2") {
+//                int y; cin >> y;
+//                a2(x, y);
+//            } else if (op == "A3") {
+//                a3(x);
+//            } else if (op == "F1") {
+//                cout << f1(x) << "\n";
+//            } else {
+//                cout << f2(x) << "\n";
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From aaa8633f61d9a3bf3553c0691b7d4d9fe571c306 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Dec 2024 16:10:39 +0800
Subject: [PATCH 0243/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 884a6f35e..668eb81c3 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -241,7 +241,7 @@ public static void main(String[] args) {
 		io.close();
 	}
 
-	// ReaderWriter处理读写
+	// 读写工具类
 	public static class ReaderWriter extends PrintWriter {
 		byte[] buf = new byte[1 << 15];
 		int bId = 0, bSize = 0;

From 62f3739418687be399fea762d84fda0d7428d264 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Dec 2024 21:14:10 +0800
Subject: [PATCH 0244/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 668eb81c3..a4fd43a04 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -243,7 +243,7 @@ public static void main(String[] args) {
 
 	// 读写工具类
 	public static class ReaderWriter extends PrintWriter {
-		byte[] buf = new byte[1 << 15];
+		byte[] buf = new byte[1 << 10];
 		int bId = 0, bSize = 0;
 		boolean eof = false;
 

From d418999607286fb4e7819a4ba497426e48fe7a95 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 18 Dec 2024 23:34:11 +0800
Subject: [PATCH 0245/1712] modify code

---
 src/class155/Code03_KShortestPath1.java | 324 ++++++++++++++++++++++++
 src/class155/Code03_KShortestPath2.java | 237 +++++++++++++++++
 2 files changed, 561 insertions(+)
 create mode 100644 src/class155/Code03_KShortestPath1.java
 create mode 100644 src/class155/Code03_KShortestPath2.java

diff --git a/src/class155/Code03_KShortestPath1.java b/src/class155/Code03_KShortestPath1.java
new file mode 100644
index 000000000..54a9c312e
--- /dev/null
+++ b/src/class155/Code03_KShortestPath1.java
@@ -0,0 +1,324 @@
+package class155;
+
+// 可持久化左偏树 + k短路，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2483
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+
+public class Code03_KShortestPath1 {
+
+	public static int MAXN = 50001;
+	public static int MAXM = 200001;
+	public static int MAXT = MAXN * 20;
+	public static int MAXH = 4200001;
+
+	public static int n, m;
+	public static double money;
+
+	public static int[] headg = new int[MAXN];
+	public static int[] tog = new int[MAXM];
+	public static int[] nextg = new int[MAXM];
+	public static double[] weightg = new double[MAXM];
+	public static int cntg = 0;
+
+	public static int[] headr = new int[MAXN];
+	public static int[] tor = new int[MAXM];
+	public static int[] nextr = new int[MAXM];
+	public static double[] weightr = new double[MAXM];
+	public static int cntr = 0;
+
+	public static int[] rt = new int[MAXN];
+	public static double[] num = new double[MAXT];
+	public static int[] left = new int[MAXT];
+	public static int[] right = new int[MAXT];
+	public static int[] dist = new int[MAXT];
+	public static int[] father = new int[MAXT];
+	public static int cnth = 0;
+
+	public static int[] idx = new int[MAXH];
+	public static double[] cost = new double[MAXH];
+	public static int cntd;
+	public static int[] heap = new int[MAXH];
+	public static int cntp;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] path = new int[MAXN];
+	public static double[] dis = new double[MAXN];
+
+	public static void addEdgeG(int u, int v, double w) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		weightg[cntg] = w;
+		headg[u] = cntg;
+	}
+
+	public static void addEdgeR(int u, int v, double w) {
+		nextr[++cntr] = headr[u];
+		tor[cntr] = v;
+		weightr[cntr] = w;
+		headr[u] = cntr;
+	}
+
+	public static int init(int f, double v) {
+		num[++cnth] = v;
+		left[cnth] = right[cnth] = dist[cnth] = 0;
+		father[cnth] = f;
+		return cnth;
+	}
+
+	public static int clone(int i) {
+		num[++cnth] = num[i];
+		left[cnth] = left[i];
+		right[cnth] = right[i];
+		dist[cnth] = dist[i];
+		father[cnth] = father[i];
+		return cnth;
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (num[i] > num[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		int k = clone(i);
+		right[k] = merge(right[k], j);
+		if (dist[left[k]] < dist[right[k]]) {
+			tmp = left[k];
+			left[k] = right[k];
+			right[k] = tmp;
+		}
+		dist[k] = dist[right[k]] + 1;
+		return k;
+	}
+
+	public static void heapAdd(int i, double v) {
+		idx[++cntd] = i;
+		cost[cntd] = v;
+		heap[++cntp] = cntd;
+		int cur = cntp, up = cur / 2, tmp;
+		while (cur > 1 && cost[heap[up]] > cost[heap[cur]]) {
+			tmp = heap[up];
+			heap[up] = heap[cur];
+			heap[cur] = tmp;
+			cur = up;
+			up = cur / 2;
+		}
+	}
+
+	public static int heapPop() {
+		int ans = heap[1];
+		heap[1] = heap[cntp--];
+		int cur = 1, l = cur * 2, r = l + 1, best, tmp;
+		while (l <= cntp) {
+			best = (r <= cntp && cost[heap[r]] < cost[heap[l]]) ? r : l;
+			best = (cost[heap[best]] < cost[heap[cur]]) ? best : cur;
+			if (best == cur) {
+				break;
+			}
+			tmp = heap[best];
+			heap[best] = heap[cur];
+			heap[cur] = tmp;
+			cur = best;
+			l = cur * 2;
+			r = l + 1;
+		}
+		return ans;
+	}
+
+	public static boolean isEmpty() {
+		return cntp == 0;
+	}
+
+	public static void dijkstra() {
+		dis[n] = 0;
+		for (int i = 1; i < n; i++) {
+			dis[i] = Double.POSITIVE_INFINITY;
+		}
+		cntd = cntp = 0;
+		heapAdd(n, 0);
+		while (!isEmpty()) {
+			int h = heapPop();
+			int u = idx[h];
+			double w = cost[h];
+			if (!vis[u]) {
+				vis[u] = true;
+				for (int e = headr[u], v; e > 0; e = nextr[e]) {
+					v = tor[e];
+					if (dis[v] > w + weightr[e]) {
+						dis[v] = w + weightr[e];
+						path[v] = e;
+						heapAdd(v, dis[v]);
+					}
+				}
+			}
+		}
+	}
+
+	public static void mergeRoad() {
+		cntd = cntp = 0;
+		for (int i = 1; i <= n; i++) {
+			heapAdd(i, dis[i]);
+		}
+		dist[0] = -1;
+		while (!isEmpty()) {
+			int h = heapPop();
+			int u = idx[h];
+			for (int e = headg[u]; e > 0; e = nextg[e]) {
+				if (e != path[u]) {
+					rt[u] = merge(rt[u], init(tog[e], weightg[e] + dis[tog[e]] - dis[u]));
+				}
+			}
+			if (path[u] != 0) {
+				rt[u] = merge(rt[u], rt[tog[path[u]]]);
+			}
+		}
+	}
+
+	public static int expand() {
+		int ans = 0;
+		money -= dis[1];
+		if (money >= 0) {
+			ans++;
+			cntd = cntp = 0;
+			if (rt[1] != 0) {
+				heapAdd(rt[1], num[rt[1]]);
+			}
+			while (!isEmpty()) {
+				int h = heapPop();
+				int u = idx[h];
+				double w = cost[h];
+				money -= w + dis[1];
+				if (money < 0) {
+					break;
+				}
+				ans++;
+				if (left[u] != 0) {
+					heapAdd(left[u], w - num[u] + num[left[u]]);
+				}
+				if (right[u] != 0) {
+					heapAdd(right[u], w - num[u] + num[right[u]]);
+				}
+				if (father[u] != 0 && rt[father[u]] != 0) {
+					heapAdd(rt[father[u]], w + num[rt[father[u]]]);
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		money = in.nextDouble();
+		int u, v;
+		double w;
+		for (int i = 1; i <= m; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextDouble();
+			if (u != n) {
+				addEdgeG(u, v, w);
+				addEdgeR(v, u, w);
+			}
+		}
+		dijkstra();
+		mergeRoad();
+		out.write(expand() + "\n");
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public boolean hasNext() throws IOException {
+			while (hasNextByte()) {
+				byte b = buffer[ptr];
+				if (!isWhitespace(b))
+					return true;
+				ptr++;
+			}
+			return false;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public double nextDouble() throws IOException {
+			double num = 0, div = 1;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != '.' && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			if (b == '.') {
+				b = readByte();
+				while (!isWhitespace(b) && b != -1) {
+					num += (b - '0') / (div *= 10);
+					b = readByte();
+				}
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class155/Code03_KShortestPath2.java b/src/class155/Code03_KShortestPath2.java
new file mode 100644
index 000000000..06cee5e58
--- /dev/null
+++ b/src/class155/Code03_KShortestPath2.java
@@ -0,0 +1,237 @@
+package class155;
+
+// 可持久化左偏树 + k短路，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2483
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50001;
+//const int MAXM = 200001;
+//const int MAXT = MAXN * 20;
+//const int MAXH = 4200001;
+//
+//int n, m;
+//double money;
+//
+//int headg[MAXN];
+//int tog[MAXM];
+//int nextg[MAXM];
+//double weightg[MAXM];
+//int cntg = 0;
+//
+//int headr[MAXN];
+//int tor[MAXM];
+//int nextr[MAXM];
+//double weightr[MAXM];
+//int cntr = 0;
+//
+//int rt[MAXN];
+//double num[MAXT];
+//int ls[MAXT];
+//int rs[MAXT];
+//int dist[MAXT];
+//int fa[MAXT];
+//int cnth = 0;
+//
+//int idx[MAXH];
+//double cost[MAXH];
+//int cntd = 0;
+//int heap[MAXH];
+//int cntp = 0;
+//
+//bool vis[MAXN];
+//int path[MAXN];
+//double dis[MAXN];
+//
+//void addEdgeG(int u, int v, double w){
+//    cntg++;
+//    nextg[cntg] = headg[u];
+//    tog[cntg] = v;
+//    weightg[cntg] = w;
+//    headg[u] = cntg;
+//}
+//
+//void addEdgeR(int u, int v, double w){
+//    cntr++;
+//    nextr[cntr] = headr[u];
+//    tor[cntr] = v;
+//    weightr[cntr] = w;
+//    headr[u] = cntr;
+//}
+//
+//int init(int f, double v){
+//    cnth++;
+//    num[cnth] = v;
+//    ls[cnth] = rs[cnth] = dist[cnth] = 0;
+//    fa[cnth] = f;
+//    return cnth;
+//}
+//
+//int clone(int i){
+//    cnth++;
+//    num[cnth] = num[i];
+//    ls[cnth] = ls[i];
+//    rs[cnth] = rs[i];
+//    dist[cnth] = dist[i];
+//    fa[cnth] = fa[i];
+//    return cnth;
+//}
+//
+//int merge(int i, int j){
+//    if(i == 0 || j == 0){
+//        return i + j;
+//    }
+//    if(num[i] > num[j]){
+//        swap(i, j);
+//    }
+//    int k = clone(i);
+//    rs[k] = merge(rs[k], j);
+//    if(dist[ls[k]] < dist[rs[k]]){
+//        swap(ls[k], rs[k]);
+//    }
+//    dist[k] = dist[rs[k]] + 1;
+//    return k;
+//}
+//
+//void heapAdd(int i, double v){
+//    cntd++;
+//    idx[cntd] = i;
+//    cost[cntd] = v;
+//    cntp++;
+//    heap[cntp] = cntd;
+//    int cur = cntp;
+//    while(cur > 1){
+//        int up = cur / 2;
+//        if(cost[heap[up]] > cost[heap[cur]]){
+//            swap(heap[up], heap[cur]);
+//            cur = up;
+//        }
+//        else{
+//            break;
+//        }
+//    }
+//}
+//
+//int heapPop(){
+//    int ans = heap[1];
+//    heap[1] = heap[cntp];
+//    cntp--;
+//    int cur = 1;
+//    while(cur * 2 <= cntp){
+//        int l = cur * 2;
+//        int r = l + 1;
+//        int best = l;
+//        if(r <= cntp && cost[heap[r]] < cost[heap[l]]){
+//            best = r;
+//        }
+//        if(cost[heap[best]] < cost[heap[cur]]){
+//            swap(heap[best], heap[cur]);
+//            cur = best;
+//        }
+//        else{
+//            break;
+//        }
+//    }
+//    return ans;
+//}
+//
+//bool isEmpty(){
+//    return cntp == 0;
+//}
+//
+//void dijkstra(){
+//    fill(dis, dis + MAXN, 1e18);
+//    dis[n] = 0;
+//    cntd = cntp = 0;
+//    heapAdd(n, 0.0);
+//    while(!isEmpty()){
+//        int h = heapPop();
+//        int u = idx[h];
+//        double w = cost[h];
+//        if(!vis[u]){
+//            vis[u] = true;
+//            for(int e = headr[u]; e != 0; e = nextr[e]){
+//                int v = tor[e];
+//                if(dis[v] > w + weightr[e]){
+//                    dis[v] = w + weightr[e];
+//                    path[v] = e;
+//                    heapAdd(v, dis[v]);
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void mergeRoad(){
+//    cntd = cntp = 0;
+//    for(int i = 1; i <= n; i++){
+//        heapAdd(i, dis[i]);
+//    }
+//    dist[0] = -1;
+//    while(!isEmpty()){
+//        int h = heapPop();
+//        int u = idx[h];
+//        for(int e = headg[u]; e != 0; e = nextg[e]){
+//            if(e != path[u]){
+//                rt[u] = merge(rt[u], init(tog[e], weightg[e] + dis[tog[e]] - dis[u]));
+//            }
+//        }
+//        if(path[u] != 0){
+//            rt[u] = merge(rt[u], rt[tog[path[u]]]);
+//        }
+//    }
+//}
+//
+//int expand(){
+//    int ans = 0;
+//    money -= dis[1];
+//    if(money >= 0){
+//        ans++;
+//        cntd = cntp = 0;
+//        if(rt[1] != 0){
+//            heapAdd(rt[1], num[rt[1]]);
+//        }
+//        while(!isEmpty()){
+//            int h = heapPop();
+//            int u = idx[h];
+//            double w = cost[h];
+//            money -= w + dis[1];
+//            if(money < 0){
+//                break;
+//            }
+//            ans++;
+//            if(ls[u] != 0){
+//                heapAdd(ls[u], w - num[u] + num[ls[u]]);
+//            }
+//            if(rs[u] != 0){
+//                heapAdd(rs[u], w - num[u] + num[rs[u]]);
+//            }
+//            if(fa[u] != 0 && rt[fa[u]] != 0){
+//                heapAdd(rt[fa[u]], w + num[rt[fa[u]]]);
+//            }
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(NULL);
+//    cin >> n >> m >> money;
+//    int u, v;
+//    double w;
+//    for(int i = 1; i <= m; i++){
+//        cin >> u >> v >> w;
+//        if(u != n){
+//            addEdgeG(u, v, w);
+//            addEdgeR(v, u, w);
+//        }
+//    }
+//    dijkstra();
+//    mergeRoad();
+//    int ans = expand();
+//    cout << ans << endl;
+//    return 0;
+//}
\ No newline at end of file

From 2638a2cd65b1025e132979d7483c6a6f54ae9c5e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 18 Dec 2024 23:52:10 +0800
Subject: [PATCH 0246/1712] modify code

---
 src/class155/Code03_KShortestPath1.java | 42 ++++++++++----------
 src/class155/Code03_KShortestPath2.java | 51 ++++++++++++-------------
 2 files changed, 45 insertions(+), 48 deletions(-)

diff --git a/src/class155/Code03_KShortestPath1.java b/src/class155/Code03_KShortestPath1.java
index 54a9c312e..0be70d59d 100644
--- a/src/class155/Code03_KShortestPath1.java
+++ b/src/class155/Code03_KShortestPath1.java
@@ -36,13 +36,13 @@ public class Code03_KShortestPath1 {
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
 	public static int[] father = new int[MAXT];
-	public static int cnth = 0;
+	public static int cntt = 0;
 
 	public static int[] idx = new int[MAXH];
 	public static double[] cost = new double[MAXH];
 	public static int cntd;
 	public static int[] heap = new int[MAXH];
-	public static int cntp;
+	public static int cnth;
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] path = new int[MAXN];
@@ -63,19 +63,19 @@ public static void addEdgeR(int u, int v, double w) {
 	}
 
 	public static int init(int f, double v) {
-		num[++cnth] = v;
-		left[cnth] = right[cnth] = dist[cnth] = 0;
-		father[cnth] = f;
-		return cnth;
+		num[++cntt] = v;
+		left[cntt] = right[cntt] = dist[cntt] = 0;
+		father[cntt] = f;
+		return cntt;
 	}
 
 	public static int clone(int i) {
-		num[++cnth] = num[i];
-		left[cnth] = left[i];
-		right[cnth] = right[i];
-		dist[cnth] = dist[i];
-		father[cnth] = father[i];
-		return cnth;
+		num[++cntt] = num[i];
+		left[cntt] = left[i];
+		right[cntt] = right[i];
+		dist[cntt] = dist[i];
+		father[cntt] = father[i];
+		return cntt;
 	}
 
 	public static int merge(int i, int j) {
@@ -102,8 +102,8 @@ public static int merge(int i, int j) {
 	public static void heapAdd(int i, double v) {
 		idx[++cntd] = i;
 		cost[cntd] = v;
-		heap[++cntp] = cntd;
-		int cur = cntp, up = cur / 2, tmp;
+		heap[++cnth] = cntd;
+		int cur = cnth, up = cur / 2, tmp;
 		while (cur > 1 && cost[heap[up]] > cost[heap[cur]]) {
 			tmp = heap[up];
 			heap[up] = heap[cur];
@@ -115,10 +115,10 @@ public static void heapAdd(int i, double v) {
 
 	public static int heapPop() {
 		int ans = heap[1];
-		heap[1] = heap[cntp--];
+		heap[1] = heap[cnth--];
 		int cur = 1, l = cur * 2, r = l + 1, best, tmp;
-		while (l <= cntp) {
-			best = (r <= cntp && cost[heap[r]] < cost[heap[l]]) ? r : l;
+		while (l <= cnth) {
+			best = (r <= cnth && cost[heap[r]] < cost[heap[l]]) ? r : l;
 			best = (cost[heap[best]] < cost[heap[cur]]) ? best : cur;
 			if (best == cur) {
 				break;
@@ -134,7 +134,7 @@ public static int heapPop() {
 	}
 
 	public static boolean isEmpty() {
-		return cntp == 0;
+		return cnth == 0;
 	}
 
 	public static void dijkstra() {
@@ -142,7 +142,7 @@ public static void dijkstra() {
 		for (int i = 1; i < n; i++) {
 			dis[i] = Double.POSITIVE_INFINITY;
 		}
-		cntd = cntp = 0;
+		cntd = cnth = 0;
 		heapAdd(n, 0);
 		while (!isEmpty()) {
 			int h = heapPop();
@@ -163,7 +163,7 @@ public static void dijkstra() {
 	}
 
 	public static void mergeRoad() {
-		cntd = cntp = 0;
+		cntd = cnth = 0;
 		for (int i = 1; i <= n; i++) {
 			heapAdd(i, dis[i]);
 		}
@@ -187,7 +187,7 @@ public static int expand() {
 		money -= dis[1];
 		if (money >= 0) {
 			ans++;
-			cntd = cntp = 0;
+			cntd = cnth = 0;
 			if (rt[1] != 0) {
 				heapAdd(rt[1], num[rt[1]]);
 			}
diff --git a/src/class155/Code03_KShortestPath2.java b/src/class155/Code03_KShortestPath2.java
index 06cee5e58..ad1cc1a7b 100644
--- a/src/class155/Code03_KShortestPath2.java
+++ b/src/class155/Code03_KShortestPath2.java
@@ -33,13 +33,13 @@
 //int rs[MAXT];
 //int dist[MAXT];
 //int fa[MAXT];
-//int cnth = 0;
+//int cntt = 0;
 //
 //int idx[MAXH];
 //double cost[MAXH];
 //int cntd = 0;
 //int heap[MAXH];
-//int cntp = 0;
+//int cnth = 0;
 //
 //bool vis[MAXN];
 //int path[MAXN];
@@ -62,21 +62,21 @@
 //}
 //
 //int init(int f, double v){
-//    cnth++;
-//    num[cnth] = v;
-//    ls[cnth] = rs[cnth] = dist[cnth] = 0;
-//    fa[cnth] = f;
-//    return cnth;
+//    cntt++;
+//    num[cntt] = v;
+//    ls[cntt] = rs[cntt] = dist[cntt] = 0;
+//    fa[cntt] = f;
+//    return cntt;
 //}
 //
 //int clone(int i){
-//    cnth++;
-//    num[cnth] = num[i];
-//    ls[cnth] = ls[i];
-//    rs[cnth] = rs[i];
-//    dist[cnth] = dist[i];
-//    fa[cnth] = fa[i];
-//    return cnth;
+//    cntt++;
+//    num[cntt] = num[i];
+//    ls[cntt] = ls[i];
+//    rs[cntt] = rs[i];
+//    dist[cntt] = dist[i];
+//    fa[cntt] = fa[i];
+//    return cntt;
 //}
 //
 //int merge(int i, int j){
@@ -96,12 +96,10 @@
 //}
 //
 //void heapAdd(int i, double v){
-//    cntd++;
-//    idx[cntd] = i;
+//    idx[++cntd] = i;
 //    cost[cntd] = v;
-//    cntp++;
-//    heap[cntp] = cntd;
-//    int cur = cntp;
+//    heap[++cnth] = cntd;
+//    int cur = cnth;
 //    while(cur > 1){
 //        int up = cur / 2;
 //        if(cost[heap[up]] > cost[heap[cur]]){
@@ -116,14 +114,13 @@
 //
 //int heapPop(){
 //    int ans = heap[1];
-//    heap[1] = heap[cntp];
-//    cntp--;
+//    heap[1] = heap[cnth--];
 //    int cur = 1;
-//    while(cur * 2 <= cntp){
+//    while(cur * 2 <= cnth){
 //        int l = cur * 2;
 //        int r = l + 1;
 //        int best = l;
-//        if(r <= cntp && cost[heap[r]] < cost[heap[l]]){
+//        if(r <= cnth && cost[heap[r]] < cost[heap[l]]){
 //            best = r;
 //        }
 //        if(cost[heap[best]] < cost[heap[cur]]){
@@ -138,13 +135,13 @@
 //}
 //
 //bool isEmpty(){
-//    return cntp == 0;
+//    return cnth == 0;
 //}
 //
 //void dijkstra(){
 //    fill(dis, dis + MAXN, 1e18);
 //    dis[n] = 0;
-//    cntd = cntp = 0;
+//    cntd = cnth = 0;
 //    heapAdd(n, 0.0);
 //    while(!isEmpty()){
 //        int h = heapPop();
@@ -165,7 +162,7 @@
 //}
 //
 //void mergeRoad(){
-//    cntd = cntp = 0;
+//    cntd = cnth = 0;
 //    for(int i = 1; i <= n; i++){
 //        heapAdd(i, dis[i]);
 //    }
@@ -189,7 +186,7 @@
 //    money -= dis[1];
 //    if(money >= 0){
 //        ans++;
-//        cntd = cntp = 0;
+//        cntd = cnth = 0;
 //        if(rt[1] != 0){
 //            heapAdd(rt[1], num[rt[1]]);
 //        }

From 51b2e919c335af3a0ae1700829f0871d16c55222 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 18 Dec 2024 23:53:38 +0800
Subject: [PATCH 0247/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 1 +
 src/class155/Code02_TrickyOperation2.java | 2 ++
 src/class155/Code03_KShortestPath1.java   | 1 +
 src/class155/Code03_KShortestPath2.java   | 2 ++
 4 files changed, 6 insertions(+)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index a4fd43a04..243581336 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -2,6 +2,7 @@
 
 // 棘手的操作，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3273
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.PrintWriter;
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
index 0700f36b5..249fdc465 100644
--- a/src/class155/Code02_TrickyOperation2.java
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -2,6 +2,8 @@
 
 // 棘手的操作，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3273
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
 
 //#include <bits/stdc++.h>
 //
diff --git a/src/class155/Code03_KShortestPath1.java b/src/class155/Code03_KShortestPath1.java
index 0be70d59d..74c9a0905 100644
--- a/src/class155/Code03_KShortestPath1.java
+++ b/src/class155/Code03_KShortestPath1.java
@@ -2,6 +2,7 @@
 
 // 可持久化左偏树 + k短路，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedWriter;
 import java.io.IOException;
diff --git a/src/class155/Code03_KShortestPath2.java b/src/class155/Code03_KShortestPath2.java
index ad1cc1a7b..34b4d5cf8 100644
--- a/src/class155/Code03_KShortestPath2.java
+++ b/src/class155/Code03_KShortestPath2.java
@@ -2,6 +2,8 @@
 
 // 可持久化左偏树 + k短路，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
 
 //#include <bits/stdc++.h>
 //

From c8cc56b202211061d7ba757c9de58844a43e33dd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Dec 2024 14:38:56 +0800
Subject: [PATCH 0248/1712] modify code

---
 ...{Code03_KShortestPath1.java => Code04_KShortestPath1.java} | 4 ++--
 ...{Code03_KShortestPath2.java => Code04_KShortestPath2.java} | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class155/{Code03_KShortestPath1.java => Code04_KShortestPath1.java} (98%)
 rename src/class155/{Code03_KShortestPath2.java => Code04_KShortestPath2.java} (99%)

diff --git a/src/class155/Code03_KShortestPath1.java b/src/class155/Code04_KShortestPath1.java
similarity index 98%
rename from src/class155/Code03_KShortestPath1.java
rename to src/class155/Code04_KShortestPath1.java
index 74c9a0905..22e9735d6 100644
--- a/src/class155/Code03_KShortestPath1.java
+++ b/src/class155/Code04_KShortestPath1.java
@@ -1,6 +1,6 @@
 package class155;
 
-// 可持久化左偏树 + k短路，java版
+// k短路问题最优解，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -9,7 +9,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code03_KShortestPath1 {
+public class Code04_KShortestPath1 {
 
 	public static int MAXN = 50001;
 	public static int MAXM = 200001;
diff --git a/src/class155/Code03_KShortestPath2.java b/src/class155/Code04_KShortestPath2.java
similarity index 99%
rename from src/class155/Code03_KShortestPath2.java
rename to src/class155/Code04_KShortestPath2.java
index 34b4d5cf8..3a5ce0b91 100644
--- a/src/class155/Code03_KShortestPath2.java
+++ b/src/class155/Code04_KShortestPath2.java
@@ -1,6 +1,6 @@
 package class155;
 
-// 可持久化左偏树 + k短路，C++版
+// k短路问题的最优解，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From fbd2f22ed026eaab11747cb9de86d09d567d8104 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Dec 2024 14:52:06 +0800
Subject: [PATCH 0249/1712] modify code

---
 src/class155/Code04_KShortestPath1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/Code04_KShortestPath1.java b/src/class155/Code04_KShortestPath1.java
index 22e9735d6..a5a6b01dc 100644
--- a/src/class155/Code04_KShortestPath1.java
+++ b/src/class155/Code04_KShortestPath1.java
@@ -1,6 +1,6 @@
 package class155;
 
-// k短路问题最优解，java版
+// k短路问题的最优解，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 55f5fb898dd3a687cc6df751377080336cee62c5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Dec 2024 18:46:38 +0800
Subject: [PATCH 0250/1712] modify code

---
 src/class155/Code04_KShortestPath1.java | 21 +++++++++++----------
 src/class155/Code04_KShortestPath2.java | 18 +++++++++---------
 2 files changed, 20 insertions(+), 19 deletions(-)

diff --git a/src/class155/Code04_KShortestPath1.java b/src/class155/Code04_KShortestPath1.java
index a5a6b01dc..83cdd5ef2 100644
--- a/src/class155/Code04_KShortestPath1.java
+++ b/src/class155/Code04_KShortestPath1.java
@@ -33,10 +33,10 @@ public class Code04_KShortestPath1 {
 
 	public static int[] rt = new int[MAXN];
 	public static double[] num = new double[MAXT];
+	public static int[] up = new int[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
-	public static int[] father = new int[MAXT];
 	public static int cntt = 0;
 
 	public static int[] idx = new int[MAXH];
@@ -65,17 +65,17 @@ public static void addEdgeR(int u, int v, double w) {
 
 	public static int init(int f, double v) {
 		num[++cntt] = v;
+		up[cntt] = f;
 		left[cntt] = right[cntt] = dist[cntt] = 0;
-		father[cntt] = f;
 		return cntt;
 	}
 
 	public static int clone(int i) {
 		num[++cntt] = num[i];
+		up[cntt] = up[i];
 		left[cntt] = left[i];
 		right[cntt] = right[i];
 		dist[cntt] = dist[i];
-		father[cntt] = father[i];
 		return cntt;
 	}
 
@@ -134,7 +134,7 @@ public static int heapPop() {
 		return ans;
 	}
 
-	public static boolean isEmpty() {
+	public static boolean heapEmpty() {
 		return cnth == 0;
 	}
 
@@ -145,7 +145,7 @@ public static void dijkstra() {
 		}
 		cntd = cnth = 0;
 		heapAdd(n, 0);
-		while (!isEmpty()) {
+		while (!heapEmpty()) {
 			int h = heapPop();
 			int u = idx[h];
 			double w = cost[h];
@@ -169,7 +169,7 @@ public static void mergeRoad() {
 			heapAdd(i, dis[i]);
 		}
 		dist[0] = -1;
-		while (!isEmpty()) {
+		while (!heapEmpty()) {
 			int h = heapPop();
 			int u = idx[h];
 			for (int e = headg[u]; e > 0; e = nextg[e]) {
@@ -192,7 +192,7 @@ public static int expand() {
 			if (rt[1] != 0) {
 				heapAdd(rt[1], num[rt[1]]);
 			}
-			while (!isEmpty()) {
+			while (!heapEmpty()) {
 				int h = heapPop();
 				int u = idx[h];
 				double w = cost[h];
@@ -207,8 +207,8 @@ public static int expand() {
 				if (right[u] != 0) {
 					heapAdd(right[u], w - num[u] + num[right[u]]);
 				}
-				if (father[u] != 0 && rt[father[u]] != 0) {
-					heapAdd(rt[father[u]], w + num[rt[father[u]]]);
+				if (up[u] != 0 && rt[up[u]] != 0) {
+					heapAdd(rt[up[u]], w + num[rt[up[u]]]);
 				}
 			}
 		}
@@ -234,7 +234,8 @@ public static void main(String[] args) throws IOException {
 		}
 		dijkstra();
 		mergeRoad();
-		out.write(expand() + "\n");
+		int ans = expand();
+		out.write(ans + "\n");
 		out.flush();
 		out.close();
 	}
diff --git a/src/class155/Code04_KShortestPath2.java b/src/class155/Code04_KShortestPath2.java
index 3a5ce0b91..bbdd5978a 100644
--- a/src/class155/Code04_KShortestPath2.java
+++ b/src/class155/Code04_KShortestPath2.java
@@ -31,10 +31,10 @@
 //
 //int rt[MAXN];
 //double num[MAXT];
+//int up[MAXT];
 //int ls[MAXT];
 //int rs[MAXT];
 //int dist[MAXT];
-//int fa[MAXT];
 //int cntt = 0;
 //
 //int idx[MAXH];
@@ -66,18 +66,18 @@
 //int init(int f, double v){
 //    cntt++;
 //    num[cntt] = v;
+//    up[cntt] = f;
 //    ls[cntt] = rs[cntt] = dist[cntt] = 0;
-//    fa[cntt] = f;
 //    return cntt;
 //}
 //
 //int clone(int i){
 //    cntt++;
 //    num[cntt] = num[i];
+//    up[cntt] = up[i];
 //    ls[cntt] = ls[i];
 //    rs[cntt] = rs[i];
 //    dist[cntt] = dist[i];
-//    fa[cntt] = fa[i];
 //    return cntt;
 //}
 //
@@ -136,7 +136,7 @@
 //    return ans;
 //}
 //
-//bool isEmpty(){
+//bool heapEmpty(){
 //    return cnth == 0;
 //}
 //
@@ -145,7 +145,7 @@
 //    dis[n] = 0;
 //    cntd = cnth = 0;
 //    heapAdd(n, 0.0);
-//    while(!isEmpty()){
+//    while(!heapEmpty()){
 //        int h = heapPop();
 //        int u = idx[h];
 //        double w = cost[h];
@@ -169,7 +169,7 @@
 //        heapAdd(i, dis[i]);
 //    }
 //    dist[0] = -1;
-//    while(!isEmpty()){
+//    while(!heapEmpty()){
 //        int h = heapPop();
 //        int u = idx[h];
 //        for(int e = headg[u]; e != 0; e = nextg[e]){
@@ -192,7 +192,7 @@
 //        if(rt[1] != 0){
 //            heapAdd(rt[1], num[rt[1]]);
 //        }
-//        while(!isEmpty()){
+//        while(!heapEmpty()){
 //            int h = heapPop();
 //            int u = idx[h];
 //            double w = cost[h];
@@ -207,8 +207,8 @@
 //            if(rs[u] != 0){
 //                heapAdd(rs[u], w - num[u] + num[rs[u]]);
 //            }
-//            if(fa[u] != 0 && rt[fa[u]] != 0){
-//                heapAdd(rt[fa[u]], w + num[rt[fa[u]]]);
+//            if(up[u] != 0 && rt[up[u]] != 0){
+//                heapAdd(rt[up[u]], w + num[rt[up[u]]]);
 //            }
 //        }
 //    }

From e2687f41d1ac633d613cb97ce84a2d98820fda15 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Dec 2024 22:35:39 +0800
Subject: [PATCH 0251/1712] modify code

---
 .../Code03_PersistentLeftistTree1.java        | 186 ++++++++++++++++++
 src/class155/Code04_KShortestPath1.java       |  16 +-
 src/class155/Code04_KShortestPath2.java       |  12 +-
 3 files changed, 200 insertions(+), 14 deletions(-)
 create mode 100644 src/class155/Code03_PersistentLeftistTree1.java

diff --git a/src/class155/Code03_PersistentLeftistTree1.java b/src/class155/Code03_PersistentLeftistTree1.java
new file mode 100644
index 000000000..ac0ee9d06
--- /dev/null
+++ b/src/class155/Code03_PersistentLeftistTree1.java
@@ -0,0 +1,186 @@
+package class155;
+
+// 可持久化左偏树练习题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2409
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_PersistentLeftistTree1 {
+
+	public static int MAXN = 101;
+	public static int MAXM = 10001;
+	public static int MAXT = 1000001;
+	public static int INF = 10000001;
+
+	public static int n, k;
+
+	public static int[] start = new int[MAXN];
+	public static int[] end = new int[MAXN];
+	public static int[] arr = new int[MAXM];
+
+	public static int[] idx = new int[MAXT];
+	public static int[] jdx = new int[MAXT];
+	public static int[] num = new int[MAXT];
+	public static int[] left = new int[MAXT];
+	public static int[] right = new int[MAXT];
+	public static int[] dist = new int[MAXT];
+	public static int cnt = 0;
+
+	public static int[] base = new int[MAXT];
+
+	public static int[] heap = new int[MAXM];
+	public static int heapSize = 0;
+
+	public static int[] ans = new int[MAXM];
+
+	public static int init(int i, int j) {
+		idx[++cnt] = i;
+		jdx[cnt] = j;
+		num[cnt] = j + 1 < end[i] ? (arr[j + 1] - arr[j]) : INF;
+		left[cnt] = right[cnt] = dist[cnt] = 0;
+		return cnt;
+	}
+
+	public static int clone(int i) {
+		idx[++cnt] = idx[i];
+		jdx[cnt] = jdx[i];
+		num[cnt] = num[i];
+		left[cnt] = left[i];
+		right[cnt] = right[i];
+		dist[cnt] = dist[i];
+		return cnt;
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (num[i] > num[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		int h = clone(i);
+		right[h] = merge(right[h], j);
+		if (dist[left[h]] < dist[right[h]]) {
+			tmp = left[h];
+			left[h] = right[h];
+			right[h] = tmp;
+		}
+		dist[h] = dist[right[h]] + 1;
+		return h;
+	}
+
+	public static int pop(int i) {
+		if (left[i] == 0 && right[i] == 0) {
+			return 0;
+		}
+		if (left[i] == 0 || right[i] == 0) {
+			return clone(left[i] + right[i]);
+		}
+		return merge(left[i], right[i]);
+	}
+
+	public static boolean compare(int i, int j) {
+		return base[heap[i]] + num[heap[i]] < base[heap[j]] + num[heap[j]];
+	}
+
+	public static void heapAdd(int i) {
+		heap[++heapSize] = i;
+		int cur = heapSize, up = cur / 2, tmp;
+		while (cur > 1 && compare(cur, up)) {
+			tmp = heap[up];
+			heap[up] = heap[cur];
+			heap[cur] = tmp;
+			cur = up;
+			up = cur / 2;
+		}
+	}
+
+	public static int heapPop() {
+		int ans = heap[1];
+		heap[1] = heap[heapSize--];
+		int cur = 1, l = cur * 2, r = l + 1, best, tmp;
+		while (l <= heapSize) {
+			best = (r <= heapSize && compare(r, l)) ? r : l;
+			best = compare(best, cur) ? best : cur;
+			if (best == cur) {
+				break;
+			}
+			tmp = heap[best];
+			heap[best] = heap[cur];
+			heap[cur] = tmp;
+			cur = best;
+			l = cur * 2;
+			r = l + 1;
+		}
+		return ans;
+	}
+
+	public static void compute() {
+		int first = 0;
+		for (int i = 1; i <= n; i++) {
+			Arrays.sort(arr, start[i], end[i]);
+			first += arr[start[i]];
+		}
+		dist[0] = -1;
+		int head = 0;
+		for (int i = 1; i <= n; i++) {
+			head = merge(head, init(i, start[i]));
+		}
+		base[head] = first;
+		ans[1] = first;
+		heapAdd(head);
+		for (int ansi = 2, h1, h2; ansi <= k; ansi++) {
+			head = heapPop();
+			ans[ansi] = base[head] + num[head];
+			h1 = pop(head);
+			if (h1 != 0) {
+				base[h1] = base[head];
+				heapAdd(h1);
+			}
+			if (jdx[head] + 1 < end[idx[head]]) {
+				h2 = merge(h1, init(idx[head], jdx[head] + 1));
+				base[h2] = ans[ansi];
+				heapAdd(h2);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		for (int i = 1, m, ai = 0; i <= n; i++) {
+			in.nextToken();
+			m = (int) in.nval;
+			start[i] = ai + 1;
+			for (int j = 1; j <= m; j++) {
+				in.nextToken();
+				arr[++ai] = (int) in.nval;
+			}
+			end[i] = start[i] + m;
+		}
+		compute();
+		for (int i = 1; i <= k; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class155/Code04_KShortestPath1.java b/src/class155/Code04_KShortestPath1.java
index 83cdd5ef2..4bb8e5632 100644
--- a/src/class155/Code04_KShortestPath1.java
+++ b/src/class155/Code04_KShortestPath1.java
@@ -89,15 +89,15 @@ public static int merge(int i, int j) {
 			i = j;
 			j = tmp;
 		}
-		int k = clone(i);
-		right[k] = merge(right[k], j);
-		if (dist[left[k]] < dist[right[k]]) {
-			tmp = left[k];
-			left[k] = right[k];
-			right[k] = tmp;
+		int h = clone(i);
+		right[h] = merge(right[h], j);
+		if (dist[left[h]] < dist[right[h]]) {
+			tmp = left[h];
+			left[h] = right[h];
+			right[h] = tmp;
 		}
-		dist[k] = dist[right[k]] + 1;
-		return k;
+		dist[h] = dist[right[h]] + 1;
+		return h;
 	}
 
 	public static void heapAdd(int i, double v) {
diff --git a/src/class155/Code04_KShortestPath2.java b/src/class155/Code04_KShortestPath2.java
index bbdd5978a..e4b7a9711 100644
--- a/src/class155/Code04_KShortestPath2.java
+++ b/src/class155/Code04_KShortestPath2.java
@@ -88,13 +88,13 @@
 //    if(num[i] > num[j]){
 //        swap(i, j);
 //    }
-//    int k = clone(i);
-//    rs[k] = merge(rs[k], j);
-//    if(dist[ls[k]] < dist[rs[k]]){
-//        swap(ls[k], rs[k]);
+//    int h = clone(i);
+//    rs[h] = merge(rs[h], j);
+//    if(dist[ls[h]] < dist[rs[h]]){
+//        swap(ls[h], rs[h]);
 //    }
-//    dist[k] = dist[rs[k]] + 1;
-//    return k;
+//    dist[h] = dist[rs[h]] + 1;
+//    return h;
 //}
 //
 //void heapAdd(int i, double v){

From 66f8f1f16a675b76fa883b2389826a326cd58c76 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Dec 2024 23:03:27 +0800
Subject: [PATCH 0252/1712] modify code

---
 .../Code03_PersistentLeftistTree1.java        |  10 +-
 .../Code03_PersistentLeftistTree2.java        | 153 ++++++++++++++++++
 src/class155/Code04_KShortestPath1.java       |   6 +-
 src/class155/Code04_KShortestPath2.java       |   3 +-
 4 files changed, 163 insertions(+), 9 deletions(-)
 create mode 100644 src/class155/Code03_PersistentLeftistTree2.java

diff --git a/src/class155/Code03_PersistentLeftistTree1.java b/src/class155/Code03_PersistentLeftistTree1.java
index ac0ee9d06..b6a01adf1 100644
--- a/src/class155/Code03_PersistentLeftistTree1.java
+++ b/src/class155/Code03_PersistentLeftistTree1.java
@@ -22,7 +22,7 @@ public class Code03_PersistentLeftistTree1 {
 	public static int n, k;
 
 	public static int[] start = new int[MAXN];
-	public static int[] end = new int[MAXN];
+	public static int[] boundary = new int[MAXN];
 	public static int[] arr = new int[MAXM];
 
 	public static int[] idx = new int[MAXT];
@@ -43,7 +43,7 @@ public class Code03_PersistentLeftistTree1 {
 	public static int init(int i, int j) {
 		idx[++cnt] = i;
 		jdx[cnt] = j;
-		num[cnt] = j + 1 < end[i] ? (arr[j + 1] - arr[j]) : INF;
+		num[cnt] = j + 1 < boundary[i] ? (arr[j + 1] - arr[j]) : INF;
 		left[cnt] = right[cnt] = dist[cnt] = 0;
 		return cnt;
 	}
@@ -128,7 +128,7 @@ public static int heapPop() {
 	public static void compute() {
 		int first = 0;
 		for (int i = 1; i <= n; i++) {
-			Arrays.sort(arr, start[i], end[i]);
+			Arrays.sort(arr, start[i], boundary[i]);
 			first += arr[start[i]];
 		}
 		dist[0] = -1;
@@ -147,7 +147,7 @@ public static void compute() {
 				base[h1] = base[head];
 				heapAdd(h1);
 			}
-			if (jdx[head] + 1 < end[idx[head]]) {
+			if (jdx[head] + 1 < boundary[idx[head]]) {
 				h2 = merge(h1, init(idx[head], jdx[head] + 1));
 				base[h2] = ans[ansi];
 				heapAdd(h2);
@@ -171,7 +171,7 @@ public static void main(String[] args) throws IOException {
 				in.nextToken();
 				arr[++ai] = (int) in.nval;
 			}
-			end[i] = start[i] + m;
+			boundary[i] = start[i] + m;
 		}
 		compute();
 		for (int i = 1; i <= k; i++) {
diff --git a/src/class155/Code03_PersistentLeftistTree2.java b/src/class155/Code03_PersistentLeftistTree2.java
new file mode 100644
index 000000000..a357d465b
--- /dev/null
+++ b/src/class155/Code03_PersistentLeftistTree2.java
@@ -0,0 +1,153 @@
+package class155;
+
+// 可持久化左偏树练习题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2409
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <algorithm>
+//
+//using namespace std;
+//
+//const int MAXN = 101;
+//const int MAXM = 10001;
+//const int MAXT = 1000001;
+//const int INF = 10000001;
+//
+//int n, k;
+//
+//int start[MAXN];
+//int boundary[MAXN];
+//int arr[MAXM];
+//
+//int idx[MAXT];
+//int jdx[MAXT];
+//int num[MAXT];
+//int ls[MAXT];
+//int rs[MAXT];
+//int dist[MAXT];
+//int cnt = 0;
+//
+//int base[MAXT];
+//
+//int heap[MAXM];
+//int heapSize = 0;
+//
+//int ans[MAXM];
+//
+//int init(int i, int j) {
+//    idx[++cnt] = i;
+//    jdx[cnt] = j;
+//    num[cnt] = (j + 1 < boundary[i]) ? (arr[j + 1] - arr[j]) : INF;
+//    ls[cnt] = rs[cnt] = dist[cnt] = 0;
+//    return cnt;
+//}
+//
+//int clone(int i) {
+//    idx[++cnt] = idx[i];
+//    jdx[cnt] = jdx[i];
+//    num[cnt] = num[i];
+//    ls[cnt] = ls[i];
+//    rs[cnt] = rs[i];
+//    dist[cnt] = dist[i];
+//    return cnt;
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) return i + j;
+//    if (num[i] > num[j]) swap(i, j);
+//    int h = clone(i);
+//    rs[h] = merge(rs[h], j);
+//    if (dist[ls[h]] < dist[rs[h]]) swap(ls[h], rs[h]);
+//    dist[h] = dist[rs[h]] + 1;
+//    return h;
+//}
+//
+//int pop(int i) {
+//    if (ls[i] == 0 && rs[i] == 0) return 0;
+//    if (ls[i] == 0 || rs[i] == 0) return clone(ls[i] + rs[i]);
+//    return merge(ls[i], rs[i]);
+//}
+//
+//bool compare(int i, int j) {
+//    return base[heap[i]] + num[heap[i]] < base[heap[j]] + num[heap[j]];
+//}
+//
+//void heapAdd(int i) {
+//    heap[++heapSize] = i;
+//    int cur = heapSize, up = cur / 2;
+//    while (cur > 1 && compare(cur, up)) {
+//        swap(heap[cur], heap[up]);
+//        cur = up;
+//        up = cur / 2;
+//    }
+//}
+//
+//int heapPop() {
+//    int top = heap[1];
+//    heap[1] = heap[heapSize--];
+//    int cur = 1, l = 2, r = 3, best;
+//    while (l <= heapSize) {
+//        best = (r <= heapSize && compare(r, l)) ? r : l;
+//        best = compare(best, cur) ? best : cur;
+//        if (best == cur) break;
+//        swap(heap[cur], heap[best]);
+//        cur = best;
+//        l = cur * 2;
+//        r = l + 1;
+//    }
+//    return top;
+//}
+//
+//void compute() {
+//    int first = 0;
+//    for (int i = 1; i <= n; ++i) {
+//        sort(arr + start[i], arr + boundary[i]);
+//        first += arr[start[i]];
+//    }
+//    dist[0] = -1;
+//    int head = 0;
+//    for (int i = 1; i <= n; ++i) {
+//        head = merge(head, init(i, start[i]));
+//    }
+//    base[head] = first;
+//    ans[1] = first;
+//    heapAdd(head);
+//    for (int ansi = 2, h1, h2; ansi <= k; ++ansi) {
+//        head = heapPop();
+//        ans[ansi] = base[head] + num[head];
+//        h1 = pop(head);
+//        if (h1 != 0) {
+//            base[h1] = base[head];
+//            heapAdd(h1);
+//        }
+//        if (jdx[head] + 1 < boundary[idx[head]]) {
+//            h2 = merge(h1, init(idx[head], jdx[head] + 1));
+//            base[h2] = ans[ansi];
+//            heapAdd(h2);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    int ai = 0;
+//    for (int i = 1; i <= n; ++i) {
+//        int m;
+//        cin >> m;
+//        start[i] = ai + 1;
+//        for (int j = 1; j <= m; ++j) {
+//            cin >> arr[++ai];
+//        }
+//        boundary[i] = start[i] + m;
+//    }
+//    compute();
+//    for (int i = 1; i <= k; ++i) {
+//        cout << ans[i] << " ";
+//    }
+//    cout << endl;
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class155/Code04_KShortestPath1.java b/src/class155/Code04_KShortestPath1.java
index 4bb8e5632..ec0f881ea 100644
--- a/src/class155/Code04_KShortestPath1.java
+++ b/src/class155/Code04_KShortestPath1.java
@@ -8,6 +8,7 @@
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
+import java.util.Arrays;
 
 public class Code04_KShortestPath1 {
 
@@ -15,6 +16,7 @@ public class Code04_KShortestPath1 {
 	public static int MAXM = 200001;
 	public static int MAXT = MAXN * 20;
 	public static int MAXH = 4200001;
+	public static double INF = 1e18;
 
 	public static int n, m;
 	public static double money;
@@ -140,9 +142,7 @@ public static boolean heapEmpty() {
 
 	public static void dijkstra() {
 		dis[n] = 0;
-		for (int i = 1; i < n; i++) {
-			dis[i] = Double.POSITIVE_INFINITY;
-		}
+		Arrays.fill(dis, 1, n, INF);
 		cntd = cnth = 0;
 		heapAdd(n, 0);
 		while (!heapEmpty()) {
diff --git a/src/class155/Code04_KShortestPath2.java b/src/class155/Code04_KShortestPath2.java
index e4b7a9711..4c7db3287 100644
--- a/src/class155/Code04_KShortestPath2.java
+++ b/src/class155/Code04_KShortestPath2.java
@@ -13,6 +13,7 @@
 //const int MAXM = 200001;
 //const int MAXT = MAXN * 20;
 //const int MAXH = 4200001;
+//const double INF = 1e18;
 //
 //int n, m;
 //double money;
@@ -141,7 +142,7 @@
 //}
 //
 //void dijkstra(){
-//    fill(dis, dis + MAXN, 1e18);
+//    fill(dis, dis + MAXN, INF);
 //    dis[n] = 0;
 //    cntd = cnth = 0;
 //    heapAdd(n, 0.0);

From f99df9f46fd0db9b88522318f8e7ae6046456a1f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 12:14:21 +0800
Subject: [PATCH 0253/1712] modify code

---
 src/class155/Code03_PersistentLeftistTree1.java | 5 +++--
 src/class155/Code03_PersistentLeftistTree2.java | 5 +++--
 2 files changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/class155/Code03_PersistentLeftistTree1.java b/src/class155/Code03_PersistentLeftistTree1.java
index b6a01adf1..ec2ced2e4 100644
--- a/src/class155/Code03_PersistentLeftistTree1.java
+++ b/src/class155/Code03_PersistentLeftistTree1.java
@@ -16,6 +16,7 @@ public class Code03_PersistentLeftistTree1 {
 
 	public static int MAXN = 101;
 	public static int MAXM = 10001;
+	public static int MAXK = 10001;
 	public static int MAXT = 1000001;
 	public static int INF = 10000001;
 
@@ -35,10 +36,10 @@ public class Code03_PersistentLeftistTree1 {
 
 	public static int[] base = new int[MAXT];
 
-	public static int[] heap = new int[MAXM];
+	public static int[] heap = new int[MAXK];
 	public static int heapSize = 0;
 
-	public static int[] ans = new int[MAXM];
+	public static int[] ans = new int[MAXK];
 
 	public static int init(int i, int j) {
 		idx[++cnt] = i;
diff --git a/src/class155/Code03_PersistentLeftistTree2.java b/src/class155/Code03_PersistentLeftistTree2.java
index a357d465b..9dccaabb6 100644
--- a/src/class155/Code03_PersistentLeftistTree2.java
+++ b/src/class155/Code03_PersistentLeftistTree2.java
@@ -12,6 +12,7 @@
 //
 //const int MAXN = 101;
 //const int MAXM = 10001;
+//const int MAXK = 10001;
 //const int MAXT = 1000001;
 //const int INF = 10000001;
 //
@@ -31,10 +32,10 @@
 //
 //int base[MAXT];
 //
-//int heap[MAXM];
+//int heap[MAXK];
 //int heapSize = 0;
 //
-//int ans[MAXM];
+//int ans[MAXK];
 //
 //int init(int i, int j) {
 //    idx[++cnt] = i;

From 8f86504f32271afa5967c1fc110dd7b8fea95023 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 13:07:57 +0800
Subject: [PATCH 0254/1712] modify code

---
 src/class155/Code04_KShortestPath1.java | 65 +++++++++-----------
 src/class155/Code04_KShortestPath2.java | 82 +++++++++++--------------
 2 files changed, 64 insertions(+), 83 deletions(-)

diff --git a/src/class155/Code04_KShortestPath1.java b/src/class155/Code04_KShortestPath1.java
index ec0f881ea..aad5f76b9 100644
--- a/src/class155/Code04_KShortestPath1.java
+++ b/src/class155/Code04_KShortestPath1.java
@@ -33,16 +33,17 @@ public class Code04_KShortestPath1 {
 	public static double[] weightr = new double[MAXM];
 	public static int cntr = 0;
 
-	public static int[] rt = new int[MAXN];
-	public static double[] num = new double[MAXT];
-	public static int[] up = new int[MAXT];
+	public static int[] start = new int[MAXT];
+	public static double[] cost = new double[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
 	public static int cntt = 0;
+	
+	public static int[] rt = new int[MAXN];
 
 	public static int[] idx = new int[MAXH];
-	public static double[] cost = new double[MAXH];
+	public static double[] val = new double[MAXH];
 	public static int cntd;
 	public static int[] heap = new int[MAXH];
 	public static int cnth;
@@ -65,16 +66,16 @@ public static void addEdgeR(int u, int v, double w) {
 		headr[u] = cntr;
 	}
 
-	public static int init(int f, double v) {
-		num[++cntt] = v;
-		up[cntt] = f;
+	public static int init(int s, double c) {
+		start[++cntt] = s;
+		cost[cntt] = c;
 		left[cntt] = right[cntt] = dist[cntt] = 0;
 		return cntt;
 	}
 
 	public static int clone(int i) {
-		num[++cntt] = num[i];
-		up[cntt] = up[i];
+		start[++cntt] = start[i];
+		cost[cntt] = cost[i];
 		left[cntt] = left[i];
 		right[cntt] = right[i];
 		dist[cntt] = dist[i];
@@ -86,17 +87,13 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
-		if (num[i] > num[j]) {
-			tmp = i;
-			i = j;
-			j = tmp;
+		if (cost[i] > cost[j]) {
+			tmp = i; i = j; j = tmp;
 		}
 		int h = clone(i);
 		right[h] = merge(right[h], j);
 		if (dist[left[h]] < dist[right[h]]) {
-			tmp = left[h];
-			left[h] = right[h];
-			right[h] = tmp;
+			tmp = left[h]; left[h] = right[h]; right[h] = tmp;
 		}
 		dist[h] = dist[right[h]] + 1;
 		return h;
@@ -104,15 +101,13 @@ public static int merge(int i, int j) {
 
 	public static void heapAdd(int i, double v) {
 		idx[++cntd] = i;
-		cost[cntd] = v;
+		val[cntd] = v;
 		heap[++cnth] = cntd;
-		int cur = cnth, up = cur / 2, tmp;
-		while (cur > 1 && cost[heap[up]] > cost[heap[cur]]) {
-			tmp = heap[up];
-			heap[up] = heap[cur];
-			heap[cur] = tmp;
-			cur = up;
-			up = cur / 2;
+		int cur = cnth, father = cur / 2, tmp;
+		while (cur > 1 && val[heap[father]] > val[heap[cur]]) {
+			tmp = heap[father]; heap[father] = heap[cur]; heap[cur] = tmp;
+			cur = father;
+			father = cur / 2;
 		}
 	}
 
@@ -121,14 +116,12 @@ public static int heapPop() {
 		heap[1] = heap[cnth--];
 		int cur = 1, l = cur * 2, r = l + 1, best, tmp;
 		while (l <= cnth) {
-			best = (r <= cnth && cost[heap[r]] < cost[heap[l]]) ? r : l;
-			best = (cost[heap[best]] < cost[heap[cur]]) ? best : cur;
+			best = r <= cnth && val[heap[r]] < val[heap[l]] ? r : l;
+			best = val[heap[best]] < val[heap[cur]] ? best : cur;
 			if (best == cur) {
 				break;
 			}
-			tmp = heap[best];
-			heap[best] = heap[cur];
-			heap[cur] = tmp;
+			tmp = heap[best]; heap[best] = heap[cur]; heap[cur] = tmp;
 			cur = best;
 			l = cur * 2;
 			r = l + 1;
@@ -148,7 +141,7 @@ public static void dijkstra() {
 		while (!heapEmpty()) {
 			int h = heapPop();
 			int u = idx[h];
-			double w = cost[h];
+			double w = val[h];
 			if (!vis[u]) {
 				vis[u] = true;
 				for (int e = headr[u], v; e > 0; e = nextr[e]) {
@@ -190,25 +183,25 @@ public static int expand() {
 			ans++;
 			cntd = cnth = 0;
 			if (rt[1] != 0) {
-				heapAdd(rt[1], num[rt[1]]);
+				heapAdd(rt[1], cost[rt[1]]);
 			}
 			while (!heapEmpty()) {
 				int h = heapPop();
 				int u = idx[h];
-				double w = cost[h];
+				double w = val[h];
 				money -= w + dis[1];
 				if (money < 0) {
 					break;
 				}
 				ans++;
 				if (left[u] != 0) {
-					heapAdd(left[u], w - num[u] + num[left[u]]);
+					heapAdd(left[u], w - cost[u] + cost[left[u]]);
 				}
 				if (right[u] != 0) {
-					heapAdd(right[u], w - num[u] + num[right[u]]);
+					heapAdd(right[u], w - cost[u] + cost[right[u]]);
 				}
-				if (up[u] != 0 && rt[up[u]] != 0) {
-					heapAdd(rt[up[u]], w + num[rt[up[u]]]);
+				if (start[u] != 0 && rt[start[u]] != 0) {
+					heapAdd(rt[start[u]], w + cost[rt[start[u]]]);
 				}
 			}
 		}
diff --git a/src/class155/Code04_KShortestPath2.java b/src/class155/Code04_KShortestPath2.java
index 4c7db3287..989ee1f9f 100644
--- a/src/class155/Code04_KShortestPath2.java
+++ b/src/class155/Code04_KShortestPath2.java
@@ -30,16 +30,17 @@
 //double weightr[MAXM];
 //int cntr = 0;
 //
-//int rt[MAXN];
-//double num[MAXT];
-//int up[MAXT];
+//int start[MAXT];
+//double cost[MAXT];
 //int ls[MAXT];
 //int rs[MAXT];
 //int dist[MAXT];
 //int cntt = 0;
 //
+//int rt[MAXN];
+//
 //int idx[MAXH];
-//double cost[MAXH];
+//double val[MAXH];
 //int cntd = 0;
 //int heap[MAXH];
 //int cnth = 0;
@@ -49,33 +50,29 @@
 //double dis[MAXN];
 //
 //void addEdgeG(int u, int v, double w){
-//    cntg++;
-//    nextg[cntg] = headg[u];
+//    nextg[++cntg] = headg[u];
 //    tog[cntg] = v;
 //    weightg[cntg] = w;
 //    headg[u] = cntg;
 //}
 //
 //void addEdgeR(int u, int v, double w){
-//    cntr++;
-//    nextr[cntr] = headr[u];
+//    nextr[++cntr] = headr[u];
 //    tor[cntr] = v;
 //    weightr[cntr] = w;
 //    headr[u] = cntr;
 //}
 //
-//int init(int f, double v){
-//    cntt++;
-//    num[cntt] = v;
-//    up[cntt] = f;
+//int init(int s, double v){
+//    start[++cntt] = s;
+//    cost[cntt] = v;
 //    ls[cntt] = rs[cntt] = dist[cntt] = 0;
 //    return cntt;
 //}
 //
 //int clone(int i){
-//    cntt++;
-//    num[cntt] = num[i];
-//    up[cntt] = up[i];
+//    start[++cntt] = start[i];
+//    cost[cntt] = cost[i];
 //    ls[cntt] = ls[i];
 //    rs[cntt] = rs[i];
 //    dist[cntt] = dist[i];
@@ -86,7 +83,7 @@
 //    if(i == 0 || j == 0){
 //        return i + j;
 //    }
-//    if(num[i] > num[j]){
+//    if(cost[i] > cost[j]){
 //        swap(i, j);
 //    }
 //    int h = clone(i);
@@ -100,39 +97,30 @@
 //
 //void heapAdd(int i, double v){
 //    idx[++cntd] = i;
-//    cost[cntd] = v;
+//    val[cntd] = v;
 //    heap[++cnth] = cntd;
-//    int cur = cnth;
-//    while(cur > 1){
-//        int up = cur / 2;
-//        if(cost[heap[up]] > cost[heap[cur]]){
-//            swap(heap[up], heap[cur]);
-//            cur = up;
-//        }
-//        else{
-//            break;
-//        }
+//    int cur = cnth, father = cur / 2;
+//    while(cur > 1 && val[heap[father]] > val[heap[cur]]){
+//        swap(heap[father], heap[cur]);
+//        cur = father;
+//        father = cur / 2;
 //    }
 //}
 //
 //int heapPop(){
 //    int ans = heap[1];
 //    heap[1] = heap[cnth--];
-//    int cur = 1;
-//    while(cur * 2 <= cnth){
-//        int l = cur * 2;
-//        int r = l + 1;
-//        int best = l;
-//        if(r <= cnth && cost[heap[r]] < cost[heap[l]]){
-//            best = r;
-//        }
-//        if(cost[heap[best]] < cost[heap[cur]]){
-//            swap(heap[best], heap[cur]);
-//            cur = best;
-//        }
-//        else{
+//    int cur = 1, l = cur * 2, r = l + 1, best;
+//    while(l <= cnth){
+//        best = r <= cnth && val[heap[r]] < val[heap[l]] ? r : l;
+//        best = val[heap[best]] < val[heap[cur]] ? best : cur;
+//        if(best == cur) {
 //            break;
 //        }
+//        swap(heap[best], heap[cur]);
+//        cur = best;
+//        l = cur * 2;
+//        r = l + 1;
 //    }
 //    return ans;
 //}
@@ -149,7 +137,7 @@
 //    while(!heapEmpty()){
 //        int h = heapPop();
 //        int u = idx[h];
-//        double w = cost[h];
+//        double w = val[h];
 //        if(!vis[u]){
 //            vis[u] = true;
 //            for(int e = headr[u]; e != 0; e = nextr[e]){
@@ -191,25 +179,25 @@
 //        ans++;
 //        cntd = cnth = 0;
 //        if(rt[1] != 0){
-//            heapAdd(rt[1], num[rt[1]]);
+//            heapAdd(rt[1], cost[rt[1]]);
 //        }
 //        while(!heapEmpty()){
 //            int h = heapPop();
 //            int u = idx[h];
-//            double w = cost[h];
+//            double w = val[h];
 //            money -= w + dis[1];
 //            if(money < 0){
 //                break;
 //            }
 //            ans++;
 //            if(ls[u] != 0){
-//                heapAdd(ls[u], w - num[u] + num[ls[u]]);
+//                heapAdd(ls[u], w - cost[u] + cost[ls[u]]);
 //            }
 //            if(rs[u] != 0){
-//                heapAdd(rs[u], w - num[u] + num[rs[u]]);
+//                heapAdd(rs[u], w - cost[u] + cost[rs[u]]);
 //            }
-//            if(up[u] != 0 && rt[up[u]] != 0){
-//                heapAdd(rt[up[u]], w + num[rt[up[u]]]);
+//            if(start[u] != 0 && rt[start[u]] != 0){
+//                heapAdd(rt[start[u]], w + cost[rt[start[u]]]);
 //            }
 //        }
 //    }

From 6a652ed82005d08d127ded52e603afaf83041845 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 13:15:37 +0800
Subject: [PATCH 0255/1712] modify code

---
 ...de03_PersistentLeftistTree1.java => Code03_Blocks1.java} | 4 ++--
 ...de03_PersistentLeftistTree2.java => Code03_Blocks2.java} | 2 +-
 src/class155/Code04_KShortestPath1.java                     | 2 +-
 src/class155/Code04_KShortestPath2.java                     | 2 +-
 src/class155/ShowDetail.java                                | 6 ++++++
 5 files changed, 11 insertions(+), 5 deletions(-)
 rename src/class155/{Code03_PersistentLeftistTree1.java => Code03_Blocks1.java} (97%)
 rename src/class155/{Code03_PersistentLeftistTree2.java => Code03_Blocks2.java} (98%)
 create mode 100644 src/class155/ShowDetail.java

diff --git a/src/class155/Code03_PersistentLeftistTree1.java b/src/class155/Code03_Blocks1.java
similarity index 97%
rename from src/class155/Code03_PersistentLeftistTree1.java
rename to src/class155/Code03_Blocks1.java
index ec2ced2e4..7f21ba4f2 100644
--- a/src/class155/Code03_PersistentLeftistTree1.java
+++ b/src/class155/Code03_Blocks1.java
@@ -1,6 +1,6 @@
 package class155;
 
-// 可持久化左偏树练习题，java版
+// Y的积木，可持久化左偏树实现最优解，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2409
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_PersistentLeftistTree1 {
+public class Code03_Blocks1 {
 
 	public static int MAXN = 101;
 	public static int MAXM = 10001;
diff --git a/src/class155/Code03_PersistentLeftistTree2.java b/src/class155/Code03_Blocks2.java
similarity index 98%
rename from src/class155/Code03_PersistentLeftistTree2.java
rename to src/class155/Code03_Blocks2.java
index 9dccaabb6..d42199c84 100644
--- a/src/class155/Code03_PersistentLeftistTree2.java
+++ b/src/class155/Code03_Blocks2.java
@@ -1,6 +1,6 @@
 package class155;
 
-// 可持久化左偏树练习题，C++版
+// Y的积木，可持久化左偏树实现最优解，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2409
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class155/Code04_KShortestPath1.java b/src/class155/Code04_KShortestPath1.java
index aad5f76b9..70277aea4 100644
--- a/src/class155/Code04_KShortestPath1.java
+++ b/src/class155/Code04_KShortestPath1.java
@@ -1,6 +1,6 @@
 package class155;
 
-// k短路问题的最优解，java版
+// k短路问题，可持久化左偏树实现最优解，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class155/Code04_KShortestPath2.java b/src/class155/Code04_KShortestPath2.java
index 989ee1f9f..1b5558c75 100644
--- a/src/class155/Code04_KShortestPath2.java
+++ b/src/class155/Code04_KShortestPath2.java
@@ -1,6 +1,6 @@
 package class155;
 
-// k短路问题的最优解，C++版
+// k短路问题，可持久化左偏树实现最优解，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class155/ShowDetail.java b/src/class155/ShowDetail.java
new file mode 100644
index 000000000..22ae9c539
--- /dev/null
+++ b/src/class155/ShowDetail.java
@@ -0,0 +1,6 @@
+package class155;
+
+// 可持久化左偏树的实现和验证
+public class ShowDetail {
+
+}

From 3b6578dbd546e727d8881cbe3f47b02a11abe6b4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 14:54:47 +0800
Subject: [PATCH 0256/1712] modify code

---
 src/class155/ShowDetail.java | 231 ++++++++++++++++++++++++++++++++++-
 1 file changed, 230 insertions(+), 1 deletion(-)

diff --git a/src/class155/ShowDetail.java b/src/class155/ShowDetail.java
index 22ae9c539..994aa14e4 100644
--- a/src/class155/ShowDetail.java
+++ b/src/class155/ShowDetail.java
@@ -1,6 +1,235 @@
 package class155;
 
-// 可持久化左偏树的实现和验证
+// 可持久化左偏树的实现 + 对数器验证实现的正确性
+
+import java.util.ArrayList;
+import java.util.PriorityQueue;
+
 public class ShowDetail {
 
+	public static int MAXN = 10000;
+
+	public static int MAXV = 100000;
+
+	public static int MAXT = 10000001;
+
+	public static int[] num = new int[MAXT];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static int[] dist = new int[MAXT];
+
+	public static int cnt = 0;
+
+	public static int[] rt = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int init(int v) {
+		num[++cnt] = v;
+		left[cnt] = right[cnt] = dist[cnt] = 0;
+		return cnt;
+	}
+
+	public static int clone(int i) {
+		num[++cnt] = num[i];
+		left[cnt] = left[i];
+		right[cnt] = right[i];
+		dist[cnt] = dist[i];
+		return cnt;
+	}
+
+	public static int merge(int i, int j) {
+		if (i == 0 || j == 0) {
+			return i + j;
+		}
+		int tmp;
+		if (num[i] > num[j]) {
+			tmp = i;
+			i = j;
+			j = tmp;
+		}
+		int h = clone(i);
+		right[h] = merge(right[h], j);
+		if (dist[left[h]] < dist[right[h]]) {
+			tmp = left[h];
+			left[h] = right[h];
+			right[h] = tmp;
+		}
+		dist[h] = dist[right[h]] + 1;
+		return h;
+	}
+
+	public static int pop(int i) {
+		if (left[i] == 0 && right[i] == 0) {
+			return 0;
+		}
+		if (left[i] == 0 || right[i] == 0) {
+			return clone(left[i] + right[i]);
+		}
+		return merge(left[i], right[i]);
+	}
+
+	// 可持久化左偏树，x版本加入数字y，生成最新的i版本
+	public static void treeAdd(int x, int y, int i) {
+		size[i] = size[x] + 1;
+		rt[i] = merge(rt[x], init(y));
+	}
+
+	// 可持久化左偏树，x版本与y版本合并，生成最新的i版本
+	public static void treeMerge(int x, int y, int i) {
+		size[i] = size[x] + size[y];
+		if (rt[x] == 0 && rt[y] == 0) {
+			rt[i] = 0;
+		} else if (rt[x] == 0 || rt[y] == 0) {
+			rt[i] = clone(rt[x] + rt[y]);
+		} else {
+			rt[i] = merge(rt[x], rt[y]);
+		}
+	}
+
+	// 可持久化左偏树，x版本弹出顶部，生成最新的i版本
+	public static void treePop(int x, int i) {
+		if (size[x] == 0) {
+			size[i] = 0;
+			rt[i] = 0;
+		} else {
+			size[i] = size[x] - 1;
+			rt[i] = pop(rt[x]);
+		}
+	}
+
+	// 验证结构
+	public static ArrayList<PriorityQueue<Integer>> verify = new ArrayList<>();
+
+	// 验证结构，x版本加入数字y，生成最新版本
+	public static void verifyAdd(int x, int y) {
+		PriorityQueue<Integer> pre = verify.get(x);
+		ArrayList<Integer> tmp = new ArrayList<>();
+		while (!pre.isEmpty()) {
+			tmp.add(pre.poll());
+		}
+		PriorityQueue<Integer> cur = new PriorityQueue<>();
+		for (int number : tmp) {
+			pre.add(number);
+			cur.add(number);
+		}
+		cur.add(y);
+		verify.add(cur);
+	}
+
+	// 验证结构，x版本与y版本合并，生成最新版本
+	public static void verifyMerge(int x, int y) {
+		PriorityQueue<Integer> h1 = verify.get(x);
+		PriorityQueue<Integer> h2 = verify.get(y);
+		ArrayList<Integer> tmp = new ArrayList<>();
+		PriorityQueue<Integer> cur = new PriorityQueue<>();
+		while (!h1.isEmpty()) {
+			int number = h1.poll();
+			tmp.add(number);
+			cur.add(number);
+		}
+		for (int number : tmp) {
+			h1.add(number);
+		}
+		tmp.clear();
+		while (!h2.isEmpty()) {
+			int number = h2.poll();
+			tmp.add(number);
+			cur.add(number);
+		}
+		for (int number : tmp) {
+			h2.add(number);
+		}
+		verify.add(cur);
+	}
+
+	// 验证结构，x版本弹出顶部，生成最新版本
+	public static void verifyPop(int x) {
+		PriorityQueue<Integer> pre = verify.get(x);
+		PriorityQueue<Integer> cur = new PriorityQueue<>();
+		if (pre.size() == 0) {
+			verify.add(cur);
+		} else {
+			int top = pre.poll();
+			ArrayList<Integer> tmp = new ArrayList<>();
+			while (!pre.isEmpty()) {
+				tmp.add(pre.poll());
+			}
+			for (int number : tmp) {
+				pre.add(number);
+				cur.add(number);
+			}
+			pre.add(top);
+			verify.add(cur);
+		}
+	}
+
+	// 可持久化左偏树i版本的堆
+	// 是否等于
+	// 验证结构i版本的堆
+	public static boolean check(int i) {
+		int h1 = rt[i];
+		int s1 = size[i];
+		PriorityQueue<Integer> h2 = verify.get(i);
+		if (s1 != h2.size()) {
+			return false;
+		}
+		boolean ans = true;
+		ArrayList<Integer> tmp = new ArrayList<>();
+		while (!h2.isEmpty()) {
+			int o1 = num[h1];
+			h1 = pop(h1);
+			int o2 = h2.poll();
+			tmp.add(o2);
+			if (o1 != o2) {
+				ans = false;
+				break;
+			}
+		}
+		for (int v : tmp) {
+			h2.add(v);
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		System.out.println("测试开始");
+		dist[0] = -1;
+		rt[0] = size[0] = 0; // 可持久化左偏树生成0版本的堆
+		verify.add(new PriorityQueue<>()); // 验证结构生成0版本的堆
+		for (int i = 1, op, x, y; i < MAXN; i++) {
+			// op == 1，x版本的堆里加入数字y，形成i号版本的堆
+			// op == 2，x版本的堆和y版本的堆合并，形成i号版本的堆
+			// op == 3，x版本的堆弹出堆顶，形成i号版本的堆
+			op = i == 1 ? 1 : ((int) (Math.random() * 3) + 1);
+			x = (int) (Math.random() * i);
+			if (op == 1) {
+				y = (int) (Math.random() * MAXV);
+				treeAdd(x, y, i);
+				verifyAdd(x, y);
+			} else if (op == 2) {
+				y = x;
+				// 保证x != y
+				do {
+					y = (int) (Math.random() * i);
+				} while (y == x);
+				treeMerge(x, y, i);
+				verifyMerge(x, y);
+			} else {
+				treePop(x, i);
+				verifyPop(x);
+			}
+		}
+		// 验证在两个结构中是否每个版本的堆都一样
+		for (int i = 1; i < MAXN; i++) {
+			if (!check(i)) {
+				System.out.println("出错了！");
+			}
+		}
+		System.out.println("测试结束");
+	}
+
 }

From e782fa40e579f6a92431ff5bcbbe442414b84512 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 15:00:20 +0800
Subject: [PATCH 0257/1712] modify code

---
 src/class155/ShowDetail.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/ShowDetail.java b/src/class155/ShowDetail.java
index 994aa14e4..ac81b898d 100644
--- a/src/class155/ShowDetail.java
+++ b/src/class155/ShowDetail.java
@@ -11,7 +11,7 @@ public class ShowDetail {
 
 	public static int MAXV = 100000;
 
-	public static int MAXT = 10000001;
+	public static int MAXT = 1000001;
 
 	public static int[] num = new int[MAXT];
 

From 47a585f39bc98e2858ac4b76520dd50a041fdd89 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 21:15:40 +0800
Subject: [PATCH 0258/1712] modify code

---
 ...ava => Code03_PersistentLeftistTree1.java} |  14 +-
 .../Code03_PersistentLeftistTree2.java        | 218 ++++++++++++++++++
 ...ode03_Blocks1.java => Code04_Blocks1.java} |   2 +-
 ...ode03_Blocks2.java => Code04_Blocks2.java} |   0
 ...tPath1.java => Code05_KShortestPath1.java} |   2 +-
 ...tPath2.java => Code05_KShortestPath2.java} |   0
 6 files changed, 229 insertions(+), 7 deletions(-)
 rename src/class155/{ShowDetail.java => Code03_PersistentLeftistTree1.java} (94%)
 create mode 100644 src/class155/Code03_PersistentLeftistTree2.java
 rename src/class155/{Code03_Blocks1.java => Code04_Blocks1.java} (99%)
 rename src/class155/{Code03_Blocks2.java => Code04_Blocks2.java} (100%)
 rename src/class155/{Code04_KShortestPath1.java => Code05_KShortestPath1.java} (99%)
 rename src/class155/{Code04_KShortestPath2.java => Code05_KShortestPath2.java} (100%)

diff --git a/src/class155/ShowDetail.java b/src/class155/Code03_PersistentLeftistTree1.java
similarity index 94%
rename from src/class155/ShowDetail.java
rename to src/class155/Code03_PersistentLeftistTree1.java
index ac81b898d..647630ac9 100644
--- a/src/class155/ShowDetail.java
+++ b/src/class155/Code03_PersistentLeftistTree1.java
@@ -1,17 +1,17 @@
 package class155;
 
-// 可持久化左偏树的实现 + 对数器验证实现的正确性
+// 可持久化左偏树的实现，利用对数器验证正确性，java版
 
 import java.util.ArrayList;
 import java.util.PriorityQueue;
 
-public class ShowDetail {
+public class Code03_PersistentLeftistTree1 {
 
 	public static int MAXN = 10000;
 
 	public static int MAXV = 100000;
 
-	public static int MAXT = 1000001;
+	public static int MAXT = 2000001;
 
 	public static int[] num = new int[MAXT];
 
@@ -212,18 +212,22 @@ public static void main(String[] args) {
 				verifyAdd(x, y);
 			} else if (op == 2) {
 				y = x;
-				// 保证x != y
 				do {
 					y = (int) (Math.random() * i);
 				} while (y == x);
+				// 保证x != y
 				treeMerge(x, y, i);
 				verifyMerge(x, y);
 			} else {
 				treePop(x, i);
 				verifyPop(x);
 			}
+			// 检查最新版本的堆是否一样
+			if (!check(i)) {
+				System.out.println("出错了！");
+			}
 		}
-		// 验证在两个结构中是否每个版本的堆都一样
+		// 最后验证是否所有版本的堆都一样
 		for (int i = 1; i < MAXN; i++) {
 			if (!check(i)) {
 				System.out.println("出错了！");
diff --git a/src/class155/Code03_PersistentLeftistTree2.java b/src/class155/Code03_PersistentLeftistTree2.java
new file mode 100644
index 000000000..4d9728681
--- /dev/null
+++ b/src/class155/Code03_PersistentLeftistTree2.java
@@ -0,0 +1,218 @@
+package class155;
+
+// 可持久化左偏树的实现，利用对数器验证正确性，C++版
+
+//#include <iostream>
+//#include <vector>
+//#include <queue>
+//#include <algorithm>
+//#include <cstdlib>
+//#include <ctime>
+//
+//using namespace std;
+//
+//const int MAXN = 10000;
+//const int MAXV = 100000;
+//const int MAXT = 2000001;
+//
+//int num[MAXT];
+//int ls[MAXT];
+//int rs[MAXT];
+//int dist[MAXT];
+//int cnt = 0;
+//int rt[MAXN];
+//int siz[MAXN];
+//
+//int init(int v) {
+//    num[++cnt] = v;
+//    ls[cnt] = rs[cnt] = dist[cnt] = 0;
+//    return cnt;
+//}
+//
+//int clone(int i) {
+//    num[++cnt] = num[i];
+//    ls[cnt] = ls[i];
+//    rs[cnt] = rs[i];
+//    dist[cnt] = dist[i];
+//    return cnt;
+//}
+//
+//int merge(int i, int j) {
+//    if (i == 0 || j == 0) {
+//        return i + j;
+//    }
+//    if (num[i] > num[j]) {
+//        swap(i, j);
+//    }
+//    int h = clone(i);
+//    rs[h] = merge(rs[h], j);
+//    if (dist[ls[h]] < dist[rs[h]]) {
+//        swap(ls[h], rs[h]);
+//    }
+//    dist[h] = dist[rs[h]] + 1;
+//    return h;
+//}
+//
+//int pop(int i) {
+//    if (ls[i] == 0 && rs[i] == 0) {
+//        return 0;
+//    }
+//    if (ls[i] == 0 || rs[i] == 0) {
+//        return clone(ls[i] + rs[i]);
+//    }
+//    return merge(ls[i], rs[i]);
+//}
+//
+//void treeAdd(int x, int y, int i) {
+//    siz[i] = siz[x] + 1;
+//    rt[i] = merge(rt[x], init(y));
+//}
+//
+//void treeMerge(int x, int y, int i) {
+//    siz[i] = siz[x] + siz[y];
+//    if (rt[x] == 0 && rt[y] == 0) {
+//        rt[i] = 0;
+//    } else if (rt[x] == 0 || rt[y] == 0) {
+//        rt[i] = clone(rt[x] + rt[y]);
+//    } else {
+//        rt[i] = merge(rt[x], rt[y]);
+//    }
+//}
+//
+//void treePop(int x, int i) {
+//    if (siz[x] == 0) {
+//        siz[i] = 0;
+//        rt[i] = 0;
+//    } else {
+//        siz[i] = siz[x] - 1;
+//        rt[i] = pop(rt[x]);
+//    }
+//}
+//
+//vector<priority_queue<int, vector<int>, greater<int>>> verify;
+//
+//void verifyAdd(int x, int y) {
+//    priority_queue<int, vector<int>, greater<int>> pre = verify[x];
+//    vector<int> tmp;
+//    while (!pre.empty()) {
+//        tmp.push_back(pre.top());
+//        pre.pop();
+//    }
+//    priority_queue<int, vector<int>, greater<int>> cur;
+//    for (int number : tmp) {
+//        cur.push(number);
+//    }
+//    cur.push(y);
+//    verify.push_back(cur);
+//}
+//
+//void verifyMerge(int x, int y) {
+//    priority_queue<int, vector<int>, greater<int>> h1 = verify[x];
+//    priority_queue<int, vector<int>, greater<int>> h2 = verify[y];
+//    vector<int> tmp;
+//    priority_queue<int, vector<int>, greater<int>> cur;
+//    while (!h1.empty()) {
+//        int number = h1.top();
+//        h1.pop();
+//        tmp.push_back(number);
+//        cur.push(number);
+//    }
+//    for (int number : tmp) {
+//        h1.push(number);
+//    }
+//    tmp.clear();
+//    while (!h2.empty()) {
+//        int number = h2.top();
+//        h2.pop();
+//        tmp.push_back(number);
+//        cur.push(number);
+//    }
+//    for (int number : tmp) {
+//        h2.push(number);
+//    }
+//    verify.push_back(cur);
+//}
+//
+//void verifyPop(int x) {
+//    priority_queue<int, vector<int>, greater<int>> pre = verify[x];
+//    priority_queue<int, vector<int>, greater<int>> cur;
+//    if (pre.empty()) {
+//        verify.push_back(cur);
+//    } else {
+//        int top = pre.top();
+//        pre.pop();
+//        vector<int> tmp;
+//        while (!pre.empty()) {
+//            tmp.push_back(pre.top());
+//            pre.pop();
+//        }
+//        for (int number : tmp) {
+//            pre.push(number);
+//            cur.push(number);
+//        }
+//        pre.push(top);
+//        verify.push_back(cur);
+//    }
+//}
+//
+//bool check(int i) {
+//    int h1 = rt[i];
+//    int s1 = siz[i];
+//    priority_queue<int, vector<int>, greater<int>> h2 = verify[i];
+//    if (s1 != h2.size()) {
+//        return false;
+//    }
+//    bool ans = true;
+//    vector<int> tmp;
+//    while (!h2.empty()) {
+//        int o1 = num[h1];
+//        h1 = pop(h1);
+//        int o2 = h2.top();
+//        h2.pop();
+//        tmp.push_back(o2);
+//        if (o1 != o2) {
+//            ans = false;
+//            break;
+//        }
+//    }
+//    for (int v : tmp) {
+//        h2.push(v);
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    cout << "test begin" << endl;
+//    dist[0] = -1;
+//    rt[0] = siz[0] = 0;
+//    verify.emplace_back(priority_queue<int, vector<int>, greater<int>>());
+//    srand(time(nullptr));
+//    for (int i = 1, op, x, y; i < MAXN; i++) {
+//        op = i == 1 ? 1 : (rand() % 3 + 1);
+//        x = rand() % i;
+//        if (op == 1) {
+//            y = rand() % MAXV;
+//            treeAdd(x, y, i);
+//            verifyAdd(x, y);
+//        } else if (op == 2) {
+//            do {
+//                y = rand() % i;
+//            } while (y == x);
+//            treeMerge(x, y, i);
+//            verifyMerge(x, y);
+//        } else {
+//            treePop(x, i);
+//            verifyPop(x);
+//        }
+//        if (!check(i)) {
+//            cout << "err!" << endl;
+//        }
+//    }
+//    for (int i = 1; i < MAXN; i++) {
+//        if (!check(i)) {
+//            cout << "err!" << endl;
+//        }
+//    }
+//    cout << "test fin" << endl;
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class155/Code03_Blocks1.java b/src/class155/Code04_Blocks1.java
similarity index 99%
rename from src/class155/Code03_Blocks1.java
rename to src/class155/Code04_Blocks1.java
index 7f21ba4f2..915846c3b 100644
--- a/src/class155/Code03_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_Blocks1 {
+public class Code04_Blocks1 {
 
 	public static int MAXN = 101;
 	public static int MAXM = 10001;
diff --git a/src/class155/Code03_Blocks2.java b/src/class155/Code04_Blocks2.java
similarity index 100%
rename from src/class155/Code03_Blocks2.java
rename to src/class155/Code04_Blocks2.java
diff --git a/src/class155/Code04_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
similarity index 99%
rename from src/class155/Code04_KShortestPath1.java
rename to src/class155/Code05_KShortestPath1.java
index 70277aea4..92a45b277 100644
--- a/src/class155/Code04_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.util.Arrays;
 
-public class Code04_KShortestPath1 {
+public class Code05_KShortestPath1 {
 
 	public static int MAXN = 50001;
 	public static int MAXM = 200001;
diff --git a/src/class155/Code04_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
similarity index 100%
rename from src/class155/Code04_KShortestPath2.java
rename to src/class155/Code05_KShortestPath2.java

From 17fed16e5c9c0139fc0920268c0fb5366f96f4bb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 21:22:11 +0800
Subject: [PATCH 0259/1712] modify code

---
 src/class155/Code03_PersistentLeftistTree2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/Code03_PersistentLeftistTree2.java b/src/class155/Code03_PersistentLeftistTree2.java
index 4d9728681..45ed0871a 100644
--- a/src/class155/Code03_PersistentLeftistTree2.java
+++ b/src/class155/Code03_PersistentLeftistTree2.java
@@ -213,6 +213,6 @@
 //            cout << "err!" << endl;
 //        }
 //    }
-//    cout << "test fin" << endl;
+//    cout << "test end" << endl;
 //    return 0;
 //}
\ No newline at end of file

From f35ea8fd6ff2b3497a52b3ff841fd55c28a9db4b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Dec 2024 22:11:12 +0800
Subject: [PATCH 0260/1712] modify code

---
 .../Code03_PersistentLeftistTree1.java        | 21 ++++++-------------
 .../Code03_PersistentLeftistTree2.java        | 15 +++++++------
 src/class155/Code04_Blocks1.java              |  3 +--
 src/class155/Code04_Blocks2.java              |  3 +--
 4 files changed, 15 insertions(+), 27 deletions(-)

diff --git a/src/class155/Code03_PersistentLeftistTree1.java b/src/class155/Code03_PersistentLeftistTree1.java
index 647630ac9..3c8d16db0 100644
--- a/src/class155/Code03_PersistentLeftistTree1.java
+++ b/src/class155/Code03_PersistentLeftistTree1.java
@@ -8,25 +8,18 @@
 public class Code03_PersistentLeftistTree1 {
 
 	public static int MAXN = 10000;
-
 	public static int MAXV = 100000;
-
 	public static int MAXT = 2000001;
 
 	public static int[] num = new int[MAXT];
-
 	public static int[] left = new int[MAXT];
-
 	public static int[] right = new int[MAXT];
-
 	public static int[] dist = new int[MAXT];
-
+	public static int[] size = new int[MAXT];
 	public static int cnt = 0;
 
 	public static int[] rt = new int[MAXN];
 
-	public static int[] size = new int[MAXN];
-
 	public static int init(int v) {
 		num[++cnt] = v;
 		left[cnt] = right[cnt] = dist[cnt] = 0;
@@ -74,13 +67,12 @@ public static int pop(int i) {
 
 	// 可持久化左偏树，x版本加入数字y，生成最新的i版本
 	public static void treeAdd(int x, int y, int i) {
-		size[i] = size[x] + 1;
 		rt[i] = merge(rt[x], init(y));
+		size[rt[i]] = size[rt[x]] + 1;
 	}
 
 	// 可持久化左偏树，x版本与y版本合并，生成最新的i版本
 	public static void treeMerge(int x, int y, int i) {
-		size[i] = size[x] + size[y];
 		if (rt[x] == 0 && rt[y] == 0) {
 			rt[i] = 0;
 		} else if (rt[x] == 0 || rt[y] == 0) {
@@ -88,16 +80,16 @@ public static void treeMerge(int x, int y, int i) {
 		} else {
 			rt[i] = merge(rt[x], rt[y]);
 		}
+		size[rt[i]] = size[rt[x]] + size[rt[y]];
 	}
 
 	// 可持久化左偏树，x版本弹出顶部，生成最新的i版本
 	public static void treePop(int x, int i) {
-		if (size[x] == 0) {
-			size[i] = 0;
+		if (size[rt[x]] == 0) {
 			rt[i] = 0;
 		} else {
-			size[i] = size[x] - 1;
 			rt[i] = pop(rt[x]);
+			size[rt[i]] = size[rt[x]] - 1;
 		}
 	}
 
@@ -172,9 +164,8 @@ public static void verifyPop(int x) {
 	// 验证结构i版本的堆
 	public static boolean check(int i) {
 		int h1 = rt[i];
-		int s1 = size[i];
 		PriorityQueue<Integer> h2 = verify.get(i);
-		if (s1 != h2.size()) {
+		if (size[h1] != h2.size()) {
 			return false;
 		}
 		boolean ans = true;
diff --git a/src/class155/Code03_PersistentLeftistTree2.java b/src/class155/Code03_PersistentLeftistTree2.java
index 45ed0871a..fbe2caaa1 100644
--- a/src/class155/Code03_PersistentLeftistTree2.java
+++ b/src/class155/Code03_PersistentLeftistTree2.java
@@ -19,9 +19,10 @@
 //int ls[MAXT];
 //int rs[MAXT];
 //int dist[MAXT];
+//int siz[MAXT];
 //int cnt = 0;
+//
 //int rt[MAXN];
-//int siz[MAXN];
 //
 //int init(int v) {
 //    num[++cnt] = v;
@@ -64,12 +65,11 @@
 //}
 //
 //void treeAdd(int x, int y, int i) {
-//    siz[i] = siz[x] + 1;
 //    rt[i] = merge(rt[x], init(y));
+//    siz[rt[i]] = siz[rt[x]] + 1;
 //}
 //
 //void treeMerge(int x, int y, int i) {
-//    siz[i] = siz[x] + siz[y];
 //    if (rt[x] == 0 && rt[y] == 0) {
 //        rt[i] = 0;
 //    } else if (rt[x] == 0 || rt[y] == 0) {
@@ -77,15 +77,15 @@
 //    } else {
 //        rt[i] = merge(rt[x], rt[y]);
 //    }
+//    siz[rt[i]] = siz[rt[x]] + siz[rt[y]];
 //}
 //
 //void treePop(int x, int i) {
-//    if (siz[x] == 0) {
-//        siz[i] = 0;
+//    if (siz[rt[x]] == 0) {
 //        rt[i] = 0;
 //    } else {
-//        siz[i] = siz[x] - 1;
 //        rt[i] = pop(rt[x]);
+//        siz[rt[i]] = siz[rt[x]] - 1;
 //    }
 //}
 //
@@ -157,9 +157,8 @@
 //
 //bool check(int i) {
 //    int h1 = rt[i];
-//    int s1 = siz[i];
 //    priority_queue<int, vector<int>, greater<int>> h2 = verify[i];
-//    if (s1 != h2.size()) {
+//    if (siz[h1] != h2.size()) {
 //        return false;
 //    }
 //    bool ans = true;
diff --git a/src/class155/Code04_Blocks1.java b/src/class155/Code04_Blocks1.java
index 915846c3b..25293b6da 100644
--- a/src/class155/Code04_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -32,9 +32,8 @@ public class Code04_Blocks1 {
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
-	public static int cnt = 0;
-
 	public static int[] base = new int[MAXT];
+	public static int cnt = 0;
 
 	public static int[] heap = new int[MAXK];
 	public static int heapSize = 0;
diff --git a/src/class155/Code04_Blocks2.java b/src/class155/Code04_Blocks2.java
index d42199c84..598daf971 100644
--- a/src/class155/Code04_Blocks2.java
+++ b/src/class155/Code04_Blocks2.java
@@ -28,9 +28,8 @@
 //int ls[MAXT];
 //int rs[MAXT];
 //int dist[MAXT];
-//int cnt = 0;
-//
 //int base[MAXT];
+//int cnt = 0;
 //
 //int heap[MAXK];
 //int heapSize = 0;

From 34b2eb47d2cc5ad1c62383bb37018b3fa1d0162e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Dec 2024 11:00:01 +0800
Subject: [PATCH 0261/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 1 -
 src/class155/Code01_CityCapture2.java | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index 8e120f52d..ee2a289c6 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -93,7 +93,6 @@ public static int merge(int i, int j) {
 			j = tmp;
 		}
 		down(i);
-		down(j);
 		right[i] = merge(right[i], j);
 		if (dist[left[i]] < dist[right[i]]) {
 			tmp = left[i];
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index d3978d4e9..a17585805 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -70,7 +70,6 @@
 //        j = tmp;
 //    }
 //    down(i);
-//    down(j);
 //    rs[i] = merge(rs[i], j);
 //    if (dist[ls[i]] < dist[rs[i]]) {
 //        tmp = ls[i];

From 011ef257325556f16ade9429b25fbaa6f066266b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 22 Dec 2024 12:30:21 +0800
Subject: [PATCH 0262/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 38 ++++++++++++-------------
 src/class155/Code05_KShortestPath2.java | 36 +++++++++++------------
 2 files changed, 37 insertions(+), 37 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 92a45b277..b9bf1e0dd 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -33,13 +33,13 @@ public class Code05_KShortestPath1 {
 	public static double[] weightr = new double[MAXM];
 	public static int cntr = 0;
 
-	public static int[] start = new int[MAXT];
+	public static int[] to = new int[MAXT];
 	public static double[] cost = new double[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
 	public static int cntt = 0;
-	
+
 	public static int[] rt = new int[MAXN];
 
 	public static int[] idx = new int[MAXH];
@@ -66,15 +66,15 @@ public static void addEdgeR(int u, int v, double w) {
 		headr[u] = cntr;
 	}
 
-	public static int init(int s, double c) {
-		start[++cntt] = s;
+	public static int init(int t, double c) {
+		to[++cntt] = t;
 		cost[cntt] = c;
 		left[cntt] = right[cntt] = dist[cntt] = 0;
 		return cntt;
 	}
 
 	public static int clone(int i) {
-		start[++cntt] = start[i];
+		to[++cntt] = to[i];
 		cost[cntt] = cost[i];
 		left[cntt] = left[i];
 		right[cntt] = right[i];
@@ -139,9 +139,9 @@ public static void dijkstra() {
 		cntd = cnth = 0;
 		heapAdd(n, 0);
 		while (!heapEmpty()) {
-			int h = heapPop();
-			int u = idx[h];
-			double w = val[h];
+			int top = heapPop();
+			int u = idx[top];
+			double w = val[top];
 			if (!vis[u]) {
 				vis[u] = true;
 				for (int e = headr[u], v; e > 0; e = nextr[e]) {
@@ -163,8 +163,8 @@ public static void mergeRoad() {
 		}
 		dist[0] = -1;
 		while (!heapEmpty()) {
-			int h = heapPop();
-			int u = idx[h];
+			int top = heapPop();
+			int u = idx[top];
 			for (int e = headg[u]; e > 0; e = nextg[e]) {
 				if (e != path[u]) {
 					rt[u] = merge(rt[u], init(tog[e], weightg[e] + dis[tog[e]] - dis[u]));
@@ -186,22 +186,22 @@ public static int expand() {
 				heapAdd(rt[1], cost[rt[1]]);
 			}
 			while (!heapEmpty()) {
-				int h = heapPop();
-				int u = idx[h];
-				double w = val[h];
+				int top = heapPop();
+				int i = idx[top];
+				double w = val[top];
 				money -= w + dis[1];
 				if (money < 0) {
 					break;
 				}
 				ans++;
-				if (left[u] != 0) {
-					heapAdd(left[u], w - cost[u] + cost[left[u]]);
+				if (left[i] != 0) {
+					heapAdd(left[i], w - cost[i] + cost[left[i]]);
 				}
-				if (right[u] != 0) {
-					heapAdd(right[u], w - cost[u] + cost[right[u]]);
+				if (right[i] != 0) {
+					heapAdd(right[i], w - cost[i] + cost[right[i]]);
 				}
-				if (start[u] != 0 && rt[start[u]] != 0) {
-					heapAdd(rt[start[u]], w + cost[rt[start[u]]]);
+				if (to[i] != 0 && rt[to[i]] != 0) {
+					heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
 				}
 			}
 		}
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index 1b5558c75..19c93804e 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -30,7 +30,7 @@
 //double weightr[MAXM];
 //int cntr = 0;
 //
-//int start[MAXT];
+//int to[MAXT];
 //double cost[MAXT];
 //int ls[MAXT];
 //int rs[MAXT];
@@ -63,15 +63,15 @@
 //    headr[u] = cntr;
 //}
 //
-//int init(int s, double v){
-//    start[++cntt] = s;
+//int init(int t, double v){
+//    to[++cntt] = t;
 //    cost[cntt] = v;
 //    ls[cntt] = rs[cntt] = dist[cntt] = 0;
 //    return cntt;
 //}
 //
 //int clone(int i){
-//    start[++cntt] = start[i];
+//    to[++cntt] = to[i];
 //    cost[cntt] = cost[i];
 //    ls[cntt] = ls[i];
 //    rs[cntt] = rs[i];
@@ -135,9 +135,9 @@
 //    cntd = cnth = 0;
 //    heapAdd(n, 0.0);
 //    while(!heapEmpty()){
-//        int h = heapPop();
-//        int u = idx[h];
-//        double w = val[h];
+//        int top = heapPop();
+//        int u = idx[top];
+//        double w = val[top];
 //        if(!vis[u]){
 //            vis[u] = true;
 //            for(int e = headr[u]; e != 0; e = nextr[e]){
@@ -159,8 +159,8 @@
 //    }
 //    dist[0] = -1;
 //    while(!heapEmpty()){
-//        int h = heapPop();
-//        int u = idx[h];
+//        int top = heapPop();
+//        int u = idx[top];
 //        for(int e = headg[u]; e != 0; e = nextg[e]){
 //            if(e != path[u]){
 //                rt[u] = merge(rt[u], init(tog[e], weightg[e] + dis[tog[e]] - dis[u]));
@@ -182,22 +182,22 @@
 //            heapAdd(rt[1], cost[rt[1]]);
 //        }
 //        while(!heapEmpty()){
-//            int h = heapPop();
-//            int u = idx[h];
-//            double w = val[h];
+//            int top = heapPop();
+//            int i = idx[top];
+//            double w = val[top];
 //            money -= w + dis[1];
 //            if(money < 0){
 //                break;
 //            }
 //            ans++;
-//            if(ls[u] != 0){
-//                heapAdd(ls[u], w - cost[u] + cost[ls[u]]);
+//            if(ls[i] != 0){
+//                heapAdd(ls[i], w - cost[i] + cost[ls[i]]);
 //            }
-//            if(rs[u] != 0){
-//                heapAdd(rs[u], w - cost[u] + cost[rs[u]]);
+//            if(rs[i] != 0){
+//                heapAdd(rs[i], w - cost[i] + cost[rs[i]]);
 //            }
-//            if(start[u] != 0 && rt[start[u]] != 0){
-//                heapAdd(rt[start[u]], w + cost[rt[start[u]]]);
+//            if(to[i] != 0 && rt[to[i]] != 0){
+//                heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
 //            }
 //        }
 //    }

From 9901f0d7eaa022cb4c149fc7cead87f846272908 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 22 Dec 2024 12:46:03 +0800
Subject: [PATCH 0263/1712] modify code

---
 src/class154/Code01_LeftistTree2.java     | 8 ++------
 src/class154/Code01_LeftistTree4.java     | 8 ++------
 src/class154/Code02_Convict2.java         | 9 ++++-----
 src/class154/Code03_MonkeyKing2.java      | 9 ++-------
 src/class154/Code04_Dispatch2.java        | 9 ++-------
 src/class154/Code05_NumberSequence2.java  | 5 ++---
 src/class155/Code01_CityCapture2.java     | 9 ++-------
 src/class155/Code02_TrickyOperation2.java | 9 ++++-----
 src/class155/Code04_Blocks2.java          | 8 ++++++--
 9 files changed, 26 insertions(+), 48 deletions(-)

diff --git a/src/class154/Code01_LeftistTree2.java b/src/class154/Code01_LeftistTree2.java
index 01857ea29..1d8fe0b0a 100644
--- a/src/class154/Code01_LeftistTree2.java
+++ b/src/class154/Code01_LeftistTree2.java
@@ -43,15 +43,11 @@
 //        return i + j;
 //    }
 //    if (num[i] > num[j] || (num[i] == num[j] && i > j)) {
-//        int tmp = i;
-//        i = j;
-//        j = tmp;
+//        swap(i, j);
 //    }
 //    rs[i] = merge(rs[i], j);
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        int tmp = ls[i];
-//        ls[i] = rs[i];
-//        rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    fa[ls[i]] = fa[rs[i]] = i;
diff --git a/src/class154/Code01_LeftistTree4.java b/src/class154/Code01_LeftistTree4.java
index 6d7cbcb40..cb86536cb 100644
--- a/src/class154/Code01_LeftistTree4.java
+++ b/src/class154/Code01_LeftistTree4.java
@@ -44,15 +44,11 @@
 //        return i + j;
 //    }
 //    if (num[i] > num[j] || (num[i] == num[j] && i > j)) {
-//        int tmp = i;
-//        i = j;
-//        j = tmp;
+//        swap(i, j);
 //    }
 //    rs[i] = merge(rs[i], j);
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        int tmp = ls[i];
-//        ls[i] = rs[i];
-//        rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    fa[ls[i]] = fa[rs[i]] = i;
diff --git a/src/class154/Code02_Convict2.java b/src/class154/Code02_Convict2.java
index 0e21f1f31..e2c949bda 100644
--- a/src/class154/Code02_Convict2.java
+++ b/src/class154/Code02_Convict2.java
@@ -56,14 +56,13 @@
 //    if (i == 0 || j == 0) {
 //        return i + j;
 //    }
-//    int tmp;
 //    if (num[i] < num[j] || (num[i] == num[j] && i > j)) {
-//        tmp = i; i = j; j = tmp;
+//        swap(i, j);
 //    }
 //    rs[i] = merge(rs[i], j);
 //    up[rs[i]] = i;
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    fa[ls[i]] = fa[rs[i]] = i;
@@ -85,10 +84,10 @@
 //        } else {
 //            rs[f] = s;
 //        }
-//        for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
+//        for (int d = dist[s]; dist[f] > d + 1; f = up[f], d++) {
 //            dist[f] = d + 1;
 //            if (dist[ls[f]] < dist[rs[f]]) {
-//                tmp = ls[f]; ls[f] = rs[f]; rs[f] = tmp;
+//                swap(ls[f], rs[f]);
 //            }
 //        }
 //    }
diff --git a/src/class154/Code03_MonkeyKing2.java b/src/class154/Code03_MonkeyKing2.java
index 0b10ccada..9e71edb8a 100644
--- a/src/class154/Code03_MonkeyKing2.java
+++ b/src/class154/Code03_MonkeyKing2.java
@@ -43,17 +43,12 @@
 //    if (i == 0 || j == 0) {
 //        return i + j;
 //    }
-//    int tmp;
 //    if (num[i] < num[j]) {
-//        tmp = i;
-//        i = j;
-//        j = tmp;
+//        swap(i, j);
 //    }
 //    rs[i] = merge(rs[i], j);
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        tmp = ls[i];
-//        ls[i] = rs[i];
-//        rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    fa[ls[i]] = fa[rs[i]] = i;
diff --git a/src/class154/Code04_Dispatch2.java b/src/class154/Code04_Dispatch2.java
index c80580a56..0ab81a5b7 100644
--- a/src/class154/Code04_Dispatch2.java
+++ b/src/class154/Code04_Dispatch2.java
@@ -35,17 +35,12 @@
 //    if (i == 0 || j == 0) {
 //        return i + j;
 //    }
-//    int tmp;
 //    if (cost[i] < cost[j]) {
-//        tmp = i;
-//        i = j;
-//        j = tmp;
+//        swap(i, j);
 //    }
 //    rs[i] = merge(rs[i], j);
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        tmp = ls[i];
-//        ls[i] = rs[i];
-//        rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    fa[ls[i]] = fa[rs[i]] = i;
diff --git a/src/class154/Code05_NumberSequence2.java b/src/class154/Code05_NumberSequence2.java
index 82d0f00f9..1a99b3895 100644
--- a/src/class154/Code05_NumberSequence2.java
+++ b/src/class154/Code05_NumberSequence2.java
@@ -45,13 +45,12 @@
 //    if (i == 0 || j == 0) {
 //        return i + j;
 //    }
-//    int tmp;
 //    if (arr[i] < arr[j]) {
-//        tmp = i; i = j; j = tmp;
+//        swap(i, j);
 //    }
 //    rs[i] = merge(rs[i], j);
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    fa[ls[i]] = fa[rs[i]] = i;
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index a17585805..50e191dfe 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -63,18 +63,13 @@
 //    if (i == 0 || j == 0) {
 //        return i + j;
 //    }
-//    int tmp;
 //    if (attack[i] > attack[j]) {
-//        tmp = i;
-//        i = j;
-//        j = tmp;
+//        swap(i, j);
 //    }
 //    down(i);
 //    rs[i] = merge(rs[i], j);
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        tmp = ls[i];
-//        ls[i] = rs[i];
-//        rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    return i;
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
index 249fdc465..290a6532b 100644
--- a/src/class155/Code02_TrickyOperation2.java
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -55,14 +55,13 @@
 //
 //int merge(int i, int j) {
 //    if (i == 0 || j == 0) return i + j;
-//    int tmp;
 //    if (num[i] < num[j]) {
-//        tmp = i; i = j; j = tmp;
+//        swap(i, j);
 //    }
 //    rs[i] = merge(rs[i], j);
 //    up[rs[i]] = i;
 //    if (dist[ls[i]] < dist[rs[i]]) {
-//        tmp = ls[i]; ls[i] = rs[i]; rs[i] = tmp;
+//        swap(ls[i], rs[i]);
 //    }
 //    dist[i] = dist[rs[i]] + 1;
 //    fa[ls[i]] = i;
@@ -85,10 +84,10 @@
 //        } else {
 //            rs[f] = s;
 //        }
-//        for (int d = dist[s], tmp; dist[f] > d + 1; f = up[f], d++) {
+//        for (int d = dist[s]; dist[f] > d + 1; f = up[f], d++) {
 //            dist[f] = d + 1;
 //            if (dist[ls[f]] < dist[rs[f]]) {
-//                tmp = ls[f]; ls[f] = rs[f]; rs[f] = tmp;
+//                swap(ls[f], rs[f]);
 //            }
 //        }
 //    }
diff --git a/src/class155/Code04_Blocks2.java b/src/class155/Code04_Blocks2.java
index 598daf971..16edc7599 100644
--- a/src/class155/Code04_Blocks2.java
+++ b/src/class155/Code04_Blocks2.java
@@ -56,10 +56,14 @@
 //
 //int merge(int i, int j) {
 //    if (i == 0 || j == 0) return i + j;
-//    if (num[i] > num[j]) swap(i, j);
+//    if (num[i] > num[j]) {
+//        swap(i, j);
+//    }
 //    int h = clone(i);
 //    rs[h] = merge(rs[h], j);
-//    if (dist[ls[h]] < dist[rs[h]]) swap(ls[h], rs[h]);
+//    if (dist[ls[h]] < dist[rs[h]]) {
+//        swap(ls[h], rs[h]);
+//    }
 //    dist[h] = dist[rs[h]] + 1;
 //    return h;
 //}

From 40d85a93e5ef957e62f9a32979b51686892651e2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 22 Dec 2024 13:01:08 +0800
Subject: [PATCH 0264/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 18 +++++++++++++-----
 src/class155/Code05_KShortestPath2.java |  2 +-
 2 files changed, 14 insertions(+), 6 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index b9bf1e0dd..f31cc7958 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -14,7 +14,7 @@ public class Code05_KShortestPath1 {
 
 	public static int MAXN = 50001;
 	public static int MAXM = 200001;
-	public static int MAXT = MAXN * 20;
+	public static int MAXT = 1000001;
 	public static int MAXH = 4200001;
 	public static double INF = 1e18;
 
@@ -88,12 +88,16 @@ public static int merge(int i, int j) {
 		}
 		int tmp;
 		if (cost[i] > cost[j]) {
-			tmp = i; i = j; j = tmp;
+			tmp = i;
+			i = j;
+			j = tmp;
 		}
 		int h = clone(i);
 		right[h] = merge(right[h], j);
 		if (dist[left[h]] < dist[right[h]]) {
-			tmp = left[h]; left[h] = right[h]; right[h] = tmp;
+			tmp = left[h];
+			left[h] = right[h];
+			right[h] = tmp;
 		}
 		dist[h] = dist[right[h]] + 1;
 		return h;
@@ -105,7 +109,9 @@ public static void heapAdd(int i, double v) {
 		heap[++cnth] = cntd;
 		int cur = cnth, father = cur / 2, tmp;
 		while (cur > 1 && val[heap[father]] > val[heap[cur]]) {
-			tmp = heap[father]; heap[father] = heap[cur]; heap[cur] = tmp;
+			tmp = heap[father];
+			heap[father] = heap[cur];
+			heap[cur] = tmp;
 			cur = father;
 			father = cur / 2;
 		}
@@ -121,7 +127,9 @@ public static int heapPop() {
 			if (best == cur) {
 				break;
 			}
-			tmp = heap[best]; heap[best] = heap[cur]; heap[cur] = tmp;
+			tmp = heap[best];
+			heap[best] = heap[cur];
+			heap[cur] = tmp;
 			cur = best;
 			l = cur * 2;
 			r = l + 1;
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index 19c93804e..dc329cbbd 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -11,7 +11,7 @@
 //
 //const int MAXN = 50001;
 //const int MAXM = 200001;
-//const int MAXT = MAXN * 20;
+//const int MAXT = 1000001;
 //const int MAXH = 4200001;
 //const double INF = 1e18;
 //

From 7ef3f77bd8e4f6f558738120ca8443dbbf84ae4f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 22 Dec 2024 23:44:16 +0800
Subject: [PATCH 0265/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 347 +++++++++-----------------
 1 file changed, 119 insertions(+), 228 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index ee2a289c6..23809fa98 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -5,15 +5,8 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3261
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-import java.io.BufferedWriter;
-import java.io.ByteArrayOutputStream;
-import java.io.FileNotFoundException;
-import java.io.FileOutputStream;
 import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.io.Writer;
-import java.util.InputMismatchException;
+import java.io.PrintWriter;
 
 public class Code01_CityCapture1 {
 
@@ -151,254 +144,152 @@ public static void compute() {
 	}
 
 	public static void main(String[] args) {
-		FastReader in = new FastReader(System.in);
-		FastWriter out = new FastWriter(System.out);
-		n = in.readInt();
-		m = in.readInt();
+		ReaderWriter io = new ReaderWriter();
+		n = io.nextInt();
+		m = io.nextInt();
 		prepare();
 		for (int i = 1; i <= n; i++) {
-			defend[i] = in.readLong();
+			defend[i] = io.nextLong();
 		}
 		for (int i = 2; i <= n; i++) {
-			belong[i] = in.readInt();
-			op[i] = in.readInt();
-			gain[i] = in.readLong();
+			belong[i] = io.nextInt();
+			op[i] = io.nextInt();
+			gain[i] = io.nextLong();
 		}
 		for (int i = 1; i <= m; i++) {
-			attack[i] = in.readLong();
-			born[i] = in.readInt();
+			attack[i] = io.nextLong();
+			born[i] = io.nextInt();
 		}
 		compute();
 		for (int i = 1; i <= n; i++) {
-			out.println(sacrifice[i]);
+			io.println(sacrifice[i]);
 		}
 		for (int i = 1; i <= m; i++) {
-			out.println(deep[born[i]] - deep[die[i]]);
+			io.println(deep[born[i]] - deep[die[i]]);
 		}
-		out.flush();
-		out.close();
+		io.flush();
+		io.close();
 	}
 
-	// 快读
-	public static class FastReader {
-		InputStream is;
-		private byte[] inbuf = new byte[1024];
-		public int lenbuf = 0;
-		public int ptrbuf = 0;
+	// 读写工具类
+	public static class ReaderWriter extends PrintWriter {
+		byte[] buf = new byte[1 << 16];
+		int bId = 0, bSize = 0;
+		boolean eof = false;
 
-		public FastReader(final InputStream is) {
-			this.is = is;
+		public ReaderWriter() {
+			super(System.out);
 		}
 
-		public int readByte() {
-			if (lenbuf == -1) {
-				throw new InputMismatchException();
-			}
-			if (ptrbuf >= lenbuf) {
-				ptrbuf = 0;
+		private byte getByte() {
+			if (bId >= bSize) {
 				try {
-					lenbuf = is.read(inbuf);
+					bSize = System.in.read(buf);
 				} catch (IOException e) {
-					throw new InputMismatchException();
-				}
-				if (lenbuf <= 0) {
-					return -1;
+					e.printStackTrace();
 				}
+				if (bSize == -1)
+					eof = true;
+				bId = 0;
 			}
-			return inbuf[ptrbuf++];
+			return buf[bId++];
 		}
 
-		public int readInt() {
-			return (int) readLong();
-		}
+		byte c;
 
-		public long readLong() {
-			long num = 0;
-			int b;
-			boolean minus = false;
-			while ((b = readByte()) != -1 && !((b >= '0' && b <= '9') || b == '-'))
+		public boolean hasNext() {
+			if (eof)
+				return false;
+			while ((c = getByte()) <= 32 && !eof)
 				;
-			if (b == '-') {
-				minus = true;
-				b = readByte();
-			}
-
-			while (true) {
-				if (b >= '0' && b <= '9') {
-					num = num * 10 + (b - '0');
-				} else {
-					return minus ? -num : num;
-				}
-				b = readByte();
-			}
-		}
-	}
-
-	// 快写
-	public static class FastWriter {
-		private static final int BUF_SIZE = 1 << 13;
-		private final byte[] buf = new byte[BUF_SIZE];
-		private OutputStream out;
-		private Writer writer;
-		private int ptr = 0;
-
-		public FastWriter(Writer writer) {
-			this.writer = new BufferedWriter(writer);
-			out = new ByteArrayOutputStream();
-		}
-
-		public FastWriter(OutputStream os) {
-			this.out = os;
-		}
-
-		public FastWriter(String path) {
-			try {
-				this.out = new FileOutputStream(path);
-			} catch (FileNotFoundException e) {
-				throw new RuntimeException("FastWriter");
-			}
-		}
-
-		public FastWriter write(byte b) {
-			buf[ptr++] = b;
-			if (ptr == BUF_SIZE) {
-				innerflush();
-			}
-			return this;
-		}
-
-		public FastWriter write(String s) {
-			s.chars().forEach(c -> {
-				buf[ptr++] = (byte) c;
-				if (ptr == BUF_SIZE) {
-					innerflush();
-				}
-			});
-			return this;
-		}
-
-		private static int countDigits(long l) {
-			if (l >= 1000000000000000000L) {
-				return 19;
-			}
-			if (l >= 100000000000000000L) {
-				return 18;
-			}
-			if (l >= 10000000000000000L) {
-				return 17;
-			}
-			if (l >= 1000000000000000L) {
-				return 16;
-			}
-			if (l >= 100000000000000L) {
-				return 15;
-			}
-			if (l >= 10000000000000L) {
-				return 14;
-			}
-			if (l >= 1000000000000L) {
-				return 13;
-			}
-			if (l >= 100000000000L) {
-				return 12;
-			}
-			if (l >= 10000000000L) {
-				return 11;
-			}
-			if (l >= 1000000000L) {
-				return 10;
-			}
-			if (l >= 100000000L) {
-				return 9;
-			}
-			if (l >= 10000000L) {
-				return 8;
-			}
-			if (l >= 1000000L) {
-				return 7;
-			}
-			if (l >= 100000L) {
-				return 6;
-			}
-			if (l >= 10000L) {
-				return 5;
-			}
-			if (l >= 1000L) {
-				return 4;
-			}
-			if (l >= 100L) {
-				return 3;
-			}
-			if (l >= 10L) {
-				return 2;
-			}
-			return 1;
-		}
-
-		public FastWriter write(long x) {
-			if (x == Long.MIN_VALUE) {
-				return write("" + x);
-			}
-			if (ptr + 21 >= BUF_SIZE) {
-				innerflush();
-			}
-			if (x < 0) {
-				write((byte) '-');
-				x = -x;
-			}
-			int d = countDigits(x);
-			for (int i = ptr + d - 1; i >= ptr; i--) {
-				buf[i] = (byte) ('0' + x % 10);
-				x /= 10;
-			}
-			ptr += d;
-			return this;
-		}
-
-		public FastWriter writeln(long x) {
-			return write(x).writeln();
-		}
-
-		public FastWriter writeln() {
-			return write((byte) '\n');
-		}
-
-		private void innerflush() {
-			try {
-				out.write(buf, 0, ptr);
-				ptr = 0;
-			} catch (IOException e) {
-				throw new RuntimeException("innerflush");
-			}
-		}
-
-		public void flush() {
-			innerflush();
-			try {
-				if (writer != null) {
-					writer.write(((ByteArrayOutputStream) out).toString());
-					out = new ByteArrayOutputStream();
-					writer.flush();
-				} else {
-					out.flush();
+			if (eof)
+				return false;
+			bId--;
+			return true;
+		}
+
+		public String next() {
+			if (!hasNext())
+				return null;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			StringBuilder sb = new StringBuilder();
+			while (c > 32) {
+				sb.append((char) c);
+				c = getByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() {
+			if (!hasNext())
+				return Integer.MIN_VALUE;
+			int sign = 1;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			if (c == '-') {
+				sign = -1;
+				c = getByte();
+			}
+			int val = 0;
+			while (c >= '0' && c <= '9') {
+				val = val * 10 + (c - '0');
+				c = getByte();
+			}
+			bId--;
+			return val * sign;
+		}
+
+		public long nextLong() {
+			if (!hasNext())
+				return Long.MIN_VALUE;
+			int sign = 1;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			if (c == '-') {
+				sign = -1;
+				c = getByte();
+			}
+			long val = 0;
+			while (c >= '0' && c <= '9') {
+				val = val * 10 + (c - '0');
+				c = getByte();
+			}
+			bId--;
+			return val * sign;
+		}
+
+		public double nextDouble() {
+			if (!hasNext())
+				return Double.NaN;
+			int sign = 1;
+			byte c = getByte();
+			while (c <= 32)
+				c = getByte();
+			if (c == '-') {
+				sign = -1;
+				c = getByte();
+			}
+			double val = 0;
+			while (c >= '0' && c <= '9') {
+				val = val * 10 + (c - '0');
+				c = getByte();
+			}
+			if (c == '.') {
+				double mul = 1;
+				c = getByte();
+				while (c >= '0' && c <= '9') {
+					mul *= 0.1;
+					val += (c - '0') * mul;
+					c = getByte();
 				}
-			} catch (IOException e) {
-				throw new RuntimeException("flush");
-			}
-		}
-
-		public FastWriter println(long x) {
-			return writeln(x);
-		}
-
-		public void close() {
-			flush();
-			try {
-				out.close();
-			} catch (Exception e) {
 			}
+			bId--;
+			return val * sign;
 		}
-
 	}
 
 }

From fe94a4dafbde4862f4c2b4bbb6a72884fe878657 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 22 Dec 2024 23:49:57 +0800
Subject: [PATCH 0266/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 14 +++++++-------
 src/class155/Code02_TrickyOperation2.java | 10 +++++-----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 243581336..0b382e8b4 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -28,7 +28,7 @@ public class Code02_TrickyOperation1 {
 
 	public static int[] add = new int[MAXN];
 
-	public static TreeMap<Integer, Integer> heads = new TreeMap<>();
+	public static TreeMap<Integer, Integer> heap = new TreeMap<>();
 
 	public static int addAll = 0;
 
@@ -39,10 +39,10 @@ public class Code02_TrickyOperation1 {
 	public static void minusHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
-			if (heads.get(hnum) == 1) {
-				heads.remove(hnum);
+			if (heap.get(hnum) == 1) {
+				heap.remove(hnum);
 			} else {
-				heads.put(hnum, heads.get(hnum) - 1);
+				heap.put(hnum, heap.get(hnum) - 1);
 			}
 		}
 	}
@@ -50,13 +50,13 @@ public static void minusHead(int h) {
 	public static void addHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
-			heads.put(hnum, heads.getOrDefault(hnum, 0) + 1);
+			heap.put(hnum, heap.getOrDefault(hnum, 0) + 1);
 		}
 	}
 
 	public static void prepare() {
 		dist[0] = -1;
-		heads.clear();
+		heap.clear();
 		for (int i = 1; i <= n; i++) {
 			up[i] = left[i] = right[i] = dist[i] = 0;
 			father[i] = i;
@@ -202,7 +202,7 @@ public static int f2(int i) {
 	}
 
 	public static int f3() {
-		return heads.lastKey() + addAll;
+		return heap.lastKey() + addAll;
 	}
 
 	public static void main(String[] args) {
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
index 290a6532b..61ab69857 100644
--- a/src/class155/Code02_TrickyOperation2.java
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -19,25 +19,25 @@
 //int siz[MAXN]; 
 //int add[MAXN];
 //int sta[MAXN];
-//multiset<int> heads;
+//multiset<int> heap;
 //int addAll = 0;
 //int n, m;
 //
 //void minusHead(int h) {
 //    if (h != 0) {
-//        heads.erase(heads.find(num[h] + add[h]));
+//        heap.erase(heap.find(num[h] + add[h]));
 //    }
 //}
 //
 //void addHead(int h) {
 //    if (h != 0) {
-//        heads.insert(num[h] + add[h]);
+//        heap.insert(num[h] + add[h]);
 //    }
 //}
 //
 //void prepare() {
 //    dist[0] = -1;
-//    heads.clear();
+//    heap.clear();
 //    for (int i = 1; i <= n; i++) {
 //        up[i] = ls[i] = rs[i] = dist[i] = 0;
 //        fa[i] = i;
@@ -169,7 +169,7 @@
 //}
 //
 //int f3() {
-//    return (*heads.rbegin()) + addAll;
+//    return (*heap.rbegin()) + addAll;
 //}
 //
 //int main(){

From 147224db6a138e2b8cf85b48d4ac5aadf11646f3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Dec 2024 15:19:17 +0800
Subject: [PATCH 0267/1712] modify code

---
 src/class155/Code01_CityCapture1.java     | 30 +++++++++++++++--------
 src/class155/Code01_CityCapture2.java     | 26 ++++++++++++++------
 src/class155/Code02_TrickyOperation1.java |  9 +++++++
 src/class155/Code02_TrickyOperation2.java |  9 +++++++
 src/class155/Code04_Blocks1.java          |  7 ++++++
 src/class155/Code04_Blocks2.java          |  7 ++++++
 src/class155/Code05_KShortestPath1.java   |  8 ++++++
 src/class155/Code05_KShortestPath2.java   |  8 ++++++
 8 files changed, 86 insertions(+), 18 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index 23809fa98..be279ec01 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -1,7 +1,17 @@
 package class155;
 
 // 城池攻占，java版
-// 输入保证，如果城市a管辖城市b，必有a < b
+// 一共有n个城市，1号城市是城市树的头，每个城市有di、bi、oi、gi
+// 分别表示，城市防御值、上级城市编号、奖励类型、奖励值
+// 如果奖励类型为0，那么任何骑士攻克这个城市后，攻击力会增加gi
+// 如果奖励类型为1，那么任何骑士攻克这个城市后，攻击力会乘以gi
+// 输入保证，任何城市的上级编号 < 这座城市的编号
+// 一共有m个骑士，每个骑士都有攻击力ai、第一次攻击的城市fi
+// 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市
+// 如果骑士攻击力  < 城市防御值，那么骑士会在该城市牺牲，没有后续动作了
+// 所有骑士都是独立的，不会影响其他骑士攻击这座城池的结果
+// 打印每个城市牺牲的骑士数量，打印每个骑士攻占的城市数量
+// 1 <= n、m <= 3 * 10^5，攻击值的增加也不会超过long类型范围
 // 测试链接 : https://www.luogu.com.cn/problem/P3261
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -22,16 +32,16 @@ public class Code01_CityCapture1 {
 
 	public static long[] gain = new long[MAXN];
 
+	public static long[] attack = new long[MAXN];
+
+	public static int[] first = new int[MAXN];
+
 	public static int[] deep = new int[MAXN];
 
 	public static int[] top = new int[MAXN];
 
 	public static int[] sacrifice = new int[MAXN];
 
-	public static long[] attack = new long[MAXN];
-
-	public static int[] born = new int[MAXN];
-
 	public static int[] die = new int[MAXN];
 
 	public static int[] left = new int[MAXN];
@@ -120,10 +130,10 @@ public static void compute() {
 			deep[i] = deep[belong[i]] + 1;
 		}
 		for (int i = 1; i <= m; i++) {
-			if (top[born[i]] == 0) {
-				top[born[i]] = i;
+			if (top[first[i]] == 0) {
+				top[first[i]] = i;
 			} else {
-				top[born[i]] = merge(top[born[i]], i);
+				top[first[i]] = merge(top[first[i]], i);
 			}
 		}
 		for (int i = n; i >= 1; i--) {
@@ -158,14 +168,14 @@ public static void main(String[] args) {
 		}
 		for (int i = 1; i <= m; i++) {
 			attack[i] = io.nextLong();
-			born[i] = io.nextInt();
+			first[i] = io.nextInt();
 		}
 		compute();
 		for (int i = 1; i <= n; i++) {
 			io.println(sacrifice[i]);
 		}
 		for (int i = 1; i <= m; i++) {
-			io.println(deep[born[i]] - deep[die[i]]);
+			io.println(deep[first[i]] - deep[die[i]]);
 		}
 		io.flush();
 		io.close();
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 50e191dfe..2e2227737 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -1,7 +1,17 @@
 package class155;
 
 // 城池攻占，C++版
-// 输入保证，如果城市a管辖城市b，必有a < b
+// 一共有n个城市，1号城市是城市树的头，每个城市有di、bi、oi、gi
+// 分别表示，城市防御值、上级城市编号、奖励类型、奖励值
+// 如果奖励类型为0，那么任何骑士攻克这个城市后，攻击力会增加gi
+// 如果奖励类型为1，那么任何骑士攻克这个城市后，攻击力会乘以gi
+// 输入保证，任何城市的上级编号 < 这座城市的编号
+// 一共有m个骑士，每个骑士都有攻击力ai、第一次攻击的城市fi
+// 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市
+// 如果骑士攻击力  < 城市防御值，那么骑士会在该城市牺牲，没有后续动作了
+// 所有骑士都是独立的，不会影响其他骑士攻击这座城池的结果
+// 打印每个城市牺牲的骑士数量，打印每个骑士攻占的城市数量
+// 1 <= n、m <= 3 * 10^5，攻击值的增加也不会超过long类型范围
 // 测试链接 : https://www.luogu.com.cn/problem/P3261
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -16,11 +26,11 @@
 //int belong[MAXN];
 //int op[MAXN];       
 //long long gain[MAXN];
+//long long attack[MAXN];
+//int first[MAXN];
 //int deep[MAXN];
 //int top[MAXN];
 //int sacrifice[MAXN];
-//long long attack[MAXN];
-//int born[MAXN];
 //int die[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
@@ -99,10 +109,10 @@
 //        deep[i] = deep[belong[i]] + 1;
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        if (top[born[i]] == 0) {
-//            top[born[i]] = i;
+//        if (top[first[i]] == 0) {
+//            top[first[i]] = i;
 //        } else {
-//            top[born[i]] = merge(top[born[i]], i);
+//            top[first[i]] = merge(top[first[i]], i);
 //        }
 //    }
 //    for (int i = n; i >= 1; i--) {
@@ -134,14 +144,14 @@
 //        cin >> belong[i] >> op[i] >> gain[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> attack[i] >> born[i];
+//        cin >> attack[i] >> first[i];
 //    }
 //    compute();
 //    for (int i = 1; i <= n; i++) {
 //        cout << sacrifice[i] << "\n";
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cout << deep[born[i]] - deep[die[i]] << endl;
+//        cout << deep[first[i]] - deep[die[i]] << endl;
 //    }
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 0b382e8b4..e86ca3b83 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -1,6 +1,15 @@
 package class155;
 
 // 棘手的操作，java版
+// 编号1~n个节点，每个节点独立且有自己的权值，实现如下6种操作，操作一共调用m次
+// U x y  : x所在的集合和y所在的集合合并
+// A1 x v : x节点的权值增加v
+// A2 x v : x所在的集合所有节点的权值增加v
+// A3 v   : 所有节点的权值增加v
+// F1 x   : 打印x节点的权值
+// F2 x   : 打印x所在的集合中，权值最大的节点的权值
+// F3     : 打印所有节点中，权值最大的节点的权值
+// 1 <= n、m <= 3 * 10^5，权值不会超过int类型的范围
 // 测试链接 : https://www.luogu.com.cn/problem/P3273
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
index 61ab69857..53c162222 100644
--- a/src/class155/Code02_TrickyOperation2.java
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -1,6 +1,15 @@
 package class155;
 
 // 棘手的操作，C++版
+// 编号1~n个节点，每个节点独立且有自己的权值，实现如下6种操作，操作一共调用m次
+// U x y  : x所在的集合和y所在的集合合并
+// A1 x v : x节点的权值增加v
+// A2 x v : x所在的集合所有节点的权值增加v
+// A3 v   : 所有节点的权值增加v
+// F1 x   : 打印x节点的权值
+// F2 x   : 打印x所在的集合中，权值最大的节点的权值
+// F3     : 打印所有节点中，权值最大的节点的权值
+// 1 <= n、m <= 3 * 10^5，权值不会超过int类型的范围
 // 测试链接 : https://www.luogu.com.cn/problem/P3273
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class155/Code04_Blocks1.java b/src/class155/Code04_Blocks1.java
index 25293b6da..485acbb12 100644
--- a/src/class155/Code04_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -1,6 +1,13 @@
 package class155;
 
 // Y的积木，可持久化左偏树实现最优解，java版
+// 一共有n个正数数组，给定每个数组的大小mi，以及每个数组的数字
+// 每个数组必须选且只能选一个数字，就可以形成n个数字的挑选方案
+// 所有这些方案中，有数字累加和第1小的方案、第2小的方案、第3小的方案...
+// 打印，累加和前k小的方案，各自的累加和，要求实现O(k * log k)的解
+// 1 <= n、mi <= 100
+// 1 <= k <= 10^4
+// 1 <= 数字 <= 100
 // 测试链接 : https://www.luogu.com.cn/problem/P2409
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class155/Code04_Blocks2.java b/src/class155/Code04_Blocks2.java
index 16edc7599..048fb2d65 100644
--- a/src/class155/Code04_Blocks2.java
+++ b/src/class155/Code04_Blocks2.java
@@ -1,6 +1,13 @@
 package class155;
 
 // Y的积木，可持久化左偏树实现最优解，C++版
+// 一共有n个正数数组，给定每个数组的大小mi，以及每个数组的数字
+// 每个数组必须选且只能选一个数字，就可以形成n个数字的挑选方案
+// 所有这些方案中，有数字累加和第1小的方案、第2小的方案、第3小的方案...
+// 打印，累加和前k小的方案，各自的累加和，要求实现O(k * log k)的解
+// 1 <= n、mi <= 100
+// 1 <= k <= 10^4
+// 1 <= 数字 <= 100
 // 测试链接 : https://www.luogu.com.cn/problem/P2409
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index f31cc7958..7b2d895a3 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -1,6 +1,14 @@
 package class155;
 
 // k短路问题，可持久化左偏树实现最优解，java版
+// 一共有n个点，编号1~n，一共有m条边，每条边有边权，组成一个有向带权图
+// 从1号点走到n号点，就认为是一次旅行
+// 一次旅行中，边不能重复选，但是点可以重复经过，如果到达了n号点，那么这次旅行直接停止
+// 从1号点走到n号点，会有很多通路方案，通路方案的路费为所有选择边集的边权和
+// 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
+// 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
+// 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
+// 可持久化左偏树的解法可以做到最优解，请用此方法实现
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index dc329cbbd..b15e0ff92 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -1,6 +1,14 @@
 package class155;
 
 // k短路问题，可持久化左偏树实现最优解，C++版
+// 一共有n个点，编号1~n，m条边，每条边都有边权，组成一个有向带权图
+// 从1号点走到n号点，就认为是一次旅行
+// 一次旅行中，边不能重复选，但是点可以重复经过，如果到达了n号点，那么这次旅行直接停止
+// 从1号点走到n号点，会有很多通路方案，通路方案的路费为所有选择边集的边权和
+// 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
+// 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
+// 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
+// 可持久化左偏树的解法可以做到最优解，请用此方法实现
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 15fc26d32d8f9f5bf68ace0657567529eb5973a8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Dec 2024 15:37:56 +0800
Subject: [PATCH 0268/1712] modify code

---
 src/class155/Code01_CityCapture1.java   | 9 ++++-----
 src/class155/Code01_CityCapture2.java   | 9 ++++-----
 src/class155/Code05_KShortestPath1.java | 2 +-
 src/class155/Code05_KShortestPath2.java | 2 +-
 4 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index be279ec01..dd1c5f0bf 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -1,12 +1,11 @@
 package class155;
 
 // 城池攻占，java版
-// 一共有n个城市，1号城市是城市树的头，每个城市有di、bi、oi、gi
-// 分别表示，城市防御值、上级城市编号、奖励类型、奖励值
-// 如果奖励类型为0，那么任何骑士攻克这个城市后，攻击力会增加gi
-// 如果奖励类型为1，那么任何骑士攻克这个城市后，攻击力会乘以gi
+// 一共有n个城市，1号城市是城市树的头，每个城市有城市防御值、上级城市编号、奖励类型、奖励值
+// 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上该城市的奖励值
+// 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以该城市的奖励值
 // 输入保证，任何城市的上级编号 < 这座城市的编号
-// 一共有m个骑士，每个骑士都有攻击力ai、第一次攻击的城市fi
+// 一共有m个骑士，每个骑士都有攻击力、第一次攻击的城市
 // 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市
 // 如果骑士攻击力  < 城市防御值，那么骑士会在该城市牺牲，没有后续动作了
 // 所有骑士都是独立的，不会影响其他骑士攻击这座城池的结果
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 2e2227737..1cdbe6a32 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -1,12 +1,11 @@
 package class155;
 
 // 城池攻占，C++版
-// 一共有n个城市，1号城市是城市树的头，每个城市有di、bi、oi、gi
-// 分别表示，城市防御值、上级城市编号、奖励类型、奖励值
-// 如果奖励类型为0，那么任何骑士攻克这个城市后，攻击力会增加gi
-// 如果奖励类型为1，那么任何骑士攻克这个城市后，攻击力会乘以gi
+// 一共有n个城市，1号城市是城市树的头，每个城市有城市防御值、上级城市编号、奖励类型、奖励值
+// 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上该城市的奖励值
+// 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以该城市的奖励值
 // 输入保证，任何城市的上级编号 < 这座城市的编号
-// 一共有m个骑士，每个骑士都有攻击力ai、第一次攻击的城市fi
+// 一共有m个骑士，每个骑士都有攻击力、第一次攻击的城市
 // 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市
 // 如果骑士攻击力  < 城市防御值，那么骑士会在该城市牺牲，没有后续动作了
 // 所有骑士都是独立的，不会影响其他骑士攻击这座城池的结果
diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 7b2d895a3..18458b2c7 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -8,7 +8,7 @@
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
 // 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
 // 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
-// 可持久化左偏树的解法可以做到最优解，请用此方法实现
+// 可持久化左偏树的解法能做到最优解，请用此方法实现
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index b15e0ff92..bf7a6afbf 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -8,7 +8,7 @@
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
 // 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
 // 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
-// 可持久化左偏树的解法可以做到最优解，请用此方法实现
+// 可持久化左偏树的解法能做到最优解，请用此方法实现
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 21e866d7ba6b90298928cf0b411f0fa993aad3b8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Dec 2024 16:04:27 +0800
Subject: [PATCH 0269/1712] modify code

---
 src/class155/Code01_CityCapture1.java     | 13 +++++++++++++
 src/class155/Code02_TrickyOperation1.java | 11 +++++++++--
 src/class155/Code02_TrickyOperation2.java |  2 +-
 3 files changed, 23 insertions(+), 3 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index dd1c5f0bf..ae6cee7a6 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -23,34 +23,47 @@ public class Code01_CityCapture1 {
 
 	public static int n, m;
 
+	// 城市防御值
 	public static long[] defend = new long[MAXN];
 
+	// 上级城市编号
 	public static int[] belong = new int[MAXN];
 
+	// 奖励类型
 	public static int[] op = new int[MAXN];
 
+	// 奖励值
 	public static long[] gain = new long[MAXN];
 
+	// 骑士攻击力
 	public static long[] attack = new long[MAXN];
 
+	// 骑士第一次攻击的城市
 	public static int[] first = new int[MAXN];
 
+	// 城市在城市树中的深度
 	public static int[] deep = new int[MAXN];
 
+	// 城市拥有的骑士列表，用小根堆左偏树组织，最弱的骑士是头
 	public static int[] top = new int[MAXN];
 
+	// 每个城市牺牲人数统计
 	public static int[] sacrifice = new int[MAXN];
 
+	// 每个骑士死在了什么城市
 	public static int[] die = new int[MAXN];
 
+	// 左偏树需要
 	public static int[] left = new int[MAXN];
 
 	public static int[] right = new int[MAXN];
 
 	public static int[] dist = new int[MAXN];
 
+	// 懒更新信息，攻击力应该乘多少
 	public static long[] mul = new long[MAXN];
 
+	// 懒更新信息，攻击力应该加多少
 	public static long[] add = new long[MAXN];
 
 	public static void prepare() {
diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index e86ca3b83..c932531bc 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -21,6 +21,9 @@ public class Code02_TrickyOperation1 {
 
 	public static int MAXN = 300001;
 
+	public static int n, m;
+
+	// 左偏树需要
 	public static int[] num = new int[MAXN];
 
 	public static int[] up = new int[MAXN];
@@ -31,20 +34,24 @@ public class Code02_TrickyOperation1 {
 
 	public static int[] dist = new int[MAXN];
 
+	// 并查集的路径信息
 	public static int[] father = new int[MAXN];
 
+	// 集合的大小信息
 	public static int[] size = new int[MAXN];
 
+	// 集合内所有数字应该加多少值
 	public static int[] add = new int[MAXN];
 
+	// 所有集合头节点的值，进入这个堆
 	public static TreeMap<Integer, Integer> heap = new TreeMap<>();
 
+	// 所有数字应该加多少
 	public static int addAll = 0;
 
+	// 准备好一个栈，用迭代方式实现先序遍历，不用递归方式
 	public static int[] stack = new int[MAXN];
 
-	public static int n, m;
-
 	public static void minusHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
index 53c162222..7b84cd101 100644
--- a/src/class155/Code02_TrickyOperation2.java
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -19,6 +19,7 @@
 //using namespace std;
 //
 //const int MAXN = 300001;
+//int n, m;
 //int num[MAXN];
 //int up[MAXN];
 //int ls[MAXN];
@@ -30,7 +31,6 @@
 //int sta[MAXN];
 //multiset<int> heap;
 //int addAll = 0;
-//int n, m;
 //
 //void minusHead(int h) {
 //    if (h != 0) {

From 933496d23f0e2e09da6f5c375c66d49929c043c2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Dec 2024 16:15:46 +0800
Subject: [PATCH 0270/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 4 ++--
 src/class155/Code01_CityCapture2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index ae6cee7a6..c3385adb5 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -1,10 +1,10 @@
 package class155;
 
 // 城池攻占，java版
-// 一共有n个城市，1号城市是城市树的头，每个城市有城市防御值、上级城市编号、奖励类型、奖励值
+// 一共有n个城市，1号城市是城市树的头，每个城市都有防御值、上级城市编号、奖励类型、奖励值
 // 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上该城市的奖励值
 // 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以该城市的奖励值
-// 输入保证，任何城市的上级编号 < 这座城市的编号
+// 任何城市的上级编号 < 这座城市的编号，1号城市没有上级城市编号、奖励类型、奖励值
 // 一共有m个骑士，每个骑士都有攻击力、第一次攻击的城市
 // 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市
 // 如果骑士攻击力  < 城市防御值，那么骑士会在该城市牺牲，没有后续动作了
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 1cdbe6a32..aaa73ad90 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -1,10 +1,10 @@
 package class155;
 
 // 城池攻占，C++版
-// 一共有n个城市，1号城市是城市树的头，每个城市有城市防御值、上级城市编号、奖励类型、奖励值
+// 一共有n个城市，1号城市是城市树的头，每个城市都有防御值、上级城市编号、奖励类型、奖励值
 // 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上该城市的奖励值
 // 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以该城市的奖励值
-// 输入保证，任何城市的上级编号 < 这座城市的编号
+// 任何城市的上级编号 < 这座城市的编号，1号城市没有上级城市编号、奖励类型、奖励值
 // 一共有m个骑士，每个骑士都有攻击力、第一次攻击的城市
 // 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市
 // 如果骑士攻击力  < 城市防御值，那么骑士会在该城市牺牲，没有后续动作了

From 7f5a6ee4a28aac3e8d208a89bc8c46fc468c9dbf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Dec 2024 16:23:48 +0800
Subject: [PATCH 0271/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index c932531bc..93d18662f 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -43,7 +43,7 @@ public class Code02_TrickyOperation1 {
 	// 集合内所有数字应该加多少值
 	public static int[] add = new int[MAXN];
 
-	// 所有集合头节点的值，进入这个堆
+	// 所有集合头节点的值，进入这个堆，头堆
 	public static TreeMap<Integer, Integer> heap = new TreeMap<>();
 
 	// 所有数字应该加多少

From 97ab0565b11c018aa1572c82bdafccbdf8d6c12a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Dec 2024 16:51:33 +0800
Subject: [PATCH 0272/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 22 +++++++++++-----------
 src/class155/Code01_CityCapture2.java | 22 +++++++++++-----------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index c3385adb5..ada3d8c8b 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -78,6 +78,17 @@ public static void prepare() {
 		}
 	}
 
+	public static void upgrade(int i, int t, long v) {
+		if (t == 0) {
+			add[i] += v;
+			attack[i] += v;
+		} else {
+			mul[i] *= v;
+			add[i] *= v;
+			attack[i] *= v;
+		}
+	}
+
 	public static void down(int i) {
 		if (mul[i] != 1 || add[i] != 0) {
 			int l = left[i];
@@ -125,17 +136,6 @@ public static int pop(int i) {
 		return ans;
 	}
 
-	public static void upgrade(int i, int t, long v) {
-		if (t == 0) {
-			add[i] += v;
-			attack[i] += v;
-		} else {
-			mul[i] *= v;
-			add[i] *= v;
-			attack[i] *= v;
-		}
-	}
-
 	public static void compute() {
 		deep[1] = 1;
 		for (int i = 2; i <= n; i++) {
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index aaa73ad90..757fe5161 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -49,6 +49,17 @@
 //    }
 //}
 //
+//void upgrade(int i, int t, long long v) {
+//    if (t == 0) {
+//        add[i] += v;
+//        attack[i] += v;
+//    } else {
+//        mul[i] *= v;
+//        add[i] = add[i] * v;
+//        attack[i] = attack[i] * v;
+//    }
+//}
+//
 //void down(int i) {
 //    if (mul[i] != 1 || add[i] != 0) {
 //        int l = ls[i];
@@ -91,17 +102,6 @@
 //    return ans;
 //}
 //
-//void upgrade(int i, int t, long long v) {
-//    if (t == 0) {
-//        add[i] += v;
-//        attack[i] += v;
-//    } else {
-//        mul[i] *= v;
-//        add[i] = add[i] * v;
-//        attack[i] = attack[i] * v;
-//    }
-//}
-//
 //void compute() {
 //    deep[1] = 1;
 //    for (int i = 2; i <= n; i++) {

From 033eb56a54df403f4338ae59d7e53f60bad4f19b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Dec 2024 17:16:09 +0800
Subject: [PATCH 0273/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 1 -
 src/class155/Code05_KShortestPath2.java | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 18458b2c7..f429d807d 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -8,7 +8,6 @@
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
 // 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
 // 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
-// 可持久化左偏树的解法能做到最优解，请用此方法实现
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index bf7a6afbf..e3aaa3690 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -8,7 +8,6 @@
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
 // 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
 // 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
-// 可持久化左偏树的解法能做到最优解，请用此方法实现
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 60d6c32b63a0eb9aff51da58fe8986070b324594 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 11:44:53 +0800
Subject: [PATCH 0274/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 10 +++++-----
 src/class155/Code05_KShortestPath2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index f429d807d..5b3e1dc2c 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -203,20 +203,20 @@ public static int expand() {
 			while (!heapEmpty()) {
 				int top = heapPop();
 				int i = idx[top];
-				double w = val[top];
-				money -= w + dis[1];
+				double v = val[top];
+				money -= v + dis[1];
 				if (money < 0) {
 					break;
 				}
 				ans++;
 				if (left[i] != 0) {
-					heapAdd(left[i], w - cost[i] + cost[left[i]]);
+					heapAdd(left[i], v - cost[i] + cost[left[i]]);
 				}
 				if (right[i] != 0) {
-					heapAdd(right[i], w - cost[i] + cost[right[i]]);
+					heapAdd(right[i], v - cost[i] + cost[right[i]]);
 				}
 				if (to[i] != 0 && rt[to[i]] != 0) {
-					heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
+					heapAdd(rt[to[i]], v + cost[rt[to[i]]]);
 				}
 			}
 		}
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index e3aaa3690..a0ed8956b 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -191,20 +191,20 @@
 //        while(!heapEmpty()){
 //            int top = heapPop();
 //            int i = idx[top];
-//            double w = val[top];
-//            money -= w + dis[1];
+//            double v = val[top];
+//            money -= v + dis[1];
 //            if(money < 0){
 //                break;
 //            }
 //            ans++;
 //            if(ls[i] != 0){
-//                heapAdd(ls[i], w - cost[i] + cost[ls[i]]);
+//                heapAdd(ls[i], v - cost[i] + cost[ls[i]]);
 //            }
 //            if(rs[i] != 0){
-//                heapAdd(rs[i], w - cost[i] + cost[rs[i]]);
+//                heapAdd(rs[i], v - cost[i] + cost[rs[i]]);
 //            }
 //            if(to[i] != 0 && rt[to[i]] != 0){
-//                heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
+//                heapAdd(rt[to[i]], v + cost[rt[to[i]]]);
 //            }
 //        }
 //    }

From a930f1ca8ddd9e561d335bf0adb3c9ffc14bc08b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 12:04:57 +0800
Subject: [PATCH 0275/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 3 +--
 src/class155/Code05_KShortestPath2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 5b3e1dc2c..4a898e413 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -51,9 +51,8 @@ public class Code05_KShortestPath1 {
 
 	public static int[] idx = new int[MAXH];
 	public static double[] val = new double[MAXH];
-	public static int cntd;
 	public static int[] heap = new int[MAXH];
-	public static int cnth;
+	public static int cntd, cnth;
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] path = new int[MAXN];
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index a0ed8956b..511c9df68 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -48,9 +48,8 @@
 //
 //int idx[MAXH];
 //double val[MAXH];
-//int cntd = 0;
 //int heap[MAXH];
-//int cnth = 0;
+//int cntd, cnth;
 //
 //bool vis[MAXN];
 //int path[MAXN];

From 2d8ed22b7aec3f601a7b11f33f723fd04093d722 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 12:09:55 +0800
Subject: [PATCH 0276/1712] modify code

---
 src/class155/Code03_PersistentLeftistTree1.java | 3 +--
 src/class155/Code03_PersistentLeftistTree2.java | 5 ++---
 src/class155/Code05_KShortestPath1.java         | 3 +--
 src/class155/Code05_KShortestPath2.java         | 3 +--
 4 files changed, 5 insertions(+), 9 deletions(-)

diff --git a/src/class155/Code03_PersistentLeftistTree1.java b/src/class155/Code03_PersistentLeftistTree1.java
index 3c8d16db0..34566df9d 100644
--- a/src/class155/Code03_PersistentLeftistTree1.java
+++ b/src/class155/Code03_PersistentLeftistTree1.java
@@ -11,6 +11,7 @@ public class Code03_PersistentLeftistTree1 {
 	public static int MAXV = 100000;
 	public static int MAXT = 2000001;
 
+	public static int[] rt = new int[MAXN];
 	public static int[] num = new int[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
@@ -18,8 +19,6 @@ public class Code03_PersistentLeftistTree1 {
 	public static int[] size = new int[MAXT];
 	public static int cnt = 0;
 
-	public static int[] rt = new int[MAXN];
-
 	public static int init(int v) {
 		num[++cnt] = v;
 		left[cnt] = right[cnt] = dist[cnt] = 0;
diff --git a/src/class155/Code03_PersistentLeftistTree2.java b/src/class155/Code03_PersistentLeftistTree2.java
index fbe2caaa1..e649a298c 100644
--- a/src/class155/Code03_PersistentLeftistTree2.java
+++ b/src/class155/Code03_PersistentLeftistTree2.java
@@ -15,6 +15,7 @@
 //const int MAXV = 100000;
 //const int MAXT = 2000001;
 //
+//int rt[MAXN];
 //int num[MAXT];
 //int ls[MAXT];
 //int rs[MAXT];
@@ -22,8 +23,6 @@
 //int siz[MAXT];
 //int cnt = 0;
 //
-//int rt[MAXN];
-//
 //int init(int v) {
 //    num[++cnt] = v;
 //    ls[cnt] = rs[cnt] = dist[cnt] = 0;
@@ -212,6 +211,6 @@
 //            cout << "err!" << endl;
 //        }
 //    }
-//    cout << "test end" << endl;
+//    cout << "test finish" << endl;
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 4a898e413..a05bf0682 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -40,6 +40,7 @@ public class Code05_KShortestPath1 {
 	public static double[] weightr = new double[MAXM];
 	public static int cntr = 0;
 
+	public static int[] rt = new int[MAXN];
 	public static int[] to = new int[MAXT];
 	public static double[] cost = new double[MAXT];
 	public static int[] left = new int[MAXT];
@@ -47,8 +48,6 @@ public class Code05_KShortestPath1 {
 	public static int[] dist = new int[MAXT];
 	public static int cntt = 0;
 
-	public static int[] rt = new int[MAXN];
-
 	public static int[] idx = new int[MAXH];
 	public static double[] val = new double[MAXH];
 	public static int[] heap = new int[MAXH];
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index 511c9df68..5cd59d614 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -37,6 +37,7 @@
 //double weightr[MAXM];
 //int cntr = 0;
 //
+//int rt[MAXN];
 //int to[MAXT];
 //double cost[MAXT];
 //int ls[MAXT];
@@ -44,8 +45,6 @@
 //int dist[MAXT];
 //int cntt = 0;
 //
-//int rt[MAXN];
-//
 //int idx[MAXH];
 //double val[MAXH];
 //int heap[MAXH];

From a8c83271724cb3a446c01fc84430575776ddca8f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 12:25:40 +0800
Subject: [PATCH 0277/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 15 ++++++++-------
 src/class155/Code05_KShortestPath2.java | 21 +++++++++++----------
 2 files changed, 19 insertions(+), 17 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index a05bf0682..35a288ffc 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -178,9 +178,10 @@ public static void mergeRoad() {
 		while (!heapEmpty()) {
 			int top = heapPop();
 			int u = idx[top];
-			for (int e = headg[u]; e > 0; e = nextg[e]) {
+			for (int e = headg[u], v; e > 0; e = nextg[e]) {
+				v = tog[e];
 				if (e != path[u]) {
-					rt[u] = merge(rt[u], init(tog[e], weightg[e] + dis[tog[e]] - dis[u]));
+					rt[u] = merge(rt[u], init(v, weightg[e] + dis[v] - dis[u]));
 				}
 			}
 			if (path[u] != 0) {
@@ -201,20 +202,20 @@ public static int expand() {
 			while (!heapEmpty()) {
 				int top = heapPop();
 				int i = idx[top];
-				double v = val[top];
-				money -= v + dis[1];
+				double w = val[top];
+				money -= w + dis[1];
 				if (money < 0) {
 					break;
 				}
 				ans++;
 				if (left[i] != 0) {
-					heapAdd(left[i], v - cost[i] + cost[left[i]]);
+					heapAdd(left[i], w - cost[i] + cost[left[i]]);
 				}
 				if (right[i] != 0) {
-					heapAdd(right[i], v - cost[i] + cost[right[i]]);
+					heapAdd(right[i], w - cost[i] + cost[right[i]]);
 				}
 				if (to[i] != 0 && rt[to[i]] != 0) {
-					heapAdd(rt[to[i]], v + cost[rt[to[i]]]);
+					heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
 				}
 			}
 		}
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index 5cd59d614..b204d9b4d 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -1,7 +1,7 @@
 package class155;
 
 // k短路问题，可持久化左偏树实现最优解，C++版
-// 一共有n个点，编号1~n，m条边，每条边都有边权，组成一个有向带权图
+// 一共有n个点，编号1~n，一共有m条边，每条边有边权，组成一个有向带权图
 // 从1号点走到n号点，就认为是一次旅行
 // 一次旅行中，边不能重复选，但是点可以重复经过，如果到达了n号点，那么这次旅行直接停止
 // 从1号点走到n号点，会有很多通路方案，通路方案的路费为所有选择边集的边权和
@@ -145,8 +145,8 @@
 //        double w = val[top];
 //        if(!vis[u]){
 //            vis[u] = true;
-//            for(int e = headr[u]; e != 0; e = nextr[e]){
-//                int v = tor[e];
+//            for(int e = headr[u], v; e != 0; e = nextr[e]){
+//                v = tor[e];
 //                if(dis[v] > w + weightr[e]){
 //                    dis[v] = w + weightr[e];
 //                    path[v] = e;
@@ -166,9 +166,10 @@
 //    while(!heapEmpty()){
 //        int top = heapPop();
 //        int u = idx[top];
-//        for(int e = headg[u]; e != 0; e = nextg[e]){
+//        for(int e = headg[u], v; e != 0; e = nextg[e]){
+//            v = tog[e];
 //            if(e != path[u]){
-//                rt[u] = merge(rt[u], init(tog[e], weightg[e] + dis[tog[e]] - dis[u]));
+//                rt[u] = merge(rt[u], init(v, weightg[e] + dis[v] - dis[u]));
 //            }
 //        }
 //        if(path[u] != 0){
@@ -189,20 +190,20 @@
 //        while(!heapEmpty()){
 //            int top = heapPop();
 //            int i = idx[top];
-//            double v = val[top];
-//            money -= v + dis[1];
+//            double w = val[top];
+//            money -= w + dis[1];
 //            if(money < 0){
 //                break;
 //            }
 //            ans++;
 //            if(ls[i] != 0){
-//                heapAdd(ls[i], v - cost[i] + cost[ls[i]]);
+//                heapAdd(ls[i], w - cost[i] + cost[ls[i]]);
 //            }
 //            if(rs[i] != 0){
-//                heapAdd(rs[i], v - cost[i] + cost[rs[i]]);
+//                heapAdd(rs[i], w - cost[i] + cost[rs[i]]);
 //            }
 //            if(to[i] != 0 && rt[to[i]] != 0){
-//                heapAdd(rt[to[i]], v + cost[rt[to[i]]]);
+//                heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
 //            }
 //        }
 //    }

From 692f2f7ded3d2e53a6342135900c1b78cfce3a8e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 13:32:46 +0800
Subject: [PATCH 0278/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 24 ++++++++++++------------
 src/class155/Code05_KShortestPath2.java | 24 ++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 35a288ffc..76815a507 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -48,7 +48,7 @@ public class Code05_KShortestPath1 {
 	public static int[] dist = new int[MAXT];
 	public static int cntt = 0;
 
-	public static int[] idx = new int[MAXH];
+	public static int[] key = new int[MAXH];
 	public static double[] val = new double[MAXH];
 	public static int[] heap = new int[MAXH];
 	public static int cntd, cnth;
@@ -108,8 +108,8 @@ public static int merge(int i, int j) {
 		return h;
 	}
 
-	public static void heapAdd(int i, double v) {
-		idx[++cntd] = i;
+	public static void heapAdd(int k, double v) {
+		key[++cntd] = k;
 		val[cntd] = v;
 		heap[++cnth] = cntd;
 		int cur = cnth, father = cur / 2, tmp;
@@ -153,7 +153,7 @@ public static void dijkstra() {
 		heapAdd(n, 0);
 		while (!heapEmpty()) {
 			int top = heapPop();
-			int u = idx[top];
+			int u = key[top];
 			double w = val[top];
 			if (!vis[u]) {
 				vis[u] = true;
@@ -177,7 +177,7 @@ public static void mergeRoad() {
 		dist[0] = -1;
 		while (!heapEmpty()) {
 			int top = heapPop();
-			int u = idx[top];
+			int u = key[top];
 			for (int e = headg[u], v; e > 0; e = nextg[e]) {
 				v = tog[e];
 				if (e != path[u]) {
@@ -201,21 +201,21 @@ public static int expand() {
 			}
 			while (!heapEmpty()) {
 				int top = heapPop();
-				int i = idx[top];
+				int h = key[top];
 				double w = val[top];
 				money -= w + dis[1];
 				if (money < 0) {
 					break;
 				}
 				ans++;
-				if (left[i] != 0) {
-					heapAdd(left[i], w - cost[i] + cost[left[i]]);
+				if (left[h] != 0) {
+					heapAdd(left[h], w - cost[h] + cost[left[h]]);
 				}
-				if (right[i] != 0) {
-					heapAdd(right[i], w - cost[i] + cost[right[i]]);
+				if (right[h] != 0) {
+					heapAdd(right[h], w - cost[h] + cost[right[h]]);
 				}
-				if (to[i] != 0 && rt[to[i]] != 0) {
-					heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
+				if (to[h] != 0 && rt[to[h]] != 0) {
+					heapAdd(rt[to[h]], w + cost[rt[to[h]]]);
 				}
 			}
 		}
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index b204d9b4d..d4f2f786e 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -45,7 +45,7 @@
 //int dist[MAXT];
 //int cntt = 0;
 //
-//int idx[MAXH];
+//int key[MAXH];
 //double val[MAXH];
 //int heap[MAXH];
 //int cntd, cnth;
@@ -100,8 +100,8 @@
 //    return h;
 //}
 //
-//void heapAdd(int i, double v){
-//    idx[++cntd] = i;
+//void heapAdd(int k, double v){
+//    key[++cntd] = k;
 //    val[cntd] = v;
 //    heap[++cnth] = cntd;
 //    int cur = cnth, father = cur / 2;
@@ -141,7 +141,7 @@
 //    heapAdd(n, 0.0);
 //    while(!heapEmpty()){
 //        int top = heapPop();
-//        int u = idx[top];
+//        int u = key[top];
 //        double w = val[top];
 //        if(!vis[u]){
 //            vis[u] = true;
@@ -165,7 +165,7 @@
 //    dist[0] = -1;
 //    while(!heapEmpty()){
 //        int top = heapPop();
-//        int u = idx[top];
+//        int u = key[top];
 //        for(int e = headg[u], v; e != 0; e = nextg[e]){
 //            v = tog[e];
 //            if(e != path[u]){
@@ -189,21 +189,21 @@
 //        }
 //        while(!heapEmpty()){
 //            int top = heapPop();
-//            int i = idx[top];
+//            int h = key[top];
 //            double w = val[top];
 //            money -= w + dis[1];
 //            if(money < 0){
 //                break;
 //            }
 //            ans++;
-//            if(ls[i] != 0){
-//                heapAdd(ls[i], w - cost[i] + cost[ls[i]]);
+//            if(ls[h] != 0){
+//                heapAdd(ls[h], w - cost[h] + cost[ls[h]]);
 //            }
-//            if(rs[i] != 0){
-//                heapAdd(rs[i], w - cost[i] + cost[rs[i]]);
+//            if(rs[h] != 0){
+//                heapAdd(rs[h], w - cost[h] + cost[rs[h]]);
 //            }
-//            if(to[i] != 0 && rt[to[i]] != 0){
-//                heapAdd(rt[to[i]], w + cost[rt[to[i]]]);
+//            if(to[h] != 0 && rt[to[h]] != 0){
+//                heapAdd(rt[to[h]], w + cost[rt[to[h]]]);
 //            }
 //        }
 //    }

From 00040b12f175965e717d27772d1d0aadc10777f7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 13:42:41 +0800
Subject: [PATCH 0279/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 4 ++--
 src/class155/Code01_CityCapture2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index ada3d8c8b..e0c0703e1 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -2,8 +2,8 @@
 
 // 城池攻占，java版
 // 一共有n个城市，1号城市是城市树的头，每个城市都有防御值、上级城市编号、奖励类型、奖励值
-// 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上该城市的奖励值
-// 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以该城市的奖励值
+// 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上奖励值
+// 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以奖励值
 // 任何城市的上级编号 < 这座城市的编号，1号城市没有上级城市编号、奖励类型、奖励值
 // 一共有m个骑士，每个骑士都有攻击力、第一次攻击的城市
 // 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 757fe5161..0a3b5d7e9 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -2,8 +2,8 @@
 
 // 城池攻占，C++版
 // 一共有n个城市，1号城市是城市树的头，每个城市都有防御值、上级城市编号、奖励类型、奖励值
-// 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上该城市的奖励值
-// 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以该城市的奖励值
+// 如果奖励类型为0，任何骑士攻克这个城市后，攻击力会加上奖励值
+// 如果奖励类型为1，任何骑士攻克这个城市后，攻击力会乘以奖励值
 // 任何城市的上级编号 < 这座城市的编号，1号城市没有上级城市编号、奖励类型、奖励值
 // 一共有m个骑士，每个骑士都有攻击力、第一次攻击的城市
 // 如果骑士攻击力 >= 城市防御值，当前城市会被攻占，骑士获得奖励，继续攻击上级城市

From c9c32f2c993955115619cca6f84886e5e161c329 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 13:48:55 +0800
Subject: [PATCH 0280/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 6 +++---
 src/class155/Code01_CityCapture2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index e0c0703e1..b97e96616 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -30,7 +30,7 @@ public class Code01_CityCapture1 {
 	public static int[] belong = new int[MAXN];
 
 	// 奖励类型
-	public static int[] op = new int[MAXN];
+	public static int[] type = new int[MAXN];
 
 	// 奖励值
 	public static long[] gain = new long[MAXN];
@@ -155,7 +155,7 @@ public static void compute() {
 				top[i] = pop(top[i]);
 			}
 			if (top[i] != 0) {
-				upgrade(top[i], op[i], gain[i]);
+				upgrade(top[i], type[i], gain[i]);
 				if (top[belong[i]] == 0) {
 					top[belong[i]] = top[i];
 				} else {
@@ -175,7 +175,7 @@ public static void main(String[] args) {
 		}
 		for (int i = 2; i <= n; i++) {
 			belong[i] = io.nextInt();
-			op[i] = io.nextInt();
+			type[i] = io.nextInt();
 			gain[i] = io.nextLong();
 		}
 		for (int i = 1; i <= m; i++) {
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 0a3b5d7e9..13e792aae 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -23,7 +23,7 @@
 //int n, m;
 //long long defend[MAXN];
 //int belong[MAXN];
-//int op[MAXN];       
+//int type[MAXN];       
 //long long gain[MAXN];
 //long long attack[MAXN];
 //int first[MAXN];
@@ -121,7 +121,7 @@
 //            top[i] = pop(top[i]);
 //        }
 //        if (top[i] != 0) {
-//            upgrade(top[i], op[i], gain[i]);
+//            upgrade(top[i], type[i], gain[i]);
 //            if (top[belong[i]] == 0) {
 //                top[belong[i]] = top[i];
 //            } else {
@@ -140,7 +140,7 @@
 //        cin >> defend[i];
 //    }
 //    for (int i = 2; i <= n; i++) {
-//        cin >> belong[i] >> op[i] >> gain[i];
+//        cin >> belong[i] >> type[i] >> gain[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cin >> attack[i] >> first[i];

From 22794892301ca8ce832f9e338e000185e3ee0914 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 13:55:23 +0800
Subject: [PATCH 0281/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 4 ++--
 src/class155/Code01_CityCapture2.java | 8 ++++----
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index b97e96616..4a0a71c5e 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -95,12 +95,12 @@ public static void down(int i) {
 			int r = right[i];
 			if (l != 0) {
 				attack[l] = attack[l] * mul[i] + add[i];
-				mul[l] *= mul[i];
+				mul[l] = mul[l] * mul[i];
 				add[l] = add[l] * mul[i] + add[i];
 			}
 			if (r != 0) {
 				attack[r] = attack[r] * mul[i] + add[i];
-				mul[r] *= mul[i];
+				mul[r] = mul[r] * mul[i];
 				add[r] = add[r] * mul[i] + add[i];
 			}
 			mul[i] = 1;
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 13e792aae..2005bbe8d 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -55,8 +55,8 @@
 //        attack[i] += v;
 //    } else {
 //        mul[i] *= v;
-//        add[i] = add[i] * v;
-//        attack[i] = attack[i] * v;
+//        add[i] *= v;
+//        attack[i] *= v;
 //    }
 //}
 //
@@ -66,12 +66,12 @@
 //        int r = rs[i];
 //        if (l != 0) {
 //            attack[l] = attack[l] * mul[i] + add[i];
-//            mul[l] *= mul[i];
+//            mul[l] = mul[l] * mul[i];
 //            add[l] = add[l] * mul[i] + add[i];
 //        }
 //        if (r != 0) {
 //            attack[r] = attack[r] * mul[i] + add[i];
-//            mul[r] *= mul[i];
+//            mul[r] = mul[r] * mul[i];
 //            add[r] = add[r] * mul[i] + add[i];
 //        }
 //        mul[i] = 1;

From bbb087b9cca1541e1e2ecc7e99be20c831535536 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 15:46:11 +0800
Subject: [PATCH 0282/1712] modify code

---
 src/class155/Code01_CityCapture1.java | 4 ++--
 src/class155/Code01_CityCapture2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class155/Code01_CityCapture1.java b/src/class155/Code01_CityCapture1.java
index 4a0a71c5e..8099d866a 100644
--- a/src/class155/Code01_CityCapture1.java
+++ b/src/class155/Code01_CityCapture1.java
@@ -80,12 +80,12 @@ public static void prepare() {
 
 	public static void upgrade(int i, int t, long v) {
 		if (t == 0) {
-			add[i] += v;
 			attack[i] += v;
+			add[i] += v;
 		} else {
+			attack[i] *= v;
 			mul[i] *= v;
 			add[i] *= v;
-			attack[i] *= v;
 		}
 	}
 
diff --git a/src/class155/Code01_CityCapture2.java b/src/class155/Code01_CityCapture2.java
index 2005bbe8d..65953abbb 100644
--- a/src/class155/Code01_CityCapture2.java
+++ b/src/class155/Code01_CityCapture2.java
@@ -51,12 +51,12 @@
 //
 //void upgrade(int i, int t, long long v) {
 //    if (t == 0) {
-//        add[i] += v;
 //        attack[i] += v;
+//        add[i] += v;
 //    } else {
+//        attack[i] *= v;
 //        mul[i] *= v;
 //        add[i] *= v;
-//        attack[i] *= v;
 //    }
 //}
 //

From 4fd65b30f86bf579b4d8a9db821818effb1daca8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 16:14:06 +0800
Subject: [PATCH 0283/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 10 +++++++++-
 1 file changed, 9 insertions(+), 1 deletion(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 93d18662f..898c54f34 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -43,7 +43,7 @@ public class Code02_TrickyOperation1 {
 	// 集合内所有数字应该加多少值
 	public static int[] add = new int[MAXN];
 
-	// 所有集合头节点的值，进入这个堆，头堆
+	// 所有集合头节点的值，进入这个堆，也就是头堆
 	public static TreeMap<Integer, Integer> heap = new TreeMap<>();
 
 	// 所有数字应该加多少
@@ -52,6 +52,7 @@ public class Code02_TrickyOperation1 {
 	// 准备好一个栈，用迭代方式实现先序遍历，不用递归方式
 	public static int[] stack = new int[MAXN];
 
+	// 编号为h的节点不再是左偏树的头，在头堆里删掉一份当前节点的值
 	public static void minusHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
@@ -63,6 +64,7 @@ public static void minusHead(int h) {
 		}
 	}
 
+	// 编号为h的节点当前是左偏树的头，在头堆里增加一份当前节点的值
 	public static void addHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
@@ -83,11 +85,13 @@ public static void prepare() {
 		addAll = 0;
 	}
 
+	// 返回i节点所在左偏树的树头
 	public static int find(int i) {
 		father[i] = father[i] == i ? i : find(father[i]);
 		return father[i];
 	}
 
+	// 合并两棵左偏树
 	public static int merge(int i, int j) {
 		if (i == 0 || j == 0) {
 			return i + j;
@@ -110,6 +114,7 @@ public static int merge(int i, int j) {
 		return i;
 	}
 
+	// 节点i是所在左偏树的任意节点，删除节点i，返回整棵树的头节点编号
 	public static int remove(int i) {
 		int h = find(i);
 		father[left[i]] = left[i];
@@ -138,6 +143,9 @@ public static int remove(int i) {
 		return father[s];
 	}
 
+	// 以i为头的左偏树，遭遇了更大的左偏树
+	// i的懒更新信息取消，以i为头的整棵树所有节点的值增加v
+	// 不用递归实现先序遍历，容易爆栈，所以用迭代实现先序遍历
 	public static void down(int i, int v) {
 		if (i != 0) {
 			add[i] = 0;

From 0b9119196b2476a2381a3d9e4c04fdd2ca3f7eed Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 16:22:00 +0800
Subject: [PATCH 0284/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 2 +-
 src/class155/Code02_TrickyOperation2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 898c54f34..74c8f57c2 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -1,7 +1,7 @@
 package class155;
 
 // 棘手的操作，java版
-// 编号1~n个节点，每个节点独立且有自己的权值，实现如下6种操作，操作一共调用m次
+// 编号1~n个节点，每个节点独立且有自己的权值，实现如下7种操作，操作一共调用m次
 // U x y  : x所在的集合和y所在的集合合并
 // A1 x v : x节点的权值增加v
 // A2 x v : x所在的集合所有节点的权值增加v
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
index 7b84cd101..38f0bd8c5 100644
--- a/src/class155/Code02_TrickyOperation2.java
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -1,7 +1,7 @@
 package class155;
 
 // 棘手的操作，C++版
-// 编号1~n个节点，每个节点独立且有自己的权值，实现如下6种操作，操作一共调用m次
+// 编号1~n个节点，每个节点独立且有自己的权值，实现如下7种操作，操作一共调用m次
 // U x y  : x所在的集合和y所在的集合合并
 // A1 x v : x节点的权值增加v
 // A2 x v : x所在的集合所有节点的权值增加v

From 579e4f038627ddc7cc713ceee97528883fbe87ad Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 17:02:11 +0800
Subject: [PATCH 0285/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 20 ++++++++++----------
 src/class155/Code02_TrickyOperation2.java | 10 +++++-----
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 74c8f57c2..4f6c34ed1 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -43,8 +43,8 @@ public class Code02_TrickyOperation1 {
 	// 集合内所有数字应该加多少值
 	public static int[] add = new int[MAXN];
 
-	// 所有集合头节点的值，进入这个堆，也就是头堆
-	public static TreeMap<Integer, Integer> heap = new TreeMap<>();
+	// 所有集合头节点的值，进入这个有序表，头节点有序表
+	public static TreeMap<Integer, Integer> heads = new TreeMap<>();
 
 	// 所有数字应该加多少
 	public static int addAll = 0;
@@ -52,29 +52,29 @@ public class Code02_TrickyOperation1 {
 	// 准备好一个栈，用迭代方式实现先序遍历，不用递归方式
 	public static int[] stack = new int[MAXN];
 
-	// 编号为h的节点不再是左偏树的头，在头堆里删掉一份当前节点的值
+	// 编号为h的节点不再是左偏树的头，在头节点有序表里删掉一份当前节点的值
 	public static void minusHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
-			if (heap.get(hnum) == 1) {
-				heap.remove(hnum);
+			if (heads.get(hnum) == 1) {
+				heads.remove(hnum);
 			} else {
-				heap.put(hnum, heap.get(hnum) - 1);
+				heads.put(hnum, heads.get(hnum) - 1);
 			}
 		}
 	}
 
-	// 编号为h的节点当前是左偏树的头，在头堆里增加一份当前节点的值
+	// 编号为h的节点当前是左偏树的头，在头节点有序表里增加一份当前节点的值
 	public static void addHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
-			heap.put(hnum, heap.getOrDefault(hnum, 0) + 1);
+			heads.put(hnum, heads.getOrDefault(hnum, 0) + 1);
 		}
 	}
 
 	public static void prepare() {
 		dist[0] = -1;
-		heap.clear();
+		heads.clear();
 		for (int i = 1; i <= n; i++) {
 			up[i] = left[i] = right[i] = dist[i] = 0;
 			father[i] = i;
@@ -226,7 +226,7 @@ public static int f2(int i) {
 	}
 
 	public static int f3() {
-		return heap.lastKey() + addAll;
+		return heads.lastKey() + addAll;
 	}
 
 	public static void main(String[] args) {
diff --git a/src/class155/Code02_TrickyOperation2.java b/src/class155/Code02_TrickyOperation2.java
index 38f0bd8c5..53c8b8bde 100644
--- a/src/class155/Code02_TrickyOperation2.java
+++ b/src/class155/Code02_TrickyOperation2.java
@@ -29,24 +29,24 @@
 //int siz[MAXN]; 
 //int add[MAXN];
 //int sta[MAXN];
-//multiset<int> heap;
+//multiset<int> heads;
 //int addAll = 0;
 //
 //void minusHead(int h) {
 //    if (h != 0) {
-//        heap.erase(heap.find(num[h] + add[h]));
+//        heads.erase(heads.find(num[h] + add[h]));
 //    }
 //}
 //
 //void addHead(int h) {
 //    if (h != 0) {
-//        heap.insert(num[h] + add[h]);
+//        heads.insert(num[h] + add[h]);
 //    }
 //}
 //
 //void prepare() {
 //    dist[0] = -1;
-//    heap.clear();
+//    heads.clear();
 //    for (int i = 1; i <= n; i++) {
 //        up[i] = ls[i] = rs[i] = dist[i] = 0;
 //        fa[i] = i;
@@ -178,7 +178,7 @@
 //}
 //
 //int f3() {
-//    return (*heap.rbegin()) + addAll;
+//    return (*heads.rbegin()) + addAll;
 //}
 //
 //int main(){

From 69cca1c7f15692f20832704e523ae9ff18fcf9a7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 17:07:13 +0800
Subject: [PATCH 0286/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 4f6c34ed1..9f242f8e9 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -52,7 +52,7 @@ public class Code02_TrickyOperation1 {
 	// 准备好一个栈，用迭代方式实现先序遍历，不用递归方式
 	public static int[] stack = new int[MAXN];
 
-	// 编号为h的节点不再是左偏树的头，在头节点有序表里删掉一份当前节点的值
+	// 编号为h的节点不再是左偏树的头，在头节点有序表里删掉一份h节点的值
 	public static void minusHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];
@@ -64,7 +64,7 @@ public static void minusHead(int h) {
 		}
 	}
 
-	// 编号为h的节点当前是左偏树的头，在头节点有序表里增加一份当前节点的值
+	// 编号为h的节点当前是左偏树的头，在头节点有序表里增加一份h节点的值
 	public static void addHead(int h) {
 		if (h != 0) {
 			int hnum = num[h] + add[h];

From ddc48cca49c70f60c5073b7526aa951f096aa0f3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 18:17:00 +0800
Subject: [PATCH 0287/1712] modify code

---
 src/class155/Code02_TrickyOperation1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/Code02_TrickyOperation1.java b/src/class155/Code02_TrickyOperation1.java
index 9f242f8e9..6bb330261 100644
--- a/src/class155/Code02_TrickyOperation1.java
+++ b/src/class155/Code02_TrickyOperation1.java
@@ -144,7 +144,7 @@ public static int remove(int i) {
 	}
 
 	// 以i为头的左偏树，遭遇了更大的左偏树
-	// i的懒更新信息取消，以i为头的整棵树所有节点的值增加v
+	// i的标签信息取消，以i为头的整棵树所有节点的值增加v
 	// 不用递归实现先序遍历，容易爆栈，所以用迭代实现先序遍历
 	public static void down(int i, int v) {
 		if (i != 0) {

From 1759196d31e94d2e5816b21fb619060cfc168a09 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 21:24:06 +0800
Subject: [PATCH 0288/1712] modify code

---
 src/class155/Code04_Blocks1.java | 24 +++++++++++++++++-------
 src/class155/Code04_Blocks2.java | 14 +++++++-------
 2 files changed, 24 insertions(+), 14 deletions(-)

diff --git a/src/class155/Code04_Blocks1.java b/src/class155/Code04_Blocks1.java
index 485acbb12..bf20e3fa4 100644
--- a/src/class155/Code04_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -29,28 +29,38 @@ public class Code04_Blocks1 {
 
 	public static int n, k;
 
+	// 所有数组所有的数字都放在arr中
+	public static int[] arr = new int[MAXM];
+	// start[i] : 第i个数组的第一个数字在arr中的什么位置
 	public static int[] start = new int[MAXN];
+	// boundary[i] : 第i个数组的越界位置在arr中的什么位置
 	public static int[] boundary = new int[MAXN];
-	public static int[] arr = new int[MAXM];
 
+	// 左偏树需要，假设某棵左偏树的头节点为h
+	// idx[h] : 当前堆顶来自哪个数组
 	public static int[] idx = new int[MAXT];
+	// jdx[h] : 当前堆顶来自idx[h]数组的什么位置
 	public static int[] jdx = new int[MAXT];
-	public static int[] num = new int[MAXT];
+	// cost[h] : 当前堆顶让代价基础值增加多少代价
+	public static int[] cost = new int[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
+	// base[h] : 整个左偏树代价基础值是什么
 	public static int[] base = new int[MAXT];
 	public static int cnt = 0;
 
+	// heap里放着所有版本的最优方案
 	public static int[] heap = new int[MAXK];
 	public static int heapSize = 0;
 
+	// 收集答案
 	public static int[] ans = new int[MAXK];
 
 	public static int init(int i, int j) {
 		idx[++cnt] = i;
 		jdx[cnt] = j;
-		num[cnt] = j + 1 < boundary[i] ? (arr[j + 1] - arr[j]) : INF;
+		cost[cnt] = j + 1 < boundary[i] ? (arr[j + 1] - arr[j]) : INF;
 		left[cnt] = right[cnt] = dist[cnt] = 0;
 		return cnt;
 	}
@@ -58,7 +68,7 @@ public static int init(int i, int j) {
 	public static int clone(int i) {
 		idx[++cnt] = idx[i];
 		jdx[cnt] = jdx[i];
-		num[cnt] = num[i];
+		cost[cnt] = cost[i];
 		left[cnt] = left[i];
 		right[cnt] = right[i];
 		dist[cnt] = dist[i];
@@ -70,7 +80,7 @@ public static int merge(int i, int j) {
 			return i + j;
 		}
 		int tmp;
-		if (num[i] > num[j]) {
+		if (cost[i] > cost[j]) {
 			tmp = i;
 			i = j;
 			j = tmp;
@@ -97,7 +107,7 @@ public static int pop(int i) {
 	}
 
 	public static boolean compare(int i, int j) {
-		return base[heap[i]] + num[heap[i]] < base[heap[j]] + num[heap[j]];
+		return base[heap[i]] + cost[heap[i]] < base[heap[j]] + cost[heap[j]];
 	}
 
 	public static void heapAdd(int i) {
@@ -148,7 +158,7 @@ public static void compute() {
 		heapAdd(head);
 		for (int ansi = 2, h1, h2; ansi <= k; ansi++) {
 			head = heapPop();
-			ans[ansi] = base[head] + num[head];
+			ans[ansi] = base[head] + cost[head];
 			h1 = pop(head);
 			if (h1 != 0) {
 				base[h1] = base[head];
diff --git a/src/class155/Code04_Blocks2.java b/src/class155/Code04_Blocks2.java
index 048fb2d65..240f78be2 100644
--- a/src/class155/Code04_Blocks2.java
+++ b/src/class155/Code04_Blocks2.java
@@ -25,13 +25,13 @@
 //
 //int n, k;
 //
+//int arr[MAXM];
 //int start[MAXN];
 //int boundary[MAXN];
-//int arr[MAXM];
 //
 //int idx[MAXT];
 //int jdx[MAXT];
-//int num[MAXT];
+//int cost[MAXT];
 //int ls[MAXT];
 //int rs[MAXT];
 //int dist[MAXT];
@@ -46,7 +46,7 @@
 //int init(int i, int j) {
 //    idx[++cnt] = i;
 //    jdx[cnt] = j;
-//    num[cnt] = (j + 1 < boundary[i]) ? (arr[j + 1] - arr[j]) : INF;
+//    cost[cnt] = (j + 1 < boundary[i]) ? (arr[j + 1] - arr[j]) : INF;
 //    ls[cnt] = rs[cnt] = dist[cnt] = 0;
 //    return cnt;
 //}
@@ -54,7 +54,7 @@
 //int clone(int i) {
 //    idx[++cnt] = idx[i];
 //    jdx[cnt] = jdx[i];
-//    num[cnt] = num[i];
+//    cost[cnt] = cost[i];
 //    ls[cnt] = ls[i];
 //    rs[cnt] = rs[i];
 //    dist[cnt] = dist[i];
@@ -63,7 +63,7 @@
 //
 //int merge(int i, int j) {
 //    if (i == 0 || j == 0) return i + j;
-//    if (num[i] > num[j]) {
+//    if (cost[i] > cost[j]) {
 //        swap(i, j);
 //    }
 //    int h = clone(i);
@@ -82,7 +82,7 @@
 //}
 //
 //bool compare(int i, int j) {
-//    return base[heap[i]] + num[heap[i]] < base[heap[j]] + num[heap[j]];
+//    return base[heap[i]] + cost[heap[i]] < base[heap[j]] + cost[heap[j]];
 //}
 //
 //void heapAdd(int i) {
@@ -127,7 +127,7 @@
 //    heapAdd(head);
 //    for (int ansi = 2, h1, h2; ansi <= k; ++ansi) {
 //        head = heapPop();
-//        ans[ansi] = base[head] + num[head];
+//        ans[ansi] = base[head] + cost[head];
 //        h1 = pop(head);
 //        if (h1 != 0) {
 //            base[h1] = base[head];

From 762b66f95f868390bada803e2a341ee45240112d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 21:24:59 +0800
Subject: [PATCH 0289/1712] modify code

---
 src/class155/Code04_Blocks1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class155/Code04_Blocks1.java b/src/class155/Code04_Blocks1.java
index bf20e3fa4..4250fffff 100644
--- a/src/class155/Code04_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -29,7 +29,7 @@ public class Code04_Blocks1 {
 
 	public static int n, k;
 
-	// 所有数组所有的数字都放在arr中
+	// 所有数组的所有数字放在arr中
 	public static int[] arr = new int[MAXM];
 	// start[i] : 第i个数组的第一个数字在arr中的什么位置
 	public static int[] start = new int[MAXN];

From 7904ad7a066d7c636c88b2a3a7c5110feb8f4262 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 21:34:34 +0800
Subject: [PATCH 0290/1712] modify code

---
 src/class155/Code04_Blocks1.java | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/class155/Code04_Blocks1.java b/src/class155/Code04_Blocks1.java
index 4250fffff..b95052666 100644
--- a/src/class155/Code04_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -36,12 +36,13 @@ public class Code04_Blocks1 {
 	// boundary[i] : 第i个数组的越界位置在arr中的什么位置
 	public static int[] boundary = new int[MAXN];
 
-	// 左偏树需要，假设某棵左偏树的头节点为h
-	// idx[h] : 当前堆顶来自哪个数组
+	// 左偏树需要
+	// 假设编号为h的节点是某棵左偏树的头
+	// idx[h] : 当前节点来自哪个数组
 	public static int[] idx = new int[MAXT];
-	// jdx[h] : 当前堆顶来自idx[h]数组的什么位置
+	// jdx[h] : 当前节点来自idx[h]数组的什么位置
 	public static int[] jdx = new int[MAXT];
-	// cost[h] : 当前堆顶让代价基础值增加多少代价
+	// cost[h] : 当前节点让代价基础值增加多少代价
 	public static int[] cost = new int[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
@@ -50,7 +51,8 @@ public class Code04_Blocks1 {
 	public static int[] base = new int[MAXT];
 	public static int cnt = 0;
 
-	// heap里放着所有版本的最优方案
+	// heap是经典的小根堆，放着所有版本左偏树的头
+	// 哪个左偏树的头节点，所代表方案的累加和最小，谁就放在heap的顶部
 	public static int[] heap = new int[MAXK];
 	public static int heapSize = 0;
 

From 7135fc15f107a53216eebe81fcc13f943e2439d9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 21:58:44 +0800
Subject: [PATCH 0291/1712] modify code

---
 src/class155/Code04_Blocks1.java | 22 +++++++++++-----------
 src/class155/Code04_Blocks2.java | 12 ++++++------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/class155/Code04_Blocks1.java b/src/class155/Code04_Blocks1.java
index b95052666..94480a7cb 100644
--- a/src/class155/Code04_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -36,19 +36,19 @@ public class Code04_Blocks1 {
 	// boundary[i] : 第i个数组的越界位置在arr中的什么位置
 	public static int[] boundary = new int[MAXN];
 
-	// 左偏树需要
+	// 左偏树代表选择数字的一种状况，左偏树的头代表这种状况下最优的行动
 	// 假设编号为h的节点是某棵左偏树的头
-	// idx[h] : 当前节点来自哪个数组
+	// idx[h] : 最优行动来自哪个数组
 	public static int[] idx = new int[MAXT];
-	// jdx[h] : 当前节点来自idx[h]数组的什么位置
+	// jdx[h] : 最优行动来自idx[h]数组的什么位置
 	public static int[] jdx = new int[MAXT];
-	// cost[h] : 当前节点让代价基础值增加多少代价
+	// cost[h] : 在前一个方案的基础上，最优行动会让累加和增加多少
 	public static int[] cost = new int[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
-	// base[h] : 整个左偏树代价基础值是什么
-	public static int[] base = new int[MAXT];
+	// pre[h] : 导致当前状况的前一个方案，累加和是多少
+	public static int[] pre = new int[MAXT];
 	public static int cnt = 0;
 
 	// heap是经典的小根堆，放着所有版本左偏树的头
@@ -109,7 +109,7 @@ public static int pop(int i) {
 	}
 
 	public static boolean compare(int i, int j) {
-		return base[heap[i]] + cost[heap[i]] < base[heap[j]] + cost[heap[j]];
+		return pre[heap[i]] + cost[heap[i]] < pre[heap[j]] + cost[heap[j]];
 	}
 
 	public static void heapAdd(int i) {
@@ -155,20 +155,20 @@ public static void compute() {
 		for (int i = 1; i <= n; i++) {
 			head = merge(head, init(i, start[i]));
 		}
-		base[head] = first;
+		pre[head] = first;
 		ans[1] = first;
 		heapAdd(head);
 		for (int ansi = 2, h1, h2; ansi <= k; ansi++) {
 			head = heapPop();
-			ans[ansi] = base[head] + cost[head];
+			ans[ansi] = pre[head] + cost[head];
 			h1 = pop(head);
 			if (h1 != 0) {
-				base[h1] = base[head];
+				pre[h1] = pre[head];
 				heapAdd(h1);
 			}
 			if (jdx[head] + 1 < boundary[idx[head]]) {
 				h2 = merge(h1, init(idx[head], jdx[head] + 1));
-				base[h2] = ans[ansi];
+				pre[h2] = ans[ansi];
 				heapAdd(h2);
 			}
 		}
diff --git a/src/class155/Code04_Blocks2.java b/src/class155/Code04_Blocks2.java
index 240f78be2..1745b4c9d 100644
--- a/src/class155/Code04_Blocks2.java
+++ b/src/class155/Code04_Blocks2.java
@@ -35,7 +35,7 @@
 //int ls[MAXT];
 //int rs[MAXT];
 //int dist[MAXT];
-//int base[MAXT];
+//int pre[MAXT];
 //int cnt = 0;
 //
 //int heap[MAXK];
@@ -82,7 +82,7 @@
 //}
 //
 //bool compare(int i, int j) {
-//    return base[heap[i]] + cost[heap[i]] < base[heap[j]] + cost[heap[j]];
+//    return pre[heap[i]] + cost[heap[i]] < pre[heap[j]] + cost[heap[j]];
 //}
 //
 //void heapAdd(int i) {
@@ -122,20 +122,20 @@
 //    for (int i = 1; i <= n; ++i) {
 //        head = merge(head, init(i, start[i]));
 //    }
-//    base[head] = first;
+//    pre[head] = first;
 //    ans[1] = first;
 //    heapAdd(head);
 //    for (int ansi = 2, h1, h2; ansi <= k; ++ansi) {
 //        head = heapPop();
-//        ans[ansi] = base[head] + cost[head];
+//        ans[ansi] = pre[head] + cost[head];
 //        h1 = pop(head);
 //        if (h1 != 0) {
-//            base[h1] = base[head];
+//            pre[h1] = pre[head];
 //            heapAdd(h1);
 //        }
 //        if (jdx[head] + 1 < boundary[idx[head]]) {
 //            h2 = merge(h1, init(idx[head], jdx[head] + 1));
-//            base[h2] = ans[ansi];
+//            pre[h2] = ans[ansi];
 //            heapAdd(h2);
 //        }
 //    }

From c36b0048df1400c437e31d94e035e9eb9b8dfa6c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Dec 2024 23:51:33 +0800
Subject: [PATCH 0292/1712] modify code

---
 src/class155/Code04_Blocks1.java | 18 +++++++++---------
 src/class155/Code04_Blocks2.java |  8 ++++----
 2 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/class155/Code04_Blocks1.java b/src/class155/Code04_Blocks1.java
index 94480a7cb..623a29e32 100644
--- a/src/class155/Code04_Blocks1.java
+++ b/src/class155/Code04_Blocks1.java
@@ -36,18 +36,18 @@ public class Code04_Blocks1 {
 	// boundary[i] : 第i个数组的越界位置在arr中的什么位置
 	public static int[] boundary = new int[MAXN];
 
-	// 左偏树代表选择数字的一种状况，左偏树的头代表这种状况下最优的行动
-	// 假设编号为h的节点是某棵左偏树的头
+	// 左偏树代表基于之前的某个方案，做出行动的可能性
+	// 左偏树的头就代表这个最优行动，假设编号为h的节点是头
 	// idx[h] : 最优行动来自哪个数组
 	public static int[] idx = new int[MAXT];
-	// jdx[h] : 最优行动来自idx[h]数组的什么位置
+	// jdx[h] : 最优行动要替换掉idx[h]数组中什么位置的数
 	public static int[] jdx = new int[MAXT];
-	// cost[h] : 在前一个方案的基础上，最优行动会让累加和增加多少
+	// cost[h] : 基于之前的某个方案，最优行动会让累加和增加多少
 	public static int[] cost = new int[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
-	// pre[h] : 导致当前状况的前一个方案，累加和是多少
+	// pre[h] : 基于之前的某个方案，这个方案的累加和，标签信息
 	public static int[] pre = new int[MAXT];
 	public static int cnt = 0;
 
@@ -109,13 +109,13 @@ public static int pop(int i) {
 	}
 
 	public static boolean compare(int i, int j) {
-		return pre[heap[i]] + cost[heap[i]] < pre[heap[j]] + cost[heap[j]];
+		return pre[i] + cost[i] < pre[j] + cost[j];
 	}
 
 	public static void heapAdd(int i) {
 		heap[++heapSize] = i;
 		int cur = heapSize, up = cur / 2, tmp;
-		while (cur > 1 && compare(cur, up)) {
+		while (cur > 1 && compare(heap[cur], heap[up])) {
 			tmp = heap[up];
 			heap[up] = heap[cur];
 			heap[cur] = tmp;
@@ -129,8 +129,8 @@ public static int heapPop() {
 		heap[1] = heap[heapSize--];
 		int cur = 1, l = cur * 2, r = l + 1, best, tmp;
 		while (l <= heapSize) {
-			best = (r <= heapSize && compare(r, l)) ? r : l;
-			best = compare(best, cur) ? best : cur;
+			best = (r <= heapSize && compare(heap[r], heap[l])) ? r : l;
+			best = compare(heap[best], heap[cur]) ? best : cur;
 			if (best == cur) {
 				break;
 			}
diff --git a/src/class155/Code04_Blocks2.java b/src/class155/Code04_Blocks2.java
index 1745b4c9d..c4011e9ba 100644
--- a/src/class155/Code04_Blocks2.java
+++ b/src/class155/Code04_Blocks2.java
@@ -82,13 +82,13 @@
 //}
 //
 //bool compare(int i, int j) {
-//    return pre[heap[i]] + cost[heap[i]] < pre[heap[j]] + cost[heap[j]];
+//    return pre[i] + cost[i] < pre[j] + cost[j];
 //}
 //
 //void heapAdd(int i) {
 //    heap[++heapSize] = i;
 //    int cur = heapSize, up = cur / 2;
-//    while (cur > 1 && compare(cur, up)) {
+//    while (cur > 1 && compare(heap[cur], heap[up])) {
 //        swap(heap[cur], heap[up]);
 //        cur = up;
 //        up = cur / 2;
@@ -100,8 +100,8 @@
 //    heap[1] = heap[heapSize--];
 //    int cur = 1, l = 2, r = 3, best;
 //    while (l <= heapSize) {
-//        best = (r <= heapSize && compare(r, l)) ? r : l;
-//        best = compare(best, cur) ? best : cur;
+//        best = (r <= heapSize && compare(heap[r], heap[l])) ? r : l;
+//        best = compare(heap[best], heap[cur]) ? best : cur;
 //        if (best == cur) break;
 //        swap(heap[cur], heap[best]);
 //        cur = best;

From 1a9159c162b25d2a6596c7b18452a085cf0a7602 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Dec 2024 12:30:31 +0800
Subject: [PATCH 0293/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 8 ++++----
 src/class155/Code05_KShortestPath2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 76815a507..6476a107a 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -1,12 +1,12 @@
 package class155;
 
 // k短路问题，可持久化左偏树实现最优解，java版
-// 一共有n个点，编号1~n，一共有m条边，每条边有边权，组成一个有向带权图
+// 有n个点编号1~n，有m条边，每条边都是正数边权，组成有向带权图
 // 从1号点走到n号点，就认为是一次旅行
-// 一次旅行中，边不能重复选，但是点可以重复经过，如果到达了n号点，那么这次旅行直接停止
-// 从1号点走到n号点，会有很多通路方案，通路方案的路费为所有选择边集的边权和
+// 一次旅行中，边不能重复选，点可以重复经过，如果到达了n号点，那么旅行直接停止
+// 从1号点走到n号点，会有很多通路方案，通路方案的路费为选择边的边权累加和
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
-// 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
+// 任何两次旅行，只要选择的边稍有不同，就认为是不同的通路方案
 // 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index d4f2f786e..14293594f 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -1,12 +1,12 @@
 package class155;
 
 // k短路问题，可持久化左偏树实现最优解，C++版
-// 一共有n个点，编号1~n，一共有m条边，每条边有边权，组成一个有向带权图
+// 有n个点编号1~n，有m条边，每条边都是正数边权，组成有向带权图
 // 从1号点走到n号点，就认为是一次旅行
-// 一次旅行中，边不能重复选，但是点可以重复经过，如果到达了n号点，那么这次旅行直接停止
-// 从1号点走到n号点，会有很多通路方案，通路方案的路费为所有选择边集的边权和
+// 一次旅行中，边不能重复选，点可以重复经过，如果到达了n号点，那么旅行直接停止
+// 从1号点走到n号点，会有很多通路方案，通路方案的路费为选择边的边权累加和
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
-// 任何两次旅行，只要选择边集稍有不同，就认为是不同的旅行
+// 任何两次旅行，只要选择的边稍有不同，就认为是不同的通路方案
 // 你的钱数为money，用来支付路费，打印你一共能进行几次旅行
 // 测试链接 : https://www.luogu.com.cn/problem/P2483
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 02e9e99841b9818b35d0f7b04fdffb473d57e945 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Dec 2024 14:09:20 +0800
Subject: [PATCH 0294/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 33 ++++++++++++++++++++++---
 src/class155/Code05_KShortestPath2.java |  5 ++--
 2 files changed, 32 insertions(+), 6 deletions(-)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 6476a107a..530fc868d 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -3,7 +3,7 @@
 // k短路问题，可持久化左偏树实现最优解，java版
 // 有n个点编号1~n，有m条边，每条边都是正数边权，组成有向带权图
 // 从1号点走到n号点，就认为是一次旅行
-// 一次旅行中，边不能重复选，点可以重复经过，如果到达了n号点，那么旅行直接停止
+// 一次旅行中，边不能重复选，点可以重复经过，如果到达了n号点，那么旅行立刻停止
 // 从1号点走到n号点，会有很多通路方案，通路方案的路费为选择边的边权累加和
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
 // 任何两次旅行，只要选择的边稍有不同，就认为是不同的通路方案
@@ -28,33 +28,51 @@ public class Code05_KShortestPath1 {
 	public static int n, m;
 	public static double money;
 
+	// 关于正反图有一个非常值得注意的地方
+	// 如果正图中，a到b的边，编号为x
+	// 那么反图中，b到a的边，编号也是x
+	// 因为每一条边，正图建立的同时，反图也同步建立
+	// 所以正反图中这条边分配的编号也是一样的
+	// 正图
 	public static int[] headg = new int[MAXN];
 	public static int[] tog = new int[MAXM];
 	public static int[] nextg = new int[MAXM];
 	public static double[] weightg = new double[MAXM];
 	public static int cntg = 0;
 
+	// 反图
 	public static int[] headr = new int[MAXN];
 	public static int[] tor = new int[MAXM];
 	public static int[] nextr = new int[MAXM];
 	public static double[] weightr = new double[MAXM];
 	public static int cntr = 0;
 
-	public static int[] rt = new int[MAXN];
+	// 左偏树代表基于之前的通路方案，选择非树边的可能性
+	// 左偏树的头就代表最优的选择，假设编号为h的节点是头
+	// to[h] : 选择最优非树边，这个非树边在正图里指向哪个节点
 	public static int[] to = new int[MAXT];
+	// cost[h] : 基于之前的通路方案，最优选择会让路费增加多少
 	public static double[] cost = new double[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] dist = new int[MAXT];
 	public static int cntt = 0;
 
+	// rt[u] : 在最短路树上，节点u及其所有祖先节点，所拥有的全部非树边，组成的左偏树
+	public static int[] rt = new int[MAXN];
+
+	// heap是经典的小根堆，放着很多(key, val)数据，根据val来组织小根堆
 	public static int[] key = new int[MAXH];
 	public static double[] val = new double[MAXH];
 	public static int[] heap = new int[MAXH];
 	public static int cntd, cnth;
 
+	// dijkstra算法需要，根据反图跑dijkstra，生成从节点n开始的最短路树
+	// vis[u] : 节点u到节点n的最短距离，是否已经计算过了
 	public static boolean[] vis = new boolean[MAXN];
+	// path[u] : 最短路树上，到达节点u的树边，编号是什么，也代表正图上，所对应的边
 	public static int[] path = new int[MAXN];
+	// dis[u] : 最短路树上，节点n到节点u的最短距离
 	public static double[] dis = new double[MAXN];
 
 	public static void addEdgeG(int u, int v, double w) {
@@ -108,6 +126,7 @@ public static int merge(int i, int j) {
 		return h;
 	}
 
+	// (k, v)组成一个数据，放到堆上，根据v来组织小根堆
 	public static void heapAdd(int k, double v) {
 		key[++cntd] = k;
 		val[cntd] = v;
@@ -122,6 +141,8 @@ public static void heapAdd(int k, double v) {
 		}
 	}
 
+	// 小根堆上，堆顶的数据(k, v)弹出，并返回数据所在的下标ans
+	// 根据返回值ans，key[ans]得到k，val[ans]得到v
 	public static int heapPop() {
 		int ans = heap[1];
 		heap[1] = heap[cnth--];
@@ -180,6 +201,8 @@ public static void mergeRoad() {
 			int u = key[top];
 			for (int e = headg[u], v; e > 0; e = nextg[e]) {
 				v = tog[e];
+				// path[u]既是边在反图中的编号，也是边在正图中的编号
+				// 因为正反图同步建立，边的正图编号 == 边的反图编号
 				if (e != path[u]) {
 					rt[u] = merge(rt[u], init(v, weightg[e] + dis[v] - dis[u]));
 				}
@@ -234,9 +257,11 @@ public static void main(String[] args) throws IOException {
 			u = in.nextInt();
 			v = in.nextInt();
 			w = in.nextDouble();
+			// 题目说了，一旦到达节点n，旅行立刻停止
+			// 所以从节点n出发的边，一律忽略
 			if (u != n) {
-				addEdgeG(u, v, w);
-				addEdgeR(v, u, w);
+				addEdgeG(u, v, w); // 建立正图
+				addEdgeR(v, u, w); // 建立反图
 			}
 		}
 		dijkstra();
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index 14293594f..143f28576 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -3,7 +3,7 @@
 // k短路问题，可持久化左偏树实现最优解，C++版
 // 有n个点编号1~n，有m条边，每条边都是正数边权，组成有向带权图
 // 从1号点走到n号点，就认为是一次旅行
-// 一次旅行中，边不能重复选，点可以重复经过，如果到达了n号点，那么旅行直接停止
+// 一次旅行中，边不能重复选，点可以重复经过，如果到达了n号点，那么旅行立刻停止
 // 从1号点走到n号点，会有很多通路方案，通路方案的路费为选择边的边权累加和
 // 虽然每次旅行都是从1号点到n号点，但是你希望每次旅行的通路方案都是不同的
 // 任何两次旅行，只要选择的边稍有不同，就认为是不同的通路方案
@@ -37,7 +37,6 @@
 //double weightr[MAXM];
 //int cntr = 0;
 //
-//int rt[MAXN];
 //int to[MAXT];
 //double cost[MAXT];
 //int ls[MAXT];
@@ -45,6 +44,8 @@
 //int dist[MAXT];
 //int cntt = 0;
 //
+//int rt[MAXN];
+//
 //int key[MAXH];
 //double val[MAXH];
 //int heap[MAXH];

From 301d5c9e54dd7d1986b894d1d759e143ef46d54f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Dec 2024 14:17:21 +0800
Subject: [PATCH 0295/1712] modify code

---
 src/class155/Code05_KShortestPath1.java | 11 +++++++++++
 1 file changed, 11 insertions(+)

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 530fc868d..795842e8b 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -167,6 +167,9 @@ public static boolean heapEmpty() {
 		return cnth == 0;
 	}
 
+	// 根据反图跑dijkstra算法
+	// 得到从节点n出发的最短路树、每个节点到节点n的最短距离信息
+	// 最短路树如果有多个，找到任何一个即可
 	public static void dijkstra() {
 		dis[n] = 0;
 		Arrays.fill(dis, 1, n, INF);
@@ -190,6 +193,9 @@ public static void dijkstra() {
 		}
 	}
 
+	// 在最短路树上的每个节点，生成自己的左偏树
+	// 节点u的左偏树 = 节点u自己的非树边左偏树 + 节点u在最短路树上的父亲的左偏树
+	// 课上重点解释了这么做的意义
 	public static void mergeRoad() {
 		cntd = cnth = 0;
 		for (int i = 1; i <= n; i++) {
@@ -213,6 +219,8 @@ public static void mergeRoad() {
 		}
 	}
 
+	// 从路费第1小的方案开始，逐渐找到第2小、第3小...
+	// 看看money能够覆盖几次旅行，返回旅行的次数
 	public static int expand() {
 		int ans = 0;
 		money -= dis[1];
@@ -231,12 +239,15 @@ public static int expand() {
 					break;
 				}
 				ans++;
+				// 当前选择的非树边，被左偏树上的左儿子替换
 				if (left[h] != 0) {
 					heapAdd(left[h], w - cost[h] + cost[left[h]]);
 				}
+				// 当前选择的非树边，被左偏树上的右儿子替换
 				if (right[h] != 0) {
 					heapAdd(right[h], w - cost[h] + cost[right[h]]);
 				}
+				// 当前选择的非树边，指向节点to[h]，那么从to[h]的左偏树里，新增一个最优的非树边
 				if (to[h] != 0 && rt[to[h]] != 0) {
 					heapAdd(rt[to[h]], w + cost[rt[to[h]]]);
 				}

From 26ff7cc56316add38ba0c79102f02adf34034f32 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Dec 2024 17:09:31 +0800
Subject: [PATCH 0296/1712] modify code

---
 ...55\350\267\257\351\227\256\351\242\230.pptx" | Bin 0 -> 49385 bytes
 src/class155/Code05_KShortestPath1.java         |   7 +++++--
 src/class155/Code05_KShortestPath2.java         |   4 ++--
 3 files changed, 7 insertions(+), 4 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243155\343\200\220\346\214\272\351\232\276\343\200\221\345\267\246\345\201\217\346\240\221\345\222\214\346\207\222\346\233\264\346\226\260\343\200\201\345\217\257\346\214\201\344\271\205\345\214\226\345\267\246\345\201\217\346\240\221\343\200\201k\347\237\255\350\267\257\351\227\256\351\242\230.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243155\343\200\220\346\214\272\351\232\276\343\200\221\345\267\246\345\201\217\346\240\221\345\222\214\346\207\222\346\233\264\346\226\260\343\200\201\345\217\257\346\214\201\344\271\205\345\214\226\345\267\246\345\201\217\346\240\221\343\200\201k\347\237\255\350\267\257\351\227\256\351\242\230.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243155\343\200\220\346\214\272\351\232\276\343\200\221\345\267\246\345\201\217\346\240\221\345\222\214\346\207\222\346\233\264\346\226\260\343\200\201\345\217\257\346\214\201\344\271\205\345\214\226\345\267\246\345\201\217\346\240\221\343\200\201k\347\237\255\350\267\257\351\227\256\351\242\230.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..7f847a7ef90d5eb4999474a6db53c7d959b4de50
GIT binary patch
literal 49385
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

literal 0
HcmV?d00001

diff --git a/src/class155/Code05_KShortestPath1.java b/src/class155/Code05_KShortestPath1.java
index 795842e8b..48e099fbd 100644
--- a/src/class155/Code05_KShortestPath1.java
+++ b/src/class155/Code05_KShortestPath1.java
@@ -228,13 +228,16 @@ public static int expand() {
 			ans++;
 			cntd = cnth = 0;
 			if (rt[1] != 0) {
-				heapAdd(rt[1], cost[rt[1]]);
+				// 开始阶段
+				// 1号节点左偏树的堆顶，代表增加代价最小的非树边，放入决策堆
+				// 目前路通方案的路费，同步放入
+				heapAdd(rt[1], dis[1] + cost[rt[1]]);
 			}
 			while (!heapEmpty()) {
 				int top = heapPop();
 				int h = key[top];
 				double w = val[top];
-				money -= w + dis[1];
+				money -= w;
 				if (money < 0) {
 					break;
 				}
diff --git a/src/class155/Code05_KShortestPath2.java b/src/class155/Code05_KShortestPath2.java
index 143f28576..484c1a29e 100644
--- a/src/class155/Code05_KShortestPath2.java
+++ b/src/class155/Code05_KShortestPath2.java
@@ -186,13 +186,13 @@
 //        ans++;
 //        cntd = cnth = 0;
 //        if(rt[1] != 0){
-//            heapAdd(rt[1], cost[rt[1]]);
+//            heapAdd(rt[1], dis[1] + cost[rt[1]]);
 //        }
 //        while(!heapEmpty()){
 //            int top = heapPop();
 //            int h = key[top];
 //            double w = val[top];
-//            money -= w + dis[1];
+//            money -= w;
 //            if(money < 0){
 //                break;
 //            }

From 944e5d40d1218ea04796ff1100aa5bfd9ce25cae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Dec 2024 23:01:52 +0800
Subject: [PATCH 0297/1712] modify code

---
 src/class156/Code01_WrongAnswers.java | 76 +++++++++++++++++++++++++++
 1 file changed, 76 insertions(+)
 create mode 100644 src/class156/Code01_WrongAnswers.java

diff --git a/src/class156/Code01_WrongAnswers.java b/src/class156/Code01_WrongAnswers.java
new file mode 100644
index 000000000..6b6176009
--- /dev/null
+++ b/src/class156/Code01_WrongAnswers.java
@@ -0,0 +1,76 @@
+package class156;
+
+// 错误答案数量
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=3038
+// 测试链接 : https://vjudge.net/problem/HDU-3038
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_WrongAnswers {
+
+	public static int MAXN = 200005;
+
+	public static int n, m, ans;
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] weight = new int[MAXN];
+
+	public static void prepare() {
+		ans = 0;
+		for (int i = 0; i <= n; i++) {
+			father[i] = i;
+			weight[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			int tmp = father[i];
+			father[i] = find(father[i]);
+			weight[i] += weight[tmp];
+		}
+		return father[i];
+	}
+
+	public static void union(int l, int r, int v) {
+		int lf = find(l), rf = find(r);
+		if (lf == rf) {
+			if ((weight[l] - weight[r]) != v) {
+				ans++;
+			}
+		} else {
+			father[lf] = rf;
+			weight[lf] = v + weight[r] - weight[l];
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			n = (int) in.nval;
+			in.nextToken();
+			m = (int) in.nval;
+			prepare();
+			for (int i = 1, l, r, v; i <= m; i++) {
+				in.nextToken(); l = (int) in.nval - 1;
+				in.nextToken(); r = (int) in.nval;
+				in.nextToken(); v = (int) in.nval;
+				union(l, r, v);
+			}
+			out.println(ans);
+			out.flush();
+		}
+		out.close();
+		br.close();
+	}
+
+}

From c78b5fcafe46ad9d05dc60cfb4caba25f426016b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Dec 2024 23:03:22 +0800
Subject: [PATCH 0298/1712] modify code

---
 src/class156/Code01_WrongAnswers.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class156/Code01_WrongAnswers.java b/src/class156/Code01_WrongAnswers.java
index 6b6176009..899762cb8 100644
--- a/src/class156/Code01_WrongAnswers.java
+++ b/src/class156/Code01_WrongAnswers.java
@@ -67,8 +67,8 @@ public static void main(String[] args) throws IOException {
 				union(l, r, v);
 			}
 			out.println(ans);
-			out.flush();
 		}
+		out.flush();
 		out.close();
 		br.close();
 	}

From c260d077cc0d7df87180d0d4907e8e3e18d05aa5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Dec 2024 23:04:31 +0800
Subject: [PATCH 0299/1712] modify code

---
 src/class156/Code01_WrongAnswers.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class156/Code01_WrongAnswers.java b/src/class156/Code01_WrongAnswers.java
index 899762cb8..708f8a6ce 100644
--- a/src/class156/Code01_WrongAnswers.java
+++ b/src/class156/Code01_WrongAnswers.java
@@ -14,7 +14,7 @@
 
 public class Code01_WrongAnswers {
 
-	public static int MAXN = 200005;
+	public static int MAXN = 200001;
 
 	public static int n, m, ans;
 

From b7b32f9c294c970b510c36df59cc01d7422d570b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 31 Dec 2024 16:24:45 +0800
Subject: [PATCH 0300/1712] modify code

---
 src/class156/Code01_WrongAnswers.java   |  19 ++--
 src/class156/Code02_LegendOfHeroes.java | 132 ++++++++++++++++++++++++
 2 files changed, 143 insertions(+), 8 deletions(-)
 create mode 100644 src/class156/Code02_LegendOfHeroes.java

diff --git a/src/class156/Code01_WrongAnswers.java b/src/class156/Code01_WrongAnswers.java
index 708f8a6ce..80baf4504 100644
--- a/src/class156/Code01_WrongAnswers.java
+++ b/src/class156/Code01_WrongAnswers.java
@@ -20,13 +20,13 @@ public class Code01_WrongAnswers {
 
 	public static int[] father = new int[MAXN];
 
-	public static int[] weight = new int[MAXN];
+	public static int[] dist = new int[MAXN];
 
 	public static void prepare() {
 		ans = 0;
 		for (int i = 0; i <= n; i++) {
 			father[i] = i;
-			weight[i] = 0;
+			dist[i] = 0;
 		}
 	}
 
@@ -34,7 +34,7 @@ public static int find(int i) {
 		if (i != father[i]) {
 			int tmp = father[i];
 			father[i] = find(father[i]);
-			weight[i] += weight[tmp];
+			dist[i] += dist[tmp];
 		}
 		return father[i];
 	}
@@ -42,12 +42,12 @@ public static int find(int i) {
 	public static void union(int l, int r, int v) {
 		int lf = find(l), rf = find(r);
 		if (lf == rf) {
-			if ((weight[l] - weight[r]) != v) {
+			if ((dist[l] - dist[r]) != v) {
 				ans++;
 			}
 		} else {
 			father[lf] = rf;
-			weight[lf] = v + weight[r] - weight[l];
+			dist[lf] = v + dist[r] - dist[l];
 		}
 	}
 
@@ -61,9 +61,12 @@ public static void main(String[] args) throws IOException {
 			m = (int) in.nval;
 			prepare();
 			for (int i = 1, l, r, v; i <= m; i++) {
-				in.nextToken(); l = (int) in.nval - 1;
-				in.nextToken(); r = (int) in.nval;
-				in.nextToken(); v = (int) in.nval;
+				in.nextToken();
+				l = (int) in.nval - 1;
+				in.nextToken();
+				r = (int) in.nval;
+				in.nextToken();
+				v = (int) in.nval;
 				union(l, r, v);
 			}
 			out.println(ans);
diff --git a/src/class156/Code02_LegendOfHeroes.java b/src/class156/Code02_LegendOfHeroes.java
new file mode 100644
index 000000000..841e46501
--- /dev/null
+++ b/src/class156/Code02_LegendOfHeroes.java
@@ -0,0 +1,132 @@
+package class156;
+
+// 银河英雄传说
+// 测试链接 : https://www.luogu.com.cn/problem/P1196
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code02_LegendOfHeroes {
+
+	public static int MAXN = 30001;
+
+	public static int n = 30000;
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	// 递归会爆栈，所以用迭代来寻找并查集代表节点
+	public static int[] stack = new int[MAXN];
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			dist[i] = 0;
+			size[i] = 1;
+		}
+	}
+
+	// 迭代的方式实现find
+	public static int find(int i) {
+		int si = 0;
+		while (i != father[i]) {
+			stack[++si] = i;
+			i = father[i];
+		}
+		stack[si + 1] = i;
+		for (int j = si; j >= 1; j--) {
+			father[stack[j]] = i;
+			dist[stack[j]] += dist[stack[j + 1]];
+		}
+		return i;
+	}
+
+	public static void union(int l, int r) {
+		int lf = find(l), rf = find(r);
+		if (lf == rf) {
+			return;
+		}
+		father[lf] = rf;
+		dist[lf] += size[rf];
+		size[rf] += size[lf];
+	}
+
+	public static int watch(int l, int r) {
+		if (find(l) != find(r)) {
+			return -1;
+		}
+		return Math.abs(dist[l] - dist[r]) - 1;
+	}
+
+	public static void main(String[] args) {
+		prepare();
+		Kattio io = new Kattio();
+		int m = io.nextInt();
+		String op;
+		for (int i = 1, l, r; i <= m; i++) {
+			op = io.next();
+			l = io.nextInt();
+			r = io.nextInt();
+			if (op.equals("M")) {
+				union(l, r);
+			} else {
+				io.println(watch(l, r));
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}

From abe3ab6f020472b042f4f97c4850817bcbdd35c9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 31 Dec 2024 16:25:25 +0800
Subject: [PATCH 0301/1712] modify code

---
 src/class156/Code02_LegendOfHeroes.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class156/Code02_LegendOfHeroes.java b/src/class156/Code02_LegendOfHeroes.java
index 841e46501..586d2836f 100644
--- a/src/class156/Code02_LegendOfHeroes.java
+++ b/src/class156/Code02_LegendOfHeroes.java
@@ -36,7 +36,7 @@ public static void prepare() {
 		}
 	}
 
-	// 迭代的方式实现find
+	// 迭代的方式实现find，递归方式实现会爆栈
 	public static int find(int i) {
 		int si = 0;
 		while (i != father[i]) {

From 616ca2dc9c538b0044c7ca6c40aa07b4fab4ef48 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 31 Dec 2024 20:56:23 +0800
Subject: [PATCH 0302/1712] modify code

---
 src/class156/Code01_DerivePartialSums.java    | 96 +++++++++++++++++++
 ...gAnswers.java => Code02_WrongAnswers.java} |  2 +-
 ...Heroes.java => Code03_LegendOfHeroes.java} | 11 +--
 3 files changed, 102 insertions(+), 7 deletions(-)
 create mode 100644 src/class156/Code01_DerivePartialSums.java
 rename src/class156/{Code01_WrongAnswers.java => Code02_WrongAnswers.java} (98%)
 rename src/class156/{Code02_LegendOfHeroes.java => Code03_LegendOfHeroes.java} (95%)

diff --git a/src/class156/Code01_DerivePartialSums.java b/src/class156/Code01_DerivePartialSums.java
new file mode 100644
index 000000000..8e354c019
--- /dev/null
+++ b/src/class156/Code01_DerivePartialSums.java
@@ -0,0 +1,96 @@
+package class156;
+
+// 推导部分和
+// 测试链接 : https://www.luogu.com.cn/problem/P8779
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_DerivePartialSums {
+
+	public static int MAXN = 200001;
+
+	public static long INF = Long.MAX_VALUE;
+
+	public static int n, m, q;
+
+	public static int[] father = new int[MAXN];
+
+	public static long[] dist = new long[MAXN];
+
+	public static void prepare() {
+		for (int i = 0; i <= n; i++) {
+			father[i] = i;
+			dist[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			int tmp = father[i];
+			father[i] = find(father[i]);
+			dist[i] += dist[tmp];
+		}
+		return father[i];
+	}
+
+	public static void union(int l, int r, long v) {
+		int lf = find(l), rf = find(r);
+		if (lf != rf) {
+			father[lf] = rf;
+			dist[lf] = v + dist[r] - dist[l];
+		}
+	}
+
+	public static long query(int l, int r) {
+		if (find(l) != find(r)) {
+			return INF;
+		}
+		return dist[l] - dist[r];
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		in.nextToken();
+		q = (int) in.nval;
+		prepare();
+		int l, r;
+		long v;
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			l = (int) in.nval - 1;
+			in.nextToken();
+			r = (int) in.nval;
+			in.nextToken();
+			v = (long) in.nval;
+			union(l, r, v);
+		}
+		for (int i = 1; i <= q; i++) {
+			in.nextToken();
+			l = (int) in.nval - 1;
+			in.nextToken();
+			r = (int) in.nval;
+			v = query(l, r);
+			if (v == INF) {
+				out.println("UNKNOWN");
+			} else {
+				out.println(v);
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class156/Code01_WrongAnswers.java b/src/class156/Code02_WrongAnswers.java
similarity index 98%
rename from src/class156/Code01_WrongAnswers.java
rename to src/class156/Code02_WrongAnswers.java
index 80baf4504..4c54d6d9f 100644
--- a/src/class156/Code01_WrongAnswers.java
+++ b/src/class156/Code02_WrongAnswers.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code01_WrongAnswers {
+public class Code02_WrongAnswers {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class156/Code02_LegendOfHeroes.java b/src/class156/Code03_LegendOfHeroes.java
similarity index 95%
rename from src/class156/Code02_LegendOfHeroes.java
rename to src/class156/Code03_LegendOfHeroes.java
index 586d2836f..2e007d964 100644
--- a/src/class156/Code02_LegendOfHeroes.java
+++ b/src/class156/Code03_LegendOfHeroes.java
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code02_LegendOfHeroes {
+public class Code03_LegendOfHeroes {
 
 	public static int MAXN = 30001;
 
@@ -53,12 +53,11 @@ public static int find(int i) {
 
 	public static void union(int l, int r) {
 		int lf = find(l), rf = find(r);
-		if (lf == rf) {
-			return;
+		if (lf != rf) {
+			father[lf] = rf;
+			dist[lf] += size[rf];
+			size[rf] += size[lf];
 		}
-		father[lf] = rf;
-		dist[lf] += size[rf];
-		size[rf] += size[lf];
 	}
 
 	public static int watch(int l, int r) {

From 59738758d7d75f94de167c94a5f533cb28a25464 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 31 Dec 2024 23:48:15 +0800
Subject: [PATCH 0303/1712] modify code

---
 src/class156/Code01_DerivePartialSums.java |  2 +-
 src/class156/Code02_WrongAnswers.java      |  2 +-
 src/class156/Code04_EvaluateDivision.java  | 67 ++++++++++++++++++++++
 3 files changed, 69 insertions(+), 2 deletions(-)
 create mode 100644 src/class156/Code04_EvaluateDivision.java

diff --git a/src/class156/Code01_DerivePartialSums.java b/src/class156/Code01_DerivePartialSums.java
index 8e354c019..57c70fafd 100644
--- a/src/class156/Code01_DerivePartialSums.java
+++ b/src/class156/Code01_DerivePartialSums.java
@@ -33,7 +33,7 @@ public static void prepare() {
 	public static int find(int i) {
 		if (i != father[i]) {
 			int tmp = father[i];
-			father[i] = find(father[i]);
+			father[i] = find(tmp);
 			dist[i] += dist[tmp];
 		}
 		return father[i];
diff --git a/src/class156/Code02_WrongAnswers.java b/src/class156/Code02_WrongAnswers.java
index 4c54d6d9f..70dab9a5a 100644
--- a/src/class156/Code02_WrongAnswers.java
+++ b/src/class156/Code02_WrongAnswers.java
@@ -33,7 +33,7 @@ public static void prepare() {
 	public static int find(int i) {
 		if (i != father[i]) {
 			int tmp = father[i];
-			father[i] = find(father[i]);
+			father[i] = find(tmp);
 			dist[i] += dist[tmp];
 		}
 		return father[i];
diff --git a/src/class156/Code04_EvaluateDivision.java b/src/class156/Code04_EvaluateDivision.java
new file mode 100644
index 000000000..445acdd6b
--- /dev/null
+++ b/src/class156/Code04_EvaluateDivision.java
@@ -0,0 +1,67 @@
+package class156;
+
+import java.util.HashMap;
+import java.util.List;
+
+// 除法求值
+// 测试链接 : https://leetcode.cn/problems/evaluate-division/
+public class Code04_EvaluateDivision {
+
+	public static double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
+		build(equations);
+		for (int i = 0; i < values.length; i++) {
+			union(equations.get(i).get(0), equations.get(i).get(1), values[i]);
+		}
+		double[] ans = new double[queries.size()];
+		for (int i = 0; i < queries.size(); i++) {
+			ans[i] = compute(queries.get(i).get(0), queries.get(i).get(1));
+		}
+		return ans;
+	}
+
+	public static HashMap<String, String> father = new HashMap<>();
+
+	public static HashMap<String, Double> dist = new HashMap<>();
+
+	public static void build(List<List<String>> equations) {
+		father.clear();
+		dist.clear();
+		for (List<String> list : equations) {
+			for (String key : list) {
+				father.put(key, key);
+				dist.put(key, 1.0);
+			}
+		}
+	}
+
+	public static String find(String x) {
+		if (!father.containsKey(x)) {
+			return null;
+		}
+		String tmp, fa = x;
+		if (!x.equals(father.get(x))) {
+			tmp = father.get(x);
+			fa = find(tmp);
+			dist.put(x, dist.get(x) * dist.get(tmp));
+			father.put(x, fa);
+		}
+		return fa;
+	}
+
+	public static void union(String l, String r, double v) {
+		String lf = find(l), rf = find(r);
+		if (!lf.equals(rf)) {
+			father.put(lf, rf);
+			dist.put(lf, dist.get(r) / dist.get(l) * v);
+		}
+	}
+
+	public static double compute(String l, String r) {
+		String lf = find(l), rf = find(r);
+		if (lf == null || rf == null || !lf.equals(rf)) {
+			return -1.0;
+		}
+		return dist.get(l) / dist.get(r);
+	}
+
+}

From 146e9c7df164482f3bd21035a171d640137d59ee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 31 Dec 2024 23:56:20 +0800
Subject: [PATCH 0304/1712] modify code

---
 src/class156/Code04_EvaluateDivision.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class156/Code04_EvaluateDivision.java b/src/class156/Code04_EvaluateDivision.java
index 445acdd6b..c1e3639b7 100644
--- a/src/class156/Code04_EvaluateDivision.java
+++ b/src/class156/Code04_EvaluateDivision.java
@@ -8,7 +8,7 @@
 public class Code04_EvaluateDivision {
 
 	public static double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
-		build(equations);
+		prepare(equations);
 		for (int i = 0; i < values.length; i++) {
 			union(equations.get(i).get(0), equations.get(i).get(1), values[i]);
 		}
@@ -23,7 +23,7 @@ public static double[] calcEquation(List<List<String>> equations, double[] value
 
 	public static HashMap<String, Double> dist = new HashMap<>();
 
-	public static void build(List<List<String>> equations) {
+	public static void prepare(List<List<String>> equations) {
 		father.clear();
 		dist.clear();
 		for (List<String> list : equations) {

From 3b7b3eed6565cdd73e72d034d6705ece0c727702 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Jan 2025 22:31:04 +0800
Subject: [PATCH 0305/1712] modify code

---
 src/class156/Code02_WrongAnswers.java         | 21 ++--
 src/class156/Code05_FoodChainTrueOrFalse.java | 95 +++++++++++++++++++
 2 files changed, 110 insertions(+), 6 deletions(-)
 create mode 100644 src/class156/Code05_FoodChainTrueOrFalse.java

diff --git a/src/class156/Code02_WrongAnswers.java b/src/class156/Code02_WrongAnswers.java
index 70dab9a5a..704d58eea 100644
--- a/src/class156/Code02_WrongAnswers.java
+++ b/src/class156/Code02_WrongAnswers.java
@@ -41,16 +41,21 @@ public static int find(int i) {
 
 	public static void union(int l, int r, int v) {
 		int lf = find(l), rf = find(r);
-		if (lf == rf) {
-			if ((dist[l] - dist[r]) != v) {
-				ans++;
-			}
-		} else {
+		if (lf != rf) {
 			father[lf] = rf;
 			dist[lf] = v + dist[r] - dist[l];
 		}
 	}
 
+	public static boolean check(int l, int r, int v) {
+		if (find(l) == find(r)) {
+			if ((dist[l] - dist[r]) != v) {
+				return false;
+			}
+		}
+		return true;
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -67,7 +72,11 @@ public static void main(String[] args) throws IOException {
 				r = (int) in.nval;
 				in.nextToken();
 				v = (int) in.nval;
-				union(l, r, v);
+				if (!check(l, r, v)) {
+					ans++;
+				} else {
+					union(l, r, v);
+				}
 			}
 			out.println(ans);
 		}
diff --git a/src/class156/Code05_FoodChainTrueOrFalse.java b/src/class156/Code05_FoodChainTrueOrFalse.java
new file mode 100644
index 000000000..34a7ff006
--- /dev/null
+++ b/src/class156/Code05_FoodChainTrueOrFalse.java
@@ -0,0 +1,95 @@
+package class156;
+
+// 食物链真假判断
+// 测试链接 : https://www.luogu.com.cn/problem/P2024
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code05_FoodChainTrueOrFalse {
+
+	public static int MAXN = 50001;
+
+	public static int n, k, ans;
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] relation = new int[MAXN];
+
+	public static void prepare() {
+		ans = 0;
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			relation[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			int tmp = father[i];
+			father[i] = find(tmp);
+			relation[i] = (relation[i] + relation[tmp]) % 3;
+		}
+		return father[i];
+	}
+
+	public static void union(int op, int l, int r) {
+		int lf = find(l), rf = find(r), v = op == 1 ? 0 : 1;
+		if (lf != rf) {
+			father[lf] = rf;
+			relation[lf] = (relation[r] - relation[l] + v + 3) % 3;
+		}
+	}
+
+	public static boolean check(int op, int l, int r) {
+		if (l > n || r > n || (op == 2 && l == r)) {
+			return false;
+		}
+		if (find(l) == find(r)) {
+			if (op == 1) {
+				if (relation[l] != relation[r]) {
+					return false;
+				}
+			} else {
+				if ((relation[l] - relation[r] + 3) % 3 != 1) {
+					return false;
+				}
+			}
+		}
+		return true;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		prepare();
+		for (int i = 1, op, x, y; i <= k; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			in.nextToken();
+			y = (int) in.nval;
+			if (!check(op, x, y)) {
+				ans++;
+			} else {
+				union(op, x, y);
+			}
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 943377ebea7b0a185ecff4a258686fe1e0396226 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Jan 2025 12:33:55 +0800
Subject: [PATCH 0306/1712] modify code

---
 src/class156/Code01_DerivePartialSums.java | 10 +++++-----
 src/class156/Code02_WrongAnswers.java      |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class156/Code01_DerivePartialSums.java b/src/class156/Code01_DerivePartialSums.java
index 57c70fafd..4225032aa 100644
--- a/src/class156/Code01_DerivePartialSums.java
+++ b/src/class156/Code01_DerivePartialSums.java
@@ -13,7 +13,7 @@
 
 public class Code01_DerivePartialSums {
 
-	public static int MAXN = 200001;
+	public static int MAXN = 100002;
 
 	public static long INF = Long.MAX_VALUE;
 
@@ -69,18 +69,18 @@ public static void main(String[] args) throws IOException {
 		long v;
 		for (int i = 1; i <= m; i++) {
 			in.nextToken();
-			l = (int) in.nval - 1;
+			l = (int) in.nval;
 			in.nextToken();
-			r = (int) in.nval;
+			r = (int) in.nval + 1;
 			in.nextToken();
 			v = (long) in.nval;
 			union(l, r, v);
 		}
 		for (int i = 1; i <= q; i++) {
 			in.nextToken();
-			l = (int) in.nval - 1;
+			l = (int) in.nval;
 			in.nextToken();
-			r = (int) in.nval;
+			r = (int) in.nval + 1;
 			v = query(l, r);
 			if (v == INF) {
 				out.println("UNKNOWN");
diff --git a/src/class156/Code02_WrongAnswers.java b/src/class156/Code02_WrongAnswers.java
index 704d58eea..a640895e1 100644
--- a/src/class156/Code02_WrongAnswers.java
+++ b/src/class156/Code02_WrongAnswers.java
@@ -14,7 +14,7 @@
 
 public class Code02_WrongAnswers {
 
-	public static int MAXN = 200001;
+	public static int MAXN = 200002;
 
 	public static int n, m, ans;
 
@@ -67,9 +67,9 @@ public static void main(String[] args) throws IOException {
 			prepare();
 			for (int i = 1, l, r, v; i <= m; i++) {
 				in.nextToken();
-				l = (int) in.nval - 1;
+				l = (int) in.nval;
 				in.nextToken();
-				r = (int) in.nval;
+				r = (int) in.nval + 1;
 				in.nextToken();
 				v = (int) in.nval;
 				if (!check(l, r, v)) {

From 044890fb825ba40c33e7019566b69bdae503a93f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Jan 2025 12:36:24 +0800
Subject: [PATCH 0307/1712] modify code

---
 src/class156/Code03_LegendOfHeroes.java   | 4 ++--
 src/class156/Code04_EvaluateDivision.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class156/Code03_LegendOfHeroes.java b/src/class156/Code03_LegendOfHeroes.java
index 2e007d964..f6df38952 100644
--- a/src/class156/Code03_LegendOfHeroes.java
+++ b/src/class156/Code03_LegendOfHeroes.java
@@ -60,7 +60,7 @@ public static void union(int l, int r) {
 		}
 	}
 
-	public static int watch(int l, int r) {
+	public static int query(int l, int r) {
 		if (find(l) != find(r)) {
 			return -1;
 		}
@@ -79,7 +79,7 @@ public static void main(String[] args) {
 			if (op.equals("M")) {
 				union(l, r);
 			} else {
-				io.println(watch(l, r));
+				io.println(query(l, r));
 			}
 		}
 		io.flush();
diff --git a/src/class156/Code04_EvaluateDivision.java b/src/class156/Code04_EvaluateDivision.java
index c1e3639b7..8a92b3ee8 100644
--- a/src/class156/Code04_EvaluateDivision.java
+++ b/src/class156/Code04_EvaluateDivision.java
@@ -14,7 +14,7 @@ public static double[] calcEquation(List<List<String>> equations, double[] value
 		}
 		double[] ans = new double[queries.size()];
 		for (int i = 0; i < queries.size(); i++) {
-			ans[i] = compute(queries.get(i).get(0), queries.get(i).get(1));
+			ans[i] = query(queries.get(i).get(0), queries.get(i).get(1));
 		}
 		return ans;
 	}
@@ -56,7 +56,7 @@ public static void union(String l, String r, double v) {
 		}
 	}
 
-	public static double compute(String l, String r) {
+	public static double query(String l, String r) {
 		String lf = find(l), rf = find(r);
 		if (lf == null || rf == null || !lf.equals(rf)) {
 			return -1.0;

From 9866ca4a3ecdedb16e3428548b0437b8a0eb0f5d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Jan 2025 21:15:53 +0800
Subject: [PATCH 0308/1712] modify code

---
 src/class156/Code01_DerivePartialSums.java    |   2 +-
 src/class156/Code02_CunningMerchant.java      |  92 ++++++
 ...gAnswers.java => Code03_WrongAnswers.java} |   4 +-
 ...Heroes.java => Code04_LegendOfHeroes.java} |   2 +-
 ...sion.java => Code05_EvaluateDivision.java} |   2 +-
 src/class156/Code06_ExclusiveOR.java          | 288 ++++++++++++++++++
 ....java => Code07_FoodChainTrueOrFalse.java} |  12 +-
 src/class156/Code08_DetainCriminals.java      |  98 ++++++
 8 files changed, 489 insertions(+), 11 deletions(-)
 create mode 100644 src/class156/Code02_CunningMerchant.java
 rename src/class156/{Code02_WrongAnswers.java => Code03_WrongAnswers.java} (96%)
 rename src/class156/{Code03_LegendOfHeroes.java => Code04_LegendOfHeroes.java} (98%)
 rename src/class156/{Code04_EvaluateDivision.java => Code05_EvaluateDivision.java} (97%)
 create mode 100644 src/class156/Code06_ExclusiveOR.java
 rename src/class156/{Code05_FoodChainTrueOrFalse.java => Code07_FoodChainTrueOrFalse.java} (91%)
 create mode 100644 src/class156/Code08_DetainCriminals.java

diff --git a/src/class156/Code01_DerivePartialSums.java b/src/class156/Code01_DerivePartialSums.java
index 4225032aa..7cc8ba7e2 100644
--- a/src/class156/Code01_DerivePartialSums.java
+++ b/src/class156/Code01_DerivePartialSums.java
@@ -59,7 +59,7 @@ public static void main(String[] args) throws IOException {
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		in.nextToken();
-		n = (int) in.nval;
+		n = (int) in.nval + 1;
 		in.nextToken();
 		m = (int) in.nval;
 		in.nextToken();
diff --git a/src/class156/Code02_CunningMerchant.java b/src/class156/Code02_CunningMerchant.java
new file mode 100644
index 000000000..1f4037bf1
--- /dev/null
+++ b/src/class156/Code02_CunningMerchant.java
@@ -0,0 +1,92 @@
+package class156;
+
+// 狡猾的商人
+// 测试链接 : https://www.luogu.com.cn/problem/P2294
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_CunningMerchant {
+
+	public static int MAXN = 102;
+
+	public static int t, n, m;
+
+	public static boolean ans;
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] dist = new int[MAXN];
+
+	public static void prepare() {
+		ans = true;
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			dist[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			int tmp = father[i];
+			father[i] = find(tmp);
+			dist[i] += dist[tmp];
+		}
+		return father[i];
+	}
+
+	public static void union(int l, int r, int v) {
+		int lf = find(l), rf = find(r);
+		if (lf != rf) {
+			father[lf] = rf;
+			dist[lf] = v + dist[r] - dist[l];
+		}
+	}
+
+	public static boolean check(int l, int r, int v) {
+		if (find(l) == find(r)) {
+			if ((dist[l] - dist[r]) != v) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		t = (int) in.nval;
+		for (int c = 1; c <= t; c++) {
+			in.nextToken();
+			n = (int) in.nval + 1;
+			in.nextToken();
+			m = (int) in.nval;
+			prepare();
+			for (int i = 1, l, r, v; i <= m; i++) {
+				in.nextToken();
+				l = (int) in.nval;
+				in.nextToken();
+				r = (int) in.nval + 1;
+				in.nextToken();
+				v = (int) in.nval;
+				if (!check(l, r, v)) {
+					ans = false;
+				} else {
+					union(l, r, v);
+				}
+			}
+			out.println(ans);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class156/Code02_WrongAnswers.java b/src/class156/Code03_WrongAnswers.java
similarity index 96%
rename from src/class156/Code02_WrongAnswers.java
rename to src/class156/Code03_WrongAnswers.java
index a640895e1..3da2a3637 100644
--- a/src/class156/Code02_WrongAnswers.java
+++ b/src/class156/Code03_WrongAnswers.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_WrongAnswers {
+public class Code03_WrongAnswers {
 
 	public static int MAXN = 200002;
 
@@ -61,7 +61,7 @@ public static void main(String[] args) throws IOException {
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		while (in.nextToken() != StreamTokenizer.TT_EOF) {
-			n = (int) in.nval;
+			n = (int) in.nval + 1;
 			in.nextToken();
 			m = (int) in.nval;
 			prepare();
diff --git a/src/class156/Code03_LegendOfHeroes.java b/src/class156/Code04_LegendOfHeroes.java
similarity index 98%
rename from src/class156/Code03_LegendOfHeroes.java
rename to src/class156/Code04_LegendOfHeroes.java
index f6df38952..3c96f73ab 100644
--- a/src/class156/Code03_LegendOfHeroes.java
+++ b/src/class156/Code04_LegendOfHeroes.java
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code03_LegendOfHeroes {
+public class Code04_LegendOfHeroes {
 
 	public static int MAXN = 30001;
 
diff --git a/src/class156/Code04_EvaluateDivision.java b/src/class156/Code05_EvaluateDivision.java
similarity index 97%
rename from src/class156/Code04_EvaluateDivision.java
rename to src/class156/Code05_EvaluateDivision.java
index 8a92b3ee8..d5365e2f2 100644
--- a/src/class156/Code04_EvaluateDivision.java
+++ b/src/class156/Code05_EvaluateDivision.java
@@ -5,7 +5,7 @@
 
 // 除法求值
 // 测试链接 : https://leetcode.cn/problems/evaluate-division/
-public class Code04_EvaluateDivision {
+public class Code05_EvaluateDivision {
 
 	public static double[] calcEquation(List<List<String>> equations, double[] values, List<List<String>> queries) {
 		prepare(equations);
diff --git a/src/class156/Code06_ExclusiveOR.java b/src/class156/Code06_ExclusiveOR.java
new file mode 100644
index 000000000..88799afce
--- /dev/null
+++ b/src/class156/Code06_ExclusiveOR.java
@@ -0,0 +1,288 @@
+package class156;
+
+// 异或关系
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=3234
+// 测试链接 : https://www.luogu.com.cn/problem/UVA12232
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code06_ExclusiveOR {
+
+	public static int MAXN = 20002;
+
+	public static int MAXK = 21;
+
+	public static int t, n, m;
+
+	public static boolean conflict;
+
+	public static int cnti;
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] exclu = new int[MAXN];
+
+	public static int[] nums = new int[MAXK];
+
+	public static int[] collect = new int[MAXK];
+
+	public static void prepare() {
+		conflict = false;
+		cnti = 0;
+		for (int i = 0; i <= n; i++) {
+			father[i] = i;
+			exclu[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			int tmp = father[i];
+			father[i] = find(tmp);
+			exclu[i] ^= exclu[tmp];
+		}
+		return father[i];
+	}
+
+	public static void union(int l, int r, int v) {
+		int lf = find(l), rf = find(r);
+		if (lf == n) {
+			lf = rf;
+			rf = n;
+		}
+		if (lf != rf) {
+			father[lf] = rf;
+			exclu[lf] = exclu[r] ^ exclu[l] ^ v;
+		}
+	}
+
+	public static boolean check(int l, int r, int v) {
+		if (find(l) == find(r)) {
+			if ((exclu[l] ^ exclu[r]) != v) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static boolean opi(int l, int r, int v) {
+		cnti++;
+		if (!check(l, r, v)) {
+			conflict = true;
+			return false;
+		}
+		union(l, r, v);
+		return true;
+	}
+
+	public static int opq(int k) {
+		int ans = 0, ci = 0, fa;
+		for (int i = 1; i <= k; i++) {
+			fa = find(nums[i]);
+			ans ^= exclu[nums[i]];
+			collect[++ci] = fa;
+		}
+		Arrays.sort(collect, 1, ci + 1);
+		for (int l = 1, r = 1; l <= ci; l = ++r) {
+			while (r + 1 <= ci && collect[r + 1] == collect[l]) {
+				r++;
+			}
+			if ((r - l + 1) % 2 != 0) {
+				if (collect[l] == n) {
+					ans ^= exclu[n];
+				} else {
+					return -1;
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		t = 0;
+		n = in.nextInt();
+		m = in.nextInt();
+		while (n != 0 || m != 0) {
+			prepare();
+			out.println("Case " + (++t) + ":");
+			for (int i = 1; i <= m; i++) {
+				String op = in.next();
+				if (op.equals("I")) {
+					int l, r, v;
+					in.numbers();
+					if (in.size == 2) {
+						l = in.a;
+						r = n;
+						v = in.b;
+					} else {
+						l = in.a;
+						r = in.b;
+						v = in.c;
+					}
+					if (!conflict) {
+						if (!opi(l, r, v)) {
+							out.println("The first " + cnti + " facts are conflicting.");
+						}
+					}
+				} else {
+					int k = in.nextInt();
+					for (int j = 1; j <= k; j++) {
+						nums[j] = in.nextInt();
+					}
+					if (!conflict) {
+						int ans = opq(k);
+						if (ans == -1) {
+							out.println("I don't know.");
+						} else {
+							out.println(ans);
+						}
+					}
+				}
+			}
+			out.println();
+			n = in.nextInt();
+			m = in.nextInt();
+		}
+		out.flush();
+		out.close();
+		in.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int pointer, bytesRead;
+
+		public int a;
+		public int b;
+		public int c;
+		public int size;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			pointer = bytesRead = 0;
+		}
+
+		private byte read() throws IOException {
+			if (pointer >= bytesRead) {
+				fillBuffer();
+				if (bytesRead == -1) {
+					return -1;
+				}
+			}
+			return buffer[pointer++];
+		}
+
+		private void fillBuffer() throws IOException {
+			bytesRead = in.read(buffer, 0, BUFFER_SIZE);
+			pointer = 0;
+		}
+
+		private void skipWhiteSpace() throws IOException {
+			byte c;
+			while ((c = read()) != -1) {
+				if (c > ' ') {
+					pointer--;
+					break;
+				}
+			}
+		}
+
+		private String readLine() throws IOException {
+			StringBuilder sb = new StringBuilder();
+			while (true) {
+				byte c = read();
+				if (c == -1 || c == '\n') {
+					break;
+				}
+				if (c == '\r') {
+					byte nextc = read();
+					if (nextc != '\n') {
+						pointer--;
+					}
+					break;
+				}
+				sb.append((char) c);
+			}
+			if (sb.length() == 0 && bytesRead == -1) {
+				return null;
+			}
+			return sb.toString();
+		}
+
+		public String next() throws IOException {
+			skipWhiteSpace();
+			if (bytesRead == -1) {
+				return null;
+			}
+			StringBuilder sb = new StringBuilder();
+			byte c = read();
+			while (c != -1 && c > ' ') {
+				sb.append((char) c);
+				c = read();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() throws IOException {
+			skipWhiteSpace();
+			if (bytesRead == -1) {
+				throw new IOException("No more data to read (EOF)");
+			}
+			boolean negative = false;
+			int result = 0;
+			byte c = read();
+			if (c == '-') {
+				negative = true;
+				c = read();
+			}
+			while (c >= '0' && c <= '9') {
+				result = result * 10 + (c - '0');
+				c = read();
+			}
+			if (c != -1 && c > ' ') {
+				pointer--;
+			}
+			return negative ? -result : result;
+		}
+
+		public void numbers() throws IOException {
+			a = b = c = size = 0;
+			String line = readLine();
+			if (line == null) {
+				return;
+			}
+			String[] parts = line.trim().split("\\s+");
+			if (parts.length == 0) {
+				return;
+			}
+			size = Math.min(parts.length, 3);
+			if (size >= 1) {
+				a = Integer.parseInt(parts[0]);
+			}
+			if (size >= 2) {
+				b = Integer.parseInt(parts[1]);
+			}
+			if (size >= 3) {
+				c = Integer.parseInt(parts[2]);
+			}
+		}
+
+		public void close() throws IOException {
+			if (in != null) {
+				in.close();
+			}
+		}
+	}
+
+}
diff --git a/src/class156/Code05_FoodChainTrueOrFalse.java b/src/class156/Code07_FoodChainTrueOrFalse.java
similarity index 91%
rename from src/class156/Code05_FoodChainTrueOrFalse.java
rename to src/class156/Code07_FoodChainTrueOrFalse.java
index 34a7ff006..7ef305e59 100644
--- a/src/class156/Code05_FoodChainTrueOrFalse.java
+++ b/src/class156/Code07_FoodChainTrueOrFalse.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_FoodChainTrueOrFalse {
+public class Code07_FoodChainTrueOrFalse {
 
 	public static int MAXN = 50001;
 
@@ -73,17 +73,17 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		k = (int) in.nval;
 		prepare();
-		for (int i = 1, op, x, y; i <= k; i++) {
+		for (int i = 1, op, l, r; i <= k; i++) {
 			in.nextToken();
 			op = (int) in.nval;
 			in.nextToken();
-			x = (int) in.nval;
+			l = (int) in.nval;
 			in.nextToken();
-			y = (int) in.nval;
-			if (!check(op, x, y)) {
+			r = (int) in.nval;
+			if (!check(op, l, r)) {
 				ans++;
 			} else {
-				union(op, x, y);
+				union(op, l, r);
 			}
 		}
 		out.println(ans);
diff --git a/src/class156/Code08_DetainCriminals.java b/src/class156/Code08_DetainCriminals.java
new file mode 100644
index 000000000..587050384
--- /dev/null
+++ b/src/class156/Code08_DetainCriminals.java
@@ -0,0 +1,98 @@
+package class156;
+
+// 关押罪犯
+// 测试链接 : https://www.luogu.com.cn/problem/P1525
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code08_DetainCriminals {
+
+	public static int MAXN = 20002;
+
+	public static int MAXM = 100001;
+
+	public static int n, m;
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] enemy = new int[MAXN];
+
+	public static int[][] arr = new int[MAXM][3];
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			enemy[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		father[i] = father[i] == i ? i : find(father[i]);
+		return father[i];
+	}
+
+	public static void union(int l, int r) {
+		father[find(l)] = find(r);
+	}
+
+	public static boolean same(int l, int r) {
+		return find(l) == find(r);
+	}
+
+	public static int compute() {
+		Arrays.sort(arr, 1, m + 1, (a, b) -> b[2] - a[2]);
+		int ans = 0;
+		for (int i = 1, l, r, v; i <= m; i++) {
+			l = arr[i][0];
+			r = arr[i][1];
+			v = arr[i][2];
+			if (same(l, r)) {
+				ans = v;
+				break;
+			} else {
+				if (enemy[l] == 0) {
+					enemy[l] = r;
+				} else {
+					union(enemy[l], r);
+				}
+				if (enemy[r] == 0) {
+					enemy[r] = l;
+				} else {
+					union(l, enemy[r]);
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		prepare();
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			arr[i][0] = (int) in.nval;
+			in.nextToken();
+			arr[i][1] = (int) in.nval;
+			in.nextToken();
+			arr[i][2] = (int) in.nval;
+		}
+		out.println(compute());
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 1c30bf0e74940f71a5cbd67ec6d7f31e029061bf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Jan 2025 21:19:37 +0800
Subject: [PATCH 0309/1712] modify code

---
 ...odChainTrueOrFalse.java => Code06_FoodChainTrueOrFalse.java} | 2 +-
 ...{Code08_DetainCriminals.java => Code07_DetainCriminals.java} | 2 +-
 .../{Code06_ExclusiveOR.java => Code08_ExclusiveOR.java}        | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class156/{Code07_FoodChainTrueOrFalse.java => Code06_FoodChainTrueOrFalse.java} (97%)
 rename src/class156/{Code08_DetainCriminals.java => Code07_DetainCriminals.java} (98%)
 rename src/class156/{Code06_ExclusiveOR.java => Code08_ExclusiveOR.java} (99%)

diff --git a/src/class156/Code07_FoodChainTrueOrFalse.java b/src/class156/Code06_FoodChainTrueOrFalse.java
similarity index 97%
rename from src/class156/Code07_FoodChainTrueOrFalse.java
rename to src/class156/Code06_FoodChainTrueOrFalse.java
index 7ef305e59..026ba3e60 100644
--- a/src/class156/Code07_FoodChainTrueOrFalse.java
+++ b/src/class156/Code06_FoodChainTrueOrFalse.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code07_FoodChainTrueOrFalse {
+public class Code06_FoodChainTrueOrFalse {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class156/Code08_DetainCriminals.java b/src/class156/Code07_DetainCriminals.java
similarity index 98%
rename from src/class156/Code08_DetainCriminals.java
rename to src/class156/Code07_DetainCriminals.java
index 587050384..a7c5031bb 100644
--- a/src/class156/Code08_DetainCriminals.java
+++ b/src/class156/Code07_DetainCriminals.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code08_DetainCriminals {
+public class Code07_DetainCriminals {
 
 	public static int MAXN = 20002;
 
diff --git a/src/class156/Code06_ExclusiveOR.java b/src/class156/Code08_ExclusiveOR.java
similarity index 99%
rename from src/class156/Code06_ExclusiveOR.java
rename to src/class156/Code08_ExclusiveOR.java
index 88799afce..5d86f21bd 100644
--- a/src/class156/Code06_ExclusiveOR.java
+++ b/src/class156/Code08_ExclusiveOR.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code06_ExclusiveOR {
+public class Code08_ExclusiveOR {
 
 	public static int MAXN = 20002;
 

From 74ffec87365a35646d9c1a2cbc3dde703f9fa4e0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Jan 2025 21:22:18 +0800
Subject: [PATCH 0310/1712] modify code

---
 ...6_FoodChainTrueOrFalse.java => Code06_JudgeFoodChain.java} | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
 rename src/class156/{Code06_FoodChainTrueOrFalse.java => Code06_JudgeFoodChain.java} (96%)

diff --git a/src/class156/Code06_FoodChainTrueOrFalse.java b/src/class156/Code06_JudgeFoodChain.java
similarity index 96%
rename from src/class156/Code06_FoodChainTrueOrFalse.java
rename to src/class156/Code06_JudgeFoodChain.java
index 026ba3e60..a53101674 100644
--- a/src/class156/Code06_FoodChainTrueOrFalse.java
+++ b/src/class156/Code06_JudgeFoodChain.java
@@ -1,6 +1,6 @@
 package class156;
 
-// 食物链真假判断
+// 甄别食物链
 // 测试链接 : https://www.luogu.com.cn/problem/P2024
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_FoodChainTrueOrFalse {
+public class Code06_JudgeFoodChain {
 
 	public static int MAXN = 50001;
 

From 6299637770d500854df13da203a08bc309f6292d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Jan 2025 21:33:03 +0800
Subject: [PATCH 0311/1712] modify code

---
 src/class156/Code08_ExclusiveOR.java | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/class156/Code08_ExclusiveOR.java b/src/class156/Code08_ExclusiveOR.java
index 5d86f21bd..4ebc0fe72 100644
--- a/src/class156/Code08_ExclusiveOR.java
+++ b/src/class156/Code08_ExclusiveOR.java
@@ -3,6 +3,7 @@
 // 异或关系
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=3234
 // 测试链接 : https://www.luogu.com.cn/problem/UVA12232
+// 测试链接 : https://vjudge.net/problem/UVA-12232
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
@@ -117,16 +118,12 @@ public static void main(String[] args) throws IOException {
 				if (op.equals("I")) {
 					int l, r, v;
 					in.numbers();
-					if (in.size == 2) {
-						l = in.a;
-						r = n;
-						v = in.b;
-					} else {
-						l = in.a;
-						r = in.b;
-						v = in.c;
-					}
 					if (!conflict) {
+						if (in.size == 2) {
+							l = in.a; r = n; v = in.b;
+						} else {
+							l = in.a; r = in.b; v = in.c;
+						}
 						if (!opi(l, r, v)) {
 							out.println("The first " + cnti + " facts are conflicting.");
 						}

From 72b87bf1485e3e8a4f5c084a4dfc06d3380833de Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Jan 2025 21:44:49 +0800
Subject: [PATCH 0312/1712] modify code

---
 src/class156/Code08_ExclusiveOR.java | 34 +++++++++-------------------
 1 file changed, 11 insertions(+), 23 deletions(-)

diff --git a/src/class156/Code08_ExclusiveOR.java b/src/class156/Code08_ExclusiveOR.java
index 4ebc0fe72..d740f1756 100644
--- a/src/class156/Code08_ExclusiveOR.java
+++ b/src/class156/Code08_ExclusiveOR.java
@@ -50,37 +50,25 @@ public static int find(int i) {
 		return father[i];
 	}
 
-	public static void union(int l, int r, int v) {
+	public static boolean opi(int l, int r, int v) {
+		cnti++;
 		int lf = find(l), rf = find(r);
-		if (lf == n) {
-			lf = rf;
-			rf = n;
-		}
-		if (lf != rf) {
-			father[lf] = rf;
-			exclu[lf] = exclu[r] ^ exclu[l] ^ v;
-		}
-	}
-
-	public static boolean check(int l, int r, int v) {
-		if (find(l) == find(r)) {
+		if (lf == rf) {
 			if ((exclu[l] ^ exclu[r]) != v) {
+				conflict = true;
 				return false;
 			}
+		} else {
+			if (lf == n) {
+				lf = rf;
+				rf = n;
+			}
+			father[lf] = rf;
+			exclu[lf] = exclu[r] ^ exclu[l] ^ v;
 		}
 		return true;
 	}
 
-	public static boolean opi(int l, int r, int v) {
-		cnti++;
-		if (!check(l, r, v)) {
-			conflict = true;
-			return false;
-		}
-		union(l, r, v);
-		return true;
-	}
-
 	public static int opq(int k) {
 		int ans = 0, ci = 0, fa;
 		for (int i = 1; i <= k; i++) {

From 6564ad31dac7f7366330dbc765d5f0a88e900456 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Jan 2025 12:34:13 +0800
Subject: [PATCH 0313/1712] modify code

---
 src/class156/Code01_DerivePartialSums.java |  7 +++++++
 src/class156/Code02_CunningMerchant.java   |  7 +++++++
 src/class156/Code03_WrongAnswers.java      |  7 +++++++
 src/class156/Code04_LegendOfHeroes.java    | 13 +++++++++++--
 src/class156/Code05_EvaluateDivision.java  |  9 +++++++++
 src/class156/Code06_JudgeFoodChain.java    | 12 ++++++++++++
 6 files changed, 53 insertions(+), 2 deletions(-)

diff --git a/src/class156/Code01_DerivePartialSums.java b/src/class156/Code01_DerivePartialSums.java
index 7cc8ba7e2..121de8b3d 100644
--- a/src/class156/Code01_DerivePartialSums.java
+++ b/src/class156/Code01_DerivePartialSums.java
@@ -1,6 +1,13 @@
 package class156;
 
 // 推导部分和
+// 有n个数字，下标1 ~ n，但是并不知道每个数字是多少
+// 先给出m个数字段的累加和，再查询q个数字段的累加和
+// 给出数字段累加和的操作 l r v，代表l~r范围上的数字，累加和为v
+// 查询数字段累加和的操作 l r，代表查询l~r范围上的数字累加和
+// 请根据m个给定，完成q个查询，如果某个查询无法给出答案，打印"UNKNOWN"
+// 1 <= n, m, q <= 10^5
+// 累加和不会超过long类型范围
 // 测试链接 : https://www.luogu.com.cn/problem/P8779
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class156/Code02_CunningMerchant.java b/src/class156/Code02_CunningMerchant.java
index 1f4037bf1..25f64058f 100644
--- a/src/class156/Code02_CunningMerchant.java
+++ b/src/class156/Code02_CunningMerchant.java
@@ -1,6 +1,13 @@
 package class156;
 
 // 狡猾的商人
+// 有n个月的收入，下标1 ~ n，但是并不知道每个月收入是多少
+// 操作 l r v，代表从第l个月到第r个月，总收入为v
+// 一共给你m个操作，请判断给定的数据是自洽还是自相矛盾
+// 自洽打印true，自相矛盾打印false
+// 1 <= n <= 100
+// 1 <= m <= 1000
+// 总收入不会超过int类型范围
 // 测试链接 : https://www.luogu.com.cn/problem/P2294
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class156/Code03_WrongAnswers.java b/src/class156/Code03_WrongAnswers.java
index 3da2a3637..a7c0c2637 100644
--- a/src/class156/Code03_WrongAnswers.java
+++ b/src/class156/Code03_WrongAnswers.java
@@ -1,6 +1,13 @@
 package class156;
 
 // 错误答案数量
+// 有n个数字，下标1 ~ n，但是并不知道每个数字是多少
+// 操作 l r v，代表l~r范围上累加和为v
+// 一共m个操作，如果某个操作和之前的操作信息自相矛盾，认为当前操作是错误的，不进行这个操作
+// 最后打印错误操作的数量
+// 1 <= n <= 200000
+// 1 <= m <= 40000
+// 累加和不会超过int类型范围
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=3038
 // 测试链接 : https://vjudge.net/problem/HDU-3038
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class156/Code04_LegendOfHeroes.java b/src/class156/Code04_LegendOfHeroes.java
index 3c96f73ab..117f2c31e 100644
--- a/src/class156/Code04_LegendOfHeroes.java
+++ b/src/class156/Code04_LegendOfHeroes.java
@@ -1,6 +1,15 @@
 package class156;
 
 // 银河英雄传说
+// 一共有30000搜战舰，编号1~30000，一开始每艘战舰各自成一队
+// 如果若干战舰变成一队，那么队伍里的所有战舰竖直地排成一列
+// 实现如下两种操作，操作一共调用t次
+// M l r : 合并l号战舰所在队伍和r号战舰所在队伍
+//         l号战舰的队伍，整体移动到，r号战舰所在队伍的最末尾战舰的后面
+//         如果l号战舰和r号战舰已经是一队，不进行任何操作
+// C l r : 如果l号战舰和r号战舰不在一个队伍，打印-1
+//         如果l号战舰和r号战舰在一个队伍，打印它俩中间隔着几艘战舰
+// 1 <= t <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P1196
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -70,9 +79,9 @@ public static int query(int l, int r) {
 	public static void main(String[] args) {
 		prepare();
 		Kattio io = new Kattio();
-		int m = io.nextInt();
+		int t = io.nextInt();
 		String op;
-		for (int i = 1, l, r; i <= m; i++) {
+		for (int i = 1, l, r; i <= t; i++) {
 			op = io.next();
 			l = io.nextInt();
 			r = io.nextInt();
diff --git a/src/class156/Code05_EvaluateDivision.java b/src/class156/Code05_EvaluateDivision.java
index d5365e2f2..7e3f0d7c0 100644
--- a/src/class156/Code05_EvaluateDivision.java
+++ b/src/class156/Code05_EvaluateDivision.java
@@ -4,6 +4,15 @@
 import java.util.List;
 
 // 除法求值
+// 所有变量都用字符串表示，并且给定若干组等式
+// 比如等式
+// ["ab", "ef"] = 8，代表ab / ef = 8
+// ["ct", "ef"] = 2，代表ct / ef = 2
+// 所有等式都是正确的并且可以进行推断，给定所有等式之后，会给你若干条查询
+// 比如查询，["ab", "ct"]，根据上面的等式推断，ab / ct = 4
+// 如果某条查询中的变量，从来没在等式中出现过，认为答案是-1.0
+// 如果某条查询的答案根本推断不出来，认为答案是-1.0
+// 返回所有查询的答案
 // 测试链接 : https://leetcode.cn/problems/evaluate-division/
 public class Code05_EvaluateDivision {
 
diff --git a/src/class156/Code06_JudgeFoodChain.java b/src/class156/Code06_JudgeFoodChain.java
index a53101674..998c792eb 100644
--- a/src/class156/Code06_JudgeFoodChain.java
+++ b/src/class156/Code06_JudgeFoodChain.java
@@ -1,6 +1,18 @@
 package class156;
 
 // 甄别食物链
+// 一共有n只动物，编号1 ~ n，每只动物的类别未知，但一定是A、B、C中的一种
+// 这三种类别是轮流捕食的关系，A吃B、B吃C、C吃A
+// 一共有k句话，希望你判断哪些话是假话，每句话是如下两类句子中的一类
+// 1 X Y : 第X只动物和第Y只动物是同类
+// 2 X Y : 第X只动物吃第Y只动物
+// 假话的标准如下
+// 当前的话与前面的某些真话冲突，视为假话
+// 当前的话提到的X和Y，有任何一个大于n，视为假话
+// 当前的话如果关于吃，又有X==Y，视为假话
+// 返回k句话中，假话的数量
+// 1 <= n <= 5 * 10^4
+// 1 <= k <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2024
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 905758749fe69161b1ec16afc375a1c6024b17c5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Jan 2025 14:51:28 +0800
Subject: [PATCH 0314/1712] modify code

---
 src/class156/Code02_CunningMerchant.java      |   3 +-
 src/class156/Code03_WrongAnswers.java         |   3 +-
 src/class156/Code06_JudgeFoodChain.java       |   3 +-
 src/class156/Code07_DetainCriminals.java      |   6 +
 src/class156/Code08_Gangster.java             | 133 ++++++++++++++++++
 ...clusiveOR.java => Code09_ExclusiveOR.java} |  41 +++---
 6 files changed, 167 insertions(+), 22 deletions(-)
 create mode 100644 src/class156/Code08_Gangster.java
 rename src/class156/{Code08_ExclusiveOR.java => Code09_ExclusiveOR.java} (81%)

diff --git a/src/class156/Code02_CunningMerchant.java b/src/class156/Code02_CunningMerchant.java
index 25f64058f..171592321 100644
--- a/src/class156/Code02_CunningMerchant.java
+++ b/src/class156/Code02_CunningMerchant.java
@@ -5,8 +5,7 @@
 // 操作 l r v，代表从第l个月到第r个月，总收入为v
 // 一共给你m个操作，请判断给定的数据是自洽还是自相矛盾
 // 自洽打印true，自相矛盾打印false
-// 1 <= n <= 100
-// 1 <= m <= 1000
+// 1 <= n <= 100    1 <= m <= 1000
 // 总收入不会超过int类型范围
 // 测试链接 : https://www.luogu.com.cn/problem/P2294
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class156/Code03_WrongAnswers.java b/src/class156/Code03_WrongAnswers.java
index a7c0c2637..d1026aa49 100644
--- a/src/class156/Code03_WrongAnswers.java
+++ b/src/class156/Code03_WrongAnswers.java
@@ -5,8 +5,7 @@
 // 操作 l r v，代表l~r范围上累加和为v
 // 一共m个操作，如果某个操作和之前的操作信息自相矛盾，认为当前操作是错误的，不进行这个操作
 // 最后打印错误操作的数量
-// 1 <= n <= 200000
-// 1 <= m <= 40000
+// 1 <= n <= 200000    1 <= m <= 40000
 // 累加和不会超过int类型范围
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=3038
 // 测试链接 : https://vjudge.net/problem/HDU-3038
diff --git a/src/class156/Code06_JudgeFoodChain.java b/src/class156/Code06_JudgeFoodChain.java
index 998c792eb..c83586afa 100644
--- a/src/class156/Code06_JudgeFoodChain.java
+++ b/src/class156/Code06_JudgeFoodChain.java
@@ -11,8 +11,7 @@
 // 当前的话提到的X和Y，有任何一个大于n，视为假话
 // 当前的话如果关于吃，又有X==Y，视为假话
 // 返回k句话中，假话的数量
-// 1 <= n <= 5 * 10^4
-// 1 <= k <= 10^5
+// 1 <= n <= 5 * 10^4    1 <= k <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2024
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class156/Code07_DetainCriminals.java b/src/class156/Code07_DetainCriminals.java
index a7c5031bb..a34e9616e 100644
--- a/src/class156/Code07_DetainCriminals.java
+++ b/src/class156/Code07_DetainCriminals.java
@@ -1,6 +1,12 @@
 package class156;
 
 // 关押罪犯
+// 一共有n个犯人，编号1 ~ n，一共有两个监狱，你可以决定每个犯人去哪个监狱
+// 给定m条记录，每条记录 l r v，表示l号犯人和r号犯人的仇恨值
+// 每个监狱的暴力值 = 该监狱中仇恨最深的犯人之间的仇恨值
+// 冲突值 = max(第一座监狱的暴力值，第二座监狱的暴力值)
+// 犯人的分配方案需要让这个冲突值最小，返回最小能是多少
+// 1 <= n <= 20000    1 <= m <= 100000    1 <= 仇恨值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1525
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class156/Code08_Gangster.java b/src/class156/Code08_Gangster.java
new file mode 100644
index 000000000..99a42b6ca
--- /dev/null
+++ b/src/class156/Code08_Gangster.java
@@ -0,0 +1,133 @@
+package class156;
+
+// 团伙
+// 注意洛谷关于本题的描述有问题，请按照如下的描述来理解题意
+// 一共有n个黑帮成员，编号1 ~ n，发现了m条事实，每条事实一定属于如下两种类型中的一种
+// F l r : l号成员和r号成员是朋友
+// E l r : l号成员和r号成员是敌人
+// 黑帮遵守如下的约定
+// 我的敌人的敌人一定是我的朋友
+// 彼此是朋友的成员一定来自一个黑帮
+// 彼此是敌人的成员一定不来自一个黑帮
+// 如果根据事实无法推断出一个成员有哪些朋友，那么该成员自己是一个黑帮
+// 输入数据不存在矛盾，也就是任何两人不会推出既是朋友又是敌人的结论
+// 遵守上面的约定，根据m条事实，计算黑帮有多少个
+// 1 <= n <= 1000    1 <= m <= 5000
+// 测试链接 : https://www.luogu.com.cn/problem/P1892
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code08_Gangster {
+
+	public static int MAXN = 1001;
+
+	public static int n, m;
+
+	public static int[] father = new int[MAXN];
+
+	public static int[] enemy = new int[MAXN];
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			enemy[i] = 0;
+		}
+	}
+
+	public static int find(int i) {
+		father[i] = father[i] == i ? i : find(father[i]);
+		return father[i];
+	}
+
+	public static void union(int l, int r) {
+		father[find(l)] = find(r);
+	}
+
+	public static void main(String[] args) throws IOException {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		m = io.nextInt();
+		prepare();
+		String op;
+		int l, r;
+		for (int i = 1; i <= m; i++) {
+			op = io.next();
+			l = io.nextInt();
+			r = io.nextInt();
+			if (op.equals("F")) {
+				union(l, r);
+			} else {
+				if (enemy[l] == 0) {
+					enemy[l] = r;
+				} else {
+					union(enemy[l], r);
+				}
+				if (enemy[r] == 0) {
+					enemy[r] = l;
+				} else {
+					union(l, enemy[r]);
+				}
+			}
+		}
+		int ans = 0;
+		for (int i = 1; i <= n; i++) {
+			if (i == father[i]) {
+				ans++;
+			}
+		}
+		io.println(ans);
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class156/Code08_ExclusiveOR.java b/src/class156/Code09_ExclusiveOR.java
similarity index 81%
rename from src/class156/Code08_ExclusiveOR.java
rename to src/class156/Code09_ExclusiveOR.java
index d740f1756..0e79be3c1 100644
--- a/src/class156/Code08_ExclusiveOR.java
+++ b/src/class156/Code09_ExclusiveOR.java
@@ -1,6 +1,15 @@
 package class156;
 
 // 异或关系
+// 一共n个数，编号0 ~ n-1，实现如下三种类型的操作，一共调用m次
+// I x v        : 声明 第x个数 = v
+// I x y v      : 声明 第x个数 ^ 第y个数 = v
+// Q k a1 .. ak : 查询 一共k个数，编号为a1 .. ak，这些数字异或起来的值是多少
+// 对每个Q的操作打印答案，如果根据之前的声明无法推出答案，打印"I don't know."
+// 如果处理到第s条声明，发现了矛盾，打印"The first s facts are conflicting."
+// 注意只有声明操作出现，s才会增加，查询操作不占用声明操作的计数
+// 发现矛盾之后，所有的操作都不再处理，更多的细节可以打开测试链接查看题目
+// 1 <= n <= 20000    1 <= m <= 40000    1 <= k <= 15
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=3234
 // 测试链接 : https://www.luogu.com.cn/problem/UVA12232
 // 测试链接 : https://vjudge.net/problem/UVA-12232
@@ -12,7 +21,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code08_ExclusiveOR {
+public class Code09_ExclusiveOR {
 
 	public static int MAXN = 20002;
 
@@ -30,7 +39,7 @@ public class Code08_ExclusiveOR {
 
 	public static int[] nums = new int[MAXK];
 
-	public static int[] collect = new int[MAXK];
+	public static int[] fas = new int[MAXK];
 
 	public static void prepare() {
 		conflict = false;
@@ -70,23 +79,19 @@ public static boolean opi(int l, int r, int v) {
 	}
 
 	public static int opq(int k) {
-		int ans = 0, ci = 0, fa;
-		for (int i = 1; i <= k; i++) {
+		int ans = 0;
+		for (int i = 1, fa; i <= k; i++) {
 			fa = find(nums[i]);
 			ans ^= exclu[nums[i]];
-			collect[++ci] = fa;
+			fas[i] = fa;
 		}
-		Arrays.sort(collect, 1, ci + 1);
-		for (int l = 1, r = 1; l <= ci; l = ++r) {
-			while (r + 1 <= ci && collect[r + 1] == collect[l]) {
+		Arrays.sort(fas, 1, k + 1);
+		for (int l = 1, r = 1; l <= k; l = ++r) {
+			while (r + 1 <= k && fas[r + 1] == fas[l]) {
 				r++;
 			}
-			if ((r - l + 1) % 2 != 0) {
-				if (collect[l] == n) {
-					ans ^= exclu[n];
-				} else {
-					return -1;
-				}
+			if ((r - l + 1) % 2 != 0 && fas[l] != n) {
+				return -1;
 			}
 		}
 		return ans;
@@ -108,9 +113,13 @@ public static void main(String[] args) throws IOException {
 					in.numbers();
 					if (!conflict) {
 						if (in.size == 2) {
-							l = in.a; r = n; v = in.b;
+							l = in.a;
+							r = n;
+							v = in.b;
 						} else {
-							l = in.a; r = in.b; v = in.c;
+							l = in.a;
+							r = in.b;
+							v = in.c;
 						}
 						if (!opi(l, r, v)) {
 							out.println("The first " + cnti + " facts are conflicting.");

From f2bc94a040132e63c01914d30e048e57ecce7932 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Jan 2025 15:16:22 +0800
Subject: [PATCH 0315/1712] modify code

---
 src/class156/Code01_DerivePartialSums.java | 2 +-
 src/class156/Code02_CunningMerchant.java   | 2 +-
 src/class156/Code03_WrongAnswers.java      | 2 +-
 src/class156/Code06_JudgeFoodChain.java    | 4 +---
 src/class156/Code08_Gangster.java          | 5 +----
 5 files changed, 5 insertions(+), 10 deletions(-)

diff --git a/src/class156/Code01_DerivePartialSums.java b/src/class156/Code01_DerivePartialSums.java
index 121de8b3d..db34f2966 100644
--- a/src/class156/Code01_DerivePartialSums.java
+++ b/src/class156/Code01_DerivePartialSums.java
@@ -1,6 +1,6 @@
 package class156;
 
-// 推导部分和
+// 推导部分和，带权并查集模版题1
 // 有n个数字，下标1 ~ n，但是并不知道每个数字是多少
 // 先给出m个数字段的累加和，再查询q个数字段的累加和
 // 给出数字段累加和的操作 l r v，代表l~r范围上的数字，累加和为v
diff --git a/src/class156/Code02_CunningMerchant.java b/src/class156/Code02_CunningMerchant.java
index 171592321..17b13643d 100644
--- a/src/class156/Code02_CunningMerchant.java
+++ b/src/class156/Code02_CunningMerchant.java
@@ -1,6 +1,6 @@
 package class156;
 
-// 狡猾的商人
+// 狡猾的商人，带权并查集模版题2
 // 有n个月的收入，下标1 ~ n，但是并不知道每个月收入是多少
 // 操作 l r v，代表从第l个月到第r个月，总收入为v
 // 一共给你m个操作，请判断给定的数据是自洽还是自相矛盾
diff --git a/src/class156/Code03_WrongAnswers.java b/src/class156/Code03_WrongAnswers.java
index d1026aa49..c6d1c0957 100644
--- a/src/class156/Code03_WrongAnswers.java
+++ b/src/class156/Code03_WrongAnswers.java
@@ -1,6 +1,6 @@
 package class156;
 
-// 错误答案数量
+// 错误答案数量，带权并查集模版题3
 // 有n个数字，下标1 ~ n，但是并不知道每个数字是多少
 // 操作 l r v，代表l~r范围上累加和为v
 // 一共m个操作，如果某个操作和之前的操作信息自相矛盾，认为当前操作是错误的，不进行这个操作
diff --git a/src/class156/Code06_JudgeFoodChain.java b/src/class156/Code06_JudgeFoodChain.java
index c83586afa..866c9eeb7 100644
--- a/src/class156/Code06_JudgeFoodChain.java
+++ b/src/class156/Code06_JudgeFoodChain.java
@@ -1,12 +1,10 @@
 package class156;
 
 // 甄别食物链
-// 一共有n只动物，编号1 ~ n，每只动物的类别未知，但一定是A、B、C中的一种
-// 这三种类别是轮流捕食的关系，A吃B、B吃C、C吃A
+// 一共有n只动物，编号1 ~ n，每只动物都是A、B、C中的一种，A吃B、B吃C、C吃A
 // 一共有k句话，希望你判断哪些话是假话，每句话是如下两类句子中的一类
 // 1 X Y : 第X只动物和第Y只动物是同类
 // 2 X Y : 第X只动物吃第Y只动物
-// 假话的标准如下
 // 当前的话与前面的某些真话冲突，视为假话
 // 当前的话提到的X和Y，有任何一个大于n，视为假话
 // 当前的话如果关于吃，又有X==Y，视为假话
diff --git a/src/class156/Code08_Gangster.java b/src/class156/Code08_Gangster.java
index 99a42b6ca..5bbf71528 100644
--- a/src/class156/Code08_Gangster.java
+++ b/src/class156/Code08_Gangster.java
@@ -5,10 +5,7 @@
 // 一共有n个黑帮成员，编号1 ~ n，发现了m条事实，每条事实一定属于如下两种类型中的一种
 // F l r : l号成员和r号成员是朋友
 // E l r : l号成员和r号成员是敌人
-// 黑帮遵守如下的约定
-// 我的敌人的敌人一定是我的朋友
-// 彼此是朋友的成员一定来自一个黑帮
-// 彼此是敌人的成员一定不来自一个黑帮
+// 黑帮遵守如下的约定，敌人的敌人一定是朋友，朋友都来自同一个黑帮，敌人一定不是同一个黑帮
 // 如果根据事实无法推断出一个成员有哪些朋友，那么该成员自己是一个黑帮
 // 输入数据不存在矛盾，也就是任何两人不会推出既是朋友又是敌人的结论
 // 遵守上面的约定，根据m条事实，计算黑帮有多少个

From eaf4011eaff933639945f6f5001b0bcc51cb3f5d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Jan 2025 21:22:46 +0800
Subject: [PATCH 0316/1712] modify code

---
 src/class156/Code06_JudgeFoodChain.java | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/class156/Code06_JudgeFoodChain.java b/src/class156/Code06_JudgeFoodChain.java
index 866c9eeb7..f9685b8d7 100644
--- a/src/class156/Code06_JudgeFoodChain.java
+++ b/src/class156/Code06_JudgeFoodChain.java
@@ -28,13 +28,16 @@ public class Code06_JudgeFoodChain {
 
 	public static int[] father = new int[MAXN];
 
-	public static int[] relation = new int[MAXN];
+	// dist[i] = 0，代表i和头是同类
+	// dist[i] = 1，代表i吃头
+	// dist[i] = 2，代表i被头吃
+	public static int[] dist = new int[MAXN];
 
 	public static void prepare() {
 		ans = 0;
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
-			relation[i] = 0;
+			dist[i] = 0;
 		}
 	}
 
@@ -42,16 +45,18 @@ public static int find(int i) {
 		if (i != father[i]) {
 			int tmp = father[i];
 			father[i] = find(tmp);
-			relation[i] = (relation[i] + relation[tmp]) % 3;
+			dist[i] = (dist[i] + dist[tmp]) % 3;
 		}
 		return father[i];
 	}
 
+	// op == 1, 1 l r，l和r是同类
+	// op == 2, 2 l r，l吃r
 	public static void union(int op, int l, int r) {
 		int lf = find(l), rf = find(r), v = op == 1 ? 0 : 1;
 		if (lf != rf) {
 			father[lf] = rf;
-			relation[lf] = (relation[r] - relation[l] + v + 3) % 3;
+			dist[lf] = (dist[r] - dist[l] + v + 3) % 3;
 		}
 	}
 
@@ -61,11 +66,11 @@ public static boolean check(int op, int l, int r) {
 		}
 		if (find(l) == find(r)) {
 			if (op == 1) {
-				if (relation[l] != relation[r]) {
+				if (dist[l] != dist[r]) {
 					return false;
 				}
 			} else {
-				if ((relation[l] - relation[r] + 3) % 3 != 1) {
+				if ((dist[l] - dist[r] + 3) % 3 != 1) {
 					return false;
 				}
 			}

From 9d77b9b7beb27beece9cccc5b2dd05dde77085f2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Jan 2025 23:24:52 +0800
Subject: [PATCH 0317/1712] modify code

---
 ...51\345\261\225\351\242\230\347\233\256.pptx" | Bin 0 -> 56553 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243156\343\200\220\346\214\272\351\232\276\343\200\221\345\270\246\346\235\203\345\271\266\346\237\245\351\233\206\347\232\204\345\216\237\347\220\206\345\222\214\346\211\251\345\261\225\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243156\343\200\220\346\214\272\351\232\276\343\200\221\345\270\246\346\235\203\345\271\266\346\237\245\351\233\206\347\232\204\345\216\237\347\220\206\345\222\214\346\211\251\345\261\225\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243156\343\200\220\346\214\272\351\232\276\343\200\221\345\270\246\346\235\203\345\271\266\346\237\245\351\233\206\347\232\204\345\216\237\347\220\206\345\222\214\346\211\251\345\261\225\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..85e5b81674a1e2e479f46b210e1eff0e3ab55dd4
GIT binary patch
literal 56553
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%0ABoXk#4(<HPgPPfyhFx
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
EFF=7@r~m)}

literal 0
HcmV?d00001


From 5f60924a2993587c0063e27870f1576f22f2a0f5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Jan 2025 16:29:08 +0800
Subject: [PATCH 0318/1712] modify code

---
 .../Code01_PersistentSegmentTree.java         | 135 +++++++++++++
 .../Code02_SmallestMissingNaturalNumber.java  | 101 +++++++++
 src/class157/Code03_LargestMedian.java        | 191 ++++++++++++++++++
 3 files changed, 427 insertions(+)
 create mode 100644 src/class157/Code01_PersistentSegmentTree.java
 create mode 100644 src/class157/Code02_SmallestMissingNaturalNumber.java
 create mode 100644 src/class157/Code03_LargestMedian.java

diff --git a/src/class157/Code01_PersistentSegmentTree.java b/src/class157/Code01_PersistentSegmentTree.java
new file mode 100644
index 000000000..3e1e0ab45
--- /dev/null
+++ b/src/class157/Code01_PersistentSegmentTree.java
@@ -0,0 +1,135 @@
+package class157;
+
+// 可持久化线段树模版题
+// 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code01_PersistentSegmentTree {
+
+	public static int MAXN = 200001;
+
+	public static int MAXM = MAXN * 22;
+
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] sort = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	public static int[] count = new int[MAXM];
+
+	public static int cnt;
+
+	public static void prepare() {
+		cnt = 0;
+		for (int i = 1; i <= n; i++) {
+			sort[i] = arr[i];
+		}
+		Arrays.sort(sort, 1, n + 1);
+		root[0] = build(1, n);
+	}
+
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		count[rt] = 0;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int rank(int v) {
+		int l = 1;
+		int r = n;
+		int m = 0;
+		int ans = 0;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (sort[m] <= v) {
+				ans = m;
+				l = m + 1;
+			} else {
+				r = m - 1;
+			}
+		}
+		return ans;
+	}
+
+	public static int insert(int p, int l, int r, int x) {
+		int rt = ++cnt;
+		left[rt] = left[p];
+		right[rt] = right[p];
+		count[rt] = count[p] + 1;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			if (x <= mid) {
+				left[rt] = insert(left[p], l, mid, x);
+			} else {
+				right[rt] = insert(right[p], mid + 1, r, x);
+			}
+		}
+		return rt;
+	}
+
+	public static int query(int u, int v, int k, int l, int r) {
+		if (l == r) {
+			return l;
+		}
+		int lcount = count[left[v]] - count[left[u]];
+		int mid = (l + r) / 2;
+		if (lcount >= k) {
+			return query(left[u], left[v], k, l, mid);
+		} else {
+			return query(right[u], right[v], k - lcount, mid + 1, r);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		prepare();
+		for (int i = 1, x; i <= n; i++) {
+			x = rank(arr[i]);
+			root[i] = insert(root[i - 1], 1, n, x);
+		}
+		for (int i = 1, l, r, k; i <= m; i++) {
+			in.nextToken();
+			l = (int) in.nval;
+			in.nextToken();
+			r = (int) in.nval;
+			in.nextToken();
+			k = (int) in.nval;
+			int ans = query(root[l - 1], root[r], k, 1, n);
+			out.println(sort[ans]);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class157/Code02_SmallestMissingNaturalNumber.java b/src/class157/Code02_SmallestMissingNaturalNumber.java
new file mode 100644
index 000000000..de34b2be3
--- /dev/null
+++ b/src/class157/Code02_SmallestMissingNaturalNumber.java
@@ -0,0 +1,101 @@
+package class157;
+
+// 区间内没有出现的最小自然数
+// 给定一个长度为n的数组arr，一共有m次询问
+// 每次查询一个区间[l, r]内没有出现过的最小自然数
+// 注意0是自然数
+// 测试链接 : https://www.luogu.com.cn/problem/P4137
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_SmallestMissingNaturalNumber {
+
+	public static int MAXN = 200001;
+
+	public static int MAXM = MAXN * 22;
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	// last[i] : l~r的信息存在last[i]
+	// 表示该范围每个数字最后出现的位置中，最左在哪
+	public static int[] lateLeft = new int[MAXM];
+
+	public static int n, m, cnt;
+
+	public static int update(int pre, int l, int r, int v, int pos) {
+		int rt = ++cnt;
+		left[rt] = left[pre];
+		right[rt] = right[pre];
+		lateLeft[rt] = lateLeft[pre];
+		if (l == r) {
+			lateLeft[rt] = pos;
+		} else {
+			int mid = (l + r) / 2;
+			if (v <= mid) {
+				left[rt] = update(left[pre], l, mid, v, pos);
+			} else {
+				right[rt] = update(right[pre], mid + 1, r, v, pos);
+			}
+			lateLeft[rt] = Math.min(lateLeft[left[rt]], lateLeft[right[rt]]);
+		}
+		return rt;
+	}
+
+	public static int query(int rt, int l, int r, int pos) {
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) / 2;
+		if (lateLeft[left[rt]] < pos) {
+			// l...mid范围上，每个数字最晚出现的位置中
+			// 最左的位置如果在pos以左，说明l...mid范围上，一定有缺失的数字
+			return query(left[rt], l, mid, pos);
+		} else {
+			// 缺失的数字一定在mid+1....r范围
+			// 因为l...r一定有缺失的数字才会来到这个范围的
+			// 如果左侧不缺失，那缺失的数字一定在右侧范围上
+			return query(right[rt], mid + 1, r, pos);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		cnt = 0;
+		for (int i = 1, v; i <= n; i++) {
+			in.nextToken();
+			v = (int) in.nval;
+			if (v >= n) {
+				root[i] = root[i - 1];
+			} else {
+				root[i] = update(root[i - 1], 0, n, v, i);
+			}
+		}
+		for (int i = 1, l, r; i <= m; i++) {
+			in.nextToken();
+			l = (int) in.nval;
+			in.nextToken();
+			r = (int) in.nval;
+			out.println(query(root[r], 0, n, l));
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class157/Code03_LargestMedian.java b/src/class157/Code03_LargestMedian.java
new file mode 100644
index 000000000..4a26cf930
--- /dev/null
+++ b/src/class157/Code03_LargestMedian.java
@@ -0,0 +1,191 @@
+package class157;
+
+// 最大的中位数
+// 测试链接 : https://www.luogu.com.cn/problem/P2839
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_LargestMedian {
+
+	public static int MAXN = 20001;
+
+	public static int MAXM = MAXN * 20;
+
+	public static int INF = 10000001;
+
+	public static int n, m;
+
+	// 原始位置、数值
+	public static int[][] arr = new int[MAXN][2];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	// 区间内最大前缀和，前缀不能为空
+	public static int[] pre = new int[MAXM];
+
+	// 区间内最大后缀和，后缀不能为空
+	public static int[] suf = new int[MAXM];
+
+	// 区间内累加和，区间为空认为累加和是0
+	public static int[] sum = new int[MAXM];
+
+	public static int cnt;
+
+	// 查询的问题，a、b、c、d
+	public static int[] ques = new int[4];
+
+	// 收集区间信息，pre、suf、sum
+	public static int[] info = new int[3];
+
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		pre[rt] = suf[rt] = sum[rt] = r - l + 1;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int clone(int i) {
+		int rt = ++cnt;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		pre[rt] = pre[i];
+		suf[rt] = suf[i];
+		sum[rt] = sum[i];
+		return rt;
+	}
+
+	public static void up(int i) {
+		pre[i] = Math.max(pre[left[i]], sum[left[i]] + pre[right[i]]);
+		suf[i] = Math.max(suf[right[i]], suf[left[i]] + sum[right[i]]);
+		sum[i] = sum[left[i]] + sum[right[i]];
+	}
+
+	public static int update(int p, int l, int r, int x) {
+		int rt = clone(p);
+		if (l == r) {
+			pre[rt] = suf[rt] = sum[rt] = -1;
+		} else {
+			int mid = (l + r) / 2;
+			if (x <= mid) {
+				left[rt] = update(left[rt], l, mid, x);
+			} else {
+				right[rt] = update(right[rt], mid + 1, r, x);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static void prepare() {
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
+		cnt = 0;
+		root[1] = build(1, n);
+		for (int i = 2; i <= n; i++) {
+			root[i] = update(root[i - 1], 1, n, arr[i - 1][0]);
+		}
+	}
+
+	public static void initInfo() {
+		info[0] = info[1] = -INF;
+		info[2] = 0;
+	}
+
+	public static void mergeRight(int r) {
+		info[0] = Math.max(info[0], info[2] + pre[r]);
+		info[1] = Math.max(suf[r], info[1] + sum[r]);
+		info[2] += sum[r];
+	}
+
+	public static void query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			mergeRight(i);
+		} else {
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				query(jobl, jobr, l, mid, left[i]);
+			}
+			if (jobr > mid) {
+				query(jobl, jobr, mid + 1, r, right[i]);
+			}
+		}
+	}
+
+	public static boolean check(int i) {
+		int a = ques[0] + 1, b = ques[1] + 1, c = ques[2] + 1, d = ques[3] + 1, best;
+		initInfo();
+		query(a, b, 1, n, root[i]);
+		best = info[1];
+		initInfo();
+		query(c, d, 1, n, root[i]);
+		best += info[0];
+		if (b + 1 <= c - 1) {
+			initInfo();
+			query(b + 1, c - 1, 1, n, root[i]);
+			best += info[2];
+		}
+		return best >= 0;
+	}
+
+	public static int compute() {
+		int left = 1, right = n, mid;
+		int ans = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (check(mid)) {
+				ans = arr[mid][1];
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = i;
+			in.nextToken();
+			arr[i][1] = (int) in.nval;
+		}
+		prepare();
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, lastAns = 0; i <= m; i++) {
+			in.nextToken();
+			ques[0] = ((int) in.nval + lastAns) % n;
+			in.nextToken();
+			ques[1] = ((int) in.nval + lastAns) % n;
+			in.nextToken();
+			ques[2] = ((int) in.nval + lastAns) % n;
+			in.nextToken();
+			ques[3] = ((int) in.nval + lastAns) % n;
+			Arrays.sort(ques);
+			lastAns = compute();
+			out.println(lastAns);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 7ecd690012235f9f976ab26064d65797759af7b7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Jan 2025 20:52:33 +0800
Subject: [PATCH 0319/1712] modify code

---
 src/class157/Code04_CountOnTree.java | 256 +++++++++++++++++++++++++++
 1 file changed, 256 insertions(+)
 create mode 100644 src/class157/Code04_CountOnTree.java

diff --git a/src/class157/Code04_CountOnTree.java b/src/class157/Code04_CountOnTree.java
new file mode 100644
index 000000000..94e13bb61
--- /dev/null
+++ b/src/class157/Code04_CountOnTree.java
@@ -0,0 +1,256 @@
+package class157;
+
+// 两节点间第k小值
+// 测试链接 : https://www.luogu.com.cn/problem/P2633
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code04_CountOnTree {
+
+	public static int MAXN = 100001;
+
+	public static int MAXH = 20;
+
+	public static int MAXM = MAXN * MAXH;
+
+	public static int n, s, m;
+
+	// 各个节点权值
+	public static int[] arr = new int[MAXN];
+
+	// 收集权值排序做离散化
+	public static int[] sort = new int[MAXN];
+
+	// 链式前向星需要
+	public static int[] head = new int[MAXN];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	// 可持久化线段树
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	public static int[] count = new int[MAXM];
+
+	public static int cntt = 0;
+
+	// 树上倍增找lca需要
+	public static int[] deep = new int[MAXN];
+
+	public static int[][] stjump = new int[MAXN][MAXH];
+
+	public static int rank(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sort[mid] == num) {
+				return mid;
+			} else if (sort[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static int build(int l, int r) {
+		int rt = ++cntt;
+		count[rt] = 0;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sort[i] = arr[i];
+		}
+		Arrays.sort(sort, 1, n + 1);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sort[s] != sort[i]) {
+				sort[++s] = sort[i];
+			}
+		}
+		root[0] = build(1, s);
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int insert(int p, int l, int r, int x) {
+		int rt = ++cntt;
+		left[rt] = left[p];
+		right[rt] = right[p];
+		count[rt] = count[p] + 1;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			if (x <= mid) {
+				left[rt] = insert(left[rt], l, mid, x);
+			} else {
+				right[rt] = insert(right[rt], mid + 1, r, x);
+			}
+		}
+		return rt;
+	}
+
+	public static int query(int u, int v, int fa, int fafa, int l, int r, int k) {
+		if (l == r) {
+			return l;
+		}
+		int leftCnt = count[left[u]] + count[left[v]] - count[left[fa]] - count[left[fafa]];
+		int mid = (l + r) / 2;
+		if (leftCnt >= k) {
+			return query(left[u], left[v], left[fa], left[fafa], l, mid, k);
+		} else {
+			return query(right[u], right[v], right[fa], right[fafa], mid + 1, r, k - leftCnt);
+		}
+	}
+
+	// dfs递归版，C++可以通过，java无法通过，递归会爆栈
+	public static void dfs1(int u, int f) {
+		root[u] = insert(root[f], 1, s, rank(arr[u]));
+		deep[u] = deep[f] + 1;
+		stjump[u][0] = f;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != f) {
+				dfs1(to[e], u);
+			}
+		}
+	}
+
+	// dfs迭代版，都可以通过，讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stackSize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stackSize][0] = u;
+		ufe[stackSize][1] = f;
+		ufe[stackSize][2] = e;
+		stackSize++;
+	}
+
+	public static void pop() {
+		--stackSize;
+		u = ufe[stackSize][0];
+		f = ufe[stackSize][1];
+		e = ufe[stackSize][2];
+	}
+
+	public static void dfs2() {
+		stackSize = 0;
+		push(1, 0, -1);
+		while (stackSize > 0) {
+			pop();
+			if (e == -1) {
+				root[u] = insert(root[f], 1, s, rank(arr[u]));
+				deep[u] = deep[f] + 1;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (deep[a] < deep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (deep[stjump[a][p]] >= deep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int kth(int u, int v, int k) {
+		int lca = lca(u, v);
+		int i = query(root[u], root[v], root[lca], root[stjump[lca][0]], 1, s, k);
+		return sort[i];
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		prepare();
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs2(); // 用迭代版dfs，防止爆栈
+		for (int i = 1, u, v, k, lastAns = 0; i <= m; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			in.nextToken();
+			k = (int) in.nval;
+			lastAns = kth(u ^ lastAns, v, k);
+			out.println(lastAns);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 08dfdc66f80256a4b901a99617ecd2e8dcbc504a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Jan 2025 21:05:13 +0800
Subject: [PATCH 0320/1712] modify code

---
 src/class157/Code04_CountOnTree.java | 22 +++++++++++-----------
 1 file changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/class157/Code04_CountOnTree.java b/src/class157/Code04_CountOnTree.java
index 94e13bb61..4a016cb16 100644
--- a/src/class157/Code04_CountOnTree.java
+++ b/src/class157/Code04_CountOnTree.java
@@ -20,7 +20,7 @@ public class Code04_CountOnTree {
 
 	public static int MAXM = MAXN * MAXH;
 
-	public static int n, s, m;
+	public static int n, s, q;
 
 	// 各个节点权值
 	public static int[] arr = new int[MAXN];
@@ -54,15 +54,15 @@ public class Code04_CountOnTree {
 	public static int[][] stjump = new int[MAXN][MAXH];
 
 	public static int rank(int num) {
-		int left = 1, right = s, mid;
-		while (left <= right) {
-			mid = (left + right) / 2;
-			if (sort[mid] == num) {
-				return mid;
-			} else if (sort[mid] < num) {
-				left = mid + 1;
+		int l = 1, r = s, m;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (sort[m] == num) {
+				return m;
+			} else if (sort[m] < num) {
+				l = m + 1;
 			} else {
-				right = mid - 1;
+				r = m - 1;
 			}
 		}
 		return -1;
@@ -223,7 +223,7 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		n = (int) in.nval;
 		in.nextToken();
-		m = (int) in.nval;
+		q = (int) in.nval;
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
 			arr[i] = (int) in.nval;
@@ -238,7 +238,7 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		dfs2(); // 用迭代版dfs，防止爆栈
-		for (int i = 1, u, v, k, lastAns = 0; i <= m; i++) {
+		for (int i = 1, u, v, k, lastAns = 0; i <= q; i++) {
 			in.nextToken();
 			u = (int) in.nval;
 			in.nextToken();

From b2cf6a7eaa5fc6feb89fcc65d83b581ff638b788 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Jan 2025 21:11:52 +0800
Subject: [PATCH 0321/1712] modify code

---
 .../Code01_PersistentSegmentTree.java         | 11 ++----
 .../Code02_SmallestMissingNaturalNumber.java  |  6 +--
 src/class157/Code03_LargestMedian.java        | 38 ++++++++-----------
 3 files changed, 23 insertions(+), 32 deletions(-)

diff --git a/src/class157/Code01_PersistentSegmentTree.java b/src/class157/Code01_PersistentSegmentTree.java
index 3e1e0ab45..95d177626 100644
--- a/src/class157/Code01_PersistentSegmentTree.java
+++ b/src/class157/Code01_PersistentSegmentTree.java
@@ -18,7 +18,7 @@ public class Code01_PersistentSegmentTree {
 
 	public static int MAXM = MAXN * 22;
 
-	public static int n, m;
+	public static int n, q;
 
 	public static int[] arr = new int[MAXN];
 
@@ -55,10 +55,7 @@ public static int build(int l, int r) {
 	}
 
 	public static int rank(int v) {
-		int l = 1;
-		int r = n;
-		int m = 0;
-		int ans = 0;
+		int l = 1, r = n, m, ans = 0;
 		while (l <= r) {
 			m = (l + r) / 2;
 			if (sort[m] <= v) {
@@ -107,7 +104,7 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		n = (int) in.nval;
 		in.nextToken();
-		m = (int) in.nval;
+		q = (int) in.nval;
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
 			arr[i] = (int) in.nval;
@@ -117,7 +114,7 @@ public static void main(String[] args) throws IOException {
 			x = rank(arr[i]);
 			root[i] = insert(root[i - 1], 1, n, x);
 		}
-		for (int i = 1, l, r, k; i <= m; i++) {
+		for (int i = 1, l, r, k; i <= q; i++) {
 			in.nextToken();
 			l = (int) in.nval;
 			in.nextToken();
diff --git a/src/class157/Code02_SmallestMissingNaturalNumber.java b/src/class157/Code02_SmallestMissingNaturalNumber.java
index de34b2be3..a1850c8ef 100644
--- a/src/class157/Code02_SmallestMissingNaturalNumber.java
+++ b/src/class157/Code02_SmallestMissingNaturalNumber.java
@@ -30,7 +30,7 @@ public class Code02_SmallestMissingNaturalNumber {
 	// 表示该范围每个数字最后出现的位置中，最左在哪
 	public static int[] lateLeft = new int[MAXM];
 
-	public static int n, m, cnt;
+	public static int n, q, cnt;
 
 	public static int update(int pre, int l, int r, int v, int pos) {
 		int rt = ++cnt;
@@ -75,7 +75,7 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		n = (int) in.nval;
 		in.nextToken();
-		m = (int) in.nval;
+		q = (int) in.nval;
 		cnt = 0;
 		for (int i = 1, v; i <= n; i++) {
 			in.nextToken();
@@ -86,7 +86,7 @@ public static void main(String[] args) throws IOException {
 				root[i] = update(root[i - 1], 0, n, v, i);
 			}
 		}
-		for (int i = 1, l, r; i <= m; i++) {
+		for (int i = 1, l, r; i <= q; i++) {
 			in.nextToken();
 			l = (int) in.nval;
 			in.nextToken();
diff --git a/src/class157/Code03_LargestMedian.java b/src/class157/Code03_LargestMedian.java
index 4a26cf930..f4742ad66 100644
--- a/src/class157/Code03_LargestMedian.java
+++ b/src/class157/Code03_LargestMedian.java
@@ -20,7 +20,7 @@ public class Code03_LargestMedian {
 
 	public static int INF = 10000001;
 
-	public static int n, m;
+	public static int n, q;
 
 	// 原始位置、数值
 	public static int[][] arr = new int[MAXN][2];
@@ -59,16 +59,6 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
-	public static int clone(int i) {
-		int rt = ++cnt;
-		left[rt] = left[i];
-		right[rt] = right[i];
-		pre[rt] = pre[i];
-		suf[rt] = suf[i];
-		sum[rt] = sum[i];
-		return rt;
-	}
-
 	public static void up(int i) {
 		pre[i] = Math.max(pre[left[i]], sum[left[i]] + pre[right[i]]);
 		suf[i] = Math.max(suf[right[i]], suf[left[i]] + sum[right[i]]);
@@ -76,7 +66,12 @@ public static void up(int i) {
 	}
 
 	public static int update(int p, int l, int r, int x) {
-		int rt = clone(p);
+		int rt = ++cnt;
+		left[rt] = left[p];
+		right[rt] = right[p];
+		pre[rt] = pre[p];
+		suf[rt] = suf[p];
+		sum[rt] = sum[p];
 		if (l == r) {
 			pre[rt] = suf[rt] = sum[rt] = -1;
 		} else {
@@ -142,15 +137,14 @@ public static boolean check(int i) {
 	}
 
 	public static int compute() {
-		int left = 1, right = n, mid;
-		int ans = 0;
-		while (left <= right) {
-			mid = (left + right) / 2;
-			if (check(mid)) {
-				ans = arr[mid][1];
-				left = mid + 1;
+		int l = 1, r = n, m, ans = 0;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (check(m)) {
+				ans = arr[m][1];
+				l = m + 1;
 			} else {
-				right = mid - 1;
+				r = m - 1;
 			}
 		}
 		return ans;
@@ -169,8 +163,8 @@ public static void main(String[] args) throws IOException {
 		}
 		prepare();
 		in.nextToken();
-		m = (int) in.nval;
-		for (int i = 1, lastAns = 0; i <= m; i++) {
+		q = (int) in.nval;
+		for (int i = 1, lastAns = 0; i <= q; i++) {
 			in.nextToken();
 			ques[0] = ((int) in.nval + lastAns) % n;
 			in.nextToken();

From d7ef40b46bfd004b1dfaad4ed2b32b475fc11124 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Jan 2025 21:13:27 +0800
Subject: [PATCH 0322/1712] modify code

---
 src/class157/Code02_SmallestMissingNaturalNumber.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/class157/Code02_SmallestMissingNaturalNumber.java b/src/class157/Code02_SmallestMissingNaturalNumber.java
index a1850c8ef..abf512604 100644
--- a/src/class157/Code02_SmallestMissingNaturalNumber.java
+++ b/src/class157/Code02_SmallestMissingNaturalNumber.java
@@ -20,6 +20,8 @@ public class Code02_SmallestMissingNaturalNumber {
 
 	public static int MAXM = MAXN * 22;
 
+	public static int n, q;
+
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXM];
@@ -30,7 +32,7 @@ public class Code02_SmallestMissingNaturalNumber {
 	// 表示该范围每个数字最后出现的位置中，最左在哪
 	public static int[] lateLeft = new int[MAXM];
 
-	public static int n, q, cnt;
+	public static int cnt;
 
 	public static int update(int pre, int l, int r, int v, int pos) {
 		int rt = ++cnt;

From bfc843a5146ee039ff204774114420fcc0862705 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Jan 2025 21:15:32 +0800
Subject: [PATCH 0323/1712] modify code

---
 src/class157/Code04_CountOnTree.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code04_CountOnTree.java b/src/class157/Code04_CountOnTree.java
index 4a016cb16..037e09160 100644
--- a/src/class157/Code04_CountOnTree.java
+++ b/src/class157/Code04_CountOnTree.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 两节点间第k小值
+// 节点路径第k小值
 // 测试链接 : https://www.luogu.com.cn/problem/P2633
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -143,7 +143,8 @@ public static void dfs1(int u, int f) {
 		}
 	}
 
-	// dfs迭代版，都可以通过，讲解118，详解了从递归版改迭代版
+	// dfs迭代版，都可以通过
+	// 讲解118，详解了从递归版改迭代版
 	public static int[][] ufe = new int[MAXN][3];
 
 	public static int stackSize, u, f, e;

From 48495b53bc9d2bd81657a680fc24aaf3aa09b27c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Jan 2025 21:18:16 +0800
Subject: [PATCH 0324/1712] modify code

---
 src/class157/Code04_CountOnTree.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code04_CountOnTree.java b/src/class157/Code04_CountOnTree.java
index 037e09160..a6d17caff 100644
--- a/src/class157/Code04_CountOnTree.java
+++ b/src/class157/Code04_CountOnTree.java
@@ -241,12 +241,12 @@ public static void main(String[] args) throws IOException {
 		dfs2(); // 用迭代版dfs，防止爆栈
 		for (int i = 1, u, v, k, lastAns = 0; i <= q; i++) {
 			in.nextToken();
-			u = (int) in.nval;
+			u = (int) in.nval ^ lastAns; // 题目要求
 			in.nextToken();
 			v = (int) in.nval;
 			in.nextToken();
 			k = (int) in.nval;
-			lastAns = kth(u ^ lastAns, v, k);
+			lastAns = kth(u, v, k);
 			out.println(lastAns);
 		}
 		out.flush();

From 60bafb0bc0aaff72ad5cacf9233ec3d761b61653 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 8 Jan 2025 19:57:36 +0800
Subject: [PATCH 0325/1712] modify code

---
 .../Code01_PersistentSegmentTree.java         |  26 +-
 .../Code02_SmallestMissingNaturalNumber.java  |  28 +--
 src/class157/Code03_LargestMedian.java        |  20 +-
 src/class157/Code04_CountOnTree.java          |  45 ++--
 src/class157/Code05_MoreImpressive1.java      | 233 ++++++++++++++++++
 src/class157/Code05_MoreImpressive2.java      | 130 ++++++++++
 6 files changed, 423 insertions(+), 59 deletions(-)
 create mode 100644 src/class157/Code05_MoreImpressive1.java
 create mode 100644 src/class157/Code05_MoreImpressive2.java

diff --git a/src/class157/Code01_PersistentSegmentTree.java b/src/class157/Code01_PersistentSegmentTree.java
index 95d177626..e571c4637 100644
--- a/src/class157/Code01_PersistentSegmentTree.java
+++ b/src/class157/Code01_PersistentSegmentTree.java
@@ -68,32 +68,32 @@ public static int rank(int v) {
 		return ans;
 	}
 
-	public static int insert(int p, int l, int r, int x) {
+	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
-		left[rt] = left[p];
-		right[rt] = right[p];
-		count[rt] = count[p] + 1;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		count[rt] = count[i] + 1;
 		if (l < r) {
 			int mid = (l + r) / 2;
-			if (x <= mid) {
-				left[rt] = insert(left[p], l, mid, x);
+			if (jobi <= mid) {
+				left[rt] = insert(jobi, l, mid, left[rt]);
 			} else {
-				right[rt] = insert(right[p], mid + 1, r, x);
+				right[rt] = insert(jobi, mid + 1, r, right[rt]);
 			}
 		}
 		return rt;
 	}
 
-	public static int query(int u, int v, int k, int l, int r) {
+	public static int query(int jobk, int l, int r, int u, int v) {
 		if (l == r) {
 			return l;
 		}
 		int lcount = count[left[v]] - count[left[u]];
 		int mid = (l + r) / 2;
-		if (lcount >= k) {
-			return query(left[u], left[v], k, l, mid);
+		if (lcount >= jobk) {
+			return query(jobk, l, mid, left[u], left[v]);
 		} else {
-			return query(right[u], right[v], k - lcount, mid + 1, r);
+			return query(jobk - lcount, mid + 1, r, right[u], right[v]);
 		}
 	}
 
@@ -112,7 +112,7 @@ public static void main(String[] args) throws IOException {
 		prepare();
 		for (int i = 1, x; i <= n; i++) {
 			x = rank(arr[i]);
-			root[i] = insert(root[i - 1], 1, n, x);
+			root[i] = insert(x, 1, n, root[i - 1]);
 		}
 		for (int i = 1, l, r, k; i <= q; i++) {
 			in.nextToken();
@@ -121,7 +121,7 @@ public static void main(String[] args) throws IOException {
 			r = (int) in.nval;
 			in.nextToken();
 			k = (int) in.nval;
-			int ans = query(root[l - 1], root[r], k, 1, n);
+			int ans = query(k, 1, n, root[l - 1], root[r]);
 			out.println(sort[ans]);
 		}
 		out.flush();
diff --git a/src/class157/Code02_SmallestMissingNaturalNumber.java b/src/class157/Code02_SmallestMissingNaturalNumber.java
index abf512604..26bf085fb 100644
--- a/src/class157/Code02_SmallestMissingNaturalNumber.java
+++ b/src/class157/Code02_SmallestMissingNaturalNumber.java
@@ -34,39 +34,39 @@ public class Code02_SmallestMissingNaturalNumber {
 
 	public static int cnt;
 
-	public static int update(int pre, int l, int r, int v, int pos) {
+	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
-		left[rt] = left[pre];
-		right[rt] = right[pre];
-		lateLeft[rt] = lateLeft[pre];
+		left[rt] = left[i];
+		right[rt] = right[i];
+		lateLeft[rt] = lateLeft[i];
 		if (l == r) {
-			lateLeft[rt] = pos;
+			lateLeft[rt] = jobv;
 		} else {
 			int mid = (l + r) / 2;
-			if (v <= mid) {
-				left[rt] = update(left[pre], l, mid, v, pos);
+			if (jobi <= mid) {
+				left[rt] = update(jobi, jobv, l, mid, left[rt]);
 			} else {
-				right[rt] = update(right[pre], mid + 1, r, v, pos);
+				right[rt] = update(jobi, jobv, mid + 1, r, right[rt]);
 			}
 			lateLeft[rt] = Math.min(lateLeft[left[rt]], lateLeft[right[rt]]);
 		}
 		return rt;
 	}
 
-	public static int query(int rt, int l, int r, int pos) {
+	public static int query(int pos, int l, int r, int i) {
 		if (l == r) {
 			return l;
 		}
 		int mid = (l + r) / 2;
-		if (lateLeft[left[rt]] < pos) {
+		if (lateLeft[left[i]] < pos) {
 			// l...mid范围上，每个数字最晚出现的位置中
 			// 最左的位置如果在pos以左，说明l...mid范围上，一定有缺失的数字
-			return query(left[rt], l, mid, pos);
+			return query(pos, l, mid, left[i]);
 		} else {
 			// 缺失的数字一定在mid+1....r范围
 			// 因为l...r一定有缺失的数字才会来到这个范围的
 			// 如果左侧不缺失，那缺失的数字一定在右侧范围上
-			return query(right[rt], mid + 1, r, pos);
+			return query(pos, mid + 1, r, right[i]);
 		}
 	}
 
@@ -85,7 +85,7 @@ public static void main(String[] args) throws IOException {
 			if (v >= n) {
 				root[i] = root[i - 1];
 			} else {
-				root[i] = update(root[i - 1], 0, n, v, i);
+				root[i] = update(v, i, 0, n, root[i - 1]);
 			}
 		}
 		for (int i = 1, l, r; i <= q; i++) {
@@ -93,7 +93,7 @@ public static void main(String[] args) throws IOException {
 			l = (int) in.nval;
 			in.nextToken();
 			r = (int) in.nval;
-			out.println(query(root[r], 0, n, l));
+			out.println(query(l, 0, n, root[r]));
 		}
 		out.flush();
 		out.close();
diff --git a/src/class157/Code03_LargestMedian.java b/src/class157/Code03_LargestMedian.java
index f4742ad66..0a4993edd 100644
--- a/src/class157/Code03_LargestMedian.java
+++ b/src/class157/Code03_LargestMedian.java
@@ -65,21 +65,21 @@ public static void up(int i) {
 		sum[i] = sum[left[i]] + sum[right[i]];
 	}
 
-	public static int update(int p, int l, int r, int x) {
+	public static int update(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
-		left[rt] = left[p];
-		right[rt] = right[p];
-		pre[rt] = pre[p];
-		suf[rt] = suf[p];
-		sum[rt] = sum[p];
+		left[rt] = left[i];
+		right[rt] = right[i];
+		pre[rt] = pre[i];
+		suf[rt] = suf[i];
+		sum[rt] = sum[i];
 		if (l == r) {
 			pre[rt] = suf[rt] = sum[rt] = -1;
 		} else {
 			int mid = (l + r) / 2;
-			if (x <= mid) {
-				left[rt] = update(left[rt], l, mid, x);
+			if (jobi <= mid) {
+				left[rt] = update(jobi, l, mid, left[rt]);
 			} else {
-				right[rt] = update(right[rt], mid + 1, r, x);
+				right[rt] = update(jobi, mid + 1, r, right[rt]);
 			}
 			up(rt);
 		}
@@ -91,7 +91,7 @@ public static void prepare() {
 		cnt = 0;
 		root[1] = build(1, n);
 		for (int i = 2; i <= n; i++) {
-			root[i] = update(root[i - 1], 1, n, arr[i - 1][0]);
+			root[i] = update(arr[i - 1][0], 1, n, root[i - 1]);
 		}
 	}
 
diff --git a/src/class157/Code04_CountOnTree.java b/src/class157/Code04_CountOnTree.java
index a6d17caff..52d720c3d 100644
--- a/src/class157/Code04_CountOnTree.java
+++ b/src/class157/Code04_CountOnTree.java
@@ -37,7 +37,7 @@ public class Code04_CountOnTree {
 
 	public static int cntg = 0;
 
-	// 可持久化线段树
+	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXM];
@@ -99,51 +99,51 @@ public static void addEdge(int u, int v) {
 		head[u] = cntg;
 	}
 
-	public static int insert(int p, int l, int r, int x) {
+	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cntt;
-		left[rt] = left[p];
-		right[rt] = right[p];
-		count[rt] = count[p] + 1;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		count[rt] = count[i] + 1;
 		if (l < r) {
 			int mid = (l + r) / 2;
-			if (x <= mid) {
-				left[rt] = insert(left[rt], l, mid, x);
+			if (jobi <= mid) {
+				left[rt] = insert(jobi, l, mid, left[rt]);
 			} else {
-				right[rt] = insert(right[rt], mid + 1, r, x);
+				right[rt] = insert(jobi, mid + 1, r, right[rt]);
 			}
 		}
 		return rt;
 	}
 
-	public static int query(int u, int v, int fa, int fafa, int l, int r, int k) {
+	public static int query(int jobk, int l, int r, int u, int v, int lca, int lcafa) {
 		if (l == r) {
 			return l;
 		}
-		int leftCnt = count[left[u]] + count[left[v]] - count[left[fa]] - count[left[fafa]];
+		int leftCnt = count[left[u]] + count[left[v]] - count[left[lca]] - count[left[lcafa]];
 		int mid = (l + r) / 2;
-		if (leftCnt >= k) {
-			return query(left[u], left[v], left[fa], left[fafa], l, mid, k);
+		if (leftCnt >= jobk) {
+			return query(jobk, l, mid, left[u], left[v], left[lca], left[lcafa]);
 		} else {
-			return query(right[u], right[v], right[fa], right[fafa], mid + 1, r, k - leftCnt);
+			return query(jobk - leftCnt, mid + 1, r, right[u], right[v], right[lca], right[lcafa]);
 		}
 	}
 
-	// dfs递归版，C++可以通过，java无法通过，递归会爆栈
+	// 递归版，C++可以通过，java无法通过，递归会爆栈
 	public static void dfs1(int u, int f) {
-		root[u] = insert(root[f], 1, s, rank(arr[u]));
+		root[u] = insert(rank(arr[u]), 1, s, root[f]);
 		deep[u] = deep[f] + 1;
 		stjump[u][0] = f;
 		for (int p = 1; p < MAXH; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 		}
-		for (int e = head[u]; e > 0; e = next[e]) {
-			if (to[e] != f) {
-				dfs1(to[e], u);
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			if (to[ei] != f) {
+				dfs1(to[ei], u);
 			}
 		}
 	}
 
-	// dfs迭代版，都可以通过
+	// 迭代版，都可以通过
 	// 讲解118，详解了从递归版改迭代版
 	public static int[][] ufe = new int[MAXN][3];
 
@@ -163,13 +163,14 @@ public static void pop() {
 		e = ufe[stackSize][2];
 	}
 
+	// dfs1的迭代版
 	public static void dfs2() {
 		stackSize = 0;
 		push(1, 0, -1);
 		while (stackSize > 0) {
 			pop();
 			if (e == -1) {
-				root[u] = insert(root[f], 1, s, rank(arr[u]));
+				root[u] = insert(rank(arr[u]), 1, s, root[f]);
 				deep[u] = deep[f] + 1;
 				stjump[u][0] = f;
 				for (int p = 1; p < MAXH; p++) {
@@ -213,7 +214,7 @@ public static int lca(int a, int b) {
 
 	public static int kth(int u, int v, int k) {
 		int lca = lca(u, v);
-		int i = query(root[u], root[v], root[lca], root[stjump[lca][0]], 1, s, k);
+		int i = query(k, 1, s, root[u], root[v], root[lca], root[stjump[lca][0]]);
 		return sort[i];
 	}
 
@@ -238,7 +239,7 @@ public static void main(String[] args) throws IOException {
 			addEdge(u, v);
 			addEdge(v, u);
 		}
-		dfs2(); // 用迭代版dfs，防止爆栈
+		dfs2(); // 使用迭代版防止爆栈
 		for (int i = 1, u, v, k, lastAns = 0; i <= q; i++) {
 			in.nextToken();
 			u = (int) in.nval ^ lastAns; // 题目要求
diff --git a/src/class157/Code05_MoreImpressive1.java b/src/class157/Code05_MoreImpressive1.java
new file mode 100644
index 000000000..4f4fe1a7c
--- /dev/null
+++ b/src/class157/Code05_MoreImpressive1.java
@@ -0,0 +1,233 @@
+package class157;
+
+// 更为厉害，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3899
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code05_MoreImpressive1 {
+
+	public static int MAXN = 300001;
+
+	public static int MAXM = MAXN * 22;
+
+	public static int n, q;
+
+	// 链式前向星需要
+	public static int[] head = new int[MAXN];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	// 可持久化线段树需要
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	public static long[] sum = new long[MAXM];
+
+	public static int cntt = 0;
+
+	// dfs需要
+	public static int[] deep = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int cntd = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int build(int l, int r) {
+		int rt = ++cntt;
+		sum[rt] = 0;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int add(int jobi, long jobv, int l, int r, int i) {
+		int rt = ++cntt;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		sum[rt] = sum[i] + jobv;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[rt] = add(jobi, jobv, l, mid, left[rt]);
+			} else {
+				right[rt] = add(jobi, jobv, mid + 1, r, right[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static long query(int jobl, int jobr, int l, int r, int u, int v) {
+		if (jobl <= l && r <= jobr) {
+			return sum[u] - sum[v];
+		}
+		long ans = 0;
+		int mid = (l + r) / 2;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, l, mid, left[u], left[v]);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, mid + 1, r, right[u], right[v]);
+		}
+		return ans;
+	}
+
+	// 递归版，C++可以通过，java无法通过，递归会爆栈
+	public static void dfs1(int u, int f) {
+		deep[u] = deep[f] + 1;
+		size[u] = 1;
+		dfn[u] = ++cntd;
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			if (to[ei] != f) {
+				dfs1(to[ei], u);
+			}
+		}
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			if (to[ei] != f) {
+				size[u] += size[to[ei]];
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java无法通过，递归会爆栈
+	public static void dfs2(int u, int f) {
+		root[dfn[u]] = add(deep[u], size[u] - 1, 1, n, root[dfn[u] - 1]);
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			if (to[ei] != f) {
+				dfs2(to[ei], u);
+			}
+		}
+	}
+
+	// dfs1、dfs2，分别改成迭代版，dfs3、dfs4
+	// 讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stackSize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stackSize][0] = u;
+		ufe[stackSize][1] = f;
+		ufe[stackSize][2] = e;
+		stackSize++;
+	}
+
+	public static void pop() {
+		--stackSize;
+		u = ufe[stackSize][0];
+		f = ufe[stackSize][1];
+		e = ufe[stackSize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stackSize = 0;
+		push(1, 0, -1);
+		while (stackSize > 0) {
+			pop();
+			if (e == -1) {
+				deep[u] = deep[f] + 1;
+				size[u] = 1;
+				dfn[u] = ++cntd;
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = next[ei]) {
+					if (to[ei] != f) {
+						size[u] += size[to[ei]];
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stackSize = 0;
+		push(1, 0, -1);
+		while (stackSize > 0) {
+			pop();
+			if (e == -1) {
+				root[dfn[u]] = add(deep[u], size[u] - 1, 1, n, root[dfn[u] - 1]);
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			}
+		}
+	}
+
+	public static long compute(int p, int k) {
+		long ans = query(deep[p] + 1, deep[p] + k, 1, n, root[dfn[p] + size[p] - 1], root[dfn[p] - 1]);
+		ans += (long) (size[p] - 1) * Math.min(k, deep[p] - 1);
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		q = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		root[0] = build(1, n);
+		dfs3(); // 使用迭代版防止爆栈
+		dfs4(); // 使用迭代版防止爆栈
+		for (int i = 1, p, k; i <= q; i++) {
+			in.nextToken();
+			p = (int) in.nval;
+			in.nextToken();
+			k = (int) in.nval;
+			out.println(compute(p, k));
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class157/Code05_MoreImpressive2.java b/src/class157/Code05_MoreImpressive2.java
new file mode 100644
index 000000000..0d43ab40b
--- /dev/null
+++ b/src/class157/Code05_MoreImpressive2.java
@@ -0,0 +1,130 @@
+package class157;
+
+// 更为厉害，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3899
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//static const int MAXN = 300001;
+//static const int MAXM = MAXN * 22;
+//int n, q;
+//
+//int head[MAXN];
+//int to[MAXN << 1];
+//int nxt[MAXN << 1];
+//int cntg = 0;
+//
+//int root[MAXN];
+//int ls[MAXM];
+//int rs[MAXM];
+//long long sum[MAXM];
+//int cntt = 0;
+//
+//int dep[MAXN];
+//int siz[MAXN];
+//int dfn[MAXN];
+//int cntd = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int build(int l, int r) {
+//    int rt = ++cntt;
+//    sum[rt] = 0LL;
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int add(int jobi, long long jobv, int l, int r, int i) {
+//    int rt = ++cntt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    sum[rt] = sum[i] + jobv;
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//long long query(int jobl, int jobr, int l, int r, int u, int v) {
+//    if (jobl <= l && r <= jobr) {
+//        return sum[u] - sum[v];
+//    }
+//    long long ans = 0;
+//    int mid = (l + r) >> 1;
+//    if (jobl <= mid) {
+//        ans += query(jobl, jobr, l, mid, ls[u], ls[v]);
+//    }
+//    if (jobr > mid) {
+//        ans += query(jobl, jobr, mid + 1, r, rs[u], rs[v]);
+//    }
+//    return ans;
+//}
+//
+//void dfs1(int u, int f) {
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    dfn[u] = ++cntd;
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+//        if (to[ei] != f) {
+//            dfs1(to[ei], u);
+//        }
+//    }
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+//        if (to[ei] != f) {
+//            siz[u] += siz[to[ei]];
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int f) {
+//    root[dfn[u]] = add(dep[u], (long long)siz[u] - 1, 1, n, root[dfn[u] - 1]);
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+//        if (to[ei] != f) {
+//            dfs2(to[ei], u);
+//        }
+//    }
+//}
+//
+//long long compute(int p, int k) {
+//    long long ans = query(dep[p] + 1, dep[p] + k, 1, n, root[dfn[p] + siz[p] - 1], root[dfn[p] - 1]);
+//    ans += (long long)(siz[p] - 1) * min(k, dep[p] - 1);
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i < n; i++) {
+//        int u, v;
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    root[0] = build(1, n);
+//    dfs1(1, 0);
+//    dfs2(1, 0);
+//    for(int i = 1; i <= q; i++) {
+//        int p, k;
+//        cin >> p >> k;
+//        cout << compute(p, k) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 89ad6dbd1386609774118f94678bb8017130fedc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 8 Jan 2025 20:10:08 +0800
Subject: [PATCH 0326/1712] modify code

---
 src/class157/Code05_MoreImpressive1.java | 4 ++--
 src/class157/Code05_MoreImpressive2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class157/Code05_MoreImpressive1.java b/src/class157/Code05_MoreImpressive1.java
index 4f4fe1a7c..6d8c80d9d 100644
--- a/src/class157/Code05_MoreImpressive1.java
+++ b/src/class157/Code05_MoreImpressive1.java
@@ -83,7 +83,7 @@ public static int add(int jobi, long jobv, int l, int r, int i) {
 
 	public static long query(int jobl, int jobr, int l, int r, int u, int v) {
 		if (jobl <= l && r <= jobr) {
-			return sum[u] - sum[v];
+			return sum[v] - sum[u];
 		}
 		long ans = 0;
 		int mid = (l + r) / 2;
@@ -194,7 +194,7 @@ public static void dfs4() {
 	}
 
 	public static long compute(int p, int k) {
-		long ans = query(deep[p] + 1, deep[p] + k, 1, n, root[dfn[p] + size[p] - 1], root[dfn[p] - 1]);
+		long ans = query(deep[p] + 1, deep[p] + k, 1, n, root[dfn[p] - 1], root[dfn[p] + size[p] - 1]);
 		ans += (long) (size[p] - 1) * Math.min(k, deep[p] - 1);
 		return ans;
 	}
diff --git a/src/class157/Code05_MoreImpressive2.java b/src/class157/Code05_MoreImpressive2.java
index 0d43ab40b..e33ed5d16 100644
--- a/src/class157/Code05_MoreImpressive2.java
+++ b/src/class157/Code05_MoreImpressive2.java
@@ -64,7 +64,7 @@
 //
 //long long query(int jobl, int jobr, int l, int r, int u, int v) {
 //    if (jobl <= l && r <= jobr) {
-//        return sum[u] - sum[v];
+//        return sum[v] - sum[u];
 //    }
 //    long long ans = 0;
 //    int mid = (l + r) >> 1;
@@ -103,7 +103,7 @@
 //}
 //
 //long long compute(int p, int k) {
-//    long long ans = query(dep[p] + 1, dep[p] + k, 1, n, root[dfn[p] + siz[p] - 1], root[dfn[p] - 1]);
+//    long long ans = query(dep[p] + 1, dep[p] + k, 1, n, root[dfn[p] - 1], root[dfn[p] + siz[p] - 1]);
 //    ans += (long long)(siz[p] - 1) * min(k, dep[p] - 1);
 //    return ans;
 //}

From 67201db30e85bd6a90ff2ed133e5d64487f78256 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 00:57:51 +0800
Subject: [PATCH 0327/1712] modify code

---
 .../Code01_PersistentSegmentTree.java         |  18 +-
 ... Code02_MissingSmallestNaturalNumber.java} |   2 +-
 .../Code03_RangeDifferentNumbers1.java        | 219 +++++++++++++++++
 .../Code03_RangeDifferentNumbers2.java        | 123 ++++++++++
 ...tMedian.java => Code04_LargestMedian.java} |  20 +-
 ...untOnTree.java => Code05_CountOnTree.java} |   2 +-
 ...sive1.java => Code06_MoreImpressive1.java} |   2 +-
 ...sive2.java => Code06_MoreImpressive2.java} |   0
 src/class157/Code07_ToTheMoon1.java           | 225 ++++++++++++++++++
 src/class157/Code07_ToTheMoon2.java           | 103 ++++++++
 10 files changed, 692 insertions(+), 22 deletions(-)
 rename src/class157/{Code02_SmallestMissingNaturalNumber.java => Code02_MissingSmallestNaturalNumber.java} (98%)
 create mode 100644 src/class157/Code03_RangeDifferentNumbers1.java
 create mode 100644 src/class157/Code03_RangeDifferentNumbers2.java
 rename src/class157/{Code03_LargestMedian.java => Code04_LargestMedian.java} (99%)
 rename src/class157/{Code04_CountOnTree.java => Code05_CountOnTree.java} (99%)
 rename src/class157/{Code05_MoreImpressive1.java => Code06_MoreImpressive1.java} (99%)
 rename src/class157/{Code05_MoreImpressive2.java => Code06_MoreImpressive2.java} (100%)
 create mode 100644 src/class157/Code07_ToTheMoon1.java
 create mode 100644 src/class157/Code07_ToTheMoon2.java

diff --git a/src/class157/Code01_PersistentSegmentTree.java b/src/class157/Code01_PersistentSegmentTree.java
index e571c4637..e6c59d1f9 100644
--- a/src/class157/Code01_PersistentSegmentTree.java
+++ b/src/class157/Code01_PersistentSegmentTree.java
@@ -34,15 +34,6 @@ public class Code01_PersistentSegmentTree {
 
 	public static int cnt;
 
-	public static void prepare() {
-		cnt = 0;
-		for (int i = 1; i <= n; i++) {
-			sort[i] = arr[i];
-		}
-		Arrays.sort(sort, 1, n + 1);
-		root[0] = build(1, n);
-	}
-
 	public static int build(int l, int r) {
 		int rt = ++cnt;
 		count[rt] = 0;
@@ -54,6 +45,15 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
+	public static void prepare() {
+		cnt = 0;
+		for (int i = 1; i <= n; i++) {
+			sort[i] = arr[i];
+		}
+		Arrays.sort(sort, 1, n + 1);
+		root[0] = build(1, n);
+	}
+
 	public static int rank(int v) {
 		int l = 1, r = n, m, ans = 0;
 		while (l <= r) {
diff --git a/src/class157/Code02_SmallestMissingNaturalNumber.java b/src/class157/Code02_MissingSmallestNaturalNumber.java
similarity index 98%
rename from src/class157/Code02_SmallestMissingNaturalNumber.java
rename to src/class157/Code02_MissingSmallestNaturalNumber.java
index 26bf085fb..bb0d4be29 100644
--- a/src/class157/Code02_SmallestMissingNaturalNumber.java
+++ b/src/class157/Code02_MissingSmallestNaturalNumber.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_SmallestMissingNaturalNumber {
+public class Code02_MissingSmallestNaturalNumber {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class157/Code03_RangeDifferentNumbers1.java b/src/class157/Code03_RangeDifferentNumbers1.java
new file mode 100644
index 000000000..ae7cb3c07
--- /dev/null
+++ b/src/class157/Code03_RangeDifferentNumbers1.java
@@ -0,0 +1,219 @@
+package class157;
+
+// 区间内的不同数字，java版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.util.Arrays;
+
+public class Code03_RangeDifferentNumbers1 {
+
+	public static int MAXN = 200002;
+
+	public static int MAXM = MAXN * 37;
+
+	public static int cases, n, q;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] pos = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	public static int[] diff = new int[MAXM];
+
+	public static int cnt;
+
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		if (l == r) {
+			return rt;
+		}
+		int mid = (l + r) / 2;
+		left[rt] = build(l, mid);
+		right[rt] = build(mid + 1, r);
+		return rt;
+	}
+
+	public static int update(int jobi, int jobv, int l, int r, int i) {
+		int rt = ++cnt;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		diff[rt] = diff[i] + jobv;
+		if (l == r) {
+			return rt;
+		}
+		int mid = (l + r) / 2;
+		if (jobi <= mid) {
+			left[rt] = update(jobi, jobv, l, mid, left[rt]);
+		} else {
+			right[rt] = update(jobi, jobv, mid + 1, r, right[rt]);
+		}
+		return rt;
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return diff[i];
+		}
+		int mid = (l + r) / 2;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, l, mid, left[i]);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, mid + 1, r, right[i]);
+		}
+		return ans;
+	}
+
+	public static int find(int jobk, int l, int r, int i) {
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) / 2;
+		int leftDiff = diff[left[i]];
+		if (leftDiff >= jobk) {
+			return find(jobk, l, mid, left[i]);
+		} else {
+			return find(jobk - leftDiff, mid + 1, r, right[i]);
+		}
+	}
+
+	public static void prepare() {
+		cnt = 0;
+		Arrays.fill(pos, 0);
+		root[n + 1] = build(1, n);
+		for (int i = n; i >= 1; i--) {
+			if (pos[arr[i]] == 0) {
+				root[i] = update(i, 1, 1, n, root[i + 1]);
+			} else {
+				root[i] = update(pos[arr[i]], -1, 1, n, root[i + 1]);
+				root[i] = update(i, 1, 1, n, root[i]);
+			}
+			pos[arr[i]] = i;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		ReaderWriter io = new ReaderWriter();
+		cases = io.nextInt();
+		for (int t = 1; t <= cases; t++) {
+			n = io.nextInt();
+			q = io.nextInt();
+			for (int i = 1; i <= n; i++) {
+				arr[i] = io.nextInt();
+			}
+			prepare();
+			io.write("Case #");
+			io.writeInt(t);
+			io.write(":");
+			for (int i = 1, l, r, tmp, k, lastAns = 0; i <= q; i++) {
+				l = (io.nextInt() + lastAns) % n + 1;
+				r = (io.nextInt() + lastAns) % n + 1;
+				if (l > r) {
+					tmp = l;
+					l = r;
+					r = tmp;
+				}
+				k = (query(l, r, 1, n, root[l]) + 1) >> 1;
+				lastAns = find(k, 1, n, root[l]);
+				io.write(" ");
+				io.writeInt(lastAns);
+			}
+			io.write("\n");
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class ReaderWriter {
+		private static final int BUFFER_SIZE = 1 << 9;
+		private byte[] inBuf = new byte[BUFFER_SIZE];
+		private int bId, bSize;
+		private final java.io.InputStream in;
+
+		private byte[] outBuf = new byte[BUFFER_SIZE];
+		private int oId;
+		private final java.io.OutputStream out;
+
+		ReaderWriter() {
+			in = System.in;
+			out = System.out;
+		}
+
+		private byte read() throws IOException {
+			if (bId == bSize) {
+				bSize = in.read(inBuf);
+				bId = 0;
+				if (bSize == -1)
+					return -1;
+			}
+			return inBuf[bId++];
+		}
+
+		public int nextInt() throws IOException {
+			int s = 0;
+			byte c = read();
+			while (c <= ' ') {
+				if (c == -1)
+					return -1;
+				c = read();
+			}
+			boolean neg = (c == '-');
+			if (neg)
+				c = read();
+			while (c >= '0' && c <= '9') {
+				s = s * 10 + (c - '0');
+				c = read();
+			}
+			return neg ? -s : s;
+		}
+
+		public void write(String s) throws IOException {
+			for (int i = 0; i < s.length(); i++) {
+				writeByte((byte) s.charAt(i));
+			}
+		}
+
+		public void writeInt(int x) throws IOException {
+			if (x == 0) {
+				writeByte((byte) '0');
+				return;
+			}
+			if (x < 0) {
+				writeByte((byte) '-');
+				x = -x;
+			}
+			int len = 0;
+			byte[] tmp = new byte[12];
+			while (x > 0) {
+				tmp[len++] = (byte) ((x % 10) + '0');
+				x /= 10;
+			}
+			while (len-- > 0) {
+				writeByte(tmp[len]);
+			}
+		}
+
+		private void writeByte(byte b) throws IOException {
+			if (oId == BUFFER_SIZE) {
+				flush();
+			}
+			outBuf[oId++] = b;
+		}
+
+		public void flush() throws IOException {
+			if (oId > 0) {
+				out.write(outBuf, 0, oId);
+				oId = 0;
+			}
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class157/Code03_RangeDifferentNumbers2.java b/src/class157/Code03_RangeDifferentNumbers2.java
new file mode 100644
index 000000000..5bfa3c95a
--- /dev/null
+++ b/src/class157/Code03_RangeDifferentNumbers2.java
@@ -0,0 +1,123 @@
+package class157;
+
+// 区间内的不同数字，C++版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//static const int MAXN = 200002;
+//static const int MAXM = MAXN * 37;
+//int cases, n, q;
+//int arr[MAXN];
+//int pos[MAXN];
+//int root[MAXN];
+//int ls[MAXM];
+//int rs[MAXM];
+//int diff[MAXM];
+//int cnt;
+//
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    if (l == r) {
+//        return rt;
+//    }
+//    int mid = (l + r) / 2;
+//    ls[rt] = build(l, mid);
+//    rs[rt] = build(mid + 1, r);
+//    return rt;
+//}
+//
+//int update(int jobi, int jobv, int l, int r, int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    diff[rt] = diff[i] + jobv;
+//    if (l == r) {
+//        return rt;
+//    }
+//    int mid = (l + r) / 2;
+//    if (jobi <= mid) {
+//        ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+//    } else {
+//        rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+//    }
+//    return rt;
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return diff[i];
+//    }
+//    int mid = (l + r) / 2;
+//    int ans = 0;
+//    if (jobl <= mid) {
+//        ans += query(jobl, jobr, l, mid, ls[i]);
+//    }
+//    if (jobr > mid) {
+//        ans += query(jobl, jobr, mid + 1, r, rs[i]);
+//    }
+//    return ans;
+//}
+//
+//int find(int jobk, int l, int r, int i) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) / 2;
+//    int leftDiff = diff[ls[i]];
+//    if (leftDiff >= jobk) {
+//        return find(jobk, l, mid, ls[i]);
+//    } else {
+//        return find(jobk - leftDiff, mid + 1, r, rs[i]);
+//    }
+//}
+//
+//void prepare() {
+//    cnt = 0;
+//    memset(pos, 0, sizeof(pos));
+//    root[n + 1] = build(1, n);
+//    for (int i = n; i >= 1; i--) {
+//        if (pos[arr[i]] == 0) {
+//            root[i] = update(i, 1, 1, n, root[i + 1]);
+//        } else {
+//            root[i] = update(pos[arr[i]], -1, 1, n, root[i + 1]);
+//            root[i] = update(i, 1, 1, n, root[i]);
+//        }
+//        pos[arr[i]] = i;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> cases;
+//    for (int t = 1; t <= cases; t++) {
+//        cin >> n >> q;
+//        for (int i = 1; i <= n; i++) {
+//            cin >> arr[i];
+//        }
+//        prepare();
+//        cout << "Case #" << t << ":";
+//        int lastAns = 0;
+//        for (int i = 1; i <= q; i++) {
+//            int l, r;
+//            cin >> l >> r;
+//            l = (l + lastAns) % n + 1;
+//            r = (r + lastAns) % n + 1;
+//            if (l > r) {
+//                int tmp = l; 
+//                l = r; 
+//                r = tmp;
+//            }
+//            int k = (query(l, r, 1, n, root[l]) + 1) >> 1;
+//            lastAns = find(k, 1, n, root[l]);
+//            cout << " " << lastAns;
+//        }
+//        cout << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code03_LargestMedian.java b/src/class157/Code04_LargestMedian.java
similarity index 99%
rename from src/class157/Code03_LargestMedian.java
rename to src/class157/Code04_LargestMedian.java
index 0a4993edd..8b7bf8075 100644
--- a/src/class157/Code03_LargestMedian.java
+++ b/src/class157/Code04_LargestMedian.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_LargestMedian {
+public class Code04_LargestMedian {
 
 	public static int MAXN = 20001;
 
@@ -86,15 +86,6 @@ public static int update(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
-	public static void prepare() {
-		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
-		cnt = 0;
-		root[1] = build(1, n);
-		for (int i = 2; i <= n; i++) {
-			root[i] = update(arr[i - 1][0], 1, n, root[i - 1]);
-		}
-	}
-
 	public static void initInfo() {
 		info[0] = info[1] = -INF;
 		info[2] = 0;
@@ -120,6 +111,15 @@ public static void query(int jobl, int jobr, int l, int r, int i) {
 		}
 	}
 
+	public static void prepare() {
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
+		cnt = 0;
+		root[1] = build(1, n);
+		for (int i = 2; i <= n; i++) {
+			root[i] = update(arr[i - 1][0], 1, n, root[i - 1]);
+		}
+	}
+
 	public static boolean check(int i) {
 		int a = ques[0] + 1, b = ques[1] + 1, c = ques[2] + 1, d = ques[3] + 1, best;
 		initInfo();
diff --git a/src/class157/Code04_CountOnTree.java b/src/class157/Code05_CountOnTree.java
similarity index 99%
rename from src/class157/Code04_CountOnTree.java
rename to src/class157/Code05_CountOnTree.java
index 52d720c3d..479480e85 100644
--- a/src/class157/Code04_CountOnTree.java
+++ b/src/class157/Code05_CountOnTree.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_CountOnTree {
+public class Code05_CountOnTree {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class157/Code05_MoreImpressive1.java b/src/class157/Code06_MoreImpressive1.java
similarity index 99%
rename from src/class157/Code05_MoreImpressive1.java
rename to src/class157/Code06_MoreImpressive1.java
index 6d8c80d9d..d470737c7 100644
--- a/src/class157/Code05_MoreImpressive1.java
+++ b/src/class157/Code06_MoreImpressive1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_MoreImpressive1 {
+public class Code06_MoreImpressive1 {
 
 	public static int MAXN = 300001;
 
diff --git a/src/class157/Code05_MoreImpressive2.java b/src/class157/Code06_MoreImpressive2.java
similarity index 100%
rename from src/class157/Code05_MoreImpressive2.java
rename to src/class157/Code06_MoreImpressive2.java
diff --git a/src/class157/Code07_ToTheMoon1.java b/src/class157/Code07_ToTheMoon1.java
new file mode 100644
index 000000000..036a89655
--- /dev/null
+++ b/src/class157/Code07_ToTheMoon1.java
@@ -0,0 +1,225 @@
+package class157;
+
+// 去月球，java版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
+// 测试链接 : https://www.spoj.com/problems/TTM/s
+// java版的实现就是通过不了，怎么优化也通过不了，这是语言歧视
+// C++版的实现就能通过，两个版本的逻辑是完全一样的
+// 想通过就用C++写吧，本节课Code07_ToTheMoon2文件就是C++的实现
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+
+public class Code07_ToTheMoon1 {
+
+	public static int MAXN = 100001;
+
+	public static int MAXM = MAXN * 30;
+
+	public static int n, q, t = 0;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXM];
+
+	public static int[] right = new int[MAXM];
+
+	public static long[] sum = new long[MAXM];
+
+	public static long[] addTag = new long[MAXM];
+
+	public static int cnt = 0;
+
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		addTag[rt] = 0;
+		if (l == r) {
+			sum[rt] = arr[l];
+		} else {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+			sum[rt] = sum[left[rt]] + sum[right[rt]];
+		}
+		return rt;
+	}
+
+	public static void prepare() {
+		t = 0;
+		cnt = 0;
+		root[0] = build(1, n);
+	}
+
+	public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
+		int rt = ++cnt, a = Math.max(jobl, l), b = Math.min(jobr, r);
+		left[rt] = left[i];
+		right[rt] = right[i];
+		sum[rt] = sum[i] + jobv * (b - a + 1);
+		addTag[rt] = addTag[i];
+		if (jobl <= l && r <= jobr) {
+			addTag[rt] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				left[rt] = add(jobl, jobr, jobv, l, mid, left[rt]);
+			}
+			if (jobr > mid) {
+				right[rt] = add(jobl, jobr, jobv, mid + 1, r, right[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static long query(int jobl, int jobr, long historyAdd, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i] + historyAdd * (r - l + 1);
+		}
+		int mid = (l + r) / 2;
+		long ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, historyAdd + addTag[i], l, mid, left[i]);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, historyAdd + addTag[i], mid + 1, r, right[i]);
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		root[0] = build(1, n);
+		String op;
+		for (int i = 1, x, y, z; i <= q; i++) {
+			op = in.next();
+			if (op.equals("C")) {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				root[t + 1] = add(x, y, z, 1, n, root[t]);
+				t++;
+			} else if (op.equals("Q")) {
+				x = in.nextInt();
+				y = in.nextInt();
+				out.write(query(x, y, 0, 1, n, root[t]) + "\n");
+			} else if (op.equals("H")) {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				out.write(query(x, y, 0, 1, n, root[z]) + "\n");
+			} else {
+				t = in.nextInt();
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public boolean hasNext() throws IOException {
+			while (hasNextByte()) {
+				byte b = buffer[ptr];
+				if (!isWhitespace(b))
+					return true;
+				ptr++;
+			}
+			return false;
+		}
+
+		public String next() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return null;
+			} while (c <= ' ');
+			StringBuilder sb = new StringBuilder();
+			while (c > ' ') {
+				sb.append((char) c);
+				c = readByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public double nextDouble() throws IOException {
+			double num = 0, div = 1;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != '.' && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			if (b == '.') {
+				b = readByte();
+				while (!isWhitespace(b) && b != -1) {
+					num += (b - '0') / (div *= 10);
+					b = readByte();
+				}
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class157/Code07_ToTheMoon2.java b/src/class157/Code07_ToTheMoon2.java
new file mode 100644
index 000000000..a0f04a79d
--- /dev/null
+++ b/src/class157/Code07_ToTheMoon2.java
@@ -0,0 +1,103 @@
+package class157;
+
+// 去月球，C++版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
+// 测试链接 : https://www.spoj.com/problems/TTM/
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//static const int MAXN = 100001;
+//static const int MAXM = MAXN * 30;
+//int n, q, t = 0;
+//long long arr[MAXN];
+//int root[MAXN];
+//int ls[MAXM];
+//int rs[MAXM];
+//long long sum[MAXM];
+//long long addTag[MAXM];
+//int cnt = 0;
+//
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    addTag[rt] = 0;
+//    if (l == r) {
+//        sum[rt] = arr[l];
+//    } else {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//        sum[rt] = sum[ls[rt]] + sum[rs[rt]];
+//    }
+//    return rt;
+//}
+//
+//int add(int jobl, int jobr, long long jobv, int l, int r, int i) {
+//    int rt = ++cnt, a = max(jobl, l), b = min(jobr, r);
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    sum[rt] = sum[i] + jobv * (b - a + 1);
+//    addTag[rt] = addTag[i];
+//    if (jobl <= l && r <= jobr) {
+//        addTag[rt] += jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobl <= mid) {
+//            ls[rt] = add(jobl, jobr, jobv, l, mid, ls[rt]);
+//        }
+//        if (jobr > mid) {
+//            rs[rt] = add(jobl, jobr, jobv, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//long long query(int jobl, int jobr, long long historyAdd, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i] + historyAdd * (r - l + 1);
+//    }
+//    int mid = (l + r) / 2;
+//    long long ans = 0;
+//    if (jobl <= mid) {
+//        ans += query(jobl, jobr, historyAdd + addTag[i], l, mid, ls[i]);
+//    }
+//    if (jobr > mid) {
+//        ans += query(jobl, jobr, historyAdd + addTag[i], mid + 1, r, rs[i]);
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    root[0] = build(1, n);
+//    for (int i = 1; i <= q; i++) {
+//        char op;
+//        cin >> op;
+//        if (op == 'C') {
+//            int x, y;
+//            long long z;
+//            cin >> x >> y >> z;
+//            root[t + 1] = add(x, y, z, 1, n, root[t]);
+//            t++;
+//        } else if (op == 'Q') {
+//            int x, y;
+//            cin >> x >> y;
+//            cout << query(x, y, 0, 1, n, root[t]) << "\n";
+//        } else if (op == 'H') {
+//            int x, y, z;
+//            cin >> x >> y >> z;
+//            cout << query(x, y, 0, 1, n, root[z]) << "\n";
+//        } else {
+//            cin >> t;
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From d123ef1495378a3e18604ab2f8e5768736be4aa1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 01:04:10 +0800
Subject: [PATCH 0328/1712] modify code

---
 src/class157/Code01_PersistentSegmentTree.java | 12 ++++++------
 src/class157/Code05_CountOnTree.java           | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class157/Code01_PersistentSegmentTree.java b/src/class157/Code01_PersistentSegmentTree.java
index e6c59d1f9..2e6c3119e 100644
--- a/src/class157/Code01_PersistentSegmentTree.java
+++ b/src/class157/Code01_PersistentSegmentTree.java
@@ -30,13 +30,13 @@ public class Code01_PersistentSegmentTree {
 
 	public static int[] right = new int[MAXM];
 
-	public static int[] count = new int[MAXM];
+	public static int[] size = new int[MAXM];
 
 	public static int cnt;
 
 	public static int build(int l, int r) {
 		int rt = ++cnt;
-		count[rt] = 0;
+		size[rt] = 0;
 		if (l < r) {
 			int mid = (l + r) / 2;
 			left[rt] = build(l, mid);
@@ -72,7 +72,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
 		right[rt] = right[i];
-		count[rt] = count[i] + 1;
+		size[rt] = size[i] + 1;
 		if (l < r) {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
@@ -88,12 +88,12 @@ public static int query(int jobk, int l, int r, int u, int v) {
 		if (l == r) {
 			return l;
 		}
-		int lcount = count[left[v]] - count[left[u]];
+		int lsize = size[left[v]] - size[left[u]];
 		int mid = (l + r) / 2;
-		if (lcount >= jobk) {
+		if (lsize >= jobk) {
 			return query(jobk, l, mid, left[u], left[v]);
 		} else {
-			return query(jobk - lcount, mid + 1, r, right[u], right[v]);
+			return query(jobk - lsize, mid + 1, r, right[u], right[v]);
 		}
 	}
 
diff --git a/src/class157/Code05_CountOnTree.java b/src/class157/Code05_CountOnTree.java
index 479480e85..4b138446c 100644
--- a/src/class157/Code05_CountOnTree.java
+++ b/src/class157/Code05_CountOnTree.java
@@ -44,7 +44,7 @@ public class Code05_CountOnTree {
 
 	public static int[] right = new int[MAXM];
 
-	public static int[] count = new int[MAXM];
+	public static int[] size = new int[MAXM];
 
 	public static int cntt = 0;
 
@@ -70,7 +70,7 @@ public static int rank(int num) {
 
 	public static int build(int l, int r) {
 		int rt = ++cntt;
-		count[rt] = 0;
+		size[rt] = 0;
 		if (l < r) {
 			int mid = (l + r) / 2;
 			left[rt] = build(l, mid);
@@ -103,7 +103,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cntt;
 		left[rt] = left[i];
 		right[rt] = right[i];
-		count[rt] = count[i] + 1;
+		size[rt] = size[i] + 1;
 		if (l < r) {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
@@ -119,12 +119,12 @@ public static int query(int jobk, int l, int r, int u, int v, int lca, int lcafa
 		if (l == r) {
 			return l;
 		}
-		int leftCnt = count[left[u]] + count[left[v]] - count[left[lca]] - count[left[lcafa]];
+		int lsize = size[left[u]] + size[left[v]] - size[left[lca]] - size[left[lcafa]];
 		int mid = (l + r) / 2;
-		if (leftCnt >= jobk) {
+		if (lsize >= jobk) {
 			return query(jobk, l, mid, left[u], left[v], left[lca], left[lcafa]);
 		} else {
-			return query(jobk - leftCnt, mid + 1, r, right[u], right[v], right[lca], right[lcafa]);
+			return query(jobk - lsize, mid + 1, r, right[u], right[v], right[lca], right[lcafa]);
 		}
 	}
 

From 3de2a1e2b390e8b7cf00943594979fd996c798f0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 01:07:08 +0800
Subject: [PATCH 0329/1712] modify code

---
 ...de04_LargestMedian.java => Code04_RangeLargestMedian.java} | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
 rename src/class157/{Code04_LargestMedian.java => Code04_RangeLargestMedian.java} (98%)

diff --git a/src/class157/Code04_LargestMedian.java b/src/class157/Code04_RangeLargestMedian.java
similarity index 98%
rename from src/class157/Code04_LargestMedian.java
rename to src/class157/Code04_RangeLargestMedian.java
index 8b7bf8075..d97d4ba6f 100644
--- a/src/class157/Code04_LargestMedian.java
+++ b/src/class157/Code04_RangeLargestMedian.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 最大的中位数
+// 区间内最大中位数
 // 测试链接 : https://www.luogu.com.cn/problem/P2839
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_LargestMedian {
+public class Code04_RangeLargestMedian {
 
 	public static int MAXN = 20001;
 

From 5fbf84fa9526a2cfdf84bf7876f7d89fbbc88160 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 01:08:42 +0800
Subject: [PATCH 0330/1712] modify code

---
 ...ngSmallestNaturalNumber.java => Code02_MissingSmallest.java} | 2 +-
 ...angeDifferentNumbers1.java => Code03_DifferentNumbers1.java} | 2 +-
 ...angeDifferentNumbers2.java => Code03_DifferentNumbers2.java} | 0
 ...Code04_RangeLargestMedian.java => Code04_LargestMedian.java} | 2 +-
 4 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class157/{Code02_MissingSmallestNaturalNumber.java => Code02_MissingSmallest.java} (98%)
 rename src/class157/{Code03_RangeDifferentNumbers1.java => Code03_DifferentNumbers1.java} (99%)
 rename src/class157/{Code03_RangeDifferentNumbers2.java => Code03_DifferentNumbers2.java} (100%)
 rename src/class157/{Code04_RangeLargestMedian.java => Code04_LargestMedian.java} (99%)

diff --git a/src/class157/Code02_MissingSmallestNaturalNumber.java b/src/class157/Code02_MissingSmallest.java
similarity index 98%
rename from src/class157/Code02_MissingSmallestNaturalNumber.java
rename to src/class157/Code02_MissingSmallest.java
index bb0d4be29..a3c71451d 100644
--- a/src/class157/Code02_MissingSmallestNaturalNumber.java
+++ b/src/class157/Code02_MissingSmallest.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_MissingSmallestNaturalNumber {
+public class Code02_MissingSmallest {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class157/Code03_RangeDifferentNumbers1.java b/src/class157/Code03_DifferentNumbers1.java
similarity index 99%
rename from src/class157/Code03_RangeDifferentNumbers1.java
rename to src/class157/Code03_DifferentNumbers1.java
index ae7cb3c07..f2d64f0a0 100644
--- a/src/class157/Code03_RangeDifferentNumbers1.java
+++ b/src/class157/Code03_DifferentNumbers1.java
@@ -7,7 +7,7 @@
 import java.io.IOException;
 import java.util.Arrays;
 
-public class Code03_RangeDifferentNumbers1 {
+public class Code03_DifferentNumbers1 {
 
 	public static int MAXN = 200002;
 
diff --git a/src/class157/Code03_RangeDifferentNumbers2.java b/src/class157/Code03_DifferentNumbers2.java
similarity index 100%
rename from src/class157/Code03_RangeDifferentNumbers2.java
rename to src/class157/Code03_DifferentNumbers2.java
diff --git a/src/class157/Code04_RangeLargestMedian.java b/src/class157/Code04_LargestMedian.java
similarity index 99%
rename from src/class157/Code04_RangeLargestMedian.java
rename to src/class157/Code04_LargestMedian.java
index d97d4ba6f..ac09b95c0 100644
--- a/src/class157/Code04_RangeLargestMedian.java
+++ b/src/class157/Code04_LargestMedian.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_RangeLargestMedian {
+public class Code04_LargestMedian {
 
 	public static int MAXN = 20001;
 

From 7e170aeccc4230a74f3297a44a76e6a4a37a86e0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 01:19:02 +0800
Subject: [PATCH 0331/1712] modify code

---
 src/class157/Code07_ToTheMoon1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class157/Code07_ToTheMoon1.java b/src/class157/Code07_ToTheMoon1.java
index 036a89655..3a55006fd 100644
--- a/src/class157/Code07_ToTheMoon1.java
+++ b/src/class157/Code07_ToTheMoon1.java
@@ -2,7 +2,7 @@
 
 // 去月球，java版
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
-// 测试链接 : https://www.spoj.com/problems/TTM/s
+// 测试链接 : https://www.spoj.com/problems/TTM/
 // java版的实现就是通过不了，怎么优化也通过不了，这是语言歧视
 // C++版的实现就能通过，两个版本的逻辑是完全一样的
 // 想通过就用C++写吧，本节课Code07_ToTheMoon2文件就是C++的实现

From 9bd6d250e87e096b7310651b80387797bc4948f7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 02:13:30 +0800
Subject: [PATCH 0332/1712] modify code

---
 src/class157/Code07_ToTheMoon1.java | 8 ++++----
 src/class157/Code07_ToTheMoon2.java | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class157/Code07_ToTheMoon1.java b/src/class157/Code07_ToTheMoon1.java
index 3a55006fd..544e4c38e 100644
--- a/src/class157/Code07_ToTheMoon1.java
+++ b/src/class157/Code07_ToTheMoon1.java
@@ -3,9 +3,9 @@
 // 去月球，java版
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
-// java版的实现就是通过不了，怎么优化也通过不了，这是语言歧视
-// C++版的实现就能通过，两个版本的逻辑是完全一样的
-// 想通过就用C++写吧，本节课Code07_ToTheMoon2文件就是C++的实现
+// 这道题两个测试链接都严重卡常，java版很难通过，这是语言歧视
+// 想通过用C++写吧，本节课Code07_ToTheMoon2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
 import java.io.IOException;
@@ -16,7 +16,7 @@ public class Code07_ToTheMoon1 {
 
 	public static int MAXN = 100001;
 
-	public static int MAXM = MAXN * 30;
+	public static int MAXM = MAXN * 25;
 
 	public static int n, q, t = 0;
 
diff --git a/src/class157/Code07_ToTheMoon2.java b/src/class157/Code07_ToTheMoon2.java
index a0f04a79d..a9ae682e4 100644
--- a/src/class157/Code07_ToTheMoon2.java
+++ b/src/class157/Code07_ToTheMoon2.java
@@ -11,7 +11,7 @@
 //using namespace std;
 //
 //static const int MAXN = 100001;
-//static const int MAXM = MAXN * 30;
+//static const int MAXM = MAXN * 25;
 //int n, q, t = 0;
 //long long arr[MAXN];
 //int root[MAXN];

From 2a3e266a5ede5d76de3ca02959d3e4cc99d68dab Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 02:14:25 +0800
Subject: [PATCH 0333/1712] modify code

---
 src/class157/Code07_ToTheMoon1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class157/Code07_ToTheMoon1.java b/src/class157/Code07_ToTheMoon1.java
index 544e4c38e..2c83a452a 100644
--- a/src/class157/Code07_ToTheMoon1.java
+++ b/src/class157/Code07_ToTheMoon1.java
@@ -3,7 +3,7 @@
 // 去月球，java版
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
-// 这道题两个测试链接都严重卡常，java版很难通过，这是语言歧视
+// 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
 // 想通过用C++写吧，本节课Code07_ToTheMoon2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 

From 65479469e595b67a90246b18672827c942885f95 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 12:09:17 +0800
Subject: [PATCH 0334/1712] modify code

---
 src/class157/Code03_DifferentNumbers1.java | 20 +++++++++---------
 src/class157/Code03_DifferentNumbers2.java | 24 +++++++++-------------
 2 files changed, 20 insertions(+), 24 deletions(-)

diff --git a/src/class157/Code03_DifferentNumbers1.java b/src/class157/Code03_DifferentNumbers1.java
index f2d64f0a0..ace768bdf 100644
--- a/src/class157/Code03_DifferentNumbers1.java
+++ b/src/class157/Code03_DifferentNumbers1.java
@@ -57,31 +57,31 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static int query(int jobl, int jobr, int l, int r, int i) {
+	public static int queryDiff(int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			return diff[i];
 		}
 		int mid = (l + r) / 2;
 		int ans = 0;
 		if (jobl <= mid) {
-			ans += query(jobl, jobr, l, mid, left[i]);
+			ans += queryDiff(jobl, jobr, l, mid, left[i]);
 		}
 		if (jobr > mid) {
-			ans += query(jobl, jobr, mid + 1, r, right[i]);
+			ans += queryDiff(jobl, jobr, mid + 1, r, right[i]);
 		}
 		return ans;
 	}
 
-	public static int find(int jobk, int l, int r, int i) {
+	public static int queryKth(int jobk, int l, int r, int i) {
 		if (l == r) {
 			return l;
 		}
 		int mid = (l + r) / 2;
 		int leftDiff = diff[left[i]];
 		if (leftDiff >= jobk) {
-			return find(jobk, l, mid, left[i]);
+			return queryKth(jobk, l, mid, left[i]);
 		} else {
-			return find(jobk - leftDiff, mid + 1, r, right[i]);
+			return queryKth(jobk - leftDiff, mid + 1, r, right[i]);
 		}
 	}
 
@@ -113,16 +113,16 @@ public static void main(String[] args) throws IOException {
 			io.write("Case #");
 			io.writeInt(t);
 			io.write(":");
-			for (int i = 1, l, r, tmp, k, lastAns = 0; i <= q; i++) {
+			for (int i = 1, l, r, k, lastAns = 0; i <= q; i++) {
 				l = (io.nextInt() + lastAns) % n + 1;
 				r = (io.nextInt() + lastAns) % n + 1;
 				if (l > r) {
-					tmp = l;
+					int tmp = l;
 					l = r;
 					r = tmp;
 				}
-				k = (query(l, r, 1, n, root[l]) + 1) >> 1;
-				lastAns = find(k, 1, n, root[l]);
+				k = (queryDiff(l, r, 1, n, root[l]) + 1) >> 1;
+				lastAns = queryKth(k, 1, n, root[l]);
 				io.write(" ");
 				io.writeInt(lastAns);
 			}
diff --git a/src/class157/Code03_DifferentNumbers2.java b/src/class157/Code03_DifferentNumbers2.java
index 5bfa3c95a..cf8ffec03 100644
--- a/src/class157/Code03_DifferentNumbers2.java
+++ b/src/class157/Code03_DifferentNumbers2.java
@@ -48,31 +48,31 @@
 //    return rt;
 //}
 //
-//int query(int jobl, int jobr, int l, int r, int i) {
+//int queryDiff(int jobl, int jobr, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
 //        return diff[i];
 //    }
 //    int mid = (l + r) / 2;
 //    int ans = 0;
 //    if (jobl <= mid) {
-//        ans += query(jobl, jobr, l, mid, ls[i]);
+//        ans += queryDiff(jobl, jobr, l, mid, ls[i]);
 //    }
 //    if (jobr > mid) {
-//        ans += query(jobl, jobr, mid + 1, r, rs[i]);
+//        ans += queryDiff(jobl, jobr, mid + 1, r, rs[i]);
 //    }
 //    return ans;
 //}
 //
-//int find(int jobk, int l, int r, int i) {
+//int queryKth(int jobk, int l, int r, int i) {
 //    if (l == r) {
 //        return l;
 //    }
 //    int mid = (l + r) / 2;
 //    int leftDiff = diff[ls[i]];
 //    if (leftDiff >= jobk) {
-//        return find(jobk, l, mid, ls[i]);
+//        return queryKth(jobk, l, mid, ls[i]);
 //    } else {
-//        return find(jobk - leftDiff, mid + 1, r, rs[i]);
+//        return queryKth(jobk - leftDiff, mid + 1, r, rs[i]);
 //    }
 //}
 //
@@ -102,19 +102,15 @@
 //        }
 //        prepare();
 //        cout << "Case #" << t << ":";
-//        int lastAns = 0;
-//        for (int i = 1; i <= q; i++) {
-//            int l, r;
+//        for (int i = 1, l, r, k, lastAns = 0; i <= q; i++) {
 //            cin >> l >> r;
 //            l = (l + lastAns) % n + 1;
 //            r = (r + lastAns) % n + 1;
 //            if (l > r) {
-//                int tmp = l; 
-//                l = r; 
-//                r = tmp;
+//                swap(l, r);
 //            }
-//            int k = (query(l, r, 1, n, root[l]) + 1) >> 1;
-//            lastAns = find(k, 1, n, root[l]);
+//            k = (queryDiff(l, r, 1, n, root[l]) + 1) >> 1;
+//            lastAns = queryKth(k, 1, n, root[l]);
 //            cout << " " << lastAns;
 //        }
 //        cout << "\n";

From 242ce501297b8b2f333fbfed8915bc94b1365330 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 18:39:27 +0800
Subject: [PATCH 0335/1712] modify code

---
 ...ava => Code01_PersistentSegmentTree1.java} |  63 +++---
 .../Code01_PersistentSegmentTree2.java        | 110 +++++++++++
 ...lest.java => Code02_MissingSmallest1.java} |  46 +++--
 src/class157/Code02_MissingSmallest2.java     |  95 +++++++++
 src/class157/Code03_DifferentNumbers1.java    |  24 ++-
 src/class157/Code03_DifferentNumbers2.java    |  26 ++-
 ...a => Code04_LazyTagPermanentization1.java} |  17 +-
 ...a => Code04_LazyTagPermanentization2.java} |  25 ++-
 ...dian.java => Code05_LargestUpMedian1.java} |  38 ++--
 src/class157/Code05_LargestUpMedian2.java     | 163 ++++++++++++++++
 ...ntOnTree.java => Code06_CountOnTree1.java} |  34 ++--
 src/class157/Code06_CountOnTree2.java         | 180 ++++++++++++++++++
 ...sive1.java => Code07_MoreImpressive1.java} |  10 +-
 ...sive2.java => Code07_MoreImpressive2.java} |  12 +-
 14 files changed, 737 insertions(+), 106 deletions(-)
 rename src/class157/{Code01_PersistentSegmentTree.java => Code01_PersistentSegmentTree1.java} (85%)
 create mode 100644 src/class157/Code01_PersistentSegmentTree2.java
 rename src/class157/{Code02_MissingSmallest.java => Code02_MissingSmallest1.java} (75%)
 create mode 100644 src/class157/Code02_MissingSmallest2.java
 rename src/class157/{Code07_ToTheMoon1.java => Code04_LazyTagPermanentization1.java} (87%)
 rename src/class157/{Code07_ToTheMoon2.java => Code04_LazyTagPermanentization2.java} (78%)
 rename src/class157/{Code04_LargestMedian.java => Code05_LargestUpMedian1.java} (75%)
 create mode 100644 src/class157/Code05_LargestUpMedian2.java
 rename src/class157/{Code05_CountOnTree.java => Code06_CountOnTree1.java} (84%)
 create mode 100644 src/class157/Code06_CountOnTree2.java
 rename src/class157/{Code06_MoreImpressive1.java => Code07_MoreImpressive1.java} (90%)
 rename src/class157/{Code06_MoreImpressive2.java => Code07_MoreImpressive2.java} (84%)

diff --git a/src/class157/Code01_PersistentSegmentTree.java b/src/class157/Code01_PersistentSegmentTree1.java
similarity index 85%
rename from src/class157/Code01_PersistentSegmentTree.java
rename to src/class157/Code01_PersistentSegmentTree1.java
index 2e6c3119e..8b4897e77 100644
--- a/src/class157/Code01_PersistentSegmentTree.java
+++ b/src/class157/Code01_PersistentSegmentTree1.java
@@ -1,6 +1,9 @@
 package class157;
 
-// 可持久化线段树模版题
+// 可持久化线段树模版题，java版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 l r k : 打印arr[l..r]中第k小的数字
+// 1 <= n、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +15,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code01_PersistentSegmentTree {
+public class Code01_PersistentSegmentTree1 {
 
 	public static int MAXN = 200001;
 
@@ -22,7 +25,7 @@ public class Code01_PersistentSegmentTree {
 
 	public static int[] arr = new int[MAXN];
 
-	public static int[] sort = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
 
 	public static int[] root = new int[MAXN];
 
@@ -34,31 +37,11 @@ public class Code01_PersistentSegmentTree {
 
 	public static int cnt;
 
-	public static int build(int l, int r) {
-		int rt = ++cnt;
-		size[rt] = 0;
-		if (l < r) {
-			int mid = (l + r) / 2;
-			left[rt] = build(l, mid);
-			right[rt] = build(mid + 1, r);
-		}
-		return rt;
-	}
-
-	public static void prepare() {
-		cnt = 0;
-		for (int i = 1; i <= n; i++) {
-			sort[i] = arr[i];
-		}
-		Arrays.sort(sort, 1, n + 1);
-		root[0] = build(1, n);
-	}
-
-	public static int rank(int v) {
+	public static int kth(int num) {
 		int l = 1, r = n, m, ans = 0;
 		while (l <= r) {
 			m = (l + r) / 2;
-			if (sort[m] <= v) {
+			if (sorted[m] <= num) {
 				ans = m;
 				l = m + 1;
 			} else {
@@ -68,6 +51,17 @@ public static int rank(int v) {
 		return ans;
 	}
 
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		size[rt] = 0;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
 	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
@@ -97,6 +91,19 @@ public static int query(int jobk, int l, int r, int u, int v) {
 		}
 	}
 
+	public static void prepare() {
+		cnt = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		root[0] = build(1, n);
+		for (int i = 1, x; i <= n; i++) {
+			x = kth(arr[i]);
+			root[i] = insert(x, 1, n, root[i - 1]);
+		}
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -110,10 +117,6 @@ public static void main(String[] args) throws IOException {
 			arr[i] = (int) in.nval;
 		}
 		prepare();
-		for (int i = 1, x; i <= n; i++) {
-			x = rank(arr[i]);
-			root[i] = insert(x, 1, n, root[i - 1]);
-		}
 		for (int i = 1, l, r, k; i <= q; i++) {
 			in.nextToken();
 			l = (int) in.nval;
@@ -122,7 +125,7 @@ public static void main(String[] args) throws IOException {
 			in.nextToken();
 			k = (int) in.nval;
 			int ans = query(k, 1, n, root[l - 1], root[r]);
-			out.println(sort[ans]);
+			out.println(sorted[ans]);
 		}
 		out.flush();
 		out.close();
diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code01_PersistentSegmentTree2.java
new file mode 100644
index 000000000..ea65a6e86
--- /dev/null
+++ b/src/class157/Code01_PersistentSegmentTree2.java
@@ -0,0 +1,110 @@
+package class157;
+
+// 可持久化线段树模版题，C++版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 l r k : 打印arr[l..r]中第k小的数字
+// 1 <= n、q <= 2 * 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <cstdio>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXM = MAXN * 22;
+//int n, q;
+//int arr[MAXN];
+//int sorted[MAXN];
+//int root[MAXN];
+//int ls[MAXM];
+//int rs[MAXM];
+//int size[MAXM];
+//int cnt;
+//
+//int kth(int num) {
+//    int l = 1, r = n, m, ans = 0;
+//    while (l <= r) {
+//        m = (l + r) / 2;
+//        if (sorted[m] <= num) {
+//            ans = m;
+//            l = m + 1;
+//        } else {
+//            r = m - 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    size[rt] = 0;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int insert(int jobi, int l, int r, int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    size[rt] = size[i] + 1;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//int query(int jobk, int l, int r, int u, int v) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int lsize = size[ls[v]] - size[ls[u]];
+//    int mid = (l + r) / 2;
+//    if (lsize >= jobk) {
+//        return query(jobk, l, mid, ls[u], ls[v]);
+//    } else {
+//        return query(jobk - lsize, mid + 1, r, rs[u], rs[v]);
+//    }
+//}
+//
+//void prepare() {
+//    cnt = 0;
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    root[0] = build(1, n);
+//    for (int i = 1, x; i <= n; i++) {
+//        x = kth(arr[i]);
+//        root[i] = insert(x, 1, n, root[i - 1]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, l, r, k; i <= q; i++) {
+//        cin >> l >> r >> k;
+//        int ans = query(k, 1, n, root[l - 1], root[r]);
+//        cout << sorted[ans] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code02_MissingSmallest.java b/src/class157/Code02_MissingSmallest1.java
similarity index 75%
rename from src/class157/Code02_MissingSmallest.java
rename to src/class157/Code02_MissingSmallest1.java
index a3c71451d..5de0adba5 100644
--- a/src/class157/Code02_MissingSmallest.java
+++ b/src/class157/Code02_MissingSmallest1.java
@@ -1,9 +1,9 @@
 package class157;
 
-// 区间内没有出现的最小自然数
-// 给定一个长度为n的数组arr，一共有m次询问
-// 每次查询一个区间[l, r]内没有出现过的最小自然数
-// 注意0是自然数
+// 区间内没有出现的最小自然数，java版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
+// 1 <= n、q、arr[i] <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4137
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_MissingSmallest {
+public class Code02_MissingSmallest1 {
 
 	public static int MAXN = 200001;
 
@@ -22,6 +22,8 @@ public class Code02_MissingSmallest {
 
 	public static int n, q;
 
+	public static int[] arr = new int[MAXN];
+
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXM];
@@ -34,6 +36,17 @@ public class Code02_MissingSmallest {
 
 	public static int cnt;
 
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		lateLeft[rt] = 0;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
@@ -70,6 +83,18 @@ public static int query(int pos, int l, int r, int i) {
 		}
 	}
 
+	public static void prepare() {
+		cnt = 0;
+		root[0] = build(1, n);
+		for (int i = 1; i <= n; i++) {
+			if (arr[i] >= n) {
+				root[i] = root[i - 1];
+			} else {
+				root[i] = update(arr[i], i, 0, n, root[i - 1]);
+			}
+		}
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -78,16 +103,11 @@ public static void main(String[] args) throws IOException {
 		n = (int) in.nval;
 		in.nextToken();
 		q = (int) in.nval;
-		cnt = 0;
-		for (int i = 1, v; i <= n; i++) {
+		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			v = (int) in.nval;
-			if (v >= n) {
-				root[i] = root[i - 1];
-			} else {
-				root[i] = update(v, i, 0, n, root[i - 1]);
-			}
+			arr[i] = (int) in.nval;
 		}
+		prepare();
 		for (int i = 1, l, r; i <= q; i++) {
 			in.nextToken();
 			l = (int) in.nval;
diff --git a/src/class157/Code02_MissingSmallest2.java b/src/class157/Code02_MissingSmallest2.java
new file mode 100644
index 000000000..59164ff00
--- /dev/null
+++ b/src/class157/Code02_MissingSmallest2.java
@@ -0,0 +1,95 @@
+package class157;
+
+// 区间内没有出现的最小自然数，C++版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
+// 1 <= n、q、arr[i] <= 2 * 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P4137
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <cstdio>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXM = MAXN * 22;
+//int n, q;
+//int arr[MAXN];
+//int root[MAXN];
+//int ls[MAXM];
+//int rs[MAXM];
+//int lateLeft[MAXM];
+//int cnt;
+//
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    lateLeft[rt] = 0;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int update(int jobi, int jobv, int l, int r, int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    lateLeft[rt] = lateLeft[i];
+//    if (l == r) {
+//        lateLeft[rt] = jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//        lateLeft[rt] = min(lateLeft[ls[rt]], lateLeft[rs[rt]]);
+//    }
+//    return rt;
+//}
+//
+//int query(int pos, int l, int r, int i) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) / 2;
+//    if (lateLeft[ls[i]] < pos) {
+//        return query(pos, l, mid, ls[i]);
+//    } else {
+//        return query(pos, mid + 1, r, rs[i]);
+//    }
+//}
+//
+//void prepare() {
+//    cnt = 0;
+//    root[0] = build(1, n);
+//    for (int i = 1; i <= n; i++) {
+//        if (arr[i] >= n) {
+//            root[i] = root[i - 1];
+//        } else {
+//            root[i] = update(arr[i], i, 0, n, root[i - 1]);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 0, l, r; i < q; i++) {
+//        cin >> l >> r;
+//        cout << query(l, 0, n, root[r]) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code03_DifferentNumbers1.java b/src/class157/Code03_DifferentNumbers1.java
index ace768bdf..993ec3d87 100644
--- a/src/class157/Code03_DifferentNumbers1.java
+++ b/src/class157/Code03_DifferentNumbers1.java
@@ -1,6 +1,15 @@
 package class157;
 
 // 区间内的不同数字，java版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
+// 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
+// 每次给定的l和r，按照如下方式得到真实的l和r，查询完成后更新lastAns
+// a = (给定l + lastAns) % n + 1
+// b = (给定r + lastAns) % n + 1
+// 真实l = min(a, b)
+// 真实r = max(a, b)
+// 1 <= n、q、arr[i] <= 2 * 10^5
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -113,15 +122,12 @@ public static void main(String[] args) throws IOException {
 			io.write("Case #");
 			io.writeInt(t);
 			io.write(":");
-			for (int i = 1, l, r, k, lastAns = 0; i <= q; i++) {
-				l = (io.nextInt() + lastAns) % n + 1;
-				r = (io.nextInt() + lastAns) % n + 1;
-				if (l > r) {
-					int tmp = l;
-					l = r;
-					r = tmp;
-				}
-				k = (queryDiff(l, r, 1, n, root[l]) + 1) >> 1;
+			for (int i = 1, a, b, l, r, k, lastAns = 0; i <= q; i++) {
+				a = (io.nextInt() + lastAns) % n + 1;
+				b = (io.nextInt() + lastAns) % n + 1;
+				l = Math.min(a, b);
+				r = Math.max(a, b);
+				k = (queryDiff(l, r, 1, n, root[l]) + 1) / 2;
 				lastAns = queryKth(k, 1, n, root[l]);
 				io.write(" ");
 				io.writeInt(lastAns);
diff --git a/src/class157/Code03_DifferentNumbers2.java b/src/class157/Code03_DifferentNumbers2.java
index cf8ffec03..25291fdfb 100644
--- a/src/class157/Code03_DifferentNumbers2.java
+++ b/src/class157/Code03_DifferentNumbers2.java
@@ -1,6 +1,15 @@
 package class157;
 
 // 区间内的不同数字，C++版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
+// 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
+// 每次给定的l和r，按照如下方式得到真实的l和r，查询完成后更新lastAns
+// a = (给定l + lastAns) % n + 1
+// b = (给定r + lastAns) % n + 1
+// 真实l = min(a, b)
+// 真实r = max(a, b)
+// 1 <= n、q、arr[i] <= 2 * 10^5
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -9,8 +18,8 @@
 //
 //using namespace std;
 //
-//static const int MAXN = 200002;
-//static const int MAXM = MAXN * 37;
+//const int MAXN = 200002;
+//const int MAXM = MAXN * 37;
 //int cases, n, q;
 //int arr[MAXN];
 //int pos[MAXN];
@@ -102,14 +111,13 @@
 //        }
 //        prepare();
 //        cout << "Case #" << t << ":";
-//        for (int i = 1, l, r, k, lastAns = 0; i <= q; i++) {
+//        for (int i = 1, a, b, l, r, k, lastAns = 0; i <= q; i++) {
 //            cin >> l >> r;
-//            l = (l + lastAns) % n + 1;
-//            r = (r + lastAns) % n + 1;
-//            if (l > r) {
-//                swap(l, r);
-//            }
-//            k = (queryDiff(l, r, 1, n, root[l]) + 1) >> 1;
+//            a = (l + lastAns) % n + 1;
+//            b = (r + lastAns) % n + 1;
+//            l = min(a, b);
+//            r = max(a, b);
+//            k = (queryDiff(l, r, 1, n, root[l]) + 1) / 2;
 //            lastAns = queryKth(k, 1, n, root[l]);
 //            cout << " " << lastAns;
 //        }
diff --git a/src/class157/Code07_ToTheMoon1.java b/src/class157/Code04_LazyTagPermanentization1.java
similarity index 87%
rename from src/class157/Code07_ToTheMoon1.java
rename to src/class157/Code04_LazyTagPermanentization1.java
index 2c83a452a..3fcaba968 100644
--- a/src/class157/Code07_ToTheMoon1.java
+++ b/src/class157/Code04_LazyTagPermanentization1.java
@@ -1,10 +1,18 @@
 package class157;
 
-// 去月球，java版
+// 可持久化线段树的标签永久化，java版
+// 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
+// 一共有q条查询，每条查询为如下四种类型中的一种
+// C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
+// Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
+// H x y z : z版本的数组，打印[x..y]范围的累加和
+// B x     : 当前时间戳t设置成x
+// 1 <= n、q <= 10^5
+// -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
-// 想通过用C++写吧，本节课Code07_ToTheMoon2文件就是C++的实现
+// 想通过用C++写吧，本节课Code04_LazyTagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -12,7 +20,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code07_ToTheMoon1 {
+public class Code04_LazyTagPermanentization1 {
 
 	public static int MAXN = 100001;
 
@@ -117,7 +125,8 @@ public static void main(String[] args) throws IOException {
 				z = in.nextInt();
 				out.write(query(x, y, 0, 1, n, root[z]) + "\n");
 			} else {
-				t = in.nextInt();
+				x = in.nextInt();
+				t = x;
 			}
 		}
 		out.flush();
diff --git a/src/class157/Code07_ToTheMoon2.java b/src/class157/Code04_LazyTagPermanentization2.java
similarity index 78%
rename from src/class157/Code07_ToTheMoon2.java
rename to src/class157/Code04_LazyTagPermanentization2.java
index a9ae682e4..05002d400 100644
--- a/src/class157/Code07_ToTheMoon2.java
+++ b/src/class157/Code04_LazyTagPermanentization2.java
@@ -1,6 +1,14 @@
 package class157;
 
-// 去月球，C++版
+// 可持久化线段树的标签永久化，C++版
+// 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
+// 一共有q条查询，每条查询为如下四种类型中的一种
+// C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
+// Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
+// H x y z : z版本的数组，打印[x..y]范围的累加和
+// B x     : 当前时间戳t设置成x
+// 1 <= n、q <= 10^5
+// -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -10,8 +18,8 @@
 //
 //using namespace std;
 //
-//static const int MAXN = 100001;
-//static const int MAXM = MAXN * 25;
+//const int MAXN = 100001;
+//const int MAXM = MAXN * 25;
 //int n, q, t = 0;
 //long long arr[MAXN];
 //int root[MAXN];
@@ -78,25 +86,24 @@
 //        cin >> arr[i];
 //    }
 //    root[0] = build(1, n);
+//    char op;
+//    int x, y;
+//    long long z;
 //    for (int i = 1; i <= q; i++) {
-//        char op;
 //        cin >> op;
 //        if (op == 'C') {
-//            int x, y;
-//            long long z;
 //            cin >> x >> y >> z;
 //            root[t + 1] = add(x, y, z, 1, n, root[t]);
 //            t++;
 //        } else if (op == 'Q') {
-//            int x, y;
 //            cin >> x >> y;
 //            cout << query(x, y, 0, 1, n, root[t]) << "\n";
 //        } else if (op == 'H') {
-//            int x, y, z;
 //            cin >> x >> y >> z;
 //            cout << query(x, y, 0, 1, n, root[z]) << "\n";
 //        } else {
-//            cin >> t;
+//            cin >> x;
+//            t = x;
 //        }
 //    }
 //    return 0;
diff --git a/src/class157/Code04_LargestMedian.java b/src/class157/Code05_LargestUpMedian1.java
similarity index 75%
rename from src/class157/Code04_LargestMedian.java
rename to src/class157/Code05_LargestUpMedian1.java
index ac09b95c0..9575f88cd 100644
--- a/src/class157/Code04_LargestMedian.java
+++ b/src/class157/Code05_LargestUpMedian1.java
@@ -1,6 +1,15 @@
 package class157;
 
-// 区间内最大中位数
+// 区间最大上中位数，java版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
+//                   哪个区间有最大的上中位数，打印最大的上中位数
+// 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
+// 每次给定四个参数，按照如下方式得到a、b、c、d，查询完成后更新lastAns
+// (给定的每个参数 + lastAns) % n + 1，得到四个值，从小到大对应a、b、c、d
+// 1 <= n <= 20000
+// 1 <= q <= 25000
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2839
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_LargestMedian {
+public class Code05_LargestUpMedian1 {
 
 	public static int MAXN = 20001;
 
@@ -120,27 +129,26 @@ public static void prepare() {
 		}
 	}
 
-	public static boolean check(int i) {
-		int a = ques[0] + 1, b = ques[1] + 1, c = ques[2] + 1, d = ques[3] + 1, best;
+	public static boolean check(int a, int b, int c, int d, int v) {
 		initInfo();
-		query(a, b, 1, n, root[i]);
-		best = info[1];
+		query(a, b, 1, n, root[v]);
+		int best = info[1];
 		initInfo();
-		query(c, d, 1, n, root[i]);
+		query(c, d, 1, n, root[v]);
 		best += info[0];
 		if (b + 1 <= c - 1) {
 			initInfo();
-			query(b + 1, c - 1, 1, n, root[i]);
+			query(b + 1, c - 1, 1, n, root[v]);
 			best += info[2];
 		}
 		return best >= 0;
 	}
 
-	public static int compute() {
+	public static int compute(int a, int b, int c, int d) {
 		int l = 1, r = n, m, ans = 0;
 		while (l <= r) {
 			m = (l + r) / 2;
-			if (check(m)) {
+			if (check(a, b, c, d, m)) {
 				ans = arr[m][1];
 				l = m + 1;
 			} else {
@@ -166,15 +174,15 @@ public static void main(String[] args) throws IOException {
 		q = (int) in.nval;
 		for (int i = 1, lastAns = 0; i <= q; i++) {
 			in.nextToken();
-			ques[0] = ((int) in.nval + lastAns) % n;
+			ques[0] = ((int) in.nval + lastAns) % n + 1;
 			in.nextToken();
-			ques[1] = ((int) in.nval + lastAns) % n;
+			ques[1] = ((int) in.nval + lastAns) % n + 1;
 			in.nextToken();
-			ques[2] = ((int) in.nval + lastAns) % n;
+			ques[2] = ((int) in.nval + lastAns) % n + 1;
 			in.nextToken();
-			ques[3] = ((int) in.nval + lastAns) % n;
+			ques[3] = ((int) in.nval + lastAns) % n + 1;
 			Arrays.sort(ques);
-			lastAns = compute();
+			lastAns = compute(ques[0], ques[1], ques[2], ques[3]);
 			out.println(lastAns);
 		}
 		out.flush();
diff --git a/src/class157/Code05_LargestUpMedian2.java b/src/class157/Code05_LargestUpMedian2.java
new file mode 100644
index 000000000..b0d11dbf3
--- /dev/null
+++ b/src/class157/Code05_LargestUpMedian2.java
@@ -0,0 +1,163 @@
+package class157;
+
+// 区间最大上中位数，C++版
+// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
+//                   哪个区间有最大的上中位数，打印最大的上中位数
+// 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
+// 每次给定四个参数，按照如下方式得到a、b、c、d，查询完成后更新lastAns
+// (给定的每个参数 + lastAns) % n + 1，得到四个值，从小到大对应a、b、c、d
+// 1 <= n <= 20000
+// 1 <= q <= 25000
+// 1 <= arr[i] <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P2839
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <cstdio>
+//#include <cstring>
+//
+//using namespace std;
+//
+//const int MAXN = 20001;
+//const int MAXM = MAXN * 20;
+//const int INF = 10000001;
+//int n, q;
+//vector<pair<int, int>> arr;
+//int root[MAXN];
+//int ls[MAXM];
+//int rs[MAXM];
+//int pre[MAXM];
+//int suf[MAXM];
+//int sum[MAXM];
+//int cnt;
+//int ques[4], info[3];
+//
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    pre[rt] = suf[rt] = sum[rt] = r - l + 1;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//void up(int i) {
+//    pre[i] = max(pre[ls[i]], sum[ls[i]] + pre[rs[i]]);
+//    suf[i] = max(suf[rs[i]], suf[ls[i]] + sum[rs[i]]);
+//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//}
+//
+//int update(int jobi, int l, int r, int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    pre[rt] = pre[i];
+//    suf[rt] = suf[i];
+//    sum[rt] = sum[i];
+//    if (l == r) {
+//        pre[rt] = suf[rt] = sum[rt] = -1;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = update(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = update(jobi, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//void initInfo() {
+//    info[0] = info[1] = -INF;
+//    info[2] = 0;
+//}
+//
+//void mergeRight(int r) {
+//    info[0] = max(info[0], info[2] + pre[r]);
+//    info[1] = max(suf[r], info[1] + sum[r]);
+//    info[2] += sum[r];
+//}
+//
+//void query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        mergeRight(i);
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobl <= mid) {
+//            query(jobl, jobr, l, mid, ls[i]);
+//        }
+//        if (jobr > mid) {
+//            query(jobl, jobr, mid + 1, r, rs[i]);
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    sort(arr.begin() + 1, arr.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
+//        return a.second < b.second;
+//    });
+//    cnt = 0;
+//    root[1] = build(1, n);
+//    for (int i = 2; i <= n; i++) {
+//        root[i] = update(arr[i - 1].first, 1, n, root[i - 1]);
+//    }
+//}
+//
+//bool check(int a, int b, int c, int d, int v) {
+//    initInfo();
+//    query(a, b, 1, n, root[v]);
+//    int best = info[1];
+//    initInfo();
+//    query(c, d, 1, n, root[v]);
+//    best += info[0];
+//    if (b + 1 <= c - 1) {
+//        initInfo();
+//        query(b + 1, c - 1, 1, n, root[v]);
+//        best += info[2];
+//    }
+//    return best >= 0;
+//}
+//
+//int compute(int a, int b, int c, int d) {
+//    int l = 1, r = n, m, ans = 0;
+//    while (l <= r) {
+//        m = (l + r) / 2;
+//        if (check(a, b, c, d, m)) {
+//            ans = arr[m].second;
+//            l = m + 1;
+//        } else {
+//            r = m - 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    arr.resize(n + 1);
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].first = i;
+//        cin >> arr[i].second;
+//    }
+//    prepare();
+//    cin >> q;
+//    for (int i = 1, lastAns = 0; i <= q; i++) {
+//        for (int j = 0; j < 4; j++) {
+//            cin >> ques[j];
+//            ques[j] = (ques[j] + lastAns) % n + 1;
+//        }
+//        sort(ques, ques + 4);
+//        lastAns = compute(ques[0], ques[1], ques[2], ques[3]);
+//        cout << lastAns << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code05_CountOnTree.java b/src/class157/Code06_CountOnTree1.java
similarity index 84%
rename from src/class157/Code05_CountOnTree.java
rename to src/class157/Code06_CountOnTree1.java
index 4b138446c..a9464950b 100644
--- a/src/class157/Code05_CountOnTree.java
+++ b/src/class157/Code06_CountOnTree1.java
@@ -1,6 +1,12 @@
 package class157;
 
-// 节点路径第k小值
+// 节点路径第k小值，java版
+// 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
+// 一共有q条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
+// 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
+// 每次给定的u、v、k，按照如下方式得到真实的u、v、k，查询完成后更新lastAns
+// 真实u = 给定u ^ lastAns    真实v = 给定v    真实k = 给定k
+// 1 <= n、q <= 10^5    1 <= arr[i] <= 2^32 - 1
 // 测试链接 : https://www.luogu.com.cn/problem/P2633
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +18,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code05_CountOnTree {
+public class Code06_CountOnTree1 {
 
 	public static int MAXN = 100001;
 
@@ -26,7 +32,7 @@ public class Code05_CountOnTree {
 	public static int[] arr = new int[MAXN];
 
 	// 收集权值排序做离散化
-	public static int[] sort = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
 
 	// 链式前向星需要
 	public static int[] head = new int[MAXN];
@@ -53,13 +59,13 @@ public class Code05_CountOnTree {
 
 	public static int[][] stjump = new int[MAXN][MAXH];
 
-	public static int rank(int num) {
+	public static int kth(int num) {
 		int l = 1, r = s, m;
 		while (l <= r) {
 			m = (l + r) / 2;
-			if (sort[m] == num) {
+			if (sorted[m] == num) {
 				return m;
-			} else if (sort[m] < num) {
+			} else if (sorted[m] < num) {
 				l = m + 1;
 			} else {
 				r = m - 1;
@@ -81,13 +87,13 @@ public static int build(int l, int r) {
 
 	public static void prepare() {
 		for (int i = 1; i <= n; i++) {
-			sort[i] = arr[i];
+			sorted[i] = arr[i];
 		}
-		Arrays.sort(sort, 1, n + 1);
+		Arrays.sort(sorted, 1, n + 1);
 		s = 1;
 		for (int i = 2; i <= n; i++) {
-			if (sort[s] != sort[i]) {
-				sort[++s] = sort[i];
+			if (sorted[s] != sorted[i]) {
+				sorted[++s] = sorted[i];
 			}
 		}
 		root[0] = build(1, s);
@@ -130,7 +136,7 @@ public static int query(int jobk, int l, int r, int u, int v, int lca, int lcafa
 
 	// 递归版，C++可以通过，java无法通过，递归会爆栈
 	public static void dfs1(int u, int f) {
-		root[u] = insert(rank(arr[u]), 1, s, root[f]);
+		root[u] = insert(kth(arr[u]), 1, s, root[f]);
 		deep[u] = deep[f] + 1;
 		stjump[u][0] = f;
 		for (int p = 1; p < MAXH; p++) {
@@ -170,7 +176,7 @@ public static void dfs2() {
 		while (stackSize > 0) {
 			pop();
 			if (e == -1) {
-				root[u] = insert(rank(arr[u]), 1, s, root[f]);
+				root[u] = insert(kth(arr[u]), 1, s, root[f]);
 				deep[u] = deep[f] + 1;
 				stjump[u][0] = f;
 				for (int p = 1; p < MAXH; p++) {
@@ -215,7 +221,7 @@ public static int lca(int a, int b) {
 	public static int kth(int u, int v, int k) {
 		int lca = lca(u, v);
 		int i = query(k, 1, s, root[u], root[v], root[lca], root[stjump[lca][0]]);
-		return sort[i];
+		return sorted[i];
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -242,7 +248,7 @@ public static void main(String[] args) throws IOException {
 		dfs2(); // 使用迭代版防止爆栈
 		for (int i = 1, u, v, k, lastAns = 0; i <= q; i++) {
 			in.nextToken();
-			u = (int) in.nval ^ lastAns; // 题目要求
+			u = (int) in.nval ^ lastAns;
 			in.nextToken();
 			v = (int) in.nval;
 			in.nextToken();
diff --git a/src/class157/Code06_CountOnTree2.java b/src/class157/Code06_CountOnTree2.java
new file mode 100644
index 000000000..66d624dc3
--- /dev/null
+++ b/src/class157/Code06_CountOnTree2.java
@@ -0,0 +1,180 @@
+package class157;
+
+// 节点路径第k小值，C++版
+// 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
+// 一共有q条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
+// 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
+// 每次给定的u、v、k，按照如下方式得到真实的u、v、k，查询完成后更新lastAns
+// 真实u = 给定u ^ lastAns    真实v = 给定v    真实k = 给定k
+// 1 <= n、q <= 10^5    1 <= arr[i] <= 2^32 - 1
+// 测试链接 : https://www.luogu.com.cn/problem/P2633
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <vector>
+//#include <algorithm>
+//#include <cstdio>
+//#include <cstring>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXH = 20;
+//const int MAXM = MAXN * MAXH;
+//int n, s, q;
+//int arr[MAXN];
+//int sorted[MAXN];
+//
+//int head[MAXN];
+//int to[MAXN << 1];
+//int nextEdge[MAXN << 1];
+//int cntg = 0;
+//
+//int root[MAXN];
+//int ls[MAXM];
+//int rs[MAXM];
+//int size[MAXM];
+//int cntt = 0;
+//
+//int deep[MAXN];
+//int stjump[MAXN][MAXH];
+//
+//int kth(int num) {
+//    int l = 1, r = s, m;
+//    while (l <= r) {
+//        m = (l + r) / 2;
+//        if (sorted[m] == num) {
+//            return m;
+//        } else if (sorted[m] < num) {
+//            l = m + 1;
+//        } else {
+//            r = m - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
+//int build(int l, int r) {
+//    int rt = ++cntt;
+//    size[rt] = 0;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[s] != sorted[i]) {
+//            sorted[++s] = sorted[i];
+//        }
+//    }
+//    root[0] = build(1, s);
+//}
+//
+//void addEdge(int u, int v) {
+//	nextEdge[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int insert(int jobi, int l, int r, int i) {
+//    int rt = ++cntt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    size[rt] = size[i] + 1;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//int query(int jobk, int l, int r, int u, int v, int lca, int lcafa) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int lsize = size[ls[u]] + size[ls[v]] - size[ls[lca]] - size[ls[lcafa]];
+//    int mid = (l + r) / 2;
+//    if (lsize >= jobk) {
+//        return query(jobk, l, mid, ls[u], ls[v], ls[lca], ls[lcafa]);
+//    } else {
+//        return query(jobk - lsize, mid + 1, r, rs[u], rs[v], rs[lca], rs[lcafa]);
+//    }
+//}
+//
+//void dfs(int u, int f) {
+//    root[u] = insert(kth(arr[u]), 1, s, root[f]);
+//    deep[u] = deep[f] + 1;
+//    stjump[u][0] = f;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int ei = head[u]; ei > 0; ei = nextEdge[ei]) {
+//        if (to[ei] != f) {
+//            dfs(to[ei], u);
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    if (deep[a] < deep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (deep[stjump[a][p]] >= deep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int kth(int u, int v, int k) {
+//    int lcaNode = lca(u, v);
+//    int i = query(k, 1, s, root[u], root[v], root[lcaNode], root[stjump[lcaNode][0]]);
+//    return sorted[i];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs(1, 0);
+//    for (int i = 1, u, v, k, lastAns = 0; i <= q; i++) {
+//        cin >> u >> v >> k;
+//        u ^= lastAns;
+//        lastAns = kth(u, v, k);
+//        cout << lastAns << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code06_MoreImpressive1.java b/src/class157/Code07_MoreImpressive1.java
similarity index 90%
rename from src/class157/Code06_MoreImpressive1.java
rename to src/class157/Code07_MoreImpressive1.java
index d470737c7..e9fa77da6 100644
--- a/src/class157/Code06_MoreImpressive1.java
+++ b/src/class157/Code07_MoreImpressive1.java
@@ -1,6 +1,14 @@
 package class157;
 
 // 更为厉害，java版
+// 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
+// 如果节点a是节点b的祖先节点，认为"a比b更厉害"
+// 如果节点a到节点b的路径上边的数量 <= 常数k，认为"a和b是盟友"
+// 一共有q条查询，每条查询 p k : 查询有多少三元组(a, b, c)满足如下规定
+// 1，a就是节点p，但是a、b、c为三个不同的点
+// 2，a和b都比c厉害
+// 3，a和b是盟友，路径上边的数量 <= 给定的k
+// 1 <= n、q、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -11,7 +19,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_MoreImpressive1 {
+public class Code07_MoreImpressive1 {
 
 	public static int MAXN = 300001;
 
diff --git a/src/class157/Code06_MoreImpressive2.java b/src/class157/Code07_MoreImpressive2.java
similarity index 84%
rename from src/class157/Code06_MoreImpressive2.java
rename to src/class157/Code07_MoreImpressive2.java
index e33ed5d16..de8245cac 100644
--- a/src/class157/Code06_MoreImpressive2.java
+++ b/src/class157/Code07_MoreImpressive2.java
@@ -1,6 +1,14 @@
 package class157;
 
 // 更为厉害，C++版
+// 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
+// 如果节点a是节点b的祖先节点，认为"a比b更厉害"
+// 如果节点a到节点b的路径上边的数量 <= 常数k，认为"a和b是盟友"
+// 一共有q条查询，每条查询 p k : 查询有多少三元组(a, b, c)满足如下规定
+// 1，a就是节点p，但是a、b、c为三个不同的点
+// 2，a和b都比c厉害
+// 3，a和b是盟友，路径上边的数量 <= 给定的k
+// 1 <= n、q、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -9,8 +17,8 @@
 //
 //using namespace std;
 //
-//static const int MAXN = 300001;
-//static const int MAXM = MAXN * 22;
+//const int MAXN = 300001;
+//const int MAXM = MAXN * 22;
 //int n, q;
 //
 //int head[MAXN];

From 550c0c0aa8684c59abd17d5b9f29b3bc1a85e76f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 18:57:48 +0800
Subject: [PATCH 0336/1712] modify code

---
 ...e05_LargestUpMedian1.java => Code04_LargestUpMedian1.java} | 2 +-
 ...e05_LargestUpMedian2.java => Code04_LargestUpMedian2.java} | 0
 ...nentization1.java => Code05_LazyTagPermanentization1.java} | 4 ++--
 ...nentization2.java => Code05_LazyTagPermanentization2.java} | 0
 4 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class157/{Code05_LargestUpMedian1.java => Code04_LargestUpMedian1.java} (99%)
 rename src/class157/{Code05_LargestUpMedian2.java => Code04_LargestUpMedian2.java} (100%)
 rename src/class157/{Code04_LazyTagPermanentization1.java => Code05_LazyTagPermanentization1.java} (98%)
 rename src/class157/{Code04_LazyTagPermanentization2.java => Code05_LazyTagPermanentization2.java} (100%)

diff --git a/src/class157/Code05_LargestUpMedian1.java b/src/class157/Code04_LargestUpMedian1.java
similarity index 99%
rename from src/class157/Code05_LargestUpMedian1.java
rename to src/class157/Code04_LargestUpMedian1.java
index 9575f88cd..ad1c76f2e 100644
--- a/src/class157/Code05_LargestUpMedian1.java
+++ b/src/class157/Code04_LargestUpMedian1.java
@@ -21,7 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code05_LargestUpMedian1 {
+public class Code04_LargestUpMedian1 {
 
 	public static int MAXN = 20001;
 
diff --git a/src/class157/Code05_LargestUpMedian2.java b/src/class157/Code04_LargestUpMedian2.java
similarity index 100%
rename from src/class157/Code05_LargestUpMedian2.java
rename to src/class157/Code04_LargestUpMedian2.java
diff --git a/src/class157/Code04_LazyTagPermanentization1.java b/src/class157/Code05_LazyTagPermanentization1.java
similarity index 98%
rename from src/class157/Code04_LazyTagPermanentization1.java
rename to src/class157/Code05_LazyTagPermanentization1.java
index 3fcaba968..8f99554ef 100644
--- a/src/class157/Code04_LazyTagPermanentization1.java
+++ b/src/class157/Code05_LazyTagPermanentization1.java
@@ -12,7 +12,7 @@
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
-// 想通过用C++写吧，本节课Code04_LazyTagPermanentization2文件就是C++的实现
+// 想通过用C++写吧，本节课Code05_LazyTagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -20,7 +20,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code04_LazyTagPermanentization1 {
+public class Code05_LazyTagPermanentization1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class157/Code04_LazyTagPermanentization2.java b/src/class157/Code05_LazyTagPermanentization2.java
similarity index 100%
rename from src/class157/Code04_LazyTagPermanentization2.java
rename to src/class157/Code05_LazyTagPermanentization2.java

From 66eef1783bc6e704ef56869c6b00525689e937f1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 18:59:38 +0800
Subject: [PATCH 0337/1712] modify code

---
 ...ermanentization1.java => Code05_TagPermanentization1.java} | 4 ++--
 ...ermanentization2.java => Code05_TagPermanentization2.java} | 0
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class157/{Code05_LazyTagPermanentization1.java => Code05_TagPermanentization1.java} (97%)
 rename src/class157/{Code05_LazyTagPermanentization2.java => Code05_TagPermanentization2.java} (100%)

diff --git a/src/class157/Code05_LazyTagPermanentization1.java b/src/class157/Code05_TagPermanentization1.java
similarity index 97%
rename from src/class157/Code05_LazyTagPermanentization1.java
rename to src/class157/Code05_TagPermanentization1.java
index 8f99554ef..78417c0a1 100644
--- a/src/class157/Code05_LazyTagPermanentization1.java
+++ b/src/class157/Code05_TagPermanentization1.java
@@ -12,7 +12,7 @@
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
-// 想通过用C++写吧，本节课Code05_LazyTagPermanentization2文件就是C++的实现
+// 想通过用C++写吧，本节课Code05_TagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -20,7 +20,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code05_LazyTagPermanentization1 {
+public class Code05_TagPermanentization1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class157/Code05_LazyTagPermanentization2.java b/src/class157/Code05_TagPermanentization2.java
similarity index 100%
rename from src/class157/Code05_LazyTagPermanentization2.java
rename to src/class157/Code05_TagPermanentization2.java

From e8b15e724b23e5b13a7d8783d9b257e090659c65 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 19:15:25 +0800
Subject: [PATCH 0338/1712] modify code

---
 src/class157/Code06_CountOnTree1.java    | 3 ++-
 src/class157/Code06_CountOnTree2.java    | 3 ++-
 src/class157/Code07_MoreImpressive1.java | 1 +
 src/class157/Code07_MoreImpressive2.java | 1 +
 4 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code06_CountOnTree1.java b/src/class157/Code06_CountOnTree1.java
index a9464950b..5006b49cd 100644
--- a/src/class157/Code06_CountOnTree1.java
+++ b/src/class157/Code06_CountOnTree1.java
@@ -6,7 +6,8 @@
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的u、v、k，按照如下方式得到真实的u、v、k，查询完成后更新lastAns
 // 真实u = 给定u ^ lastAns    真实v = 给定v    真实k = 给定k
-// 1 <= n、q <= 10^5    1 <= arr[i] <= 2^32 - 1
+// 1 <= n、q <= 10^5
+// 1 <= arr[i] <= 2^32 - 1
 // 测试链接 : https://www.luogu.com.cn/problem/P2633
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class157/Code06_CountOnTree2.java b/src/class157/Code06_CountOnTree2.java
index 66d624dc3..a0f5c9bf3 100644
--- a/src/class157/Code06_CountOnTree2.java
+++ b/src/class157/Code06_CountOnTree2.java
@@ -6,7 +6,8 @@
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的u、v、k，按照如下方式得到真实的u、v、k，查询完成后更新lastAns
 // 真实u = 给定u ^ lastAns    真实v = 给定v    真实k = 给定k
-// 1 <= n、q <= 10^5    1 <= arr[i] <= 2^32 - 1
+// 1 <= n、q <= 10^5
+// 1 <= arr[i] <= 2^32 - 1
 // 测试链接 : https://www.luogu.com.cn/problem/P2633
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class157/Code07_MoreImpressive1.java b/src/class157/Code07_MoreImpressive1.java
index e9fa77da6..f7ebc522b 100644
--- a/src/class157/Code07_MoreImpressive1.java
+++ b/src/class157/Code07_MoreImpressive1.java
@@ -1,6 +1,7 @@
 package class157;
 
 // 更为厉害，java版
+// 原始题意有坑，多注意！
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
 // 如果节点a是节点b的祖先节点，认为"a比b更厉害"
 // 如果节点a到节点b的路径上边的数量 <= 常数k，认为"a和b是盟友"
diff --git a/src/class157/Code07_MoreImpressive2.java b/src/class157/Code07_MoreImpressive2.java
index de8245cac..884101dcd 100644
--- a/src/class157/Code07_MoreImpressive2.java
+++ b/src/class157/Code07_MoreImpressive2.java
@@ -1,6 +1,7 @@
 package class157;
 
 // 更为厉害，C++版
+// 原始题意有坑，多注意！
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
 // 如果节点a是节点b的祖先节点，认为"a比b更厉害"
 // 如果节点a到节点b的路径上边的数量 <= 常数k，认为"a和b是盟友"

From 784500f2ef0f95080e5bea0b2eb9301320046532 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 19:33:00 +0800
Subject: [PATCH 0339/1712] modify code

---
 ...anentization1.java => Code05_LazyPermanentization1.java} | 6 +++---
 ...anentization2.java => Code05_LazyPermanentization2.java} | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class157/{Code05_TagPermanentization1.java => Code05_LazyPermanentization1.java} (96%)
 rename src/class157/{Code05_TagPermanentization2.java => Code05_LazyPermanentization2.java} (98%)

diff --git a/src/class157/Code05_TagPermanentization1.java b/src/class157/Code05_LazyPermanentization1.java
similarity index 96%
rename from src/class157/Code05_TagPermanentization1.java
rename to src/class157/Code05_LazyPermanentization1.java
index 78417c0a1..427f53dbc 100644
--- a/src/class157/Code05_TagPermanentization1.java
+++ b/src/class157/Code05_LazyPermanentization1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树的标签永久化，java版
+// 可持久化线段树懒更新永久化，java版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有q条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
@@ -12,7 +12,7 @@
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
-// 想通过用C++写吧，本节课Code05_TagPermanentization2文件就是C++的实现
+// 想通过用C++写吧，本节课Code05_LazyPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -20,7 +20,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code05_TagPermanentization1 {
+public class Code05_LazyPermanentization1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class157/Code05_TagPermanentization2.java b/src/class157/Code05_LazyPermanentization2.java
similarity index 98%
rename from src/class157/Code05_TagPermanentization2.java
rename to src/class157/Code05_LazyPermanentization2.java
index 05002d400..25f9fd61e 100644
--- a/src/class157/Code05_TagPermanentization2.java
+++ b/src/class157/Code05_LazyPermanentization2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树的标签永久化，C++版
+// 可持久化线段树懒更新永久化，C++版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有q条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++

From 2659584bba187b41ce224c5d196d8c4123509130 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Jan 2025 19:40:25 +0800
Subject: [PATCH 0340/1712] modify code

---
 ...manentization1.java => Code05_TagPermanentization1.java} | 6 +++---
 ...manentization2.java => Code05_TagPermanentization2.java} | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class157/{Code05_LazyPermanentization1.java => Code05_TagPermanentization1.java} (96%)
 rename src/class157/{Code05_LazyPermanentization2.java => Code05_TagPermanentization2.java} (98%)

diff --git a/src/class157/Code05_LazyPermanentization1.java b/src/class157/Code05_TagPermanentization1.java
similarity index 96%
rename from src/class157/Code05_LazyPermanentization1.java
rename to src/class157/Code05_TagPermanentization1.java
index 427f53dbc..8ab1827b5 100644
--- a/src/class157/Code05_LazyPermanentization1.java
+++ b/src/class157/Code05_TagPermanentization1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树懒更新永久化，java版
+// 可持久化线段树标记永久化，java版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有q条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
@@ -12,7 +12,7 @@
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
-// 想通过用C++写吧，本节课Code05_LazyPermanentization2文件就是C++的实现
+// 想通过用C++写吧，本节课Code05_TagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -20,7 +20,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code05_LazyPermanentization1 {
+public class Code05_TagPermanentization1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class157/Code05_LazyPermanentization2.java b/src/class157/Code05_TagPermanentization2.java
similarity index 98%
rename from src/class157/Code05_LazyPermanentization2.java
rename to src/class157/Code05_TagPermanentization2.java
index 25f9fd61e..6d64d9499 100644
--- a/src/class157/Code05_LazyPermanentization2.java
+++ b/src/class157/Code05_TagPermanentization2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树懒更新永久化，C++版
+// 可持久化线段树标记永久化，C++版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有q条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++

From 08be4dca2b2433e366de9eda4348255dec4089c4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Jan 2025 01:55:14 +0800
Subject: [PATCH 0341/1712] modify code

---
 src/class157/Code07_MoreImpressive1.java | 23 ++++++++++----------
 src/class157/Code07_MoreImpressive2.java | 27 +++++++++++-------------
 2 files changed, 23 insertions(+), 27 deletions(-)

diff --git a/src/class157/Code07_MoreImpressive1.java b/src/class157/Code07_MoreImpressive1.java
index f7ebc522b..6ed4f103d 100644
--- a/src/class157/Code07_MoreImpressive1.java
+++ b/src/class157/Code07_MoreImpressive1.java
@@ -1,14 +1,13 @@
 package class157;
 
 // 更为厉害，java版
-// 原始题意有坑，多注意！
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
-// 如果节点a是节点b的祖先节点，认为"a比b更厉害"
-// 如果节点a到节点b的路径上边的数量 <= 常数k，认为"a和b是盟友"
-// 一共有q条查询，每条查询 p k : 查询有多少三元组(a, b, c)满足如下规定
-// 1，a就是节点p，但是a、b、c为三个不同的点
+// 如果x是y的祖先节点，认为"x比y更厉害"
+// 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"
+// 一共有q条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
+// 1，a、b、c为三个不同的点
 // 2，a和b都比c厉害
-// 3，a和b是盟友，路径上边的数量 <= 给定的k
+// 3，a和b是邻居，路径边的数量 <= 给定的k
 // 1 <= n、q、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -202,9 +201,9 @@ public static void dfs4() {
 		}
 	}
 
-	public static long compute(int p, int k) {
-		long ans = query(deep[p] + 1, deep[p] + k, 1, n, root[dfn[p] - 1], root[dfn[p] + size[p] - 1]);
-		ans += (long) (size[p] - 1) * Math.min(k, deep[p] - 1);
+	public static long compute(int a, int k) {
+		long ans = query(deep[a] + 1, deep[a] + k, 1, n, root[dfn[a] - 1], root[dfn[a] + size[a] - 1]);
+		ans += (long) (size[a] - 1) * Math.min(k, deep[a] - 1);
 		return ans;
 	}
 
@@ -227,12 +226,12 @@ public static void main(String[] args) throws IOException {
 		root[0] = build(1, n);
 		dfs3(); // 使用迭代版防止爆栈
 		dfs4(); // 使用迭代版防止爆栈
-		for (int i = 1, p, k; i <= q; i++) {
+		for (int i = 1, a, k; i <= q; i++) {
 			in.nextToken();
-			p = (int) in.nval;
+			a = (int) in.nval;
 			in.nextToken();
 			k = (int) in.nval;
-			out.println(compute(p, k));
+			out.println(compute(a, k));
 		}
 		out.flush();
 		out.close();
diff --git a/src/class157/Code07_MoreImpressive2.java b/src/class157/Code07_MoreImpressive2.java
index 884101dcd..41534fe61 100644
--- a/src/class157/Code07_MoreImpressive2.java
+++ b/src/class157/Code07_MoreImpressive2.java
@@ -1,14 +1,13 @@
 package class157;
 
 // 更为厉害，C++版
-// 原始题意有坑，多注意！
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
-// 如果节点a是节点b的祖先节点，认为"a比b更厉害"
-// 如果节点a到节点b的路径上边的数量 <= 常数k，认为"a和b是盟友"
-// 一共有q条查询，每条查询 p k : 查询有多少三元组(a, b, c)满足如下规定
-// 1，a就是节点p，但是a、b、c为三个不同的点
+// 如果x是y的祖先节点，认为"x比y更厉害"
+// 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"
+// 一共有q条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
+// 1，a、b、c为三个不同的点
 // 2，a和b都比c厉害
-// 3，a和b是盟友，路径上边的数量 <= 给定的k
+// 3，a和b是邻居，路径边的数量 <= 给定的k
 // 1 <= n、q、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -111,9 +110,9 @@
 //    }
 //}
 //
-//long long compute(int p, int k) {
-//    long long ans = query(dep[p] + 1, dep[p] + k, 1, n, root[dfn[p] - 1], root[dfn[p] + siz[p] - 1]);
-//    ans += (long long)(siz[p] - 1) * min(k, dep[p] - 1);
+//long long compute(int a, int k) {
+//    long long ans = query(dep[a] + 1, dep[a] + k, 1, n, root[dfn[a] - 1], root[dfn[a] + siz[a] - 1]);
+//    ans += (long long)(siz[a] - 1) * min(k, dep[a] - 1);
 //    return ans;
 //}
 //
@@ -121,8 +120,7 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> q;
-//    for (int i = 1; i < n; i++) {
-//        int u, v;
+//    for (int i = 1, u, v; i < n; i++) {
 //        cin >> u >> v;
 //        addEdge(u, v);
 //        addEdge(v, u);
@@ -130,10 +128,9 @@
 //    root[0] = build(1, n);
 //    dfs1(1, 0);
 //    dfs2(1, 0);
-//    for(int i = 1; i <= q; i++) {
-//        int p, k;
-//        cin >> p >> k;
-//        cout << compute(p, k) << "\n";
+//    for(int i = 1, a, k; i <= q; i++) {
+//        cin >> a >> k;
+//        cout << compute(a, k) << "\n";
 //    }
 //    return 0;
 //}
\ No newline at end of file

From be80677c8df3f6d7264f376382d341b42a6d43b9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Jan 2025 01:59:36 +0800
Subject: [PATCH 0342/1712] modify code

---
 src/class157/Code06_CountOnTree2.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class157/Code06_CountOnTree2.java b/src/class157/Code06_CountOnTree2.java
index a0f5c9bf3..60751e362 100644
--- a/src/class157/Code06_CountOnTree2.java
+++ b/src/class157/Code06_CountOnTree2.java
@@ -29,7 +29,7 @@
 //
 //int head[MAXN];
 //int to[MAXN << 1];
-//int nextEdge[MAXN << 1];
+//int nxt[MAXN << 1];
 //int cntg = 0;
 //
 //int root[MAXN];
@@ -82,7 +82,7 @@
 //}
 //
 //void addEdge(int u, int v) {
-//	nextEdge[++cntg] = head[u];
+//    nxt[++cntg] = head[u];
 //    to[cntg] = v;
 //    head[u] = cntg;
 //}
@@ -123,7 +123,7 @@
 //    for (int p = 1; p < MAXH; p++) {
 //        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 //    }
-//    for (int ei = head[u]; ei > 0; ei = nextEdge[ei]) {
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 //        if (to[ei] != f) {
 //            dfs(to[ei], u);
 //        }

From 04ef9ed121ee00d4d09efd3ec1bad80ff6fd571d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Jan 2025 21:18:41 +0800
Subject: [PATCH 0343/1712] modify code

---
 src/class157/Code01_PersistentSegmentTree2.java | 5 +----
 src/class157/Code02_MissingSmallest2.java       | 5 +----
 src/class157/Code04_LargestUpMedian2.java       | 6 +-----
 src/class157/Code05_TagPermanentization1.java   | 2 +-
 src/class157/Code05_TagPermanentization2.java   | 2 +-
 src/class157/Code06_CountOnTree2.java           | 6 +-----
 6 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code01_PersistentSegmentTree2.java
index ea65a6e86..7f95eac3e 100644
--- a/src/class157/Code01_PersistentSegmentTree2.java
+++ b/src/class157/Code01_PersistentSegmentTree2.java
@@ -8,10 +8,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <vector>
-//#include <algorithm>
-//#include <cstdio>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //
diff --git a/src/class157/Code02_MissingSmallest2.java b/src/class157/Code02_MissingSmallest2.java
index 59164ff00..714b7e11d 100644
--- a/src/class157/Code02_MissingSmallest2.java
+++ b/src/class157/Code02_MissingSmallest2.java
@@ -8,10 +8,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <vector>
-//#include <algorithm>
-//#include <cstdio>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //
diff --git a/src/class157/Code04_LargestUpMedian2.java b/src/class157/Code04_LargestUpMedian2.java
index b0d11dbf3..f61b983f2 100644
--- a/src/class157/Code04_LargestUpMedian2.java
+++ b/src/class157/Code04_LargestUpMedian2.java
@@ -14,11 +14,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <vector>
-//#include <algorithm>
-//#include <cstdio>
-//#include <cstring>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //
diff --git a/src/class157/Code05_TagPermanentization1.java b/src/class157/Code05_TagPermanentization1.java
index 8ab1827b5..773b9aaac 100644
--- a/src/class157/Code05_TagPermanentization1.java
+++ b/src/class157/Code05_TagPermanentization1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树标记永久化，java版
+// 线段树标记永久化结合可持久化，java版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有q条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
diff --git a/src/class157/Code05_TagPermanentization2.java b/src/class157/Code05_TagPermanentization2.java
index 6d64d9499..f1e6bb55b 100644
--- a/src/class157/Code05_TagPermanentization2.java
+++ b/src/class157/Code05_TagPermanentization2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树标记永久化，C++版
+// 线段树标记永久化结合可持久化，C++版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有q条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
diff --git a/src/class157/Code06_CountOnTree2.java b/src/class157/Code06_CountOnTree2.java
index 60751e362..35331136f 100644
--- a/src/class157/Code06_CountOnTree2.java
+++ b/src/class157/Code06_CountOnTree2.java
@@ -12,11 +12,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <vector>
-//#include <algorithm>
-//#include <cstdio>
-//#include <cstring>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //

From 1ac89b8251e7786ed29f8810d3022ebb90299641 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 12:37:30 +0800
Subject: [PATCH 0344/1712] modify code

---
 .../Code01_PersistentSegmentTree1.java        | 24 +++++++--------
 .../Code01_PersistentSegmentTree2.java        | 24 +++++++--------
 ....java => Code02_TagPermanentization1.java} | 16 +++++-----
 ....java => Code02_TagPermanentization2.java} | 12 ++++----
 ...est1.java => Code03_MissingSmallest1.java} | 12 ++++----
 ...est2.java => Code03_MissingSmallest2.java} | 10 +++----
 ...rs1.java => Code04_DifferentNumbers1.java} | 12 ++++----
 ...rs2.java => Code04_DifferentNumbers2.java} | 10 +++----
 ...ian1.java => Code05_LargestUpMedian1.java} | 26 ++++++++--------
 ...ian2.java => Code05_LargestUpMedian2.java} | 24 +++++++--------
 src/class157/Code06_CountOnTree1.java         | 30 ++++++++++---------
 src/class157/Code06_CountOnTree2.java         | 30 ++++++++++---------
 src/class157/Code07_MoreImpressive1.java      | 10 +++----
 src/class157/Code07_MoreImpressive2.java      | 10 +++----
 14 files changed, 127 insertions(+), 123 deletions(-)
 rename src/class157/{Code05_TagPermanentization1.java => Code02_TagPermanentization1.java} (93%)
 rename src/class157/{Code05_TagPermanentization2.java => Code02_TagPermanentization2.java} (93%)
 rename src/class157/{Code02_MissingSmallest1.java => Code03_MissingSmallest1.java} (93%)
 rename src/class157/{Code02_MissingSmallest2.java => Code03_MissingSmallest2.java} (92%)
 rename src/class157/{Code03_DifferentNumbers1.java => Code04_DifferentNumbers1.java} (95%)
 rename src/class157/{Code03_DifferentNumbers2.java => Code04_DifferentNumbers2.java} (94%)
 rename src/class157/{Code04_LargestUpMedian1.java => Code05_LargestUpMedian1.java} (91%)
 rename src/class157/{Code04_LargestUpMedian2.java => Code05_LargestUpMedian2.java} (90%)

diff --git a/src/class157/Code01_PersistentSegmentTree1.java b/src/class157/Code01_PersistentSegmentTree1.java
index 8b4897e77..86d5116fe 100644
--- a/src/class157/Code01_PersistentSegmentTree1.java
+++ b/src/class157/Code01_PersistentSegmentTree1.java
@@ -1,9 +1,9 @@
 package class157;
 
 // 可持久化线段树模版题，java版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
-// 1 <= n、q <= 2 * 10^5
+// 1 <= n、m <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -21,7 +21,7 @@ public class Code01_PersistentSegmentTree1 {
 
 	public static int MAXM = MAXN * 22;
 
-	public static int n, q;
+	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
 
@@ -38,14 +38,14 @@ public class Code01_PersistentSegmentTree1 {
 	public static int cnt;
 
 	public static int kth(int num) {
-		int l = 1, r = n, m, ans = 0;
-		while (l <= r) {
-			m = (l + r) / 2;
-			if (sorted[m] <= num) {
-				ans = m;
-				l = m + 1;
+		int left = 1, right = n, mid, ans = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ans = mid;
+				left = mid + 1;
 			} else {
-				r = m - 1;
+				right = mid - 1;
 			}
 		}
 		return ans;
@@ -111,13 +111,13 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		n = (int) in.nval;
 		in.nextToken();
-		q = (int) in.nval;
+		m = (int) in.nval;
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
 			arr[i] = (int) in.nval;
 		}
 		prepare();
-		for (int i = 1, l, r, k; i <= q; i++) {
+		for (int i = 1, l, r, k; i <= m; i++) {
 			in.nextToken();
 			l = (int) in.nval;
 			in.nextToken();
diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code01_PersistentSegmentTree2.java
index 7f95eac3e..6634d416c 100644
--- a/src/class157/Code01_PersistentSegmentTree2.java
+++ b/src/class157/Code01_PersistentSegmentTree2.java
@@ -1,9 +1,9 @@
 package class157;
 
 // 可持久化线段树模版题，C++版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
-// 1 <= n、q <= 2 * 10^5
+// 1 <= n、m <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -14,7 +14,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXM = MAXN * 22;
-//int n, q;
+//int n, m;
 //int arr[MAXN];
 //int sorted[MAXN];
 //int root[MAXN];
@@ -24,14 +24,14 @@
 //int cnt;
 //
 //int kth(int num) {
-//    int l = 1, r = n, m, ans = 0;
-//    while (l <= r) {
-//        m = (l + r) / 2;
-//        if (sorted[m] <= num) {
-//            ans = m;
-//            l = m + 1;
+//    int left = 1, right = n, mid, ans = 0;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] <= num) {
+//            ans = mid;
+//            left = mid + 1;
 //        } else {
-//            r = m - 1;
+//            right = mid - 1;
 //        }
 //    }
 //    return ans;
@@ -93,12 +93,12 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> q;
+//    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
 //    prepare();
-//    for (int i = 1, l, r, k; i <= q; i++) {
+//    for (int i = 1, l, r, k; i <= m; i++) {
 //        cin >> l >> r >> k;
 //        int ans = query(k, 1, n, root[l - 1], root[r]);
 //        cout << sorted[ans] << '\n';
diff --git a/src/class157/Code05_TagPermanentization1.java b/src/class157/Code02_TagPermanentization1.java
similarity index 93%
rename from src/class157/Code05_TagPermanentization1.java
rename to src/class157/Code02_TagPermanentization1.java
index 773b9aaac..2bc5ccbb8 100644
--- a/src/class157/Code05_TagPermanentization1.java
+++ b/src/class157/Code02_TagPermanentization1.java
@@ -1,18 +1,18 @@
 package class157;
 
-// 线段树标记永久化结合可持久化，java版
+// 范围修改的可持久化线段树 + 标记永久化，java版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
-// 一共有q条查询，每条查询为如下四种类型中的一种
+// 一共有m条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
 // Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
 // H x y z : z版本的数组，打印[x..y]范围的累加和
 // B x     : 当前时间戳t设置成x
-// 1 <= n、q <= 10^5
+// 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
-// 想通过用C++写吧，本节课Code05_TagPermanentization2文件就是C++的实现
+// 想通过用C++写吧，本节课Code02_TagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -20,13 +20,13 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code05_TagPermanentization1 {
+public class Code02_TagPermanentization1 {
 
 	public static int MAXN = 100001;
 
 	public static int MAXM = MAXN * 25;
 
-	public static int n, q, t = 0;
+	public static int n, m, t = 0;
 
 	public static int[] arr = new int[MAXN];
 
@@ -101,13 +101,13 @@ public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader();
 		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
-		q = in.nextInt();
+		m = in.nextInt();
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
 		root[0] = build(1, n);
 		String op;
-		for (int i = 1, x, y, z; i <= q; i++) {
+		for (int i = 1, x, y, z; i <= m; i++) {
 			op = in.next();
 			if (op.equals("C")) {
 				x = in.nextInt();
diff --git a/src/class157/Code05_TagPermanentization2.java b/src/class157/Code02_TagPermanentization2.java
similarity index 93%
rename from src/class157/Code05_TagPermanentization2.java
rename to src/class157/Code02_TagPermanentization2.java
index f1e6bb55b..2449185ee 100644
--- a/src/class157/Code05_TagPermanentization2.java
+++ b/src/class157/Code02_TagPermanentization2.java
@@ -1,13 +1,13 @@
 package class157;
 
-// 线段树标记永久化结合可持久化，C++版
+// 范围修改的可持久化线段树 + 标记永久化，C++版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
-// 一共有q条查询，每条查询为如下四种类型中的一种
+// 一共有m条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
 // Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
 // H x y z : z版本的数组，打印[x..y]范围的累加和
 // B x     : 当前时间戳t设置成x
-// 1 <= n、q <= 10^5
+// 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
@@ -20,7 +20,7 @@
 //
 //const int MAXN = 100001;
 //const int MAXM = MAXN * 25;
-//int n, q, t = 0;
+//int n, m, t = 0;
 //long long arr[MAXN];
 //int root[MAXN];
 //int ls[MAXM];
@@ -81,7 +81,7 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> q;
+//    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
@@ -89,7 +89,7 @@
 //    char op;
 //    int x, y;
 //    long long z;
-//    for (int i = 1; i <= q; i++) {
+//    for (int i = 1; i <= m; i++) {
 //        cin >> op;
 //        if (op == 'C') {
 //            cin >> x >> y >> z;
diff --git a/src/class157/Code02_MissingSmallest1.java b/src/class157/Code03_MissingSmallest1.java
similarity index 93%
rename from src/class157/Code02_MissingSmallest1.java
rename to src/class157/Code03_MissingSmallest1.java
index 5de0adba5..b5df3ccac 100644
--- a/src/class157/Code02_MissingSmallest1.java
+++ b/src/class157/Code03_MissingSmallest1.java
@@ -1,9 +1,9 @@
 package class157;
 
 // 区间内没有出现的最小自然数，java版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
-// 1 <= n、q、arr[i] <= 2 * 10^5
+// 1 <= n、m、arr[i] <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4137
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,13 +14,13 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_MissingSmallest1 {
+public class Code03_MissingSmallest1 {
 
 	public static int MAXN = 200001;
 
 	public static int MAXM = MAXN * 22;
 
-	public static int n, q;
+	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
 
@@ -102,13 +102,13 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		n = (int) in.nval;
 		in.nextToken();
-		q = (int) in.nval;
+		m = (int) in.nval;
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
 			arr[i] = (int) in.nval;
 		}
 		prepare();
-		for (int i = 1, l, r; i <= q; i++) {
+		for (int i = 1, l, r; i <= m; i++) {
 			in.nextToken();
 			l = (int) in.nval;
 			in.nextToken();
diff --git a/src/class157/Code02_MissingSmallest2.java b/src/class157/Code03_MissingSmallest2.java
similarity index 92%
rename from src/class157/Code02_MissingSmallest2.java
rename to src/class157/Code03_MissingSmallest2.java
index 714b7e11d..ad2f8635f 100644
--- a/src/class157/Code02_MissingSmallest2.java
+++ b/src/class157/Code03_MissingSmallest2.java
@@ -1,9 +1,9 @@
 package class157;
 
 // 区间内没有出现的最小自然数，C++版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
-// 1 <= n、q、arr[i] <= 2 * 10^5
+// 1 <= n、m、arr[i] <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4137
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -14,7 +14,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXM = MAXN * 22;
-//int n, q;
+//int n, m;
 //int arr[MAXN];
 //int root[MAXN];
 //int ls[MAXM];
@@ -79,12 +79,12 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> q;
+//    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
 //    prepare();
-//    for (int i = 0, l, r; i < q; i++) {
+//    for (int i = 1, l, r; i <= m; i++) {
 //        cin >> l >> r;
 //        cout << query(l, 0, n, root[r]) << "\n";
 //    }
diff --git a/src/class157/Code03_DifferentNumbers1.java b/src/class157/Code04_DifferentNumbers1.java
similarity index 95%
rename from src/class157/Code03_DifferentNumbers1.java
rename to src/class157/Code04_DifferentNumbers1.java
index 993ec3d87..1a9ad5ea3 100644
--- a/src/class157/Code03_DifferentNumbers1.java
+++ b/src/class157/Code04_DifferentNumbers1.java
@@ -1,7 +1,7 @@
 package class157;
 
 // 区间内的不同数字，java版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的l和r，按照如下方式得到真实的l和r，查询完成后更新lastAns
@@ -9,20 +9,20 @@
 // b = (给定r + lastAns) % n + 1
 // 真实l = min(a, b)
 // 真实r = max(a, b)
-// 1 <= n、q、arr[i] <= 2 * 10^5
+// 1 <= n、m、arr[i] <= 2 * 10^5
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.util.Arrays;
 
-public class Code03_DifferentNumbers1 {
+public class Code04_DifferentNumbers1 {
 
 	public static int MAXN = 200002;
 
 	public static int MAXM = MAXN * 37;
 
-	public static int cases, n, q;
+	public static int cases, n, m;
 
 	public static int[] arr = new int[MAXN];
 
@@ -114,7 +114,7 @@ public static void main(String[] args) throws IOException {
 		cases = io.nextInt();
 		for (int t = 1; t <= cases; t++) {
 			n = io.nextInt();
-			q = io.nextInt();
+			m = io.nextInt();
 			for (int i = 1; i <= n; i++) {
 				arr[i] = io.nextInt();
 			}
@@ -122,7 +122,7 @@ public static void main(String[] args) throws IOException {
 			io.write("Case #");
 			io.writeInt(t);
 			io.write(":");
-			for (int i = 1, a, b, l, r, k, lastAns = 0; i <= q; i++) {
+			for (int i = 1, a, b, l, r, k, lastAns = 0; i <= m; i++) {
 				a = (io.nextInt() + lastAns) % n + 1;
 				b = (io.nextInt() + lastAns) % n + 1;
 				l = Math.min(a, b);
diff --git a/src/class157/Code03_DifferentNumbers2.java b/src/class157/Code04_DifferentNumbers2.java
similarity index 94%
rename from src/class157/Code03_DifferentNumbers2.java
rename to src/class157/Code04_DifferentNumbers2.java
index 25291fdfb..244bf3ae1 100644
--- a/src/class157/Code03_DifferentNumbers2.java
+++ b/src/class157/Code04_DifferentNumbers2.java
@@ -1,7 +1,7 @@
 package class157;
 
 // 区间内的不同数字，C++版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的l和r，按照如下方式得到真实的l和r，查询完成后更新lastAns
@@ -9,7 +9,7 @@
 // b = (给定r + lastAns) % n + 1
 // 真实l = min(a, b)
 // 真实r = max(a, b)
-// 1 <= n、q、arr[i] <= 2 * 10^5
+// 1 <= n、m、arr[i] <= 2 * 10^5
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -20,7 +20,7 @@
 //
 //const int MAXN = 200002;
 //const int MAXM = MAXN * 37;
-//int cases, n, q;
+//int cases, n, m;
 //int arr[MAXN];
 //int pos[MAXN];
 //int root[MAXN];
@@ -105,13 +105,13 @@
 //    cin.tie(nullptr);
 //    cin >> cases;
 //    for (int t = 1; t <= cases; t++) {
-//        cin >> n >> q;
+//        cin >> n >> m;
 //        for (int i = 1; i <= n; i++) {
 //            cin >> arr[i];
 //        }
 //        prepare();
 //        cout << "Case #" << t << ":";
-//        for (int i = 1, a, b, l, r, k, lastAns = 0; i <= q; i++) {
+//        for (int i = 1, a, b, l, r, k, lastAns = 0; i <= m; i++) {
 //            cin >> l >> r;
 //            a = (l + lastAns) % n + 1;
 //            b = (r + lastAns) % n + 1;
diff --git a/src/class157/Code04_LargestUpMedian1.java b/src/class157/Code05_LargestUpMedian1.java
similarity index 91%
rename from src/class157/Code04_LargestUpMedian1.java
rename to src/class157/Code05_LargestUpMedian1.java
index ad1c76f2e..e21ff5b4f 100644
--- a/src/class157/Code04_LargestUpMedian1.java
+++ b/src/class157/Code05_LargestUpMedian1.java
@@ -1,14 +1,14 @@
 package class157;
 
 // 区间最大上中位数，java版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
 //                   哪个区间有最大的上中位数，打印最大的上中位数
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定四个参数，按照如下方式得到a、b、c、d，查询完成后更新lastAns
 // (给定的每个参数 + lastAns) % n + 1，得到四个值，从小到大对应a、b、c、d
 // 1 <= n <= 20000
-// 1 <= q <= 25000
+// 1 <= m <= 25000
 // 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2839
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -21,7 +21,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_LargestUpMedian1 {
+public class Code05_LargestUpMedian1 {
 
 	public static int MAXN = 20001;
 
@@ -29,7 +29,7 @@ public class Code04_LargestUpMedian1 {
 
 	public static int INF = 10000001;
 
-	public static int n, q;
+	public static int n, m;
 
 	// 原始位置、数值
 	public static int[][] arr = new int[MAXN][2];
@@ -145,14 +145,14 @@ public static boolean check(int a, int b, int c, int d, int v) {
 	}
 
 	public static int compute(int a, int b, int c, int d) {
-		int l = 1, r = n, m, ans = 0;
-		while (l <= r) {
-			m = (l + r) / 2;
-			if (check(a, b, c, d, m)) {
-				ans = arr[m][1];
-				l = m + 1;
+		int left = 1, right = n, mid, ans = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (check(a, b, c, d, mid)) {
+				ans = arr[mid][1];
+				left = mid + 1;
 			} else {
-				r = m - 1;
+				right = mid - 1;
 			}
 		}
 		return ans;
@@ -171,8 +171,8 @@ public static void main(String[] args) throws IOException {
 		}
 		prepare();
 		in.nextToken();
-		q = (int) in.nval;
-		for (int i = 1, lastAns = 0; i <= q; i++) {
+		m = (int) in.nval;
+		for (int i = 1, lastAns = 0; i <= m; i++) {
 			in.nextToken();
 			ques[0] = ((int) in.nval + lastAns) % n + 1;
 			in.nextToken();
diff --git a/src/class157/Code04_LargestUpMedian2.java b/src/class157/Code05_LargestUpMedian2.java
similarity index 90%
rename from src/class157/Code04_LargestUpMedian2.java
rename to src/class157/Code05_LargestUpMedian2.java
index f61b983f2..c7a6a660f 100644
--- a/src/class157/Code04_LargestUpMedian2.java
+++ b/src/class157/Code05_LargestUpMedian2.java
@@ -1,14 +1,14 @@
 package class157;
 
 // 区间最大上中位数，C++版
-// 给定一个长度为n的数组arr，下标1~n，一共有q条查询
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
 //                   哪个区间有最大的上中位数，打印最大的上中位数
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定四个参数，按照如下方式得到a、b、c、d，查询完成后更新lastAns
 // (给定的每个参数 + lastAns) % n + 1，得到四个值，从小到大对应a、b、c、d
 // 1 <= n <= 20000
-// 1 <= q <= 25000
+// 1 <= m <= 25000
 // 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2839
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -21,7 +21,7 @@
 //const int MAXN = 20001;
 //const int MAXM = MAXN * 20;
 //const int INF = 10000001;
-//int n, q;
+//int n, m;
 //vector<pair<int, int>> arr;
 //int root[MAXN];
 //int ls[MAXM];
@@ -122,14 +122,14 @@
 //}
 //
 //int compute(int a, int b, int c, int d) {
-//    int l = 1, r = n, m, ans = 0;
-//    while (l <= r) {
-//        m = (l + r) / 2;
-//        if (check(a, b, c, d, m)) {
-//            ans = arr[m].second;
-//            l = m + 1;
+//    int left = 1, right = n, mid, ans = 0;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (check(a, b, c, d, mid)) {
+//            ans = arr[mid].second;
+//            left = mid + 1;
 //        } else {
-//            r = m - 1;
+//            right = mid - 1;
 //        }
 //    }
 //    return ans;
@@ -145,8 +145,8 @@
 //        cin >> arr[i].second;
 //    }
 //    prepare();
-//    cin >> q;
-//    for (int i = 1, lastAns = 0; i <= q; i++) {
+//    cin >> m;
+//    for (int i = 1, lastAns = 0; i <= m; i++) {
 //        for (int j = 0; j < 4; j++) {
 //            cin >> ques[j];
 //            ques[j] = (ques[j] + lastAns) % n + 1;
diff --git a/src/class157/Code06_CountOnTree1.java b/src/class157/Code06_CountOnTree1.java
index 5006b49cd..5d3c89222 100644
--- a/src/class157/Code06_CountOnTree1.java
+++ b/src/class157/Code06_CountOnTree1.java
@@ -2,11 +2,13 @@
 
 // 节点路径第k小值，java版
 // 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
-// 一共有q条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
+// 一共有m条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的u、v、k，按照如下方式得到真实的u、v、k，查询完成后更新lastAns
-// 真实u = 给定u ^ lastAns    真实v = 给定v    真实k = 给定k
-// 1 <= n、q <= 10^5
+// 真实u = 给定u ^ lastAns
+// 真实v = 给定v
+// 真实k = 给定k
+// 1 <= n、m <= 10^5
 // 1 <= arr[i] <= 2^32 - 1
 // 测试链接 : https://www.luogu.com.cn/problem/P2633
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -27,7 +29,7 @@ public class Code06_CountOnTree1 {
 
 	public static int MAXM = MAXN * MAXH;
 
-	public static int n, s, q;
+	public static int n, s, m;
 
 	// 各个节点权值
 	public static int[] arr = new int[MAXN];
@@ -61,15 +63,15 @@ public class Code06_CountOnTree1 {
 	public static int[][] stjump = new int[MAXN][MAXH];
 
 	public static int kth(int num) {
-		int l = 1, r = s, m;
-		while (l <= r) {
-			m = (l + r) / 2;
-			if (sorted[m] == num) {
-				return m;
-			} else if (sorted[m] < num) {
-				l = m + 1;
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
 			} else {
-				r = m - 1;
+				right = mid - 1;
 			}
 		}
 		return -1;
@@ -232,7 +234,7 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		n = (int) in.nval;
 		in.nextToken();
-		q = (int) in.nval;
+		m = (int) in.nval;
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
 			arr[i] = (int) in.nval;
@@ -247,7 +249,7 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		dfs2(); // 使用迭代版防止爆栈
-		for (int i = 1, u, v, k, lastAns = 0; i <= q; i++) {
+		for (int i = 1, u, v, k, lastAns = 0; i <= m; i++) {
 			in.nextToken();
 			u = (int) in.nval ^ lastAns;
 			in.nextToken();
diff --git a/src/class157/Code06_CountOnTree2.java b/src/class157/Code06_CountOnTree2.java
index 35331136f..cb4d01c09 100644
--- a/src/class157/Code06_CountOnTree2.java
+++ b/src/class157/Code06_CountOnTree2.java
@@ -2,11 +2,13 @@
 
 // 节点路径第k小值，C++版
 // 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
-// 一共有q条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
+// 一共有m条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的u、v、k，按照如下方式得到真实的u、v、k，查询完成后更新lastAns
-// 真实u = 给定u ^ lastAns    真实v = 给定v    真实k = 给定k
-// 1 <= n、q <= 10^5
+// 真实u = 给定u ^ lastAns
+// 真实v = 给定v
+// 真实k = 给定k
+// 1 <= n、m <= 10^5
 // 1 <= arr[i] <= 2^32 - 1
 // 测试链接 : https://www.luogu.com.cn/problem/P2633
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -19,7 +21,7 @@
 //const int MAXN = 100001;
 //const int MAXH = 20;
 //const int MAXM = MAXN * MAXH;
-//int n, s, q;
+//int n, s, m;
 //int arr[MAXN];
 //int sorted[MAXN];
 //
@@ -38,15 +40,15 @@
 //int stjump[MAXN][MAXH];
 //
 //int kth(int num) {
-//    int l = 1, r = s, m;
-//    while (l <= r) {
-//        m = (l + r) / 2;
-//        if (sorted[m] == num) {
-//            return m;
-//        } else if (sorted[m] < num) {
-//            l = m + 1;
+//    int left = 1, right = s, mid;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            left = mid + 1;
 //        } else {
-//            r = m - 1;
+//            right = mid - 1;
 //        }
 //    }
 //    return -1;
@@ -156,7 +158,7 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> q;
+//    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
@@ -167,7 +169,7 @@
 //        addEdge(v, u);
 //    }
 //    dfs(1, 0);
-//    for (int i = 1, u, v, k, lastAns = 0; i <= q; i++) {
+//    for (int i = 1, u, v, k, lastAns = 0; i <= m; i++) {
 //        cin >> u >> v >> k;
 //        u ^= lastAns;
 //        lastAns = kth(u, v, k);
diff --git a/src/class157/Code07_MoreImpressive1.java b/src/class157/Code07_MoreImpressive1.java
index 6ed4f103d..01479c749 100644
--- a/src/class157/Code07_MoreImpressive1.java
+++ b/src/class157/Code07_MoreImpressive1.java
@@ -4,11 +4,11 @@
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
 // 如果x是y的祖先节点，认为"x比y更厉害"
 // 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"
-// 一共有q条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
+// 一共有m条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
 // 1，a、b、c为三个不同的点
 // 2，a和b都比c厉害
 // 3，a和b是邻居，路径边的数量 <= 给定的k
-// 1 <= n、q、k <= 3 * 10^5
+// 1 <= n、m、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -25,7 +25,7 @@ public class Code07_MoreImpressive1 {
 
 	public static int MAXM = MAXN * 22;
 
-	public static int n, q;
+	public static int n, m;
 
 	// 链式前向星需要
 	public static int[] head = new int[MAXN];
@@ -214,7 +214,7 @@ public static void main(String[] args) throws IOException {
 		in.nextToken();
 		n = (int) in.nval;
 		in.nextToken();
-		q = (int) in.nval;
+		m = (int) in.nval;
 		for (int i = 1, u, v; i < n; i++) {
 			in.nextToken();
 			u = (int) in.nval;
@@ -226,7 +226,7 @@ public static void main(String[] args) throws IOException {
 		root[0] = build(1, n);
 		dfs3(); // 使用迭代版防止爆栈
 		dfs4(); // 使用迭代版防止爆栈
-		for (int i = 1, a, k; i <= q; i++) {
+		for (int i = 1, a, k; i <= m; i++) {
 			in.nextToken();
 			a = (int) in.nval;
 			in.nextToken();
diff --git a/src/class157/Code07_MoreImpressive2.java b/src/class157/Code07_MoreImpressive2.java
index 41534fe61..15918ab20 100644
--- a/src/class157/Code07_MoreImpressive2.java
+++ b/src/class157/Code07_MoreImpressive2.java
@@ -4,11 +4,11 @@
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
 // 如果x是y的祖先节点，认为"x比y更厉害"
 // 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"
-// 一共有q条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
+// 一共有m条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
 // 1，a、b、c为三个不同的点
 // 2，a和b都比c厉害
 // 3，a和b是邻居，路径边的数量 <= 给定的k
-// 1 <= n、q、k <= 3 * 10^5
+// 1 <= n、m、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -19,7 +19,7 @@
 //
 //const int MAXN = 300001;
 //const int MAXM = MAXN * 22;
-//int n, q;
+//int n, m;
 //
 //int head[MAXN];
 //int to[MAXN << 1];
@@ -119,7 +119,7 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> q;
+//    cin >> n >> m;
 //    for (int i = 1, u, v; i < n; i++) {
 //        cin >> u >> v;
 //        addEdge(u, v);
@@ -128,7 +128,7 @@
 //    root[0] = build(1, n);
 //    dfs1(1, 0);
 //    dfs2(1, 0);
-//    for(int i = 1, a, k; i <= q; i++) {
+//    for(int i = 1, a, k; i <= m; i++) {
 //        cin >> a >> k;
 //        cout << compute(a, k) << "\n";
 //    }

From fbd0aadc7faa32bb22670d35cc4b3ea7507310b8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 14:27:46 +0800
Subject: [PATCH 0345/1712] modify code

---
 src/class157/Code02_TagPermanentization1.java | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code02_TagPermanentization1.java b/src/class157/Code02_TagPermanentization1.java
index 2bc5ccbb8..6c965f37e 100644
--- a/src/class157/Code02_TagPermanentization1.java
+++ b/src/class157/Code02_TagPermanentization1.java
@@ -11,8 +11,10 @@
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
-// 这道题的两个测试，都严重卡常，java版很难通过，这是语言歧视
-// 想通过用C++写吧，本节课Code02_TagPermanentization2文件就是C++的实现
+// 这道题的目的是让你去实现标记永久化的版本，减少可持久化线段树的空间消耗
+// 所以题目一定要卡住，没有进行标记永久化的实现，而且是根据C++的使用空间来卡！
+// 但是这样一来，空间资源非常少，java的实现哪怕做了标记永久化也很难通过了！
+// 所以想通过就用C++实现吧，本节课Code02_TagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;

From 17f4cde76c6d4475fab597ab4ac87e79338e9199 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 14:28:55 +0800
Subject: [PATCH 0346/1712] modify code

---
 src/class157/Code02_TagPermanentization1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class157/Code02_TagPermanentization1.java b/src/class157/Code02_TagPermanentization1.java
index 6c965f37e..255a4f59f 100644
--- a/src/class157/Code02_TagPermanentization1.java
+++ b/src/class157/Code02_TagPermanentization1.java
@@ -14,6 +14,7 @@
 // 这道题的目的是让你去实现标记永久化的版本，减少可持久化线段树的空间消耗
 // 所以题目一定要卡住，没有进行标记永久化的实现，而且是根据C++的使用空间来卡！
 // 但是这样一来，空间资源非常少，java的实现哪怕做了标记永久化也很难通过了！
+// java版本的实现也是最优解，逻辑一定是正确的
 // 所以想通过就用C++实现吧，本节课Code02_TagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 

From 94643a74df304a78a67be597d86de96ec183561a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 14:31:21 +0800
Subject: [PATCH 0347/1712] modify code

---
 src/class157/Code02_TagPermanentization1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class157/Code02_TagPermanentization1.java b/src/class157/Code02_TagPermanentization1.java
index 255a4f59f..5315fda8a 100644
--- a/src/class157/Code02_TagPermanentization1.java
+++ b/src/class157/Code02_TagPermanentization1.java
@@ -12,9 +12,9 @@
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这道题的目的是让你去实现标记永久化的版本，减少可持久化线段树的空间消耗
-// 所以题目一定要卡住，没有进行标记永久化的实现，而且是根据C++的使用空间来卡！
-// 但是这样一来，空间资源非常少，java的实现哪怕做了标记永久化也很难通过了！
-// java版本的实现也是最优解，逻辑一定是正确的
+// 所以题目一定要卡住，没有进行标记永久化的实现，而且是根据C++使用空间的状况来卡的！
+// 但是这样一来，空间资源非常少，java的实现哪怕做了标记永久化的优化，也很难通过了！
+// java版本的实现一定是最优解，逻辑一定是正确的
 // 所以想通过就用C++实现吧，本节课Code02_TagPermanentization2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 

From c3eff3d1ca97e04ebe9632ff79cc2e86ce4b43c6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 14:56:34 +0800
Subject: [PATCH 0348/1712] modify code

---
 src/class157/Code07_MoreImpressive1.java | 4 +---
 src/class157/Code07_MoreImpressive2.java | 4 +---
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/class157/Code07_MoreImpressive1.java b/src/class157/Code07_MoreImpressive1.java
index 01479c749..ae2e02b14 100644
--- a/src/class157/Code07_MoreImpressive1.java
+++ b/src/class157/Code07_MoreImpressive1.java
@@ -5,9 +5,7 @@
 // 如果x是y的祖先节点，认为"x比y更厉害"
 // 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"
 // 一共有m条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
-// 1，a、b、c为三个不同的点
-// 2，a和b都比c厉害
-// 3，a和b是邻居，路径边的数量 <= 给定的k
+// a、b、c为三个不同的点；a和b都比c厉害；a和b是邻居，路径边的数量 <= 给定的k
 // 1 <= n、m、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class157/Code07_MoreImpressive2.java b/src/class157/Code07_MoreImpressive2.java
index 15918ab20..39ca2f78d 100644
--- a/src/class157/Code07_MoreImpressive2.java
+++ b/src/class157/Code07_MoreImpressive2.java
@@ -5,9 +5,7 @@
 // 如果x是y的祖先节点，认为"x比y更厉害"
 // 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"
 // 一共有m条查询，每条查询 a k : 打印有多少三元组(a, b, c)满足如下规定
-// 1，a、b、c为三个不同的点
-// 2，a和b都比c厉害
-// 3，a和b是邻居，路径边的数量 <= 给定的k
+// a、b、c为三个不同的点；a和b都比c厉害；a和b是邻居，路径边的数量 <= 给定的k
 // 1 <= n、m、k <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3899
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 8a74050c67573cfa8bbd9c7798e8bc69bf1e1e5e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 15:09:20 +0800
Subject: [PATCH 0349/1712] modify code

---
 src/class157/Code01_PersistentSegmentTree1.java | 2 +-
 src/class157/Code01_PersistentSegmentTree2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code01_PersistentSegmentTree1.java b/src/class157/Code01_PersistentSegmentTree1.java
index 86d5116fe..f0f462019 100644
--- a/src/class157/Code01_PersistentSegmentTree1.java
+++ b/src/class157/Code01_PersistentSegmentTree1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树模版题，java版
+// 单点修改的可持久化线段树模版题，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
 // 1 <= n、m <= 2 * 10^5
diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code01_PersistentSegmentTree2.java
index 6634d416c..6ab6d4796 100644
--- a/src/class157/Code01_PersistentSegmentTree2.java
+++ b/src/class157/Code01_PersistentSegmentTree2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 可持久化线段树模版题，C++版
+// 单点修改的可持久化线段树模版题，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
 // 1 <= n、m <= 2 * 10^5

From 44cd77526256863ec15793a43b8508f119430170 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 15:16:40 +0800
Subject: [PATCH 0350/1712] modify code

---
 ...ifferentNumbers1.java => Code04_DifferentNumbersKth1.java} | 4 ++--
 ...ifferentNumbers2.java => Code04_DifferentNumbersKth2.java} | 2 +-
 src/class157/Code05_LargestUpMedian1.java                     | 2 +-
 src/class157/Code05_LargestUpMedian2.java                     | 2 +-
 src/class157/Code06_CountOnTree1.java                         | 2 +-
 src/class157/Code06_CountOnTree2.java                         | 2 +-
 6 files changed, 7 insertions(+), 7 deletions(-)
 rename src/class157/{Code04_DifferentNumbers1.java => Code04_DifferentNumbersKth1.java} (98%)
 rename src/class157/{Code04_DifferentNumbers2.java => Code04_DifferentNumbersKth2.java} (98%)

diff --git a/src/class157/Code04_DifferentNumbers1.java b/src/class157/Code04_DifferentNumbersKth1.java
similarity index 98%
rename from src/class157/Code04_DifferentNumbers1.java
rename to src/class157/Code04_DifferentNumbersKth1.java
index 1a9ad5ea3..ff11fd605 100644
--- a/src/class157/Code04_DifferentNumbers1.java
+++ b/src/class157/Code04_DifferentNumbersKth1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 区间内的不同数字，java版
+// 区间内不同数字的第k小，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
@@ -16,7 +16,7 @@
 import java.io.IOException;
 import java.util.Arrays;
 
-public class Code04_DifferentNumbers1 {
+public class Code04_DifferentNumbersKth1 {
 
 	public static int MAXN = 200002;
 
diff --git a/src/class157/Code04_DifferentNumbers2.java b/src/class157/Code04_DifferentNumbersKth2.java
similarity index 98%
rename from src/class157/Code04_DifferentNumbers2.java
rename to src/class157/Code04_DifferentNumbersKth2.java
index 244bf3ae1..361824d3c 100644
--- a/src/class157/Code04_DifferentNumbers2.java
+++ b/src/class157/Code04_DifferentNumbersKth2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 区间内的不同数字，C++版
+// 区间内不同数字的第k小，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
diff --git a/src/class157/Code05_LargestUpMedian1.java b/src/class157/Code05_LargestUpMedian1.java
index e21ff5b4f..c7d331640 100644
--- a/src/class157/Code05_LargestUpMedian1.java
+++ b/src/class157/Code05_LargestUpMedian1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 区间最大上中位数，java版
+// 浮动区间的最大上中位数，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
 //                   哪个区间有最大的上中位数，打印最大的上中位数
diff --git a/src/class157/Code05_LargestUpMedian2.java b/src/class157/Code05_LargestUpMedian2.java
index c7a6a660f..145424a0a 100644
--- a/src/class157/Code05_LargestUpMedian2.java
+++ b/src/class157/Code05_LargestUpMedian2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 区间最大上中位数，C++版
+// 浮动区间的最大上中位数，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
 //                   哪个区间有最大的上中位数，打印最大的上中位数
diff --git a/src/class157/Code06_CountOnTree1.java b/src/class157/Code06_CountOnTree1.java
index 5d3c89222..da0808874 100644
--- a/src/class157/Code06_CountOnTree1.java
+++ b/src/class157/Code06_CountOnTree1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 节点路径第k小值，java版
+// 路径上的第k小，java版
 // 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
 // 一共有m条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
diff --git a/src/class157/Code06_CountOnTree2.java b/src/class157/Code06_CountOnTree2.java
index cb4d01c09..9770cb763 100644
--- a/src/class157/Code06_CountOnTree2.java
+++ b/src/class157/Code06_CountOnTree2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 节点路径第k小值，C++版
+// 路径上的第k小，C++版
 // 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
 // 一共有m条查询，每条查询 u v k : 打印u号点到v号点的路径上，第k小的点权
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0

From 92298d05510cc85aab09076b847b225079014e0c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 15:33:14 +0800
Subject: [PATCH 0351/1712] modify code

---
 src/class157/Code01_PersistentSegmentTree1.java | 1 +
 src/class157/Code01_PersistentSegmentTree2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class157/Code01_PersistentSegmentTree1.java b/src/class157/Code01_PersistentSegmentTree1.java
index f0f462019..d91890ff8 100644
--- a/src/class157/Code01_PersistentSegmentTree1.java
+++ b/src/class157/Code01_PersistentSegmentTree1.java
@@ -4,6 +4,7 @@
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
 // 1 <= n、m <= 2 * 10^5
+// 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code01_PersistentSegmentTree2.java
index 6ab6d4796..15a205200 100644
--- a/src/class157/Code01_PersistentSegmentTree2.java
+++ b/src/class157/Code01_PersistentSegmentTree2.java
@@ -4,6 +4,7 @@
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
 // 1 <= n、m <= 2 * 10^5
+// 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 9e459d519ab66139c53ffb7eeb967a57727e4b48 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 15:45:34 +0800
Subject: [PATCH 0352/1712] modify code

---
 .../Code01_PersistentSegmentTree1.java        | 20 ++++++++++++-------
 .../Code01_PersistentSegmentTree2.java        | 20 ++++++++++++-------
 2 files changed, 26 insertions(+), 14 deletions(-)

diff --git a/src/class157/Code01_PersistentSegmentTree1.java b/src/class157/Code01_PersistentSegmentTree1.java
index d91890ff8..bc50ce875 100644
--- a/src/class157/Code01_PersistentSegmentTree1.java
+++ b/src/class157/Code01_PersistentSegmentTree1.java
@@ -22,7 +22,7 @@ public class Code01_PersistentSegmentTree1 {
 
 	public static int MAXM = MAXN * 22;
 
-	public static int n, m;
+	public static int n, s, m;
 
 	public static int[] arr = new int[MAXN];
 
@@ -39,7 +39,7 @@ public class Code01_PersistentSegmentTree1 {
 	public static int cnt;
 
 	public static int kth(int num) {
-		int left = 1, right = n, mid, ans = 0;
+		int left = 1, right = s, mid, ans = 0;
 		while (left <= right) {
 			mid = (left + right) / 2;
 			if (sorted[mid] <= num) {
@@ -98,10 +98,16 @@ public static void prepare() {
 			sorted[i] = arr[i];
 		}
 		Arrays.sort(sorted, 1, n + 1);
-		root[0] = build(1, n);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[s] != sorted[i]) {
+				sorted[++s] = sorted[i];
+			}
+		}
+		root[0] = build(1, s);
 		for (int i = 1, x; i <= n; i++) {
 			x = kth(arr[i]);
-			root[i] = insert(x, 1, n, root[i - 1]);
+			root[i] = insert(x, 1, s, root[i - 1]);
 		}
 	}
 
@@ -118,15 +124,15 @@ public static void main(String[] args) throws IOException {
 			arr[i] = (int) in.nval;
 		}
 		prepare();
-		for (int i = 1, l, r, k; i <= m; i++) {
+		for (int i = 1, l, r, k, rank; i <= m; i++) {
 			in.nextToken();
 			l = (int) in.nval;
 			in.nextToken();
 			r = (int) in.nval;
 			in.nextToken();
 			k = (int) in.nval;
-			int ans = query(k, 1, n, root[l - 1], root[r]);
-			out.println(sorted[ans]);
+			rank = query(k, 1, s, root[l - 1], root[r]);
+			out.println(sorted[rank]);
 		}
 		out.flush();
 		out.close();
diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code01_PersistentSegmentTree2.java
index 15a205200..ce0556e33 100644
--- a/src/class157/Code01_PersistentSegmentTree2.java
+++ b/src/class157/Code01_PersistentSegmentTree2.java
@@ -15,7 +15,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXM = MAXN * 22;
-//int n, m;
+//int n, s, m;
 //int arr[MAXN];
 //int sorted[MAXN];
 //int root[MAXN];
@@ -25,7 +25,7 @@
 //int cnt;
 //
 //int kth(int num) {
-//    int left = 1, right = n, mid, ans = 0;
+//    int left = 1, right = s, mid, ans = 0;
 //    while (left <= right) {
 //        mid = (left + right) / 2;
 //        if (sorted[mid] <= num) {
@@ -84,10 +84,16 @@
 //        sorted[i] = arr[i];
 //    }
 //    sort(sorted + 1, sorted + n + 1);
-//    root[0] = build(1, n);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[s] != sorted[i]) {
+//            sorted[++s] = sorted[i];
+//        }
+//    }
+//    root[0] = build(1, s);
 //    for (int i = 1, x; i <= n; i++) {
 //        x = kth(arr[i]);
-//        root[i] = insert(x, 1, n, root[i - 1]);
+//        root[i] = insert(x, 1, s, root[i - 1]);
 //    }
 //}
 //
@@ -99,10 +105,10 @@
 //        cin >> arr[i];
 //    }
 //    prepare();
-//    for (int i = 1, l, r, k; i <= m; i++) {
+//    for (int i = 1, l, r, k, rank; i <= m; i++) {
 //        cin >> l >> r >> k;
-//        int ans = query(k, 1, n, root[l - 1], root[r]);
-//        cout << sorted[ans] << '\n';
+//        rank = query(k, 1, s, root[l - 1], root[r]);
+//        cout << sorted[rank] << '\n';
 //    }
 //    return 0;
 //}
\ No newline at end of file

From fa05386313a4edac368756ace0fd2dc7b6e3c83a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 16:06:34 +0800
Subject: [PATCH 0353/1712] modify code

---
 src/class044/Code02_TrieTree.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/class044/Code02_TrieTree.java b/src/class044/Code02_TrieTree.java
index a840ff155..44efbfff1 100644
--- a/src/class044/Code02_TrieTree.java
+++ b/src/class044/Code02_TrieTree.java
@@ -71,6 +71,10 @@ public static int prefixNumber(String pre) {
 	public static void delete(String word) {
 		if (search(word) > 0) {
 			int cur = 1;
+			// 如下这行代码，讲课的时候没加
+			// 本题不会用到pass[1]的信息，所以加不加都可以
+			// 不过正确的写法是加上
+			pass[cur]--;
 			for (int i = 0, path; i < word.length(); i++) {
 				path = word.charAt(i) - 'a';
 				if (--pass[tree[cur][path]] == 0) {

From f7c33bf0fd9ad9287259ae46d182cf4106930f28 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 16:07:53 +0800
Subject: [PATCH 0354/1712] modify code

---
 src/class044/Code02_TrieTree.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/class044/Code02_TrieTree.java b/src/class044/Code02_TrieTree.java
index 44efbfff1..53033c44f 100644
--- a/src/class044/Code02_TrieTree.java
+++ b/src/class044/Code02_TrieTree.java
@@ -71,9 +71,8 @@ public static int prefixNumber(String pre) {
 	public static void delete(String word) {
 		if (search(word) > 0) {
 			int cur = 1;
-			// 如下这行代码，讲课的时候没加
-			// 本题不会用到pass[1]的信息，所以加不加都可以
-			// 不过正确的写法是加上
+			// 下面这一行代码，讲课的时候没加
+			// 本题不会用到pass[1]的信息，所以加不加都可以，不过正确的写法是加上
 			pass[cur]--;
 			for (int i = 0, path; i < word.length(); i++) {
 				path = word.charAt(i) - 'a';

From 10d2f6bb6d63dd8d872eac07e1af61ed33f31910 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 16:12:02 +0800
Subject: [PATCH 0355/1712] modify code

---
 src/class157/Code01_PersistentSegmentTree1.java | 2 +-
 src/class157/Code01_PersistentSegmentTree2.java | 2 +-
 src/class157/Code06_CountOnTree1.java           | 2 +-
 src/class157/Code06_CountOnTree2.java           | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class157/Code01_PersistentSegmentTree1.java b/src/class157/Code01_PersistentSegmentTree1.java
index bc50ce875..5403870b1 100644
--- a/src/class157/Code01_PersistentSegmentTree1.java
+++ b/src/class157/Code01_PersistentSegmentTree1.java
@@ -22,7 +22,7 @@ public class Code01_PersistentSegmentTree1 {
 
 	public static int MAXM = MAXN * 22;
 
-	public static int n, s, m;
+	public static int n, m, s;
 
 	public static int[] arr = new int[MAXN];
 
diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code01_PersistentSegmentTree2.java
index ce0556e33..73b4948cb 100644
--- a/src/class157/Code01_PersistentSegmentTree2.java
+++ b/src/class157/Code01_PersistentSegmentTree2.java
@@ -15,7 +15,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXM = MAXN * 22;
-//int n, s, m;
+//int n, m, s;
 //int arr[MAXN];
 //int sorted[MAXN];
 //int root[MAXN];
diff --git a/src/class157/Code06_CountOnTree1.java b/src/class157/Code06_CountOnTree1.java
index da0808874..e33585668 100644
--- a/src/class157/Code06_CountOnTree1.java
+++ b/src/class157/Code06_CountOnTree1.java
@@ -29,7 +29,7 @@ public class Code06_CountOnTree1 {
 
 	public static int MAXM = MAXN * MAXH;
 
-	public static int n, s, m;
+	public static int n, m, s;
 
 	// 各个节点权值
 	public static int[] arr = new int[MAXN];
diff --git a/src/class157/Code06_CountOnTree2.java b/src/class157/Code06_CountOnTree2.java
index 9770cb763..f1347a8bd 100644
--- a/src/class157/Code06_CountOnTree2.java
+++ b/src/class157/Code06_CountOnTree2.java
@@ -21,7 +21,7 @@
 //const int MAXN = 100001;
 //const int MAXH = 20;
 //const int MAXM = MAXN * MAXH;
-//int n, s, m;
+//int n, m, s;
 //int arr[MAXN];
 //int sorted[MAXN];
 //

From eaf3448d4a557649f301befc78b477ded9e95672 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 16:25:26 +0800
Subject: [PATCH 0356/1712] modify code

---
 src/class157/Code02_TagPermanentization1.java | 8 ++++----
 src/class157/Code02_TagPermanentization2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class157/Code02_TagPermanentization1.java b/src/class157/Code02_TagPermanentization1.java
index 5315fda8a..ee02d1043 100644
--- a/src/class157/Code02_TagPermanentization1.java
+++ b/src/class157/Code02_TagPermanentization1.java
@@ -85,17 +85,17 @@ public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static long query(int jobl, int jobr, long historyAdd, int l, int r, int i) {
+	public static long query(int jobl, int jobr, long addHistory, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			return sum[i] + historyAdd * (r - l + 1);
+			return sum[i] + addHistory * (r - l + 1);
 		}
 		int mid = (l + r) / 2;
 		long ans = 0;
 		if (jobl <= mid) {
-			ans += query(jobl, jobr, historyAdd + addTag[i], l, mid, left[i]);
+			ans += query(jobl, jobr, addHistory + addTag[i], l, mid, left[i]);
 		}
 		if (jobr > mid) {
-			ans += query(jobl, jobr, historyAdd + addTag[i], mid + 1, r, right[i]);
+			ans += query(jobl, jobr, addHistory + addTag[i], mid + 1, r, right[i]);
 		}
 		return ans;
 	}
diff --git a/src/class157/Code02_TagPermanentization2.java b/src/class157/Code02_TagPermanentization2.java
index 2449185ee..f68bc56e2 100644
--- a/src/class157/Code02_TagPermanentization2.java
+++ b/src/class157/Code02_TagPermanentization2.java
@@ -63,17 +63,17 @@
 //    return rt;
 //}
 //
-//long long query(int jobl, int jobr, long long historyAdd, int l, int r, int i) {
+//long long query(int jobl, int jobr, long long addHistory, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
-//        return sum[i] + historyAdd * (r - l + 1);
+//        return sum[i] + addHistory * (r - l + 1);
 //    }
 //    int mid = (l + r) / 2;
 //    long long ans = 0;
 //    if (jobl <= mid) {
-//        ans += query(jobl, jobr, historyAdd + addTag[i], l, mid, ls[i]);
+//        ans += query(jobl, jobr, addHistory + addTag[i], l, mid, ls[i]);
 //    }
 //    if (jobr > mid) {
-//        ans += query(jobl, jobr, historyAdd + addTag[i], mid + 1, r, rs[i]);
+//        ans += query(jobl, jobr, addHistory + addTag[i], mid + 1, r, rs[i]);
 //    }
 //    return ans;
 //}

From 4744d76f4124418f9f6a311a3d0c623bd29c9941 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 16:39:15 +0800
Subject: [PATCH 0357/1712] modify code

---
 src/class157/Code01_PersistentSegmentTree1.java | 14 ++++++++++++++
 src/class157/Code06_CountOnTree1.java           |  2 +-
 2 files changed, 15 insertions(+), 1 deletion(-)

diff --git a/src/class157/Code01_PersistentSegmentTree1.java b/src/class157/Code01_PersistentSegmentTree1.java
index 5403870b1..09d7d89fe 100644
--- a/src/class157/Code01_PersistentSegmentTree1.java
+++ b/src/class157/Code01_PersistentSegmentTree1.java
@@ -24,20 +24,28 @@ public class Code01_PersistentSegmentTree1 {
 
 	public static int n, m, s;
 
+	// 原始数组
 	public static int[] arr = new int[MAXN];
 
+	// 收集权值排序并且去重做离散化
 	public static int[] sorted = new int[MAXN];
 
+	// 可持久化线段树需要
+	// root[i] : 插入arr[i]之后形成的线段树，记录头节点编号
 	public static int[] root = new int[MAXN];
 
+	// 左孩子
 	public static int[] left = new int[MAXM];
 
+	// 右孩子
 	public static int[] right = new int[MAXM];
 
+	// 收集了多少个数字
 	public static int[] size = new int[MAXM];
 
 	public static int cnt;
 
+	// 返回num在所有值中排名多少
 	public static int kth(int num) {
 		int left = 1, right = s, mid, ans = 0;
 		while (left <= right) {
@@ -52,6 +60,7 @@ public static int kth(int num) {
 		return ans;
 	}
 
+	// l~r范围建立线段树，返回头节点编号
 	public static int build(int l, int r) {
 		int rt = ++cnt;
 		size[rt] = 0;
@@ -63,6 +72,8 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
+	// l~r范围，信息在i位置，增加一个jobi位置上的数字
+	// 返回新的头节点编号
 	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
@@ -79,6 +90,8 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
+	// l~r范围，老版本信息在u位置，新版本信息在v位置
+	// 返回第jobk小的数是多少
 	public static int query(int jobk, int l, int r, int u, int v) {
 		if (l == r) {
 			return l;
@@ -92,6 +105,7 @@ public static int query(int jobk, int l, int r, int u, int v) {
 		}
 	}
 
+	// 权值做离散化并且去重 + 生成各版本的线段树
 	public static void prepare() {
 		cnt = 0;
 		for (int i = 1; i <= n; i++) {
diff --git a/src/class157/Code06_CountOnTree1.java b/src/class157/Code06_CountOnTree1.java
index e33585668..a8d6a2f86 100644
--- a/src/class157/Code06_CountOnTree1.java
+++ b/src/class157/Code06_CountOnTree1.java
@@ -34,7 +34,7 @@ public class Code06_CountOnTree1 {
 	// 各个节点权值
 	public static int[] arr = new int[MAXN];
 
-	// 收集权值排序做离散化
+	// 收集权值排序并且去重做离散化
 	public static int[] sorted = new int[MAXN];
 
 	// 链式前向星需要

From e7a465c0bca672c8277203d86b31dd4041930762 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 16:57:10 +0800
Subject: [PATCH 0358/1712] modify code

---
 src/class157/Code02_TagPermanentization1.java | 10 ++++++++++
 src/class157/Code03_MissingSmallest1.java     |  3 +++
 src/class157/Code04_DifferentNumbersKth1.java |  3 +++
 src/class157/Code05_LargestUpMedian1.java     |  1 +
 src/class157/Code07_MoreImpressive1.java      |  3 +++
 5 files changed, 20 insertions(+)

diff --git a/src/class157/Code02_TagPermanentization1.java b/src/class157/Code02_TagPermanentization1.java
index ee02d1043..9fe9a6a5b 100644
--- a/src/class157/Code02_TagPermanentization1.java
+++ b/src/class157/Code02_TagPermanentization1.java
@@ -31,16 +31,21 @@ public class Code02_TagPermanentization1 {
 
 	public static int n, m, t = 0;
 
+	// 原始数组
 	public static int[] arr = new int[MAXN];
 
+	// 可持久化线段树需要
+	// root[i] : 时间戳i为版本号，线段树的头节点编号
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXM];
 
 	public static int[] right = new int[MAXM];
 
+	// 区间累加和
 	public static long[] sum = new long[MAXM];
 
+	// 区间关于加的懒更新信息，变成了标记永久化信息
 	public static long[] addTag = new long[MAXM];
 
 	public static int cnt = 0;
@@ -65,6 +70,8 @@ public static void prepare() {
 		root[0] = build(1, n);
 	}
 
+	// l~r范围，信息在i位置，任务是jobl~jobr范围，所有数字增加jobv
+	// 返回新的头节点编号
 	public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
 		int rt = ++cnt, a = Math.max(jobl, l), b = Math.min(jobr, r);
 		left[rt] = left[i];
@@ -85,6 +92,9 @@ public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
 		return rt;
 	}
 
+	// l~r范围，信息在i位置，任务是jobl~jobr范围，查询累加和
+	// addHistory是从上方的大范围一路带下来的标记历史
+	// 返回累加和
 	public static long query(int jobl, int jobr, long addHistory, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			return sum[i] + addHistory * (r - l + 1);
diff --git a/src/class157/Code03_MissingSmallest1.java b/src/class157/Code03_MissingSmallest1.java
index b5df3ccac..86fde1a3d 100644
--- a/src/class157/Code03_MissingSmallest1.java
+++ b/src/class157/Code03_MissingSmallest1.java
@@ -47,6 +47,8 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
+	// l~r范围，信息在i位置，jobi这个数字，最新出现在jobv位置
+	// 返回新的头节点编号
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
@@ -66,6 +68,7 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
+	// 数字在l~r范围上，没有出现的最小自然数，课上重点图解
 	public static int query(int pos, int l, int r, int i) {
 		if (l == r) {
 			return l;
diff --git a/src/class157/Code04_DifferentNumbersKth1.java b/src/class157/Code04_DifferentNumbersKth1.java
index ff11fd605..eef2ea10e 100644
--- a/src/class157/Code04_DifferentNumbersKth1.java
+++ b/src/class157/Code04_DifferentNumbersKth1.java
@@ -26,14 +26,17 @@ public class Code04_DifferentNumbersKth1 {
 
 	public static int[] arr = new int[MAXN];
 
+	// pos[v] : v这个数字最左出现的位置
 	public static int[] pos = new int[MAXN];
 
+	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXM];
 
 	public static int[] right = new int[MAXM];
 
+	// 区间不同数字的个数
 	public static int[] diff = new int[MAXM];
 
 	public static int cnt;
diff --git a/src/class157/Code05_LargestUpMedian1.java b/src/class157/Code05_LargestUpMedian1.java
index c7d331640..dba38ef6a 100644
--- a/src/class157/Code05_LargestUpMedian1.java
+++ b/src/class157/Code05_LargestUpMedian1.java
@@ -34,6 +34,7 @@ public class Code05_LargestUpMedian1 {
 	// 原始位置、数值
 	public static int[][] arr = new int[MAXN][2];
 
+	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXM];
diff --git a/src/class157/Code07_MoreImpressive1.java b/src/class157/Code07_MoreImpressive1.java
index ae2e02b14..542ce253a 100644
--- a/src/class157/Code07_MoreImpressive1.java
+++ b/src/class157/Code07_MoreImpressive1.java
@@ -46,10 +46,13 @@ public class Code07_MoreImpressive1 {
 	public static int cntt = 0;
 
 	// dfs需要
+	// deep[i] : i号节点的深度
 	public static int[] deep = new int[MAXN];
 
+	// size[i] : 以i号节点为头的树，有多少个节点
 	public static int[] size = new int[MAXN];
 
+	// dfn[i] : i号节点的dfn序号
 	public static int[] dfn = new int[MAXN];
 
 	public static int cntd = 0;

From 81d9108329da24cde29aed9b58015ccbce60fe4c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 17:00:45 +0800
Subject: [PATCH 0359/1712] modify code

---
 ...fferentNumbersKth1.java => Code03_DifferentNumbersKth1.java} | 2 +-
 ...fferentNumbersKth2.java => Code03_DifferentNumbersKth2.java} | 0
 ...ode03_MissingSmallest1.java => Code04_MissingSmallest1.java} | 2 +-
 ...ode03_MissingSmallest2.java => Code04_MissingSmallest2.java} | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class157/{Code04_DifferentNumbersKth1.java => Code03_DifferentNumbersKth1.java} (99%)
 rename src/class157/{Code04_DifferentNumbersKth2.java => Code03_DifferentNumbersKth2.java} (100%)
 rename src/class157/{Code03_MissingSmallest1.java => Code04_MissingSmallest1.java} (98%)
 rename src/class157/{Code03_MissingSmallest2.java => Code04_MissingSmallest2.java} (100%)

diff --git a/src/class157/Code04_DifferentNumbersKth1.java b/src/class157/Code03_DifferentNumbersKth1.java
similarity index 99%
rename from src/class157/Code04_DifferentNumbersKth1.java
rename to src/class157/Code03_DifferentNumbersKth1.java
index eef2ea10e..e167cfb52 100644
--- a/src/class157/Code04_DifferentNumbersKth1.java
+++ b/src/class157/Code03_DifferentNumbersKth1.java
@@ -16,7 +16,7 @@
 import java.io.IOException;
 import java.util.Arrays;
 
-public class Code04_DifferentNumbersKth1 {
+public class Code03_DifferentNumbersKth1 {
 
 	public static int MAXN = 200002;
 
diff --git a/src/class157/Code04_DifferentNumbersKth2.java b/src/class157/Code03_DifferentNumbersKth2.java
similarity index 100%
rename from src/class157/Code04_DifferentNumbersKth2.java
rename to src/class157/Code03_DifferentNumbersKth2.java
diff --git a/src/class157/Code03_MissingSmallest1.java b/src/class157/Code04_MissingSmallest1.java
similarity index 98%
rename from src/class157/Code03_MissingSmallest1.java
rename to src/class157/Code04_MissingSmallest1.java
index 86fde1a3d..db09ee17b 100644
--- a/src/class157/Code03_MissingSmallest1.java
+++ b/src/class157/Code04_MissingSmallest1.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_MissingSmallest1 {
+public class Code04_MissingSmallest1 {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class157/Code03_MissingSmallest2.java b/src/class157/Code04_MissingSmallest2.java
similarity index 100%
rename from src/class157/Code03_MissingSmallest2.java
rename to src/class157/Code04_MissingSmallest2.java

From 29215c0a4349a5d3ab3a4eca3dd79e9094f0ad11 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 17:07:01 +0800
Subject: [PATCH 0360/1712] modify code

---
 src/class157/Code04_MissingSmallest1.java | 2 +-
 src/class157/Code04_MissingSmallest2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code04_MissingSmallest1.java b/src/class157/Code04_MissingSmallest1.java
index db09ee17b..5bfd203e3 100644
--- a/src/class157/Code04_MissingSmallest1.java
+++ b/src/class157/Code04_MissingSmallest1.java
@@ -88,7 +88,7 @@ public static int query(int pos, int l, int r, int i) {
 
 	public static void prepare() {
 		cnt = 0;
-		root[0] = build(1, n);
+		root[0] = build(0, n);
 		for (int i = 1; i <= n; i++) {
 			if (arr[i] >= n) {
 				root[i] = root[i - 1];
diff --git a/src/class157/Code04_MissingSmallest2.java b/src/class157/Code04_MissingSmallest2.java
index ad2f8635f..ab2d25b3b 100644
--- a/src/class157/Code04_MissingSmallest2.java
+++ b/src/class157/Code04_MissingSmallest2.java
@@ -66,7 +66,7 @@
 //
 //void prepare() {
 //    cnt = 0;
-//    root[0] = build(1, n);
+//    root[0] = build(0, n);
 //    for (int i = 1; i <= n; i++) {
 //        if (arr[i] >= n) {
 //            root[i] = root[i - 1];

From 140ba31303218bb44ebf7ed52e1bffd241f4de5f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Jan 2025 18:48:56 +0800
Subject: [PATCH 0361/1712] modify code

---
 ...fferentNumbersKth1.java => Code03_Sequence1.java} | 12 +++++++-----
 ...fferentNumbersKth2.java => Code03_Sequence2.java} | 10 ++++++----
 src/class157/Code04_MissingSmallest1.java            |  3 ++-
 src/class157/Code04_MissingSmallest2.java            |  3 ++-
 4 files changed, 17 insertions(+), 11 deletions(-)
 rename src/class157/{Code03_DifferentNumbersKth1.java => Code03_Sequence1.java} (92%)
 rename src/class157/{Code03_DifferentNumbersKth2.java => Code03_Sequence2.java} (90%)

diff --git a/src/class157/Code03_DifferentNumbersKth1.java b/src/class157/Code03_Sequence1.java
similarity index 92%
rename from src/class157/Code03_DifferentNumbersKth1.java
rename to src/class157/Code03_Sequence1.java
index e167cfb52..2614807ac 100644
--- a/src/class157/Code03_DifferentNumbersKth1.java
+++ b/src/class157/Code03_Sequence1.java
@@ -1,22 +1,24 @@
 package class157;
 
-// 区间内不同数字的第k小，java版
-// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
-// 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
+// 下标序列，java版
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询，每条查询格式如下
+// l r : arr[l..r]范围上，每个数第一次出现的位置，把这些位置组成一个序列
+//       假设该范围有s种不同的数，那么序列长度为s
+//       打印该序列第s/2个位置(向上取整)，对应arr的什么位置
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的l和r，按照如下方式得到真实的l和r，查询完成后更新lastAns
 // a = (给定l + lastAns) % n + 1
 // b = (给定r + lastAns) % n + 1
 // 真实l = min(a, b)
 // 真实r = max(a, b)
-// 1 <= n、m、arr[i] <= 2 * 10^5
+// 1 <= n、m <= 2 * 10^5    0 <= arr[i] <= 2 * 10^5
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.util.Arrays;
 
-public class Code03_DifferentNumbersKth1 {
+public class Code03_Sequence1 {
 
 	public static int MAXN = 200002;
 
diff --git a/src/class157/Code03_DifferentNumbersKth2.java b/src/class157/Code03_Sequence2.java
similarity index 90%
rename from src/class157/Code03_DifferentNumbersKth2.java
rename to src/class157/Code03_Sequence2.java
index 361824d3c..fa869c49f 100644
--- a/src/class157/Code03_DifferentNumbersKth2.java
+++ b/src/class157/Code03_Sequence2.java
@@ -1,15 +1,17 @@
 package class157;
 
-// 区间内不同数字的第k小，C++版
-// 给定一个长度为n的数组arr，下标1~n，一共有m条查询
-// 每条查询 l r : 如果arr[l..r]范围有s种不同的数，打印第s/2种数，向上取整
+// 下标序列，C++版
+// 给定一个长度为n的数组arr，下标1~n，一共有m条查询，每条查询格式如下
+// l r : arr[l..r]范围上，每个数第一次出现的位置，把这些位置组成一个序列
+//       假设该范围有s种不同的数，那么序列长度为s
+//       打印该序列第s/2个位置(向上取整)，对应arr的什么位置
 // 题目有强制在线的要求，上一次打印的答案为lastAns，初始时lastAns = 0
 // 每次给定的l和r，按照如下方式得到真实的l和r，查询完成后更新lastAns
 // a = (给定l + lastAns) % n + 1
 // b = (给定r + lastAns) % n + 1
 // 真实l = min(a, b)
 // 真实r = max(a, b)
-// 1 <= n、m、arr[i] <= 2 * 10^5
+// 1 <= n、m <= 2 * 10^5    0 <= arr[i] <= 2 * 10^5
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5919
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class157/Code04_MissingSmallest1.java b/src/class157/Code04_MissingSmallest1.java
index 5bfd203e3..34fb0fe7c 100644
--- a/src/class157/Code04_MissingSmallest1.java
+++ b/src/class157/Code04_MissingSmallest1.java
@@ -3,7 +3,8 @@
 // 区间内没有出现的最小自然数，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
-// 1 <= n、m、arr[i] <= 2 * 10^5
+// 1 <= n、m <= 2 * 10^5
+// 0 <= arr[i] <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4137
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class157/Code04_MissingSmallest2.java b/src/class157/Code04_MissingSmallest2.java
index ab2d25b3b..e0c5a8baf 100644
--- a/src/class157/Code04_MissingSmallest2.java
+++ b/src/class157/Code04_MissingSmallest2.java
@@ -3,7 +3,8 @@
 // 区间内没有出现的最小自然数，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
-// 1 <= n、m、arr[i] <= 2 * 10^5
+// 1 <= n、m <= 2 * 10^5
+// 0 <= arr[i] <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4137
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 4a084201e01eab2acfa0adfac8f4c699c67de6ff Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Jan 2025 18:55:22 +0800
Subject: [PATCH 0362/1712] modify code

---
 src/class157/Code01_PointPersistent1.java     | 182 ++++++++++++
 src/class157/Code01_PointPersistent2.java     |  89 ++++++
 ...ree1.java => Code02_PointPersistent1.java} |  12 +-
 ...ree2.java => Code02_PointPersistent2.java} |  10 +-
 src/class157/Code03_RangePersistent1.java     | 262 ++++++++++++++++++
 src/class157/Code03_RangePersistent2.java     | 143 ++++++++++
 src/class157/Code04_TagPermanentization1.java | 110 ++++++++
 src/class157/Code04_TagPermanentization2.java |  88 ++++++
 ...ion1.java => Code05_RangePersistent1.java} |  24 +-
 ...ion2.java => Code05_RangePersistent2.java} |  14 +-
 .../Code01_FirstTimeSequence1.java}           |  14 +-
 .../Code01_FirstTimeSequence2.java}           |  12 +-
 .../Code02_MissingSmallest1.java}             |  12 +-
 .../Code02_MissingSmallest2.java}             |  10 +-
 .../Code03_LargestUpMedian1.java}             |  16 +-
 .../Code03_LargestUpMedian2.java}             |  14 +-
 .../Code04_CountOnTree1.java}                 |  12 +-
 .../Code04_CountOnTree2.java}                 |  10 +-
 .../Code05_MoreImpressive1.java}              |  12 +-
 .../Code05_MoreImpressive2.java}              |  10 +-
 20 files changed, 964 insertions(+), 92 deletions(-)
 create mode 100644 src/class157/Code01_PointPersistent1.java
 create mode 100644 src/class157/Code01_PointPersistent2.java
 rename src/class157/{Code01_PersistentSegmentTree1.java => Code02_PointPersistent1.java} (93%)
 rename src/class157/{Code01_PersistentSegmentTree2.java => Code02_PointPersistent2.java} (95%)
 create mode 100644 src/class157/Code03_RangePersistent1.java
 create mode 100644 src/class157/Code03_RangePersistent2.java
 create mode 100644 src/class157/Code04_TagPermanentization1.java
 create mode 100644 src/class157/Code04_TagPermanentization2.java
 rename src/class157/{Code02_TagPermanentization1.java => Code05_RangePersistent1.java} (86%)
 rename src/class157/{Code02_TagPermanentization2.java => Code05_RangePersistent2.java} (92%)
 rename src/{class157/Code03_Sequence1.java => class158/Code01_FirstTimeSequence1.java} (95%)
 rename src/{class157/Code03_Sequence2.java => class158/Code01_FirstTimeSequence2.java} (96%)
 rename src/{class157/Code04_MissingSmallest1.java => class158/Code02_MissingSmallest1.java} (93%)
 rename src/{class157/Code04_MissingSmallest2.java => class158/Code02_MissingSmallest2.java} (95%)
 rename src/{class157/Code05_LargestUpMedian1.java => class158/Code03_LargestUpMedian1.java} (93%)
 rename src/{class157/Code05_LargestUpMedian2.java => class158/Code03_LargestUpMedian2.java} (96%)
 rename src/{class157/Code06_CountOnTree1.java => class158/Code04_CountOnTree1.java} (96%)
 rename src/{class157/Code06_CountOnTree2.java => class158/Code04_CountOnTree2.java} (97%)
 rename src/{class157/Code07_MoreImpressive1.java => class158/Code05_MoreImpressive1.java} (96%)
 rename src/{class157/Code07_MoreImpressive2.java => class158/Code05_MoreImpressive2.java} (97%)

diff --git a/src/class157/Code01_PointPersistent1.java b/src/class157/Code01_PointPersistent1.java
new file mode 100644
index 000000000..e9f2081de
--- /dev/null
+++ b/src/class157/Code01_PointPersistent1.java
@@ -0,0 +1,182 @@
+package class157;
+
+// 单点修改的可持久化线段树模版题1，java版
+// 给定一个长度为n的数组arr，下标1~n，原始数组认为是0号版本
+// 一共有m条操作，每条操作是如下两种类型中的一种
+// v 1 x y : 基于v号版本的数组，把x位置的值设置成y，生成新版本的数组
+// v 2 x   : 基于v号版本的数组，打印x位置的值，生成新版本的数组和v版本一致
+// 每条操作后得到的新版本数组，版本编号为操作的计数
+// 1 <= n, m <= 10^6
+// 测试链接 : https://www.luogu.com.cn/problem/P3919
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.io.IOException;
+
+public class Code01_PointPersistent1 {
+
+	public static int MAXN = 1000001;
+
+	public static int MAXT = MAXN * 23;
+
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static int[] value = new int[MAXT];
+
+	public static int cnt = 0;
+
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		if (l == r) {
+			value[rt] = arr[l];
+		} else {
+			int mid = (l + r) >> 1;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int update(int jobi, int jobv, int l, int r, int i) {
+		int rt = ++cnt;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		value[rt] = value[i];
+		if (l == r) {
+			value[rt] = jobv;
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				left[rt] = update(jobi, jobv, l, mid, left[rt]);
+			} else {
+				right[rt] = update(jobi, jobv, mid + 1, r, right[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static int query(int jobi, int l, int r, int i) {
+		if (l == r) {
+			return value[i];
+		}
+		int mid = (l + r) >> 1;
+		if (jobi <= mid) {
+			return query(jobi, l, mid, left[i]);
+		} else {
+			return query(jobi, mid + 1, r, right[i]);
+		}
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = io.nextInt();
+		}
+		root[0] = build(1, n);
+		for (int i = 1, version, op, x, y; i <= m; i++) {
+			version = io.nextInt();
+			op = io.nextInt();
+			x = io.nextInt();
+			if (op == 1) {
+				y = io.nextInt();
+				root[i] = update(x, y, 1, n, root[version]);
+			} else {
+				root[i] = root[version];
+				io.writelnInt(query(x, 1, n, root[i]));
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class157/Code01_PointPersistent2.java b/src/class157/Code01_PointPersistent2.java
new file mode 100644
index 000000000..40d4980fb
--- /dev/null
+++ b/src/class157/Code01_PointPersistent2.java
@@ -0,0 +1,89 @@
+package class157;
+
+// 单点修改的可持久化线段树模版题1，C++版
+// 给定一个长度为n的数组arr，下标1~n，原始数组认为是0号版本
+// 一共有m条操作，每条操作是如下两种类型中的一种
+// v 1 x y : 基于v号版本的数组，把x位置的值设置成y，生成新版本的数组
+// v 2 x   : 基于v号版本的数组，打印x位置的值，生成新版本的数组和v版本一致
+// 每条操作后得到的新版本数组，版本编号为操作的计数
+// 1 <= n, m <= 10^6
+// 测试链接 : https://www.luogu.com.cn/problem/P3919
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//const int MAXT = MAXN * 23;
+//int n, m;
+//int arr[MAXN];
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int value[MAXT];
+//int cnt = 0;
+//
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    if (l == r) {
+//        value[rt] = arr[l];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int update(int jobi, int jobv, int l, int r, int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    value[rt] = value[i];
+//    if (l == r) {
+//        value[rt] = jobv;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//int query(int jobi, int l, int r, int i) {
+//    if (l == r) {
+//        return value[i];
+//    }
+//    int mid = (l + r) >> 1;
+//    if (jobi <= mid) {
+//        return query(jobi, l, mid, ls[i]);
+//    } else {
+//        return query(jobi, mid + 1, r, rs[i]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    root[0] = build(1, n);
+//    for (int i = 1, version, op, x, y; i <= m; i++) {
+//        cin >> version >> op >> x;
+//        if (op == 1) {
+//            cin >> y;
+//            root[i] = update(x, y, 1, n, root[version]);
+//        } else {
+//            root[i] = root[version];
+//            cout << query(x, 1, n, root[i]) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code01_PersistentSegmentTree1.java b/src/class157/Code02_PointPersistent1.java
similarity index 93%
rename from src/class157/Code01_PersistentSegmentTree1.java
rename to src/class157/Code02_PointPersistent1.java
index 09d7d89fe..614328e9f 100644
--- a/src/class157/Code01_PersistentSegmentTree1.java
+++ b/src/class157/Code02_PointPersistent1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 单点修改的可持久化线段树模版题，java版
+// 单点修改的可持久化线段树模版题2，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
 // 1 <= n、m <= 2 * 10^5
@@ -16,11 +16,11 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code01_PersistentSegmentTree1 {
+public class Code02_PointPersistent1 {
 
 	public static int MAXN = 200001;
 
-	public static int MAXM = MAXN * 22;
+	public static int MAXT = MAXN * 22;
 
 	public static int n, m, s;
 
@@ -35,13 +35,13 @@ public class Code01_PersistentSegmentTree1 {
 	public static int[] root = new int[MAXN];
 
 	// 左孩子
-	public static int[] left = new int[MAXM];
+	public static int[] left = new int[MAXT];
 
 	// 右孩子
-	public static int[] right = new int[MAXM];
+	public static int[] right = new int[MAXT];
 
 	// 收集了多少个数字
-	public static int[] size = new int[MAXM];
+	public static int[] size = new int[MAXT];
 
 	public static int cnt;
 
diff --git a/src/class157/Code01_PersistentSegmentTree2.java b/src/class157/Code02_PointPersistent2.java
similarity index 95%
rename from src/class157/Code01_PersistentSegmentTree2.java
rename to src/class157/Code02_PointPersistent2.java
index 73b4948cb..31e5b9ca5 100644
--- a/src/class157/Code01_PersistentSegmentTree2.java
+++ b/src/class157/Code02_PointPersistent2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 单点修改的可持久化线段树模版题，C++版
+// 单点修改的可持久化线段树模版题2，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r k : 打印arr[l..r]中第k小的数字
 // 1 <= n、m <= 2 * 10^5
@@ -14,14 +14,14 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//const int MAXM = MAXN * 22;
+//const int MAXT = MAXN * 22;
 //int n, m, s;
 //int arr[MAXN];
 //int sorted[MAXN];
 //int root[MAXN];
-//int ls[MAXM];
-//int rs[MAXM];
-//int size[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//int size[MAXT];
 //int cnt;
 //
 //int kth(int num) {
diff --git a/src/class157/Code03_RangePersistent1.java b/src/class157/Code03_RangePersistent1.java
new file mode 100644
index 000000000..d8b740115
--- /dev/null
+++ b/src/class157/Code03_RangePersistent1.java
@@ -0,0 +1,262 @@
+package class157;
+
+// 范围修改的可持久化线段树，经典的方式，java版
+// 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
+// 一共有m条查询，每条查询为如下四种类型中的一种
+// C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
+// Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
+// H x y z : z版本的数组，打印[x..y]范围的累加和
+// B x     : 当前时间戳t设置成x
+// 1 <= n、m <= 10^5
+// -10^9 <= arr[i] <= +10^9
+// 测试链接 : https://www.luogu.com.cn/problem/SP11470
+// 测试链接 : https://www.spoj.com/problems/TTM/
+// 这是实现范围修改的可持久化线段树，经典的方式
+// 但是java的实现过不了，因为这道题各种平台测试的时候，就没考虑java的用户
+// 所以想通过就用C++实现吧，本节课Code03_RangePersistent2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+
+public class Code03_RangePersistent1 {
+
+	public static int MAXN = 100001;
+
+	public static int MAXT = MAXN * 100;
+
+	public static int n, m, t = 0;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static long[] sum = new long[MAXT];
+
+	public static long[] add = new long[MAXT];
+
+	public static int cnt = 0;
+
+	public static int clone(int i) {
+		int rt = ++cnt;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		sum[rt] = sum[i];
+		add[rt] = add[i];
+		return rt;
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[left[i]] + sum[right[i]];
+	}
+
+	public static void lazy(int i, long v, int n) {
+		sum[i] += v * n;
+		add[i] += v;
+	}
+
+	public static void down(int i, int ln, int rn) {
+		if (add[i] != 0) {
+			left[i] = clone(left[i]);
+			right[i] = clone(right[i]);
+			lazy(left[i], add[i], ln);
+			lazy(right[i], add[i], rn);
+			add[i] = 0;
+		}
+	}
+
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		add[rt] = 0;
+		if (l == r) {
+			sum[rt] = arr[l];
+		} else {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
+		int rt = clone(i);
+		if (jobl <= l && r <= jobr) {
+			lazy(rt, jobv, r - l + 1);
+		} else {
+			int mid = (l + r) / 2;
+			down(rt, mid - l + 1, r - mid);
+			if (jobl <= mid) {
+				left[rt] = add(jobl, jobr, jobv, l, mid, left[rt]);
+			}
+			if (jobr > mid) {
+				right[rt] = add(jobl, jobr, jobv, mid + 1, r, right[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static long query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		down(i, mid - l + 1, r - mid);
+		long ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, l, mid, left[i]);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, mid + 1, r, right[i]);
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		t = 0;
+		cnt = 0;
+		root[0] = build(1, n);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		root[0] = build(1, n);
+		String op;
+		for (int i = 1, x, y, z; i <= m; i++) {
+			op = in.next();
+			if (op.equals("C")) {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				root[t + 1] = add(x, y, z, 1, n, root[t]);
+				t++;
+			} else if (op.equals("Q")) {
+				x = in.nextInt();
+				y = in.nextInt();
+				out.write(query(x, y, 1, n, root[t]) + "\n");
+			} else if (op.equals("H")) {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				out.write(query(x, y, 1, n, root[z]) + "\n");
+			} else {
+				x = in.nextInt();
+				t = x;
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public boolean hasNext() throws IOException {
+			while (hasNextByte()) {
+				byte b = buffer[ptr];
+				if (!isWhitespace(b))
+					return true;
+				ptr++;
+			}
+			return false;
+		}
+
+		public String next() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return null;
+			} while (c <= ' ');
+			StringBuilder sb = new StringBuilder();
+			while (c > ' ') {
+				sb.append((char) c);
+				c = readByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public double nextDouble() throws IOException {
+			double num = 0, div = 1;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != '.' && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			if (b == '.') {
+				b = readByte();
+				while (!isWhitespace(b) && b != -1) {
+					num += (b - '0') / (div *= 10);
+					b = readByte();
+				}
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class157/Code03_RangePersistent2.java b/src/class157/Code03_RangePersistent2.java
new file mode 100644
index 000000000..7a2fccb23
--- /dev/null
+++ b/src/class157/Code03_RangePersistent2.java
@@ -0,0 +1,143 @@
+package class157;
+
+// 范围修改的可持久化线段树，经典的方式，C++版
+// 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
+// 一共有m条查询，每条查询为如下四种类型中的一种
+// C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
+// Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
+// H x y z : z版本的数组，打印[x..y]范围的累加和
+// B x     : 当前时间戳t设置成x
+// 1 <= n、m <= 10^5
+// -10^9 <= arr[i] <= +10^9
+// 测试链接 : https://www.luogu.com.cn/problem/SP11470
+// 测试链接 : https://www.spoj.com/problems/TTM/
+// 这是实现范围修改的可持久化线段树，经典的方式
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+// 
+//const int MAXN = 100001;
+//const int MAXT = MAXN * 100;
+//int n, m, t;
+//int arr[MAXN];
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//long long sum[MAXT];
+//long long add[MAXT];
+//int cnt;
+// 
+//int clone(int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    sum[rt] = sum[i];
+//    add[rt] = add[i];
+//    return rt;
+//}
+// 
+//void up(int i) {
+//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//}
+// 
+//void lazy(int i, long long v, int n) {
+//    sum[i] += v * n;
+//    add[i] += v;
+//}
+// 
+//void down(int i, int ln, int rn) {
+//    if (add[i] != 0) {
+//        ls[i] = clone(ls[i]);
+//        rs[i] = clone(rs[i]);
+//        lazy(ls[i], add[i], ln);
+//        lazy(rs[i], add[i], rn);
+//        add[i] = 0;
+//    }
+//}
+// 
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    add[rt] = 0;
+//    if (l == r) {
+//        sum[rt] = arr[l];
+//    } else {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//        up(rt);
+//    }
+//    return rt;
+//}
+// 
+//int addRange(int jobl, int jobr, long long jobv, int l, int r, int i) {
+//    int rt = clone(i);
+//    if (jobl <= l && r <= jobr) {
+//        lazy(rt, jobv, r - l + 1);
+//    } else {
+//        int mid = (l + r) / 2;
+//        down(rt, mid - l + 1, r - mid);
+//        if (jobl <= mid) {
+//            ls[rt] = addRange(jobl, jobr, jobv, l, mid, ls[rt]);
+//        }
+//        if (jobr > mid) {
+//            rs[rt] = addRange(jobl, jobr, jobv, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+// 
+//long long query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i];
+//    }
+//    int mid = (l + r) / 2;
+//    down(i, mid - l + 1, r - mid);
+//    long long ans = 0;
+//    if (jobl <= mid) {
+//        ans += query(jobl, jobr, l, mid, ls[i]);
+//    }
+//    if (jobr > mid) {
+//        ans += query(jobl, jobr, mid + 1, r, rs[i]);
+//    }
+//    return ans;
+//}
+// 
+//void prepare() {
+//    t = 0;
+//    cnt = 0;
+//    root[0] = build(1, n);
+//}
+// 
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    root[0] = build(1, n);
+//    string op;
+//    int x, y, z;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op;
+//        if (op == "C") {
+//            cin >> x >> y >> z;
+//            root[t + 1] = addRange(x, y, z, 1, n, root[t]);
+//            t++;
+//        } else if (op == "Q") {
+//            cin >> x >> y;
+//            cout << query(x, y, 1, n, root[t]) << "\n";
+//        } else if (op == "H") {
+//            cin >> x >> y >> z;
+//            cout << query(x, y, 1, n, root[z]) << "\n";
+//        } else if (op == "B") {
+//            cin >> x;
+//            t = x;
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code04_TagPermanentization1.java b/src/class157/Code04_TagPermanentization1.java
new file mode 100644
index 000000000..fa10b81f6
--- /dev/null
+++ b/src/class157/Code04_TagPermanentization1.java
@@ -0,0 +1,110 @@
+package class157;
+
+// 标记永久化，范围增加、查询累加和，java版
+// 给定一个长度为n的数组arr，下标1~n，一共有m条操作，操作类型如下
+// 1 x y k : 将区间[x, y]每个数加上k
+// 2 x y   : 打印区间[x, y]的累加和
+// 这就是普通线段树，请用标记永久化的方式实现
+// 测试链接 : https://www.luogu.com.cn/problem/P3372
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_TagPermanentization1 {
+
+	public static int MAXN = 100001;
+
+	public static long[] arr = new long[MAXN];
+
+	public static long[] sum = new long[MAXN << 2];
+
+	public static long[] addTag = new long[MAXN << 2];
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			sum[i] = arr[l];
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			sum[i] = sum[i << 1] + sum[i << 1 | 1];
+		}
+		addTag[i] = 0;
+	}
+
+	public static void add(int jobl, int jobr, long jobv, int l, int r, int i) {
+		int a = Math.max(jobl, l), b = Math.min(jobr, r);
+		sum[i] += jobv * (b - a + 1);
+		if (jobl <= l && r <= jobr) {
+			addTag[i] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static long query(int jobl, int jobr, long addHistory, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i] + addHistory * (r - l + 1);
+		}
+		int mid = (l + r) >> 1;
+		long ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, addHistory + addTag[i], l, mid, i << 1);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, addHistory + addTag[i], mid + 1, r, i << 1 | 1);
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		in.nextToken();
+		int m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (long) in.nval;
+		}
+		build(1, n, 1);
+		int op, jobl, jobr;
+		long jobv;
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			if (op == 1) {
+				in.nextToken();
+				jobl = (int) in.nval;
+				in.nextToken();
+				jobr = (int) in.nval;
+				in.nextToken();
+				jobv = (long) in.nval;
+				add(jobl, jobr, jobv, 1, n, 1);
+			} else {
+				in.nextToken();
+				jobl = (int) in.nval;
+				in.nextToken();
+				jobr = (int) in.nval;
+				out.println(query(jobl, jobr, 0, 1, n, 1));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
\ No newline at end of file
diff --git a/src/class157/Code04_TagPermanentization2.java b/src/class157/Code04_TagPermanentization2.java
new file mode 100644
index 000000000..cf282b323
--- /dev/null
+++ b/src/class157/Code04_TagPermanentization2.java
@@ -0,0 +1,88 @@
+package class157;
+
+// 标记永久化，范围增加、查询累加和，C++版
+// 给定一个长度为n的数组arr，下标1~n，一共有m条操作，操作类型如下
+// 1 x y k : 将区间[x, y]每个数加上k
+// 2 x y   : 打印区间[x, y]的累加和
+// 这就是普通线段树，请用标记永久化的方式实现
+// 测试链接 : https://www.luogu.com.cn/problem/P3372
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//#include <cstdio>
+//#include <cstring>
+//#include <algorithm>
+//using namespace std;
+//
+//const int MAXN = 100001;
+//long long arr[MAXN];
+//long long sum[MAXN << 2];
+//long long addTag[MAXN << 2];
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//        sum[i] = arr[l];
+//    } else {
+//        int mid = (l + r) / 2;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//        sum[i] = sum[i << 1] + sum[i << 1 | 1];
+//    }
+//    addTag[i] = 0;
+//}
+//
+//void add(int jobl, int jobr, long long jobv, int l, int r, int i) {
+//    int a = max(jobl, l), b = min(jobr, r);
+//    sum[i] += jobv * (b - a + 1);
+//    if (jobl <= l && r <= jobr) {
+//        addTag[i] += jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//long long query(int jobl, int jobr, long long addHistory, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i] + addHistory * (r - l + 1);
+//    }
+//    int mid = (l + r) >> 1;
+//    long long ans = 0;
+//    if (jobl <= mid) {
+//        ans += query(jobl, jobr, addHistory + addTag[i], l, mid, i << 1);
+//    }
+//    if (jobr > mid) {
+//        ans += query(jobl, jobr, addHistory + addTag[i], mid + 1, r, i << 1 | 1);
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n, m;
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    build(1, n, 1);
+//    int op, jobl, jobr;
+//    long long jobv;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op;
+//        if (op == 1) {
+//            cin >> jobl >> jobr >> jobv;
+//            add(jobl, jobr, jobv, 1, n, 1);
+//        } else {
+//            cin >> jobl >> jobr;
+//            cout << query(jobl, jobr, 0, 1, n, 1) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class157/Code02_TagPermanentization1.java b/src/class157/Code05_RangePersistent1.java
similarity index 86%
rename from src/class157/Code02_TagPermanentization1.java
rename to src/class157/Code05_RangePersistent1.java
index 9fe9a6a5b..89ea9d889 100644
--- a/src/class157/Code02_TagPermanentization1.java
+++ b/src/class157/Code05_RangePersistent1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 范围修改的可持久化线段树 + 标记永久化，java版
+// 范围修改的可持久化线段树 + 标记永久化减少空间占用，java版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有m条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
@@ -9,13 +9,11 @@
 // B x     : 当前时间戳t设置成x
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
-// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
+// 测试链接 : https://www.luogu.com.cn/problem/SP11470
 // 测试链接 : https://www.spoj.com/problems/TTM/
-// 这道题的目的是让你去实现标记永久化的版本，减少可持久化线段树的空间消耗
-// 所以题目一定要卡住，没有进行标记永久化的实现，而且是根据C++使用空间的状况来卡的！
-// 但是这样一来，空间资源非常少，java的实现哪怕做了标记永久化的优化，也很难通过了！
-// java版本的实现一定是最优解，逻辑一定是正确的
-// 所以想通过就用C++实现吧，本节课Code02_TagPermanentization2文件就是C++的实现
+// 这是实现范围修改的可持久化线段树，使用标记永久化减少空间占用的方式
+// 但是java的实现依然通过不了，因为这道题各种平台测试的时候，就没考虑java的用户
+// 所以想通过就用C++实现吧，本节课Code05_RangePersistent2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -23,11 +21,11 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code02_TagPermanentization1 {
+public class Code05_RangePersistent1 {
 
 	public static int MAXN = 100001;
 
-	public static int MAXM = MAXN * 25;
+	public static int MAXT = MAXN * 25;
 
 	public static int n, m, t = 0;
 
@@ -38,15 +36,15 @@ public class Code02_TagPermanentization1 {
 	// root[i] : 时间戳i为版本号，线段树的头节点编号
 	public static int[] root = new int[MAXN];
 
-	public static int[] left = new int[MAXM];
+	public static int[] left = new int[MAXT];
 
-	public static int[] right = new int[MAXM];
+	public static int[] right = new int[MAXT];
 
 	// 区间累加和
-	public static long[] sum = new long[MAXM];
+	public static long[] sum = new long[MAXT];
 
 	// 区间关于加的懒更新信息，变成了标记永久化信息
-	public static long[] addTag = new long[MAXM];
+	public static long[] addTag = new long[MAXT];
 
 	public static int cnt = 0;
 
diff --git a/src/class157/Code02_TagPermanentization2.java b/src/class157/Code05_RangePersistent2.java
similarity index 92%
rename from src/class157/Code02_TagPermanentization2.java
rename to src/class157/Code05_RangePersistent2.java
index f68bc56e2..9c4177f45 100644
--- a/src/class157/Code02_TagPermanentization2.java
+++ b/src/class157/Code05_RangePersistent2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 范围修改的可持久化线段树 + 标记永久化，C++版
+// 范围修改的可持久化线段树 + 标记永久化减少空间占用，C++版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有m条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
@@ -9,7 +9,7 @@
 // B x     : 当前时间戳t设置成x
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
-// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
+// 测试链接 : https://www.luogu.com.cn/problem/SP11470
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -19,14 +19,14 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
-//const int MAXM = MAXN * 25;
+//const int MAXT = MAXN * 25;
 //int n, m, t = 0;
 //long long arr[MAXN];
 //int root[MAXN];
-//int ls[MAXM];
-//int rs[MAXM];
-//long long sum[MAXM];
-//long long addTag[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//long long sum[MAXT];
+//long long addTag[MAXT];
 //int cnt = 0;
 //
 //int build(int l, int r) {
diff --git a/src/class157/Code03_Sequence1.java b/src/class158/Code01_FirstTimeSequence1.java
similarity index 95%
rename from src/class157/Code03_Sequence1.java
rename to src/class158/Code01_FirstTimeSequence1.java
index 2614807ac..b01112f23 100644
--- a/src/class157/Code03_Sequence1.java
+++ b/src/class158/Code01_FirstTimeSequence1.java
@@ -1,6 +1,6 @@
-package class157;
+package class158;
 
-// 下标序列，java版
+// 第一次出现位置的序列，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询，每条查询格式如下
 // l r : arr[l..r]范围上，每个数第一次出现的位置，把这些位置组成一个序列
 //       假设该范围有s种不同的数，那么序列长度为s
@@ -18,11 +18,11 @@
 import java.io.IOException;
 import java.util.Arrays;
 
-public class Code03_Sequence1 {
+public class Code01_FirstTimeSequence1 {
 
 	public static int MAXN = 200002;
 
-	public static int MAXM = MAXN * 37;
+	public static int MAXT = MAXN * 37;
 
 	public static int cases, n, m;
 
@@ -34,12 +34,12 @@ public class Code03_Sequence1 {
 	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
-	public static int[] left = new int[MAXM];
+	public static int[] left = new int[MAXT];
 
-	public static int[] right = new int[MAXM];
+	public static int[] right = new int[MAXT];
 
 	// 区间不同数字的个数
-	public static int[] diff = new int[MAXM];
+	public static int[] diff = new int[MAXT];
 
 	public static int cnt;
 
diff --git a/src/class157/Code03_Sequence2.java b/src/class158/Code01_FirstTimeSequence2.java
similarity index 96%
rename from src/class157/Code03_Sequence2.java
rename to src/class158/Code01_FirstTimeSequence2.java
index fa869c49f..72a3ac746 100644
--- a/src/class157/Code03_Sequence2.java
+++ b/src/class158/Code01_FirstTimeSequence2.java
@@ -1,6 +1,6 @@
-package class157;
+package class158;
 
-// 下标序列，C++版
+// 第一次出现位置的序列，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询，每条查询格式如下
 // l r : arr[l..r]范围上，每个数第一次出现的位置，把这些位置组成一个序列
 //       假设该范围有s种不同的数，那么序列长度为s
@@ -21,14 +21,14 @@
 //using namespace std;
 //
 //const int MAXN = 200002;
-//const int MAXM = MAXN * 37;
+//const int MAXT = MAXN * 37;
 //int cases, n, m;
 //int arr[MAXN];
 //int pos[MAXN];
 //int root[MAXN];
-//int ls[MAXM];
-//int rs[MAXM];
-//int diff[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//int diff[MAXT];
 //int cnt;
 //
 //int build(int l, int r) {
diff --git a/src/class157/Code04_MissingSmallest1.java b/src/class158/Code02_MissingSmallest1.java
similarity index 93%
rename from src/class157/Code04_MissingSmallest1.java
rename to src/class158/Code02_MissingSmallest1.java
index 34fb0fe7c..132b9f5d5 100644
--- a/src/class157/Code04_MissingSmallest1.java
+++ b/src/class158/Code02_MissingSmallest1.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 区间内没有出现的最小自然数，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
@@ -15,11 +15,11 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_MissingSmallest1 {
+public class Code02_MissingSmallest1 {
 
 	public static int MAXN = 200001;
 
-	public static int MAXM = MAXN * 22;
+	public static int MAXT = MAXN * 22;
 
 	public static int n, m;
 
@@ -27,13 +27,13 @@ public class Code04_MissingSmallest1 {
 
 	public static int[] root = new int[MAXN];
 
-	public static int[] left = new int[MAXM];
+	public static int[] left = new int[MAXT];
 
-	public static int[] right = new int[MAXM];
+	public static int[] right = new int[MAXT];
 
 	// last[i] : l~r的信息存在last[i]
 	// 表示该范围每个数字最后出现的位置中，最左在哪
-	public static int[] lateLeft = new int[MAXM];
+	public static int[] lateLeft = new int[MAXT];
 
 	public static int cnt;
 
diff --git a/src/class157/Code04_MissingSmallest2.java b/src/class158/Code02_MissingSmallest2.java
similarity index 95%
rename from src/class157/Code04_MissingSmallest2.java
rename to src/class158/Code02_MissingSmallest2.java
index e0c5a8baf..9b2d473ce 100644
--- a/src/class157/Code04_MissingSmallest2.java
+++ b/src/class158/Code02_MissingSmallest2.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 区间内没有出现的最小自然数，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
@@ -14,13 +14,13 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//const int MAXM = MAXN * 22;
+//const int MAXT = MAXN * 22;
 //int n, m;
 //int arr[MAXN];
 //int root[MAXN];
-//int ls[MAXM];
-//int rs[MAXM];
-//int lateLeft[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//int lateLeft[MAXT];
 //int cnt;
 //
 //int build(int l, int r) {
diff --git a/src/class157/Code05_LargestUpMedian1.java b/src/class158/Code03_LargestUpMedian1.java
similarity index 93%
rename from src/class157/Code05_LargestUpMedian1.java
rename to src/class158/Code03_LargestUpMedian1.java
index dba38ef6a..7a20cb3bc 100644
--- a/src/class157/Code05_LargestUpMedian1.java
+++ b/src/class158/Code03_LargestUpMedian1.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 浮动区间的最大上中位数，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
@@ -21,11 +21,11 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code05_LargestUpMedian1 {
+public class Code03_LargestUpMedian1 {
 
 	public static int MAXN = 20001;
 
-	public static int MAXM = MAXN * 20;
+	public static int MAXT = MAXN * 20;
 
 	public static int INF = 10000001;
 
@@ -37,18 +37,18 @@ public class Code05_LargestUpMedian1 {
 	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
-	public static int[] left = new int[MAXM];
+	public static int[] left = new int[MAXT];
 
-	public static int[] right = new int[MAXM];
+	public static int[] right = new int[MAXT];
 
 	// 区间内最大前缀和，前缀不能为空
-	public static int[] pre = new int[MAXM];
+	public static int[] pre = new int[MAXT];
 
 	// 区间内最大后缀和，后缀不能为空
-	public static int[] suf = new int[MAXM];
+	public static int[] suf = new int[MAXT];
 
 	// 区间内累加和，区间为空认为累加和是0
-	public static int[] sum = new int[MAXM];
+	public static int[] sum = new int[MAXT];
 
 	public static int cnt;
 
diff --git a/src/class157/Code05_LargestUpMedian2.java b/src/class158/Code03_LargestUpMedian2.java
similarity index 96%
rename from src/class157/Code05_LargestUpMedian2.java
rename to src/class158/Code03_LargestUpMedian2.java
index 145424a0a..5e3b3cc2b 100644
--- a/src/class157/Code05_LargestUpMedian2.java
+++ b/src/class158/Code03_LargestUpMedian2.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 浮动区间的最大上中位数，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
@@ -19,16 +19,16 @@
 //using namespace std;
 //
 //const int MAXN = 20001;
-//const int MAXM = MAXN * 20;
+//const int MAXT = MAXN * 20;
 //const int INF = 10000001;
 //int n, m;
 //vector<pair<int, int>> arr;
 //int root[MAXN];
-//int ls[MAXM];
-//int rs[MAXM];
-//int pre[MAXM];
-//int suf[MAXM];
-//int sum[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//int pre[MAXT];
+//int suf[MAXT];
+//int sum[MAXT];
 //int cnt;
 //int ques[4], info[3];
 //
diff --git a/src/class157/Code06_CountOnTree1.java b/src/class158/Code04_CountOnTree1.java
similarity index 96%
rename from src/class157/Code06_CountOnTree1.java
rename to src/class158/Code04_CountOnTree1.java
index a8d6a2f86..555dedd95 100644
--- a/src/class157/Code06_CountOnTree1.java
+++ b/src/class158/Code04_CountOnTree1.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 路径上的第k小，java版
 // 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
@@ -21,13 +21,13 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code06_CountOnTree1 {
+public class Code04_CountOnTree1 {
 
 	public static int MAXN = 100001;
 
 	public static int MAXH = 20;
 
-	public static int MAXM = MAXN * MAXH;
+	public static int MAXT = MAXN * MAXH;
 
 	public static int n, m, s;
 
@@ -49,11 +49,11 @@ public class Code06_CountOnTree1 {
 	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
-	public static int[] left = new int[MAXM];
+	public static int[] left = new int[MAXT];
 
-	public static int[] right = new int[MAXM];
+	public static int[] right = new int[MAXT];
 
-	public static int[] size = new int[MAXM];
+	public static int[] size = new int[MAXT];
 
 	public static int cntt = 0;
 
diff --git a/src/class157/Code06_CountOnTree2.java b/src/class158/Code04_CountOnTree2.java
similarity index 97%
rename from src/class157/Code06_CountOnTree2.java
rename to src/class158/Code04_CountOnTree2.java
index f1347a8bd..af273f7ed 100644
--- a/src/class157/Code06_CountOnTree2.java
+++ b/src/class158/Code04_CountOnTree2.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 路径上的第k小，C++版
 // 有n个节点，编号1~n，每个节点有权值，有n-1条边，所有节点组成一棵树
@@ -20,7 +20,7 @@
 //
 //const int MAXN = 100001;
 //const int MAXH = 20;
-//const int MAXM = MAXN * MAXH;
+//const int MAXT = MAXN * MAXH;
 //int n, m, s;
 //int arr[MAXN];
 //int sorted[MAXN];
@@ -31,9 +31,9 @@
 //int cntg = 0;
 //
 //int root[MAXN];
-//int ls[MAXM];
-//int rs[MAXM];
-//int size[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//int size[MAXT];
 //int cntt = 0;
 //
 //int deep[MAXN];
diff --git a/src/class157/Code07_MoreImpressive1.java b/src/class158/Code05_MoreImpressive1.java
similarity index 96%
rename from src/class157/Code07_MoreImpressive1.java
rename to src/class158/Code05_MoreImpressive1.java
index 542ce253a..d9b6b60e9 100644
--- a/src/class157/Code07_MoreImpressive1.java
+++ b/src/class158/Code05_MoreImpressive1.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 更为厉害，java版
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
@@ -17,11 +17,11 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code07_MoreImpressive1 {
+public class Code05_MoreImpressive1 {
 
 	public static int MAXN = 300001;
 
-	public static int MAXM = MAXN * 22;
+	public static int MAXT = MAXN * 22;
 
 	public static int n, m;
 
@@ -37,11 +37,11 @@ public class Code07_MoreImpressive1 {
 	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
-	public static int[] left = new int[MAXM];
+	public static int[] left = new int[MAXT];
 
-	public static int[] right = new int[MAXM];
+	public static int[] right = new int[MAXT];
 
-	public static long[] sum = new long[MAXM];
+	public static long[] sum = new long[MAXT];
 
 	public static int cntt = 0;
 
diff --git a/src/class157/Code07_MoreImpressive2.java b/src/class158/Code05_MoreImpressive2.java
similarity index 97%
rename from src/class157/Code07_MoreImpressive2.java
rename to src/class158/Code05_MoreImpressive2.java
index 39ca2f78d..13a36eda8 100644
--- a/src/class157/Code07_MoreImpressive2.java
+++ b/src/class158/Code05_MoreImpressive2.java
@@ -1,4 +1,4 @@
-package class157;
+package class158;
 
 // 更为厉害，C++版
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
@@ -16,7 +16,7 @@
 //using namespace std;
 //
 //const int MAXN = 300001;
-//const int MAXM = MAXN * 22;
+//const int MAXT = MAXN * 22;
 //int n, m;
 //
 //int head[MAXN];
@@ -25,9 +25,9 @@
 //int cntg = 0;
 //
 //int root[MAXN];
-//int ls[MAXM];
-//int rs[MAXM];
-//long long sum[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//long long sum[MAXT];
 //int cntt = 0;
 //
 //int dep[MAXN];

From f0983c66fde39e8fd77d83b1113561c6d8581633 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Jan 2025 18:57:38 +0800
Subject: [PATCH 0363/1712] modify code

---
 ..._RangePersistent1.java => Code03_RangePersistentClassic1.java} | 0
 ..._RangePersistent2.java => Code03_RangePersistentClassic2.java} | 0
 ...angePersistent1.java => Code05_RangePersistentLessSpace1.java} | 0
 ...angePersistent2.java => Code05_RangePersistentLessSpace2.java} | 0
 4 files changed, 0 insertions(+), 0 deletions(-)
 rename src/class157/{Code03_RangePersistent1.java => Code03_RangePersistentClassic1.java} (100%)
 rename src/class157/{Code03_RangePersistent2.java => Code03_RangePersistentClassic2.java} (100%)
 rename src/class157/{Code05_RangePersistent1.java => Code05_RangePersistentLessSpace1.java} (100%)
 rename src/class157/{Code05_RangePersistent2.java => Code05_RangePersistentLessSpace2.java} (100%)

diff --git a/src/class157/Code03_RangePersistent1.java b/src/class157/Code03_RangePersistentClassic1.java
similarity index 100%
rename from src/class157/Code03_RangePersistent1.java
rename to src/class157/Code03_RangePersistentClassic1.java
diff --git a/src/class157/Code03_RangePersistent2.java b/src/class157/Code03_RangePersistentClassic2.java
similarity index 100%
rename from src/class157/Code03_RangePersistent2.java
rename to src/class157/Code03_RangePersistentClassic2.java
diff --git a/src/class157/Code05_RangePersistent1.java b/src/class157/Code05_RangePersistentLessSpace1.java
similarity index 100%
rename from src/class157/Code05_RangePersistent1.java
rename to src/class157/Code05_RangePersistentLessSpace1.java
diff --git a/src/class157/Code05_RangePersistent2.java b/src/class157/Code05_RangePersistentLessSpace2.java
similarity index 100%
rename from src/class157/Code05_RangePersistent2.java
rename to src/class157/Code05_RangePersistentLessSpace2.java

From bb4dc602bd5e034543c1143b40ea52c71295a860 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Jan 2025 18:57:45 +0800
Subject: [PATCH 0364/1712] modify code

---
 src/class157/Code03_RangePersistentClassic1.java   | 4 ++--
 src/class157/Code05_RangePersistentLessSpace1.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class157/Code03_RangePersistentClassic1.java b/src/class157/Code03_RangePersistentClassic1.java
index d8b740115..0df595f8b 100644
--- a/src/class157/Code03_RangePersistentClassic1.java
+++ b/src/class157/Code03_RangePersistentClassic1.java
@@ -13,7 +13,7 @@
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这是实现范围修改的可持久化线段树，经典的方式
 // 但是java的实现过不了，因为这道题各种平台测试的时候，就没考虑java的用户
-// 所以想通过就用C++实现吧，本节课Code03_RangePersistent2文件就是C++的实现
+// 所以想通过就用C++实现吧，本节课Code03_RangePersistentClassic2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -21,7 +21,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code03_RangePersistent1 {
+public class Code03_RangePersistentClassic1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class157/Code05_RangePersistentLessSpace1.java b/src/class157/Code05_RangePersistentLessSpace1.java
index 89ea9d889..a02bb2d94 100644
--- a/src/class157/Code05_RangePersistentLessSpace1.java
+++ b/src/class157/Code05_RangePersistentLessSpace1.java
@@ -13,7 +13,7 @@
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这是实现范围修改的可持久化线段树，使用标记永久化减少空间占用的方式
 // 但是java的实现依然通过不了，因为这道题各种平台测试的时候，就没考虑java的用户
-// 所以想通过就用C++实现吧，本节课Code05_RangePersistent2文件就是C++的实现
+// 所以想通过就用C++实现吧，本节课Code05_RangePersistentLessSpace2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -21,7 +21,7 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 
-public class Code05_RangePersistent1 {
+public class Code05_RangePersistentLessSpace1 {
 
 	public static int MAXN = 100001;
 

From 60db40e35d4c6414c250bfbecd1c8ec751544201 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Jan 2025 19:08:24 +0800
Subject: [PATCH 0365/1712] modify code

---
 src/class157/Code03_RangePersistentClassic1.java   | 2 +-
 src/class157/Code05_RangePersistentLessSpace1.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code03_RangePersistentClassic1.java b/src/class157/Code03_RangePersistentClassic1.java
index 0df595f8b..22bb0abdc 100644
--- a/src/class157/Code03_RangePersistentClassic1.java
+++ b/src/class157/Code03_RangePersistentClassic1.java
@@ -12,7 +12,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/SP11470
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这是实现范围修改的可持久化线段树，经典的方式
-// 但是java的实现过不了，因为这道题各种平台测试的时候，就没考虑java的用户
+// 但是java的实现过不了，因为这道题完全根据C++的性能设置的通过标准，根本没考虑java的用户
 // 所以想通过就用C++实现吧，本节课Code03_RangePersistentClassic2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
diff --git a/src/class157/Code05_RangePersistentLessSpace1.java b/src/class157/Code05_RangePersistentLessSpace1.java
index a02bb2d94..e2dd6aa2d 100644
--- a/src/class157/Code05_RangePersistentLessSpace1.java
+++ b/src/class157/Code05_RangePersistentLessSpace1.java
@@ -12,7 +12,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/SP11470
 // 测试链接 : https://www.spoj.com/problems/TTM/
 // 这是实现范围修改的可持久化线段树，使用标记永久化减少空间占用的方式
-// 但是java的实现依然通过不了，因为这道题各种平台测试的时候，就没考虑java的用户
+// 但是java的实现过不了，因为这道题完全根据C++的性能设置的通过标准，根本没考虑java的用户
 // 所以想通过就用C++实现吧，本节课Code05_RangePersistentLessSpace2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 

From d78b3c8cd6da3aa417a99945b657351347a67776 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 13:56:25 +0800
Subject: [PATCH 0366/1712] modify code

---
 src/class157/Code04_TagPermanentization1.java      | 2 +-
 src/class157/Code04_TagPermanentization2.java      | 2 +-
 src/class157/Code05_RangePersistentLessSpace1.java | 5 ++---
 src/class157/Code05_RangePersistentLessSpace2.java | 5 ++---
 4 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/class157/Code04_TagPermanentization1.java b/src/class157/Code04_TagPermanentization1.java
index fa10b81f6..4209de55f 100644
--- a/src/class157/Code04_TagPermanentization1.java
+++ b/src/class157/Code04_TagPermanentization1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 标记永久化，范围增加、查询累加和，java版
+// 标记永久化，范围增加 + 查询累加和，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条操作，操作类型如下
 // 1 x y k : 将区间[x, y]每个数加上k
 // 2 x y   : 打印区间[x, y]的累加和
diff --git a/src/class157/Code04_TagPermanentization2.java b/src/class157/Code04_TagPermanentization2.java
index cf282b323..0e83b7a0d 100644
--- a/src/class157/Code04_TagPermanentization2.java
+++ b/src/class157/Code04_TagPermanentization2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 标记永久化，范围增加、查询累加和，C++版
+// 标记永久化，范围增加 + 查询累加和，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条操作，操作类型如下
 // 1 x y k : 将区间[x, y]每个数加上k
 // 2 x y   : 打印区间[x, y]的累加和
diff --git a/src/class157/Code05_RangePersistentLessSpace1.java b/src/class157/Code05_RangePersistentLessSpace1.java
index e2dd6aa2d..d0a9c7cbe 100644
--- a/src/class157/Code05_RangePersistentLessSpace1.java
+++ b/src/class157/Code05_RangePersistentLessSpace1.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 范围修改的可持久化线段树 + 标记永久化减少空间占用，java版
+// 范围修改的可持久化线段树，标记永久化减少空间占用，java版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有m条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
@@ -9,8 +9,7 @@
 // B x     : 当前时间戳t设置成x
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
-// 测试链接 : https://www.luogu.com.cn/problem/SP11470
-// 测试链接 : https://www.spoj.com/problems/TTM/
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 这是实现范围修改的可持久化线段树，使用标记永久化减少空间占用的方式
 // 但是java的实现过不了，因为这道题完全根据C++的性能设置的通过标准，根本没考虑java的用户
 // 所以想通过就用C++实现吧，本节课Code05_RangePersistentLessSpace2文件就是C++的实现
diff --git a/src/class157/Code05_RangePersistentLessSpace2.java b/src/class157/Code05_RangePersistentLessSpace2.java
index 9c4177f45..603b54777 100644
--- a/src/class157/Code05_RangePersistentLessSpace2.java
+++ b/src/class157/Code05_RangePersistentLessSpace2.java
@@ -1,6 +1,6 @@
 package class157;
 
-// 范围修改的可持久化线段树 + 标记永久化减少空间占用，C++版
+// 范围修改的可持久化线段树，标记永久化减少空间占用，C++版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
 // 一共有m条查询，每条查询为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
@@ -9,8 +9,7 @@
 // B x     : 当前时间戳t设置成x
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
-// 测试链接 : https://www.luogu.com.cn/problem/SP11470
-// 测试链接 : https://www.spoj.com/problems/TTM/
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 

From 406a6a8ae6b62d2b84a2365f2f3f074702aa8a7f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 14:05:25 +0800
Subject: [PATCH 0367/1712] modify code

---
 src/class157/Code03_RangePersistentClassic1.java   | 8 ++++----
 src/class157/Code03_RangePersistentClassic2.java   | 2 +-
 src/class157/Code05_RangePersistentLessSpace1.java | 6 +++---
 3 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class157/Code03_RangePersistentClassic1.java b/src/class157/Code03_RangePersistentClassic1.java
index 22bb0abdc..c874c9242 100644
--- a/src/class157/Code03_RangePersistentClassic1.java
+++ b/src/class157/Code03_RangePersistentClassic1.java
@@ -11,9 +11,9 @@
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP11470
 // 测试链接 : https://www.spoj.com/problems/TTM/
-// 这是实现范围修改的可持久化线段树，经典的方式
-// 但是java的实现过不了，因为这道题完全根据C++的性能设置的通过标准，根本没考虑java的用户
-// 所以想通过就用C++实现吧，本节课Code03_RangePersistentClassic2文件就是C++的实现
+// java实现的逻辑一定是正确的，但是通过不了
+// 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code03_RangePersistentClassic2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;
@@ -25,7 +25,7 @@ public class Code03_RangePersistentClassic1 {
 
 	public static int MAXN = 100001;
 
-	public static int MAXT = MAXN * 100;
+	public static int MAXT = MAXN * 70;
 
 	public static int n, m, t = 0;
 
diff --git a/src/class157/Code03_RangePersistentClassic2.java b/src/class157/Code03_RangePersistentClassic2.java
index 7a2fccb23..39739d65e 100644
--- a/src/class157/Code03_RangePersistentClassic2.java
+++ b/src/class157/Code03_RangePersistentClassic2.java
@@ -20,7 +20,7 @@
 //using namespace std;
 // 
 //const int MAXN = 100001;
-//const int MAXT = MAXN * 100;
+//const int MAXT = MAXN * 70;
 //int n, m, t;
 //int arr[MAXN];
 //int root[MAXN];
diff --git a/src/class157/Code05_RangePersistentLessSpace1.java b/src/class157/Code05_RangePersistentLessSpace1.java
index d0a9c7cbe..f26016315 100644
--- a/src/class157/Code05_RangePersistentLessSpace1.java
+++ b/src/class157/Code05_RangePersistentLessSpace1.java
@@ -10,9 +10,9 @@
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
-// 这是实现范围修改的可持久化线段树，使用标记永久化减少空间占用的方式
-// 但是java的实现过不了，因为这道题完全根据C++的性能设置的通过标准，根本没考虑java的用户
-// 所以想通过就用C++实现吧，本节课Code05_RangePersistentLessSpace2文件就是C++的实现
+// java实现的逻辑一定是正确的，但是通过不了
+// 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code05_RangePersistentLessSpace2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedWriter;

From ccffbeb11176d36aa84b1dd6f686e0a17052514b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 14:06:33 +0800
Subject: [PATCH 0368/1712] modify code

---
 src/class157/Code03_RangePersistentClassic2.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class157/Code03_RangePersistentClassic2.java b/src/class157/Code03_RangePersistentClassic2.java
index 39739d65e..2818f33bd 100644
--- a/src/class157/Code03_RangePersistentClassic2.java
+++ b/src/class157/Code03_RangePersistentClassic2.java
@@ -11,7 +11,6 @@
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP11470
 // 测试链接 : https://www.spoj.com/problems/TTM/
-// 这是实现范围修改的可持久化线段树，经典的方式
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 

From 902608bb5e032979c0425a38396c358659a37c2f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 14:13:58 +0800
Subject: [PATCH 0369/1712] modify code

---
 src/class157/Code05_RangePersistentLessSpace1.java | 10 ----------
 1 file changed, 10 deletions(-)

diff --git a/src/class157/Code05_RangePersistentLessSpace1.java b/src/class157/Code05_RangePersistentLessSpace1.java
index f26016315..d1bdd1c15 100644
--- a/src/class157/Code05_RangePersistentLessSpace1.java
+++ b/src/class157/Code05_RangePersistentLessSpace1.java
@@ -28,21 +28,16 @@ public class Code05_RangePersistentLessSpace1 {
 
 	public static int n, m, t = 0;
 
-	// 原始数组
 	public static int[] arr = new int[MAXN];
 
-	// 可持久化线段树需要
-	// root[i] : 时间戳i为版本号，线段树的头节点编号
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXT];
 
 	public static int[] right = new int[MAXT];
 
-	// 区间累加和
 	public static long[] sum = new long[MAXT];
 
-	// 区间关于加的懒更新信息，变成了标记永久化信息
 	public static long[] addTag = new long[MAXT];
 
 	public static int cnt = 0;
@@ -67,8 +62,6 @@ public static void prepare() {
 		root[0] = build(1, n);
 	}
 
-	// l~r范围，信息在i位置，任务是jobl~jobr范围，所有数字增加jobv
-	// 返回新的头节点编号
 	public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
 		int rt = ++cnt, a = Math.max(jobl, l), b = Math.min(jobr, r);
 		left[rt] = left[i];
@@ -89,9 +82,6 @@ public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	// l~r范围，信息在i位置，任务是jobl~jobr范围，查询累加和
-	// addHistory是从上方的大范围一路带下来的标记历史
-	// 返回累加和
 	public static long query(int jobl, int jobr, long addHistory, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			return sum[i] + addHistory * (r - l + 1);

From d366f3694e568ab57dc54b79327c0f7ea2410e43 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 14:20:45 +0800
Subject: [PATCH 0370/1712] modify code

---
 src/class157/Code01_PointPersistent1.java | 11 +++++++++++
 src/class157/Code02_PointPersistent1.java |  6 ++----
 2 files changed, 13 insertions(+), 4 deletions(-)

diff --git a/src/class157/Code01_PointPersistent1.java b/src/class157/Code01_PointPersistent1.java
index e9f2081de..8fe3b3f30 100644
--- a/src/class157/Code01_PointPersistent1.java
+++ b/src/class157/Code01_PointPersistent1.java
@@ -22,18 +22,24 @@ public class Code01_PointPersistent1 {
 
 	public static int n, m;
 
+	// 原始数组
 	public static int[] arr = new int[MAXN];
 
+	// 可持久化线段树需要
+	// root[i] : i号版本线段树的头节点编号
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXT];
 
 	public static int[] right = new int[MAXT];
 
+	// value[i] : 节点i的值信息，只有叶节点有这个信息
 	public static int[] value = new int[MAXT];
 
+	// 可持久化线段树的节点空间计数
 	public static int cnt = 0;
 
+	// 建树，返回头节点编号
 	public static int build(int l, int r) {
 		int rt = ++cnt;
 		if (l == r) {
@@ -46,6 +52,9 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
+	// 线段树范围l~r，信息在i号节点里
+	// 在l~r范围上，jobi位置的值，设置成jobv
+	// 生成的新节点编号返回
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
@@ -64,6 +73,8 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
+	// 线段树范围l~r，信息在i号节点里
+	// 返回l~r范围上jobi位置的值
 	public static int query(int jobi, int l, int r, int i) {
 		if (l == r) {
 			return value[i];
diff --git a/src/class157/Code02_PointPersistent1.java b/src/class157/Code02_PointPersistent1.java
index 614328e9f..0f2a87a3b 100644
--- a/src/class157/Code02_PointPersistent1.java
+++ b/src/class157/Code02_PointPersistent1.java
@@ -31,16 +31,14 @@ public class Code02_PointPersistent1 {
 	public static int[] sorted = new int[MAXN];
 
 	// 可持久化线段树需要
-	// root[i] : 插入arr[i]之后形成的线段树，记录头节点编号
+	// root[i] : 插入arr[i]之后形成新版本的线段树，记录头节点编号
 	public static int[] root = new int[MAXN];
 
-	// 左孩子
 	public static int[] left = new int[MAXT];
 
-	// 右孩子
 	public static int[] right = new int[MAXT];
 
-	// 收集了多少个数字
+	// 范围内收集了多少个数字
 	public static int[] size = new int[MAXT];
 
 	public static int cnt;

From 4fe826f9d1af916cc4bf54db83ce36fd26355ccc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 16:12:41 +0800
Subject: [PATCH 0371/1712] modify code

---
 src/class157/Code02_PointPersistent1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class157/Code02_PointPersistent1.java b/src/class157/Code02_PointPersistent1.java
index 0f2a87a3b..56baaa0f6 100644
--- a/src/class157/Code02_PointPersistent1.java
+++ b/src/class157/Code02_PointPersistent1.java
@@ -38,7 +38,7 @@ public class Code02_PointPersistent1 {
 
 	public static int[] right = new int[MAXT];
 
-	// 范围内收集了多少个数字
+	// 数字范围内收集了多少个数字
 	public static int[] size = new int[MAXT];
 
 	public static int cnt;
@@ -58,7 +58,7 @@ public static int kth(int num) {
 		return ans;
 	}
 
-	// l~r范围建立线段树，返回头节点编号
+	// 数字范围l~r，建立线段树，返回头节点编号
 	public static int build(int l, int r) {
 		int rt = ++cnt;
 		size[rt] = 0;
@@ -70,7 +70,7 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
-	// l~r范围，信息在i位置，增加一个jobi位置上的数字
+	// 数字范围l~r，信息在i号节点，增加一个数字jobi
 	// 返回新的头节点编号
 	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
@@ -88,8 +88,8 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
-	// l~r范围，老版本信息在u位置，新版本信息在v位置
-	// 返回第jobk小的数是多少
+	// 数字范围l~r，老版本信息在u号节点，新版本信息在v号节点
+	// 返回第jobk小的数
 	public static int query(int jobk, int l, int r, int u, int v) {
 		if (l == r) {
 			return l;

From ba0e0eebd5d1ffe6a1561d9f8e9b4a1d5f455758 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 16:18:19 +0800
Subject: [PATCH 0372/1712] modify code

---
 src/class157/Code02_PointPersistent1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class157/Code02_PointPersistent1.java b/src/class157/Code02_PointPersistent1.java
index 56baaa0f6..1bc9150c5 100644
--- a/src/class157/Code02_PointPersistent1.java
+++ b/src/class157/Code02_PointPersistent1.java
@@ -38,7 +38,7 @@ public class Code02_PointPersistent1 {
 
 	public static int[] right = new int[MAXT];
 
-	// 数字范围内收集了多少个数字
+	// 排名范围内收集了多少个数字
 	public static int[] size = new int[MAXT];
 
 	public static int cnt;
@@ -58,7 +58,7 @@ public static int kth(int num) {
 		return ans;
 	}
 
-	// 数字范围l~r，建立线段树，返回头节点编号
+	// 排名范围l~r，建立线段树，返回头节点编号
 	public static int build(int l, int r) {
 		int rt = ++cnt;
 		size[rt] = 0;
@@ -70,7 +70,7 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
-	// 数字范围l~r，信息在i号节点，增加一个数字jobi
+	// 排名范围l~r，信息在i号节点，增加一个排名为jobi的数字
 	// 返回新的头节点编号
 	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
@@ -88,8 +88,8 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
-	// 数字范围l~r，老版本信息在u号节点，新版本信息在v号节点
-	// 返回第jobk小的数
+	// 排名范围l~r，老版本信息在u号节点，新版本信息在v号节点
+	// 返回第jobk小的排名
 	public static int query(int jobk, int l, int r, int u, int v) {
 		if (l == r) {
 			return l;

From 1ef8fb49ab1e742b12dc9faf01371ed069bd2529 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 17:41:59 +0800
Subject: [PATCH 0373/1712] modify code

---
 src/class157/Code02_PointPersistent1.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/class157/Code02_PointPersistent1.java b/src/class157/Code02_PointPersistent1.java
index 1bc9150c5..27839e758 100644
--- a/src/class157/Code02_PointPersistent1.java
+++ b/src/class157/Code02_PointPersistent1.java
@@ -32,6 +32,8 @@ public class Code02_PointPersistent1 {
 
 	// 可持久化线段树需要
 	// root[i] : 插入arr[i]之后形成新版本的线段树，记录头节点编号
+	// 0号版本的线段树代表一个数字也没有时，每种名次的数字出现的次数
+	// i号版本的线段树代表arr[1..i]范围内，每种名次的数字出现的次数
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXT];
@@ -89,7 +91,7 @@ public static int insert(int jobi, int l, int r, int i) {
 	}
 
 	// 排名范围l~r，老版本信息在u号节点，新版本信息在v号节点
-	// 返回第jobk小的排名
+	// 返回，第jobk小的数字，排名多少
 	public static int query(int jobk, int l, int r, int u, int v) {
 		if (l == r) {
 			return l;

From 49977a20efb36c975facad874521930cb767b56b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 20:20:49 +0800
Subject: [PATCH 0374/1712] modify code

---
 src/class157/Code03_RangePersistentClassic1.java | 4 +++-
 src/class157/Code03_RangePersistentClassic2.java | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code03_RangePersistentClassic1.java b/src/class157/Code03_RangePersistentClassic1.java
index c874c9242..35df62a8d 100644
--- a/src/class157/Code03_RangePersistentClassic1.java
+++ b/src/class157/Code03_RangePersistentClassic1.java
@@ -2,7 +2,7 @@
 
 // 范围修改的可持久化线段树，经典的方式，java版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
-// 一共有m条查询，每条查询为如下四种类型中的一种
+// 一共有m条操作，每条操作为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
 // Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
 // H x y z : z版本的数组，打印[x..y]范围的累加和
@@ -37,8 +37,10 @@ public class Code03_RangePersistentClassic1 {
 
 	public static int[] right = new int[MAXT];
 
+	// 累加和信息
 	public static long[] sum = new long[MAXT];
 
+	// 懒更新信息，范围增加的懒更新
 	public static long[] add = new long[MAXT];
 
 	public static int cnt = 0;
diff --git a/src/class157/Code03_RangePersistentClassic2.java b/src/class157/Code03_RangePersistentClassic2.java
index 2818f33bd..7298feb31 100644
--- a/src/class157/Code03_RangePersistentClassic2.java
+++ b/src/class157/Code03_RangePersistentClassic2.java
@@ -2,7 +2,7 @@
 
 // 范围修改的可持久化线段树，经典的方式，C++版
 // 给定一个长度为n的数组arr，下标1~n，时间戳t=0，arr认为是0版本的数组
-// 一共有m条查询，每条查询为如下四种类型中的一种
+// 一共有m条操作，每条操作为如下四种类型中的一种
 // C x y z : 当前时间戳t版本的数组，[x..y]范围每个数字增加z，得到t+1版本数组，并且t++
 // Q x y   : 当前时间戳t版本的数组，打印[x..y]范围累加和
 // H x y z : z版本的数组，打印[x..y]范围的累加和

From ea7238160d44c6261e32090212a7f0ff8cf8fe0e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 21:33:05 +0800
Subject: [PATCH 0375/1712] modify code

---
 src/class157/Code04_TagPermanentization1.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/class157/Code04_TagPermanentization1.java b/src/class157/Code04_TagPermanentization1.java
index 4209de55f..d9436d39c 100644
--- a/src/class157/Code04_TagPermanentization1.java
+++ b/src/class157/Code04_TagPermanentization1.java
@@ -21,8 +21,12 @@ public class Code04_TagPermanentization1 {
 
 	public static long[] arr = new long[MAXN];
 
+	// 不是真实累加和，而是之前的任务中
+	// 不考虑被上方范围截住的任务，只考虑来到当前范围 或者 往下走的任务
+	// 累加和变成了什么
 	public static long[] sum = new long[MAXN << 2];
 
+	// 不再是懒更新信息，变成标记信息
 	public static long[] addTag = new long[MAXN << 2];
 
 	public static void build(int l, int r, int i) {

From 6b245980ccbe8be8eed0a4f8e7824f1c7feb8161 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 21:40:35 +0800
Subject: [PATCH 0376/1712] modify code

---
 src/class157/Code03_RangePersistentClassic1.java   |  6 ------
 src/class157/Code03_RangePersistentClassic2.java   | 10 ++--------
 src/class157/Code05_RangePersistentLessSpace1.java | 10 ++++------
 3 files changed, 6 insertions(+), 20 deletions(-)

diff --git a/src/class157/Code03_RangePersistentClassic1.java b/src/class157/Code03_RangePersistentClassic1.java
index 35df62a8d..24bd5105d 100644
--- a/src/class157/Code03_RangePersistentClassic1.java
+++ b/src/class157/Code03_RangePersistentClassic1.java
@@ -121,12 +121,6 @@ public static long query(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
-	public static void prepare() {
-		t = 0;
-		cnt = 0;
-		root[0] = build(1, n);
-	}
-
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader();
 		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
diff --git a/src/class157/Code03_RangePersistentClassic2.java b/src/class157/Code03_RangePersistentClassic2.java
index 7298feb31..3ae4ab33d 100644
--- a/src/class157/Code03_RangePersistentClassic2.java
+++ b/src/class157/Code03_RangePersistentClassic2.java
@@ -20,14 +20,14 @@
 // 
 //const int MAXN = 100001;
 //const int MAXT = MAXN * 70;
-//int n, m, t;
+//int n, m, t = 0;
 //int arr[MAXN];
 //int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
 //long long sum[MAXT];
 //long long add[MAXT];
-//int cnt;
+//int cnt = 0;
 // 
 //int clone(int i) {
 //    int rt = ++cnt;
@@ -105,12 +105,6 @@
 //    return ans;
 //}
 // 
-//void prepare() {
-//    t = 0;
-//    cnt = 0;
-//    root[0] = build(1, n);
-//}
-// 
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
diff --git a/src/class157/Code05_RangePersistentLessSpace1.java b/src/class157/Code05_RangePersistentLessSpace1.java
index d1bdd1c15..3d01cd922 100644
--- a/src/class157/Code05_RangePersistentLessSpace1.java
+++ b/src/class157/Code05_RangePersistentLessSpace1.java
@@ -36,8 +36,12 @@ public class Code05_RangePersistentLessSpace1 {
 
 	public static int[] right = new int[MAXT];
 
+	// 不是真实累加和，而是之前的任务中
+	// 不考虑被上方范围截住的任务，只考虑来到当前范围 或者 往下走的任务
+	// 累加和变成了什么
 	public static long[] sum = new long[MAXT];
 
+	// 不再是懒更新信息，变成标记信息
 	public static long[] addTag = new long[MAXT];
 
 	public static int cnt = 0;
@@ -56,12 +60,6 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
-	public static void prepare() {
-		t = 0;
-		cnt = 0;
-		root[0] = build(1, n);
-	}
-
 	public static int add(int jobl, int jobr, long jobv, int l, int r, int i) {
 		int rt = ++cnt, a = Math.max(jobl, l), b = Math.min(jobr, r);
 		left[rt] = left[i];

From 1a3ac8688a3673dc2fe6a237dc77e9e1da29bd56 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Jan 2025 21:50:59 +0800
Subject: [PATCH 0377/1712] modify code

---
 ...60\346\260\270\344\271\205\345\214\226.pptx" | Bin 0 -> 51544 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243157\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\347\272\277\346\256\265\346\240\221\345\222\214\346\240\207\350\256\260\346\260\270\344\271\205\345\214\226.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243157\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\347\272\277\346\256\265\346\240\221\345\222\214\346\240\207\350\256\260\346\260\270\344\271\205\345\214\226.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243157\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\347\272\277\346\256\265\346\240\221\345\222\214\346\240\207\350\256\260\346\260\270\344\271\205\345\214\226.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..ac8fd7d3f9a940a989ce6b376e1defb459923890
GIT binary patch
literal 51544
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

literal 0
HcmV?d00001


From 0674f2bf32fc9972c15b729aae4f869d814b8074 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 13:16:29 +0800
Subject: [PATCH 0378/1712] modify code

---
 src/class158/Code01_FirstTimeSequence1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class158/Code01_FirstTimeSequence1.java b/src/class158/Code01_FirstTimeSequence1.java
index b01112f23..ad7823944 100644
--- a/src/class158/Code01_FirstTimeSequence1.java
+++ b/src/class158/Code01_FirstTimeSequence1.java
@@ -38,7 +38,7 @@ public class Code01_FirstTimeSequence1 {
 
 	public static int[] right = new int[MAXT];
 
-	// 区间不同数字的个数
+	// 数组范围上出现不同数字的个数
 	public static int[] diff = new int[MAXT];
 
 	public static int cnt;

From 10df8fb6665d7e3af98c167e90143e7509c90556 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 13:22:29 +0800
Subject: [PATCH 0379/1712] modify code

---
 src/class158/Code02_MissingSmallest1.java | 1 +
 src/class158/Code02_MissingSmallest2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class158/Code02_MissingSmallest1.java b/src/class158/Code02_MissingSmallest1.java
index 132b9f5d5..0f1c40bed 100644
--- a/src/class158/Code02_MissingSmallest1.java
+++ b/src/class158/Code02_MissingSmallest1.java
@@ -3,6 +3,7 @@
 // 区间内没有出现的最小自然数，java版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
+// 请用在线算法解决该问题，因为可以设计强制在线的要求，让离线算法失效
 // 1 <= n、m <= 2 * 10^5
 // 0 <= arr[i] <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4137
diff --git a/src/class158/Code02_MissingSmallest2.java b/src/class158/Code02_MissingSmallest2.java
index 9b2d473ce..61d3341a3 100644
--- a/src/class158/Code02_MissingSmallest2.java
+++ b/src/class158/Code02_MissingSmallest2.java
@@ -3,6 +3,7 @@
 // 区间内没有出现的最小自然数，C++版
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
+// 请用在线算法解决该问题，因为可以设计强制在线的要求，让离线算法失效
 // 1 <= n、m <= 2 * 10^5
 // 0 <= arr[i] <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4137

From 689626cccddfa7835b959153d6245369618c2204 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 14:01:23 +0800
Subject: [PATCH 0380/1712] modify code

---
 src/class158/Code03_LargestUpMedian1.java | 1 +
 src/class158/Code03_LargestUpMedian2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class158/Code03_LargestUpMedian1.java b/src/class158/Code03_LargestUpMedian1.java
index 7a20cb3bc..4d16f773d 100644
--- a/src/class158/Code03_LargestUpMedian1.java
+++ b/src/class158/Code03_LargestUpMedian1.java
@@ -1,6 +1,7 @@
 package class158;
 
 // 浮动区间的最大上中位数，java版
+// 为了方便理解，我改写了题意，但是改写的题意和原始题意等效
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
 //                   哪个区间有最大的上中位数，打印最大的上中位数
diff --git a/src/class158/Code03_LargestUpMedian2.java b/src/class158/Code03_LargestUpMedian2.java
index 5e3b3cc2b..c46b29003 100644
--- a/src/class158/Code03_LargestUpMedian2.java
+++ b/src/class158/Code03_LargestUpMedian2.java
@@ -1,6 +1,7 @@
 package class158;
 
 // 浮动区间的最大上中位数，C++版
+// 为了方便理解，我改写了题意，但是改写的题意和原始题意等效
 // 给定一个长度为n的数组arr，下标1~n，一共有m条查询
 // 每条查询 a b c d : 左端点在[a,b]之间、右端点在[c,d]之间，保证a<b<c<d
 //                   哪个区间有最大的上中位数，打印最大的上中位数

From 71179e377c5ee6144cb84ba9cb6cac96bd70ffde Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 14:02:48 +0800
Subject: [PATCH 0381/1712] modify code

---
 src/class158/Code05_MoreImpressive1.java | 1 +
 src/class158/Code05_MoreImpressive2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class158/Code05_MoreImpressive1.java b/src/class158/Code05_MoreImpressive1.java
index d9b6b60e9..e2c2e255e 100644
--- a/src/class158/Code05_MoreImpressive1.java
+++ b/src/class158/Code05_MoreImpressive1.java
@@ -1,6 +1,7 @@
 package class158;
 
 // 更为厉害，java版
+// 为了方便理解，我改写了题意，但是改写的题意和原始题意等效
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
 // 如果x是y的祖先节点，认为"x比y更厉害"
 // 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"
diff --git a/src/class158/Code05_MoreImpressive2.java b/src/class158/Code05_MoreImpressive2.java
index 13a36eda8..7dfe04b9a 100644
--- a/src/class158/Code05_MoreImpressive2.java
+++ b/src/class158/Code05_MoreImpressive2.java
@@ -1,6 +1,7 @@
 package class158;
 
 // 更为厉害，C++版
+// 为了方便理解，我改写了题意，但是改写的题意和原始题意等效
 // 有n个节点，编号1~n，给定n-1条边，连成一棵树，1号点是树头
 // 如果x是y的祖先节点，认为"x比y更厉害"
 // 如果x到y的路径上，边的数量 <= 某个常数，认为"x和y是邻居"

From b940672d22add017d6bb5887514f40061d1abbbb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 14:47:52 +0800
Subject: [PATCH 0382/1712] modify code

---
 src/class158/Code01_FirstTimeSequence1.java | 18 +++++++++---------
 src/class158/Code01_FirstTimeSequence2.java | 16 ++++++++--------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/class158/Code01_FirstTimeSequence1.java b/src/class158/Code01_FirstTimeSequence1.java
index ad7823944..59bd650c6 100644
--- a/src/class158/Code01_FirstTimeSequence1.java
+++ b/src/class158/Code01_FirstTimeSequence1.java
@@ -38,8 +38,8 @@ public class Code01_FirstTimeSequence1 {
 
 	public static int[] right = new int[MAXT];
 
-	// 数组范围上出现不同数字的个数
-	public static int[] diff = new int[MAXT];
+	// 数组范围上只记录每种数第一次出现的位置，这样的位置有多少个
+	public static int[] firstSize = new int[MAXT];
 
 	public static int cnt;
 
@@ -58,7 +58,7 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
 		right[rt] = right[i];
-		diff[rt] = diff[i] + jobv;
+		firstSize[rt] = firstSize[i] + jobv;
 		if (l == r) {
 			return rt;
 		}
@@ -71,17 +71,17 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static int queryDiff(int jobl, int jobr, int l, int r, int i) {
+	public static int querySize(int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			return diff[i];
+			return firstSize[i];
 		}
 		int mid = (l + r) / 2;
 		int ans = 0;
 		if (jobl <= mid) {
-			ans += queryDiff(jobl, jobr, l, mid, left[i]);
+			ans += querySize(jobl, jobr, l, mid, left[i]);
 		}
 		if (jobr > mid) {
-			ans += queryDiff(jobl, jobr, mid + 1, r, right[i]);
+			ans += querySize(jobl, jobr, mid + 1, r, right[i]);
 		}
 		return ans;
 	}
@@ -91,7 +91,7 @@ public static int queryKth(int jobk, int l, int r, int i) {
 			return l;
 		}
 		int mid = (l + r) / 2;
-		int leftDiff = diff[left[i]];
+		int leftDiff = firstSize[left[i]];
 		if (leftDiff >= jobk) {
 			return queryKth(jobk, l, mid, left[i]);
 		} else {
@@ -132,7 +132,7 @@ public static void main(String[] args) throws IOException {
 				b = (io.nextInt() + lastAns) % n + 1;
 				l = Math.min(a, b);
 				r = Math.max(a, b);
-				k = (queryDiff(l, r, 1, n, root[l]) + 1) / 2;
+				k = (querySize(l, r, 1, n, root[l]) + 1) / 2;
 				lastAns = queryKth(k, 1, n, root[l]);
 				io.write(" ");
 				io.writeInt(lastAns);
diff --git a/src/class158/Code01_FirstTimeSequence2.java b/src/class158/Code01_FirstTimeSequence2.java
index 72a3ac746..6a74d32cb 100644
--- a/src/class158/Code01_FirstTimeSequence2.java
+++ b/src/class158/Code01_FirstTimeSequence2.java
@@ -28,7 +28,7 @@
 //int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
-//int diff[MAXT];
+//int firstSize[MAXT];
 //int cnt;
 //
 //int build(int l, int r) {
@@ -46,7 +46,7 @@
 //    int rt = ++cnt;
 //    ls[rt] = ls[i];
 //    rs[rt] = rs[i];
-//    diff[rt] = diff[i] + jobv;
+//    firstSize[rt] = firstSize[i] + jobv;
 //    if (l == r) {
 //        return rt;
 //    }
@@ -59,17 +59,17 @@
 //    return rt;
 //}
 //
-//int queryDiff(int jobl, int jobr, int l, int r, int i) {
+//int querySize(int jobl, int jobr, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
-//        return diff[i];
+//        return firstSize[i];
 //    }
 //    int mid = (l + r) / 2;
 //    int ans = 0;
 //    if (jobl <= mid) {
-//        ans += queryDiff(jobl, jobr, l, mid, ls[i]);
+//        ans += querySize(jobl, jobr, l, mid, ls[i]);
 //    }
 //    if (jobr > mid) {
-//        ans += queryDiff(jobl, jobr, mid + 1, r, rs[i]);
+//        ans += querySize(jobl, jobr, mid + 1, r, rs[i]);
 //    }
 //    return ans;
 //}
@@ -79,7 +79,7 @@
 //        return l;
 //    }
 //    int mid = (l + r) / 2;
-//    int leftDiff = diff[ls[i]];
+//    int leftDiff = firstSize[ls[i]];
 //    if (leftDiff >= jobk) {
 //        return queryKth(jobk, l, mid, ls[i]);
 //    } else {
@@ -119,7 +119,7 @@
 //            b = (r + lastAns) % n + 1;
 //            l = min(a, b);
 //            r = max(a, b);
-//            k = (queryDiff(l, r, 1, n, root[l]) + 1) / 2;
+//            k = (querySize(l, r, 1, n, root[l]) + 1) / 2;
 //            lastAns = queryKth(k, 1, n, root[l]);
 //            cout << " " << lastAns;
 //        }

From 93ac05aaacf7638ee4ed4f907fe36bcd496a0d9d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 16:12:46 +0800
Subject: [PATCH 0383/1712] modify code

---
 src/class158/Code01_FirstTimeSequence1.java | 19 ++++++++++++++-----
 src/class158/Code01_FirstTimeSequence2.java | 10 +++++-----
 2 files changed, 19 insertions(+), 10 deletions(-)

diff --git a/src/class158/Code01_FirstTimeSequence1.java b/src/class158/Code01_FirstTimeSequence1.java
index 59bd650c6..c83b0fb46 100644
--- a/src/class158/Code01_FirstTimeSequence1.java
+++ b/src/class158/Code01_FirstTimeSequence1.java
@@ -45,15 +45,19 @@ public class Code01_FirstTimeSequence1 {
 
 	public static int build(int l, int r) {
 		int rt = ++cnt;
-		if (l == r) {
-			return rt;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
 		}
-		int mid = (l + r) / 2;
-		left[rt] = build(l, mid);
-		right[rt] = build(mid + 1, r);
+		firstSize[rt] = 0;
 		return rt;
 	}
 
+	// 数组范围l~r，信息在i号节点
+	// 如果jobv = -1，意味着jobi位置减少一个计数
+	// 如果jobv = 1，意味着jobi位置增加一个计数
+	// 返回新的头节点编号
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
@@ -71,6 +75,8 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
+	// 数组范围l~r，信息在i号节点
+	// jobl ~ jobr范围上，一共有几种不同的数字，也就是这个范围上，有多少个位置有1
 	public static int querySize(int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			return firstSize[i];
@@ -86,6 +92,8 @@ public static int querySize(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
+	// 数组范围l~r，信息在i号节点
+	// 查询这个范围上，第jobk个1在哪
 	public static int queryKth(int jobk, int l, int r, int i) {
 		if (l == r) {
 			return l;
@@ -99,6 +107,7 @@ public static int queryKth(int jobk, int l, int r, int i) {
 		}
 	}
 
+	// 从右往左建立各个版本的线段树
 	public static void prepare() {
 		cnt = 0;
 		Arrays.fill(pos, 0);
diff --git a/src/class158/Code01_FirstTimeSequence2.java b/src/class158/Code01_FirstTimeSequence2.java
index 6a74d32cb..28b3c3d7e 100644
--- a/src/class158/Code01_FirstTimeSequence2.java
+++ b/src/class158/Code01_FirstTimeSequence2.java
@@ -33,12 +33,12 @@
 //
 //int build(int l, int r) {
 //    int rt = ++cnt;
-//    if (l == r) {
-//        return rt;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
 //    }
-//    int mid = (l + r) / 2;
-//    ls[rt] = build(l, mid);
-//    rs[rt] = build(mid + 1, r);
+//    firstSize[rt] = 0;
 //    return rt;
 //}
 //

From edee772da1dfe243344f2e1a2de5b1108dff4335 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 16:32:59 +0800
Subject: [PATCH 0384/1712] modify code

---
 src/class158/Code01_FirstTimeSequence1.java | 10 +++++-----
 src/class158/Code01_FirstTimeSequence2.java |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class158/Code01_FirstTimeSequence1.java b/src/class158/Code01_FirstTimeSequence1.java
index c83b0fb46..417d9e98e 100644
--- a/src/class158/Code01_FirstTimeSequence1.java
+++ b/src/class158/Code01_FirstTimeSequence1.java
@@ -28,7 +28,7 @@ public class Code01_FirstTimeSequence1 {
 
 	public static int[] arr = new int[MAXN];
 
-	// pos[v] : v这个数字最左出现的位置
+	// pos[v] : v这个数字上次出现的位置
 	public static int[] pos = new int[MAXN];
 
 	// 可持久化线段树需要
@@ -56,7 +56,7 @@ public static int build(int l, int r) {
 
 	// 数组范围l~r，信息在i号节点
 	// 如果jobv = -1，意味着jobi位置减少一个计数
-	// 如果jobv = 1，意味着jobi位置增加一个计数
+	// 如果jobv = +1，意味着jobi位置增加一个计数
 	// 返回新的头节点编号
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
@@ -99,11 +99,11 @@ public static int queryKth(int jobk, int l, int r, int i) {
 			return l;
 		}
 		int mid = (l + r) / 2;
-		int leftDiff = firstSize[left[i]];
-		if (leftDiff >= jobk) {
+		int lsize = firstSize[left[i]];
+		if (lsize >= jobk) {
 			return queryKth(jobk, l, mid, left[i]);
 		} else {
-			return queryKth(jobk - leftDiff, mid + 1, r, right[i]);
+			return queryKth(jobk - lsize, mid + 1, r, right[i]);
 		}
 	}
 
diff --git a/src/class158/Code01_FirstTimeSequence2.java b/src/class158/Code01_FirstTimeSequence2.java
index 28b3c3d7e..1cf70176e 100644
--- a/src/class158/Code01_FirstTimeSequence2.java
+++ b/src/class158/Code01_FirstTimeSequence2.java
@@ -79,11 +79,11 @@
 //        return l;
 //    }
 //    int mid = (l + r) / 2;
-//    int leftDiff = firstSize[ls[i]];
-//    if (leftDiff >= jobk) {
+//    int lsize = firstSize[ls[i]];
+//    if (lsize >= jobk) {
 //        return queryKth(jobk, l, mid, ls[i]);
 //    } else {
-//        return queryKth(jobk - leftDiff, mid + 1, r, rs[i]);
+//        return queryKth(jobk - lsize, mid + 1, r, rs[i]);
 //    }
 //}
 //

From 4e536110d660f140576b7a45349e91a68586b6ee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 19:16:40 +0800
Subject: [PATCH 0385/1712] modify code

---
 src/class158/Code02_MissingSmallest1.java |  6 +++---
 src/class158/Code05_MoreImpressive1.java  | 21 ++++++++++++++-------
 src/class158/Code05_MoreImpressive2.java  | 18 ++++++++++++------
 3 files changed, 29 insertions(+), 16 deletions(-)

diff --git a/src/class158/Code02_MissingSmallest1.java b/src/class158/Code02_MissingSmallest1.java
index 0f1c40bed..4aaca1ee6 100644
--- a/src/class158/Code02_MissingSmallest1.java
+++ b/src/class158/Code02_MissingSmallest1.java
@@ -32,8 +32,7 @@ public class Code02_MissingSmallest1 {
 
 	public static int[] right = new int[MAXT];
 
-	// last[i] : l~r的信息存在last[i]
-	// 表示该范围每个数字最后出现的位置中，最左在哪
+	// 数字范围中，每个数字出现的最晚位置中，最左的位置在哪
 	public static int[] lateLeft = new int[MAXT];
 
 	public static int cnt;
@@ -49,7 +48,8 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
-	// l~r范围，信息在i位置，jobi这个数字，最新出现在jobv位置
+	// 数字范围l~r，信息在i号节点
+	// jobi这个数字，当前最晚出现在jobv位置
 	// 返回新的头节点编号
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
diff --git a/src/class158/Code05_MoreImpressive1.java b/src/class158/Code05_MoreImpressive1.java
index e2c2e255e..6e4c1612a 100644
--- a/src/class158/Code05_MoreImpressive1.java
+++ b/src/class158/Code05_MoreImpressive1.java
@@ -24,7 +24,7 @@ public class Code05_MoreImpressive1 {
 
 	public static int MAXT = MAXN * 22;
 
-	public static int n, m;
+	public static int n, m, depth;
 
 	// 链式前向星需要
 	public static int[] head = new int[MAXN];
@@ -109,6 +109,7 @@ public static long query(int jobl, int jobr, int l, int r, int u, int v) {
 	// 递归版，C++可以通过，java无法通过，递归会爆栈
 	public static void dfs1(int u, int f) {
 		deep[u] = deep[f] + 1;
+		depth = Math.max(depth, deep[u]);
 		size[u] = 1;
 		dfn[u] = ++cntd;
 		for (int ei = head[u]; ei > 0; ei = next[ei]) {
@@ -125,7 +126,7 @@ public static void dfs1(int u, int f) {
 
 	// 递归版，C++可以通过，java无法通过，递归会爆栈
 	public static void dfs2(int u, int f) {
-		root[dfn[u]] = add(deep[u], size[u] - 1, 1, n, root[dfn[u] - 1]);
+		root[dfn[u]] = add(deep[u], size[u] - 1, 1, depth, root[dfn[u] - 1]);
 		for (int ei = head[u]; ei > 0; ei = next[ei]) {
 			if (to[ei] != f) {
 				dfs2(to[ei], u);
@@ -161,6 +162,7 @@ public static void dfs3() {
 			pop();
 			if (e == -1) {
 				deep[u] = deep[f] + 1;
+				depth = Math.max(depth, deep[u]);
 				size[u] = 1;
 				dfn[u] = ++cntd;
 				e = head[u];
@@ -189,7 +191,7 @@ public static void dfs4() {
 		while (stackSize > 0) {
 			pop();
 			if (e == -1) {
-				root[dfn[u]] = add(deep[u], size[u] - 1, 1, n, root[dfn[u] - 1]);
+				root[dfn[u]] = add(deep[u], size[u] - 1, 1, depth, root[dfn[u] - 1]);
 				e = head[u];
 			} else {
 				e = next[e];
@@ -203,8 +205,15 @@ public static void dfs4() {
 		}
 	}
 
+	public static void prepare() {
+		depth = 0;
+		dfs3(); // 使用迭代版防止爆栈
+		root[0] = build(1, depth);
+		dfs4(); // 使用迭代版防止爆栈
+	}
+
 	public static long compute(int a, int k) {
-		long ans = query(deep[a] + 1, deep[a] + k, 1, n, root[dfn[a] - 1], root[dfn[a] + size[a] - 1]);
+		long ans = query(deep[a] + 1, deep[a] + k, 1, depth, root[dfn[a] - 1], root[dfn[a] + size[a] - 1]);
 		ans += (long) (size[a] - 1) * Math.min(k, deep[a] - 1);
 		return ans;
 	}
@@ -225,9 +234,7 @@ public static void main(String[] args) throws IOException {
 			addEdge(u, v);
 			addEdge(v, u);
 		}
-		root[0] = build(1, n);
-		dfs3(); // 使用迭代版防止爆栈
-		dfs4(); // 使用迭代版防止爆栈
+		prepare();
 		for (int i = 1, a, k; i <= m; i++) {
 			in.nextToken();
 			a = (int) in.nval;
diff --git a/src/class158/Code05_MoreImpressive2.java b/src/class158/Code05_MoreImpressive2.java
index 7dfe04b9a..9cf12cbd7 100644
--- a/src/class158/Code05_MoreImpressive2.java
+++ b/src/class158/Code05_MoreImpressive2.java
@@ -18,7 +18,7 @@
 //
 //const int MAXN = 300001;
 //const int MAXT = MAXN * 22;
-//int n, m;
+//int n, m, depth;
 //
 //int head[MAXN];
 //int to[MAXN << 1];
@@ -86,6 +86,7 @@
 //
 //void dfs1(int u, int f) {
 //    dep[u] = dep[f] + 1;
+//    depth = max(depth, dep[u]);
 //    siz[u] = 1;
 //    dfn[u] = ++cntd;
 //    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
@@ -101,7 +102,7 @@
 //}
 //
 //void dfs2(int u, int f) {
-//    root[dfn[u]] = add(dep[u], (long long)siz[u] - 1, 1, n, root[dfn[u] - 1]);
+//    root[dfn[u]] = add(dep[u], (long long)siz[u] - 1, 1, depth, root[dfn[u] - 1]);
 //    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 //        if (to[ei] != f) {
 //            dfs2(to[ei], u);
@@ -109,8 +110,15 @@
 //    }
 //}
 //
+//void prepare() {
+//    depth = 0;
+//    dfs1(1, 0);
+//    root[0] = build(1, depth);
+//    dfs2(1, 0);
+//}
+//
 //long long compute(int a, int k) {
-//    long long ans = query(dep[a] + 1, dep[a] + k, 1, n, root[dfn[a] - 1], root[dfn[a] + siz[a] - 1]);
+//    long long ans = query(dep[a] + 1, dep[a] + k, 1, depth, root[dfn[a] - 1], root[dfn[a] + siz[a] - 1]);
 //    ans += (long long)(siz[a] - 1) * min(k, dep[a] - 1);
 //    return ans;
 //}
@@ -124,9 +132,7 @@
 //        addEdge(u, v);
 //        addEdge(v, u);
 //    }
-//    root[0] = build(1, n);
-//    dfs1(1, 0);
-//    dfs2(1, 0);
+//    prepare();
 //    for(int i = 1, a, k; i <= m; i++) {
 //        cin >> a >> k;
 //        cout << compute(a, k) << "\n";

From 4d227fa9dc1048ba31753bf6f9bf101a3d77858e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 19:59:38 +0800
Subject: [PATCH 0386/1712] modify code

---
 src/class158/Code02_MissingSmallest1.java | 4 ++--
 src/class158/Code02_MissingSmallest2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class158/Code02_MissingSmallest1.java b/src/class158/Code02_MissingSmallest1.java
index 4aaca1ee6..bca570236 100644
--- a/src/class158/Code02_MissingSmallest1.java
+++ b/src/class158/Code02_MissingSmallest1.java
@@ -49,7 +49,7 @@ public static int build(int l, int r) {
 	}
 
 	// 数字范围l~r，信息在i号节点
-	// jobi这个数字，当前最晚出现在jobv位置
+	// 数字范围上，jobi这个数字，最晚出现的位置更新为jobv
 	// 返回新的头节点编号
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
@@ -92,7 +92,7 @@ public static void prepare() {
 		cnt = 0;
 		root[0] = build(0, n);
 		for (int i = 1; i <= n; i++) {
-			if (arr[i] >= n) {
+			if (arr[i] > n) {
 				root[i] = root[i - 1];
 			} else {
 				root[i] = update(arr[i], i, 0, n, root[i - 1]);
diff --git a/src/class158/Code02_MissingSmallest2.java b/src/class158/Code02_MissingSmallest2.java
index 61d3341a3..313049915 100644
--- a/src/class158/Code02_MissingSmallest2.java
+++ b/src/class158/Code02_MissingSmallest2.java
@@ -70,7 +70,7 @@
 //    cnt = 0;
 //    root[0] = build(0, n);
 //    for (int i = 1; i <= n; i++) {
-//        if (arr[i] >= n) {
+//        if (arr[i] > n) {
 //            root[i] = root[i - 1];
 //        } else {
 //            root[i] = update(arr[i], i, 0, n, root[i - 1]);

From 054d60960dc33bbb2a14e700456b1d6f3e61fe56 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 20:08:34 +0800
Subject: [PATCH 0387/1712] modify code

---
 src/class158/Code02_MissingSmallest1.java | 2 +-
 src/class158/Code02_MissingSmallest2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class158/Code02_MissingSmallest1.java b/src/class158/Code02_MissingSmallest1.java
index bca570236..ace64190c 100644
--- a/src/class158/Code02_MissingSmallest1.java
+++ b/src/class158/Code02_MissingSmallest1.java
@@ -92,7 +92,7 @@ public static void prepare() {
 		cnt = 0;
 		root[0] = build(0, n);
 		for (int i = 1; i <= n; i++) {
-			if (arr[i] > n) {
+			if (arr[i] > n || arr[i] < 0) {
 				root[i] = root[i - 1];
 			} else {
 				root[i] = update(arr[i], i, 0, n, root[i - 1]);
diff --git a/src/class158/Code02_MissingSmallest2.java b/src/class158/Code02_MissingSmallest2.java
index 313049915..bbdbf6275 100644
--- a/src/class158/Code02_MissingSmallest2.java
+++ b/src/class158/Code02_MissingSmallest2.java
@@ -70,7 +70,7 @@
 //    cnt = 0;
 //    root[0] = build(0, n);
 //    for (int i = 1; i <= n; i++) {
-//        if (arr[i] > n) {
+//        if (arr[i] > n || arr[i] < 0) {
 //            root[i] = root[i - 1];
 //        } else {
 //            root[i] = update(arr[i], i, 0, n, root[i - 1]);

From e787e0ff5aba99729d61f8e63843aaeb751ba20c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Jan 2025 22:53:33 +0800
Subject: [PATCH 0388/1712] modify code

---
 src/class158/Code03_LargestUpMedian1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class158/Code03_LargestUpMedian1.java b/src/class158/Code03_LargestUpMedian1.java
index 4d16f773d..da2983ce9 100644
--- a/src/class158/Code03_LargestUpMedian1.java
+++ b/src/class158/Code03_LargestUpMedian1.java
@@ -48,7 +48,7 @@ public class Code03_LargestUpMedian1 {
 	// 区间内最大后缀和，后缀不能为空
 	public static int[] suf = new int[MAXT];
 
-	// 区间内累加和，区间为空认为累加和是0
+	// 区间内累加和
 	public static int[] sum = new int[MAXT];
 
 	public static int cnt;
@@ -76,6 +76,7 @@ public static void up(int i) {
 		sum[i] = sum[left[i]] + sum[right[i]];
 	}
 
+	// jobi位置，原来是1，现在改为-1
 	public static int update(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];

From 7eb7faae263e4144804ec0d85579a3513a0162ae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 17 Jan 2025 01:04:56 +0800
Subject: [PATCH 0389/1712] modify code

---
 ...70\345\205\263\351\242\230\347\233\256.pptx" | Bin 0 -> 46661 bytes
 src/class158/Code05_MoreImpressive1.java        |   4 ++--
 src/class158/Code05_MoreImpressive2.java        |   4 ++--
 3 files changed, 4 insertions(+), 4 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243158\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\347\272\277\346\256\265\346\240\221\347\232\204\347\233\270\345\205\263\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243158\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\347\272\277\346\256\265\346\240\221\347\232\204\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243158\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\347\272\277\346\256\265\346\240\221\347\232\204\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..65c50aa3ad26827bed0a9d39c08607ea65a8150c
GIT binary patch
literal 46661
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
Nd(aJ`U*Ynn{{qTy!S?_F

literal 0
HcmV?d00001

diff --git a/src/class158/Code05_MoreImpressive1.java b/src/class158/Code05_MoreImpressive1.java
index 6e4c1612a..9f7662586 100644
--- a/src/class158/Code05_MoreImpressive1.java
+++ b/src/class158/Code05_MoreImpressive1.java
@@ -213,8 +213,8 @@ public static void prepare() {
 	}
 
 	public static long compute(int a, int k) {
-		long ans = query(deep[a] + 1, deep[a] + k, 1, depth, root[dfn[a] - 1], root[dfn[a] + size[a] - 1]);
-		ans += (long) (size[a] - 1) * Math.min(k, deep[a] - 1);
+		long ans = (long) (size[a] - 1) * Math.min(k, deep[a] - 1);
+		ans += query(deep[a] + 1, deep[a] + k, 1, depth, root[dfn[a] - 1], root[dfn[a] + size[a] - 1]);
 		return ans;
 	}
 
diff --git a/src/class158/Code05_MoreImpressive2.java b/src/class158/Code05_MoreImpressive2.java
index 9cf12cbd7..b349e9287 100644
--- a/src/class158/Code05_MoreImpressive2.java
+++ b/src/class158/Code05_MoreImpressive2.java
@@ -118,8 +118,8 @@
 //}
 //
 //long long compute(int a, int k) {
-//    long long ans = query(dep[a] + 1, dep[a] + k, 1, depth, root[dfn[a] - 1], root[dfn[a] + siz[a] - 1]);
-//    ans += (long long)(siz[a] - 1) * min(k, dep[a] - 1);
+//    long long ans = (long long)(siz[a] - 1) * min(k, dep[a] - 1);
+//    ans += query(dep[a] + 1, dep[a] + k, 1, depth, root[dfn[a] - 1], root[dfn[a] + siz[a] - 1]);
 //    return ans;
 //}
 //

From e56e98960e59eda7a558980e3125857bcbafaa94 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 17 Jan 2025 23:24:03 +0800
Subject: [PATCH 0390/1712] modify code

---
 src/class109/Code04_DifferentColors.java | 160 ++++++++++++++++++-----
 1 file changed, 124 insertions(+), 36 deletions(-)

diff --git a/src/class109/Code04_DifferentColors.java b/src/class109/Code04_DifferentColors.java
index f18005492..3698a4b76 100644
--- a/src/class109/Code04_DifferentColors.java
+++ b/src/class109/Code04_DifferentColors.java
@@ -8,21 +8,18 @@
 // 1 <= n、m、arr[i] <= 10^6
 // 1 <= li <= ri <= n
 // 测试链接 : https://www.luogu.com.cn/problem/P1972
-// 请同学们务必参考如下代码中关于输入、输出的处理
-// 这是输入输出处理效率很高的写法
-// 提交以下的code，提交时请把类名改成"Main"，可以直接通过
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 代码逻辑和课上讲的完全一致，但是重写了读写工具类，增加了io效率
 
-import java.io.BufferedReader;
+import java.io.BufferedWriter;
 import java.io.IOException;
-import java.io.InputStreamReader;
+import java.io.InputStream;
 import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.StreamTokenizer;
 import java.util.Arrays;
 
 public class Code04_DifferentColors {
 
-	public static int MAXN = 1000010;
+	public static int MAXN = 1000001;
 
 	public static int[] arr = new int[MAXN];
 
@@ -60,34 +57,6 @@ public static int range(int l, int r) {
 		return sum(r) - sum(l - 1);
 	}
 
-	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		n = (int) in.nval;
-		for (int i = 1; i <= n; i++) {
-			in.nextToken();
-			arr[i] = (int) in.nval;
-		}
-		in.nextToken();
-		m = (int) in.nval;
-		for (int i = 1; i <= m; i++) {
-			in.nextToken();
-			query[i][0] = (int) in.nval;
-			in.nextToken();
-			query[i][1] = (int) in.nval;
-			query[i][2] = i;
-		}
-		compute();
-		for (int i = 1; i <= m; i++) {
-			out.println(ans[i]);
-		}
-		out.flush();
-		out.close();
-		br.close();
-	}
-
 	public static void compute() {
 		Arrays.sort(query, 1, m + 1, (a, b) -> a[1] - b[1]);
 		for (int s = 1, q = 1, l, r, i; q <= m; q++) {
@@ -106,4 +75,123 @@ public static void compute() {
 		}
 	}
 
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		m = in.nextInt();
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.write(ans[i] + "\n");
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public boolean hasNext() throws IOException {
+			while (hasNextByte()) {
+				byte b = buffer[ptr];
+				if (!isWhitespace(b))
+					return true;
+				ptr++;
+			}
+			return false;
+		}
+
+		public String next() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return null;
+			} while (c <= ' ');
+			StringBuilder sb = new StringBuilder();
+			while (c > ' ') {
+				sb.append((char) c);
+				c = readByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public double nextDouble() throws IOException {
+			double num = 0, div = 1;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != '.' && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			if (b == '.') {
+				b = readByte();
+				while (!isWhitespace(b) && b != -1) {
+					num += (b - '0') / (div *= 10);
+					b = readByte();
+				}
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
 }

From e06e093e26eb672fc78dfe2887ac1c1e3385c2dc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Jan 2025 00:31:41 +0800
Subject: [PATCH 0391/1712] modify code

---
 .../Code03_RangePersistentClassic1.java       |   1 +
 .../Code05_RangePersistentLessSpace1.java     |   1 +
 src/class159/Code01_MaxExclusiveOr1.java      | 197 ++++++++++++++++++
 src/class159/Code01_MaxExclusiveOr2.java      |  77 +++++++
 4 files changed, 276 insertions(+)
 create mode 100644 src/class159/Code01_MaxExclusiveOr1.java
 create mode 100644 src/class159/Code01_MaxExclusiveOr2.java

diff --git a/src/class157/Code03_RangePersistentClassic1.java b/src/class157/Code03_RangePersistentClassic1.java
index 24bd5105d..6fe9f1dfe 100644
--- a/src/class157/Code03_RangePersistentClassic1.java
+++ b/src/class157/Code03_RangePersistentClassic1.java
@@ -11,6 +11,7 @@
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP11470
 // 测试链接 : https://www.spoj.com/problems/TTM/
+// 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code03_RangePersistentClassic2文件就是C++的实现
diff --git a/src/class157/Code05_RangePersistentLessSpace1.java b/src/class157/Code05_RangePersistentLessSpace1.java
index 3d01cd922..c28752a9b 100644
--- a/src/class157/Code05_RangePersistentLessSpace1.java
+++ b/src/class157/Code05_RangePersistentLessSpace1.java
@@ -10,6 +10,7 @@
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=4348
+// 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code05_RangePersistentLessSpace2文件就是C++的实现
diff --git a/src/class159/Code01_MaxExclusiveOr1.java b/src/class159/Code01_MaxExclusiveOr1.java
new file mode 100644
index 000000000..1ab336a1c
--- /dev/null
+++ b/src/class159/Code01_MaxExclusiveOr1.java
@@ -0,0 +1,197 @@
+package class159;
+
+// 最大异或和，java版
+// 因为练的就是可持久化前缀树，所以就用在线算法
+// 测试链接 : https://www.luogu.com.cn/problem/P4735
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是通过不了
+// 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code01_MaxExclusiveOr2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.BufferedWriter;
+import java.io.IOException;
+import java.io.OutputStreamWriter;
+import java.io.InputStream;
+
+public class Code01_MaxExclusiveOr1 {
+
+	public static int MAXN = 600001;
+
+	public static int MAXT = MAXN * 22;
+
+	public static int BIT = 25;
+
+	public static int n, m;
+
+	public static int[] root = new int[MAXN];
+
+	public static int[][] next = new int[MAXT][2];
+
+	public static int[] size = new int[MAXT];
+
+	public static int cnt = 0;
+
+	public static int[] eor = new int[MAXN];
+
+	public static int insert(int num, int bit, int i) {
+		int rt = ++cnt;
+		next[rt][0] = next[i][0];
+		next[rt][1] = next[i][1];
+		size[rt] = size[i] + 1;
+		if (bit >= 0) {
+			int cur = (num >> bit) & 1;
+			next[rt][cur] = insert(num, bit - 1, next[rt][cur]);
+		}
+		return rt;
+	}
+
+	public static int query(int num, int bit, int u, int v) {
+		if (bit < 0) {
+			return 0;
+		}
+		int cur = (num >> bit) & 1;
+		int opp = cur ^ 1;
+		if (size[next[v][opp]] > size[next[u][opp]]) {
+			return (1 << bit) + query(num, bit - 1, next[u][opp], next[v][opp]);
+		} else {
+			return query(num, bit - 1, next[u][cur], next[v][cur]);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		root[0] = insert(0, BIT, 0);
+		for (int i = 1, num; i <= n; i++) {
+			num = in.nextInt();
+			eor[i] = eor[i - 1] ^ num;
+			root[i] = insert(eor[i], BIT, root[i - 1]);
+		}
+		String op;
+		int x, y, z;
+		StringBuilder ans = new StringBuilder();
+		for (int i = 1; i <= m; i++) {
+			op = in.next();
+			if (op.equals("A")) {
+				x = in.nextInt();
+				n++;
+				eor[n] = eor[n - 1] ^ x;
+				root[n] = insert(eor[n], 25, root[n - 1]);
+			} else {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				if (x == 1) {
+					ans.append(query(eor[n] ^ z, BIT, 0, root[y - 1])).append("\n");
+				} else {
+					ans.append(query(eor[n] ^ z, BIT, root[x - 2], root[y - 1])).append("\n");
+				}
+			}
+		}
+		out.write(ans.toString());
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public boolean hasNext() throws IOException {
+			while (hasNextByte()) {
+				byte b = buffer[ptr];
+				if (!isWhitespace(b))
+					return true;
+				ptr++;
+			}
+			return false;
+		}
+
+		public String next() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return null;
+			} while (c <= ' ');
+			StringBuilder sb = new StringBuilder();
+			while (c > ' ') {
+				sb.append((char) c);
+				c = readByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public double nextDouble() throws IOException {
+			double num = 0, div = 1;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != '.' && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			if (b == '.') {
+				b = readByte();
+				while (!isWhitespace(b) && b != -1) {
+					num += (b - '0') / (div *= 10);
+					b = readByte();
+				}
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class159/Code01_MaxExclusiveOr2.java b/src/class159/Code01_MaxExclusiveOr2.java
new file mode 100644
index 000000000..71cf5f820
--- /dev/null
+++ b/src/class159/Code01_MaxExclusiveOr2.java
@@ -0,0 +1,77 @@
+package class159;
+
+// 最大异或和，C++版
+// 因为练的就是可持久化前缀树，所以就用在线算法
+// 测试链接 : https://www.luogu.com.cn/problem/P4735
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 600001;
+//const int MAXT = MAXN * 22;
+//const int BIT = 25;
+//int n, m;
+//int root[MAXN];
+//int nxt[MAXT][2];
+//int size[MAXT];
+//int cnt = 0;
+//int eor[MAXN];
+//
+//int insert(int num, int bit, int i) {
+//    int rt = ++cnt;
+//    nxt[rt][0] = nxt[i][0];
+//    nxt[rt][1] = nxt[i][1];
+//    size[rt] = size[i] + 1;
+//    if (bit >= 0) {
+//        int cur = (num >> bit) & 1;
+//        nxt[rt][cur] = insert(num, bit - 1, nxt[rt][cur]);
+//    }
+//    return rt;
+//}
+//
+//int query(int num, int bit, int u, int v) {
+//    if (bit < 0) {
+//        return 0;
+//    }
+//    int cur = (num >> bit) & 1;
+//    int opp = cur ^ 1;
+//    if (size[nxt[v][opp]] > size[nxt[u][opp]]) {
+//        return (1 << bit) + query(num, bit - 1, nxt[u][opp], nxt[v][opp]);
+//    } else {
+//        return query(num, bit - 1, nxt[u][cur], nxt[v][cur]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(0);
+//    cin >> n >> m;
+//    root[0] = insert(0, BIT, 0);
+//    for (int i = 1, num; i <= n; i++) {
+//        cin >> num;
+//        eor[i] = eor[i - 1] ^ num;
+//        root[i] = insert(eor[i], BIT, root[i - 1]);
+//    }
+//    string op;
+//    int x, y, z;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op;
+//        if (op == "A") {
+//            cin >> x;
+//            n++;
+//            eor[n] = eor[n - 1] ^ x;
+//            root[n] = insert(eor[n], BIT, root[n - 1]);
+//        } else {
+//            cin >> x >> y >> z;
+//            if (x == 1) {
+//                cout << query(eor[n] ^ z, BIT, 0, root[y - 1]) << "\n";
+//            } else {
+//                cout << query(eor[n] ^ z, BIT, root[x - 2], root[y - 1]) << "\n";
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 76c6b208d5dae679ea4eddff71b1e31f5bffa962 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Jan 2025 00:34:29 +0800
Subject: [PATCH 0392/1712] modify code

---
 src/class159/Code01_MaxExclusiveOr1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class159/Code01_MaxExclusiveOr1.java b/src/class159/Code01_MaxExclusiveOr1.java
index 1ab336a1c..3dfd24e8e 100644
--- a/src/class159/Code01_MaxExclusiveOr1.java
+++ b/src/class159/Code01_MaxExclusiveOr1.java
@@ -4,7 +4,7 @@
 // 因为练的就是可持久化前缀树，所以就用在线算法
 // 测试链接 : https://www.luogu.com.cn/problem/P4735
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是通过不了
+// java实现的逻辑一定是正确的，但是通过不了所有测试用例
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code01_MaxExclusiveOr2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试

From 80f220e62fc6acedc7a63ceda4422ddeaf156248 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Jan 2025 00:45:36 +0800
Subject: [PATCH 0393/1712] modify code

---
 src/class159/Code01_MaxExclusiveOr1.java | 21 +++++++++------------
 src/class159/Code01_MaxExclusiveOr2.java | 14 +++++++-------
 2 files changed, 16 insertions(+), 19 deletions(-)

diff --git a/src/class159/Code01_MaxExclusiveOr1.java b/src/class159/Code01_MaxExclusiveOr1.java
index 3dfd24e8e..48123c703 100644
--- a/src/class159/Code01_MaxExclusiveOr1.java
+++ b/src/class159/Code01_MaxExclusiveOr1.java
@@ -9,9 +9,9 @@
 // 想通过用C++实现，本节课Code01_MaxExclusiveOr2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
-import java.io.BufferedWriter;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
 import java.io.InputStream;
 
 public class Code01_MaxExclusiveOr1 {
@@ -32,8 +32,6 @@ public class Code01_MaxExclusiveOr1 {
 
 	public static int cnt = 0;
 
-	public static int[] eor = new int[MAXN];
-
 	public static int insert(int num, int bit, int i) {
 		int rt = ++cnt;
 		next[rt][0] = next[i][0];
@@ -61,37 +59,36 @@ public static int query(int num, int bit, int u, int v) {
 
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader();
-		BufferedWriter out = new BufferedWriter(new OutputStreamWriter(System.out));
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		m = in.nextInt();
 		root[0] = insert(0, BIT, 0);
+		int eor = 0;
 		for (int i = 1, num; i <= n; i++) {
 			num = in.nextInt();
-			eor[i] = eor[i - 1] ^ num;
-			root[i] = insert(eor[i], BIT, root[i - 1]);
+			eor ^= num;
+			root[i] = insert(eor, BIT, root[i - 1]);
 		}
 		String op;
 		int x, y, z;
-		StringBuilder ans = new StringBuilder();
 		for (int i = 1; i <= m; i++) {
 			op = in.next();
 			if (op.equals("A")) {
 				x = in.nextInt();
+				eor ^= x;
 				n++;
-				eor[n] = eor[n - 1] ^ x;
-				root[n] = insert(eor[n], 25, root[n - 1]);
+				root[n] = insert(eor, 25, root[n - 1]);
 			} else {
 				x = in.nextInt();
 				y = in.nextInt();
 				z = in.nextInt();
 				if (x == 1) {
-					ans.append(query(eor[n] ^ z, BIT, 0, root[y - 1])).append("\n");
+					out.println(query(eor ^ z, BIT, 0, root[y - 1]));
 				} else {
-					ans.append(query(eor[n] ^ z, BIT, root[x - 2], root[y - 1])).append("\n");
+					out.println(query(eor ^ z, BIT, root[x - 2], root[y - 1]));
 				}
 			}
 		}
-		out.write(ans.toString());
 		out.flush();
 		out.close();
 	}
diff --git a/src/class159/Code01_MaxExclusiveOr2.java b/src/class159/Code01_MaxExclusiveOr2.java
index 71cf5f820..a2b20c206 100644
--- a/src/class159/Code01_MaxExclusiveOr2.java
+++ b/src/class159/Code01_MaxExclusiveOr2.java
@@ -18,7 +18,6 @@
 //int nxt[MAXT][2];
 //int size[MAXT];
 //int cnt = 0;
-//int eor[MAXN];
 //
 //int insert(int num, int bit, int i) {
 //    int rt = ++cnt;
@@ -50,10 +49,11 @@
 //    cin.tie(0);
 //    cin >> n >> m;
 //    root[0] = insert(0, BIT, 0);
+//    int eor = 0;
 //    for (int i = 1, num; i <= n; i++) {
 //        cin >> num;
-//        eor[i] = eor[i - 1] ^ num;
-//        root[i] = insert(eor[i], BIT, root[i - 1]);
+//        eor ^= num;
+//        root[i] = insert(eor, BIT, root[i - 1]);
 //    }
 //    string op;
 //    int x, y, z;
@@ -61,15 +61,15 @@
 //        cin >> op;
 //        if (op == "A") {
 //            cin >> x;
+//            eor ^= x;
 //            n++;
-//            eor[n] = eor[n - 1] ^ x;
-//            root[n] = insert(eor[n], BIT, root[n - 1]);
+//            root[n] = insert(eor, BIT, root[n - 1]);
 //        } else {
 //            cin >> x >> y >> z;
 //            if (x == 1) {
-//                cout << query(eor[n] ^ z, BIT, 0, root[y - 1]) << "\n";
+//                cout << query(eor ^ z, BIT, 0, root[y - 1]) << "\n";
 //            } else {
-//                cout << query(eor[n] ^ z, BIT, root[x - 2], root[y - 1]) << "\n";
+//                cout << query(eor ^ z, BIT, root[x - 2], root[y - 1]) << "\n";
 //            }
 //        }
 //    }

From 1bd81c22819232b5f168df0bf52abbeea68ed813 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Jan 2025 12:37:32 +0800
Subject: [PATCH 0394/1712] modify code

---
 src/class159/Code01_MaxExclusiveOr1.java | 6 +++---
 src/class159/Code01_MaxExclusiveOr2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class159/Code01_MaxExclusiveOr1.java b/src/class159/Code01_MaxExclusiveOr1.java
index 48123c703..1cc2fd917 100644
--- a/src/class159/Code01_MaxExclusiveOr1.java
+++ b/src/class159/Code01_MaxExclusiveOr1.java
@@ -28,7 +28,7 @@ public class Code01_MaxExclusiveOr1 {
 
 	public static int[][] next = new int[MAXT][2];
 
-	public static int[] size = new int[MAXT];
+	public static int[] pass = new int[MAXT];
 
 	public static int cnt = 0;
 
@@ -36,7 +36,7 @@ public static int insert(int num, int bit, int i) {
 		int rt = ++cnt;
 		next[rt][0] = next[i][0];
 		next[rt][1] = next[i][1];
-		size[rt] = size[i] + 1;
+		pass[rt] = pass[i] + 1;
 		if (bit >= 0) {
 			int cur = (num >> bit) & 1;
 			next[rt][cur] = insert(num, bit - 1, next[rt][cur]);
@@ -50,7 +50,7 @@ public static int query(int num, int bit, int u, int v) {
 		}
 		int cur = (num >> bit) & 1;
 		int opp = cur ^ 1;
-		if (size[next[v][opp]] > size[next[u][opp]]) {
+		if (pass[next[v][opp]] > pass[next[u][opp]]) {
 			return (1 << bit) + query(num, bit - 1, next[u][opp], next[v][opp]);
 		} else {
 			return query(num, bit - 1, next[u][cur], next[v][cur]);
diff --git a/src/class159/Code01_MaxExclusiveOr2.java b/src/class159/Code01_MaxExclusiveOr2.java
index a2b20c206..6cb22d8f5 100644
--- a/src/class159/Code01_MaxExclusiveOr2.java
+++ b/src/class159/Code01_MaxExclusiveOr2.java
@@ -16,14 +16,14 @@
 //int n, m;
 //int root[MAXN];
 //int nxt[MAXT][2];
-//int size[MAXT];
+//int pass[MAXT];
 //int cnt = 0;
 //
 //int insert(int num, int bit, int i) {
 //    int rt = ++cnt;
 //    nxt[rt][0] = nxt[i][0];
 //    nxt[rt][1] = nxt[i][1];
-//    size[rt] = size[i] + 1;
+//    pass[rt] = pass[i] + 1;
 //    if (bit >= 0) {
 //        int cur = (num >> bit) & 1;
 //        nxt[rt][cur] = insert(num, bit - 1, nxt[rt][cur]);
@@ -37,7 +37,7 @@
 //    }
 //    int cur = (num >> bit) & 1;
 //    int opp = cur ^ 1;
-//    if (size[nxt[v][opp]] > size[nxt[u][opp]]) {
+//    if (pass[nxt[v][opp]] > pass[nxt[u][opp]]) {
 //        return (1 << bit) + query(num, bit - 1, nxt[u][opp], nxt[v][opp]);
 //    } else {
 //        return query(num, bit - 1, nxt[u][cur], nxt[v][cur]);

From 22c7397f9a7d1b0d038539520cb9fd0a7cf2a7d9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Jan 2025 12:40:57 +0800
Subject: [PATCH 0395/1712] modify code

---
 src/class159/Code01_MaxExclusiveOr1.java | 6 +++---
 src/class159/Code01_MaxExclusiveOr2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class159/Code01_MaxExclusiveOr1.java b/src/class159/Code01_MaxExclusiveOr1.java
index 1cc2fd917..a59d9f592 100644
--- a/src/class159/Code01_MaxExclusiveOr1.java
+++ b/src/class159/Code01_MaxExclusiveOr1.java
@@ -22,7 +22,7 @@ public class Code01_MaxExclusiveOr1 {
 
 	public static int BIT = 25;
 
-	public static int n, m;
+	public static int n, m, eor;
 
 	public static int[] root = new int[MAXN];
 
@@ -62,8 +62,8 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		m = in.nextInt();
-		root[0] = insert(0, BIT, 0);
-		int eor = 0;
+		eor = 0;
+		root[0] = insert(eor, BIT, 0);
 		for (int i = 1, num; i <= n; i++) {
 			num = in.nextInt();
 			eor ^= num;
diff --git a/src/class159/Code01_MaxExclusiveOr2.java b/src/class159/Code01_MaxExclusiveOr2.java
index 6cb22d8f5..aa22932b5 100644
--- a/src/class159/Code01_MaxExclusiveOr2.java
+++ b/src/class159/Code01_MaxExclusiveOr2.java
@@ -13,7 +13,7 @@
 //const int MAXN = 600001;
 //const int MAXT = MAXN * 22;
 //const int BIT = 25;
-//int n, m;
+//int n, m, eor;
 //int root[MAXN];
 //int nxt[MAXT][2];
 //int pass[MAXT];
@@ -48,8 +48,8 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(0);
 //    cin >> n >> m;
-//    root[0] = insert(0, BIT, 0);
-//    int eor = 0;
+//    eor = 0;
+//    root[0] = insert(eor, BIT, 0);
 //    for (int i = 1, num; i <= n; i++) {
 //        cin >> num;
 //        eor ^= num;

From 0ef9a067c6e1f6786a3bb12e595f14e9316cff23 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Jan 2025 19:41:11 +0800
Subject: [PATCH 0396/1712] modify code

---
 src/class159/Code02_Yummy1.java | 133 ++++++++++++++++++++++++++++++++
 src/class159/Code02_Yummy2.java | 107 +++++++++++++++++++++++++
 2 files changed, 240 insertions(+)
 create mode 100644 src/class159/Code02_Yummy1.java
 create mode 100644 src/class159/Code02_Yummy2.java

diff --git a/src/class159/Code02_Yummy1.java b/src/class159/Code02_Yummy1.java
new file mode 100644
index 000000000..83dedb53f
--- /dev/null
+++ b/src/class159/Code02_Yummy1.java
@@ -0,0 +1,133 @@
+package class159;
+
+// 美味，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3293
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_Yummy1 {
+
+	public static int MAXN = 200001;
+
+	public static int MAXT = 4000001;
+
+	public static int BIT = 18;
+
+	public static int n, m, s;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static int[] size = new int[MAXT];
+
+	public static int cnt;
+
+	public static int build(int l, int r) {
+		int rt = ++cnt;
+		size[rt] = 0;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			left[rt] = build(l, mid);
+			right[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int update(int jobi, int l, int r, int i) {
+		int rt = ++cnt;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		size[rt] = size[i] + 1;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[rt] = update(jobi, l, mid, left[rt]);
+			} else {
+				right[rt] = update(jobi, mid + 1, r, right[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int u, int v) {
+		if (jobr < l || jobl > r) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return size[v] - size[u];
+		}
+		int mid = (l + r) / 2;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, l, mid, left[u], left[v]);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, mid + 1, r, right[u], right[v]);
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		cnt = 0;
+		s = 0;
+		for (int i = 1; i <= n; i++) {
+			s = Math.max(s, arr[i]);
+		}
+		root[0] = build(0, s);
+		for (int i = 1; i <= n; i++) {
+			root[i] = update(arr[i], 0, s, root[i - 1]);
+		}
+	}
+
+	public static int compute(int b, int x, int l, int r) {
+		int ans = 0;
+		for (int i = BIT; i >= 0; i--) {
+			if (((b >> i) & 1) == 1) {
+				if (query(ans - x, ans - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
+					ans += 1 << i;
+				}
+			} else {
+				if (query(ans - x + (1 << i), ans - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
+					ans += 1 << i;
+				}
+			}
+		}
+		return ans ^ b;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		prepare();
+		for (int i = 1, b, x, l, r; i <= m; i++) {
+			in.nextToken(); b = (int) in.nval;
+			in.nextToken(); x = (int) in.nval;
+			in.nextToken(); l = (int) in.nval;
+			in.nextToken(); r = (int) in.nval;
+			out.println(compute(b, x, l, r));
+		}
+		out.flush();
+		out.close();
+	}
+
+}
diff --git a/src/class159/Code02_Yummy2.java b/src/class159/Code02_Yummy2.java
new file mode 100644
index 000000000..7b8bb1e55
--- /dev/null
+++ b/src/class159/Code02_Yummy2.java
@@ -0,0 +1,107 @@
+package class159;
+
+// 美味，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3293
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXT = 4000001;
+//const int BIT = 18;
+//int n, m, s;
+//int arr[MAXN];
+//int root[MAXN];
+//int ls[MAXT], rs[MAXT], size[MAXT];
+//int cnt;
+//
+//int build(int l, int r) {
+//    int rt = ++cnt;
+//    size[rt] = 0;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int update(int jobi, int l, int r, int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    size[rt] = size[i] + 1;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = update(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = update(jobi, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int u, int v) {
+//    if (jobr < l || jobl > r) {
+//        return 0;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        return size[v] - size[u];
+//    }
+//    int mid = (l + r) / 2;
+//    int ans = 0;
+//    if (jobl <= mid) {
+//        ans += query(jobl, jobr, l, mid, ls[u], ls[v]);
+//    }
+//    if (jobr > mid) {
+//        ans += query(jobl, jobr, mid + 1, r, rs[u], rs[v]);
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    cnt = 0;
+//    s = 0;
+//    for (int i = 1; i <= n; i++) {
+//        s = max(s, arr[i]);
+//    }
+//    root[0] = build(0, s);
+//    for (int i = 1; i <= n; i++) {
+//        root[i] = update(arr[i], 0, s, root[i - 1]);
+//    }
+//}
+//
+//int compute(int b, int x, int l, int r) {
+//    int ans = 0;
+//    for (int i = BIT; i >= 0; i--) {
+//        if (((b >> i) & 1) == 1) {
+//            if (query(ans - x, ans - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
+//                ans += 1 << i;
+//            }
+//        } else {
+//            if (query(ans - x + (1 << i), ans - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
+//                ans += 1 << i;
+//            }
+//        }
+//    }
+//    return ans ^ b;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(0);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, b, x, l, r; i <= m; i++) {
+//        cin >> b >> x >> l >> r;
+//        cout << compute(b, x, l, r) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 1f7de2a0e805262aa1e12af2311427cee71036a8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Jan 2025 16:54:33 +0800
Subject: [PATCH 0397/1712] modify code

---
 src/class159/Code01_MaxExclusiveOr1.java |  53 +++--
 src/class159/Code01_MaxExclusiveOr2.java |  53 +++--
 src/class159/Code02_Yummy1.java          |   8 +-
 src/class159/Code02_Yummy2.java          |   8 +-
 src/class159/Code03_StringTree1.java     | 254 +++++++++++++++++++++++
 src/class159/Code03_StringTree2.java     | 127 ++++++++++++
 6 files changed, 451 insertions(+), 52 deletions(-)
 create mode 100644 src/class159/Code03_StringTree1.java
 create mode 100644 src/class159/Code03_StringTree2.java

diff --git a/src/class159/Code01_MaxExclusiveOr1.java b/src/class159/Code01_MaxExclusiveOr1.java
index a59d9f592..f83b540d7 100644
--- a/src/class159/Code01_MaxExclusiveOr1.java
+++ b/src/class159/Code01_MaxExclusiveOr1.java
@@ -26,35 +26,44 @@ public class Code01_MaxExclusiveOr1 {
 
 	public static int[] root = new int[MAXN];
 
-	public static int[][] next = new int[MAXT][2];
+	public static int[][] tree = new int[MAXT][2];
 
 	public static int[] pass = new int[MAXT];
 
 	public static int cnt = 0;
 
-	public static int insert(int num, int bit, int i) {
+	public static int insert(int num, int i) {
 		int rt = ++cnt;
-		next[rt][0] = next[i][0];
-		next[rt][1] = next[i][1];
+		tree[rt][0] = tree[i][0];
+		tree[rt][1] = tree[i][1];
 		pass[rt] = pass[i] + 1;
-		if (bit >= 0) {
-			int cur = (num >> bit) & 1;
-			next[rt][cur] = insert(num, bit - 1, next[rt][cur]);
+		for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+			path = (num >> b) & 1;
+			i = tree[i][path];
+			cur = ++cnt;
+			tree[cur][0] = tree[i][0];
+			tree[cur][1] = tree[i][1];
+			pass[cur] = pass[i] + 1;
+			tree[pre][path] = cur;
 		}
 		return rt;
 	}
 
-	public static int query(int num, int bit, int u, int v) {
-		if (bit < 0) {
-			return 0;
-		}
-		int cur = (num >> bit) & 1;
-		int opp = cur ^ 1;
-		if (pass[next[v][opp]] > pass[next[u][opp]]) {
-			return (1 << bit) + query(num, bit - 1, next[u][opp], next[v][opp]);
-		} else {
-			return query(num, bit - 1, next[u][cur], next[v][cur]);
+	public static int query(int num, int u, int v) {
+		int ans = 0;
+		for (int b = BIT, path, best; b >= 0; b--) {
+			path = (num >> b) & 1;
+			best = path ^ 1;
+			if (pass[tree[v][best]] > pass[tree[u][best]]) {
+				ans += 1 << b;
+				u = tree[u][best];
+				v = tree[v][best];
+			} else {
+				u = tree[u][path];
+				v = tree[v][path];
+			}
 		}
+		return ans;
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -63,11 +72,11 @@ public static void main(String[] args) throws IOException {
 		n = in.nextInt();
 		m = in.nextInt();
 		eor = 0;
-		root[0] = insert(eor, BIT, 0);
+		root[0] = insert(eor, 0);
 		for (int i = 1, num; i <= n; i++) {
 			num = in.nextInt();
 			eor ^= num;
-			root[i] = insert(eor, BIT, root[i - 1]);
+			root[i] = insert(eor, root[i - 1]);
 		}
 		String op;
 		int x, y, z;
@@ -77,15 +86,15 @@ public static void main(String[] args) throws IOException {
 				x = in.nextInt();
 				eor ^= x;
 				n++;
-				root[n] = insert(eor, 25, root[n - 1]);
+				root[n] = insert(eor, root[n - 1]);
 			} else {
 				x = in.nextInt();
 				y = in.nextInt();
 				z = in.nextInt();
 				if (x == 1) {
-					out.println(query(eor ^ z, BIT, 0, root[y - 1]));
+					out.println(query(eor ^ z, 0, root[y - 1]));
 				} else {
-					out.println(query(eor ^ z, BIT, root[x - 2], root[y - 1]));
+					out.println(query(eor ^ z, root[x - 2], root[y - 1]));
 				}
 			}
 		}
diff --git a/src/class159/Code01_MaxExclusiveOr2.java b/src/class159/Code01_MaxExclusiveOr2.java
index aa22932b5..be2b18585 100644
--- a/src/class159/Code01_MaxExclusiveOr2.java
+++ b/src/class159/Code01_MaxExclusiveOr2.java
@@ -15,33 +15,42 @@
 //const int BIT = 25;
 //int n, m, eor;
 //int root[MAXN];
-//int nxt[MAXT][2];
+//int tree[MAXT][2];
 //int pass[MAXT];
 //int cnt = 0;
 //
-//int insert(int num, int bit, int i) {
+//int insert(int num, int i) {
 //    int rt = ++cnt;
-//    nxt[rt][0] = nxt[i][0];
-//    nxt[rt][1] = nxt[i][1];
+//    tree[rt][0] = tree[i][0];
+//    tree[rt][1] = tree[i][1];
 //    pass[rt] = pass[i] + 1;
-//    if (bit >= 0) {
-//        int cur = (num >> bit) & 1;
-//        nxt[rt][cur] = insert(num, bit - 1, nxt[rt][cur]);
+//    for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+//        path = (num >> b) & 1;
+//        i = tree[i][path];
+//        cur = ++cnt;
+//        tree[cur][0] = tree[i][0];
+//        tree[cur][1] = tree[i][1];
+//        pass[cur] = pass[i] + 1;
+//        tree[pre][path] = cur;
 //    }
 //    return rt;
 //}
 //
-//int query(int num, int bit, int u, int v) {
-//    if (bit < 0) {
-//        return 0;
-//    }
-//    int cur = (num >> bit) & 1;
-//    int opp = cur ^ 1;
-//    if (pass[nxt[v][opp]] > pass[nxt[u][opp]]) {
-//        return (1 << bit) + query(num, bit - 1, nxt[u][opp], nxt[v][opp]);
-//    } else {
-//        return query(num, bit - 1, nxt[u][cur], nxt[v][cur]);
+//int query(int num, int u, int v) {
+//    int ans = 0;
+//    for (int b = BIT, path, best; b >= 0; b--) {
+//        path = (num >> b) & 1;
+//        best = path ^ 1;
+//        if (pass[tree[v][best]] > pass[tree[u][best]]) {
+//            ans += 1 << b;
+//            u = tree[u][best];
+//            v = tree[v][best];
+//        } else {
+//            u = tree[u][path];
+//            v = tree[v][path];
+//        }
 //    }
+//    return ans;
 //}
 //
 //int main() {
@@ -49,11 +58,11 @@
 //    cin.tie(0);
 //    cin >> n >> m;
 //    eor = 0;
-//    root[0] = insert(eor, BIT, 0);
+//    root[0] = insert(eor, 0);
 //    for (int i = 1, num; i <= n; i++) {
 //        cin >> num;
 //        eor ^= num;
-//        root[i] = insert(eor, BIT, root[i - 1]);
+//        root[i] = insert(eor, root[i - 1]);
 //    }
 //    string op;
 //    int x, y, z;
@@ -63,13 +72,13 @@
 //            cin >> x;
 //            eor ^= x;
 //            n++;
-//            root[n] = insert(eor, BIT, root[n - 1]);
+//            root[n] = insert(eor, root[n - 1]);
 //        } else {
 //            cin >> x >> y >> z;
 //            if (x == 1) {
-//                cout << query(eor ^ z, BIT, 0, root[y - 1]) << "\n";
+//                cout << query(eor ^ z, 0, root[y - 1]) << "\n";
 //            } else {
-//                cout << query(eor ^ z, BIT, root[x - 2], root[y - 1]) << "\n";
+//                cout << query(eor ^ z, root[x - 2], root[y - 1]) << "\n";
 //            }
 //        }
 //    }
diff --git a/src/class159/Code02_Yummy1.java b/src/class159/Code02_Yummy1.java
index 83dedb53f..470407dfb 100644
--- a/src/class159/Code02_Yummy1.java
+++ b/src/class159/Code02_Yummy1.java
@@ -44,7 +44,7 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
-	public static int update(int jobi, int l, int r, int i) {
+	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cnt;
 		left[rt] = left[i];
 		right[rt] = right[i];
@@ -52,9 +52,9 @@ public static int update(int jobi, int l, int r, int i) {
 		if (l < r) {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
-				left[rt] = update(jobi, l, mid, left[rt]);
+				left[rt] = insert(jobi, l, mid, left[rt]);
 			} else {
-				right[rt] = update(jobi, mid + 1, r, right[rt]);
+				right[rt] = insert(jobi, mid + 1, r, right[rt]);
 			}
 		}
 		return rt;
@@ -86,7 +86,7 @@ public static void prepare() {
 		}
 		root[0] = build(0, s);
 		for (int i = 1; i <= n; i++) {
-			root[i] = update(arr[i], 0, s, root[i - 1]);
+			root[i] = insert(arr[i], 0, s, root[i - 1]);
 		}
 	}
 
diff --git a/src/class159/Code02_Yummy2.java b/src/class159/Code02_Yummy2.java
index 7b8bb1e55..ebfa72d58 100644
--- a/src/class159/Code02_Yummy2.java
+++ b/src/class159/Code02_Yummy2.java
@@ -29,7 +29,7 @@
 //    return rt;
 //}
 //
-//int update(int jobi, int l, int r, int i) {
+//int insert(int jobi, int l, int r, int i) {
 //    int rt = ++cnt;
 //    ls[rt] = ls[i];
 //    rs[rt] = rs[i];
@@ -37,9 +37,9 @@
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
-//            ls[rt] = update(jobi, l, mid, ls[rt]);
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
 //        } else {
-//            rs[rt] = update(jobi, mid + 1, r, rs[rt]);
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
 //        }
 //    }
 //    return rt;
@@ -71,7 +71,7 @@
 //    }
 //    root[0] = build(0, s);
 //    for (int i = 1; i <= n; i++) {
-//        root[i] = update(arr[i], 0, s, root[i - 1]);
+//        root[i] = insert(arr[i], 0, s, root[i - 1]);
 //    }
 //}
 //
diff --git a/src/class159/Code03_StringTree1.java b/src/class159/Code03_StringTree1.java
new file mode 100644
index 000000000..ad45c5082
--- /dev/null
+++ b/src/class159/Code03_StringTree1.java
@@ -0,0 +1,254 @@
+package class159;
+
+// 字符串树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P6088
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code03_StringTree1 {
+
+	public static int MAXN = 100001;
+
+	public static int MAXT = 1000001;
+
+	public static int MAXH = 20;
+
+	public static int n, m;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static String[] weight = new String[MAXN << 1];
+
+	public static int cntg;
+
+	public static int[] root = new int[MAXN];
+
+	public static int[][] tree = new int[MAXT][27];
+
+	public static int[] pass = new int[MAXT];
+
+	public static int cntt = 0;
+
+	public static int[] deep = new int[MAXN];
+
+	public static int[][] stjump = new int[MAXN][MAXH];
+
+	public static void addEdge(int u, int v, String w) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	public static int num(char cha) {
+		return cha - 'a' + 1;
+	}
+
+	public static int clone(int i) {
+		int rt = ++cntt;
+		for (int cha = 1; cha <= 26; cha++) {
+			tree[rt][cha] = tree[i][cha];
+		}
+		pass[rt] = pass[i];
+		return rt;
+	}
+
+	public static int insert(String str, int i) {
+		int rt = clone(i);
+		pass[rt]++;
+		for (int j = 0, path, pre = rt, cur; j < str.length(); j++, pre = cur) {
+			path = num(str.charAt(j));
+			i = tree[i][path];
+			cur = clone(i);
+			pass[cur]++;
+			tree[pre][path] = cur;
+		}
+		return rt;
+	}
+
+	public static int query(String str, int i) {
+		for (int j = 0, path; j < str.length(); j++) {
+			path = num(str.charAt(j));
+			i = tree[i][path];
+			if (i == 0) {
+				return 0;
+			}
+		}
+		return pass[i];
+	}
+
+	// 递归版，C++可以通过，java无法通过，递归会爆栈
+	public static void dfs1(int u, int fa, String path) {
+		root[u] = insert(path, root[fa]);
+		deep[u] = deep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != fa) {
+				dfs1(to[e], u, weight[e]);
+			}
+		}
+	}
+
+	// 迭代版，都可以通过
+	// 讲解118，详解了从递归版改迭代版
+	public static int[] us = new int[MAXN];
+	public static int[] fs = new int[MAXN];
+	public static int[] es = new int[MAXN];
+	public static String[] ps = new String[MAXN];
+	public static int stackSize;
+	public static int u;
+	public static int f;
+	public static int e;
+	public static String p;
+
+	public static void push(int u, int f, int e, String p) {
+		us[stackSize] = u;
+		fs[stackSize] = f;
+		es[stackSize] = e;
+		ps[stackSize] = p;
+		stackSize++;
+	}
+
+	public static void pop() {
+		--stackSize;
+		u = us[stackSize];
+		f = fs[stackSize];
+		e = es[stackSize];
+		p = ps[stackSize];
+	}
+
+	// dfs1方法改成迭代版
+	public static void dfs2() {
+		stackSize = 0;
+		push(1, 0, -1, "");
+		while (stackSize > 0) {
+			pop();
+			if (e == -1) {
+				root[u] = insert(p, root[f]);
+				deep[u] = deep[f] + 1;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e, p);
+				if (to[e] != f) {
+					push(to[e], u, -1, weight[e]);
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (deep[a] < deep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (deep[stjump[a][p]] >= deep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int compute(int u, int v, String s) {
+		return query(s, root[u]) + query(s, root[v]) - 2 * query(s, root[lca(u, v)]);
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		int u, v;
+		String s;
+		for (int i = 1; i < n; i++) {
+			u = io.nextInt();
+			v = io.nextInt();
+			s = io.next();
+			addEdge(u, v, s);
+			addEdge(v, u, s);
+		}
+		dfs2(); // 使用迭代版防止爆栈
+		m = io.nextInt();
+		for (int i = 1; i <= m; i++) {
+			u = io.nextInt();
+			v = io.nextInt();
+			s = io.next();
+			io.println(compute(u, v, s));
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class159/Code03_StringTree2.java b/src/class159/Code03_StringTree2.java
new file mode 100644
index 000000000..ce14a9634
--- /dev/null
+++ b/src/class159/Code03_StringTree2.java
@@ -0,0 +1,127 @@
+package class159;
+
+// 字符串树，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P6088
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//static const int MAXN = 100001;
+//static const int MAXT = 1000001;
+//static const int MAXH = 20;
+//int n, m;
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//string weight[MAXN << 1];
+//int cntg;
+//int root[MAXN];
+//int tree[MAXT][27];
+//int pass[MAXT];
+//int cntt;
+//int deep[MAXN];
+//int stjump[MAXN][MAXH];
+//
+//void addEdge(int u, int v, const string &w) {
+//	nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//int num(char c) {
+//    return c - 'a' + 1;
+//}
+//
+//int clone(int i) {
+//    int rt = ++cntt;
+//    for (int c = 1; c <= 26; c++) {
+//        tree[rt][c] = tree[i][c];
+//    }
+//    pass[rt] = pass[i];
+//    return rt;
+//}
+//
+//int insert(const string &str, int i) {
+//    int rt = clone(i);
+//    pass[rt]++;
+//    int pre = rt;
+//    for (int j = 0; j < (int)str.size(); j++) {
+//        int path = num(str[j]);
+//        i = tree[i][path];
+//        int cur = clone(i);
+//        pass[cur]++;
+//        tree[pre][path] = cur;
+//        pre = cur;
+//    }
+//    return rt;
+//}
+//
+//int query(const string &str, int i) {
+//    for (int j = 0; j < (int)str.size(); j++) {
+//        int path = num(str[j]);
+//        i = tree[i][path];
+//        if (!i) return 0;
+//    }
+//    return pass[i];
+//}
+//
+//void dfs(int u, int fa, const string &path) {
+//    root[u] = insert(path, root[fa]);
+//    deep[u] = deep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        if (to[e] != fa) {
+//            dfs(to[e], u, weight[e]);
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    if (deep[a] < deep[b]) swap(a, b);
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (deep[stjump[a][p]] >= deep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) return a;
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int compute(int u, int v, const string &s) {
+//    return query(s, root[u]) + query(s, root[v]) - 2 * query(s, root[lca(u, v)]);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i < n; i++) {
+//        int u, v;
+//        string s;
+//        cin >> u >> v >> s;
+//        addEdge(u, v, s);
+//        addEdge(v, u, s);
+//    }
+//    dfs(1, 0, "");
+//    cin >> m;
+//    while (m--) {
+//        int u, v;
+//        string s;
+//        cin >> u >> v >> s;
+//        cout << compute(u, v, s) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From e678379d8238efd721c11f3e782eee02ebab7f91 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Jan 2025 16:56:41 +0800
Subject: [PATCH 0398/1712] modify code

---
 src/class159/Code03_StringTree1.java | 2 +-
 src/class159/Code03_StringTree2.java | 7 +++++--
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/class159/Code03_StringTree1.java b/src/class159/Code03_StringTree1.java
index ad45c5082..09f6e639d 100644
--- a/src/class159/Code03_StringTree1.java
+++ b/src/class159/Code03_StringTree1.java
@@ -31,7 +31,7 @@ public class Code03_StringTree1 {
 
 	public static String[] weight = new String[MAXN << 1];
 
-	public static int cntg;
+	public static int cntg = 0;
 
 	public static int[] root = new int[MAXN];
 
diff --git a/src/class159/Code03_StringTree2.java b/src/class159/Code03_StringTree2.java
index ce14a9634..43b1dfb19 100644
--- a/src/class159/Code03_StringTree2.java
+++ b/src/class159/Code03_StringTree2.java
@@ -13,15 +13,18 @@
 //static const int MAXT = 1000001;
 //static const int MAXH = 20;
 //int n, m;
+//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //string weight[MAXN << 1];
-//int cntg;
+//int cntg = 0;
+//
 //int root[MAXN];
 //int tree[MAXT][27];
 //int pass[MAXT];
-//int cntt;
+//int cntt = 0;
+//
 //int deep[MAXN];
 //int stjump[MAXN][MAXH];
 //

From 16f01eec3fe0de76eff0d58283b0109f38684ce6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Jan 2025 20:47:44 +0800
Subject: [PATCH 0399/1712] modify code

---
 .../{Code03_StringTree1.java => Code02_StringTree1.java}        | 2 +-
 .../{Code03_StringTree2.java => Code02_StringTree2.java}        | 0
 src/class159/{Code02_Yummy1.java => Code03_Yummy1.java}         | 2 +-
 src/class159/{Code02_Yummy2.java => Code03_Yummy2.java}         | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class159/{Code03_StringTree1.java => Code02_StringTree1.java} (99%)
 rename src/class159/{Code03_StringTree2.java => Code02_StringTree2.java} (100%)
 rename src/class159/{Code02_Yummy1.java => Code03_Yummy1.java} (99%)
 rename src/class159/{Code02_Yummy2.java => Code03_Yummy2.java} (100%)

diff --git a/src/class159/Code03_StringTree1.java b/src/class159/Code02_StringTree1.java
similarity index 99%
rename from src/class159/Code03_StringTree1.java
rename to src/class159/Code02_StringTree1.java
index 09f6e639d..6eac5dd9a 100644
--- a/src/class159/Code03_StringTree1.java
+++ b/src/class159/Code02_StringTree1.java
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code03_StringTree1 {
+public class Code02_StringTree1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class159/Code03_StringTree2.java b/src/class159/Code02_StringTree2.java
similarity index 100%
rename from src/class159/Code03_StringTree2.java
rename to src/class159/Code02_StringTree2.java
diff --git a/src/class159/Code02_Yummy1.java b/src/class159/Code03_Yummy1.java
similarity index 99%
rename from src/class159/Code02_Yummy1.java
rename to src/class159/Code03_Yummy1.java
index 470407dfb..b8649b16a 100644
--- a/src/class159/Code02_Yummy1.java
+++ b/src/class159/Code03_Yummy1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_Yummy1 {
+public class Code03_Yummy1 {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class159/Code02_Yummy2.java b/src/class159/Code03_Yummy2.java
similarity index 100%
rename from src/class159/Code02_Yummy2.java
rename to src/class159/Code03_Yummy2.java

From aab5213c6de40f55a07e418bae62881a0148cd2f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Jan 2025 23:20:50 +0800
Subject: [PATCH 0400/1712] modify code

---
 src/class159/Code03_Yummy1.java |   1 +
 src/class159/Code03_Yummy2.java |   2 +-
 src/class159/Code04_ALO1.java   | 125 ++++++++++++++++++++++++++++++++
 src/class159/Code04_ALO2.java   | 106 +++++++++++++++++++++++++++
 4 files changed, 233 insertions(+), 1 deletion(-)
 create mode 100644 src/class159/Code04_ALO1.java
 create mode 100644 src/class159/Code04_ALO2.java

diff --git a/src/class159/Code03_Yummy1.java b/src/class159/Code03_Yummy1.java
index b8649b16a..7d579de24 100644
--- a/src/class159/Code03_Yummy1.java
+++ b/src/class159/Code03_Yummy1.java
@@ -128,6 +128,7 @@ public static void main(String[] args) throws IOException {
 		}
 		out.flush();
 		out.close();
+		br.close();
 	}
 
 }
diff --git a/src/class159/Code03_Yummy2.java b/src/class159/Code03_Yummy2.java
index ebfa72d58..d79fca517 100644
--- a/src/class159/Code03_Yummy2.java
+++ b/src/class159/Code03_Yummy2.java
@@ -93,7 +93,7 @@
 //
 //int main() {
 //    ios::sync_with_stdio(false);
-//    cin.tie(0);
+//    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
diff --git a/src/class159/Code04_ALO1.java b/src/class159/Code04_ALO1.java
new file mode 100644
index 000000000..fdc30b6bd
--- /dev/null
+++ b/src/class159/Code04_ALO1.java
@@ -0,0 +1,125 @@
+package class159;
+
+// 生成能量密度最大的宝石，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4098
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code04_ALO1 {
+
+	public static int MAXN = 50002;
+
+	public static int MAXT = MAXN * 32;
+
+	public static int BIT = 30;
+
+	public static int n, m;
+
+	public static int[][] arr = new int[MAXN][2];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[][] tree = new int[MAXT][2];
+
+	public static int[] pass = new int[MAXT];
+
+	public static int cnt;
+
+	public static int[] last = new int[MAXN];
+
+	public static int[] next = new int[MAXN];
+
+	public static int insert(int num, int i) {
+		int rt = ++cnt;
+		tree[rt][0] = tree[i][0];
+		tree[rt][1] = tree[i][1];
+		pass[rt] = pass[i] + 1;
+		for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+			path = (num >> b) & 1;
+			i = tree[i][path];
+			cur = ++cnt;
+			tree[cur][0] = tree[i][0];
+			tree[cur][1] = tree[i][1];
+			pass[cur] = pass[i] + 1;
+			tree[pre][path] = cur;
+		}
+		return rt;
+	}
+
+	public static int query(int num, int u, int v) {
+		int ans = 0;
+		for (int b = BIT, path, best; b >= 0; b--) {
+			path = (num >> b) & 1;
+			best = path ^ 1;
+			if (pass[tree[v][best]] > pass[tree[u][best]]) {
+				ans += 1 << b;
+				u = tree[u][best];
+				v = tree[v][best];
+			} else {
+				u = tree[u][path];
+				v = tree[v][path];
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		last[0] = 0;
+		next[0] = 1;
+		last[n + 1] = n;
+		next[n + 1] = n + 1;
+		for (int i = 1; i <= n; i++) {
+			root[i] = insert(arr[i][1], root[i - 1]);
+			last[i] = i - 1;
+			next[i] = i + 1;
+		}
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
+	}
+
+	public static int compute() {
+		int ans = 0;
+		for (int i = 1, index, value, l1, l2, r1, r2; i <= n; i++) {
+			index = arr[i][0];
+			value = arr[i][1];
+			l1 = last[index];
+			l2 = last[l1];
+			r1 = next[index];
+			r2 = next[r1];
+			if (l1 != 0) {
+				ans = Math.max(ans, query(value, root[l2], root[r1 - 1]));
+			}
+			if (r1 != n + 1) {
+				ans = Math.max(ans, query(value, root[l1], root[r2 - 1]));
+			}
+			next[l1] = r1;
+			last[r1] = l1;
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = i;
+			in.nextToken();
+			arr[i][1] = (int) in.nval;
+		}
+		prepare();
+		out.println(compute());
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class159/Code04_ALO2.java b/src/class159/Code04_ALO2.java
new file mode 100644
index 000000000..a67e63650
--- /dev/null
+++ b/src/class159/Code04_ALO2.java
@@ -0,0 +1,106 @@
+package class159;
+
+// 生成能量密度最大的宝石，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4098
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50002;
+//const int MAXT = MAXN * 32;
+//const int BIT = 30;
+//int n, m;
+//vector<pair<int, int>> arr;
+//int root[MAXN];
+//int tree[MAXT][2];
+//int pass[MAXT];
+//int cnt;
+//int last[MAXN];
+//int nxt[MAXN];
+//
+//int insert_(int num, int i) {
+//    int rt = ++cnt;
+//    tree[rt][0] = tree[i][0];
+//    tree[rt][1] = tree[i][1];
+//    pass[rt] = pass[i] + 1;
+//    for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+//        path = (num >> b) & 1;
+//        i = tree[i][path];
+//        cur = ++cnt;
+//        tree[cur][0] = tree[i][0];
+//        tree[cur][1] = tree[i][1];
+//        pass[cur] = pass[i] + 1;
+//        tree[pre][path] = cur;
+//    }
+//    return rt;
+//}
+//
+//int query(int num, int u, int v) {
+//    int ans = 0;
+//    for (int b = BIT, path, best; b >= 0; b--) {
+//        path = (num >> b) & 1;
+//        best = path ^ 1;
+//        if (pass[tree[v][best]] > pass[tree[u][best]]) {
+//            ans += 1 << b;
+//            u = tree[u][best];
+//            v = tree[v][best];
+//        } else {
+//            u = tree[u][path];
+//            v = tree[v][path];
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    last[0] = 0;
+//    nxt[0] = 1;
+//    last[n + 1] = n;
+//    nxt[n + 1] = n + 1;
+//    for (int i = 1; i <= n; i++) {
+//        root[i] = insert_(arr[i].second, root[i - 1]);
+//        last[i] = i - 1;
+//        nxt[i] = i + 1;
+//    }
+//    sort(arr.begin() + 1, arr.end(), [](const pair<int, int>& a, const pair<int, int>& b) {
+//        return a.second < b.second;
+//    });
+//}
+//
+//int compute() {
+//    int ans = 0;
+//    for (int i = 1, index, value, l1, l2, r1, r2; i <= n; i++) {
+//        index = arr[i].first;
+//        value = arr[i].second;
+//        l1 = last[index];
+//        l2 = last[l1];
+//        r1 = nxt[index];
+//        r2 = nxt[r1];
+//        if (l1 != 0) {
+//            ans = max(ans, query(value, root[l2], root[r1 - 1]));
+//        }
+//        if (r1 != n + 1) {
+//            ans = max(ans, query(value, root[l1], root[r2 - 1]));
+//        }
+//        nxt[l1] = r1;
+//        last[r1] = l1;
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    arr.resize(n + 1);
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].first = i;
+//        cin >> arr[i].second;
+//    }
+//    prepare();
+//    cout << compute() << "\n";
+//    return 0;
+//}
\ No newline at end of file

From 7ec30ea7351744df72f60871589373bdf56e293b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Jan 2025 23:23:35 +0800
Subject: [PATCH 0401/1712] modify code

---
 src/class159/Code04_ALO2.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class159/Code04_ALO2.java b/src/class159/Code04_ALO2.java
index a67e63650..97fc84ee7 100644
--- a/src/class159/Code04_ALO2.java
+++ b/src/class159/Code04_ALO2.java
@@ -21,7 +21,7 @@
 //int last[MAXN];
 //int nxt[MAXN];
 //
-//int insert_(int num, int i) {
+//int insert(int num, int i) {
 //    int rt = ++cnt;
 //    tree[rt][0] = tree[i][0];
 //    tree[rt][1] = tree[i][1];
@@ -61,7 +61,7 @@
 //    last[n + 1] = n;
 //    nxt[n + 1] = n + 1;
 //    for (int i = 1; i <= n; i++) {
-//        root[i] = insert_(arr[i].second, root[i - 1]);
+//        root[i] = insert(arr[i].second, root[i - 1]);
 //        last[i] = i - 1;
 //        nxt[i] = i + 1;
 //    }

From 1cbb2c18eb20a0528c9602e9a2508226e9f84708 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Jan 2025 13:58:16 +0800
Subject: [PATCH 0402/1712] modify code

---
 ...xExclusiveOr1.java => Code01_MaxXor1.java} |  4 +--
 ...xExclusiveOr2.java => Code01_MaxXor2.java} |  0
 src/class159/Code03_PathDfnXor1.java          | 26 +++++++++++++++++++
 ...{Code03_Yummy1.java => Code04_Yummy1.java} |  2 +-
 ...{Code03_Yummy2.java => Code04_Yummy2.java} |  0
 .../{Code04_ALO1.java => Code05_ALO1.java}    |  2 +-
 .../{Code04_ALO2.java => Code05_ALO2.java}    |  0
 7 files changed, 30 insertions(+), 4 deletions(-)
 rename src/class159/{Code01_MaxExclusiveOr1.java => Code01_MaxXor1.java} (97%)
 rename src/class159/{Code01_MaxExclusiveOr2.java => Code01_MaxXor2.java} (100%)
 create mode 100644 src/class159/Code03_PathDfnXor1.java
 rename src/class159/{Code03_Yummy1.java => Code04_Yummy1.java} (99%)
 rename src/class159/{Code03_Yummy2.java => Code04_Yummy2.java} (100%)
 rename src/class159/{Code04_ALO1.java => Code05_ALO1.java} (99%)
 rename src/class159/{Code04_ALO2.java => Code05_ALO2.java} (100%)

diff --git a/src/class159/Code01_MaxExclusiveOr1.java b/src/class159/Code01_MaxXor1.java
similarity index 97%
rename from src/class159/Code01_MaxExclusiveOr1.java
rename to src/class159/Code01_MaxXor1.java
index f83b540d7..16c12cf01 100644
--- a/src/class159/Code01_MaxExclusiveOr1.java
+++ b/src/class159/Code01_MaxXor1.java
@@ -6,7 +6,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了所有测试用例
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code01_MaxExclusiveOr2文件就是C++的实现
+// 想通过用C++实现，本节课Code01_MaxXor2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.io.InputStream;
 
-public class Code01_MaxExclusiveOr1 {
+public class Code01_MaxXor1 {
 
 	public static int MAXN = 600001;
 
diff --git a/src/class159/Code01_MaxExclusiveOr2.java b/src/class159/Code01_MaxXor2.java
similarity index 100%
rename from src/class159/Code01_MaxExclusiveOr2.java
rename to src/class159/Code01_MaxXor2.java
diff --git a/src/class159/Code03_PathDfnXor1.java b/src/class159/Code03_PathDfnXor1.java
new file mode 100644
index 000000000..6336002c5
--- /dev/null
+++ b/src/class159/Code03_PathDfnXor1.java
@@ -0,0 +1,26 @@
+package class159;
+
+// 路径和子树的异或，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4592
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code03_PathDfnXor1 {
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class159/Code03_Yummy1.java b/src/class159/Code04_Yummy1.java
similarity index 99%
rename from src/class159/Code03_Yummy1.java
rename to src/class159/Code04_Yummy1.java
index 7d579de24..31ac72adb 100644
--- a/src/class159/Code03_Yummy1.java
+++ b/src/class159/Code04_Yummy1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_Yummy1 {
+public class Code04_Yummy1 {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class159/Code03_Yummy2.java b/src/class159/Code04_Yummy2.java
similarity index 100%
rename from src/class159/Code03_Yummy2.java
rename to src/class159/Code04_Yummy2.java
diff --git a/src/class159/Code04_ALO1.java b/src/class159/Code05_ALO1.java
similarity index 99%
rename from src/class159/Code04_ALO1.java
rename to src/class159/Code05_ALO1.java
index fdc30b6bd..f55e7911a 100644
--- a/src/class159/Code04_ALO1.java
+++ b/src/class159/Code05_ALO1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_ALO1 {
+public class Code05_ALO1 {
 
 	public static int MAXN = 50002;
 
diff --git a/src/class159/Code04_ALO2.java b/src/class159/Code05_ALO2.java
similarity index 100%
rename from src/class159/Code04_ALO2.java
rename to src/class159/Code05_ALO2.java

From ce271e9b67ffdfe1dcc416c83a36bdf11db50f80 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Jan 2025 15:11:47 +0800
Subject: [PATCH 0403/1712] modify code

---
 src/class159/Code01_MaxXor1.java     |   2 +-
 src/class159/Code03_PathDfnXor1.java | 180 ++++++++++++++++++++++++++-
 src/class159/Code03_PathDfnXor2.java | 153 +++++++++++++++++++++++
 3 files changed, 332 insertions(+), 3 deletions(-)
 create mode 100644 src/class159/Code03_PathDfnXor2.java

diff --git a/src/class159/Code01_MaxXor1.java b/src/class159/Code01_MaxXor1.java
index 16c12cf01..4f8996ade 100644
--- a/src/class159/Code01_MaxXor1.java
+++ b/src/class159/Code01_MaxXor1.java
@@ -4,7 +4,7 @@
 // 因为练的就是可持久化前缀树，所以就用在线算法
 // 测试链接 : https://www.luogu.com.cn/problem/P4735
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是通过不了所有测试用例
+// java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code01_MaxXor2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
diff --git a/src/class159/Code03_PathDfnXor1.java b/src/class159/Code03_PathDfnXor1.java
index 6336002c5..4ca07794f 100644
--- a/src/class159/Code03_PathDfnXor1.java
+++ b/src/class159/Code03_PathDfnXor1.java
@@ -2,7 +2,10 @@
 
 // 路径和子树的异或，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4592
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// java实现的逻辑一定是正确的，但是通过不了
+// 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code03_PathDfnXor2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -13,11 +16,184 @@
 
 public class Code03_PathDfnXor1 {
 
+	public static int MAXN = 100001;
+
+	public static int MAXT = MAXN * 62;
+
+	public static int MAXH = 16;
+
+	public static int BIT = 29;
+
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg;
+
+	public static int[] deep = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[][] stjump = new int[MAXN][MAXH];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int cntd;
+
+	public static int[] root1 = new int[MAXN];
+
+	public static int[] root2 = new int[MAXN];
+
+	public static int[][] tree = new int[MAXT][2];
+
+	public static int[] pass = new int[MAXT];
+
+	public static int cntt;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int insert(int num, int i) {
+		int rt = ++cntt;
+		tree[rt][0] = tree[i][0];
+		tree[rt][1] = tree[i][1];
+		pass[rt] = pass[i] + 1;
+		for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+			path = (num >> b) & 1;
+			i = tree[i][path];
+			cur = ++cntt;
+			tree[cur][0] = tree[i][0];
+			tree[cur][1] = tree[i][1];
+			pass[cur] = pass[i] + 1;
+			tree[pre][path] = cur;
+		}
+		return rt;
+	}
+
+	public static int query(int num, int u, int v) {
+		int ans = 0;
+		for (int b = BIT, path, best; b >= 0; b--) {
+			path = (num >> b) & 1;
+			best = path ^ 1;
+			if (pass[tree[v][best]] > pass[tree[u][best]]) {
+				ans += 1 << b;
+				u = tree[u][best];
+				v = tree[v][best];
+			} else {
+				u = tree[u][path];
+				v = tree[v][path];
+			}
+		}
+		return ans;
+	}
+
+	// 按道理说dfs1应该改成迭代版，防止递归爆栈
+	// 不过本题给定的空间很小，java版怎么也无法通过，索性不改了
+	// 有兴趣的同学可以看一下，讲解118，详解了树上dfs从递归版改迭代版
+	public static void dfs1(int u, int fa) {
+		deep[u] = deep[fa] + 1;
+		size[u] = 1;
+		stjump[u][0] = fa;
+		dfn[u] = ++cntd;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			if (to[ei] != fa) {
+				dfs1(to[ei], u);
+			}
+		}
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			if (to[ei] != fa) {
+				size[u] += size[to[ei]];
+			}
+		}
+	}
+
+	// 按道理说dfs2应该改成迭代版，防止递归爆栈
+	// 不过本题给定的空间很小，java版怎么也无法通过，索性不改了
+	// 有兴趣的同学可以看一下，讲解118，详解了树上dfs从递归版改迭代版
+	public static void dfs2(int u, int fa) {
+		root1[dfn[u]] = insert(arr[u], root1[dfn[u] - 1]);
+		root2[u] = insert(arr[u], root2[fa]);
+		for (int ei = head[u]; ei > 0; ei = next[ei]) {
+			if (to[ei] != fa) {
+				dfs2(to[ei], u);
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (deep[a] < deep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (deep[stjump[a][p]] >= deep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs1(1, 0);
+		dfs2(1, 0);
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			in.nextToken();
+			y = (int) in.nval;
+			if (op == 1) {
+				out.println(query(y, root1[dfn[x] - 1], root1[dfn[x] + size[x] - 1]));
+			} else {
+				in.nextToken();
+				z = (int) in.nval;
+				int lcafa = stjump[lca(x, y)][0];
+				int ans = Math.max(query(z, root2[lcafa], root2[x]), query(z, root2[lcafa], root2[y]));
+				out.println(ans);
+			}
+		}
 		out.flush();
 		out.close();
 		br.close();
diff --git a/src/class159/Code03_PathDfnXor2.java b/src/class159/Code03_PathDfnXor2.java
new file mode 100644
index 000000000..05262f34f
--- /dev/null
+++ b/src/class159/Code03_PathDfnXor2.java
@@ -0,0 +1,153 @@
+package class159;
+
+// 路径和子树的异或，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4592
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXT = MAXN * 62;
+//const int MAXH = 16;
+//const int BIT = 29;
+//int n, m;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int deep[MAXN];
+//int size[MAXN];
+//int stjump[MAXN][MAXH];
+//int dfn[MAXN];
+//int cntd;
+//
+//int root1[MAXN];
+//int root2[MAXN];
+//int tree[MAXT][2];
+//int pass[MAXT];
+//int cntt;
+//
+//void addEdge(int u, int v) {
+//	nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int insert(int num, int i) {
+//    int rt = ++cntt;
+//    tree[rt][0] = tree[i][0];
+//    tree[rt][1] = tree[i][1];
+//    pass[rt] = pass[i] + 1;
+//    for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+//        path = (num >> b) & 1;
+//        i = tree[i][path];
+//        cur = ++cntt;
+//        tree[cur][0] = tree[i][0];
+//        tree[cur][1] = tree[i][1];
+//        pass[cur] = pass[i] + 1;
+//        tree[pre][path] = cur;
+//    }
+//    return rt;
+//}
+//
+//int query(int num, int u, int v) {
+//    int ans = 0;
+//    for (int b = BIT, path, best; b >= 0; b--) {
+//        path = (num >> b) & 1;
+//        best = path ^ 1;
+//        if (pass[tree[v][best]] > pass[tree[u][best]]) {
+//            ans += (1 << b);
+//            u = tree[u][best];
+//            v = tree[v][best];
+//        } else {
+//            u = tree[u][path];
+//            v = tree[v][path];
+//        }
+//    }
+//    return ans;
+//}
+//
+//void dfs1(int u, int fa) {
+//    deep[u] = deep[fa] + 1;
+//    size[u] = 1;
+//    stjump[u][0] = fa;
+//    dfn[u] = ++cntd;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+//        if (to[ei] != fa) {
+//            dfs1(to[ei], u);
+//        }
+//    }
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+//        if (to[ei] != fa) {
+//            size[u] += size[to[ei]];
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int fa) {
+//    root1[dfn[u]] = insert(arr[u], root1[dfn[u] - 1]);
+//    root2[u] = insert(arr[u], root2[fa]);
+//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+//        if (to[ei] != fa) {
+//            dfs2(to[ei], u);
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    if (deep[a] < deep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (deep[stjump[a][p]] >= deep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 0);
+//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 1) {
+//            cout << query(y, root1[dfn[x] - 1], root1[dfn[x] + size[x] - 1]) << '\n';
+//        } else {
+//            cin >> z;
+//            int lcafa = stjump[lca(x, y)][0];
+//            int ans = max(query(z, root2[lcafa], root2[x]), query(z, root2[lcafa], root2[y]));
+//            cout << ans << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 7b68d489f13d57d50840ba190e543367cbb286d4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Jan 2025 15:18:08 +0800
Subject: [PATCH 0404/1712] modify code

---
 src/class159/Code03_PathDfnXor1.java | 13 +++++--------
 src/class159/Code03_PathDfnXor2.java | 15 ++++++---------
 2 files changed, 11 insertions(+), 17 deletions(-)

diff --git a/src/class159/Code03_PathDfnXor1.java b/src/class159/Code03_PathDfnXor1.java
index 4ca07794f..3834d411c 100644
--- a/src/class159/Code03_PathDfnXor1.java
+++ b/src/class159/Code03_PathDfnXor1.java
@@ -107,14 +107,11 @@ public static void dfs1(int u, int fa) {
 		for (int p = 1; p < MAXH; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 		}
-		for (int ei = head[u]; ei > 0; ei = next[ei]) {
-			if (to[ei] != fa) {
-				dfs1(to[ei], u);
-			}
-		}
-		for (int ei = head[u]; ei > 0; ei = next[ei]) {
-			if (to[ei] != fa) {
-				size[u] += size[to[ei]];
+		for (int ei = head[u], v; ei > 0; ei = next[ei]) {
+			v = to[ei];
+			if (v != fa) {
+				dfs1(v, u);
+				size[u] += size[v];
 			}
 		}
 	}
diff --git a/src/class159/Code03_PathDfnXor2.java b/src/class159/Code03_PathDfnXor2.java
index 05262f34f..c46b6e010 100644
--- a/src/class159/Code03_PathDfnXor2.java
+++ b/src/class159/Code03_PathDfnXor2.java
@@ -34,7 +34,7 @@
 //int cntt;
 //
 //void addEdge(int u, int v) {
-//	nxt[++cntg] = head[u];
+//    nxt[++cntg] = head[u];
 //    to[cntg] = v;
 //    head[u] = cntg;
 //}
@@ -81,14 +81,11 @@
 //    for (int p = 1; p < MAXH; p++) {
 //        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 //    }
-//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
-//        if (to[ei] != fa) {
-//            dfs1(to[ei], u);
-//        }
-//    }
-//    for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
-//        if (to[ei] != fa) {
-//            size[u] += size[to[ei]];
+//    for (int ei = head[u], v; ei > 0; ei = nxt[ei]) {
+//        v = to[ei];
+//        if (v != fa) {
+//            dfs1(v, u);
+//            size[u] += size[v];
 //        }
 //    }
 //}

From 2ca7a9c5cd0e47568340535d4ea3df79aea157ba Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Jan 2025 17:58:30 +0800
Subject: [PATCH 0405/1712] modify code

---
 src/class159/Code03_PathDfnXor1.java   |   6 +-
 src/class159/Code03_PathDfnXor2.java   |   6 +-
 src/class159/Code05_XorOperation1.java | 131 +++++++++++++++++++++++++
 src/class159/Code05_XorOperation2.java |  97 ++++++++++++++++++
 4 files changed, 234 insertions(+), 6 deletions(-)
 create mode 100644 src/class159/Code05_XorOperation1.java
 create mode 100644 src/class159/Code05_XorOperation2.java

diff --git a/src/class159/Code03_PathDfnXor1.java b/src/class159/Code03_PathDfnXor1.java
index 3834d411c..bb60b109d 100644
--- a/src/class159/Code03_PathDfnXor1.java
+++ b/src/class159/Code03_PathDfnXor1.java
@@ -34,7 +34,7 @@ public class Code03_PathDfnXor1 {
 
 	public static int[] to = new int[MAXN << 1];
 
-	public static int cntg;
+	public static int cntg = 0;
 
 	public static int[] deep = new int[MAXN];
 
@@ -44,7 +44,7 @@ public class Code03_PathDfnXor1 {
 
 	public static int[] dfn = new int[MAXN];
 
-	public static int cntd;
+	public static int cntd = 0;
 
 	public static int[] root1 = new int[MAXN];
 
@@ -54,7 +54,7 @@ public class Code03_PathDfnXor1 {
 
 	public static int[] pass = new int[MAXT];
 
-	public static int cntt;
+	public static int cntt = 0;
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
diff --git a/src/class159/Code03_PathDfnXor2.java b/src/class159/Code03_PathDfnXor2.java
index c46b6e010..82f4ec7c7 100644
--- a/src/class159/Code03_PathDfnXor2.java
+++ b/src/class159/Code03_PathDfnXor2.java
@@ -19,19 +19,19 @@
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
-//int cntg;
+//int cntg = 0;
 //
 //int deep[MAXN];
 //int size[MAXN];
 //int stjump[MAXN][MAXH];
 //int dfn[MAXN];
-//int cntd;
+//int cntd = 0;
 //
 //int root1[MAXN];
 //int root2[MAXN];
 //int tree[MAXT][2];
 //int pass[MAXT];
-//int cntt;
+//int cntt = 0;
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
diff --git a/src/class159/Code05_XorOperation1.java b/src/class159/Code05_XorOperation1.java
new file mode 100644
index 000000000..c2a1bec51
--- /dev/null
+++ b/src/class159/Code05_XorOperation1.java
@@ -0,0 +1,131 @@
+package class159;
+
+// 异或运算，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5795
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code05_XorOperation1 {
+
+	public static int MAXN = 300001;
+
+	public static int MAXT = MAXN * 32;
+
+	public static int BIT = 30;
+
+	public static int n, m, p;
+
+	public static int[] x = new int[MAXN];
+
+	public static int[] y = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[][] tree = new int[MAXT][2];
+
+	public static int[] pass = new int[MAXT];
+
+	public static int cnt = 0;
+
+	public static int[][] rtpath = new int[MAXN][2];
+
+	public static int insert(int num, int i) {
+		int rt = ++cnt;
+		tree[rt][0] = tree[i][0];
+		tree[rt][1] = tree[i][1];
+		pass[rt] = pass[i] + 1;
+		for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+			path = (num >> b) & 1;
+			i = tree[i][path];
+			cur = ++cnt;
+			tree[cur][0] = tree[i][0];
+			tree[cur][1] = tree[i][1];
+			pass[cur] = pass[i] + 1;
+			tree[pre][path] = cur;
+		}
+		return rt;
+	}
+
+	public static int xorMaxKth(int xl, int xr, int yl, int yr, int k) {
+		for (int i = xl; i <= xr; i++) {
+			rtpath[i][0] = root[yl - 1];
+			rtpath[i][1] = root[yr];
+		}
+		int ans = 0;
+		for (int b = BIT, path, best, sum; b >= 0; b--) {
+			sum = 0;
+			for (int i = xl; i <= xr; i++) {
+				path = (x[i] >> b) & 1;
+				best = path ^ 1;
+				sum += pass[tree[rtpath[i][1]][best]] - pass[tree[rtpath[i][0]][best]];
+			}
+			for (int i = xl; i <= xr; i++) {
+				path = (x[i] >> b) & 1;
+				best = path ^ 1;
+				if (sum >= k) {
+					rtpath[i][0] = tree[rtpath[i][0]][best];
+					rtpath[i][1] = tree[rtpath[i][1]][best];
+				} else {
+					rtpath[i][0] = tree[rtpath[i][0]][path];
+					rtpath[i][1] = tree[rtpath[i][1]][path];
+				}
+			}
+			if (sum >= k) {
+				ans += 1 << b;
+			} else {
+				k -= sum;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= m; i++) {
+			root[i] = insert(y[i], root[i - 1]);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			x[i] = (int) in.nval;
+		}
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			y[i] = (int) in.nval;
+		}
+		prepare();
+		in.nextToken();
+		p = (int) in.nval;
+		for (int i = 1, xl, xr, yl, yr, k; i <= p; i++) {
+			in.nextToken();
+			xl = (int) in.nval;
+			in.nextToken();
+			xr = (int) in.nval;
+			in.nextToken();
+			yl = (int) in.nval;
+			in.nextToken();
+			yr = (int) in.nval;
+			in.nextToken();
+			k = (int) in.nval;
+			out.println(xorMaxKth(xl, xr, yl, yr, k));
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class159/Code05_XorOperation2.java b/src/class159/Code05_XorOperation2.java
new file mode 100644
index 000000000..5a686da3f
--- /dev/null
+++ b/src/class159/Code05_XorOperation2.java
@@ -0,0 +1,97 @@
+package class159;
+
+// 异或运算，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5795
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//const int MAXT = MAXN * 32;
+//const int BIT = 30;
+//int n, m, p;
+//int x[MAXN];
+//int y[MAXN];
+//int root[MAXN];
+//int tree[MAXT][2];
+//int pass[MAXT];
+//int cnt = 0;
+//int rtpath[MAXN][2];
+//
+//int insert(int num, int i) {
+//    int rt = ++cnt;
+//    tree[rt][0] = tree[i][0];
+//    tree[rt][1] = tree[i][1];
+//    pass[rt] = pass[i] + 1;
+//    for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+//        path = (num >> b) & 1;
+//        i = tree[i][path];
+//        cur = ++cnt;
+//        tree[cur][0] = tree[i][0];
+//        tree[cur][1] = tree[i][1];
+//        pass[cur] = pass[i] + 1;
+//        tree[pre][path] = cur;
+//    }
+//    return rt;
+//}
+//
+//int xorMaxKth(int xl, int xr, int yl, int yr, int k) {
+//    for (int i = xl; i <= xr; i++) {
+//        rtpath[i][0] = root[yl - 1];
+//        rtpath[i][1] = root[yr];
+//    }
+//    int ans = 0;
+//    for (int b = BIT, path, best, sum; b >= 0; b--) {
+//        sum = 0;
+//        for (int i = xl; i <= xr; i++) {
+//            path = (x[i] >> b) & 1;
+//            best = path ^ 1;
+//            sum += pass[tree[rtpath[i][1]][best]] - pass[tree[rtpath[i][0]][best]];
+//        }
+//        for (int i = xl; i <= xr; i++) {
+//            path = (x[i] >> b) & 1;
+//            best = path ^ 1;
+//            if (sum >= k) {
+//                rtpath[i][0] = tree[rtpath[i][0]][best];
+//                rtpath[i][1] = tree[rtpath[i][1]][best];
+//            } else {
+//                rtpath[i][0] = tree[rtpath[i][0]][path];
+//                rtpath[i][1] = tree[rtpath[i][1]][path];
+//            }
+//        }
+//        if (sum >= k) {
+//            ans += 1 << b;
+//        } else {
+//            k -= sum;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= m; i++) {
+//        root[i] = insert(y[i], root[i - 1]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> x[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> y[i];
+//    }
+//    prepare();
+//    cin >> p;
+//    for (int i = 1, xl, xr, yl, yr, k; i <= p; i++) {
+//        cin >> xl >> xr >> yl >> yr >> k;
+//        cout << xorMaxKth(xl, xr, yl, yr, k) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 5aaf935f620442a9c8f89c5d36d199aa2a06e8b1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Jan 2025 17:59:01 +0800
Subject: [PATCH 0406/1712] modify code

---
 .../{Code05_XorOperation1.java => Code06_XorOperation1.java}    | 2 +-
 .../{Code05_XorOperation2.java => Code06_XorOperation2.java}    | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class159/{Code05_XorOperation1.java => Code06_XorOperation1.java} (98%)
 rename src/class159/{Code05_XorOperation2.java => Code06_XorOperation2.java} (100%)

diff --git a/src/class159/Code05_XorOperation1.java b/src/class159/Code06_XorOperation1.java
similarity index 98%
rename from src/class159/Code05_XorOperation1.java
rename to src/class159/Code06_XorOperation1.java
index c2a1bec51..1ecc744cd 100644
--- a/src/class159/Code05_XorOperation1.java
+++ b/src/class159/Code06_XorOperation1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_XorOperation1 {
+public class Code06_XorOperation1 {
 
 	public static int MAXN = 300001;
 
diff --git a/src/class159/Code05_XorOperation2.java b/src/class159/Code06_XorOperation2.java
similarity index 100%
rename from src/class159/Code05_XorOperation2.java
rename to src/class159/Code06_XorOperation2.java

From 5599c087720f6138f7ad0c6aae5888cc6f03e381 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Jan 2025 18:00:18 +0800
Subject: [PATCH 0407/1712] modify code

---
 src/class159/Code06_XorOperation1.java | 4 ++--
 src/class159/Code06_XorOperation2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class159/Code06_XorOperation1.java b/src/class159/Code06_XorOperation1.java
index 1ecc744cd..2e392df8a 100644
--- a/src/class159/Code06_XorOperation1.java
+++ b/src/class159/Code06_XorOperation1.java
@@ -52,7 +52,7 @@ public static int insert(int num, int i) {
 		return rt;
 	}
 
-	public static int xorMaxKth(int xl, int xr, int yl, int yr, int k) {
+	public static int maxKth(int xl, int xr, int yl, int yr, int k) {
 		for (int i = xl; i <= xr; i++) {
 			rtpath[i][0] = root[yl - 1];
 			rtpath[i][1] = root[yr];
@@ -121,7 +121,7 @@ public static void main(String[] args) throws IOException {
 			yr = (int) in.nval;
 			in.nextToken();
 			k = (int) in.nval;
-			out.println(xorMaxKth(xl, xr, yl, yr, k));
+			out.println(maxKth(xl, xr, yl, yr, k));
 		}
 		out.flush();
 		out.close();
diff --git a/src/class159/Code06_XorOperation2.java b/src/class159/Code06_XorOperation2.java
index 5a686da3f..a94d2f92d 100644
--- a/src/class159/Code06_XorOperation2.java
+++ b/src/class159/Code06_XorOperation2.java
@@ -38,7 +38,7 @@
 //    return rt;
 //}
 //
-//int xorMaxKth(int xl, int xr, int yl, int yr, int k) {
+//int maxKth(int xl, int xr, int yl, int yr, int k) {
 //    for (int i = xl; i <= xr; i++) {
 //        rtpath[i][0] = root[yl - 1];
 //        rtpath[i][1] = root[yr];
@@ -91,7 +91,7 @@
 //    cin >> p;
 //    for (int i = 1, xl, xr, yl, yr, k; i <= p; i++) {
 //        cin >> xl >> xr >> yl >> yr >> k;
-//        cout << xorMaxKth(xl, xr, yl, yr, k) << "\n";
+//        cout << maxKth(xl, xr, yl, yr, k) << "\n";
 //    }
 //    return 0;
 //}
\ No newline at end of file

From fd7abd6811749d71168088b1130a96fa2ab15dce Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 22 Jan 2025 11:45:32 +0800
Subject: [PATCH 0408/1712] modify code

---
 src/class159/Code06_XorOperation1.java | 16 ++++++++--------
 src/class159/Code06_XorOperation2.java | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/class159/Code06_XorOperation1.java b/src/class159/Code06_XorOperation1.java
index 2e392df8a..0c52b8341 100644
--- a/src/class159/Code06_XorOperation1.java
+++ b/src/class159/Code06_XorOperation1.java
@@ -33,7 +33,7 @@ public class Code06_XorOperation1 {
 
 	public static int cnt = 0;
 
-	public static int[][] rtpath = new int[MAXN][2];
+	public static int[][] xroad = new int[MAXN][2];
 
 	public static int insert(int num, int i) {
 		int rt = ++cnt;
@@ -54,8 +54,8 @@ public static int insert(int num, int i) {
 
 	public static int maxKth(int xl, int xr, int yl, int yr, int k) {
 		for (int i = xl; i <= xr; i++) {
-			rtpath[i][0] = root[yl - 1];
-			rtpath[i][1] = root[yr];
+			xroad[i][0] = root[yl - 1];
+			xroad[i][1] = root[yr];
 		}
 		int ans = 0;
 		for (int b = BIT, path, best, sum; b >= 0; b--) {
@@ -63,17 +63,17 @@ public static int maxKth(int xl, int xr, int yl, int yr, int k) {
 			for (int i = xl; i <= xr; i++) {
 				path = (x[i] >> b) & 1;
 				best = path ^ 1;
-				sum += pass[tree[rtpath[i][1]][best]] - pass[tree[rtpath[i][0]][best]];
+				sum += pass[tree[xroad[i][1]][best]] - pass[tree[xroad[i][0]][best]];
 			}
 			for (int i = xl; i <= xr; i++) {
 				path = (x[i] >> b) & 1;
 				best = path ^ 1;
 				if (sum >= k) {
-					rtpath[i][0] = tree[rtpath[i][0]][best];
-					rtpath[i][1] = tree[rtpath[i][1]][best];
+					xroad[i][0] = tree[xroad[i][0]][best];
+					xroad[i][1] = tree[xroad[i][1]][best];
 				} else {
-					rtpath[i][0] = tree[rtpath[i][0]][path];
-					rtpath[i][1] = tree[rtpath[i][1]][path];
+					xroad[i][0] = tree[xroad[i][0]][path];
+					xroad[i][1] = tree[xroad[i][1]][path];
 				}
 			}
 			if (sum >= k) {
diff --git a/src/class159/Code06_XorOperation2.java b/src/class159/Code06_XorOperation2.java
index a94d2f92d..f1754da3b 100644
--- a/src/class159/Code06_XorOperation2.java
+++ b/src/class159/Code06_XorOperation2.java
@@ -19,7 +19,7 @@
 //int tree[MAXT][2];
 //int pass[MAXT];
 //int cnt = 0;
-//int rtpath[MAXN][2];
+//int xroad[MAXN][2];
 //
 //int insert(int num, int i) {
 //    int rt = ++cnt;
@@ -40,8 +40,8 @@
 //
 //int maxKth(int xl, int xr, int yl, int yr, int k) {
 //    for (int i = xl; i <= xr; i++) {
-//        rtpath[i][0] = root[yl - 1];
-//        rtpath[i][1] = root[yr];
+//        xroad[i][0] = root[yl - 1];
+//        xroad[i][1] = root[yr];
 //    }
 //    int ans = 0;
 //    for (int b = BIT, path, best, sum; b >= 0; b--) {
@@ -49,17 +49,17 @@
 //        for (int i = xl; i <= xr; i++) {
 //            path = (x[i] >> b) & 1;
 //            best = path ^ 1;
-//            sum += pass[tree[rtpath[i][1]][best]] - pass[tree[rtpath[i][0]][best]];
+//            sum += pass[tree[xroad[i][1]][best]] - pass[tree[xroad[i][0]][best]];
 //        }
 //        for (int i = xl; i <= xr; i++) {
 //            path = (x[i] >> b) & 1;
 //            best = path ^ 1;
 //            if (sum >= k) {
-//                rtpath[i][0] = tree[rtpath[i][0]][best];
-//                rtpath[i][1] = tree[rtpath[i][1]][best];
+//                xroad[i][0] = tree[xroad[i][0]][best];
+//                xroad[i][1] = tree[xroad[i][1]][best];
 //            } else {
-//                rtpath[i][0] = tree[rtpath[i][0]][path];
-//                rtpath[i][1] = tree[rtpath[i][1]][path];
+//                xroad[i][0] = tree[xroad[i][0]][path];
+//                xroad[i][1] = tree[xroad[i][1]][path];
 //            }
 //        }
 //        if (sum >= k) {

From 5d361988f2a47a1fd94646696fdad09feaddc184 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 22 Jan 2025 12:00:56 +0800
Subject: [PATCH 0409/1712] modify code

---
 src/class159/Code01_MaxXor1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class159/Code01_MaxXor1.java b/src/class159/Code01_MaxXor1.java
index 4f8996ade..a29d58e9b 100644
--- a/src/class159/Code01_MaxXor1.java
+++ b/src/class159/Code01_MaxXor1.java
@@ -4,7 +4,7 @@
 // 因为练的就是可持久化前缀树，所以就用在线算法
 // 测试链接 : https://www.luogu.com.cn/problem/P4735
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是通过不了
+// java实现的逻辑一定是正确的，但是有一些测试用例通过不了
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code01_MaxXor2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试

From b06ef9c3d56609ea9ab9850f952ca692bd7a01b9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 22 Jan 2025 18:52:12 +0800
Subject: [PATCH 0410/1712] modify code

---
 src/class159/Code07_Friends1.java | 178 ++++++++++++++++++++++++++++++
 src/class159/Code07_Friends3.java | 160 +++++++++++++++++++++++++++
 2 files changed, 338 insertions(+)
 create mode 100644 src/class159/Code07_Friends1.java
 create mode 100644 src/class159/Code07_Friends3.java

diff --git a/src/class159/Code07_Friends1.java b/src/class159/Code07_Friends1.java
new file mode 100644
index 000000000..495f8bfd4
--- /dev/null
+++ b/src/class159/Code07_Friends1.java
@@ -0,0 +1,178 @@
+package class159;
+
+// 前m大两两异或值的和，java版
+// 本题只用到了经典前缀树，没有用到可持久化前缀树
+// 测试链接 : https://www.luogu.com.cn/problem/CF241B
+// 测试链接 : https://codeforces.com/problemset/problem/241/B
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code07_Friends1 {
+
+	public static int MAXN = 50001;
+
+	public static int MAXT = MAXN * 20;
+
+	public static int BIT = 30;
+
+	public static int MOD = 1000000007;
+
+	public static int INV2 = 500000004;
+
+	public static int n, k;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[][] tree = new int[MAXT][2];
+
+	public static int[] pass = new int[MAXT];
+
+	public static int cnt = 1;
+
+	public static int[][] sum = new int[MAXT][BIT + 1];
+
+	public static void insert(int num) {
+		int cur = 1;
+		pass[cur]++;
+		for (int b = BIT, path; b >= 0; b--) {
+			path = (num >> b) & 1;
+			if (tree[cur][path] == 0) {
+				tree[cur][path] = ++cnt;
+			}
+			cur = tree[cur][path];
+			pass[cur]++;
+		}
+	}
+
+	public static void dfs(int u, int h, int s) {
+		if (u == 0) {
+			return;
+		}
+		if (h == 0) {
+			for (int i = 0; i <= BIT; i++) {
+				if (((s >> i) & 1) == 1) {
+					sum[u][i] = pass[u];
+				}
+			}
+		} else {
+			dfs(tree[u][0], h - 1, s);
+			dfs(tree[u][1], h - 1, s | (1 << (h - 1)));
+			for (int i = 0; i <= BIT; i++) {
+				sum[u][i] = sum[tree[u][0]][i] + sum[tree[u][1]][i];
+			}
+		}
+	}
+
+	public static long moreThan(int x) {
+		long sum = 0;
+		for (int i = 1, num, cur; i <= n; i++) {
+			num = arr[i];
+			cur = 1;
+			for (int b = BIT, path, best, xpath; b >= 0; b--) {
+				path = (num >> b) & 1;
+				best = path ^ 1;
+				xpath = (x >> b) & 1;
+				if (xpath == 0) {
+					sum += pass[tree[cur][best]];
+					cur = tree[cur][path];
+				} else {
+					cur = tree[cur][best];
+				}
+				if (cur == 0) {
+					break;
+				}
+			}
+			sum += pass[cur];
+		}
+		if (x == 0) {
+			sum -= n;
+		}
+		return sum / 2;
+	}
+
+	public static int maxKth() {
+		int l = 0, r = 1 << BIT, m;
+		int ans = 0;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (moreThan(m) >= k) {
+				ans = m;
+				l = m + 1;
+			} else {
+				r = m - 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			insert(arr[i]);
+		}
+		dfs(tree[1][0], BIT, 0);
+		dfs(tree[1][1], BIT, 1 << BIT);
+	}
+
+	public static long compute() {
+		int kth = maxKth();
+		long ans = 0;
+		for (int i = 1, num, cur; i <= n; i++) {
+			num = arr[i];
+			cur = 1;
+			for (int b = BIT, path, best, kpath; b >= 0; b--) {
+				path = (num >> b) & 1;
+				best = path ^ 1;
+				kpath = (kth >> b) & 1;
+				if (kpath == 0) {
+					for (int j = 0; j <= BIT; j++) {
+						if (((num >> j) & 1) == 1) {
+							ans = (ans + ((long) pass[tree[cur][best]] - sum[tree[cur][best]][j]) * (1L << j)) % MOD;
+						} else {
+							ans = (ans + (long) sum[tree[cur][best]][j] * (1L << j)) % MOD;
+						}
+					}
+					cur = tree[cur][path];
+				} else {
+					cur = tree[cur][best];
+				}
+				if (cur == 0) {
+					break;
+				}
+			}
+			ans = (ans + (long) pass[cur] * kth) % MOD;
+		}
+		ans = ans * INV2 % MOD;
+		ans = ((ans - (moreThan(kth) - k) * kth % MOD) % MOD + MOD) % MOD;
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		if (k == 0) {
+			out.println(0);
+		} else {
+			prepare();
+			out.println(compute());
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class159/Code07_Friends3.java b/src/class159/Code07_Friends3.java
new file mode 100644
index 000000000..07e3ff987
--- /dev/null
+++ b/src/class159/Code07_Friends3.java
@@ -0,0 +1,160 @@
+package class159;
+
+// 前m大两两异或值的和，C++版
+// 本题只用到了经典前缀树，没有用到可持久化前缀树
+// 测试链接 : https://www.luogu.com.cn/problem/CF241B
+// 测试链接 : https://codeforces.com/problemset/problem/241/B
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50001;
+//const int MAXT = MAXN * 20;
+//const int BIT = 30;
+//const int MOD = 1000000007;
+//const int INV2 = 500000004;
+//int n, k;
+//int arr[MAXN];
+//int tree[MAXT][2];
+//int pass[MAXT];
+//int cnt = 1;
+//int sum[MAXT][BIT + 1];
+//
+//void insert(int num) {
+//    int cur = 1;
+//    pass[cur]++;
+//    for (int b = BIT; b >= 0; b--) {
+//        int path = (num >> b) & 1;
+//        if (!tree[cur][path]) {
+//        	tree[cur][path] = ++cnt;
+//        }
+//        cur = tree[cur][path];
+//        pass[cur]++;
+//    }
+//}
+//
+//void dfs(int u, int h, int s) {
+//    if (!u) {
+//        return;
+//    }
+//    if (!h) {
+//        for (int i = 0; i <= BIT; i++) {
+//            if ((s >> i) & 1) {
+//            	sum[u][i] = pass[u];
+//            }
+//        }
+//    } else {
+//        dfs(tree[u][0], h - 1, s);
+//        dfs(tree[u][1], h - 1, s | (1 << (h - 1)));
+//        for (int i = 0; i <= BIT; i++) {
+//        	sum[u][i] = sum[tree[u][0]][i] + sum[tree[u][1]][i];
+//        }
+//    }
+//}
+//
+//long long moreThan(int x) {
+//    long long sum = 0;
+//    for (int i = 1; i <= n; i++) {
+//        int num = arr[i];
+//        int cur = 1;
+//        for (int b = BIT; b >= 0; b--) {
+//            int path = (num >> b) & 1;
+//            int best = path ^ 1;
+//            int xpath = (x >> b) & 1;
+//            if (!xpath) {
+//                sum += pass[tree[cur][best]];
+//                cur = tree[cur][path];
+//            } else {
+//                cur = tree[cur][best];
+//            }
+//            if (!cur) {
+//                break;
+//            }
+//        }
+//        if (cur) {
+//            sum += pass[cur];
+//        }
+//    }
+//    if (!x) {
+//        sum -= n;
+//    }
+//    return sum / 2;
+//}
+//
+//int maxKth() {
+//    int l = 0, r = 1 << BIT, ans = 0;
+//    while (l <= r) {
+//        int m = (l + r) >> 1;
+//        if (moreThan(m) >= k) {
+//            ans = m;
+//            l = m + 1;
+//        } else {
+//            r = m - 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        insert(arr[i]);
+//    }
+//    dfs(tree[1][0], BIT, 0);
+//    dfs(tree[1][1], BIT, 1 << BIT);
+//}
+//
+//long long compute() {
+//    int kth = maxKth();
+//    long long ans = 0;
+//    for (int i = 1; i <= n; i++) {
+//        int num = arr[i];
+//        int cur = 1;
+//        for (int b = BIT; b >= 0; b--) {
+//            int path = (num >> b) & 1;
+//            int best = path ^ 1;
+//            int kpath = (kth >> b) & 1;
+//            if (!kpath) {
+//                if (tree[cur][best]) {
+//                    for (int j = 0; j <= BIT; j++) {
+//                        if ((num >> j) & 1) {
+//                            ans = (ans + ((long long)pass[tree[cur][best]] - sum[tree[cur][best]][j]) * (1LL << j)) % MOD;
+//                        } else {
+//                            ans = (ans + ((long long)sum[tree[cur][best]][j]) * (1LL << j)) % MOD;
+//                        }
+//                    }
+//                }
+//                cur = tree[cur][path];
+//            } else {
+//                cur = tree[cur][best];
+//            }
+//            if (!cur) {
+//                break;
+//            }
+//        }
+//        if (cur) {
+//            ans = (ans + (long long)pass[cur] * kth) % MOD;
+//        }
+//    }
+//    ans = ans * INV2 % MOD;    
+//    ans = ((ans - ((moreThan(kth) - k) * kth) % MOD) % MOD + MOD) % MOD;
+//    return ans;
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    if (!k) {
+//        cout << 0 << "\n";
+//    } else {
+//        prepare();
+//        cout << compute() << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 11c9c0d4ba1f805a475eee9434ec0ed2de372c38 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 22 Jan 2025 18:56:06 +0800
Subject: [PATCH 0411/1712] modify code

---
 src/class159/{Code07_Friends3.java => Code07_Friends2.java} | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/class159/{Code07_Friends3.java => Code07_Friends2.java} (100%)

diff --git a/src/class159/Code07_Friends3.java b/src/class159/Code07_Friends2.java
similarity index 100%
rename from src/class159/Code07_Friends3.java
rename to src/class159/Code07_Friends2.java

From a1790359d9cf7684554695aab0dcb62603bd14d4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 26 Jan 2025 17:42:53 +0800
Subject: [PATCH 0412/1712] modify code

---
 src/class159/Code01_MaxXor1.java       |  9 ++++++++-
 src/class159/Code01_MaxXor2.java       |  9 ++++++++-
 src/class159/Code02_StringTree1.java   |  5 +++++
 src/class159/Code02_StringTree2.java   |  5 +++++
 src/class159/Code03_PathDfnXor1.java   |  6 ++++++
 src/class159/Code03_PathDfnXor2.java   |  6 ++++++
 src/class159/Code04_Yummy1.java        | 17 +++++++++++++----
 src/class159/Code04_Yummy2.java        |  5 +++++
 src/class159/Code05_ALO1.java          |  6 ++++++
 src/class159/Code05_ALO2.java          |  6 ++++++
 src/class159/Code06_XorOperation1.java |  8 ++++++++
 src/class159/Code06_XorOperation2.java |  8 ++++++++
 src/class159/Code07_Friends1.java      |  7 +++++++
 src/class159/Code07_Friends2.java      |  7 +++++++
 14 files changed, 98 insertions(+), 6 deletions(-)

diff --git a/src/class159/Code01_MaxXor1.java b/src/class159/Code01_MaxXor1.java
index a29d58e9b..a7b3a4399 100644
--- a/src/class159/Code01_MaxXor1.java
+++ b/src/class159/Code01_MaxXor1.java
@@ -1,7 +1,14 @@
 package class159;
 
 // 最大异或和，java版
-// 因为练的就是可持久化前缀树，所以就用在线算法
+// 非负序列arr的初始长度为n，一共有m条操作，每条操作是如下两种类型中的一种
+// A x     : arr的末尾增加数字x，arr的长度n也增加1
+// Q l r x : l~r这些位置中，选一个位置p，现在希望
+//           arr[p] ^ arr[p+1] ^ .. ^ arr[n] ^ x 这个值最大
+//           打印这个最大值
+// 1 <= n、m <= 3 * 10^5
+// 0 <= arr[i]、x <= 10^7
+// 因为练的就是可持久化前缀树，所以就用在线算法，不要使用离线算法
 // 测试链接 : https://www.luogu.com.cn/problem/P4735
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是有一些测试用例通过不了
diff --git a/src/class159/Code01_MaxXor2.java b/src/class159/Code01_MaxXor2.java
index be2b18585..ef1010587 100644
--- a/src/class159/Code01_MaxXor2.java
+++ b/src/class159/Code01_MaxXor2.java
@@ -1,7 +1,14 @@
 package class159;
 
 // 最大异或和，C++版
-// 因为练的就是可持久化前缀树，所以就用在线算法
+// 非负序列arr的初始长度为n，一共有m条操作，每条操作是如下两种类型中的一种
+// A x     : arr的末尾增加数字x，arr的长度n也增加1
+// Q l r x : l~r这些位置中，选一个位置p，现在希望
+//           arr[p] ^ arr[p+1] ^ .. ^ arr[n] ^ x 这个值最大
+//           打印这个最大值
+// 1 <= n、m <= 3 * 10^5
+// 0 <= arr[i]、x <= 10^7
+// 因为练的就是可持久化前缀树，所以就用在线算法，不要使用离线算法
 // 测试链接 : https://www.luogu.com.cn/problem/P4735
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class159/Code02_StringTree1.java b/src/class159/Code02_StringTree1.java
index 6eac5dd9a..3c7ec3295 100644
--- a/src/class159/Code02_StringTree1.java
+++ b/src/class159/Code02_StringTree1.java
@@ -1,6 +1,11 @@
 package class159;
 
 // 字符串树，java版
+// 一共有n个节点，n-1条边，组成一棵树，每条边的边权为字符串
+// 一共有m条查询，每条查询的格式为
+// u v s : 查询节点u到节点v的路径中，有多少边的字符串以字符串s作为前缀
+// 1 <= n、m <= 10^5
+// 所有字符串长度不超过10，并且都由字符a~z组成
 // 测试链接 : https://www.luogu.com.cn/problem/P6088
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class159/Code02_StringTree2.java b/src/class159/Code02_StringTree2.java
index 43b1dfb19..47898dc6a 100644
--- a/src/class159/Code02_StringTree2.java
+++ b/src/class159/Code02_StringTree2.java
@@ -1,6 +1,11 @@
 package class159;
 
 // 字符串树，C++版
+// 一共有n个节点，n-1条边，组成一棵树，每条边的边权为字符串
+// 一共有m条查询，每条查询的格式为
+// u v s : 查询节点u到节点v的路径中，有多少边的字符串以字符串s作为前缀
+// 1 <= n、m <= 10^5
+// 所有字符串长度不超过10，并且都由字符a~z组成
 // 测试链接 : https://www.luogu.com.cn/problem/P6088
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class159/Code03_PathDfnXor1.java b/src/class159/Code03_PathDfnXor1.java
index bb60b109d..33f76d10c 100644
--- a/src/class159/Code03_PathDfnXor1.java
+++ b/src/class159/Code03_PathDfnXor1.java
@@ -1,6 +1,12 @@
 package class159;
 
 // 路径和子树的异或，java版
+// 一共有n个节点，n-1条边，组成一棵树，1号节点为树头，每个节点给定点权
+// 一共有m条查询，每条查询是如下两种类型中的一种
+// 1 x y   : 以x为头的子树中任选一个值，希望异或y之后的值最大，打印最大值
+// 2 x y z : 节点x到节点y的路径中任选一个值，希望异或z之后的值最大，打印最大值
+// 2 <= n、m <= 10^5
+// 1 <= 点权、z < 2^30
 // 测试链接 : https://www.luogu.com.cn/problem/P4592
 // java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
diff --git a/src/class159/Code03_PathDfnXor2.java b/src/class159/Code03_PathDfnXor2.java
index 82f4ec7c7..e899a01a8 100644
--- a/src/class159/Code03_PathDfnXor2.java
+++ b/src/class159/Code03_PathDfnXor2.java
@@ -1,6 +1,12 @@
 package class159;
 
 // 路径和子树的异或，C++版
+// 一共有n个节点，n-1条边，组成一棵树，1号节点为树头，每个节点给定点权
+// 一共有m条查询，每条查询是如下两种类型中的一种
+// 1 x y   : 以x为头的子树中任选一个值，希望异或y之后的值最大，打印最大值
+// 2 x y z : 节点x到节点y的路径中任选一个值，希望异或z之后的值最大，打印最大值
+// 2 <= n、m <= 10^5
+// 1 <= 点权、z < 2^30
 // 测试链接 : https://www.luogu.com.cn/problem/P4592
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class159/Code04_Yummy1.java b/src/class159/Code04_Yummy1.java
index 31ac72adb..3829938bb 100644
--- a/src/class159/Code04_Yummy1.java
+++ b/src/class159/Code04_Yummy1.java
@@ -1,6 +1,11 @@
 package class159;
 
 // 美味，java版
+// 给定一个长度为n的数组arr，一共有m条查询，查询格式如下
+// b x l r : 从arr[l..r]中选一个数字，希望b ^ (该数字 + x)的值最大，打印这个值
+// 1 <= n <= 2 * 10^5
+// 1 <= m <= 10^5
+// 0 <= arr[i]、b、x < 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3293
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -120,10 +125,14 @@ public static void main(String[] args) throws IOException {
 		}
 		prepare();
 		for (int i = 1, b, x, l, r; i <= m; i++) {
-			in.nextToken(); b = (int) in.nval;
-			in.nextToken(); x = (int) in.nval;
-			in.nextToken(); l = (int) in.nval;
-			in.nextToken(); r = (int) in.nval;
+			in.nextToken();
+			b = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			in.nextToken();
+			l = (int) in.nval;
+			in.nextToken();
+			r = (int) in.nval;
 			out.println(compute(b, x, l, r));
 		}
 		out.flush();
diff --git a/src/class159/Code04_Yummy2.java b/src/class159/Code04_Yummy2.java
index d79fca517..761ab6ffa 100644
--- a/src/class159/Code04_Yummy2.java
+++ b/src/class159/Code04_Yummy2.java
@@ -1,6 +1,11 @@
 package class159;
 
 // 美味，C++版
+// 给定一个长度为n的数组arr，一共有m条查询，查询格式如下
+// b x l r : 从arr[l..r]中选一个数字，希望b ^ (该数字 + x)的值最大，打印这个值
+// 1 <= n <= 2 * 10^5
+// 1 <= m <= 10^5
+// 0 <= arr[i]、b、x < 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3293
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class159/Code05_ALO1.java b/src/class159/Code05_ALO1.java
index f55e7911a..58b810e52 100644
--- a/src/class159/Code05_ALO1.java
+++ b/src/class159/Code05_ALO1.java
@@ -1,6 +1,12 @@
 package class159;
 
 // 生成能量密度最大的宝石，java版
+// 给定一个长度为n的数组arr，数组中没有重复数字
+// 你可以随意挑选一个连续的部分，该部分的长度要求大于等于2
+// 这部分的次大值 ^ 除了次大值之外随意选一个数字，所能得到的最大值，叫做这部分的能量密度
+// 那么必有某个连续部分，拥有最大的能量密度，打印这个最大的能量密度
+// 1 <= n <= 5 * 10^4
+// 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4098
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class159/Code05_ALO2.java b/src/class159/Code05_ALO2.java
index 97fc84ee7..cc709fbb3 100644
--- a/src/class159/Code05_ALO2.java
+++ b/src/class159/Code05_ALO2.java
@@ -1,6 +1,12 @@
 package class159;
 
 // 生成能量密度最大的宝石，C++版
+// 给定一个长度为n的数组arr，数组中没有重复数字
+// 你可以随意挑选一个连续的部分，该部分的长度要求大于等于2
+// 这部分的次大值 ^ 除了次大值之外随意选一个数字，所能得到的最大值，叫做这部分的能量密度
+// 那么必有某个连续部分，拥有最大的能量密度，打印这个最大的能量密度
+// 1 <= n <= 5 * 10^4
+// 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4098
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class159/Code06_XorOperation1.java b/src/class159/Code06_XorOperation1.java
index 0c52b8341..fe71790a5 100644
--- a/src/class159/Code06_XorOperation1.java
+++ b/src/class159/Code06_XorOperation1.java
@@ -1,6 +1,14 @@
 package class159;
 
 // 异或运算，java版
+// 给定一个长度n的数组x，还有一个长度为m的数组y
+// 想象一个二维矩阵mat，数组x作为行，数组y作为列，mat[i][j] = x[i] ^ y[j]
+// 一共有p条查询，每条查询格式如下
+// xl xr yl yr k : 划定mat的范围是，行从xl~xr，列从yl~yr，打印其中第k大的值
+// 1 <= n <= 1000
+// 1 <= m <= 3 * 10^5
+// 1 <= p <= 500
+// 0 <= x[i]、y[i] < 2^31
 // 测试链接 : https://www.luogu.com.cn/problem/P5795
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class159/Code06_XorOperation2.java b/src/class159/Code06_XorOperation2.java
index f1754da3b..47c3dc44e 100644
--- a/src/class159/Code06_XorOperation2.java
+++ b/src/class159/Code06_XorOperation2.java
@@ -1,6 +1,14 @@
 package class159;
 
 // 异或运算，C++版
+// 给定一个长度n的数组x，还有一个长度为m的数组y
+// 想象一个二维矩阵mat，数组x作为行，数组y作为列，mat[i][j] = x[i] ^ y[j]
+// 一共有p条查询，每条查询格式如下
+// xl xr yl yr k : 划定mat的范围是，行从xl~xr，列从yl~yr，打印其中第k大的值
+// 1 <= n <= 1000
+// 1 <= m <= 3 * 10^5
+// 1 <= p <= 500
+// 0 <= x[i]、y[i] < 2^31
 // 测试链接 : https://www.luogu.com.cn/problem/P5795
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class159/Code07_Friends1.java b/src/class159/Code07_Friends1.java
index 495f8bfd4..8760372d0 100644
--- a/src/class159/Code07_Friends1.java
+++ b/src/class159/Code07_Friends1.java
@@ -2,6 +2,13 @@
 
 // 前m大两两异或值的和，java版
 // 本题只用到了经典前缀树，没有用到可持久化前缀树
+// 给定一个长度为n的数组arr，下标1~n
+// 你可以随意选不同位置的两个数字进行异或，这叫做两两异或值
+// 那么，两两异或值，就有第1大、第2大...
+// 返回前m大两两异或值的累加和，答案对1000000007取模
+// 1 <= n <= 5 * 10^4
+// 0 <= m <= n * (n-1) / 2
+// 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF241B
 // 测试链接 : https://codeforces.com/problemset/problem/241/B
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class159/Code07_Friends2.java b/src/class159/Code07_Friends2.java
index 07e3ff987..2dacd683a 100644
--- a/src/class159/Code07_Friends2.java
+++ b/src/class159/Code07_Friends2.java
@@ -2,6 +2,13 @@
 
 // 前m大两两异或值的和，C++版
 // 本题只用到了经典前缀树，没有用到可持久化前缀树
+// 给定一个长度为n的数组arr，下标1~n
+// 你可以随意选不同位置的两个数字进行异或，这叫做两两异或值
+// 那么，两两异或值，就有第1大、第2大...
+// 返回前m大两两异或值的累加和，答案对1000000007取模
+// 1 <= n <= 5 * 10^4
+// 0 <= m <= n * (n-1) / 2
+// 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF241B
 // 测试链接 : https://codeforces.com/problemset/problem/241/B
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From e32e404c01fdc84e54b3b6b158d4d4897e3dd4ae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Jan 2025 00:53:38 +0800
Subject: [PATCH 0413/1712] modify code

---
 src/class056/Code02_UnionFindLuogu.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class056/Code02_UnionFindLuogu.java b/src/class056/Code02_UnionFindLuogu.java
index 8aa9a2bba..96fd9629f 100644
--- a/src/class056/Code02_UnionFindLuogu.java
+++ b/src/class056/Code02_UnionFindLuogu.java
@@ -16,7 +16,7 @@
 
 public class Code02_UnionFindLuogu {
 
-	public static int MAXN = 10001;
+	public static int MAXN = 200001;
 
 	public static int[] father = new int[MAXN];
 

From 108a9ee26cb9ae38282929942cfb01f2aa4e1d69 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Jan 2025 22:01:10 +0800
Subject: [PATCH 0414/1712] modify code

---
 src/class159/Code01_MaxXor1.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/class159/Code01_MaxXor1.java b/src/class159/Code01_MaxXor1.java
index a7b3a4399..80c96cddc 100644
--- a/src/class159/Code01_MaxXor1.java
+++ b/src/class159/Code01_MaxXor1.java
@@ -79,6 +79,7 @@ public static void main(String[] args) throws IOException {
 		n = in.nextInt();
 		m = in.nextInt();
 		eor = 0;
+		// 其实有空版本，空版本的头节点编号是0
 		root[0] = insert(eor, 0);
 		for (int i = 1, num; i <= n; i++) {
 			num = in.nextInt();
@@ -95,9 +96,9 @@ public static void main(String[] args) throws IOException {
 				n++;
 				root[n] = insert(eor, root[n - 1]);
 			} else {
-				x = in.nextInt();
-				y = in.nextInt();
-				z = in.nextInt();
+				x = in.nextInt(); // l
+				y = in.nextInt(); // r
+				z = in.nextInt(); // x
 				if (x == 1) {
 					out.println(query(eor ^ z, 0, root[y - 1]));
 				} else {

From 9308ee5eac5b8370763e26453565ca5d71cdf19d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Jan 2025 23:56:34 +0800
Subject: [PATCH 0415/1712] modify code

---
 src/class159/Code02_StringTree1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class159/Code02_StringTree1.java b/src/class159/Code02_StringTree1.java
index 3c7ec3295..9043037ff 100644
--- a/src/class159/Code02_StringTree1.java
+++ b/src/class159/Code02_StringTree1.java
@@ -28,6 +28,7 @@ public class Code02_StringTree1 {
 
 	public static int n, m;
 
+	// 链式前向星需要
 	public static int[] head = new int[MAXN];
 
 	public static int[] next = new int[MAXN << 1];
@@ -38,6 +39,7 @@ public class Code02_StringTree1 {
 
 	public static int cntg = 0;
 
+	// 可持久化前缀树需要
 	public static int[] root = new int[MAXN];
 
 	public static int[][] tree = new int[MAXT][27];
@@ -46,6 +48,7 @@ public class Code02_StringTree1 {
 
 	public static int cntt = 0;
 
+	// 树上倍增和LCA需要
 	public static int[] deep = new int[MAXN];
 
 	public static int[][] stjump = new int[MAXN][MAXH];

From 34132e04b29cd03bc197033a3216cf0b216fd1b3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 28 Jan 2025 00:56:05 +0800
Subject: [PATCH 0416/1712] modify code

---
 src/class159/Code03_PathDfnXor1.java | 13 +++++++++++++
 1 file changed, 13 insertions(+)

diff --git a/src/class159/Code03_PathDfnXor1.java b/src/class159/Code03_PathDfnXor1.java
index 33f76d10c..60e281a0a 100644
--- a/src/class159/Code03_PathDfnXor1.java
+++ b/src/class159/Code03_PathDfnXor1.java
@@ -32,34 +32,47 @@ public class Code03_PathDfnXor1 {
 
 	public static int n, m;
 
+	// 每个节点的点权
 	public static int[] arr = new int[MAXN];
 
+	// 链式前向星需要
 	public static int[] head = new int[MAXN];
 
 	public static int[] next = new int[MAXN << 1];
 
 	public static int[] to = new int[MAXN << 1];
 
+	// 链式前向星的边的计数
 	public static int cntg = 0;
 
+	// 树上dfs求节点深度
 	public static int[] deep = new int[MAXN];
 
+	// 树上dfs求子树大小
 	public static int[] size = new int[MAXN];
 
+	// 树上dfs求st表
 	public static int[][] stjump = new int[MAXN][MAXH];
 
+	// 树上dfs求每个节点的dfn序号
 	public static int[] dfn = new int[MAXN];
 
+	// dfn序号计数
 	public static int cntd = 0;
 
+	// 1类型的可持久化01Trie，根据dfn序号的次序建树
 	public static int[] root1 = new int[MAXN];
 
+	// 2类型的可持久化01Trie，根据父节点的版本建新树
 	public static int[] root2 = new int[MAXN];
 
+	// 1类型和2类型都可以用这个tree结构
 	public static int[][] tree = new int[MAXT][2];
 
+	// 1类型和2类型都可以用这个pass数组
 	public static int[] pass = new int[MAXT];
 
+	// 1类型和2类型一起的节点计数
 	public static int cntt = 0;
 
 	public static void addEdge(int u, int v) {

From f94196d35cc53fa5650a61149368883f811cef31 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 28 Jan 2025 01:04:03 +0800
Subject: [PATCH 0417/1712] modify code

---
 src/class159/Code04_Yummy1.java | 13 +++++++------
 src/class159/Code04_Yummy2.java | 16 +++++++++-------
 2 files changed, 16 insertions(+), 13 deletions(-)

diff --git a/src/class159/Code04_Yummy1.java b/src/class159/Code04_Yummy1.java
index 3829938bb..093f42918 100644
--- a/src/class159/Code04_Yummy1.java
+++ b/src/class159/Code04_Yummy1.java
@@ -28,6 +28,7 @@ public class Code04_Yummy1 {
 
 	public static int[] arr = new int[MAXN];
 
+	// 可持久化线段树需要
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXT];
@@ -96,19 +97,19 @@ public static void prepare() {
 	}
 
 	public static int compute(int b, int x, int l, int r) {
-		int ans = 0;
+		int best = 0;
 		for (int i = BIT; i >= 0; i--) {
 			if (((b >> i) & 1) == 1) {
-				if (query(ans - x, ans - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
-					ans += 1 << i;
+				if (query(best - x, best - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
+					best += 1 << i;
 				}
 			} else {
-				if (query(ans - x + (1 << i), ans - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
-					ans += 1 << i;
+				if (query(best - x + (1 << i), best - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
+					best += 1 << i;
 				}
 			}
 		}
-		return ans ^ b;
+		return best ^ b;
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class159/Code04_Yummy2.java b/src/class159/Code04_Yummy2.java
index 761ab6ffa..74fb8f2b3 100644
--- a/src/class159/Code04_Yummy2.java
+++ b/src/class159/Code04_Yummy2.java
@@ -20,7 +20,9 @@
 //int n, m, s;
 //int arr[MAXN];
 //int root[MAXN];
-//int ls[MAXT], rs[MAXT], size[MAXT];
+//int ls[MAXT];
+//int rs[MAXT];
+//int size[MAXT];
 //int cnt;
 //
 //int build(int l, int r) {
@@ -81,19 +83,19 @@
 //}
 //
 //int compute(int b, int x, int l, int r) {
-//    int ans = 0;
+//    int best = 0;
 //    for (int i = BIT; i >= 0; i--) {
 //        if (((b >> i) & 1) == 1) {
-//            if (query(ans - x, ans - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
-//                ans += 1 << i;
+//            if (query(best - x, best - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
+//                best += 1 << i;
 //            }
 //        } else {
-//            if (query(ans - x + (1 << i), ans - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
-//                ans += 1 << i;
+//            if (query(best - x + (1 << i), best - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
+//                best += 1 << i;
 //            }
 //        }
 //    }
-//    return ans ^ b;
+//    return best ^ b;
 //}
 //
 //int main() {

From 0777330c1588032bef4f61917d938832a871d3fd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 28 Jan 2025 03:07:46 +0800
Subject: [PATCH 0418/1712] modify code

---
 src/class159/Code04_Yummy1.java | 4 ++--
 src/class159/Code04_Yummy2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class159/Code04_Yummy1.java b/src/class159/Code04_Yummy1.java
index 093f42918..a7b5119ee 100644
--- a/src/class159/Code04_Yummy1.java
+++ b/src/class159/Code04_Yummy1.java
@@ -100,11 +100,11 @@ public static int compute(int b, int x, int l, int r) {
 		int best = 0;
 		for (int i = BIT; i >= 0; i--) {
 			if (((b >> i) & 1) == 1) {
-				if (query(best - x, best - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
+				if (query(best - x, best + (1 << i) - 1 - x, 0, s, root[l - 1], root[r]) == 0) {
 					best += 1 << i;
 				}
 			} else {
-				if (query(best - x + (1 << i), best - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
+				if (query(best + (1 << i) - x, best + (1 << (i + 1)) - 1 - x, 0, s, root[l - 1], root[r]) != 0) {
 					best += 1 << i;
 				}
 			}
diff --git a/src/class159/Code04_Yummy2.java b/src/class159/Code04_Yummy2.java
index 74fb8f2b3..18a567473 100644
--- a/src/class159/Code04_Yummy2.java
+++ b/src/class159/Code04_Yummy2.java
@@ -86,11 +86,11 @@
 //    int best = 0;
 //    for (int i = BIT; i >= 0; i--) {
 //        if (((b >> i) & 1) == 1) {
-//            if (query(best - x, best - x + (1 << i) - 1, 0, s, root[l - 1], root[r]) == 0) {
+//            if (query(best - x, best + (1 << i) - 1 - x, 0, s, root[l - 1], root[r]) == 0) {
 //                best += 1 << i;
 //            }
 //        } else {
-//            if (query(best - x + (1 << i), best - x + (1 << (i + 1)) - 1, 0, s, root[l - 1], root[r]) != 0) {
+//            if (query(best + (1 << i) - x, best + (1 << (i + 1)) - 1 - x, 0, s, root[l - 1], root[r]) != 0) {
 //                best += 1 << i;
 //            }
 //        }

From d03b7d037a92061035891ef4dca9fc171b9096af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 29 Jan 2025 13:40:26 +0800
Subject: [PATCH 0419/1712] modify code

---
 src/class159/Code05_ALO1.java | 11 ++++++-----
 src/class159/Code05_ALO2.java | 11 ++++++-----
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/class159/Code05_ALO1.java b/src/class159/Code05_ALO1.java
index 58b810e52..984bde0df 100644
--- a/src/class159/Code05_ALO1.java
+++ b/src/class159/Code05_ALO1.java
@@ -2,10 +2,11 @@
 
 // 生成能量密度最大的宝石，java版
 // 给定一个长度为n的数组arr，数组中没有重复数字
-// 你可以随意挑选一个连续的部分，该部分的长度要求大于等于2
-// 这部分的次大值 ^ 除了次大值之外随意选一个数字，所能得到的最大值，叫做这部分的能量密度
-// 那么必有某个连续部分，拥有最大的能量密度，打印这个最大的能量密度
-// 1 <= n <= 5 * 10^4
+// 你可以随意选择一个子数组，长度要求大于等于2，因为这样一来，子数组必存在次大值
+// 子数组的次大值 ^ 子数组中除了次大值之外随意选一个数字
+// 所能得到的最大结果，叫做子数组的能量密度
+// 那么必有某个子数组，拥有最大的能量密度，打印这个最大的能量密度
+// 2 <= n <= 5 * 10^4
 // 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4098
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -26,7 +27,7 @@ public class Code05_ALO1 {
 
 	public static int BIT = 30;
 
-	public static int n, m;
+	public static int n;
 
 	public static int[][] arr = new int[MAXN][2];
 
diff --git a/src/class159/Code05_ALO2.java b/src/class159/Code05_ALO2.java
index cc709fbb3..35d8394c1 100644
--- a/src/class159/Code05_ALO2.java
+++ b/src/class159/Code05_ALO2.java
@@ -2,10 +2,11 @@
 
 // 生成能量密度最大的宝石，C++版
 // 给定一个长度为n的数组arr，数组中没有重复数字
-// 你可以随意挑选一个连续的部分，该部分的长度要求大于等于2
-// 这部分的次大值 ^ 除了次大值之外随意选一个数字，所能得到的最大值，叫做这部分的能量密度
-// 那么必有某个连续部分，拥有最大的能量密度，打印这个最大的能量密度
-// 1 <= n <= 5 * 10^4
+// 你可以随意选择一个子数组，长度要求大于等于2，因为这样一来，子数组必存在次大值
+// 子数组的次大值 ^ 子数组中除了次大值之外随意选一个数字
+// 所能得到的最大结果，叫做子数组的能量密度
+// 那么必有某个子数组，拥有最大的能量密度，打印这个最大的能量密度
+// 2 <= n <= 5 * 10^4
 // 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4098
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -18,7 +19,7 @@
 //const int MAXN = 50002;
 //const int MAXT = MAXN * 32;
 //const int BIT = 30;
-//int n, m;
+//int n;
 //vector<pair<int, int>> arr;
 //int root[MAXN];
 //int tree[MAXT][2];

From 58d7da1fe9c5a824ccd1a46e51b3ceeb247ab1a4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 29 Jan 2025 15:36:26 +0800
Subject: [PATCH 0420/1712] modify code

---
 src/class159/Code06_XorOperation1.java | 23 ++++++++++++-----------
 src/class159/Code06_XorOperation2.java | 11 ++++-------
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/class159/Code06_XorOperation1.java b/src/class159/Code06_XorOperation1.java
index fe71790a5..0db0d3e01 100644
--- a/src/class159/Code06_XorOperation1.java
+++ b/src/class159/Code06_XorOperation1.java
@@ -31,8 +31,6 @@ public class Code06_XorOperation1 {
 
 	public static int[] x = new int[MAXN];
 
-	public static int[] y = new int[MAXN];
-
 	public static int[] root = new int[MAXN];
 
 	public static int[][] tree = new int[MAXT][2];
@@ -61,6 +59,7 @@ public static int insert(int num, int i) {
 	}
 
 	public static int maxKth(int xl, int xr, int yl, int yr, int k) {
+		// 基于哪两个节点的pass值查询，一开始x[xl...xr]每个数字，都是一样的
 		for (int i = xl; i <= xr; i++) {
 			xroad[i][0] = root[yl - 1];
 			xroad[i][1] = root[yr];
@@ -68,11 +67,19 @@ public static int maxKth(int xl, int xr, int yl, int yr, int k) {
 		int ans = 0;
 		for (int b = BIT, path, best, sum; b >= 0; b--) {
 			sum = 0;
+			// 统计x[xl...xr]范围上
+			// 每个数字 ^ y[yl...yr]任意一个数字，在第b位上能取得1的结果，有多少个
+			// 结果数量累加起来
 			for (int i = xl; i <= xr; i++) {
 				path = (x[i] >> b) & 1;
 				best = path ^ 1;
 				sum += pass[tree[xroad[i][1]][best]] - pass[tree[xroad[i][0]][best]];
 			}
+			// 如果sum >= k
+			// 说明x[xl...xr]对应y[yl...yr]，第k大的异或结果，在第b位上能是1
+			// 如果sum < k
+			// 说明x[xl...xr]对应y[yl...yr]，第k大的异或结果，在第b位上只能是0
+			// x[xl...xr]每个数字，都有自己专属的跳转，要记录好！
 			for (int i = xl; i <= xr; i++) {
 				path = (x[i] >> b) & 1;
 				best = path ^ 1;
@@ -93,12 +100,6 @@ public static int maxKth(int xl, int xr, int yl, int yr, int k) {
 		return ans;
 	}
 
-	public static void prepare() {
-		for (int i = 1; i <= m; i++) {
-			root[i] = insert(y[i], root[i - 1]);
-		}
-	}
-
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -111,11 +112,11 @@ public static void main(String[] args) throws IOException {
 			in.nextToken();
 			x[i] = (int) in.nval;
 		}
-		for (int i = 1; i <= m; i++) {
+		for (int i = 1, yi; i <= m; i++) {
 			in.nextToken();
-			y[i] = (int) in.nval;
+			yi = (int) in.nval;
+			root[i] = insert(yi, root[i - 1]);
 		}
-		prepare();
 		in.nextToken();
 		p = (int) in.nval;
 		for (int i = 1, xl, xr, yl, yr, k; i <= p; i++) {
diff --git a/src/class159/Code06_XorOperation2.java b/src/class159/Code06_XorOperation2.java
index 47c3dc44e..a767981c0 100644
--- a/src/class159/Code06_XorOperation2.java
+++ b/src/class159/Code06_XorOperation2.java
@@ -22,7 +22,6 @@
 //const int BIT = 30;
 //int n, m, p;
 //int x[MAXN];
-//int y[MAXN];
 //int root[MAXN];
 //int tree[MAXT][2];
 //int pass[MAXT];
@@ -80,9 +79,7 @@
 //}
 //
 //void prepare() {
-//    for (int i = 1; i <= m; i++) {
-//        root[i] = insert(y[i], root[i - 1]);
-//    }
+
 //}
 //
 //int main() {
@@ -92,10 +89,10 @@
 //    for (int i = 1; i <= n; i++) {
 //        cin >> x[i];
 //    }
-//    for (int i = 1; i <= m; i++) {
-//        cin >> y[i];
+//    for (int i = 1, yi; i <= m; i++) {
+//        cin >> yi;
+//        root[i] = insert(yi, root[i - 1]);
 //    }
-//    prepare();
 //    cin >> p;
 //    for (int i = 1, xl, xr, yl, yr, k; i <= p; i++) {
 //        cin >> xl >> xr >> yl >> yr >> k;

From 27998a22a01255168fb94d110044a766f2db91ac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 29 Jan 2025 20:26:00 +0800
Subject: [PATCH 0421/1712] modify code

---
 ...\345\205\263\351\242\230\347\233\256.pptx" | Bin 0 -> 51811 bytes
 src/class159/Code07_Friends1.java             |  65 ++++++++-------
 src/class159/Code07_Friends2.java             |  75 +++++++++---------
 3 files changed, 68 insertions(+), 72 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243159\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\345\211\215\347\274\200\346\240\221\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243159\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\345\211\215\347\274\200\346\240\221\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243159\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\345\211\215\347\274\200\346\240\221\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..285a603fbfd9548282a80bf622615efc20dd39c1
GIT binary patch
literal 51811
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
T@(tKp1K!TS=EO?l(YOBrk;k<=

literal 0
HcmV?d00001

diff --git a/src/class159/Code07_Friends1.java b/src/class159/Code07_Friends1.java
index 8760372d0..7135bee4f 100644
--- a/src/class159/Code07_Friends1.java
+++ b/src/class159/Code07_Friends1.java
@@ -3,11 +3,11 @@
 // 前m大两两异或值的和，java版
 // 本题只用到了经典前缀树，没有用到可持久化前缀树
 // 给定一个长度为n的数组arr，下标1~n
-// 你可以随意选不同位置的两个数字进行异或，这叫做两两异或值
+// 你可以随意选两个不同位置的数字进行异或，得到两两异或值，顺序不同的话，算做一个两两异或值
 // 那么，两两异或值，就有第1大、第2大...
-// 返回前m大两两异或值的累加和，答案对1000000007取模
+// 返回前k大两两异或值的累加和，答案对1000000007取模
 // 1 <= n <= 5 * 10^4
-// 0 <= m <= n * (n-1) / 2
+// 0 <= k <= n * (n-1) / 2
 // 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF241B
 // 测试链接 : https://codeforces.com/problemset/problem/241/B
@@ -46,7 +46,7 @@ public class Code07_Friends1 {
 
 	public static void insert(int num) {
 		int cur = 1;
-		pass[cur]++;
+		pass[1]++;
 		for (int b = BIT, path; b >= 0; b--) {
 			path = (num >> b) & 1;
 			if (tree[cur][path] == 0) {
@@ -57,27 +57,27 @@ public static void insert(int num) {
 		}
 	}
 
-	public static void dfs(int u, int h, int s) {
-		if (u == 0) {
+	public static void dfs(int i, int h, int s) {
+		if (i == 0) {
 			return;
 		}
 		if (h == 0) {
-			for (int i = 0; i <= BIT; i++) {
-				if (((s >> i) & 1) == 1) {
-					sum[u][i] = pass[u];
+			for (int j = 0; j <= BIT; j++) {
+				if (((s >> j) & 1) == 1) {
+					sum[i][j] = pass[i];
 				}
 			}
 		} else {
-			dfs(tree[u][0], h - 1, s);
-			dfs(tree[u][1], h - 1, s | (1 << (h - 1)));
-			for (int i = 0; i <= BIT; i++) {
-				sum[u][i] = sum[tree[u][0]][i] + sum[tree[u][1]][i];
+			dfs(tree[i][0], h - 1, s);
+			dfs(tree[i][1], h - 1, s | (1 << (h - 1)));
+			for (int j = 0; j <= BIT; j++) {
+				sum[i][j] = sum[tree[i][0]][j] + sum[tree[i][1]][j];
 			}
 		}
 	}
 
-	public static long moreThan(int x) {
-		long sum = 0;
+	public static long moreEqual(int x) {
+		long ans = 0;
 		for (int i = 1, num, cur; i <= n; i++) {
 			num = arr[i];
 			cur = 1;
@@ -86,7 +86,7 @@ public static long moreThan(int x) {
 				best = path ^ 1;
 				xpath = (x >> b) & 1;
 				if (xpath == 0) {
-					sum += pass[tree[cur][best]];
+					ans += pass[tree[cur][best]];
 					cur = tree[cur][path];
 				} else {
 					cur = tree[cur][best];
@@ -95,12 +95,12 @@ public static long moreThan(int x) {
 					break;
 				}
 			}
-			sum += pass[cur];
+			ans += pass[cur];
 		}
 		if (x == 0) {
-			sum -= n;
+			ans -= n;
 		}
-		return sum / 2;
+		return ans / 2;
 	}
 
 	public static int maxKth() {
@@ -108,7 +108,7 @@ public static int maxKth() {
 		int ans = 0;
 		while (l <= r) {
 			m = (l + r) / 2;
-			if (moreThan(m) >= k) {
+			if (moreEqual(m) >= k) {
 				ans = m;
 				l = m + 1;
 			} else {
@@ -118,27 +118,18 @@ public static int maxKth() {
 		return ans;
 	}
 
-	public static void prepare() {
-		for (int i = 1; i <= n; i++) {
-			insert(arr[i]);
-		}
-		dfs(tree[1][0], BIT, 0);
-		dfs(tree[1][1], BIT, 1 << BIT);
-	}
-
 	public static long compute() {
 		int kth = maxKth();
 		long ans = 0;
-		for (int i = 1, num, cur; i <= n; i++) {
-			num = arr[i];
+		for (int i = 1, cur; i <= n; i++) {
 			cur = 1;
 			for (int b = BIT, path, best, kpath; b >= 0; b--) {
-				path = (num >> b) & 1;
+				path = (arr[i] >> b) & 1;
 				best = path ^ 1;
 				kpath = (kth >> b) & 1;
 				if (kpath == 0) {
 					for (int j = 0; j <= BIT; j++) {
-						if (((num >> j) & 1) == 1) {
+						if (((arr[i] >> j) & 1) == 1) {
 							ans = (ans + ((long) pass[tree[cur][best]] - sum[tree[cur][best]][j]) * (1L << j)) % MOD;
 						} else {
 							ans = (ans + (long) sum[tree[cur][best]][j] * (1L << j)) % MOD;
@@ -155,10 +146,18 @@ public static long compute() {
 			ans = (ans + (long) pass[cur] * kth) % MOD;
 		}
 		ans = ans * INV2 % MOD;
-		ans = ((ans - (moreThan(kth) - k) * kth % MOD) % MOD + MOD) % MOD;
+		ans = ((ans - (moreEqual(kth) - k) * kth % MOD) % MOD + MOD) % MOD;
 		return ans;
 	}
 
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			insert(arr[i]);
+		}
+		dfs(tree[1][0], BIT, 0);
+		dfs(tree[1][1], BIT, 1 << BIT);
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
diff --git a/src/class159/Code07_Friends2.java b/src/class159/Code07_Friends2.java
index 2dacd683a..b8c3c88c9 100644
--- a/src/class159/Code07_Friends2.java
+++ b/src/class159/Code07_Friends2.java
@@ -3,11 +3,11 @@
 // 前m大两两异或值的和，C++版
 // 本题只用到了经典前缀树，没有用到可持久化前缀树
 // 给定一个长度为n的数组arr，下标1~n
-// 你可以随意选不同位置的两个数字进行异或，这叫做两两异或值
+// 你可以随意选两个不同位置的数字进行异或，得到两两异或值，顺序不同的话，算做一个两两异或值
 // 那么，两两异或值，就有第1大、第2大...
-// 返回前m大两两异或值的累加和，答案对1000000007取模
+// 返回前k大两两异或值的累加和，答案对1000000007取模
 // 1 <= n <= 5 * 10^4
-// 0 <= m <= n * (n-1) / 2
+// 0 <= k <= n * (n-1) / 2
 // 0 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF241B
 // 测试链接 : https://codeforces.com/problemset/problem/241/B
@@ -32,38 +32,38 @@
 //
 //void insert(int num) {
 //    int cur = 1;
-//    pass[cur]++;
+//    pass[1]++;
 //    for (int b = BIT; b >= 0; b--) {
 //        int path = (num >> b) & 1;
 //        if (!tree[cur][path]) {
-//        	tree[cur][path] = ++cnt;
+//            tree[cur][path] = ++cnt;
 //        }
 //        cur = tree[cur][path];
 //        pass[cur]++;
 //    }
 //}
 //
-//void dfs(int u, int h, int s) {
-//    if (!u) {
+//void dfs(int i, int h, int s) {
+//    if (!i) {
 //        return;
 //    }
 //    if (!h) {
-//        for (int i = 0; i <= BIT; i++) {
-//            if ((s >> i) & 1) {
-//            	sum[u][i] = pass[u];
+//        for (int j = 0; j <= BIT; j++) {
+//            if ((s >> j) & 1) {
+//                sum[i][j] = pass[i];
 //            }
 //        }
 //    } else {
-//        dfs(tree[u][0], h - 1, s);
-//        dfs(tree[u][1], h - 1, s | (1 << (h - 1)));
-//        for (int i = 0; i <= BIT; i++) {
-//        	sum[u][i] = sum[tree[u][0]][i] + sum[tree[u][1]][i];
+//        dfs(tree[i][0], h - 1, s);
+//        dfs(tree[i][1], h - 1, s | (1 << (h - 1)));
+//        for (int j = 0; j <= BIT; j++) {
+//            sum[i][j] = sum[tree[i][0]][j] + sum[tree[i][1]][j];
 //        }
 //    }
 //}
 //
-//long long moreThan(int x) {
-//    long long sum = 0;
+//long long moreEqual(int x) {
+//    long long ans = 0;
 //    for (int i = 1; i <= n; i++) {
 //        int num = arr[i];
 //        int cur = 1;
@@ -72,7 +72,7 @@
 //            int best = path ^ 1;
 //            int xpath = (x >> b) & 1;
 //            if (!xpath) {
-//                sum += pass[tree[cur][best]];
+//                ans += pass[tree[cur][best]];
 //                cur = tree[cur][path];
 //            } else {
 //                cur = tree[cur][best];
@@ -81,21 +81,19 @@
 //                break;
 //            }
 //        }
-//        if (cur) {
-//            sum += pass[cur];
-//        }
+//        ans += pass[cur];
 //    }
-//    if (!x) {
-//        sum -= n;
+//    if (x == 0) {
+//        ans -= n;
 //    }
-//    return sum / 2;
+//    return ans / 2;
 //}
 //
 //int maxKth() {
 //    int l = 0, r = 1 << BIT, ans = 0;
 //    while (l <= r) {
 //        int m = (l + r) >> 1;
-//        if (moreThan(m) >= k) {
+//        if (moreEqual(m) >= k) {
 //            ans = m;
 //            l = m + 1;
 //        } else {
@@ -105,28 +103,19 @@
 //    return ans;
 //}
 //
-//void prepare() {
-//    for (int i = 1; i <= n; i++) {
-//        insert(arr[i]);
-//    }
-//    dfs(tree[1][0], BIT, 0);
-//    dfs(tree[1][1], BIT, 1 << BIT);
-//}
-//
 //long long compute() {
 //    int kth = maxKth();
 //    long long ans = 0;
-//    for (int i = 1; i <= n; i++) {
-//        int num = arr[i];
-//        int cur = 1;
+//    for (int i = 1, cur; i <= n; i++) {
+//        cur = 1;
 //        for (int b = BIT; b >= 0; b--) {
-//            int path = (num >> b) & 1;
+//            int path = (arr[i] >> b) & 1;
 //            int best = path ^ 1;
 //            int kpath = (kth >> b) & 1;
 //            if (!kpath) {
 //                if (tree[cur][best]) {
 //                    for (int j = 0; j <= BIT; j++) {
-//                        if ((num >> j) & 1) {
+//                        if ((arr[i] >> j) & 1) {
 //                            ans = (ans + ((long long)pass[tree[cur][best]] - sum[tree[cur][best]][j]) * (1LL << j)) % MOD;
 //                        } else {
 //                            ans = (ans + ((long long)sum[tree[cur][best]][j]) * (1LL << j)) % MOD;
@@ -146,11 +135,19 @@
 //        }
 //    }
 //    ans = ans * INV2 % MOD;    
-//    ans = ((ans - ((moreThan(kth) - k) * kth) % MOD) % MOD + MOD) % MOD;
+//    ans = ((ans - ((moreEqual(kth) - k) * kth) % MOD) % MOD + MOD) % MOD;
 //    return ans;
 //}
 //
-//int main(){
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        insert(arr[i]);
+//    }
+//    dfs(tree[1][0], BIT, 0);
+//    dfs(tree[1][1], BIT, 1 << BIT);
+//}
+//
+//int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> k;

From ce623c11ccbe85fcea6614d13289c026ac01f46f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 6 Feb 2025 11:56:57 +0800
Subject: [PATCH 0422/1712] modify code

---
 src/class159/Code06_XorOperation2.java | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/class159/Code06_XorOperation2.java b/src/class159/Code06_XorOperation2.java
index a767981c0..18bfb94fe 100644
--- a/src/class159/Code06_XorOperation2.java
+++ b/src/class159/Code06_XorOperation2.java
@@ -76,10 +76,6 @@
 //        }
 //    }
 //    return ans;
-//}
-//
-//void prepare() {
-
 //}
 //
 //int main() {

From 5afdb0ec32e860c7890f666779664b02174f560f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 7 Feb 2025 17:05:33 +0800
Subject: [PATCH 0423/1712] modify code

---
 src/class160/Code01_NestedTree1.java | 269 +++++++++++++++++++++++++++
 src/class160/Code01_NestedTree2.java | 213 +++++++++++++++++++++
 2 files changed, 482 insertions(+)
 create mode 100644 src/class160/Code01_NestedTree1.java
 create mode 100644 src/class160/Code01_NestedTree2.java

diff --git a/src/class160/Code01_NestedTree1.java b/src/class160/Code01_NestedTree1.java
new file mode 100644
index 000000000..75ccb5fc8
--- /dev/null
+++ b/src/class160/Code01_NestedTree1.java
@@ -0,0 +1,269 @@
+package class160;
+
+// 树套树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3380
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code01_NestedTree1 {
+
+	public static int MAXN = 50001;
+
+	public static int MAXT = MAXN * 160;
+
+	public static int INF = Integer.MAX_VALUE;
+
+	public static int n, m, s;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[][] ques = new int[MAXN][4];
+
+	public static int[] sorted = new int[MAXN * 2];
+
+	// 注意这不是主席树！而是若干棵动态开点权值线段树！
+	public static int[] root = new int[MAXN];
+
+	public static int[] sum = new int[MAXT];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static int cntt = 0;
+
+	public static int[] pos = new int[MAXN];
+
+	public static int[] pre = new int[MAXN];
+
+	public static int cntpos;
+
+	public static int cntpre;
+
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[left[i]] + sum[right[i]];
+	}
+
+	public static int add(int jobi, int jobv, int l, int r, int i) {
+		if (i == 0) {
+			i = ++cntt;
+		}
+		if (l == r) {
+			sum[i] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[i] = add(jobi, jobv, l, mid, left[i]);
+			} else {
+				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
+			}
+			up(i);
+		}
+		return i;
+	}
+
+	public static void add(int i, int v) {
+		for (int j = i; j <= n; j += lowbit(j)) {
+			root[j] = add(arr[i], v, 1, s, root[j]);
+		}
+	}
+
+	public static int queryNumber(int jobk, int l, int r) {
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) / 2;
+		int leftsum = 0;
+		for (int i = 1; i <= cntpos; i++) {
+			leftsum += sum[left[pos[i]]];
+		}
+		for (int i = 1; i <= cntpre; i++) {
+			leftsum -= sum[left[pre[i]]];
+		}
+		if (jobk <= leftsum) {
+			for (int i = 1; i <= cntpos; i++) {
+				pos[i] = left[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				pre[i] = left[pre[i]];
+			}
+			return queryNumber(jobk, l, mid);
+		} else {
+			for (int i = 1; i <= cntpos; i++) {
+				pos[i] = right[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				pre[i] = right[pre[i]];
+			}
+			return queryNumber(jobk - leftsum, mid + 1, r);
+		}
+	}
+
+	public static int findNumber(int l, int r, int k) {
+		cntpos = cntpre = 0;
+		for (int i = r; i > 0; i -= lowbit(i)) {
+			pos[++cntpos] = root[i];
+		}
+		for (int i = l - 1; i > 0; i -= lowbit(i)) {
+			pre[++cntpre] = root[i];
+		}
+		return queryNumber(k, 1, s);
+	}
+
+	public static int queryRank(int jobk, int l, int r) {
+		if (l == r) {
+			return 0;
+		}
+		int mid = (l + r) / 2;
+		if (jobk <= mid) {
+			for (int i = 1; i <= cntpos; i++) {
+				pos[i] = left[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				pre[i] = left[pre[i]];
+			}
+			return queryRank(jobk, l, mid);
+		} else {
+			int leftsum = 0;
+			for (int i = 1; i <= cntpos; i++) {
+				leftsum += sum[left[pos[i]]];
+				pos[i] = right[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				leftsum -= sum[left[pre[i]]];
+				pre[i] = right[pre[i]];
+			}
+			return leftsum + queryRank(jobk, mid + 1, r);
+		}
+	}
+
+	public static int findRank(int l, int r, int k) {
+		cntpos = cntpre = 0;
+		for (int i = r; i > 0; i -= lowbit(i)) {
+			pos[++cntpos] = root[i];
+		}
+		for (int i = l - 1; i > 0; i -= lowbit(i)) {
+			pre[++cntpre] = root[i];
+		}
+		return queryRank(k, 1, s) + 1;
+	}
+
+	public static int findLast(int l, int r, int k) {
+		int rank = findRank(l, r, k);
+		if (rank == 1) {
+			return 0;
+		}
+		return findNumber(l, r, rank - 1);
+	}
+
+	public static int findNext(int l, int r, int k) {
+		if (k == s) {
+			return s + 1;
+		}
+		int rank = findRank(l, r, k + 1);
+		if (rank == r - l + 2) {
+			return s + 1;
+		}
+		return findNumber(l, r, rank);
+	}
+
+	public static void prepare() {
+		s = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[++s] = arr[i];
+		}
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 3) {
+				sorted[++s] = ques[i][2];
+			} else if (ques[i][0] != 2) {
+				sorted[++s] = ques[i][3];
+			}
+		}
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+			add(i, 1);
+		}
+		sorted[0] = -INF;
+		sorted[s + 1] = INF;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			ques[i][0] = (int) in.nval;
+			in.nextToken();
+			ques[i][1] = (int) in.nval;
+			in.nextToken();
+			ques[i][2] = (int) in.nval;
+			if (ques[i][0] != 3) {
+				in.nextToken();
+				ques[i][3] = (int) in.nval;
+			}
+		}
+		prepare();
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 1) {
+				out.println(findRank(ques[i][1], ques[i][2], kth(ques[i][3])));
+			} else if (ques[i][0] == 2) {
+				out.println(sorted[findNumber(ques[i][1], ques[i][2], ques[i][3])]);
+			} else if (ques[i][0] == 3) {
+				add(ques[i][1], -1);
+				arr[ques[i][1]] = kth(ques[i][2]);
+				add(ques[i][1], 1);
+			} else if (ques[i][0] == 4) {
+				out.println(sorted[findLast(ques[i][1], ques[i][2], kth(ques[i][3]))]);
+			} else {
+				out.println(sorted[findNext(ques[i][1], ques[i][2], kth(ques[i][3]))]);
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class160/Code01_NestedTree2.java b/src/class160/Code01_NestedTree2.java
new file mode 100644
index 000000000..a7c32d7fc
--- /dev/null
+++ b/src/class160/Code01_NestedTree2.java
@@ -0,0 +1,213 @@
+package class160;
+
+// 树套树，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3380
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50001;
+//const int MAXT = MAXN * 160;
+//const int INF = INT_MAX;
+//int n,m,s;
+//int arr[MAXN];
+//int ques[MAXN][4];
+//int sorted[MAXN*2];
+//int root[MAXN];
+//int sum[MAXT];
+//int ls[MAXT];
+//int rs[MAXT];
+//int cntt;
+//int pos[MAXN];
+//int pre[MAXN];
+//int cntpos,cntpre;
+//
+//int kth(int num){
+//    int l=1,r=s;
+//    while(l<=r){
+//        int mid=(l+r)>>1;
+//        if(sorted[mid]==num) return mid;
+//        if(sorted[mid]<num) l=mid+1;
+//        else r=mid-1;
+//    }
+//    return -1;
+//}
+//
+//int lowbit(int x){
+//    return x&(-x);
+//}
+//
+//void up(int i){
+//    sum[i]=sum[ls[i]]+sum[rs[i]];
+//}
+//
+//int add(int idx,int v,int L,int R,int i){
+//    if(!i) i=++cntt;
+//    if(L==R){
+//        sum[i]+=v;
+//    } else {
+//        int mid=(L+R)>>1;
+//        if(idx<=mid) ls[i]=add(idx,v,L,mid,ls[i]);
+//        else rs[i]=add(idx,v,mid+1,R,rs[i]);
+//        up(i);
+//    }
+//    return i;
+//}
+//
+//void add(int i,int v){
+//    for(int j=i;j<=n;j+=lowbit(j)){
+//        root[j]=add(arr[i],v,1,s,root[j]);
+//    }
+//}
+//
+//int queryNumber(int k,int L,int R){
+//    if(L==R) return L;
+//    int mid=(L+R)>>1;
+//    int leftsum=0;
+//    for(int i=1;i<=cntpos;i++){
+//        leftsum+=sum[ls[pos[i]]];
+//    }
+//    for(int i=1;i<=cntpre;i++){
+//        leftsum-=sum[ls[pre[i]]];
+//    }
+//    if(k<=leftsum){
+//        for(int i=1;i<=cntpos;i++){
+//            pos[i]=ls[pos[i]];
+//        }
+//        for(int i=1;i<=cntpre;i++){
+//            pre[i]=ls[pre[i]];
+//        }
+//        return queryNumber(k,L,mid);
+//    } else {
+//        for(int i=1;i<=cntpos;i++){
+//            pos[i]=rs[pos[i]];
+//        }
+//        for(int i=1;i<=cntpre;i++){
+//            pre[i]=rs[pre[i]];
+//        }
+//        return queryNumber(k-leftsum,mid+1,R);
+//    }
+//}
+//
+//int findNumber(int L,int R,int k){
+//    cntpos=cntpre=0;
+//    for(int i=R;i>0;i-=lowbit(i)){
+//        pos[++cntpos]=root[i];
+//    }
+//    for(int i=L-1;i>0;i-=lowbit(i)){
+//        pre[++cntpre]=root[i];
+//    }
+//    return queryNumber(k,1,s);
+//}
+//
+//int queryRank(int idx,int L,int R){
+//    if(L==R) return 0;
+//    int mid=(L+R)>>1;
+//    if(idx<=mid){
+//        for(int i=1;i<=cntpos;i++){
+//            pos[i]=ls[pos[i]];
+//        }
+//        for(int i=1;i<=cntpre;i++){
+//            pre[i]=ls[pre[i]];
+//        }
+//        return queryRank(idx,L,mid);
+//    } else {
+//        int leftsum=0;
+//        for(int i=1;i<=cntpos;i++){
+//            leftsum+=sum[ls[pos[i]]];
+//            pos[i]=rs[pos[i]];
+//        }
+//        for(int i=1;i<=cntpre;i++){
+//            leftsum-=sum[ls[pre[i]]];
+//            pre[i]=rs[pre[i]];
+//        }
+//        return leftsum+queryRank(idx,mid+1,R);
+//    }
+//}
+//
+//int findRank(int L,int R,int val){
+//    cntpos=cntpre=0;
+//    for(int i=R;i>0;i-=lowbit(i)){
+//        pos[++cntpos]=root[i];
+//    }
+//    for(int i=L-1;i>0;i-=lowbit(i)){
+//        pre[++cntpre]=root[i];
+//    }
+//    return queryRank(val,1,s)+1;
+//}
+//
+//int findLast(int L,int R,int k){
+//    int rk=findRank(L,R,k);
+//    if(rk==1) return 0;
+//    return findNumber(L,R,rk-1);
+//}
+//
+//int findNext(int L,int R,int k){
+//    if(k==s) return s+1;
+//    int rk=findRank(L,R,k+1);
+//    if(rk==R-L+2) return s+1;
+//    return findNumber(L,R,rk);
+//}
+//
+//void prepare(){
+//    s=0;
+//    for(int i=1;i<=n;i++){
+//        sorted[++s]=arr[i];
+//    }
+//    for(int i=1;i<=m;i++){
+//        if(ques[i][0]==3){
+//            sorted[++s]=ques[i][2];
+//        } else if(ques[i][0]!=2){
+//            sorted[++s]=ques[i][3];
+//        }
+//    }
+//    sort(sorted+1,sorted+s+1);
+//    int len=1;
+//    for(int i=2;i<=s;i++){
+//        if(sorted[len]!=sorted[i]){
+//            sorted[++len]=sorted[i];
+//        }
+//    }
+//    s=len;
+//    for(int i=1;i<=n;i++){
+//        arr[i]=kth(arr[i]);
+//        add(i,1);
+//    }
+//    sorted[0]=-INF;
+//    sorted[s+1]=INF;
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin>>n>>m;
+//    for(int i=1;i<=n;i++){
+//        cin>>arr[i];
+//    }
+//    for(int i=1;i<=m;i++){
+//        cin>>ques[i][0]>>ques[i][1]>>ques[i][2];
+//        if(ques[i][0]!=3){
+//            cin>>ques[i][3];
+//        }
+//    }
+//    prepare();
+//    for(int i=1;i<=m;i++){
+//        if(ques[i][0]==1){
+//            cout<<findRank(ques[i][1],ques[i][2],kth(ques[i][3]))<<"\n";
+//        } else if(ques[i][0]==2){
+//            cout<<sorted[findNumber(ques[i][1],ques[i][2],ques[i][3])]<< "\n";
+//        } else if(ques[i][0]==3){
+//            add(ques[i][1],-1);
+//            arr[ques[i][1]]=kth(ques[i][2]);
+//            add(ques[i][1],1);
+//        } else if(ques[i][0]==4){
+//            cout<<sorted[findLast(ques[i][1],ques[i][2],kth(ques[i][3]))]<<"\n";
+//        } else {
+//            cout<<sorted[findNext(ques[i][1],ques[i][2],kth(ques[i][3]))]<<"\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From cf4c71af1282c07c12c56a0fa967002d6b9da95d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 8 Feb 2025 17:45:34 +0800
Subject: [PATCH 0424/1712] modify code

---
 ...NestedTree1.java => Code01_IndextreeWithSegmenttree1.java} | 4 ++--
 ...NestedTree2.java => Code01_IndextreeWithSegmenttree2.java} | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class160/{Code01_NestedTree1.java => Code01_IndextreeWithSegmenttree1.java} (98%)
 rename src/class160/{Code01_NestedTree2.java => Code01_IndextreeWithSegmenttree2.java} (99%)

diff --git a/src/class160/Code01_NestedTree1.java b/src/class160/Code01_IndextreeWithSegmenttree1.java
similarity index 98%
rename from src/class160/Code01_NestedTree1.java
rename to src/class160/Code01_IndextreeWithSegmenttree1.java
index 75ccb5fc8..ff327b8ac 100644
--- a/src/class160/Code01_NestedTree1.java
+++ b/src/class160/Code01_IndextreeWithSegmenttree1.java
@@ -1,6 +1,6 @@
 package class160;
 
-// 树套树，java版
+// 树状数组套线段树，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code01_NestedTree1 {
+public class Code01_IndextreeWithSegmenttree1 {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class160/Code01_NestedTree2.java b/src/class160/Code01_IndextreeWithSegmenttree2.java
similarity index 99%
rename from src/class160/Code01_NestedTree2.java
rename to src/class160/Code01_IndextreeWithSegmenttree2.java
index a7c32d7fc..28ef4e6d2 100644
--- a/src/class160/Code01_NestedTree2.java
+++ b/src/class160/Code01_IndextreeWithSegmenttree2.java
@@ -1,6 +1,6 @@
 package class160;
 
-// 树套树，C++版
+// 树状数组套线段树，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 2545d82d2953cc5fe33d32b152349d0ca0d51207 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 8 Feb 2025 17:58:01 +0800
Subject: [PATCH 0425/1712] modify code

---
 ...treeWithSegmenttree1.java => Code01_NestedTree1.java} | 4 ++--
 ...treeWithSegmenttree2.java => Code01_NestedTree2.java} | 2 +-
 src/class160/Code02_LuckAndLove1.java                    | 9 +++++++++
 3 files changed, 12 insertions(+), 3 deletions(-)
 rename src/class160/{Code01_IndextreeWithSegmenttree1.java => Code01_NestedTree1.java} (98%)
 rename src/class160/{Code01_IndextreeWithSegmenttree2.java => Code01_NestedTree2.java} (99%)
 create mode 100644 src/class160/Code02_LuckAndLove1.java

diff --git a/src/class160/Code01_IndextreeWithSegmenttree1.java b/src/class160/Code01_NestedTree1.java
similarity index 98%
rename from src/class160/Code01_IndextreeWithSegmenttree1.java
rename to src/class160/Code01_NestedTree1.java
index ff327b8ac..75ccb5fc8 100644
--- a/src/class160/Code01_IndextreeWithSegmenttree1.java
+++ b/src/class160/Code01_NestedTree1.java
@@ -1,6 +1,6 @@
 package class160;
 
-// 树状数组套线段树，java版
+// 树套树，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code01_IndextreeWithSegmenttree1 {
+public class Code01_NestedTree1 {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class160/Code01_IndextreeWithSegmenttree2.java b/src/class160/Code01_NestedTree2.java
similarity index 99%
rename from src/class160/Code01_IndextreeWithSegmenttree2.java
rename to src/class160/Code01_NestedTree2.java
index 28ef4e6d2..a7c32d7fc 100644
--- a/src/class160/Code01_IndextreeWithSegmenttree2.java
+++ b/src/class160/Code01_NestedTree2.java
@@ -1,6 +1,6 @@
 package class160;
 
-// 树状数组套线段树，C++版
+// 树套树，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class160/Code02_LuckAndLove1.java b/src/class160/Code02_LuckAndLove1.java
new file mode 100644
index 000000000..b61c28932
--- /dev/null
+++ b/src/class160/Code02_LuckAndLove1.java
@@ -0,0 +1,9 @@
+package class160;
+
+// 线段树套线段树，java版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=1823
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code02_LuckAndLove1 {
+
+}

From 2978f84a27cf8c1a866d644a8f32b7061c738cfa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 8 Feb 2025 21:39:02 +0800
Subject: [PATCH 0426/1712] modify code

---
 .../Code01_SegmentTreeWithSegmentTree1.java   | 180 ++++++++++++++++++
 .../Code01_SegmentTreeWithSegmentTree2.java   | 126 ++++++++++++
 ... => Code02_IndexTreeWithSegmentTree1.java} |   4 +-
 ... => Code02_IndexTreeWithSegmentTree2.java} |   2 +-
 src/class160/Code02_LuckAndLove1.java         |   9 -
 5 files changed, 309 insertions(+), 12 deletions(-)
 create mode 100644 src/class160/Code01_SegmentTreeWithSegmentTree1.java
 create mode 100644 src/class160/Code01_SegmentTreeWithSegmentTree2.java
 rename src/class160/{Code01_NestedTree1.java => Code02_IndexTreeWithSegmentTree1.java} (98%)
 rename src/class160/{Code01_NestedTree2.java => Code02_IndexTreeWithSegmentTree2.java} (99%)
 delete mode 100644 src/class160/Code02_LuckAndLove1.java

diff --git a/src/class160/Code01_SegmentTreeWithSegmentTree1.java b/src/class160/Code01_SegmentTreeWithSegmentTree1.java
new file mode 100644
index 000000000..2898ce5af
--- /dev/null
+++ b/src/class160/Code01_SegmentTreeWithSegmentTree1.java
@@ -0,0 +1,180 @@
+package class160;
+
+// 线段树套线段树，java版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=1823
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code01_SegmentTreeWithSegmentTree1 {
+
+	public static int MAXH = 101;
+
+	public static int MAXA = 1001;
+
+	public static int n = 1000, m;
+
+	public static int[][] tree = new int[MAXH << 2][MAXA << 2];
+
+	public static void ybuild(int yl, int yr, int xi, int yi) {
+		tree[xi][yi] = -1;
+		if (yl < yr) {
+			int mid = (yl + yr) / 2;
+			ybuild(yl, mid, xi, yi << 1);
+			ybuild(mid + 1, yr, xi, yi << 1 | 1);
+		}
+	}
+
+	public static void build(int xl, int xr, int xi) {
+		ybuild(0, n, xi, 1);
+		if (xl < xr) {
+			int mid = (xl + xr) / 2;
+			build(xl, mid, xi << 1);
+			build(mid + 1, xr, xi << 1 | 1);
+		}
+	}
+
+	public static void yupdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
+		if (yl == yr) {
+			tree[xi][yi] = Math.max(tree[xi][yi], jobv);
+		} else {
+			int mid = (yl + yr) / 2;
+			if (joby <= mid) {
+				yupdate(joby, jobv, yl, mid, xi, yi << 1);
+			} else {
+				yupdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
+			}
+			tree[xi][yi] = Math.max(tree[xi][yi << 1], tree[xi][yi << 1 | 1]);
+		}
+	}
+
+	public static void update(int jobx, int joby, int jobv, int xl, int xr, int xi) {
+		yupdate(joby, jobv, 0, n, xi, 1);
+		if (xl < xr) {
+			int mid = (xl + xr) / 2;
+			if (jobx <= mid) {
+				update(jobx, joby, jobv, xl, mid, xi << 1);
+			} else {
+				update(jobx, joby, jobv, mid + 1, xr, xi << 1 | 1);
+			}
+		}
+	}
+
+	public static int yquery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
+		if (jobyl <= yl && yr <= jobyr) {
+			return tree[xi][yi];
+		}
+		int mid = (yl + yr) / 2;
+		int ans = -1;
+		if (jobyl <= mid) {
+			ans = yquery(jobyl, jobyr, yl, mid, xi, yi << 1);
+
+		}
+		if (jobyr > mid) {
+			ans = Math.max(ans, yquery(jobyl, jobyr, mid + 1, yr, xi, yi << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static int query(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
+		if (jobxl <= xl && xr <= jobxr) {
+			return yquery(jobyl, jobyr, 0, n, xi, 1);
+		}
+		int mid = (xl + xr) / 2;
+		int ans = -1;
+		if (jobxl <= mid) {
+			ans = query(jobxl, jobxr, jobyl, jobyr, xl, mid, xi << 1);
+		}
+		if (jobxr > mid) {
+			ans = Math.max(ans, query(jobxl, jobxr, jobyl, jobyr, mid + 1, xr, xi << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		m = io.nextInt();
+		String op;
+		int a, b, c, d;
+		while (m != 0) {
+			build(100, 200, 1);
+			for (int i = 1; i <= m; i++) {
+				op = io.next();
+				if (op.equals("I")) {
+					a = io.nextInt();
+					b = (int) (io.nextDouble() * 10);
+					c = (int) (io.nextDouble() * 10);
+					update(a, b, c, 100, 200, 1);
+				} else {
+					a = io.nextInt();
+					b = io.nextInt();
+					c = (int) (io.nextDouble() * 10);
+					d = (int) (io.nextDouble() * 10);
+					int xl = Math.min(a, b);
+					int xr = Math.max(a, b);
+					int yl = Math.min(c, d);
+					int yr = Math.max(c, d);
+					int ans = query(xl, xr, yl, yr, 100, 200, 1);
+					if (ans == -1) {
+						io.println(ans);
+					} else {
+						io.println(((double) ans) / 10);
+					}
+				}
+			}
+			m = io.nextInt();
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class160/Code01_SegmentTreeWithSegmentTree2.java b/src/class160/Code01_SegmentTreeWithSegmentTree2.java
new file mode 100644
index 000000000..b8bc5a2d5
--- /dev/null
+++ b/src/class160/Code01_SegmentTreeWithSegmentTree2.java
@@ -0,0 +1,126 @@
+package class160;
+
+// 线段树套线段树，C++版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=1823
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXH = 101;
+//const int MAXA = 1001;
+//int n = 1000, m;
+//int tree[MAXH << 2][MAXA << 2];
+//
+//void ybuild(int yl, int yr, int xi, int yi) {
+//    tree[xi][yi] = -1;
+//    if (yl < yr) {
+//        int mid = (yl + yr) >> 1;
+//        ybuild(yl, mid, xi, yi << 1);
+//        ybuild(mid + 1, yr, xi, yi << 1 | 1);
+//    }
+//}
+//
+//void build(int xl, int xr, int xi) {
+//    ybuild(0, n, xi, 1);
+//    if (xl < xr) {
+//        int mid = (xl + xr) >> 1;
+//        build(xl, mid, xi << 1);
+//        build(mid + 1, xr, xi << 1 | 1);
+//    }
+//}
+//
+//void yupdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
+//    if (yl == yr) {
+//        tree[xi][yi] = max(tree[xi][yi], jobv);
+//    } else {
+//        int mid = (yl + yr) >> 1;
+//        if (joby <= mid) {
+//            yupdate(joby, jobv, yl, mid, xi, yi << 1);
+//        } else {
+//            yupdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
+//        }
+//        tree[xi][yi] = max(tree[xi][yi << 1], tree[xi][(yi << 1) | 1]);
+//    }
+//}
+//
+//void update(int jobx, int joby, int jobv, int xl, int xr, int xi) {
+//    yupdate(joby, jobv, 0, n, xi, 1);
+//    if (xl < xr) {
+//        int mid = (xl + xr) >> 1;
+//        if (jobx <= mid) {
+//            update(jobx, joby, jobv, xl, mid, xi << 1);
+//        } else {
+//            update(jobx, joby, jobv, mid + 1, xr, xi << 1 | 1);
+//        }
+//    }
+//}
+//
+//int yquery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
+//    if (jobyl <= yl && yr <= jobyr) {
+//        return tree[xi][yi];
+//    }
+//    int mid = (yl + yr) >> 1;
+//    int ans = -1;
+//    if (jobyl <= mid) {
+//        ans = max(ans, yquery(jobyl, jobyr, yl, mid, xi, yi << 1));
+//    }
+//    if (jobyr > mid) {
+//        ans = max(ans, yquery(jobyl, jobyr, mid + 1, yr, xi, (yi << 1) | 1));
+//    }
+//    return ans;
+//}
+//
+//int query(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
+//    if (jobxl <= xl && xr <= jobxr) {
+//        return yquery(jobyl, jobyr, 0, n, xi, 1);
+//    }
+//    int mid = (xl + xr) >> 1;
+//    int ans = -1;
+//    if (jobxl <= mid) {
+//        ans = max(ans, query(jobxl, jobxr, jobyl, jobyr, xl, mid, xi << 1));
+//    }
+//    if (jobxr > mid) {
+//        ans = max(ans, query(jobxl, jobxr, jobyl, jobyr, mid + 1, xr, (xi << 1) | 1));
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//	scanf("%d", &m);
+//	while(m != 0) {
+//        build(100, 200, 1);
+//        for (int i = 0; i < m; i++) {
+//        	char op[2];
+//            scanf("%s", op);
+//            if (op[0] == 'I') {
+//                int a;
+//                double bd, cd;
+//                scanf("%d %lf %lf", &a, &bd, &cd);
+//                int b = (int)(bd * 10);
+//                int c = (int)(cd * 10);
+//                update(a, b, c, 100, 200, 1);
+//            } else {
+//                int a, b;
+//                double cd, dd;
+//                scanf("%d %d %lf %lf", &a, &b, &cd, &dd);
+//                int c = (int)(cd * 10);
+//                int d = (int)(dd * 10);
+//                int xl = min(a, b);
+//                int xr = max(a, b);
+//                int yl = min(c, d);
+//                int yr = max(c, d);
+//                int ans = query(xl, xr, yl, yr, 100, 200, 1);
+//                if (ans == -1) {
+//                    printf("-1\n");
+//                } else {
+//                    printf("%.1f\n", ans / 10.0);
+//                }
+//            }
+//        }
+//        scanf("%d", &m);
+//	}
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class160/Code01_NestedTree1.java b/src/class160/Code02_IndexTreeWithSegmentTree1.java
similarity index 98%
rename from src/class160/Code01_NestedTree1.java
rename to src/class160/Code02_IndexTreeWithSegmentTree1.java
index 75ccb5fc8..b8b79a7d4 100644
--- a/src/class160/Code01_NestedTree1.java
+++ b/src/class160/Code02_IndexTreeWithSegmentTree1.java
@@ -1,6 +1,6 @@
 package class160;
 
-// 树套树，java版
+// 树状数组套线段树，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code01_NestedTree1 {
+public class Code02_IndexTreeWithSegmentTree1 {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class160/Code01_NestedTree2.java b/src/class160/Code02_IndexTreeWithSegmentTree2.java
similarity index 99%
rename from src/class160/Code01_NestedTree2.java
rename to src/class160/Code02_IndexTreeWithSegmentTree2.java
index a7c32d7fc..28ef4e6d2 100644
--- a/src/class160/Code01_NestedTree2.java
+++ b/src/class160/Code02_IndexTreeWithSegmentTree2.java
@@ -1,6 +1,6 @@
 package class160;
 
-// 树套树，C++版
+// 树状数组套线段树，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class160/Code02_LuckAndLove1.java b/src/class160/Code02_LuckAndLove1.java
deleted file mode 100644
index b61c28932..000000000
--- a/src/class160/Code02_LuckAndLove1.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package class160;
-
-// 线段树套线段树，java版
-// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=1823
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code02_LuckAndLove1 {
-
-}

From 3bcf3a9416ab060416f6e51b4a577e5bdf850822 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Feb 2025 23:51:28 +0800
Subject: [PATCH 0427/1712] modify code

---
 src/class160/Code03_QueryKthMaximum1.java | 193 ++++++++++++++++++++++
 src/class160/Code03_QueryKthMaximum2.java | 147 ++++++++++++++++
 2 files changed, 340 insertions(+)
 create mode 100644 src/class160/Code03_QueryKthMaximum1.java
 create mode 100644 src/class160/Code03_QueryKthMaximum2.java

diff --git a/src/class160/Code03_QueryKthMaximum1.java b/src/class160/Code03_QueryKthMaximum1.java
new file mode 100644
index 000000000..e891d9695
--- /dev/null
+++ b/src/class160/Code03_QueryKthMaximum1.java
@@ -0,0 +1,193 @@
+package class160;
+
+// K大数查询，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3332
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_QueryKthMaximum1 {
+
+	public static int MAXN = 50001;
+
+	public static int MAXT = MAXN * 230;
+
+	public static int n, m, s;
+
+	public static int[][] ques = new int[MAXN][4];
+
+	public static int[] sorted = new int[MAXN];
+
+	public static int[] root = new int[MAXN << 2];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static long[] sum = new long[MAXT];
+
+	public static int[] lazy = new int[MAXT];
+
+	public static int cntt;
+
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[left[i]] + sum[right[i]];
+	}
+
+	public static void down(int i, int ln, int rn) {
+		if (lazy[i] != 0) {
+			if (left[i] == 0) {
+				left[i] = ++cntt;
+			}
+			if (right[i] == 0) {
+				right[i] = ++cntt;
+			}
+			sum[left[i]] += lazy[i] * ln;
+			lazy[left[i]] += lazy[i];
+			sum[right[i]] += lazy[i] * rn;
+			lazy[right[i]] += lazy[i];
+			lazy[i] = 0;
+		}
+	}
+
+	public static int update(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			i = ++cntt;
+		}
+		if (jobl <= l && r <= jobr) {
+			sum[i] += r - l + 1;
+			lazy[i]++;
+		} else {
+			int mid = (l + r) / 2;
+			down(i, mid - l + 1, r - mid);
+			if (jobl <= mid) {
+				left[i] = update(jobl, jobr, l, mid, left[i]);
+			}
+			if (jobr > mid) {
+				right[i] = update(jobl, jobr, mid + 1, r, right[i]);
+			}
+			up(i);
+		}
+		return i;
+	}
+
+	public static long querySum(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		down(i, mid - l + 1, r - mid);
+		long ans = 0;
+		if (jobl <= mid) {
+			ans += querySum(jobl, jobr, l, mid, left[i]);
+		}
+		if (jobr > mid) {
+			ans += querySum(jobl, jobr, mid + 1, r, right[i]);
+		}
+		return ans;
+	}
+
+	public static void add(int jobl, int jobr, int jobk, int l, int r, int i) {
+		root[i] = update(jobl, jobr, 1, n, root[i]);
+		if (l < r) {
+			int mid = (l + r) / 2;
+			if (jobk <= mid) {
+				add(jobl, jobr, jobk, l, mid, i << 1);
+			} else {
+				add(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static int query(int jobl, int jobr, long jobk, int l, int r, int i) {
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) / 2;
+		long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
+		if (jobk > rightsum) {
+			return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
+		} else {
+			return query(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+		}
+	}
+
+	public static void prepare() {
+		s = 0;
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 1) {
+				sorted[++s] = ques[i][3];
+			}
+		}
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 1) {
+				ques[i][3] = kth(ques[i][3]);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			ques[i][0] = (int) in.nval;
+			in.nextToken();
+			ques[i][1] = (int) in.nval;
+			in.nextToken();
+			ques[i][2] = (int) in.nval;
+			in.nextToken();
+			ques[i][3] = (int) in.nval;
+		}
+		prepare();
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 1) {
+				add(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+			} else {
+				int idx = query(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+				out.println(sorted[idx]);
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class160/Code03_QueryKthMaximum2.java b/src/class160/Code03_QueryKthMaximum2.java
new file mode 100644
index 000000000..8fa2233c1
--- /dev/null
+++ b/src/class160/Code03_QueryKthMaximum2.java
@@ -0,0 +1,147 @@
+package class160;
+
+// K大数查询，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3332
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50001;
+//const int MAXT = MAXN * 230;
+//int n, m, s;
+//int ques[MAXN][4];
+//int sorted[MAXN];
+//int root[MAXN << 2];
+//int ls[MAXT];
+//int rs[MAXT];
+//long long sum[MAXT];
+//int lazy[MAXT];
+//int cntt;
+//
+//int kth(int num) {
+//    int l = 1, r = s;
+//    while (l <= r) {
+//        int mid = (l + r) >> 1;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            l = mid + 1;
+//        } else {
+//            r = mid - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
+//void up(int i) {
+//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//}
+//
+//void down(int i, int ln, int rn) {
+//    if (lazy[i]) {
+//        if (!ls[i]) ls[i] = ++cntt;
+//        if (!rs[i]) rs[i] = ++cntt;
+//        sum[ls[i]] += 1LL * lazy[i] * ln;
+//        lazy[ls[i]] += lazy[i];
+//        sum[rs[i]] += 1LL * lazy[i] * rn;
+//        lazy[rs[i]] += lazy[i];
+//        lazy[i] = 0;
+//    }
+//}
+//
+//int update(int jobl, int jobr, int l, int r, int i) {
+//    if (!i) i = ++cntt;
+//    if (jobl <= l && r <= jobr) {
+//        sum[i] += (long long)(r - l + 1);
+//        lazy[i]++;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        down(i, mid - l + 1, r - mid);
+//        if (jobl <= mid) ls[i] = update(jobl, jobr, l, mid, ls[i]);
+//        if (jobr > mid) rs[i] = update(jobl, jobr, mid + 1, r, rs[i]);
+//        up(i);
+//    }
+//    return i;
+//}
+//
+//long long querySum(int jobl, int jobr, int l, int r, int i) {
+//    if (!i) return 0;
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i];
+//    }
+//    int mid = (l + r) >> 1;
+//    down(i, mid - l + 1, r - mid);
+//    long long ans = 0;
+//    if (jobl <= mid) ans += querySum(jobl, jobr, l, mid, ls[i]);
+//    if (jobr > mid) ans += querySum(jobl, jobr, mid + 1, r, rs[i]);
+//    return ans;
+//}
+//
+//void add(int jobl, int jobr, int jobk, int l, int r, int i) {
+//    root[i] = update(jobl, jobr, 1, n, root[i]);
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        if (jobk <= mid) {
+//            add(jobl, jobr, jobk, l, mid, i << 1);
+//        } else {
+//            add(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//int query(int jobl, int jobr, long long jobk, int l, int r, int i) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) >> 1;
+//    long long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
+//    if (jobk > rightsum) {
+//        return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
+//    } else {
+//        return query(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+//    }
+//}
+//
+//void prepare() {
+//    s = 0;
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 1) {
+//            sorted[++s] = ques[i][3];
+//        }
+//    }
+//    sort(sorted + 1, sorted + s + 1);
+//    int len = 1;
+//    for (int i = 2; i <= s; i++) {
+//        if (sorted[len] != sorted[i]) {
+//            sorted[++len] = sorted[i];
+//        }
+//    }
+//    s = len;
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 1) {
+//            ques[i][3] = kth(ques[i][3]);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> ques[i][0] >> ques[i][1] >> ques[i][2] >> ques[i][3];
+//    }
+//    prepare();
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 1) {
+//            add(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+//        } else {
+//            int idx = query(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+//            cout << sorted[idx] << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From b122c52e344173959cbdcd0feae6faf41558fa1a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Feb 2025 23:59:40 +0800
Subject: [PATCH 0428/1712] modify code

---
 src/class160/Code03_QueryKthMaximum1.java | 6 +++---
 src/class160/Code03_QueryKthMaximum2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class160/Code03_QueryKthMaximum1.java b/src/class160/Code03_QueryKthMaximum1.java
index e891d9695..7fa344a7e 100644
--- a/src/class160/Code03_QueryKthMaximum1.java
+++ b/src/class160/Code03_QueryKthMaximum1.java
@@ -24,7 +24,7 @@ public class Code03_QueryKthMaximum1 {
 
 	public static int[] sorted = new int[MAXN];
 
-	public static int[] root = new int[MAXN << 2];
+	public static int[] outer = new int[MAXN << 2];
 
 	public static int[] left = new int[MAXT];
 
@@ -112,7 +112,7 @@ public static long querySum(int jobl, int jobr, int l, int r, int i) {
 	}
 
 	public static void add(int jobl, int jobr, int jobk, int l, int r, int i) {
-		root[i] = update(jobl, jobr, 1, n, root[i]);
+		outer[i] = update(jobl, jobr, 1, n, outer[i]);
 		if (l < r) {
 			int mid = (l + r) / 2;
 			if (jobk <= mid) {
@@ -128,7 +128,7 @@ public static int query(int jobl, int jobr, long jobk, int l, int r, int i) {
 			return l;
 		}
 		int mid = (l + r) / 2;
-		long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
+		long rightsum = querySum(jobl, jobr, 1, n, outer[i << 1 | 1]);
 		if (jobk > rightsum) {
 			return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
 		} else {
diff --git a/src/class160/Code03_QueryKthMaximum2.java b/src/class160/Code03_QueryKthMaximum2.java
index 8fa2233c1..797f39e8e 100644
--- a/src/class160/Code03_QueryKthMaximum2.java
+++ b/src/class160/Code03_QueryKthMaximum2.java
@@ -14,7 +14,7 @@
 //int n, m, s;
 //int ques[MAXN][4];
 //int sorted[MAXN];
-//int root[MAXN << 2];
+//int outer[MAXN << 2];
 //int ls[MAXT];
 //int rs[MAXT];
 //long long sum[MAXT];
@@ -81,7 +81,7 @@
 //}
 //
 //void add(int jobl, int jobr, int jobk, int l, int r, int i) {
-//    root[i] = update(jobl, jobr, 1, n, root[i]);
+//    outer[i] = update(jobl, jobr, 1, n, outer[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
 //        if (jobk <= mid) {
@@ -97,7 +97,7 @@
 //        return l;
 //    }
 //    int mid = (l + r) >> 1;
-//    long long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
+//    long long rightsum = querySum(jobl, jobr, 1, n, outer[i << 1 | 1]);
 //    if (jobk > rightsum) {
 //        return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
 //    } else {

From 1ba7a2a034606868c98ec477f0bcbbd2ed9f652b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Feb 2025 17:24:24 +0800
Subject: [PATCH 0429/1712] modify code

---
 src/class160/Code04_NetworkManagement1.java | 356 ++++++++++++++++++++
 src/class160/Code04_NetworkManagement2.java | 189 +++++++++++
 2 files changed, 545 insertions(+)
 create mode 100644 src/class160/Code04_NetworkManagement1.java
 create mode 100644 src/class160/Code04_NetworkManagement2.java

diff --git a/src/class160/Code04_NetworkManagement1.java b/src/class160/Code04_NetworkManagement1.java
new file mode 100644
index 000000000..3838c132a
--- /dev/null
+++ b/src/class160/Code04_NetworkManagement1.java
@@ -0,0 +1,356 @@
+package class160;
+
+// 网络管理，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4175
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code04_NetworkManagement1 {
+
+	public static int MAXN = 100001;
+
+	public static int MAXT = MAXN * 200;
+
+	public static int MAXH = 20;
+
+	public static int n, m, s;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[][] ques = new int[MAXN][3];
+
+	public static int[] sorted = new int[MAXN << 1];
+
+	// 链式前向星需要
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	// 注意这不是主席树！而是若干棵动态开点权值线段树！
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static int[] sum = new int[MAXT];
+
+	public static int cntt = 0;
+
+	// 树上倍增需要
+	public static int[] deep = new int[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int[][] stjump = new int[MAXN][MAXH];
+
+	public static int cntd = 0;
+
+	public static int[] pos = new int[MAXN];
+
+	public static int[] pre = new int[MAXN];
+
+	public static int cntpos;
+
+	public static int cntpre;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[left[i]] + sum[right[i]];
+	}
+
+	public static int add(int jobi, int jobv, int l, int r, int i) {
+		if (i == 0) {
+			i = ++cntt;
+		}
+		if (l == r) {
+			sum[i] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[i] = add(jobi, jobv, l, mid, left[i]);
+			} else {
+				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
+			}
+			up(i);
+		}
+		return i;
+	}
+
+	public static void add(int i, int kth, int val) {
+		for (; i <= n; i += lowbit(i)) {
+			root[i] = add(kth, val, 1, s, root[i]);
+		}
+	}
+
+	public static int queryNumber(int jobk, int l, int r) {
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) / 2;
+		int leftsum = 0;
+		for (int i = 1; i <= cntpos; i++) {
+			leftsum += sum[left[pos[i]]];
+		}
+		for (int i = 1; i <= cntpre; i++) {
+			leftsum -= sum[left[pre[i]]];
+		}
+		if (jobk <= leftsum) {
+			for (int i = 1; i <= cntpos; i++) {
+				pos[i] = left[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				pre[i] = left[pre[i]];
+			}
+			return queryNumber(jobk, l, mid);
+		} else {
+			for (int i = 1; i <= cntpos; i++) {
+				pos[i] = right[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				pre[i] = right[pre[i]];
+			}
+			return queryNumber(jobk - leftsum, mid + 1, r);
+		}
+	}
+
+	// dfs1是递归版，java版本提交会爆栈，C++版本不会爆栈
+	public static void dfs1(int u, int fa) {
+		deep[u] = deep[fa] + 1;
+		size[u] = 1;
+		dfn[u] = ++cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != fa) {
+				dfs1(to[e], u);
+			}
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != fa) {
+				size[u] += size[to[e]];
+			}
+		}
+	}
+
+	// dfs迭代版，都可以通过
+	// 讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stackSize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stackSize][0] = u;
+		ufe[stackSize][1] = f;
+		ufe[stackSize][2] = e;
+		stackSize++;
+	}
+
+	public static void pop() {
+		--stackSize;
+		u = ufe[stackSize][0];
+		f = ufe[stackSize][1];
+		e = ufe[stackSize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs2() {
+		stackSize = 0;
+		push(1, 0, -1);
+		while (stackSize > 0) {
+			pop();
+			if (e == -1) {
+				deep[u] = deep[f] + 1;
+				size[u] = 1;
+				dfn[u] = ++cntd;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				for (int e = head[u]; e > 0; e = next[e]) {
+					if (to[e] != f) {
+						size[u] += size[to[e]];
+					}
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (deep[a] < deep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (deep[stjump[a][p]] >= deep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static void prepare() {
+		s = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[++s] = arr[i];
+		}
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 0) {
+				sorted[++s] = ques[i][2];
+			}
+		}
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		dfs2();
+		for (int i = 1; i <= n; i++) {
+			add(dfn[i], arr[i], 1);
+			add(dfn[i] + size[i], arr[i], -1);
+		}
+	}
+
+	public static void change(int i, int v) {
+		add(dfn[i], arr[i], -1);
+		add(dfn[i] + size[i], arr[i], 1);
+		arr[i] = kth(v);
+		add(dfn[i], arr[i], 1);
+		add(dfn[i] + size[i], arr[i], -1);
+	}
+
+	public static int query(int x, int y, int k) {
+		int lca = lca(x, y);
+		int lcafa = stjump[lca][0];
+		int num = deep[x] + deep[y] - deep[lca] - deep[lcafa];
+		if (num < k) {
+			return -1;
+		}
+		cntpos = cntpre = 0;
+		for (int i = dfn[x]; i > 0; i -= lowbit(i)) {
+			pos[++cntpos] = root[i];
+		}
+		for (int i = dfn[y]; i > 0; i -= lowbit(i)) {
+			pos[++cntpos] = root[i];
+		}
+		for (int i = dfn[lca]; i > 0; i -= lowbit(i)) {
+			pre[++cntpre] = root[i];
+		}
+		for (int i = dfn[lcafa]; i > 0; i -= lowbit(i)) {
+			pre[++cntpre] = root[i];
+		}
+		return queryNumber(num - k + 1, 1, s);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			ques[i][0] = (int) in.nval;
+			in.nextToken();
+			ques[i][1] = (int) in.nval;
+			in.nextToken();
+			ques[i][2] = (int) in.nval;
+		}
+		prepare();
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 0) {
+				change(ques[i][1], ques[i][2]);
+			} else {
+				int ans = query(ques[i][1], ques[i][2], ques[i][0]);
+				if (ans == -1) {
+					out.println("invalid request!");
+				} else {
+					out.println(sorted[ans]);
+				}
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class160/Code04_NetworkManagement2.java b/src/class160/Code04_NetworkManagement2.java
new file mode 100644
index 000000000..e37efee61
--- /dev/null
+++ b/src/class160/Code04_NetworkManagement2.java
@@ -0,0 +1,189 @@
+package class160;
+
+// 网络管理，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4175
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXT = MAXN * 200;
+//const int MAXH = 20;
+//int n, m, s;
+//
+//int arr[MAXN];
+//int ques[MAXN][3];
+//int sorted[MAXN << 1];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int sum[MAXT];
+//int cntt;
+//
+//int deep[MAXN];
+//int size[MAXN];
+//int dfn[MAXN];
+//int stjump[MAXN][MAXH];
+//int cntd;
+//
+//int pos[MAXN];
+//int pre[MAXN];
+//int cntpos, cntpre;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int kth(int num) {
+//    int ls = 1, rs = s, mid;
+//    while (ls <= rs) {
+//        mid = (ls + rs) / 2;
+//        if (sorted[mid] == num) return mid;
+//        else if (sorted[mid] < num) ls = mid + 1;
+//        else rs = mid - 1;
+//    }
+//    return -1;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void up(int i) {
+//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//}
+//
+//int add(int jobi, int jobv, int l, int r, int i) {
+//    if (i == 0) i = ++cntt;
+//    if (l == r) sum[i] += jobv;
+//    else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) ls[i] = add(jobi, jobv, l, mid, ls[i]);
+//        else rs[i] = add(jobi, jobv, mid + 1, r, rs[i]);
+//        up(i);
+//    }
+//    return i;
+//}
+//
+//void add(int i, int kth, int val) {
+//    for (; i <= n; i += lowbit(i)) root[i] = add(kth, val, 1, s, root[i]);
+//}
+//
+//int queryNumber(int jobk, int l, int r) {
+//    if (l == r) return l;
+//    int mid = (l + r) / 2;
+//    int leftsum = 0;
+//    for (int i = 1; i <= cntpos; i++) leftsum += sum[ls[pos[i]]];
+//    for (int i = 1; i <= cntpre; i++) leftsum -= sum[ls[pre[i]]];
+//    if (jobk <= leftsum) {
+//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
+//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
+//        return queryNumber(jobk, l, mid);
+//    } else {
+//        for (int i = 1; i <= cntpos; i++) pos[i] = rs[pos[i]];
+//        for (int i = 1; i <= cntpre; i++) pre[i] = rs[pre[i]];
+//        return queryNumber(jobk - leftsum, mid + 1, r);
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    deep[u] = deep[fa] + 1;
+//    size[u] = 1;
+//    dfn[u] = ++cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        if (to[e] != fa) dfs(to[e], u);
+//    }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        if (to[e] != fa) size[u] += size[to[e]];
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    if (deep[a] < deep[b]) swap(a, b);
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (deep[stjump[a][p]] >= deep[b]) a = stjump[a][p];
+//    }
+//    if (a == b) return a;
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//void prepare() {
+//    s = 0;
+//    for (int i = 1; i <= n; i++) sorted[++s] = arr[i];
+//    for (int i = 1; i <= m; i++) if (ques[i][0] == 0) sorted[++s] = ques[i][2];
+//    sort(sorted + 1, sorted + s + 1);
+//    s = unique(sorted + 1, sorted + s + 1) - sorted - 1;
+//    for (int i = 1; i <= n; i++) arr[i] = kth(arr[i]);
+//    dfs(1, 0);
+//    for (int i = 1; i <= n; i++) {
+//        add(dfn[i], arr[i], 1);
+//        add(dfn[i] + size[i], arr[i], -1);
+//    }
+//}
+//
+//void change(int i, int v) {
+//    add(dfn[i], arr[i], -1);
+//    add(dfn[i] + size[i], arr[i], 1);
+//    arr[i] = kth(v);
+//    add(dfn[i], arr[i], 1);
+//    add(dfn[i] + size[i], arr[i], -1);
+//}
+//
+//int query(int x, int y, int k) {
+//    int xylca = lca(x, y);
+//    int lcafa = stjump[xylca][0];
+//    int num = deep[x] + deep[y] - deep[xylca] - deep[lcafa];
+//    if (num < k) return -1;
+//    cntpos = cntpre = 0;
+//    for (int i = dfn[x]; i; i -= lowbit(i)) pos[++cntpos] = root[i];
+//    for (int i = dfn[y]; i; i -= lowbit(i)) pos[++cntpos] = root[i];
+//    for (int i = dfn[xylca]; i; i -= lowbit(i)) pre[++cntpre] = root[i];
+//    for (int i = dfn[lcafa]; i; i -= lowbit(i)) pre[++cntpre] = root[i];
+//    return queryNumber(num - k + 1, 1, s);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(0);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) cin >> arr[i];
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= m; i++) cin >> ques[i][0] >> ques[i][1] >> ques[i][2];
+//    prepare();
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 0) {
+//            change(ques[i][1], ques[i][2]);
+//        } else {
+//            int ans = query(ques[i][1], ques[i][2], ques[i][0]);
+//            if(ans == -1) {
+//            	cout << "invalid request!" << "\n";
+//            } else {
+//            	cout << sorted[ans] << "\n";
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 9f24d27baefea9c2a99342be05814130c63dceef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Feb 2025 17:25:51 +0800
Subject: [PATCH 0430/1712] modify code

---
 src/class160/Code04_NetworkManagement1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class160/Code04_NetworkManagement1.java b/src/class160/Code04_NetworkManagement1.java
index 3838c132a..3b0a9719d 100644
--- a/src/class160/Code04_NetworkManagement1.java
+++ b/src/class160/Code04_NetworkManagement1.java
@@ -59,6 +59,7 @@ public class Code04_NetworkManagement1 {
 
 	public static int cntd = 0;
 
+	// 查询信息需要，所有pos版本的信息和 - 所有pre版本的信息和
 	public static int[] pos = new int[MAXN];
 
 	public static int[] pre = new int[MAXN];

From 15696cbcbc07d0b9144bac80540224855bacb050 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Feb 2025 17:33:45 +0800
Subject: [PATCH 0431/1712] modify code

---
 src/class160/Code04_NetworkManagement1.java | 6 +++---
 src/class160/Code04_NetworkManagement2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class160/Code04_NetworkManagement1.java b/src/class160/Code04_NetworkManagement1.java
index 3b0a9719d..79e221f9d 100644
--- a/src/class160/Code04_NetworkManagement1.java
+++ b/src/class160/Code04_NetworkManagement1.java
@@ -14,11 +14,11 @@
 
 public class Code04_NetworkManagement1 {
 
-	public static int MAXN = 100001;
+	public static int MAXN = 80001;
 
-	public static int MAXT = MAXN * 200;
+	public static int MAXT = MAXN * 110;
 
-	public static int MAXH = 20;
+	public static int MAXH = 18;
 
 	public static int n, m, s;
 
diff --git a/src/class160/Code04_NetworkManagement2.java b/src/class160/Code04_NetworkManagement2.java
index e37efee61..b8d014477 100644
--- a/src/class160/Code04_NetworkManagement2.java
+++ b/src/class160/Code04_NetworkManagement2.java
@@ -9,9 +9,9 @@
 //
 //using namespace std;
 //
-//const int MAXN = 100001;
-//const int MAXT = MAXN * 200;
-//const int MAXH = 20;
+//const int MAXN = 80001;
+//const int MAXT = MAXN * 110;
+//const int MAXH = 18;
 //int n, m, s;
 //
 //int arr[MAXN];

From e725135805c8b308213c0be6ec675d1ecd14e77f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Feb 2025 17:54:46 +0800
Subject: [PATCH 0432/1712] modify code

---
 .../Code02_IndexTreeWithSegmentTree1.java     |   6 +-
 .../Code02_IndexTreeWithSegmentTree2.java     | 255 ++++++++----------
 src/class160/Code03_QueryKthMaximum2.java     |   1 +
 src/class160/Code04_NetworkManagement1.java   |   6 +-
 src/class160/Code04_NetworkManagement2.java   |   8 +-
 5 files changed, 113 insertions(+), 163 deletions(-)

diff --git a/src/class160/Code02_IndexTreeWithSegmentTree1.java b/src/class160/Code02_IndexTreeWithSegmentTree1.java
index b8b79a7d4..5668779b6 100644
--- a/src/class160/Code02_IndexTreeWithSegmentTree1.java
+++ b/src/class160/Code02_IndexTreeWithSegmentTree1.java
@@ -66,10 +66,6 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	public static void up(int i) {
-		sum[i] = sum[left[i]] + sum[right[i]];
-	}
-
 	public static int add(int jobi, int jobv, int l, int r, int i) {
 		if (i == 0) {
 			i = ++cntt;
@@ -83,7 +79,7 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 			} else {
 				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
 			}
-			up(i);
+			sum[i] = sum[left[i]] + sum[right[i]];
 		}
 		return i;
 	}
diff --git a/src/class160/Code02_IndexTreeWithSegmentTree2.java b/src/class160/Code02_IndexTreeWithSegmentTree2.java
index 28ef4e6d2..89bcac3e9 100644
--- a/src/class160/Code02_IndexTreeWithSegmentTree2.java
+++ b/src/class160/Code02_IndexTreeWithSegmentTree2.java
@@ -12,201 +12,162 @@
 //const int MAXN = 50001;
 //const int MAXT = MAXN * 160;
 //const int INF = INT_MAX;
-//int n,m,s;
+//int n, m, s;
 //int arr[MAXN];
 //int ques[MAXN][4];
-//int sorted[MAXN*2];
+//int sorted[MAXN * 2];
+//
 //int root[MAXN];
 //int sum[MAXT];
 //int ls[MAXT];
 //int rs[MAXT];
 //int cntt;
+//
 //int pos[MAXN];
 //int pre[MAXN];
-//int cntpos,cntpre;
-//
-//int kth(int num){
-//    int l=1,r=s;
-//    while(l<=r){
-//        int mid=(l+r)>>1;
-//        if(sorted[mid]==num) return mid;
-//        if(sorted[mid]<num) l=mid+1;
-//        else r=mid-1;
+//int cntpos, cntpre;
+//
+//int kth(int num) {
+//    int l = 1, r = s;
+//    while (l <= r) {
+//        int mid = (l + r) >> 1;
+//        if (sorted[mid] == num) return mid;
+//        if (sorted[mid] < num) l = mid + 1;
+//        else r = mid - 1;
 //    }
 //    return -1;
 //}
 //
-//int lowbit(int x){
-//    return x&(-x);
+//int lowbit(int i) {
+//    return i & -i;
 //}
 //
-//void up(int i){
-//    sum[i]=sum[ls[i]]+sum[rs[i]];
-//}
-//
-//int add(int idx,int v,int L,int R,int i){
-//    if(!i) i=++cntt;
-//    if(L==R){
-//        sum[i]+=v;
+//int add(int jobi, int jobv, int l, int r, int i) {
+//    if (!i) i = ++cntt;
+//    if (l == r) {
+//        sum[i] += jobv;
 //    } else {
-//        int mid=(L+R)>>1;
-//        if(idx<=mid) ls[i]=add(idx,v,L,mid,ls[i]);
-//        else rs[i]=add(idx,v,mid+1,R,rs[i]);
-//        up(i);
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) ls[i] = add(jobi, jobv, l, mid, ls[i]);
+//        else rs[i] = add(jobi, jobv, mid + 1, r, rs[i]);
+//        sum[i] = sum[ls[i]] + sum[rs[i]];
 //    }
 //    return i;
 //}
 //
-//void add(int i,int v){
-//    for(int j=i;j<=n;j+=lowbit(j)){
-//        root[j]=add(arr[i],v,1,s,root[j]);
+//void add(int i, int v) {
+//    for (int j = i; j <= n; j += lowbit(j)) {
+//        root[j] = add(arr[i], v, 1, s, root[j]);
 //    }
 //}
 //
-//int queryNumber(int k,int L,int R){
-//    if(L==R) return L;
-//    int mid=(L+R)>>1;
-//    int leftsum=0;
-//    for(int i=1;i<=cntpos;i++){
-//        leftsum+=sum[ls[pos[i]]];
-//    }
-//    for(int i=1;i<=cntpre;i++){
-//        leftsum-=sum[ls[pre[i]]];
-//    }
-//    if(k<=leftsum){
-//        for(int i=1;i<=cntpos;i++){
-//            pos[i]=ls[pos[i]];
-//        }
-//        for(int i=1;i<=cntpre;i++){
-//            pre[i]=ls[pre[i]];
-//        }
-//        return queryNumber(k,L,mid);
+//int queryNumber(int jobk, int l, int r) {
+//    if (l == r) return l;
+//    int mid = (l + r) >> 1;
+//    int leftsum = 0;
+//    for (int i = 1; i <= cntpos; i++) leftsum += sum[ls[pos[i]]];
+//    for (int i = 1; i <= cntpre; i++) leftsum -= sum[ls[pre[i]]];
+//    
+//    if (jobk <= leftsum) {
+//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
+//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
+//        return queryNumber(jobk, l, mid);
 //    } else {
-//        for(int i=1;i<=cntpos;i++){
-//            pos[i]=rs[pos[i]];
-//        }
-//        for(int i=1;i<=cntpre;i++){
-//            pre[i]=rs[pre[i]];
-//        }
-//        return queryNumber(k-leftsum,mid+1,R);
+//        for (int i = 1; i <= cntpos; i++) pos[i] = rs[pos[i]];
+//        for (int i = 1; i <= cntpre; i++) pre[i] = rs[pre[i]];
+//        return queryNumber(jobk - leftsum, mid + 1, r);
 //    }
 //}
 //
-//int findNumber(int L,int R,int k){
-//    cntpos=cntpre=0;
-//    for(int i=R;i>0;i-=lowbit(i)){
-//        pos[++cntpos]=root[i];
-//    }
-//    for(int i=L-1;i>0;i-=lowbit(i)){
-//        pre[++cntpre]=root[i];
-//    }
-//    return queryNumber(k,1,s);
+//int findNumber(int l, int r, int k) {
+//    cntpos = cntpre = 0;
+//    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
+//    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
+//    return queryNumber(k, 1, s);
 //}
 //
-//int queryRank(int idx,int L,int R){
-//    if(L==R) return 0;
-//    int mid=(L+R)>>1;
-//    if(idx<=mid){
-//        for(int i=1;i<=cntpos;i++){
-//            pos[i]=ls[pos[i]];
-//        }
-//        for(int i=1;i<=cntpre;i++){
-//            pre[i]=ls[pre[i]];
-//        }
-//        return queryRank(idx,L,mid);
+//int queryRank(int jobi, int l, int r) {
+//    if (l == r) return 0;
+//    int mid = (l + r) >> 1;
+//    if (jobi <= mid) {
+//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
+//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
+//        return queryRank(jobi, l, mid);
 //    } else {
-//        int leftsum=0;
-//        for(int i=1;i<=cntpos;i++){
-//            leftsum+=sum[ls[pos[i]]];
-//            pos[i]=rs[pos[i]];
+//        int leftsum = 0;
+//        for (int i = 1; i <= cntpos; i++) {
+//            leftsum += sum[ls[pos[i]]];
+//            pos[i] = rs[pos[i]];
 //        }
-//        for(int i=1;i<=cntpre;i++){
-//            leftsum-=sum[ls[pre[i]]];
-//            pre[i]=rs[pre[i]];
+//        for (int i = 1; i <= cntpre; i++) {
+//            leftsum -= sum[ls[pre[i]]];
+//            pre[i] = rs[pre[i]];
 //        }
-//        return leftsum+queryRank(idx,mid+1,R);
+//        return leftsum + queryRank(jobi, mid + 1, r);
 //    }
 //}
 //
-//int findRank(int L,int R,int val){
-//    cntpos=cntpre=0;
-//    for(int i=R;i>0;i-=lowbit(i)){
-//        pos[++cntpos]=root[i];
-//    }
-//    for(int i=L-1;i>0;i-=lowbit(i)){
-//        pre[++cntpre]=root[i];
-//    }
-//    return queryRank(val,1,s)+1;
+//int findRank(int l, int r, int k) {
+//    cntpos = cntpre = 0;
+//    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
+//    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
+//    return queryRank(k, 1, s) + 1;
 //}
 //
-//int findLast(int L,int R,int k){
-//    int rk=findRank(L,R,k);
-//    if(rk==1) return 0;
-//    return findNumber(L,R,rk-1);
+//int findLast(int l, int r, int k) {
+//    int rk = findRank(l, r, k);
+//    return (rk == 1) ? 0 : findNumber(l, r, rk - 1);
 //}
 //
-//int findNext(int L,int R,int k){
-//    if(k==s) return s+1;
-//    int rk=findRank(L,R,k+1);
-//    if(rk==R-L+2) return s+1;
-//    return findNumber(L,R,rk);
+//int findNext(int l, int r, int k) {
+//    if (k == s) return s + 1;
+//    int rk = findRank(l, r, k + 1);
+//    return (rk == r - l + 2) ? s + 1 : findNumber(l, r, rk);
 //}
 //
-//void prepare(){
-//    s=0;
-//    for(int i=1;i<=n;i++){
-//        sorted[++s]=arr[i];
-//    }
-//    for(int i=1;i<=m;i++){
-//        if(ques[i][0]==3){
-//            sorted[++s]=ques[i][2];
-//        } else if(ques[i][0]!=2){
-//            sorted[++s]=ques[i][3];
-//        }
-//    }
-//    sort(sorted+1,sorted+s+1);
-//    int len=1;
-//    for(int i=2;i<=s;i++){
-//        if(sorted[len]!=sorted[i]){
-//            sorted[++len]=sorted[i];
-//        }
-//    }
-//    s=len;
-//    for(int i=1;i<=n;i++){
-//        arr[i]=kth(arr[i]);
-//        add(i,1);
-//    }
-//    sorted[0]=-INF;
-//    sorted[s+1]=INF;
+//void prepare() {
+//    s = 0;
+//    for (int i = 1; i <= n; i++) sorted[++s] = arr[i];
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 3) sorted[++s] = ques[i][2];
+//        else if (ques[i][0] != 2) sorted[++s] = ques[i][3];
+//    }
+//    sort(sorted + 1, sorted + s + 1);
+//    int len = 1;
+//    for (int i = 2; i <= s; i++)
+//        if (sorted[len] != sorted[i]) sorted[++len] = sorted[i];
+//    s = len;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//        add(i, 1);
+//    }
+//    sorted[0] = -INF;
+//    sorted[s + 1] = INF;
 //}
 //
-//int main(){
+//int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin>>n>>m;
-//    for(int i=1;i<=n;i++){
-//        cin>>arr[i];
-//    }
-//    for(int i=1;i<=m;i++){
-//        cin>>ques[i][0]>>ques[i][1]>>ques[i][2];
-//        if(ques[i][0]!=3){
-//            cin>>ques[i][3];
-//        }
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) cin >> arr[i];
+//    for (int i = 1; i <= m; i++) {
+//        cin >> ques[i][0] >> ques[i][1] >> ques[i][2];
+//        if (ques[i][0] != 3) cin >> ques[i][3];
 //    }
 //    prepare();
-//    for(int i=1;i<=m;i++){
-//        if(ques[i][0]==1){
-//            cout<<findRank(ques[i][1],ques[i][2],kth(ques[i][3]))<<"\n";
-//        } else if(ques[i][0]==2){
-//            cout<<sorted[findNumber(ques[i][1],ques[i][2],ques[i][3])]<< "\n";
-//        } else if(ques[i][0]==3){
-//            add(ques[i][1],-1);
-//            arr[ques[i][1]]=kth(ques[i][2]);
-//            add(ques[i][1],1);
-//        } else if(ques[i][0]==4){
-//            cout<<sorted[findLast(ques[i][1],ques[i][2],kth(ques[i][3]))]<<"\n";
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 1) {
+//            cout << findRank(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
+//        } else if (ques[i][0] == 2) {
+//            cout << sorted[findNumber(ques[i][1], ques[i][2], ques[i][3])] << "\n";
+//        } else if (ques[i][0] == 3) {
+//            add(ques[i][1], -1);
+//            arr[ques[i][1]] = kth(ques[i][2]);
+//            add(ques[i][1], 1);
+//        } else if (ques[i][0] == 4) {
+//            cout << sorted[findLast(ques[i][1], ques[i][2], kth(ques[i][3]))] << "\n";
 //        } else {
-//            cout<<sorted[findNext(ques[i][1],ques[i][2],kth(ques[i][3]))]<<"\n";
+//            cout << sorted[findNext(ques[i][1], ques[i][2], kth(ques[i][3]))] << "\n";
 //        }
 //    }
 //    return 0;
diff --git a/src/class160/Code03_QueryKthMaximum2.java b/src/class160/Code03_QueryKthMaximum2.java
index 797f39e8e..39d17cb50 100644
--- a/src/class160/Code03_QueryKthMaximum2.java
+++ b/src/class160/Code03_QueryKthMaximum2.java
@@ -14,6 +14,7 @@
 //int n, m, s;
 //int ques[MAXN][4];
 //int sorted[MAXN];
+//
 //int outer[MAXN << 2];
 //int ls[MAXT];
 //int rs[MAXT];
diff --git a/src/class160/Code04_NetworkManagement1.java b/src/class160/Code04_NetworkManagement1.java
index 79e221f9d..1f431d142 100644
--- a/src/class160/Code04_NetworkManagement1.java
+++ b/src/class160/Code04_NetworkManagement1.java
@@ -93,10 +93,6 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	public static void up(int i) {
-		sum[i] = sum[left[i]] + sum[right[i]];
-	}
-
 	public static int add(int jobi, int jobv, int l, int r, int i) {
 		if (i == 0) {
 			i = ++cntt;
@@ -110,7 +106,7 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 			} else {
 				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
 			}
-			up(i);
+			sum[i] = sum[left[i]] + sum[right[i]];
 		}
 		return i;
 	}
diff --git a/src/class160/Code04_NetworkManagement2.java b/src/class160/Code04_NetworkManagement2.java
index b8d014477..e17f3b50a 100644
--- a/src/class160/Code04_NetworkManagement2.java
+++ b/src/class160/Code04_NetworkManagement2.java
@@ -60,10 +60,6 @@
 //    return i & -i;
 //}
 //
-//void up(int i) {
-//    sum[i] = sum[ls[i]] + sum[rs[i]];
-//}
-//
 //int add(int jobi, int jobv, int l, int r, int i) {
 //    if (i == 0) i = ++cntt;
 //    if (l == r) sum[i] += jobv;
@@ -71,7 +67,7 @@
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) ls[i] = add(jobi, jobv, l, mid, ls[i]);
 //        else rs[i] = add(jobi, jobv, mid + 1, r, rs[i]);
-//        up(i);
+//        sum[i] = sum[ls[i]] + sum[rs[i]];
 //    }
 //    return i;
 //}
@@ -163,7 +159,7 @@
 //
 //int main() {
 //    ios::sync_with_stdio(false);
-//    cin.tie(0);
+//    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) cin >> arr[i];
 //    for (int i = 1, u, v; i < n; i++) {

From cea63516cc926ac1e814ed3e41c32b960a924d6e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Feb 2025 20:07:25 +0800
Subject: [PATCH 0433/1712] modify code

---
 ...ode03_QueryKthMaximum1.java => Code02_QueryKthMaximum1.java} | 2 +-
 ...ode03_QueryKthMaximum2.java => Code02_QueryKthMaximum2.java} | 0
 ...hSegmentTree1.java => Code03_IndexTreeWithSegmentTree1.java} | 2 +-
 ...hSegmentTree2.java => Code03_IndexTreeWithSegmentTree2.java} | 0
 ...4_NetworkManagement1.java => Code05_NetworkManagement1.java} | 2 +-
 ...4_NetworkManagement2.java => Code05_NetworkManagement2.java} | 0
 6 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class160/{Code03_QueryKthMaximum1.java => Code02_QueryKthMaximum1.java} (99%)
 rename src/class160/{Code03_QueryKthMaximum2.java => Code02_QueryKthMaximum2.java} (100%)
 rename src/class160/{Code02_IndexTreeWithSegmentTree1.java => Code03_IndexTreeWithSegmentTree1.java} (99%)
 rename src/class160/{Code02_IndexTreeWithSegmentTree2.java => Code03_IndexTreeWithSegmentTree2.java} (100%)
 rename src/class160/{Code04_NetworkManagement1.java => Code05_NetworkManagement1.java} (99%)
 rename src/class160/{Code04_NetworkManagement2.java => Code05_NetworkManagement2.java} (100%)

diff --git a/src/class160/Code03_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
similarity index 99%
rename from src/class160/Code03_QueryKthMaximum1.java
rename to src/class160/Code02_QueryKthMaximum1.java
index 7fa344a7e..b22ab5622 100644
--- a/src/class160/Code03_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_QueryKthMaximum1 {
+public class Code02_QueryKthMaximum1 {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class160/Code03_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
similarity index 100%
rename from src/class160/Code03_QueryKthMaximum2.java
rename to src/class160/Code02_QueryKthMaximum2.java
diff --git a/src/class160/Code02_IndexTreeWithSegmentTree1.java b/src/class160/Code03_IndexTreeWithSegmentTree1.java
similarity index 99%
rename from src/class160/Code02_IndexTreeWithSegmentTree1.java
rename to src/class160/Code03_IndexTreeWithSegmentTree1.java
index 5668779b6..daf93c7b5 100644
--- a/src/class160/Code02_IndexTreeWithSegmentTree1.java
+++ b/src/class160/Code03_IndexTreeWithSegmentTree1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code02_IndexTreeWithSegmentTree1 {
+public class Code03_IndexTreeWithSegmentTree1 {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class160/Code02_IndexTreeWithSegmentTree2.java b/src/class160/Code03_IndexTreeWithSegmentTree2.java
similarity index 100%
rename from src/class160/Code02_IndexTreeWithSegmentTree2.java
rename to src/class160/Code03_IndexTreeWithSegmentTree2.java
diff --git a/src/class160/Code04_NetworkManagement1.java b/src/class160/Code05_NetworkManagement1.java
similarity index 99%
rename from src/class160/Code04_NetworkManagement1.java
rename to src/class160/Code05_NetworkManagement1.java
index 1f431d142..eafceab1f 100644
--- a/src/class160/Code04_NetworkManagement1.java
+++ b/src/class160/Code05_NetworkManagement1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_NetworkManagement1 {
+public class Code05_NetworkManagement1 {
 
 	public static int MAXN = 80001;
 
diff --git a/src/class160/Code04_NetworkManagement2.java b/src/class160/Code05_NetworkManagement2.java
similarity index 100%
rename from src/class160/Code04_NetworkManagement2.java
rename to src/class160/Code05_NetworkManagement2.java

From 789bf1d4995f56da3e096c02cdf0e0f8da1082e5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Feb 2025 21:51:15 +0800
Subject: [PATCH 0434/1712] modify code

---
 src/class160/Code04_LineUp1.java | 188 +++++++++++++++++++++++++++++++
 src/class160/Code04_LineUp2.java | 121 ++++++++++++++++++++
 2 files changed, 309 insertions(+)
 create mode 100644 src/class160/Code04_LineUp1.java
 create mode 100644 src/class160/Code04_LineUp2.java

diff --git a/src/class160/Code04_LineUp1.java b/src/class160/Code04_LineUp1.java
new file mode 100644
index 000000000..23001bcd6
--- /dev/null
+++ b/src/class160/Code04_LineUp1.java
@@ -0,0 +1,188 @@
+package class160;
+
+// 排队，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1975
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code04_LineUp1 {
+
+	public static int MAXN = 20001;
+
+	public static int MAXT = MAXN * 80;
+
+	public static int INF = 1000000001;
+
+	public static int n, m, s;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] sorted = new int[MAXN + 2];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static int[] sum = new int[MAXT];
+
+	public static int cnt = 0;
+
+	public static int ans = 0;
+
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static int add(int jobi, int jobv, int l, int r, int i) {
+		if (i == 0) {
+			i = ++cnt;
+		}
+		if (l == r) {
+			sum[i] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[i] = add(jobi, jobv, l, mid, left[i]);
+			} else {
+				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
+			}
+			sum[i] = sum[left[i]] + sum[right[i]];
+		}
+		return i;
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, l, mid, left[i]);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, mid + 1, r, right[i]);
+		}
+		return ans;
+	}
+
+	public static void insert(int i, int v) {
+		for (int j = i; j <= n; j += lowbit(j)) {
+			root[j] = add(arr[i], v, 1, s, root[j]);
+		}
+	}
+
+	public static int queryCnt(int al, int ar, int numl, int numr) {
+		int ans = 0;
+		for (int i = ar; i > 0; i -= lowbit(i)) {
+			ans += query(numl, numr, 1, s, root[i]);
+		}
+		for (int i = al - 1; i > 0; i -= lowbit(i)) {
+			ans -= query(numl, numr, 1, s, root[i]);
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		s = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[++s] = arr[i];
+		}
+		sorted[++s] = -INF;
+		sorted[++s] = INF;
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+			insert(i, 1);
+		}
+	}
+
+	public static void compute(int a, int b) {
+		ans -= queryCnt(a + 1, b - 1, 1, arr[a] - 1);
+		ans += queryCnt(a + 1, b - 1, arr[a] + 1, s);
+		ans -= queryCnt(a + 1, b - 1, arr[b] + 1, s);
+		ans += queryCnt(a + 1, b - 1, 1, arr[b] - 1);
+		if (arr[a] < arr[b]) {
+			ans++;
+		} else if (arr[a] > arr[b]) {
+			ans--;
+		}
+		insert(a, -1);
+		insert(b, -1);
+		int tmp = arr[a];
+		arr[a] = arr[b];
+		arr[b] = tmp;
+		insert(a, 1);
+		insert(b, 1);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		prepare();
+		for (int i = 2; i <= n; i++) {
+			ans += queryCnt(1, i - 1, arr[i] + 1, s);
+		}
+		out.println(ans);
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, a, b; i <= m; i++) {
+			in.nextToken();
+			a = (int) in.nval;
+			in.nextToken();
+			b = (int) in.nval;
+			if (a > b) {
+				int tmp = a;
+				a = b;
+				b = tmp;
+			}
+			compute(a, b);
+			out.println(ans);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class160/Code04_LineUp2.java b/src/class160/Code04_LineUp2.java
new file mode 100644
index 000000000..a941c58f9
--- /dev/null
+++ b/src/class160/Code04_LineUp2.java
@@ -0,0 +1,121 @@
+package class160;
+
+// 排队，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P1975
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 20001;
+//const int MAXT = MAXN * 80;
+//const int INF = 1000000001;
+//int n, m, s;
+//int arr[MAXN];
+//int sorted[MAXN + 2];
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int sum[MAXT];
+//int cnt = 0;
+//int ans = 0;
+//
+//int kth(int num) {
+//    int l = 1, r = s, mid;
+//    while (l <= r) {
+//        mid = (l + r) / 2;
+//        if (sorted[mid] == num) return mid;
+//        else if (sorted[mid] < num) l = mid + 1;
+//        else r = mid - 1;
+//    }
+//    return -1;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//int add(int jobi, int jobv, int l, int r, int i) {
+//    if (i == 0) i = ++cnt;
+//    if (l == r) sum[i] += jobv;
+//    else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) ls[i] = add(jobi, jobv, l, mid, ls[i]);
+//        else rs[i] = add(jobi, jobv, mid + 1, r, rs[i]);
+//        sum[i] = sum[ls[i]] + sum[rs[i]];
+//    }
+//    return i;
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (i == 0) return 0;
+//    if (jobl <= l && r <= jobr) return sum[i];
+//    int mid = (l + r) / 2, res = 0;
+//    if (jobl <= mid) res += query(jobl, jobr, l, mid, ls[i]);
+//    if (jobr > mid) res += query(jobl, jobr, mid + 1, r, rs[i]);
+//    return res;
+//}
+//
+//void insert(int i, int v) {
+//    for (int j = i; j <= n; j += lowbit(j)) {
+//        root[j] = add(arr[i], v, 1, s, root[j]);
+//    }
+//}
+//
+//int queryCnt(int al, int ar, int numl, int numr) {
+//    int res = 0;
+//    for (int i = ar; i > 0; i -= lowbit(i)) res += query(numl, numr, 1, s, root[i]);
+//    for (int i = al - 1; i > 0; i -= lowbit(i)) res -= query(numl, numr, 1, s, root[i]);
+//    return res;
+//}
+//
+//void prepare() {
+//    s = 0;
+//    for (int i = 1; i <= n; i++) sorted[++s] = arr[i];
+//    sorted[++s] = -INF;
+//    sorted[++s] = INF;
+//    sort(sorted + 1, sorted + s + 1);
+//    int len = 1;
+//    for (int i = 2; i <= s; i++) {
+//        if (sorted[len] != sorted[i]) sorted[++len] = sorted[i];
+//    }
+//    s = len;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//        insert(i, 1);
+//    }
+//}
+//
+//void compute(int a, int b) {
+//    ans -= queryCnt(a + 1, b - 1, 1, arr[a] - 1);
+//    ans += queryCnt(a + 1, b - 1, arr[a] + 1, s);
+//    ans -= queryCnt(a + 1, b - 1, arr[b] + 1, s);
+//    ans += queryCnt(a + 1, b - 1, 1, arr[b] - 1);
+//    if (arr[a] < arr[b]) ans++;
+//    else if (arr[a] > arr[b]) ans--;
+//    insert(a, -1);
+//    insert(b, -1);
+//    swap(arr[a], arr[b]);
+//    insert(a, 1);
+//    insert(b, 1);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) cin >> arr[i];
+//    prepare();
+//    for (int i = 2; i <= n; i++) ans += queryCnt(1, i - 1, arr[i] + 1, s);
+//    cout << ans << '\n';
+//    cin >> m;
+//    for (int i = 1, a, b; i <= m; i++) {
+//        cin >> a >> b;
+//        if (a > b) swap(a, b);
+//        compute(a, b);
+//        cout << ans << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From d4d1be6bad16dc517c08a3355444356360a743aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Feb 2025 22:25:09 +0800
Subject: [PATCH 0435/1712] modify code

---
 .../Code03_IndexTreeWithSegmentTree1.java       | 16 +++++++---------
 .../Code03_IndexTreeWithSegmentTree2.java       | 17 +++++++----------
 2 files changed, 14 insertions(+), 19 deletions(-)

diff --git a/src/class160/Code03_IndexTreeWithSegmentTree1.java b/src/class160/Code03_IndexTreeWithSegmentTree1.java
index daf93c7b5..ed04e2d14 100644
--- a/src/class160/Code03_IndexTreeWithSegmentTree1.java
+++ b/src/class160/Code03_IndexTreeWithSegmentTree1.java
@@ -129,7 +129,7 @@ public static int findNumber(int l, int r, int k) {
 		for (int i = l - 1; i > 0; i -= lowbit(i)) {
 			pre[++cntpre] = root[i];
 		}
-		return queryNumber(k, 1, s);
+		return sorted[queryNumber(k, 1, s)];
 	}
 
 	public static int queryRank(int jobk, int l, int r) {
@@ -173,18 +173,18 @@ public static int findRank(int l, int r, int k) {
 	public static int findLast(int l, int r, int k) {
 		int rank = findRank(l, r, k);
 		if (rank == 1) {
-			return 0;
+			return -INF;
 		}
 		return findNumber(l, r, rank - 1);
 	}
 
 	public static int findNext(int l, int r, int k) {
 		if (k == s) {
-			return s + 1;
+			return INF;
 		}
 		int rank = findRank(l, r, k + 1);
 		if (rank == r - l + 2) {
-			return s + 1;
+			return INF;
 		}
 		return findNumber(l, r, rank);
 	}
@@ -213,8 +213,6 @@ public static void prepare() {
 			arr[i] = kth(arr[i]);
 			add(i, 1);
 		}
-		sorted[0] = -INF;
-		sorted[s + 1] = INF;
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -246,15 +244,15 @@ public static void main(String[] args) throws IOException {
 			if (ques[i][0] == 1) {
 				out.println(findRank(ques[i][1], ques[i][2], kth(ques[i][3])));
 			} else if (ques[i][0] == 2) {
-				out.println(sorted[findNumber(ques[i][1], ques[i][2], ques[i][3])]);
+				out.println(findNumber(ques[i][1], ques[i][2], ques[i][3]));
 			} else if (ques[i][0] == 3) {
 				add(ques[i][1], -1);
 				arr[ques[i][1]] = kth(ques[i][2]);
 				add(ques[i][1], 1);
 			} else if (ques[i][0] == 4) {
-				out.println(sorted[findLast(ques[i][1], ques[i][2], kth(ques[i][3]))]);
+				out.println(findLast(ques[i][1], ques[i][2], kth(ques[i][3])));
 			} else {
-				out.println(sorted[findNext(ques[i][1], ques[i][2], kth(ques[i][3]))]);
+				out.println(findNext(ques[i][1], ques[i][2], kth(ques[i][3])));
 			}
 		}
 		out.flush();
diff --git a/src/class160/Code03_IndexTreeWithSegmentTree2.java b/src/class160/Code03_IndexTreeWithSegmentTree2.java
index 89bcac3e9..e692fe066 100644
--- a/src/class160/Code03_IndexTreeWithSegmentTree2.java
+++ b/src/class160/Code03_IndexTreeWithSegmentTree2.java
@@ -67,7 +67,6 @@
 //    int leftsum = 0;
 //    for (int i = 1; i <= cntpos; i++) leftsum += sum[ls[pos[i]]];
 //    for (int i = 1; i <= cntpre; i++) leftsum -= sum[ls[pre[i]]];
-//    
 //    if (jobk <= leftsum) {
 //        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
 //        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
@@ -83,7 +82,7 @@
 //    cntpos = cntpre = 0;
 //    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
 //    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
-//    return queryNumber(k, 1, s);
+//    return sorted[queryNumber(k, 1, s)];
 //}
 //
 //int queryRank(int jobi, int l, int r) {
@@ -116,13 +115,13 @@
 //
 //int findLast(int l, int r, int k) {
 //    int rk = findRank(l, r, k);
-//    return (rk == 1) ? 0 : findNumber(l, r, rk - 1);
+//    return (rk == 1) ? -INF : findNumber(l, r, rk - 1);
 //}
 //
 //int findNext(int l, int r, int k) {
-//    if (k == s) return s + 1;
+//    if (k == s) return INF;
 //    int rk = findRank(l, r, k + 1);
-//    return (rk == r - l + 2) ? s + 1 : findNumber(l, r, rk);
+//    return (rk == r - l + 2) ? INF : findNumber(l, r, rk);
 //}
 //
 //void prepare() {
@@ -141,8 +140,6 @@
 //        arr[i] = kth(arr[i]);
 //        add(i, 1);
 //    }
-//    sorted[0] = -INF;
-//    sorted[s + 1] = INF;
 //}
 //
 //int main() {
@@ -159,15 +156,15 @@
 //        if (ques[i][0] == 1) {
 //            cout << findRank(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
 //        } else if (ques[i][0] == 2) {
-//            cout << sorted[findNumber(ques[i][1], ques[i][2], ques[i][3])] << "\n";
+//            cout << findNumber(ques[i][1], ques[i][2], ques[i][3]) << "\n";
 //        } else if (ques[i][0] == 3) {
 //            add(ques[i][1], -1);
 //            arr[ques[i][1]] = kth(ques[i][2]);
 //            add(ques[i][1], 1);
 //        } else if (ques[i][0] == 4) {
-//            cout << sorted[findLast(ques[i][1], ques[i][2], kth(ques[i][3]))] << "\n";
+//            cout << findLast(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
 //        } else {
-//            cout << sorted[findNext(ques[i][1], ques[i][2], kth(ques[i][3]))] << "\n";
+//            cout << findNext(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
 //        }
 //    }
 //    return 0;

From 1c2a0e2677619995d728dcb884359a1baf7ec0af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Feb 2025 13:28:34 +0800
Subject: [PATCH 0436/1712] modify code

---
 ...SegmentTree1.java => Code01_SegmentWithSegment1.java} | 2 +-
 ...SegmentTree2.java => Code01_SegmentWithSegment2.java} | 0
 src/class160/Code03_SegmentWithBalanced1.java            | 9 +++++++++
 ...thSegmentTree1.java => Code04_IndexWithSegment1.java} | 2 +-
 ...thSegmentTree2.java => Code04_IndexWithSegment2.java} | 0
 .../{Code04_LineUp1.java => Code05_LineUp1.java}         | 2 +-
 .../{Code04_LineUp2.java => Code05_LineUp2.java}         | 0
 ...rkManagement1.java => Code06_NetworkManagement1.java} | 2 +-
 ...rkManagement2.java => Code06_NetworkManagement2.java} | 0
 9 files changed, 13 insertions(+), 4 deletions(-)
 rename src/class160/{Code01_SegmentTreeWithSegmentTree1.java => Code01_SegmentWithSegment1.java} (98%)
 rename src/class160/{Code01_SegmentTreeWithSegmentTree2.java => Code01_SegmentWithSegment2.java} (100%)
 create mode 100644 src/class160/Code03_SegmentWithBalanced1.java
 rename src/class160/{Code03_IndexTreeWithSegmentTree1.java => Code04_IndexWithSegment1.java} (99%)
 rename src/class160/{Code03_IndexTreeWithSegmentTree2.java => Code04_IndexWithSegment2.java} (100%)
 rename src/class160/{Code04_LineUp1.java => Code05_LineUp1.java} (99%)
 rename src/class160/{Code04_LineUp2.java => Code05_LineUp2.java} (100%)
 rename src/class160/{Code05_NetworkManagement1.java => Code06_NetworkManagement1.java} (99%)
 rename src/class160/{Code05_NetworkManagement2.java => Code06_NetworkManagement2.java} (100%)

diff --git a/src/class160/Code01_SegmentTreeWithSegmentTree1.java b/src/class160/Code01_SegmentWithSegment1.java
similarity index 98%
rename from src/class160/Code01_SegmentTreeWithSegmentTree1.java
rename to src/class160/Code01_SegmentWithSegment1.java
index 2898ce5af..0e8a2cf60 100644
--- a/src/class160/Code01_SegmentTreeWithSegmentTree1.java
+++ b/src/class160/Code01_SegmentWithSegment1.java
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code01_SegmentTreeWithSegmentTree1 {
+public class Code01_SegmentWithSegment1 {
 
 	public static int MAXH = 101;
 
diff --git a/src/class160/Code01_SegmentTreeWithSegmentTree2.java b/src/class160/Code01_SegmentWithSegment2.java
similarity index 100%
rename from src/class160/Code01_SegmentTreeWithSegmentTree2.java
rename to src/class160/Code01_SegmentWithSegment2.java
diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
new file mode 100644
index 000000000..43addba20
--- /dev/null
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -0,0 +1,9 @@
+package class160;
+
+// 线段树套平衡树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3380
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code03_SegmentWithBalanced1 {
+
+}
diff --git a/src/class160/Code03_IndexTreeWithSegmentTree1.java b/src/class160/Code04_IndexWithSegment1.java
similarity index 99%
rename from src/class160/Code03_IndexTreeWithSegmentTree1.java
rename to src/class160/Code04_IndexWithSegment1.java
index ed04e2d14..29b5f69dc 100644
--- a/src/class160/Code03_IndexTreeWithSegmentTree1.java
+++ b/src/class160/Code04_IndexWithSegment1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code03_IndexTreeWithSegmentTree1 {
+public class Code04_IndexWithSegment1 {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class160/Code03_IndexTreeWithSegmentTree2.java b/src/class160/Code04_IndexWithSegment2.java
similarity index 100%
rename from src/class160/Code03_IndexTreeWithSegmentTree2.java
rename to src/class160/Code04_IndexWithSegment2.java
diff --git a/src/class160/Code04_LineUp1.java b/src/class160/Code05_LineUp1.java
similarity index 99%
rename from src/class160/Code04_LineUp1.java
rename to src/class160/Code05_LineUp1.java
index 23001bcd6..4c03c4887 100644
--- a/src/class160/Code04_LineUp1.java
+++ b/src/class160/Code05_LineUp1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_LineUp1 {
+public class Code05_LineUp1 {
 
 	public static int MAXN = 20001;
 
diff --git a/src/class160/Code04_LineUp2.java b/src/class160/Code05_LineUp2.java
similarity index 100%
rename from src/class160/Code04_LineUp2.java
rename to src/class160/Code05_LineUp2.java
diff --git a/src/class160/Code05_NetworkManagement1.java b/src/class160/Code06_NetworkManagement1.java
similarity index 99%
rename from src/class160/Code05_NetworkManagement1.java
rename to src/class160/Code06_NetworkManagement1.java
index eafceab1f..6322abb3c 100644
--- a/src/class160/Code05_NetworkManagement1.java
+++ b/src/class160/Code06_NetworkManagement1.java
@@ -12,7 +12,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code05_NetworkManagement1 {
+public class Code06_NetworkManagement1 {
 
 	public static int MAXN = 80001;
 
diff --git a/src/class160/Code05_NetworkManagement2.java b/src/class160/Code06_NetworkManagement2.java
similarity index 100%
rename from src/class160/Code05_NetworkManagement2.java
rename to src/class160/Code06_NetworkManagement2.java

From ea3116118096a00ed36f67ab366d60551f310d84 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Feb 2025 17:01:19 +0800
Subject: [PATCH 0437/1712] modify code

---
 src/class160/Code02_QueryKthMaximum1.java     |   6 +-
 src/class160/Code02_QueryKthMaximum2.java     |   6 +-
 src/class160/Code03_SegmentWithBalanced1.java | 310 ++++++++++++++++++
 3 files changed, 316 insertions(+), 6 deletions(-)

diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index b22ab5622..0acf61836 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -24,7 +24,7 @@ public class Code02_QueryKthMaximum1 {
 
 	public static int[] sorted = new int[MAXN];
 
-	public static int[] outer = new int[MAXN << 2];
+	public static int[] root = new int[MAXN << 2];
 
 	public static int[] left = new int[MAXT];
 
@@ -112,7 +112,7 @@ public static long querySum(int jobl, int jobr, int l, int r, int i) {
 	}
 
 	public static void add(int jobl, int jobr, int jobk, int l, int r, int i) {
-		outer[i] = update(jobl, jobr, 1, n, outer[i]);
+		root[i] = update(jobl, jobr, 1, n, root[i]);
 		if (l < r) {
 			int mid = (l + r) / 2;
 			if (jobk <= mid) {
@@ -128,7 +128,7 @@ public static int query(int jobl, int jobr, long jobk, int l, int r, int i) {
 			return l;
 		}
 		int mid = (l + r) / 2;
-		long rightsum = querySum(jobl, jobr, 1, n, outer[i << 1 | 1]);
+		long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
 		if (jobk > rightsum) {
 			return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
 		} else {
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index 39d17cb50..60c74019a 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -15,7 +15,7 @@
 //int ques[MAXN][4];
 //int sorted[MAXN];
 //
-//int outer[MAXN << 2];
+//int root[MAXN << 2];
 //int ls[MAXT];
 //int rs[MAXT];
 //long long sum[MAXT];
@@ -82,7 +82,7 @@
 //}
 //
 //void add(int jobl, int jobr, int jobk, int l, int r, int i) {
-//    outer[i] = update(jobl, jobr, 1, n, outer[i]);
+//    root[i] = update(jobl, jobr, 1, n, root[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
 //        if (jobk <= mid) {
@@ -98,7 +98,7 @@
 //        return l;
 //    }
 //    int mid = (l + r) >> 1;
-//    long long rightsum = querySum(jobl, jobr, 1, n, outer[i << 1 | 1]);
+//    long long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
 //    if (jobk > rightsum) {
 //        return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
 //    } else {
diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index 43addba20..19c35c5cc 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -4,6 +4,316 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
 public class Code03_SegmentWithBalanced1 {
 
+	public static int MAXN = 50001;
+	public static int MAXT = MAXN * 40;
+	public static int INF = Integer.MAX_VALUE;
+	public static double ALPHA = 0.7;
+	public static int n, m;
+
+	// 原始数组
+	public static int[] arr = new int[MAXN];
+
+	// 线段树维护的替罪羊树根节点编号
+	public static int[] root = new int[MAXN << 2];
+
+	// 替罪羊树需要
+	public static int[] key = new int[MAXT];
+	public static int[] count = new int[MAXT];
+	public static int[] left = new int[MAXT];
+	public static int[] right = new int[MAXT];
+	public static int[] size = new int[MAXT];
+	public static int[] diff = new int[MAXT];
+	public static int cnt = 0;
+
+	// rebuild用到的中序收集数组
+	public static int[] collect = new int[MAXT];
+	public static int ci;
+
+	// 最上方的失衡点、失衡点的父节点、失衡点的方向
+	public static int top, father, side;
+
+	public static int init(int num) {
+		key[++cnt] = num;
+		left[cnt] = right[cnt] = 0;
+		count[cnt] = size[cnt] = diff[cnt] = 1;
+		return cnt;
+	}
+
+	public static void up(int i) {
+		size[i] = size[left[i]] + size[right[i]] + count[i];
+		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
+	}
+
+	public static void inorder(int i) {
+		if (i != 0) {
+			inorder(left[i]);
+			if (count[i] > 0) {
+				collect[++ci] = i;
+			}
+			inorder(right[i]);
+		}
+	}
+
+	public static int build(int l, int r) {
+		if (l > r) {
+			return 0;
+		}
+		int m = (l + r) >> 1;
+		int h = collect[m];
+		left[h] = build(l, m - 1);
+		right[h] = build(m + 1, r);
+		up(h);
+		return h;
+	}
+
+	public static int rebuild(int i) {
+		if (top != 0) {
+			ci = 0;
+			inorder(top);
+			if (ci > 0) {
+				if (father == 0) {
+					i = build(1, ci);
+				} else if (side == 1) {
+					left[father] = build(1, ci);
+				} else {
+					right[father] = build(1, ci);
+				}
+			}
+		}
+		return i;
+	}
+
+	public static boolean balance(int i) {
+		if (i == 0) {
+			return true;
+		}
+		return ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
+	}
+
+	public static int insert(int num, int i, int f, int s) {
+		if (i == 0) {
+			i = init(num);
+		} else {
+			if (key[i] == num) {
+				count[i]++;
+			} else if (key[i] > num) {
+				left[i] = insert(num, left[i], i, 1);
+			} else {
+				right[i] = insert(num, right[i], i, 2);
+			}
+			up(i);
+			if (!balance(i)) {
+				top = i;
+				father = f;
+				side = s;
+			}
+		}
+		return i;
+	}
+
+	public static int insert(int num, int i) {
+		top = father = side = 0;
+		i = insert(num, i, 0, 0);
+		i = rebuild(i);
+		return i;
+	}
+
+	public static int querySmall(int num, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (key[i] >= num) {
+			return querySmall(num, left[i]);
+		} else {
+			return size[left[i]] + count[i] + querySmall(num, right[i]);
+		}
+	}
+
+	public static int queryIndex(int index, int i) {
+		int leftsize = size[left[i]];
+		if (leftsize >= index) {
+			return queryIndex(index, left[i]);
+		} else if (leftsize + count[i] < index) {
+			return queryIndex(index - leftsize - count[i], right[i]);
+		} else {
+			return key[i];
+		}
+	}
+
+	public static int queryPre(int num, int i) {
+		int kth = querySmall(num, i) + 1;
+		if (kth == 1) {
+			return -INF;
+		} else {
+			return queryIndex(kth - 1, i);
+		}
+	}
+
+	public static int queryPost(int num, int i) {
+		int kth = querySmall(num + 1, i);
+		if (kth == size[i]) {
+			return INF;
+		} else {
+			return queryIndex(kth + 1, i);
+		}
+	}
+
+	public static void remove(int num, int i, int f, int s) {
+		if (key[i] == num) {
+			count[i]--;
+		} else if (key[i] > num) {
+			remove(num, left[i], i, 1);
+		} else {
+			remove(num, right[i], i, 2);
+		}
+		up(i);
+		if (!balance(i)) {
+			top = i;
+			father = f;
+			side = s;
+		}
+	}
+
+	public static int remove(int num, int i) {
+		if (querySmall(num, i) != querySmall(num + 1, i)) {
+			top = father = side = 0;
+			remove(num, i, 0, 0);
+			i = rebuild(i);
+		}
+		return i;
+	}
+
+	public static void build(int l, int r, int i) {
+		for (int j = l; j <= r; j++) {
+			root[i] = insert(arr[j], root[i]);
+		}
+		if (l < r) {
+			int mid = (l + r) >> 1;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+		}
+	}
+
+	public static void update(int jobi, int jobv, int l, int r, int i) {
+		root[i] = remove(arr[jobi], root[i]);
+		root[i] = insert(jobv, root[i]);
+		if (l < r) {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				update(jobi, jobv, l, mid, i << 1);
+			} else {
+				update(jobi, jobv, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static int small(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return querySmall(jobv, root[i]);
+		}
+		int mid = (l + r) >> 1;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans += small(jobl, jobr, jobv, l, mid, i << 1);
+		}
+		if (jobr > mid) {
+			ans += small(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+		}
+		return ans;
+	}
+
+	public static int number(int jobl, int jobr, int jobk) {
+		int L = 0, R = 100000000, mid, ans = 0;
+		while (L <= R) {
+			mid = (L + R) >> 1;
+			if (small(jobl, jobr, mid + 1, 1, n, 1) >= jobk) {
+				ans = mid;
+				R = mid - 1;
+			} else {
+				L = mid + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static int pre(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return queryPre(jobv, root[i]);
+		}
+		int mid = (l + r) >> 1;
+		int ans = -INF;
+		if (jobl <= mid) {
+			ans = Math.max(ans, pre(jobl, jobr, jobv, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.max(ans, pre(jobl, jobr, jobv, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static int post(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return queryPost(jobv, root[i]);
+		}
+		int mid = (l + r) >> 1;
+		int ans = INF;
+		if (jobl <= mid) {
+			ans = Math.min(ans, post(jobl, jobr, jobv, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.min(ans, post(jobl, jobr, jobv, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		build(1, n, 1);
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			in.nextToken();
+			x = (int) in.nval;
+			in.nextToken();
+			y = (int) in.nval;
+			if (op == 3) {
+				update(x, y, 1, n, 1);
+				arr[x] = y;
+			} else {
+				in.nextToken();
+				z = (int) in.nval;
+				if (op == 1) {
+					out.println(small(x, y, z, 1, n, 1) + 1);
+				} else if (op == 2) {
+					out.println(number(x, y, z));
+				} else if (op == 4) {
+					out.println(pre(x, y, z, 1, n, 1));
+				} else {
+					out.println(post(x, y, z, 1, n, 1));
+				}
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
 }

From b07763c66ced0fcb44a0982e8f0cd3bff9215e55 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Feb 2025 17:37:42 +0800
Subject: [PATCH 0438/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced1.java |  51 ++--
 src/class160/Code03_SegmentWithBalanced2.java | 238 ++++++++++++++++++
 2 files changed, 262 insertions(+), 27 deletions(-)
 create mode 100644 src/class160/Code03_SegmentWithBalanced2.java

diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index 19c35c5cc..e16062c2f 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -27,7 +27,7 @@ public class Code03_SegmentWithBalanced1 {
 
 	// 替罪羊树需要
 	public static int[] key = new int[MAXT];
-	public static int[] count = new int[MAXT];
+	public static int[] cnts = new int[MAXT];
 	public static int[] left = new int[MAXT];
 	public static int[] right = new int[MAXT];
 	public static int[] size = new int[MAXT];
@@ -44,19 +44,19 @@ public class Code03_SegmentWithBalanced1 {
 	public static int init(int num) {
 		key[++cnt] = num;
 		left[cnt] = right[cnt] = 0;
-		count[cnt] = size[cnt] = diff[cnt] = 1;
+		cnts[cnt] = size[cnt] = diff[cnt] = 1;
 		return cnt;
 	}
 
 	public static void up(int i) {
-		size[i] = size[left[i]] + size[right[i]] + count[i];
-		diff[i] = diff[left[i]] + diff[right[i]] + (count[i] > 0 ? 1 : 0);
+		size[i] = size[left[i]] + size[right[i]] + cnts[i];
+		diff[i] = diff[left[i]] + diff[right[i]] + (cnts[i] > 0 ? 1 : 0);
 	}
 
 	public static void inorder(int i) {
 		if (i != 0) {
 			inorder(left[i]);
-			if (count[i] > 0) {
+			if (cnts[i] > 0) {
 				collect[++ci] = i;
 			}
 			inorder(right[i]);
@@ -93,22 +93,19 @@ public static int rebuild(int i) {
 	}
 
 	public static boolean balance(int i) {
-		if (i == 0) {
-			return true;
-		}
-		return ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
+		return i == 0 || ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
 	}
 
-	public static int insert(int num, int i, int f, int s) {
+	public static int insertNumber(int num, int i, int f, int s) {
 		if (i == 0) {
 			i = init(num);
 		} else {
 			if (key[i] == num) {
-				count[i]++;
+				cnts[i]++;
 			} else if (key[i] > num) {
-				left[i] = insert(num, left[i], i, 1);
+				left[i] = insertNumber(num, left[i], i, 1);
 			} else {
-				right[i] = insert(num, right[i], i, 2);
+				right[i] = insertNumber(num, right[i], i, 2);
 			}
 			up(i);
 			if (!balance(i)) {
@@ -120,9 +117,9 @@ public static int insert(int num, int i, int f, int s) {
 		return i;
 	}
 
-	public static int insert(int num, int i) {
+	public static int insertNumber(int num, int i) {
 		top = father = side = 0;
-		i = insert(num, i, 0, 0);
+		i = insertNumber(num, i, 0, 0);
 		i = rebuild(i);
 		return i;
 	}
@@ -134,7 +131,7 @@ public static int querySmall(int num, int i) {
 		if (key[i] >= num) {
 			return querySmall(num, left[i]);
 		} else {
-			return size[left[i]] + count[i] + querySmall(num, right[i]);
+			return size[left[i]] + cnts[i] + querySmall(num, right[i]);
 		}
 	}
 
@@ -142,8 +139,8 @@ public static int queryIndex(int index, int i) {
 		int leftsize = size[left[i]];
 		if (leftsize >= index) {
 			return queryIndex(index, left[i]);
-		} else if (leftsize + count[i] < index) {
-			return queryIndex(index - leftsize - count[i], right[i]);
+		} else if (leftsize + cnts[i] < index) {
+			return queryIndex(index - leftsize - cnts[i], right[i]);
 		} else {
 			return key[i];
 		}
@@ -167,13 +164,13 @@ public static int queryPost(int num, int i) {
 		}
 	}
 
-	public static void remove(int num, int i, int f, int s) {
+	public static void removeNumber(int num, int i, int f, int s) {
 		if (key[i] == num) {
-			count[i]--;
+			cnts[i]--;
 		} else if (key[i] > num) {
-			remove(num, left[i], i, 1);
+			removeNumber(num, left[i], i, 1);
 		} else {
-			remove(num, right[i], i, 2);
+			removeNumber(num, right[i], i, 2);
 		}
 		up(i);
 		if (!balance(i)) {
@@ -183,10 +180,10 @@ public static void remove(int num, int i, int f, int s) {
 		}
 	}
 
-	public static int remove(int num, int i) {
+	public static int removeNumber(int num, int i) {
 		if (querySmall(num, i) != querySmall(num + 1, i)) {
 			top = father = side = 0;
-			remove(num, i, 0, 0);
+			removeNumber(num, i, 0, 0);
 			i = rebuild(i);
 		}
 		return i;
@@ -194,7 +191,7 @@ public static int remove(int num, int i) {
 
 	public static void build(int l, int r, int i) {
 		for (int j = l; j <= r; j++) {
-			root[i] = insert(arr[j], root[i]);
+			root[i] = insertNumber(arr[j], root[i]);
 		}
 		if (l < r) {
 			int mid = (l + r) >> 1;
@@ -204,8 +201,8 @@ public static void build(int l, int r, int i) {
 	}
 
 	public static void update(int jobi, int jobv, int l, int r, int i) {
-		root[i] = remove(arr[jobi], root[i]);
-		root[i] = insert(jobv, root[i]);
+		root[i] = removeNumber(arr[jobi], root[i]);
+		root[i] = insertNumber(jobv, root[i]);
 		if (l < r) {
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
new file mode 100644
index 000000000..063f81896
--- /dev/null
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -0,0 +1,238 @@
+package class160;
+
+// 线段树套平衡树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3380
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50001;
+//const int MAXT = MAXN * 40;
+//const int INF = INT_MAX;
+//double ALPHA = 0.7;
+//int n, m;
+//int arr[MAXN];
+//int root[MAXN << 2];
+//int key[MAXT];
+//int cnts[MAXT];
+//int ls[MAXT];
+//int rs[MAXT];
+//int siz[MAXT];
+//int diff[MAXT];
+//int cnt;
+//int collect[MAXT];
+//int ci;
+//int top, father, side;
+//
+//int init(int num) {
+//    key[++cnt] = num;
+//    ls[cnt] = rs[cnt] = 0;
+//    cnts[cnt] = siz[cnt] = diff[cnt] = 1;
+//    return cnt;
+//}
+//
+//void up(int i) {
+//	siz[i] = siz[ls[i]] + siz[rs[i]] + cnts[i];
+//	diff[i] = diff[ls[i]] + diff[rs[i]] + (cnts[i] > 0 ? 1 : 0);
+//}
+//
+//void inorder(int i) {
+//    if (i) {
+//        inorder(ls[i]);
+//        if (cnts[i] > 0) collect[++ci] = i;
+//        inorder(rs[i]);
+//    }
+//}
+//
+//int build(int l, int r) {
+//    if (l > r) return 0;
+//    int mid = (l + r) >> 1;
+//    int h = collect[mid];
+//    ls[h] = build(l, mid - 1);
+//    rs[h] = build(mid + 1, r);
+//    up(h);
+//    return h;
+//}
+//
+//int rebuild(int i) {
+//    if (top) {
+//        ci = 0;
+//        inorder(top);
+//        if (ci > 0) {
+//            if (father == 0) {
+//                i = build(1, ci);
+//            } else if (side == 1) {
+//            	ls[father] = build(1, ci);
+//            } else {
+//            	rs[father] = build(1, ci);
+//            }
+//        }
+//    }
+//    return i;
+//}
+//
+//bool balance(int i) {
+//    return i == 0 || ALPHA * diff[i] >= max(diff[ls[i]], diff[rs[i]]);
+//}
+//
+//int insertNumber(int num, int i, int f, int s) {
+//    if (!i) {
+//        i = init(num);
+//    } else {
+//        if (key[i] == num) {
+//        	cnts[i]++;
+//        } else if (key[i] > num) {
+//        	ls[i] = insertNumber(num, ls[i], i, 1);
+//        } else {
+//        	rs[i] = insertNumber(num, rs[i], i, 2);
+//        }
+//        up(i);
+//        if (!balance(i)) {
+//            top = i;
+//            father = f;
+//            side = s;
+//        }
+//    }
+//    return i;
+//}
+//
+//int insertNumber(int num, int i) {
+//    top = father = side = 0;
+//    i = insertNumber(num, i, 0, 0);
+//    i = rebuild(i);
+//    return i;
+//}
+//
+//int querySmall(int num, int i) {
+//    if (!i) return 0;
+//    if (key[i] >= num) return querySmall(num, ls[i]);
+//    return siz[ls[i]] + cnts[i] + querySmall(num, rs[i]);
+//}
+//
+//int queryIndex(int index, int i) {
+//    int leftsize = siz[ls[i]];
+//    if (leftsize >= index) {
+//        return queryIndex(index, ls[i]);
+//    } else if (leftsize + cnts[i] < index) {
+//        return queryIndex(index - leftsize - cnts[i], rs[i]);
+//    }
+//    return key[i];
+//}
+//
+//int queryPre(int num, int i) {
+//    int kth = querySmall(num, i) + 1;
+//    if (kth == 1) return -INF;
+//    return queryIndex(kth - 1, i);
+//}
+//
+//int queryPost(int num, int i) {
+//    int kth = querySmall(num + 1, i);
+//    if (kth == siz[i]) return INF;
+//    return queryIndex(kth + 1, i);
+//}
+//
+//void removeNumber(int num, int i, int f, int s) {
+//    if (key[i] == num) {
+//    	cnts[i]--;
+//    } else if (key[i] > num) {
+//    	removeNumber(num, ls[i], i, 1);
+//    } else {
+//    	removeNumber(num, rs[i], i, 2);
+//    }
+//    up(i);
+//    if (!balance(i)) {
+//        top = i;
+//        father = f;
+//        side = s;
+//    }
+//}
+//
+//int removeNumber(int num, int i) {
+//    if (querySmall(num, i) != querySmall(num + 1, i)) {
+//        top = father = side = 0;
+//        removeNumber(num, i, 0, 0);
+//        i = rebuild(i);
+//    }
+//    return i;
+//}
+//
+//void build(int l, int r, int i) {
+//    for (int j = l; j <= r; j++) root[i] = insertNumber(arr[j], root[i]);
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//    }
+//}
+//
+//void update(int jobi, int jobv, int l, int r, int i) {
+//    root[i] = removeNumber(arr[jobi], root[i]);
+//    root[i] = insertNumber(jobv, root[i]);
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) update(jobi, jobv, l, mid, i << 1);
+//        else update(jobi, jobv, mid + 1, r, i << 1 | 1);
+//    }
+//}
+//
+//int small(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) return querySmall(jobv, root[i]);
+//    int mid = (l + r) >> 1, ans = 0;
+//    if (jobl <= mid) ans += small(jobl, jobr, jobv, l, mid, i << 1);
+//    if (jobr > mid) ans += small(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//    return ans;
+//}
+//
+//int number(int jobl, int jobr, int jobk) {
+//    int l = 0, r = 100000000, mid, ans = 0;
+//    while (l <= r) {
+//        mid = (l + r) >> 1;
+//        if (small(jobl, jobr, mid + 1, 1, n, 1) >= jobk) {
+//            ans = mid;
+//            r = mid - 1;
+//        } else {
+//            l = mid + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int pre(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) return queryPre(jobv, root[i]);
+//    int mid = (l + r) >> 1, ans = -INF;
+//    if (jobl <= mid) ans = max(ans, pre(jobl, jobr, jobv, l, mid, i << 1));
+//    if (jobr > mid) ans = max(ans, pre(jobl, jobr, jobv, mid + 1, r, i << 1 | 1));
+//    return ans;
+//}
+//
+//int post(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) return queryPost(jobv, root[i]);
+//    int mid = (l + r) >> 1, ans = INF;
+//    if (jobl <= mid) ans = min(ans, post(jobl, jobr, jobv, l, mid, i << 1));
+//    if (jobr > mid) ans = min(ans, post(jobl, jobr, jobv, mid + 1, r, i << 1 | 1));
+//    return ans;
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for(int i=1;i<=n;i++) cin >> arr[i];
+//    build(1,n,1);
+//    for(int i=1,op,x,y,z;i<=m;i++){
+//        cin >> op >> x >> y;
+//        if(op==3){
+//            update(x,y,1,n,1);
+//            arr[x]=y;
+//        } else {
+//            cin >> z;
+//            if(op==1) cout << small(x,y,z,1,n,1)+1 << "\n";
+//            else if(op==2) cout << number(x,y,z) << "\n";
+//            else if(op==4) cout << pre(x,y,z,1,n,1) << "\n";
+//            else cout << post(x,y,z,1,n,1) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 6b588bb98f2cd85a32e6772d1e075b319a4730cb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Feb 2025 17:55:27 +0800
Subject: [PATCH 0439/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced2.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 063f81896..13078eb6b 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -1,8 +1,9 @@
 package class160;
 
-// 线段树套平衡树，java版
+// 线段树套平衡树，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
 
 //#include <bits/stdc++.h>
 //

From aa58efcb5dd948b9c871c47f61a7ee4fc5666b9f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Feb 2025 14:52:11 +0800
Subject: [PATCH 0440/1712] modify code

---
 src/class160/Code01_SegmentWithSegment1.java  |  74 ++++-----
 src/class160/Code01_SegmentWithSegment2.java  |  74 ++++-----
 src/class160/Code02_QueryKthMaximum1.java     |  32 ++--
 src/class160/Code02_QueryKthMaximum2.java     |  32 ++--
 src/class160/Code03_SegmentWithBalanced1.java |  95 ++++++-----
 src/class160/Code03_SegmentWithBalanced2.java |  84 +++++-----
 src/class160/Code04_IndexWithSegment1.java    |  82 ++++-----
 src/class160/Code04_IndexWithSegment2.java    |  74 ++++-----
 src/class160/Code05_LineUp1.java              |  30 ++--
 src/class160/Code05_LineUp2.java              |  55 +++---
 src/class160/Code06_NetworkManagement1.java   | 156 +++++++++---------
 src/class160/Code06_NetworkManagement2.java   | 100 +++++------
 12 files changed, 459 insertions(+), 429 deletions(-)

diff --git a/src/class160/Code01_SegmentWithSegment1.java b/src/class160/Code01_SegmentWithSegment1.java
index 0e8a2cf60..a5ff8220f 100644
--- a/src/class160/Code01_SegmentWithSegment1.java
+++ b/src/class160/Code01_SegmentWithSegment1.java
@@ -23,77 +23,77 @@ public class Code01_SegmentWithSegment1 {
 
 	public static int[][] tree = new int[MAXH << 2][MAXA << 2];
 
-	public static void ybuild(int yl, int yr, int xi, int yi) {
+	public static void innerBuild(int yl, int yr, int xi, int yi) {
 		tree[xi][yi] = -1;
 		if (yl < yr) {
 			int mid = (yl + yr) / 2;
-			ybuild(yl, mid, xi, yi << 1);
-			ybuild(mid + 1, yr, xi, yi << 1 | 1);
+			innerBuild(yl, mid, xi, yi << 1);
+			innerBuild(mid + 1, yr, xi, yi << 1 | 1);
 		}
 	}
 
-	public static void build(int xl, int xr, int xi) {
-		ybuild(0, n, xi, 1);
-		if (xl < xr) {
-			int mid = (xl + xr) / 2;
-			build(xl, mid, xi << 1);
-			build(mid + 1, xr, xi << 1 | 1);
-		}
-	}
-
-	public static void yupdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
+	public static void innerUpdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
 		if (yl == yr) {
 			tree[xi][yi] = Math.max(tree[xi][yi], jobv);
 		} else {
 			int mid = (yl + yr) / 2;
 			if (joby <= mid) {
-				yupdate(joby, jobv, yl, mid, xi, yi << 1);
+				innerUpdate(joby, jobv, yl, mid, xi, yi << 1);
 			} else {
-				yupdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
+				innerUpdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
 			}
 			tree[xi][yi] = Math.max(tree[xi][yi << 1], tree[xi][yi << 1 | 1]);
 		}
 	}
 
-	public static void update(int jobx, int joby, int jobv, int xl, int xr, int xi) {
-		yupdate(joby, jobv, 0, n, xi, 1);
-		if (xl < xr) {
-			int mid = (xl + xr) / 2;
-			if (jobx <= mid) {
-				update(jobx, joby, jobv, xl, mid, xi << 1);
-			} else {
-				update(jobx, joby, jobv, mid + 1, xr, xi << 1 | 1);
-			}
-		}
-	}
-
-	public static int yquery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
+	public static int innerQuery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
 		if (jobyl <= yl && yr <= jobyr) {
 			return tree[xi][yi];
 		}
 		int mid = (yl + yr) / 2;
 		int ans = -1;
 		if (jobyl <= mid) {
-			ans = yquery(jobyl, jobyr, yl, mid, xi, yi << 1);
+			ans = innerQuery(jobyl, jobyr, yl, mid, xi, yi << 1);
 
 		}
 		if (jobyr > mid) {
-			ans = Math.max(ans, yquery(jobyl, jobyr, mid + 1, yr, xi, yi << 1 | 1));
+			ans = Math.max(ans, innerQuery(jobyl, jobyr, mid + 1, yr, xi, yi << 1 | 1));
 		}
 		return ans;
 	}
 
-	public static int query(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
+	public static void outerBuild(int xl, int xr, int xi) {
+		innerBuild(0, n, xi, 1);
+		if (xl < xr) {
+			int mid = (xl + xr) / 2;
+			outerBuild(xl, mid, xi << 1);
+			outerBuild(mid + 1, xr, xi << 1 | 1);
+		}
+	}
+
+	public static void outerUpdate(int jobx, int joby, int jobv, int xl, int xr, int xi) {
+		innerUpdate(joby, jobv, 0, n, xi, 1);
+		if (xl < xr) {
+			int mid = (xl + xr) / 2;
+			if (jobx <= mid) {
+				outerUpdate(jobx, joby, jobv, xl, mid, xi << 1);
+			} else {
+				outerUpdate(jobx, joby, jobv, mid + 1, xr, xi << 1 | 1);
+			}
+		}
+	}
+
+	public static int outerQuery(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
 		if (jobxl <= xl && xr <= jobxr) {
-			return yquery(jobyl, jobyr, 0, n, xi, 1);
+			return innerQuery(jobyl, jobyr, 0, n, xi, 1);
 		}
 		int mid = (xl + xr) / 2;
 		int ans = -1;
 		if (jobxl <= mid) {
-			ans = query(jobxl, jobxr, jobyl, jobyr, xl, mid, xi << 1);
+			ans = outerQuery(jobxl, jobxr, jobyl, jobyr, xl, mid, xi << 1);
 		}
 		if (jobxr > mid) {
-			ans = Math.max(ans, query(jobxl, jobxr, jobyl, jobyr, mid + 1, xr, xi << 1 | 1));
+			ans = Math.max(ans, outerQuery(jobxl, jobxr, jobyl, jobyr, mid + 1, xr, xi << 1 | 1));
 		}
 		return ans;
 	}
@@ -104,14 +104,14 @@ public static void main(String[] args) {
 		String op;
 		int a, b, c, d;
 		while (m != 0) {
-			build(100, 200, 1);
+			outerBuild(100, 200, 1);
 			for (int i = 1; i <= m; i++) {
 				op = io.next();
 				if (op.equals("I")) {
 					a = io.nextInt();
 					b = (int) (io.nextDouble() * 10);
 					c = (int) (io.nextDouble() * 10);
-					update(a, b, c, 100, 200, 1);
+					outerUpdate(a, b, c, 100, 200, 1);
 				} else {
 					a = io.nextInt();
 					b = io.nextInt();
@@ -121,7 +121,7 @@ public static void main(String[] args) {
 					int xr = Math.max(a, b);
 					int yl = Math.min(c, d);
 					int yr = Math.max(c, d);
-					int ans = query(xl, xr, yl, yr, 100, 200, 1);
+					int ans = outerQuery(xl, xr, yl, yr, 100, 200, 1);
 					if (ans == -1) {
 						io.println(ans);
 					} else {
diff --git a/src/class160/Code01_SegmentWithSegment2.java b/src/class160/Code01_SegmentWithSegment2.java
index b8bc5a2d5..e0b19f8fa 100644
--- a/src/class160/Code01_SegmentWithSegment2.java
+++ b/src/class160/Code01_SegmentWithSegment2.java
@@ -14,76 +14,76 @@
 //int n = 1000, m;
 //int tree[MAXH << 2][MAXA << 2];
 //
-//void ybuild(int yl, int yr, int xi, int yi) {
+//void innerBuild(int yl, int yr, int xi, int yi) {
 //    tree[xi][yi] = -1;
 //    if (yl < yr) {
 //        int mid = (yl + yr) >> 1;
-//        ybuild(yl, mid, xi, yi << 1);
-//        ybuild(mid + 1, yr, xi, yi << 1 | 1);
+//        innerBuild(yl, mid, xi, yi << 1);
+//        innerBuild(mid + 1, yr, xi, yi << 1 | 1);
 //    }
 //}
 //
-//void build(int xl, int xr, int xi) {
-//    ybuild(0, n, xi, 1);
-//    if (xl < xr) {
-//        int mid = (xl + xr) >> 1;
-//        build(xl, mid, xi << 1);
-//        build(mid + 1, xr, xi << 1 | 1);
-//    }
-//}
-//
-//void yupdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
+//void innerUpdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
 //    if (yl == yr) {
 //        tree[xi][yi] = max(tree[xi][yi], jobv);
 //    } else {
 //        int mid = (yl + yr) >> 1;
 //        if (joby <= mid) {
-//            yupdate(joby, jobv, yl, mid, xi, yi << 1);
+//        	innerUpdate(joby, jobv, yl, mid, xi, yi << 1);
 //        } else {
-//            yupdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
+//        	innerUpdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
 //        }
 //        tree[xi][yi] = max(tree[xi][yi << 1], tree[xi][(yi << 1) | 1]);
 //    }
 //}
 //
-//void update(int jobx, int joby, int jobv, int xl, int xr, int xi) {
-//    yupdate(joby, jobv, 0, n, xi, 1);
-//    if (xl < xr) {
-//        int mid = (xl + xr) >> 1;
-//        if (jobx <= mid) {
-//            update(jobx, joby, jobv, xl, mid, xi << 1);
-//        } else {
-//            update(jobx, joby, jobv, mid + 1, xr, xi << 1 | 1);
-//        }
-//    }
-//}
-//
-//int yquery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
+//int innerQuery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
 //    if (jobyl <= yl && yr <= jobyr) {
 //        return tree[xi][yi];
 //    }
 //    int mid = (yl + yr) >> 1;
 //    int ans = -1;
 //    if (jobyl <= mid) {
-//        ans = max(ans, yquery(jobyl, jobyr, yl, mid, xi, yi << 1));
+//        ans = max(ans, innerQuery(jobyl, jobyr, yl, mid, xi, yi << 1));
 //    }
 //    if (jobyr > mid) {
-//        ans = max(ans, yquery(jobyl, jobyr, mid + 1, yr, xi, (yi << 1) | 1));
+//        ans = max(ans, innerQuery(jobyl, jobyr, mid + 1, yr, xi, (yi << 1) | 1));
 //    }
 //    return ans;
 //}
 //
-//int query(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
+//void outerBuild(int xl, int xr, int xi) {
+//	innerBuild(0, n, xi, 1);
+//    if (xl < xr) {
+//        int mid = (xl + xr) >> 1;
+//        outerBuild(xl, mid, xi << 1);
+//        outerBuild(mid + 1, xr, xi << 1 | 1);
+//    }
+//}
+//
+//void outerUpdate(int jobx, int joby, int jobv, int xl, int xr, int xi) {
+//	innerUpdate(joby, jobv, 0, n, xi, 1);
+//    if (xl < xr) {
+//        int mid = (xl + xr) >> 1;
+//        if (jobx <= mid) {
+//        	outerUpdate(jobx, joby, jobv, xl, mid, xi << 1);
+//        } else {
+//        	outerUpdate(jobx, joby, jobv, mid + 1, xr, xi << 1 | 1);
+//        }
+//    }
+//}
+//
+//int outerQuery(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
 //    if (jobxl <= xl && xr <= jobxr) {
-//        return yquery(jobyl, jobyr, 0, n, xi, 1);
+//        return innerQuery(jobyl, jobyr, 0, n, xi, 1);
 //    }
 //    int mid = (xl + xr) >> 1;
 //    int ans = -1;
 //    if (jobxl <= mid) {
-//        ans = max(ans, query(jobxl, jobxr, jobyl, jobyr, xl, mid, xi << 1));
+//        ans = max(ans, outerQuery(jobxl, jobxr, jobyl, jobyr, xl, mid, xi << 1));
 //    }
 //    if (jobxr > mid) {
-//        ans = max(ans, query(jobxl, jobxr, jobyl, jobyr, mid + 1, xr, (xi << 1) | 1));
+//        ans = max(ans, outerQuery(jobxl, jobxr, jobyl, jobyr, mid + 1, xr, (xi << 1) | 1));
 //    }
 //    return ans;
 //}
@@ -91,7 +91,7 @@
 //int main() {
 //	scanf("%d", &m);
 //	while(m != 0) {
-//        build(100, 200, 1);
+//		outerBuild(100, 200, 1);
 //        for (int i = 0; i < m; i++) {
 //        	char op[2];
 //            scanf("%s", op);
@@ -101,7 +101,7 @@
 //                scanf("%d %lf %lf", &a, &bd, &cd);
 //                int b = (int)(bd * 10);
 //                int c = (int)(cd * 10);
-//                update(a, b, c, 100, 200, 1);
+//                outerUpdate(a, b, c, 100, 200, 1);
 //            } else {
 //                int a, b;
 //                double cd, dd;
@@ -112,7 +112,7 @@
 //                int xr = max(a, b);
 //                int yl = min(c, d);
 //                int yr = max(c, d);
-//                int ans = query(xl, xr, yl, yr, 100, 200, 1);
+//                int ans = outerQuery(xl, xr, yl, yr, 100, 200, 1);
 //                if (ans == -1) {
 //                    printf("-1\n");
 //                } else {
diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index 0acf61836..688a487f5 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -71,7 +71,7 @@ public static void down(int i, int ln, int rn) {
 		}
 	}
 
-	public static int update(int jobl, int jobr, int l, int r, int i) {
+	public static int innerAdd(int jobl, int jobr, int l, int r, int i) {
 		if (i == 0) {
 			i = ++cntt;
 		}
@@ -82,17 +82,17 @@ public static int update(int jobl, int jobr, int l, int r, int i) {
 			int mid = (l + r) / 2;
 			down(i, mid - l + 1, r - mid);
 			if (jobl <= mid) {
-				left[i] = update(jobl, jobr, l, mid, left[i]);
+				left[i] = innerAdd(jobl, jobr, l, mid, left[i]);
 			}
 			if (jobr > mid) {
-				right[i] = update(jobl, jobr, mid + 1, r, right[i]);
+				right[i] = innerAdd(jobl, jobr, mid + 1, r, right[i]);
 			}
 			up(i);
 		}
 		return i;
 	}
 
-	public static long querySum(int jobl, int jobr, int l, int r, int i) {
+	public static long innerQuery(int jobl, int jobr, int l, int r, int i) {
 		if (i == 0) {
 			return 0;
 		}
@@ -103,36 +103,36 @@ public static long querySum(int jobl, int jobr, int l, int r, int i) {
 		down(i, mid - l + 1, r - mid);
 		long ans = 0;
 		if (jobl <= mid) {
-			ans += querySum(jobl, jobr, l, mid, left[i]);
+			ans += innerQuery(jobl, jobr, l, mid, left[i]);
 		}
 		if (jobr > mid) {
-			ans += querySum(jobl, jobr, mid + 1, r, right[i]);
+			ans += innerQuery(jobl, jobr, mid + 1, r, right[i]);
 		}
 		return ans;
 	}
 
-	public static void add(int jobl, int jobr, int jobk, int l, int r, int i) {
-		root[i] = update(jobl, jobr, 1, n, root[i]);
+	public static void outerAdd(int jobl, int jobr, int jobk, int l, int r, int i) {
+		root[i] = innerAdd(jobl, jobr, 1, n, root[i]);
 		if (l < r) {
 			int mid = (l + r) / 2;
 			if (jobk <= mid) {
-				add(jobl, jobr, jobk, l, mid, i << 1);
+				outerAdd(jobl, jobr, jobk, l, mid, i << 1);
 			} else {
-				add(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+				outerAdd(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
 			}
 		}
 	}
 
-	public static int query(int jobl, int jobr, long jobk, int l, int r, int i) {
+	public static int outerQuery(int jobl, int jobr, long jobk, int l, int r, int i) {
 		if (l == r) {
 			return l;
 		}
 		int mid = (l + r) / 2;
-		long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
+		long rightsum = innerQuery(jobl, jobr, 1, n, root[i << 1 | 1]);
 		if (jobk > rightsum) {
-			return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
+			return outerQuery(jobl, jobr, jobk - rightsum, l, mid, i << 1);
 		} else {
-			return query(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+			return outerQuery(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
 		}
 	}
 
@@ -179,9 +179,9 @@ public static void main(String[] args) throws IOException {
 		prepare();
 		for (int i = 1; i <= m; i++) {
 			if (ques[i][0] == 1) {
-				add(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+				outerAdd(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
 			} else {
-				int idx = query(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+				int idx = outerQuery(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
 				out.println(sorted[idx]);
 			}
 		}
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index 60c74019a..c4d45feac 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -53,7 +53,7 @@
 //    }
 //}
 //
-//int update(int jobl, int jobr, int l, int r, int i) {
+//int innerAdd(int jobl, int jobr, int l, int r, int i) {
 //    if (!i) i = ++cntt;
 //    if (jobl <= l && r <= jobr) {
 //        sum[i] += (long long)(r - l + 1);
@@ -61,14 +61,14 @@
 //    } else {
 //        int mid = (l + r) >> 1;
 //        down(i, mid - l + 1, r - mid);
-//        if (jobl <= mid) ls[i] = update(jobl, jobr, l, mid, ls[i]);
-//        if (jobr > mid) rs[i] = update(jobl, jobr, mid + 1, r, rs[i]);
+//        if (jobl <= mid) ls[i] = innerAdd(jobl, jobr, l, mid, ls[i]);
+//        if (jobr > mid) rs[i] = innerAdd(jobl, jobr, mid + 1, r, rs[i]);
 //        up(i);
 //    }
 //    return i;
 //}
 //
-//long long querySum(int jobl, int jobr, int l, int r, int i) {
+//long long innerQuery(int jobl, int jobr, int l, int r, int i) {
 //    if (!i) return 0;
 //    if (jobl <= l && r <= jobr) {
 //        return sum[i];
@@ -76,33 +76,33 @@
 //    int mid = (l + r) >> 1;
 //    down(i, mid - l + 1, r - mid);
 //    long long ans = 0;
-//    if (jobl <= mid) ans += querySum(jobl, jobr, l, mid, ls[i]);
-//    if (jobr > mid) ans += querySum(jobl, jobr, mid + 1, r, rs[i]);
+//    if (jobl <= mid) ans += innerQuery(jobl, jobr, l, mid, ls[i]);
+//    if (jobr > mid) ans += innerQuery(jobl, jobr, mid + 1, r, rs[i]);
 //    return ans;
 //}
 //
-//void add(int jobl, int jobr, int jobk, int l, int r, int i) {
-//    root[i] = update(jobl, jobr, 1, n, root[i]);
+//void outerAdd(int jobl, int jobr, int jobk, int l, int r, int i) {
+//    root[i] = innerAdd(jobl, jobr, 1, n, root[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
 //        if (jobk <= mid) {
-//            add(jobl, jobr, jobk, l, mid, i << 1);
+//            outerAdd(jobl, jobr, jobk, l, mid, i << 1);
 //        } else {
-//            add(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+//            outerAdd(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
 //        }
 //    }
 //}
 //
-//int query(int jobl, int jobr, long long jobk, int l, int r, int i) {
+//int outerQuery(int jobl, int jobr, long long jobk, int l, int r, int i) {
 //    if (l == r) {
 //        return l;
 //    }
 //    int mid = (l + r) >> 1;
-//    long long rightsum = querySum(jobl, jobr, 1, n, root[i << 1 | 1]);
+//    long long rightsum = innerQuery(jobl, jobr, 1, n, root[i << 1 | 1]);
 //    if (jobk > rightsum) {
-//        return query(jobl, jobr, jobk - rightsum, l, mid, i << 1);
+//        return outerQuery(jobl, jobr, jobk - rightsum, l, mid, i << 1);
 //    } else {
-//        return query(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+//        return outerQuery(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
 //    }
 //}
 //
@@ -138,9 +138,9 @@
 //    prepare();
 //    for (int i = 1; i <= m; i++) {
 //        if (ques[i][0] == 1) {
-//            add(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+//            outerAdd(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
 //        } else {
-//            int idx = query(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
+//            int idx = outerQuery(ques[i][1], ques[i][2], ques[i][3], 1, s, 1);
 //            cout << sorted[idx] << "\n";
 //        }
 //    }
diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index e16062c2f..608353819 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -14,9 +14,13 @@
 public class Code03_SegmentWithBalanced1 {
 
 	public static int MAXN = 50001;
+
 	public static int MAXT = MAXN * 40;
+
 	public static int INF = Integer.MAX_VALUE;
+
 	public static double ALPHA = 0.7;
+
 	public static int n, m;
 
 	// 原始数组
@@ -27,15 +31,22 @@ public class Code03_SegmentWithBalanced1 {
 
 	// 替罪羊树需要
 	public static int[] key = new int[MAXT];
+
 	public static int[] cnts = new int[MAXT];
+
 	public static int[] left = new int[MAXT];
+
 	public static int[] right = new int[MAXT];
+
 	public static int[] size = new int[MAXT];
+
 	public static int[] diff = new int[MAXT];
+
 	public static int cnt = 0;
 
 	// rebuild用到的中序收集数组
 	public static int[] collect = new int[MAXT];
+
 	public static int ci;
 
 	// 最上方的失衡点、失衡点的父节点、失衡点的方向
@@ -53,6 +64,10 @@ public static void up(int i) {
 		diff[i] = diff[left[i]] + diff[right[i]] + (cnts[i] > 0 ? 1 : 0);
 	}
 
+	public static boolean balance(int i) {
+		return i == 0 || ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
+	}
+
 	public static void inorder(int i) {
 		if (i != 0) {
 			inorder(left[i]);
@@ -63,49 +78,45 @@ public static void inorder(int i) {
 		}
 	}
 
-	public static int build(int l, int r) {
+	public static int innerBuild(int l, int r) {
 		if (l > r) {
 			return 0;
 		}
 		int m = (l + r) >> 1;
 		int h = collect[m];
-		left[h] = build(l, m - 1);
-		right[h] = build(m + 1, r);
+		left[h] = innerBuild(l, m - 1);
+		right[h] = innerBuild(m + 1, r);
 		up(h);
 		return h;
 	}
 
-	public static int rebuild(int i) {
+	public static int innerRebuild(int i) {
 		if (top != 0) {
 			ci = 0;
 			inorder(top);
 			if (ci > 0) {
 				if (father == 0) {
-					i = build(1, ci);
+					i = innerBuild(1, ci);
 				} else if (side == 1) {
-					left[father] = build(1, ci);
+					left[father] = innerBuild(1, ci);
 				} else {
-					right[father] = build(1, ci);
+					right[father] = innerBuild(1, ci);
 				}
 			}
 		}
 		return i;
 	}
 
-	public static boolean balance(int i) {
-		return i == 0 || ALPHA * diff[i] >= Math.max(diff[left[i]], diff[right[i]]);
-	}
-
-	public static int insertNumber(int num, int i, int f, int s) {
+	public static int innerInsert(int num, int i, int f, int s) {
 		if (i == 0) {
 			i = init(num);
 		} else {
 			if (key[i] == num) {
 				cnts[i]++;
 			} else if (key[i] > num) {
-				left[i] = insertNumber(num, left[i], i, 1);
+				left[i] = innerInsert(num, left[i], i, 1);
 			} else {
-				right[i] = insertNumber(num, right[i], i, 2);
+				right[i] = innerInsert(num, right[i], i, 2);
 			}
 			up(i);
 			if (!balance(i)) {
@@ -117,60 +128,60 @@ public static int insertNumber(int num, int i, int f, int s) {
 		return i;
 	}
 
-	public static int insertNumber(int num, int i) {
+	public static int innerInsert(int num, int i) {
 		top = father = side = 0;
-		i = insertNumber(num, i, 0, 0);
-		i = rebuild(i);
+		i = innerInsert(num, i, 0, 0);
+		i = innerRebuild(i);
 		return i;
 	}
 
-	public static int querySmall(int num, int i) {
+	public static int innerSmall(int num, int i) {
 		if (i == 0) {
 			return 0;
 		}
 		if (key[i] >= num) {
-			return querySmall(num, left[i]);
+			return innerSmall(num, left[i]);
 		} else {
-			return size[left[i]] + cnts[i] + querySmall(num, right[i]);
+			return size[left[i]] + cnts[i] + innerSmall(num, right[i]);
 		}
 	}
 
-	public static int queryIndex(int index, int i) {
+	public static int innerIndex(int index, int i) {
 		int leftsize = size[left[i]];
 		if (leftsize >= index) {
-			return queryIndex(index, left[i]);
+			return innerIndex(index, left[i]);
 		} else if (leftsize + cnts[i] < index) {
-			return queryIndex(index - leftsize - cnts[i], right[i]);
+			return innerIndex(index - leftsize - cnts[i], right[i]);
 		} else {
 			return key[i];
 		}
 	}
 
-	public static int queryPre(int num, int i) {
-		int kth = querySmall(num, i) + 1;
+	public static int innerPre(int num, int i) {
+		int kth = innerSmall(num, i) + 1;
 		if (kth == 1) {
 			return -INF;
 		} else {
-			return queryIndex(kth - 1, i);
+			return innerIndex(kth - 1, i);
 		}
 	}
 
-	public static int queryPost(int num, int i) {
-		int kth = querySmall(num + 1, i);
+	public static int innerPost(int num, int i) {
+		int kth = innerSmall(num + 1, i);
 		if (kth == size[i]) {
 			return INF;
 		} else {
-			return queryIndex(kth + 1, i);
+			return innerIndex(kth + 1, i);
 		}
 	}
 
-	public static void removeNumber(int num, int i, int f, int s) {
+	public static void innerRemove(int num, int i, int f, int s) {
 		if (key[i] == num) {
 			cnts[i]--;
 		} else if (key[i] > num) {
-			removeNumber(num, left[i], i, 1);
+			innerRemove(num, left[i], i, 1);
 		} else {
-			removeNumber(num, right[i], i, 2);
+			innerRemove(num, right[i], i, 2);
 		}
 		up(i);
 		if (!balance(i)) {
@@ -180,18 +191,18 @@ public static void removeNumber(int num, int i, int f, int s) {
 		}
 	}
 
-	public static int removeNumber(int num, int i) {
-		if (querySmall(num, i) != querySmall(num + 1, i)) {
+	public static int innerRemove(int num, int i) {
+		if (innerSmall(num, i) != innerSmall(num + 1, i)) {
 			top = father = side = 0;
-			removeNumber(num, i, 0, 0);
-			i = rebuild(i);
+			innerRemove(num, i, 0, 0);
+			i = innerRebuild(i);
 		}
 		return i;
 	}
 
 	public static void build(int l, int r, int i) {
 		for (int j = l; j <= r; j++) {
-			root[i] = insertNumber(arr[j], root[i]);
+			root[i] = innerInsert(arr[j], root[i]);
 		}
 		if (l < r) {
 			int mid = (l + r) >> 1;
@@ -201,8 +212,8 @@ public static void build(int l, int r, int i) {
 	}
 
 	public static void update(int jobi, int jobv, int l, int r, int i) {
-		root[i] = removeNumber(arr[jobi], root[i]);
-		root[i] = insertNumber(jobv, root[i]);
+		root[i] = innerRemove(arr[jobi], root[i]);
+		root[i] = innerInsert(jobv, root[i]);
 		if (l < r) {
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
@@ -215,7 +226,7 @@ public static void update(int jobi, int jobv, int l, int r, int i) {
 
 	public static int small(int jobl, int jobr, int jobv, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			return querySmall(jobv, root[i]);
+			return innerSmall(jobv, root[i]);
 		}
 		int mid = (l + r) >> 1;
 		int ans = 0;
@@ -244,7 +255,7 @@ public static int number(int jobl, int jobr, int jobk) {
 
 	public static int pre(int jobl, int jobr, int jobv, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			return queryPre(jobv, root[i]);
+			return innerPre(jobv, root[i]);
 		}
 		int mid = (l + r) >> 1;
 		int ans = -INF;
@@ -259,7 +270,7 @@ public static int pre(int jobl, int jobr, int jobv, int l, int r, int i) {
 
 	public static int post(int jobl, int jobr, int jobv, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			return queryPost(jobv, root[i]);
+			return innerPost(jobv, root[i]);
 		}
 		int mid = (l + r) >> 1;
 		int ans = INF;
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 13078eb6b..6d0a819c7 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -39,6 +39,10 @@
 //	diff[i] = diff[ls[i]] + diff[rs[i]] + (cnts[i] > 0 ? 1 : 0);
 //}
 //
+//bool balance(int i) {
+//    return i == 0 || ALPHA * diff[i] >= max(diff[ls[i]], diff[rs[i]]);
+//}
+//
 //void inorder(int i) {
 //    if (i) {
 //        inorder(ls[i]);
@@ -47,47 +51,43 @@
 //    }
 //}
 //
-//int build(int l, int r) {
+//int innerBuild(int l, int r) {
 //    if (l > r) return 0;
 //    int mid = (l + r) >> 1;
 //    int h = collect[mid];
-//    ls[h] = build(l, mid - 1);
-//    rs[h] = build(mid + 1, r);
+//    ls[h] = innerBuild(l, mid - 1);
+//    rs[h] = innerBuild(mid + 1, r);
 //    up(h);
 //    return h;
 //}
 //
-//int rebuild(int i) {
+//int innerRebuild(int i) {
 //    if (top) {
 //        ci = 0;
 //        inorder(top);
 //        if (ci > 0) {
 //            if (father == 0) {
-//                i = build(1, ci);
+//                i = innerBuild(1, ci);
 //            } else if (side == 1) {
-//            	ls[father] = build(1, ci);
+//            	ls[father] = innerBuild(1, ci);
 //            } else {
-//            	rs[father] = build(1, ci);
+//            	rs[father] = innerBuild(1, ci);
 //            }
 //        }
 //    }
 //    return i;
 //}
 //
-//bool balance(int i) {
-//    return i == 0 || ALPHA * diff[i] >= max(diff[ls[i]], diff[rs[i]]);
-//}
-//
-//int insertNumber(int num, int i, int f, int s) {
+//int innerInsert(int num, int i, int f, int s) {
 //    if (!i) {
 //        i = init(num);
 //    } else {
 //        if (key[i] == num) {
 //        	cnts[i]++;
 //        } else if (key[i] > num) {
-//        	ls[i] = insertNumber(num, ls[i], i, 1);
+//        	ls[i] = innerInsert(num, ls[i], i, 1);
 //        } else {
-//        	rs[i] = insertNumber(num, rs[i], i, 2);
+//        	rs[i] = innerInsert(num, rs[i], i, 2);
 //        }
 //        up(i);
 //        if (!balance(i)) {
@@ -99,48 +99,48 @@
 //    return i;
 //}
 //
-//int insertNumber(int num, int i) {
+//int innerInsert(int num, int i) {
 //    top = father = side = 0;
-//    i = insertNumber(num, i, 0, 0);
-//    i = rebuild(i);
+//    i = innerInsert(num, i, 0, 0);
+//    i = innerRebuild(i);
 //    return i;
 //}
 //
-//int querySmall(int num, int i) {
+//int innerSmall(int num, int i) {
 //    if (!i) return 0;
-//    if (key[i] >= num) return querySmall(num, ls[i]);
-//    return siz[ls[i]] + cnts[i] + querySmall(num, rs[i]);
+//    if (key[i] >= num) return innerSmall(num, ls[i]);
+//    return siz[ls[i]] + cnts[i] + innerSmall(num, rs[i]);
 //}
 //
-//int queryIndex(int index, int i) {
+//int innerIndex(int index, int i) {
 //    int leftsize = siz[ls[i]];
 //    if (leftsize >= index) {
-//        return queryIndex(index, ls[i]);
+//        return innerIndex(index, ls[i]);
 //    } else if (leftsize + cnts[i] < index) {
-//        return queryIndex(index - leftsize - cnts[i], rs[i]);
+//        return innerIndex(index - leftsize - cnts[i], rs[i]);
 //    }
 //    return key[i];
 //}
 //
-//int queryPre(int num, int i) {
-//    int kth = querySmall(num, i) + 1;
+//int innerPre(int num, int i) {
+//    int kth = innerSmall(num, i) + 1;
 //    if (kth == 1) return -INF;
-//    return queryIndex(kth - 1, i);
+//    return innerIndex(kth - 1, i);
 //}
 //
-//int queryPost(int num, int i) {
-//    int kth = querySmall(num + 1, i);
+//int innerPost(int num, int i) {
+//    int kth = innerSmall(num + 1, i);
 //    if (kth == siz[i]) return INF;
-//    return queryIndex(kth + 1, i);
+//    return innerIndex(kth + 1, i);
 //}
 //
-//void removeNumber(int num, int i, int f, int s) {
+//void innerRemove(int num, int i, int f, int s) {
 //    if (key[i] == num) {
 //    	cnts[i]--;
 //    } else if (key[i] > num) {
-//    	removeNumber(num, ls[i], i, 1);
+//    	innerRemove(num, ls[i], i, 1);
 //    } else {
-//    	removeNumber(num, rs[i], i, 2);
+//    	innerRemove(num, rs[i], i, 2);
 //    }
 //    up(i);
 //    if (!balance(i)) {
@@ -150,17 +150,17 @@
 //    }
 //}
 //
-//int removeNumber(int num, int i) {
-//    if (querySmall(num, i) != querySmall(num + 1, i)) {
+//int innerRemove(int num, int i) {
+//    if (innerSmall(num, i) != innerSmall(num + 1, i)) {
 //        top = father = side = 0;
-//        removeNumber(num, i, 0, 0);
-//        i = rebuild(i);
+//        innerRemove(num, i, 0, 0);
+//        i = innerRebuild(i);
 //    }
 //    return i;
 //}
 //
 //void build(int l, int r, int i) {
-//    for (int j = l; j <= r; j++) root[i] = insertNumber(arr[j], root[i]);
+//    for (int j = l; j <= r; j++) root[i] = innerInsert(arr[j], root[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
 //        build(l, mid, i << 1);
@@ -169,8 +169,8 @@
 //}
 //
 //void update(int jobi, int jobv, int l, int r, int i) {
-//    root[i] = removeNumber(arr[jobi], root[i]);
-//    root[i] = insertNumber(jobv, root[i]);
+//    root[i] = innerRemove(arr[jobi], root[i]);
+//    root[i] = innerInsert(jobv, root[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
 //        if (jobi <= mid) update(jobi, jobv, l, mid, i << 1);
@@ -179,7 +179,7 @@
 //}
 //
 //int small(int jobl, int jobr, int jobv, int l, int r, int i) {
-//    if (jobl <= l && r <= jobr) return querySmall(jobv, root[i]);
+//    if (jobl <= l && r <= jobr) return innerSmall(jobv, root[i]);
 //    int mid = (l + r) >> 1, ans = 0;
 //    if (jobl <= mid) ans += small(jobl, jobr, jobv, l, mid, i << 1);
 //    if (jobr > mid) ans += small(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
@@ -201,7 +201,7 @@
 //}
 //
 //int pre(int jobl, int jobr, int jobv, int l, int r, int i) {
-//    if (jobl <= l && r <= jobr) return queryPre(jobv, root[i]);
+//    if (jobl <= l && r <= jobr) return innerPre(jobv, root[i]);
 //    int mid = (l + r) >> 1, ans = -INF;
 //    if (jobl <= mid) ans = max(ans, pre(jobl, jobr, jobv, l, mid, i << 1));
 //    if (jobr > mid) ans = max(ans, pre(jobl, jobr, jobv, mid + 1, r, i << 1 | 1));
@@ -209,7 +209,7 @@
 //}
 //
 //int post(int jobl, int jobr, int jobv, int l, int r, int i) {
-//    if (jobl <= l && r <= jobr) return queryPost(jobv, root[i]);
+//    if (jobl <= l && r <= jobr) return innerPost(jobv, root[i]);
 //    int mid = (l + r) >> 1, ans = INF;
 //    if (jobl <= mid) ans = min(ans, post(jobl, jobr, jobv, l, mid, i << 1));
 //    if (jobr > mid) ans = min(ans, post(jobl, jobr, jobv, mid + 1, r, i << 1 | 1));
diff --git a/src/class160/Code04_IndexWithSegment1.java b/src/class160/Code04_IndexWithSegment1.java
index 29b5f69dc..c1301045f 100644
--- a/src/class160/Code04_IndexWithSegment1.java
+++ b/src/class160/Code04_IndexWithSegment1.java
@@ -66,7 +66,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	public static int add(int jobi, int jobv, int l, int r, int i) {
+	public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
 		if (i == 0) {
 			i = ++cntt;
 		}
@@ -75,22 +75,16 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 		} else {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
-				left[i] = add(jobi, jobv, l, mid, left[i]);
+				left[i] = innerAdd(jobi, jobv, l, mid, left[i]);
 			} else {
-				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
+				right[i] = innerAdd(jobi, jobv, mid + 1, r, right[i]);
 			}
 			sum[i] = sum[left[i]] + sum[right[i]];
 		}
 		return i;
 	}
 
-	public static void add(int i, int v) {
-		for (int j = i; j <= n; j += lowbit(j)) {
-			root[j] = add(arr[i], v, 1, s, root[j]);
-		}
-	}
-
-	public static int queryNumber(int jobk, int l, int r) {
+	public static int innerQuery(int jobk, int l, int r) {
 		if (l == r) {
 			return l;
 		}
@@ -109,7 +103,7 @@ public static int queryNumber(int jobk, int l, int r) {
 			for (int i = 1; i <= cntpre; i++) {
 				pre[i] = left[pre[i]];
 			}
-			return queryNumber(jobk, l, mid);
+			return innerQuery(jobk, l, mid);
 		} else {
 			for (int i = 1; i <= cntpos; i++) {
 				pos[i] = right[pos[i]];
@@ -117,22 +111,11 @@ public static int queryNumber(int jobk, int l, int r) {
 			for (int i = 1; i <= cntpre; i++) {
 				pre[i] = right[pre[i]];
 			}
-			return queryNumber(jobk - leftsum, mid + 1, r);
-		}
-	}
-
-	public static int findNumber(int l, int r, int k) {
-		cntpos = cntpre = 0;
-		for (int i = r; i > 0; i -= lowbit(i)) {
-			pos[++cntpos] = root[i];
-		}
-		for (int i = l - 1; i > 0; i -= lowbit(i)) {
-			pre[++cntpre] = root[i];
+			return innerQuery(jobk - leftsum, mid + 1, r);
 		}
-		return sorted[queryNumber(k, 1, s)];
 	}
 
-	public static int queryRank(int jobk, int l, int r) {
+	public static int innerRank(int jobk, int l, int r) {
 		if (l == r) {
 			return 0;
 		}
@@ -144,7 +127,7 @@ public static int queryRank(int jobk, int l, int r) {
 			for (int i = 1; i <= cntpre; i++) {
 				pre[i] = left[pre[i]];
 			}
-			return queryRank(jobk, l, mid);
+			return innerRank(jobk, l, mid);
 		} else {
 			int leftsum = 0;
 			for (int i = 1; i <= cntpos; i++) {
@@ -155,11 +138,28 @@ public static int queryRank(int jobk, int l, int r) {
 				leftsum -= sum[left[pre[i]]];
 				pre[i] = right[pre[i]];
 			}
-			return leftsum + queryRank(jobk, mid + 1, r);
+			return leftsum + innerRank(jobk, mid + 1, r);
+		}
+	}
+
+	public static void outerAdd(int i, int v) {
+		for (int j = i; j <= n; j += lowbit(j)) {
+			root[j] = innerAdd(arr[i], v, 1, s, root[j]);
+		}
+	}
+
+	public static int outerQuery(int l, int r, int k) {
+		cntpos = cntpre = 0;
+		for (int i = r; i > 0; i -= lowbit(i)) {
+			pos[++cntpos] = root[i];
+		}
+		for (int i = l - 1; i > 0; i -= lowbit(i)) {
+			pre[++cntpre] = root[i];
 		}
+		return sorted[innerQuery(k, 1, s)];
 	}
 
-	public static int findRank(int l, int r, int k) {
+	public static int outerRank(int l, int r, int k) {
 		cntpos = cntpre = 0;
 		for (int i = r; i > 0; i -= lowbit(i)) {
 			pos[++cntpos] = root[i];
@@ -167,26 +167,26 @@ public static int findRank(int l, int r, int k) {
 		for (int i = l - 1; i > 0; i -= lowbit(i)) {
 			pre[++cntpre] = root[i];
 		}
-		return queryRank(k, 1, s) + 1;
+		return innerRank(k, 1, s) + 1;
 	}
 
-	public static int findLast(int l, int r, int k) {
-		int rank = findRank(l, r, k);
+	public static int outerPre(int l, int r, int k) {
+		int rank = outerRank(l, r, k);
 		if (rank == 1) {
 			return -INF;
 		}
-		return findNumber(l, r, rank - 1);
+		return outerQuery(l, r, rank - 1);
 	}
 
-	public static int findNext(int l, int r, int k) {
+	public static int outerPost(int l, int r, int k) {
 		if (k == s) {
 			return INF;
 		}
-		int rank = findRank(l, r, k + 1);
+		int rank = outerRank(l, r, k + 1);
 		if (rank == r - l + 2) {
 			return INF;
 		}
-		return findNumber(l, r, rank);
+		return outerQuery(l, r, rank);
 	}
 
 	public static void prepare() {
@@ -211,7 +211,7 @@ public static void prepare() {
 		s = len;
 		for (int i = 1; i <= n; i++) {
 			arr[i] = kth(arr[i]);
-			add(i, 1);
+			outerAdd(i, 1);
 		}
 	}
 
@@ -242,17 +242,17 @@ public static void main(String[] args) throws IOException {
 		prepare();
 		for (int i = 1; i <= m; i++) {
 			if (ques[i][0] == 1) {
-				out.println(findRank(ques[i][1], ques[i][2], kth(ques[i][3])));
+				out.println(outerRank(ques[i][1], ques[i][2], kth(ques[i][3])));
 			} else if (ques[i][0] == 2) {
-				out.println(findNumber(ques[i][1], ques[i][2], ques[i][3]));
+				out.println(outerQuery(ques[i][1], ques[i][2], ques[i][3]));
 			} else if (ques[i][0] == 3) {
-				add(ques[i][1], -1);
+				outerAdd(ques[i][1], -1);
 				arr[ques[i][1]] = kth(ques[i][2]);
-				add(ques[i][1], 1);
+				outerAdd(ques[i][1], 1);
 			} else if (ques[i][0] == 4) {
-				out.println(findLast(ques[i][1], ques[i][2], kth(ques[i][3])));
+				out.println(outerPre(ques[i][1], ques[i][2], kth(ques[i][3])));
 			} else {
-				out.println(findNext(ques[i][1], ques[i][2], kth(ques[i][3])));
+				out.println(outerPost(ques[i][1], ques[i][2], kth(ques[i][3])));
 			}
 		}
 		out.flush();
diff --git a/src/class160/Code04_IndexWithSegment2.java b/src/class160/Code04_IndexWithSegment2.java
index e692fe066..2e8447e69 100644
--- a/src/class160/Code04_IndexWithSegment2.java
+++ b/src/class160/Code04_IndexWithSegment2.java
@@ -42,26 +42,20 @@
 //    return i & -i;
 //}
 //
-//int add(int jobi, int jobv, int l, int r, int i) {
+//int innerAdd(int jobi, int jobv, int l, int r, int i) {
 //    if (!i) i = ++cntt;
 //    if (l == r) {
 //        sum[i] += jobv;
 //    } else {
 //        int mid = (l + r) >> 1;
-//        if (jobi <= mid) ls[i] = add(jobi, jobv, l, mid, ls[i]);
-//        else rs[i] = add(jobi, jobv, mid + 1, r, rs[i]);
+//        if (jobi <= mid) ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
+//        else rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
 //        sum[i] = sum[ls[i]] + sum[rs[i]];
 //    }
 //    return i;
 //}
 //
-//void add(int i, int v) {
-//    for (int j = i; j <= n; j += lowbit(j)) {
-//        root[j] = add(arr[i], v, 1, s, root[j]);
-//    }
-//}
-//
-//int queryNumber(int jobk, int l, int r) {
+//int innerQuery(int jobk, int l, int r) {
 //    if (l == r) return l;
 //    int mid = (l + r) >> 1;
 //    int leftsum = 0;
@@ -70,28 +64,21 @@
 //    if (jobk <= leftsum) {
 //        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
 //        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
-//        return queryNumber(jobk, l, mid);
+//        return innerQuery(jobk, l, mid);
 //    } else {
 //        for (int i = 1; i <= cntpos; i++) pos[i] = rs[pos[i]];
 //        for (int i = 1; i <= cntpre; i++) pre[i] = rs[pre[i]];
-//        return queryNumber(jobk - leftsum, mid + 1, r);
+//        return innerQuery(jobk - leftsum, mid + 1, r);
 //    }
 //}
 //
-//int findNumber(int l, int r, int k) {
-//    cntpos = cntpre = 0;
-//    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
-//    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
-//    return sorted[queryNumber(k, 1, s)];
-//}
-//
-//int queryRank(int jobi, int l, int r) {
+//int innerRank(int jobi, int l, int r) {
 //    if (l == r) return 0;
 //    int mid = (l + r) >> 1;
 //    if (jobi <= mid) {
 //        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
 //        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
-//        return queryRank(jobi, l, mid);
+//        return innerRank(jobi, l, mid);
 //    } else {
 //        int leftsum = 0;
 //        for (int i = 1; i <= cntpos; i++) {
@@ -102,26 +89,39 @@
 //            leftsum -= sum[ls[pre[i]]];
 //            pre[i] = rs[pre[i]];
 //        }
-//        return leftsum + queryRank(jobi, mid + 1, r);
+//        return leftsum + innerRank(jobi, mid + 1, r);
 //    }
 //}
 //
-//int findRank(int l, int r, int k) {
+//void outerAdd(int i, int v) {
+//    for (int j = i; j <= n; j += lowbit(j)) {
+//        root[j] = innerAdd(arr[i], v, 1, s, root[j]);
+//    }
+//}
+//
+//int outerQuery(int l, int r, int k) {
+//    cntpos = cntpre = 0;
+//    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
+//    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
+//    return sorted[innerQuery(k, 1, s)];
+//}
+//
+//int outerRank(int l, int r, int k) {
 //    cntpos = cntpre = 0;
 //    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
 //    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
-//    return queryRank(k, 1, s) + 1;
+//    return innerRank(k, 1, s) + 1;
 //}
 //
-//int findLast(int l, int r, int k) {
-//    int rk = findRank(l, r, k);
-//    return (rk == 1) ? -INF : findNumber(l, r, rk - 1);
+//int outerPre(int l, int r, int k) {
+//    int rk = outerRank(l, r, k);
+//    return (rk == 1) ? -INF : outerQuery(l, r, rk - 1);
 //}
 //
-//int findNext(int l, int r, int k) {
+//int outerPost(int l, int r, int k) {
 //    if (k == s) return INF;
-//    int rk = findRank(l, r, k + 1);
-//    return (rk == r - l + 2) ? INF : findNumber(l, r, rk);
+//    int rk = outerRank(l, r, k + 1);
+//    return (rk == r - l + 2) ? INF : outerQuery(l, r, rk);
 //}
 //
 //void prepare() {
@@ -138,7 +138,7 @@
 //    s = len;
 //    for (int i = 1; i <= n; i++) {
 //        arr[i] = kth(arr[i]);
-//        add(i, 1);
+//        outerAdd(i, 1);
 //    }
 //}
 //
@@ -154,17 +154,17 @@
 //    prepare();
 //    for (int i = 1; i <= m; i++) {
 //        if (ques[i][0] == 1) {
-//            cout << findRank(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
+//            cout << outerRank(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
 //        } else if (ques[i][0] == 2) {
-//            cout << findNumber(ques[i][1], ques[i][2], ques[i][3]) << "\n";
+//            cout << outerQuery(ques[i][1], ques[i][2], ques[i][3]) << "\n";
 //        } else if (ques[i][0] == 3) {
-//            add(ques[i][1], -1);
+//            outerAdd(ques[i][1], -1);
 //            arr[ques[i][1]] = kth(ques[i][2]);
-//            add(ques[i][1], 1);
+//            outerAdd(ques[i][1], 1);
 //        } else if (ques[i][0] == 4) {
-//            cout << findLast(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
+//            cout << outerPre(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
 //        } else {
-//            cout << findNext(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
+//            cout << outerPost(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
 //        }
 //    }
 //    return 0;
diff --git a/src/class160/Code05_LineUp1.java b/src/class160/Code05_LineUp1.java
index 4c03c4887..e44b8ea1c 100644
--- a/src/class160/Code05_LineUp1.java
+++ b/src/class160/Code05_LineUp1.java
@@ -57,7 +57,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	public static int add(int jobi, int jobv, int l, int r, int i) {
+	public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
 		if (i == 0) {
 			i = ++cnt;
 		}
@@ -66,16 +66,16 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 		} else {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
-				left[i] = add(jobi, jobv, l, mid, left[i]);
+				left[i] = innerAdd(jobi, jobv, l, mid, left[i]);
 			} else {
-				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
+				right[i] = innerAdd(jobi, jobv, mid + 1, r, right[i]);
 			}
 			sum[i] = sum[left[i]] + sum[right[i]];
 		}
 		return i;
 	}
 
-	public static int query(int jobl, int jobr, int l, int r, int i) {
+	public static int innerQuery(int jobl, int jobr, int l, int r, int i) {
 		if (i == 0) {
 			return 0;
 		}
@@ -85,27 +85,27 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 		int mid = (l + r) / 2;
 		int ans = 0;
 		if (jobl <= mid) {
-			ans += query(jobl, jobr, l, mid, left[i]);
+			ans += innerQuery(jobl, jobr, l, mid, left[i]);
 		}
 		if (jobr > mid) {
-			ans += query(jobl, jobr, mid + 1, r, right[i]);
+			ans += innerQuery(jobl, jobr, mid + 1, r, right[i]);
 		}
 		return ans;
 	}
 
 	public static void insert(int i, int v) {
 		for (int j = i; j <= n; j += lowbit(j)) {
-			root[j] = add(arr[i], v, 1, s, root[j]);
+			root[j] = innerAdd(arr[i], v, 1, s, root[j]);
 		}
 	}
 
-	public static int queryCnt(int al, int ar, int numl, int numr) {
+	public static int query(int al, int ar, int numl, int numr) {
 		int ans = 0;
 		for (int i = ar; i > 0; i -= lowbit(i)) {
-			ans += query(numl, numr, 1, s, root[i]);
+			ans += innerQuery(numl, numr, 1, s, root[i]);
 		}
 		for (int i = al - 1; i > 0; i -= lowbit(i)) {
-			ans -= query(numl, numr, 1, s, root[i]);
+			ans -= innerQuery(numl, numr, 1, s, root[i]);
 		}
 		return ans;
 	}
@@ -132,10 +132,10 @@ public static void prepare() {
 	}
 
 	public static void compute(int a, int b) {
-		ans -= queryCnt(a + 1, b - 1, 1, arr[a] - 1);
-		ans += queryCnt(a + 1, b - 1, arr[a] + 1, s);
-		ans -= queryCnt(a + 1, b - 1, arr[b] + 1, s);
-		ans += queryCnt(a + 1, b - 1, 1, arr[b] - 1);
+		ans -= query(a + 1, b - 1, 1, arr[a] - 1);
+		ans += query(a + 1, b - 1, arr[a] + 1, s);
+		ans -= query(a + 1, b - 1, arr[b] + 1, s);
+		ans += query(a + 1, b - 1, 1, arr[b] - 1);
 		if (arr[a] < arr[b]) {
 			ans++;
 		} else if (arr[a] > arr[b]) {
@@ -162,7 +162,7 @@ public static void main(String[] args) throws IOException {
 		}
 		prepare();
 		for (int i = 2; i <= n; i++) {
-			ans += queryCnt(1, i - 1, arr[i] + 1, s);
+			ans += query(1, i - 1, arr[i] + 1, s);
 		}
 		out.println(ans);
 		in.nextToken();
diff --git a/src/class160/Code05_LineUp2.java b/src/class160/Code05_LineUp2.java
index a941c58f9..96e22416e 100644
--- a/src/class160/Code05_LineUp2.java
+++ b/src/class160/Code05_LineUp2.java
@@ -37,38 +37,51 @@
 //    return i & -i;
 //}
 //
-//int add(int jobi, int jobv, int l, int r, int i) {
+//int innerAdd(int jobi, int jobv, int l, int r, int i) {
 //    if (i == 0) i = ++cnt;
-//    if (l == r) sum[i] += jobv;
-//    else {
+//    if (l == r) {
+//        sum[i] += jobv;
+//    } else {
 //        int mid = (l + r) / 2;
-//        if (jobi <= mid) ls[i] = add(jobi, jobv, l, mid, ls[i]);
-//        else rs[i] = add(jobi, jobv, mid + 1, r, rs[i]);
+//        if (jobi <= mid) {
+//            ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
+//        } else {
+//            rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
+//        }
 //        sum[i] = sum[ls[i]] + sum[rs[i]];
 //    }
 //    return i;
 //}
 //
-//int query(int jobl, int jobr, int l, int r, int i) {
+//int innerQuery(int jobl, int jobr, int l, int r, int i) {
 //    if (i == 0) return 0;
 //    if (jobl <= l && r <= jobr) return sum[i];
-//    int mid = (l + r) / 2, res = 0;
-//    if (jobl <= mid) res += query(jobl, jobr, l, mid, ls[i]);
-//    if (jobr > mid) res += query(jobl, jobr, mid + 1, r, rs[i]);
-//    return res;
+//    int mid = (l + r) / 2;
+//    int ans = 0;
+//    if (jobl <= mid) {
+//    	ans += innerQuery(jobl, jobr, l, mid, ls[i]);
+//    }
+//    if (jobr > mid) {
+//    	ans += innerQuery(jobl, jobr, mid + 1, r, rs[i]);
+//    }
+//    return ans;
 //}
 //
 //void insert(int i, int v) {
 //    for (int j = i; j <= n; j += lowbit(j)) {
-//        root[j] = add(arr[i], v, 1, s, root[j]);
+//        root[j] = innerAdd(arr[i], v, 1, s, root[j]);
 //    }
 //}
 //
-//int queryCnt(int al, int ar, int numl, int numr) {
-//    int res = 0;
-//    for (int i = ar; i > 0; i -= lowbit(i)) res += query(numl, numr, 1, s, root[i]);
-//    for (int i = al - 1; i > 0; i -= lowbit(i)) res -= query(numl, numr, 1, s, root[i]);
-//    return res;
+//int query(int al, int ar, int numl, int numr) {
+//    int ans = 0;
+//    for (int i = ar; i > 0; i -= lowbit(i)) {
+//        ans += innerQuery(numl, numr, 1, s, root[i]);
+//    }
+//    for (int i = al - 1; i > 0; i -= lowbit(i)) {
+//        ans -= innerQuery(numl, numr, 1, s, root[i]);
+//    }
+//    return ans;
 //}
 //
 //void prepare() {
@@ -89,10 +102,10 @@
 //}
 //
 //void compute(int a, int b) {
-//    ans -= queryCnt(a + 1, b - 1, 1, arr[a] - 1);
-//    ans += queryCnt(a + 1, b - 1, arr[a] + 1, s);
-//    ans -= queryCnt(a + 1, b - 1, arr[b] + 1, s);
-//    ans += queryCnt(a + 1, b - 1, 1, arr[b] - 1);
+//    ans -= query(a + 1, b - 1, 1, arr[a] - 1);
+//    ans += query(a + 1, b - 1, arr[a] + 1, s);
+//    ans -= query(a + 1, b - 1, arr[b] + 1, s);
+//    ans += query(a + 1, b - 1, 1, arr[b] - 1);
 //    if (arr[a] < arr[b]) ans++;
 //    else if (arr[a] > arr[b]) ans--;
 //    insert(a, -1);
@@ -108,7 +121,7 @@
 //    cin >> n;
 //    for (int i = 1; i <= n; i++) cin >> arr[i];
 //    prepare();
-//    for (int i = 2; i <= n; i++) ans += queryCnt(1, i - 1, arr[i] + 1, s);
+//    for (int i = 2; i <= n; i++) ans += query(1, i - 1, arr[i] + 1, s);
 //    cout << ans << '\n';
 //    cin >> m;
 //    for (int i = 1, a, b; i <= m; i++) {
diff --git a/src/class160/Code06_NetworkManagement1.java b/src/class160/Code06_NetworkManagement1.java
index 6322abb3c..c4fcb17f2 100644
--- a/src/class160/Code06_NetworkManagement1.java
+++ b/src/class160/Code06_NetworkManagement1.java
@@ -93,61 +93,6 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	public static int add(int jobi, int jobv, int l, int r, int i) {
-		if (i == 0) {
-			i = ++cntt;
-		}
-		if (l == r) {
-			sum[i] += jobv;
-		} else {
-			int mid = (l + r) / 2;
-			if (jobi <= mid) {
-				left[i] = add(jobi, jobv, l, mid, left[i]);
-			} else {
-				right[i] = add(jobi, jobv, mid + 1, r, right[i]);
-			}
-			sum[i] = sum[left[i]] + sum[right[i]];
-		}
-		return i;
-	}
-
-	public static void add(int i, int kth, int val) {
-		for (; i <= n; i += lowbit(i)) {
-			root[i] = add(kth, val, 1, s, root[i]);
-		}
-	}
-
-	public static int queryNumber(int jobk, int l, int r) {
-		if (l == r) {
-			return l;
-		}
-		int mid = (l + r) / 2;
-		int leftsum = 0;
-		for (int i = 1; i <= cntpos; i++) {
-			leftsum += sum[left[pos[i]]];
-		}
-		for (int i = 1; i <= cntpre; i++) {
-			leftsum -= sum[left[pre[i]]];
-		}
-		if (jobk <= leftsum) {
-			for (int i = 1; i <= cntpos; i++) {
-				pos[i] = left[pos[i]];
-			}
-			for (int i = 1; i <= cntpre; i++) {
-				pre[i] = left[pre[i]];
-			}
-			return queryNumber(jobk, l, mid);
-		} else {
-			for (int i = 1; i <= cntpos; i++) {
-				pos[i] = right[pos[i]];
-			}
-			for (int i = 1; i <= cntpre; i++) {
-				pre[i] = right[pre[i]];
-			}
-			return queryNumber(jobk - leftsum, mid + 1, r);
-		}
-	}
-
 	// dfs1是递归版，java版本提交会爆栈，C++版本不会爆栈
 	public static void dfs1(int u, int fa) {
 		deep[u] = deep[fa] + 1;
@@ -245,35 +190,62 @@ public static int lca(int a, int b) {
 		return stjump[a][0];
 	}
 
-	public static void prepare() {
-		s = 0;
-		for (int i = 1; i <= n; i++) {
-			sorted[++s] = arr[i];
+	public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
+		if (i == 0) {
+			i = ++cntt;
 		}
-		for (int i = 1; i <= m; i++) {
-			if (ques[i][0] == 0) {
-				sorted[++s] = ques[i][2];
+		if (l == r) {
+			sum[i] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[i] = innerAdd(jobi, jobv, l, mid, left[i]);
+			} else {
+				right[i] = innerAdd(jobi, jobv, mid + 1, r, right[i]);
 			}
+			sum[i] = sum[left[i]] + sum[right[i]];
 		}
-		Arrays.sort(sorted, 1, s + 1);
-		int len = 1;
-		for (int i = 2; i <= s; i++) {
-			if (sorted[len] != sorted[i]) {
-				sorted[++len] = sorted[i];
-			}
+		return i;
+	}
+
+	public static int innerQuery(int jobk, int l, int r) {
+		if (l == r) {
+			return l;
 		}
-		s = len;
-		for (int i = 1; i <= n; i++) {
-			arr[i] = kth(arr[i]);
+		int mid = (l + r) / 2;
+		int leftsum = 0;
+		for (int i = 1; i <= cntpos; i++) {
+			leftsum += sum[left[pos[i]]];
 		}
-		dfs2();
-		for (int i = 1; i <= n; i++) {
-			add(dfn[i], arr[i], 1);
-			add(dfn[i] + size[i], arr[i], -1);
+		for (int i = 1; i <= cntpre; i++) {
+			leftsum -= sum[left[pre[i]]];
+		}
+		if (jobk <= leftsum) {
+			for (int i = 1; i <= cntpos; i++) {
+				pos[i] = left[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				pre[i] = left[pre[i]];
+			}
+			return innerQuery(jobk, l, mid);
+		} else {
+			for (int i = 1; i <= cntpos; i++) {
+				pos[i] = right[pos[i]];
+			}
+			for (int i = 1; i <= cntpre; i++) {
+				pre[i] = right[pre[i]];
+			}
+			return innerQuery(jobk - leftsum, mid + 1, r);
 		}
 	}
 
-	public static void change(int i, int v) {
+	public static void add(int i, int kth, int val) {
+		for (; i <= n; i += lowbit(i)) {
+			root[i] = innerAdd(kth, val, 1, s, root[i]);
+		}
+	}
+
+	public static void update(int i, int v) {
 		add(dfn[i], arr[i], -1);
 		add(dfn[i] + size[i], arr[i], 1);
 		arr[i] = kth(v);
@@ -301,7 +273,35 @@ public static int query(int x, int y, int k) {
 		for (int i = dfn[lcafa]; i > 0; i -= lowbit(i)) {
 			pre[++cntpre] = root[i];
 		}
-		return queryNumber(num - k + 1, 1, s);
+		return innerQuery(num - k + 1, 1, s);
+	}
+
+	public static void prepare() {
+		s = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[++s] = arr[i];
+		}
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 0) {
+				sorted[++s] = ques[i][2];
+			}
+		}
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		dfs2();
+		for (int i = 1; i <= n; i++) {
+			add(dfn[i], arr[i], 1);
+			add(dfn[i] + size[i], arr[i], -1);
+		}
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -335,7 +335,7 @@ public static void main(String[] args) throws IOException {
 		prepare();
 		for (int i = 1; i <= m; i++) {
 			if (ques[i][0] == 0) {
-				change(ques[i][1], ques[i][2]);
+				update(ques[i][1], ques[i][2]);
 			} else {
 				int ans = query(ques[i][1], ques[i][2], ques[i][0]);
 				if (ans == -1) {
diff --git a/src/class160/Code06_NetworkManagement2.java b/src/class160/Code06_NetworkManagement2.java
index e17f3b50a..c2972d36a 100644
--- a/src/class160/Code06_NetworkManagement2.java
+++ b/src/class160/Code06_NetworkManagement2.java
@@ -60,39 +60,6 @@
 //    return i & -i;
 //}
 //
-//int add(int jobi, int jobv, int l, int r, int i) {
-//    if (i == 0) i = ++cntt;
-//    if (l == r) sum[i] += jobv;
-//    else {
-//        int mid = (l + r) / 2;
-//        if (jobi <= mid) ls[i] = add(jobi, jobv, l, mid, ls[i]);
-//        else rs[i] = add(jobi, jobv, mid + 1, r, rs[i]);
-//        sum[i] = sum[ls[i]] + sum[rs[i]];
-//    }
-//    return i;
-//}
-//
-//void add(int i, int kth, int val) {
-//    for (; i <= n; i += lowbit(i)) root[i] = add(kth, val, 1, s, root[i]);
-//}
-//
-//int queryNumber(int jobk, int l, int r) {
-//    if (l == r) return l;
-//    int mid = (l + r) / 2;
-//    int leftsum = 0;
-//    for (int i = 1; i <= cntpos; i++) leftsum += sum[ls[pos[i]]];
-//    for (int i = 1; i <= cntpre; i++) leftsum -= sum[ls[pre[i]]];
-//    if (jobk <= leftsum) {
-//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
-//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
-//        return queryNumber(jobk, l, mid);
-//    } else {
-//        for (int i = 1; i <= cntpos; i++) pos[i] = rs[pos[i]];
-//        for (int i = 1; i <= cntpre; i++) pre[i] = rs[pre[i]];
-//        return queryNumber(jobk - leftsum, mid + 1, r);
-//    }
-//}
-//
 //void dfs(int u, int fa) {
 //    deep[u] = deep[fa] + 1;
 //    size[u] = 1;
@@ -122,21 +89,44 @@
 //    return stjump[a][0];
 //}
 //
-//void prepare() {
-//    s = 0;
-//    for (int i = 1; i <= n; i++) sorted[++s] = arr[i];
-//    for (int i = 1; i <= m; i++) if (ques[i][0] == 0) sorted[++s] = ques[i][2];
-//    sort(sorted + 1, sorted + s + 1);
-//    s = unique(sorted + 1, sorted + s + 1) - sorted - 1;
-//    for (int i = 1; i <= n; i++) arr[i] = kth(arr[i]);
-//    dfs(1, 0);
-//    for (int i = 1; i <= n; i++) {
-//        add(dfn[i], arr[i], 1);
-//        add(dfn[i] + size[i], arr[i], -1);
+//int innerAdd(int jobi, int jobv, int l, int r, int i) {
+//    if (i == 0) i = ++cntt;
+//    if (l == r) {
+//        sum[i] += jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
+//        } else {
+//            rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
+//        }
+//        sum[i] = sum[ls[i]] + sum[rs[i]];
+//    }
+//    return i;
+//}
+//
+//int innerQuery(int jobk, int l, int r) {
+//    if (l == r) return l;
+//    int mid = (l + r) / 2;
+//    int leftsum = 0;
+//    for (int i = 1; i <= cntpos; i++) leftsum += sum[ls[pos[i]]];
+//    for (int i = 1; i <= cntpre; i++) leftsum -= sum[ls[pre[i]]];
+//    if (jobk <= leftsum) {
+//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
+//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
+//        return innerQuery(jobk, l, mid);
+//    } else {
+//        for (int i = 1; i <= cntpos; i++) pos[i] = rs[pos[i]];
+//        for (int i = 1; i <= cntpre; i++) pre[i] = rs[pre[i]];
+//        return innerQuery(jobk - leftsum, mid + 1, r);
 //    }
 //}
 //
-//void change(int i, int v) {
+//void add(int i, int kth, int val) {
+//    for (; i <= n; i += lowbit(i)) root[i] = innerAdd(kth, val, 1, s, root[i]);
+//}
+//
+//void update(int i, int v) {
 //    add(dfn[i], arr[i], -1);
 //    add(dfn[i] + size[i], arr[i], 1);
 //    arr[i] = kth(v);
@@ -154,7 +144,23 @@
 //    for (int i = dfn[y]; i; i -= lowbit(i)) pos[++cntpos] = root[i];
 //    for (int i = dfn[xylca]; i; i -= lowbit(i)) pre[++cntpre] = root[i];
 //    for (int i = dfn[lcafa]; i; i -= lowbit(i)) pre[++cntpre] = root[i];
-//    return queryNumber(num - k + 1, 1, s);
+//    return innerQuery(num - k + 1, 1, s);
+//}
+//
+//void prepare() {
+//    s = 0;
+//    for (int i = 1; i <= n; i++) sorted[++s] = arr[i];
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 0) sorted[++s] = ques[i][2];
+//    }
+//    sort(sorted + 1, sorted + s + 1);
+//    s = unique(sorted + 1, sorted + s + 1) - sorted - 1;
+//    for (int i = 1; i <= n; i++) arr[i] = kth(arr[i]);
+//    dfs(1, 0);
+//    for (int i = 1; i <= n; i++) {
+//        add(dfn[i], arr[i], 1);
+//        add(dfn[i] + size[i], arr[i], -1);
+//    }
 //}
 //
 //int main() {
@@ -171,7 +177,7 @@
 //    prepare();
 //    for (int i = 1; i <= m; i++) {
 //        if (ques[i][0] == 0) {
-//            change(ques[i][1], ques[i][2]);
+//        	update(ques[i][1], ques[i][2]);
 //        } else {
 //            int ans = query(ques[i][1], ques[i][2], ques[i][0]);
 //            if(ans == -1) {

From ceb76444240e666de86a0905d12d7fde35be22c5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Feb 2025 15:53:34 +0800
Subject: [PATCH 0441/1712] modify code

---
 src/class160/Code01_SegmentWithSegment1.java  |  8 ++++++++
 src/class160/Code01_SegmentWithSegment2.java  |  8 ++++++++
 src/class160/Code02_QueryKthMaximum1.java     |  8 +++++++-
 src/class160/Code02_QueryKthMaximum2.java     |  8 +++++++-
 src/class160/Code03_SegmentWithBalanced1.java | 19 ++++++++++++++-----
 src/class160/Code03_SegmentWithBalanced2.java |  9 +++++++++
 src/class160/Code04_IndexWithSegment1.java    |  9 +++++++++
 src/class160/Code04_IndexWithSegment2.java    |  9 +++++++++
 src/class160/Code05_LineUp1.java              |  7 +++++++
 src/class160/Code05_LineUp2.java              |  7 +++++++
 src/class160/Code06_NetworkManagement1.java   |  7 +++++++
 src/class160/Code06_NetworkManagement2.java   |  7 +++++++
 12 files changed, 99 insertions(+), 7 deletions(-)

diff --git a/src/class160/Code01_SegmentWithSegment1.java b/src/class160/Code01_SegmentWithSegment1.java
index a5ff8220f..5fe80ec65 100644
--- a/src/class160/Code01_SegmentWithSegment1.java
+++ b/src/class160/Code01_SegmentWithSegment1.java
@@ -1,6 +1,14 @@
 package class160;
 
 // 线段树套线段树，java版
+// 人有三种属性，身高、活泼度、缘分值
+// 身高为int类型，活泼度和缘分值为小数点后最多1位的double类型
+// 实现一种结构，提供如下两种类型的操作
+// 操作 I a b c   : 加入一个人，身高为a，活泼度为b，缘分值为c
+// 操作 Q a b c d : 查询身高范围[a,b]，活泼度范围[c,d]，所有人中的缘分最大值
+// 注意操作Q，如果a > b需要交换，如果c > d需要交换
+// 100 <= 身高 <= 200
+// 0.0 <= 活泼度、缘分值 <= 100.0
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=1823
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class160/Code01_SegmentWithSegment2.java b/src/class160/Code01_SegmentWithSegment2.java
index e0b19f8fa..160ae0774 100644
--- a/src/class160/Code01_SegmentWithSegment2.java
+++ b/src/class160/Code01_SegmentWithSegment2.java
@@ -1,6 +1,14 @@
 package class160;
 
 // 线段树套线段树，C++版
+// 人有三种属性，身高、活泼度、缘分值
+// 身高为int类型，活泼度和缘分值为小数点后最多1位的double类型
+// 实现一种结构，提供如下两种类型的操作
+// 操作 I a b c   : 加入一个人，身高为a，活泼度为b，缘分值为c
+// 操作 Q a b c d : 查询身高范围[a,b]，活泼度范围[c,d]，所有人中的缘分最大值
+// 注意操作Q，如果a > b需要交换，如果c > d需要交换
+// 100 <= 身高 <= 200
+// 0.0 <= 活泼度、缘分值 <= 100.0
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=1823
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index 688a487f5..3e54faee6 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -1,6 +1,12 @@
 package class160;
 
-// K大数查询，java版
+// k大数查询，java版
+// 初始时有n个空集合，编号1~n，实现如下两种类型的操作，操作一共发生m次
+// 操作 1 l r v : 数字v放入编号范围[l,r]的每一个集合中
+// 操作 2 l r k : 编号范围[l,r]的所有集合，如果生成不去重的并集，返回第k大的数字
+// 1 <= n、m <= 5 * 10^4
+// 1 <= v <= n
+// 1 <= k < 2^63，题目保证第k大的数字一定存在
 // 测试链接 : https://www.luogu.com.cn/problem/P3332
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index c4d45feac..12963cb0f 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -1,6 +1,12 @@
 package class160;
 
-// K大数查询，C++版
+// k大数查询，C++版
+// 初始时有n个空集合，编号1~n，实现如下两种类型的操作，操作一共发生m次
+// 操作 1 l r v : 数字v放入编号范围[l,r]的每一个集合中
+// 操作 2 l r k : 编号范围[l,r]的所有集合，如果生成不去重的并集，返回第k大的数字
+// 1 <= n、m <= 5 * 10^4
+// 1 <= v <= n
+// 1 <= k < 2^63，题目保证第k大的数字一定存在
 // 测试链接 : https://www.luogu.com.cn/problem/P3332
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index 608353819..21285c3f8 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -1,6 +1,15 @@
 package class160;
 
 // 线段树套平衡树，java版
+// 给定一个长度为n的数组arr，下标1~n
+// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 操作 1 x y z : 查询数字z在arr[x..y]中的排名
+// 操作 2 x y z : 查询arr[x..y]中排第z名的数字
+// 操作 3 x y   : arr中x位置的数字改成y
+// 操作 4 x y z : 查询数字z在arr[x..y]中的前驱，不存在返回-2147483647
+// 操作 5 x y z : 查询数字z在arr[x..y]中的后继，不存在返回+2147483647
+// 1 <= n、m <= 5 * 10^4
+// 数组中的值永远在[0, 10^8]范围内
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -240,14 +249,14 @@ public static int small(int jobl, int jobr, int jobv, int l, int r, int i) {
 	}
 
 	public static int number(int jobl, int jobr, int jobk) {
-		int L = 0, R = 100000000, mid, ans = 0;
-		while (L <= R) {
-			mid = (L + R) >> 1;
+		int l = 0, r = 100000000, mid, ans = 0;
+		while (l <= r) {
+			mid = (l + r) >> 1;
 			if (small(jobl, jobr, mid + 1, 1, n, 1) >= jobk) {
 				ans = mid;
-				R = mid - 1;
+				r = mid - 1;
 			} else {
-				L = mid + 1;
+				l = mid + 1;
 			}
 		}
 		return ans;
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 6d0a819c7..2a3b47b49 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -1,6 +1,15 @@
 package class160;
 
 // 线段树套平衡树，C++版
+// 给定一个长度为n的数组arr，下标1~n
+// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 操作 1 x y z : 查询数字z在arr[x..y]中的排名
+// 操作 2 x y z : 查询arr[x..y]中排第z名的数字
+// 操作 3 x y   : arr中x位置的数字改成y
+// 操作 4 x y z : 查询数字z在arr[x..y]中的前驱，不存在返回-2147483647
+// 操作 5 x y z : 查询数字z在arr[x..y]中的后继，不存在返回+2147483647
+// 1 <= n、m <= 5 * 10^4
+// 数组中的值永远在[0, 10^8]范围内
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class160/Code04_IndexWithSegment1.java b/src/class160/Code04_IndexWithSegment1.java
index c1301045f..af99c995f 100644
--- a/src/class160/Code04_IndexWithSegment1.java
+++ b/src/class160/Code04_IndexWithSegment1.java
@@ -1,6 +1,15 @@
 package class160;
 
 // 树状数组套线段树，java版
+// 给定一个长度为n的数组arr，下标1~n
+// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 操作 1 x y z : 查询数字z在arr[x..y]中的排名
+// 操作 2 x y z : 查询arr[x..y]中排第z名的数字
+// 操作 3 x y   : arr中x位置的数字改成y
+// 操作 4 x y z : 查询数字z在arr[x..y]中的前驱，不存在返回-2147483647
+// 操作 5 x y z : 查询数字z在arr[x..y]中的后继，不存在返回+2147483647
+// 1 <= n、m <= 5 * 10^4
+// 数组中的值永远在[0, 10^8]范围内
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class160/Code04_IndexWithSegment2.java b/src/class160/Code04_IndexWithSegment2.java
index 2e8447e69..69b6be34b 100644
--- a/src/class160/Code04_IndexWithSegment2.java
+++ b/src/class160/Code04_IndexWithSegment2.java
@@ -1,6 +1,15 @@
 package class160;
 
 // 树状数组套线段树，C++版
+// 给定一个长度为n的数组arr，下标1~n
+// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 操作 1 x y z : 查询数字z在arr[x..y]中的排名
+// 操作 2 x y z : 查询arr[x..y]中排第z名的数字
+// 操作 3 x y   : arr中x位置的数字改成y
+// 操作 4 x y z : 查询数字z在arr[x..y]中的前驱，不存在返回-2147483647
+// 操作 5 x y z : 查询数字z在arr[x..y]中的后继，不存在返回+2147483647
+// 1 <= n、m <= 5 * 10^4
+// 数组中的值永远在[0, 10^8]范围内
 // 测试链接 : https://www.luogu.com.cn/problem/P3380
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class160/Code05_LineUp1.java b/src/class160/Code05_LineUp1.java
index e44b8ea1c..72bc1d237 100644
--- a/src/class160/Code05_LineUp1.java
+++ b/src/class160/Code05_LineUp1.java
@@ -1,6 +1,13 @@
 package class160;
 
 // 排队，java版
+// 给定一个长度为n的数组arr，下标1~n
+// 如果有i < j，并且arr[i] > arr[j]，那么(i,j)就叫做一个逆序对
+// 首先打印原始arr中有多少逆序对，然后进行如下类型的操作，一共发生m次
+// 操作 a b : 交换arr中a位置的数和b位置的数，打印数组中逆序对的数量
+// 1 <= n <= 2 * 10^4
+// 1 <= m <= 2 * 10^3
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1975
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class160/Code05_LineUp2.java b/src/class160/Code05_LineUp2.java
index 96e22416e..e52766dab 100644
--- a/src/class160/Code05_LineUp2.java
+++ b/src/class160/Code05_LineUp2.java
@@ -1,6 +1,13 @@
 package class160;
 
 // 排队，C++版
+// 给定一个长度为n的数组arr，下标1~n
+// 如果有i < j，并且arr[i] > arr[j]，那么(i,j)就叫做一个逆序对
+// 首先打印原始arr中有多少逆序对，然后进行如下类型的操作，一共发生m次
+// 操作 a b : 交换arr中a位置的数和b位置的数，打印数组中逆序对的数量
+// 1 <= n <= 2 * 10^4
+// 1 <= m <= 2 * 10^3
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1975
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class160/Code06_NetworkManagement1.java b/src/class160/Code06_NetworkManagement1.java
index c4fcb17f2..83e721266 100644
--- a/src/class160/Code06_NetworkManagement1.java
+++ b/src/class160/Code06_NetworkManagement1.java
@@ -1,6 +1,13 @@
 package class160;
 
 // 网络管理，java版
+// 一共有n个点，编号1~n，每个点给定点权，给定n-1条边，所有点连成一棵树
+// 实现如下类型的操作，操作一共发生m次
+// 操作 0 x y : x号点的点权变成y
+// 操作 k x y : 保证k > 0，点x到点y的路径上，打印第k大的值
+//              如果路径上不够k个点，打印"invalid request!"
+// 1 <= n、m <= 8 * 10^4
+// 点权 <= 10^8
 // 测试链接 : https://www.luogu.com.cn/problem/P4175
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class160/Code06_NetworkManagement2.java b/src/class160/Code06_NetworkManagement2.java
index c2972d36a..7e2eb432a 100644
--- a/src/class160/Code06_NetworkManagement2.java
+++ b/src/class160/Code06_NetworkManagement2.java
@@ -1,6 +1,13 @@
 package class160;
 
 // 网络管理，C++版
+// 一共有n个点，编号1~n，每个点给定点权，给定n-1条边，所有点连成一棵树
+// 实现如下类型的操作，操作一共发生m次
+// 操作 0 x y : x号点的点权变成y
+// 操作 k x y : 保证k > 0，点x到点y的路径上，打印第k大的值
+//              如果路径上不够k个点，打印"invalid request!"
+// 1 <= n、m <= 8 * 10^4
+// 点权 <= 10^8
 // 测试链接 : https://www.luogu.com.cn/problem/P4175
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 60e3846add10a262e17a561833546716c2163ec4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Feb 2025 16:25:09 +0800
Subject: [PATCH 0442/1712] modify code

---
 src/class160/Code02_QueryKthMaximum1.java | 8 ++++----
 src/class160/Code02_QueryKthMaximum2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index 3e54faee6..807b3a535 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -40,7 +40,7 @@ public class Code02_QueryKthMaximum1 {
 
 	public static int[] lazy = new int[MAXT];
 
-	public static int cntt;
+	public static int cnt;
 
 	public static int kth(int num) {
 		int left = 1, right = s, mid;
@@ -64,10 +64,10 @@ public static void up(int i) {
 	public static void down(int i, int ln, int rn) {
 		if (lazy[i] != 0) {
 			if (left[i] == 0) {
-				left[i] = ++cntt;
+				left[i] = ++cnt;
 			}
 			if (right[i] == 0) {
-				right[i] = ++cntt;
+				right[i] = ++cnt;
 			}
 			sum[left[i]] += lazy[i] * ln;
 			lazy[left[i]] += lazy[i];
@@ -79,7 +79,7 @@ public static void down(int i, int ln, int rn) {
 
 	public static int innerAdd(int jobl, int jobr, int l, int r, int i) {
 		if (i == 0) {
-			i = ++cntt;
+			i = ++cnt;
 		}
 		if (jobl <= l && r <= jobr) {
 			sum[i] += r - l + 1;
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index 12963cb0f..78f55130a 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -26,7 +26,7 @@
 //int rs[MAXT];
 //long long sum[MAXT];
 //int lazy[MAXT];
-//int cntt;
+//int cnt;
 //
 //int kth(int num) {
 //    int l = 1, r = s;
@@ -49,8 +49,8 @@
 //
 //void down(int i, int ln, int rn) {
 //    if (lazy[i]) {
-//        if (!ls[i]) ls[i] = ++cntt;
-//        if (!rs[i]) rs[i] = ++cntt;
+//        if (!ls[i]) ls[i] = ++cnt;
+//        if (!rs[i]) rs[i] = ++cnt;
 //        sum[ls[i]] += 1LL * lazy[i] * ln;
 //        lazy[ls[i]] += lazy[i];
 //        sum[rs[i]] += 1LL * lazy[i] * rn;
@@ -60,7 +60,7 @@
 //}
 //
 //int innerAdd(int jobl, int jobr, int l, int r, int i) {
-//    if (!i) i = ++cntt;
+//    if (!i) i = ++cnt;
 //    if (jobl <= l && r <= jobr) {
 //        sum[i] += (long long)(r - l + 1);
 //        lazy[i]++;

From 07888734dfe4781b7d80d2b2ad80b3299325dafa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Feb 2025 14:34:07 +0800
Subject: [PATCH 0443/1712] modify code

---
 src/class160/Code01_SegmentWithSegment1.java | 28 ++++++------
 src/class160/Code01_SegmentWithSegment2.java | 45 +++++++++-----------
 2 files changed, 35 insertions(+), 38 deletions(-)

diff --git a/src/class160/Code01_SegmentWithSegment1.java b/src/class160/Code01_SegmentWithSegment1.java
index 5fe80ec65..8a8907837 100644
--- a/src/class160/Code01_SegmentWithSegment1.java
+++ b/src/class160/Code01_SegmentWithSegment1.java
@@ -23,13 +23,13 @@
 
 public class Code01_SegmentWithSegment1 {
 
-	public static int MAXH = 101;
+	public static int n = 101;
 
-	public static int MAXA = 1001;
+	public static int m = 1001;
 
-	public static int n = 1000, m;
+	public static int MINX = 100, MAXX = 200, MINY = 0, MAXY = 1000;
 
-	public static int[][] tree = new int[MAXH << 2][MAXA << 2];
+	public static int[][] tree = new int[n << 2][m << 2];
 
 	public static void innerBuild(int yl, int yr, int xi, int yi) {
 		tree[xi][yi] = -1;
@@ -71,7 +71,7 @@ public static int innerQuery(int jobyl, int jobyr, int yl, int yr, int xi, int y
 	}
 
 	public static void outerBuild(int xl, int xr, int xi) {
-		innerBuild(0, n, xi, 1);
+		innerBuild(MINY, MAXY, xi, 1);
 		if (xl < xr) {
 			int mid = (xl + xr) / 2;
 			outerBuild(xl, mid, xi << 1);
@@ -80,7 +80,7 @@ public static void outerBuild(int xl, int xr, int xi) {
 	}
 
 	public static void outerUpdate(int jobx, int joby, int jobv, int xl, int xr, int xi) {
-		innerUpdate(joby, jobv, 0, n, xi, 1);
+		innerUpdate(joby, jobv, MINY, MAXY, xi, 1);
 		if (xl < xr) {
 			int mid = (xl + xr) / 2;
 			if (jobx <= mid) {
@@ -93,7 +93,7 @@ public static void outerUpdate(int jobx, int joby, int jobv, int xl, int xr, int
 
 	public static int outerQuery(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
 		if (jobxl <= xl && xr <= jobxr) {
-			return innerQuery(jobyl, jobyr, 0, n, xi, 1);
+			return innerQuery(jobyl, jobyr, MINY, MAXY, xi, 1);
 		}
 		int mid = (xl + xr) / 2;
 		int ans = -1;
@@ -108,18 +108,18 @@ public static int outerQuery(int jobxl, int jobxr, int jobyl, int jobyr, int xl,
 
 	public static void main(String[] args) {
 		Kattio io = new Kattio();
-		m = io.nextInt();
+		int q = io.nextInt();
 		String op;
 		int a, b, c, d;
-		while (m != 0) {
-			outerBuild(100, 200, 1);
-			for (int i = 1; i <= m; i++) {
+		while (q != 0) {
+			outerBuild(MINX, MAXX, 1);
+			for (int i = 1; i <= q; i++) {
 				op = io.next();
 				if (op.equals("I")) {
 					a = io.nextInt();
 					b = (int) (io.nextDouble() * 10);
 					c = (int) (io.nextDouble() * 10);
-					outerUpdate(a, b, c, 100, 200, 1);
+					outerUpdate(a, b, c, MINX, MAXX, 1);
 				} else {
 					a = io.nextInt();
 					b = io.nextInt();
@@ -129,7 +129,7 @@ public static void main(String[] args) {
 					int xr = Math.max(a, b);
 					int yl = Math.min(c, d);
 					int yr = Math.max(c, d);
-					int ans = outerQuery(xl, xr, yl, yr, 100, 200, 1);
+					int ans = outerQuery(xl, xr, yl, yr, MINX, MAXX, 1);
 					if (ans == -1) {
 						io.println(ans);
 					} else {
@@ -137,7 +137,7 @@ public static void main(String[] args) {
 					}
 				}
 			}
-			m = io.nextInt();
+			q = io.nextInt();
 		}
 		io.flush();
 		io.close();
diff --git a/src/class160/Code01_SegmentWithSegment2.java b/src/class160/Code01_SegmentWithSegment2.java
index 160ae0774..44b127100 100644
--- a/src/class160/Code01_SegmentWithSegment2.java
+++ b/src/class160/Code01_SegmentWithSegment2.java
@@ -17,10 +17,10 @@
 //
 //using namespace std;
 //
-//const int MAXH = 101;
-//const int MAXA = 1001;
-//int n = 1000, m;
-//int tree[MAXH << 2][MAXA << 2];
+//const int n = 101;
+//const int m = 1001;
+//int MINX = 100, MAXX = 200, MINY = 0, MAXY = 1000;
+//int tree[n << 2][m << 2];
 //
 //void innerBuild(int yl, int yr, int xi, int yi) {
 //    tree[xi][yi] = -1;
@@ -61,7 +61,7 @@
 //}
 //
 //void outerBuild(int xl, int xr, int xi) {
-//	innerBuild(0, n, xi, 1);
+//	innerBuild(MINY, MAXY, xi, 1);
 //    if (xl < xr) {
 //        int mid = (xl + xr) >> 1;
 //        outerBuild(xl, mid, xi << 1);
@@ -70,7 +70,7 @@
 //}
 //
 //void outerUpdate(int jobx, int joby, int jobv, int xl, int xr, int xi) {
-//	innerUpdate(joby, jobv, 0, n, xi, 1);
+//	innerUpdate(joby, jobv, MINY, MAXY, xi, 1);
 //    if (xl < xr) {
 //        int mid = (xl + xr) >> 1;
 //        if (jobx <= mid) {
@@ -83,7 +83,7 @@
 //
 //int outerQuery(int jobxl, int jobxr, int jobyl, int jobyr, int xl, int xr, int xi) {
 //    if (jobxl <= xl && xr <= jobxr) {
-//        return innerQuery(jobyl, jobyr, 0, n, xi, 1);
+//        return innerQuery(jobyl, jobyr, MINY, MAXY, xi, 1);
 //    }
 //    int mid = (xl + xr) >> 1;
 //    int ans = -1;
@@ -97,30 +97,27 @@
 //}
 //
 //int main() {
-//	scanf("%d", &m);
-//	while(m != 0) {
-//		outerBuild(100, 200, 1);
-//        for (int i = 0; i < m; i++) {
+//	int q;
+//	scanf("%d", &q);
+//	while(q != 0) {
+//		outerBuild(MINX, MAXX, 1);
+//        for (int i = 0; i < q; i++) {
 //        	char op[2];
 //            scanf("%s", op);
 //            if (op[0] == 'I') {
 //                int a;
-//                double bd, cd;
-//                scanf("%d %lf %lf", &a, &bd, &cd);
-//                int b = (int)(bd * 10);
-//                int c = (int)(cd * 10);
-//                outerUpdate(a, b, c, 100, 200, 1);
+//                double b, c;
+//                scanf("%d %lf %lf", &a, &b, &c);
+//                outerUpdate(a, (int)(b * 10), (int)(c * 10), MINX, MAXX, 1);
 //            } else {
 //                int a, b;
-//                double cd, dd;
-//                scanf("%d %d %lf %lf", &a, &b, &cd, &dd);
-//                int c = (int)(cd * 10);
-//                int d = (int)(dd * 10);
+//                double c, d;
+//                scanf("%d %d %lf %lf", &a, &b, &c, &d);
 //                int xl = min(a, b);
 //                int xr = max(a, b);
-//                int yl = min(c, d);
-//                int yr = max(c, d);
-//                int ans = outerQuery(xl, xr, yl, yr, 100, 200, 1);
+//                int yl = min((int)(c * 10), (int)(d * 10));
+//                int yr = max((int)(c * 10), (int)(d * 10));
+//                int ans = outerQuery(xl, xr, yl, yr, MINX, MAXX, 1);
 //                if (ans == -1) {
 //                    printf("-1\n");
 //                } else {
@@ -128,7 +125,7 @@
 //                }
 //            }
 //        }
-//        scanf("%d", &m);
+//        scanf("%d", &q);
 //	}
 //    return 0;
 //}
\ No newline at end of file

From aff31650259b93d7d417e669c44aed928ee5e9fe Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Feb 2025 15:30:10 +0800
Subject: [PATCH 0444/1712] modify code

---
 src/class160/Code04_IndexWithSegment1.java  | 87 +++++++++---------
 src/class160/Code04_IndexWithSegment2.java  | 98 +++++++++++++--------
 src/class160/Code06_NetworkManagement1.java | 43 +++++----
 src/class160/Code06_NetworkManagement2.java | 60 +++++++++----
 4 files changed, 170 insertions(+), 118 deletions(-)

diff --git a/src/class160/Code04_IndexWithSegment1.java b/src/class160/Code04_IndexWithSegment1.java
index af99c995f..df2510093 100644
--- a/src/class160/Code04_IndexWithSegment1.java
+++ b/src/class160/Code04_IndexWithSegment1.java
@@ -37,7 +37,6 @@ public class Code04_IndexWithSegment1 {
 
 	public static int[] sorted = new int[MAXN * 2];
 
-	// 注意这不是主席树！而是若干棵动态开点权值线段树！
 	public static int[] root = new int[MAXN];
 
 	public static int[] sum = new int[MAXT];
@@ -48,13 +47,13 @@ public class Code04_IndexWithSegment1 {
 
 	public static int cntt = 0;
 
-	public static int[] pos = new int[MAXN];
+	public static int[] addTree = new int[MAXN];
 
-	public static int[] pre = new int[MAXN];
+	public static int[] minusTree = new int[MAXN];
 
-	public static int cntpos;
+	public static int cntadd;
 
-	public static int cntpre;
+	public static int cntminus;
 
 	public static int kth(int num) {
 		int left = 1, right = s, mid;
@@ -99,55 +98,55 @@ public static int innerQuery(int jobk, int l, int r) {
 		}
 		int mid = (l + r) / 2;
 		int leftsum = 0;
-		for (int i = 1; i <= cntpos; i++) {
-			leftsum += sum[left[pos[i]]];
+		for (int i = 1; i <= cntadd; i++) {
+			leftsum += sum[left[addTree[i]]];
 		}
-		for (int i = 1; i <= cntpre; i++) {
-			leftsum -= sum[left[pre[i]]];
+		for (int i = 1; i <= cntminus; i++) {
+			leftsum -= sum[left[minusTree[i]]];
 		}
 		if (jobk <= leftsum) {
-			for (int i = 1; i <= cntpos; i++) {
-				pos[i] = left[pos[i]];
+			for (int i = 1; i <= cntadd; i++) {
+				addTree[i] = left[addTree[i]];
 			}
-			for (int i = 1; i <= cntpre; i++) {
-				pre[i] = left[pre[i]];
+			for (int i = 1; i <= cntminus; i++) {
+				minusTree[i] = left[minusTree[i]];
 			}
 			return innerQuery(jobk, l, mid);
 		} else {
-			for (int i = 1; i <= cntpos; i++) {
-				pos[i] = right[pos[i]];
+			for (int i = 1; i <= cntadd; i++) {
+				addTree[i] = right[addTree[i]];
 			}
-			for (int i = 1; i <= cntpre; i++) {
-				pre[i] = right[pre[i]];
+			for (int i = 1; i <= cntminus; i++) {
+				minusTree[i] = right[minusTree[i]];
 			}
 			return innerQuery(jobk - leftsum, mid + 1, r);
 		}
 	}
 
-	public static int innerRank(int jobk, int l, int r) {
+	public static int innerSmall(int jobi, int l, int r) {
 		if (l == r) {
 			return 0;
 		}
 		int mid = (l + r) / 2;
-		if (jobk <= mid) {
-			for (int i = 1; i <= cntpos; i++) {
-				pos[i] = left[pos[i]];
+		if (jobi <= mid) {
+			for (int i = 1; i <= cntadd; i++) {
+				addTree[i] = left[addTree[i]];
 			}
-			for (int i = 1; i <= cntpre; i++) {
-				pre[i] = left[pre[i]];
+			for (int i = 1; i <= cntminus; i++) {
+				minusTree[i] = left[minusTree[i]];
 			}
-			return innerRank(jobk, l, mid);
+			return innerSmall(jobi, l, mid);
 		} else {
 			int leftsum = 0;
-			for (int i = 1; i <= cntpos; i++) {
-				leftsum += sum[left[pos[i]]];
-				pos[i] = right[pos[i]];
+			for (int i = 1; i <= cntadd; i++) {
+				leftsum += sum[left[addTree[i]]];
+				addTree[i] = right[addTree[i]];
 			}
-			for (int i = 1; i <= cntpre; i++) {
-				leftsum -= sum[left[pre[i]]];
-				pre[i] = right[pre[i]];
+			for (int i = 1; i <= cntminus; i++) {
+				leftsum -= sum[left[minusTree[i]]];
+				minusTree[i] = right[minusTree[i]];
 			}
-			return leftsum + innerRank(jobk, mid + 1, r);
+			return leftsum + innerSmall(jobi, mid + 1, r);
 		}
 	}
 
@@ -158,40 +157,40 @@ public static void outerAdd(int i, int v) {
 	}
 
 	public static int outerQuery(int l, int r, int k) {
-		cntpos = cntpre = 0;
+		cntadd = cntminus = 0;
 		for (int i = r; i > 0; i -= lowbit(i)) {
-			pos[++cntpos] = root[i];
+			addTree[++cntadd] = root[i];
 		}
 		for (int i = l - 1; i > 0; i -= lowbit(i)) {
-			pre[++cntpre] = root[i];
+			minusTree[++cntminus] = root[i];
 		}
 		return sorted[innerQuery(k, 1, s)];
 	}
 
-	public static int outerRank(int l, int r, int k) {
-		cntpos = cntpre = 0;
+	public static int outerRank(int l, int r, int v) {
+		cntadd = cntminus = 0;
 		for (int i = r; i > 0; i -= lowbit(i)) {
-			pos[++cntpos] = root[i];
+			addTree[++cntadd] = root[i];
 		}
 		for (int i = l - 1; i > 0; i -= lowbit(i)) {
-			pre[++cntpre] = root[i];
+			minusTree[++cntminus] = root[i];
 		}
-		return innerRank(k, 1, s) + 1;
+		return innerSmall(v, 1, s) + 1;
 	}
 
-	public static int outerPre(int l, int r, int k) {
-		int rank = outerRank(l, r, k);
+	public static int outerPre(int l, int r, int v) {
+		int rank = outerRank(l, r, v);
 		if (rank == 1) {
 			return -INF;
 		}
 		return outerQuery(l, r, rank - 1);
 	}
 
-	public static int outerPost(int l, int r, int k) {
-		if (k == s) {
+	public static int outerPost(int l, int r, int v) {
+		if (v == s) {
 			return INF;
 		}
-		int rank = outerRank(l, r, k + 1);
+		int rank = outerRank(l, r, v + 1);
 		if (rank == r - l + 2) {
 			return INF;
 		}
diff --git a/src/class160/Code04_IndexWithSegment2.java b/src/class160/Code04_IndexWithSegment2.java
index 69b6be34b..aeac1b7d5 100644
--- a/src/class160/Code04_IndexWithSegment2.java
+++ b/src/class160/Code04_IndexWithSegment2.java
@@ -32,9 +32,10 @@
 //int rs[MAXT];
 //int cntt;
 //
-//int pos[MAXN];
-//int pre[MAXN];
-//int cntpos, cntpre;
+//int addTree[MAXN];
+//int minusTree[MAXN];
+//int cntadd;
+//int cntminus;
 //
 //int kth(int num) {
 //    int l = 1, r = s;
@@ -57,8 +58,11 @@
 //        sum[i] += jobv;
 //    } else {
 //        int mid = (l + r) >> 1;
-//        if (jobi <= mid) ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
-//        else rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
+//        if (jobi <= mid) {
+//            ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
+//        } else {
+//            rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
+//        }
 //        sum[i] = sum[ls[i]] + sum[rs[i]];
 //    }
 //    return i;
@@ -68,37 +72,53 @@
 //    if (l == r) return l;
 //    int mid = (l + r) >> 1;
 //    int leftsum = 0;
-//    for (int i = 1; i <= cntpos; i++) leftsum += sum[ls[pos[i]]];
-//    for (int i = 1; i <= cntpre; i++) leftsum -= sum[ls[pre[i]]];
+//    for (int i = 1; i <= cntadd; i++) {
+//        leftsum += sum[ls[addTree[i]]];
+//    }
+//    for (int i = 1; i <= cntminus; i++) {
+//        leftsum -= sum[ls[minusTree[i]]];
+//    }
 //    if (jobk <= leftsum) {
-//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
-//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
+//        for (int i = 1; i <= cntadd; i++) {
+//            addTree[i] = ls[addTree[i]];
+//        }
+//        for (int i = 1; i <= cntminus; i++) {
+//            minusTree[i] = ls[minusTree[i]];
+//        }
 //        return innerQuery(jobk, l, mid);
 //    } else {
-//        for (int i = 1; i <= cntpos; i++) pos[i] = rs[pos[i]];
-//        for (int i = 1; i <= cntpre; i++) pre[i] = rs[pre[i]];
+//        for (int i = 1; i <= cntadd; i++) {
+//            addTree[i] = rs[addTree[i]];
+//        }
+//        for (int i = 1; i <= cntminus; i++) {
+//            minusTree[i] = rs[minusTree[i]];
+//        }
 //        return innerQuery(jobk - leftsum, mid + 1, r);
 //    }
 //}
 //
-//int innerRank(int jobi, int l, int r) {
+//int innerSmall(int jobi, int l, int r) {
 //    if (l == r) return 0;
 //    int mid = (l + r) >> 1;
 //    if (jobi <= mid) {
-//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
-//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
-//        return innerRank(jobi, l, mid);
+//        for (int i = 1; i <= cntadd; i++) {
+//            addTree[i] = ls[addTree[i]];
+//        }
+//        for (int i = 1; i <= cntminus; i++) {
+//            minusTree[i] = ls[minusTree[i]];
+//        }
+//        return innerSmall(jobi, l, mid);
 //    } else {
 //        int leftsum = 0;
-//        for (int i = 1; i <= cntpos; i++) {
-//            leftsum += sum[ls[pos[i]]];
-//            pos[i] = rs[pos[i]];
+//        for (int i = 1; i <= cntadd; i++) {
+//            leftsum += sum[ls[addTree[i]]];
+//            addTree[i] = rs[addTree[i]];
 //        }
-//        for (int i = 1; i <= cntpre; i++) {
-//            leftsum -= sum[ls[pre[i]]];
-//            pre[i] = rs[pre[i]];
+//        for (int i = 1; i <= cntminus; i++) {
+//            leftsum -= sum[ls[minusTree[i]]];
+//            minusTree[i] = rs[minusTree[i]];
 //        }
-//        return leftsum + innerRank(jobi, mid + 1, r);
+//        return leftsum + innerSmall(jobi, mid + 1, r);
 //    }
 //}
 //
@@ -109,27 +129,35 @@
 //}
 //
 //int outerQuery(int l, int r, int k) {
-//    cntpos = cntpre = 0;
-//    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
-//    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
+//    cntadd = cntminus = 0;
+//    for (int i = r; i > 0; i -= lowbit(i)) {
+//        addTree[++cntadd] = root[i];
+//    }
+//    for (int i = l - 1; i > 0; i -= lowbit(i)) {
+//        minusTree[++cntminus] = root[i];
+//    }
 //    return sorted[innerQuery(k, 1, s)];
 //}
 //
-//int outerRank(int l, int r, int k) {
-//    cntpos = cntpre = 0;
-//    for (int i = r; i > 0; i -= lowbit(i)) pos[++cntpos] = root[i];
-//    for (int i = l - 1; i > 0; i -= lowbit(i)) pre[++cntpre] = root[i];
-//    return innerRank(k, 1, s) + 1;
+//int outerRank(int l, int r, int v) {
+//    cntadd = cntminus = 0;
+//    for (int i = r; i > 0; i -= lowbit(i)) {
+//        addTree[++cntadd] = root[i];
+//    }
+//    for (int i = l - 1; i > 0; i -= lowbit(i)) {
+//        minusTree[++cntminus] = root[i];
+//    }
+//    return innerSmall(v, 1, s) + 1;
 //}
 //
-//int outerPre(int l, int r, int k) {
-//    int rk = outerRank(l, r, k);
+//int outerPre(int l, int r, int v) {
+//    int rk = outerRank(l, r, v);
 //    return (rk == 1) ? -INF : outerQuery(l, r, rk - 1);
 //}
 //
-//int outerPost(int l, int r, int k) {
-//    if (k == s) return INF;
-//    int rk = outerRank(l, r, k + 1);
+//int outerPost(int l, int r, int v) {
+//    if (v == s) return INF;
+//    int rk = outerRank(l, r, v + 1);
 //    return (rk == r - l + 2) ? INF : outerQuery(l, r, rk);
 //}
 //
diff --git a/src/class160/Code06_NetworkManagement1.java b/src/class160/Code06_NetworkManagement1.java
index 83e721266..2c609701f 100644
--- a/src/class160/Code06_NetworkManagement1.java
+++ b/src/class160/Code06_NetworkManagement1.java
@@ -66,14 +66,13 @@ public class Code06_NetworkManagement1 {
 
 	public static int cntd = 0;
 
-	// 查询信息需要，所有pos版本的信息和 - 所有pre版本的信息和
-	public static int[] pos = new int[MAXN];
+	public static int[] addTree = new int[MAXN];
 
-	public static int[] pre = new int[MAXN];
+	public static int[] minusTree = new int[MAXN];
 
-	public static int cntpos;
+	public static int cntadd;
 
-	public static int cntpre;
+	public static int cntminus;
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
@@ -221,26 +220,26 @@ public static int innerQuery(int jobk, int l, int r) {
 		}
 		int mid = (l + r) / 2;
 		int leftsum = 0;
-		for (int i = 1; i <= cntpos; i++) {
-			leftsum += sum[left[pos[i]]];
+		for (int i = 1; i <= cntadd; i++) {
+			leftsum += sum[left[addTree[i]]];
 		}
-		for (int i = 1; i <= cntpre; i++) {
-			leftsum -= sum[left[pre[i]]];
+		for (int i = 1; i <= cntminus; i++) {
+			leftsum -= sum[left[minusTree[i]]];
 		}
 		if (jobk <= leftsum) {
-			for (int i = 1; i <= cntpos; i++) {
-				pos[i] = left[pos[i]];
+			for (int i = 1; i <= cntadd; i++) {
+				addTree[i] = left[addTree[i]];
 			}
-			for (int i = 1; i <= cntpre; i++) {
-				pre[i] = left[pre[i]];
+			for (int i = 1; i <= cntminus; i++) {
+				minusTree[i] = left[minusTree[i]];
 			}
 			return innerQuery(jobk, l, mid);
 		} else {
-			for (int i = 1; i <= cntpos; i++) {
-				pos[i] = right[pos[i]];
+			for (int i = 1; i <= cntadd; i++) {
+				addTree[i] = right[addTree[i]];
 			}
-			for (int i = 1; i <= cntpre; i++) {
-				pre[i] = right[pre[i]];
+			for (int i = 1; i <= cntminus; i++) {
+				minusTree[i] = right[minusTree[i]];
 			}
 			return innerQuery(jobk - leftsum, mid + 1, r);
 		}
@@ -267,18 +266,18 @@ public static int query(int x, int y, int k) {
 		if (num < k) {
 			return -1;
 		}
-		cntpos = cntpre = 0;
+		cntadd = cntminus = 0;
 		for (int i = dfn[x]; i > 0; i -= lowbit(i)) {
-			pos[++cntpos] = root[i];
+			addTree[++cntadd] = root[i];
 		}
 		for (int i = dfn[y]; i > 0; i -= lowbit(i)) {
-			pos[++cntpos] = root[i];
+			addTree[++cntadd] = root[i];
 		}
 		for (int i = dfn[lca]; i > 0; i -= lowbit(i)) {
-			pre[++cntpre] = root[i];
+			minusTree[++cntminus] = root[i];
 		}
 		for (int i = dfn[lcafa]; i > 0; i -= lowbit(i)) {
-			pre[++cntpre] = root[i];
+			minusTree[++cntminus] = root[i];
 		}
 		return innerQuery(num - k + 1, 1, s);
 	}
diff --git a/src/class160/Code06_NetworkManagement2.java b/src/class160/Code06_NetworkManagement2.java
index 7e2eb432a..16328a234 100644
--- a/src/class160/Code06_NetworkManagement2.java
+++ b/src/class160/Code06_NetworkManagement2.java
@@ -42,9 +42,9 @@
 //int stjump[MAXN][MAXH];
 //int cntd;
 //
-//int pos[MAXN];
-//int pre[MAXN];
-//int cntpos, cntpre;
+//int addTree[MAXN];
+//int minusTree[MAXN];
+//int cntadd, cntminus;
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
@@ -72,7 +72,9 @@
 //    size[u] = 1;
 //    dfn[u] = ++cntd;
 //    stjump[u][0] = fa;
-//    for (int p = 1; p < MAXH; p++) stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        if (to[e] != fa) dfs(to[e], u);
 //    }
@@ -84,7 +86,9 @@
 //int lca(int a, int b) {
 //    if (deep[a] < deep[b]) swap(a, b);
 //    for (int p = MAXH - 1; p >= 0; p--) {
-//        if (deep[stjump[a][p]] >= deep[b]) a = stjump[a][p];
+//        if (deep[stjump[a][p]] >= deep[b]) {
+//            a = stjump[a][p];
+//        }
 //    }
 //    if (a == b) return a;
 //    for (int p = MAXH - 1; p >= 0; p--) {
@@ -116,21 +120,35 @@
 //    if (l == r) return l;
 //    int mid = (l + r) / 2;
 //    int leftsum = 0;
-//    for (int i = 1; i <= cntpos; i++) leftsum += sum[ls[pos[i]]];
-//    for (int i = 1; i <= cntpre; i++) leftsum -= sum[ls[pre[i]]];
+//    for (int i = 1; i <= cntadd; i++) {
+//        leftsum += sum[ls[addTree[i]]];
+//    }
+//    for (int i = 1; i <= cntminus; i++) {
+//        leftsum -= sum[ls[minusTree[i]]];
+//    }
 //    if (jobk <= leftsum) {
-//        for (int i = 1; i <= cntpos; i++) pos[i] = ls[pos[i]];
-//        for (int i = 1; i <= cntpre; i++) pre[i] = ls[pre[i]];
+//        for (int i = 1; i <= cntadd; i++) {
+//            addTree[i] = ls[addTree[i]];
+//        }
+//        for (int i = 1; i <= cntminus; i++) {
+//            minusTree[i] = ls[minusTree[i]];
+//        }
 //        return innerQuery(jobk, l, mid);
 //    } else {
-//        for (int i = 1; i <= cntpos; i++) pos[i] = rs[pos[i]];
-//        for (int i = 1; i <= cntpre; i++) pre[i] = rs[pre[i]];
+//        for (int i = 1; i <= cntadd; i++) {
+//            addTree[i] = rs[addTree[i]];
+//        }
+//        for (int i = 1; i <= cntminus; i++) {
+//            minusTree[i] = rs[minusTree[i]];
+//        }
 //        return innerQuery(jobk - leftsum, mid + 1, r);
 //    }
 //}
 //
 //void add(int i, int kth, int val) {
-//    for (; i <= n; i += lowbit(i)) root[i] = innerAdd(kth, val, 1, s, root[i]);
+//    for (; i <= n; i += lowbit(i)) {
+//        root[i] = innerAdd(kth, val, 1, s, root[i]);
+//    }
 //}
 //
 //void update(int i, int v) {
@@ -146,11 +164,19 @@
 //    int lcafa = stjump[xylca][0];
 //    int num = deep[x] + deep[y] - deep[xylca] - deep[lcafa];
 //    if (num < k) return -1;
-//    cntpos = cntpre = 0;
-//    for (int i = dfn[x]; i; i -= lowbit(i)) pos[++cntpos] = root[i];
-//    for (int i = dfn[y]; i; i -= lowbit(i)) pos[++cntpos] = root[i];
-//    for (int i = dfn[xylca]; i; i -= lowbit(i)) pre[++cntpre] = root[i];
-//    for (int i = dfn[lcafa]; i; i -= lowbit(i)) pre[++cntpre] = root[i];
+//    cntadd = cntminus = 0;
+//    for (int i = dfn[x]; i; i -= lowbit(i)) {
+//        addTree[++cntadd] = root[i];
+//    }
+//    for (int i = dfn[y]; i; i -= lowbit(i)) {
+//        addTree[++cntadd] = root[i];
+//    }
+//    for (int i = dfn[xylca]; i; i -= lowbit(i)) {
+//        minusTree[++cntminus] = root[i];
+//    }
+//    for (int i = dfn[lcafa]; i; i -= lowbit(i)) {
+//        minusTree[++cntminus] = root[i];
+//    }
 //    return innerQuery(num - k + 1, 1, s);
 //}
 //

From e907f5f711fe64a1a2a3a7c1c34f80ecedc40338 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Feb 2025 16:12:59 +0800
Subject: [PATCH 0445/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced2.java |  20 +--
 src/class160/Code04_IndexWithSegment1.java    |  60 +++++---
 src/class160/Code04_IndexWithSegment2.java    | 145 +++++++++++-------
 src/class160/Code06_NetworkManagement1.java   |  15 +-
 src/class160/Code06_NetworkManagement2.java   |  15 +-
 5 files changed, 156 insertions(+), 99 deletions(-)

diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 2a3b47b49..62c8a2b48 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -229,19 +229,19 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m;
-//    for(int i=1;i<=n;i++) cin >> arr[i];
-//    build(1,n,1);
-//    for(int i=1,op,x,y,z;i<=m;i++){
+//    for(int i = 1; i <= n; i++) cin >> arr[i];
+//    build(1, n, 1);
+//    for(int i = 1, op, x, y, z; i <= m; i++) {
 //        cin >> op >> x >> y;
-//        if(op==3){
-//            update(x,y,1,n,1);
-//            arr[x]=y;
+//        if(op == 3) {
+//            update(x, y, 1, n, 1);
+//            arr[x] = y;
 //        } else {
 //            cin >> z;
-//            if(op==1) cout << small(x,y,z,1,n,1)+1 << "\n";
-//            else if(op==2) cout << number(x,y,z) << "\n";
-//            else if(op==4) cout << pre(x,y,z,1,n,1) << "\n";
-//            else cout << post(x,y,z,1,n,1) << "\n";
+//            if(op == 1) cout << small(x, y, z, 1, n, 1) + 1 << "\n";
+//            else if(op == 2) cout << number(x, y, z) << "\n";
+//            else if(op == 4) cout << pre(x, y, z, 1, n, 1) << "\n";
+//            else cout << post(x, y, z, 1, n, 1) << "\n";
 //        }
 //    }
 //    return 0;
diff --git a/src/class160/Code04_IndexWithSegment1.java b/src/class160/Code04_IndexWithSegment1.java
index df2510093..5572dd2a8 100644
--- a/src/class160/Code04_IndexWithSegment1.java
+++ b/src/class160/Code04_IndexWithSegment1.java
@@ -150,13 +150,19 @@ public static int innerSmall(int jobi, int l, int r) {
 		}
 	}
 
-	public static void outerAdd(int i, int v) {
+	public static void add(int i, int cnt) {
 		for (int j = i; j <= n; j += lowbit(j)) {
-			root[j] = innerAdd(arr[i], v, 1, s, root[j]);
+			root[j] = innerAdd(arr[i], cnt, 1, s, root[j]);
 		}
 	}
 
-	public static int outerQuery(int l, int r, int k) {
+	public static void update(int i, int v) {
+		add(i, -1);
+		arr[i] = kth(v);
+		add(i, 1);
+	}
+
+	public static int small(int l, int r, int v) {
 		cntadd = cntminus = 0;
 		for (int i = r; i > 0; i -= lowbit(i)) {
 			addTree[++cntadd] = root[i];
@@ -164,10 +170,10 @@ public static int outerQuery(int l, int r, int k) {
 		for (int i = l - 1; i > 0; i -= lowbit(i)) {
 			minusTree[++cntminus] = root[i];
 		}
-		return sorted[innerQuery(k, 1, s)];
+		return innerSmall(v, 1, s);
 	}
 
-	public static int outerRank(int l, int r, int v) {
+	public static int number(int l, int r, int k) {
 		cntadd = cntminus = 0;
 		for (int i = r; i > 0; i -= lowbit(i)) {
 			addTree[++cntadd] = root[i];
@@ -175,26 +181,26 @@ public static int outerRank(int l, int r, int v) {
 		for (int i = l - 1; i > 0; i -= lowbit(i)) {
 			minusTree[++cntminus] = root[i];
 		}
-		return innerSmall(v, 1, s) + 1;
+		return sorted[innerQuery(k, 1, s)];
 	}
 
-	public static int outerPre(int l, int r, int v) {
-		int rank = outerRank(l, r, v);
+	public static int pre(int l, int r, int v) {
+		int rank = small(l, r, v) + 1;
 		if (rank == 1) {
 			return -INF;
 		}
-		return outerQuery(l, r, rank - 1);
+		return number(l, r, rank - 1);
 	}
 
-	public static int outerPost(int l, int r, int v) {
+	public static int post(int l, int r, int v) {
 		if (v == s) {
 			return INF;
 		}
-		int rank = outerRank(l, r, v + 1);
+		int rank = small(l, r, v + 1) + 1;
 		if (rank == r - l + 2) {
 			return INF;
 		}
-		return outerQuery(l, r, rank);
+		return number(l, r, rank);
 	}
 
 	public static void prepare() {
@@ -219,7 +225,7 @@ public static void prepare() {
 		s = len;
 		for (int i = 1; i <= n; i++) {
 			arr[i] = kth(arr[i]);
-			outerAdd(i, 1);
+			add(i, 1);
 		}
 	}
 
@@ -248,19 +254,23 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		prepare();
-		for (int i = 1; i <= m; i++) {
-			if (ques[i][0] == 1) {
-				out.println(outerRank(ques[i][1], ques[i][2], kth(ques[i][3])));
-			} else if (ques[i][0] == 2) {
-				out.println(outerQuery(ques[i][1], ques[i][2], ques[i][3]));
-			} else if (ques[i][0] == 3) {
-				outerAdd(ques[i][1], -1);
-				arr[ques[i][1]] = kth(ques[i][2]);
-				outerAdd(ques[i][1], 1);
-			} else if (ques[i][0] == 4) {
-				out.println(outerPre(ques[i][1], ques[i][2], kth(ques[i][3])));
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			op = ques[i][0];
+			x = ques[i][1];
+			y = ques[i][2];
+			if (op == 3) {
+				update(x, y);
 			} else {
-				out.println(outerPost(ques[i][1], ques[i][2], kth(ques[i][3])));
+				z = ques[i][3];
+				if (op == 1) {
+					out.println(small(x, y, kth(z)) + 1);
+				} else if (op == 2) {
+					out.println(number(x, y, z));
+				} else if (op == 4) {
+					out.println(pre(x, y, kth(z)));
+				} else {
+					out.println(post(x, y, kth(z)));
+				}
 			}
 		}
 		out.flush();
diff --git a/src/class160/Code04_IndexWithSegment2.java b/src/class160/Code04_IndexWithSegment2.java
index aeac1b7d5..9693aad80 100644
--- a/src/class160/Code04_IndexWithSegment2.java
+++ b/src/class160/Code04_IndexWithSegment2.java
@@ -25,25 +25,27 @@
 //int arr[MAXN];
 //int ques[MAXN][4];
 //int sorted[MAXN * 2];
-//
 //int root[MAXN];
 //int sum[MAXT];
 //int ls[MAXT];
 //int rs[MAXT];
-//int cntt;
-//
+//int cntt = 0;
 //int addTree[MAXN];
 //int minusTree[MAXN];
 //int cntadd;
 //int cntminus;
 //
 //int kth(int num) {
-//    int l = 1, r = s;
-//    while (l <= r) {
-//        int mid = (l + r) >> 1;
-//        if (sorted[mid] == num) return mid;
-//        if (sorted[mid] < num) l = mid + 1;
-//        else r = mid - 1;
+//    int left = 1, right = s, mid;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
 //    }
 //    return -1;
 //}
@@ -53,15 +55,17 @@
 //}
 //
 //int innerAdd(int jobi, int jobv, int l, int r, int i) {
-//    if (!i) i = ++cntt;
+//    if (i == 0) {
+//        i = ++cntt;
+//    }
 //    if (l == r) {
 //        sum[i] += jobv;
 //    } else {
-//        int mid = (l + r) >> 1;
+//        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
-//            ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
+//        	ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
 //        } else {
-//            rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
+//        	rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
 //        }
 //        sum[i] = sum[ls[i]] + sum[rs[i]];
 //    }
@@ -69,8 +73,10 @@
 //}
 //
 //int innerQuery(int jobk, int l, int r) {
-//    if (l == r) return l;
-//    int mid = (l + r) >> 1;
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) / 2;
 //    int leftsum = 0;
 //    for (int i = 1; i <= cntadd; i++) {
 //        leftsum += sum[ls[addTree[i]]];
@@ -98,8 +104,10 @@
 //}
 //
 //int innerSmall(int jobi, int l, int r) {
-//    if (l == r) return 0;
-//    int mid = (l + r) >> 1;
+//    if (l == r) {
+//        return 0;
+//    }
+//    int mid = (l + r) / 2;
 //    if (jobi <= mid) {
 //        for (int i = 1; i <= cntadd; i++) {
 //            addTree[i] = ls[addTree[i]];
@@ -122,13 +130,19 @@
 //    }
 //}
 //
-//void outerAdd(int i, int v) {
+//void add(int i, int cnt) {
 //    for (int j = i; j <= n; j += lowbit(j)) {
-//        root[j] = innerAdd(arr[i], v, 1, s, root[j]);
+//        root[j] = innerAdd(arr[i], cnt, 1, s, root[j]);
 //    }
 //}
 //
-//int outerQuery(int l, int r, int k) {
+//void update(int i, int v) {
+//    add(i, -1);
+//    arr[i] = kth(v);
+//    add(i, 1);
+//}
+//
+//int small(int l, int r, int v) {
 //    cntadd = cntminus = 0;
 //    for (int i = r; i > 0; i -= lowbit(i)) {
 //        addTree[++cntadd] = root[i];
@@ -136,10 +150,10 @@
 //    for (int i = l - 1; i > 0; i -= lowbit(i)) {
 //        minusTree[++cntminus] = root[i];
 //    }
-//    return sorted[innerQuery(k, 1, s)];
+//    return innerSmall(v, 1, s);
 //}
 //
-//int outerRank(int l, int r, int v) {
+//int number(int l, int r, int k) {
 //    cntadd = cntminus = 0;
 //    for (int i = r; i > 0; i -= lowbit(i)) {
 //        addTree[++cntadd] = root[i];
@@ -147,61 +161,88 @@
 //    for (int i = l - 1; i > 0; i -= lowbit(i)) {
 //        minusTree[++cntminus] = root[i];
 //    }
-//    return innerSmall(v, 1, s) + 1;
+//    return sorted[innerQuery(k, 1, s)];
 //}
 //
-//int outerPre(int l, int r, int v) {
-//    int rk = outerRank(l, r, v);
-//    return (rk == 1) ? -INF : outerQuery(l, r, rk - 1);
+//int pre(int l, int r, int v) {
+//    int rank = small(l, r, v) + 1;
+//    if (rank == 1) {
+//        return -INF;
+//    }
+//    return number(l, r, rank - 1);
 //}
 //
-//int outerPost(int l, int r, int v) {
-//    if (v == s) return INF;
-//    int rk = outerRank(l, r, v + 1);
-//    return (rk == r - l + 2) ? INF : outerQuery(l, r, rk);
+//int post(int l, int r, int v) {
+//    if (v == s) {
+//        return INF;
+//    }
+//    int rank = small(l, r, v + 1) + 1;
+//    if (rank == r - l + 2) {
+//        return INF;
+//    }
+//    return number(l, r, rank);
 //}
 //
 //void prepare() {
 //    s = 0;
-//    for (int i = 1; i <= n; i++) sorted[++s] = arr[i];
+//    for (int i = 1; i <= n; i++) {
+//        sorted[++s] = arr[i];
+//    }
 //    for (int i = 1; i <= m; i++) {
-//        if (ques[i][0] == 3) sorted[++s] = ques[i][2];
-//        else if (ques[i][0] != 2) sorted[++s] = ques[i][3];
+//        if (ques[i][0] == 3) {
+//            sorted[++s] = ques[i][2];
+//        } else if (ques[i][0] != 2) {
+//            sorted[++s] = ques[i][3];
+//        }
 //    }
 //    sort(sorted + 1, sorted + s + 1);
 //    int len = 1;
-//    for (int i = 2; i <= s; i++)
-//        if (sorted[len] != sorted[i]) sorted[++len] = sorted[i];
+//    for (int i = 2; i <= s; i++) {
+//        if (sorted[len] != sorted[i]) {
+//            sorted[++len] = sorted[i];
+//        }
+//    }
 //    s = len;
 //    for (int i = 1; i <= n; i++) {
 //        arr[i] = kth(arr[i]);
-//        outerAdd(i, 1);
+//        add(i, 1);
 //    }
 //}
 //
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> m;
-//    for (int i = 1; i <= n; i++) cin >> arr[i];
+//    cin >> n;
+//    cin >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> ques[i][0] >> ques[i][1] >> ques[i][2];
-//        if (ques[i][0] != 3) cin >> ques[i][3];
+//        cin >> ques[i][0];
+//        cin >> ques[i][1];
+//        cin >> ques[i][2];
+//        if (ques[i][0] != 3) {
+//            cin >> ques[i][3];
+//        }
 //    }
 //    prepare();
-//    for (int i = 1; i <= m; i++) {
-//        if (ques[i][0] == 1) {
-//            cout << outerRank(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
-//        } else if (ques[i][0] == 2) {
-//            cout << outerQuery(ques[i][1], ques[i][2], ques[i][3]) << "\n";
-//        } else if (ques[i][0] == 3) {
-//            outerAdd(ques[i][1], -1);
-//            arr[ques[i][1]] = kth(ques[i][2]);
-//            outerAdd(ques[i][1], 1);
-//        } else if (ques[i][0] == 4) {
-//            cout << outerPre(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
+//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//        op = ques[i][0];
+//        x = ques[i][1];
+//        y = ques[i][2];
+//        if (op == 3) {
+//            update(x, y);
 //        } else {
-//            cout << outerPost(ques[i][1], ques[i][2], kth(ques[i][3])) << "\n";
+//            z = ques[i][3];
+//            if (op == 1) {
+//                cout << small(x, y, kth(z)) + 1 << "\n";
+//            } else if (op == 2) {
+//                cout << number(x, y, z) << "\n";
+//            } else if (op == 4) {
+//                cout << pre(x, y, kth(z)) << "\n";
+//            } else {
+//                cout << post(x, y, kth(z)) << "\n";
+//            }
 //        }
 //    }
 //    return 0;
diff --git a/src/class160/Code06_NetworkManagement1.java b/src/class160/Code06_NetworkManagement1.java
index 2c609701f..fd7d769f6 100644
--- a/src/class160/Code06_NetworkManagement1.java
+++ b/src/class160/Code06_NetworkManagement1.java
@@ -339,15 +339,18 @@ public static void main(String[] args) throws IOException {
 			ques[i][2] = (int) in.nval;
 		}
 		prepare();
-		for (int i = 1; i <= m; i++) {
-			if (ques[i][0] == 0) {
-				update(ques[i][1], ques[i][2]);
+		for (int i = 1, k, x, y; i <= m; i++) {
+			k = ques[i][0];
+			x = ques[i][1];
+			y = ques[i][2];
+			if (k == 0) {
+				update(x, y);
 			} else {
-				int ans = query(ques[i][1], ques[i][2], ques[i][0]);
-				if (ans == -1) {
+				int idx = query(x, y, k);
+				if (idx == -1) {
 					out.println("invalid request!");
 				} else {
-					out.println(sorted[ans]);
+					out.println(sorted[idx]);
 				}
 			}
 		}
diff --git a/src/class160/Code06_NetworkManagement2.java b/src/class160/Code06_NetworkManagement2.java
index 16328a234..09aeae9d9 100644
--- a/src/class160/Code06_NetworkManagement2.java
+++ b/src/class160/Code06_NetworkManagement2.java
@@ -208,15 +208,18 @@
 //    }
 //    for (int i = 1; i <= m; i++) cin >> ques[i][0] >> ques[i][1] >> ques[i][2];
 //    prepare();
-//    for (int i = 1; i <= m; i++) {
-//        if (ques[i][0] == 0) {
-//        	update(ques[i][1], ques[i][2]);
+//    for (int i = 1, k, x, y; i <= m; i++) {
+//        k = ques[i][0];
+//        x = ques[i][1];
+//        y = ques[i][2];
+//        if (k == 0) {
+//        	update(x, y);
 //        } else {
-//            int ans = query(ques[i][1], ques[i][2], ques[i][0]);
-//            if(ans == -1) {
+//            int idx = query(x, y, k);
+//            if(idx == -1) {
 //            	cout << "invalid request!" << "\n";
 //            } else {
-//            	cout << sorted[ans] << "\n";
+//            	cout << sorted[idx] << "\n";
 //            }
 //        }
 //    }

From 92f183eb8920b7015bb4ca499f4f5dfdaaff0adc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Feb 2025 16:17:35 +0800
Subject: [PATCH 0446/1712] modify code

---
 src/class160/Code06_NetworkManagement1.java | 8 ++++----
 src/class160/Code06_NetworkManagement2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class160/Code06_NetworkManagement1.java b/src/class160/Code06_NetworkManagement1.java
index fd7d769f6..6fecf33bb 100644
--- a/src/class160/Code06_NetworkManagement1.java
+++ b/src/class160/Code06_NetworkManagement1.java
@@ -279,7 +279,7 @@ public static int query(int x, int y, int k) {
 		for (int i = dfn[lcafa]; i > 0; i -= lowbit(i)) {
 			minusTree[++cntminus] = root[i];
 		}
-		return innerQuery(num - k + 1, 1, s);
+		return sorted[innerQuery(num - k + 1, 1, s)];
 	}
 
 	public static void prepare() {
@@ -346,11 +346,11 @@ public static void main(String[] args) throws IOException {
 			if (k == 0) {
 				update(x, y);
 			} else {
-				int idx = query(x, y, k);
-				if (idx == -1) {
+				int ans = query(x, y, k);
+				if (ans == -1) {
 					out.println("invalid request!");
 				} else {
-					out.println(sorted[idx]);
+					out.println(ans);
 				}
 			}
 		}
diff --git a/src/class160/Code06_NetworkManagement2.java b/src/class160/Code06_NetworkManagement2.java
index 09aeae9d9..540f3b2d8 100644
--- a/src/class160/Code06_NetworkManagement2.java
+++ b/src/class160/Code06_NetworkManagement2.java
@@ -177,7 +177,7 @@
 //    for (int i = dfn[lcafa]; i; i -= lowbit(i)) {
 //        minusTree[++cntminus] = root[i];
 //    }
-//    return innerQuery(num - k + 1, 1, s);
+//    return sorted[innerQuery(num - k + 1, 1, s)];
 //}
 //
 //void prepare() {
@@ -215,11 +215,11 @@
 //        if (k == 0) {
 //        	update(x, y);
 //        } else {
-//            int idx = query(x, y, k);
-//            if(idx == -1) {
+//            int ans = query(x, y, k);
+//            if(ans == -1) {
 //            	cout << "invalid request!" << "\n";
 //            } else {
-//            	cout << sorted[idx] << "\n";
+//            	cout << ans << "\n";
 //            }
 //        }
 //    }

From 1fb81e351bda28fe63466a50172e6457edd6bafd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Feb 2025 17:11:47 +0800
Subject: [PATCH 0447/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced1.java |   3 +-
 src/class160/Code03_SegmentWithBalanced2.java |   3 +-
 src/class160/Code04_IndexWithSegment1.java    |   3 +-
 src/class160/Code04_IndexWithSegment2.java    |   3 +-
 src/class160/Code05_DynamicRankings1.java     | 242 ++++++++++++++++++
 src/class160/Code05_DynamicRankings2.java     | 182 +++++++++++++
 ...ode05_LineUp1.java => Code06_LineUp1.java} |   2 +-
 ...ode05_LineUp2.java => Code06_LineUp2.java} |   0
 ...t1.java => Code07_NetworkManagement1.java} |   2 +-
 ...t2.java => Code07_NetworkManagement2.java} |   0
 10 files changed, 430 insertions(+), 10 deletions(-)
 create mode 100644 src/class160/Code05_DynamicRankings1.java
 create mode 100644 src/class160/Code05_DynamicRankings2.java
 rename src/class160/{Code05_LineUp1.java => Code06_LineUp1.java} (99%)
 rename src/class160/{Code05_LineUp2.java => Code06_LineUp2.java} (100%)
 rename src/class160/{Code06_NetworkManagement1.java => Code07_NetworkManagement1.java} (99%)
 rename src/class160/{Code06_NetworkManagement2.java => Code07_NetworkManagement2.java} (100%)

diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index 21285c3f8..e594a2ad4 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -1,8 +1,7 @@
 package class160;
 
 // 线段树套平衡树，java版
-// 给定一个长度为n的数组arr，下标1~n
-// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 给定一个长度为n的数组arr，下标1~n，每条操作都是如下5种类型中的一种，一共进行m次操作
 // 操作 1 x y z : 查询数字z在arr[x..y]中的排名
 // 操作 2 x y z : 查询arr[x..y]中排第z名的数字
 // 操作 3 x y   : arr中x位置的数字改成y
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 62c8a2b48..5e6318480 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -1,8 +1,7 @@
 package class160;
 
 // 线段树套平衡树，C++版
-// 给定一个长度为n的数组arr，下标1~n
-// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 给定一个长度为n的数组arr，下标1~n，每条操作都是如下5种类型中的一种，一共进行m次操作
 // 操作 1 x y z : 查询数字z在arr[x..y]中的排名
 // 操作 2 x y z : 查询arr[x..y]中排第z名的数字
 // 操作 3 x y   : arr中x位置的数字改成y
diff --git a/src/class160/Code04_IndexWithSegment1.java b/src/class160/Code04_IndexWithSegment1.java
index 5572dd2a8..7b5eaaf0f 100644
--- a/src/class160/Code04_IndexWithSegment1.java
+++ b/src/class160/Code04_IndexWithSegment1.java
@@ -1,8 +1,7 @@
 package class160;
 
 // 树状数组套线段树，java版
-// 给定一个长度为n的数组arr，下标1~n
-// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 给定一个长度为n的数组arr，下标1~n，每条操作都是如下5种类型中的一种，一共进行m次操作
 // 操作 1 x y z : 查询数字z在arr[x..y]中的排名
 // 操作 2 x y z : 查询arr[x..y]中排第z名的数字
 // 操作 3 x y   : arr中x位置的数字改成y
diff --git a/src/class160/Code04_IndexWithSegment2.java b/src/class160/Code04_IndexWithSegment2.java
index 9693aad80..a9a4b7589 100644
--- a/src/class160/Code04_IndexWithSegment2.java
+++ b/src/class160/Code04_IndexWithSegment2.java
@@ -1,8 +1,7 @@
 package class160;
 
 // 树状数组套线段树，C++版
-// 给定一个长度为n的数组arr，下标1~n
-// 每条操作都是如下5种类型中的一种，一共进行m次操作
+// 给定一个长度为n的数组arr，下标1~n，每条操作都是如下5种类型中的一种，一共进行m次操作
 // 操作 1 x y z : 查询数字z在arr[x..y]中的排名
 // 操作 2 x y z : 查询arr[x..y]中排第z名的数字
 // 操作 3 x y   : arr中x位置的数字改成y
diff --git a/src/class160/Code05_DynamicRankings1.java b/src/class160/Code05_DynamicRankings1.java
new file mode 100644
index 000000000..8a129f2ec
--- /dev/null
+++ b/src/class160/Code05_DynamicRankings1.java
@@ -0,0 +1,242 @@
+package class160;
+
+// 动态排名，java版
+// 给定一个长度为n的数组arr，下标1~n，每条操作都是如下2种类型中的一种，一共进行m次操作
+// 操作 Q x y z : 查询arr[x..y]中排第z名的数字
+// 操作 C x y   : arr中x位置的数字改成y
+// 1 <= n、m <= 10^5
+// 数组中的值永远在[0, 10^9]范围内
+// 测试链接 : https://www.luogu.com.cn/problem/P2617
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.StringTokenizer;
+
+public class Code05_DynamicRankings1 {
+
+	public static int MAXN = 100001;
+
+	public static int MAXT = MAXN * 130;
+
+	public static int n, m, s;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[][] ques = new int[MAXN][4];
+
+	public static int[] sorted = new int[MAXN * 2];
+
+	public static int[] root = new int[MAXN];
+
+	public static int[] sum = new int[MAXT];
+
+	public static int[] left = new int[MAXT];
+
+	public static int[] right = new int[MAXT];
+
+	public static int cntt = 0;
+
+	public static int[] addTree = new int[MAXN];
+
+	public static int[] minusTree = new int[MAXN];
+
+	public static int cntadd;
+
+	public static int cntminus;
+
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
+		if (i == 0) {
+			i = ++cntt;
+		}
+		if (l == r) {
+			sum[i] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[i] = innerAdd(jobi, jobv, l, mid, left[i]);
+			} else {
+				right[i] = innerAdd(jobi, jobv, mid + 1, r, right[i]);
+			}
+			sum[i] = sum[left[i]] + sum[right[i]];
+		}
+		return i;
+	}
+
+	public static int innerQuery(int jobk, int l, int r) {
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) / 2;
+		int leftsum = 0;
+		for (int i = 1; i <= cntadd; i++) {
+			leftsum += sum[left[addTree[i]]];
+		}
+		for (int i = 1; i <= cntminus; i++) {
+			leftsum -= sum[left[minusTree[i]]];
+		}
+		if (jobk <= leftsum) {
+			for (int i = 1; i <= cntadd; i++) {
+				addTree[i] = left[addTree[i]];
+			}
+			for (int i = 1; i <= cntminus; i++) {
+				minusTree[i] = left[minusTree[i]];
+			}
+			return innerQuery(jobk, l, mid);
+		} else {
+			for (int i = 1; i <= cntadd; i++) {
+				addTree[i] = right[addTree[i]];
+			}
+			for (int i = 1; i <= cntminus; i++) {
+				minusTree[i] = right[minusTree[i]];
+			}
+			return innerQuery(jobk - leftsum, mid + 1, r);
+		}
+	}
+
+	public static void add(int i, int cnt) {
+		for (int j = i; j <= n; j += lowbit(j)) {
+			root[j] = innerAdd(arr[i], cnt, 1, s, root[j]);
+		}
+	}
+
+	public static void update(int i, int v) {
+		add(i, -1);
+		arr[i] = kth(v);
+		add(i, 1);
+	}
+
+	public static int number(int l, int r, int k) {
+		cntadd = cntminus = 0;
+		for (int i = r; i > 0; i -= lowbit(i)) {
+			addTree[++cntadd] = root[i];
+		}
+		for (int i = l - 1; i > 0; i -= lowbit(i)) {
+			minusTree[++cntminus] = root[i];
+		}
+		return sorted[innerQuery(k, 1, s)];
+	}
+
+	public static void prepare() {
+		s = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[++s] = arr[i];
+		}
+		for (int i = 1; i <= m; i++) {
+			if (ques[i][0] == 2) {
+				sorted[++s] = ques[i][2];
+			}
+		}
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+			add(i, 1);
+		}
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = io.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			ques[i][0] = io.next().equals("Q") ? 1 : 2;
+			ques[i][1] = io.nextInt();
+			ques[i][2] = io.nextInt();
+			if (ques[i][0] == 1) {
+				ques[i][3] = io.nextInt();
+			}
+		}
+		prepare();
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			op = ques[i][0];
+			x = ques[i][1];
+			y = ques[i][2];
+			if (op == 1) {
+				z = ques[i][3];
+				io.println(number(x, y, z));
+			} else {
+				update(x, y);
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class160/Code05_DynamicRankings2.java b/src/class160/Code05_DynamicRankings2.java
new file mode 100644
index 000000000..4b872c698
--- /dev/null
+++ b/src/class160/Code05_DynamicRankings2.java
@@ -0,0 +1,182 @@
+package class160;
+
+// 动态排名，C++版
+// 给定一个长度为n的数组arr，下标1~n，每条操作都是如下2种类型中的一种，一共进行m次操作
+// 操作 Q x y z : 查询arr[x..y]中排第z名的数字
+// 操作 C x y   : arr中x位置的数字改成y
+// 1 <= n、m <= 10^5
+// 数组中的值永远在[0, 10^9]范围内
+// 测试链接 : https://www.luogu.com.cn/problem/P2617
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXT = MAXN * 130;
+//int n, m, s;
+//int arr[MAXN];
+//int ques[MAXN][4];
+//int sorted[MAXN * 2];
+//int root[MAXN];
+//int sum[MAXT];
+//int ls[MAXT];
+//int rs[MAXT];
+//int cntt = 0;
+//int addTree[MAXN];
+//int minusTree[MAXN];
+//int cntadd;
+//int cntminus;
+//
+//int kth(int num) {
+//    int l = 1, r = s, mid;
+//    while (l <= r) {
+//        mid = (l + r) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            l = mid + 1;
+//        } else {
+//            r = mid - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//int innerAdd(int jobi, int jobv, int l, int r, int i) {
+//    if (i == 0) {
+//        i = ++cntt;
+//    }
+//    if (l == r) {
+//    	sum[i] += jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//        	ls[i] = innerAdd(jobi, jobv, l, mid, ls[i]);
+//        } else {
+//        	rs[i] = innerAdd(jobi, jobv, mid + 1, r, rs[i]);
+//        }
+//        sum[i] = sum[ls[i]] + sum[rs[i]];
+//    }
+//    return i;
+//}
+//
+//int innerQuery(int jobk, int l, int r) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) / 2;
+//    int leftsum = 0;
+//    for (int i = 1; i <= cntadd; i++) {
+//        leftsum += sum[ls[addTree[i]]];
+//    }
+//    for (int i = 1; i <= cntminus; i++) {
+//        leftsum -= sum[ls[minusTree[i]]];
+//    }
+//    if (jobk <= leftsum) {
+//        for (int i = 1; i <= cntadd; i++) {
+//            addTree[i] = ls[addTree[i]];
+//        }
+//        for (int i = 1; i <= cntminus; i++) {
+//            minusTree[i] = ls[minusTree[i]];
+//        }
+//        return innerQuery(jobk, l, mid);
+//    } else {
+//        for (int i = 1; i <= cntadd; i++) {
+//            addTree[i] = rs[addTree[i]];
+//        }
+//        for (int i = 1; i <= cntminus; i++) {
+//            minusTree[i] = rs[minusTree[i]];
+//        }
+//        return innerQuery(jobk - leftsum, mid + 1, r);
+//    }
+//}
+//
+//void add(int i, int cnt) {
+//    for (int j = i; j <= n; j += lowbit(j)) {
+//        root[j] = innerAdd(arr[i], cnt, 1, s, root[j]);
+//    }
+//}
+//
+//void update(int i, int v) {
+//    add(i, -1);
+//    arr[i] = kth(v);
+//    add(i, 1);
+//}
+//
+//int number(int l, int r, int k) {
+//    cntadd = cntminus = 0;
+//    for (int i = r; i > 0; i -= lowbit(i)) {
+//        addTree[++cntadd] = root[i];
+//    }
+//    for (int i = l - 1; i > 0; i -= lowbit(i)) {
+//        minusTree[++cntminus] = root[i];
+//    }
+//    return sorted[innerQuery(k, 1, s)];
+//}
+//
+//void prepare() {
+//    s = 0;
+//    for (int i = 1; i <= n; i++) {
+//    	sorted[++s] = arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (ques[i][0] == 2) {
+//        	sorted[++s] = ques[i][2];
+//        }
+//    }
+//    sort(sorted + 1, sorted + s + 1);
+//    int len = 1;
+//    for (int i = 2; i <= s; i++) {
+//        if (sorted[len] != sorted[i]) {
+//        	sorted[++len] = sorted[i];
+//        }
+//    }
+//    s = len;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//        add(i, 1);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        string op;
+//        cin >> op;
+//        if (op == "Q") {
+//            ques[i][0] = 1;
+//        } else {
+//            ques[i][0] = 2;
+//        }
+//        cin >> ques[i][1];
+//        cin >> ques[i][2];
+//        if (ques[i][0] == 1) {
+//            cin >> ques[i][3];
+//        }
+//    }
+//    prepare();
+//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//        op = ques[i][0];
+//        x = ques[i][1];
+//        y = ques[i][2];
+//        if (op == 1) {
+//            z = ques[i][3];
+//            cout << number(x, y, z) << "\n";
+//        } else {
+//            update(x, y);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class160/Code05_LineUp1.java b/src/class160/Code06_LineUp1.java
similarity index 99%
rename from src/class160/Code05_LineUp1.java
rename to src/class160/Code06_LineUp1.java
index 72bc1d237..a78d7579e 100644
--- a/src/class160/Code05_LineUp1.java
+++ b/src/class160/Code06_LineUp1.java
@@ -19,7 +19,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code05_LineUp1 {
+public class Code06_LineUp1 {
 
 	public static int MAXN = 20001;
 
diff --git a/src/class160/Code05_LineUp2.java b/src/class160/Code06_LineUp2.java
similarity index 100%
rename from src/class160/Code05_LineUp2.java
rename to src/class160/Code06_LineUp2.java
diff --git a/src/class160/Code06_NetworkManagement1.java b/src/class160/Code07_NetworkManagement1.java
similarity index 99%
rename from src/class160/Code06_NetworkManagement1.java
rename to src/class160/Code07_NetworkManagement1.java
index 6fecf33bb..868f32f8c 100644
--- a/src/class160/Code06_NetworkManagement1.java
+++ b/src/class160/Code07_NetworkManagement1.java
@@ -19,7 +19,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code06_NetworkManagement1 {
+public class Code07_NetworkManagement1 {
 
 	public static int MAXN = 80001;
 
diff --git a/src/class160/Code06_NetworkManagement2.java b/src/class160/Code07_NetworkManagement2.java
similarity index 100%
rename from src/class160/Code06_NetworkManagement2.java
rename to src/class160/Code07_NetworkManagement2.java

From 96111c043826b4518da0ad05f5858d322eb54a01 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 13:04:07 +0800
Subject: [PATCH 0448/1712] modify code

---
 src/class122/Code05_TransportPlan2.java | 106 ++++++++++++++++--------
 1 file changed, 72 insertions(+), 34 deletions(-)

diff --git a/src/class122/Code05_TransportPlan2.java b/src/class122/Code05_TransportPlan2.java
index b84f76fee..bde647031 100644
--- a/src/class122/Code05_TransportPlan2.java
+++ b/src/class122/Code05_TransportPlan2.java
@@ -10,12 +10,10 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P2680
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有用例
 
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
+import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.io.StreamTokenizer;
 import java.util.Arrays;
 
 public class Code05_TransportPlan2 {
@@ -213,30 +211,38 @@ public static boolean dfs(int root) {
 		return false;
 	}
 
+	public static int compute() {
+		tarjan(1);
+		int l = 0, r = maxCost, mid;
+		int ans = 0;
+		while (l <= r) {
+			mid = (l + r) / 2;
+			if (f(mid)) {
+				ans = mid;
+				r = mid - 1;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return ans;
+	}
+
 	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		n = (int) in.nval;
+		FastIO in = new FastIO();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out), false);
+		n = in.nextInt();
 		build();
-		in.nextToken();
-		m = (int) in.nval;
+		m = in.nextInt();
 		for (int i = 1, u, v, w; i < n; i++) {
-			in.nextToken();
-			u = (int) in.nval;
-			in.nextToken();
-			v = (int) in.nval;
-			in.nextToken();
-			w = (int) in.nval;
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextInt();
 			addEdge(u, v, w);
 			addEdge(v, u, w);
 		}
 		for (int i = 1, u, v; i <= m; i++) {
-			in.nextToken();
-			u = (int) in.nval;
-			in.nextToken();
-			v = (int) in.nval;
+			u = in.nextInt();
+			v = in.nextInt();
 			quesu[i] = u;
 			quesv[i] = v;
 			addQuery(u, v, i);
@@ -245,23 +251,55 @@ public static void main(String[] args) throws IOException {
 		out.println(compute());
 		out.flush();
 		out.close();
-		br.close();
 	}
 
-	public static int compute() {
-		tarjan(1);
-		int l = 0, r = maxCost, mid;
-		int ans = 0;
-		while (l <= r) {
-			mid = (l + r) / 2;
-			if (f(mid)) {
-				ans = mid;
-				r = mid - 1;
-			} else {
-				l = mid + 1;
+	// IO工具类
+	static class FastIO {
+		private final int SIZE = 1 << 20;
+		private byte[] buf;
+		private int pos;
+		private int count;
+		private InputStream is;
+
+		public FastIO() {
+			buf = new byte[SIZE];
+			pos = 0;
+			count = 0;
+			is = System.in;
+		}
+
+		private int readByte() throws IOException {
+			if (count == -1) {
+				return -1; // EOF
+			}
+			if (pos >= count) {
+				pos = 0;
+				count = is.read(buf);
+				if (count == -1) {
+					return -1;
+				}
 			}
+			return buf[pos++] & 0xff;
+		}
+
+		public int nextInt() throws IOException {
+			int c, value = 0;
+			boolean neg = false;
+			do {
+				c = readByte();
+				if (c == -1) {
+					return -1;
+				}
+			} while (c <= ' ');
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			for (; c >= '0' && c <= '9'; c = readByte()) {
+				value = value * 10 + (c - '0');
+			}
+			return neg ? -value : value;
 		}
-		return ans;
 	}
 
-}
\ No newline at end of file
+}

From 1b301011ed7254846ec9c918eb54b5bf249893f0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 13:42:25 +0800
Subject: [PATCH 0449/1712] modify code

---
 src/class122/Code05_TransportPlan1.java |  34 ++---
 src/class122/Code05_TransportPlan2.java |  10 +-
 src/class122/Code05_TransportPlan3.java | 172 ++++++++++++++++++++++++
 3 files changed, 196 insertions(+), 20 deletions(-)
 create mode 100644 src/class122/Code05_TransportPlan3.java

diff --git a/src/class122/Code05_TransportPlan1.java b/src/class122/Code05_TransportPlan1.java
index 85d688844..987e4bbe8 100644
--- a/src/class122/Code05_TransportPlan1.java
+++ b/src/class122/Code05_TransportPlan1.java
@@ -1,6 +1,6 @@
 package class122;
 
-// 运输计划(递归版)
+// 运输计划，java版，递归dfs
 // 有n个节点，给定n-1条边使其连接成一棵树，每条边有正数边权
 // 给定很多运输计划，每个运输计划(a,b)表示从a去往b
 // 每个运输计划的代价就是沿途边权和，运输计划之间完全互不干扰
@@ -170,6 +170,22 @@ public static boolean dfs(int u, int f, int w) {
 		return num[u] == beyond && w >= atLeast;
 	}
 
+	public static int compute() {
+		tarjan(1, 0, 0);
+		int l = 0, r = maxCost, mid;
+		int ans = 0;
+		while (l <= r) {
+			mid = (l + r) / 2;
+			if (f(mid)) {
+				ans = mid;
+				r = mid - 1;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return ans;
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -205,20 +221,4 @@ public static void main(String[] args) throws IOException {
 		br.close();
 	}
 
-	public static int compute() {
-		tarjan(1, 0, 0);
-		int l = 0, r = maxCost, mid;
-		int ans = 0;
-		while (l <= r) {
-			mid = (l + r) / 2;
-			if (f(mid)) {
-				ans = mid;
-				r = mid - 1;
-			} else {
-				l = mid + 1;
-			}
-		}
-		return ans;
-	}
-
 }
\ No newline at end of file
diff --git a/src/class122/Code05_TransportPlan2.java b/src/class122/Code05_TransportPlan2.java
index bde647031..d2e283c0d 100644
--- a/src/class122/Code05_TransportPlan2.java
+++ b/src/class122/Code05_TransportPlan2.java
@@ -1,6 +1,6 @@
 package class122;
 
-// 运输计划(迭代版)
+// 运输计划，java版，迭代dfs
 // 有n个节点，给定n-1条边使其连接成一棵树，每条边有正数边权
 // 给定很多运输计划，每个运输计划(a,b)表示从a去往b
 // 每个运输计划的代价就是沿途边权和，运输计划之间完全互不干扰
@@ -8,7 +8,11 @@
 // 你的目的是让所有运输计划代价的最大值尽量小
 // 返回所有运输计划代价的最大值最小能是多少
 // 测试链接 : https://www.luogu.com.cn/problem/P2680
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有用例
+// 提交以下的code，提交时请把类名改成"Main"
+// 有时候可以完全通过，有时候会有一个测试用例超时
+// 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
+// 本节课Code05_TransportPlan3文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -270,7 +274,7 @@ public FastIO() {
 
 		private int readByte() throws IOException {
 			if (count == -1) {
-				return -1; // EOF
+				return -1;
 			}
 			if (pos >= count) {
 				pos = 0;
diff --git a/src/class122/Code05_TransportPlan3.java b/src/class122/Code05_TransportPlan3.java
new file mode 100644
index 000000000..00bba0de2
--- /dev/null
+++ b/src/class122/Code05_TransportPlan3.java
@@ -0,0 +1,172 @@
+package class122;
+
+// 运输计划，C++版，递归dfs
+// 有n个节点，给定n-1条边使其连接成一棵树，每条边有正数边权
+// 给定很多运输计划，每个运输计划(a,b)表示从a去往b
+// 每个运输计划的代价就是沿途边权和，运输计划之间完全互不干扰
+// 你只能选择一条边，将其边权变成0
+// 你的目的是让所有运输计划代价的最大值尽量小
+// 返回所有运输计划代价的最大值最小能是多少
+// 测试链接 : https://www.luogu.com.cn/problem/P2680
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//const int MAXM = 300001;
+//int n, m;
+//int num[MAXN];
+//int headEdge[MAXN];
+//int edgeNext[MAXN << 1];
+//int edgeTo[MAXN << 1];
+//int edgeWeight[MAXN << 1];
+//int tcnt;
+//int headQuery[MAXN];
+//int queryNext[MAXM << 1];
+//int queryTo[MAXM << 1];
+//int queryIndex[MAXM << 1];
+//int qcnt;
+//bool visited[MAXN];
+//int unionfind[MAXN];
+//int quesu[MAXM];
+//int quesv[MAXM];
+//int dist[MAXN];
+//int lca[MAXM];
+//int cost[MAXM];
+//int maxCost;
+//int atLeast;
+//int beyond;
+//
+//void build() {
+//    tcnt = 1;
+//    qcnt = 1;
+//    for(int i = 1; i <= n; i++) {
+//        headEdge[i] = 0;
+//        headQuery[i] = 0;
+//        visited[i] = false;
+//        unionfind[i] = i;
+//    }
+//    maxCost = 0;
+//}
+//
+//void addEdge(int u, int v, int w) {
+//    edgeNext[tcnt] = headEdge[u];
+//    edgeTo[tcnt] = v;
+//    edgeWeight[tcnt] = w;
+//    headEdge[u] = tcnt++;
+//}
+//
+//void addQuery(int u, int v, int i) {
+//    queryNext[qcnt] = headQuery[u];
+//    queryTo[qcnt] = v;
+//    queryIndex[qcnt] = i;
+//    headQuery[u] = qcnt++;
+//}
+//
+//int find(int i) {
+//    if(i != unionfind[i]) {
+//        unionfind[i] = find(unionfind[i]);
+//    }
+//    return unionfind[i];
+//}
+//
+//void tarjan(int u, int f, int w) {
+//    visited[u] = true;
+//    dist[u] = dist[f] + w;
+//    for(int e = headEdge[u]; e != 0; e = edgeNext[e]) {
+//        int v = edgeTo[e];
+//        if(v != f) {
+//            tarjan(v, u, edgeWeight[e]);
+//        }
+//    }
+//    for(int e = headQuery[u]; e != 0; e = queryNext[e]) {
+//        int v = queryTo[e];
+//        if(visited[v]) {
+//            int i = queryIndex[e];
+//            lca[i] = find(v);
+//            cost[i] = dist[u] + dist[v] - 2 * dist[lca[i]];
+//            maxCost = max(maxCost, cost[i]);
+//        }
+//    }
+//    unionfind[u] = f;
+//}
+//
+//bool dfs(int u, int f, int w) {
+//    for(int e = headEdge[u]; e != 0; e = edgeNext[e]) {
+//        int v = edgeTo[e];
+//        if(v != f) {
+//            if(dfs(v, u, edgeWeight[e])) {
+//                return true;
+//            }
+//        }
+//    }
+//    for(int e = headEdge[u]; e != 0; e = edgeNext[e]) {
+//        int v = edgeTo[e];
+//        if(v != f) {
+//            num[u] += num[v];
+//        }
+//    }
+//    return (num[u] == beyond && w >= atLeast);
+//}
+//
+//bool f(int limit) {
+//    atLeast = maxCost - limit;
+//    for(int i = 1; i <= n; i++) {
+//        num[i] = 0;
+//    }
+//    beyond = 0;
+//    for(int i = 1; i <= m; i++) {
+//        if(cost[i] > limit) {
+//            num[quesu[i]]++;
+//            num[quesv[i]]++;
+//            num[lca[i]] -= 2;
+//            beyond++;
+//        }
+//    }
+//    if(beyond == 0) return true;
+//    return dfs(1, 0, 0);
+//}
+//
+//int compute() {
+//    tarjan(1, 0, 0);
+//    int l = 0;
+//    int r = maxCost;
+//    int ans = 0;
+//    while(l <= r) {
+//        int mid = (l + r) / 2;
+//        if(f(mid)) {
+//            ans = mid;
+//            r = mid - 1;
+//        } else {
+//            l = mid + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    build();
+//    cin >> m;
+//    for(int i = 1; i < n; i++){
+//        int u,v,w;
+//        cin >> u >> v >> w;
+//        addEdge(u,v,w);
+//        addEdge(v,u,w);
+//    }
+//    for(int i = 1; i <= m; i++){
+//        int u,v;
+//        cin >> u >> v;
+//        quesu[i] = u;
+//        quesv[i] = v;
+//        addQuery(u,v,i);
+//        addQuery(v,u,i);
+//    }
+//    cout << compute() << "\n";
+//    return 0;
+//}
\ No newline at end of file

From 578b6dc5df8b197b5f02873e4f9519f6aa80ef8f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 13:45:52 +0800
Subject: [PATCH 0450/1712] modify code

---
 src/class122/Code05_TransportPlan1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class122/Code05_TransportPlan1.java b/src/class122/Code05_TransportPlan1.java
index 987e4bbe8..9efd32f18 100644
--- a/src/class122/Code05_TransportPlan1.java
+++ b/src/class122/Code05_TransportPlan1.java
@@ -10,7 +10,6 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P2680
 // 提交以下的code，提交时请把类名改成"Main"
 // C++这么写能通过，java会因为递归层数太多而爆栈
-// java能通过的写法参考本节课Code05_TransportPlan2文件
 
 import java.io.BufferedReader;
 import java.io.IOException;

From 036e1fea7273e475e283677719a5afe7c5661583 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 13:47:48 +0800
Subject: [PATCH 0451/1712] modify code

---
 src/class122/Code05_TransportPlan1.java | 3 ++-
 src/class122/Code05_TransportPlan2.java | 2 +-
 src/class122/Code05_TransportPlan3.java | 2 +-
 3 files changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/class122/Code05_TransportPlan1.java b/src/class122/Code05_TransportPlan1.java
index 9efd32f18..48013c427 100644
--- a/src/class122/Code05_TransportPlan1.java
+++ b/src/class122/Code05_TransportPlan1.java
@@ -1,6 +1,6 @@
 package class122;
 
-// 运输计划，java版，递归dfs
+// 运输计划，java递归版
 // 有n个节点，给定n-1条边使其连接成一棵树，每条边有正数边权
 // 给定很多运输计划，每个运输计划(a,b)表示从a去往b
 // 每个运输计划的代价就是沿途边权和，运输计划之间完全互不干扰
@@ -10,6 +10,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P2680
 // 提交以下的code，提交时请把类名改成"Main"
 // C++这么写能通过，java会因为递归层数太多而爆栈
+// 本节课Code05_TransportPlan3文件就是C++的实现
 
 import java.io.BufferedReader;
 import java.io.IOException;
diff --git a/src/class122/Code05_TransportPlan2.java b/src/class122/Code05_TransportPlan2.java
index d2e283c0d..e78f1fc86 100644
--- a/src/class122/Code05_TransportPlan2.java
+++ b/src/class122/Code05_TransportPlan2.java
@@ -1,6 +1,6 @@
 package class122;
 
-// 运输计划，java版，迭代dfs
+// 运输计划，java迭代版
 // 有n个节点，给定n-1条边使其连接成一棵树，每条边有正数边权
 // 给定很多运输计划，每个运输计划(a,b)表示从a去往b
 // 每个运输计划的代价就是沿途边权和，运输计划之间完全互不干扰
diff --git a/src/class122/Code05_TransportPlan3.java b/src/class122/Code05_TransportPlan3.java
index 00bba0de2..a60e0a895 100644
--- a/src/class122/Code05_TransportPlan3.java
+++ b/src/class122/Code05_TransportPlan3.java
@@ -1,6 +1,6 @@
 package class122;
 
-// 运输计划，C++版，递归dfs
+// 运输计划，C++版，递归不用改迭代
 // 有n个节点，给定n-1条边使其连接成一棵树，每条边有正数边权
 // 给定很多运输计划，每个运输计划(a,b)表示从a去往b
 // 每个运输计划的代价就是沿途边权和，运输计划之间完全互不干扰

From 5e2e571dbad3f968a4a4a3dd82e272943015d5b8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 14:15:22 +0800
Subject: [PATCH 0452/1712] modify code

---
 src/class160/Code01_SegmentWithSegment1.java | 24 ++++++++++++--------
 src/class160/Code01_SegmentWithSegment2.java | 20 ++++++++--------
 2 files changed, 24 insertions(+), 20 deletions(-)

diff --git a/src/class160/Code01_SegmentWithSegment1.java b/src/class160/Code01_SegmentWithSegment1.java
index 8a8907837..2b3df7ee7 100644
--- a/src/class160/Code01_SegmentWithSegment1.java
+++ b/src/class160/Code01_SegmentWithSegment1.java
@@ -27,8 +27,12 @@ public class Code01_SegmentWithSegment1 {
 
 	public static int m = 1001;
 
+	// 身高范围对应[MINX, MAXX]，活泼度范围对应[MINY, MAXY]
 	public static int MINX = 100, MAXX = 200, MINY = 0, MAXY = 1000;
 
+	// 外层是身高线段树，内层是活泼度线段树
+	// 每一个外层线段树的节点，对应着一棵内层线段树
+	// 内层线段树收集缘分值
 	public static int[][] tree = new int[n << 2][m << 2];
 
 	public static void innerBuild(int yl, int yr, int xi, int yi) {
@@ -40,32 +44,32 @@ public static void innerBuild(int yl, int yr, int xi, int yi) {
 		}
 	}
 
-	public static void innerUpdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
+	public static void innerUpdate(int jobi, int jobv, int yl, int yr, int xi, int yi) {
 		if (yl == yr) {
 			tree[xi][yi] = Math.max(tree[xi][yi], jobv);
 		} else {
 			int mid = (yl + yr) / 2;
-			if (joby <= mid) {
-				innerUpdate(joby, jobv, yl, mid, xi, yi << 1);
+			if (jobi <= mid) {
+				innerUpdate(jobi, jobv, yl, mid, xi, yi << 1);
 			} else {
-				innerUpdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
+				innerUpdate(jobi, jobv, mid + 1, yr, xi, yi << 1 | 1);
 			}
 			tree[xi][yi] = Math.max(tree[xi][yi << 1], tree[xi][yi << 1 | 1]);
 		}
 	}
 
-	public static int innerQuery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
-		if (jobyl <= yl && yr <= jobyr) {
+	public static int innerQuery(int jobl, int jobr, int yl, int yr, int xi, int yi) {
+		if (jobl <= yl && yr <= jobr) {
 			return tree[xi][yi];
 		}
 		int mid = (yl + yr) / 2;
 		int ans = -1;
-		if (jobyl <= mid) {
-			ans = innerQuery(jobyl, jobyr, yl, mid, xi, yi << 1);
+		if (jobl <= mid) {
+			ans = innerQuery(jobl, jobr, yl, mid, xi, yi << 1);
 
 		}
-		if (jobyr > mid) {
-			ans = Math.max(ans, innerQuery(jobyl, jobyr, mid + 1, yr, xi, yi << 1 | 1));
+		if (jobr > mid) {
+			ans = Math.max(ans, innerQuery(jobl, jobr, mid + 1, yr, xi, yi << 1 | 1));
 		}
 		return ans;
 	}
diff --git a/src/class160/Code01_SegmentWithSegment2.java b/src/class160/Code01_SegmentWithSegment2.java
index 44b127100..b09aaa352 100644
--- a/src/class160/Code01_SegmentWithSegment2.java
+++ b/src/class160/Code01_SegmentWithSegment2.java
@@ -31,31 +31,31 @@
 //    }
 //}
 //
-//void innerUpdate(int joby, int jobv, int yl, int yr, int xi, int yi) {
+//void innerUpdate(int jobi, int jobv, int yl, int yr, int xi, int yi) {
 //    if (yl == yr) {
 //        tree[xi][yi] = max(tree[xi][yi], jobv);
 //    } else {
 //        int mid = (yl + yr) >> 1;
-//        if (joby <= mid) {
-//        	innerUpdate(joby, jobv, yl, mid, xi, yi << 1);
+//        if (jobi <= mid) {
+//        	innerUpdate(jobi, jobv, yl, mid, xi, yi << 1);
 //        } else {
-//        	innerUpdate(joby, jobv, mid + 1, yr, xi, yi << 1 | 1);
+//        	innerUpdate(jobi, jobv, mid + 1, yr, xi, yi << 1 | 1);
 //        }
 //        tree[xi][yi] = max(tree[xi][yi << 1], tree[xi][(yi << 1) | 1]);
 //    }
 //}
 //
-//int innerQuery(int jobyl, int jobyr, int yl, int yr, int xi, int yi) {
-//    if (jobyl <= yl && yr <= jobyr) {
+//int innerQuery(int jobl, int jobr, int yl, int yr, int xi, int yi) {
+//    if (jobl <= yl && yr <= jobr) {
 //        return tree[xi][yi];
 //    }
 //    int mid = (yl + yr) >> 1;
 //    int ans = -1;
-//    if (jobyl <= mid) {
-//        ans = max(ans, innerQuery(jobyl, jobyr, yl, mid, xi, yi << 1));
+//    if (jobl <= mid) {
+//        ans = max(ans, innerQuery(jobl, jobr, yl, mid, xi, yi << 1));
 //    }
-//    if (jobyr > mid) {
-//        ans = max(ans, innerQuery(jobyl, jobyr, mid + 1, yr, xi, (yi << 1) | 1));
+//    if (jobr > mid) {
+//        ans = max(ans, innerQuery(jobl, jobr, mid + 1, yr, xi, (yi << 1) | 1));
 //    }
 //    return ans;
 //}

From eebb5dcf788ed06b568caa31fba347ccbeb26783 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 14:19:59 +0800
Subject: [PATCH 0453/1712] modify code

---
 src/class160/Code01_SegmentWithSegment1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class160/Code01_SegmentWithSegment1.java b/src/class160/Code01_SegmentWithSegment1.java
index 2b3df7ee7..26c187203 100644
--- a/src/class160/Code01_SegmentWithSegment1.java
+++ b/src/class160/Code01_SegmentWithSegment1.java
@@ -23,8 +23,10 @@
 
 public class Code01_SegmentWithSegment1 {
 
+	// 身高范围内有多少数字
 	public static int n = 101;
 
+	// 活泼度范围内有多少数字
 	public static int m = 1001;
 
 	// 身高范围对应[MINX, MAXX]，活泼度范围对应[MINY, MAXY]

From 0c26139ca10ba7af72ec80fb69e046a3157fab45 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 16:06:15 +0800
Subject: [PATCH 0454/1712] modify code

---
 src/class160/Code01_SegmentWithSegment1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class160/Code01_SegmentWithSegment1.java b/src/class160/Code01_SegmentWithSegment1.java
index 26c187203..75b07b974 100644
--- a/src/class160/Code01_SegmentWithSegment1.java
+++ b/src/class160/Code01_SegmentWithSegment1.java
@@ -68,7 +68,6 @@ public static int innerQuery(int jobl, int jobr, int yl, int yr, int xi, int yi)
 		int ans = -1;
 		if (jobl <= mid) {
 			ans = innerQuery(jobl, jobr, yl, mid, xi, yi << 1);
-
 		}
 		if (jobr > mid) {
 			ans = Math.max(ans, innerQuery(jobl, jobr, mid + 1, yr, xi, yi << 1 | 1));

From 33e4bf0d0ca3c07905e6bc8d3a61f04a80658f73 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 16:42:32 +0800
Subject: [PATCH 0455/1712] modify code

---
 src/class160/Code02_QueryKthMaximum1.java | 18 ++++++++++++++----
 src/class160/Code02_QueryKthMaximum2.java |  6 +++---
 2 files changed, 17 insertions(+), 7 deletions(-)

diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index 807b3a535..756172a0c 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -26,12 +26,22 @@ public class Code02_QueryKthMaximum1 {
 
 	public static int n, m, s;
 
+	// 所有操作收集起来，因为牵扯到离散化
 	public static int[][] ques = new int[MAXN][4];
 
+	// 所有可能数字的数字，收集起来去重，方便得到数字排名
 	public static int[] sorted = new int[MAXN];
 
+	// 外部(a~b) + 内部(c~d)表示：数字排名范围a~b，集合范围c~d，上面数字的个数
+	// 外部线段树的下标表示数字的排名
+	// 外部(a~b)，假设对应的节点编号为i，那么root[i]就是内部线段树的头节点编号
 	public static int[] root = new int[MAXN << 2];
 
+	// 内部线段树是开点线段树，所以需要cnt来获得节点计数
+	// 内部线段树的下标表示集合的编号
+	// 内部(c~d)，假设对应的节点编号为i
+	// sum[i]表示集合范围c~d，一共收集了多少数字
+	// lazy[i]懒更新信息，集合范围c~d，增加了多少个数字，等待懒更新的下发
 	public static int[] left = new int[MAXT];
 
 	public static int[] right = new int[MAXT];
@@ -117,14 +127,14 @@ public static long innerQuery(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
-	public static void outerAdd(int jobl, int jobr, int jobk, int l, int r, int i) {
+	public static void outerAdd(int jobl, int jobr, int jobv, int l, int r, int i) {
 		root[i] = innerAdd(jobl, jobr, 1, n, root[i]);
 		if (l < r) {
 			int mid = (l + r) / 2;
-			if (jobk <= mid) {
-				outerAdd(jobl, jobr, jobk, l, mid, i << 1);
+			if (jobv <= mid) {
+				outerAdd(jobl, jobr, jobv, l, mid, i << 1);
 			} else {
-				outerAdd(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+				outerAdd(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
 			}
 		}
 	}
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index 78f55130a..bf35d30f3 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -87,14 +87,14 @@
 //    return ans;
 //}
 //
-//void outerAdd(int jobl, int jobr, int jobk, int l, int r, int i) {
+//void outerAdd(int jobl, int jobr, int jobv, int l, int r, int i) {
 //    root[i] = innerAdd(jobl, jobr, 1, n, root[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
 //        if (jobk <= mid) {
-//            outerAdd(jobl, jobr, jobk, l, mid, i << 1);
+//            outerAdd(jobl, jobr, jobv, l, mid, i << 1);
 //        } else {
-//            outerAdd(jobl, jobr, jobk, mid + 1, r, i << 1 | 1);
+//            outerAdd(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
 //        }
 //    }
 //}

From d06d8fe4dd01632c8a2720b6faae508d4240f475 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 16:50:00 +0800
Subject: [PATCH 0456/1712] modify code

---
 src/class160/Code02_QueryKthMaximum1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index 756172a0c..a1640124d 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -26,13 +26,13 @@ public class Code02_QueryKthMaximum1 {
 
 	public static int n, m, s;
 
-	// 所有操作收集起来，因为牵扯到离散化
+	// 所有操作收集起来，因为牵扯到数字离散化
 	public static int[][] ques = new int[MAXN][4];
 
-	// 所有可能数字的数字，收集起来去重，方便得到数字排名
+	// 所有可能的数字，收集起来去重，方便得到数字排名
 	public static int[] sorted = new int[MAXN];
 
-	// 外部(a~b) + 内部(c~d)表示：数字排名范围a~b，集合范围c~d，上面数字的个数
+	// 外部(a~b) + 内部(c~d)表示：数字排名范围a~b，集合范围c~d，数字的个数
 	// 外部线段树的下标表示数字的排名
 	// 外部(a~b)，假设对应的节点编号为i，那么root[i]就是内部线段树的头节点编号
 	public static int[] root = new int[MAXN << 2];
@@ -41,7 +41,7 @@ public class Code02_QueryKthMaximum1 {
 	// 内部线段树的下标表示集合的编号
 	// 内部(c~d)，假设对应的节点编号为i
 	// sum[i]表示集合范围c~d，一共收集了多少数字
-	// lazy[i]懒更新信息，集合范围c~d，增加了多少个数字，等待懒更新的下发
+	// lazy[i]懒更新信息，集合范围c~d，增加了几个数字，等待懒更新的下发
 	public static int[] left = new int[MAXT];
 
 	public static int[] right = new int[MAXT];

From 9db67fa340cfe08745c67bdc75b6a4ad9b52eb01 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 16:50:38 +0800
Subject: [PATCH 0457/1712] modify code

---
 src/class160/Code02_QueryKthMaximum2.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index bf35d30f3..e6b60c909 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -20,7 +20,6 @@
 //int n, m, s;
 //int ques[MAXN][4];
 //int sorted[MAXN];
-//
 //int root[MAXN << 2];
 //int ls[MAXT];
 //int rs[MAXT];

From b697036a72a74da7bf5d239b8e5274c65fbcfc57 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 17:07:02 +0800
Subject: [PATCH 0458/1712] modify code

---
 src/class160/Code02_QueryKthMaximum1.java | 2 +-
 src/class160/Code02_QueryKthMaximum2.java | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index a1640124d..5002bfbe0 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -5,8 +5,8 @@
 // 操作 1 l r v : 数字v放入编号范围[l,r]的每一个集合中
 // 操作 2 l r k : 编号范围[l,r]的所有集合，如果生成不去重的并集，返回第k大的数字
 // 1 <= n、m <= 5 * 10^4
-// 1 <= v <= n
 // 1 <= k < 2^63，题目保证第k大的数字一定存在
+// 注意，测试用例里增加了Hack数据，v可能是很大的数字
 // 测试链接 : https://www.luogu.com.cn/problem/P3332
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index e6b60c909..8243eb640 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -5,8 +5,8 @@
 // 操作 1 l r v : 数字v放入编号范围[l,r]的每一个集合中
 // 操作 2 l r k : 编号范围[l,r]的所有集合，如果生成不去重的并集，返回第k大的数字
 // 1 <= n、m <= 5 * 10^4
-// 1 <= v <= n
 // 1 <= k < 2^63，题目保证第k大的数字一定存在
+// 注意，测试用例里增加了Hack数据，v可能是很大的数字
 // 测试链接 : https://www.luogu.com.cn/problem/P3332
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -90,7 +90,7 @@
 //    root[i] = innerAdd(jobl, jobr, 1, n, root[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
-//        if (jobk <= mid) {
+//        if (jobv <= mid) {
 //            outerAdd(jobl, jobr, jobv, l, mid, i << 1);
 //        } else {
 //            outerAdd(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);

From c748079df22aecff4af13f479111289c1bc2c5fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 17:18:56 +0800
Subject: [PATCH 0459/1712] modify code

---
 src/class160/Code02_QueryKthMaximum1.java | 12 +++++++-----
 src/class160/Code02_QueryKthMaximum2.java | 10 +++++-----
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index 5002bfbe0..4a24b7586 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -20,22 +20,24 @@
 
 public class Code02_QueryKthMaximum1 {
 
-	public static int MAXN = 50001;
+	// 外部线段树的范围，一共只有m个操作，所以最多有m种数字
+	public static int MAXM = 50001;
 
-	public static int MAXT = MAXN * 230;
+	// 内部线段树的节点数上限
+	public static int MAXT = MAXM * 230;
 
 	public static int n, m, s;
 
 	// 所有操作收集起来，因为牵扯到数字离散化
-	public static int[][] ques = new int[MAXN][4];
+	public static int[][] ques = new int[MAXM][4];
 
 	// 所有可能的数字，收集起来去重，方便得到数字排名
-	public static int[] sorted = new int[MAXN];
+	public static int[] sorted = new int[MAXM];
 
 	// 外部(a~b) + 内部(c~d)表示：数字排名范围a~b，集合范围c~d，数字的个数
 	// 外部线段树的下标表示数字的排名
 	// 外部(a~b)，假设对应的节点编号为i，那么root[i]就是内部线段树的头节点编号
-	public static int[] root = new int[MAXN << 2];
+	public static int[] root = new int[MAXM << 2];
 
 	// 内部线段树是开点线段树，所以需要cnt来获得节点计数
 	// 内部线段树的下标表示集合的编号
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index 8243eb640..8a634362d 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -15,12 +15,12 @@
 //
 //using namespace std;
 //
-//const int MAXN = 50001;
-//const int MAXT = MAXN * 230;
+//const int MAXM = 50001;
+//const int MAXT = MAXM * 230;
 //int n, m, s;
-//int ques[MAXN][4];
-//int sorted[MAXN];
-//int root[MAXN << 2];
+//int ques[MAXM][4];
+//int sorted[MAXM];
+//int root[MAXM << 2];
 //int ls[MAXT];
 //int rs[MAXT];
 //long long sum[MAXT];

From e731aff6b552b9ca3c444cfb601161c878b03780 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Feb 2025 17:22:12 +0800
Subject: [PATCH 0460/1712] modify code

---
 src/class160/Code02_QueryKthMaximum1.java | 2 +-
 src/class160/Code02_QueryKthMaximum2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class160/Code02_QueryKthMaximum1.java b/src/class160/Code02_QueryKthMaximum1.java
index 4a24b7586..54c47fca6 100644
--- a/src/class160/Code02_QueryKthMaximum1.java
+++ b/src/class160/Code02_QueryKthMaximum1.java
@@ -5,8 +5,8 @@
 // 操作 1 l r v : 数字v放入编号范围[l,r]的每一个集合中
 // 操作 2 l r k : 编号范围[l,r]的所有集合，如果生成不去重的并集，返回第k大的数字
 // 1 <= n、m <= 5 * 10^4
+// -n <= v <= +n
 // 1 <= k < 2^63，题目保证第k大的数字一定存在
-// 注意，测试用例里增加了Hack数据，v可能是很大的数字
 // 测试链接 : https://www.luogu.com.cn/problem/P3332
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class160/Code02_QueryKthMaximum2.java b/src/class160/Code02_QueryKthMaximum2.java
index 8a634362d..a8fbd7c68 100644
--- a/src/class160/Code02_QueryKthMaximum2.java
+++ b/src/class160/Code02_QueryKthMaximum2.java
@@ -5,8 +5,8 @@
 // 操作 1 l r v : 数字v放入编号范围[l,r]的每一个集合中
 // 操作 2 l r k : 编号范围[l,r]的所有集合，如果生成不去重的并集，返回第k大的数字
 // 1 <= n、m <= 5 * 10^4
+// -n <= v <= +n
 // 1 <= k < 2^63，题目保证第k大的数字一定存在
-// 注意，测试用例里增加了Hack数据，v可能是很大的数字
 // 测试链接 : https://www.luogu.com.cn/problem/P3332
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From ffc1cd818899db8beba703f7e21d8a8b3d776f38 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Feb 2025 10:34:22 +0800
Subject: [PATCH 0461/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced1.java | 6 +++---
 src/class160/Code03_SegmentWithBalanced2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index e594a2ad4..ee110d112 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -98,13 +98,13 @@ public static int innerBuild(int l, int r) {
 		return h;
 	}
 
-	public static int innerRebuild(int i) {
+	public static int innerRebuild(int h) {
 		if (top != 0) {
 			ci = 0;
 			inorder(top);
 			if (ci > 0) {
 				if (father == 0) {
-					i = innerBuild(1, ci);
+					h = innerBuild(1, ci);
 				} else if (side == 1) {
 					left[father] = innerBuild(1, ci);
 				} else {
@@ -112,7 +112,7 @@ public static int innerRebuild(int i) {
 				}
 			}
 		}
-		return i;
+		return h;
 	}
 
 	public static int innerInsert(int num, int i, int f, int s) {
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 5e6318480..4a23ce150 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -69,13 +69,13 @@
 //    return h;
 //}
 //
-//int innerRebuild(int i) {
+//int innerRebuild(int h) {
 //    if (top) {
 //        ci = 0;
 //        inorder(top);
 //        if (ci > 0) {
 //            if (father == 0) {
-//                i = innerBuild(1, ci);
+//                h = innerBuild(1, ci);
 //            } else if (side == 1) {
 //            	ls[father] = innerBuild(1, ci);
 //            } else {
@@ -83,7 +83,7 @@
 //            }
 //        }
 //    }
-//    return i;
+//    return h;
 //}
 //
 //int innerInsert(int num, int i, int f, int s) {

From 8ef3cf35490267cbcf96265c4da9a623bad7eebf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Feb 2025 17:07:44 +0800
Subject: [PATCH 0462/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced1.java | 17 ++++++++++-------
 src/class160/Code03_SegmentWithBalanced2.java | 10 +++++-----
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index ee110d112..2724d5aa6 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -208,14 +208,15 @@ public static int innerRemove(int num, int i) {
 		return i;
 	}
 
-	public static void build(int l, int r, int i) {
-		for (int j = l; j <= r; j++) {
-			root[i] = innerInsert(arr[j], root[i]);
-		}
+	public static void add(int jobi, int jobv, int l, int r, int i) {
+		root[i] = innerInsert(jobv, root[i]);
 		if (l < r) {
 			int mid = (l + r) >> 1;
-			build(l, mid, i << 1);
-			build(mid + 1, r, i << 1 | 1);
+			if (jobi <= mid) {
+				add(jobi, jobv, l, mid, i << 1);
+			} else {
+				add(jobi, jobv, mid + 1, r, i << 1 | 1);
+			}
 		}
 	}
 
@@ -303,7 +304,9 @@ public static void main(String[] args) throws IOException {
 			in.nextToken();
 			arr[i] = (int) in.nval;
 		}
-		build(1, n, 1);
+		for (int i = 1; i <= n; i++) {
+			add(i, arr[i], 1, n, 1);
+		}
 		for (int i = 1, op, x, y, z; i <= m; i++) {
 			in.nextToken();
 			op = (int) in.nval;
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 4a23ce150..6b9dc5144 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -167,12 +167,12 @@
 //    return i;
 //}
 //
-//void build(int l, int r, int i) {
-//    for (int j = l; j <= r; j++) root[i] = innerInsert(arr[j], root[i]);
+//void add(int jobi, int jobv, int l, int r, int i) {
+//	root[i] = innerInsert(jobv, root[i]);
 //    if (l < r) {
 //        int mid = (l + r) >> 1;
-//        build(l, mid, i << 1);
-//        build(mid + 1, r, i << 1 | 1);
+//        if (jobi <= mid) add(jobi, jobv, l, mid, i << 1);
+//        else add(jobi, jobv, mid + 1, r, i << 1 | 1);
 //    }
 //}
 //
@@ -229,7 +229,7 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for(int i = 1; i <= n; i++) cin >> arr[i];
-//    build(1, n, 1);
+//    for(int i = 1; i <= n; i++) add(i, arr[i], 1, n, 1);
 //    for(int i = 1, op, x, y, z; i <= m; i++) {
 //        cin >> op >> x >> y;
 //        if(op == 3) {

From 6e190a334ac65d0bf01b6ee5c6c4eb108f65a188 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Feb 2025 17:14:55 +0800
Subject: [PATCH 0463/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced1.java | 2 +-
 src/class160/Code03_SegmentWithBalanced2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index 2724d5aa6..fcc7efed9 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -252,7 +252,7 @@ public static int number(int jobl, int jobr, int jobk) {
 		int l = 0, r = 100000000, mid, ans = 0;
 		while (l <= r) {
 			mid = (l + r) >> 1;
-			if (small(jobl, jobr, mid + 1, 1, n, 1) >= jobk) {
+			if (small(jobl, jobr, mid + 1, 1, n, 1) + 1 > jobk) {
 				ans = mid;
 				r = mid - 1;
 			} else {
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 6b9dc5144..569fa0578 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -198,7 +198,7 @@
 //    int l = 0, r = 100000000, mid, ans = 0;
 //    while (l <= r) {
 //        mid = (l + r) >> 1;
-//        if (small(jobl, jobr, mid + 1, 1, n, 1) >= jobk) {
+//        if (small(jobl, jobr, mid + 1, 1, n, 1) + 1 > jobk) {
 //            ans = mid;
 //            r = mid - 1;
 //        } else {

From 0dec580006e074be467169c10995773d0d5f4883 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Feb 2025 19:31:54 +0800
Subject: [PATCH 0464/1712] modify code

---
 src/class160/Code03_SegmentWithBalanced1.java | 15 +++++++++++----
 src/class160/Code03_SegmentWithBalanced2.java |  6 +++---
 2 files changed, 14 insertions(+), 7 deletions(-)

diff --git a/src/class160/Code03_SegmentWithBalanced1.java b/src/class160/Code03_SegmentWithBalanced1.java
index fcc7efed9..a52a2ae3a 100644
--- a/src/class160/Code03_SegmentWithBalanced1.java
+++ b/src/class160/Code03_SegmentWithBalanced1.java
@@ -136,6 +136,8 @@ public static int innerInsert(int num, int i, int f, int s) {
 		return i;
 	}
 
+	// 平衡树当前来到i号节点，把num这个数字插入
+	// 返回头节点编号
 	public static int innerInsert(int num, int i) {
 		top = father = side = 0;
 		i = innerInsert(num, i, 0, 0);
@@ -143,6 +145,7 @@ public static int innerInsert(int num, int i) {
 		return i;
 	}
 
+	// 平衡树当前来到i号节点，返回<num的数字个数
 	public static int innerSmall(int num, int i) {
 		if (i == 0) {
 			return 0;
@@ -154,6 +157,7 @@ public static int innerSmall(int num, int i) {
 		}
 	}
 
+	// 平衡树当前来到i号节点，返回第index小的数字
 	public static int innerIndex(int index, int i) {
 		int leftsize = size[left[i]];
 		if (leftsize >= index) {
@@ -165,6 +169,7 @@ public static int innerIndex(int index, int i) {
 		}
 	}
 
+	// 平衡树当前来到i号节点，返回num的前驱
 	public static int innerPre(int num, int i) {
 		int kth = innerSmall(num, i) + 1;
 		if (kth == 1) {
@@ -174,12 +179,13 @@ public static int innerPre(int num, int i) {
 		}
 	}
 
+	// 平衡树当前来到i号节点，返回num的后继
 	public static int innerPost(int num, int i) {
-		int kth = innerSmall(num + 1, i);
-		if (kth == size[i]) {
+		int k = innerSmall(num + 1, i);
+		if (k == size[i]) {
 			return INF;
 		} else {
-			return innerIndex(kth + 1, i);
+			return innerIndex(k + 1, i);
 		}
 	}
 
@@ -251,7 +257,8 @@ public static int small(int jobl, int jobr, int jobv, int l, int r, int i) {
 	public static int number(int jobl, int jobr, int jobk) {
 		int l = 0, r = 100000000, mid, ans = 0;
 		while (l <= r) {
-			mid = (l + r) >> 1;
+			mid = (l + r) >> 1; 
+		    // mid + 1 名次 > jobk
 			if (small(jobl, jobr, mid + 1, 1, n, 1) + 1 > jobk) {
 				ans = mid;
 				r = mid - 1;
diff --git a/src/class160/Code03_SegmentWithBalanced2.java b/src/class160/Code03_SegmentWithBalanced2.java
index 569fa0578..2456a85d4 100644
--- a/src/class160/Code03_SegmentWithBalanced2.java
+++ b/src/class160/Code03_SegmentWithBalanced2.java
@@ -137,9 +137,9 @@
 //}
 //
 //int innerPost(int num, int i) {
-//    int kth = innerSmall(num + 1, i);
-//    if (kth == siz[i]) return INF;
-//    return innerIndex(kth + 1, i);
+//    int k = innerSmall(num + 1, i);
+//    if (k == siz[i]) return INF;
+//    return innerIndex(k + 1, i);
 //}
 //
 //void innerRemove(int num, int i, int f, int s) {

From c6d0bc3899dc1d4ace2171f6217e14ae66a591d8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Feb 2025 21:36:06 +0800
Subject: [PATCH 0465/1712] modify code

---
 src/class160/Code04_IndexWithSegment1.java | 59 +++++++++++++---------
 src/class160/Code04_IndexWithSegment2.java |  6 +--
 2 files changed, 38 insertions(+), 27 deletions(-)

diff --git a/src/class160/Code04_IndexWithSegment1.java b/src/class160/Code04_IndexWithSegment1.java
index 7b5eaaf0f..ce330ca11 100644
--- a/src/class160/Code04_IndexWithSegment1.java
+++ b/src/class160/Code04_IndexWithSegment1.java
@@ -73,6 +73,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
+	// 第jobi小的数字，增加jobv的计数，数字范围l~r，节点编号i，返回头节点编号
 	public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
 		if (i == 0) {
 			i = ++cntt;
@@ -91,76 +92,83 @@ public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
 		return i;
 	}
 
-	public static int innerQuery(int jobk, int l, int r) {
+	// 查询比jobi小的数字个数，数字范围l~r
+	// 不需要头节点编号，因为有多棵树，所有的头节点记录在addTree、minusTree
+	public static int innerSmall(int jobi, int l, int r) {
 		if (l == r) {
-			return l;
+			return 0;
 		}
 		int mid = (l + r) / 2;
-		int leftsum = 0;
-		for (int i = 1; i <= cntadd; i++) {
-			leftsum += sum[left[addTree[i]]];
-		}
-		for (int i = 1; i <= cntminus; i++) {
-			leftsum -= sum[left[minusTree[i]]];
-		}
-		if (jobk <= leftsum) {
+		if (jobi <= mid) {
 			for (int i = 1; i <= cntadd; i++) {
 				addTree[i] = left[addTree[i]];
 			}
 			for (int i = 1; i <= cntminus; i++) {
 				minusTree[i] = left[minusTree[i]];
 			}
-			return innerQuery(jobk, l, mid);
+			return innerSmall(jobi, l, mid);
 		} else {
+			int leftsum = 0;
 			for (int i = 1; i <= cntadd; i++) {
+				leftsum += sum[left[addTree[i]]];
 				addTree[i] = right[addTree[i]];
 			}
 			for (int i = 1; i <= cntminus; i++) {
+				leftsum -= sum[left[minusTree[i]]];
 				minusTree[i] = right[minusTree[i]];
 			}
-			return innerQuery(jobk - leftsum, mid + 1, r);
+			return leftsum + innerSmall(jobi, mid + 1, r);
 		}
 	}
 
-	public static int innerSmall(int jobi, int l, int r) {
+	// 查询第jobk小的数字，数字范围l~r
+	// 不需要头节点编号，因为有多棵树，所有的头节点记录在addTree、minusTree
+	public static int innerQuery(int jobk, int l, int r) {
 		if (l == r) {
-			return 0;
+			return l;
 		}
 		int mid = (l + r) / 2;
-		if (jobi <= mid) {
+		int leftsum = 0;
+		for (int i = 1; i <= cntadd; i++) {
+			leftsum += sum[left[addTree[i]]];
+		}
+		for (int i = 1; i <= cntminus; i++) {
+			leftsum -= sum[left[minusTree[i]]];
+		}
+		if (jobk <= leftsum) {
 			for (int i = 1; i <= cntadd; i++) {
 				addTree[i] = left[addTree[i]];
 			}
 			for (int i = 1; i <= cntminus; i++) {
 				minusTree[i] = left[minusTree[i]];
 			}
-			return innerSmall(jobi, l, mid);
+			return innerQuery(jobk, l, mid);
 		} else {
-			int leftsum = 0;
 			for (int i = 1; i <= cntadd; i++) {
-				leftsum += sum[left[addTree[i]]];
 				addTree[i] = right[addTree[i]];
 			}
 			for (int i = 1; i <= cntminus; i++) {
-				leftsum -= sum[left[minusTree[i]]];
 				minusTree[i] = right[minusTree[i]];
 			}
-			return leftsum + innerSmall(jobi, mid + 1, r);
+			return innerQuery(jobk - leftsum, mid + 1, r);
 		}
 	}
 
+	// arr中i下标的数字，增加cnt的计数
 	public static void add(int i, int cnt) {
 		for (int j = i; j <= n; j += lowbit(j)) {
 			root[j] = innerAdd(arr[i], cnt, 1, s, root[j]);
 		}
 	}
 
+	// arr中i下标的数字，改成v
 	public static void update(int i, int v) {
 		add(i, -1);
 		arr[i] = kth(v);
 		add(i, 1);
 	}
 
+	// arr[l..r]范围上，比v小的数字个数
 	public static int small(int l, int r, int v) {
 		cntadd = cntminus = 0;
 		for (int i = r; i > 0; i -= lowbit(i)) {
@@ -172,6 +180,7 @@ public static int small(int l, int r, int v) {
 		return innerSmall(v, 1, s);
 	}
 
+	// arr[l..r]范围上，查询第k小的数字是什么
 	public static int number(int l, int r, int k) {
 		cntadd = cntminus = 0;
 		for (int i = r; i > 0; i -= lowbit(i)) {
@@ -183,6 +192,7 @@ public static int number(int l, int r, int k) {
 		return sorted[innerQuery(k, 1, s)];
 	}
 
+	// arr[l..r]范围上，查询v的前驱
 	public static int pre(int l, int r, int v) {
 		int rank = small(l, r, v) + 1;
 		if (rank == 1) {
@@ -191,15 +201,16 @@ public static int pre(int l, int r, int v) {
 		return number(l, r, rank - 1);
 	}
 
+	// arr[l..r]范围上，查询v的后继
 	public static int post(int l, int r, int v) {
 		if (v == s) {
 			return INF;
 		}
-		int rank = small(l, r, v + 1) + 1;
-		if (rank == r - l + 2) {
+		int sml = small(l, r, v + 1);
+		if (sml == r - l + 1) {
 			return INF;
 		}
-		return number(l, r, rank);
+		return number(l, r, sml + 1);
 	}
 
 	public static void prepare() {
@@ -224,7 +235,7 @@ public static void prepare() {
 		s = len;
 		for (int i = 1; i <= n; i++) {
 			arr[i] = kth(arr[i]);
-			add(i, 1);
+			add(i, 1); // arr中i位置的数字，增加1个词频
 		}
 	}
 
diff --git a/src/class160/Code04_IndexWithSegment2.java b/src/class160/Code04_IndexWithSegment2.java
index a9a4b7589..3f0e9ac5d 100644
--- a/src/class160/Code04_IndexWithSegment2.java
+++ b/src/class160/Code04_IndexWithSegment2.java
@@ -175,11 +175,11 @@
 //    if (v == s) {
 //        return INF;
 //    }
-//    int rank = small(l, r, v + 1) + 1;
-//    if (rank == r - l + 2) {
+//    int sml = small(l, r, v + 1);
+//    if (sml == r - l + 1) {
 //        return INF;
 //    }
-//    return number(l, r, rank);
+//    return number(l, r, sml + 1);
 //}
 //
 //void prepare() {

From 8f5bbfbf1bbc63433023076530eec6c85cc36f08 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Feb 2025 21:46:01 +0800
Subject: [PATCH 0466/1712] modify code

---
 src/class160/Code06_LineUp1.java | 12 ++++++------
 src/class160/Code06_LineUp2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class160/Code06_LineUp1.java b/src/class160/Code06_LineUp1.java
index a78d7579e..c93829c03 100644
--- a/src/class160/Code06_LineUp1.java
+++ b/src/class160/Code06_LineUp1.java
@@ -100,7 +100,7 @@ public static int innerQuery(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
-	public static void insert(int i, int v) {
+	public static void add(int i, int v) {
 		for (int j = i; j <= n; j += lowbit(j)) {
 			root[j] = innerAdd(arr[i], v, 1, s, root[j]);
 		}
@@ -134,7 +134,7 @@ public static void prepare() {
 		s = len;
 		for (int i = 1; i <= n; i++) {
 			arr[i] = kth(arr[i]);
-			insert(i, 1);
+			add(i, 1);
 		}
 	}
 
@@ -148,13 +148,13 @@ public static void compute(int a, int b) {
 		} else if (arr[a] > arr[b]) {
 			ans--;
 		}
-		insert(a, -1);
-		insert(b, -1);
+		add(a, -1);
+		add(b, -1);
 		int tmp = arr[a];
 		arr[a] = arr[b];
 		arr[b] = tmp;
-		insert(a, 1);
-		insert(b, 1);
+		add(a, 1);
+		add(b, 1);
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class160/Code06_LineUp2.java b/src/class160/Code06_LineUp2.java
index e52766dab..0ab753045 100644
--- a/src/class160/Code06_LineUp2.java
+++ b/src/class160/Code06_LineUp2.java
@@ -74,7 +74,7 @@
 //    return ans;
 //}
 //
-//void insert(int i, int v) {
+//void add(int i, int v) {
 //    for (int j = i; j <= n; j += lowbit(j)) {
 //        root[j] = innerAdd(arr[i], v, 1, s, root[j]);
 //    }
@@ -104,7 +104,7 @@
 //    s = len;
 //    for (int i = 1; i <= n; i++) {
 //        arr[i] = kth(arr[i]);
-//        insert(i, 1);
+//        add(i, 1);
 //    }
 //}
 //
@@ -115,11 +115,11 @@
 //    ans += query(a + 1, b - 1, 1, arr[b] - 1);
 //    if (arr[a] < arr[b]) ans++;
 //    else if (arr[a] > arr[b]) ans--;
-//    insert(a, -1);
-//    insert(b, -1);
+//    add(a, -1);
+//    add(b, -1);
 //    swap(arr[a], arr[b]);
-//    insert(a, 1);
-//    insert(b, 1);
+//    add(a, 1);
+//    add(b, 1);
 //}
 //
 //int main() {

From 392c33e2241c1fbb8615d6b9833e05680d15d06c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Feb 2025 23:02:35 +0800
Subject: [PATCH 0467/1712] modify code

---
 src/class160/Code06_LineUp1.java | 45 ++++++++++++++++++--------------
 src/class160/Code06_LineUp2.java | 28 ++++++++++----------
 2 files changed, 40 insertions(+), 33 deletions(-)

diff --git a/src/class160/Code06_LineUp1.java b/src/class160/Code06_LineUp1.java
index c93829c03..6840e0be8 100644
--- a/src/class160/Code06_LineUp1.java
+++ b/src/class160/Code06_LineUp1.java
@@ -64,6 +64,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
+	// 线段树单点修改，jobi这个数字词频增加jobv
 	public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
 		if (i == 0) {
 			i = ++cnt;
@@ -82,6 +83,8 @@ public static int innerAdd(int jobi, int jobv, int l, int r, int i) {
 		return i;
 	}
 
+	// 查询的数字范围[jobl...jobr]，线段树的数字范围[l..r]，节点编号i
+	// 返回有多少词频
 	public static int innerQuery(int jobl, int jobr, int l, int r, int i) {
 		if (i == 0) {
 			return 0;
@@ -100,12 +103,14 @@ public static int innerQuery(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
+	// arr的i位置的数字，词频增加v
 	public static void add(int i, int v) {
 		for (int j = i; j <= n; j += lowbit(j)) {
 			root[j] = innerAdd(arr[i], v, 1, s, root[j]);
 		}
 	}
 
+	// arr[al..ar]范围上，有多少数字在[numl..numr]范围上
 	public static int query(int al, int ar, int numl, int numr) {
 		int ans = 0;
 		for (int i = ar; i > 0; i -= lowbit(i)) {
@@ -117,6 +122,27 @@ public static int query(int al, int ar, int numl, int numr) {
 		return ans;
 	}
 
+	// 交换a和b位置的数字，保证a在前，b在后
+	// 修正好逆序对的数量ans
+	public static void compute(int a, int b) {
+		ans -= query(a + 1, b - 1, 1, arr[a] - 1);
+		ans += query(a + 1, b - 1, arr[a] + 1, s);
+		ans -= query(a + 1, b - 1, arr[b] + 1, s);
+		ans += query(a + 1, b - 1, 1, arr[b] - 1);
+		if (arr[a] < arr[b]) {
+			ans++;
+		} else if (arr[a] > arr[b]) {
+			ans--;
+		}
+		add(a, -1);
+		add(b, -1);
+		int tmp = arr[a];
+		arr[a] = arr[b];
+		arr[b] = tmp;
+		add(a, 1);
+		add(b, 1);
+	}
+
 	public static void prepare() {
 		s = 0;
 		for (int i = 1; i <= n; i++) {
@@ -138,25 +164,6 @@ public static void prepare() {
 		}
 	}
 
-	public static void compute(int a, int b) {
-		ans -= query(a + 1, b - 1, 1, arr[a] - 1);
-		ans += query(a + 1, b - 1, arr[a] + 1, s);
-		ans -= query(a + 1, b - 1, arr[b] + 1, s);
-		ans += query(a + 1, b - 1, 1, arr[b] - 1);
-		if (arr[a] < arr[b]) {
-			ans++;
-		} else if (arr[a] > arr[b]) {
-			ans--;
-		}
-		add(a, -1);
-		add(b, -1);
-		int tmp = arr[a];
-		arr[a] = arr[b];
-		arr[b] = tmp;
-		add(a, 1);
-		add(b, 1);
-	}
-
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
diff --git a/src/class160/Code06_LineUp2.java b/src/class160/Code06_LineUp2.java
index 0ab753045..686211baa 100644
--- a/src/class160/Code06_LineUp2.java
+++ b/src/class160/Code06_LineUp2.java
@@ -91,6 +91,20 @@
 //    return ans;
 //}
 //
+//void compute(int a, int b) {
+//    ans -= query(a + 1, b - 1, 1, arr[a] - 1);
+//    ans += query(a + 1, b - 1, arr[a] + 1, s);
+//    ans -= query(a + 1, b - 1, arr[b] + 1, s);
+//    ans += query(a + 1, b - 1, 1, arr[b] - 1);
+//    if (arr[a] < arr[b]) ans++;
+//    else if (arr[a] > arr[b]) ans--;
+//    add(a, -1);
+//    add(b, -1);
+//    swap(arr[a], arr[b]);
+//    add(a, 1);
+//    add(b, 1);
+//}
+//
 //void prepare() {
 //    s = 0;
 //    for (int i = 1; i <= n; i++) sorted[++s] = arr[i];
@@ -108,20 +122,6 @@
 //    }
 //}
 //
-//void compute(int a, int b) {
-//    ans -= query(a + 1, b - 1, 1, arr[a] - 1);
-//    ans += query(a + 1, b - 1, arr[a] + 1, s);
-//    ans -= query(a + 1, b - 1, arr[b] + 1, s);
-//    ans += query(a + 1, b - 1, 1, arr[b] - 1);
-//    if (arr[a] < arr[b]) ans++;
-//    else if (arr[a] > arr[b]) ans--;
-//    add(a, -1);
-//    add(b, -1);
-//    swap(arr[a], arr[b]);
-//    add(a, 1);
-//    add(b, 1);
-//}
-//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);

From b7113495feedd78d6469754b197db34497c78e24 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 22 Feb 2025 00:16:42 +0800
Subject: [PATCH 0468/1712] modify code

---
 ...70\345\205\263\351\242\230\347\233\256.pptx" | Bin 0 -> 52122 bytes
 src/class160/Code07_NetworkManagement1.java     |   7 ++++---
 src/class160/Code07_NetworkManagement2.java     |   4 ++--
 3 files changed, 6 insertions(+), 5 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243160\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\345\245\227\346\240\221\347\232\204\345\216\237\347\220\206\343\200\201\344\274\230\345\214\226\343\200\201\347\233\270\345\205\263\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243160\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\345\245\227\346\240\221\347\232\204\345\216\237\347\220\206\343\200\201\344\274\230\345\214\226\343\200\201\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243160\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\345\245\227\346\240\221\347\232\204\345\216\237\347\220\206\343\200\201\344\274\230\345\214\226\343\200\201\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..d3ea4445694fe7be19e66f42b37c90030faf783f
GIT binary patch
literal 52122
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
K6C`zK-~JD@apATA

literal 0
HcmV?d00001

diff --git a/src/class160/Code07_NetworkManagement1.java b/src/class160/Code07_NetworkManagement1.java
index 868f32f8c..0e0a9199f 100644
--- a/src/class160/Code07_NetworkManagement1.java
+++ b/src/class160/Code07_NetworkManagement1.java
@@ -44,7 +44,7 @@ public class Code07_NetworkManagement1 {
 
 	public static int cntg = 0;
 
-	// 注意这不是主席树！而是若干棵动态开点权值线段树！
+	// 外层的树状数组
 	public static int[] root = new int[MAXN];
 
 	public static int[] left = new int[MAXT];
@@ -245,9 +245,10 @@ public static int innerQuery(int jobk, int l, int r) {
 		}
 	}
 
-	public static void add(int i, int kth, int val) {
+	// i是dfn序号，val这是值，增加cnt的计数
+	public static void add(int i, int val, int cnt) {
 		for (; i <= n; i += lowbit(i)) {
-			root[i] = innerAdd(kth, val, 1, s, root[i]);
+			root[i] = innerAdd(val, cnt, 1, s, root[i]);
 		}
 	}
 
diff --git a/src/class160/Code07_NetworkManagement2.java b/src/class160/Code07_NetworkManagement2.java
index 540f3b2d8..b29cb49dd 100644
--- a/src/class160/Code07_NetworkManagement2.java
+++ b/src/class160/Code07_NetworkManagement2.java
@@ -145,9 +145,9 @@
 //    }
 //}
 //
-//void add(int i, int kth, int val) {
+//void add(int i, int val, int cnt) {
 //    for (; i <= n; i += lowbit(i)) {
-//        root[i] = innerAdd(kth, val, 1, s, root[i]);
+//        root[i] = innerAdd(val, cnt, 1, s, root[i]);
 //    }
 //}
 //

From 64cd35fd605e89c4fc55cb0495c0c37db224f655 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 25 Feb 2025 11:59:15 +0800
Subject: [PATCH 0469/1712] modify code

---
 src/class090/Code03_MeetingMonopoly1.java | 20 +++++++++++++++++++-
 src/class090/Code03_MeetingMonopoly2.java |  2 +-
 2 files changed, 20 insertions(+), 2 deletions(-)

diff --git a/src/class090/Code03_MeetingMonopoly1.java b/src/class090/Code03_MeetingMonopoly1.java
index 657936105..018220812 100644
--- a/src/class090/Code03_MeetingMonopoly1.java
+++ b/src/class090/Code03_MeetingMonopoly1.java
@@ -6,9 +6,27 @@
 // 给定若干会议的开始、结束时间
 // 你参加某个会议的期间，不能参加其他会议
 // 返回你能参加的最大会议数量
-// 来自真实大厂笔试，没有在线测试，对数器验证
+// 同学找到了Leetcode的在线测试，题意类似
+// 测试链接 :https://leetcode.cn/problems/non-overlapping-intervals/
 public class Code03_MeetingMonopoly1 {
 
+	// 测试链接 :https://leetcode.cn/problems/non-overlapping-intervals/
+	// 测试链接中，问至少删除多少会议，可以让剩下的会议都不重合
+	// 那么求出，最多能不重合的参加多少会议，然后 n - 这个数量，就是答案
+	// 同时注意，测试链接中，会议的时间点范围[- 5 * 10 ^ 4 ~ + 5 * 10 ^ 4]
+	public static int eraseOverlapIntervals(int[][] meeting) {
+		Arrays.sort(meeting, (a, b) -> a[1] - b[1]);
+		int n = meeting.length;
+		int ans = 0;
+		for (int i = 0, cur = -50001; i < n; i++) {
+			if (cur <= meeting[i][0]) {
+				ans++;
+				cur = meeting[i][1];
+			}
+		}
+		return n - ans;
+	}
+
 	// 暴力方法
 	// 为了验证
 	// 时间复杂度O(n!)
diff --git a/src/class090/Code03_MeetingMonopoly2.java b/src/class090/Code03_MeetingMonopoly2.java
index 19cc23f0c..107c36ca4 100644
--- a/src/class090/Code03_MeetingMonopoly2.java
+++ b/src/class090/Code03_MeetingMonopoly2.java
@@ -1,6 +1,6 @@
 package class090;
 
-// 同学找到了在线测试，看似是题目3，其实不是
+// 同学找到了洛谷的在线测试，看似是题目3，其实不是
 // 区别在于数据量，如下测试链接中的题目
 // 会议的数量10^6，会议的开始、结束时间也是10^6
 // 排序会超时，C++的同学可能不会，但是java的同学会

From ec85e539ccdec082ede420aa1d890a81d12d40b1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 25 Feb 2025 12:03:23 +0800
Subject: [PATCH 0470/1712] modify code

---
 src/class090/Code03_MeetingMonopoly1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class090/Code03_MeetingMonopoly1.java b/src/class090/Code03_MeetingMonopoly1.java
index 018220812..b091494d8 100644
--- a/src/class090/Code03_MeetingMonopoly1.java
+++ b/src/class090/Code03_MeetingMonopoly1.java
@@ -14,16 +14,19 @@ public class Code03_MeetingMonopoly1 {
 	// 测试链接中，问至少删除多少会议，可以让剩下的会议都不重合
 	// 那么求出，最多能不重合的参加多少会议，然后 n - 这个数量，就是答案
 	// 同时注意，测试链接中，会议的时间点范围[- 5 * 10 ^ 4 ~ + 5 * 10 ^ 4]
+	// 其实就是课上讲的方法，稍微改动一下即可，改动的地方已经加上注释
 	public static int eraseOverlapIntervals(int[][] meeting) {
 		Arrays.sort(meeting, (a, b) -> a[1] - b[1]);
 		int n = meeting.length;
 		int ans = 0;
+		// cur初始设置为-50001，因为题目数据状况如此
 		for (int i = 0, cur = -50001; i < n; i++) {
 			if (cur <= meeting[i][0]) {
 				ans++;
 				cur = meeting[i][1];
 			}
 		}
+		// 会议总数 - 参加的最大会议数量
 		return n - ans;
 	}
 

From b9d6f4f2a7411f81a5c11d1df1a6b80004b92a79 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 25 Feb 2025 17:05:20 +0800
Subject: [PATCH 0471/1712] modify code

---
 .../Code01_HeavyLightDecompositionLCA1.java   | 201 ++++++++++++++++++
 .../Code01_HeavyLightDecompositionLCA2.java   |  92 ++++++++
 2 files changed, 293 insertions(+)
 create mode 100644 src/class161/Code01_HeavyLightDecompositionLCA1.java
 create mode 100644 src/class161/Code01_HeavyLightDecompositionLCA2.java

diff --git a/src/class161/Code01_HeavyLightDecompositionLCA1.java b/src/class161/Code01_HeavyLightDecompositionLCA1.java
new file mode 100644
index 000000000..64940589d
--- /dev/null
+++ b/src/class161/Code01_HeavyLightDecompositionLCA1.java
@@ -0,0 +1,201 @@
+package class161;
+
+// 树链剖分解决LCA查询，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3379
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_HeavyLightDecompositionLCA1 {
+
+	public static int MAXN = 500001;
+
+	public static int n, m, root;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cnt;
+
+	public static int[] fa = new int[MAXN];
+
+	public static int[] dep = new int[MAXN];
+
+	public static int[] siz = new int[MAXN];
+
+	public static int[] son = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				if (v == son[u]) {
+					dfs2(v, t);
+				} else {
+					dfs2(v, v);
+				}
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(root, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(root, root, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first]) {
+					if (to[edge] == son[first]) {
+						push(to[edge], second, -1);
+					} else {
+						push(to[edge], to[edge], -1);
+					}
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		while (top[a] != top[b]) {
+			if (dep[top[a]] >= dep[top[b]]) {
+				a = fa[top[a]];
+			} else {
+				b = fa[top[b]];
+			}
+		}
+		return dep[a] <= dep[b] ? a : b;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		in.nextToken();
+		root = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs3(); // dfs3() 等同于 dfs1(root, 0)，调用迭代版防止爆栈
+		dfs4(); // dfs4() 等同于 dfs2(root, root)，调用迭代版防止爆栈
+		for (int i = 1, a, b; i <= m; i++) {
+			in.nextToken();
+			a = (int) in.nval;
+			in.nextToken();
+			b = (int) in.nval;
+			out.println(lca(a, b));
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class161/Code01_HeavyLightDecompositionLCA2.java b/src/class161/Code01_HeavyLightDecompositionLCA2.java
new file mode 100644
index 000000000..fdf55e172
--- /dev/null
+++ b/src/class161/Code01_HeavyLightDecompositionLCA2.java
@@ -0,0 +1,92 @@
+package class161;
+
+// 树链剖分解决LCA查询，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3379
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//int n, m, root;
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt;
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            if (v == son[u]) {
+//                dfs2(v, t);
+//            } else {
+//                dfs2(v, v);
+//            }
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    while (top[a] != top[b]) {
+//        if (dep[top[a]] >= dep[top[b]]) {
+//            a = fa[top[a]];
+//        } else {
+//            b = fa[top[b]];
+//        }
+//    }
+//    return dep[a] <= dep[b] ? a : b;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> root;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(root, 0);
+//    dfs2(root, root);
+//    for (int i = 1, a, b; i <= m; i++) {
+//        cin >> a >> b;
+//        cout << lca(a, b) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 5c259d9b7c340fe074a847a20e37490e13c87440 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 25 Feb 2025 21:46:14 +0800
Subject: [PATCH 0472/1712] modify code

---
 .../Code01_HeavyLightDecompositionLCA1.java   |  39 +-
 .../Code01_HeavyLightDecompositionLCA2.java   |  20 +-
 src/class161/Code02_HLD1.java                 | 341 ++++++++++++++++++
 src/class161/Code02_HLD2.java                 | 209 +++++++++++
 4 files changed, 581 insertions(+), 28 deletions(-)
 create mode 100644 src/class161/Code02_HLD1.java
 create mode 100644 src/class161/Code02_HLD2.java

diff --git a/src/class161/Code01_HeavyLightDecompositionLCA1.java b/src/class161/Code01_HeavyLightDecompositionLCA1.java
index 64940589d..6ff87e69f 100644
--- a/src/class161/Code01_HeavyLightDecompositionLCA1.java
+++ b/src/class161/Code01_HeavyLightDecompositionLCA1.java
@@ -23,7 +23,7 @@ public class Code01_HeavyLightDecompositionLCA1 {
 
 	public static int[] to = new int[MAXN << 1];
 
-	public static int cnt;
+	public static int cnt = 0;
 
 	public static int[] fa = new int[MAXN];
 
@@ -66,14 +66,14 @@ public static void dfs1(int u, int f) {
 	// 递归版，C++可以通过，java会爆栈
 	public static void dfs2(int u, int t) {
 		top[u] = t;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
-			if (v != fa[u]) {
-				if (v == son[u]) {
-					dfs2(v, t);
-				} else {
-					dfs2(v, v);
-				}
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
 			}
 		}
 	}
@@ -136,20 +136,23 @@ public static void dfs4() {
 		push(root, root, -1);
 		while (stacksize > 0) {
 			pop();
-			if (edge == -1) {
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
 				top[first] = second;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
 				edge = head[first];
-			} else {
+			} else { // edge >= 0, 继续处理其他的边
 				edge = next[edge];
 			}
 			if (edge != 0) {
 				push(first, second, edge);
-				if (to[edge] != fa[first]) {
-					if (to[edge] == son[first]) {
-						push(to[edge], second, -1);
-					} else {
-						push(to[edge], to[edge], -1);
-					}
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
 				}
 			}
 		}
@@ -157,10 +160,10 @@ public static void dfs4() {
 
 	public static int lca(int a, int b) {
 		while (top[a] != top[b]) {
-			if (dep[top[a]] >= dep[top[b]]) {
-				a = fa[top[a]];
-			} else {
+			if (dep[top[a]] <= dep[top[b]]) {
 				b = fa[top[b]];
+			} else {
+				a = fa[top[a]];
 			}
 		}
 		return dep[a] <= dep[b] ? a : b;
diff --git a/src/class161/Code01_HeavyLightDecompositionLCA2.java b/src/class161/Code01_HeavyLightDecompositionLCA2.java
index fdf55e172..033ccc8d0 100644
--- a/src/class161/Code01_HeavyLightDecompositionLCA2.java
+++ b/src/class161/Code01_HeavyLightDecompositionLCA2.java
@@ -14,7 +14,7 @@
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
-//int cnt;
+//int cnt = 0;
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -50,24 +50,24 @@
 //
 //void dfs2(int u, int t) {
 //    top[u] = t;
+//    if(son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
-//        if (v != fa[u]) {
-//            if (v == son[u]) {
-//                dfs2(v, t);
-//            } else {
-//                dfs2(v, v);
-//            }
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
 //        }
 //    }
 //}
 //
 //int lca(int a, int b) {
 //    while (top[a] != top[b]) {
-//        if (dep[top[a]] >= dep[top[b]]) {
-//            a = fa[top[a]];
-//        } else {
+//        if (dep[top[a]] <= dep[top[b]]) {
 //            b = fa[top[b]];
+//        } else {
+//            a = fa[top[a]];
 //        }
 //    }
 //    return dep[a] <= dep[b] ? a : b;
diff --git a/src/class161/Code02_HLD1.java b/src/class161/Code02_HLD1.java
new file mode 100644
index 000000000..8511af74b
--- /dev/null
+++ b/src/class161/Code02_HLD1.java
@@ -0,0 +1,341 @@
+package class161;
+
+// 树链剖分模版题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3384
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_HLD1 {
+
+	public static int MAXN = 100001;
+
+	public static int n, m, root, MOD;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	public static long[] sum = new long[MAXN << 2];
+
+	public static long[] addTag = new long[MAXN << 2];
+
+	public static int[] fa = new int[MAXN];
+
+	public static int[] dep = new int[MAXN];
+
+	public static int[] siz = new int[MAXN];
+
+	public static int[] son = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int[] val = new int[MAXN];
+
+	public static int cntd = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void up(int i) {
+		sum[i] = (sum[i << 1] + sum[i << 1 | 1]) % MOD;
+	}
+
+	public static void lazy(int i, long v, int n) {
+		sum[i] = (sum[i] + v * n) % MOD;
+		addTag[i] = (addTag[i] + v) % MOD;
+	}
+
+	public static void down(int i, int ln, int rn) {
+		if (addTag[i] != 0) {
+			lazy(i << 1, addTag[i], ln);
+			lazy(i << 1 | 1, addTag[i], rn);
+			addTag[i] = 0;
+		}
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			sum[i] = val[l] % MOD;
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i, jobv, r - l + 1);
+		} else {
+			int mid = (l + r) / 2;
+			down(i, mid - l + 1, r - mid);
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static long query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		down(i, mid - l + 1, r - mid);
+		long ans = 0;
+		if (jobl <= mid) {
+			ans = (ans + query(jobl, jobr, l, mid, i << 1)) % MOD;
+		}
+		if (jobr > mid) {
+			ans = (ans + query(jobl, jobr, mid + 1, r, i << 1 | 1)) % MOD;
+		}
+		return ans;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		val[cntd] = arr[u];
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(root, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(root, root, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				val[cntd] = arr[first];
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void pathAdd(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				add(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				add(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		if (dep[x] <= dep[y]) {
+			add(dfn[x], dfn[y], v, 1, n, 1);
+		} else {
+			add(dfn[y], dfn[x], v, 1, n, 1);
+		}
+	}
+
+	public static void subtreeAdd(int x, int v) {
+		add(dfn[x], dfn[x] + siz[x] - 1, v, 1, n, 1);
+	}
+
+	public static long pathSum(int x, int y) {
+		long ans = 0;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans = (ans + query(dfn[top[y]], dfn[y], 1, n, 1)) % MOD;
+				y = fa[top[y]];
+			} else {
+				ans = (ans + query(dfn[top[x]], dfn[x], 1, n, 1)) % MOD;
+				x = fa[top[x]];
+			}
+		}
+		if (dep[x] <= dep[y]) {
+			ans = (ans + query(dfn[x], dfn[y], 1, n, 1)) % MOD;
+		} else {
+			ans = (ans + query(dfn[y], dfn[x], 1, n, 1)) % MOD;
+		}
+		return ans;
+	}
+
+	public static long subtreeSum(int x) {
+		return query(dfn[x], dfn[x] + siz[x] - 1, 1, n, 1);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		in.nextToken();
+		root = (int) in.nval;
+		in.nextToken();
+		MOD = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs3(); // dfs3() 等同于 dfs1(root, 0)，调用迭代版防止爆栈
+		dfs4(); // dfs4() 等同于 dfs2(root, root)，调用迭代版防止爆栈
+		build(1, n, 1);
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			if (op == 1) {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				in.nextToken();
+				z = (int) in.nval;
+				pathAdd(x, y, z);
+			} else if (op == 2) {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				out.println(pathSum(x, y));
+			} else if (op == 3) {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				subtreeAdd(x, y);
+			} else {
+				in.nextToken();
+				x = (int) in.nval;
+				out.println(subtreeSum(x));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+}
\ No newline at end of file
diff --git a/src/class161/Code02_HLD2.java b/src/class161/Code02_HLD2.java
new file mode 100644
index 000000000..a03f012d4
--- /dev/null
+++ b/src/class161/Code02_HLD2.java
@@ -0,0 +1,209 @@
+package class161;
+
+// 树链剖分模版题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3384
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m, root, MOD;
+//int arr[MAXN];
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//long long sum[MAXN << 2];
+//long long addTag[MAXN << 2];
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int val[MAXN];
+//int cntd = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void up(int i) {
+//    sum[i] = (sum[i << 1] + sum[i << 1 | 1]) % MOD;
+//}
+//
+//void lazy(int i, long long v, int n) {
+//    sum[i] = (sum[i] + v * n) % MOD;
+//    addTag[i] = (addTag[i] + v) % MOD;
+//}
+//
+//void down(int i, int ln, int rn) {
+//    if (addTag[i] != 0) {
+//    	lazy(i << 1, addTag[i], ln);
+//    	lazy(i << 1 | 1, addTag[i], rn);
+//    	addTag[i] = 0;
+//    }
+//}
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//        sum[i] = val[l] % MOD;
+//    } else {
+//        int mid = (l + r) / 2;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//        up(i);
+//    }
+//}
+//
+//void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//    	lazy(i, jobv, r - l + 1);
+//    } else {
+//        int mid = (l + r) / 2;
+//        down(i, mid - l + 1, r - mid);
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//long long query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i];
+//    }
+//    int mid = (l + r) / 2;
+//    down(i, mid - l + 1, r - mid);
+//    long long ans = 0;
+//    if (jobl <= mid) {
+//        ans = (ans + query(jobl, jobr, l, mid, i << 1)) % MOD;
+//    }
+//    if (jobr > mid) {
+//        ans = (ans + query(jobl, jobr, mid + 1, r, i << 1 | 1)) % MOD;
+//    }
+//    return ans;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    val[cntd] = arr[u];
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void pathAdd(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            add(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            add(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    if (dep[x] <= dep[y]) {
+//        add(dfn[x], dfn[y], v, 1, n, 1);
+//    } else {
+//        add(dfn[y], dfn[x], v, 1, n, 1);
+//    }
+//}
+//
+//void subtreeAdd(int x, int v) {
+//    add(dfn[x], dfn[x] + siz[x] - 1, v, 1, n, 1);
+//}
+//
+//long long pathSum(int x, int y) {
+//    long long ans = 0;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans = (ans + query(dfn[top[y]], dfn[y], 1, n, 1)) % MOD;
+//            y = fa[top[y]];
+//        } else {
+//            ans = (ans + query(dfn[top[x]], dfn[x], 1, n, 1)) % MOD;
+//            x = fa[top[x]];
+//        }
+//    }
+//    if (dep[x] <= dep[y]) {
+//        ans = (ans + query(dfn[x], dfn[y], 1, n, 1)) % MOD;
+//    } else {
+//        ans = (ans + query(dfn[y], dfn[x], 1, n, 1)) % MOD;
+//    }
+//    return ans;
+//}
+//
+//long long subtreeSum(int x) {
+//    return query(dfn[x], dfn[x] + siz[x] - 1, 1, n, 1);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> root >> MOD;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(root, 0);
+//    dfs2(root, root);
+//    build(1, n, 1);
+//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//        cin >> op;
+//        if (op == 1) {
+//            cin >> x >> y >> z;
+//            pathAdd(x, y, z);
+//        } else if (op == 2) {
+//            cin >> x >> y;
+//            cout << pathSum(x, y) << "\n";
+//        } else if (op == 3) {
+//            cin >> x >> y;
+//            subtreeAdd(x, y);
+//        } else {
+//            cin >> x;
+//            cout << subtreeSum(x) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 103a07b9a300d5dae9899336240f2e6ebed3116c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Feb 2025 14:46:23 +0800
Subject: [PATCH 0473/1712] modify code

---
 ...java => Code02_PathSumAndSubtreeSum1.java} |  24 +-
 ...java => Code02_PathSumAndSubtreeSum2.java} |  20 +-
 src/class161/Code03_PathMaxAndPathSum1.java   | 351 ++++++++++++++++++
 src/class161/Code03_PathMaxAndPathSum2.java   | 191 ++++++++++
 4 files changed, 556 insertions(+), 30 deletions(-)
 rename src/class161/{Code02_HLD1.java => Code02_PathSumAndSubtreeSum1.java} (94%)
 rename src/class161/{Code02_HLD2.java => Code02_PathSumAndSubtreeSum2.java} (91%)
 create mode 100644 src/class161/Code03_PathMaxAndPathSum1.java
 create mode 100644 src/class161/Code03_PathMaxAndPathSum2.java

diff --git a/src/class161/Code02_HLD1.java b/src/class161/Code02_PathSumAndSubtreeSum1.java
similarity index 94%
rename from src/class161/Code02_HLD1.java
rename to src/class161/Code02_PathSumAndSubtreeSum1.java
index 8511af74b..93e87d833 100644
--- a/src/class161/Code02_HLD1.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum1.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题，java版
+// 路径累加和与子树累加和，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3384
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_HLD1 {
+public class Code02_PathSumAndSubtreeSum1 {
 
 	public static int MAXN = 100001;
 
@@ -43,7 +43,7 @@ public class Code02_HLD1 {
 
 	public static int[] dfn = new int[MAXN];
 
-	public static int[] val = new int[MAXN];
+	public static int[] seg = new int[MAXN];
 
 	public static int cntd = 0;
 
@@ -72,7 +72,7 @@ public static void down(int i, int ln, int rn) {
 
 	public static void build(int l, int r, int i) {
 		if (l == r) {
-			sum[i] = val[l] % MOD;
+			sum[i] = arr[seg[l]] % MOD;
 		} else {
 			int mid = (l + r) / 2;
 			build(l, mid, i << 1);
@@ -139,7 +139,7 @@ public static void dfs1(int u, int f) {
 	public static void dfs2(int u, int t) {
 		top[u] = t;
 		dfn[u] = ++cntd;
-		val[cntd] = arr[u];
+		seg[cntd] = u;
 		if (son[u] == 0) {
 			return;
 		}
@@ -213,7 +213,7 @@ public static void dfs4() {
 			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
 				top[first] = second;
 				dfn[first] = ++cntd;
-				val[cntd] = arr[first];
+				seg[cntd] = first;
 				if (son[first] == 0) {
 					continue;
 				}
@@ -244,11 +244,7 @@ public static void pathAdd(int x, int y, int v) {
 				x = fa[top[x]];
 			}
 		}
-		if (dep[x] <= dep[y]) {
-			add(dfn[x], dfn[y], v, 1, n, 1);
-		} else {
-			add(dfn[y], dfn[x], v, 1, n, 1);
-		}
+		add(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v, 1, n, 1);
 	}
 
 	public static void subtreeAdd(int x, int v) {
@@ -266,11 +262,7 @@ public static long pathSum(int x, int y) {
 				x = fa[top[x]];
 			}
 		}
-		if (dep[x] <= dep[y]) {
-			ans = (ans + query(dfn[x], dfn[y], 1, n, 1)) % MOD;
-		} else {
-			ans = (ans + query(dfn[y], dfn[x], 1, n, 1)) % MOD;
-		}
+		ans = (ans + query(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), 1, n, 1)) % MOD;
 		return ans;
 	}
 
diff --git a/src/class161/Code02_HLD2.java b/src/class161/Code02_PathSumAndSubtreeSum2.java
similarity index 91%
rename from src/class161/Code02_HLD2.java
rename to src/class161/Code02_PathSumAndSubtreeSum2.java
index a03f012d4..5b376299e 100644
--- a/src/class161/Code02_HLD2.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum2.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题，C++版
+// 路径累加和与子树累加和，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3384
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -24,7 +24,7 @@
 //int son[MAXN];
 //int top[MAXN];
 //int dfn[MAXN];
-//int val[MAXN];
+//int seg[MAXN];
 //int cntd = 0;
 //
 //void addEdge(int u, int v) {
@@ -52,7 +52,7 @@
 //
 //void build(int l, int r, int i) {
 //    if (l == r) {
-//        sum[i] = val[l] % MOD;
+//        sum[i] = arr[seg[l]] % MOD;
 //    } else {
 //        int mid = (l + r) / 2;
 //        build(l, mid, i << 1);
@@ -117,7 +117,7 @@
 //void dfs2(int u, int t) {
 //    top[u] = t;
 //    dfn[u] = ++cntd;
-//    val[cntd] = arr[u];
+//    seg[cntd] = u;
 //    if (son[u] == 0) {
 //        return;
 //    }
@@ -140,11 +140,7 @@
 //            x = fa[top[x]];
 //        }
 //    }
-//    if (dep[x] <= dep[y]) {
-//        add(dfn[x], dfn[y], v, 1, n, 1);
-//    } else {
-//        add(dfn[y], dfn[x], v, 1, n, 1);
-//    }
+//    add(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v, 1, n, 1);
 //}
 //
 //void subtreeAdd(int x, int v) {
@@ -162,11 +158,7 @@
 //            x = fa[top[x]];
 //        }
 //    }
-//    if (dep[x] <= dep[y]) {
-//        ans = (ans + query(dfn[x], dfn[y], 1, n, 1)) % MOD;
-//    } else {
-//        ans = (ans + query(dfn[y], dfn[x], 1, n, 1)) % MOD;
-//    }
+//    ans = (ans + query(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), 1, n, 1)) % MOD;
 //    return ans;
 //}
 //
diff --git a/src/class161/Code03_PathMaxAndPathSum1.java b/src/class161/Code03_PathMaxAndPathSum1.java
new file mode 100644
index 000000000..4d4111e1e
--- /dev/null
+++ b/src/class161/Code03_PathMaxAndPathSum1.java
@@ -0,0 +1,351 @@
+package class161;
+
+// 路径最大值与路径累加和，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2590
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code03_PathMaxAndPathSum1 {
+
+	public static int MAXN = 30001;
+
+	public static int INF = 10000001;
+
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	public static int[] max = new int[MAXN << 2];
+
+	public static int[] sum = new int[MAXN << 2];
+
+	public static int[] fa = new int[MAXN];
+
+	public static int[] dep = new int[MAXN];
+
+	public static int[] siz = new int[MAXN];
+
+	public static int[] son = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int[] seg = new int[MAXN];
+
+	public static int cntd = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[i << 1] + sum[i << 1 | 1];
+		max[i] = Math.max(max[i << 1], max[i << 1 | 1]);
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			sum[i] = max[i] = arr[seg[l]];
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void update(int jobi, int jobv, int l, int r, int i) {
+		if (l == r) {
+			sum[i] = max[i] = jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				update(jobi, jobv, l, mid, i << 1);
+			} else {
+				update(jobi, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static int queryMax(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return max[i];
+		}
+		int mid = (l + r) / 2;
+		int ans = -INF;
+		if (jobl <= mid) {
+			ans = Math.max(ans, queryMax(jobl, jobr, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.max(ans, queryMax(jobl, jobr, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static int querySum(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans += querySum(jobl, jobr, l, mid, i << 1);
+		}
+		if (jobr > mid) {
+			ans += querySum(jobl, jobr, mid + 1, r, i << 1 | 1);
+		}
+		return ans;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				seg[cntd] = first;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void pointUpdate(int u, int v) {
+		update(dfn[u], v, 1, n, 1);
+	}
+
+	public static int pathMax(int x, int y) {
+		int ans = -INF;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans = Math.max(ans, queryMax(dfn[top[y]], dfn[y], 1, n, 1));
+				y = fa[top[y]];
+			} else {
+				ans = Math.max(ans, queryMax(dfn[top[x]], dfn[x], 1, n, 1));
+				x = fa[top[x]];
+			}
+		}
+		ans = Math.max(ans, queryMax(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), 1, n, 1));
+		return ans;
+	}
+
+	public static int pathSum(int x, int y) {
+		int ans = 0;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans += querySum(dfn[top[y]], dfn[y], 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				ans += querySum(dfn[top[x]], dfn[x], 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		ans += querySum(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), 1, n, 1);
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = io.nextInt();
+			v = io.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = io.nextInt();
+		}
+		dfs3(); // dfs3() 等同于 dfs1(1, 0)，调用迭代版防止爆栈
+		dfs4(); // dfs4() 等同于 dfs2(1, 1)，调用迭代版防止爆栈
+		build(1, n, 1);
+		m = io.nextInt();
+		String op;
+		int x, y;
+		for (int i = 1; i <= m; i++) {
+			op = io.next();
+			x = io.nextInt();
+			y = io.nextInt();
+			if (op.equals("CHANGE")) {
+				pointUpdate(x, y);
+			} else if (op.equals("QMAX")) {
+				io.println(pathMax(x, y));
+			} else {
+				io.println(pathSum(x, y));
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class161/Code03_PathMaxAndPathSum2.java b/src/class161/Code03_PathMaxAndPathSum2.java
new file mode 100644
index 000000000..55be327dd
--- /dev/null
+++ b/src/class161/Code03_PathMaxAndPathSum2.java
@@ -0,0 +1,191 @@
+package class161;
+
+// 路径最大值与路径累加和，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2590
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 30001;
+//const int INF = 10000001;
+//int n, m;
+//int arr[MAXN];
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//int maxv[MAXN << 2];
+//int sumv[MAXN << 2];
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int seg[MAXN];
+//int cntd = 0;
+//
+//void addEdge(int u, int v) {
+//	nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void up(int i) {
+//	sumv[i] = sumv[i << 1] + sumv[i << 1 | 1];
+//    maxv[i] = max(maxv[i << 1], maxv[i << 1 | 1]);
+//}
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//    	sumv[i] = maxv[i] = arr[seg[l]];
+//    } else {
+//        int mid = (l + r) / 2;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//        up(i);
+//    }
+//}
+//
+//void update(int jobi, int jobv, int l, int r, int i) {
+//    if (l == r) {
+//    	sumv[i] = maxv[i] = jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            update(jobi, jobv, l, mid, i << 1);
+//        } else {
+//            update(jobi, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int queryMax(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return maxv[i];
+//    }
+//    int mid = (l + r) / 2, ans = -INF;
+//    if (jobl <= mid) {
+//        ans = max(ans, queryMax(jobl, jobr, l, mid, i << 1));
+//    }
+//    if (jobr > mid) {
+//        ans = max(ans, queryMax(jobl, jobr, mid + 1, r, i << 1 | 1));
+//    }
+//    return ans;
+//}
+//
+//int querySum(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return sumv[i];
+//    }
+//    int mid = (l + r) / 2, ans = 0;
+//    if (jobl <= mid) {
+//        ans += querySum(jobl, jobr, l, mid, i << 1);
+//    }
+//    if (jobr > mid) {
+//        ans += querySum(jobl, jobr, mid + 1, r, i << 1 | 1);
+//    }
+//    return ans;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (!son[u] || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    if (!son[u]) return;
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void pointUpdate(int u, int v) {
+//    update(dfn[u], v, 1, n, 1);
+//}
+//
+//int pathMax(int x, int y) {
+//    int ans = -INF;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans = max(ans, queryMax(dfn[top[y]], dfn[y], 1, n, 1));
+//            y = fa[top[y]];
+//        } else {
+//            ans = max(ans, queryMax(dfn[top[x]], dfn[x], 1, n, 1));
+//            x = fa[top[x]];
+//        }
+//    }
+//    return max(ans, queryMax(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), 1, n, 1));
+//}
+//
+//int pathSum(int x, int y) {
+//    int ans = 0;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans += querySum(dfn[top[y]], dfn[y], 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            ans += querySum(dfn[top[x]], dfn[x], 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    return ans + querySum(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), 1, n, 1);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    build(1, n, 1);
+//    cin >> m;
+//    string op;
+//    int x, y;
+//    while (m--) {
+//        cin >> op >> x >> y;
+//        if (op == "CHANGE") {
+//            pointUpdate(x, y);
+//        } else if(op == "QMAX") {
+//            cout << pathMax(x, y) << '\n';
+//        } else {
+//            cout << pathSum(x, y) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 35af843614d9141d9ad706039dcb6813743df314 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Feb 2025 17:33:27 +0800
Subject: [PATCH 0474/1712] modify code

---
 .../Code02_PathSumAndSubtreeSum1.java         | 120 +++----
 .../Code02_PathSumAndSubtreeSum2.java         |  82 ++---
 src/class161/Code03_PathMaxAndPathSum1.java   | 120 +++----
 src/class161/Code03_PathMaxAndPathSum2.java   |  78 ++---
 src/class161/Code04_PackageManager1.java      | 321 ++++++++++++++++++
 src/class161/Code04_PackageManager2.java      | 159 +++++++++
 6 files changed, 680 insertions(+), 200 deletions(-)
 create mode 100644 src/class161/Code04_PackageManager1.java
 create mode 100644 src/class161/Code04_PackageManager2.java

diff --git a/src/class161/Code02_PathSumAndSubtreeSum1.java b/src/class161/Code02_PathSumAndSubtreeSum1.java
index 93e87d833..469c2bf9d 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum1.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum1.java
@@ -53,66 +53,6 @@ public static void addEdge(int u, int v) {
 		head[u] = cntg;
 	}
 
-	public static void up(int i) {
-		sum[i] = (sum[i << 1] + sum[i << 1 | 1]) % MOD;
-	}
-
-	public static void lazy(int i, long v, int n) {
-		sum[i] = (sum[i] + v * n) % MOD;
-		addTag[i] = (addTag[i] + v) % MOD;
-	}
-
-	public static void down(int i, int ln, int rn) {
-		if (addTag[i] != 0) {
-			lazy(i << 1, addTag[i], ln);
-			lazy(i << 1 | 1, addTag[i], rn);
-			addTag[i] = 0;
-		}
-	}
-
-	public static void build(int l, int r, int i) {
-		if (l == r) {
-			sum[i] = arr[seg[l]] % MOD;
-		} else {
-			int mid = (l + r) / 2;
-			build(l, mid, i << 1);
-			build(mid + 1, r, i << 1 | 1);
-			up(i);
-		}
-	}
-
-	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
-		if (jobl <= l && r <= jobr) {
-			lazy(i, jobv, r - l + 1);
-		} else {
-			int mid = (l + r) / 2;
-			down(i, mid - l + 1, r - mid);
-			if (jobl <= mid) {
-				add(jobl, jobr, jobv, l, mid, i << 1);
-			}
-			if (jobr > mid) {
-				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
-			}
-			up(i);
-		}
-	}
-
-	public static long query(int jobl, int jobr, int l, int r, int i) {
-		if (jobl <= l && r <= jobr) {
-			return sum[i];
-		}
-		int mid = (l + r) / 2;
-		down(i, mid - l + 1, r - mid);
-		long ans = 0;
-		if (jobl <= mid) {
-			ans = (ans + query(jobl, jobr, l, mid, i << 1)) % MOD;
-		}
-		if (jobr > mid) {
-			ans = (ans + query(jobl, jobr, mid + 1, r, i << 1 | 1)) % MOD;
-		}
-		return ans;
-	}
-
 	// 递归版，C++可以通过，java会爆栈
 	public static void dfs1(int u, int f) {
 		fa[u] = f;
@@ -234,6 +174,66 @@ public static void dfs4() {
 		}
 	}
 
+	public static void up(int i) {
+		sum[i] = (sum[i << 1] + sum[i << 1 | 1]) % MOD;
+	}
+
+	public static void lazy(int i, long v, int n) {
+		sum[i] = (sum[i] + v * n) % MOD;
+		addTag[i] = (addTag[i] + v) % MOD;
+	}
+
+	public static void down(int i, int ln, int rn) {
+		if (addTag[i] != 0) {
+			lazy(i << 1, addTag[i], ln);
+			lazy(i << 1 | 1, addTag[i], rn);
+			addTag[i] = 0;
+		}
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			sum[i] = arr[seg[l]] % MOD;
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i, jobv, r - l + 1);
+		} else {
+			int mid = (l + r) / 2;
+			down(i, mid - l + 1, r - mid);
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static long query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		down(i, mid - l + 1, r - mid);
+		long ans = 0;
+		if (jobl <= mid) {
+			ans = (ans + query(jobl, jobr, l, mid, i << 1)) % MOD;
+		}
+		if (jobr > mid) {
+			ans = (ans + query(jobl, jobr, mid + 1, r, i << 1 | 1)) % MOD;
+		}
+		return ans;
+	}
+
 	public static void pathAdd(int x, int y, int v) {
 		while (top[x] != top[y]) {
 			if (dep[top[x]] <= dep[top[y]]) {
diff --git a/src/class161/Code02_PathSumAndSubtreeSum2.java b/src/class161/Code02_PathSumAndSubtreeSum2.java
index 5b376299e..854a9e731 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum2.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum2.java
@@ -33,6 +33,43 @@
 //    head[u] = cntg;
 //}
 //
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
 //void up(int i) {
 //    sum[i] = (sum[i << 1] + sum[i << 1 | 1]) % MOD;
 //}
@@ -44,9 +81,9 @@
 //
 //void down(int i, int ln, int rn) {
 //    if (addTag[i] != 0) {
-//    	lazy(i << 1, addTag[i], ln);
-//    	lazy(i << 1 | 1, addTag[i], rn);
-//    	addTag[i] = 0;
+//        lazy(i << 1, addTag[i], ln);
+//        lazy(i << 1 | 1, addTag[i], rn);
+//        addTag[i] = 0;
 //    }
 //}
 //
@@ -63,7 +100,7 @@
 //
 //void add(int jobl, int jobr, int jobv, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
-//    	lazy(i, jobv, r - l + 1);
+//        lazy(i, jobv, r - l + 1);
 //    } else {
 //        int mid = (l + r) / 2;
 //        down(i, mid - l + 1, r - mid);
@@ -93,43 +130,6 @@
 //    return ans;
 //}
 //
-//void dfs1(int u, int f) {
-//    fa[u] = f;
-//    dep[u] = dep[f] + 1;
-//    siz[u] = 1;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
-//        }
-//    }
-//}
-//
-//void dfs2(int u, int t) {
-//    top[u] = t;
-//    dfn[u] = ++cntd;
-//    seg[cntd] = u;
-//    if (son[u] == 0) {
-//        return;
-//    }
-//    dfs2(son[u], t);
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
-//            dfs2(v, v);
-//        }
-//    }
-//}
-//
 //void pathAdd(int x, int y, int v) {
 //    while (top[x] != top[y]) {
 //        if (dep[top[x]] <= dep[top[y]]) {
diff --git a/src/class161/Code03_PathMaxAndPathSum1.java b/src/class161/Code03_PathMaxAndPathSum1.java
index 4d4111e1e..619697d2c 100644
--- a/src/class161/Code03_PathMaxAndPathSum1.java
+++ b/src/class161/Code03_PathMaxAndPathSum1.java
@@ -57,66 +57,6 @@ public static void addEdge(int u, int v) {
 		head[u] = cntg;
 	}
 
-	public static void up(int i) {
-		sum[i] = sum[i << 1] + sum[i << 1 | 1];
-		max[i] = Math.max(max[i << 1], max[i << 1 | 1]);
-	}
-
-	public static void build(int l, int r, int i) {
-		if (l == r) {
-			sum[i] = max[i] = arr[seg[l]];
-		} else {
-			int mid = (l + r) / 2;
-			build(l, mid, i << 1);
-			build(mid + 1, r, i << 1 | 1);
-			up(i);
-		}
-	}
-
-	public static void update(int jobi, int jobv, int l, int r, int i) {
-		if (l == r) {
-			sum[i] = max[i] = jobv;
-		} else {
-			int mid = (l + r) / 2;
-			if (jobi <= mid) {
-				update(jobi, jobv, l, mid, i << 1);
-			} else {
-				update(jobi, jobv, mid + 1, r, i << 1 | 1);
-			}
-			up(i);
-		}
-	}
-
-	public static int queryMax(int jobl, int jobr, int l, int r, int i) {
-		if (jobl <= l && r <= jobr) {
-			return max[i];
-		}
-		int mid = (l + r) / 2;
-		int ans = -INF;
-		if (jobl <= mid) {
-			ans = Math.max(ans, queryMax(jobl, jobr, l, mid, i << 1));
-		}
-		if (jobr > mid) {
-			ans = Math.max(ans, queryMax(jobl, jobr, mid + 1, r, i << 1 | 1));
-		}
-		return ans;
-	}
-
-	public static int querySum(int jobl, int jobr, int l, int r, int i) {
-		if (jobl <= l && r <= jobr) {
-			return sum[i];
-		}
-		int mid = (l + r) / 2;
-		int ans = 0;
-		if (jobl <= mid) {
-			ans += querySum(jobl, jobr, l, mid, i << 1);
-		}
-		if (jobr > mid) {
-			ans += querySum(jobl, jobr, mid + 1, r, i << 1 | 1);
-		}
-		return ans;
-	}
-
 	// 递归版，C++可以通过，java会爆栈
 	public static void dfs1(int u, int f) {
 		fa[u] = f;
@@ -238,6 +178,66 @@ public static void dfs4() {
 		}
 	}
 
+	public static void up(int i) {
+		sum[i] = sum[i << 1] + sum[i << 1 | 1];
+		max[i] = Math.max(max[i << 1], max[i << 1 | 1]);
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			sum[i] = max[i] = arr[seg[l]];
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void update(int jobi, int jobv, int l, int r, int i) {
+		if (l == r) {
+			sum[i] = max[i] = jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				update(jobi, jobv, l, mid, i << 1);
+			} else {
+				update(jobi, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static int queryMax(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return max[i];
+		}
+		int mid = (l + r) / 2;
+		int ans = -INF;
+		if (jobl <= mid) {
+			ans = Math.max(ans, queryMax(jobl, jobr, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.max(ans, queryMax(jobl, jobr, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static int querySum(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans += querySum(jobl, jobr, l, mid, i << 1);
+		}
+		if (jobr > mid) {
+			ans += querySum(jobl, jobr, mid + 1, r, i << 1 | 1);
+		}
+		return ans;
+	}
+
 	public static void pointUpdate(int u, int v) {
 		update(dfn[u], v, 1, n, 1);
 	}
diff --git a/src/class161/Code03_PathMaxAndPathSum2.java b/src/class161/Code03_PathMaxAndPathSum2.java
index 55be327dd..99fbc4905 100644
--- a/src/class161/Code03_PathMaxAndPathSum2.java
+++ b/src/class161/Code03_PathMaxAndPathSum2.java
@@ -29,19 +29,54 @@
 //int cntd = 0;
 //
 //void addEdge(int u, int v) {
-//	nxt[++cntg] = head[u];
+//    nxt[++cntg] = head[u];
 //    to[cntg] = v;
 //    head[u] = cntg;
 //}
 //
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (!son[u] || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    if (!son[u]) return;
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
 //void up(int i) {
-//	sumv[i] = sumv[i << 1] + sumv[i << 1 | 1];
+//    sumv[i] = sumv[i << 1] + sumv[i << 1 | 1];
 //    maxv[i] = max(maxv[i << 1], maxv[i << 1 | 1]);
 //}
 //
 //void build(int l, int r, int i) {
 //    if (l == r) {
-//    	sumv[i] = maxv[i] = arr[seg[l]];
+//        sumv[i] = maxv[i] = arr[seg[l]];
 //    } else {
 //        int mid = (l + r) / 2;
 //        build(l, mid, i << 1);
@@ -52,7 +87,7 @@
 //
 //void update(int jobi, int jobv, int l, int r, int i) {
 //    if (l == r) {
-//    	sumv[i] = maxv[i] = jobv;
+//        sumv[i] = maxv[i] = jobv;
 //    } else {
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
@@ -92,41 +127,6 @@
 //    return ans;
 //}
 //
-//void dfs1(int u, int f) {
-//    fa[u] = f;
-//    dep[u] = dep[f] + 1;
-//    siz[u] = 1;
-//    for (int e = head[u], v; e; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
-//    }
-//    for (int e = head[u], v; e; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (!son[u] || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
-//        }
-//    }
-//}
-//
-//void dfs2(int u, int t) {
-//    top[u] = t;
-//    dfn[u] = ++cntd;
-//    seg[cntd] = u;
-//    if (!son[u]) return;
-//    dfs2(son[u], t);
-//    for (int e = head[u], v; e; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
-//            dfs2(v, v);
-//        }
-//    }
-//}
-//
 //void pointUpdate(int u, int v) {
 //    update(dfn[u], v, 1, n, 1);
 //}
diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
new file mode 100644
index 000000000..8ca0d44b3
--- /dev/null
+++ b/src/class161/Code04_PackageManager1.java
@@ -0,0 +1,321 @@
+package class161;
+
+// 软件包管理器，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2146
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code04_PackageManager1 {
+
+	public static int MAXN = 100001;
+
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	public static int[] sum = new int[MAXN << 2];
+
+	public static boolean[] update = new boolean[MAXN << 2];
+
+	public static int[] change = new int[MAXN << 2];
+
+	public static int[] fa = new int[MAXN];
+
+	public static int[] dep = new int[MAXN];
+
+	public static int[] siz = new int[MAXN];
+
+	public static int[] son = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int cntd = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[i << 1] + sum[i << 1 | 1];
+	}
+
+	public static void lazy(int i, int v, int n) {
+		sum[i] = v * n;
+		update[i] = true;
+		change[i] = v;
+	}
+
+	public static void down(int i, int ln, int rn) {
+		if (update[i]) {
+			lazy(i << 1, change[i], ln);
+			lazy(i << 1 | 1, change[i], rn);
+			update[i] = false;
+		}
+	}
+
+	public static void update(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i, jobv, r - l + 1);
+		} else {
+			int mid = (l + r) / 2;
+			down(i, mid - l + 1, r - mid);
+			if (jobl <= mid) {
+				update(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				update(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static long query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		down(i, mid - l + 1, r - mid);
+		long ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, l, mid, i << 1);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, mid + 1, r, i << 1 | 1);
+		}
+		return ans;
+	}
+
+	public static void pathUpdate(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				update(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				update(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		update(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v, 1, n, 1);
+	}
+
+	public static int install(int x) {
+		int pre = sum[1];
+		pathUpdate(1, x, 1);
+		int post = sum[1];
+		return Math.abs(post - pre);
+	}
+
+	public static int uninstall(int x) {
+		int pre = sum[1];
+		update(dfn[x], dfn[x] + siz[x] - 1, 0, 1, n, 1);
+		int post = sum[1];
+		return Math.abs(post - pre);
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		for (int u = 2, v; u <= n; u++) {
+			v = io.nextInt() + 1;
+			addEdge(v, u);
+		}
+		dfs3();
+		dfs4();
+		m = io.nextInt();
+		String op;
+		int x;
+		for (int i = 1; i <= m; i++) {
+			op = io.next();
+			x = io.nextInt() + 1;
+			if (op.equals("install")) {
+				io.println(install(x));
+			} else {
+				io.println(uninstall(x));
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class161/Code04_PackageManager2.java b/src/class161/Code04_PackageManager2.java
new file mode 100644
index 000000000..33d22bc72
--- /dev/null
+++ b/src/class161/Code04_PackageManager2.java
@@ -0,0 +1,159 @@
+package class161;
+
+// 软件包管理器，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2146
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//int arr[MAXN];
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//int sum[MAXN << 2];
+//bool update[MAXN << 2];
+//int change[MAXN << 2];
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int cntd = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) dfs1(v, u);
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    if (son[u] == 0) return;
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void up(int i) {
+//    sum[i] = sum[i << 1] + sum[i << 1 | 1];
+//}
+//
+//void lazy(int i, int v, int n) {
+//    sum[i] = v * n;
+//    update[i] = true;
+//    change[i] = v;
+//}
+//
+//void down(int i, int ln, int rn) {
+//    if (update[i]) {
+//        lazy(i << 1, change[i], ln);
+//        lazy(i << 1 | 1, change[i], rn);
+//        update[i] = false;
+//    }
+//}
+//
+//void updateRange(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        lazy(i, jobv, r - l + 1);
+//    } else {
+//        int mid = (l + r) / 2;
+//        down(i, mid - l + 1, r - mid);
+//        if (jobl <= mid) updateRange(jobl, jobr, jobv, l, mid, i << 1);
+//        if (jobr > mid) updateRange(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        up(i);
+//    }
+//}
+//
+//long long query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) return sum[i];
+//    int mid = (l + r) / 2;
+//    down(i, mid - l + 1, r - mid);
+//    long long ans = 0;
+//    if (jobl <= mid) ans += query(jobl, jobr, l, mid, i << 1);
+//    if (jobr > mid) ans += query(jobl, jobr, mid + 1, r, i << 1 | 1);
+//    return ans;
+//}
+//
+//void pathUpdate(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            updateRange(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            updateRange(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    updateRange(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v, 1, n, 1);
+//}
+//
+//int install(int x) {
+//    int pre = sum[1];
+//    pathUpdate(1, x, 1);
+//    int post = sum[1];
+//    return abs(post - pre);
+//}
+//
+//int uninstall(int x) {
+//    int pre = sum[1];
+//    updateRange(dfn[x], dfn[x] + siz[x] - 1, 0, 1, n, 1);
+//    int post = sum[1];
+//    return abs(post - pre);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int u = 2, v; u <= n; u++) {
+//        cin >> v;
+//        v++;
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    cin >> m;
+//    string op;
+//    int x;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op >> x;
+//        x++;
+//        if (op == "install") {
+//            cout << install(x) << '\n';
+//        } else {
+//            cout << uninstall(x) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From faeb0522e2d2ec4a884dd6d3d44ccb85073bd847 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Feb 2025 17:36:13 +0800
Subject: [PATCH 0475/1712] modify code

---
 src/class161/Code04_PackageManager1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
index 8ca0d44b3..c3ba0029b 100644
--- a/src/class161/Code04_PackageManager1.java
+++ b/src/class161/Code04_PackageManager1.java
@@ -258,8 +258,8 @@ public static void main(String[] args) {
 			v = io.nextInt() + 1;
 			addEdge(v, u);
 		}
-		dfs3();
-		dfs4();
+		dfs3(); // dfs3() 等同于 dfs1(1, 0)，调用迭代版防止爆栈
+		dfs4(); // dfs4() 等同于 dfs2(1, 1)，调用迭代版防止爆栈
 		m = io.nextInt();
 		String op;
 		int x;

From 4f29d6f8ddf0b31263341d428ef47b80e3d97609 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Feb 2025 20:24:41 +0800
Subject: [PATCH 0476/1712] modify code

---
 src/class161/Code05_Coloring1.java | 378 +++++++++++++++++++++++++++++
 src/class161/Code05_Coloring2.java | 225 +++++++++++++++++
 2 files changed, 603 insertions(+)
 create mode 100644 src/class161/Code05_Coloring1.java
 create mode 100644 src/class161/Code05_Coloring2.java

diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
new file mode 100644
index 000000000..45ef2ff6c
--- /dev/null
+++ b/src/class161/Code05_Coloring1.java
@@ -0,0 +1,378 @@
+package class161;
+
+// 染色，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2486
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code05_Coloring1 {
+
+	public static int MAXN = 100001;
+
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	public static int[] sum = new int[MAXN << 2];
+
+	public static int[] lc = new int[MAXN << 2];
+
+	public static int[] rc = new int[MAXN << 2];
+
+	public static int[] change = new int[MAXN << 2];
+
+	public static int[] fa = new int[MAXN];
+
+	public static int[] dep = new int[MAXN];
+
+	public static int[] siz = new int[MAXN];
+
+	public static int[] son = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int[] seg = new int[MAXN];
+
+	public static int cntd = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				seg[cntd] = first;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[i << 1] + sum[i << 1 | 1];
+		if (rc[i << 1] == lc[i << 1 | 1]) {
+			sum[i]--;
+		}
+		lc[i] = lc[i << 1];
+		rc[i] = rc[i << 1 | 1];
+	}
+
+	public static void lazy(int i, int v) {
+		sum[i] = 1;
+		lc[i] = v;
+		rc[i] = v;
+		change[i] = v;
+	}
+
+	public static void down(int i) {
+		if (change[i] != 0) {
+			lazy(i << 1, change[i]);
+			lazy(i << 1 | 1, change[i]);
+			change[i] = 0;
+		}
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			sum[i] = 1;
+			lc[i] = arr[seg[l]];
+			rc[i] = arr[seg[l]];
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void update(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i, jobv);
+		} else {
+			down(i);
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				update(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				update(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		down(i);
+		int mid = (l + r) / 2;
+		if (jobr <= mid) {
+			return query(jobl, jobr, l, mid, i << 1);
+		} else if (jobl > mid) {
+			return query(jobl, jobr, mid + 1, r, i << 1 | 1);
+		} else {
+			int ans = query(jobl, jobr, l, mid, i << 1) + query(jobl, jobr, mid + 1, r, i << 1 | 1);
+			if (rc[i << 1] == lc[i << 1 | 1]) {
+				ans--;
+			}
+			return ans;
+		}
+	}
+
+	public static int pointColor(int jobi, int l, int r, int i) {
+		if (l == r) {
+			return lc[i];
+		}
+		down(i);
+		int mid = (l + r) / 2;
+		if (jobi <= mid) {
+			return pointColor(jobi, l, mid, i << 1);
+		} else {
+			return pointColor(jobi, mid + 1, r, i << 1 | 1);
+		}
+	}
+
+	public static void pathUpdate(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				update(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				update(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		update(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v, 1, n, 1);
+	}
+
+	public static int pathColors(int x, int y) {
+		int ans = 0, sonc, fac;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans += query(dfn[top[y]], dfn[y], 1, n, 1);
+				sonc = pointColor(dfn[top[y]], 1, n, 1);
+				fac = pointColor(dfn[fa[top[y]]], 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				ans += query(dfn[top[x]], dfn[x], 1, n, 1);
+				sonc = pointColor(dfn[top[x]], 1, n, 1);
+				fac = pointColor(dfn[fa[top[x]]], 1, n, 1);
+				x = fa[top[x]];
+			}
+			if (sonc == fac) {
+				ans--;
+			}
+		}
+		ans += query(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), 1, n, 1);
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = io.nextInt();
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			u = io.nextInt();
+			v = io.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs3();
+		dfs4();
+		build(1, n, 1);
+		String op;
+		int x, y, z;
+		for (int i = 1; i <= m; i++) {
+			op = io.next();
+			x = io.nextInt();
+			y = io.nextInt();
+			if (op.equals("C")) {
+				z = io.nextInt();
+				pathUpdate(x, y, z);
+			} else {
+				io.println(pathColors(x, y));
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
new file mode 100644
index 000000000..c578ee6b4
--- /dev/null
+++ b/src/class161/Code05_Coloring2.java
@@ -0,0 +1,225 @@
+package class161;
+
+// 染色，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2486
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//int arr[MAXN];
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//int sum[MAXN << 2];
+//int lc[MAXN << 2];
+//int rc[MAXN << 2];
+//int change[MAXN << 2];
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int seg[MAXN];
+//int cntd = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void up(int i) {
+//	sum[i] = sum[i << 1] + sum[i << 1 | 1];
+//    if (rc[i << 1] == lc[(i << 1) | 1]) {
+//    	sum[i]--;
+//    }
+//    lc[i] = lc[i << 1];
+//    rc[i] = rc[(i << 1) | 1];
+//}
+//
+//void lazy(int i, int v) {
+//	sum[i] = 1;
+//    lc[i] = v;
+//    rc[i] = v;
+//    change[i] = v;
+//}
+//
+//void down(int i) {
+//    if (change[i] != 0) {
+//        lazy(i << 1, change[i]);
+//        lazy((i << 1) | 1, change[i]);
+//        change[i] = 0;
+//    }
+//}
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//    	sum[i] = 1;
+//        lc[i] = arr[seg[l]];
+//        rc[i] = arr[seg[l]];
+//    } else {
+//        int mid = (l + r) / 2;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, (i << 1) | 1);
+//        up(i);
+//    }
+//}
+//
+//void update(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        lazy(i, jobv);
+//    } else {
+//        down(i);
+//        int mid = (l + r) / 2;
+//        if (jobl <= mid) {
+//            update(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            update(jobl, jobr, jobv, mid + 1, r, (i << 1) | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i];
+//    }
+//    down(i);
+//    int mid = (l + r) / 2;
+//    if (jobr <= mid) {
+//        return query(jobl, jobr, l, mid, i << 1);
+//    } else if (jobl > mid) {
+//        return query(jobl, jobr, mid + 1, r, (i << 1) | 1);
+//    } else {
+//        int ans = query(jobl, jobr, l, mid, i << 1)
+//                + query(jobl, jobr, mid + 1, r, (i << 1) | 1);
+//        if (rc[i << 1] == lc[(i << 1) | 1]) {
+//            ans--;
+//        }
+//        return ans;
+//    }
+//}
+//
+//int pointColor(int jobi, int l, int r, int i) {
+//    if (l == r) {
+//        return lc[i];
+//    }
+//    down(i);
+//    int mid = (l + r) / 2;
+//    if (jobi <= mid) {
+//        return pointColor(jobi, l, mid, i << 1);
+//    } else {
+//        return pointColor(jobi, mid + 1, r, (i << 1) | 1);
+//    }
+//}
+//
+//void pathUpdate(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            update(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            update(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    update(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v, 1, n, 1);
+//}
+//
+//int pathColors(int x, int y) {
+//    int ans = 0, sonc, fac;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans += query(dfn[top[y]], dfn[y], 1, n, 1);
+//            sonc = pointColor(dfn[top[y]], 1, n, 1);
+//            fac = pointColor(dfn[fa[top[y]]], 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            ans += query(dfn[top[x]], dfn[x], 1, n, 1);
+//            sonc = pointColor(dfn[top[x]], 1, n, 1);
+//            fac = pointColor(dfn[fa[top[x]]], 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//        if (sonc == fac) {
+//            ans--;
+//        }
+//    }
+//    ans += query(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), 1, n, 1);
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    build(1, n, 1);
+//    string op;
+//    int x, y;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op;
+//        cin >> x >> y;
+//        if (op == "C") {
+//            int z;
+//            cin >> z;
+//            pathUpdate(x, y, z);
+//        } else {
+//            cout << pathColors(x, y) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 9d256a2cbec85be1a0b0cc0cfd5a2765e7d15c79 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Feb 2025 20:28:20 +0800
Subject: [PATCH 0477/1712] modify code

---
 src/class161/Code05_Coloring1.java | 22 +++++++++++-----------
 src/class161/Code05_Coloring2.java | 26 +++++++++++++-------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
index 45ef2ff6c..057aefe8c 100644
--- a/src/class161/Code05_Coloring1.java
+++ b/src/class161/Code05_Coloring1.java
@@ -31,9 +31,9 @@ public class Code05_Coloring1 {
 
 	public static int[] sum = new int[MAXN << 2];
 
-	public static int[] lc = new int[MAXN << 2];
+	public static int[] lcolor = new int[MAXN << 2];
 
-	public static int[] rc = new int[MAXN << 2];
+	public static int[] rcolor = new int[MAXN << 2];
 
 	public static int[] change = new int[MAXN << 2];
 
@@ -182,17 +182,17 @@ public static void dfs4() {
 
 	public static void up(int i) {
 		sum[i] = sum[i << 1] + sum[i << 1 | 1];
-		if (rc[i << 1] == lc[i << 1 | 1]) {
+		if (rcolor[i << 1] == lcolor[i << 1 | 1]) {
 			sum[i]--;
 		}
-		lc[i] = lc[i << 1];
-		rc[i] = rc[i << 1 | 1];
+		lcolor[i] = lcolor[i << 1];
+		rcolor[i] = rcolor[i << 1 | 1];
 	}
 
 	public static void lazy(int i, int v) {
 		sum[i] = 1;
-		lc[i] = v;
-		rc[i] = v;
+		lcolor[i] = v;
+		rcolor[i] = v;
 		change[i] = v;
 	}
 
@@ -207,8 +207,8 @@ public static void down(int i) {
 	public static void build(int l, int r, int i) {
 		if (l == r) {
 			sum[i] = 1;
-			lc[i] = arr[seg[l]];
-			rc[i] = arr[seg[l]];
+			lcolor[i] = arr[seg[l]];
+			rcolor[i] = arr[seg[l]];
 		} else {
 			int mid = (l + r) / 2;
 			build(l, mid, i << 1);
@@ -245,7 +245,7 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 			return query(jobl, jobr, mid + 1, r, i << 1 | 1);
 		} else {
 			int ans = query(jobl, jobr, l, mid, i << 1) + query(jobl, jobr, mid + 1, r, i << 1 | 1);
-			if (rc[i << 1] == lc[i << 1 | 1]) {
+			if (rcolor[i << 1] == lcolor[i << 1 | 1]) {
 				ans--;
 			}
 			return ans;
@@ -254,7 +254,7 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 
 	public static int pointColor(int jobi, int l, int r, int i) {
 		if (l == r) {
-			return lc[i];
+			return lcolor[i];
 		}
 		down(i);
 		int mid = (l + r) / 2;
diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
index c578ee6b4..1cb750f8a 100644
--- a/src/class161/Code05_Coloring2.java
+++ b/src/class161/Code05_Coloring2.java
@@ -17,8 +17,8 @@
 //int to[MAXN << 1];
 //int cntg = 0;
 //int sum[MAXN << 2];
-//int lc[MAXN << 2];
-//int rc[MAXN << 2];
+//int lcolor[MAXN << 2];
+//int rcolor[MAXN << 2];
 //int change[MAXN << 2];
 //int fa[MAXN];
 //int dep[MAXN];
@@ -73,18 +73,18 @@
 //}
 //
 //void up(int i) {
-//	sum[i] = sum[i << 1] + sum[i << 1 | 1];
-//    if (rc[i << 1] == lc[(i << 1) | 1]) {
+//    sum[i] = sum[i << 1] + sum[i << 1 | 1];
+//    if (rcolor[i << 1] == lcolor[(i << 1) | 1]) {
 //    	sum[i]--;
 //    }
-//    lc[i] = lc[i << 1];
-//    rc[i] = rc[(i << 1) | 1];
+//    lcolor[i] = lcolor[i << 1];
+//    rcolor[i] = rcolor[(i << 1) | 1];
 //}
 //
 //void lazy(int i, int v) {
-//	sum[i] = 1;
-//    lc[i] = v;
-//    rc[i] = v;
+//    sum[i] = 1;
+//    lcolor[i] = v;
+//    rcolor[i] = v;
 //    change[i] = v;
 //}
 //
@@ -99,8 +99,8 @@
 //void build(int l, int r, int i) {
 //    if (l == r) {
 //    	sum[i] = 1;
-//        lc[i] = arr[seg[l]];
-//        rc[i] = arr[seg[l]];
+//        lcolor[i] = arr[seg[l]];
+//        rcolor[i] = arr[seg[l]];
 //    } else {
 //        int mid = (l + r) / 2;
 //        build(l, mid, i << 1);
@@ -138,7 +138,7 @@
 //    } else {
 //        int ans = query(jobl, jobr, l, mid, i << 1)
 //                + query(jobl, jobr, mid + 1, r, (i << 1) | 1);
-//        if (rc[i << 1] == lc[(i << 1) | 1]) {
+//        if (rcolor[i << 1] == lcolor[(i << 1) | 1]) {
 //            ans--;
 //        }
 //        return ans;
@@ -147,7 +147,7 @@
 //
 //int pointColor(int jobi, int l, int r, int i) {
 //    if (l == r) {
-//        return lc[i];
+//        return lcolor[i];
 //    }
 //    down(i);
 //    int mid = (l + r) / 2;

From 67db7b285d19c9c046501ea9447c89d47843d233 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Feb 2025 20:47:55 +0800
Subject: [PATCH 0478/1712] modify code

---
 src/class161/Code05_Coloring2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
index 1cb750f8a..be1f17bed 100644
--- a/src/class161/Code05_Coloring2.java
+++ b/src/class161/Code05_Coloring2.java
@@ -98,7 +98,7 @@
 //
 //void build(int l, int r, int i) {
 //    if (l == r) {
-//    	sum[i] = 1;
+//        sum[i] = 1;
 //        lcolor[i] = arr[seg[l]];
 //        rcolor[i] = arr[seg[l]];
 //    } else {

From 8f618f57602b1f6db279d287ba21dcc8ba3fcc8a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Feb 2025 20:50:41 +0800
Subject: [PATCH 0479/1712] modify code

---
 src/class161/Code05_Coloring2.java | 18 +++++++++---------
 1 file changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
index be1f17bed..f12a2ebcd 100644
--- a/src/class161/Code05_Coloring2.java
+++ b/src/class161/Code05_Coloring2.java
@@ -74,11 +74,11 @@
 //
 //void up(int i) {
 //    sum[i] = sum[i << 1] + sum[i << 1 | 1];
-//    if (rcolor[i << 1] == lcolor[(i << 1) | 1]) {
+//    if (rcolor[i << 1] == lcolor[i << 1 | 1]) {
 //    	sum[i]--;
 //    }
 //    lcolor[i] = lcolor[i << 1];
-//    rcolor[i] = rcolor[(i << 1) | 1];
+//    rcolor[i] = rcolor[i << 1 | 1];
 //}
 //
 //void lazy(int i, int v) {
@@ -91,7 +91,7 @@
 //void down(int i) {
 //    if (change[i] != 0) {
 //        lazy(i << 1, change[i]);
-//        lazy((i << 1) | 1, change[i]);
+//        lazy(i << 1 | 1, change[i]);
 //        change[i] = 0;
 //    }
 //}
@@ -104,7 +104,7 @@
 //    } else {
 //        int mid = (l + r) / 2;
 //        build(l, mid, i << 1);
-//        build(mid + 1, r, (i << 1) | 1);
+//        build(mid + 1, r, i << 1 | 1);
 //        up(i);
 //    }
 //}
@@ -119,7 +119,7 @@
 //            update(jobl, jobr, jobv, l, mid, i << 1);
 //        }
 //        if (jobr > mid) {
-//            update(jobl, jobr, jobv, mid + 1, r, (i << 1) | 1);
+//            update(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
 //        }
 //        up(i);
 //    }
@@ -134,11 +134,11 @@
 //    if (jobr <= mid) {
 //        return query(jobl, jobr, l, mid, i << 1);
 //    } else if (jobl > mid) {
-//        return query(jobl, jobr, mid + 1, r, (i << 1) | 1);
+//        return query(jobl, jobr, mid + 1, r, i << 1 | 1);
 //    } else {
 //        int ans = query(jobl, jobr, l, mid, i << 1)
-//                + query(jobl, jobr, mid + 1, r, (i << 1) | 1);
-//        if (rcolor[i << 1] == lcolor[(i << 1) | 1]) {
+//                + query(jobl, jobr, mid + 1, r, i << 1 | 1);
+//        if (rcolor[i << 1] == lcolor[i << 1 | 1]) {
 //            ans--;
 //        }
 //        return ans;
@@ -154,7 +154,7 @@
 //    if (jobi <= mid) {
 //        return pointColor(jobi, l, mid, i << 1);
 //    } else {
-//        return pointColor(jobi, mid + 1, r, (i << 1) | 1);
+//        return pointColor(jobi, mid + 1, r, i << 1 | 1);
 //    }
 //}
 //

From 88702f8ff3a3a5b4c1a1be914dd915ebe1aa94f2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Feb 2025 16:18:10 +0800
Subject: [PATCH 0480/1712] modify code

---
 .../Code02_PathSumAndSubtreeSum1.java         |   8 +-
 .../Code02_PathSumAndSubtreeSum2.java         |   4 +-
 src/class161/Code03_PathMaxAndPathSum1.java   |   8 +-
 src/class161/Code03_PathMaxAndPathSum2.java   |   4 +-
 src/class161/Code04_PackageManager1.java      |  12 +-
 src/class161/Code04_PackageManager2.java      |   6 +-
 src/class161/Code05_Coloring1.java            |  16 +-
 src/class161/Code05_Coloring2.java            |   8 +-
 src/class161/Code06_Travel1.java              | 345 ++++++++++++++++++
 src/class161/Code06_Travel2.java              | 239 ++++++++++++
 10 files changed, 617 insertions(+), 33 deletions(-)
 create mode 100644 src/class161/Code06_Travel1.java
 create mode 100644 src/class161/Code06_Travel2.java

diff --git a/src/class161/Code02_PathSumAndSubtreeSum1.java b/src/class161/Code02_PathSumAndSubtreeSum1.java
index 469c2bf9d..ed8c04e59 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum1.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum1.java
@@ -27,10 +27,6 @@ public class Code02_PathSumAndSubtreeSum1 {
 
 	public static int cntg = 0;
 
-	public static long[] sum = new long[MAXN << 2];
-
-	public static long[] addTag = new long[MAXN << 2];
-
 	public static int[] fa = new int[MAXN];
 
 	public static int[] dep = new int[MAXN];
@@ -47,6 +43,10 @@ public class Code02_PathSumAndSubtreeSum1 {
 
 	public static int cntd = 0;
 
+	public static long[] sum = new long[MAXN << 2];
+
+	public static long[] addTag = new long[MAXN << 2];
+
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
diff --git a/src/class161/Code02_PathSumAndSubtreeSum2.java b/src/class161/Code02_PathSumAndSubtreeSum2.java
index 854a9e731..3cf25f725 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum2.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum2.java
@@ -16,8 +16,6 @@
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
-//long long sum[MAXN << 2];
-//long long addTag[MAXN << 2];
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -26,6 +24,8 @@
 //int dfn[MAXN];
 //int seg[MAXN];
 //int cntd = 0;
+//long long sum[MAXN << 2];
+//long long addTag[MAXN << 2];
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
diff --git a/src/class161/Code03_PathMaxAndPathSum1.java b/src/class161/Code03_PathMaxAndPathSum1.java
index 619697d2c..ac40502e6 100644
--- a/src/class161/Code03_PathMaxAndPathSum1.java
+++ b/src/class161/Code03_PathMaxAndPathSum1.java
@@ -31,10 +31,6 @@ public class Code03_PathMaxAndPathSum1 {
 
 	public static int cntg = 0;
 
-	public static int[] max = new int[MAXN << 2];
-
-	public static int[] sum = new int[MAXN << 2];
-
 	public static int[] fa = new int[MAXN];
 
 	public static int[] dep = new int[MAXN];
@@ -51,6 +47,10 @@ public class Code03_PathMaxAndPathSum1 {
 
 	public static int cntd = 0;
 
+	public static int[] max = new int[MAXN << 2];
+
+	public static int[] sum = new int[MAXN << 2];
+
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
diff --git a/src/class161/Code03_PathMaxAndPathSum2.java b/src/class161/Code03_PathMaxAndPathSum2.java
index 99fbc4905..3ce3f5ce8 100644
--- a/src/class161/Code03_PathMaxAndPathSum2.java
+++ b/src/class161/Code03_PathMaxAndPathSum2.java
@@ -17,8 +17,6 @@
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
-//int maxv[MAXN << 2];
-//int sumv[MAXN << 2];
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -27,6 +25,8 @@
 //int dfn[MAXN];
 //int seg[MAXN];
 //int cntd = 0;
+//int maxv[MAXN << 2];
+//int sumv[MAXN << 2];
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
index c3ba0029b..7f76a6325 100644
--- a/src/class161/Code04_PackageManager1.java
+++ b/src/class161/Code04_PackageManager1.java
@@ -29,12 +29,6 @@ public class Code04_PackageManager1 {
 
 	public static int cntg = 0;
 
-	public static int[] sum = new int[MAXN << 2];
-
-	public static boolean[] update = new boolean[MAXN << 2];
-
-	public static int[] change = new int[MAXN << 2];
-
 	public static int[] fa = new int[MAXN];
 
 	public static int[] dep = new int[MAXN];
@@ -49,6 +43,12 @@ public class Code04_PackageManager1 {
 
 	public static int cntd = 0;
 
+	public static int[] sum = new int[MAXN << 2];
+
+	public static boolean[] update = new boolean[MAXN << 2];
+
+	public static int[] change = new int[MAXN << 2];
+
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
diff --git a/src/class161/Code04_PackageManager2.java b/src/class161/Code04_PackageManager2.java
index 33d22bc72..8d9b34677 100644
--- a/src/class161/Code04_PackageManager2.java
+++ b/src/class161/Code04_PackageManager2.java
@@ -16,9 +16,6 @@
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
-//int sum[MAXN << 2];
-//bool update[MAXN << 2];
-//int change[MAXN << 2];
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -26,6 +23,9 @@
 //int top[MAXN];
 //int dfn[MAXN];
 //int cntd = 0;
+//int sum[MAXN << 2];
+//bool update[MAXN << 2];
+//int change[MAXN << 2];
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
index 057aefe8c..14d55ad04 100644
--- a/src/class161/Code05_Coloring1.java
+++ b/src/class161/Code05_Coloring1.java
@@ -29,14 +29,6 @@ public class Code05_Coloring1 {
 
 	public static int cntg = 0;
 
-	public static int[] sum = new int[MAXN << 2];
-
-	public static int[] lcolor = new int[MAXN << 2];
-
-	public static int[] rcolor = new int[MAXN << 2];
-
-	public static int[] change = new int[MAXN << 2];
-
 	public static int[] fa = new int[MAXN];
 
 	public static int[] dep = new int[MAXN];
@@ -53,6 +45,14 @@ public class Code05_Coloring1 {
 
 	public static int cntd = 0;
 
+	public static int[] sum = new int[MAXN << 2];
+
+	public static int[] lcolor = new int[MAXN << 2];
+
+	public static int[] rcolor = new int[MAXN << 2];
+
+	public static int[] change = new int[MAXN << 2];
+
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
index f12a2ebcd..0e3b16528 100644
--- a/src/class161/Code05_Coloring2.java
+++ b/src/class161/Code05_Coloring2.java
@@ -16,10 +16,6 @@
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
-//int sum[MAXN << 2];
-//int lcolor[MAXN << 2];
-//int rcolor[MAXN << 2];
-//int change[MAXN << 2];
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -28,6 +24,10 @@
 //int dfn[MAXN];
 //int seg[MAXN];
 //int cntd = 0;
+//int sum[MAXN << 2];
+//int lcolor[MAXN << 2];
+//int rcolor[MAXN << 2];
+//int change[MAXN << 2];
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
diff --git a/src/class161/Code06_Travel1.java b/src/class161/Code06_Travel1.java
new file mode 100644
index 000000000..1cf6f4fd2
--- /dev/null
+++ b/src/class161/Code06_Travel1.java
@@ -0,0 +1,345 @@
+package class161;
+
+// 旅游，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3976
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code06_Travel1 {
+
+	public static int MAXN = 50001;
+
+	public static int INF = 1000000001;
+
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	public static int[] fa = new int[MAXN];
+
+	public static int[] dep = new int[MAXN];
+
+	public static int[] siz = new int[MAXN];
+
+	public static int[] son = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int[] seg = new int[MAXN];
+
+	public static int cntd = 0;
+
+	public static int[] max = new int[MAXN << 2];
+
+	public static int[] min = new int[MAXN << 2];
+
+	public static int[] lprofit = new int[MAXN << 2];
+
+	public static int[] rprofit = new int[MAXN << 2];
+
+	public static int[] addTag = new int[MAXN << 2];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				seg[cntd] = first;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void up(int i) {
+		int l = i << 1, r = i << 1 | 1;
+		max[i] = Math.max(max[l], max[r]);
+		min[i] = Math.min(min[l], min[r]);
+		lprofit[i] = Math.max(Math.max(lprofit[l], lprofit[r]), max[r] - min[l]);
+		rprofit[i] = Math.max(Math.max(rprofit[l], rprofit[r]), max[l] - min[r]);
+	}
+
+	public static void lazy(int i, int v) {
+		max[i] += v;
+		min[i] += v;
+		addTag[i] += v;
+	}
+
+	public static void down(int i) {
+		if (addTag[i] != 0) {
+			lazy(i << 1, addTag[i]);
+			lazy(i << 1 | 1, addTag[i]);
+			addTag[i] = 0;
+		}
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			max[i] = min[i] = arr[seg[l]];
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i, jobv);
+		} else {
+			down(i);
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static void merge(int[] ans, int rmax, int rmin, int rlpro, int rrpro) {
+		int lmax = ans[0];
+		int lmin = ans[1];
+		int llpro = ans[2];
+		int lrpro = ans[3];
+		ans[0] = Math.max(lmax, rmax);
+		ans[1] = Math.min(lmin, rmin);
+		ans[2] = Math.max(Math.max(llpro, rlpro), rmax - lmin);
+		ans[3] = Math.max(Math.max(lrpro, rrpro), lmax - rmin);
+	}
+
+	public static void query(int[] ans, int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			merge(ans, max[i], min[i], lprofit[i], rprofit[i]);
+		} else {
+			down(i);
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				query(ans, jobl, jobr, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				query(ans, jobl, jobr, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static int[] query(int jobl, int jobr) {
+		int[] ans = new int[] { -INF, INF, 0, 0 };
+		query(ans, jobl, jobr, 1, n, 1);
+		return ans;
+	}
+
+	public static int compute(int x, int y, int v) {
+		int tmpx = x, tmpy = y;
+		int[] xpath = new int[] { -INF, INF, 0, 0 };
+		int[] ypath = new int[] { -INF, INF, 0, 0 };
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				int[] cur = query(dfn[top[y]], dfn[y]);
+				merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
+				ypath = cur;
+				y = fa[top[y]];
+			} else {
+				int[] cur = query(dfn[top[x]], dfn[x]);
+				merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
+				xpath = cur;
+				x = fa[top[x]];
+			}
+		}
+		if (dep[x] <= dep[y]) {
+			int[] cur = query(dfn[x], dfn[y]);
+			merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
+			ypath = cur;
+		} else {
+			int[] cur = query(dfn[y], dfn[x]);
+			merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
+			xpath = cur;
+		}
+		int ans = Math.max(Math.max(xpath[3], ypath[2]), ypath[0] - xpath[1]);
+		x = tmpx;
+		y = tmpy;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				add(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				add(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		add(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v, 1, n, 1);
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs3(); // dfs3() 等同于 dfs1(1, 0)，调用迭代版防止爆栈
+		dfs4(); // dfs4() 等同于 dfs2(1, 1)，调用迭代版防止爆栈
+		build(1, n, 1);
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, x, y, v; i <= m; i++) {
+			in.nextToken();
+			x = (int) in.nval;
+			in.nextToken();
+			y = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			out.println(compute(x, y, v));
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class161/Code06_Travel2.java b/src/class161/Code06_Travel2.java
new file mode 100644
index 000000000..be5e8c724
--- /dev/null
+++ b/src/class161/Code06_Travel2.java
@@ -0,0 +1,239 @@
+package class161;
+
+// 旅游，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3976
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50001;
+//const int INF  = 1000000001;
+//int n, m;
+//int arr[MAXN];
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int seg[MAXN];
+//int cntd = 0;
+//int maxv[MAXN << 2];
+//int minv[MAXN << 2];
+//int lprofit[MAXN << 2];
+//int rprofit[MAXN << 2];
+//int addTag[MAXN << 2];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void up(int i) {
+//    int l = i << 1;
+//    int r = i << 1 | 1;
+//    maxv[i] = max(maxv[l], maxv[r]);
+//    minv[i] = min(minv[l], minv[r]);
+//    lprofit[i] = max({lprofit[l], lprofit[r], maxv[r] - minv[l]});
+//    rprofit[i] = max({rprofit[l], rprofit[r], maxv[l] - minv[r]});
+//}
+//
+//void lazy(int i, int v) {
+//    maxv[i] += v;
+//    minv[i] += v;
+//    addTag[i] += v;
+//}
+//
+//void down(int i) {
+//    if (addTag[i] != 0) {
+//        lazy(i << 1, addTag[i]);
+//        lazy(i << 1 | 1, addTag[i]);
+//        addTag[i] = 0;
+//    }
+//}
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//        maxv[i] = minv[i] = arr[seg[l]];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//        up(i);
+//    }
+//}
+//
+//void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        lazy(i, jobv);
+//    } else {
+//        down(i);
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//void merge(int ans[], int rmax, int rmin, int rlpro, int rrpro) {
+//    int lmax  = ans[0];
+//    int lmin  = ans[1];
+//    int llpro = ans[2];
+//    int lrpro = ans[3];
+//    ans[0] = max(lmax, rmax);
+//    ans[1] = min(lmin, rmin);
+//    ans[2] = max({llpro, rlpro, rmax - lmin});
+//    ans[3] = max({lrpro, rrpro, lmax - rmin});
+//}
+//
+//void query(int ans[], int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//    	merge(ans, maxv[i], minv[i], lprofit[i], rprofit[i]);
+//    } else {
+//        down(i);
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            query(ans, jobl, jobr, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            query(ans, jobl, jobr, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void query(int ans[], int jobl, int jobr) {
+//    ans[0] = -INF;
+//    ans[1] =  INF;
+//    ans[2] =  0;
+//    ans[3] =  0;
+//    query(ans, jobl, jobr, 1, n, 1);
+//}
+//
+//int compute(int x, int y, int v) {
+//    int tmpx = x;
+//    int tmpy = y;
+//    int xpath[4] = {-INF, INF, 0, 0};
+//    int ypath[4] = {-INF, INF, 0, 0};
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            int cur[4];
+//            query(cur, dfn[top[y]], dfn[y]);
+//            merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
+//            for (int i = 0; i < 4; i++) {
+//                ypath[i] = cur[i];
+//            }
+//            y = fa[top[y]];
+//        } else {
+//            int cur[4];
+//            query(cur, dfn[top[x]], dfn[x]);
+//            merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
+//            for (int i = 0; i < 4; i++) {
+//                xpath[i] = cur[i];
+//            }
+//            x = fa[top[x]];
+//        }
+//    }
+//    if (dep[x] <= dep[y]) {
+//        int cur[4];
+//        query(cur, dfn[x], dfn[y]);
+//        merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
+//        for (int i = 0; i < 4; i++) {
+//            ypath[i] = cur[i];
+//        }
+//    } else {
+//        int cur[4];
+//        query(cur, dfn[y], dfn[x]);
+//        merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
+//        for (int i = 0; i < 4; i++) {
+//            xpath[i] = cur[i];
+//        }
+//    }
+//    int ans = max({xpath[3], ypath[2], ypath[0] - xpath[1]});
+//    x = tmpx;
+//    y = tmpy;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            add(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            add(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    add(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v, 1, n, 1);
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i < n; i++) {
+//        int u, v;
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    build(1, n, 1);
+//    cin >> m;
+//    for (int i = 1; i <= m; i++) {
+//        int x, y, v;
+//        cin >> x >> y >> v;
+//        cout << compute(x, y, v) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From af34c3f42d28c5570623f2465b338ac0842173f7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Feb 2025 16:28:26 +0800
Subject: [PATCH 0481/1712] modify code

---
 src/class161/Code06_Travel1.java | 33 +++++++++++++++++++++-----------
 src/class161/Code06_Travel2.java | 13 +++++--------
 2 files changed, 27 insertions(+), 19 deletions(-)

diff --git a/src/class161/Code06_Travel1.java b/src/class161/Code06_Travel1.java
index 1cf6f4fd2..a9cb7cb6f 100644
--- a/src/class161/Code06_Travel1.java
+++ b/src/class161/Code06_Travel1.java
@@ -257,37 +257,48 @@ public static void query(int[] ans, int jobl, int jobr, int l, int r, int i) {
 		}
 	}
 
-	public static int[] query(int jobl, int jobr) {
-		int[] ans = new int[] { -INF, INF, 0, 0 };
+	public static void query(int[] ans, int jobl, int jobr) {
+		ans[0] = -INF;
+		ans[1] = INF;
+		ans[2] = 0;
+		ans[3] = 0;
 		query(ans, jobl, jobr, 1, n, 1);
-		return ans;
 	}
 
 	public static int compute(int x, int y, int v) {
 		int tmpx = x, tmpy = y;
 		int[] xpath = new int[] { -INF, INF, 0, 0 };
 		int[] ypath = new int[] { -INF, INF, 0, 0 };
+		int[] cur = new int[4];
 		while (top[x] != top[y]) {
 			if (dep[top[x]] <= dep[top[y]]) {
-				int[] cur = query(dfn[top[y]], dfn[y]);
+				query(cur, dfn[top[y]], dfn[y]);
 				merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-				ypath = cur;
+				for (int i = 0; i <= 3; i++) {
+					ypath[i] = cur[i];
+				}
 				y = fa[top[y]];
 			} else {
-				int[] cur = query(dfn[top[x]], dfn[x]);
+				query(cur, dfn[top[x]], dfn[x]);
 				merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-				xpath = cur;
+				for (int i = 0; i <= 3; i++) {
+					xpath[i] = cur[i];
+				}
 				x = fa[top[x]];
 			}
 		}
 		if (dep[x] <= dep[y]) {
-			int[] cur = query(dfn[x], dfn[y]);
+			query(cur, dfn[x], dfn[y]);
 			merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-			ypath = cur;
+			for (int i = 0; i <= 3; i++) {
+				ypath[i] = cur[i];
+			}
 		} else {
-			int[] cur = query(dfn[y], dfn[x]);
+			query(cur, dfn[y], dfn[x]);
 			merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-			xpath = cur;
+			for (int i = 0; i <= 3; i++) {
+				xpath[i] = cur[i];
+			}
 		}
 		int ans = Math.max(Math.max(xpath[3], ypath[2]), ypath[0] - xpath[1]);
 		x = tmpx;
diff --git a/src/class161/Code06_Travel2.java b/src/class161/Code06_Travel2.java
index be5e8c724..9b5312e59 100644
--- a/src/class161/Code06_Travel2.java
+++ b/src/class161/Code06_Travel2.java
@@ -163,37 +163,34 @@
 //    int tmpy = y;
 //    int xpath[4] = {-INF, INF, 0, 0};
 //    int ypath[4] = {-INF, INF, 0, 0};
+//    int cur[4];
 //    while (top[x] != top[y]) {
 //        if (dep[top[x]] <= dep[top[y]]) {
-//            int cur[4];
 //            query(cur, dfn[top[y]], dfn[y]);
 //            merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-//            for (int i = 0; i < 4; i++) {
+//            for (int i = 0; i <= 3; i++) {
 //                ypath[i] = cur[i];
 //            }
 //            y = fa[top[y]];
 //        } else {
-//            int cur[4];
 //            query(cur, dfn[top[x]], dfn[x]);
 //            merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-//            for (int i = 0; i < 4; i++) {
+//            for (int i = 0; i <= 3; i++) {
 //                xpath[i] = cur[i];
 //            }
 //            x = fa[top[x]];
 //        }
 //    }
 //    if (dep[x] <= dep[y]) {
-//        int cur[4];
 //        query(cur, dfn[x], dfn[y]);
 //        merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-//        for (int i = 0; i < 4; i++) {
+//        for (int i = 0; i <= 3; i++) {
 //            ypath[i] = cur[i];
 //        }
 //    } else {
-//        int cur[4];
 //        query(cur, dfn[y], dfn[x]);
 //        merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-//        for (int i = 0; i < 4; i++) {
+//        for (int i = 0; i <= 3; i++) {
 //            xpath[i] = cur[i];
 //        }
 //    }

From 43f11bb2d74c48779836b9a95f22c6f4fbb5bbe2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Feb 2025 16:33:55 +0800
Subject: [PATCH 0482/1712] modify code

---
 src/class161/{Code06_Travel1.java => Code06_Tourism1.java} | 2 +-
 src/class161/{Code06_Travel2.java => Code06_Tourism2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class161/{Code06_Travel1.java => Code06_Tourism1.java} (99%)
 rename src/class161/{Code06_Travel2.java => Code06_Tourism2.java} (100%)

diff --git a/src/class161/Code06_Travel1.java b/src/class161/Code06_Tourism1.java
similarity index 99%
rename from src/class161/Code06_Travel1.java
rename to src/class161/Code06_Tourism1.java
index a9cb7cb6f..8a229252e 100644
--- a/src/class161/Code06_Travel1.java
+++ b/src/class161/Code06_Tourism1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code06_Travel1 {
+public class Code06_Tourism1 {
 
 	public static int MAXN = 50001;
 
diff --git a/src/class161/Code06_Travel2.java b/src/class161/Code06_Tourism2.java
similarity index 100%
rename from src/class161/Code06_Travel2.java
rename to src/class161/Code06_Tourism2.java

From 9e52032fc8eab0d45801b4af6a1f33206e87e034 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Feb 2025 16:37:19 +0800
Subject: [PATCH 0483/1712] modify code

---
 src/class161/Code06_Tourism2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class161/Code06_Tourism2.java b/src/class161/Code06_Tourism2.java
index 9b5312e59..471b2f771 100644
--- a/src/class161/Code06_Tourism2.java
+++ b/src/class161/Code06_Tourism2.java
@@ -137,7 +137,7 @@
 //
 //void query(int ans[], int jobl, int jobr, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
-//    	merge(ans, maxv[i], minv[i], lprofit[i], rprofit[i]);
+//        merge(ans, maxv[i], minv[i], lprofit[i], rprofit[i]);
 //    } else {
 //        down(i);
 //        int mid = (l + r) >> 1;

From 08db5816b17705cb700cc28b569134e2dbff126b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Feb 2025 22:19:11 +0800
Subject: [PATCH 0484/1712] modify code

---
 src/class161/Code07_Network1.java | 369 ++++++++++++++++++++++++++++++
 src/class161/Code07_Network2.java | 239 +++++++++++++++++++
 2 files changed, 608 insertions(+)
 create mode 100644 src/class161/Code07_Network1.java
 create mode 100644 src/class161/Code07_Network2.java

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
new file mode 100644
index 000000000..808aa5a71
--- /dev/null
+++ b/src/class161/Code07_Network1.java
@@ -0,0 +1,369 @@
+package class161;
+
+// 网络，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3250
+// 提交以下的code，提交时请把类名改成"Main"，会有一个测试用例超时
+// 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
+// 本节课Code07_Network2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code07_Network1 {
+
+	public static int MAXN = 100001;
+
+	public static int MAXM = 200001;
+
+	public static int n, m;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN << 1];
+
+	public static int[] to = new int[MAXN << 1];
+
+	public static int cntg = 0;
+
+	public static int[] fa = new int[MAXN];
+
+	public static int[] dep = new int[MAXN];
+
+	public static int[] siz = new int[MAXN];
+
+	public static int[] son = new int[MAXN];
+
+	public static int[] top = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int[] seg = new int[MAXN];
+
+	public static int cntd = 0;
+
+	public static int[] tree = new int[MAXN];
+
+	public static int[][] events = new int[MAXM][4];
+
+	public static int[][] levent = new int[MAXM][4];
+
+	public static int[][] revent = new int[MAXM][4];
+
+	public static int[] sorted = new int[MAXM];
+
+	public static int s = 0;
+
+	public static int[] ans = new int[MAXM];
+
+	public static int cntans = 0;
+
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				seg[cntd] = first;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void add(int i, int v) {
+		for (; i <= n; i += i & -i) {
+			tree[i] += v;
+		}
+	}
+
+	public static void add(int l, int r, int v) {
+		add(l, v);
+		add(r + 1, -v);
+	}
+
+	public static int query(int i) {
+		int sum = 0;
+		for (; i > 0; i -= i & -i) {
+			sum += tree[i];
+		}
+		return sum;
+	}
+
+	public static void pathAdd(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				add(dfn[top[y]], dfn[y], v);
+				y = fa[top[y]];
+			} else {
+				add(dfn[top[x]], dfn[x], v);
+				x = fa[top[x]];
+			}
+		}
+		add(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v);
+	}
+
+	public static void copyEvent(int[] event1, int[] event2) {
+		event1[0] = event2[0];
+		event1[1] = event2[1];
+		event1[2] = event2[2];
+		event1[3] = event2[3];
+	}
+
+	public static void prepare() {
+		dfs3(); // dfs3() 等同于 dfs1(1, 0)，调用迭代版防止爆栈
+		dfs4(); // dfs4() 等同于 dfs2(1, 1)，调用迭代版防止爆栈
+		sorted[0] = -1;
+		for (int i = 1; i <= m; i++) {
+			if (events[i][0] == 0) {
+				sorted[++s] = events[i][3];
+			}
+		}
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= m; i++) {
+			if (events[i][0] == 0) {
+				events[i][3] = kth(events[i][3]);
+			} else if (events[i][0] == 1) {
+				copyEvent(events[i], events[events[i][1]]);
+				events[i][0] = -1;
+			} else {
+				events[i][0] = ++cntans;
+			}
+		}
+	}
+
+	public static void compute(int evtl, int evtr, int impl, int impr) {
+		if (impl == impr) {
+			for (int i = evtl; i <= evtr; i++) {
+				if (events[i][0] > 0) {
+					ans[events[i][0]] = impl;
+				}
+			}
+		} else {
+			int impm = (impl + impr) / 2;
+			int left = 0, right = 0, activeCnt = 0;
+			for (int i = evtl; i <= evtr; i++) {
+				if (events[i][0] == 0) {
+					if (events[i][3] > impm) {
+						pathAdd(events[i][1], events[i][2], 1);
+						copyEvent(revent[++right], events[i]);
+						activeCnt++;
+					} else {
+						copyEvent(levent[++left], events[i]);
+					}
+				} else if (events[i][0] == -1) {
+					if (events[i][3] > impm) {
+						pathAdd(events[i][1], events[i][2], -1);
+						copyEvent(revent[++right], events[i]);
+						activeCnt--;
+					} else {
+						copyEvent(levent[++left], events[i]);
+					}
+				} else {
+					int sum = query(dfn[events[i][1]]);
+					if (sum != activeCnt) {
+						copyEvent(revent[++right], events[i]);
+					} else {
+						copyEvent(levent[++left], events[i]);
+					}
+				}
+			}
+			for (int i = 1; i <= right; i++) {
+				if (revent[i][0] == 0) {
+					if (revent[i][3] > impm) {
+						pathAdd(revent[i][1], revent[i][2], -1);
+					}
+				} else if (revent[i][0] == -1 && revent[i][3] > impm) {
+					pathAdd(revent[i][1], revent[i][2], 1);
+				}
+			}
+			for (int i = 1; i <= left; i++) {
+				copyEvent(events[evtl + i - 1], levent[i]);
+			}
+			for (int i = 1; i <= right; i++) {
+				copyEvent(events[evtl + left + i - 1], revent[i]);
+			}
+			compute(evtl, evtl + left - 1, impl, impm);
+			compute(evtl + left, evtr, impm + 1, impr);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			events[i][0] = (int) in.nval;
+			in.nextToken();
+			events[i][1] = (int) in.nval;
+			if (events[i][0] == 0) {
+				in.nextToken();
+				events[i][2] = (int) in.nval;
+				in.nextToken();
+				events[i][3] = (int) in.nval;
+			}
+		}
+		prepare();
+		compute(1, m, 0, s);
+		for (int i = 1; i <= cntans; i++) {
+			out.println(sorted[ans[i]]);
+		}
+		out.flush();
+		out.close();
+	}
+
+}
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
new file mode 100644
index 000000000..dd878c8e8
--- /dev/null
+++ b/src/class161/Code07_Network2.java
@@ -0,0 +1,239 @@
+package class161;
+
+// 网络，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3250
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXM = 200001;
+//int n, m;
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int seg[MAXN];
+//int cntd = 0;
+//int tree[MAXN];
+//int events[MAXM][4];
+//int levent[MAXM][4];
+//int revent[MAXM][4];
+//int sorted[MAXM];
+//int s = 0;
+//int ans[MAXM];
+//int cntans = 0;
+//
+//int kth(int num) {
+//    int left = 1, right = s, mid;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void add(int i, int v) {
+//    for (; i <= n; i += i & -i) {
+//        tree[i] += v;
+//    }
+//}
+//
+//void add(int l, int r, int v) {
+//    add(l, v);
+//    add(r + 1, -v);
+//}
+//
+//int query(int i) {
+//    int sum = 0;
+//    for (; i > 0; i -= i & -i) {
+//        sum += tree[i];
+//    }
+//    return sum;
+//}
+//
+//void pathAdd(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            add(dfn[top[y]], dfn[y], v);
+//            y = fa[top[y]];
+//        } else {
+//            add(dfn[top[x]], dfn[x], v);
+//            x = fa[top[x]];
+//        }
+//    }
+//    add(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v);
+//}
+//
+//void copyEvent(int *event1, int *event2) {
+//    event1[0] = event2[0];
+//    event1[1] = event2[1];
+//    event1[2] = event2[2];
+//    event1[3] = event2[3];
+//}
+//
+//void prepare() {
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    sorted[0] = -1;
+//    for (int i = 1; i <= m; i++) {
+//        if (events[i][0] == 0) {
+//        	sorted[++s] = events[i][3];
+//        }
+//    }
+//    sort(sorted + 1, sorted + s + 1);
+//    int len = 1;
+//    for (int i = 2; i <= s; i++) {
+//        if (sorted[len] != sorted[i]) {
+//        	sorted[++len] = sorted[i];
+//        }
+//    }
+//    s = len;
+//    for (int i = 1; i <= m; i++) {
+//        if (events[i][0] == 0) {
+//        	events[i][3] = kth(events[i][3]);
+//        } else if (events[i][0] == 1) {
+//            copyEvent(events[i], events[events[i][1]]);
+//            events[i][0] = -1;
+//        } else {
+//        	events[i][0] = ++cntans;
+//        }
+//    }
+//}
+//
+//void compute(int evtl, int evtr, int impl, int impr) {
+//    if (impl == impr) {
+//        for (int i = evtl; i <= evtr; i++) {
+//            if (events[i][0] > 0) {
+//                ans[events[i][0]] = impl;
+//            }
+//        }
+//    } else {
+//        int impm = (impl + impr) / 2;
+//        int left = 0, right = 0, activeCnt = 0;
+//        for (int i = evtl; i <= evtr; i++) {
+//            if (events[i][0] == 0) {
+//                if (events[i][3] > impm) {
+//                    pathAdd(events[i][1], events[i][2], 1);
+//                    copyEvent(revent[++right], events[i]);
+//                    activeCnt++;
+//                } else {
+//                    copyEvent(levent[++left], events[i]);
+//                }
+//            } else if (events[i][0] == -1) {
+//                if (events[i][3] > impm) {
+//                    pathAdd(events[i][1], events[i][2], -1);
+//                    copyEvent(revent[++right], events[i]);
+//                    activeCnt--;
+//                } else {
+//                    copyEvent(levent[++left], events[i]);
+//                }
+//            } else {
+//                int sum = query(dfn[events[i][1]]);
+//                if (sum != activeCnt) {
+//                    copyEvent(revent[++right], events[i]);
+//                } else {
+//                    copyEvent(levent[++left], events[i]);
+//                }
+//            }
+//        }
+//        for (int i = 1; i <= right; i++) {
+//            if (revent[i][0] == 0) {
+//                if (revent[i][3] > impm) {
+//                    pathAdd(revent[i][1], revent[i][2], -1);
+//                }
+//            } else if (revent[i][0] == -1 && revent[i][3] > impm) {
+//                pathAdd(revent[i][1], revent[i][2], 1);
+//            }
+//        }
+//        for (int i = 1; i <= left; i++) {
+//            copyEvent(events[evtl + i - 1], levent[i]);
+//        }
+//        for (int i = 1; i <= right; i++) {
+//            copyEvent(events[evtl + left + i - 1], revent[i]);
+//        }
+//        compute(evtl, evtl + left - 1, impl, impm);
+//        compute(evtl + left, evtr, impm + 1, impr);
+//    }
+//}
+//
+//int main() {
+//    scanf("%d%d", &n, &m);
+//    for(int i = 1; i < n; i++) {
+//        int u, v;
+//        scanf("%d%d", &u, &v);
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for(int i = 1; i <= m; i++) {
+//        scanf("%d", &events[i][0]);
+//        scanf("%d", &events[i][1]);
+//        if(events[i][0] == 0) {
+//            scanf("%d%d", &events[i][2], &events[i][3]);
+//        }
+//    }
+//    prepare();
+//    compute(1, m, 0, s);
+//    for(int i = 1; i <= cntans; i++) {
+//        printf("%d\n", sorted[ans[i]]);
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 6bbafd6c8c162f1db1553c32dec5f4b4004841fd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Feb 2025 22:24:59 +0800
Subject: [PATCH 0485/1712] modify code

---
 src/class161/Code07_Network1.java | 20 ++++++++++----------
 src/class161/Code07_Network2.java | 20 ++++++++++----------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index 808aa5a71..ac0f89291 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -237,7 +237,7 @@ public static void pathAdd(int x, int y, int v) {
 		add(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v);
 	}
 
-	public static void copyEvent(int[] event1, int[] event2) {
+	public static void clone(int[] event1, int[] event2) {
 		event1[0] = event2[0];
 		event1[1] = event2[1];
 		event1[2] = event2[2];
@@ -265,7 +265,7 @@ public static void prepare() {
 			if (events[i][0] == 0) {
 				events[i][3] = kth(events[i][3]);
 			} else if (events[i][0] == 1) {
-				copyEvent(events[i], events[events[i][1]]);
+				clone(events[i], events[events[i][1]]);
 				events[i][0] = -1;
 			} else {
 				events[i][0] = ++cntans;
@@ -287,25 +287,25 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 				if (events[i][0] == 0) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], 1);
-						copyEvent(revent[++right], events[i]);
+						clone(revent[++right], events[i]);
 						activeCnt++;
 					} else {
-						copyEvent(levent[++left], events[i]);
+						clone(levent[++left], events[i]);
 					}
 				} else if (events[i][0] == -1) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], -1);
-						copyEvent(revent[++right], events[i]);
+						clone(revent[++right], events[i]);
 						activeCnt--;
 					} else {
-						copyEvent(levent[++left], events[i]);
+						clone(levent[++left], events[i]);
 					}
 				} else {
 					int sum = query(dfn[events[i][1]]);
 					if (sum != activeCnt) {
-						copyEvent(revent[++right], events[i]);
+						clone(revent[++right], events[i]);
 					} else {
-						copyEvent(levent[++left], events[i]);
+						clone(levent[++left], events[i]);
 					}
 				}
 			}
@@ -319,10 +319,10 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 				}
 			}
 			for (int i = 1; i <= left; i++) {
-				copyEvent(events[evtl + i - 1], levent[i]);
+				clone(events[evtl + i - 1], levent[i]);
 			}
 			for (int i = 1; i <= right; i++) {
-				copyEvent(events[evtl + left + i - 1], revent[i]);
+				clone(events[evtl + left + i - 1], revent[i]);
 			}
 			compute(evtl, evtl + left - 1, impl, impm);
 			compute(evtl + left, evtr, impm + 1, impr);
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index dd878c8e8..96fcfe88b 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -123,7 +123,7 @@
 //    add(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v);
 //}
 //
-//void copyEvent(int *event1, int *event2) {
+//void clone(int *event1, int *event2) {
 //    event1[0] = event2[0];
 //    event1[1] = event2[1];
 //    event1[2] = event2[2];
@@ -151,7 +151,7 @@
 //        if (events[i][0] == 0) {
 //        	events[i][3] = kth(events[i][3]);
 //        } else if (events[i][0] == 1) {
-//            copyEvent(events[i], events[events[i][1]]);
+//            clone(events[i], events[events[i][1]]);
 //            events[i][0] = -1;
 //        } else {
 //        	events[i][0] = ++cntans;
@@ -173,25 +173,25 @@
 //            if (events[i][0] == 0) {
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], 1);
-//                    copyEvent(revent[++right], events[i]);
+//                    clone(revent[++right], events[i]);
 //                    activeCnt++;
 //                } else {
-//                    copyEvent(levent[++left], events[i]);
+//                    clone(levent[++left], events[i]);
 //                }
 //            } else if (events[i][0] == -1) {
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], -1);
-//                    copyEvent(revent[++right], events[i]);
+//                    clone(revent[++right], events[i]);
 //                    activeCnt--;
 //                } else {
-//                    copyEvent(levent[++left], events[i]);
+//                    clone(levent[++left], events[i]);
 //                }
 //            } else {
 //                int sum = query(dfn[events[i][1]]);
 //                if (sum != activeCnt) {
-//                    copyEvent(revent[++right], events[i]);
+//                    clone(revent[++right], events[i]);
 //                } else {
-//                    copyEvent(levent[++left], events[i]);
+//                    clone(levent[++left], events[i]);
 //                }
 //            }
 //        }
@@ -205,10 +205,10 @@
 //            }
 //        }
 //        for (int i = 1; i <= left; i++) {
-//            copyEvent(events[evtl + i - 1], levent[i]);
+//            clone(events[evtl + i - 1], levent[i]);
 //        }
 //        for (int i = 1; i <= right; i++) {
-//            copyEvent(events[evtl + left + i - 1], revent[i]);
+//            clone(events[evtl + left + i - 1], revent[i]);
 //        }
 //        compute(evtl, evtl + left - 1, impl, impm);
 //        compute(evtl + left, evtr, impm + 1, impr);

From 0775ec5691593b135ab9d50d0a22f4469bb8eb90 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 16:39:19 +0800
Subject: [PATCH 0486/1712] modify code

---
 src/class161/Code01_HeavyLightDecompositionLCA1.java |  4 ++++
 src/class161/Code01_HeavyLightDecompositionLCA2.java |  4 ++++
 src/class161/Code02_PathSumAndSubtreeSum1.java       | 10 ++++++++++
 src/class161/Code02_PathSumAndSubtreeSum2.java       | 10 ++++++++++
 src/class161/Code03_PathMaxAndPathSum1.java          |  8 ++++++++
 src/class161/Code03_PathMaxAndPathSum2.java          |  8 ++++++++
 src/class161/Code04_PackageManager1.java             |  7 +++++++
 src/class161/Code04_PackageManager2.java             |  7 +++++++
 src/class161/Code05_Coloring1.java                   |  8 ++++++++
 src/class161/Code05_Coloring2.java                   |  8 ++++++++
 src/class161/Code06_Tourism1.java                    |  8 ++++++++
 src/class161/Code06_Tourism2.java                    |  8 ++++++++
 src/class161/Code07_Network1.java                    |  4 ----
 src/class161/Code07_Network2.java                    |  2 --
 14 files changed, 90 insertions(+), 6 deletions(-)

diff --git a/src/class161/Code01_HeavyLightDecompositionLCA1.java b/src/class161/Code01_HeavyLightDecompositionLCA1.java
index 6ff87e69f..b5a1e500e 100644
--- a/src/class161/Code01_HeavyLightDecompositionLCA1.java
+++ b/src/class161/Code01_HeavyLightDecompositionLCA1.java
@@ -1,6 +1,10 @@
 package class161;
 
 // 树链剖分解决LCA查询，java版
+// 一共有n个节点，n-1条边，节点连成一棵树，给定头节点编号root
+// 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
+// 请用树链剖分的方式实现
+// 1 <= n、m <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3379
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code01_HeavyLightDecompositionLCA2.java b/src/class161/Code01_HeavyLightDecompositionLCA2.java
index 033ccc8d0..b784ad703 100644
--- a/src/class161/Code01_HeavyLightDecompositionLCA2.java
+++ b/src/class161/Code01_HeavyLightDecompositionLCA2.java
@@ -1,6 +1,10 @@
 package class161;
 
 // 树链剖分解决LCA查询，C++版
+// 一共有n个节点，n-1条边，节点连成一棵树，给定头节点编号root
+// 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
+// 请用树链剖分的方式实现
+// 1 <= n、m <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3379
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class161/Code02_PathSumAndSubtreeSum1.java b/src/class161/Code02_PathSumAndSubtreeSum1.java
index ed8c04e59..8959fb90c 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum1.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum1.java
@@ -1,6 +1,16 @@
 package class161;
 
 // 路径累加和与子树累加和，java版
+// 一共有n个节点，n-1条边，节点连成一棵树
+// 给定头节点编号root，给定数字MOD
+// 一共有m条操作，每种操作是如下4种类型中的一种
+// 操作 1 x y z : x到y的路径上，每个节点值增加v
+// 操作 2 x y   : x到y的路径上，打印所有节点值的累加和 % MOD
+// 操作 3 x y   : x为头的子树上，每个节点值增加y
+// 操作 4 x     : x为头的子树上，打印所有节点值的累加和 % MOD
+// 1 <= n、m <= 10^5
+// 1 <= MOD <= 2^30
+// 输入的值都为int类型
 // 测试链接 : https://www.luogu.com.cn/problem/P3384
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code02_PathSumAndSubtreeSum2.java b/src/class161/Code02_PathSumAndSubtreeSum2.java
index 3cf25f725..e7b8af442 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum2.java
+++ b/src/class161/Code02_PathSumAndSubtreeSum2.java
@@ -1,6 +1,16 @@
 package class161;
 
 // 路径累加和与子树累加和，C++版
+// 一共有n个节点，n-1条边，节点连成一棵树
+// 给定头节点编号root，给定数字MOD
+// 一共有m条操作，每种操作是如下4种类型中的一种
+// 操作 1 x y z : x到y的路径上，每个节点值增加v
+// 操作 2 x y   : x到y的路径上，打印所有节点值的累加和 % MOD
+// 操作 3 x y   : x为头的子树上，每个节点值增加y
+// 操作 4 x     : x为头的子树上，打印所有节点值的累加和 % MOD
+// 1 <= n、m <= 10^5
+// 1 <= MOD <= 2^30
+// 输入的值都为int类型
 // 测试链接 : https://www.luogu.com.cn/problem/P3384
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class161/Code03_PathMaxAndPathSum1.java b/src/class161/Code03_PathMaxAndPathSum1.java
index ac40502e6..f77268727 100644
--- a/src/class161/Code03_PathMaxAndPathSum1.java
+++ b/src/class161/Code03_PathMaxAndPathSum1.java
@@ -1,6 +1,14 @@
 package class161;
 
 // 路径最大值与路径累加和，java版
+// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定权值
+// 一共有m条操作，每种操作是如下3种类型中的一种
+// 操作 CHANGE x y : x的权值修改为y
+// 操作 QMAX u v   : x到y的路径上，打印节点值的最大值
+// 操作 QSUM u v   : x到y的路径上，打印节点值的累加和
+// 1 <= n <= 3 * 10^4
+// 0 <= m <= 2 * 10^5
+// -30000 <= 节点权值 <= +30000
 // 测试链接 : https://www.luogu.com.cn/problem/P2590
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code03_PathMaxAndPathSum2.java b/src/class161/Code03_PathMaxAndPathSum2.java
index 3ce3f5ce8..3fd35e15c 100644
--- a/src/class161/Code03_PathMaxAndPathSum2.java
+++ b/src/class161/Code03_PathMaxAndPathSum2.java
@@ -1,6 +1,14 @@
 package class161;
 
 // 路径最大值与路径累加和，C++版
+// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定权值
+// 一共有m条操作，每种操作是如下3种类型中的一种
+// 操作 CHANGE x y : x的权值修改为y
+// 操作 QMAX u v   : x到y的路径上，打印节点值的最大值
+// 操作 QSUM u v   : x到y的路径上，打印节点值的累加和
+// 1 <= n <= 3 * 10^4
+// 0 <= m <= 2 * 10^5
+// -30000 <= 节点权值 <= +30000
 // 测试链接 : https://www.luogu.com.cn/problem/P2590
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
index 7f76a6325..bd9251b8d 100644
--- a/src/class161/Code04_PackageManager1.java
+++ b/src/class161/Code04_PackageManager1.java
@@ -1,6 +1,13 @@
 package class161;
 
 // 软件包管理器，java版
+// 一共有n个软件，编号0~n-1，0号软件不依赖任何软件，其他每个软件都仅依赖一个软件
+// 依赖关系由数组形式给出，题目保证不会出现循环依赖
+// 一开始所有软件都是没有安装的，如果a依赖b，那么安装a需要安装b，同时卸载b需要卸载a
+// 一共有m条操作，每种操作是如下2种类型中的一种
+// 操作 install x    : 安装x，如果x已经安装打印0，否则打印有多少个软件的状态需要改变
+// 操作 uninstall x  : 卸载x，如果x没有安装打印0，否则打印有多少个软件的状态需要改变
+// 1 <= n、m <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P2146
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code04_PackageManager2.java b/src/class161/Code04_PackageManager2.java
index 8d9b34677..d9b0dbed5 100644
--- a/src/class161/Code04_PackageManager2.java
+++ b/src/class161/Code04_PackageManager2.java
@@ -1,6 +1,13 @@
 package class161;
 
 // 软件包管理器，C++版
+// 一共有n个软件，编号0~n-1，0号软件不依赖任何软件，其他每个软件都仅依赖一个软件
+// 依赖关系由数组形式给出，题目保证不会出现循环依赖
+// 一开始所有软件都是没有安装的，如果a依赖b，那么安装a需要安装b，同时卸载b需要卸载a
+// 一共有m条操作，每种操作是如下2种类型中的一种
+// 操作 install x    : 安装x，如果x已经安装打印0，否则打印有多少个软件的状态需要改变
+// 操作 uninstall x  : 卸载x，如果x没有安装打印0，否则打印有多少个软件的状态需要改变
+// 1 <= n、m <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P2146
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
index 14d55ad04..fd539ebce 100644
--- a/src/class161/Code05_Coloring1.java
+++ b/src/class161/Code05_Coloring1.java
@@ -1,6 +1,14 @@
 package class161;
 
 // 染色，java版
+// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定初始颜色值
+// 连续相同颜色被认为是一段，变化了就认为是另一段
+// 比如，112221，有三个颜色段，分别为 11、222、1
+// 一共有m条操作，每种操作是如下2种类型中的一种
+// 操作 C x y z : x到y的路径上，每个节点的颜色都改为z
+// 操作 Q x y   : x到y的路径上，打印有几个颜色段
+// 1 <= n、m <= 10^5
+// 1 <= 任何时候的颜色值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2486
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
index 0e3b16528..72184109c 100644
--- a/src/class161/Code05_Coloring2.java
+++ b/src/class161/Code05_Coloring2.java
@@ -1,6 +1,14 @@
 package class161;
 
 // 染色，C++版
+// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定初始颜色值
+// 连续相同颜色被认为是一段，变化了就认为是另一段
+// 比如，112221，有三个颜色段，分别为 11、222、1
+// 一共有m条操作，每种操作是如下2种类型中的一种
+// 操作 C x y z : x到y的路径上，每个节点的颜色都改为z
+// 操作 Q x y   : x到y的路径上，打印有几个颜色段
+// 1 <= n、m <= 10^5
+// 1 <= 任何时候的颜色值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2486
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class161/Code06_Tourism1.java b/src/class161/Code06_Tourism1.java
index 8a229252e..7b69823c6 100644
--- a/src/class161/Code06_Tourism1.java
+++ b/src/class161/Code06_Tourism1.java
@@ -1,6 +1,14 @@
 package class161;
 
 // 旅游，java版
+// 一共有n个城市，n-1条边，城市连成一棵树，每个城市给定初始的宝石价格
+// 一共有m条操作，操作类型如下
+// 操作 x y v : 城市x到城市y的最短路途中，你可以选择一城买入宝石
+//              继续行进的过程中，再选一城卖出宝石，以此获得利润
+//              打印你能获得的最大利润，如果为负数，打印0
+//              当你结束旅途后，沿途所有城市的宝石价格增加v
+// 1 <= n、m <= 5 * 10^4
+// 0 <= 任何时候的宝石价格 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3976
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code06_Tourism2.java b/src/class161/Code06_Tourism2.java
index 471b2f771..57057a6ee 100644
--- a/src/class161/Code06_Tourism2.java
+++ b/src/class161/Code06_Tourism2.java
@@ -1,6 +1,14 @@
 package class161;
 
 // 旅游，C++版
+// 一共有n个城市，n-1条边，城市连成一棵树，每个城市给定初始的宝石价格
+// 一共有m条操作，操作类型如下
+// 操作 x y v : 城市x到城市y的最短路途中，你可以选择一城买入宝石
+//              继续行进的过程中，再选一城卖出宝石，以此获得利润
+//              打印你能获得的最大利润，如果为负数，打印0
+//              当你结束旅途后，沿途所有城市的宝石价格增加v
+// 1 <= n、m <= 5 * 10^4
+// 0 <= 任何时候的宝石价格 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3976
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index ac0f89291..e193f45ba 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -43,8 +43,6 @@ public class Code07_Network1 {
 
 	public static int[] dfn = new int[MAXN];
 
-	public static int[] seg = new int[MAXN];
-
 	public static int cntd = 0;
 
 	public static int[] tree = new int[MAXN];
@@ -110,7 +108,6 @@ public static void dfs1(int u, int f) {
 	public static void dfs2(int u, int t) {
 		top[u] = t;
 		dfn[u] = ++cntd;
-		seg[cntd] = u;
 		if (son[u] == 0) {
 			return;
 		}
@@ -184,7 +181,6 @@ public static void dfs4() {
 			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
 				top[first] = second;
 				dfn[first] = ++cntd;
-				seg[cntd] = first;
 				if (son[first] == 0) {
 					continue;
 				}
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 96fcfe88b..b36570599 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -22,7 +22,6 @@
 //int son[MAXN];
 //int top[MAXN];
 //int dfn[MAXN];
-//int seg[MAXN];
 //int cntd = 0;
 //int tree[MAXN];
 //int events[MAXM][4];
@@ -78,7 +77,6 @@
 //void dfs2(int u, int t) {
 //    top[u] = t;
 //    dfn[u] = ++cntd;
-//    seg[cntd] = u;
 //    if (son[u] == 0) {
 //        return;
 //    }

From d9364088ebb1803e4075962c58b7188b50015f88 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 16:52:37 +0800
Subject: [PATCH 0487/1712] modify code

---
 src/class161/Code07_Network1.java | 9 ++++-----
 src/class161/Code07_Network2.java | 9 ++++-----
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index e193f45ba..845768c17 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -306,11 +306,10 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 				}
 			}
 			for (int i = 1; i <= right; i++) {
-				if (revent[i][0] == 0) {
-					if (revent[i][3] > impm) {
-						pathAdd(revent[i][1], revent[i][2], -1);
-					}
-				} else if (revent[i][0] == -1 && revent[i][3] > impm) {
+				if (revent[i][0] == 0 && revent[i][3] > impm) {
+					pathAdd(revent[i][1], revent[i][2], -1);
+				}
+				if (revent[i][0] == -1 && revent[i][3] > impm) {
 					pathAdd(revent[i][1], revent[i][2], 1);
 				}
 			}
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index b36570599..80847fdfd 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -194,11 +194,10 @@
 //            }
 //        }
 //        for (int i = 1; i <= right; i++) {
-//            if (revent[i][0] == 0) {
-//                if (revent[i][3] > impm) {
-//                    pathAdd(revent[i][1], revent[i][2], -1);
-//                }
-//            } else if (revent[i][0] == -1 && revent[i][3] > impm) {
+//            if (revent[i][0] == 0 && revent[i][3] > impm) {
+//                pathAdd(revent[i][1], revent[i][2], -1);
+//            }
+//            if (revent[i][0] == -1 && revent[i][3] > impm) {
 //                pathAdd(revent[i][1], revent[i][2], 1);
 //            }
 //        }

From e567c5bfe211aec266deac21a1edf8362a940851 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 17:05:09 +0800
Subject: [PATCH 0488/1712] modify code

---
 src/class161/Code07_Network1.java | 40 +++++++++++++++----------------
 src/class161/Code07_Network2.java | 40 +++++++++++++++----------------
 2 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index 845768c17..ac7253f36 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -49,9 +49,9 @@ public class Code07_Network1 {
 
 	public static int[][] events = new int[MAXM][4];
 
-	public static int[][] levent = new int[MAXM][4];
+	public static int[][] lset = new int[MAXM][4];
 
-	public static int[][] revent = new int[MAXM][4];
+	public static int[][] rset = new int[MAXM][4];
 
 	public static int[] sorted = new int[MAXM];
 
@@ -278,49 +278,49 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 			}
 		} else {
 			int impm = (impl + impr) / 2;
-			int left = 0, right = 0, activeCnt = 0;
+			int lsize = 0, rsize = 0, activeCnt = 0;
 			for (int i = evtl; i <= evtr; i++) {
 				if (events[i][0] == 0) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], 1);
-						clone(revent[++right], events[i]);
+						clone(rset[++rsize], events[i]);
 						activeCnt++;
 					} else {
-						clone(levent[++left], events[i]);
+						clone(lset[++lsize], events[i]);
 					}
 				} else if (events[i][0] == -1) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], -1);
-						clone(revent[++right], events[i]);
+						clone(rset[++rsize], events[i]);
 						activeCnt--;
 					} else {
-						clone(levent[++left], events[i]);
+						clone(lset[++lsize], events[i]);
 					}
 				} else {
 					int sum = query(dfn[events[i][1]]);
 					if (sum != activeCnt) {
-						clone(revent[++right], events[i]);
+						clone(rset[++rsize], events[i]);
 					} else {
-						clone(levent[++left], events[i]);
+						clone(lset[++lsize], events[i]);
 					}
 				}
 			}
-			for (int i = 1; i <= right; i++) {
-				if (revent[i][0] == 0 && revent[i][3] > impm) {
-					pathAdd(revent[i][1], revent[i][2], -1);
+			for (int i = 1; i <= rsize; i++) {
+				if (rset[i][0] == 0 && rset[i][3] > impm) {
+					pathAdd(rset[i][1], rset[i][2], -1);
 				}
-				if (revent[i][0] == -1 && revent[i][3] > impm) {
-					pathAdd(revent[i][1], revent[i][2], 1);
+				if (rset[i][0] == -1 && rset[i][3] > impm) {
+					pathAdd(rset[i][1], rset[i][2], 1);
 				}
 			}
-			for (int i = 1; i <= left; i++) {
-				clone(events[evtl + i - 1], levent[i]);
+			for (int i = 1; i <= lsize; i++) {
+				clone(events[evtl + i - 1], lset[i]);
 			}
-			for (int i = 1; i <= right; i++) {
-				clone(events[evtl + left + i - 1], revent[i]);
+			for (int i = 1; i <= rsize; i++) {
+				clone(events[evtl + lsize + i - 1], rset[i]);
 			}
-			compute(evtl, evtl + left - 1, impl, impm);
-			compute(evtl + left, evtr, impm + 1, impr);
+			compute(evtl, evtl + lsize - 1, impl, impm);
+			compute(evtl + lsize, evtr, impm + 1, impr);
 		}
 	}
 
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 80847fdfd..a62919e0a 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -25,8 +25,8 @@
 //int cntd = 0;
 //int tree[MAXN];
 //int events[MAXM][4];
-//int levent[MAXM][4];
-//int revent[MAXM][4];
+//int lset[MAXM][4];
+//int rset[MAXM][4];
 //int sorted[MAXM];
 //int s = 0;
 //int ans[MAXM];
@@ -166,49 +166,49 @@
 //        }
 //    } else {
 //        int impm = (impl + impr) / 2;
-//        int left = 0, right = 0, activeCnt = 0;
+//        int lsize = 0, rsize = 0, activeCnt = 0;
 //        for (int i = evtl; i <= evtr; i++) {
 //            if (events[i][0] == 0) {
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], 1);
-//                    clone(revent[++right], events[i]);
+//                    clone(rset[++rsize], events[i]);
 //                    activeCnt++;
 //                } else {
-//                    clone(levent[++left], events[i]);
+//                    clone(lset[++lsize], events[i]);
 //                }
 //            } else if (events[i][0] == -1) {
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], -1);
-//                    clone(revent[++right], events[i]);
+//                    clone(rset[++rsize], events[i]);
 //                    activeCnt--;
 //                } else {
-//                    clone(levent[++left], events[i]);
+//                    clone(lset[++lsize], events[i]);
 //                }
 //            } else {
 //                int sum = query(dfn[events[i][1]]);
 //                if (sum != activeCnt) {
-//                    clone(revent[++right], events[i]);
+//                    clone(rset[++rsize], events[i]);
 //                } else {
-//                    clone(levent[++left], events[i]);
+//                    clone(lset[++lsize], events[i]);
 //                }
 //            }
 //        }
-//        for (int i = 1; i <= right; i++) {
-//            if (revent[i][0] == 0 && revent[i][3] > impm) {
-//                pathAdd(revent[i][1], revent[i][2], -1);
+//        for (int i = 1; i <= rsize; i++) {
+//            if (rset[i][0] == 0 && rset[i][3] > impm) {
+//                pathAdd(rset[i][1], rset[i][2], -1);
 //            }
-//            if (revent[i][0] == -1 && revent[i][3] > impm) {
-//                pathAdd(revent[i][1], revent[i][2], 1);
+//            if (rset[i][0] == -1 && rset[i][3] > impm) {
+//                pathAdd(rset[i][1], rset[i][2], 1);
 //            }
 //        }
-//        for (int i = 1; i <= left; i++) {
-//            clone(events[evtl + i - 1], levent[i]);
+//        for (int i = 1; i <= lsize; i++) {
+//            clone(events[evtl + i - 1], lset[i]);
 //        }
-//        for (int i = 1; i <= right; i++) {
-//            clone(events[evtl + left + i - 1], revent[i]);
+//        for (int i = 1; i <= rsize; i++) {
+//            clone(events[evtl + lsize + i - 1], rset[i]);
 //        }
-//        compute(evtl, evtl + left - 1, impl, impm);
-//        compute(evtl + left, evtr, impm + 1, impr);
+//        compute(evtl, evtl + lsize - 1, impl, impm);
+//        compute(evtl + lsize, evtr, impm + 1, impr);
 //    }
 //}
 //

From 7c770142c911c48647e36051c49c8e953c4652af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 17:10:39 +0800
Subject: [PATCH 0489/1712] modify code

---
 src/class161/Code07_Network1.java | 16 ++++++++--------
 src/class161/Code07_Network2.java | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index ac7253f36..6d5652e98 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -207,11 +207,6 @@ public static void add(int i, int v) {
 		}
 	}
 
-	public static void add(int l, int r, int v) {
-		add(l, v);
-		add(r + 1, -v);
-	}
-
 	public static int query(int i) {
 		int sum = 0;
 		for (; i > 0; i -= i & -i) {
@@ -220,17 +215,22 @@ public static int query(int i) {
 		return sum;
 	}
 
+	public static void linkAdd(int x, int y, int v) {
+		add(x, v);
+		add(y + 1, -v);
+	}
+
 	public static void pathAdd(int x, int y, int v) {
 		while (top[x] != top[y]) {
 			if (dep[top[x]] <= dep[top[y]]) {
-				add(dfn[top[y]], dfn[y], v);
+				linkAdd(dfn[top[y]], dfn[y], v);
 				y = fa[top[y]];
 			} else {
-				add(dfn[top[x]], dfn[x], v);
+				linkAdd(dfn[top[x]], dfn[x], v);
 				x = fa[top[x]];
 			}
 		}
-		add(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v);
+		linkAdd(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v);
 	}
 
 	public static void clone(int[] event1, int[] event2) {
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index a62919e0a..f50620ac7 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -95,11 +95,6 @@
 //    }
 //}
 //
-//void add(int l, int r, int v) {
-//    add(l, v);
-//    add(r + 1, -v);
-//}
-//
 //int query(int i) {
 //    int sum = 0;
 //    for (; i > 0; i -= i & -i) {
@@ -108,17 +103,22 @@
 //    return sum;
 //}
 //
+//void linkAdd(int x, int y, int v) {
+//    add(x, v);
+//    add(y + 1, -v);
+//}
+//
 //void pathAdd(int x, int y, int v) {
 //    while (top[x] != top[y]) {
 //        if (dep[top[x]] <= dep[top[y]]) {
-//            add(dfn[top[y]], dfn[y], v);
+//            linkAdd(dfn[top[y]], dfn[y], v);
 //            y = fa[top[y]];
 //        } else {
-//            add(dfn[top[x]], dfn[x], v);
+//            linkAdd(dfn[top[x]], dfn[x], v);
 //            x = fa[top[x]];
 //        }
 //    }
-//    add(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v);
+//    linkAdd(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v);
 //}
 //
 //void clone(int *event1, int *event2) {

From 08f09902c3736c094709230d8df4e9267d8c9b5a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 18:03:54 +0800
Subject: [PATCH 0490/1712] modify code

---
 src/class161/Code07_Network1.java | 18 ++++++++++++++----
 src/class161/Code07_Network2.java | 18 ++++++++++++++----
 2 files changed, 28 insertions(+), 8 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index 6d5652e98..04a5f93be 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -1,6 +1,16 @@
 package class161;
 
 // 网络，java版
+// 一共有n个服务器，n-1条边，所有服务器连成一棵树
+// 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
+// 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
+// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
+// 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
+// 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
+//                如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
+// 2 <= n <= 10^5
+// 1 <= m <= 2 * 10^5
+// 重要度 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3250
 // 提交以下的code，提交时请把类名改成"Main"，会有一个测试用例超时
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
@@ -278,13 +288,13 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 			}
 		} else {
 			int impm = (impl + impr) / 2;
-			int lsize = 0, rsize = 0, activeCnt = 0;
+			int lsize = 0, rsize = 0, influence = 0;
 			for (int i = evtl; i <= evtr; i++) {
 				if (events[i][0] == 0) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], 1);
 						clone(rset[++rsize], events[i]);
-						activeCnt++;
+						influence++;
 					} else {
 						clone(lset[++lsize], events[i]);
 					}
@@ -292,13 +302,13 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], -1);
 						clone(rset[++rsize], events[i]);
-						activeCnt--;
+						influence--;
 					} else {
 						clone(lset[++lsize], events[i]);
 					}
 				} else {
 					int sum = query(dfn[events[i][1]]);
-					if (sum != activeCnt) {
+					if (sum != influence) {
 						clone(rset[++rsize], events[i]);
 					} else {
 						clone(lset[++lsize], events[i]);
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index f50620ac7..59e518247 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -1,6 +1,16 @@
 package class161;
 
 // 网络，C++版
+// 一共有n个服务器，n-1条边，所有服务器连成一棵树
+// 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
+// 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
+// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
+// 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
+// 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
+//                如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
+// 2 <= n <= 10^5
+// 1 <= m <= 2 * 10^5
+// 重要度 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3250
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -166,13 +176,13 @@
 //        }
 //    } else {
 //        int impm = (impl + impr) / 2;
-//        int lsize = 0, rsize = 0, activeCnt = 0;
+//        int lsize = 0, rsize = 0, influence = 0;
 //        for (int i = evtl; i <= evtr; i++) {
 //            if (events[i][0] == 0) {
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], 1);
 //                    clone(rset[++rsize], events[i]);
-//                    activeCnt++;
+//                    influence++;
 //                } else {
 //                    clone(lset[++lsize], events[i]);
 //                }
@@ -180,13 +190,13 @@
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], -1);
 //                    clone(rset[++rsize], events[i]);
-//                    activeCnt--;
+//                    influence--;
 //                } else {
 //                    clone(lset[++lsize], events[i]);
 //                }
 //            } else {
 //                int sum = query(dfn[events[i][1]]);
-//                if (sum != activeCnt) {
+//                if (sum != influence) {
 //                    clone(rset[++rsize], events[i]);
 //                } else {
 //                    clone(lset[++lsize], events[i]);

From 93781ca386e5358983420a4b51f6d72c79b2ad38 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 19:35:36 +0800
Subject: [PATCH 0491/1712] modify code

---
 src/class161/Code07_Network1.java | 8 ++++----
 src/class161/Code07_Network2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index 04a5f93be..a9726d695 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -323,11 +323,11 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 					pathAdd(rset[i][1], rset[i][2], 1);
 				}
 			}
-			for (int i = 1; i <= lsize; i++) {
-				clone(events[evtl + i - 1], lset[i]);
+			for (int i = evtl, j = 1; j <= lsize; i++, j++) {
+				clone(events[i], lset[j]);
 			}
-			for (int i = 1; i <= rsize; i++) {
-				clone(events[evtl + lsize + i - 1], rset[i]);
+			for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
+				clone(events[i], rset[j]);
 			}
 			compute(evtl, evtl + lsize - 1, impl, impm);
 			compute(evtl + lsize, evtr, impm + 1, impr);
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 59e518247..3d77413b8 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -211,11 +211,11 @@
 //                pathAdd(rset[i][1], rset[i][2], 1);
 //            }
 //        }
-//        for (int i = 1; i <= lsize; i++) {
-//            clone(events[evtl + i - 1], lset[i]);
+//        for (int i = evtl, j = 1; j <= lsize; i++, j++) {
+//            clone(events[i], lset[j]);
 //        }
-//        for (int i = 1; i <= rsize; i++) {
-//            clone(events[evtl + lsize + i - 1], rset[i]);
+//        for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
+//            clone(events[i], rset[j]);
 //        }
 //        compute(evtl, evtl + lsize - 1, impl, impm);
 //        compute(evtl + lsize, evtr, impm + 1, impr);

From 931bc7eae594e51cce9073bd127383bba3b00ed6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 19:38:16 +0800
Subject: [PATCH 0492/1712] modify code

---
 src/class161/Code07_Network2.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 3d77413b8..914f8d39a 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -144,25 +144,25 @@
 //    sorted[0] = -1;
 //    for (int i = 1; i <= m; i++) {
 //        if (events[i][0] == 0) {
-//        	sorted[++s] = events[i][3];
+//            sorted[++s] = events[i][3];
 //        }
 //    }
 //    sort(sorted + 1, sorted + s + 1);
 //    int len = 1;
 //    for (int i = 2; i <= s; i++) {
 //        if (sorted[len] != sorted[i]) {
-//        	sorted[++len] = sorted[i];
+//            sorted[++len] = sorted[i];
 //        }
 //    }
 //    s = len;
 //    for (int i = 1; i <= m; i++) {
 //        if (events[i][0] == 0) {
-//        	events[i][3] = kth(events[i][3]);
+//            events[i][3] = kth(events[i][3]);
 //        } else if (events[i][0] == 1) {
 //            clone(events[i], events[events[i][1]]);
 //            events[i][0] = -1;
 //        } else {
-//        	events[i][0] = ++cntans;
+//            events[i][0] = ++cntans;
 //        }
 //    }
 //}

From de4e5d143ee158797f3d9006413c3c21eba4a840 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Feb 2025 20:40:29 +0800
Subject: [PATCH 0493/1712] modify code

---
 src/class161/Code07_Network1.java | 10 +++++-----
 src/class161/Code07_Network2.java |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index a9726d695..57aa9a6f4 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -14,7 +14,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3250
 // 提交以下的code，提交时请把类名改成"Main"，会有一个测试用例超时
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
-// 本节课Code07_Network2文件就是C++的实现
+// 想通过用C++实现，本节课Code07_Network2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.BufferedReader;
@@ -288,13 +288,13 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 			}
 		} else {
 			int impm = (impl + impr) / 2;
-			int lsize = 0, rsize = 0, influence = 0;
+			int lsize = 0, rsize = 0, request = 0;
 			for (int i = evtl; i <= evtr; i++) {
 				if (events[i][0] == 0) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], 1);
 						clone(rset[++rsize], events[i]);
-						influence++;
+						request++;
 					} else {
 						clone(lset[++lsize], events[i]);
 					}
@@ -302,13 +302,13 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 					if (events[i][3] > impm) {
 						pathAdd(events[i][1], events[i][2], -1);
 						clone(rset[++rsize], events[i]);
-						influence--;
+						request--;
 					} else {
 						clone(lset[++lsize], events[i]);
 					}
 				} else {
 					int sum = query(dfn[events[i][1]]);
-					if (sum != influence) {
+					if (sum != request) {
 						clone(rset[++rsize], events[i]);
 					} else {
 						clone(lset[++lsize], events[i]);
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 914f8d39a..523a4f0bc 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -176,13 +176,13 @@
 //        }
 //    } else {
 //        int impm = (impl + impr) / 2;
-//        int lsize = 0, rsize = 0, influence = 0;
+//        int lsize = 0, rsize = 0, request = 0;
 //        for (int i = evtl; i <= evtr; i++) {
 //            if (events[i][0] == 0) {
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], 1);
 //                    clone(rset[++rsize], events[i]);
-//                    influence++;
+//                    request++;
 //                } else {
 //                    clone(lset[++lsize], events[i]);
 //                }
@@ -190,13 +190,13 @@
 //                if (events[i][3] > impm) {
 //                    pathAdd(events[i][1], events[i][2], -1);
 //                    clone(rset[++rsize], events[i]);
-//                    influence--;
+//                    request--;
 //                } else {
 //                    clone(lset[++lsize], events[i]);
 //                }
 //            } else {
 //                int sum = query(dfn[events[i][1]]);
-//                if (sum != influence) {
+//                if (sum != request) {
 //                    clone(rset[++rsize], events[i]);
 //                } else {
 //                    clone(lset[++lsize], events[i]);

From 86b972b6da85c83a9a5a6d93cfd63cefe9b4e26e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 1 Mar 2025 20:00:51 +0800
Subject: [PATCH 0494/1712] modify code

---
 ...dSubtreeSum1.java => Code01_HeavyLightDecomposition1.java} | 4 ++--
 ...dSubtreeSum2.java => Code01_HeavyLightDecomposition2.java} | 2 +-
 ...de01_HeavyLightDecompositionLCA1.java => Code02_LCA1.java} | 4 ++--
 ...de01_HeavyLightDecompositionLCA2.java => Code02_LCA2.java} | 2 +-
 ...e03_PathMaxAndPathSum1.java => Code03_PathMaxAndSum1.java} | 4 ++--
 ...e03_PathMaxAndPathSum2.java => Code03_PathMaxAndSum2.java} | 2 +-
 6 files changed, 9 insertions(+), 9 deletions(-)
 rename src/class161/{Code02_PathSumAndSubtreeSum1.java => Code01_HeavyLightDecomposition1.java} (98%)
 rename src/class161/{Code02_PathSumAndSubtreeSum2.java => Code01_HeavyLightDecomposition2.java} (99%)
 rename src/class161/{Code01_HeavyLightDecompositionLCA1.java => Code02_LCA1.java} (98%)
 rename src/class161/{Code01_HeavyLightDecompositionLCA2.java => Code02_LCA2.java} (98%)
 rename src/class161/{Code03_PathMaxAndPathSum1.java => Code03_PathMaxAndSum1.java} (98%)
 rename src/class161/{Code03_PathMaxAndPathSum2.java => Code03_PathMaxAndSum2.java} (99%)

diff --git a/src/class161/Code02_PathSumAndSubtreeSum1.java b/src/class161/Code01_HeavyLightDecomposition1.java
similarity index 98%
rename from src/class161/Code02_PathSumAndSubtreeSum1.java
rename to src/class161/Code01_HeavyLightDecomposition1.java
index 8959fb90c..4ffb238b3 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum1.java
+++ b/src/class161/Code01_HeavyLightDecomposition1.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 路径累加和与子树累加和，java版
+// 树链剖分模版题1，java版
 // 一共有n个节点，n-1条边，节点连成一棵树
 // 给定头节点编号root，给定数字MOD
 // 一共有m条操作，每种操作是如下4种类型中的一种
@@ -21,7 +21,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_PathSumAndSubtreeSum1 {
+public class Code01_HeavyLightDecomposition1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class161/Code02_PathSumAndSubtreeSum2.java b/src/class161/Code01_HeavyLightDecomposition2.java
similarity index 99%
rename from src/class161/Code02_PathSumAndSubtreeSum2.java
rename to src/class161/Code01_HeavyLightDecomposition2.java
index e7b8af442..9f249f126 100644
--- a/src/class161/Code02_PathSumAndSubtreeSum2.java
+++ b/src/class161/Code01_HeavyLightDecomposition2.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 路径累加和与子树累加和，C++版
+// 树链剖分模版题1，C++版
 // 一共有n个节点，n-1条边，节点连成一棵树
 // 给定头节点编号root，给定数字MOD
 // 一共有m条操作，每种操作是如下4种类型中的一种
diff --git a/src/class161/Code01_HeavyLightDecompositionLCA1.java b/src/class161/Code02_LCA1.java
similarity index 98%
rename from src/class161/Code01_HeavyLightDecompositionLCA1.java
rename to src/class161/Code02_LCA1.java
index b5a1e500e..a90a3091d 100644
--- a/src/class161/Code01_HeavyLightDecompositionLCA1.java
+++ b/src/class161/Code02_LCA1.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分解决LCA查询，java版
+// 树链剖分模版题2，java版
 // 一共有n个节点，n-1条边，节点连成一棵树，给定头节点编号root
 // 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
 // 请用树链剖分的方式实现
@@ -15,7 +15,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code01_HeavyLightDecompositionLCA1 {
+public class Code02_LCA1 {
 
 	public static int MAXN = 500001;
 
diff --git a/src/class161/Code01_HeavyLightDecompositionLCA2.java b/src/class161/Code02_LCA2.java
similarity index 98%
rename from src/class161/Code01_HeavyLightDecompositionLCA2.java
rename to src/class161/Code02_LCA2.java
index b784ad703..deaee2c43 100644
--- a/src/class161/Code01_HeavyLightDecompositionLCA2.java
+++ b/src/class161/Code02_LCA2.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分解决LCA查询，C++版
+// 树链剖分模版题2，C++版
 // 一共有n个节点，n-1条边，节点连成一棵树，给定头节点编号root
 // 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
 // 请用树链剖分的方式实现
diff --git a/src/class161/Code03_PathMaxAndPathSum1.java b/src/class161/Code03_PathMaxAndSum1.java
similarity index 98%
rename from src/class161/Code03_PathMaxAndPathSum1.java
rename to src/class161/Code03_PathMaxAndSum1.java
index f77268727..e0bdeae15 100644
--- a/src/class161/Code03_PathMaxAndPathSum1.java
+++ b/src/class161/Code03_PathMaxAndSum1.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 路径最大值与路径累加和，java版
+// 树链剖分模版题3，java版
 // 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y
@@ -21,7 +21,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code03_PathMaxAndPathSum1 {
+public class Code03_PathMaxAndSum1 {
 
 	public static int MAXN = 30001;
 
diff --git a/src/class161/Code03_PathMaxAndPathSum2.java b/src/class161/Code03_PathMaxAndSum2.java
similarity index 99%
rename from src/class161/Code03_PathMaxAndPathSum2.java
rename to src/class161/Code03_PathMaxAndSum2.java
index 3fd35e15c..9315b2c14 100644
--- a/src/class161/Code03_PathMaxAndPathSum2.java
+++ b/src/class161/Code03_PathMaxAndSum2.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 路径最大值与路径累加和，C++版
+// 树链剖分模版题3，C++版
 // 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y

From ffaa692d58e52a64077f83dbcd7db7c2fe85d106 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 1 Mar 2025 20:12:01 +0800
Subject: [PATCH 0495/1712] modify code

---
 .../{Code01_HeavyLightDecomposition1.java => Code01_HLD1.java}  | 2 +-
 .../{Code01_HeavyLightDecomposition2.java => Code01_HLD2.java}  | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class161/{Code01_HeavyLightDecomposition1.java => Code01_HLD1.java} (99%)
 rename src/class161/{Code01_HeavyLightDecomposition2.java => Code01_HLD2.java} (100%)

diff --git a/src/class161/Code01_HeavyLightDecomposition1.java b/src/class161/Code01_HLD1.java
similarity index 99%
rename from src/class161/Code01_HeavyLightDecomposition1.java
rename to src/class161/Code01_HLD1.java
index 4ffb238b3..43be9c6bc 100644
--- a/src/class161/Code01_HeavyLightDecomposition1.java
+++ b/src/class161/Code01_HLD1.java
@@ -21,7 +21,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code01_HeavyLightDecomposition1 {
+public class Code01_HLD1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class161/Code01_HeavyLightDecomposition2.java b/src/class161/Code01_HLD2.java
similarity index 100%
rename from src/class161/Code01_HeavyLightDecomposition2.java
rename to src/class161/Code01_HLD2.java

From 40c3b1f3f4eb899d644bc3d9d5998ff49fc33b43 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 15:28:02 +0800
Subject: [PATCH 0496/1712] modify code

---
 src/class161/Code01_HLD1.java           | 8 ++++----
 src/class161/Code01_HLD2.java           | 8 ++++----
 src/class161/Code02_LCA1.java           | 2 +-
 src/class161/Code02_LCA2.java           | 2 +-
 src/class161/Code03_PathMaxAndSum1.java | 2 +-
 src/class161/Code03_PathMaxAndSum2.java | 2 +-
 src/class161/Code05_Coloring1.java      | 2 +-
 src/class161/Code05_Coloring2.java      | 2 +-
 src/class161/Code06_Tourism1.java       | 2 +-
 src/class161/Code06_Tourism2.java       | 2 +-
 src/class161/Code07_Network1.java       | 2 +-
 src/class161/Code07_Network2.java       | 2 +-
 12 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index 43be9c6bc..4240ac2f9 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -1,16 +1,16 @@
 package class161;
 
 // 树链剖分模版题1，java版
-// 一共有n个节点，n-1条边，节点连成一棵树
-// 给定头节点编号root，给定数字MOD
+// 一共有n个节点，n-1条边，节点连成一棵树，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
 // 操作 1 x y z : x到y的路径上，每个节点值增加v
-// 操作 2 x y   : x到y的路径上，打印所有节点值的累加和 % MOD
+// 操作 2 x y   : x到y的路径上，打印所有节点值的累加和
 // 操作 3 x y   : x为头的子树上，每个节点值增加y
-// 操作 4 x     : x为头的子树上，打印所有节点值的累加和 % MOD
+// 操作 4 x     : x为头的子树上，打印所有节点值的累加和
 // 1 <= n、m <= 10^5
 // 1 <= MOD <= 2^30
 // 输入的值都为int类型
+// 查询操作时，打印(查询结果 % MOD)，题目会给定MOD值
 // 测试链接 : https://www.luogu.com.cn/problem/P3384
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code01_HLD2.java b/src/class161/Code01_HLD2.java
index 9f249f126..6aa440ac4 100644
--- a/src/class161/Code01_HLD2.java
+++ b/src/class161/Code01_HLD2.java
@@ -1,16 +1,16 @@
 package class161;
 
 // 树链剖分模版题1，C++版
-// 一共有n个节点，n-1条边，节点连成一棵树
-// 给定头节点编号root，给定数字MOD
+// 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
 // 操作 1 x y z : x到y的路径上，每个节点值增加v
-// 操作 2 x y   : x到y的路径上，打印所有节点值的累加和 % MOD
+// 操作 2 x y   : x到y的路径上，打印所有节点值的累加和
 // 操作 3 x y   : x为头的子树上，每个节点值增加y
-// 操作 4 x     : x为头的子树上，打印所有节点值的累加和 % MOD
+// 操作 4 x     : x为头的子树上，打印所有节点值的累加和
 // 1 <= n、m <= 10^5
 // 1 <= MOD <= 2^30
 // 输入的值都为int类型
+// 查询操作时，打印(查询结果 % MOD)，题目会给定MOD值
 // 测试链接 : https://www.luogu.com.cn/problem/P3384
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class161/Code02_LCA1.java b/src/class161/Code02_LCA1.java
index a90a3091d..36276828e 100644
--- a/src/class161/Code02_LCA1.java
+++ b/src/class161/Code02_LCA1.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 树链剖分模版题2，java版
-// 一共有n个节点，n-1条边，节点连成一棵树，给定头节点编号root
+// 一共有n个节点，给定n-1条边，节点连成一棵树，给定头节点编号root
 // 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
 // 请用树链剖分的方式实现
 // 1 <= n、m <= 5 * 10^5
diff --git a/src/class161/Code02_LCA2.java b/src/class161/Code02_LCA2.java
index deaee2c43..1eb0667fd 100644
--- a/src/class161/Code02_LCA2.java
+++ b/src/class161/Code02_LCA2.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 树链剖分模版题2，C++版
-// 一共有n个节点，n-1条边，节点连成一棵树，给定头节点编号root
+// 一共有n个节点，给定n-1条边，节点连成一棵树，给定头节点编号root
 // 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
 // 请用树链剖分的方式实现
 // 1 <= n、m <= 5 * 10^5
diff --git a/src/class161/Code03_PathMaxAndSum1.java b/src/class161/Code03_PathMaxAndSum1.java
index e0bdeae15..31fa28688 100644
--- a/src/class161/Code03_PathMaxAndSum1.java
+++ b/src/class161/Code03_PathMaxAndSum1.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 树链剖分模版题3，java版
-// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定权值
+// 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y
 // 操作 QMAX u v   : x到y的路径上，打印节点值的最大值
diff --git a/src/class161/Code03_PathMaxAndSum2.java b/src/class161/Code03_PathMaxAndSum2.java
index 9315b2c14..278224079 100644
--- a/src/class161/Code03_PathMaxAndSum2.java
+++ b/src/class161/Code03_PathMaxAndSum2.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 树链剖分模版题3，C++版
-// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定权值
+// 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y
 // 操作 QMAX u v   : x到y的路径上，打印节点值的最大值
diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
index fd539ebce..dfbca8445 100644
--- a/src/class161/Code05_Coloring1.java
+++ b/src/class161/Code05_Coloring1.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 染色，java版
-// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定初始颜色值
+// 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定初始颜色值
 // 连续相同颜色被认为是一段，变化了就认为是另一段
 // 比如，112221，有三个颜色段，分别为 11、222、1
 // 一共有m条操作，每种操作是如下2种类型中的一种
diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
index 72184109c..634b1e536 100644
--- a/src/class161/Code05_Coloring2.java
+++ b/src/class161/Code05_Coloring2.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 染色，C++版
-// 一共有n个节点，n-1条边，节点连成一棵树，每个节点给定初始颜色值
+// 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定初始颜色值
 // 连续相同颜色被认为是一段，变化了就认为是另一段
 // 比如，112221，有三个颜色段，分别为 11、222、1
 // 一共有m条操作，每种操作是如下2种类型中的一种
diff --git a/src/class161/Code06_Tourism1.java b/src/class161/Code06_Tourism1.java
index 7b69823c6..03fda9a42 100644
--- a/src/class161/Code06_Tourism1.java
+++ b/src/class161/Code06_Tourism1.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 旅游，java版
-// 一共有n个城市，n-1条边，城市连成一棵树，每个城市给定初始的宝石价格
+// 一共有n个城市，给定n-1条边，城市连成一棵树，每个城市给定初始的宝石价格
 // 一共有m条操作，操作类型如下
 // 操作 x y v : 城市x到城市y的最短路途中，你可以选择一城买入宝石
 //              继续行进的过程中，再选一城卖出宝石，以此获得利润
diff --git a/src/class161/Code06_Tourism2.java b/src/class161/Code06_Tourism2.java
index 57057a6ee..cdde5e641 100644
--- a/src/class161/Code06_Tourism2.java
+++ b/src/class161/Code06_Tourism2.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 旅游，C++版
-// 一共有n个城市，n-1条边，城市连成一棵树，每个城市给定初始的宝石价格
+// 一共有n个城市，给定n-1条边，城市连成一棵树，每个城市给定初始的宝石价格
 // 一共有m条操作，操作类型如下
 // 操作 x y v : 城市x到城市y的最短路途中，你可以选择一城买入宝石
 //              继续行进的过程中，再选一城卖出宝石，以此获得利润
diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index 57aa9a6f4..37cefdbb1 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 网络，java版
-// 一共有n个服务器，n-1条边，所有服务器连成一棵树
+// 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
 // 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
 // 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
 // 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 523a4f0bc..168bb6356 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 网络，C++版
-// 一共有n个服务器，n-1条边，所有服务器连成一棵树
+// 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
 // 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
 // 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
 // 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求

From a4911b073fb1be6ea3445294db95401d06dbfc2f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 15:28:39 +0800
Subject: [PATCH 0497/1712] modify code

---
 src/class161/Code01_HLD1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index 4240ac2f9..bbd516990 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -1,7 +1,7 @@
 package class161;
 
 // 树链剖分模版题1，java版
-// 一共有n个节点，n-1条边，节点连成一棵树，给定树的头节点编号root
+// 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
 // 操作 1 x y z : x到y的路径上，每个节点值增加v
 // 操作 2 x y   : x到y的路径上，打印所有节点值的累加和

From 60367ac8c06efbbc15e8d8028870b8bffc59b221 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 15:32:35 +0800
Subject: [PATCH 0498/1712] modify code

---
 src/class161/Code01_HLD1.java | 14 +++++++-------
 src/class161/Code01_HLD2.java | 14 +++++++-------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index bbd516990..6eda53f45 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -3,9 +3,9 @@
 // 树链剖分模版题1，java版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
-// 操作 1 x y z : x到y的路径上，每个节点值增加v
+// 操作 1 x y v : x到y的路径上，每个节点值增加v
 // 操作 2 x y   : x到y的路径上，打印所有节点值的累加和
-// 操作 3 x y   : x为头的子树上，每个节点值增加y
+// 操作 3 x v   : x为头的子树上，每个节点值增加v
 // 操作 4 x     : x为头的子树上，打印所有节点值的累加和
 // 1 <= n、m <= 10^5
 // 1 <= MOD <= 2^30
@@ -307,7 +307,7 @@ public static void main(String[] args) throws IOException {
 		dfs3(); // dfs3() 等同于 dfs1(root, 0)，调用迭代版防止爆栈
 		dfs4(); // dfs4() 等同于 dfs2(root, root)，调用迭代版防止爆栈
 		build(1, n, 1);
-		for (int i = 1, op, x, y, z; i <= m; i++) {
+		for (int i = 1, op, x, y, v; i <= m; i++) {
 			in.nextToken();
 			op = (int) in.nval;
 			if (op == 1) {
@@ -316,8 +316,8 @@ public static void main(String[] args) throws IOException {
 				in.nextToken();
 				y = (int) in.nval;
 				in.nextToken();
-				z = (int) in.nval;
-				pathAdd(x, y, z);
+				v = (int) in.nval;
+				pathAdd(x, y, v);
 			} else if (op == 2) {
 				in.nextToken();
 				x = (int) in.nval;
@@ -328,8 +328,8 @@ public static void main(String[] args) throws IOException {
 				in.nextToken();
 				x = (int) in.nval;
 				in.nextToken();
-				y = (int) in.nval;
-				subtreeAdd(x, y);
+				v = (int) in.nval;
+				subtreeAdd(x, v);
 			} else {
 				in.nextToken();
 				x = (int) in.nval;
diff --git a/src/class161/Code01_HLD2.java b/src/class161/Code01_HLD2.java
index 6aa440ac4..046fe8860 100644
--- a/src/class161/Code01_HLD2.java
+++ b/src/class161/Code01_HLD2.java
@@ -3,9 +3,9 @@
 // 树链剖分模版题1，C++版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
-// 操作 1 x y z : x到y的路径上，每个节点值增加v
+// 操作 1 x y v : x到y的路径上，每个节点值增加v
 // 操作 2 x y   : x到y的路径上，打印所有节点值的累加和
-// 操作 3 x y   : x为头的子树上，每个节点值增加y
+// 操作 3 x v   : x为头的子树上，每个节点值增加v
 // 操作 4 x     : x为头的子树上，打印所有节点值的累加和
 // 1 <= n、m <= 10^5
 // 1 <= MOD <= 2^30
@@ -191,17 +191,17 @@
 //    dfs1(root, 0);
 //    dfs2(root, root);
 //    build(1, n, 1);
-//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//    for (int i = 1, op, x, y, v; i <= m; i++) {
 //        cin >> op;
 //        if (op == 1) {
-//            cin >> x >> y >> z;
-//            pathAdd(x, y, z);
+//            cin >> x >> y >> v;
+//            pathAdd(x, y, v);
 //        } else if (op == 2) {
 //            cin >> x >> y;
 //            cout << pathSum(x, y) << "\n";
 //        } else if (op == 3) {
-//            cin >> x >> y;
-//            subtreeAdd(x, y);
+//            cin >> x >> v;
+//            subtreeAdd(x, v);
 //        } else {
 //            cin >> x;
 //            cout << subtreeSum(x) << "\n";

From 44877d0cfb25b848d83420dfa76f6c1b149d7573 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 15:34:53 +0800
Subject: [PATCH 0499/1712] modify code

---
 src/class161/Code03_PathMaxAndSum1.java | 4 ++--
 src/class161/Code03_PathMaxAndSum2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class161/Code03_PathMaxAndSum1.java b/src/class161/Code03_PathMaxAndSum1.java
index 31fa28688..0a496a5f8 100644
--- a/src/class161/Code03_PathMaxAndSum1.java
+++ b/src/class161/Code03_PathMaxAndSum1.java
@@ -4,8 +4,8 @@
 // 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y
-// 操作 QMAX u v   : x到y的路径上，打印节点值的最大值
-// 操作 QSUM u v   : x到y的路径上，打印节点值的累加和
+// 操作 QMAX x y   : x到y的路径上，打印节点值的最大值
+// 操作 QSUM x y   : x到y的路径上，打印节点值的累加和
 // 1 <= n <= 3 * 10^4
 // 0 <= m <= 2 * 10^5
 // -30000 <= 节点权值 <= +30000
diff --git a/src/class161/Code03_PathMaxAndSum2.java b/src/class161/Code03_PathMaxAndSum2.java
index 278224079..723ba299e 100644
--- a/src/class161/Code03_PathMaxAndSum2.java
+++ b/src/class161/Code03_PathMaxAndSum2.java
@@ -4,8 +4,8 @@
 // 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y
-// 操作 QMAX u v   : x到y的路径上，打印节点值的最大值
-// 操作 QSUM u v   : x到y的路径上，打印节点值的累加和
+// 操作 QMAX x y   : x到y的路径上，打印节点值的最大值
+// 操作 QSUM x y   : x到y的路径上，打印节点值的累加和
 // 1 <= n <= 3 * 10^4
 // 0 <= m <= 2 * 10^5
 // -30000 <= 节点权值 <= +30000

From cb45ccc880e59c23c66246baa8228bbe120182b8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 15:49:16 +0800
Subject: [PATCH 0500/1712] modify code

---
 src/class161/Code01_HLD1.java            | 11 -----------
 src/class161/Code01_HLD2.java            |  3 +++
 src/class161/Code02_LCA1.java            |  7 -------
 src/class161/Code02_LCA2.java            |  2 ++
 src/class161/Code03_PathMaxAndSum1.java  | 11 -----------
 src/class161/Code03_PathMaxAndSum2.java  |  3 +++
 src/class161/Code04_PackageManager1.java | 11 -----------
 src/class161/Code04_PackageManager2.java |  3 +++
 src/class161/Code05_Coloring1.java       | 13 -------------
 src/class161/Code05_Coloring2.java       |  3 +++
 src/class161/Code06_Tourism1.java        | 14 --------------
 src/class161/Code06_Tourism2.java        |  3 +++
 src/class161/Code07_Network1.java        | 20 ++++----------------
 src/class161/Code07_Network2.java        |  8 ++++++--
 14 files changed, 27 insertions(+), 85 deletions(-)

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index 6eda53f45..827a553e4 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -30,31 +30,20 @@ public class Code01_HLD1 {
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
-
 	public static int[] next = new int[MAXN << 1];
-
 	public static int[] to = new int[MAXN << 1];
-
 	public static int cntg = 0;
 
 	public static int[] fa = new int[MAXN];
-
 	public static int[] dep = new int[MAXN];
-
 	public static int[] siz = new int[MAXN];
-
 	public static int[] son = new int[MAXN];
-
 	public static int[] top = new int[MAXN];
-
 	public static int[] dfn = new int[MAXN];
-
 	public static int[] seg = new int[MAXN];
-
 	public static int cntd = 0;
 
 	public static long[] sum = new long[MAXN << 2];
-
 	public static long[] addTag = new long[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
diff --git a/src/class161/Code01_HLD2.java b/src/class161/Code01_HLD2.java
index 046fe8860..fdc28fc34 100644
--- a/src/class161/Code01_HLD2.java
+++ b/src/class161/Code01_HLD2.java
@@ -22,10 +22,12 @@
 //const int MAXN = 100001;
 //int n, m, root, MOD;
 //int arr[MAXN];
+//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
+//
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -34,6 +36,7 @@
 //int dfn[MAXN];
 //int seg[MAXN];
 //int cntd = 0;
+//
 //long long sum[MAXN << 2];
 //long long addTag[MAXN << 2];
 //
diff --git a/src/class161/Code02_LCA1.java b/src/class161/Code02_LCA1.java
index 36276828e..eb6b10169 100644
--- a/src/class161/Code02_LCA1.java
+++ b/src/class161/Code02_LCA1.java
@@ -22,21 +22,14 @@ public class Code02_LCA1 {
 	public static int n, m, root;
 
 	public static int[] head = new int[MAXN];
-
 	public static int[] next = new int[MAXN << 1];
-
 	public static int[] to = new int[MAXN << 1];
-
 	public static int cnt = 0;
 
 	public static int[] fa = new int[MAXN];
-
 	public static int[] dep = new int[MAXN];
-
 	public static int[] siz = new int[MAXN];
-
 	public static int[] son = new int[MAXN];
-
 	public static int[] top = new int[MAXN];
 
 	public static void addEdge(int u, int v) {
diff --git a/src/class161/Code02_LCA2.java b/src/class161/Code02_LCA2.java
index 1eb0667fd..99b45a9e9 100644
--- a/src/class161/Code02_LCA2.java
+++ b/src/class161/Code02_LCA2.java
@@ -15,10 +15,12 @@
 //
 //const int MAXN = 500001;
 //int n, m, root;
+//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cnt = 0;
+//
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
diff --git a/src/class161/Code03_PathMaxAndSum1.java b/src/class161/Code03_PathMaxAndSum1.java
index 0a496a5f8..3f156c747 100644
--- a/src/class161/Code03_PathMaxAndSum1.java
+++ b/src/class161/Code03_PathMaxAndSum1.java
@@ -32,31 +32,20 @@ public class Code03_PathMaxAndSum1 {
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
-
 	public static int[] next = new int[MAXN << 1];
-
 	public static int[] to = new int[MAXN << 1];
-
 	public static int cntg = 0;
 
 	public static int[] fa = new int[MAXN];
-
 	public static int[] dep = new int[MAXN];
-
 	public static int[] siz = new int[MAXN];
-
 	public static int[] son = new int[MAXN];
-
 	public static int[] top = new int[MAXN];
-
 	public static int[] dfn = new int[MAXN];
-
 	public static int[] seg = new int[MAXN];
-
 	public static int cntd = 0;
 
 	public static int[] max = new int[MAXN << 2];
-
 	public static int[] sum = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
diff --git a/src/class161/Code03_PathMaxAndSum2.java b/src/class161/Code03_PathMaxAndSum2.java
index 723ba299e..216f7ca1a 100644
--- a/src/class161/Code03_PathMaxAndSum2.java
+++ b/src/class161/Code03_PathMaxAndSum2.java
@@ -21,10 +21,12 @@
 //const int INF = 10000001;
 //int n, m;
 //int arr[MAXN];
+//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
+//
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -33,6 +35,7 @@
 //int dfn[MAXN];
 //int seg[MAXN];
 //int cntd = 0;
+//
 //int maxv[MAXN << 2];
 //int sumv[MAXN << 2];
 //
diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
index bd9251b8d..9d5a09dde 100644
--- a/src/class161/Code04_PackageManager1.java
+++ b/src/class161/Code04_PackageManager1.java
@@ -29,31 +29,20 @@ public class Code04_PackageManager1 {
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
-
 	public static int[] next = new int[MAXN << 1];
-
 	public static int[] to = new int[MAXN << 1];
-
 	public static int cntg = 0;
 
 	public static int[] fa = new int[MAXN];
-
 	public static int[] dep = new int[MAXN];
-
 	public static int[] siz = new int[MAXN];
-
 	public static int[] son = new int[MAXN];
-
 	public static int[] top = new int[MAXN];
-
 	public static int[] dfn = new int[MAXN];
-
 	public static int cntd = 0;
 
 	public static int[] sum = new int[MAXN << 2];
-
 	public static boolean[] update = new boolean[MAXN << 2];
-
 	public static int[] change = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
diff --git a/src/class161/Code04_PackageManager2.java b/src/class161/Code04_PackageManager2.java
index d9b0dbed5..c417bfc1d 100644
--- a/src/class161/Code04_PackageManager2.java
+++ b/src/class161/Code04_PackageManager2.java
@@ -19,10 +19,12 @@
 //const int MAXN = 100001;
 //int n, m;
 //int arr[MAXN];
+//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
+//
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -30,6 +32,7 @@
 //int top[MAXN];
 //int dfn[MAXN];
 //int cntd = 0;
+//
 //int sum[MAXN << 2];
 //bool update[MAXN << 2];
 //int change[MAXN << 2];
diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
index dfbca8445..abbe638fc 100644
--- a/src/class161/Code05_Coloring1.java
+++ b/src/class161/Code05_Coloring1.java
@@ -30,35 +30,22 @@ public class Code05_Coloring1 {
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
-
 	public static int[] next = new int[MAXN << 1];
-
 	public static int[] to = new int[MAXN << 1];
-
 	public static int cntg = 0;
 
 	public static int[] fa = new int[MAXN];
-
 	public static int[] dep = new int[MAXN];
-
 	public static int[] siz = new int[MAXN];
-
 	public static int[] son = new int[MAXN];
-
 	public static int[] top = new int[MAXN];
-
 	public static int[] dfn = new int[MAXN];
-
 	public static int[] seg = new int[MAXN];
-
 	public static int cntd = 0;
 
 	public static int[] sum = new int[MAXN << 2];
-
 	public static int[] lcolor = new int[MAXN << 2];
-
 	public static int[] rcolor = new int[MAXN << 2];
-
 	public static int[] change = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
diff --git a/src/class161/Code05_Coloring2.java b/src/class161/Code05_Coloring2.java
index 634b1e536..cb21f6e01 100644
--- a/src/class161/Code05_Coloring2.java
+++ b/src/class161/Code05_Coloring2.java
@@ -20,10 +20,12 @@
 //const int MAXN = 100001;
 //int n, m;
 //int arr[MAXN];
+//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
+//
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -32,6 +34,7 @@
 //int dfn[MAXN];
 //int seg[MAXN];
 //int cntd = 0;
+//
 //int sum[MAXN << 2];
 //int lcolor[MAXN << 2];
 //int rcolor[MAXN << 2];
diff --git a/src/class161/Code06_Tourism1.java b/src/class161/Code06_Tourism1.java
index 03fda9a42..1cd06db73 100644
--- a/src/class161/Code06_Tourism1.java
+++ b/src/class161/Code06_Tourism1.java
@@ -30,37 +30,23 @@ public class Code06_Tourism1 {
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
-
 	public static int[] next = new int[MAXN << 1];
-
 	public static int[] to = new int[MAXN << 1];
-
 	public static int cntg = 0;
 
 	public static int[] fa = new int[MAXN];
-
 	public static int[] dep = new int[MAXN];
-
 	public static int[] siz = new int[MAXN];
-
 	public static int[] son = new int[MAXN];
-
 	public static int[] top = new int[MAXN];
-
 	public static int[] dfn = new int[MAXN];
-
 	public static int[] seg = new int[MAXN];
-
 	public static int cntd = 0;
 
 	public static int[] max = new int[MAXN << 2];
-
 	public static int[] min = new int[MAXN << 2];
-
 	public static int[] lprofit = new int[MAXN << 2];
-
 	public static int[] rprofit = new int[MAXN << 2];
-
 	public static int[] addTag = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
diff --git a/src/class161/Code06_Tourism2.java b/src/class161/Code06_Tourism2.java
index cdde5e641..a7d692925 100644
--- a/src/class161/Code06_Tourism2.java
+++ b/src/class161/Code06_Tourism2.java
@@ -21,10 +21,12 @@
 //const int INF  = 1000000001;
 //int n, m;
 //int arr[MAXN];
+//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
+//
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -33,6 +35,7 @@
 //int dfn[MAXN];
 //int seg[MAXN];
 //int cntd = 0;
+//
 //int maxv[MAXN << 2];
 //int minv[MAXN << 2];
 //int lprofit[MAXN << 2];
diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index 37cefdbb1..cb8d08553 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -34,41 +34,29 @@ public class Code07_Network1 {
 	public static int n, m;
 
 	public static int[] head = new int[MAXN];
-
 	public static int[] next = new int[MAXN << 1];
-
 	public static int[] to = new int[MAXN << 1];
-
 	public static int cntg = 0;
 
 	public static int[] fa = new int[MAXN];
-
 	public static int[] dep = new int[MAXN];
-
 	public static int[] siz = new int[MAXN];
-
 	public static int[] son = new int[MAXN];
-
 	public static int[] top = new int[MAXN];
-
 	public static int[] dfn = new int[MAXN];
-
 	public static int cntd = 0;
 
+	// 树状数组
 	public static int[] tree = new int[MAXN];
 
+	// 从早到晚发生的事件
 	public static int[][] events = new int[MAXM][4];
-
-	public static int[][] lset = new int[MAXM][4];
-
-	public static int[][] rset = new int[MAXM][4];
-
 	public static int[] sorted = new int[MAXM];
-
 	public static int s = 0;
 
+	public static int[][] lset = new int[MAXM][4];
+	public static int[][] rset = new int[MAXM][4];
 	public static int[] ans = new int[MAXM];
-
 	public static int cntans = 0;
 
 	public static int kth(int num) {
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 168bb6356..f0cf0f9e5 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -26,6 +26,7 @@
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
+//
 //int fa[MAXN];
 //int dep[MAXN];
 //int siz[MAXN];
@@ -33,12 +34,15 @@
 //int top[MAXN];
 //int dfn[MAXN];
 //int cntd = 0;
+//
 //int tree[MAXN];
+//
 //int events[MAXM][4];
-//int lset[MAXM][4];
-//int rset[MAXM][4];
 //int sorted[MAXM];
 //int s = 0;
+//
+//int lset[MAXM][4];
+//int rset[MAXM][4];
 //int ans[MAXM];
 //int cntans = 0;
 //

From fa74ae026686a0a443f6144d65849c126a6466c3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 16:05:55 +0800
Subject: [PATCH 0501/1712] modify code

---
 src/class161/Code01_HLD1.java           | 2 +-
 src/class161/Code01_HLD2.java           | 2 +-
 src/class161/Code02_LCA1.java           | 2 +-
 src/class161/Code02_LCA2.java           | 2 +-
 src/class161/Code03_PathMaxAndSum1.java | 2 +-
 src/class161/Code03_PathMaxAndSum2.java | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index 827a553e4..bf4ed25dc 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题1，java版
+// 重链剖分模版题，java版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
 // 操作 1 x y v : x到y的路径上，每个节点值增加v
diff --git a/src/class161/Code01_HLD2.java b/src/class161/Code01_HLD2.java
index fdc28fc34..ca6697a09 100644
--- a/src/class161/Code01_HLD2.java
+++ b/src/class161/Code01_HLD2.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题1，C++版
+// 重链剖分模版题，C++版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
 // 操作 1 x y v : x到y的路径上，每个节点值增加v
diff --git a/src/class161/Code02_LCA1.java b/src/class161/Code02_LCA1.java
index eb6b10169..8ac627c0d 100644
--- a/src/class161/Code02_LCA1.java
+++ b/src/class161/Code02_LCA1.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题2，java版
+// 重链剖分解决LCA查询，java版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定头节点编号root
 // 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
 // 请用树链剖分的方式实现
diff --git a/src/class161/Code02_LCA2.java b/src/class161/Code02_LCA2.java
index 99b45a9e9..9185a2e43 100644
--- a/src/class161/Code02_LCA2.java
+++ b/src/class161/Code02_LCA2.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题2，C++版
+// 重链剖分解决LCA查询，C++版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定头节点编号root
 // 一共有m条查询，每条查询给定a和b，打印a和b的最低公共祖先
 // 请用树链剖分的方式实现
diff --git a/src/class161/Code03_PathMaxAndSum1.java b/src/class161/Code03_PathMaxAndSum1.java
index 3f156c747..a1db818c8 100644
--- a/src/class161/Code03_PathMaxAndSum1.java
+++ b/src/class161/Code03_PathMaxAndSum1.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题3，java版
+// 路径最大值与累加和，java版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y
diff --git a/src/class161/Code03_PathMaxAndSum2.java b/src/class161/Code03_PathMaxAndSum2.java
index 216f7ca1a..9041b1065 100644
--- a/src/class161/Code03_PathMaxAndSum2.java
+++ b/src/class161/Code03_PathMaxAndSum2.java
@@ -1,6 +1,6 @@
 package class161;
 
-// 树链剖分模版题3，C++版
+// 路径最大值与累加和，C++版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，每个节点给定权值
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 CHANGE x y : x的权值修改为y

From 58519055d2a3759af3a182932e15a05e8e1ebe8c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 17:32:14 +0800
Subject: [PATCH 0502/1712] modify code

---
 src/class161/Code01_HLD1.java | 3 ++-
 src/class161/Code01_HLD2.java | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index bf4ed25dc..9cdb986cb 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -1,7 +1,8 @@
 package class161;
 
 // 重链剖分模版题，java版
-// 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
+// 一共有n个节点，给定n-1条边，节点连成一棵树
+// 给定每个节点的初始权值，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
 // 操作 1 x y v : x到y的路径上，每个节点值增加v
 // 操作 2 x y   : x到y的路径上，打印所有节点值的累加和
diff --git a/src/class161/Code01_HLD2.java b/src/class161/Code01_HLD2.java
index ca6697a09..812811ac9 100644
--- a/src/class161/Code01_HLD2.java
+++ b/src/class161/Code01_HLD2.java
@@ -1,7 +1,8 @@
 package class161;
 
 // 重链剖分模版题，C++版
-// 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的头节点编号root
+// 一共有n个节点，给定n-1条边，节点连成一棵树
+// 给定每个节点的初始权值，给定树的头节点编号root
 // 一共有m条操作，每种操作是如下4种类型中的一种
 // 操作 1 x y v : x到y的路径上，每个节点值增加v
 // 操作 2 x y   : x到y的路径上，打印所有节点值的累加和

From b6dda2170295d44b4fb8bb91c030aea00ba93945 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 2 Mar 2025 20:05:37 +0800
Subject: [PATCH 0503/1712] modify code

---
 src/class161/Code01_HLD1.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index 9cdb986cb..c5c6d6397 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -54,6 +54,8 @@ public static void addEdge(int u, int v) {
 	}
 
 	// 递归版，C++可以通过，java会爆栈
+	// 来到节点u，节点u树上的父节点是f
+	// dfs1的过程去设置 fa dep siz son
 	public static void dfs1(int u, int f) {
 		fa[u] = f;
 		dep[u] = dep[f] + 1;
@@ -76,6 +78,8 @@ public static void dfs1(int u, int f) {
 	}
 
 	// 递归版，C++可以通过，java会爆栈
+	// 来到节点u，节点u所在重链的头节点是t
+	// dfs2的过程去设置 top dfn seg
 	public static void dfs2(int u, int t) {
 		top[u] = t;
 		dfn[u] = ++cntd;
@@ -234,6 +238,7 @@ public static long query(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
+	// 从x到y的路径上，所有节点的值增加v
 	public static void pathAdd(int x, int y, int v) {
 		while (top[x] != top[y]) {
 			if (dep[top[x]] <= dep[top[y]]) {
@@ -247,10 +252,12 @@ public static void pathAdd(int x, int y, int v) {
 		add(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v, 1, n, 1);
 	}
 
+	// x的子树上，所有节点的值增加v
 	public static void subtreeAdd(int x, int v) {
 		add(dfn[x], dfn[x] + siz[x] - 1, v, 1, n, 1);
 	}
 
+	// 从x到y的路径上，查询所有节点的累加和
 	public static long pathSum(int x, int y) {
 		long ans = 0;
 		while (top[x] != top[y]) {
@@ -266,6 +273,7 @@ public static long pathSum(int x, int y) {
 		return ans;
 	}
 
+	// x的子树上，查询所有节点的累加和
 	public static long subtreeSum(int x) {
 		return query(dfn[x], dfn[x] + siz[x] - 1, 1, n, 1);
 	}

From ed5ce296b76089b3a973c3b03d2b03b9a72321f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 00:24:54 +0800
Subject: [PATCH 0504/1712] modify code

---
 src/class161/Code07_Network1.java | 47 ++++++++++++++++++-------------
 src/class161/Code07_Network2.java | 42 ++++++++++++++++-----------
 2 files changed, 53 insertions(+), 36 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index cb8d08553..e2c9270b9 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -12,10 +12,7 @@
 // 1 <= m <= 2 * 10^5
 // 重要度 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3250
-// 提交以下的code，提交时请把类名改成"Main"，会有一个测试用例超时
-// 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code07_Network2文件就是C++的实现
-// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -199,6 +196,17 @@ public static void dfs4() {
 		}
 	}
 
+	public static int lca(int a, int b) {
+		while (top[a] != top[b]) {
+			if (dep[top[a]] <= dep[top[b]]) {
+				b = fa[top[b]];
+			} else {
+				a = fa[top[a]];
+			}
+		}
+		return dep[a] <= dep[b] ? a : b;
+	}
+
 	public static void add(int i, int v) {
 		for (; i <= n; i += i & -i) {
 			tree[i] += v;
@@ -213,22 +221,19 @@ public static int query(int i) {
 		return sum;
 	}
 
-	public static void linkAdd(int x, int y, int v) {
-		add(x, v);
-		add(y + 1, -v);
-	}
-
 	public static void pathAdd(int x, int y, int v) {
-		while (top[x] != top[y]) {
-			if (dep[top[x]] <= dep[top[y]]) {
-				linkAdd(dfn[top[y]], dfn[y], v);
-				y = fa[top[y]];
-			} else {
-				linkAdd(dfn[top[x]], dfn[x], v);
-				x = fa[top[x]];
-			}
+		int xylca = lca(x, y);
+		int lcafa = fa[xylca];
+		add(dfn[x], v);
+		add(dfn[y], v);
+		add(dfn[xylca], -v);
+		if (lcafa != 0) {
+			add(dfn[lcafa], -v);
 		}
-		linkAdd(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v);
+	}
+
+	public static int pointQuery(int x) {
+		return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 	}
 
 	public static void clone(int[] event1, int[] event2) {
@@ -268,6 +273,9 @@ public static void prepare() {
 	}
 
 	public static void compute(int evtl, int evtr, int impl, int impr) {
+		if (evtl > evtr) {
+			return;
+		}
 		if (impl == impr) {
 			for (int i = evtl; i <= evtr; i++) {
 				if (events[i][0] > 0) {
@@ -295,8 +303,7 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 						clone(lset[++lsize], events[i]);
 					}
 				} else {
-					int sum = query(dfn[events[i][1]]);
-					if (sum != request) {
+					if (pointQuery(events[i][1]) != request) {
 						clone(rset[++rsize], events[i]);
 					} else {
 						clone(lset[++lsize], events[i]);
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index f0cf0f9e5..9f7c091dc 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -103,6 +103,17 @@
 //    }
 //}
 //
+//int lca(int a, int b) {
+//    while (top[a] != top[b]) {
+//        if (dep[top[a]] <= dep[top[b]]) {
+//            b = fa[top[b]];
+//        } else {
+//            a = fa[top[a]];
+//        }
+//    }
+//    return dep[a] <= dep[b] ? a : b;
+//}
+//
 //void add(int i, int v) {
 //    for (; i <= n; i += i & -i) {
 //        tree[i] += v;
@@ -117,22 +128,19 @@
 //    return sum;
 //}
 //
-//void linkAdd(int x, int y, int v) {
-//    add(x, v);
-//    add(y + 1, -v);
-//}
-//
 //void pathAdd(int x, int y, int v) {
-//    while (top[x] != top[y]) {
-//        if (dep[top[x]] <= dep[top[y]]) {
-//            linkAdd(dfn[top[y]], dfn[y], v);
-//            y = fa[top[y]];
-//        } else {
-//            linkAdd(dfn[top[x]], dfn[x], v);
-//            x = fa[top[x]];
-//        }
+//    int xylca = lca(x, y);
+//    int lcafa = fa[xylca];
+//    add(dfn[x], v);
+//    add(dfn[y], v);
+//    add(dfn[xylca], -v);
+//    if (lcafa != 0) {
+//    	add(dfn[lcafa], -v);
 //    }
-//    linkAdd(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v);
+//}
+//
+//int pointQuery(int x) {
+//    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 //}
 //
 //void clone(int *event1, int *event2) {
@@ -172,6 +180,9 @@
 //}
 //
 //void compute(int evtl, int evtr, int impl, int impr) {
+//    if(evtl > evtr) {
+//        return;
+//    }
 //    if (impl == impr) {
 //        for (int i = evtl; i <= evtr; i++) {
 //            if (events[i][0] > 0) {
@@ -199,8 +210,7 @@
 //                    clone(lset[++lsize], events[i]);
 //                }
 //            } else {
-//                int sum = query(dfn[events[i][1]]);
-//                if (sum != request) {
+//                if (pointQuery(events[i][1]) != request) {
 //                    clone(rset[++rsize], events[i]);
 //                } else {
 //                    clone(lset[++lsize], events[i]);

From 07b200630e23bb60970a0f156a13aa2706ce928e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 12:52:36 +0800
Subject: [PATCH 0505/1712] modify code

---
 src/class161/Code07_Network1.java | 2 +-
 src/class161/Code07_Network2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index e2c9270b9..a034a30a1 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -10,7 +10,7 @@
 //                如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
 // 2 <= n <= 10^5
 // 1 <= m <= 2 * 10^5
-// 重要度 <= 10^9
+// 1 <= 重要度 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3250
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 9f7c091dc..8f67dd3c4 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -10,7 +10,7 @@
 //                如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
 // 2 <= n <= 10^5
 // 1 <= m <= 2 * 10^5
-// 重要度 <= 10^9
+// 1 <= 重要度 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3250
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 797d88034da6605001cfd8d3c00a61a1cc2e9308 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 13:14:29 +0800
Subject: [PATCH 0506/1712] modify code

---
 src/class161/Code07_Network1.java | 30 +++++++++++++++---------------
 src/class161/Code07_Network2.java | 30 +++++++++++++++---------------
 2 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
index a034a30a1..cc19f228d 100644
--- a/src/class161/Code07_Network1.java
+++ b/src/class161/Code07_Network1.java
@@ -56,21 +56,6 @@ public class Code07_Network1 {
 	public static int[] ans = new int[MAXM];
 	public static int cntans = 0;
 
-	public static int kth(int num) {
-		int left = 1, right = s, mid;
-		while (left <= right) {
-			mid = (left + right) / 2;
-			if (sorted[mid] == num) {
-				return mid;
-			} else if (sorted[mid] < num) {
-				left = mid + 1;
-			} else {
-				right = mid - 1;
-			}
-		}
-		return -1;
-	}
-
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
@@ -236,6 +221,21 @@ public static int pointQuery(int x) {
 		return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 	}
 
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
 	public static void clone(int[] event1, int[] event2) {
 		event1[0] = event2[0];
 		event1[1] = event2[1];
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
index 8f67dd3c4..72e83d7c0 100644
--- a/src/class161/Code07_Network2.java
+++ b/src/class161/Code07_Network2.java
@@ -46,21 +46,6 @@
 //int ans[MAXM];
 //int cntans = 0;
 //
-//int kth(int num) {
-//    int left = 1, right = s, mid;
-//    while (left <= right) {
-//        mid = (left + right) / 2;
-//        if (sorted[mid] == num) {
-//            return mid;
-//        } else if (sorted[mid] < num) {
-//            left = mid + 1;
-//        } else {
-//            right = mid - 1;
-//        }
-//    }
-//    return -1;
-//}
-//
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
 //    to[cntg] = v;
@@ -143,6 +128,21 @@
 //    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 //}
 //
+//int kth(int num) {
+//    int left = 1, right = s, mid;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
 //void clone(int *event1, int *event2) {
 //    event1[0] = event2[0];
 //    event1[1] = event2[1];

From c78409cb1348d9d4d149606eac1d133a9fb3bfc5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 15:17:50 +0800
Subject: [PATCH 0507/1712] modify code

---
 src/class161/Code04_PackageManager1.java | 8 ++++----
 src/class161/Code04_PackageManager2.java | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
index 9d5a09dde..6613b5434 100644
--- a/src/class161/Code04_PackageManager1.java
+++ b/src/class161/Code04_PackageManager1.java
@@ -26,8 +26,6 @@ public class Code04_PackageManager1 {
 
 	public static int n, m;
 
-	public static int[] arr = new int[MAXN];
-
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
@@ -220,7 +218,9 @@ public static long query(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
-	public static void pathUpdate(int x, int y, int v) {
+	// 从1到x的路径上，所有节点值改成v
+	public static void pathUpdate(int x, int v) {
+		int y = 1;
 		while (top[x] != top[y]) {
 			if (dep[top[x]] <= dep[top[y]]) {
 				update(dfn[top[y]], dfn[y], v, 1, n, 1);
@@ -235,7 +235,7 @@ public static void pathUpdate(int x, int y, int v) {
 
 	public static int install(int x) {
 		int pre = sum[1];
-		pathUpdate(1, x, 1);
+		pathUpdate(x, 1);
 		int post = sum[1];
 		return Math.abs(post - pre);
 	}
diff --git a/src/class161/Code04_PackageManager2.java b/src/class161/Code04_PackageManager2.java
index c417bfc1d..02187672a 100644
--- a/src/class161/Code04_PackageManager2.java
+++ b/src/class161/Code04_PackageManager2.java
@@ -18,7 +18,6 @@
 //
 //const int MAXN = 100001;
 //int n, m;
-//int arr[MAXN];
 //
 //int head[MAXN];
 //int nxt[MAXN << 1];
@@ -115,7 +114,8 @@
 //    return ans;
 //}
 //
-//void pathUpdate(int x, int y, int v) {
+//void pathUpdate(int x, int v) {
+//    int y = 1;
 //    while (top[x] != top[y]) {
 //        if (dep[top[x]] <= dep[top[y]]) {
 //            updateRange(dfn[top[y]], dfn[y], v, 1, n, 1);
@@ -130,7 +130,7 @@
 //
 //int install(int x) {
 //    int pre = sum[1];
-//    pathUpdate(1, x, 1);
+//    pathUpdate(x, 1);
 //    int post = sum[1];
 //    return abs(post - pre);
 //}

From d5492db42c9587fbd6a873572567c37e2d342161 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 15:19:39 +0800
Subject: [PATCH 0508/1712] modify code

---
 src/class161/Code04_PackageManager1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
index 6613b5434..19cd5bfa6 100644
--- a/src/class161/Code04_PackageManager1.java
+++ b/src/class161/Code04_PackageManager1.java
@@ -172,6 +172,7 @@ public static void up(int i) {
 		sum[i] = sum[i << 1] + sum[i << 1 | 1];
 	}
 
+	// 线段树重置操作的懒更新
 	public static void lazy(int i, int v, int n) {
 		sum[i] = v * n;
 		update[i] = true;

From 600e5c6333a3ca7c5fcb864132e23e60fb9a7927 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 16:23:56 +0800
Subject: [PATCH 0509/1712] modify code

---
 src/class161/Code05_Coloring1.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
index abbe638fc..fe7cb508e 100644
--- a/src/class161/Code05_Coloring1.java
+++ b/src/class161/Code05_Coloring1.java
@@ -46,6 +46,9 @@ public class Code05_Coloring1 {
 	public static int[] sum = new int[MAXN << 2];
 	public static int[] lcolor = new int[MAXN << 2];
 	public static int[] rcolor = new int[MAXN << 2];
+	// change是线段树的懒更新信息
+	// change[i] == 0 代表没有懒更新信息
+	// change[i] != 0 代表颜色重置为change[i]
 	public static int[] change = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
@@ -247,6 +250,7 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 		}
 	}
 
+	// 查询单点颜色，jobi为节点的dfn序号
 	public static int pointColor(int jobi, int l, int r, int i) {
 		if (l == r) {
 			return lcolor[i];

From b04e422925b3522b254916d28bd33a0f239e7265 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 16:35:26 +0800
Subject: [PATCH 0510/1712] modify code

---
 src/class161/Code06_Tourism1.java | 37 +++++++++++++++++++++----------
 src/class161/Code06_Tourism2.java | 23 +++++++++----------
 2 files changed, 36 insertions(+), 24 deletions(-)

diff --git a/src/class161/Code06_Tourism1.java b/src/class161/Code06_Tourism1.java
index 1cd06db73..ff3876c2e 100644
--- a/src/class161/Code06_Tourism1.java
+++ b/src/class161/Code06_Tourism1.java
@@ -225,6 +225,15 @@ public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
 		}
 	}
 
+	// ans[0] : 线段树更左侧部分的max
+	// ans[1] : 线段树更左侧部分的min
+	// ans[2] : 线段树更左侧部分的lprofit
+	// ans[3] : 线段树更左侧部分的rprofit
+	// rmax : 线段树更右侧部分的max
+	// rmin : 线段树更右侧部分的min
+	// rlpro : 线段树更右侧部分的lprofit
+	// rrpro : 线段树更右侧部分的rprofit
+	// 左侧部分和右侧部分的信息整合在一起得到整个范围的max、min、lprofit、rprofit
 	public static void merge(int[] ans, int rmax, int rmin, int rlpro, int rrpro) {
 		int lmax = ans[0];
 		int lmin = ans[1];
@@ -236,6 +245,11 @@ public static void merge(int[] ans, int rmax, int rmin, int rlpro, int rrpro) {
 		ans[3] = Math.max(Math.max(lrpro, rrpro), lmax - rmin);
 	}
 
+	// ans[0] : 线段树更左侧部分的max
+	// ans[1] : 线段树更左侧部分的min
+	// ans[2] : 线段树更左侧部分的lprofit
+	// ans[3] : 线段树更左侧部分的rprofit
+	// 随着线段树查询的展开，会有更右部分的信息整合进ans，最终整合出整体信息
 	public static void query(int[] ans, int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			merge(ans, max[i], min[i], lprofit[i], rprofit[i]);
@@ -259,6 +273,13 @@ public static void query(int[] ans, int jobl, int jobr) {
 		query(ans, jobl, jobr, 1, n, 1);
 	}
 
+	public static void clone(int[] a, int[] b) {
+		a[0] = b[0];
+		a[1] = b[1];
+		a[2] = b[2];
+		a[3] = b[3];
+	}
+
 	public static int compute(int x, int y, int v) {
 		int tmpx = x, tmpy = y;
 		int[] xpath = new int[] { -INF, INF, 0, 0 };
@@ -268,31 +289,23 @@ public static int compute(int x, int y, int v) {
 			if (dep[top[x]] <= dep[top[y]]) {
 				query(cur, dfn[top[y]], dfn[y]);
 				merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-				for (int i = 0; i <= 3; i++) {
-					ypath[i] = cur[i];
-				}
+				clone(ypath, cur);
 				y = fa[top[y]];
 			} else {
 				query(cur, dfn[top[x]], dfn[x]);
 				merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-				for (int i = 0; i <= 3; i++) {
-					xpath[i] = cur[i];
-				}
+				clone(xpath, cur);
 				x = fa[top[x]];
 			}
 		}
 		if (dep[x] <= dep[y]) {
 			query(cur, dfn[x], dfn[y]);
 			merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-			for (int i = 0; i <= 3; i++) {
-				ypath[i] = cur[i];
-			}
+			clone(ypath, cur);
 		} else {
 			query(cur, dfn[y], dfn[x]);
 			merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-			for (int i = 0; i <= 3; i++) {
-				xpath[i] = cur[i];
-			}
+			clone(xpath, cur);
 		}
 		int ans = Math.max(Math.max(xpath[3], ypath[2]), ypath[0] - xpath[1]);
 		x = tmpx;
diff --git a/src/class161/Code06_Tourism2.java b/src/class161/Code06_Tourism2.java
index a7d692925..047cdfa4b 100644
--- a/src/class161/Code06_Tourism2.java
+++ b/src/class161/Code06_Tourism2.java
@@ -169,6 +169,13 @@
 //    query(ans, jobl, jobr, 1, n, 1);
 //}
 //
+//void clone(int *a, int *b) {
+//    a[0] = b[0];
+//    a[1] = b[1];
+//    a[2] = b[2];
+//    a[3] = b[3];
+//}
+//
 //int compute(int x, int y, int v) {
 //    int tmpx = x;
 //    int tmpy = y;
@@ -179,31 +186,23 @@
 //        if (dep[top[x]] <= dep[top[y]]) {
 //            query(cur, dfn[top[y]], dfn[y]);
 //            merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-//            for (int i = 0; i <= 3; i++) {
-//                ypath[i] = cur[i];
-//            }
+//            clone(ypath, cur);
 //            y = fa[top[y]];
 //        } else {
 //            query(cur, dfn[top[x]], dfn[x]);
 //            merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-//            for (int i = 0; i <= 3; i++) {
-//                xpath[i] = cur[i];
-//            }
+//            clone(xpath, cur);
 //            x = fa[top[x]];
 //        }
 //    }
 //    if (dep[x] <= dep[y]) {
 //        query(cur, dfn[x], dfn[y]);
 //        merge(cur, ypath[0], ypath[1], ypath[2], ypath[3]);
-//        for (int i = 0; i <= 3; i++) {
-//            ypath[i] = cur[i];
-//        }
+//        clone(ypath, cur);
 //    } else {
 //        query(cur, dfn[y], dfn[x]);
 //        merge(cur, xpath[0], xpath[1], xpath[2], xpath[3]);
-//        for (int i = 0; i <= 3; i++) {
-//            xpath[i] = cur[i];
-//        }
+//        clone(xpath, cur);
 //    }
 //    int ans = max({xpath[3], ypath[2], ypath[0] - xpath[1]});
 //    x = tmpx;

From 4f4188393b92067b16b69def2bc2089f2917bcfb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Mar 2025 18:22:00 +0800
Subject: [PATCH 0511/1712] modify code

---
 src/class161/Code06_Tourism1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class161/Code06_Tourism1.java b/src/class161/Code06_Tourism1.java
index ff3876c2e..adf45126f 100644
--- a/src/class161/Code06_Tourism1.java
+++ b/src/class161/Code06_Tourism1.java
@@ -47,6 +47,7 @@ public class Code06_Tourism1 {
 	public static int[] min = new int[MAXN << 2];
 	public static int[] lprofit = new int[MAXN << 2];
 	public static int[] rprofit = new int[MAXN << 2];
+	// 线段树范围增加的懒更新信息
 	public static int[] addTag = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {

From 2c4e023d97e206c44020035a2efd96dc12cdebe3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 15:15:52 +0800
Subject: [PATCH 0512/1712] modify code

---
 src/class161/Code07_FarAway1.java | 334 +++++++++++++++++++++++++++
 src/class161/Code07_FarAway2.java | 222 ++++++++++++++++++
 src/class161/Code07_Network1.java | 369 ------------------------------
 src/class161/Code07_Network2.java | 260 ---------------------
 4 files changed, 556 insertions(+), 629 deletions(-)
 create mode 100644 src/class161/Code07_FarAway1.java
 create mode 100644 src/class161/Code07_FarAway2.java
 delete mode 100644 src/class161/Code07_Network1.java
 delete mode 100644 src/class161/Code07_Network2.java

diff --git a/src/class161/Code07_FarAway1.java b/src/class161/Code07_FarAway1.java
new file mode 100644
index 000000000..6a206afa3
--- /dev/null
+++ b/src/class161/Code07_FarAway1.java
@@ -0,0 +1,334 @@
+package class161;
+
+// 遥远的国度，java版
+// 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的初始头节点，给定每个点的点权
+// 一共有m条操作，每种操作是如下3种类型中的一种
+// 操作 1 x     : 树的头节点变成x，树的形态重新组织
+// 操作 2 x y v : x到y的路径上，所有节点的值改成v
+// 操作 3 x     : 当前树的形态下，打印x的子树最小值
+// 1 <= n、m <= 10^5
+// 任何时候节点值一定是正数
+// 测试链接 : https://www.luogu.com.cn/problem/P3979
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code07_FarAway1 {
+
+	public static int MAXN = 100001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[] seg = new int[MAXN];
+	public static int cntd = 0;
+
+	public static int[] min = new int[MAXN << 2];
+	// 重置操作的懒更新信息
+	// 因为题目说了，任何时候节点值一定是正数
+	// change[i] == 0，表示没有重置懒更新
+	// change[i] != 0，表示范围内的数字修改为change[i]
+	public static int[] change = new int[MAXN << 2];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				seg[cntd] = first;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void up(int i) {
+		min[i] = Math.min(min[i << 1], min[i << 1 | 1]);
+	}
+
+	public static void lazy(int i, int v) {
+		min[i] = v;
+		change[i] = v;
+	}
+
+	public static void down(int i) {
+		if (change[i] != 0) {
+			lazy(i << 1, change[i]);
+			lazy(i << 1 | 1, change[i]);
+			change[i] = 0;
+		}
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			min[i] = arr[seg[l]];
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void update(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i, jobv);
+		} else {
+			down(i);
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				update(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				update(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return min[i];
+		}
+		down(i);
+		int mid = (l + r) / 2;
+		int ans = Integer.MAX_VALUE;
+		if (jobl <= mid) {
+			ans = Math.min(ans, query(jobl, jobr, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.min(ans, query(jobl, jobr, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static void pathUpdate(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				update(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				update(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		update(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v, 1, n, 1);
+	}
+
+	// 判断root和u的关系
+	// 如果root和u是同一个点，返回-1
+	// 如果root不在u的子树上，返回0
+	// 如果root在u的子树上，找到u的哪个儿子的子树里有root，返回那个儿子的编号
+	public static int find(int root, int u) {
+		if (u == root) {
+			return -1;
+		}
+		if (dfn[root] < dfn[u] || dfn[u] + siz[u] <= dfn[root]) {
+			return 0;
+		}
+		while (top[root] != top[u]) {
+			if (fa[top[root]] == u) {
+				return top[root];
+			}
+			root = fa[top[root]];
+		}
+		return son[u];
+	}
+
+	// 假设树的头节点变成root，查询在变化后的树中，u的子树中，最小值是多少
+	public static int treeQuery(int root, int u) {
+		int uson = find(root, u);
+		if (uson == -1) {
+			return min[1];
+		} else if (uson == 0) {
+			return query(dfn[u], dfn[u] + siz[u] - 1, 1, n, 1);
+		} else {
+			int ans = query(1, dfn[uson] - 1, 1, n, 1);
+			if (dfn[uson] + siz[uson] <= n) {
+				ans = Math.min(ans, query(dfn[uson] + siz[uson], n, 1, n, 1));
+			}
+			return ans;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		dfs3(); // dfs3() 等同于 dfs1(1, 0)，调用迭代版防止爆栈
+		dfs4(); // dfs4() 等同于 dfs2(1, 1)，调用迭代版防止爆栈
+		build(1, n, 1);
+		in.nextToken();
+		int root = (int) in.nval;
+		for (int i = 1, op, x, y, v; i <= m; i++) {
+			in.nextToken();
+			op = (int) in.nval;
+			if (op == 1) {
+				in.nextToken();
+				root = (int) in.nval;
+			} else if (op == 2) {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				in.nextToken();
+				v = (int) in.nval;
+				pathUpdate(x, y, v);
+			} else {
+				in.nextToken();
+				x = (int) in.nval;
+				out.println(treeQuery(root, x));
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class161/Code07_FarAway2.java b/src/class161/Code07_FarAway2.java
new file mode 100644
index 000000000..e59c7253b
--- /dev/null
+++ b/src/class161/Code07_FarAway2.java
@@ -0,0 +1,222 @@
+package class161;
+
+// 遥远的国度，C++版
+// 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的初始头节点，给定每个点的点权
+// 一共有m条操作，每种操作是如下3种类型中的一种
+// 操作 1 x     : 树的头节点变成x，树的形态重新组织
+// 操作 2 x y v : x到y的路径上，所有节点的值改成v
+// 操作 3 x     : 当前树的形态下，打印x的子树最小值
+// 1 <= n、m <= 10^5
+// 任何时候节点值一定是正数
+// 测试链接 : https://www.luogu.com.cn/problem/P3979
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int seg[MAXN];
+//int cntd = 0;
+//
+//int minv[MAXN << 2];
+//int change[MAXN << 2];
+//
+//void addEdge(int u, int v) {
+//    ++cntg;
+//    nxt[cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void up(int i) {
+//    minv[i] = min(minv[i << 1], minv[i << 1 | 1]);
+//}
+//
+//void lazy(int i, int v) {
+//    minv[i] = v;
+//    change[i] = v;
+//}
+//
+//void down(int i) {
+//    if (change[i] != 0) {
+//        lazy(i << 1, change[i]);
+//        lazy(i << 1 | 1, change[i]);
+//        change[i] = 0;
+//    }
+//}
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//        minv[i] = arr[seg[l]];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//        up(i);
+//    }
+//}
+//
+//void update(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        lazy(i, jobv);
+//    } else {
+//        down(i);
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//        	update(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//        	update(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return minv[i];
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    int ans = INT_MAX;
+//    if (jobl <= mid) {
+//        ans = min(ans, query(jobl, jobr, l, mid, i << 1));
+//    }
+//    if (jobr > mid) {
+//        ans = min(ans, query(jobl, jobr, mid + 1, r, i << 1 | 1));
+//    }
+//    return ans;
+//}
+//
+//void pathUpdate(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            update(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            update(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    update(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v, 1, n, 1);
+//}
+//
+//int find(int root, int u) {
+//    if (u == root) {
+//        return -1;
+//    }
+//    if (dfn[root] < dfn[u] || dfn[u] + siz[u] <= dfn[root]) {
+//        return 0;
+//    }
+//    while (top[root] != top[u]) {
+//        if (fa[top[root]] == u) {
+//            return top[root];
+//        }
+//        root = fa[top[root]];
+//    }
+//    return son[u];
+//}
+//
+//int treeQuery(int root, int u) {
+//    int uson = find(root, u);
+//    if (uson == -1) {
+//        return minv[1];
+//    } else if (uson == 0) {
+//        return query(dfn[u], dfn[u] + siz[u] - 1, 1, n, 1);
+//    } else {
+//        int ans = INT_MAX;
+//        if (1 <= dfn[uson] - 1) {
+//            ans = min(ans, query(1, dfn[uson] - 1, 1, n, 1));
+//        }
+//        if (dfn[uson] + siz[uson] <= n) {
+//            ans = min(ans, query(dfn[uson] + siz[uson], n, 1, n, 1));
+//        }
+//        return ans;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i < n; i++) {
+//        int u, v;
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    build(1, n, 1);
+//    int root;
+//    cin >> root;
+//    for (int i = 1, op, x, y, v; i <= m; i++) {
+//        cin >> op;
+//        if (op == 1) {
+//            cin >> root;
+//        } else if (op == 2) {
+//            cin >> x >> y >> v;
+//            pathUpdate(x, y, v);
+//        } else {
+//            cin >> x;
+//            cout << treeQuery(root, x) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class161/Code07_Network1.java b/src/class161/Code07_Network1.java
deleted file mode 100644
index cc19f228d..000000000
--- a/src/class161/Code07_Network1.java
+++ /dev/null
@@ -1,369 +0,0 @@
-package class161;
-
-// 网络，java版
-// 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
-// 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
-// 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
-// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
-// 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
-// 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
-//                如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
-// 2 <= n <= 10^5
-// 1 <= m <= 2 * 10^5
-// 1 <= 重要度 <= 10^9
-// 测试链接 : https://www.luogu.com.cn/problem/P3250
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.StreamTokenizer;
-import java.util.Arrays;
-
-public class Code07_Network1 {
-
-	public static int MAXN = 100001;
-
-	public static int MAXM = 200001;
-
-	public static int n, m;
-
-	public static int[] head = new int[MAXN];
-	public static int[] next = new int[MAXN << 1];
-	public static int[] to = new int[MAXN << 1];
-	public static int cntg = 0;
-
-	public static int[] fa = new int[MAXN];
-	public static int[] dep = new int[MAXN];
-	public static int[] siz = new int[MAXN];
-	public static int[] son = new int[MAXN];
-	public static int[] top = new int[MAXN];
-	public static int[] dfn = new int[MAXN];
-	public static int cntd = 0;
-
-	// 树状数组
-	public static int[] tree = new int[MAXN];
-
-	// 从早到晚发生的事件
-	public static int[][] events = new int[MAXM][4];
-	public static int[] sorted = new int[MAXM];
-	public static int s = 0;
-
-	public static int[][] lset = new int[MAXM][4];
-	public static int[][] rset = new int[MAXM][4];
-	public static int[] ans = new int[MAXM];
-	public static int cntans = 0;
-
-	public static void addEdge(int u, int v) {
-		next[++cntg] = head[u];
-		to[cntg] = v;
-		head[u] = cntg;
-	}
-
-	// 递归版，C++可以通过，java会爆栈
-	public static void dfs1(int u, int f) {
-		fa[u] = f;
-		dep[u] = dep[f] + 1;
-		siz[u] = 1;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				dfs1(v, u);
-			}
-		}
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				siz[u] += siz[v];
-				if (son[u] == 0 || siz[son[u]] < siz[v]) {
-					son[u] = v;
-				}
-			}
-		}
-	}
-
-	// 递归版，C++可以通过，java会爆栈
-	public static void dfs2(int u, int t) {
-		top[u] = t;
-		dfn[u] = ++cntd;
-		if (son[u] == 0) {
-			return;
-		}
-		dfs2(son[u], t);
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != fa[u] && v != son[u]) {
-				dfs2(v, v);
-			}
-		}
-	}
-
-	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	public static int[][] fse = new int[MAXN][3];
-
-	public static int stacksize, first, second, edge;
-
-	public static void push(int fir, int sec, int edg) {
-		fse[stacksize][0] = fir;
-		fse[stacksize][1] = sec;
-		fse[stacksize][2] = edg;
-		stacksize++;
-	}
-
-	public static void pop() {
-		--stacksize;
-		first = fse[stacksize][0];
-		second = fse[stacksize][1];
-		edge = fse[stacksize][2];
-	}
-
-	// dfs1的迭代版
-	public static void dfs3() {
-		stacksize = 0;
-		push(1, 0, -1);
-		while (stacksize > 0) {
-			pop();
-			if (edge == -1) {
-				fa[first] = second;
-				dep[first] = dep[second] + 1;
-				siz[first] = 1;
-				edge = head[first];
-			} else {
-				edge = next[edge];
-			}
-			if (edge != 0) {
-				push(first, second, edge);
-				if (to[edge] != second) {
-					push(to[edge], first, -1);
-				}
-			} else {
-				for (int e = head[first], v; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != second) {
-						siz[first] += siz[v];
-						if (son[first] == 0 || siz[son[first]] < siz[v]) {
-							son[first] = v;
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// dfs2的迭代版
-	public static void dfs4() {
-		stacksize = 0;
-		push(1, 1, -1);
-		while (stacksize > 0) {
-			pop();
-			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
-				top[first] = second;
-				dfn[first] = ++cntd;
-				if (son[first] == 0) {
-					continue;
-				}
-				push(first, second, -2);
-				push(son[first], second, -1);
-				continue;
-			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
-				edge = head[first];
-			} else { // edge >= 0, 继续处理其他的边
-				edge = next[edge];
-			}
-			if (edge != 0) {
-				push(first, second, edge);
-				if (to[edge] != fa[first] && to[edge] != son[first]) {
-					push(to[edge], to[edge], -1);
-				}
-			}
-		}
-	}
-
-	public static int lca(int a, int b) {
-		while (top[a] != top[b]) {
-			if (dep[top[a]] <= dep[top[b]]) {
-				b = fa[top[b]];
-			} else {
-				a = fa[top[a]];
-			}
-		}
-		return dep[a] <= dep[b] ? a : b;
-	}
-
-	public static void add(int i, int v) {
-		for (; i <= n; i += i & -i) {
-			tree[i] += v;
-		}
-	}
-
-	public static int query(int i) {
-		int sum = 0;
-		for (; i > 0; i -= i & -i) {
-			sum += tree[i];
-		}
-		return sum;
-	}
-
-	public static void pathAdd(int x, int y, int v) {
-		int xylca = lca(x, y);
-		int lcafa = fa[xylca];
-		add(dfn[x], v);
-		add(dfn[y], v);
-		add(dfn[xylca], -v);
-		if (lcafa != 0) {
-			add(dfn[lcafa], -v);
-		}
-	}
-
-	public static int pointQuery(int x) {
-		return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
-	}
-
-	public static int kth(int num) {
-		int left = 1, right = s, mid;
-		while (left <= right) {
-			mid = (left + right) / 2;
-			if (sorted[mid] == num) {
-				return mid;
-			} else if (sorted[mid] < num) {
-				left = mid + 1;
-			} else {
-				right = mid - 1;
-			}
-		}
-		return -1;
-	}
-
-	public static void clone(int[] event1, int[] event2) {
-		event1[0] = event2[0];
-		event1[1] = event2[1];
-		event1[2] = event2[2];
-		event1[3] = event2[3];
-	}
-
-	public static void prepare() {
-		dfs3(); // dfs3() 等同于 dfs1(1, 0)，调用迭代版防止爆栈
-		dfs4(); // dfs4() 等同于 dfs2(1, 1)，调用迭代版防止爆栈
-		sorted[0] = -1;
-		for (int i = 1; i <= m; i++) {
-			if (events[i][0] == 0) {
-				sorted[++s] = events[i][3];
-			}
-		}
-		Arrays.sort(sorted, 1, s + 1);
-		int len = 1;
-		for (int i = 2; i <= s; i++) {
-			if (sorted[len] != sorted[i]) {
-				sorted[++len] = sorted[i];
-			}
-		}
-		s = len;
-		for (int i = 1; i <= m; i++) {
-			if (events[i][0] == 0) {
-				events[i][3] = kth(events[i][3]);
-			} else if (events[i][0] == 1) {
-				clone(events[i], events[events[i][1]]);
-				events[i][0] = -1;
-			} else {
-				events[i][0] = ++cntans;
-			}
-		}
-	}
-
-	public static void compute(int evtl, int evtr, int impl, int impr) {
-		if (evtl > evtr) {
-			return;
-		}
-		if (impl == impr) {
-			for (int i = evtl; i <= evtr; i++) {
-				if (events[i][0] > 0) {
-					ans[events[i][0]] = impl;
-				}
-			}
-		} else {
-			int impm = (impl + impr) / 2;
-			int lsize = 0, rsize = 0, request = 0;
-			for (int i = evtl; i <= evtr; i++) {
-				if (events[i][0] == 0) {
-					if (events[i][3] > impm) {
-						pathAdd(events[i][1], events[i][2], 1);
-						clone(rset[++rsize], events[i]);
-						request++;
-					} else {
-						clone(lset[++lsize], events[i]);
-					}
-				} else if (events[i][0] == -1) {
-					if (events[i][3] > impm) {
-						pathAdd(events[i][1], events[i][2], -1);
-						clone(rset[++rsize], events[i]);
-						request--;
-					} else {
-						clone(lset[++lsize], events[i]);
-					}
-				} else {
-					if (pointQuery(events[i][1]) != request) {
-						clone(rset[++rsize], events[i]);
-					} else {
-						clone(lset[++lsize], events[i]);
-					}
-				}
-			}
-			for (int i = 1; i <= rsize; i++) {
-				if (rset[i][0] == 0 && rset[i][3] > impm) {
-					pathAdd(rset[i][1], rset[i][2], -1);
-				}
-				if (rset[i][0] == -1 && rset[i][3] > impm) {
-					pathAdd(rset[i][1], rset[i][2], 1);
-				}
-			}
-			for (int i = evtl, j = 1; j <= lsize; i++, j++) {
-				clone(events[i], lset[j]);
-			}
-			for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
-				clone(events[i], rset[j]);
-			}
-			compute(evtl, evtl + lsize - 1, impl, impm);
-			compute(evtl + lsize, evtr, impm + 1, impr);
-		}
-	}
-
-	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		n = (int) in.nval;
-		in.nextToken();
-		m = (int) in.nval;
-		for (int i = 1, u, v; i < n; i++) {
-			in.nextToken();
-			u = (int) in.nval;
-			in.nextToken();
-			v = (int) in.nval;
-			addEdge(u, v);
-			addEdge(v, u);
-		}
-		for (int i = 1; i <= m; i++) {
-			in.nextToken();
-			events[i][0] = (int) in.nval;
-			in.nextToken();
-			events[i][1] = (int) in.nval;
-			if (events[i][0] == 0) {
-				in.nextToken();
-				events[i][2] = (int) in.nval;
-				in.nextToken();
-				events[i][3] = (int) in.nval;
-			}
-		}
-		prepare();
-		compute(1, m, 0, s);
-		for (int i = 1; i <= cntans; i++) {
-			out.println(sorted[ans[i]]);
-		}
-		out.flush();
-		out.close();
-	}
-
-}
diff --git a/src/class161/Code07_Network2.java b/src/class161/Code07_Network2.java
deleted file mode 100644
index 72e83d7c0..000000000
--- a/src/class161/Code07_Network2.java
+++ /dev/null
@@ -1,260 +0,0 @@
-package class161;
-
-// 网络，C++版
-// 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
-// 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
-// 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
-// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
-// 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
-// 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
-//                如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
-// 2 <= n <= 10^5
-// 1 <= m <= 2 * 10^5
-// 1 <= 重要度 <= 10^9
-// 测试链接 : https://www.luogu.com.cn/problem/P3250
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//const int MAXN = 100001;
-//const int MAXM = 200001;
-//int n, m;
-//int head[MAXN];
-//int nxt[MAXN << 1];
-//int to[MAXN << 1];
-//int cntg = 0;
-//
-//int fa[MAXN];
-//int dep[MAXN];
-//int siz[MAXN];
-//int son[MAXN];
-//int top[MAXN];
-//int dfn[MAXN];
-//int cntd = 0;
-//
-//int tree[MAXN];
-//
-//int events[MAXM][4];
-//int sorted[MAXM];
-//int s = 0;
-//
-//int lset[MAXM][4];
-//int rset[MAXM][4];
-//int ans[MAXM];
-//int cntans = 0;
-//
-//void addEdge(int u, int v) {
-//    nxt[++cntg] = head[u];
-//    to[cntg] = v;
-//    head[u] = cntg;
-//}
-//
-//void dfs1(int u, int f) {
-//    fa[u] = f;
-//    dep[u] = dep[f] + 1;
-//    siz[u] = 1;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
-//    }
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
-//        }
-//    }
-//}
-//
-//void dfs2(int u, int t) {
-//    top[u] = t;
-//    dfn[u] = ++cntd;
-//    if (son[u] == 0) {
-//        return;
-//    }
-//    dfs2(son[u], t);
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != fa[u] && v != son[u]) {
-//            dfs2(v, v);
-//        }
-//    }
-//}
-//
-//int lca(int a, int b) {
-//    while (top[a] != top[b]) {
-//        if (dep[top[a]] <= dep[top[b]]) {
-//            b = fa[top[b]];
-//        } else {
-//            a = fa[top[a]];
-//        }
-//    }
-//    return dep[a] <= dep[b] ? a : b;
-//}
-//
-//void add(int i, int v) {
-//    for (; i <= n; i += i & -i) {
-//        tree[i] += v;
-//    }
-//}
-//
-//int query(int i) {
-//    int sum = 0;
-//    for (; i > 0; i -= i & -i) {
-//        sum += tree[i];
-//    }
-//    return sum;
-//}
-//
-//void pathAdd(int x, int y, int v) {
-//    int xylca = lca(x, y);
-//    int lcafa = fa[xylca];
-//    add(dfn[x], v);
-//    add(dfn[y], v);
-//    add(dfn[xylca], -v);
-//    if (lcafa != 0) {
-//    	add(dfn[lcafa], -v);
-//    }
-//}
-//
-//int pointQuery(int x) {
-//    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
-//}
-//
-//int kth(int num) {
-//    int left = 1, right = s, mid;
-//    while (left <= right) {
-//        mid = (left + right) / 2;
-//        if (sorted[mid] == num) {
-//            return mid;
-//        } else if (sorted[mid] < num) {
-//            left = mid + 1;
-//        } else {
-//            right = mid - 1;
-//        }
-//    }
-//    return -1;
-//}
-//
-//void clone(int *event1, int *event2) {
-//    event1[0] = event2[0];
-//    event1[1] = event2[1];
-//    event1[2] = event2[2];
-//    event1[3] = event2[3];
-//}
-//
-//void prepare() {
-//    dfs1(1, 0);
-//    dfs2(1, 1);
-//    sorted[0] = -1;
-//    for (int i = 1; i <= m; i++) {
-//        if (events[i][0] == 0) {
-//            sorted[++s] = events[i][3];
-//        }
-//    }
-//    sort(sorted + 1, sorted + s + 1);
-//    int len = 1;
-//    for (int i = 2; i <= s; i++) {
-//        if (sorted[len] != sorted[i]) {
-//            sorted[++len] = sorted[i];
-//        }
-//    }
-//    s = len;
-//    for (int i = 1; i <= m; i++) {
-//        if (events[i][0] == 0) {
-//            events[i][3] = kth(events[i][3]);
-//        } else if (events[i][0] == 1) {
-//            clone(events[i], events[events[i][1]]);
-//            events[i][0] = -1;
-//        } else {
-//            events[i][0] = ++cntans;
-//        }
-//    }
-//}
-//
-//void compute(int evtl, int evtr, int impl, int impr) {
-//    if(evtl > evtr) {
-//        return;
-//    }
-//    if (impl == impr) {
-//        for (int i = evtl; i <= evtr; i++) {
-//            if (events[i][0] > 0) {
-//                ans[events[i][0]] = impl;
-//            }
-//        }
-//    } else {
-//        int impm = (impl + impr) / 2;
-//        int lsize = 0, rsize = 0, request = 0;
-//        for (int i = evtl; i <= evtr; i++) {
-//            if (events[i][0] == 0) {
-//                if (events[i][3] > impm) {
-//                    pathAdd(events[i][1], events[i][2], 1);
-//                    clone(rset[++rsize], events[i]);
-//                    request++;
-//                } else {
-//                    clone(lset[++lsize], events[i]);
-//                }
-//            } else if (events[i][0] == -1) {
-//                if (events[i][3] > impm) {
-//                    pathAdd(events[i][1], events[i][2], -1);
-//                    clone(rset[++rsize], events[i]);
-//                    request--;
-//                } else {
-//                    clone(lset[++lsize], events[i]);
-//                }
-//            } else {
-//                if (pointQuery(events[i][1]) != request) {
-//                    clone(rset[++rsize], events[i]);
-//                } else {
-//                    clone(lset[++lsize], events[i]);
-//                }
-//            }
-//        }
-//        for (int i = 1; i <= rsize; i++) {
-//            if (rset[i][0] == 0 && rset[i][3] > impm) {
-//                pathAdd(rset[i][1], rset[i][2], -1);
-//            }
-//            if (rset[i][0] == -1 && rset[i][3] > impm) {
-//                pathAdd(rset[i][1], rset[i][2], 1);
-//            }
-//        }
-//        for (int i = evtl, j = 1; j <= lsize; i++, j++) {
-//            clone(events[i], lset[j]);
-//        }
-//        for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
-//            clone(events[i], rset[j]);
-//        }
-//        compute(evtl, evtl + lsize - 1, impl, impm);
-//        compute(evtl + lsize, evtr, impm + 1, impr);
-//    }
-//}
-//
-//int main() {
-//    scanf("%d%d", &n, &m);
-//    for(int i = 1; i < n; i++) {
-//        int u, v;
-//        scanf("%d%d", &u, &v);
-//        addEdge(u, v);
-//        addEdge(v, u);
-//    }
-//    for(int i = 1; i <= m; i++) {
-//        scanf("%d", &events[i][0]);
-//        scanf("%d", &events[i][1]);
-//        if(events[i][0] == 0) {
-//            scanf("%d%d", &events[i][2], &events[i][3]);
-//        }
-//    }
-//    prepare();
-//    compute(1, m, 0, s);
-//    for(int i = 1; i <= cntans; i++) {
-//        printf("%d\n", sorted[ans[i]]);
-//    }
-//    return 0;
-//}
\ No newline at end of file

From 5ae81ca90486c7185e3f808890f619498ce1f953 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 15:24:39 +0800
Subject: [PATCH 0513/1712] modify code

---
 src/class161/Code07_FarAway1.java | 4 ++--
 src/class161/Code07_FarAway2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class161/Code07_FarAway1.java b/src/class161/Code07_FarAway1.java
index 6a206afa3..7a28a0b01 100644
--- a/src/class161/Code07_FarAway1.java
+++ b/src/class161/Code07_FarAway1.java
@@ -5,7 +5,7 @@
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 1 x     : 树的头节点变成x，树的形态重新组织
 // 操作 2 x y v : x到y的路径上，所有节点的值改成v
-// 操作 3 x     : 当前树的形态下，打印x的子树最小值
+// 操作 3 x     : 当前树的形态下，打印u的子树中的最小值
 // 1 <= n、m <= 10^5
 // 任何时候节点值一定是正数
 // 测试链接 : https://www.luogu.com.cn/problem/P3979
@@ -265,7 +265,7 @@ public static int find(int root, int u) {
 		return son[u];
 	}
 
-	// 假设树的头节点变成root，查询在变化后的树中，u的子树中，最小值是多少
+	// 假设树的头节点变成root，当前树的形态下，查询u的子树中的最小值
 	public static int treeQuery(int root, int u) {
 		int uson = find(root, u);
 		if (uson == -1) {
diff --git a/src/class161/Code07_FarAway2.java b/src/class161/Code07_FarAway2.java
index e59c7253b..846c653d5 100644
--- a/src/class161/Code07_FarAway2.java
+++ b/src/class161/Code07_FarAway2.java
@@ -5,7 +5,7 @@
 // 一共有m条操作，每种操作是如下3种类型中的一种
 // 操作 1 x     : 树的头节点变成x，树的形态重新组织
 // 操作 2 x y v : x到y的路径上，所有节点的值改成v
-// 操作 3 x     : 当前树的形态下，打印x的子树最小值
+// 操作 3 x     : 当前树的形态下，打印u的子树中的最小值
 // 1 <= n、m <= 10^5
 // 任何时候节点值一定是正数
 // 测试链接 : https://www.luogu.com.cn/problem/P3979

From 86175db0899e184fb4882937e7e0f543cce8d47d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 15:33:26 +0800
Subject: [PATCH 0514/1712] modify code

---
 src/class161/Code07_FarAway1.java | 20 ++++++--------------
 src/class161/Code07_FarAway2.java | 14 ++++----------
 2 files changed, 10 insertions(+), 24 deletions(-)

diff --git a/src/class161/Code07_FarAway1.java b/src/class161/Code07_FarAway1.java
index 7a28a0b01..72e57bf1f 100644
--- a/src/class161/Code07_FarAway1.java
+++ b/src/class161/Code07_FarAway1.java
@@ -245,17 +245,9 @@ public static void pathUpdate(int x, int y, int v) {
 		update(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]), v, 1, n, 1);
 	}
 
-	// 判断root和u的关系
-	// 如果root和u是同一个点，返回-1
-	// 如果root不在u的子树上，返回0
-	// 如果root在u的子树上，找到u的哪个儿子的子树里有root，返回那个儿子的编号
-	public static int find(int root, int u) {
-		if (u == root) {
-			return -1;
-		}
-		if (dfn[root] < dfn[u] || dfn[u] + siz[u] <= dfn[root]) {
-			return 0;
-		}
+	// 已知root一定在u的子树上
+	// 找到u哪个儿子的子树里有root，返回那个儿子的编号
+	public static int findSon(int root, int u) {
 		while (top[root] != top[u]) {
 			if (fa[top[root]] == u) {
 				return top[root];
@@ -267,12 +259,12 @@ public static int find(int root, int u) {
 
 	// 假设树的头节点变成root，当前树的形态下，查询u的子树中的最小值
 	public static int treeQuery(int root, int u) {
-		int uson = find(root, u);
-		if (uson == -1) {
+		if (root == u) {
 			return min[1];
-		} else if (uson == 0) {
+		} else if (dfn[root] < dfn[u] || dfn[u] + siz[u] <= dfn[root]) {
 			return query(dfn[u], dfn[u] + siz[u] - 1, 1, n, 1);
 		} else {
+			int uson = findSon(root, u);
 			int ans = query(1, dfn[uson] - 1, 1, n, 1);
 			if (dfn[uson] + siz[uson] <= n) {
 				ans = Math.min(ans, query(dfn[uson] + siz[uson], n, 1, n, 1));
diff --git a/src/class161/Code07_FarAway2.java b/src/class161/Code07_FarAway2.java
index 846c653d5..fed9a4fdb 100644
--- a/src/class161/Code07_FarAway2.java
+++ b/src/class161/Code07_FarAway2.java
@@ -154,13 +154,7 @@
 //    update(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]), v, 1, n, 1);
 //}
 //
-//int find(int root, int u) {
-//    if (u == root) {
-//        return -1;
-//    }
-//    if (dfn[root] < dfn[u] || dfn[u] + siz[u] <= dfn[root]) {
-//        return 0;
-//    }
+//int findSon(int root, int u) {
 //    while (top[root] != top[u]) {
 //        if (fa[top[root]] == u) {
 //            return top[root];
@@ -171,12 +165,12 @@
 //}
 //
 //int treeQuery(int root, int u) {
-//    int uson = find(root, u);
-//    if (uson == -1) {
+//    if (root == u) {
 //        return minv[1];
-//    } else if (uson == 0) {
+//    } else if (dfn[root] < dfn[u] || dfn[u] + siz[u] <= dfn[root]) {
 //        return query(dfn[u], dfn[u] + siz[u] - 1, 1, n, 1);
 //    } else {
+//        int uson = findSon(root, u);
 //        int ans = INT_MAX;
 //        if (1 <= dfn[uson] - 1) {
 //            ans = min(ans, query(1, dfn[uson] - 1, 1, n, 1));

From 21a48efb737726be3e043808f0dfe057977447e1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 16:01:47 +0800
Subject: [PATCH 0515/1712] modify code

---
 src/class161/Code07_FarAway1.java | 16 ++++++++--------
 src/class161/Code07_FarAway2.java | 12 ++++++------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class161/Code07_FarAway1.java b/src/class161/Code07_FarAway1.java
index 72e57bf1f..a903f7799 100644
--- a/src/class161/Code07_FarAway1.java
+++ b/src/class161/Code07_FarAway1.java
@@ -41,9 +41,9 @@ public class Code07_FarAway1 {
 	public static int[] min = new int[MAXN << 2];
 	// 重置操作的懒更新信息
 	// 因为题目说了，任何时候节点值一定是正数
-	// change[i] == 0，表示没有重置懒更新
-	// change[i] != 0，表示范围内的数字修改为change[i]
-	public static int[] change = new int[MAXN << 2];
+	// changeTag[i] == 0，表示没有重置懒更新
+	// changeTag[i] != 0，表示范围内的数字修改为changeTag[i]
+	public static int[] changeTag = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
@@ -178,14 +178,14 @@ public static void up(int i) {
 
 	public static void lazy(int i, int v) {
 		min[i] = v;
-		change[i] = v;
+		changeTag[i] = v;
 	}
 
 	public static void down(int i) {
-		if (change[i] != 0) {
-			lazy(i << 1, change[i]);
-			lazy(i << 1 | 1, change[i]);
-			change[i] = 0;
+		if (changeTag[i] != 0) {
+			lazy(i << 1, changeTag[i]);
+			lazy(i << 1 | 1, changeTag[i]);
+			changeTag[i] = 0;
 		}
 	}
 
diff --git a/src/class161/Code07_FarAway2.java b/src/class161/Code07_FarAway2.java
index fed9a4fdb..8a12e1509 100644
--- a/src/class161/Code07_FarAway2.java
+++ b/src/class161/Code07_FarAway2.java
@@ -35,7 +35,7 @@
 //int cntd = 0;
 //
 //int minv[MAXN << 2];
-//int change[MAXN << 2];
+//int changeTag[MAXN << 2];
 //
 //void addEdge(int u, int v) {
 //    ++cntg;
@@ -87,14 +87,14 @@
 //
 //void lazy(int i, int v) {
 //    minv[i] = v;
-//    change[i] = v;
+//    changeTag[i] = v;
 //}
 //
 //void down(int i) {
-//    if (change[i] != 0) {
-//        lazy(i << 1, change[i]);
-//        lazy(i << 1 | 1, change[i]);
-//        change[i] = 0;
+//    if (changeTag[i] != 0) {
+//        lazy(i << 1, changeTag[i]);
+//        lazy(i << 1 | 1, changeTag[i]);
+//        changeTag[i] = 0;
 //    }
 //}
 //

From f127dc6acde76f28ccc8cc95bbac663384e6552a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 16:02:59 +0800
Subject: [PATCH 0516/1712] modify code

---
 src/class161/Code07_FarAway1.java | 16 ++++++++--------
 src/class161/Code07_FarAway2.java | 12 ++++++------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class161/Code07_FarAway1.java b/src/class161/Code07_FarAway1.java
index a903f7799..72e57bf1f 100644
--- a/src/class161/Code07_FarAway1.java
+++ b/src/class161/Code07_FarAway1.java
@@ -41,9 +41,9 @@ public class Code07_FarAway1 {
 	public static int[] min = new int[MAXN << 2];
 	// 重置操作的懒更新信息
 	// 因为题目说了，任何时候节点值一定是正数
-	// changeTag[i] == 0，表示没有重置懒更新
-	// changeTag[i] != 0，表示范围内的数字修改为changeTag[i]
-	public static int[] changeTag = new int[MAXN << 2];
+	// change[i] == 0，表示没有重置懒更新
+	// change[i] != 0，表示范围内的数字修改为change[i]
+	public static int[] change = new int[MAXN << 2];
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
@@ -178,14 +178,14 @@ public static void up(int i) {
 
 	public static void lazy(int i, int v) {
 		min[i] = v;
-		changeTag[i] = v;
+		change[i] = v;
 	}
 
 	public static void down(int i) {
-		if (changeTag[i] != 0) {
-			lazy(i << 1, changeTag[i]);
-			lazy(i << 1 | 1, changeTag[i]);
-			changeTag[i] = 0;
+		if (change[i] != 0) {
+			lazy(i << 1, change[i]);
+			lazy(i << 1 | 1, change[i]);
+			change[i] = 0;
 		}
 	}
 
diff --git a/src/class161/Code07_FarAway2.java b/src/class161/Code07_FarAway2.java
index 8a12e1509..fed9a4fdb 100644
--- a/src/class161/Code07_FarAway2.java
+++ b/src/class161/Code07_FarAway2.java
@@ -35,7 +35,7 @@
 //int cntd = 0;
 //
 //int minv[MAXN << 2];
-//int changeTag[MAXN << 2];
+//int change[MAXN << 2];
 //
 //void addEdge(int u, int v) {
 //    ++cntg;
@@ -87,14 +87,14 @@
 //
 //void lazy(int i, int v) {
 //    minv[i] = v;
-//    changeTag[i] = v;
+//    change[i] = v;
 //}
 //
 //void down(int i) {
-//    if (changeTag[i] != 0) {
-//        lazy(i << 1, changeTag[i]);
-//        lazy(i << 1 | 1, changeTag[i]);
-//        changeTag[i] = 0;
+//    if (change[i] != 0) {
+//        lazy(i << 1, change[i]);
+//        lazy(i << 1 | 1, change[i]);
+//        change[i] = 0;
 //    }
 //}
 //

From 4964743438541ed6fa9b690933106ad6fcbcc589 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 16:12:33 +0800
Subject: [PATCH 0517/1712] modify code

---
 src/class161/Code07_FarAway1.java | 6 +++---
 src/class161/Code07_FarAway2.java | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class161/Code07_FarAway1.java b/src/class161/Code07_FarAway1.java
index 72e57bf1f..893fbe640 100644
--- a/src/class161/Code07_FarAway1.java
+++ b/src/class161/Code07_FarAway1.java
@@ -3,9 +3,9 @@
 // 遥远的国度，java版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的初始头节点，给定每个点的点权
 // 一共有m条操作，每种操作是如下3种类型中的一种
-// 操作 1 x     : 树的头节点变成x，树的形态重新组织
+// 操作 1 x     : 树的头节点变成x，整棵树需要重新组织
 // 操作 2 x y v : x到y的路径上，所有节点的值改成v
-// 操作 3 x     : 当前树的形态下，打印u的子树中的最小值
+// 操作 3 x     : 在当前树的状态下，打印u的子树中的最小值
 // 1 <= n、m <= 10^5
 // 任何时候节点值一定是正数
 // 测试链接 : https://www.luogu.com.cn/problem/P3979
@@ -257,7 +257,7 @@ public static int findSon(int root, int u) {
 		return son[u];
 	}
 
-	// 假设树的头节点变成root，当前树的形态下，查询u的子树中的最小值
+	// 假设树的头节点变成root，在当前树的状态下，查询u的子树中的最小值
 	public static int treeQuery(int root, int u) {
 		if (root == u) {
 			return min[1];
diff --git a/src/class161/Code07_FarAway2.java b/src/class161/Code07_FarAway2.java
index fed9a4fdb..fb3d1d30c 100644
--- a/src/class161/Code07_FarAway2.java
+++ b/src/class161/Code07_FarAway2.java
@@ -3,9 +3,9 @@
 // 遥远的国度，C++版
 // 一共有n个节点，给定n-1条边，节点连成一棵树，给定树的初始头节点，给定每个点的点权
 // 一共有m条操作，每种操作是如下3种类型中的一种
-// 操作 1 x     : 树的头节点变成x，树的形态重新组织
+// 操作 1 x     : 树的头节点变成x，整棵树需要重新组织
 // 操作 2 x y v : x到y的路径上，所有节点的值改成v
-// 操作 3 x     : 当前树的形态下，打印u的子树中的最小值
+// 操作 3 x     : 在当前树的状态下，打印u的子树中的最小值
 // 1 <= n、m <= 10^5
 // 任何时候节点值一定是正数
 // 测试链接 : https://www.luogu.com.cn/problem/P3979

From d59cddd44d48c2c73c4babb16fa92ef6545912ce Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 17:26:51 +0800
Subject: [PATCH 0518/1712] modify code

---
 ...6\345\211\226\345\210\206-\344\270\212.pptx" | Bin 0 -> 53873 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243161\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\351\223\276\345\211\226\345\210\206-\344\270\212.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243161\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\351\223\276\345\211\226\345\210\206-\344\270\212.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243161\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\351\223\276\345\211\226\345\210\206-\344\270\212.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..3d9c5f3f7caaa9f3042448b6fe35fb06372edf63
GIT binary patch
literal 53873
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
NXOQ_4qqbk4{tteVi<|%e

literal 0
HcmV?d00001


From 8273c8c0855d74da18b3b9a82caf649b1191bef9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Mar 2025 19:31:16 +0800
Subject: [PATCH 0519/1712] modify code

---
 ... => Code03_MultiplyPositiveNegative1.java} |  2 +-
 .../Code03_MultiplyPositiveNegative2.java     | 55 +++++++++++++++++++
 2 files changed, 56 insertions(+), 1 deletion(-)
 rename src/class127/{Code03_MultiplyPositiveNegative.java => Code03_MultiplyPositiveNegative1.java} (97%)
 create mode 100644 src/class127/Code03_MultiplyPositiveNegative2.java

diff --git a/src/class127/Code03_MultiplyPositiveNegative.java b/src/class127/Code03_MultiplyPositiveNegative1.java
similarity index 97%
rename from src/class127/Code03_MultiplyPositiveNegative.java
rename to src/class127/Code03_MultiplyPositiveNegative1.java
index a2a1a5e94..f590949bc 100644
--- a/src/class127/Code03_MultiplyPositiveNegative.java
+++ b/src/class127/Code03_MultiplyPositiveNegative1.java
@@ -7,7 +7,7 @@
 // 1 <= n <= 10^6
 // -10^9 <= arr[i] <= +10^9，arr[i]一定不是0
 // 来自真实大厂笔试，对数器验证
-public class Code03_MultiplyPositiveNegative {
+public class Code03_MultiplyPositiveNegative1 {
 
 	// 正式方法
 	public static int[] num(int[] arr) {
diff --git a/src/class127/Code03_MultiplyPositiveNegative2.java b/src/class127/Code03_MultiplyPositiveNegative2.java
new file mode 100644
index 000000000..1e8a5db70
--- /dev/null
+++ b/src/class127/Code03_MultiplyPositiveNegative2.java
@@ -0,0 +1,55 @@
+package class127;
+
+// 感谢热心的同学，找到了题目3的线上测试
+// 测试链接 : https://codeforces.com/problemset/problem/1215/B
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code03_MultiplyPositiveNegative2 {
+
+	public static int MAXN = 200001;
+
+	public static int n;
+
+	public static int[] arr = new int[MAXN];
+
+	// 结果可能很大，所以用long类型
+	public static long ans1, ans2;
+
+	public static void compute() {
+		int[] cnt = new int[2];
+		cnt[0] = 1;
+		cnt[1] = 0;
+		ans1 = ans2 = 0;
+		for (int i = 1, cur = 0; i <= n; i++) {
+			cur ^= arr[i] > 0 ? 0 : 1;
+			ans1 += cnt[cur];
+			ans2 += cnt[cur ^ 1];
+			cnt[cur]++;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		compute();
+		out.println(ans2 + " " + ans1);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From ec64ec2c4a1336be631d437997b5ed59b8ff9965 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Mar 2025 15:14:31 +0800
Subject: [PATCH 0520/1712] modify code

---
 src/class161/Code01_HLD1.java            |   2 -
 src/class161/Code02_LCA1.java            |   1 -
 src/class161/Code03_PathMaxAndSum1.java  |   3 -
 src/class161/Code04_PackageManager1.java |   1 -
 src/class161/Code05_Coloring1.java       |   2 -
 src/class161/Code06_Tourism1.java        |   3 -
 src/class162/Code01_GrassPlanting1.java  | 305 +++++++++++++++++++++++
 src/class162/Code01_GrassPlanting2.java  | 164 ++++++++++++
 8 files changed, 469 insertions(+), 12 deletions(-)
 create mode 100644 src/class162/Code01_GrassPlanting1.java
 create mode 100644 src/class162/Code01_GrassPlanting2.java

diff --git a/src/class161/Code01_HLD1.java b/src/class161/Code01_HLD1.java
index c5c6d6397..d4f573d54 100644
--- a/src/class161/Code01_HLD1.java
+++ b/src/class161/Code01_HLD1.java
@@ -25,9 +25,7 @@
 public class Code01_HLD1 {
 
 	public static int MAXN = 100001;
-
 	public static int n, m, root, MOD;
-
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
diff --git a/src/class161/Code02_LCA1.java b/src/class161/Code02_LCA1.java
index 8ac627c0d..f257d890d 100644
--- a/src/class161/Code02_LCA1.java
+++ b/src/class161/Code02_LCA1.java
@@ -18,7 +18,6 @@
 public class Code02_LCA1 {
 
 	public static int MAXN = 500001;
-
 	public static int n, m, root;
 
 	public static int[] head = new int[MAXN];
diff --git a/src/class161/Code03_PathMaxAndSum1.java b/src/class161/Code03_PathMaxAndSum1.java
index a1db818c8..eba1394ec 100644
--- a/src/class161/Code03_PathMaxAndSum1.java
+++ b/src/class161/Code03_PathMaxAndSum1.java
@@ -24,11 +24,8 @@
 public class Code03_PathMaxAndSum1 {
 
 	public static int MAXN = 30001;
-
 	public static int INF = 10000001;
-
 	public static int n, m;
-
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
diff --git a/src/class161/Code04_PackageManager1.java b/src/class161/Code04_PackageManager1.java
index 19cd5bfa6..b243e94d5 100644
--- a/src/class161/Code04_PackageManager1.java
+++ b/src/class161/Code04_PackageManager1.java
@@ -23,7 +23,6 @@
 public class Code04_PackageManager1 {
 
 	public static int MAXN = 100001;
-
 	public static int n, m;
 
 	public static int[] head = new int[MAXN];
diff --git a/src/class161/Code05_Coloring1.java b/src/class161/Code05_Coloring1.java
index fe7cb508e..4701f1067 100644
--- a/src/class161/Code05_Coloring1.java
+++ b/src/class161/Code05_Coloring1.java
@@ -24,9 +24,7 @@
 public class Code05_Coloring1 {
 
 	public static int MAXN = 100001;
-
 	public static int n, m;
-
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
diff --git a/src/class161/Code06_Tourism1.java b/src/class161/Code06_Tourism1.java
index adf45126f..055796419 100644
--- a/src/class161/Code06_Tourism1.java
+++ b/src/class161/Code06_Tourism1.java
@@ -22,11 +22,8 @@
 public class Code06_Tourism1 {
 
 	public static int MAXN = 50001;
-
 	public static int INF = 1000000001;
-
 	public static int n, m;
-
 	public static int[] arr = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
diff --git a/src/class162/Code01_GrassPlanting1.java b/src/class162/Code01_GrassPlanting1.java
new file mode 100644
index 000000000..e35822282
--- /dev/null
+++ b/src/class162/Code01_GrassPlanting1.java
@@ -0,0 +1,305 @@
+package class162;
+
+// 边权转化为点权的模版题，java版
+// 一共有n个节点，给定n-1条边，节点连成一棵树，初始时所有边的权值为0
+// 一共有m条操作，每条操作是如下2种类型中的一种
+// 操作 P x y : x到y的路径上，每条边的权值增加1
+// 操作 Q x y : x和y保证是直接连接的，查询他们之间的边权
+// 1 <= n、m <= 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P3038
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code01_GrassPlanting1 {
+
+	public static int MAXN = 100001;
+	public static int n, m;
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int cntd = 0;
+
+	public static int[] sum = new int[MAXN << 2];
+	public static int[] addTag = new int[MAXN << 2];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 递归函数不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				dfn[first] = ++cntd;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[i << 1] + sum[i << 1 | 1];
+	}
+
+	public static void lazy(int i, int v, int n) {
+		sum[i] += v * n;
+		addTag[i] += v;
+	}
+
+	public static void down(int i, int ln, int rn) {
+		if (addTag[i] != 0) {
+			lazy(i << 1, addTag[i], ln);
+			lazy(i << 1 | 1, addTag[i], rn);
+			addTag[i] = 0;
+		}
+	}
+
+	// 范围增加
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i, jobv, r - l + 1);
+		} else {
+			int mid = (l + r) / 2;
+			down(i, mid - l + 1, r - mid);
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	// 单点查询
+	public static int query(int jobi, int l, int r, int i) {
+		if (l == r) {
+			return sum[i];
+		}
+		int mid = (l + r) / 2;
+		down(i, mid - l + 1, r - mid);
+		if (jobi <= mid) {
+			return query(jobi, l, mid, i << 1);
+		} else {
+			return query(jobi, mid + 1, r, i << 1 | 1);
+		}
+	}
+
+	// x到y的路径上，每条边的边权变成下方点的点权
+	// 每条边的边权增加v，就是若干点的点权增加v
+	// 但是要注意！x和y的最低公共祖先，不能增加点权！
+	public static void pathAdd(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				add(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				add(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		// x和y的最低公共祖先，点权不增加！
+		add(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), v, 1, n, 1);
+	}
+
+	// 返回x和y之间这条边的边权
+	public static int edgeQuery(int x, int y) {
+		int down = Math.max(dfn[x], dfn[y]);
+		return query(down, 1, n, 1);
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = io.nextInt();
+			v = io.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs3();
+		dfs4();
+		String op;
+		for (int i = 1, x, y; i <= m; i++) {
+			op = io.next();
+			x = io.nextInt();
+			y = io.nextInt();
+			if (op.equals("P")) {
+				pathAdd(x, y, 1);
+			} else {
+				io.println(edgeQuery(x, y));
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class162/Code01_GrassPlanting2.java b/src/class162/Code01_GrassPlanting2.java
new file mode 100644
index 000000000..2a36ea606
--- /dev/null
+++ b/src/class162/Code01_GrassPlanting2.java
@@ -0,0 +1,164 @@
+package class162;
+
+// 边权转化为点权的模版题，C++版
+// 一共有n个节点，给定n-1条边，节点连成一棵树，初始时所有边的权值为0
+// 一共有m条操作，每条操作是如下2种类型中的一种
+// 操作 P x y : x到y的路径上，每条边的权值增加1
+// 操作 Q x y : x和y保证是直接连接的，查询他们之间的边权
+// 1 <= n、m <= 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P3038
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int cntd = 0;
+//
+//int sum[MAXN << 2];
+//int addTag[MAXN << 2];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void up(int i) {
+//    sum[i] = sum[i << 1] + sum[i << 1 | 1];
+//}
+//
+//void lazy(int i, int v, int len) {
+//    sum[i] += v * len;
+//    addTag[i] += v;
+//}
+//
+//void down(int i, int ln, int rn) {
+//    if (addTag[i] != 0) {
+//        lazy(i << 1, addTag[i], ln);
+//        lazy(i << 1 | 1, addTag[i], rn);
+//        addTag[i] = 0;
+//    }
+//}
+//
+//void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        lazy(i, jobv, r - l + 1);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        down(i, mid - l + 1, r - mid);
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int query(int jobi, int l, int r, int i) {
+//    if (l == r) {
+//        return sum[i];
+//    }
+//    int mid = (l + r) >> 1;
+//    down(i, mid - l + 1, r - mid);
+//    if (jobi <= mid) {
+//        return query(jobi, l, mid, i << 1);
+//    } else {
+//        return query(jobi, mid + 1, r, i << 1 | 1);
+//    }
+//}
+//
+//void pathAdd(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            add(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            add(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    add(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), v, 1, n, 1);
+//}
+//
+//int edgeQuery(int x, int y) {
+//    int down = max(dfn[x], dfn[y]);
+//    return query(down, 1, n, 1);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i < n; i++) {
+//        int u, v;
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    char op;
+//    for (int i = 1, x, y; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 'P') {
+//            pathAdd(x, y, 1);
+//        } else {
+//            cout << edgeQuery(x, y) << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 575516ce0594a310e3a7a7afa5abee5aedb8cd6b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Mar 2025 17:28:19 +0800
Subject: [PATCH 0521/1712] modify code

---
 src/class162/Code01_GrassPlanting1.java |   1 -
 src/class162/Code02_UnderMoon1.java     | 387 ++++++++++++++++++++++++
 src/class162/Code02_UnderMoon2.java     | 250 +++++++++++++++
 3 files changed, 637 insertions(+), 1 deletion(-)
 create mode 100644 src/class162/Code02_UnderMoon1.java
 create mode 100644 src/class162/Code02_UnderMoon2.java

diff --git a/src/class162/Code01_GrassPlanting1.java b/src/class162/Code01_GrassPlanting1.java
index e35822282..4820324e7 100644
--- a/src/class162/Code01_GrassPlanting1.java
+++ b/src/class162/Code01_GrassPlanting1.java
@@ -81,7 +81,6 @@ public static void dfs2(int u, int t) {
 		}
 	}
 
-	// 递归函数不会改迭代版，去看讲解118，详解了从递归版改迭代版
 	public static int[][] fse = new int[MAXN][3];
 
 	public static int stacksize, first, second, edge;
diff --git a/src/class162/Code02_UnderMoon1.java b/src/class162/Code02_UnderMoon1.java
new file mode 100644
index 000000000..8d1e15a90
--- /dev/null
+++ b/src/class162/Code02_UnderMoon1.java
@@ -0,0 +1,387 @@
+package class162;
+
+// 月下毛景树，java版
+// 一共有n个节点，节点编号从1到n，所有节点连成一棵树
+// 给定n-1条边，边的编号从1到n-1，每条边给定初始边权
+// 会进行若干次操作，每条操作的类型是如下4种类型中的一种
+// 操作 Change x v  : 第x条边的边权改成v
+// 操作 Cover x y v : x号点到y号点的路径上，所有边权改成v
+// 操作 Add x y v   : x号点到y号点的路径上，所有边权增加v
+// 操作 Max x y     : x号点到y号点的路径上，打印最大的边权
+// 1 <= n <= 10^5
+// 任何时候的边权 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P4315
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code02_UnderMoon1 {
+
+	public static int MAXN = 100001;
+	public static int n;
+	public static int[][] arr = new int[MAXN][3];
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int cntd = 0;
+
+	public static int[] max = new int[MAXN << 2];
+	public static int[] addTag = new int[MAXN << 2];
+	public static boolean[] updateTag = new boolean[MAXN << 2];
+	public static int[] change = new int[MAXN << 2];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				dfn[first] = ++cntd;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void up(int i) {
+		max[i] = Math.max(max[i << 1], max[i << 1 | 1]);
+	}
+
+	public static void addLazy(int i, int v) {
+		max[i] += v;
+		addTag[i] += v;
+	}
+
+	public static void updateLazy(int i, int v) {
+		max[i] = v;
+		addTag[i] = 0;
+		updateTag[i] = true;
+		change[i] = v;
+	}
+
+	public static void down(int i) {
+		if (updateTag[i]) {
+			updateLazy(i << 1, change[i]);
+			updateLazy(i << 1 | 1, change[i]);
+			updateTag[i] = false;
+		}
+		if (addTag[i] != 0) {
+			addLazy(i << 1, addTag[i]);
+			addLazy(i << 1 | 1, addTag[i]);
+			addTag[i] = 0;
+		}
+	}
+
+	public static void update(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			updateLazy(i, jobv);
+		} else {
+			int mid = (l + r) >> 1;
+			down(i);
+			if (jobl <= mid) {
+				update(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				update(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addLazy(i, jobv);
+		} else {
+			int mid = (l + r) >> 1;
+			down(i);
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return max[i];
+		}
+		int mid = (l + r) >> 1;
+		down(i);
+		int ans = Integer.MIN_VALUE;
+		if (jobl <= mid) {
+			ans = Math.max(ans, query(jobl, jobr, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.max(ans, query(jobl, jobr, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static void edgeUpdate(int ei, int val) {
+		int x = arr[ei][0];
+		int y = arr[ei][1];
+		int down = Math.max(dfn[x], dfn[y]);
+		update(down, down, val, 1, n, 1);
+	}
+
+	public static void pathUpdate(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				update(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				update(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		update(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), v, 1, n, 1);
+	}
+
+	public static void pathAdd(int x, int y, int v) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				add(dfn[top[y]], dfn[y], v, 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				add(dfn[top[x]], dfn[x], v, 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		add(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), v, 1, n, 1);
+	}
+
+	public static int pathMax(int x, int y) {
+		int ans = Integer.MIN_VALUE;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans = Math.max(ans, query(dfn[top[y]], dfn[y], 1, n, 1));
+				y = fa[top[y]];
+			} else {
+				ans = Math.max(ans, query(dfn[top[x]], dfn[x], 1, n, 1));
+				x = fa[top[x]];
+			}
+		}
+		ans = Math.max(ans, query(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), 1, n, 1));
+		return ans;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i < n; i++) {
+			addEdge(arr[i][0], arr[i][1]);
+			addEdge(arr[i][1], arr[i][0]);
+		}
+		dfs3();
+		dfs4();
+		for (int i = 1; i < n; i++) {
+			edgeUpdate(i, arr[i][2]);
+		}
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		for (int i = 1; i < n; i++) {
+			arr[i][0] = io.nextInt();
+			arr[i][1] = io.nextInt();
+			arr[i][2] = io.nextInt();
+		}
+		prepare();
+		String op = io.next();
+		int x, y, v;
+		while (!op.equals("Stop")) {
+			if (op.equals("Change")) {
+				x = io.nextInt();
+				v = io.nextInt();
+				edgeUpdate(x, v);
+			} else if (op.equals("Cover")) {
+				x = io.nextInt();
+				y = io.nextInt();
+				v = io.nextInt();
+				pathUpdate(x, y, v);
+			} else if (op.equals("Add")) {
+				x = io.nextInt();
+				y = io.nextInt();
+				v = io.nextInt();
+				pathAdd(x, y, v);
+			} else {
+				x = io.nextInt();
+				y = io.nextInt();
+				io.println(pathMax(x, y));
+			}
+			op = io.next();
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class162/Code02_UnderMoon2.java b/src/class162/Code02_UnderMoon2.java
new file mode 100644
index 000000000..c8f411c37
--- /dev/null
+++ b/src/class162/Code02_UnderMoon2.java
@@ -0,0 +1,250 @@
+package class162;
+
+// 月下毛景树，C++版
+// 一共有n个节点，节点编号从1到n，所有节点连成一棵树
+// 给定n-1条边，边的编号从1到n-1，每条边给定初始边权
+// 会进行若干次操作，每条操作的类型是如下4种类型中的一种
+// 操作 Change x v  : 第x条边的边权改成v
+// 操作 Cover x y v : x号点到y号点的路径上，所有边权改成v
+// 操作 Add x y v   : x号点到y号点的路径上，所有边权增加v
+// 操作 Max x y     : x号点到y号点的路径上，打印最大的边权
+// 1 <= n <= 10^5
+// 任何时候的边权 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P4315
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n;
+//int arr[MAXN][3];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int cntd = 0;
+//
+//int maxv[MAXN << 2];
+//int addTag[MAXN << 2];
+//bool updateTag[MAXN << 2];
+//int change[MAXN << 2];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void up(int i) {
+//    maxv[i] = max(maxv[i << 1], maxv[i << 1 | 1]);
+//}
+//
+//void addLazy(int i, int v) {
+//    maxv[i] += v;
+//    addTag[i] += v;
+//}
+//
+//void updateLazy(int i, int v) {
+//    maxv[i] = v;
+//    addTag[i] = 0;
+//    updateTag[i] = true;
+//    change[i] = v;
+//}
+//
+//void down(int i) {
+//    if (updateTag[i]) {
+//        updateLazy(i << 1, change[i]);
+//        updateLazy(i << 1 | 1, change[i]);
+//        updateTag[i] = false;
+//    }
+//    if (addTag[i] != 0) {
+//        addLazy(i << 1, addTag[i]);
+//        addLazy(i << 1 | 1, addTag[i]);
+//        addTag[i] = 0;
+//    }
+//}
+//
+//void update(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        updateLazy(i, jobv);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        down(i);
+//        if (jobl <= mid) {
+//            update(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            update(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addLazy(i, jobv);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        down(i);
+//        if (jobl <= mid) {
+//        	add(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//        	add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return maxv[i];
+//    }
+//    int mid = (l + r) >> 1;
+//    down(i);
+//    int ans = INT_MIN;
+//    if (jobl <= mid) {
+//        ans = max(ans, query(jobl, jobr, l, mid, i << 1));
+//    }
+//    if (jobr > mid) {
+//        ans = max(ans, query(jobl, jobr, mid + 1, r, i << 1 | 1));
+//    }
+//    return ans;
+//}
+//
+//void edgeUpdate(int ei, int val) {
+//    int x = arr[ei][0];
+//    int y = arr[ei][1];
+//    int downv = max(dfn[x], dfn[y]);
+//    update(downv, downv, val, 1, n, 1);
+//}
+//
+//void pathUpdate(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            update(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            update(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    update(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), v, 1, n, 1);
+//}
+//
+//void pathAdd(int x, int y, int v) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//        	add(dfn[top[y]], dfn[y], v, 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//        	add(dfn[top[x]], dfn[x], v, 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    add(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), v, 1, n, 1);
+//}
+//
+//int pathMax(int x, int y) {
+//    int ans = INT_MIN;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans = max(ans, query(dfn[top[y]], dfn[y], 1, n, 1));
+//            y = fa[top[y]];
+//        } else {
+//            ans = max(ans, query(dfn[top[x]], dfn[x], 1, n, 1));
+//            x = fa[top[x]];
+//        }
+//    }
+//    ans = max(ans, query(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), 1, n, 1));
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i < n; i++) {
+//        addEdge(arr[i][0], arr[i][1]);
+//        addEdge(arr[i][1], arr[i][0]);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    for (int i = 1; i < n; i++) {
+//        edgeUpdate(i, arr[i][2]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i < n; i++) {
+//        cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
+//    }
+//    prepare();
+//    string op;
+//    cin >> op;
+//    int x, y, v;
+//    while (op != "Stop") {
+//        if (op == "Change") {
+//            cin >> x >> v;
+//            edgeUpdate(x, v);
+//        } else if (op == "Cover") {
+//            cin >> x >> y >> v;
+//            pathUpdate(x, y, v);
+//        } else if (op == "Add") {
+//            cin >> x >> y >> v;
+//            pathAdd(x, y, v);
+//        } else {
+//            cin >> x >> y;
+//            cout << pathMax(x, y) << "\n";
+//        }
+//        cin >> op;
+//    }
+//    return 0;
+//}
\ No newline at end of file

From c3919449f6f3856b0bc9d42f12f5dde019ac6104 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Mar 2025 17:34:58 +0800
Subject: [PATCH 0522/1712] modify code

---
 src/class162/Code01_GrassPlanting1.java | 3 +++
 src/class162/Code02_UnderMoon1.java     | 8 ++++++++
 2 files changed, 11 insertions(+)

diff --git a/src/class162/Code01_GrassPlanting1.java b/src/class162/Code01_GrassPlanting1.java
index 4820324e7..00cefcc26 100644
--- a/src/class162/Code01_GrassPlanting1.java
+++ b/src/class162/Code01_GrassPlanting1.java
@@ -23,11 +23,13 @@ public class Code01_GrassPlanting1 {
 	public static int MAXN = 100001;
 	public static int n, m;
 
+	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
+	// 重链剖分
 	public static int[] fa = new int[MAXN];
 	public static int[] dep = new int[MAXN];
 	public static int[] siz = new int[MAXN];
@@ -36,6 +38,7 @@ public class Code01_GrassPlanting1 {
 	public static int[] dfn = new int[MAXN];
 	public static int cntd = 0;
 
+	// 线段树
 	public static int[] sum = new int[MAXN << 2];
 	public static int[] addTag = new int[MAXN << 2];
 
diff --git a/src/class162/Code02_UnderMoon1.java b/src/class162/Code02_UnderMoon1.java
index 8d1e15a90..668530011 100644
--- a/src/class162/Code02_UnderMoon1.java
+++ b/src/class162/Code02_UnderMoon1.java
@@ -28,11 +28,13 @@ public class Code02_UnderMoon1 {
 	public static int n;
 	public static int[][] arr = new int[MAXN][3];
 
+	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
+	// 重链剖分
 	public static int[] fa = new int[MAXN];
 	public static int[] dep = new int[MAXN];
 	public static int[] siz = new int[MAXN];
@@ -41,6 +43,12 @@ public class Code02_UnderMoon1 {
 	public static int[] dfn = new int[MAXN];
 	public static int cntd = 0;
 
+	// 线段树查询区间最大值
+	// 但是需要同时兼顾，区间增加、区间修改，这两种操作
+	// 那么就牵扯到两种操作相互影响的问题
+	// 因为区间修改明显会取消之前的区间增加
+	// 讲解110，线段树章节，题目6，重点讲了这种线段树
+	// 不会的同学可以看看，讲的非常清楚
 	public static int[] max = new int[MAXN << 2];
 	public static int[] addTag = new int[MAXN << 2];
 	public static boolean[] updateTag = new boolean[MAXN << 2];

From 56a7ad617ae052bc479ec3af5f0ffc79b9f9ee2f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Mar 2025 17:52:50 +0800
Subject: [PATCH 0523/1712] modify code

---
 src/class162/Code02_UnderMoon1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class162/Code02_UnderMoon1.java b/src/class162/Code02_UnderMoon1.java
index 668530011..4933b8cf0 100644
--- a/src/class162/Code02_UnderMoon1.java
+++ b/src/class162/Code02_UnderMoon1.java
@@ -47,7 +47,7 @@ public class Code02_UnderMoon1 {
 	// 但是需要同时兼顾，区间增加、区间修改，这两种操作
 	// 那么就牵扯到两种操作相互影响的问题
 	// 因为区间修改明显会取消之前的区间增加
-	// 讲解110，线段树章节，题目6，重点讲了这种线段树
+	// 讲解110，线段树章节，题目5、题目6，重点讲了这种线段树
 	// 不会的同学可以看看，讲的非常清楚
 	public static int[] max = new int[MAXN << 2];
 	public static int[] addTag = new int[MAXN << 2];

From 7eb874c24c5f7a2ca6646055d3918ed1fd7cde6c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 6 Mar 2025 14:34:00 +0800
Subject: [PATCH 0524/1712] modify code

---
 .../Code03_MultiplyPositiveNegative2.java     |   2 +-
 ...edian.java => Code05_MaximizeMedian1.java} |   2 +-
 src/class128/Code05_MaximizeMedian2.java      | 126 ++++++++++++++++++
 3 files changed, 128 insertions(+), 2 deletions(-)
 rename src/class128/{Code05_MaximizeMedian.java => Code05_MaximizeMedian1.java} (98%)
 create mode 100644 src/class128/Code05_MaximizeMedian2.java

diff --git a/src/class127/Code03_MultiplyPositiveNegative2.java b/src/class127/Code03_MultiplyPositiveNegative2.java
index 1e8a5db70..02a890e34 100644
--- a/src/class127/Code03_MultiplyPositiveNegative2.java
+++ b/src/class127/Code03_MultiplyPositiveNegative2.java
@@ -1,6 +1,6 @@
 package class127;
 
-// 感谢热心的同学，找到了题目3的线上测试
+// 感谢热心的同学，找到了题目3的在线测试
 // 测试链接 : https://codeforces.com/problemset/problem/1215/B
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class128/Code05_MaximizeMedian.java b/src/class128/Code05_MaximizeMedian1.java
similarity index 98%
rename from src/class128/Code05_MaximizeMedian.java
rename to src/class128/Code05_MaximizeMedian1.java
index 592f606ac..5e206f60d 100644
--- a/src/class128/Code05_MaximizeMedian.java
+++ b/src/class128/Code05_MaximizeMedian1.java
@@ -12,7 +12,7 @@
 // 2 <=  n <= 10^5
 // 1 <= arr[i] <= 10^9
 // 来自真实大厂笔试，对数器验证
-public class Code05_MaximizeMedian {
+public class Code05_MaximizeMedian1 {
 
 	// 正式方法
 	// 时间复杂度O(n * log n)
diff --git a/src/class128/Code05_MaximizeMedian2.java b/src/class128/Code05_MaximizeMedian2.java
new file mode 100644
index 000000000..2cd4f9069
--- /dev/null
+++ b/src/class128/Code05_MaximizeMedian2.java
@@ -0,0 +1,126 @@
+package class128;
+
+// 感谢热心的同学，找到了题目5的在线测试
+// 最大平均值和中位数
+// 给定一个长度为n的数组arr，现在要选出一些数
+// 满足 任意两个相邻的数中至少有一个数被选择
+// 被选中的数字平均值的最大值，打印的答案为double类型，误差在0.001以内
+// 被选中的数字中位数的最大值，打印的答案为int类型，中位数认为是上中位数
+// 2 <= n <= 10^5
+// 1 <= arr[i] <= 10^9
+// 测试链接 : https://atcoder.jp/contests/abc236/tasks/abc236_e
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code05_MaximizeMedian2 {
+
+	public static int MAXN = 100005;
+	public static int n;
+	public static int[] arr = new int[MAXN];
+
+	// 求最大平均数需要
+	public static double[] help1 = new double[MAXN];
+	public static double[][] dp1 = new double[MAXN][2];
+
+	// 求最大上中位数需要
+	public static int[] sorted = new int[MAXN];
+	public static int[] help2 = new int[MAXN];
+	public static int[][] dp2 = new int[MAXN][2];
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		out.println(average());
+		out.println(median());
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+	// 最大平均数
+	// 课上没有讲，但是很好理解，也是二分答案
+	// 假设arr中最小值为l，最大值为r
+	// 那么最大平均值必然在[l, r]范围上
+	// 假设平均值设为中点m，arr中所有的数字都减去m
+	// 如果此时，任意两个相邻的数中至少有一个数被选择
+	// 最后得到的结果 >= 0，说明最大平均值至少是m，去右侧二分
+	// 否则去左侧二分
+	public static double average() {
+		double l = Double.MAX_VALUE, r = Double.MIN_VALUE, m;
+		for (int i = 1; i <= n; i++) {
+			l = Math.min(l, arr[i]);
+			r = Math.max(r, arr[i]);
+		}
+		// 二分60次，足够让误差小于0.001
+		for (int i = 1; i <= 60; i++) {
+			m = (l + r) / 2;
+			if (check1(m)) {
+				l = m;
+			} else {
+				r = m;
+			}
+		}
+		return l;
+	}
+
+	public static boolean check1(double x) {
+		// arr中所有的数字都减去m，得到的数字填入help1
+		for (int i = 1; i <= n; i++) {
+			help1[i] = (double) arr[i] - x;
+		}
+		// 和课上讲的一样的逻辑
+		// 任意两个相邻的数中至少有一个数被选择，去得到dp表
+		dp1[n + 1][0] = dp1[n + 1][1] = 0;
+		for (int i = n; i >= 1; i--) {
+			dp1[i][0] = Math.max(help1[i] + dp1[i + 1][0], dp1[i + 1][1]);
+			dp1[i][1] = help1[i] + dp1[i + 1][0];
+		}
+		return dp1[1][0] >= 0;
+	}
+
+	// 最大上中位数，就和课上讲的一样了
+	public static int median() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		int l = 1, r = n, m, ans = 0;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (check2(sorted[m])) {
+				ans = sorted[m];
+				l = m + 1;
+			} else {
+				r = m - 1;
+			}
+		}
+		return ans;
+	}
+
+	public static boolean check2(int x) {
+		for (int i = 1; i <= n; i++) {
+			help2[i] = arr[i] >= x ? 1 : -1;
+		}
+		dp2[n + 1][0] = dp2[n + 1][1] = 0;
+		for (int i = n; i >= 1; i--) {
+			dp2[i][0] = Math.max(help2[i] + dp2[i + 1][0], dp2[i + 1][1]);
+			dp2[i][1] = help2[i] + dp2[i + 1][0];
+		}
+		return dp2[1][0] > 0;
+	}
+
+}
\ No newline at end of file

From f0906af99d99fbf39ee7a7e111499287e4101d13 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 6 Mar 2025 14:38:41 +0800
Subject: [PATCH 0525/1712] modify code

---
 src/class128/Code05_MaximizeMedian1.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class128/Code05_MaximizeMedian1.java b/src/class128/Code05_MaximizeMedian1.java
index 5e206f60d..9726cf6b7 100644
--- a/src/class128/Code05_MaximizeMedian1.java
+++ b/src/class128/Code05_MaximizeMedian1.java
@@ -1,7 +1,5 @@
 package class128;
 
-import java.util.Arrays;
-
 // 相邻必选的子序列最大中位数
 // 给定一个长度为n的数组arr
 // 合法子序列定义为，任意相邻的两个数至少要有一个被挑选所组成的子序列
@@ -12,6 +10,9 @@
 // 2 <=  n <= 10^5
 // 1 <= arr[i] <= 10^9
 // 来自真实大厂笔试，对数器验证
+
+import java.util.Arrays;
+
 public class Code05_MaximizeMedian1 {
 
 	// 正式方法

From 5f8531add286b0092f72dc3acb651a50e9261a03 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 6 Mar 2025 15:37:30 +0800
Subject: [PATCH 0526/1712] modify code

---
 src/class138/Other1.java                      |  91 ++++++++++
 src/class138/Other2.java                      |  88 +++++++++
 src/class138/Other3.java                      | 106 +++++++++++
 src/class138/Other4.java                      | 118 +++++++++++++
 src/class138/Other5.java                      | 122 +++++++++++++
 ...04_Measurer.java => Code04_Measurer1.java} |   2 +-
 src/class142/Code04_Measurer2.java            | 167 ++++++++++++++++++
 7 files changed, 693 insertions(+), 1 deletion(-)
 create mode 100644 src/class138/Other1.java
 create mode 100644 src/class138/Other2.java
 create mode 100644 src/class138/Other3.java
 create mode 100644 src/class138/Other4.java
 create mode 100644 src/class138/Other5.java
 rename src/class142/{Code04_Measurer.java => Code04_Measurer1.java} (99%)
 create mode 100644 src/class142/Code04_Measurer2.java

diff --git a/src/class138/Other1.java b/src/class138/Other1.java
new file mode 100644
index 000000000..b18b9665f
--- /dev/null
+++ b/src/class138/Other1.java
@@ -0,0 +1,91 @@
+package class138;
+
+// 题目1，01分数规划模版题，另一种二分的写法
+// 思路是不变的，二分的写法多种多样
+// 代码中打注释的位置，就是更简单的二分逻辑，其他代码没有变化
+// 测试链接 : https://www.luogu.com.cn/problem/P10505
+// 测试链接 : http://poj.org/problem?id=2976
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Other1 {
+
+	public static int MAXN = 1001;
+
+	public static double[][] arr = new double[MAXN][3];
+
+	public static int n, k;
+
+	public static boolean check(double x) {
+		for (int i = 1; i <= n; i++) {
+			arr[i][2] = arr[i][0] - x * arr[i][1];
+		}
+		Arrays.sort(arr, 1, n + 1, new MyComparator());
+		double sum = 0;
+		for (int i = 1; i <= k; i++) {
+			sum += arr[i][2];
+		}
+		return sum >= 0;
+	}
+
+	public static class MyComparator implements Comparator<double[]> {
+
+		@Override
+		public int compare(double[] o1, double[] o2) {
+			return o1[2] >= o2[2] ? -1 : 1;
+		}
+
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		while (n != 0 || k != 0) {
+			k = n - k;
+			for (int i = 1; i <= n; i++) {
+				in.nextToken();
+				arr[i][0] = in.nval;
+			}
+			for (int i = 1; i <= n; i++) {
+				in.nextToken();
+				arr[i][1] = in.nval;
+			}
+			double l = 0, r = 0, x;
+			for (int i = 1; i <= n; i++) {
+				r += arr[i][0];
+			}
+			// 二分进行60次，足够达到题目要求的精度
+			// 二分完成后，l就是答案
+			for (int i = 1; i <= 60; i++) {
+				x = (l + r) / 2;
+				if (check(x)) {
+					l = x;
+				} else {
+					r = x;
+				}
+			}
+			out.println((int) (100 * (l + 0.005)));
+			in.nextToken();
+			n = (int) in.nval;
+			in.nextToken();
+			k = (int) in.nval;
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class138/Other2.java b/src/class138/Other2.java
new file mode 100644
index 000000000..f033bb195
--- /dev/null
+++ b/src/class138/Other2.java
@@ -0,0 +1,88 @@
+package class138;
+
+// 题目2，牛群的才艺展示，另一种二分的写法
+// 思路是不变的，二分的写法多种多样
+// 代码中打注释的位置，就是更简单的二分逻辑，其他代码没有变化
+// 测试链接 : https://www.luogu.com.cn/problem/P4377
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Other2 {
+
+	public static int MAXN = 251;
+
+	public static int MAXW = 1001;
+
+	public static double NA = -1e9;
+
+	public static int[] weight = new int[MAXN];
+
+	public static int[] talent = new int[MAXN];
+
+	public static double[] value = new double[MAXN];
+
+	public static double[] dp = new double[MAXW];
+
+	public static int n, w;
+
+	public static boolean check(double x) {
+		for (int i = 1; i <= n; i++) {
+			value[i] = (double) talent[i] - x * weight[i];
+		}
+		dp[0] = 0;
+		Arrays.fill(dp, 1, w + 1, NA);
+		for (int i = 1; i <= n; i++) {
+			for (int p = w, j; p >= 0; p--) {
+				j = (int) (p + weight[i]);
+				if (j >= w) {
+					dp[w] = Math.max(dp[w], dp[p] + value[i]);
+				} else {
+					dp[j] = Math.max(dp[j], dp[p] + value[i]);
+				}
+			}
+		}
+		return dp[w] >= 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		w = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			weight[i] = (int) in.nval;
+			in.nextToken();
+			talent[i] = (int) in.nval;
+		}
+		double l = 0, r = 0, x;
+		for (int i = 1; i <= n; i++) {
+			r += talent[i];
+		}
+		// 二分进行60次，足够达到题目要求的精度
+		// 二分完成后，l就是答案
+		for (int i = 1; i <= 60; i++) {
+			x = (l + r) / 2;
+			if (check(x)) {
+				l = x;
+			} else {
+				r = x;
+			}
+		}
+		out.println((int) (l * 1000));
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class138/Other3.java b/src/class138/Other3.java
new file mode 100644
index 000000000..e5295c334
--- /dev/null
+++ b/src/class138/Other3.java
@@ -0,0 +1,106 @@
+package class138;
+
+// 题目3，最优比率生成树，另一种二分的写法
+// 思路是不变的，二分的写法多种多样
+// 代码中打注释的位置，就是更简单的二分逻辑，其他代码没有变化
+// 测试链接 : http://poj.org/problem?id=2728
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Other3 {
+
+	public static int MAXN = 1001;
+
+	public static int[] x = new int[MAXN];
+
+	public static int[] y = new int[MAXN];
+
+	public static int[] z = new int[MAXN];
+
+	public static double[][] dist = new double[MAXN][MAXN];
+
+	public static double[][] cost = new double[MAXN][MAXN];
+
+	public static boolean[] visit = new boolean[MAXN];
+
+	public static double[] value = new double[MAXN];
+
+	public static int n;
+
+	public static double prim(double x) {
+		for (int i = 1; i <= n; i++) {
+			visit[i] = false;
+			value[i] = cost[1][i] - x * dist[1][i];
+		}
+		visit[1] = true;
+		double sum = 0;
+		for (int i = 1; i <= n - 1; i++) {
+			double minDist = Double.MAX_VALUE;
+			int next = 0;
+			for (int j = 1; j <= n; j++) {
+				if (!visit[j] && value[j] < minDist) {
+					minDist = value[j];
+					next = j;
+				}
+			}
+			sum += minDist;
+			visit[next] = true;
+			for (int j = 1; j <= n; j++) {
+				if (!visit[j] && value[j] > cost[next][j] - x * dist[next][j]) {
+					value[j] = cost[next][j] - x * dist[next][j];
+				}
+			}
+		}
+		return sum;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		while (n != 0) {
+			for (int i = 1; i <= n; i++) {
+				in.nextToken();
+				x[i] = (int) in.nval;
+				in.nextToken();
+				y[i] = (int) in.nval;
+				in.nextToken();
+				z[i] = (int) in.nval;
+			}
+			for (int i = 1; i <= n; i++) {
+				for (int j = 1; j <= n; j++) {
+					if (i != j) {
+						dist[i][j] = Math.sqrt((x[i] - x[j]) * (x[i] - x[j]) + (y[i] - y[j]) * (y[i] - y[j]));
+						cost[i][j] = Math.abs(z[i] - z[j]);
+					}
+				}
+			}
+			double l = 0, r = 100, x;
+			// 二分进行60次，足够达到题目要求的精度
+			// 二分完成后，l就是答案
+			for (int i = 1; i <= 60; i++) {
+				x = (l + r) / 2;
+				if (prim(x) <= 0) {
+					r = x;
+				} else {
+					l = x;
+				}
+			}
+			out.printf("%.3f\n", l);
+			in.nextToken();
+			n = (int) in.nval;
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class138/Other4.java b/src/class138/Other4.java
new file mode 100644
index 000000000..41de51510
--- /dev/null
+++ b/src/class138/Other4.java
@@ -0,0 +1,118 @@
+package class138;
+
+// 题目4，最小圈，另一种二分的写法
+// 思路是不变的，二分的写法多种多样
+// 代码中打注释的位置，就是更简单的二分逻辑，其他代码没有变化
+// 测试链接 : https://www.luogu.com.cn/problem/P3199
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Other4 {
+
+	public static int MAXN = 3001;
+
+	public static int MAXM = 10001;
+
+	public static double MAXE = 1e7;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXM];
+
+	public static int[] to = new int[MAXM];
+
+	public static double[] weight = new double[MAXM];
+
+	public static int cnt;
+
+	public static double[] value = new double[MAXN];
+
+	public static boolean[] path = new boolean[MAXN];
+
+	public static int n, m;
+
+	public static void prepare() {
+		cnt = 1;
+		Arrays.fill(head, 1, n + 1, 0);
+	}
+
+	public static void addEdge(int u, int v, double w) {
+		next[cnt] = head[u];
+		to[cnt] = v;
+		weight[cnt] = w;
+		head[u] = cnt++;
+	}
+
+	public static boolean check(double x) {
+		Arrays.fill(value, 1, n + 1, 0);
+		Arrays.fill(path, 1, n + 1, false);
+		return dfs(0, x);
+	}
+
+	public static boolean dfs(int u, double x) {
+		if (u == 0) {
+			for (int i = 1; i <= n; i++) {
+				if (dfs(i, x)) {
+					return true;
+				}
+			}
+		} else {
+			path[u] = true;
+			for (int e = head[u]; e != 0; e = next[e]) {
+				int v = to[e];
+				double w = weight[e] - x;
+				if (value[v] > value[u] + w) {
+					value[v] = value[u] + w;
+					if (path[v] || dfs(v, x)) {
+						return true;
+					}
+				}
+			}
+			path[u] = false;
+		}
+		return false;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		prepare();
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			int u = (int) in.nval;
+			in.nextToken();
+			int v = (int) in.nval;
+			in.nextToken();
+			double w = in.nval;
+			addEdge(u, v, w);
+		}
+		double l = -MAXE, r = MAXE, x;
+		// 二分进行60次，足够达到题目要求的精度
+		// 二分完成后，l就是答案
+		for (int i = 1; i <= 60; i++) {
+			x = (l + r) / 2;
+			if (check(x)) {
+				r = x;
+			} else {
+				l = x;
+			}
+		}
+		out.printf("%.8f\n", l);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class138/Other5.java b/src/class138/Other5.java
new file mode 100644
index 000000000..9c96c0f4b
--- /dev/null
+++ b/src/class138/Other5.java
@@ -0,0 +1,122 @@
+package class138;
+
+// 题目5，最佳团体，另一种二分的写法
+// 思路是不变的，二分的写法多种多样
+// 代码中打注释的位置，就是更简单的二分逻辑，其他代码没有变化
+// 测试链接 : https://www.luogu.com.cn/problem/P4322
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Other5 {
+
+	public static int MAXN = 3001;
+
+	public static int LIMIT = 10000;
+
+	public static double NA = -1e9;
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXN];
+
+	public static int[] to = new int[MAXN];
+
+	public static int edgeCnt;
+
+	public static int[] cost = new int[MAXN];
+
+	public static int[] strength = new int[MAXN];
+
+	public static int[] dfn = new int[MAXN];
+
+	public static int dfnCnt;
+
+	public static double[] value = new double[MAXN];
+
+	public static int[] size = new int[MAXN];
+
+	public static double[][] dp = new double[MAXN][MAXN];
+
+	public static int k, n;
+
+	public static void prepare() {
+		edgeCnt = 1;
+		dfnCnt = 0;
+		Arrays.fill(head, 1, n + 1, 0);
+	}
+
+	public static void addEdge(int u, int v) {
+		next[edgeCnt] = head[u];
+		to[edgeCnt] = v;
+		head[u] = edgeCnt++;
+	}
+
+	public static int dfs(int u) {
+		int i = ++dfnCnt;
+		dfn[u] = i;
+		size[i] = 1;
+		for (int e = head[u], v; e != 0; e = next[e]) {
+			v = to[e];
+			size[i] += dfs(v);
+		}
+		return size[i];
+	}
+
+	public static boolean check(double x) {
+		for (int i = 0; i <= n; i++) {
+			value[dfn[i]] = (double) strength[i] - x * cost[i];
+		}
+		for (int j = 1; j <= k; j++) {
+			dp[dfnCnt + 1][j] = NA;
+		}
+		for (int i = dfnCnt; i >= 2; i--) {
+			for (int j = 1; j <= k; j++) {
+				dp[i][j] = Math.max(dp[i + size[i]][j], value[i] + dp[i + 1][j - 1]);
+			}
+		}
+		return dp[2][k] >= 0;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		k = (int) in.nval;
+		in.nextToken();
+		n = (int) in.nval;
+		prepare();
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			cost[i] = (int) in.nval;
+			in.nextToken();
+			strength[i] = (int) in.nval;
+			in.nextToken();
+			addEdge((int) in.nval, i);
+		}
+		dfs(0);
+		double l = 0, r = LIMIT, x;
+		// 二分进行60次，足够达到题目要求的精度
+		// 二分完成后，l就是答案
+		for (int i = 1; i <= 60; i++) {
+			x = (l + r) / 2;
+			if (check(x)) {
+				l = x;
+			} else {
+				r = x;
+			}
+		}
+		out.printf("%.3f\n", l);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class142/Code04_Measurer.java b/src/class142/Code04_Measurer1.java
similarity index 99%
rename from src/class142/Code04_Measurer.java
rename to src/class142/Code04_Measurer1.java
index 521367652..9fa58f560 100644
--- a/src/class142/Code04_Measurer.java
+++ b/src/class142/Code04_Measurer1.java
@@ -23,7 +23,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code04_Measurer {
+public class Code04_Measurer1 {
 
 	public static int MAXN = 1002;
 
diff --git a/src/class142/Code04_Measurer2.java b/src/class142/Code04_Measurer2.java
new file mode 100644
index 000000000..e31364eba
--- /dev/null
+++ b/src/class142/Code04_Measurer2.java
@@ -0,0 +1,167 @@
+package class142;
+
+// 题目4，倍杀测量者，另一种二分的写法
+// 思路是不变的，二分的写法多种多样
+// 代码中打注释的位置，就是更简单的二分逻辑，其他代码没有变化
+// 测试链接 : https://www.luogu.com.cn/problem/P4926
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code04_Measurer2 {
+
+	public static int MAXN = 1002;
+
+	public static int MAXM = 3001;
+
+	public static double INF = 1e10;
+
+	public static int n, m1, m2;
+
+	public static int[][] vow = new int[MAXN][4];
+
+	public static int[][] score = new int[MAXN][2];
+
+	public static int[] head = new int[MAXN];
+
+	public static int[] next = new int[MAXM];
+
+	public static int[] to = new int[MAXM];
+
+	public static double[] weight = new double[MAXM];
+
+	public static int cnt;
+
+	public static double[] dist = new double[MAXN];
+
+	public static int[] update = new int[MAXN];
+
+	public static int MAXQ = 1000001;
+
+	public static int[] queue = new int[MAXQ];
+
+	public static int h, t;
+
+	public static boolean[] enter = new boolean[MAXN];
+
+	public static void prepare() {
+		cnt = 1;
+		h = t = 0;
+		Arrays.fill(head, 0, n + 2, 0);
+		Arrays.fill(dist, 0, n + 2, INF);
+		Arrays.fill(update, 0, n + 2, 0);
+		Arrays.fill(enter, 0, n + 2, false);
+	}
+
+	public static void addEdge(int u, int v, double w) {
+		next[cnt] = head[u];
+		to[cnt] = v;
+		weight[cnt] = w;
+		head[u] = cnt++;
+	}
+
+	// 另一种二分的写法
+	public static double compute() {
+		double l = 0, r = INF, m;
+		// 二分进行60次，足够达到题目要求的精度
+		// 二分完成后，l就是答案
+		for (int i = 1; i <= 60; i++) {
+			m = (l + r) / 2;
+			if (check(m)) {
+				l = m;
+			} else {
+				r = m;
+			}
+		}
+		return l;
+	}
+
+	public static boolean check(double limit) {
+		prepare();
+		for (int i = 1; i <= n; i++) {
+			addEdge(0, i, 0);
+		}
+		for (int i = 1; i <= m1; i++) {
+			if (vow[i][0] == 1) {
+				addEdge(vow[i][1], vow[i][2], -Math.log(-limit + vow[i][3]));
+			} else {
+				addEdge(vow[i][1], vow[i][2], Math.log(limit + vow[i][3]));
+			}
+		}
+		for (int i = 1; i <= m2; i++) {
+			addEdge(n + 1, score[i][0], Math.log(score[i][1]));
+			addEdge(score[i][0], n + 1, -Math.log(score[i][1]));
+		}
+		return spfa(0);
+	}
+
+	public static boolean spfa(int s) {
+		dist[s] = 0;
+		update[s] = 1;
+		queue[t++] = s;
+		enter[s] = true;
+		while (h < t) {
+			int u = queue[h++];
+			enter[u] = false;
+			for (int ei = head[u]; ei > 0; ei = next[ei]) {
+				int v = to[ei];
+				double w = weight[ei];
+				if (dist[v] > dist[u] + w) {
+					dist[v] = dist[u] + w;
+					if (!enter[v]) {
+						if (++update[v] > n + 1) {
+							return true;
+						}
+						queue[t++] = v;
+						enter[v] = true;
+					}
+				}
+			}
+		}
+		return false;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m1 = (int) in.nval;
+		in.nextToken();
+		m2 = (int) in.nval;
+		for (int i = 1; i <= m1; i++) {
+			in.nextToken();
+			vow[i][0] = (int) in.nval;
+			in.nextToken();
+			vow[i][1] = (int) in.nval;
+			in.nextToken();
+			vow[i][2] = (int) in.nval;
+			in.nextToken();
+			vow[i][3] = (int) in.nval;
+		}
+		for (int i = 1; i <= m2; i++) {
+			in.nextToken();
+			score[i][0] = (int) in.nval;
+			in.nextToken();
+			score[i][1] = (int) in.nval;
+		}
+		double ans = compute();
+		if (ans == 0) {
+			out.println("-1");
+		} else {
+			out.println(ans);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From f7a5170a3132529b02c1768564a0eb9267b5a004 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 6 Mar 2025 15:40:18 +0800
Subject: [PATCH 0527/1712] modify code

---
 src/class128/Code05_MaximizeMedian2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class128/Code05_MaximizeMedian2.java b/src/class128/Code05_MaximizeMedian2.java
index 2cd4f9069..4ba28ec9d 100644
--- a/src/class128/Code05_MaximizeMedian2.java
+++ b/src/class128/Code05_MaximizeMedian2.java
@@ -78,7 +78,7 @@ public static double average() {
 	}
 
 	public static boolean check1(double x) {
-		// arr中所有的数字都减去m，得到的数字填入help1
+		// arr中所有的数字都减去x，得到的数字填入help1
 		for (int i = 1; i <= n; i++) {
 			help1[i] = (double) arr[i] - x;
 		}

From a73c0cd9fa5e374e391ba30e1e1646193930d16a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 6 Mar 2025 17:11:25 +0800
Subject: [PATCH 0528/1712] modify code

---
 src/class162/Code03_NationalTour1.java | 431 +++++++++++++++++++++++++
 src/class162/Code03_NationalTour2.java | 299 +++++++++++++++++
 2 files changed, 730 insertions(+)
 create mode 100644 src/class162/Code03_NationalTour1.java
 create mode 100644 src/class162/Code03_NationalTour2.java

diff --git a/src/class162/Code03_NationalTour1.java b/src/class162/Code03_NationalTour1.java
new file mode 100644
index 000000000..2844cafa0
--- /dev/null
+++ b/src/class162/Code03_NationalTour1.java
@@ -0,0 +1,431 @@
+package class162;
+
+// 国家集训队旅游，java版
+// 一共有n个节点，节点编号从0到n-1，所有节点连成一棵树
+// 给定n-1条边，边的编号从1到n-1，每条边给定初始边权
+// 一共有m条操作，每条操作的类型是如下5种类型中的一种
+// 操作 C x y   : 第x条边的边权改成y
+// 操作 N x y   : x号点到y号点的路径上，所有边权变成相反数
+// 操作 SUM x y : x号点到y号点的路径上，查询所有边权的累加和
+// 操作 MAX x y : x号点到y号点的路径上，查询所有边权的最大值
+// 操作 MIN x y : x号点到y号点的路径上，查询所有边权的最小值
+// 1 <= n、m <= 2 * 10^5
+// -1000 <= 任何时候的边权 <= +1000
+// 测试链接 : https://www.luogu.com.cn/problem/P1505
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.StringTokenizer;
+
+public class Code03_NationalTour1 {
+
+	public static int MAXN = 200001;
+	public static int n, m;
+	public static int[][] arr = new int[MAXN][3];
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	// 重链剖分
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int cntd = 0;
+
+	// 线段树
+	public static int[] sum = new int[MAXN << 2];
+	public static int[] max = new int[MAXN << 2];
+	public static int[] min = new int[MAXN << 2];
+	public static boolean[] negativeTag = new boolean[MAXN << 2];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				dfn[first] = ++cntd;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void up(int i) {
+		int l = i << 1, r = i << 1 | 1;
+		sum[i] = sum[l] + sum[r];
+		max[i] = Math.max(max[l], max[r]);
+		min[i] = Math.min(min[l], min[r]);
+	}
+
+	public static void lazy(int i) {
+		sum[i] = -sum[i];
+		int tmp = max[i];
+		max[i] = -min[i];
+		min[i] = -tmp;
+		negativeTag[i] = !negativeTag[i];
+	}
+
+	public static void down(int i) {
+		if (negativeTag[i]) {
+			lazy(i << 1);
+			lazy(i << 1 | 1);
+			negativeTag[i] = false;
+		}
+	}
+
+	public static void update(int jobi, int jobv, int l, int r, int i) {
+		if (l == r) {
+			sum[i] = max[i] = min[i] = jobv;
+		} else {
+			down(i);
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				update(jobi, jobv, l, mid, i << 1);
+			} else {
+				update(jobi, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static void negative(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			lazy(i);
+		} else {
+			down(i);
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				negative(jobl, jobr, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				negative(jobl, jobr, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static int querySum(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		down(i);
+		int mid = (l + r) / 2;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans += querySum(jobl, jobr, l, mid, i << 1);
+		}
+		if (jobr > mid) {
+			ans += querySum(jobl, jobr, mid + 1, r, i << 1 | 1);
+		}
+		return ans;
+	}
+
+	public static int queryMax(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return max[i];
+		}
+		down(i);
+		int mid = (l + r) / 2;
+		int ans = Integer.MIN_VALUE;
+		if (jobl <= mid) {
+			ans = Math.max(ans, queryMax(jobl, jobr, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.max(ans, queryMax(jobl, jobr, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static int queryMin(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			return min[i];
+		}
+		down(i);
+		int mid = (l + r) / 2;
+		int ans = Integer.MAX_VALUE;
+		if (jobl <= mid) {
+			ans = Math.min(ans, queryMin(jobl, jobr, l, mid, i << 1));
+		}
+		if (jobr > mid) {
+			ans = Math.min(ans, queryMin(jobl, jobr, mid + 1, r, i << 1 | 1));
+		}
+		return ans;
+	}
+
+	public static void edgeUpdate(int ei, int val) {
+		int x = arr[ei][0];
+		int y = arr[ei][1];
+		int down = Math.max(dfn[x], dfn[y]);
+		update(down, val, 1, n, 1);
+	}
+
+	public static void pathNegative(int x, int y) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				negative(dfn[top[y]], dfn[y], 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				negative(dfn[top[x]], dfn[x], 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		negative(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), 1, n, 1);
+	}
+
+	public static int pathSum(int x, int y) {
+		int ans = 0;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans += querySum(dfn[top[y]], dfn[y], 1, n, 1);
+				y = fa[top[y]];
+			} else {
+				ans += querySum(dfn[top[x]], dfn[x], 1, n, 1);
+				x = fa[top[x]];
+			}
+		}
+		ans += querySum(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), 1, n, 1);
+		return ans;
+	}
+
+	public static int pathMax(int x, int y) {
+		int ans = Integer.MIN_VALUE;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans = Math.max(ans, queryMax(dfn[top[y]], dfn[y], 1, n, 1));
+				y = fa[top[y]];
+			} else {
+				ans = Math.max(ans, queryMax(dfn[top[x]], dfn[x], 1, n, 1));
+				x = fa[top[x]];
+			}
+		}
+		ans = Math.max(ans, queryMax(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), 1, n, 1));
+		return ans;
+	}
+
+	public static int pathMin(int x, int y) {
+		int ans = Integer.MAX_VALUE;
+		while (top[x] != top[y]) {
+			if (dep[top[x]] <= dep[top[y]]) {
+				ans = Math.min(ans, queryMin(dfn[top[y]], dfn[y], 1, n, 1));
+				y = fa[top[y]];
+			} else {
+				ans = Math.min(ans, queryMin(dfn[top[x]], dfn[x], 1, n, 1));
+				x = fa[top[x]];
+			}
+		}
+		ans = Math.min(ans, queryMin(Math.min(dfn[x], dfn[y]) + 1, Math.max(dfn[x], dfn[y]), 1, n, 1));
+		return ans;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i < n; i++) {
+			addEdge(arr[i][0], arr[i][1]);
+			addEdge(arr[i][1], arr[i][0]);
+		}
+		dfs3();
+		dfs4();
+		for (int i = 1; i < n; i++) {
+			edgeUpdate(i, arr[i][2]);
+		}
+	}
+
+	public static void main(String[] args) {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		for (int i = 1; i < n; i++) {
+			arr[i][0] = io.nextInt() + 1;
+			arr[i][1] = io.nextInt() + 1;
+			arr[i][2] = io.nextInt();
+		}
+		prepare();
+		m = io.nextInt();
+		String op;
+		for (int i = 1, x, y; i <= m; i++) {
+			op = io.next();
+			if (op.equals("C")) {
+				x = io.nextInt();
+				y = io.nextInt();
+				edgeUpdate(x, y);
+			} else {
+				x = io.nextInt() + 1;
+				y = io.nextInt() + 1;
+				if (op.equals("N")) {
+					pathNegative(x, y);
+				} else if (op.equals("SUM")) {
+					io.println(pathSum(x, y));
+				} else if (op.equals("MAX")) {
+					io.println(pathMax(x, y));
+				} else {
+					io.println(pathMin(x, y));
+				}
+			}
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class162/Code03_NationalTour2.java b/src/class162/Code03_NationalTour2.java
new file mode 100644
index 000000000..16100c9ed
--- /dev/null
+++ b/src/class162/Code03_NationalTour2.java
@@ -0,0 +1,299 @@
+package class162;
+
+// 国家集训队旅游，C++版
+// 一共有n个节点，节点编号从0到n-1，所有节点连成一棵树
+// 给定n-1条边，边的编号从1到n-1，每条边给定初始边权
+// 一共有m条操作，每条操作的类型是如下5种类型中的一种
+// 操作 C x y   : 第x条边的边权改成y
+// 操作 N x y   : x号点到y号点的路径上，所有边权变成相反数
+// 操作 SUM x y : x号点到y号点的路径上，查询所有边权的累加和
+// 操作 MAX x y : x号点到y号点的路径上，查询所有边权的最大值
+// 操作 MIN x y : x号点到y号点的路径上，查询所有边权的最小值
+// 1 <= n、m <= 2 * 10^5
+// -1000 <= 任何时候的边权 <= +1000
+// 测试链接 : https://www.luogu.com.cn/problem/P1505
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//int n, m;
+//int arr[MAXN][3];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int cntd = 0;
+//
+//int sumv[MAXN << 2];
+//int maxv[MAXN << 2];
+//int minv[MAXN << 2];
+//bool negativeTag[MAXN << 2];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void up(int i) {
+//    int l = i << 1, r = i << 1 | 1;
+//    sumv[i] = sumv[l] + sumv[r];
+//    maxv[i] = max(maxv[l], maxv[r]);
+//    minv[i] = min(minv[l], minv[r]);
+//}
+//
+//void lazy(int i) {
+//    sumv[i] = -sumv[i];
+//    int tmp = maxv[i];
+//    maxv[i] = -minv[i];
+//    minv[i] = -tmp;
+//    negativeTag[i] = !negativeTag[i];
+//}
+//
+//void down(int i) {
+//    if (negativeTag[i]) {
+//        lazy(i << 1);
+//        lazy(i << 1 | 1);
+//        negativeTag[i] = false;
+//    }
+//}
+//
+//void update(int jobi, int jobv, int l, int r, int i) {
+//    if (l == r) {
+//        sumv[i] = maxv[i] = minv[i] = jobv;
+//    } else {
+//        down(i);
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            update(jobi, jobv, l, mid, i << 1);
+//        } else {
+//            update(jobi, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//void negative(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        lazy(i);
+//    } else {
+//        down(i);
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//        	negative(jobl, jobr, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//        	negative(jobl, jobr, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//int querySum(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return sumv[i];
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    int ans = 0;
+//    if (jobl <= mid) {
+//        ans += querySum(jobl, jobr, l, mid, i << 1);
+//    }
+//    if (jobr > mid) {
+//        ans += querySum(jobl, jobr, mid + 1, r, i << 1 | 1);
+//    }
+//    return ans;
+//}
+//
+//int queryMax(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return maxv[i];
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    int ans = INT_MIN;
+//    if (jobl <= mid) {
+//        ans = max(ans, queryMax(jobl, jobr, l, mid, i << 1));
+//    }
+//    if (jobr > mid) {
+//        ans = max(ans, queryMax(jobl, jobr, mid + 1, r, i << 1 | 1));
+//    }
+//    return ans;
+//}
+//
+//int queryMin(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        return minv[i];
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    int ans = INT_MAX;
+//    if (jobl <= mid) {
+//        ans = min(ans, queryMin(jobl, jobr, l, mid, i << 1));
+//    }
+//    if (jobr > mid) {
+//        ans = min(ans, queryMin(jobl, jobr, mid + 1, r, i << 1 | 1));
+//    }
+//    return ans;
+//}
+//
+//void edgeUpdate(int ei, int val) {
+//    int x = arr[ei][0];
+//    int y = arr[ei][1];
+//    int downx = max(dfn[x], dfn[y]);
+//    update(downx, val, 1, n, 1);
+//}
+//
+//void pathNegative(int x, int y) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//        	negative(dfn[top[y]], dfn[y], 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//        	negative(dfn[top[x]], dfn[x], 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    negative(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), 1, n, 1);
+//}
+//
+//int pathSum(int x, int y) {
+//    int ans = 0;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans += querySum(dfn[top[y]], dfn[y], 1, n, 1);
+//            y = fa[top[y]];
+//        } else {
+//            ans += querySum(dfn[top[x]], dfn[x], 1, n, 1);
+//            x = fa[top[x]];
+//        }
+//    }
+//    ans += querySum(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), 1, n, 1);
+//    return ans;
+//}
+//
+//int pathMax(int x, int y) {
+//    int ans = INT_MIN;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans = max(ans, queryMax(dfn[top[y]], dfn[y], 1, n, 1));
+//            y = fa[top[y]];
+//        } else {
+//            ans = max(ans, queryMax(dfn[top[x]], dfn[x], 1, n, 1));
+//            x = fa[top[x]];
+//        }
+//    }
+//    ans = max(ans, queryMax(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), 1, n, 1));
+//    return ans;
+//}
+//
+//int pathMin(int x, int y) {
+//    int ans = INT_MAX;
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] <= dep[top[y]]) {
+//            ans = min(ans, queryMin(dfn[top[y]], dfn[y], 1, n, 1));
+//            y = fa[top[y]];
+//        } else {
+//            ans = min(ans, queryMin(dfn[top[x]], dfn[x], 1, n, 1));
+//            x = fa[top[x]];
+//        }
+//    }
+//    ans = min(ans, queryMin(min(dfn[x], dfn[y]) + 1, max(dfn[x], dfn[y]), 1, n, 1));
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i < n; i++) {
+//        addEdge(arr[i][0], arr[i][1]);
+//        addEdge(arr[i][1], arr[i][0]);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    for (int i = 1; i < n; i++) {
+//        edgeUpdate(i, arr[i][2]);
+//    }
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for(int i = 1; i < n; i++){
+//        cin >> arr[i][0] >> arr[i][1] >> arr[i][2];
+//        arr[i][0]++;
+//        arr[i][1]++;
+//    }
+//    prepare();
+//    cin >> m;
+//    string op;
+//    for(int i = 1, x, y; i <= m; i++){
+//        string op;
+//        cin >> op;
+//        if(op == "C"){
+//            cin >> x >> y;
+//            edgeUpdate(x, y);
+//        } else {
+//            cin >> x >> y;
+//            x++;
+//            y++;
+//            if(op == "N"){
+//            	pathNegative(x, y);
+//            } else if(op == "SUM"){
+//                cout << pathSum(x, y) << "\n";
+//            } else if(op == "MAX"){
+//                cout << pathMax(x, y) << "\n";
+//            } else {
+//                cout << pathMin(x, y) << "\n";
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 62426ed125657e8ce46ee75b97297b0df6cc1046 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 6 Mar 2025 17:17:14 +0800
Subject: [PATCH 0529/1712] modify code

---
 .../{Code03_NationalTour1.java => Code02_NationalTour1.java}    | 2 +-
 .../{Code03_NationalTour2.java => Code02_NationalTour2.java}    | 0
 src/class162/{Code02_UnderMoon1.java => Code03_UnderMoon1.java} | 2 +-
 src/class162/{Code02_UnderMoon2.java => Code03_UnderMoon2.java} | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class162/{Code03_NationalTour1.java => Code02_NationalTour1.java} (99%)
 rename src/class162/{Code03_NationalTour2.java => Code02_NationalTour2.java} (100%)
 rename src/class162/{Code02_UnderMoon1.java => Code03_UnderMoon1.java} (99%)
 rename src/class162/{Code02_UnderMoon2.java => Code03_UnderMoon2.java} (100%)

diff --git a/src/class162/Code03_NationalTour1.java b/src/class162/Code02_NationalTour1.java
similarity index 99%
rename from src/class162/Code03_NationalTour1.java
rename to src/class162/Code02_NationalTour1.java
index 2844cafa0..5c2188ccd 100644
--- a/src/class162/Code03_NationalTour1.java
+++ b/src/class162/Code02_NationalTour1.java
@@ -23,7 +23,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code03_NationalTour1 {
+public class Code02_NationalTour1 {
 
 	public static int MAXN = 200001;
 	public static int n, m;
diff --git a/src/class162/Code03_NationalTour2.java b/src/class162/Code02_NationalTour2.java
similarity index 100%
rename from src/class162/Code03_NationalTour2.java
rename to src/class162/Code02_NationalTour2.java
diff --git a/src/class162/Code02_UnderMoon1.java b/src/class162/Code03_UnderMoon1.java
similarity index 99%
rename from src/class162/Code02_UnderMoon1.java
rename to src/class162/Code03_UnderMoon1.java
index 4933b8cf0..ec7eb363c 100644
--- a/src/class162/Code02_UnderMoon1.java
+++ b/src/class162/Code03_UnderMoon1.java
@@ -22,7 +22,7 @@
 import java.io.PrintWriter;
 import java.util.StringTokenizer;
 
-public class Code02_UnderMoon1 {
+public class Code03_UnderMoon1 {
 
 	public static int MAXN = 100001;
 	public static int n;
diff --git a/src/class162/Code02_UnderMoon2.java b/src/class162/Code03_UnderMoon2.java
similarity index 100%
rename from src/class162/Code02_UnderMoon2.java
rename to src/class162/Code03_UnderMoon2.java

From b290eea7961e32b90afbe7c660718fb26a2c3379 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 7 Mar 2025 17:00:40 +0800
Subject: [PATCH 0530/1712] modify code

---
 src/class162/Code04_DominantIndices1.java | 246 ++++++++++++++++++++++
 src/class162/Code04_DominantIndices2.java | 120 +++++++++++
 2 files changed, 366 insertions(+)
 create mode 100644 src/class162/Code04_DominantIndices1.java
 create mode 100644 src/class162/Code04_DominantIndices2.java

diff --git a/src/class162/Code04_DominantIndices1.java b/src/class162/Code04_DominantIndices1.java
new file mode 100644
index 000000000..9eb7c8db6
--- /dev/null
+++ b/src/class162/Code04_DominantIndices1.java
@@ -0,0 +1,246 @@
+package class162;
+
+// 哪个距离的点最多，java版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
+// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
+// 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
+// 规定任何点到自己的距离为0
+// 打印每个点的答案
+// 1 <= n <= 10^6
+// 测试链接 : https://codeforces.com/problemset/problem/1009/F
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_DominantIndices1 {
+
+	public static int MAXN = 1000001;
+	public static int n;
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+
+	public static int[] len = new int[MAXN];
+	public static int[] son = new int[MAXN];
+
+	public static int[] start = new int[MAXN];
+	public static int[] dp = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static void set(int u, int i, int v) {
+		dp[start[u] + i] = v;
+	}
+
+	public static int get(int u, int i) {
+		return dp[start[u] + i];
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int fa) {
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa) {
+				if (son[u] == 0 || len[son[u]] < len[v]) {
+					son[u] = v;
+				}
+			}
+		}
+		len[u] = len[son[u]] + 1;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs2(int u, int fa) {
+		// 第一部分，给所有儿子设置start位置
+		set(u, 0, 1);
+		if (son[u] == 0) {
+			ans[u] = 0;
+			return;
+		}
+		start[son[u]] = start[u] + 1;
+		int startSum = start[u] + len[u];
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa && v != son[u]) {
+				start[v] = startSum;
+				startSum += len[v];
+			}
+		}
+		// 第二部分，先遍历长儿子，得到的答案已经放在dp里了，自动复用
+		dfs2(son[u], u);
+		// 第三部分，处理其他儿子
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa && v != son[u]) {
+				dfs2(v, u);
+			}
+		}
+		// 第四部分，计算答案
+		ans[u] = ans[son[u]] + 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa && v != son[u]) {
+				for (int i = 1; i <= len[v]; i++) {
+					set(u, i, get(u, i) + get(v, i - 1));
+					if (get(u, i) > get(u, ans[u]) || (get(u, i) == get(u, ans[u]) && i < ans[u])) {
+						ans[u] = i;
+					}
+				}
+			}
+		}
+		if (get(u, ans[u]) == 1) {
+			ans[u] = 0;
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int a, int b, int c) {
+		ufe[stacksize][0] = a;
+		ufe[stacksize][1] = b;
+		ufe[stacksize][2] = c;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		int v;
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				v = to[e];
+				if (v != f) {
+					push(v, u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = next[ei]) {
+					v = to[ei];
+					if (v != f) {
+						if (son[u] == 0 || len[son[u]] < len[v]) {
+							son[u] = v;
+						}
+					}
+				}
+				len[u] = len[son[u]] + 1;
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 0, -1);
+		int v;
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) { // e == -1，表示第一次来到当前节点，对应第一部分
+				set(u, 0, 1);
+				if (son[u] == 0) {
+					ans[u] = 0;
+					continue;
+				}
+				start[son[u]] = start[u] + 1;
+				int startSum = start[u] + len[u];
+				for (int e = head[u]; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != f && v != son[u]) {
+						start[v] = startSum;
+						startSum += len[v];
+					}
+				}
+				push(u, f, -2); // 设置e = -2，再弹出就表示处理完长儿子了
+				push(son[u], u, -1); // 长儿子的任务进入栈，对应第二部分
+				continue;
+			} else if (e == -2) { // e == -2，表示长儿子已经处理完，该处理其他儿子了
+				e = head[u];
+			} else { // 每个儿子都处理
+				e = next[e];
+			}
+			if (e != 0) { // 对应第三部分
+				push(u, f, e);
+				v = to[e];
+				if (v != f && v != son[u]) {
+					push(v, u, -1);
+				}
+			} else { // 对应第四部分，计算答案
+				ans[u] = ans[son[u]] + 1;
+				for (int e = head[u]; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != f && v != son[u]) {
+						for (int i = 1; i <= len[v]; i++) {
+							set(u, i, get(u, i) + get(v, i - 1));
+							if (get(u, i) > get(u, ans[u]) || (get(u, i) == get(u, ans[u]) && i < ans[u])) {
+								ans[u] = i;
+							}
+						}
+					}
+				}
+				if (get(u, ans[u]) == 1) {
+					ans[u] = 0;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs3();
+		start[1] = 1;
+		dfs4();
+		for (int i = 1; i <= n; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class162/Code04_DominantIndices2.java b/src/class162/Code04_DominantIndices2.java
new file mode 100644
index 000000000..5968d7768
--- /dev/null
+++ b/src/class162/Code04_DominantIndices2.java
@@ -0,0 +1,120 @@
+package class162;
+
+// 哪个距离的点最多，C++版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
+// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
+// 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
+// 规定任何点到自己的距离为0
+// 打印每个点的答案
+// 1 <= n <= 10^6
+// 测试链接 : https://codeforces.com/problemset/problem/1009/F
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//int n;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt = 0;
+//
+//int len[MAXN];
+//int son[MAXN];
+//
+//int start[MAXN];
+//int dp[MAXN];
+//int ans[MAXN];
+//
+//void setVal(int u, int i, int v) {
+//    dp[start[u] + i] = v;
+//}
+//
+//int getVal(int u, int i) {
+//    return dp[start[u] + i];
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void dfs1(int u, int fa) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            if (son[u] == 0 || len[son[u]] < len[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//    len[u] = len[son[u]] + 1;
+//}
+//
+//void dfs2(int u, int fa) {
+//    setVal(u, 0, 1);
+//    if (son[u] == 0) {
+//        ans[u] = 0;
+//        return;
+//    }
+//    start[son[u]] = start[u] + 1;
+//    int startSum = start[u] + len[u];
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            start[v] = startSum;
+//            startSum += len[v];
+//        }
+//    }
+//    dfs2(son[u], u);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            dfs2(v, u);
+//        }
+//    }
+//    ans[u] = ans[son[u]] + 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            for (int i = 1; i <= len[v]; i++) {
+//                setVal(u, i, getVal(u, i) + getVal(v, i - 1));
+//                if (getVal(u, i) > getVal(u, ans[u]) || (getVal(u, i) == getVal(u, ans[u]) && i < ans[u])) {
+//                    ans[u] = i;
+//                }
+//            }
+//        }
+//    }
+//    if (getVal(u, ans[u]) == 1) {
+//        ans[u] = 0;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    start[1] = 1;
+//    dfs2(1, 0);
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 427965c1562af174816251afc00ec87f2e6c3d2b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 7 Mar 2025 17:34:22 +0800
Subject: [PATCH 0531/1712] modify code

---
 src/class162/Code04_DominantIndices1.java | 118 +--------
 src/class162/Code04_DominantIndices2.java | 288 +++++++++++++---------
 src/class162/Code04_DominantIndices3.java | 119 +++++++++
 3 files changed, 303 insertions(+), 222 deletions(-)
 create mode 100644 src/class162/Code04_DominantIndices3.java

diff --git a/src/class162/Code04_DominantIndices1.java b/src/class162/Code04_DominantIndices1.java
index 9eb7c8db6..1a294945e 100644
--- a/src/class162/Code04_DominantIndices1.java
+++ b/src/class162/Code04_DominantIndices1.java
@@ -1,6 +1,6 @@
 package class162;
 
-// 哪个距离的点最多，java版
+// 哪个距离的点最多，java递归版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
 // 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
@@ -8,7 +8,7 @@
 // 打印每个点的答案
 // 1 <= n <= 10^6
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"，因为递归爆栈所以无法通过
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -22,14 +22,17 @@ public class Code04_DominantIndices1 {
 	public static int MAXN = 1000001;
 	public static int n;
 
+	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
 	public static int cnt = 0;
 
+	// 长链剖分
 	public static int[] len = new int[MAXN];
 	public static int[] son = new int[MAXN];
 
+	// 动态规划
 	public static int[] start = new int[MAXN];
 	public static int[] dp = new int[MAXN];
 	public static int[] ans = new int[MAXN];
@@ -111,113 +114,6 @@ public static void dfs2(int u, int fa) {
 		}
 	}
 
-	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	public static int[][] ufe = new int[MAXN][3];
-
-	public static int stacksize, u, f, e;
-
-	public static void push(int a, int b, int c) {
-		ufe[stacksize][0] = a;
-		ufe[stacksize][1] = b;
-		ufe[stacksize][2] = c;
-		stacksize++;
-	}
-
-	public static void pop() {
-		--stacksize;
-		u = ufe[stacksize][0];
-		f = ufe[stacksize][1];
-		e = ufe[stacksize][2];
-	}
-
-	// dfs1的迭代版
-	public static void dfs3() {
-		stacksize = 0;
-		push(1, 0, -1);
-		int v;
-		while (stacksize > 0) {
-			pop();
-			if (e == -1) {
-				e = head[u];
-			} else {
-				e = next[e];
-			}
-			if (e != 0) {
-				push(u, f, e);
-				v = to[e];
-				if (v != f) {
-					push(v, u, -1);
-				}
-			} else {
-				for (int ei = head[u]; ei > 0; ei = next[ei]) {
-					v = to[ei];
-					if (v != f) {
-						if (son[u] == 0 || len[son[u]] < len[v]) {
-							son[u] = v;
-						}
-					}
-				}
-				len[u] = len[son[u]] + 1;
-			}
-		}
-	}
-
-	// dfs2的迭代版
-	public static void dfs4() {
-		stacksize = 0;
-		push(1, 0, -1);
-		int v;
-		while (stacksize > 0) {
-			pop();
-			if (e == -1) { // e == -1，表示第一次来到当前节点，对应第一部分
-				set(u, 0, 1);
-				if (son[u] == 0) {
-					ans[u] = 0;
-					continue;
-				}
-				start[son[u]] = start[u] + 1;
-				int startSum = start[u] + len[u];
-				for (int e = head[u]; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != f && v != son[u]) {
-						start[v] = startSum;
-						startSum += len[v];
-					}
-				}
-				push(u, f, -2); // 设置e = -2，再弹出就表示处理完长儿子了
-				push(son[u], u, -1); // 长儿子的任务进入栈，对应第二部分
-				continue;
-			} else if (e == -2) { // e == -2，表示长儿子已经处理完，该处理其他儿子了
-				e = head[u];
-			} else { // 每个儿子都处理
-				e = next[e];
-			}
-			if (e != 0) { // 对应第三部分
-				push(u, f, e);
-				v = to[e];
-				if (v != f && v != son[u]) {
-					push(v, u, -1);
-				}
-			} else { // 对应第四部分，计算答案
-				ans[u] = ans[son[u]] + 1;
-				for (int e = head[u]; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != f && v != son[u]) {
-						for (int i = 1; i <= len[v]; i++) {
-							set(u, i, get(u, i) + get(v, i - 1));
-							if (get(u, i) > get(u, ans[u]) || (get(u, i) == get(u, ans[u]) && i < ans[u])) {
-								ans[u] = i;
-							}
-						}
-					}
-				}
-				if (get(u, ans[u]) == 1) {
-					ans[u] = 0;
-				}
-			}
-		}
-	}
-
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -232,9 +128,9 @@ public static void main(String[] args) throws IOException {
 			addEdge(u, v);
 			addEdge(v, u);
 		}
-		dfs3();
+		dfs1(1, 0);
 		start[1] = 1;
-		dfs4();
+		dfs2(1, 0);
 		for (int i = 1; i <= n; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class162/Code04_DominantIndices2.java b/src/class162/Code04_DominantIndices2.java
index 5968d7768..5d2a18e31 100644
--- a/src/class162/Code04_DominantIndices2.java
+++ b/src/class162/Code04_DominantIndices2.java
@@ -1,6 +1,6 @@
 package class162;
 
-// 哪个距离的点最多，C++版
+// 哪个距离的点最多，java迭代版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
 // 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
@@ -8,113 +8,179 @@
 // 打印每个点的答案
 // 1 <= n <= 10^6
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//const int MAXN = 1000001;
-//int n;
-//
-//int head[MAXN];
-//int nxt[MAXN << 1];
-//int to[MAXN << 1];
-//int cnt = 0;
-//
-//int len[MAXN];
-//int son[MAXN];
-//
-//int start[MAXN];
-//int dp[MAXN];
-//int ans[MAXN];
-//
-//void setVal(int u, int i, int v) {
-//    dp[start[u] + i] = v;
-//}
-//
-//int getVal(int u, int i) {
-//    return dp[start[u] + i];
-//}
-//
-//void addEdge(int u, int v) {
-//    nxt[++cnt] = head[u];
-//    to[cnt] = v;
-//    head[u] = cnt;
-//}
-//
-//void dfs1(int u, int fa) {
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa) {
-//            dfs1(v, u);
-//        }
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa) {
-//            if (son[u] == 0 || len[son[u]] < len[v]) {
-//                son[u] = v;
-//            }
-//        }
-//    }
-//    len[u] = len[son[u]] + 1;
-//}
-//
-//void dfs2(int u, int fa) {
-//    setVal(u, 0, 1);
-//    if (son[u] == 0) {
-//        ans[u] = 0;
-//        return;
-//    }
-//    start[son[u]] = start[u] + 1;
-//    int startSum = start[u] + len[u];
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa && v != son[u]) {
-//            start[v] = startSum;
-//            startSum += len[v];
-//        }
-//    }
-//    dfs2(son[u], u);
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa && v != son[u]) {
-//            dfs2(v, u);
-//        }
-//    }
-//    ans[u] = ans[son[u]] + 1;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa && v != son[u]) {
-//            for (int i = 1; i <= len[v]; i++) {
-//                setVal(u, i, getVal(u, i) + getVal(v, i - 1));
-//                if (getVal(u, i) > getVal(u, ans[u]) || (getVal(u, i) == getVal(u, ans[u]) && i < ans[u])) {
-//                    ans[u] = i;
-//                }
-//            }
-//        }
-//    }
-//    if (getVal(u, ans[u]) == 1) {
-//        ans[u] = 0;
-//    }
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n;
-//    for (int i = 1, u, v; i < n; i++) {
-//        cin >> u >> v;
-//        addEdge(u, v);
-//        addEdge(v, u);
-//    }
-//    dfs1(1, 0);
-//    start[1] = 1;
-//    dfs2(1, 0);
-//    for (int i = 1; i <= n; i++) {
-//        cout << ans[i] << "\n";
-//    }
-//    return 0;
-//}
\ No newline at end of file
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_DominantIndices2 {
+
+	public static int MAXN = 1000001;
+	public static int n;
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+
+	// 长链剖分
+	public static int[] len = new int[MAXN];
+	public static int[] son = new int[MAXN];
+
+	// 动态规划
+	public static int[] start = new int[MAXN];
+	public static int[] dp = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static void set(int u, int i, int v) {
+		dp[start[u] + i] = v;
+	}
+
+	public static int get(int u, int i) {
+		return dp[start[u] + i];
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int a, int b, int c) {
+		ufe[stacksize][0] = a;
+		ufe[stacksize][1] = b;
+		ufe[stacksize][2] = c;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// 迭代版
+	public static void dfs1() {
+		stacksize = 0;
+		push(1, 0, -1);
+		int v;
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				v = to[e];
+				if (v != f) {
+					push(v, u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = next[ei]) {
+					v = to[ei];
+					if (v != f) {
+						if (son[u] == 0 || len[son[u]] < len[v]) {
+							son[u] = v;
+						}
+					}
+				}
+				len[u] = len[son[u]] + 1;
+			}
+		}
+	}
+
+	// 迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		int v;
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) { // e == -1，表示第一次来到当前节点，对应第一部分
+				set(u, 0, 1);
+				if (son[u] == 0) {
+					ans[u] = 0;
+					continue;
+				}
+				start[son[u]] = start[u] + 1;
+				int startSum = start[u] + len[u];
+				for (int e = head[u]; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != f && v != son[u]) {
+						start[v] = startSum;
+						startSum += len[v];
+					}
+				}
+				push(u, f, -2); // 设置e = -2，再弹出就表示处理完长儿子了
+				push(son[u], u, -1); // 长儿子的任务进入栈，对应第二部分
+				continue;
+			} else if (e == -2) { // e == -2，表示长儿子已经处理完，该处理其他儿子了
+				e = head[u];
+			} else { // 每个儿子都处理
+				e = next[e];
+			}
+			if (e != 0) { // 对应第三部分
+				push(u, f, e);
+				v = to[e];
+				if (v != f && v != son[u]) {
+					push(v, u, -1);
+				}
+			} else { // 对应第四部分，计算答案
+				ans[u] = ans[son[u]] + 1;
+				for (int e = head[u]; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != f && v != son[u]) {
+						for (int i = 1; i <= len[v]; i++) {
+							set(u, i, get(u, i) + get(v, i - 1));
+							if (get(u, i) > get(u, ans[u]) || (get(u, i) == get(u, ans[u]) && i < ans[u])) {
+								ans[u] = i;
+							}
+						}
+					}
+				}
+				if (get(u, ans[u]) == 1) {
+					ans[u] = 0;
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs1();
+		start[1] = 1;
+		dfs2();
+		for (int i = 1; i <= n; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class162/Code04_DominantIndices3.java b/src/class162/Code04_DominantIndices3.java
new file mode 100644
index 000000000..65249dd28
--- /dev/null
+++ b/src/class162/Code04_DominantIndices3.java
@@ -0,0 +1,119 @@
+package class162;
+
+// 哪个距离的点最多，C++版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
+// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
+// 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
+// 规定任何点到自己的距离为0
+// 打印每个点的答案
+// 1 <= n <= 10^6
+// 测试链接 : https://codeforces.com/problemset/problem/1009/F
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//int n;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt = 0;
+//
+//int len[MAXN];
+//int son[MAXN];
+//
+//int start[MAXN];
+//int dp[MAXN];
+//int ans[MAXN];
+//
+//void setVal(int u, int i, int v) {
+//    dp[start[u] + i] = v;
+//}
+//
+//int getVal(int u, int i) {
+//    return dp[start[u] + i];
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void dfs1(int u, int fa) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            if (son[u] == 0 || len[son[u]] < len[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//    len[u] = len[son[u]] + 1;
+//}
+//
+//void dfs2(int u, int fa) {
+//    setVal(u, 0, 1);
+//    if (son[u] == 0) {
+//        ans[u] = 0;
+//        return;
+//    }
+//    start[son[u]] = start[u] + 1;
+//    int startSum = start[u] + len[u];
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            start[v] = startSum;
+//            startSum += len[v];
+//        }
+//    }
+//    dfs2(son[u], u);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            dfs2(v, u);
+//        }
+//    }
+//    ans[u] = ans[son[u]] + 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            for (int i = 1; i <= len[v]; i++) {
+//                setVal(u, i, getVal(u, i) + getVal(v, i - 1));
+//                if (getVal(u, i) > getVal(u, ans[u]) || (getVal(u, i) == getVal(u, ans[u]) && i < ans[u])) {
+//                    ans[u] = i;
+//                }
+//            }
+//        }
+//    }
+//    if (getVal(u, ans[u]) == 1) {
+//        ans[u] = 0;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    start[1] = 1;
+//    dfs2(1, 0);
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 5d432cb680c13a18b2ca8ac39f045a7557b268a7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 7 Mar 2025 17:37:18 +0800
Subject: [PATCH 0532/1712] modify code

---
 src/class162/Code04_DominantIndices1.java | 1 +
 src/class162/Code04_DominantIndices2.java | 1 +
 src/class162/Code04_DominantIndices3.java | 1 +
 3 files changed, 3 insertions(+)

diff --git a/src/class162/Code04_DominantIndices1.java b/src/class162/Code04_DominantIndices1.java
index 1a294945e..079ef867c 100644
--- a/src/class162/Code04_DominantIndices1.java
+++ b/src/class162/Code04_DominantIndices1.java
@@ -7,6 +7,7 @@
 // 规定任何点到自己的距离为0
 // 打印每个点的答案
 // 1 <= n <= 10^6
+// 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
 // 提交以下的code，提交时请把类名改成"Main"，因为递归爆栈所以无法通过
 
diff --git a/src/class162/Code04_DominantIndices2.java b/src/class162/Code04_DominantIndices2.java
index 5d2a18e31..0c66f7abf 100644
--- a/src/class162/Code04_DominantIndices2.java
+++ b/src/class162/Code04_DominantIndices2.java
@@ -7,6 +7,7 @@
 // 规定任何点到自己的距离为0
 // 打印每个点的答案
 // 1 <= n <= 10^6
+// 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class162/Code04_DominantIndices3.java b/src/class162/Code04_DominantIndices3.java
index 65249dd28..f699aed8d 100644
--- a/src/class162/Code04_DominantIndices3.java
+++ b/src/class162/Code04_DominantIndices3.java
@@ -7,6 +7,7 @@
 // 规定任何点到自己的距离为0
 // 打印每个点的答案
 // 1 <= n <= 10^6
+// 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 69d133871aec3b8534e727ba9b539569d06f9f7a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 8 Mar 2025 02:02:27 +0800
Subject: [PATCH 0533/1712] modify code

---
 src/class162/Code04_DominantIndices1.java | 20 ++++++++++----------
 src/class162/Code04_DominantIndices2.java | 20 ++++++++++----------
 src/class162/Code04_DominantIndices3.java | 21 +++++++++++----------
 3 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/src/class162/Code04_DominantIndices1.java b/src/class162/Code04_DominantIndices1.java
index 079ef867c..d64696db6 100644
--- a/src/class162/Code04_DominantIndices1.java
+++ b/src/class162/Code04_DominantIndices1.java
@@ -2,9 +2,9 @@
 
 // 哪个距离的点最多，java递归版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
-// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
-// 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
 // 规定任何点到自己的距离为0
+// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
+// 对于每个点u，想知道哪个尽量小的x，能取得最大的d(u, x)值
 // 打印每个点的答案
 // 1 <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
@@ -36,7 +36,7 @@ public class Code04_DominantIndices1 {
 	// 动态规划
 	public static int[] start = new int[MAXN];
 	public static int[] dp = new int[MAXN];
-	public static int[] ans = new int[MAXN];
+	public static int[] ansx = new int[MAXN];
 
 	public static void set(int u, int i, int v) {
 		dp[start[u] + i] = v;
@@ -76,7 +76,7 @@ public static void dfs2(int u, int fa) {
 		// 第一部分，给所有儿子设置start位置
 		set(u, 0, 1);
 		if (son[u] == 0) {
-			ans[u] = 0;
+			ansx[u] = 0;
 			return;
 		}
 		start[son[u]] = start[u] + 1;
@@ -98,20 +98,20 @@ public static void dfs2(int u, int fa) {
 			}
 		}
 		// 第四部分，计算答案
-		ans[u] = ans[son[u]] + 1;
+		ansx[u] = ansx[son[u]] + 1;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa && v != son[u]) {
 				for (int i = 1; i <= len[v]; i++) {
 					set(u, i, get(u, i) + get(v, i - 1));
-					if (get(u, i) > get(u, ans[u]) || (get(u, i) == get(u, ans[u]) && i < ans[u])) {
-						ans[u] = i;
+					if (get(u, i) > get(u, ansx[u]) || (get(u, i) == get(u, ansx[u]) && i < ansx[u])) {
+						ansx[u] = i;
 					}
 				}
 			}
 		}
-		if (get(u, ans[u]) == 1) {
-			ans[u] = 0;
+		if (get(u, ansx[u]) == 1) {
+			ansx[u] = 0;
 		}
 	}
 
@@ -133,7 +133,7 @@ public static void main(String[] args) throws IOException {
 		start[1] = 1;
 		dfs2(1, 0);
 		for (int i = 1; i <= n; i++) {
-			out.println(ans[i]);
+			out.println(ansx[i]);
 		}
 		out.flush();
 		out.close();
diff --git a/src/class162/Code04_DominantIndices2.java b/src/class162/Code04_DominantIndices2.java
index 0c66f7abf..ba520f2d8 100644
--- a/src/class162/Code04_DominantIndices2.java
+++ b/src/class162/Code04_DominantIndices2.java
@@ -2,9 +2,9 @@
 
 // 哪个距离的点最多，java迭代版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
-// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
-// 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
 // 规定任何点到自己的距离为0
+// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
+// 对于每个点u，想知道哪个尽量小的x，能取得最大的d(u, x)值
 // 打印每个点的答案
 // 1 <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
@@ -36,7 +36,7 @@ public class Code04_DominantIndices2 {
 	// 动态规划
 	public static int[] start = new int[MAXN];
 	public static int[] dp = new int[MAXN];
-	public static int[] ans = new int[MAXN];
+	public static int[] ansx = new int[MAXN];
 
 	public static void set(int u, int i, int v) {
 		dp[start[u] + i] = v;
@@ -113,7 +113,7 @@ public static void dfs2() {
 			if (e == -1) { // e == -1，表示第一次来到当前节点，对应第一部分
 				set(u, 0, 1);
 				if (son[u] == 0) {
-					ans[u] = 0;
+					ansx[u] = 0;
 					continue;
 				}
 				start[son[u]] = start[u] + 1;
@@ -140,20 +140,20 @@ public static void dfs2() {
 					push(v, u, -1);
 				}
 			} else { // 对应第四部分，计算答案
-				ans[u] = ans[son[u]] + 1;
+				ansx[u] = ansx[son[u]] + 1;
 				for (int e = head[u]; e > 0; e = next[e]) {
 					v = to[e];
 					if (v != f && v != son[u]) {
 						for (int i = 1; i <= len[v]; i++) {
 							set(u, i, get(u, i) + get(v, i - 1));
-							if (get(u, i) > get(u, ans[u]) || (get(u, i) == get(u, ans[u]) && i < ans[u])) {
-								ans[u] = i;
+							if (get(u, i) > get(u, ansx[u]) || (get(u, i) == get(u, ansx[u]) && i < ansx[u])) {
+								ansx[u] = i;
 							}
 						}
 					}
 				}
-				if (get(u, ans[u]) == 1) {
-					ans[u] = 0;
+				if (get(u, ansx[u]) == 1) {
+					ansx[u] = 0;
 				}
 			}
 		}
@@ -177,7 +177,7 @@ public static void main(String[] args) throws IOException {
 		start[1] = 1;
 		dfs2();
 		for (int i = 1; i <= n; i++) {
-			out.println(ans[i]);
+			out.println(ansx[i]);
 		}
 		out.flush();
 		out.close();
diff --git a/src/class162/Code04_DominantIndices3.java b/src/class162/Code04_DominantIndices3.java
index f699aed8d..98dac357c 100644
--- a/src/class162/Code04_DominantIndices3.java
+++ b/src/class162/Code04_DominantIndices3.java
@@ -2,9 +2,9 @@
 
 // 哪个距离的点最多，C++版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
-// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
-// 那么对于任何点u，都有若干的d(u, x)值，想让x对应的值最大，并且x尽量小
 // 规定任何点到自己的距离为0
+// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
+// 对于每个点u，想知道哪个尽量小的x，能取得最大的d(u, x)值
 // 打印每个点的答案
 // 1 <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
@@ -13,6 +13,7 @@
 // 提交如下代码，可以通过所有测试用例
 
 //#include <bits/stdc++.h>
+//
 //using namespace std;
 //
 //const int MAXN = 1000001;
@@ -28,7 +29,7 @@
 //
 //int start[MAXN];
 //int dp[MAXN];
-//int ans[MAXN];
+//int ansx[MAXN];
 //
 //void setVal(int u, int i, int v) {
 //    dp[start[u] + i] = v;
@@ -65,7 +66,7 @@
 //void dfs2(int u, int fa) {
 //    setVal(u, 0, 1);
 //    if (son[u] == 0) {
-//        ans[u] = 0;
+//        ansx[u] = 0;
 //        return;
 //    }
 //    start[son[u]] = start[u] + 1;
@@ -84,20 +85,20 @@
 //            dfs2(v, u);
 //        }
 //    }
-//    ans[u] = ans[son[u]] + 1;
+//    ansx[u] = ansx[son[u]] + 1;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != fa && v != son[u]) {
 //            for (int i = 1; i <= len[v]; i++) {
 //                setVal(u, i, getVal(u, i) + getVal(v, i - 1));
-//                if (getVal(u, i) > getVal(u, ans[u]) || (getVal(u, i) == getVal(u, ans[u]) && i < ans[u])) {
-//                    ans[u] = i;
+//                if (getVal(u, i) > getVal(u, ansx[u]) || (getVal(u, i) == getVal(u, ansx[u]) && i < ansx[u])) {
+//                    ansx[u] = i;
 //                }
 //            }
 //        }
 //    }
-//    if (getVal(u, ans[u]) == 1) {
-//        ans[u] = 0;
+//    if (getVal(u, ansx[u]) == 1) {
+//        ansx[u] = 0;
 //    }
 //}
 //
@@ -114,7 +115,7 @@
 //    start[1] = 1;
 //    dfs2(1, 0);
 //    for (int i = 1; i <= n; i++) {
-//        cout << ans[i] << "\n";
+//        cout << ansx[i] << "\n";
 //    }
 //    return 0;
 //}
\ No newline at end of file

From 426e9cdc487e9bae6b6b0116eea61681b6649456 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 8 Mar 2025 17:57:41 +0800
Subject: [PATCH 0534/1712] modify code

---
 src/class162/Code05_Walkthrough1.java | 205 ++++++++++++++++++++++++++
 src/class162/Code05_Walkthrough2.java | 107 ++++++++++++++
 2 files changed, 312 insertions(+)
 create mode 100644 src/class162/Code05_Walkthrough1.java
 create mode 100644 src/class162/Code05_Walkthrough2.java

diff --git a/src/class162/Code05_Walkthrough1.java b/src/class162/Code05_Walkthrough1.java
new file mode 100644
index 000000000..8a65d27ef
--- /dev/null
+++ b/src/class162/Code05_Walkthrough1.java
@@ -0,0 +1,205 @@
+package class162;
+
+// 攻略，java版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树，每个点给定点权
+// 规定1号点是头，任何路径都必须从头开始，然后走到某个叶节点停止
+// 路径上的点，点权的累加和，叫做这个路径的收益
+// 给定数字k，你可以随意选出k条路径，所有路径经过的点，需要取并集，也就是去重
+// 并集中的点，点权的累加和，叫做k条路径的收益
+// 打印k条路径的收益最大值
+// 1 <= n、k <= 2 * 10^5
+// 所有点权都是int类型的正数
+// 测试链接 : https://www.luogu.com.cn/problem/P10641
+// 提交以下的code，提交时请把类名改成"Main"，因为递归爆栈所以无法通过
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code05_Walkthrough1 {
+
+	public static int MAXN = 200001;
+	public static int n, k;
+	public static int[] arr = new int[MAXN];
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+
+	// 长链剖分的改写，根据money的值来标记最值钱儿子
+	public static int[] fa = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+	public static long[] money = new long[MAXN];
+
+	// 每条链的头节点收益排序
+	public static long[] sorted = new long[MAXN];
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	// 递归版
+	public static void dfs1(int u, int f) {
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				if (son[u] == 0 || money[son[u]] < money[v]) {
+					son[u] = v;
+				}
+			}
+		}
+		fa[u] = f;
+		money[u] = money[son[u]] + arr[u];
+	}
+
+	// 递归版
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						if (son[first] == 0 || money[son[first]] < money[v]) {
+							son[first] = v;
+						}
+					}
+				}
+				fa[first] = second;
+				money[first] = money[son[first]] + arr[first];
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static long compute() {
+		int len = 0;
+		for (int i = 1; i <= n; i++) {
+			if (top[i] == i) {
+				sorted[++len] = money[i];
+			}
+		}
+		Arrays.sort(sorted, 1, len + 1);
+		long ans = 0;
+		for (int i = 1, j = len; i <= k; i++, j--) {
+			ans += sorted[j];
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs3();
+		dfs4();
+		out.println(compute());
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class162/Code05_Walkthrough2.java b/src/class162/Code05_Walkthrough2.java
new file mode 100644
index 000000000..486d99f9e
--- /dev/null
+++ b/src/class162/Code05_Walkthrough2.java
@@ -0,0 +1,107 @@
+package class162;
+
+// 攻略，C++版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树，每个点给定点权
+// 规定1号点是头，任何路径都必须从头开始，然后走到某个叶节点停止
+// 路径上的点，点权的累加和，叫做这个路径的收益
+// 给定数字k，你可以随意选出k条路径，所有路径经过的点，需要取并集，也就是去重
+// 并集中的点，点权的累加和，叫做k条路径的收益
+// 打印k条路径的收益最大值
+// 1 <= n、k <= 2 * 10^5
+// 所有点权都是int类型的正数
+// 测试链接 : https://www.luogu.com.cn/problem/P10641
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//int n, k;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt = 0;
+//
+//int fa[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//long long money[MAXN];
+//
+//long long sorted[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void dfs1(int u, int f) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            if (son[u] == 0 || money[son[u]] < money[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//    fa[u] = f;
+//    money[u] = money[son[u]] + arr[u];
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//long long compute() {
+//    int len = 0;
+//    for (int i = 1; i <= n; i++) {
+//        if (top[i] == i) {
+//        	sorted[++len] = money[i];
+//        }
+//    }
+//    sort(sorted + 1, sorted + len + 1);
+//    long long ans = 0;
+//    for (int i = 1, j = len; i <= k; i++, j--) {
+//        ans += sorted[j];
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i < n; i++) {
+//        int u, v;
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    cout << compute() << "\n";
+//    return 0;
+//}
\ No newline at end of file

From d9536c5753cdd65498505b948671cd4eb71d8b20 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 8 Mar 2025 18:07:34 +0800
Subject: [PATCH 0535/1712] modify code

---
 src/class111/Code04_QueryModUpdate.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class111/Code04_QueryModUpdate.java b/src/class111/Code04_QueryModUpdate.java
index 729473a76..a707ebd32 100644
--- a/src/class111/Code04_QueryModUpdate.java
+++ b/src/class111/Code04_QueryModUpdate.java
@@ -7,6 +7,7 @@
 // 操作 3 k x : 把arr[k]上的数字设置为x
 // 1 <= n, m <= 10^5，操作1得到的结果，有可能超过int范围
 // 测试链接 : https://www.luogu.com.cn/problem/CF438D
+// 测试链接 : https://codeforces.com/problemset/problem/438/D
 // 请同学们务必参考如下代码中关于输入、输出的处理
 // 这是输入输出处理效率很高的写法
 // 提交以下的code，提交时请把类名改成"Main"，可以直接通过
@@ -67,7 +68,7 @@ public static void mod(int jobl, int jobr, int jobv, int l, int r, int i) {
 			sum[i] %= jobv;
 			max[i] %= jobv;
 		} else {
-			int mid = (l + r) >> 2;
+			int mid = (l + r) >> 1;
 			if (jobl <= mid) {
 				mod(jobl, jobr, jobv, l, mid, i << 1);
 			}

From f197a95142b5e3c831813238207dadc86f400b75 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 8 Mar 2025 18:20:30 +0800
Subject: [PATCH 0536/1712] modify code

---
 src/class162/Code05_Walkthrough1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class162/Code05_Walkthrough1.java b/src/class162/Code05_Walkthrough1.java
index 8a65d27ef..8316cd88a 100644
--- a/src/class162/Code05_Walkthrough1.java
+++ b/src/class162/Code05_Walkthrough1.java
@@ -10,7 +10,7 @@
 // 1 <= n、k <= 2 * 10^5
 // 所有点权都是int类型的正数
 // 测试链接 : https://www.luogu.com.cn/problem/P10641
-// 提交以下的code，提交时请把类名改成"Main"，因为递归爆栈所以无法通过
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedReader;
 import java.io.IOException;

From 15863cd8b869fe5630e3e420cb09bee01af44065 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 9 Mar 2025 21:09:54 +0800
Subject: [PATCH 0537/1712] modify code

---
 src/class162/Code04_TreeKthAncestor1.java     | 269 ++++++++++++++++++
 src/class162/Code04_TreeKthAncestor2.java     | 162 +++++++++++
 ...ces1.java => Code05_DominantIndices1.java} |   3 +-
 ...ces2.java => Code05_DominantIndices2.java} |   2 +-
 ...ces3.java => Code05_DominantIndices3.java} |   0
 ...through1.java => Code07_Walkthrough1.java} |   2 +-
 ...through2.java => Code07_Walkthrough2.java} |   0
 7 files changed, 435 insertions(+), 3 deletions(-)
 create mode 100644 src/class162/Code04_TreeKthAncestor1.java
 create mode 100644 src/class162/Code04_TreeKthAncestor2.java
 rename src/class162/{Code04_DominantIndices1.java => Code05_DominantIndices1.java} (97%)
 rename src/class162/{Code04_DominantIndices2.java => Code05_DominantIndices2.java} (99%)
 rename src/class162/{Code04_DominantIndices3.java => Code05_DominantIndices3.java} (100%)
 rename src/class162/{Code05_Walkthrough1.java => Code07_Walkthrough1.java} (99%)
 rename src/class162/{Code05_Walkthrough2.java => Code07_Walkthrough2.java} (100%)

diff --git a/src/class162/Code04_TreeKthAncestor1.java b/src/class162/Code04_TreeKthAncestor1.java
new file mode 100644
index 000000000..208edb9f7
--- /dev/null
+++ b/src/class162/Code04_TreeKthAncestor1.java
@@ -0,0 +1,269 @@
+package class162;
+
+// 树上k级祖先，java版
+// 一共有n个节点，编号1~n，给定一个长度为n的数组arr，表示依赖关系
+// 如果arr[i] = j，表示i号节点的父节点是j，如果arr[i] == 0，表示i号节点是树头
+// 一共有m条查询，每条查询 x k : 打印x往上走k步的祖先节点编号
+// 题目要求预处理的时间复杂度O(n * log n)，处理每条查询的时间复杂度O(1)
+// 题目要求强制在线，必须按顺序处理每条查询，如何得到每条查询的入参，请打开测试链接查看
+// 1 <= n <= 5 * 10^5
+// 1 <= m <= 5 * 10^6
+// 测试链接 : https://www.luogu.com.cn/problem/P5903
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code04_TreeKthAncestor1 {
+
+	public static int MAXN = 500001;
+	public static int MAXH = 20;
+	public static int n, m;
+	public static long s;
+	public static int root;
+
+	// 链式前向星，注意是有向图，所以边的数量不需要增倍
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
+	public static int cntg = 0;
+
+	// 倍增表 + 长链剖分
+	public static int[][] stjump = new int[MAXN][MAXH];
+	public static int[] dep = new int[MAXN];
+	public static int[] len = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int cntd = 0;
+
+	// 查询答案需要
+	public static int[] high = new int[MAXN];
+	public static int[] up = new int[MAXN];
+	public static int[] down = new int[MAXN];
+
+	// 题目规定如何得到输入数据的函数
+	// C++中有无符号整数，java中没有，选择用long类型代替
+	public static long get(long x) {
+		x ^= x << 13;
+		x &= 0xffffffffL;
+		x ^= x >>> 17;
+		x ^= x << 5;
+		x &= 0xffffffffL;
+		return s = x;
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版
+	public static void dfs1(int u, int f) {
+		stjump[u][0] = f;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		dep[u] = dep[f] + 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				if (son[u] == 0 || len[son[u]] < len[v]) {
+					son[u] = v;
+				}
+			}
+		}
+		len[u] = len[son[u]] + 1;
+	}
+
+	// 递归版
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != stjump[u][0] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(root, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				stjump[first][0] = second;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[first][p] = stjump[stjump[first][p - 1]][p - 1];
+				}
+				dep[first] = dep[second] + 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						if (son[first] == 0 || len[son[first]] < len[v]) {
+							son[first] = v;
+						}
+					}
+				}
+				len[first] = len[son[first]] + 1;
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(root, root, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) { // edge == -1，表示第一次来到当前节点，并且先处理重儿子
+				top[first] = second;
+				dfn[first] = ++cntd;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) { // edge == -2，表示处理完当前节点的重儿子，回到了当前节点
+				edge = head[first];
+			} else { // edge >= 0, 继续处理其他的边
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != stjump[first][0] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void setUp(int u, int i, int v) {
+		up[dfn[u] + i] = v;
+	}
+
+	public static int getUp(int u, int i) {
+		return up[dfn[u] + i];
+	}
+
+	public static void setDown(int u, int i, int v) {
+		down[dfn[u] + i] = v;
+	}
+
+	public static int getDown(int u, int i) {
+		return down[dfn[u] + i];
+	}
+
+	public static void prepare() {
+		dfs3();
+		dfs4();
+		high[0] = -1;
+		for (int i = 1; i <= n; i++) {
+			high[i] = high[i / 2] + 1;
+		}
+		for (int u = 1; u <= n; u++) {
+			if (top[u] == u) {
+				for (int i = 0, a = u, b = u; i < len[u]; i++, a = stjump[a][0], b = son[b]) {
+					setUp(u, i, a);
+					setDown(u, i, b);
+				}
+			}
+		}
+	}
+
+	public static int query(int x, int k) {
+		if (k == 0) {
+			return x;
+		}
+		if (k == 1 << high[k]) {
+			return stjump[x][high[k]];
+		}
+		x = stjump[x][high[k]];
+		k -= 1 << high[k];
+		k -= dep[x] - dep[top[x]];
+		x = top[x];
+		return (k >= 0) ? getUp(x, k) : getDown(x, -k);
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		in.nextToken();
+		s = (long) in.nval;
+		for (int i = 1, father; i <= n; i++) {
+			in.nextToken();
+			father = (int) in.nval;
+			if (father == 0) {
+				root = i;
+			} else {
+				addEdge(father, i);
+			}
+		}
+		prepare();
+		long ans = 0;
+		for (int i = 1, x, k, lastAns = 0; i <= m; i++) {
+			x = (int) ((get(s) ^ lastAns) % n + 1);
+			k = (int) ((get(s) ^ lastAns) % dep[x]);
+			lastAns = query(x, k);
+			ans ^= (long) i * lastAns;
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class162/Code04_TreeKthAncestor2.java b/src/class162/Code04_TreeKthAncestor2.java
new file mode 100644
index 000000000..12b7724b4
--- /dev/null
+++ b/src/class162/Code04_TreeKthAncestor2.java
@@ -0,0 +1,162 @@
+package class162;
+
+// 树上k级祖先，C++版
+// 一共有n个节点，编号1~n，给定一个长度为n的数组arr，表示依赖关系
+// 如果arr[i] = j，表示i号节点的父节点是j，如果arr[i] == 0，表示i号节点是树头
+// 一共有m条查询，每条查询 x k : 打印x往上走k步的祖先节点编号
+// 题目要求预处理的时间复杂度O(n * log n)，处理每条查询的时间复杂度O(1)
+// 题目要求强制在线，必须按顺序处理每条查询，如何得到每条查询的入参，请打开测试链接查看
+// 1 <= n <= 5 * 10^5
+// 1 <= m <= 5 * 10^6
+// 测试链接 : https://www.luogu.com.cn/problem/P5903
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//#define uint unsigned int
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//const int MAXH = 20;
+//int n, m;
+//uint s;
+//int root;
+//
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cntg = 0;
+//
+//int stjump[MAXN][MAXH];
+//int dep[MAXN];
+//int len[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int cntd = 0;
+//
+//int high[MAXN];
+//int up[MAXN];
+//int down[MAXN];
+//
+//uint get(uint x) {
+//    x ^= x << 13;
+//    x ^= x >> 17;
+//    x ^= x << 5;
+//    s = x;
+//    return x;
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    stjump[u][0] = f;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    dep[u] = dep[f] + 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            if (son[u] == 0 || len[son[u]] < len[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//    len[u] = len[son[u]] + 1;
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    if (son[u] == 0) return;
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != stjump[u][0] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void setUp(int u, int i, int v) {
+//    up[dfn[u] + i] = v;
+//}
+//
+//int getUp(int u, int i) {
+//    return up[dfn[u] + i];
+//}
+//
+//void setDown(int u, int i, int v) {
+//    down[dfn[u] + i] = v;
+//}
+//
+//int getDown(int u, int i) {
+//    return down[dfn[u] + i];
+//}
+//
+//void prepare() {
+//    dfs1(root, 0);
+//    dfs2(root, root);
+//    high[0] = -1;
+//    for (int i = 1; i <= n; i++) {
+//        high[i] = high[i / 2] + 1;
+//    }
+//    for (int u = 1; u <= n; u++) {
+//        if (top[u] == u) {
+//            for (int i = 0, a = u, b = u; i < len[u]; i++, a = stjump[a][0], b = son[b]) {
+//                setUp(u, i, a);
+//                setDown(u, i, b);
+//            }
+//        }
+//    }
+//}
+//
+//int query(int x, int k) {
+//    if (k == 0) {
+//        return x;
+//    }
+//    if (k == (1 << high[k])) {
+//        return stjump[x][high[k]];
+//    }
+//    x = stjump[x][high[k]];
+//    k -= (1 << high[k]);
+//    k -= dep[x] - dep[top[x]];
+//    x = top[x];
+//    return (k >= 0) ? getUp(x, k) : getDown(x, -k);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> s;
+//    for (int i = 1, father; i <= n; i++) {
+//        cin >> father;
+//        if (father == 0) {
+//            root = i;
+//        } else {
+//            addEdge(father, i);
+//        }
+//    }
+//    prepare();
+//    long long ans = 0;
+//    for (int i = 1, x, k, lastAns = 0; i <= m; i++) {
+//        x = (get(s) ^ lastAns) % n + 1;
+//        k = (get(s) ^ lastAns) % dep[x];
+//        lastAns = query(x, k);
+//        ans ^= (long long) i * lastAns;
+//    }
+//    cout << ans << '\n';
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class162/Code04_DominantIndices1.java b/src/class162/Code05_DominantIndices1.java
similarity index 97%
rename from src/class162/Code04_DominantIndices1.java
rename to src/class162/Code05_DominantIndices1.java
index d64696db6..766151709 100644
--- a/src/class162/Code04_DominantIndices1.java
+++ b/src/class162/Code05_DominantIndices1.java
@@ -10,6 +10,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
 // 提交以下的code，提交时请把类名改成"Main"，因为递归爆栈所以无法通过
+// 迭代版的实现就是本节课Code05_DominantIndices2文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -18,7 +19,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_DominantIndices1 {
+public class Code05_DominantIndices1 {
 
 	public static int MAXN = 1000001;
 	public static int n;
diff --git a/src/class162/Code04_DominantIndices2.java b/src/class162/Code05_DominantIndices2.java
similarity index 99%
rename from src/class162/Code04_DominantIndices2.java
rename to src/class162/Code05_DominantIndices2.java
index ba520f2d8..b9e0cbfbd 100644
--- a/src/class162/Code04_DominantIndices2.java
+++ b/src/class162/Code05_DominantIndices2.java
@@ -18,7 +18,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_DominantIndices2 {
+public class Code05_DominantIndices2 {
 
 	public static int MAXN = 1000001;
 	public static int n;
diff --git a/src/class162/Code04_DominantIndices3.java b/src/class162/Code05_DominantIndices3.java
similarity index 100%
rename from src/class162/Code04_DominantIndices3.java
rename to src/class162/Code05_DominantIndices3.java
diff --git a/src/class162/Code05_Walkthrough1.java b/src/class162/Code07_Walkthrough1.java
similarity index 99%
rename from src/class162/Code05_Walkthrough1.java
rename to src/class162/Code07_Walkthrough1.java
index 8316cd88a..5c3e5d2b7 100644
--- a/src/class162/Code05_Walkthrough1.java
+++ b/src/class162/Code07_Walkthrough1.java
@@ -20,7 +20,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code05_Walkthrough1 {
+public class Code07_Walkthrough1 {
 
 	public static int MAXN = 200001;
 	public static int n, k;
diff --git a/src/class162/Code05_Walkthrough2.java b/src/class162/Code07_Walkthrough2.java
similarity index 100%
rename from src/class162/Code05_Walkthrough2.java
rename to src/class162/Code07_Walkthrough2.java

From d444db65a15e8fbc0b2f78113ce358da93924fac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 9 Mar 2025 21:12:58 +0800
Subject: [PATCH 0538/1712] modify code

---
 src/class162/Code04_TreeKthAncestor2.java | 7 ++++---
 1 file changed, 4 insertions(+), 3 deletions(-)

diff --git a/src/class162/Code04_TreeKthAncestor2.java b/src/class162/Code04_TreeKthAncestor2.java
index 12b7724b4..2b05963b4 100644
--- a/src/class162/Code04_TreeKthAncestor2.java
+++ b/src/class162/Code04_TreeKthAncestor2.java
@@ -13,14 +13,15 @@
 // 提交如下代码，可以通过所有测试用例
 
 //#include <bits/stdc++.h>
-//#define uint unsigned int
+//
+//#define ui unsigned int
 //
 //using namespace std;
 //
 //const int MAXN = 500001;
 //const int MAXH = 20;
 //int n, m;
-//uint s;
+//ui s;
 //int root;
 //
 //int head[MAXN];
@@ -40,7 +41,7 @@
 //int up[MAXN];
 //int down[MAXN];
 //
-//uint get(uint x) {
+//ui get(ui x) {
 //    x ^= x << 13;
 //    x ^= x >> 17;
 //    x ^= x << 5;

From 36b34d520d2839dfad3f245ae51ca08294a7ec44 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Mar 2025 16:55:41 +0800
Subject: [PATCH 0539/1712] modify code

---
 src/class162/Code05_DominantIndices1.java | 120 ++++++++-
 src/class162/Code05_DominantIndices2.java | 288 +++++++++-------------
 src/class162/Code05_DominantIndices3.java | 121 ---------
 3 files changed, 224 insertions(+), 305 deletions(-)
 delete mode 100644 src/class162/Code05_DominantIndices3.java

diff --git a/src/class162/Code05_DominantIndices1.java b/src/class162/Code05_DominantIndices1.java
index 766151709..21e1d411c 100644
--- a/src/class162/Code05_DominantIndices1.java
+++ b/src/class162/Code05_DominantIndices1.java
@@ -1,6 +1,6 @@
 package class162;
 
-// 哪个距离的点最多，java递归版
+// 哪个距离的点最多，java版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
 // 规定任何点到自己的距离为0
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
@@ -9,8 +9,7 @@
 // 1 <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
-// 提交以下的code，提交时请把类名改成"Main"，因为递归爆栈所以无法通过
-// 迭代版的实现就是本节课Code05_DominantIndices2文件
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -53,7 +52,7 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
-	// 递归版，C++可以通过，java会爆栈
+	// 递归版，C++可以通过，java会爆栈，迭代版是dfs3方法
 	public static void dfs1(int u, int fa) {
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
@@ -72,7 +71,7 @@ public static void dfs1(int u, int fa) {
 		len[u] = len[son[u]] + 1;
 	}
 
-	// 递归版，C++可以通过，java会爆栈
+	// 递归版，C++可以通过，java会爆栈，迭代版是dfs4方法
 	public static void dfs2(int u, int fa) {
 		// 第一部分，给所有儿子设置start位置
 		set(u, 0, 1);
@@ -116,6 +115,113 @@ public static void dfs2(int u, int fa) {
 		}
 	}
 
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int a, int b, int c) {
+		ufe[stacksize][0] = a;
+		ufe[stacksize][1] = b;
+		ufe[stacksize][2] = c;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// 迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		int v;
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				v = to[e];
+				if (v != f) {
+					push(v, u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = next[ei]) {
+					v = to[ei];
+					if (v != f) {
+						if (son[u] == 0 || len[son[u]] < len[v]) {
+							son[u] = v;
+						}
+					}
+				}
+				len[u] = len[son[u]] + 1;
+			}
+		}
+	}
+
+	// 迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 0, -1);
+		int v;
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) { // e == -1，表示第一次来到当前节点，对应第一部分
+				set(u, 0, 1);
+				if (son[u] == 0) {
+					ansx[u] = 0;
+					continue;
+				}
+				start[son[u]] = start[u] + 1;
+				int startSum = start[u] + len[u];
+				for (int e = head[u]; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != f && v != son[u]) {
+						start[v] = startSum;
+						startSum += len[v];
+					}
+				}
+				push(u, f, -2); // 设置e = -2，再弹出就表示处理完长儿子了
+				push(son[u], u, -1); // 长儿子的任务进入栈，对应第二部分
+				continue;
+			} else if (e == -2) { // e == -2，表示长儿子已经处理完，该处理其他儿子了
+				e = head[u];
+			} else { // 每个儿子都处理
+				e = next[e];
+			}
+			if (e != 0) { // 对应第三部分
+				push(u, f, e);
+				v = to[e];
+				if (v != f && v != son[u]) {
+					push(v, u, -1);
+				}
+			} else { // 对应第四部分，计算答案
+				ansx[u] = ansx[son[u]] + 1;
+				for (int e = head[u]; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != f && v != son[u]) {
+						for (int i = 1; i <= len[v]; i++) {
+							set(u, i, get(u, i) + get(v, i - 1));
+							if (get(u, i) > get(u, ansx[u]) || (get(u, i) == get(u, ansx[u]) && i < ansx[u])) {
+								ansx[u] = i;
+							}
+						}
+					}
+				}
+				if (get(u, ansx[u]) == 1) {
+					ansx[u] = 0;
+				}
+			}
+		}
+	}
+
 	public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
@@ -130,9 +236,9 @@ public static void main(String[] args) throws IOException {
 			addEdge(u, v);
 			addEdge(v, u);
 		}
-		dfs1(1, 0);
+		dfs3();
 		start[1] = 1;
-		dfs2(1, 0);
+		dfs4();
 		for (int i = 1; i <= n; i++) {
 			out.println(ansx[i]);
 		}
diff --git a/src/class162/Code05_DominantIndices2.java b/src/class162/Code05_DominantIndices2.java
index b9e0cbfbd..98dac357c 100644
--- a/src/class162/Code05_DominantIndices2.java
+++ b/src/class162/Code05_DominantIndices2.java
@@ -1,6 +1,6 @@
 package class162;
 
-// 哪个距离的点最多，java迭代版
+// 哪个距离的点最多，C++版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
 // 规定任何点到自己的距离为0
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
@@ -9,179 +9,113 @@
 // 1 <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.StreamTokenizer;
-
-public class Code05_DominantIndices2 {
-
-	public static int MAXN = 1000001;
-	public static int n;
-
-	// 链式前向星
-	public static int[] head = new int[MAXN];
-	public static int[] next = new int[MAXN << 1];
-	public static int[] to = new int[MAXN << 1];
-	public static int cnt = 0;
-
-	// 长链剖分
-	public static int[] len = new int[MAXN];
-	public static int[] son = new int[MAXN];
-
-	// 动态规划
-	public static int[] start = new int[MAXN];
-	public static int[] dp = new int[MAXN];
-	public static int[] ansx = new int[MAXN];
-
-	public static void set(int u, int i, int v) {
-		dp[start[u] + i] = v;
-	}
-
-	public static int get(int u, int i) {
-		return dp[start[u] + i];
-	}
-
-	public static void addEdge(int u, int v) {
-		next[++cnt] = head[u];
-		to[cnt] = v;
-		head[u] = cnt;
-	}
-
-	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	public static int[][] ufe = new int[MAXN][3];
-
-	public static int stacksize, u, f, e;
-
-	public static void push(int a, int b, int c) {
-		ufe[stacksize][0] = a;
-		ufe[stacksize][1] = b;
-		ufe[stacksize][2] = c;
-		stacksize++;
-	}
-
-	public static void pop() {
-		--stacksize;
-		u = ufe[stacksize][0];
-		f = ufe[stacksize][1];
-		e = ufe[stacksize][2];
-	}
-
-	// 迭代版
-	public static void dfs1() {
-		stacksize = 0;
-		push(1, 0, -1);
-		int v;
-		while (stacksize > 0) {
-			pop();
-			if (e == -1) {
-				e = head[u];
-			} else {
-				e = next[e];
-			}
-			if (e != 0) {
-				push(u, f, e);
-				v = to[e];
-				if (v != f) {
-					push(v, u, -1);
-				}
-			} else {
-				for (int ei = head[u]; ei > 0; ei = next[ei]) {
-					v = to[ei];
-					if (v != f) {
-						if (son[u] == 0 || len[son[u]] < len[v]) {
-							son[u] = v;
-						}
-					}
-				}
-				len[u] = len[son[u]] + 1;
-			}
-		}
-	}
-
-	// 迭代版
-	public static void dfs2() {
-		stacksize = 0;
-		push(1, 0, -1);
-		int v;
-		while (stacksize > 0) {
-			pop();
-			if (e == -1) { // e == -1，表示第一次来到当前节点，对应第一部分
-				set(u, 0, 1);
-				if (son[u] == 0) {
-					ansx[u] = 0;
-					continue;
-				}
-				start[son[u]] = start[u] + 1;
-				int startSum = start[u] + len[u];
-				for (int e = head[u]; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != f && v != son[u]) {
-						start[v] = startSum;
-						startSum += len[v];
-					}
-				}
-				push(u, f, -2); // 设置e = -2，再弹出就表示处理完长儿子了
-				push(son[u], u, -1); // 长儿子的任务进入栈，对应第二部分
-				continue;
-			} else if (e == -2) { // e == -2，表示长儿子已经处理完，该处理其他儿子了
-				e = head[u];
-			} else { // 每个儿子都处理
-				e = next[e];
-			}
-			if (e != 0) { // 对应第三部分
-				push(u, f, e);
-				v = to[e];
-				if (v != f && v != son[u]) {
-					push(v, u, -1);
-				}
-			} else { // 对应第四部分，计算答案
-				ansx[u] = ansx[son[u]] + 1;
-				for (int e = head[u]; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != f && v != son[u]) {
-						for (int i = 1; i <= len[v]; i++) {
-							set(u, i, get(u, i) + get(v, i - 1));
-							if (get(u, i) > get(u, ansx[u]) || (get(u, i) == get(u, ansx[u]) && i < ansx[u])) {
-								ansx[u] = i;
-							}
-						}
-					}
-				}
-				if (get(u, ansx[u]) == 1) {
-					ansx[u] = 0;
-				}
-			}
-		}
-	}
-
-	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		n = (int) in.nval;
-		for (int i = 1, u, v; i < n; i++) {
-			in.nextToken();
-			u = (int) in.nval;
-			in.nextToken();
-			v = (int) in.nval;
-			addEdge(u, v);
-			addEdge(v, u);
-		}
-		dfs1();
-		start[1] = 1;
-		dfs2();
-		for (int i = 1; i <= n; i++) {
-			out.println(ansx[i]);
-		}
-		out.flush();
-		out.close();
-		br.close();
-	}
-
-}
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//int n;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt = 0;
+//
+//int len[MAXN];
+//int son[MAXN];
+//
+//int start[MAXN];
+//int dp[MAXN];
+//int ansx[MAXN];
+//
+//void setVal(int u, int i, int v) {
+//    dp[start[u] + i] = v;
+//}
+//
+//int getVal(int u, int i) {
+//    return dp[start[u] + i];
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void dfs1(int u, int fa) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            if (son[u] == 0 || len[son[u]] < len[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//    len[u] = len[son[u]] + 1;
+//}
+//
+//void dfs2(int u, int fa) {
+//    setVal(u, 0, 1);
+//    if (son[u] == 0) {
+//        ansx[u] = 0;
+//        return;
+//    }
+//    start[son[u]] = start[u] + 1;
+//    int startSum = start[u] + len[u];
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            start[v] = startSum;
+//            startSum += len[v];
+//        }
+//    }
+//    dfs2(son[u], u);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            dfs2(v, u);
+//        }
+//    }
+//    ansx[u] = ansx[son[u]] + 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa && v != son[u]) {
+//            for (int i = 1; i <= len[v]; i++) {
+//                setVal(u, i, getVal(u, i) + getVal(v, i - 1));
+//                if (getVal(u, i) > getVal(u, ansx[u]) || (getVal(u, i) == getVal(u, ansx[u]) && i < ansx[u])) {
+//                    ansx[u] = i;
+//                }
+//            }
+//        }
+//    }
+//    if (getVal(u, ansx[u]) == 1) {
+//        ansx[u] = 0;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    start[1] = 1;
+//    dfs2(1, 0);
+//    for (int i = 1; i <= n; i++) {
+//        cout << ansx[i] << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class162/Code05_DominantIndices3.java b/src/class162/Code05_DominantIndices3.java
deleted file mode 100644
index 98dac357c..000000000
--- a/src/class162/Code05_DominantIndices3.java
+++ /dev/null
@@ -1,121 +0,0 @@
-package class162;
-
-// 哪个距离的点最多，C++版
-// 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
-// 规定任何点到自己的距离为0
-// 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
-// 对于每个点u，想知道哪个尽量小的x，能取得最大的d(u, x)值
-// 打印每个点的答案
-// 1 <= n <= 10^6
-// 测试链接 : https://www.luogu.com.cn/problem/CF1009F
-// 测试链接 : https://codeforces.com/problemset/problem/1009/F
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//const int MAXN = 1000001;
-//int n;
-//
-//int head[MAXN];
-//int nxt[MAXN << 1];
-//int to[MAXN << 1];
-//int cnt = 0;
-//
-//int len[MAXN];
-//int son[MAXN];
-//
-//int start[MAXN];
-//int dp[MAXN];
-//int ansx[MAXN];
-//
-//void setVal(int u, int i, int v) {
-//    dp[start[u] + i] = v;
-//}
-//
-//int getVal(int u, int i) {
-//    return dp[start[u] + i];
-//}
-//
-//void addEdge(int u, int v) {
-//    nxt[++cnt] = head[u];
-//    to[cnt] = v;
-//    head[u] = cnt;
-//}
-//
-//void dfs1(int u, int fa) {
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa) {
-//            dfs1(v, u);
-//        }
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa) {
-//            if (son[u] == 0 || len[son[u]] < len[v]) {
-//                son[u] = v;
-//            }
-//        }
-//    }
-//    len[u] = len[son[u]] + 1;
-//}
-//
-//void dfs2(int u, int fa) {
-//    setVal(u, 0, 1);
-//    if (son[u] == 0) {
-//        ansx[u] = 0;
-//        return;
-//    }
-//    start[son[u]] = start[u] + 1;
-//    int startSum = start[u] + len[u];
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa && v != son[u]) {
-//            start[v] = startSum;
-//            startSum += len[v];
-//        }
-//    }
-//    dfs2(son[u], u);
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa && v != son[u]) {
-//            dfs2(v, u);
-//        }
-//    }
-//    ansx[u] = ansx[son[u]] + 1;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa && v != son[u]) {
-//            for (int i = 1; i <= len[v]; i++) {
-//                setVal(u, i, getVal(u, i) + getVal(v, i - 1));
-//                if (getVal(u, i) > getVal(u, ansx[u]) || (getVal(u, i) == getVal(u, ansx[u]) && i < ansx[u])) {
-//                    ansx[u] = i;
-//                }
-//            }
-//        }
-//    }
-//    if (getVal(u, ansx[u]) == 1) {
-//        ansx[u] = 0;
-//    }
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n;
-//    for (int i = 1, u, v; i < n; i++) {
-//        cin >> u >> v;
-//        addEdge(u, v);
-//        addEdge(v, u);
-//    }
-//    dfs1(1, 0);
-//    start[1] = 1;
-//    dfs2(1, 0);
-//    for (int i = 1; i <= n; i++) {
-//        cout << ansx[i] << "\n";
-//    }
-//    return 0;
-//}
\ No newline at end of file

From b2ddb2323f9f14296cc5d9f60f6789ec868f5514 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Mar 2025 21:36:59 +0800
Subject: [PATCH 0540/1712] modify code

---
 ...through1.java => Code05_Walkthrough1.java} |   2 +-
 ...through2.java => Code05_Walkthrough2.java} |   0
 ...ces1.java => Code06_DominantIndices1.java} |  50 ++----
 ...ces2.java => Code06_DominantIndices2.java} |  26 +--
 src/class162/Code07_HotHotels1.java           | 165 ++++++++++++++++++
 src/class162/Code07_HotHotels2.java           | 149 ++++++++++++++++
 6 files changed, 339 insertions(+), 53 deletions(-)
 rename src/class162/{Code07_Walkthrough1.java => Code05_Walkthrough1.java} (99%)
 rename src/class162/{Code07_Walkthrough2.java => Code05_Walkthrough2.java} (100%)
 rename src/class162/{Code05_DominantIndices1.java => Code06_DominantIndices1.java} (82%)
 rename src/class162/{Code05_DominantIndices2.java => Code06_DominantIndices2.java} (85%)
 create mode 100644 src/class162/Code07_HotHotels1.java
 create mode 100644 src/class162/Code07_HotHotels2.java

diff --git a/src/class162/Code07_Walkthrough1.java b/src/class162/Code05_Walkthrough1.java
similarity index 99%
rename from src/class162/Code07_Walkthrough1.java
rename to src/class162/Code05_Walkthrough1.java
index 5c3e5d2b7..8316cd88a 100644
--- a/src/class162/Code07_Walkthrough1.java
+++ b/src/class162/Code05_Walkthrough1.java
@@ -20,7 +20,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code07_Walkthrough1 {
+public class Code05_Walkthrough1 {
 
 	public static int MAXN = 200001;
 	public static int n, k;
diff --git a/src/class162/Code07_Walkthrough2.java b/src/class162/Code05_Walkthrough2.java
similarity index 100%
rename from src/class162/Code07_Walkthrough2.java
rename to src/class162/Code05_Walkthrough2.java
diff --git a/src/class162/Code05_DominantIndices1.java b/src/class162/Code06_DominantIndices1.java
similarity index 82%
rename from src/class162/Code05_DominantIndices1.java
rename to src/class162/Code06_DominantIndices1.java
index 21e1d411c..82e53c157 100644
--- a/src/class162/Code05_DominantIndices1.java
+++ b/src/class162/Code06_DominantIndices1.java
@@ -18,7 +18,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code05_DominantIndices1 {
+public class Code06_DominantIndices1 {
 
 	public static int MAXN = 1000001;
 	public static int n;
@@ -27,29 +27,30 @@ public class Code05_DominantIndices1 {
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
-	public static int cnt = 0;
+	public static int cntg = 0;
 
 	// 长链剖分
 	public static int[] len = new int[MAXN];
 	public static int[] son = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int cntd = 0;
 
 	// 动态规划
-	public static int[] start = new int[MAXN];
 	public static int[] dp = new int[MAXN];
 	public static int[] ansx = new int[MAXN];
 
 	public static void set(int u, int i, int v) {
-		dp[start[u] + i] = v;
+		dp[dfn[u] + i] = v;
 	}
 
 	public static int get(int u, int i) {
-		return dp[start[u] + i];
+		return dp[dfn[u] + i];
 	}
 
 	public static void addEdge(int u, int v) {
-		next[++cnt] = head[u];
-		to[cnt] = v;
-		head[u] = cnt;
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
 	}
 
 	// 递归版，C++可以通过，java会爆栈，迭代版是dfs3方法
@@ -73,31 +74,19 @@ public static void dfs1(int u, int fa) {
 
 	// 递归版，C++可以通过，java会爆栈，迭代版是dfs4方法
 	public static void dfs2(int u, int fa) {
-		// 第一部分，给所有儿子设置start位置
+		dfn[u] = ++cntd;
 		set(u, 0, 1);
 		if (son[u] == 0) {
 			ansx[u] = 0;
 			return;
 		}
-		start[son[u]] = start[u] + 1;
-		int startSum = start[u] + len[u];
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != fa && v != son[u]) {
-				start[v] = startSum;
-				startSum += len[v];
-			}
-		}
-		// 第二部分，先遍历长儿子，得到的答案已经放在dp里了，自动复用
 		dfs2(son[u], u);
-		// 第三部分，处理其他儿子
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa && v != son[u]) {
 				dfs2(v, u);
 			}
 		}
-		// 第四部分，计算答案
 		ansx[u] = ansx[son[u]] + 1;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
@@ -173,36 +162,28 @@ public static void dfs4() {
 		int v;
 		while (stacksize > 0) {
 			pop();
-			if (e == -1) { // e == -1，表示第一次来到当前节点，对应第一部分
+			if (e == -1) { // e == -1，表示第一次来到当前节点
+				dfn[u] = ++cntd;
 				set(u, 0, 1);
 				if (son[u] == 0) {
 					ansx[u] = 0;
 					continue;
 				}
-				start[son[u]] = start[u] + 1;
-				int startSum = start[u] + len[u];
-				for (int e = head[u]; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != f && v != son[u]) {
-						start[v] = startSum;
-						startSum += len[v];
-					}
-				}
 				push(u, f, -2); // 设置e = -2，再弹出就表示处理完长儿子了
-				push(son[u], u, -1); // 长儿子的任务进入栈，对应第二部分
+				push(son[u], u, -1); // 长儿子的任务进入栈
 				continue;
 			} else if (e == -2) { // e == -2，表示长儿子已经处理完，该处理其他儿子了
 				e = head[u];
 			} else { // 每个儿子都处理
 				e = next[e];
 			}
-			if (e != 0) { // 对应第三部分
+			if (e != 0) {
 				push(u, f, e);
 				v = to[e];
 				if (v != f && v != son[u]) {
 					push(v, u, -1);
 				}
-			} else { // 对应第四部分，计算答案
+			} else { // 更新dp、计算答案
 				ansx[u] = ansx[son[u]] + 1;
 				for (int e = head[u]; e > 0; e = next[e]) {
 					v = to[e];
@@ -237,7 +218,6 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		dfs3();
-		start[1] = 1;
 		dfs4();
 		for (int i = 1; i <= n; i++) {
 			out.println(ansx[i]);
diff --git a/src/class162/Code05_DominantIndices2.java b/src/class162/Code06_DominantIndices2.java
similarity index 85%
rename from src/class162/Code05_DominantIndices2.java
rename to src/class162/Code06_DominantIndices2.java
index 98dac357c..cf881d494 100644
--- a/src/class162/Code05_DominantIndices2.java
+++ b/src/class162/Code06_DominantIndices2.java
@@ -22,27 +22,28 @@
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
-//int cnt = 0;
+//int cntg = 0;
 //
 //int len[MAXN];
 //int son[MAXN];
+//int dfn[MAXN];
+//int cntd = 0;
 //
-//int start[MAXN];
 //int dp[MAXN];
 //int ansx[MAXN];
 //
 //void setVal(int u, int i, int v) {
-//    dp[start[u] + i] = v;
+//    dp[dfn[u] + i] = v;
 //}
 //
 //int getVal(int u, int i) {
-//    return dp[start[u] + i];
+//    return dp[dfn[u] + i];
 //}
 //
 //void addEdge(int u, int v) {
-//    nxt[++cnt] = head[u];
-//    to[cnt] = v;
-//    head[u] = cnt;
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
 //}
 //
 //void dfs1(int u, int fa) {
@@ -64,20 +65,12 @@
 //}
 //
 //void dfs2(int u, int fa) {
+//    dfn[u] = ++cntd;
 //    setVal(u, 0, 1);
 //    if (son[u] == 0) {
 //        ansx[u] = 0;
 //        return;
 //    }
-//    start[son[u]] = start[u] + 1;
-//    int startSum = start[u] + len[u];
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa && v != son[u]) {
-//            start[v] = startSum;
-//            startSum += len[v];
-//        }
-//    }
 //    dfs2(son[u], u);
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
@@ -112,7 +105,6 @@
 //        addEdge(v, u);
 //    }
 //    dfs1(1, 0);
-//    start[1] = 1;
 //    dfs2(1, 0);
 //    for (int i = 1; i <= n; i++) {
 //        cout << ansx[i] << "\n";
diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
new file mode 100644
index 000000000..6e6ad5f59
--- /dev/null
+++ b/src/class162/Code07_HotHotels1.java
@@ -0,0 +1,165 @@
+package class162;
+
+// 火热旅馆，java版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树
+// 三个点构成一个点组(a, b, c)，打乱顺序依然认为是同一个点组
+// 求树上有多少点组，两两之间的距离是一样的
+// 1 <= n <= 10^5
+// 答案一定在long类型范围内
+// 测试链接 : https://www.luogu.com.cn/problem/P5904
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code07_HotHotels1 {
+
+	public static int MAXN = 100001;
+	public static int n;
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] len = new int[MAXN];
+	public static int cntd = 0;
+
+	public static int[] fid = new int[MAXN];
+	public static int[] gid = new int[MAXN];
+	public static long[] f = new long[MAXN];
+	public static long[] g = new long[MAXN << 1];
+	public static long ans = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，居然不改迭代版也能通过，那就不改了
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				if (son[u] == 0 || len[son[u]] < len[v]) {
+					son[u] = v;
+				}
+			}
+		}
+		len[u] = len[son[u]] + 1;
+	}
+
+	// 递归版，居然不改迭代版也能通过，那就不改了
+	public static void dfs2(int u, int t) {
+		fid[u] = cntd++;
+		if (son[u] == 0) {
+			gid[u] = fid[t] * 2;
+			return;
+		}
+		dfs2(son[u], t);
+		gid[u] = gid[son[u]] + 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != son[u] && v != fa[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	public static void setf(int u, int i, long v) {
+		f[fid[u] + i] = v;
+	}
+
+	public static long getf(int u, int i) {
+		return f[fid[u] + i];
+	}
+
+	public static void setg(int u, int i, long v) {
+		g[gid[u] + i] = v;
+	}
+
+	public static long getg(int u, int i) {
+		return g[gid[u] + i];
+	}
+
+	// 递归版，居然不改迭代版也能通过，那就不改了
+	public static void dfs3(int u) {
+		if (son[u] == 0) {
+			setf(u, 0, 1);
+			return;
+		}
+		dfs3(son[u]);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != son[u] && v != fa[u]) {
+				dfs3(v);
+			}
+		}
+		ans += getg(u, 0);
+		setf(u, 0, getf(u, 0) + 1);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != son[u] && v != fa[u]) {
+				for (int i = 0; i <= len[v]; i++) {
+					if (i > 0) {
+						ans += getg(u, i) * getf(v, i - 1);
+					}
+					if (i + 1 < len[v]) {
+						ans += getf(u, i) * getg(v, i + 1);
+					}
+				}
+				for (int i = 0; i <= len[v]; i++) {
+					if (i > 0) {
+						setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+					}
+				}
+				for (int i = 0; i <= len[v]; i++) {
+					if (i < len[v]) {
+						setg(u, i, getg(u, i) + getg(v, i + 1));
+					}
+					if (i > 0) {
+						setf(u, i, getf(u, i) + getf(v, i - 1));
+					}
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs1(1, 0);
+		dfs2(1, 1);
+		dfs3(1);
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
\ No newline at end of file
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
new file mode 100644
index 000000000..0674b96f3
--- /dev/null
+++ b/src/class162/Code07_HotHotels2.java
@@ -0,0 +1,149 @@
+package class162;
+
+// 火热旅馆，C++版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树
+// 三个点构成一个点组(a, b, c)，打乱顺序依然认为是同一个点组
+// 求树上有多少点组，两两之间的距离是一样的
+// 1 <= n <= 10^5
+// 答案一定在long类型范围内
+// 测试链接 : https://www.luogu.com.cn/problem/P5904
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int fa[MAXN];
+//int son[MAXN];
+//int len[MAXN];
+//int cntd;
+//
+//int fid[MAXN];
+//int gid[MAXN];
+//long long f[MAXN << 1];
+//long long g[MAXN << 1];
+//long long ans;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            if (son[u] == 0 || len[son[u]] < len[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//    len[u] = len[son[u]] + 1;
+//}
+//
+//void dfs2(int u, int t) {
+//    fid[u] = cntd++;
+//    if (son[u] == 0) {
+//        gid[u] = fid[t] * 2;
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    gid[u] = gid[son[u]] + 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != son[u] && v != fa[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void setf(int u, int i, long long v) {
+//    f[fid[u] + i] = v;
+//}
+//
+//long long getf(int u, int i) {
+//    return f[fid[u] + i];
+//}
+//
+//void setg(int u, int i, long long v) {
+//    g[gid[u] + i] = v;
+//}
+//
+//long long getg(int u, int i) {
+//    return g[gid[u] + i];
+//}
+//
+//void dfs3(int u) {
+//    if (son[u] == 0) {
+//        setf(u, 0, 1);
+//        return;
+//    }
+//    dfs3(son[u]);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != son[u] && v != fa[u]) {
+//            dfs3(v);
+//        }
+//    }
+//    ans += getg(u, 0);
+//    setf(u, 0, getf(u, 0) + 1);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != son[u] && v != fa[u]) {
+//            for (int i = 0; i <= len[v]; i++) {
+//                if (i > 0) {
+//                    ans += getg(u, i) * getf(v, i - 1);
+//                }
+//                if (i + 1 < len[v]) {
+//                    ans += getf(u, i) * getg(v, i + 1);
+//                }
+//            }
+//            for (int i = 0; i <= len[v]; i++) {
+//                if (i > 0) {
+//                    setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+//                }
+//            }
+//            for (int i = 0; i <= len[v]; i++) {
+//                if (i < len[v]) {
+//                    setg(u, i, getg(u, i) + getg(v, i + 1));
+//                }
+//                if (i > 0) {
+//                    setf(u, i, getf(u, i) + getf(v, i - 1));
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    dfs3(1);
+//    cout << ans << "\n";
+//    return 0;
+//}
\ No newline at end of file

From c313543fc7232107887ddc27574fd4d0a2c49f11 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Mar 2025 21:44:50 +0800
Subject: [PATCH 0541/1712] modify code

---
 src/class162/Code07_HotHotels2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 0674b96f3..666f039c8 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -29,7 +29,7 @@
 //
 //int fid[MAXN];
 //int gid[MAXN];
-//long long f[MAXN << 1];
+//long long f[MAXN];
 //long long g[MAXN << 1];
 //long long ans;
 //

From c077fa3c8406840866903936305dda98db25072a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Mar 2025 21:48:23 +0800
Subject: [PATCH 0542/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 2 +-
 src/class162/Code07_HotHotels2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 6e6ad5f59..85f231a86 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -71,13 +71,13 @@ public static void dfs2(int u, int t) {
 			return;
 		}
 		dfs2(son[u], t);
-		gid[u] = gid[son[u]] + 1;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u] && v != fa[u]) {
 				dfs2(v, v);
 			}
 		}
+		gid[u] = gid[son[u]] + 1;
 	}
 
 	public static void setf(int u, int i, long v) {
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 666f039c8..5669ced3b 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -65,13 +65,13 @@
 //        return;
 //    }
 //    dfs2(son[u], t);
-//    gid[u] = gid[son[u]] + 1;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u] && v != fa[u]) {
 //            dfs2(v, v);
 //        }
 //    }
+//    gid[u] = gid[son[u]] + 1;
 //}
 //
 //void setf(int u, int i, long long v) {

From a45f28870aedf3c18a94a8f8de87d37867c5ee63 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Mar 2025 21:58:26 +0800
Subject: [PATCH 0543/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 6 +-----
 src/class162/Code07_HotHotels2.java | 6 +-----
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 85f231a86..be1f0175d 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -125,15 +125,11 @@ public static void dfs3(int u) {
 				for (int i = 0; i <= len[v]; i++) {
 					if (i > 0) {
 						setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+						setf(u, i, getf(u, i) + getf(v, i - 1));
 					}
-				}
-				for (int i = 0; i <= len[v]; i++) {
 					if (i < len[v]) {
 						setg(u, i, getg(u, i) + getg(v, i + 1));
 					}
-					if (i > 0) {
-						setf(u, i, getf(u, i) + getf(v, i - 1));
-					}
 				}
 			}
 		}
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 5669ced3b..e4cd1f2a1 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -118,15 +118,11 @@
 //            for (int i = 0; i <= len[v]; i++) {
 //                if (i > 0) {
 //                    setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+//                    setf(u, i, getf(u, i) + getf(v, i - 1));
 //                }
-//            }
-//            for (int i = 0; i <= len[v]; i++) {
 //                if (i < len[v]) {
 //                    setg(u, i, getg(u, i) + getg(v, i + 1));
 //                }
-//                if (i > 0) {
-//                    setf(u, i, getf(u, i) + getf(v, i - 1));
-//                }
 //            }
 //        }
 //    }

From e06c3ba2c4de15748289afce817bd7a57896abb9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Mar 2025 22:02:28 +0800
Subject: [PATCH 0544/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 4 ++++
 src/class162/Code07_HotHotels2.java | 4 ++++
 2 files changed, 8 insertions(+)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index be1f0175d..3ebb47014 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -125,6 +125,10 @@ public static void dfs3(int u) {
 				for (int i = 0; i <= len[v]; i++) {
 					if (i > 0) {
 						setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+					}
+				}
+				for (int i = 0; i <= len[v]; i++) {
+					if (i > 0) {
 						setf(u, i, getf(u, i) + getf(v, i - 1));
 					}
 					if (i < len[v]) {
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index e4cd1f2a1..062baea06 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -118,6 +118,10 @@
 //            for (int i = 0; i <= len[v]; i++) {
 //                if (i > 0) {
 //                    setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+//                }
+//            }
+//            for (int i = 0; i <= len[v]; i++) {
+//                if (i > 0) {
 //                    setf(u, i, getf(u, i) + getf(v, i - 1));
 //                }
 //                if (i < len[v]) {

From 0987c52ff695f8be1dc8535eb363127fff3d057b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Mar 2025 00:47:32 +0800
Subject: [PATCH 0545/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 4 ++--
 src/class162/Code07_HotHotels2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 3ebb47014..4aa05a60f 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -2,8 +2,8 @@
 
 // 火热旅馆，java版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 三个点构成一个点组(a, b, c)，打乱顺序依然认为是同一个点组
-// 求树上有多少点组，两两之间的距离是一样的
+// 三个点构成一个点组(a, b, c)，打乱顺序认为是同一个点组
+// 求树上有多少点组，内部任意两个节点之间的距离是一样的
 // 1 <= n <= 10^5
 // 答案一定在long类型范围内
 // 测试链接 : https://www.luogu.com.cn/problem/P5904
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 062baea06..de02cd101 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -2,8 +2,8 @@
 
 // 火热旅馆，C++版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 三个点构成一个点组(a, b, c)，打乱顺序依然认为是同一个点组
-// 求树上有多少点组，两两之间的距离是一样的
+// 三个点构成一个点组(a, b, c)，打乱顺序认为是同一个点组
+// 求树上有多少点组，内部任意两个节点之间的距离是一样的
 // 1 <= n <= 10^5
 // 答案一定在long类型范围内
 // 测试链接 : https://www.luogu.com.cn/problem/P5904

From 4d3dcc90af4cfe6d882388d01579a08f90b3ca64 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Mar 2025 00:51:12 +0800
Subject: [PATCH 0546/1712] modify code

---
 src/class162/Code06_DominantIndices1.java | 2 +-
 src/class162/Code06_DominantIndices2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class162/Code06_DominantIndices1.java b/src/class162/Code06_DominantIndices1.java
index 82e53c157..f0ce088cf 100644
--- a/src/class162/Code06_DominantIndices1.java
+++ b/src/class162/Code06_DominantIndices1.java
@@ -5,7 +5,7 @@
 // 规定任何点到自己的距离为0
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
 // 对于每个点u，想知道哪个尽量小的x，能取得最大的d(u, x)值
-// 打印每个点的答案
+// 打印每个点的答案x
 // 1 <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F
diff --git a/src/class162/Code06_DominantIndices2.java b/src/class162/Code06_DominantIndices2.java
index cf881d494..51fd963d7 100644
--- a/src/class162/Code06_DominantIndices2.java
+++ b/src/class162/Code06_DominantIndices2.java
@@ -5,7 +5,7 @@
 // 规定任何点到自己的距离为0
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
 // 对于每个点u，想知道哪个尽量小的x，能取得最大的d(u, x)值
-// 打印每个点的答案
+// 打印每个点的答案x
 // 1 <= n <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1009F
 // 测试链接 : https://codeforces.com/problemset/problem/1009/F

From 8783585be39ddcaf0b9222a2bedff527e7207b18 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Mar 2025 00:57:13 +0800
Subject: [PATCH 0547/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 32 ++++++++++++++---------------
 src/class162/Code07_HotHotels2.java | 32 ++++++++++++++---------------
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 4aa05a60f..78014f690 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -37,6 +37,22 @@ public class Code07_HotHotels1 {
 	public static long[] g = new long[MAXN << 1];
 	public static long ans = 0;
 
+	public static void setf(int u, int i, long v) {
+		f[fid[u] + i] = v;
+	}
+
+	public static long getf(int u, int i) {
+		return f[fid[u] + i];
+	}
+
+	public static void setg(int u, int i, long v) {
+		g[gid[u] + i] = v;
+	}
+
+	public static long getg(int u, int i) {
+		return g[gid[u] + i];
+	}
+
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
@@ -80,22 +96,6 @@ public static void dfs2(int u, int t) {
 		gid[u] = gid[son[u]] + 1;
 	}
 
-	public static void setf(int u, int i, long v) {
-		f[fid[u] + i] = v;
-	}
-
-	public static long getf(int u, int i) {
-		return f[fid[u] + i];
-	}
-
-	public static void setg(int u, int i, long v) {
-		g[gid[u] + i] = v;
-	}
-
-	public static long getg(int u, int i) {
-		return g[gid[u] + i];
-	}
-
 	// 递归版，居然不改迭代版也能通过，那就不改了
 	public static void dfs3(int u) {
 		if (son[u] == 0) {
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index de02cd101..0e2e26a35 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -33,6 +33,22 @@
 //long long g[MAXN << 1];
 //long long ans;
 //
+//void setf(int u, int i, long long v) {
+//    f[fid[u] + i] = v;
+//}
+//
+//long long getf(int u, int i) {
+//    return f[fid[u] + i];
+//}
+//
+//void setg(int u, int i, long long v) {
+//    g[gid[u] + i] = v;
+//}
+//
+//long long getg(int u, int i) {
+//    return g[gid[u] + i];
+//}
+//
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
 //    to[cntg] = v;
@@ -74,22 +90,6 @@
 //    gid[u] = gid[son[u]] + 1;
 //}
 //
-//void setf(int u, int i, long long v) {
-//    f[fid[u] + i] = v;
-//}
-//
-//long long getf(int u, int i) {
-//    return f[fid[u] + i];
-//}
-//
-//void setg(int u, int i, long long v) {
-//    g[gid[u] + i] = v;
-//}
-//
-//long long getg(int u, int i) {
-//    return g[gid[u] + i];
-//}
-//
 //void dfs3(int u) {
 //    if (son[u] == 0) {
 //        setf(u, 0, 1);

From d0da031b44d32cfc9a8ce1df6391efec0e388bef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Mar 2025 01:01:21 +0800
Subject: [PATCH 0548/1712] modify code

---
 src/class162/Code04_TreeKthAncestor1.java | 32 +++++++++++------------
 src/class162/Code04_TreeKthAncestor2.java | 32 +++++++++++------------
 2 files changed, 32 insertions(+), 32 deletions(-)

diff --git a/src/class162/Code04_TreeKthAncestor1.java b/src/class162/Code04_TreeKthAncestor1.java
index 208edb9f7..dbd1338a0 100644
--- a/src/class162/Code04_TreeKthAncestor1.java
+++ b/src/class162/Code04_TreeKthAncestor1.java
@@ -57,6 +57,22 @@ public static long get(long x) {
 		return s = x;
 	}
 
+	public static void setUp(int u, int i, int v) {
+		up[dfn[u] + i] = v;
+	}
+
+	public static int getUp(int u, int i) {
+		return up[dfn[u] + i];
+	}
+
+	public static void setDown(int u, int i, int v) {
+		down[dfn[u] + i] = v;
+	}
+
+	public static int getDown(int u, int i) {
+		return down[dfn[u] + i];
+	}
+
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
@@ -186,22 +202,6 @@ public static void dfs4() {
 		}
 	}
 
-	public static void setUp(int u, int i, int v) {
-		up[dfn[u] + i] = v;
-	}
-
-	public static int getUp(int u, int i) {
-		return up[dfn[u] + i];
-	}
-
-	public static void setDown(int u, int i, int v) {
-		down[dfn[u] + i] = v;
-	}
-
-	public static int getDown(int u, int i) {
-		return down[dfn[u] + i];
-	}
-
 	public static void prepare() {
 		dfs3();
 		dfs4();
diff --git a/src/class162/Code04_TreeKthAncestor2.java b/src/class162/Code04_TreeKthAncestor2.java
index 2b05963b4..3a80dc215 100644
--- a/src/class162/Code04_TreeKthAncestor2.java
+++ b/src/class162/Code04_TreeKthAncestor2.java
@@ -49,6 +49,22 @@
 //    return x;
 //}
 //
+//void setUp(int u, int i, int v) {
+//    up[dfn[u] + i] = v;
+//}
+//
+//int getUp(int u, int i) {
+//    return up[dfn[u] + i];
+//}
+//
+//void setDown(int u, int i, int v) {
+//    down[dfn[u] + i] = v;
+//}
+//
+//int getDown(int u, int i) {
+//    return down[dfn[u] + i];
+//}
+//
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
 //    to[cntg] = v;
@@ -91,22 +107,6 @@
 //    }
 //}
 //
-//void setUp(int u, int i, int v) {
-//    up[dfn[u] + i] = v;
-//}
-//
-//int getUp(int u, int i) {
-//    return up[dfn[u] + i];
-//}
-//
-//void setDown(int u, int i, int v) {
-//    down[dfn[u] + i] = v;
-//}
-//
-//int getDown(int u, int i) {
-//    return down[dfn[u] + i];
-//}
-//
 //void prepare() {
 //    dfs1(root, 0);
 //    dfs2(root, root);

From 4213172f94781e88fe7c217f07901f0586096933 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Mar 2025 18:18:24 +0800
Subject: [PATCH 0549/1712] modify code

---
 src/class162/Code02_NationalTour1.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/class162/Code02_NationalTour1.java b/src/class162/Code02_NationalTour1.java
index 5c2188ccd..b10f02479 100644
--- a/src/class162/Code02_NationalTour1.java
+++ b/src/class162/Code02_NationalTour1.java
@@ -27,6 +27,10 @@ public class Code02_NationalTour1 {
 
 	public static int MAXN = 200001;
 	public static int n, m;
+
+	// arr[i][0] : 第i条边的其中一点
+	// arr[i][1] : 第i条边的另外一点
+	// arr[i][2] : 第i条边的初始边权
 	public static int[][] arr = new int[MAXN][3];
 
 	// 链式前向星

From 1a9b56774bdafe06879b19a2e9f719a0f460f36d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Mar 2025 21:24:24 +0800
Subject: [PATCH 0550/1712] modify code

---
 src/class162/Code03_UnderMoon1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class162/Code03_UnderMoon1.java b/src/class162/Code03_UnderMoon1.java
index ec7eb363c..9efa4f1db 100644
--- a/src/class162/Code03_UnderMoon1.java
+++ b/src/class162/Code03_UnderMoon1.java
@@ -44,9 +44,9 @@ public class Code03_UnderMoon1 {
 	public static int cntd = 0;
 
 	// 线段树查询区间最大值
-	// 但是需要同时兼顾，区间增加、区间修改，这两种操作
+	// 但是需要同时兼顾，区间增加、区间重置，这两种操作
 	// 那么就牵扯到两种操作相互影响的问题
-	// 因为区间修改明显会取消之前的区间增加
+	// 因为区间重置操作会取消之前的区间增加操作
 	// 讲解110，线段树章节，题目5、题目6，重点讲了这种线段树
 	// 不会的同学可以看看，讲的非常清楚
 	public static int[] max = new int[MAXN << 2];

From 129f3905827d53638d41f433cd54191cacad2cad Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 15:21:05 +0800
Subject: [PATCH 0551/1712] modify code

---
 src/class162/Code06_DominantIndices1.java | 49 ++++++++++++++---------
 src/class162/Code06_DominantIndices2.java | 14 +++----
 src/class162/Code07_HotHotels1.java       |  3 +-
 src/class162/Code07_HotHotels2.java       |  3 +-
 4 files changed, 38 insertions(+), 31 deletions(-)

diff --git a/src/class162/Code06_DominantIndices1.java b/src/class162/Code06_DominantIndices1.java
index f0ce088cf..2f60158f7 100644
--- a/src/class162/Code06_DominantIndices1.java
+++ b/src/class162/Code06_DominantIndices1.java
@@ -39,11 +39,11 @@ public class Code06_DominantIndices1 {
 	public static int[] dp = new int[MAXN];
 	public static int[] ansx = new int[MAXN];
 
-	public static void set(int u, int i, int v) {
+	public static void setdp(int u, int i, int v) {
 		dp[dfn[u] + i] = v;
 	}
 
-	public static int get(int u, int i) {
+	public static int getdp(int u, int i) {
 		return dp[dfn[u] + i];
 	}
 
@@ -75,9 +75,9 @@ public static void dfs1(int u, int fa) {
 	// 递归版，C++可以通过，java会爆栈，迭代版是dfs4方法
 	public static void dfs2(int u, int fa) {
 		dfn[u] = ++cntd;
-		set(u, 0, 1);
+		setdp(u, 0, 1);
+		ansx[u] = 0;
 		if (son[u] == 0) {
-			ansx[u] = 0;
 			return;
 		}
 		dfs2(son[u], u);
@@ -87,19 +87,28 @@ public static void dfs2(int u, int fa) {
 				dfs2(v, u);
 			}
 		}
+		// 注意一定要在合并其他儿子dp信息的过程中，去更新ansx
+		// 千万不要，最后再遍历一遍u的dp信息，然后更新ansx
+		// 因为任何for循环，都不能是长链的规模！
+		// 如果for循环是长链的规模，那么u遍历下去，u的重儿子又遍历下去，长链上每个节点都遍历下去
+		// 时间复杂度必然不再是O(n)，而是O(n^2)，长链剖分的优势就不存在了！
+		// 所以长链信息会被u直接继承，绝对不要有任何与长链的长度等规模的循环出现！
 		ansx[u] = ansx[son[u]] + 1;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa && v != son[u]) {
 				for (int i = 1; i <= len[v]; i++) {
-					set(u, i, get(u, i) + get(v, i - 1));
-					if (get(u, i) > get(u, ansx[u]) || (get(u, i) == get(u, ansx[u]) && i < ansx[u])) {
+					setdp(u, i, getdp(u, i) + getdp(v, i - 1));
+					if (getdp(u, i) > getdp(u, ansx[u]) || (getdp(u, i) == getdp(u, ansx[u]) && i < ansx[u])) {
 						ansx[u] = i;
 					}
 				}
 			}
 		}
-		if (get(u, ansx[u]) == 1) {
+		// 如果u的某个距离，获得的最大节点数为1
+		// 那么u答案就是0距离，因为u到u自己的距离是0，也有1个节点了
+		// 根据题目要求，返回尽量小的距离
+		if (getdp(u, ansx[u]) == 1) {
 			ansx[u] = 0;
 		}
 	}
@@ -123,7 +132,7 @@ public static void pop() {
 		e = ufe[stacksize][2];
 	}
 
-	// 迭代版
+	// dfs1的迭代版
 	public static void dfs3() {
 		stacksize = 0;
 		push(1, 0, -1);
@@ -155,26 +164,26 @@ public static void dfs3() {
 		}
 	}
 
-	// 迭代版
+	// dfs2的迭代版
 	public static void dfs4() {
 		stacksize = 0;
 		push(1, 0, -1);
 		int v;
 		while (stacksize > 0) {
 			pop();
-			if (e == -1) { // e == -1，表示第一次来到当前节点
+			if (e == -1) {
 				dfn[u] = ++cntd;
-				set(u, 0, 1);
+				setdp(u, 0, 1);
+				ansx[u] = 0;
 				if (son[u] == 0) {
-					ansx[u] = 0;
 					continue;
 				}
-				push(u, f, -2); // 设置e = -2，再弹出就表示处理完长儿子了
-				push(son[u], u, -1); // 长儿子的任务进入栈
+				push(u, f, -2);
+				push(son[u], u, -1);
 				continue;
-			} else if (e == -2) { // e == -2，表示长儿子已经处理完，该处理其他儿子了
+			} else if (e == -2) {
 				e = head[u];
-			} else { // 每个儿子都处理
+			} else {
 				e = next[e];
 			}
 			if (e != 0) {
@@ -183,20 +192,20 @@ public static void dfs4() {
 				if (v != f && v != son[u]) {
 					push(v, u, -1);
 				}
-			} else { // 更新dp、计算答案
+			} else {
 				ansx[u] = ansx[son[u]] + 1;
 				for (int e = head[u]; e > 0; e = next[e]) {
 					v = to[e];
 					if (v != f && v != son[u]) {
 						for (int i = 1; i <= len[v]; i++) {
-							set(u, i, get(u, i) + get(v, i - 1));
-							if (get(u, i) > get(u, ansx[u]) || (get(u, i) == get(u, ansx[u]) && i < ansx[u])) {
+							setdp(u, i, getdp(u, i) + getdp(v, i - 1));
+							if (getdp(u, i) > getdp(u, ansx[u]) || (getdp(u, i) == getdp(u, ansx[u]) && i < ansx[u])) {
 								ansx[u] = i;
 							}
 						}
 					}
 				}
-				if (get(u, ansx[u]) == 1) {
+				if (getdp(u, ansx[u]) == 1) {
 					ansx[u] = 0;
 				}
 			}
diff --git a/src/class162/Code06_DominantIndices2.java b/src/class162/Code06_DominantIndices2.java
index 51fd963d7..7be2a808f 100644
--- a/src/class162/Code06_DominantIndices2.java
+++ b/src/class162/Code06_DominantIndices2.java
@@ -32,11 +32,11 @@
 //int dp[MAXN];
 //int ansx[MAXN];
 //
-//void setVal(int u, int i, int v) {
+//void setdp(int u, int i, int v) {
 //    dp[dfn[u] + i] = v;
 //}
 //
-//int getVal(int u, int i) {
+//int getdp(int u, int i) {
 //    return dp[dfn[u] + i];
 //}
 //
@@ -66,9 +66,9 @@
 //
 //void dfs2(int u, int fa) {
 //    dfn[u] = ++cntd;
-//    setVal(u, 0, 1);
+//    setdp(u, 0, 1);
+//    ansx[u] = 0;
 //    if (son[u] == 0) {
-//        ansx[u] = 0;
 //        return;
 //    }
 //    dfs2(son[u], u);
@@ -83,14 +83,14 @@
 //        v = to[e];
 //        if (v != fa && v != son[u]) {
 //            for (int i = 1; i <= len[v]; i++) {
-//                setVal(u, i, getVal(u, i) + getVal(v, i - 1));
-//                if (getVal(u, i) > getVal(u, ansx[u]) || (getVal(u, i) == getVal(u, ansx[u]) && i < ansx[u])) {
+//                setdp(u, i, getdp(u, i) + getdp(v, i - 1));
+//                if (getdp(u, i) > getdp(u, ansx[u]) || (getdp(u, i) == getdp(u, ansx[u]) && i < ansx[u])) {
 //                    ansx[u] = i;
 //                }
 //            }
 //        }
 //    }
-//    if (getVal(u, ansx[u]) == 1) {
+//    if (getdp(u, ansx[u]) == 1) {
 //        ansx[u] = 0;
 //    }
 //}
diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 78014f690..2d39e0889 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -98,8 +98,8 @@ public static void dfs2(int u, int t) {
 
 	// 递归版，居然不改迭代版也能通过，那就不改了
 	public static void dfs3(int u) {
+		setf(u, 0, 1);
 		if (son[u] == 0) {
-			setf(u, 0, 1);
 			return;
 		}
 		dfs3(son[u]);
@@ -110,7 +110,6 @@ public static void dfs3(int u) {
 			}
 		}
 		ans += getg(u, 0);
-		setf(u, 0, getf(u, 0) + 1);
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u] && v != fa[u]) {
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 0e2e26a35..672e45b40 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -91,8 +91,8 @@
 //}
 //
 //void dfs3(int u) {
+//    setf(u, 0, 1);
 //    if (son[u] == 0) {
-//        setf(u, 0, 1);
 //        return;
 //    }
 //    dfs3(son[u]);
@@ -103,7 +103,6 @@
 //        }
 //    }
 //    ans += getg(u, 0);
-//    setf(u, 0, getf(u, 0) + 1);
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u] && v != fa[u]) {

From 4344e232ffcae1805d49ed9959d37cc7aff3207b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 16:05:16 +0800
Subject: [PATCH 0552/1712] modify code

---
 src/class162/Code06_DominantIndices1.java | 2 +-
 src/class162/Code06_DominantIndices2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class162/Code06_DominantIndices1.java b/src/class162/Code06_DominantIndices1.java
index 2f60158f7..0e267e420 100644
--- a/src/class162/Code06_DominantIndices1.java
+++ b/src/class162/Code06_DominantIndices1.java
@@ -1,6 +1,6 @@
 package class162;
 
-// 哪个距离的点最多，java版
+// 长链剖分优化动态规划模版题，java版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
 // 规定任何点到自己的距离为0
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数
diff --git a/src/class162/Code06_DominantIndices2.java b/src/class162/Code06_DominantIndices2.java
index 7be2a808f..efeada7b3 100644
--- a/src/class162/Code06_DominantIndices2.java
+++ b/src/class162/Code06_DominantIndices2.java
@@ -1,6 +1,6 @@
 package class162;
 
-// 哪个距离的点最多，C++版
+// 长链剖分优化动态规划模版题，C++版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树，规定1号节点是头
 // 规定任何点到自己的距离为0
 // 定义d(u, x)，以u为头的子树中，到u的距离为x的节点数

From 799ead275bed35c39598eb5ac0bf0474bc8a400e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 17:20:13 +0800
Subject: [PATCH 0553/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 2d39e0889..9a7bfd139 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -21,21 +21,24 @@ public class Code07_HotHotels1 {
 	public static int MAXN = 100001;
 	public static int n;
 
+	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
+	// 长链剖分
 	public static int[] fa = new int[MAXN];
 	public static int[] son = new int[MAXN];
 	public static int[] len = new int[MAXN];
 	public static int cntd = 0;
 
-	public static int[] fid = new int[MAXN];
-	public static int[] gid = new int[MAXN];
-	public static long[] f = new long[MAXN];
-	public static long[] g = new long[MAXN << 1];
-	public static long ans = 0;
+	// 动态规划
+	public static int[] fid = new int[MAXN]; // 每个点在动态规划表f中的开始位置，就是dfn序
+	public static int[] gid = new int[MAXN]; // 每个点在动态规划表g中的开始位置，独特的设计
+	public static long[] f = new long[MAXN]; // 动态规划表f
+	public static long[] g = new long[MAXN << 1]; // 动态规划表g
+	public static long ans = 0; // 答案
 
 	public static void setf(int u, int i, long v) {
 		f[fid[u] + i] = v;
@@ -80,6 +83,7 @@ public static void dfs1(int u, int f) {
 	}
 
 	// 递归版，居然不改迭代版也能通过，那就不改了
+	// 给每个节点分配fid和gid
 	public static void dfs2(int u, int t) {
 		fid[u] = cntd++;
 		if (son[u] == 0) {
@@ -97,6 +101,7 @@ public static void dfs2(int u, int t) {
 	}
 
 	// 递归版，居然不改迭代版也能通过，那就不改了
+	// 计算每个节点的f信息和g信息，同时统计答案
 	public static void dfs3(int u) {
 		setf(u, 0, 1);
 		if (son[u] == 0) {

From 978ce3b08959eb126398e213d95c89d720595286 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 17:31:28 +0800
Subject: [PATCH 0554/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 6 +++---
 src/class162/Code07_HotHotels2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 9a7bfd139..da4e29295 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -84,13 +84,13 @@ public static void dfs1(int u, int f) {
 
 	// 递归版，居然不改迭代版也能通过，那就不改了
 	// 给每个节点分配fid和gid
-	public static void dfs2(int u, int t) {
+	public static void dfs2(int u, int top) {
 		fid[u] = cntd++;
 		if (son[u] == 0) {
-			gid[u] = fid[t] * 2;
+			gid[u] = fid[top] * 2;
 			return;
 		}
-		dfs2(son[u], t);
+		dfs2(son[u], top);
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u] && v != fa[u]) {
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 672e45b40..026691fb7 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -74,13 +74,13 @@
 //    len[u] = len[son[u]] + 1;
 //}
 //
-//void dfs2(int u, int t) {
+//void dfs2(int u, int top) {
 //    fid[u] = cntd++;
 //    if (son[u] == 0) {
-//        gid[u] = fid[t] * 2;
+//        gid[u] = fid[top] * 2;
 //        return;
 //    }
-//    dfs2(son[u], t);
+//    dfs2(son[u], top);
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u] && v != fa[u]) {

From e09b4261f9b1629b88caec1ff4dc561193106b1c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 17:32:37 +0800
Subject: [PATCH 0555/1712] modify code

---
 src/class162/Code06_DominantIndices1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class162/Code06_DominantIndices1.java b/src/class162/Code06_DominantIndices1.java
index 0e267e420..5089f8b34 100644
--- a/src/class162/Code06_DominantIndices1.java
+++ b/src/class162/Code06_DominantIndices1.java
@@ -37,6 +37,8 @@ public class Code06_DominantIndices1 {
 
 	// 动态规划
 	public static int[] dp = new int[MAXN];
+
+	// 答案数组
 	public static int[] ansx = new int[MAXN];
 
 	public static void setdp(int u, int i, int v) {

From f61cf14d973c0d3ce48dd5a88bc55c7ea09f74a6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 19:41:05 +0800
Subject: [PATCH 0556/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 19 ++++++++++++-------
 src/class162/Code07_HotHotels2.java | 16 ++++++++--------
 2 files changed, 20 insertions(+), 15 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index da4e29295..7fcfb7257 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -114,17 +114,19 @@ public static void dfs3(int u) {
 				dfs3(v);
 			}
 		}
-		ans += getg(u, 0);
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u] && v != fa[u]) {
+				// u为头的子树中，选择三个点，u一定不参与
+				// 情况1 : u遍历过的所有子树中选一个点，当前子树中选两个点
+				// 情况2 : u遍历过的所有子树中选两个点，当前子树中选一个点
 				for (int i = 0; i <= len[v]; i++) {
-					if (i > 0) {
-						ans += getg(u, i) * getf(v, i - 1);
-					}
-					if (i + 1 < len[v]) {
+					if (i > 0 && i + 1 < len[v]) {
 						ans += getf(u, i) * getg(v, i + 1);
 					}
+					if (i < len[u] && i - 1 >= 0) {
+						ans += getg(u, i) * getf(v, i - 1);
+					}
 				}
 				for (int i = 0; i <= len[v]; i++) {
 					if (i > 0) {
@@ -132,15 +134,18 @@ public static void dfs3(int u) {
 					}
 				}
 				for (int i = 0; i <= len[v]; i++) {
-					if (i > 0) {
+					if (i - 1 >= 0) {
 						setf(u, i, getf(u, i) + getf(v, i - 1));
 					}
-					if (i < len[v]) {
+					if (i + 1 < len[v]) {
 						setg(u, i, getg(u, i) + getg(v, i + 1));
 					}
 				}
 			}
 		}
+		// u为头的子树中，选择三个点，u一定要参与
+		// 情况3 : u为头的子树中，最上方的点选u
+		ans += getg(u, 0);
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 026691fb7..51dd6ec32 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -102,17 +102,16 @@
 //            dfs3(v);
 //        }
 //    }
-//    ans += getg(u, 0);
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u] && v != fa[u]) {
-//            for (int i = 0; i <= len[v]; i++) {
-//                if (i > 0) {
-//                    ans += getg(u, i) * getf(v, i - 1);
-//                }
-//                if (i + 1 < len[v]) {
+//            for (int i = 1; i <= len[v]; i++) {
+//                if (i > 0 && i + 1 < len[v]) {
 //                    ans += getf(u, i) * getg(v, i + 1);
 //                }
+//                if (i < len[u] && i - 1 >= 0) {
+//                    ans += getg(u, i) * getf(v, i - 1);
+//                }
 //            }
 //            for (int i = 0; i <= len[v]; i++) {
 //                if (i > 0) {
@@ -120,15 +119,16 @@
 //                }
 //            }
 //            for (int i = 0; i <= len[v]; i++) {
-//                if (i > 0) {
+//                if (i - 1 >= 0) {
 //                    setf(u, i, getf(u, i) + getf(v, i - 1));
 //                }
-//                if (i < len[v]) {
+//                if (i + 1 < len[v]) {
 //                    setg(u, i, getg(u, i) + getg(v, i + 1));
 //                }
 //            }
 //        }
 //    }
+//    ans += getg(u, 0);
 //}
 //
 //int main() {

From 516797fa5b697c4cb49a49f2e2ef4a98253b47f6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 19:45:13 +0800
Subject: [PATCH 0557/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 4 ++--
 src/class162/Code07_HotHotels2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 7fcfb7257..4153ba39d 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -129,7 +129,7 @@ public static void dfs3(int u) {
 					}
 				}
 				for (int i = 0; i <= len[v]; i++) {
-					if (i > 0) {
+					if (i - 1 >= 0) {
 						setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
 					}
 				}
@@ -144,7 +144,7 @@ public static void dfs3(int u) {
 			}
 		}
 		// u为头的子树中，选择三个点，u一定要参与
-		// 情况3 : u为头的子树中，最上方的点选u
+		// 情况3 : u为头的子树中，最上方的点选u，下方再选两个点
 		ans += getg(u, 0);
 	}
 
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 51dd6ec32..abb9f82bf 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -114,7 +114,7 @@
 //                }
 //            }
 //            for (int i = 0; i <= len[v]; i++) {
-//                if (i > 0) {
+//                if (i - 1 >= 0) {
 //                    setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
 //                }
 //            }

From ea6a374dda8c5d9f0c6e2f3f1cda9bfe41e2ea97 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 20:48:32 +0800
Subject: [PATCH 0558/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 6 +++---
 src/class162/Code07_HotHotels2.java | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 4153ba39d..40f4ac0a2 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -132,14 +132,14 @@ public static void dfs3(int u) {
 					if (i - 1 >= 0) {
 						setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
 					}
+					if (i + 1 < len[v]) {
+						setg(u, i, getg(u, i) + getg(v, i + 1));
+					}
 				}
 				for (int i = 0; i <= len[v]; i++) {
 					if (i - 1 >= 0) {
 						setf(u, i, getf(u, i) + getf(v, i - 1));
 					}
-					if (i + 1 < len[v]) {
-						setg(u, i, getg(u, i) + getg(v, i + 1));
-					}
 				}
 			}
 		}
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index abb9f82bf..4b8ecf195 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -105,7 +105,7 @@
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u] && v != fa[u]) {
-//            for (int i = 1; i <= len[v]; i++) {
+//            for (int i = 0; i <= len[v]; i++) {
 //                if (i > 0 && i + 1 < len[v]) {
 //                    ans += getf(u, i) * getg(v, i + 1);
 //                }
@@ -117,14 +117,14 @@
 //                if (i - 1 >= 0) {
 //                    setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
 //                }
+//                if (i + 1 < len[v]) {
+//                    setg(u, i, getg(u, i) + getg(v, i + 1));
+//                }
 //            }
 //            for (int i = 0; i <= len[v]; i++) {
 //                if (i - 1 >= 0) {
 //                    setf(u, i, getf(u, i) + getf(v, i - 1));
 //                }
-//                if (i + 1 < len[v]) {
-//                    setg(u, i, getg(u, i) + getg(v, i + 1));
-//                }
 //            }
 //        }
 //    }

From 2ebf41f855038bbfc403db49192b89b42bca728b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Mar 2025 20:51:03 +0800
Subject: [PATCH 0559/1712] modify code

---
 src/class162/Code07_HotHotels1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 40f4ac0a2..8e18c06a6 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -35,7 +35,7 @@ public class Code07_HotHotels1 {
 
 	// 动态规划
 	public static int[] fid = new int[MAXN]; // 每个点在动态规划表f中的开始位置，就是dfn序
-	public static int[] gid = new int[MAXN]; // 每个点在动态规划表g中的开始位置，独特的设计
+	public static int[] gid = new int[MAXN]; // 每个点在动态规划表g中的开始位置，课上讲的设计
 	public static long[] f = new long[MAXN]; // 动态规划表f
 	public static long[] g = new long[MAXN << 1]; // 动态规划表g
 	public static long ans = 0; // 答案

From 9f07a67db1a251a1fcedbb03be5d0189842be76f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Mar 2025 01:12:39 +0800
Subject: [PATCH 0560/1712] modify code

---
 ...345\211\226\345\210\206-\344\270\213.pptx" | Bin 0 -> 56310 bytes
 src/class162/Code07_HotHotels1.java           |  25 +++++++++---------
 src/class162/Code07_HotHotels2.java           |  12 ++++-----
 3 files changed, 18 insertions(+), 19 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243162\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\351\223\276\345\211\226\345\210\206-\344\270\213.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243162\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\351\223\276\345\211\226\345\210\206-\344\270\213.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243162\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\351\223\276\345\211\226\345\210\206-\344\270\213.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..56b4990bd57ae8a80966a61660d0abe1043f8934
GIT binary patch
literal 56310
zcmdqJWmKJ8vZ#%_2X}XZ!@}JqxNC5C*8stFVL^ktySuvwcXtgAAHBQJxV`&3`}Doz
z{A<Qw&3DfAtBSXtl39g<3^)Wj2nYxah$F16Rz;vC=kmu+5DWwa9t0gk-_gX{iShH_
zK0!fHKEC+#PdRYZ5}X-9?EVoh*GD`aT^jbvSQ&095$Nk*&5n$_BCIC!bkF{61}O-|
zJh`QXJN<h@t1@pYGLU7@*l@nifcg=?fK9`lkC%bS;1@#!qqDOXok@Dr56}4U?}~|>
zq5U!Fx)v<TC29OJ&RP;Uu^E0&;9D&=7mB{DS!vAU{2H-78sE6QSze=};^rU=k$f<<
zYUZq_!=%6S;7BqAo&L1anTRR?f-=IF+hL9P2zYpoz40l{$mlsMNq_5cp&0ZYKRg$R
z+K(c_F%`q4W#?_|{BHjnW^Ef@;ZJITAX&g@`4Als6a)nILoLR3MhcF0_D+mOc8(^W
z-EFM@JLT9!%UJ~pqKIC+!KJh|*b+l%-X$qxf=L-vimXf<W*`^v;Q0Ac*8Gr(7HjvM
z^H@FA@>Mq8(XCu=QKaCyjdyUW<X`_;O2v-Uk0TPoKVx<KEeCs><pSRg+p|722+7}p
zq_lY=XmqbIMolK#Avo)*z$`#{mN$T6Ivx|TvxgR6+(lj9ow`?D$E`a^kWSOFXKI1r
zrCNCUx-+nyYba`5C_mx&w#w;I5&qZc=!$O#OSBjdIi$!H_@9Npk4|8W{1E=v$1lo1
z3vXy||5vhSOpL?zFrh$fdi^BbT`%xNp?PgapCl}~2U;)tFCh+V9k1Y_dV|FDG7-%p
zwfco3esv7W;8m$d_fL)N&5v(9Qp(($!a8GD@*hG14uQ*N=%k3`s?5+maH%#AtZIb&
z?&I&|3~3b_lE2>imqokyC{?j$fhq?RQFnf=z3MC?d3{VipQSVYa@UXdXK5BXT7^Zy
zK|lrwKt5za2eG$zX0&%SaWb)WHgvYIv;8ZH&Qff?tT3SrZd@pfdhiHk5@}77E(ZVT
zQxIE%w%08jw@)8(#lAdpa|KdT6je!`(3L8A{eC}pbbF+*nXA1i4A6=RifA)tUEy)D
ziD1&HaB4_d61b?8S9<n-J1R?6ONZ$p2X2}Rp?p$it8G+LQyxThmw_Xf9}Q=kssUn2
z_5khD*(EwjG=&H@T#O0@xoTJ3-{KxvMjd54lA1nmUdo}#7gdN@-$*+zmBbk1xn8MB
z^>-#gY&XaRwAm*V3^6l`r3@?UVA=%Ra>RB!rLpWYSqS|Sh>Z>M)8Bx3v>Y7y#kz9e
zLoOQ#khO{UGLJ+ZcQ!Ve-q@o_69%aJMJ2UNZuebq+o!ddA{<&QkJeXT9_red9$EWx
zwVEI2cwI7PE&Dvi#jXh2XpQK2O9MIBlWn0ln=t0iyok!k2f)X8Ho0X#H;M%>@XZN3
zFZ)Dz@Byb{p7`o(y`$?v?Onty^;)xB8`G*sxm2(v?Zt4s&WM@xzM1411Li6%N@vOv
z3dBGLhhqa&TYcCe)H%{zL)Rl=c@m?p9<`p*88A^+&zw_bbf#erW5jlm!p~pH#wubF
zN<n`P;UwXBD1m{l3_)=VGHHP<Kqd2}VUPQnFq!<sJKx-!r;+cDG#>gz%SF{M`{ixe
z;&g9xqAh^KHDU#bY9n12P`g#P(-P=V?mSCJ4l|B34IjCQ*+&c^UdXv=KVG=|2(GxS
zq+JCLeyhaZ(E{&L6wyZQ#~vrUW@G*)T=A?~?53u-m*84EZIi^NUn<wWnTByY&%uYk
zn~68f5@7O6p}fImRQ{K)+2;gU3C}#eJ7&?UT@gw2YN1%)NVH!HECqeY?~D}FoOe%n
z(!_<_7D?U}o3;Vj+mnzy*)t2cLX{8!xS$d0V3<+FnGxR{<qpZ>xWpG2io^JFYD}v8
zX9OZmuqisM7TK%`qvSfxSOH_E_pcUz+lGv1nX&SYnLf|XbXjcjVx}7+o82O%7ym4P
zk_SJy+KluB?DX0{`Ih_~MofpAAnV4tx2L@5N(uVrLC9iHh&quM!petGNIJ`lf&++w
zF<b8C@_?QINRNTXeY**@muE|#(0*S6JiiZ22)u&+*%Hf7k(QJ`fJzDn0z&i;OZ>aP
z`B!`VOaIfpux8myj1GPI%rAE7%T8po98GD$1l5imS?&drobFvE8n|rh^Q_6itvr&A
zwVm&G_pk%A?Rm52)(x6x2{|drhA0KnhGH^$64`c<d7fk(|7D?airFTqsDMDl;J1BZ
zocPIBrjjb#6e~LhxIL>f>=LU@a7_U?9ls_b8&YqAbSu=b1bd)O3TiV08QN(y_^Oh&
zimG;3F7<Cdd!IcRZb=13r60Wk1o7;Lk?Fa`#o~u9qNivM=36IV4$(}a+h~fRZ)|r}
zzoKH3jMI(MQ)Hq|i3r+`jG&YH;h2Y3DMVdtU?*iQV&75d@XJG))Q;-}Oc^yYxDfqB
z=Bn&1HiZLQtfMfZ)w0U+Z}3{1N;}cT%6Lh>BA|ZHM29U2<)tw#BK@8BBR9M+o>UBj
z^-DNp$qz3jdPT8gscK;ic>Nf)P?om#jDx}W=nl`vUFbjmiKI2UvPVC#-}(=~_g}F5
z!}<LcDKp~aB0kt3eDM|zY?Y&}k+e7w<Mmp61tlq<oEi>FdAPc9Q-B|BfnGBD(S|(P
zHfv+Yq>A+gpZTt&II6_k(LM5LuC#LU)iJlBH)qs_a*`iIdw1s>Z5V~EO{FkR^L(oA
zr9tz+Y5bTtd6ihE^Nd7|dUto8`hd526?3s!=KAmsK>Wb%aDo^N8RqfGwui(t)8dg}
zd6Mr<Dd3%Um}v}UrA(g*g@9y7!!qQOd~6LSn;AJusAb<@{m5N7Au)1Bq|lGZK*RfA
z9AV#+BVzA|HZuQ78?F{6ZvV43rn_x>m=K^gdA=y_$<OA%%3*x(rJTTTfDR3iA)R+H
zh923O#5=R#$s!;-c)uN8CpZVFaT<grc+M_F6%%`K4>})>9}GIYS|UBqe|BqxnGK_R
z&CGLZht1!e(7FPhl9Iy#PC$Ki7W?U4ZRQ%!0$7%twPtAfF_wN{cFl$`-OKYxCrpbR
zWaunbDjlkc$smwx0;RZ5^{P(sVn;y`4C!z-$_SNfhK4JB25V-x6a{C)`YTp&7H^A_
z-V@g7zLfFL@5I7g`Oe>BA>fA=F#ln;Ms_wf9}ZN=#o64>(djQ=j48Rl1qG0sK3^1T
z8ZE>`!^>f|NAd}Y^DI6c8u!S)aCHcsNn`czUAhy+ES(cF?Q@EpPI2bYO2^?<Ry+Bc
z_w9M>Soc+oH)JnVb&5wgZ~rKaKG0(C8Njxr(bNVHhesGFERz7kn3W1Vm0XL5%+*QS
z(+Y6Z^L}D0jPbds<I3s?xVnmp#Zi^@T59Qv$J{snhCsDH|HcmcmXRRLLsFvU!@S8x
zVnhTVb%|QAL7q*!!D^hw_b=c&O(G<Pg9ZWVkOKiB`G*FatSyX9<P4phO&pyV|7pYg
zSIRg`U$I>Qpa^a}V+817RfvYQEEXvPj#?OE^%Tqm{F5xSVO%uBT{AEtpBSF2h!z-^
zNGO&aofNm(F&9%ksw8@G^d@7`dw2Us<p#>w_f)lZMez9CY$Eohm}PGIr`~ofS0m1n
z%_j8{0>j7G<D?aAze(sJ4o&I7DI(z)N++?A&EMqYapjG}XQG0}cyEmX9uc@q#;$ZY
zomqhUt~--NJNjb>7Q*@%!?d~0MXXy1sG#-bNfw$%t0RNEYK~e$93#&av?d{HuxQEL
zp8_t+t!vn}#8k)nZ}Nsx@trpWk%r1k9iZ0IWfx_AzhK=RNcjE^Kqv{wuXPyt;kg-c
z1i7=2T9wVGCeYyYyJv~jsjfEnreuUpzBu9f&Pq>SIt320L*H*#jXSWru{_<_*?e?W
zMc8P6PF~vH*HPa*4uQidbJ))OXFblc;7rtub6&J<P~zN(aiLri(Rr0zQs;)@*&$fE
zT6T@9%bqRg;OuycV4=bZEk>lRHsv@&H5VgC&Dsjo$c3XtSQ^?(&~;T(UW<lm&Jh1K
zDV><ng*kMguBVHeI`JeTc%v=3V{S*neM`T{D@?QPtX_~0(f2pK(&4P#M0dG}F<{Ts
zJ{xMoT>PC0g{86$={$WS|0s}bNR{8LI8rwWY<DqHK<+oa9W7Y%A#J%kcU`9*L>y;$
zfG;CHWKl>Q-n}^4uakD%nANz5K`bBdH^l1+kjHK_`4Kex4luvNd1kT*T!p%*3JD2u
zabSB2cs4ixF`NkKleX&8^qL;huK$FsF<rqWBH7sb{`?fus)lR1xxnS`-nu*DcBjz$
zX=(Hu6^$EGtoR@%+7S7>wEk<U6z`l`Rnob#;?|naDlWbhl-t3I>_hoa3ezG`w3_Ml
zKN2!sBHZ~xOQc$8qQzf)r+g4wZmT{YrLvre$oqM}KT9=@F0aI9vv6_TE%rKWZif`b
zv=ckWnH9ay7yqol&h0^)O5j=C@X)dz$31W0;_d17DhYg7fnMFatb6ExhM#{{<;Z`L
z%7*u1y{sue9-Vq~5(6-8h}O7C&b7eYKi_@b11IotUyRTe2+}}0F1jPbZ#nnFszY{Q
z%ylq75JM{c4a#f~$E%51#h6i|rIL>j>_B_ot21mBybCgZ_!2HlHT5nO*<L`9^#Wnx
zs1l1*^X%qm+gf~<kv>s$9@x^QWvgn;xVmp$F!Y2Qf_3nK-+3&CMb`PtjrqJ^(S1F_
z=$*G~2N0Q~zH!PR=C6;0&vox~dipzV!nQV*=`A{8!TDP-$0w%yFht2(tJnhgFUP#a
zH+e|pK=LXVs0i^X+%HxQ932Y}T7mUYR&rVF-xh+jKJ{=9%)H=I8a$fx)(x!B!7<FE
zLV`L=*@h>&^C;JzWEQN;k>YPHA~Qok5lJHY@!Z&YTr5G^jxJnOi7{xe8lKc!2O?>A
zn&7!EZYSBy8RFGh?;x#InXFt?MQJq*oiRnP3>5V?@i`V59rpa5%8ssvUoi^dhGMiv
zCOpP&uj2Ehwx+yUse_ZhrcFGl@g?#-t;nV4SJuNU_Dq~-%u!Pnj>E|i5*=T_qL-^^
zjEGq*;wn_CS?yd;g=g(yoNvX0`I!*A&r}UVf!5&P4qmIxS`hNOc)zCrS75#S?BkpA
z^Tz5?qY|a+zKCjX*NF5OmUUel*A?o(xk65CeyrS6%cd}Te;c%w(xoK;_Q`T*?s|7r
z4Zj!3;`x$r0iObnr98Rm>{LKCt(&HpT9&iUw{VR?xmZciL8LW=lm;$SPdSBGQK`LX
z(2}U#vJFXFV#t8vd%;9W%zU2!6>P%2cGCS1^97G<WiX2IG><!FVWoN4dAS8?50RzR
za5j<!ua+D+xpS@FghReDgy7dEt1jkEfVLK{{Yyyq5m_W604f~{-wzte7aM<9f|_j?
z+Y#6CGCDmgFnuw?NF<u1kc4V6?i0Uk^g(~N)e!S8+inn#V-Aud>1i5b4T(hjr?a6j
zB1(y`My^A__;T`XWQ7|-^4OxLA=X3FySJnJjWTE8-Ab<`yP31yQ)hJkw%PNuG!mkv
z@9uT>n}jhHHjuFgtxqF^U&?gpVH?pNu$Kio-c2@QGM=eV&rOg9sT=}AdFSpCG@#0i
zelpqWpCSJ3DN|5dv<h_8-{llsdLt2$-2kU5+S|9;=b80yPabVy?My6bZr}^kUj!WR
zznk9Jc5y##nfvcdS+65%3<7v;GLn)4h3RPoc1=x4n|z)*o|L6T&foXg-t@PFxb1=J
zW=ELR)k2+z?b3ncQbtaP<$qr<Go*XRrJS5DqyDk_{A0EG$Ey2}Rql_qmJi;V=$-4V
zv)NVaJ@o8!N#M`ng^gE82KGm2LHUst(EoSN_3tUdzq;7JOcDAQCanUQ(7Ud@-r<IQ
z!X_IQqAeMX6c#O<{RF2DkPE`dk2Kz&A>nd`Jx-b2vATco3Q%<tMsLji@Xo#oWX}gl
z35SrgN$Ymbe*kpyV{B`bBV7QFQ5qk7fB2wHV(W+V2R&-i=-&e@7|$Xp`7O%RoI@Kc
zlxr&lTtaANW_6mMadNcAWaZ^(R*OO7(koftOd4!fvInrV^(oo5y6IFx&6ttqDtZ;*
zXzb`3>4pGbiUuQ31#o=valL2Ny<p+T)}Fq8qS1C5VUcdwN+_pUN>XmfHs&g{mKk<U
zuSo}Dq}LEotT>IpNkh?4*?gJtztc_wa;zi8l7K9rfuw*L*nq||gDl{Jq<|ZofxbWq
zG5Fq>%p?C<>q-R$Wn@qwAR=o2rz+xXZenA?_{Zm8M=?5oL@_=W>M)+VbuB!u3Wbts
z*t*1LxKfxtI#XyS#o5#hQU|~9D2lzv2W?ZGwNC;5y`v;%0ABoXk#4(<HPgPPfyhFx
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
LmnYNn``iBlC>OWD

literal 0
HcmV?d00001

diff --git a/src/class162/Code07_HotHotels1.java b/src/class162/Code07_HotHotels1.java
index 8e18c06a6..d77624207 100644
--- a/src/class162/Code07_HotHotels1.java
+++ b/src/class162/Code07_HotHotels1.java
@@ -36,8 +36,8 @@ public class Code07_HotHotels1 {
 	// 动态规划
 	public static int[] fid = new int[MAXN]; // 每个点在动态规划表f中的开始位置，就是dfn序
 	public static int[] gid = new int[MAXN]; // 每个点在动态规划表g中的开始位置，课上讲的设计
-	public static long[] f = new long[MAXN]; // 动态规划表f
-	public static long[] g = new long[MAXN << 1]; // 动态规划表g
+	public static long[] f = new long[MAXN]; // 动态规划表f，f[父][i]依赖f[子][i-1]
+	public static long[] g = new long[MAXN << 1]; // 动态规划表g，g[父][i]依赖g[子][i+1]
 	public static long ans = 0; // 答案
 
 	public static void setf(int u, int i, long v) {
@@ -117,24 +117,24 @@ public static void dfs3(int u) {
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u] && v != fa[u]) {
-				// u为头的子树中，选择三个点，u一定不参与
-				// 情况1 : u遍历过的所有子树中选一个点，当前子树中选两个点
-				// 情况2 : u遍历过的所有子树中选两个点，当前子树中选一个点
+				// 情况2，u树上，选择三个点，u没被选中，但跨u选点
 				for (int i = 0; i <= len[v]; i++) {
-					if (i > 0 && i + 1 < len[v]) {
-						ans += getf(u, i) * getg(v, i + 1);
-					}
+					// 情况2的分支一，之前遍历的子树里选两个点，当前子树里选一个点
 					if (i < len[u] && i - 1 >= 0) {
 						ans += getg(u, i) * getf(v, i - 1);
 					}
+					// 情况2的分支二，之前遍历的子树里选一个点，当前子树里选两个点
+					if (i > 0 && i + 1 < len[v]) {
+						ans += getf(u, i) * getg(v, i + 1);
+					}
 				}
 				for (int i = 0; i <= len[v]; i++) {
-					if (i - 1 >= 0) {
-						setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
-					}
 					if (i + 1 < len[v]) {
 						setg(u, i, getg(u, i) + getg(v, i + 1));
 					}
+					if (i - 1 >= 0) {
+						setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+					}
 				}
 				for (int i = 0; i <= len[v]; i++) {
 					if (i - 1 >= 0) {
@@ -143,8 +143,7 @@ public static void dfs3(int u) {
 				}
 			}
 		}
-		// u为头的子树中，选择三个点，u一定要参与
-		// 情况3 : u为头的子树中，最上方的点选u，下方再选两个点
+		// 情况1，u树上，选择三个点，u被选中
 		ans += getg(u, 0);
 	}
 
diff --git a/src/class162/Code07_HotHotels2.java b/src/class162/Code07_HotHotels2.java
index 4b8ecf195..0696dc6c2 100644
--- a/src/class162/Code07_HotHotels2.java
+++ b/src/class162/Code07_HotHotels2.java
@@ -106,20 +106,20 @@
 //        v = to[e];
 //        if (v != son[u] && v != fa[u]) {
 //            for (int i = 0; i <= len[v]; i++) {
-//                if (i > 0 && i + 1 < len[v]) {
-//                    ans += getf(u, i) * getg(v, i + 1);
-//                }
 //                if (i < len[u] && i - 1 >= 0) {
 //                    ans += getg(u, i) * getf(v, i - 1);
 //                }
+//                if (i > 0 && i + 1 < len[v]) {
+//                    ans += getf(u, i) * getg(v, i + 1);
+//                }
 //            }
 //            for (int i = 0; i <= len[v]; i++) {
-//                if (i - 1 >= 0) {
-//                    setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
-//                }
 //                if (i + 1 < len[v]) {
 //                    setg(u, i, getg(u, i) + getg(v, i + 1));
 //                }
+//                if (i - 1 >= 0) {
+//                    setg(u, i, getg(u, i) + getf(u, i) * getf(v, i - 1));
+//                }
 //            }
 //            for (int i = 0; i <= len[v]; i++) {
 //                if (i - 1 >= 0) {

From 069c70e2fafd927cc57be8fd8e1a8c28954912f9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Mar 2025 16:09:15 +0800
Subject: [PATCH 0561/1712] modify code

---
 src/class097/Code02_LargeNumberIsPrime4.java | 105 +++++++++++++++++++
 1 file changed, 105 insertions(+)
 create mode 100644 src/class097/Code02_LargeNumberIsPrime4.java

diff --git a/src/class097/Code02_LargeNumberIsPrime4.java b/src/class097/Code02_LargeNumberIsPrime4.java
new file mode 100644
index 000000000..363c2016f
--- /dev/null
+++ b/src/class097/Code02_LargeNumberIsPrime4.java
@@ -0,0 +1,105 @@
+package class097;
+
+// Miller-Rabin测试，java版，不用BigInteger也能通过的实现
+// 这个文件课上没有讲，课上讲的是，java中的long是64位
+// 所以 long * long 需要128位才能不溢出，于是直接用BigInteger了
+// 但是
+// 如果a和b都是long类型，其实 a * b的过程，用位运算去实现，中间结果都 % mod 即可
+// 这样就不需要使用BigInteger了
+// 讲解033，位运算实现乘法，增加 每一步 % mod 的逻辑即可
+// 重点看一下本文件，代码中有注释的部分，就是位运算实现乘法的改写
+// C++的同学也可以用本文件的方式来实现，也不需要定义128位的long类型了
+// 测试链接 : https://www.luogu.com.cn/problem/U148828
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code02_LargeNumberIsPrime4 {
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		int t = Integer.valueOf(br.readLine());
+		for (int i = 0; i < t; i++) {
+			long n = Long.valueOf(br.readLine());
+			out.println(millerRabin(n) ? "Yes" : "No");
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+	public static long[] p = { 2, 3, 5, 7, 11, 13, 17, 19, 23, 29, 31, 37 };
+
+	public static boolean millerRabin(long n) {
+		if (n <= 2) {
+			return n == 2;
+		}
+		if ((n & 1) == 0) {
+			return false;
+		}
+		for (int i = 0; i < p.length && p[i] < n; i++) {
+			if (witness(p[i], n)) {
+				return false;
+			}
+		}
+		return true;
+	}
+
+	public static boolean witness(long a, long n) {
+		long u = n - 1;
+		int t = 0;
+		while ((u & 1) == 0) {
+			t++;
+			u >>= 1;
+		}
+		long x1 = power(a, u, n), x2;
+		for (int i = 1; i <= t; i++) {
+			x2 = power(x1, 2, n);
+			if (x2 == 1 && x1 != 1 && x1 != n - 1) {
+				return true;
+			}
+			x1 = x2;
+		}
+		if (x1 != 1) {
+			return true;
+		}
+		return false;
+	}
+
+	// 返回，n的p次方 % mod
+	// 乘的每一步都用multiply方法，不用语言自带的乘法
+	public static long power(long n, long p, long mod) {
+		long ans = 1;
+		while (p > 0) {
+			if ((p & 1) == 1) {
+				ans = multiply(ans, n, mod);
+			}
+			n = multiply(n, n, mod);
+			p >>= 1;
+		}
+		return ans;
+	}
+
+	// 这个原理来自，讲解033，位运算实现乘法
+	// a * b的过程，用位运算实现，让每一个中间过程都 % mod
+	// 这么写可以防止溢出，这也叫龟速乘
+	public static long multiply(long a, long b, long mod) {
+		a = (a % mod + mod) % mod;
+		b = (b % mod + mod) % mod;
+		long ans = 0;
+		while (b != 0) {
+			if ((b & 1) != 0) {
+				ans = (ans + a) % mod;
+			}
+			a = (a + a) % mod;
+			b >>= 1;
+		}
+		return ans;
+	}
+
+}
\ No newline at end of file

From 95f97a6bea8bd9ac8e0a88b726c3ff611593f6a4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Mar 2025 16:12:39 +0800
Subject: [PATCH 0562/1712] modify code

---
 src/class097/Code02_LargeNumberIsPrime4.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class097/Code02_LargeNumberIsPrime4.java b/src/class097/Code02_LargeNumberIsPrime4.java
index 363c2016f..573c87a21 100644
--- a/src/class097/Code02_LargeNumberIsPrime4.java
+++ b/src/class097/Code02_LargeNumberIsPrime4.java
@@ -2,7 +2,7 @@
 
 // Miller-Rabin测试，java版，不用BigInteger也能通过的实现
 // 这个文件课上没有讲，课上讲的是，java中的long是64位
-// 所以 long * long 需要128位才能不溢出，于是直接用BigInteger了
+// 所以 long * long 需要128位才能不溢出，于是直接用BigInteger中自带的方法了
 // 但是
 // 如果a和b都是long类型，其实 a * b的过程，用位运算去实现，中间结果都 % mod 即可
 // 这样就不需要使用BigInteger了
@@ -85,8 +85,8 @@ public static long power(long n, long p, long mod) {
 		return ans;
 	}
 
+	// a * b的过程，用位运算实现，让每一个中间结果都 % mod
 	// 这个原理来自，讲解033，位运算实现乘法
-	// a * b的过程，用位运算实现，让每一个中间过程都 % mod
 	// 这么写可以防止溢出，这也叫龟速乘
 	public static long multiply(long a, long b, long mod) {
 		a = (a % mod + mod) % mod;

From 61d6edc44d4984216f95cc74ee982e01dfa652a1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Mar 2025 16:15:25 +0800
Subject: [PATCH 0563/1712] modify code

---
 src/class097/Code02_LargeNumberIsPrime4.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class097/Code02_LargeNumberIsPrime4.java b/src/class097/Code02_LargeNumberIsPrime4.java
index 573c87a21..68ecfdf22 100644
--- a/src/class097/Code02_LargeNumberIsPrime4.java
+++ b/src/class097/Code02_LargeNumberIsPrime4.java
@@ -7,8 +7,8 @@
 // 如果a和b都是long类型，其实 a * b的过程，用位运算去实现，中间结果都 % mod 即可
 // 这样就不需要使用BigInteger了
 // 讲解033，位运算实现乘法，增加 每一步 % mod 的逻辑即可
-// 重点看一下本文件，代码中有注释的部分，就是位运算实现乘法的改写
-// C++的同学也可以用本文件的方式来实现，也不需要定义128位的long类型了
+// 重点看一下本文件中的 multiply 方法，就是位运算实现乘法的改写
+// C++的同学也可以用这种方式来实现，也不需要定义128位的long类型
 // 测试链接 : https://www.luogu.com.cn/problem/U148828
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From c8e10920fdc89a1030f18c4cae157dbd8f34dd68 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Mar 2025 16:17:19 +0800
Subject: [PATCH 0564/1712] modify code

---
 src/class097/Code02_LargeNumberIsPrime4.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class097/Code02_LargeNumberIsPrime4.java b/src/class097/Code02_LargeNumberIsPrime4.java
index 68ecfdf22..ced6d2ce6 100644
--- a/src/class097/Code02_LargeNumberIsPrime4.java
+++ b/src/class097/Code02_LargeNumberIsPrime4.java
@@ -4,8 +4,8 @@
 // 这个文件课上没有讲，课上讲的是，java中的long是64位
 // 所以 long * long 需要128位才能不溢出，于是直接用BigInteger中自带的方法了
 // 但是
-// 如果a和b都是long类型，其实 a * b的过程，用位运算去实现，中间结果都 % mod 即可
-// 这样就不需要使用BigInteger了
+// 如果a和b都是long类型，其实 a * b 的过程，用位运算去实现，中间结果都 % mod 即可
+// 这样就不需要使用BigInteger
 // 讲解033，位运算实现乘法，增加 每一步 % mod 的逻辑即可
 // 重点看一下本文件中的 multiply 方法，就是位运算实现乘法的改写
 // C++的同学也可以用这种方式来实现，也不需要定义128位的long类型

From 378c7b094fd28c23048a190c67a8e2e1b74d9653 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Mar 2025 19:43:58 +0800
Subject: [PATCH 0565/1712] modify code

---
 src/class163/Code01_ColorOnTree1.java | 143 ++++++++++++++++++++++++++
 src/class163/Code01_ColorOnTree2.java | 124 ++++++++++++++++++++++
 2 files changed, 267 insertions(+)
 create mode 100644 src/class163/Code01_ColorOnTree1.java
 create mode 100644 src/class163/Code01_ColorOnTree2.java

diff --git a/src/class163/Code01_ColorOnTree1.java b/src/class163/Code01_ColorOnTree1.java
new file mode 100644
index 000000000..aeafd5826
--- /dev/null
+++ b/src/class163/Code01_ColorOnTree1.java
@@ -0,0 +1,143 @@
+package class163;
+
+// 树上数颜色，java版
+// 测试链接 : https://www.luogu.com.cn/problem/U41492
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_ColorOnTree1 {
+
+	public static int MAXN = 100001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+
+	// 重链剖分
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+
+	// 启发式合并
+	public static int[] colorCnt = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+	public static int total = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static void effect(int u) {
+		if (++colorCnt[arr[u]] == 1) {
+			total++;
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				effect(v);
+			}
+		}
+	}
+
+	public static void cancle(int u) {
+		if (--colorCnt[arr[u]] == 0) {
+			total--;
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				cancle(v);
+			}
+		}
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int keep) {
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, 0);
+			}
+		}
+		if (son[u] != 0) {
+			dfs2(son[u], 1);
+		}
+		if (++colorCnt[arr[u]] == 1) {
+			total++;
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				effect(v);
+			}
+		}
+		ans[u] = total;
+		if (keep == 0) {
+			cancle(u);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		dfs1(1, 0);
+		dfs2(1, 1);
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, cur; i <= m; i++) {
+			in.nextToken();
+			cur = (int) in.nval;
+			out.println(ans[cur]);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class163/Code01_ColorOnTree2.java b/src/class163/Code01_ColorOnTree2.java
new file mode 100644
index 000000000..e9ebc3418
--- /dev/null
+++ b/src/class163/Code01_ColorOnTree2.java
@@ -0,0 +1,124 @@
+package class163;
+
+// 树上数颜色，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/U41492
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//int MAXN = 100001;
+//int n, m;
+//int arr[100001];
+//
+//int head[100001];
+//int nxt[200002];
+//int to[200002];
+//int cnt = 0;
+//
+//int fa[100001];
+//int siz[100001];
+//int son[100001];
+//
+//int colorCnt[100001];
+//int ans[100001];
+//int total = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void effect(int u) {
+//    if (++colorCnt[arr[u]] == 1) {
+//        total++;
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            effect(v);
+//        }
+//    }
+//}
+//
+//void cancle(int u) {
+//    if (--colorCnt[arr[u]] == 0) {
+//        total--;
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            cancle(v);
+//        }
+//    }
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int keep) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, 0);
+//        }
+//    }
+//    if (son[u] != 0) {
+//        dfs2(son[u], 1);
+//    }
+//    if (++colorCnt[arr[u]] == 1) {
+//        total++;
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            effect(v);
+//        }
+//    }
+//    ans[u] = total;
+//    if (keep == 0) {
+//        cancle(u);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    cin >> m;
+//    for (int i = 1, cur; i <= m; i++) {
+//        cin >> cur;
+//        cout << ans[cur] << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From e8bf35a3848183e06eee050820825087b9e9ac81 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Mar 2025 19:44:28 +0800
Subject: [PATCH 0566/1712] modify code

---
 src/class163/Code01_ColorOnTree1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class163/Code01_ColorOnTree1.java b/src/class163/Code01_ColorOnTree1.java
index aeafd5826..d6a7c9b68 100644
--- a/src/class163/Code01_ColorOnTree1.java
+++ b/src/class163/Code01_ColorOnTree1.java
@@ -23,7 +23,7 @@ public class Code01_ColorOnTree1 {
 	public static int[] to = new int[MAXN << 1];
 	public static int cnt = 0;
 
-	// 重链剖分
+	// 树链剖分
 	public static int[] fa = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] son = new int[MAXN];

From 1b8136d3aa11d5e751aff66286d0b2ea9f9df482 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Mar 2025 20:44:32 +0800
Subject: [PATCH 0567/1712] modify code

---
 src/class163/Code01_ColorOnTree1.java   |   4 +
 src/class163/Code01_ColorOnTree2.java   |  20 ++--
 src/class163/Code02_ColorBanlance1.java | 143 ++++++++++++++++++++++++
 src/class163/Code02_ColorBanlance3.java | 118 +++++++++++++++++++
 4 files changed, 275 insertions(+), 10 deletions(-)
 create mode 100644 src/class163/Code02_ColorBanlance1.java
 create mode 100644 src/class163/Code02_ColorBanlance3.java

diff --git a/src/class163/Code01_ColorOnTree1.java b/src/class163/Code01_ColorOnTree1.java
index d6a7c9b68..d6c15b82c 100644
--- a/src/class163/Code01_ColorOnTree1.java
+++ b/src/class163/Code01_ColorOnTree1.java
@@ -14,7 +14,10 @@
 public class Code01_ColorOnTree1 {
 
 	public static int MAXN = 100001;
+
 	public static int n, m;
+
+	// 每个节点的颜色
 	public static int[] arr = new int[MAXN];
 
 	// 链式前向星
@@ -29,6 +32,7 @@ public class Code01_ColorOnTree1 {
 	public static int[] son = new int[MAXN];
 
 	// 启发式合并
+	// colorCnt[i] = j，表示i这种颜色出现了j次
 	public static int[] colorCnt = new int[MAXN];
 	public static int[] ans = new int[MAXN];
 	public static int total = 0;
diff --git a/src/class163/Code01_ColorOnTree2.java b/src/class163/Code01_ColorOnTree2.java
index e9ebc3418..403daa8ea 100644
--- a/src/class163/Code01_ColorOnTree2.java
+++ b/src/class163/Code01_ColorOnTree2.java
@@ -9,21 +9,21 @@
 //
 //using namespace std;
 //
-//int MAXN = 100001;
+//const int MAXN = 100001;
 //int n, m;
-//int arr[100001];
+//int arr[MAXN];
 //
-//int head[100001];
-//int nxt[200002];
-//int to[200002];
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
 //int cnt = 0;
 //
-//int fa[100001];
-//int siz[100001];
-//int son[100001];
+//int fa[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
 //
-//int colorCnt[100001];
-//int ans[100001];
+//int colorCnt[MAXN];
+//int ans[MAXN];
 //int total = 0;
 //
 //void addEdge(int u, int v) {
diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
new file mode 100644
index 000000000..8243b9e49
--- /dev/null
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -0,0 +1,143 @@
+package class163;
+
+// 颜色平衡的子树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P9233
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_ColorBanlance1 {
+
+	public static int MAXN = 200001;
+
+	public static int n;
+
+	// 每个节点的颜色
+	public static int[] arr = new int[MAXN];
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+
+	// 树链剖分
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+
+	// 启发式合并
+	// colorCnt[i] = j，表示i这种颜色出现了j次
+	public static int[] colorCnt = new int[MAXN];
+	// cntCnt[i] = j，表示出现次数为i的颜色一共有j种
+	public static int[] cntCnt = new int[MAXN];
+	// 颜色平衡子树的个数
+	public static int ans = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static void effect(int u) {
+		colorCnt[arr[u]]++;
+		cntCnt[colorCnt[arr[u]] - 1]--;
+		cntCnt[colorCnt[arr[u]]]++;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				effect(v);
+			}
+		}
+	}
+
+	public static void cancle(int u) {
+		colorCnt[arr[u]]--;
+		cntCnt[colorCnt[arr[u]] + 1]--;
+		cntCnt[colorCnt[arr[u]]]++;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				cancle(v);
+			}
+		}
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int keep) {
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, 0);
+			}
+		}
+		if (son[u] != 0) {
+			dfs2(son[u], 1);
+		}
+		colorCnt[arr[u]]++;
+		cntCnt[colorCnt[arr[u]] - 1]--;
+		cntCnt[colorCnt[arr[u]]]++;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				effect(v);
+			}
+		}
+		if (colorCnt[arr[u]] * cntCnt[colorCnt[arr[u]]] == siz[u]) {
+			ans++;
+		}
+		if (keep == 0) {
+			cancle(u);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, color, father; i <= n; i++) {
+			in.nextToken();
+			color = (int) in.nval;
+			in.nextToken();
+			father = (int) in.nval;
+			arr[i] = color;
+			if (i != 1) {
+				addEdge(father, i);
+			}
+		}
+		dfs1(1, 0);
+		dfs2(1, 1);
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
new file mode 100644
index 000000000..c03402a31
--- /dev/null
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -0,0 +1,118 @@
+package class163;
+
+// 颜色平衡的子树，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P9233
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//int n;
+//int arr[MAXN];
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt = 0;
+//int fa[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int colorCnt[MAXN];
+//int cntCnt[MAXN];
+//int ans = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void effect(int u) {
+//    colorCnt[arr[u]]++;
+//    cntCnt[colorCnt[arr[u]] - 1]--;
+//    cntCnt[colorCnt[arr[u]]]++;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            effect(v);
+//        }
+//    }
+//}
+//
+//void cancle(int u) {
+//    colorCnt[arr[u]]--;
+//    cntCnt[colorCnt[arr[u]] + 1]--;
+//    cntCnt[colorCnt[arr[u]]]++;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            cancle(v);
+//        }
+//    }
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int keep) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, 0);
+//        }
+//    }
+//    if (son[u] != 0) {
+//        dfs2(son[u], 1);
+//    }
+//    colorCnt[arr[u]]++;
+//    cntCnt[colorCnt[arr[u]] - 1]--;
+//    cntCnt[colorCnt[arr[u]]]++;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            effect(v);
+//        }
+//    }
+//    if (colorCnt[arr[u]] * cntCnt[colorCnt[arr[u]]] == siz[u]) {
+//        ans++;
+//    }
+//    if (keep == 0) {
+//        cancle(u);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, color, father; i <= n; i++) {
+//        cin >> color >> father;
+//        arr[i] = color;
+//        if (i != 1) {
+//            addEdge(father, i);
+//        }
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    cout << ans << "\n";
+//    return 0;
+//}
\ No newline at end of file

From 9ac2ff644abb6740284707c4334a244713a2a946 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Mar 2025 21:59:15 +0800
Subject: [PATCH 0568/1712] modify code

---
 src/class163/Code02_ColorBanlance1.java |  45 ++----
 src/class163/Code02_ColorBanlance2.java | 205 ++++++++++++++++++++++++
 src/class163/Code02_ColorBanlance3.java |  39 ++---
 3 files changed, 235 insertions(+), 54 deletions(-)
 create mode 100644 src/class163/Code02_ColorBanlance2.java

diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index 8243b9e49..c2a052f36 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -1,8 +1,10 @@
 package class163;
 
-// 颜色平衡的子树，java版
+// 颜色平衡的子树，java实现递归版
 // 测试链接 : https://www.luogu.com.cn/problem/P9233
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"
+// 因为递归爆栈了，所以会有两个测试用例无法通过
+// 改成迭代的版本就是本节课Code02_ColorBanlance2文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -27,7 +29,6 @@ public class Code02_ColorBanlance1 {
 	public static int cnt = 0;
 
 	// 树链剖分
-	public static int[] fa = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] son = new int[MAXN];
 
@@ -49,11 +50,8 @@ public static void effect(int u) {
 		colorCnt[arr[u]]++;
 		cntCnt[colorCnt[arr[u]] - 1]--;
 		cntCnt[colorCnt[arr[u]]]++;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != fa[u]) {
-				effect(v);
-			}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			effect(to[e]);
 		}
 	}
 
@@ -61,30 +59,21 @@ public static void cancle(int u) {
 		colorCnt[arr[u]]--;
 		cntCnt[colorCnt[arr[u]] + 1]--;
 		cntCnt[colorCnt[arr[u]]]++;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != fa[u]) {
-				cancle(v);
-			}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			cancle(to[e]);
 		}
 	}
 
-	public static void dfs1(int u, int f) {
-		fa[u] = f;
+	public static void dfs1(int u) {
 		siz[u] = 1;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				dfs1(v, u);
-			}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs1(to[e]);
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
-			if (v != f) {
-				siz[u] += siz[v];
-				if (son[u] == 0 || siz[son[u]] < siz[v]) {
-					son[u] = v;
-				}
+			siz[u] += siz[v];
+			if (son[u] == 0 || siz[son[u]] < siz[v]) {
+				son[u] = v;
 			}
 		}
 	}
@@ -92,7 +81,7 @@ public static void dfs1(int u, int f) {
 	public static void dfs2(int u, int keep) {
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
-			if (v != fa[u] && v != son[u]) {
+			if (v != son[u]) {
 				dfs2(v, 0);
 			}
 		}
@@ -104,7 +93,7 @@ public static void dfs2(int u, int keep) {
 		cntCnt[colorCnt[arr[u]]]++;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
-			if (v != fa[u] && v != son[u]) {
+			if (v != son[u]) {
 				effect(v);
 			}
 		}
@@ -132,7 +121,7 @@ public static void main(String[] args) throws IOException {
 				addEdge(father, i);
 			}
 		}
-		dfs1(1, 0);
+		dfs1(1);
 		dfs2(1, 1);
 		out.println(ans);
 		out.flush();
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
new file mode 100644
index 000000000..c3e51bf32
--- /dev/null
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -0,0 +1,205 @@
+package class163;
+
+// 颜色平衡的子树，java实现迭代版
+// 测试链接 : https://www.luogu.com.cn/problem/P9233
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_ColorBanlance2 {
+
+	public static int MAXN = 200001;
+	public static int n;
+	public static int[] arr = new int[MAXN];
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] colorCnt = new int[MAXN];
+	public static int[] cntCnt = new int[MAXN];
+	public static int ans = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static int[][] stack1 = new int[MAXN][2];
+
+	public static int size1;
+
+	public static int cur1, edge1;
+
+	public static int[][] stack2 = new int[MAXN][3];
+
+	public static int size2;
+
+	public static int cur2, edge2, keep2;
+
+	public static void push1(int u, int e) {
+		stack1[size1][0] = u;
+		stack1[size1][1] = e;
+		size1++;
+	}
+
+	public static void pop1() {
+		--size1;
+		cur1 = stack1[size1][0];
+		edge1 = stack1[size1][1];
+	}
+
+	public static void push2(int u, int e, int k) {
+		stack2[size2][0] = u;
+		stack2[size2][1] = e;
+		stack2[size2][2] = k;
+		size2++;
+	}
+
+	public static void pop2() {
+		--size2;
+		cur2 = stack2[size2][0];
+		edge2 = stack2[size2][1];
+		keep2 = stack2[size2][2];
+	}
+
+	public static void effect(int root) {
+		size1 = 0;
+		push1(root, -1);
+		while (size1 > 0) {
+			pop1();
+			if (edge1 == -1) {
+				colorCnt[arr[cur1]]++;
+				cntCnt[colorCnt[arr[cur1]] - 1]--;
+				cntCnt[colorCnt[arr[cur1]]]++;
+				edge1 = head[cur1];
+			} else {
+				edge1 = next[edge1];
+			}
+			if (edge1 != 0) {
+				push1(cur1, edge1);
+				push1(to[edge1], -1);
+			}
+		}
+	}
+
+	public static void cancle(int root) {
+		size1 = 0;
+		push1(root, -1);
+		while (size1 > 0) {
+			pop1();
+			if (edge1 == -1) {
+				colorCnt[arr[cur1]]--;
+				cntCnt[colorCnt[arr[cur1]] + 1]--;
+				cntCnt[colorCnt[arr[cur1]]]++;
+				edge1 = head[cur1];
+			} else {
+				edge1 = next[edge1];
+			}
+			if (edge1 != 0) {
+				push1(cur1, edge1);
+				push1(to[edge1], -1);
+			}
+		}
+	}
+
+	public static void dfs1() {
+		size1 = 0;
+		push1(1, -1);
+		while (size1 > 0) {
+			pop1();
+			if (edge1 == -1) {
+				siz[cur1] = 1;
+				edge1 = head[cur1];
+			} else {
+				edge1 = next[edge1];
+			}
+			if (edge1 != 0) {
+				push1(cur1, edge1);
+				push1(to[edge1], -1);
+			} else {
+				for (int e = head[cur1], v; e > 0; e = next[e]) {
+					v = to[e];
+					siz[cur1] += siz[v];
+					if (son[cur1] == 0 || siz[son[cur1]] < siz[v]) {
+						son[cur1] = v;
+					}
+				}
+			}
+		}
+	}
+
+	public static void dfs2() {
+		size2 = 0;
+		push2(1, -1, 1);
+		while (size2 > 0) {
+			pop2();
+			if (edge2 != -2) {
+				if (edge2 == -1) {
+					edge2 = head[cur2];
+				} else {
+					edge2 = next[edge2];
+				}
+				if (edge2 > 0) {
+					push2(cur2, edge2, keep2);
+					if (to[edge2] != son[cur2]) {
+						push2(to[edge2], -1, 0);
+					}
+				} else {
+					push2(cur2, -2, keep2);
+					if (son[cur2] != 0) {
+						push2(son[cur2], -1, 1);
+					}
+				}
+			} else {
+				colorCnt[arr[cur2]]++;
+				cntCnt[colorCnt[arr[cur2]] - 1]--;
+				cntCnt[colorCnt[arr[cur2]]]++;
+				for (int e = head[cur2], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != son[cur2]) {
+						effect(v);
+					}
+				}
+				if (colorCnt[arr[cur2]] * cntCnt[colorCnt[arr[cur2]]] == siz[cur2]) {
+					ans++;
+				}
+				if (keep2 == 0) {
+					cancle(cur2);
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, color, father; i <= n; i++) {
+			in.nextToken();
+			color = (int) in.nval;
+			in.nextToken();
+			father = (int) in.nval;
+			arr[i] = color;
+			if (i != 1) {
+				addEdge(father, i);
+			}
+		}
+		dfs1();
+		dfs2();
+		out.println(ans);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
index c03402a31..93a33d845 100644
--- a/src/class163/Code02_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -16,7 +16,6 @@
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cnt = 0;
-//int fa[MAXN];
 //int siz[MAXN];
 //int son[MAXN];
 //int colorCnt[MAXN];
@@ -33,11 +32,8 @@
 //    colorCnt[arr[u]]++;
 //    cntCnt[colorCnt[arr[u]] - 1]--;
 //    cntCnt[colorCnt[arr[u]]]++;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u]) {
-//            effect(v);
-//        }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        effect(to[e]);
 //    }
 //}
 //
@@ -45,30 +41,21 @@
 //    colorCnt[arr[u]]--;
 //    cntCnt[colorCnt[arr[u]] + 1]--;
 //    cntCnt[colorCnt[arr[u]]]++;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u]) {
-//            cancle(v);
-//        }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        cancle(to[e]);
 //    }
 //}
 //
-//void dfs1(int u, int f) {
-//    fa[u] = f;
+//void dfs1(int u) {
 //    siz[u] = 1;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs1(to[e]);
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
+//        siz[u] += siz[v];
+//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//            son[u] = v;
 //        }
 //    }
 //}
@@ -76,7 +63,7 @@
 //void dfs2(int u, int keep) {
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
+//        if (v != son[u]) {
 //            dfs2(v, 0);
 //        }
 //    }
@@ -88,7 +75,7 @@
 //    cntCnt[colorCnt[arr[u]]]++;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
+//        if (v != son[u]) {
 //            effect(v);
 //        }
 //    }
@@ -111,7 +98,7 @@
 //            addEdge(father, i);
 //        }
 //    }
-//    dfs1(1, 0);
+//    dfs1(1);
 //    dfs2(1, 1);
 //    cout << ans << "\n";
 //    return 0;

From 5e6b1469521253d267fe721dda8a09f6a192b3d0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Mar 2025 22:06:55 +0800
Subject: [PATCH 0569/1712] modify code

---
 src/class163/Code02_ColorBanlance1.java |  4 +-
 src/class163/Code02_ColorBanlance2.java | 49 ++++++++++++-------------
 2 files changed, 26 insertions(+), 27 deletions(-)

diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index c2a052f36..e36462f02 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -3,8 +3,8 @@
 // 颜色平衡的子树，java实现递归版
 // 测试链接 : https://www.luogu.com.cn/problem/P9233
 // 提交以下的code，提交时请把类名改成"Main"
-// 因为递归爆栈了，所以会有两个测试用例无法通过
-// 改成迭代的版本就是本节课Code02_ColorBanlance2文件
+// 因为树的深度太大，递归函数爆栈了，所以会有两个测试用例无法通过
+// 迭代版可以完全通过，就是本节课Code02_ColorBanlance2文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index c3e51bf32..ae1826614 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -32,17 +32,16 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	// stack1、size1、cur1、edge1
+	// 用来把effect、cancle、dfs1改成迭代版
 	public static int[][] stack1 = new int[MAXN][2];
+	public static int size1, cur1, edge1;
 
-	public static int size1;
-
-	public static int cur1, edge1;
-
+	// stack2、size2、cur2、edge2、keep2
+	// 用来把dfs2改成迭代版
 	public static int[][] stack2 = new int[MAXN][3];
-
-	public static int size2;
-
-	public static int cur2, edge2, keep2;
+	public static int size2, cur2, edge2, keep2;
 
 	public static void push1(int u, int e) {
 		stack1[size1][0] = u;
@@ -141,7 +140,23 @@ public static void dfs2() {
 		push2(1, -1, 1);
 		while (size2 > 0) {
 			pop2();
-			if (edge2 != -2) {
+			if (edge2 == -2) {
+				colorCnt[arr[cur2]]++;
+				cntCnt[colorCnt[arr[cur2]] - 1]--;
+				cntCnt[colorCnt[arr[cur2]]]++;
+				for (int e = head[cur2], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != son[cur2]) {
+						effect(v);
+					}
+				}
+				if (colorCnt[arr[cur2]] * cntCnt[colorCnt[arr[cur2]]] == siz[cur2]) {
+					ans++;
+				}
+				if (keep2 == 0) {
+					cancle(cur2);
+				}
+			} else {
 				if (edge2 == -1) {
 					edge2 = head[cur2];
 				} else {
@@ -158,22 +173,6 @@ public static void dfs2() {
 						push2(son[cur2], -1, 1);
 					}
 				}
-			} else {
-				colorCnt[arr[cur2]]++;
-				cntCnt[colorCnt[arr[cur2]] - 1]--;
-				cntCnt[colorCnt[arr[cur2]]]++;
-				for (int e = head[cur2], v; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != son[cur2]) {
-						effect(v);
-					}
-				}
-				if (colorCnt[arr[cur2]] * cntCnt[colorCnt[arr[cur2]]] == siz[cur2]) {
-					ans++;
-				}
-				if (keep2 == 0) {
-					cancle(cur2);
-				}
 			}
 		}
 	}

From fbc06b17f9b5d02126511902586ad4fed17fedda Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Mar 2025 22:09:13 +0800
Subject: [PATCH 0570/1712] modify code

---
 src/class163/Code02_ColorBanlance2.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index ae1826614..97b3fb697 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -33,13 +33,11 @@ public static void addEdge(int u, int v) {
 	}
 
 	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	// stack1、size1、cur1、edge1
-	// 用来把effect、cancle、dfs1改成迭代版
+	// stack1、size1、cur1、edge1，用于把effect、cancle、dfs1改成迭代版
 	public static int[][] stack1 = new int[MAXN][2];
 	public static int size1, cur1, edge1;
 
-	// stack2、size2、cur2、edge2、keep2
-	// 用来把dfs2改成迭代版
+	// stack2、size2、cur2、edge2、keep2，用于把dfs2改成迭代版
 	public static int[][] stack2 = new int[MAXN][3];
 	public static int size2, cur2, edge2, keep2;
 

From 0f09382f62a5afb7f1e152a8642af15c856b6eb5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Mar 2025 17:35:51 +0800
Subject: [PATCH 0571/1712] modify code

---
 .../Code03_LongestRearrangePalindrome1.java   | 231 ++++++++++++++++++
 .../Code03_LongestRearrangePalindrome2.java   | 135 ++++++++++
 2 files changed, 366 insertions(+)
 create mode 100644 src/class163/Code03_LongestRearrangePalindrome1.java
 create mode 100644 src/class163/Code03_LongestRearrangePalindrome2.java

diff --git a/src/class163/Code03_LongestRearrangePalindrome1.java b/src/class163/Code03_LongestRearrangePalindrome1.java
new file mode 100644
index 000000000..c740463e6
--- /dev/null
+++ b/src/class163/Code03_LongestRearrangePalindrome1.java
@@ -0,0 +1,231 @@
+package class163;
+
+// 最长重排回文路径，java版，本题递归函数不会爆栈
+// 测试链接 : https://www.luogu.com.cn/problem/CF741D
+// 测试链接 : https://codeforces.com/problemset/problem/741/D
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_LongestRearrangePalindrome1 {
+
+	public static int MAXN = 500001;
+	// 字符种类最多22种
+	public static int MAXV = 22;
+	public static int n;
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cnt = 0;
+
+	// 树链剖分
+	public static int[] siz = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] eor = new int[MAXN];
+	public static int[] son = new int[MAXN];
+
+	// 统计答案
+	public static int[] maxdep = new int[1 << MAXV];
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdge(int u, int v, int w) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		weight[cnt] = w;
+		head[u] = cnt;
+	}
+
+	public static void dfs1(int u, int d, int x) {
+		siz[u] = 1;
+		dep[u] = d;
+		eor[u] = x;
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs1(to[e], d + 1, x ^ (1 << weight[e]));
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			siz[u] += siz[v];
+			if (son[u] == 0 || siz[son[u]] < siz[v]) {
+				son[u] = v;
+			}
+		}
+	}
+
+	public static void effect(int u) {
+		maxdep[eor[u]] = Math.max(maxdep[eor[u]], dep[u]);
+		for (int e = head[u]; e > 0; e = next[e]) {
+			effect(to[e]);
+		}
+	}
+
+	public static void cancle(int u) {
+		maxdep[eor[u]] = 0;
+		for (int e = head[u]; e > 0; e = next[e]) {
+			cancle(to[e]);
+		}
+	}
+
+	public static int cross(int u, int lcaDep) {
+		int ans = 0;
+		if (maxdep[eor[u]] != 0) {
+			ans = Math.max(ans, maxdep[eor[u]] + dep[u] - lcaDep * 2);
+		}
+		for (int i = 0; i < MAXV; i++) {
+			if (maxdep[eor[u] ^ (1 << i)] != 0) {
+				ans = Math.max(ans, maxdep[eor[u] ^ (1 << i)] + dep[u] - lcaDep * 2);
+			}
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			ans = Math.max(ans, cross(to[e], lcaDep));
+		}
+		return ans;
+	}
+
+	public static void dfs2(int u, int keep) {
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != son[u]) {
+				dfs2(v, 0);
+			}
+		}
+		if (son[u] != 0) {
+			dfs2(son[u], 1);
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			ans[u] = Math.max(ans[u], ans[to[e]]);
+		}
+		if (maxdep[eor[u]] != 0) {
+			ans[u] = Math.max(ans[u], maxdep[eor[u]] - dep[u]);
+		}
+		for (int i = 0; i < MAXV; i++) {
+			if (maxdep[eor[u] ^ (1 << i)] != 0) {
+				ans[u] = Math.max(ans[u], maxdep[eor[u] ^ (1 << i)] - dep[u]);
+			}
+		}
+		maxdep[eor[u]] = Math.max(maxdep[eor[u]], dep[u]);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != son[u]) {
+				ans[u] = Math.max(ans[u], cross(v, dep[u]));
+				effect(v);
+			}
+		}
+		if (keep == 0) {
+			cancle(u);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 2, fth, edg; i <= n; i++) {
+			fth = in.nextInt();
+			edg = in.nextChar() - 'a';
+			addEdge(fth, i, edg);
+		}
+		dfs1(1, 1, 0);
+		dfs2(1, 1);
+		for (int i = 1; i <= n; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public double nextDouble() throws IOException {
+			double num = 0, div = 1;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != '.' && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			if (b == '.') {
+				b = readByte();
+				while (!isWhitespace(b) && b != -1) {
+					num += (b - '0') / (div *= 10);
+					b = readByte();
+				}
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class163/Code03_LongestRearrangePalindrome2.java b/src/class163/Code03_LongestRearrangePalindrome2.java
new file mode 100644
index 000000000..4732ef008
--- /dev/null
+++ b/src/class163/Code03_LongestRearrangePalindrome2.java
@@ -0,0 +1,135 @@
+package class163;
+
+// 最长重排回文路径，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF741D
+// 测试链接 : https://codeforces.com/problemset/problem/741/D
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//const int MAXV = 22;
+//int n;
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cnt = 0;
+//int siz[MAXN];
+//int dep[MAXN];
+//int eor[MAXN];
+//int son[MAXN];
+//int maxdep[1 << MAXV];
+//int ans[MAXN];
+//
+//void addEdge(int u, int v, int w) {
+//	nxt[++cnt] = head[u];
+//	to[cnt] = v;
+//	weight[cnt] = w;
+//    head[u] = cnt;
+//}
+//
+//void dfs1(int u, int d, int x) {
+//	siz[u] = 1;
+//    dep[u] = d;
+//    eor[u] = x;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs1(to[e], d + 1, x ^ (1 << weight[e]));
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        siz[u] += siz[v];
+//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//            son[u] = v;
+//        }
+//    }
+//}
+//
+//void effect(int u) {
+//    maxdep[eor[u]] = max(maxdep[eor[u]], dep[u]);
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        effect(to[e]);
+//    }
+//}
+//
+//void cancle(int u) {
+//    maxdep[eor[u]] = 0;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        cancle(to[e]);
+//    }
+//}
+//
+//int cross(int u, int lcaDep) {
+//    int ret = 0;
+//    if (maxdep[eor[u]] != 0) {
+//        ret = max(ret, maxdep[eor[u]] + dep[u] - lcaDep * 2);
+//    }
+//    for (int i = 0; i < MAXV; i++) {
+//        if (maxdep[eor[u] ^ (1 << i)] != 0) {
+//            ret = max(ret, maxdep[eor[u] ^ (1 << i)] + dep[u] - lcaDep * 2);
+//        }
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        ret = max(ret, cross(to[e], lcaDep));
+//    }
+//    return ret;
+//}
+//
+//void dfs2(int u, int keep) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != son[u]) {
+//            dfs2(v, 0);
+//        }
+//    }
+//    if (son[u] != 0) {
+//        dfs2(son[u], 1);
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//    	ans[u] = max(ans[u], ans[to[e]]);
+//    }
+//    if (maxdep[eor[u]] != 0) {
+//    	ans[u] = max(ans[u], maxdep[eor[u]] - dep[u]);
+//    }
+//    for (int i = 0; i < MAXV; i++) {
+//        if (maxdep[eor[u] ^ (1 << i)] != 0) {
+//        	ans[u] = max(ans[u], maxdep[eor[u] ^ (1 << i)] - dep[u]);
+//        }
+//    }
+//    maxdep[eor[u]] = max(maxdep[eor[u]], dep[u]);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != son[u]) {
+//        	ans[u] = max(ans[u], cross(v, dep[u]));
+//            effect(v);
+//        }
+//    }
+//    if (keep == 0) {
+//        cancle(u);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    int fth;
+//    int edg;
+//    char c;
+//    for (int i = 2; i <= n; i++) {
+//        cin >> fth;
+//        cin >> c;
+//        edg = c - 'a';
+//        addEdge(fth, i, edg);
+//    }
+//    dfs1(1, 1, 0);
+//    dfs2(1, 1);
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << " ";
+//    }
+//    cout << "\n";
+//    return 0;
+//}
\ No newline at end of file

From 6431c80f7ba180facb35fe786446f7bedc57e341 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Mar 2025 17:38:23 +0800
Subject: [PATCH 0572/1712] modify code

---
 .../Code03_LongestRearrangePalindrome2.java      | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class163/Code03_LongestRearrangePalindrome2.java b/src/class163/Code03_LongestRearrangePalindrome2.java
index 4732ef008..f9c34e2c8 100644
--- a/src/class163/Code03_LongestRearrangePalindrome2.java
+++ b/src/class163/Code03_LongestRearrangePalindrome2.java
@@ -26,14 +26,14 @@
 //int ans[MAXN];
 //
 //void addEdge(int u, int v, int w) {
-//	nxt[++cnt] = head[u];
-//	to[cnt] = v;
-//	weight[cnt] = w;
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    weight[cnt] = w;
 //    head[u] = cnt;
 //}
 //
 //void dfs1(int u, int d, int x) {
-//	siz[u] = 1;
+//    siz[u] = 1;
 //    dep[u] = d;
 //    eor[u] = x;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
@@ -89,21 +89,21 @@
 //        dfs2(son[u], 1);
 //    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//    	ans[u] = max(ans[u], ans[to[e]]);
+//        ans[u] = max(ans[u], ans[to[e]]);
 //    }
 //    if (maxdep[eor[u]] != 0) {
-//    	ans[u] = max(ans[u], maxdep[eor[u]] - dep[u]);
+//        ans[u] = max(ans[u], maxdep[eor[u]] - dep[u]);
 //    }
 //    for (int i = 0; i < MAXV; i++) {
 //        if (maxdep[eor[u] ^ (1 << i)] != 0) {
-//        	ans[u] = max(ans[u], maxdep[eor[u] ^ (1 << i)] - dep[u]);
+//            ans[u] = max(ans[u], maxdep[eor[u] ^ (1 << i)] - dep[u]);
 //        }
 //    }
 //    maxdep[eor[u]] = max(maxdep[eor[u]], dep[u]);
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u]) {
-//        	ans[u] = max(ans[u], cross(v, dep[u]));
+//            ans[u] = max(ans[u], cross(v, dep[u]));
 //            effect(v);
 //        }
 //    }

From 7b9a93e4b57e295b2246b61e61ead13a0fc553f0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Mar 2025 17:39:11 +0800
Subject: [PATCH 0573/1712] modify code

---
 src/class163/Code03_LongestRearrangePalindrome1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class163/Code03_LongestRearrangePalindrome1.java b/src/class163/Code03_LongestRearrangePalindrome1.java
index c740463e6..cb5921d41 100644
--- a/src/class163/Code03_LongestRearrangePalindrome1.java
+++ b/src/class163/Code03_LongestRearrangePalindrome1.java
@@ -1,6 +1,6 @@
 package class163;
 
-// 最长重排回文路径，java版，本题递归函数不会爆栈
+// 最长重排回文路径，java版，本题写递归函数不会爆栈
 // 测试链接 : https://www.luogu.com.cn/problem/CF741D
 // 测试链接 : https://codeforces.com/problemset/problem/741/D
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例

From b9e32d7b67b9f061922a486e5f31842d7c13c447 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Mar 2025 21:09:15 +0800
Subject: [PATCH 0574/1712] modify code

---
 src/class163/Code03_BloodCousins1.java        | 173 ++++++++++++++++++
 src/class163/Code03_BloodCousins2.java        | 157 ++++++++++++++++
 ...> Code06_LongestRearrangePalindrome1.java} |   4 +-
 ...> Code06_LongestRearrangePalindrome2.java} |   0
 4 files changed, 332 insertions(+), 2 deletions(-)
 create mode 100644 src/class163/Code03_BloodCousins1.java
 create mode 100644 src/class163/Code03_BloodCousins2.java
 rename src/class163/{Code03_LongestRearrangePalindrome1.java => Code06_LongestRearrangePalindrome1.java} (97%)
 rename src/class163/{Code03_LongestRearrangePalindrome2.java => Code06_LongestRearrangePalindrome2.java} (100%)

diff --git a/src/class163/Code03_BloodCousins1.java b/src/class163/Code03_BloodCousins1.java
new file mode 100644
index 000000000..4a2f713d4
--- /dev/null
+++ b/src/class163/Code03_BloodCousins1.java
@@ -0,0 +1,173 @@
+package class163;
+
+// 表亲数量，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF208E
+// 测试链接 : https://codeforces.com/problemset/problem/208/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code03_BloodCousins1 {
+
+	public static int MAXN = 100001;
+	public static int MAXH = 20;
+	public static int n, m;
+
+	public static boolean[] root = new boolean[MAXN];
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headq = new int[MAXN];
+	public static int[] nextq = new int[MAXN << 1];
+	public static int[] idxq = new int[MAXN << 1];
+	public static int[] kthq = new int[MAXN << 1];
+	public static int cntq;
+
+	public static int[] siz = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXH];
+
+	public static int[] nodeCnt = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdge(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addQuestion(int u, int idx, int kth) {
+		nextq[++cntq] = headq[u];
+		idxq[cntq] = idx;
+		kthq[cntq] = kth;
+		headq[u] = cntq;
+	}
+
+	public static int kAncestor(int u, int k) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (k >= 1 << p) {
+				k -= 1 << p;
+				u = stjump[u][p];
+			}
+		}
+		return u;
+	}
+
+	public static void dfs1(int u, int fa) {
+		siz[u] = 1;
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			dfs1(tog[e], u);
+		}
+		for (int e = headg[u], v; e > 0; e = nextg[e]) {
+			v = tog[e];
+			siz[u] += siz[v];
+			if (son[u] == 0 || siz[son[u]] < siz[v]) {
+				son[u] = v;
+			}
+		}
+	}
+
+	public static void effect(int u) {
+		nodeCnt[dep[u]]++;
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			effect(tog[e]);
+		}
+	}
+
+	public static void cancle(int u) {
+		nodeCnt[dep[u]]--;
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			cancle(tog[e]);
+		}
+	}
+
+	public static void dfs2(int u, int keep) {
+		for (int e = headg[u], v; e > 0; e = nextg[e]) {
+			v = tog[e];
+			if (v != son[u]) {
+				dfs2(v, 0);
+			}
+		}
+		if (son[u] != 0) {
+			dfs2(son[u], 1);
+		}
+		nodeCnt[dep[u]]++;
+		for (int e = headg[u], v; e > 0; e = nextg[e]) {
+			v = tog[e];
+			if (v != son[u]) {
+				effect(v);
+			}
+		}
+		for (int i = headq[u]; i > 0; i = nextq[i]) {
+			ans[idxq[i]] = nodeCnt[dep[u] + kthq[i]];
+		}
+		if (keep == 0) {
+			cancle(u);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, father; i <= n; i++) {
+			in.nextToken();
+			father = (int) in.nval;
+			if (father == 0) {
+				root[i] = true;
+			} else {
+				addEdge(father, i);
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			if (root[i]) {
+				dfs1(i, 0);
+			}
+		}
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, u, k, kfather; i <= m; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			k = (int) in.nval;
+			kfather = kAncestor(u, k);
+			if (kfather != 0) {
+				addQuestion(kfather, i, k);
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			if (root[i]) {
+				dfs2(i, 0);
+			}
+		}
+		for (int i = 1; i <= m; i++) {
+			if (ans[i] == 0) {
+				out.print("0 ");
+			} else {
+				out.print((ans[i] - 1) + " ");
+			}
+		}
+		out.println();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class163/Code03_BloodCousins2.java b/src/class163/Code03_BloodCousins2.java
new file mode 100644
index 000000000..50bc6c949
--- /dev/null
+++ b/src/class163/Code03_BloodCousins2.java
@@ -0,0 +1,157 @@
+package class163;
+
+// 表亲数量，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF208E
+// 测试链接 : https://codeforces.com/problemset/problem/208/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXH = 20;
+//int n, m;
+//
+//bool root[MAXN];
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int cntg;
+//
+//int headq[MAXN];
+//int nextq[MAXN << 1];
+//int idxq[MAXN << 1];
+//int kthq[MAXN << 1];
+//int cntq;
+//
+//int siz[MAXN];
+//int dep[MAXN];
+//int son[MAXN];
+//int stjump[MAXN][20];
+//
+//int nodeCnt[MAXN];
+//int ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addQuestion(int u, int idx, int kth) {
+//    nextq[++cntq] = headq[u];
+//    idxq[cntq] = idx;
+//    kthq[cntq] = kth;
+//    headq[u] = cntq;
+//}
+//
+//int kAncestor(int u, int k) {
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (k >= (1 << p)) {
+//            k -= (1 << p);
+//            u = stjump[u][p];
+//        }
+//    }
+//    return u;
+//}
+//
+//void dfs1(int u, int fa) {
+//    siz[u] = 1;
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//    }
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        dfs1(tog[e], u);
+//    }
+//    for (int e = headg[u], v; e > 0; e = nextg[e]) {
+//        v = tog[e];
+//        siz[u] += siz[v];
+//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//            son[u] = v;
+//        }
+//    }
+//}
+//
+//void effect(int u) {
+//    nodeCnt[dep[u]]++;
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        effect(tog[e]);
+//    }
+//}
+//
+//void cancle(int u) {
+//    nodeCnt[dep[u]]--;
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        cancle(tog[e]);
+//    }
+//}
+//
+//void dfs2(int u, int keep) {
+//    for (int e = headg[u], v; e > 0; e = nextg[e]) {
+//        v = tog[e];
+//        if (v != son[u]) {
+//            dfs2(v, 0);
+//        }
+//    }
+//    if (son[u] != 0) {
+//        dfs2(son[u], 1);
+//    }
+//    nodeCnt[dep[u]]++;
+//    for (int e = headg[u], v; e > 0; e = nextg[e]) {
+//        v = tog[e];
+//        if (v != son[u]) {
+//            effect(v);
+//        }
+//    }
+//    for (int i = headq[u]; i > 0; i = nextq[i]) {
+//    	ans[idxq[i]] = nodeCnt[dep[u] + kthq[i]];
+//    }
+//    if (keep == 0) {
+//        cancle(u);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, father; i <= n; i++) {
+//        cin >> father;
+//        if (father == 0) {
+//        	root[i] = true;
+//        } else {
+//            addEdge(father, i);
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        if (root[i]) {
+//            dfs1(i, 0);
+//        }
+//    }
+//    cin >> m;
+//    for (int i = 1, u, k, kfather; i <= m; i++) {
+//        cin >> u >> k;
+//        kfather = kAncestor(u, k);
+//        if (kfather != 0) {
+//            addQuestion(kfather, i, k);
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        if (root[i]) {
+//            dfs2(i, 0);
+//        }
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (ans[i] == 0) {
+//            cout << "0 ";
+//        } else {
+//            cout << ans[i] - 1 << " ";
+//        }
+//    }
+//    cout << "\n";
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class163/Code03_LongestRearrangePalindrome1.java b/src/class163/Code06_LongestRearrangePalindrome1.java
similarity index 97%
rename from src/class163/Code03_LongestRearrangePalindrome1.java
rename to src/class163/Code06_LongestRearrangePalindrome1.java
index cb5921d41..984e53f0f 100644
--- a/src/class163/Code03_LongestRearrangePalindrome1.java
+++ b/src/class163/Code06_LongestRearrangePalindrome1.java
@@ -1,6 +1,6 @@
 package class163;
 
-// 最长重排回文路径，java版，本题写递归函数不会爆栈
+// 最长重排回文路径，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF741D
 // 测试链接 : https://codeforces.com/problemset/problem/741/D
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_LongestRearrangePalindrome1 {
+public class Code06_LongestRearrangePalindrome1 {
 
 	public static int MAXN = 500001;
 	// 字符种类最多22种
diff --git a/src/class163/Code03_LongestRearrangePalindrome2.java b/src/class163/Code06_LongestRearrangePalindrome2.java
similarity index 100%
rename from src/class163/Code03_LongestRearrangePalindrome2.java
rename to src/class163/Code06_LongestRearrangePalindrome2.java

From 0c90e3df8b0262c3e04520050af9eb1318cab0b3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Mar 2025 21:13:08 +0800
Subject: [PATCH 0575/1712] modify code

---
 src/class163/Code03_BloodCousins1.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/class163/Code03_BloodCousins1.java b/src/class163/Code03_BloodCousins1.java
index 4a2f713d4..7855e1cc7 100644
--- a/src/class163/Code03_BloodCousins1.java
+++ b/src/class163/Code03_BloodCousins1.java
@@ -136,6 +136,8 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		for (int i = 1; i <= n; i++) {
+			// 因为是森林结构，可能有多棵子树彼此是不联通的
+			// 所以对每一棵子树进行重链剖分、生成倍增表
 			if (root[i]) {
 				dfs1(i, 0);
 			}
@@ -153,6 +155,10 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		for (int i = 1; i <= n; i++) {
+			// 因为是森林结构，可能有多棵子树彼此是不联通的
+			// 所以认为每一棵树的头都是轻儿子
+			// 这样每棵子树运行完后都会消除影响
+			// 不会影响下一棵子树的答案
 			if (root[i]) {
 				dfs2(i, 0);
 			}

From abf2c1b2780115d6faa62e3c677f6e3aebaf5d68 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 17 Mar 2025 21:19:11 +0800
Subject: [PATCH 0576/1712] modify code

---
 src/class163/Code03_BloodCousins2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class163/Code03_BloodCousins2.java b/src/class163/Code03_BloodCousins2.java
index 50bc6c949..4c2a955f6 100644
--- a/src/class163/Code03_BloodCousins2.java
+++ b/src/class163/Code03_BloodCousins2.java
@@ -29,7 +29,7 @@
 //int siz[MAXN];
 //int dep[MAXN];
 //int son[MAXN];
-//int stjump[MAXN][20];
+//int stjump[MAXN][MAXH];
 //
 //int nodeCnt[MAXN];
 //int ans[MAXN];

From acce1a69ceab4c6ba786a5a610fd11bd9e02efa7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Mar 2025 17:52:33 +0800
Subject: [PATCH 0577/1712] modify code

---
 .../{Code03_BloodCousins1.java => Code05_BloodCousins1.java}    | 2 +-
 .../{Code03_BloodCousins2.java => Code05_BloodCousins2.java}    | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class163/{Code03_BloodCousins1.java => Code05_BloodCousins1.java} (99%)
 rename src/class163/{Code03_BloodCousins2.java => Code05_BloodCousins2.java} (100%)

diff --git a/src/class163/Code03_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
similarity index 99%
rename from src/class163/Code03_BloodCousins1.java
rename to src/class163/Code05_BloodCousins1.java
index 7855e1cc7..20b327f7e 100644
--- a/src/class163/Code03_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_BloodCousins1 {
+public class Code05_BloodCousins1 {
 
 	public static int MAXN = 100001;
 	public static int MAXH = 20;
diff --git a/src/class163/Code03_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
similarity index 100%
rename from src/class163/Code03_BloodCousins2.java
rename to src/class163/Code05_BloodCousins2.java

From 906790132fa3fe346689e359857e8a9c830eb7c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Mar 2025 19:52:13 +0800
Subject: [PATCH 0578/1712] modify code

---
 src/class163/Code02_ColorBanlance1.java              |  4 ++--
 src/class163/Code02_ColorBanlance2.java              |  4 ++--
 src/class163/Code02_ColorBanlance3.java              |  4 ++--
 src/class163/Code05_BloodCousins1.java               | 10 +++++-----
 src/class163/Code05_BloodCousins2.java               | 10 +++++-----
 src/class163/Code06_LongestRearrangePalindrome1.java |  6 +++---
 src/class163/Code06_LongestRearrangePalindrome2.java |  6 +++---
 7 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index e36462f02..89ab27999 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -24,8 +24,8 @@ public class Code02_ColorBanlance1 {
 
 	// 链式前向星
 	public static int[] head = new int[MAXN];
-	public static int[] next = new int[MAXN << 1];
-	public static int[] to = new int[MAXN << 1];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
 	public static int cnt = 0;
 
 	// 树链剖分
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index 97b3fb697..39f31ed9a 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -17,8 +17,8 @@ public class Code02_ColorBanlance2 {
 	public static int n;
 	public static int[] arr = new int[MAXN];
 	public static int[] head = new int[MAXN];
-	public static int[] next = new int[MAXN << 1];
-	public static int[] to = new int[MAXN << 1];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
 	public static int cnt = 0;
 	public static int[] siz = new int[MAXN];
 	public static int[] son = new int[MAXN];
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
index 93a33d845..6811ea1a8 100644
--- a/src/class163/Code02_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -13,8 +13,8 @@
 //int n;
 //int arr[MAXN];
 //int head[MAXN];
-//int nxt[MAXN << 1];
-//int to[MAXN << 1];
+//int nxt[MAXN];
+//int to[MAXN];
 //int cnt = 0;
 //int siz[MAXN];
 //int son[MAXN];
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 20b327f7e..936be844b 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -21,14 +21,14 @@ public class Code05_BloodCousins1 {
 	public static boolean[] root = new boolean[MAXN];
 
 	public static int[] headg = new int[MAXN];
-	public static int[] nextg = new int[MAXN << 1];
-	public static int[] tog = new int[MAXN << 1];
+	public static int[] nextg = new int[MAXN];
+	public static int[] tog = new int[MAXN];
 	public static int cntg;
 
 	public static int[] headq = new int[MAXN];
-	public static int[] nextq = new int[MAXN << 1];
-	public static int[] idxq = new int[MAXN << 1];
-	public static int[] kthq = new int[MAXN << 1];
+	public static int[] nextq = new int[MAXN];
+	public static int[] idxq = new int[MAXN];
+	public static int[] kthq = new int[MAXN];
 	public static int cntq;
 
 	public static int[] siz = new int[MAXN];
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index 4c2a955f6..f8f4b6489 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -16,14 +16,14 @@
 //
 //bool root[MAXN];
 //int headg[MAXN];
-//int nextg[MAXN << 1];
-//int tog[MAXN << 1];
+//int nextg[MAXN];
+//int tog[MAXN];
 //int cntg;
 //
 //int headq[MAXN];
-//int nextq[MAXN << 1];
-//int idxq[MAXN << 1];
-//int kthq[MAXN << 1];
+//int nextq[MAXN];
+//int idxq[MAXN];
+//int kthq[MAXN];
 //int cntq;
 //
 //int siz[MAXN];
diff --git a/src/class163/Code06_LongestRearrangePalindrome1.java b/src/class163/Code06_LongestRearrangePalindrome1.java
index 984e53f0f..885bc82a3 100644
--- a/src/class163/Code06_LongestRearrangePalindrome1.java
+++ b/src/class163/Code06_LongestRearrangePalindrome1.java
@@ -19,9 +19,9 @@ public class Code06_LongestRearrangePalindrome1 {
 
 	// 链式前向星
 	public static int[] head = new int[MAXN];
-	public static int[] next = new int[MAXN << 1];
-	public static int[] to = new int[MAXN << 1];
-	public static int[] weight = new int[MAXN << 1];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
+	public static int[] weight = new int[MAXN];
 	public static int cnt = 0;
 
 	// 树链剖分
diff --git a/src/class163/Code06_LongestRearrangePalindrome2.java b/src/class163/Code06_LongestRearrangePalindrome2.java
index f9c34e2c8..aa9cdb6a7 100644
--- a/src/class163/Code06_LongestRearrangePalindrome2.java
+++ b/src/class163/Code06_LongestRearrangePalindrome2.java
@@ -14,9 +14,9 @@
 //const int MAXV = 22;
 //int n;
 //int head[MAXN];
-//int nxt[MAXN << 1];
-//int to[MAXN << 1];
-//int weight[MAXN << 1];
+//int nxt[MAXN];
+//int to[MAXN];
+//int weight[MAXN];
 //int cnt = 0;
 //int siz[MAXN];
 //int dep[MAXN];

From 2e5632161b5f1a229719fb31adcf11b97e00789b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Mar 2025 22:04:51 +0800
Subject: [PATCH 0579/1712] modify code

---
 src/class163/Code02_ColorBanlance2.java |  39 ++++---
 src/class163/Code03_LomsatGelral1.java  | 146 ++++++++++++++++++++++++
 src/class163/Code03_LomsatGelral2.java  | 132 +++++++++++++++++++++
 3 files changed, 300 insertions(+), 17 deletions(-)
 create mode 100644 src/class163/Code03_LomsatGelral1.java
 create mode 100644 src/class163/Code03_LomsatGelral2.java

diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index 39f31ed9a..2f6fc27be 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -133,28 +133,17 @@ public static void dfs1() {
 		}
 	}
 
+	// 迭代版的dfs2，用edge2变量标记一个节点的不同阶段
+	// edge2 == -1，表示第一次来到当前节点，接下来依次处理轻儿子的子树
+	// edge2 > 0，表示正在依次处理轻儿子的子树
+	// edge2 == 0，表示处理完了所有轻儿子的子树，接下来处理重儿子的子树
+	// edge2 == -2，表示处理完了重儿子的子树，轮到启发式合并了
 	public static void dfs2() {
 		size2 = 0;
 		push2(1, -1, 1);
 		while (size2 > 0) {
 			pop2();
-			if (edge2 == -2) {
-				colorCnt[arr[cur2]]++;
-				cntCnt[colorCnt[arr[cur2]] - 1]--;
-				cntCnt[colorCnt[arr[cur2]]]++;
-				for (int e = head[cur2], v; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != son[cur2]) {
-						effect(v);
-					}
-				}
-				if (colorCnt[arr[cur2]] * cntCnt[colorCnt[arr[cur2]]] == siz[cur2]) {
-					ans++;
-				}
-				if (keep2 == 0) {
-					cancle(cur2);
-				}
-			} else {
+			if (edge2 != -2) {
 				if (edge2 == -1) {
 					edge2 = head[cur2];
 				} else {
@@ -171,6 +160,22 @@ public static void dfs2() {
 						push2(son[cur2], -1, 1);
 					}
 				}
+			} else {
+				colorCnt[arr[cur2]]++;
+				cntCnt[colorCnt[arr[cur2]] - 1]--;
+				cntCnt[colorCnt[arr[cur2]]]++;
+				for (int e = head[cur2], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != son[cur2]) {
+						effect(v);
+					}
+				}
+				if (colorCnt[arr[cur2]] * cntCnt[colorCnt[arr[cur2]]] == siz[cur2]) {
+					ans++;
+				}
+				if (keep2 == 0) {
+					cancle(cur2);
+				}
 			}
 		}
 	}
diff --git a/src/class163/Code03_LomsatGelral1.java b/src/class163/Code03_LomsatGelral1.java
new file mode 100644
index 000000000..f93d565d4
--- /dev/null
+++ b/src/class163/Code03_LomsatGelral1.java
@@ -0,0 +1,146 @@
+package class163;
+
+// 主导颜色累加和，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF600E
+// 测试链接 : https://codeforces.com/problemset/problem/600/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code03_LomsatGelral1 {
+
+	public static int MAXN = 100001;
+	public static int n;
+	public static int[] color = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+
+	public static int[] colorCnt = new int[MAXN];
+	public static int[] maxCnt = new int[MAXN];
+	public static long[] ans = new long[MAXN];
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void effect(int u, int h) {
+		colorCnt[color[u]]++;
+		if (colorCnt[color[u]] == maxCnt[h]) {
+			ans[h] += color[u];
+		} else if (colorCnt[color[u]] > maxCnt[h]) {
+			maxCnt[h] = colorCnt[color[u]];
+			ans[h] = color[u];
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				effect(v, h);
+			}
+		}
+	}
+
+	public static void cancle(int u) {
+		colorCnt[color[u]] = 0;
+		maxCnt[u] = 0;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				cancle(v);
+			}
+		}
+	}
+
+	public static void dfs2(int u, int keep) {
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, 0);
+			}
+		}
+		if (son[u] != 0) {
+			dfs2(son[u], 1);
+		}
+		maxCnt[u] = maxCnt[son[u]];
+		ans[u] = ans[son[u]];
+		colorCnt[color[u]]++;
+		if (colorCnt[color[u]] == maxCnt[u]) {
+			ans[u] += color[u];
+		} else if (colorCnt[color[u]] > maxCnt[u]) {
+			maxCnt[u] = colorCnt[color[u]];
+			ans[u] = color[u];
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				effect(v, u);
+			}
+		}
+		if (keep == 0) {
+			cancle(u);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			color[i] = (int) in.nval;
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs1(1, 0);
+		dfs2(1, 1);
+		for (int i = 1; i <= n; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class163/Code03_LomsatGelral2.java b/src/class163/Code03_LomsatGelral2.java
new file mode 100644
index 000000000..c89d90ebc
--- /dev/null
+++ b/src/class163/Code03_LomsatGelral2.java
@@ -0,0 +1,132 @@
+package class163;
+
+// 主导颜色累加和，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF600E
+// 测试链接 : https://codeforces.com/problemset/problem/600/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n;
+//int color[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt = 0;
+//
+//int fa[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//
+//int colorCnt[MAXN];
+//int maxCnt[MAXN];
+//long long ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void effect(int u, int h) {
+//    colorCnt[color[u]]++;
+//    if (colorCnt[color[u]] == maxCnt[h]) {
+//        ans[h] += color[u];
+//    } else if (colorCnt[color[u]] > maxCnt[h]) {
+//        maxCnt[h] = colorCnt[color[u]];
+//        ans[h] = color[u];
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            effect(v, h);
+//        }
+//    }
+//}
+//
+//void cancle(int u) {
+//    colorCnt[color[u]] = 0;
+//    maxCnt[u] = 0;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            cancle(v);
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int keep) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, 0);
+//        }
+//    }
+//    if (son[u] != 0) {
+//        dfs2(son[u], 1);
+//    }
+//    maxCnt[u] = maxCnt[son[u]];
+//    ans[u] = ans[son[u]];
+//    colorCnt[color[u]]++;
+//    if (colorCnt[color[u]] == maxCnt[u]) {
+//        ans[u] += color[u];
+//    } else if (colorCnt[color[u]] > maxCnt[u]) {
+//        maxCnt[u] = colorCnt[color[u]];
+//        ans[u] = color[u];
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            effect(v, u);
+//        }
+//    }
+//    if (keep == 0) {
+//        cancle(u);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> color[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << " ";
+//    }
+//    cout << "\n";
+//    return 0;
+//}
\ No newline at end of file

From 0d1732bae9693c54984d1121b600f8e8039a0d44 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Mar 2025 22:15:58 +0800
Subject: [PATCH 0580/1712] modify code

---
 src/class163/Code05_BloodCousins1.java | 6 +++---
 src/class163/Code05_BloodCousins2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 936be844b..352316679 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -27,7 +27,7 @@ public class Code05_BloodCousins1 {
 
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN];
-	public static int[] idxq = new int[MAXN];
+	public static int[] ansiq = new int[MAXN];
 	public static int[] kthq = new int[MAXN];
 	public static int cntq;
 
@@ -47,7 +47,7 @@ public static void addEdge(int u, int v) {
 
 	public static void addQuestion(int u, int idx, int kth) {
 		nextq[++cntq] = headq[u];
-		idxq[cntq] = idx;
+		ansiq[cntq] = idx;
 		kthq[cntq] = kth;
 		headq[u] = cntq;
 	}
@@ -113,7 +113,7 @@ public static void dfs2(int u, int keep) {
 			}
 		}
 		for (int i = headq[u]; i > 0; i = nextq[i]) {
-			ans[idxq[i]] = nodeCnt[dep[u] + kthq[i]];
+			ans[ansiq[i]] = nodeCnt[dep[u] + kthq[i]];
 		}
 		if (keep == 0) {
 			cancle(u);
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index f8f4b6489..4e1c83afb 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -22,7 +22,7 @@
 //
 //int headq[MAXN];
 //int nextq[MAXN];
-//int idxq[MAXN];
+//int ansiq[MAXN];
 //int kthq[MAXN];
 //int cntq;
 //
@@ -42,7 +42,7 @@
 //
 //void addQuestion(int u, int idx, int kth) {
 //    nextq[++cntq] = headq[u];
-//    idxq[cntq] = idx;
+//    ansiq[cntq] = idx;
 //    kthq[cntq] = kth;
 //    headq[u] = cntq;
 //}
@@ -108,7 +108,7 @@
 //        }
 //    }
 //    for (int i = headq[u]; i > 0; i = nextq[i]) {
-//    	ans[idxq[i]] = nodeCnt[dep[u] + kthq[i]];
+//    	ans[ansiq[i]] = nodeCnt[dep[u] + kthq[i]];
 //    }
 //    if (keep == 0) {
 //        cancle(u);

From 607afd4ad943e406dedff403b050f3abe78eb8c8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Mar 2025 23:14:48 +0800
Subject: [PATCH 0581/1712] modify code

---
 src/class163/Code04_DifferntName1.java | 227 +++++++++++++++++++++++++
 src/class163/Code04_DifferntName2.java | 164 ++++++++++++++++++
 src/class163/Code05_BloodCousins1.java |  10 +-
 src/class163/Code05_BloodCousins2.java |  10 +-
 4 files changed, 401 insertions(+), 10 deletions(-)
 create mode 100644 src/class163/Code04_DifferntName1.java
 create mode 100644 src/class163/Code04_DifferntName2.java

diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
new file mode 100644
index 000000000..5e3b2d8b5
--- /dev/null
+++ b/src/class163/Code04_DifferntName1.java
@@ -0,0 +1,227 @@
+package class163;
+
+// 不同名字的数量，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF246E
+// 测试链接 : https://codeforces.com/problemset/problem/246/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.FileReader;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.InputStreamReader;
+import java.io.OutputStream;
+import java.io.PrintWriter;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.HashSet;
+import java.util.StringTokenizer;
+
+public class Code04_DifferntName1 {
+
+	public static int MAXN = 100001;
+	public static int n, m;
+	public static boolean[] root = new boolean[MAXN];
+	public static int[] arr = new int[MAXN];
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN];
+	public static int[] tog = new int[MAXN];
+	public static int cntg;
+
+	public static int[] headq = new int[MAXN];
+	public static int[] nextq = new int[MAXN];
+	public static int[] ansiq = new int[MAXN];
+	public static int[] kq = new int[MAXN];
+	public static int cntq;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] son = new int[MAXN];
+
+	public static HashMap<String, Integer> nameToId = new HashMap<>();
+	public static ArrayList<HashSet<Integer>> depSet = new ArrayList<>();
+	public static int[] ans = new int[MAXN];
+
+	public static int nameId(String name) {
+		if (nameToId.containsKey(name)) {
+			return nameToId.get(name);
+		}
+		nameToId.put(name, nameToId.size() + 1);
+		return nameToId.size();
+	}
+
+	public static void addId(int deep, int id) {
+		depSet.get(deep).add(id);
+	}
+
+	public static void removeId(int deep, int id) {
+		depSet.get(deep).remove(id);
+	}
+
+	public static int sizeOfId(int deep) {
+		if (deep > n) {
+			return 0;
+		}
+		return depSet.get(deep).size();
+	}
+
+	public static void addEdge(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addQuestion(int u, int ansi, int k) {
+		nextq[++cntq] = headq[u];
+		ansiq[cntq] = ansi;
+		kq[cntq] = k;
+		headq[u] = cntq;
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		siz[u] = 1;
+		dep[u] = dep[f] + 1;
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			dfs1(tog[e], u);
+		}
+		for (int e = headg[u], v; e > 0; e = nextg[e]) {
+			v = tog[e];
+			siz[u] += siz[v];
+			if (son[u] == 0 || siz[son[u]] < siz[v]) {
+				son[u] = v;
+			}
+		}
+	}
+
+	public static void effect(int u) {
+		addId(dep[u], arr[u]);
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			effect(tog[e]);
+		}
+	}
+
+	public static void cancle(int u) {
+		removeId(dep[u], arr[u]);
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			cancle(tog[e]);
+		}
+	}
+
+	public static void dfs2(int u, int keep) {
+		for (int e = headg[u], v; e > 0; e = nextg[e]) {
+			v = tog[e];
+			if (v != son[u]) {
+				dfs2(v, 0);
+			}
+		}
+		if (son[u] != 0) {
+			dfs2(son[u], 1);
+		}
+		addId(dep[u], arr[u]);
+		for (int e = headg[u], v; e > 0; e = nextg[e]) {
+			v = tog[e];
+			if (v != son[u]) {
+				effect(v);
+			}
+		}
+		for (int i = headq[u]; i > 0; i = nextq[i]) {
+			ans[ansiq[i]] = sizeOfId(dep[u] + kq[i]);
+		}
+		if (keep == 0) {
+			cancle(u);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		Kattio io = new Kattio();
+		n = io.nextInt();
+		String name;
+		int father;
+		for (int i = 1; i <= n; i++) {
+			name = io.next();
+			father = io.nextInt();
+			arr[i] = nameId(name);
+			if (father == 0) {
+				root[i] = true;
+			} else {
+				addEdge(father, i);
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			// 因为是森林结构，可能有多棵子树彼此是不联通的
+			// 所以对每一棵子树进行重链剖分
+			if (root[i]) {
+				dfs1(i, 0);
+			}
+		}
+		for (int i = 0; i <= n; i++) {
+			depSet.add(new HashSet<>());
+		}
+		m = io.nextInt();
+		for (int i = 1, node, k; i <= m; i++) {
+			node = io.nextInt();
+			k = io.nextInt();
+			addQuestion(node, i, k);
+		}
+		for (int i = 1; i <= n; i++) {
+			// 因为是森林结构，可能有多棵子树彼此是不联通的
+			// 所以认为每一棵树的头都是轻儿子
+			// 这样每棵子树运行完后都会消除影响
+			// 不会影响下一棵子树的答案
+			if (root[i]) {
+				dfs2(i, 0);
+			}
+		}
+		for (int i = 1; i <= m; i++) {
+			io.println(ans[i]);
+		}
+		io.flush();
+		io.close();
+	}
+
+	// 读写工具类
+	public static class Kattio extends PrintWriter {
+		private BufferedReader r;
+		private StringTokenizer st;
+
+		public Kattio() {
+			this(System.in, System.out);
+		}
+
+		public Kattio(InputStream i, OutputStream o) {
+			super(o);
+			r = new BufferedReader(new InputStreamReader(i));
+		}
+
+		public Kattio(String intput, String output) throws IOException {
+			super(output);
+			r = new BufferedReader(new FileReader(intput));
+		}
+
+		public String next() {
+			try {
+				while (st == null || !st.hasMoreTokens())
+					st = new StringTokenizer(r.readLine());
+				return st.nextToken();
+			} catch (Exception e) {
+			}
+			return null;
+		}
+
+		public int nextInt() {
+			return Integer.parseInt(next());
+		}
+
+		public double nextDouble() {
+			return Double.parseDouble(next());
+		}
+
+		public long nextLong() {
+			return Long.parseLong(next());
+		}
+	}
+
+}
diff --git a/src/class163/Code04_DifferntName2.java b/src/class163/Code04_DifferntName2.java
new file mode 100644
index 000000000..4b7ad2960
--- /dev/null
+++ b/src/class163/Code04_DifferntName2.java
@@ -0,0 +1,164 @@
+package class163;
+
+// 不同名字的数量，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF246E
+// 测试链接 : https://codeforces.com/problemset/problem/246/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//bool root[MAXN];
+//int arr[MAXN];
+//
+//int headg[MAXN];
+//int nextg[MAXN];
+//int tog[MAXN];
+//int cntg;
+//
+//int headq[MAXN];
+//int nextq[MAXN];
+//int ansiq[MAXN];
+//int kq[MAXN];
+//int cntq;
+//
+//int fa[MAXN];
+//int siz[MAXN];
+//int dep[MAXN];
+//int son[MAXN];
+//unordered_map<string, int> nameToId;
+//vector<unordered_set<int>> depSet;
+//int ans[MAXN];
+//
+//int nameId(const string &name) {
+//    if (nameToId.find(name) != nameToId.end()) {
+//        return nameToId[name];
+//    }
+//    int newId = nameToId.size() + 1;
+//    nameToId[name] = newId;
+//    return newId;
+//}
+//
+//void addId(int deep, int id) {
+//    depSet[deep].insert(id);
+//}
+//
+//void removeId(int deep, int id) {
+//    depSet[deep].erase(id);
+//}
+//
+//int sizeOfId(int deep) {
+//    if (deep > n) {
+//        return 0;
+//    }
+//    return (int)depSet[deep].size();
+//}
+//
+//void addEdge(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addQuestion(int u, int ansi, int k) {
+//    nextq[++cntq] = headq[u];
+//    ansiq[cntq] = ansi;
+//    kq[cntq] = k;
+//    headq[u] = cntq;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    siz[u] = 1;
+//    dep[u] = dep[f] + 1;
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        dfs1(tog[e], u);
+//    }
+//    for (int e = headg[u], v; e > 0; e = nextg[e]) {
+//        v = tog[e];
+//        siz[u] += siz[v];
+//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//            son[u] = v;
+//        }
+//    }
+//}
+//
+//void effect(int u) {
+//    addId(dep[u], arr[u]);
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        effect(tog[e]);
+//    }
+//}
+//
+//void cancle(int u) {
+//    removeId(dep[u], arr[u]);
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        cancle(tog[e]);
+//    }
+//}
+//
+//void dfs2(int u, int keep) {
+//    for (int e = headg[u], v; e > 0; e = nextg[e]) {
+//        v = tog[e];
+//        if (v != son[u]) {
+//            dfs2(v, 0);
+//        }
+//    }
+//    if (son[u] != 0) {
+//        dfs2(son[u], 1);
+//    }
+//    addId(dep[u], arr[u]);
+//    for (int e = headg[u], v; e > 0; e = nextg[e]) {
+//        v = tog[e];
+//        if (v != son[u]) {
+//            effect(v);
+//        }
+//    }
+//    for (int i = headq[u]; i > 0; i = nextq[i]) {
+//    	ans[ansiq[i]] = sizeOfId(dep[u] + kq[i]);
+//    }
+//    if (keep == 0) {
+//        cancle(u);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    string name;
+//    int father;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> name >> father;
+//        arr[i] = nameId(name);
+//        if (father == 0) {
+//        	root[i] = true;
+//        } else {
+//            addEdge(father, i);
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        if (root[i]) {
+//            dfs1(i, 0);
+//        }
+//    }
+//    depSet.resize(n + 1);
+//    cin >> m;
+//    for (int i = 1, node, k; i <= m; i++) {
+//        cin >> node >> k;
+//        addQuestion(node, i, k);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        if (root[i]) {
+//            dfs2(i, 0);
+//        }
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 352316679..312836d9d 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -28,7 +28,7 @@ public class Code05_BloodCousins1 {
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN];
 	public static int[] ansiq = new int[MAXN];
-	public static int[] kthq = new int[MAXN];
+	public static int[] kq = new int[MAXN];
 	public static int cntq;
 
 	public static int[] siz = new int[MAXN];
@@ -45,10 +45,10 @@ public static void addEdge(int u, int v) {
 		headg[u] = cntg;
 	}
 
-	public static void addQuestion(int u, int idx, int kth) {
+	public static void addQuestion(int u, int i, int k) {
 		nextq[++cntq] = headq[u];
-		ansiq[cntq] = idx;
-		kthq[cntq] = kth;
+		ansiq[cntq] = i;
+		kq[cntq] = k;
 		headq[u] = cntq;
 	}
 
@@ -113,7 +113,7 @@ public static void dfs2(int u, int keep) {
 			}
 		}
 		for (int i = headq[u]; i > 0; i = nextq[i]) {
-			ans[ansiq[i]] = nodeCnt[dep[u] + kthq[i]];
+			ans[ansiq[i]] = nodeCnt[dep[u] + kq[i]];
 		}
 		if (keep == 0) {
 			cancle(u);
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index 4e1c83afb..e834487f0 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -23,7 +23,7 @@
 //int headq[MAXN];
 //int nextq[MAXN];
 //int ansiq[MAXN];
-//int kthq[MAXN];
+//int kq[MAXN];
 //int cntq;
 //
 //int siz[MAXN];
@@ -40,10 +40,10 @@
 //    headg[u] = cntg;
 //}
 //
-//void addQuestion(int u, int idx, int kth) {
+//void addQuestion(int u, int i, int k) {
 //    nextq[++cntq] = headq[u];
-//    ansiq[cntq] = idx;
-//    kthq[cntq] = kth;
+//    ansiq[cntq] = i;
+//    kq[cntq] = k;
 //    headq[u] = cntq;
 //}
 //
@@ -108,7 +108,7 @@
 //        }
 //    }
 //    for (int i = headq[u]; i > 0; i = nextq[i]) {
-//    	ans[ansiq[i]] = nodeCnt[dep[u] + kthq[i]];
+//    	ans[ansiq[i]] = nodeCnt[dep[u] + kq[i]];
 //    }
 //    if (keep == 0) {
 //        cancle(u);

From 1d4b949c40a57c6adf02d2b40c788f50e441cefc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Mar 2025 23:16:12 +0800
Subject: [PATCH 0582/1712] modify code

---
 src/class163/Code04_DifferntName1.java | 2 +-
 src/class163/Code04_DifferntName2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
index 5e3b2d8b5..6a820f3b3 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -1,6 +1,6 @@
 package class163;
 
-// 不同名字的数量，java版
+// 不同名字数量，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF246E
 // 测试链接 : https://codeforces.com/problemset/problem/246/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class163/Code04_DifferntName2.java b/src/class163/Code04_DifferntName2.java
index 4b7ad2960..2944a19c1 100644
--- a/src/class163/Code04_DifferntName2.java
+++ b/src/class163/Code04_DifferntName2.java
@@ -1,6 +1,6 @@
 package class163;
 
-// 不同名字的数量，C++版
+// 不同名字数量，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/CF246E
 // 测试链接 : https://codeforces.com/problemset/problem/246/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From c8ae85cbf45a2e1a1bbbf7afcbe825678044d13f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 18 Mar 2025 23:28:15 +0800
Subject: [PATCH 0583/1712] modify code

---
 ...arrangePalindrome1.java => Code06_RearrangePalindrome1.java} | 2 +-
 ...arrangePalindrome2.java => Code06_RearrangePalindrome2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class163/{Code06_LongestRearrangePalindrome1.java => Code06_RearrangePalindrome1.java} (99%)
 rename src/class163/{Code06_LongestRearrangePalindrome2.java => Code06_RearrangePalindrome2.java} (100%)

diff --git a/src/class163/Code06_LongestRearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
similarity index 99%
rename from src/class163/Code06_LongestRearrangePalindrome1.java
rename to src/class163/Code06_RearrangePalindrome1.java
index 885bc82a3..984140154 100644
--- a/src/class163/Code06_LongestRearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code06_LongestRearrangePalindrome1 {
+public class Code06_RearrangePalindrome1 {
 
 	public static int MAXN = 500001;
 	// 字符种类最多22种
diff --git a/src/class163/Code06_LongestRearrangePalindrome2.java b/src/class163/Code06_RearrangePalindrome2.java
similarity index 100%
rename from src/class163/Code06_LongestRearrangePalindrome2.java
rename to src/class163/Code06_RearrangePalindrome2.java

From ea29d330ef37d04209d901ebd7d3948ac7760dc5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Mar 2025 17:40:03 +0800
Subject: [PATCH 0584/1712] modify code

---
 .../{Code04_DifferntName1.java => Code02_DifferntName1.java}  | 2 +-
 .../{Code04_DifferntName2.java => Code02_DifferntName2.java}  | 0
 ...{Code02_ColorBanlance1.java => Code03_ColorBanlance1.java} | 4 ++--
 ...{Code02_ColorBanlance2.java => Code03_ColorBanlance2.java} | 2 +-
 ...{Code02_ColorBanlance3.java => Code03_ColorBanlance3.java} | 0
 .../{Code03_LomsatGelral1.java => Code04_LomsatGelral1.java}  | 2 +-
 .../{Code03_LomsatGelral2.java => Code04_LomsatGelral2.java}  | 0
 7 files changed, 5 insertions(+), 5 deletions(-)
 rename src/class163/{Code04_DifferntName1.java => Code02_DifferntName1.java} (99%)
 rename src/class163/{Code04_DifferntName2.java => Code02_DifferntName2.java} (100%)
 rename src/class163/{Code02_ColorBanlance1.java => Code03_ColorBanlance1.java} (96%)
 rename src/class163/{Code02_ColorBanlance2.java => Code03_ColorBanlance2.java} (99%)
 rename src/class163/{Code02_ColorBanlance3.java => Code03_ColorBanlance3.java} (100%)
 rename src/class163/{Code03_LomsatGelral1.java => Code04_LomsatGelral1.java} (98%)
 rename src/class163/{Code03_LomsatGelral2.java => Code04_LomsatGelral2.java} (100%)

diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code02_DifferntName1.java
similarity index 99%
rename from src/class163/Code04_DifferntName1.java
rename to src/class163/Code02_DifferntName1.java
index 6a820f3b3..ae0ee1356 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code02_DifferntName1.java
@@ -17,7 +17,7 @@
 import java.util.HashSet;
 import java.util.StringTokenizer;
 
-public class Code04_DifferntName1 {
+public class Code02_DifferntName1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class163/Code04_DifferntName2.java b/src/class163/Code02_DifferntName2.java
similarity index 100%
rename from src/class163/Code04_DifferntName2.java
rename to src/class163/Code02_DifferntName2.java
diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code03_ColorBanlance1.java
similarity index 96%
rename from src/class163/Code02_ColorBanlance1.java
rename to src/class163/Code03_ColorBanlance1.java
index 89ab27999..86f2458fd 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code03_ColorBanlance1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P9233
 // 提交以下的code，提交时请把类名改成"Main"
 // 因为树的深度太大，递归函数爆栈了，所以会有两个测试用例无法通过
-// 迭代版可以完全通过，就是本节课Code02_ColorBanlance2文件
+// 迭代版可以完全通过，就是本节课Code03_ColorBanlance2文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_ColorBanlance1 {
+public class Code03_ColorBanlance1 {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code03_ColorBanlance2.java
similarity index 99%
rename from src/class163/Code02_ColorBanlance2.java
rename to src/class163/Code03_ColorBanlance2.java
index 2f6fc27be..8eae184dd 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code03_ColorBanlance2.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_ColorBanlance2 {
+public class Code03_ColorBanlance2 {
 
 	public static int MAXN = 200001;
 	public static int n;
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code03_ColorBanlance3.java
similarity index 100%
rename from src/class163/Code02_ColorBanlance3.java
rename to src/class163/Code03_ColorBanlance3.java
diff --git a/src/class163/Code03_LomsatGelral1.java b/src/class163/Code04_LomsatGelral1.java
similarity index 98%
rename from src/class163/Code03_LomsatGelral1.java
rename to src/class163/Code04_LomsatGelral1.java
index f93d565d4..005dc53c9 100644
--- a/src/class163/Code03_LomsatGelral1.java
+++ b/src/class163/Code04_LomsatGelral1.java
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_LomsatGelral1 {
+public class Code04_LomsatGelral1 {
 
 	public static int MAXN = 100001;
 	public static int n;
diff --git a/src/class163/Code03_LomsatGelral2.java b/src/class163/Code04_LomsatGelral2.java
similarity index 100%
rename from src/class163/Code03_LomsatGelral2.java
rename to src/class163/Code04_LomsatGelral2.java

From b0fa4d32920d12ebf7d5b602ae62d8d6c75be308 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Mar 2025 20:11:14 +0800
Subject: [PATCH 0585/1712] modify code

---
 src/class163/Code07_Forest1.java | 344 +++++++++++++++++++++++++++++++
 src/class163/Code07_Forest2.java | 199 ++++++++++++++++++
 2 files changed, 543 insertions(+)
 create mode 100644 src/class163/Code07_Forest1.java
 create mode 100644 src/class163/Code07_Forest2.java

diff --git a/src/class163/Code07_Forest1.java b/src/class163/Code07_Forest1.java
new file mode 100644
index 000000000..f244a79be
--- /dev/null
+++ b/src/class163/Code07_Forest1.java
@@ -0,0 +1,344 @@
+package class163;
+
+// 森林，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3302
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code07_Forest1 {
+
+	public static int MAXN = 80001;
+	public static int MAXT = MAXN * 110;
+	public static int MAXH = 20;
+	public static int testcase;
+	public static int n, m, t;
+
+	public static int[] arr = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
+	public static int diff;
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	public static int[] root = new int[MAXN];
+	public static int[] left = new int[MAXT];
+	public static int[] right = new int[MAXT];
+	public static int[] siz = new int[MAXT];
+	public static int cntt = 0;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] treeHead = new int[MAXN];
+	public static int[] headSiz = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXH];
+
+	public static int kth(int num) {
+		int left = 1, right = diff, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int insert(int jobi, int l, int r, int i) {
+		int rt = ++cntt;
+		left[rt] = left[i];
+		right[rt] = right[i];
+		siz[rt] = siz[i] + 1;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				left[rt] = insert(jobi, l, mid, left[rt]);
+			} else {
+				right[rt] = insert(jobi, mid + 1, r, right[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static int query(int jobk, int l, int r, int u, int v, int lca, int lcafa) {
+		if (l == r) {
+			return l;
+		}
+		int lsize = siz[left[u]] + siz[left[v]] - siz[left[lca]] - siz[left[lcafa]];
+		int mid = (l + r) / 2;
+		if (lsize >= jobk) {
+			return query(jobk, l, mid, left[u], left[v], left[lca], left[lcafa]);
+		} else {
+			return query(jobk - lsize, mid + 1, r, right[u], right[v], right[lca], right[lcafa]);
+		}
+	}
+
+	// 递归版，C++可以通过，java无法通过，递归会爆栈
+	public static void dfs1(int u, int fa, int treeh) {
+		root[u] = insert(arr[u], 1, diff, root[fa]);
+		dep[u] = dep[fa] + 1;
+		treeHead[u] = treeh;
+		headSiz[treeh]++;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != fa) {
+				dfs1(to[e], u, treeh);
+			}
+		}
+	}
+
+	// 迭代版，都可以通过
+	// 讲解118，详解了从递归版改迭代版
+	public static int[][] stack = new int[MAXN][4];
+
+	public static int stackSize, cur, father, treehead, edge;
+
+	public static void push(int cur, int father, int treehead, int edge) {
+		stack[stackSize][0] = cur;
+		stack[stackSize][1] = father;
+		stack[stackSize][2] = treehead;
+		stack[stackSize][3] = edge;
+		stackSize++;
+	}
+
+	public static void pop() {
+		--stackSize;
+		cur = stack[stackSize][0];
+		father = stack[stackSize][1];
+		treehead = stack[stackSize][2];
+		edge = stack[stackSize][3];
+	}
+
+	// dfs1的迭代版
+	public static void dfs2(int i, int fa, int treeh) {
+		stackSize = 0;
+		push(i, fa, treeh, -1);
+		while (stackSize > 0) {
+			pop();
+			if (edge == -1) {
+				root[cur] = insert(arr[cur], 1, diff, root[father]);
+				dep[cur] = dep[father] + 1;
+				treeHead[cur] = treehead;
+				headSiz[treehead]++;
+				stjump[cur][0] = father;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[cur][p] = stjump[stjump[cur][p - 1]][p - 1];
+				}
+				edge = head[cur];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(cur, father, treehead, edge);
+				if (to[edge] != father) {
+					push(to[edge], cur, treehead, -1);
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int queryKth(int x, int y, int k) {
+		int xylca = lca(x, y);
+		int lcafa = stjump[xylca][0];
+		int i = query(k, 1, diff, root[x], root[y], root[xylca], root[lcafa]);
+		return sorted[i];
+	}
+
+	public static void connect(int x, int y) {
+		addEdge(x, y);
+		addEdge(y, x);
+		int fx = treeHead[x];
+		int fy = treeHead[y];
+		if (headSiz[fx] >= headSiz[fy]) {
+			dfs2(y, x, fx); // 调用dfs1的迭代版
+		} else {
+			dfs2(x, y, fy); // 调用dfs1的迭代版
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		diff = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[diff] != sorted[i]) {
+				sorted[++diff] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		for (int i = 1; i <= n; i++) {
+			if (treeHead[i] == 0) {
+				dfs2(i, 0, i); // 调用dfs1的迭代版
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		testcase = in.nextInt();
+		n = in.nextInt();
+		m = in.nextInt();
+		t = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1, u, v; i <= m; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		prepare();
+		char op;
+		int x, y, k, lastAns = 0;
+		for (int i = 1; i <= t; i++) {
+			op = in.nextChar();
+			x = in.nextInt() ^ lastAns;
+			y = in.nextInt() ^ lastAns;
+			if (op == 'Q') {
+				k = in.nextInt() ^ lastAns;
+				lastAns = queryKth(x, y, k);
+				out.println(lastAns);
+			} else {
+				connect(x, y);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public double nextDouble() throws IOException {
+			double num = 0, div = 1;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != '.' && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			if (b == '.') {
+				b = readByte();
+				while (!isWhitespace(b) && b != -1) {
+					num += (b - '0') / (div *= 10);
+					b = readByte();
+				}
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class163/Code07_Forest2.java b/src/class163/Code07_Forest2.java
new file mode 100644
index 000000000..883e82276
--- /dev/null
+++ b/src/class163/Code07_Forest2.java
@@ -0,0 +1,199 @@
+package class163;
+
+// 森林，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3302
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 80001;
+//const int MAXT = MAXN * 110;
+//const int MAXH = 20;
+//int testcase;
+//int n, m, t;
+//
+//int arr[MAXN];
+//int sorted[MAXN];
+//int diff;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int siz[MAXT];
+//int cntt = 0;
+//
+//int dep[MAXN];
+//int treeHead[MAXN];
+//int headSiz[MAXN];
+//int stjump[MAXN][MAXH];
+//
+//int kth(int num) {
+//    int left = 1, right = diff, mid;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int insert(int jobi, int l, int r, int i) {
+//    int rt = ++cntt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    siz[rt] = siz[i] + 1;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//int query(int jobk, int l, int r, int u, int v, int lca_, int lcafa) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int lsize = siz[ls[u]] + siz[ls[v]] - siz[ls[lca_]] - siz[ls[lcafa]];
+//    int mid = (l + r) / 2;
+//    if (lsize >= jobk) {
+//        return query(jobk, l, mid, ls[u], ls[v], ls[lca_], ls[lcafa]);
+//    } else {
+//        return query(jobk - lsize, mid + 1, r, rs[u], rs[v], rs[lca_], rs[lcafa]);
+//    }
+//}
+//
+//void dfs(int u, int fa, int treeh) {
+//    root[u] = insert(arr[u], 1, diff, root[fa]);
+//    dep[u] = dep[fa] + 1;
+//    treeHead[u] = treeh;
+//    headSiz[treeh]++;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        if (to[e] != fa) {
+//            dfs(to[e], u, treeh);
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        int tmp = a;
+//        a = b;
+//        b = tmp;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int queryKth(int x, int y, int k) {
+//    int xylca = lca(x, y);
+//    int lcafa = stjump[xylca][0];
+//    int i = query(k, 1, diff, root[x], root[y], root[xylca], root[lcafa]);
+//    return sorted[i];
+//}
+//
+//void connect(int x, int y) {
+//    addEdge(x, y);
+//    addEdge(y, x);
+//    int fx = treeHead[x];
+//    int fy = treeHead[y];
+//    if (headSiz[fx] >= headSiz[fy]) {
+//        dfs(y, x, fx);
+//    } else {
+//        dfs(x, y, fy);
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    diff = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[diff] != sorted[i]) {
+//            sorted[++diff] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        if (treeHead[i] == 0) {
+//            dfs(i, 0, i);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> testcase >> n >> m >> t;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        int u, v;
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    prepare();
+//    char op;
+//    int x, y, k, lastAns = 0;
+//    for (int i = 1; i <= t; i++) {
+//        cin >> op;
+//        cin >> x;
+//        cin >> y;
+//        x ^= lastAns;
+//        y ^= lastAns;
+//        if (op == 'Q') {
+//            cin >> k;
+//            k ^= lastAns;
+//            lastAns = queryKth(x, y, k);
+//            cout << lastAns << "\n";
+//        } else {
+//            connect(x, y);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 6922b43af28d07859e19f4a161643980aaa81870 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Mar 2025 21:11:38 +0800
Subject: [PATCH 0586/1712] modify code

---
 src/class163/Code01_ColorOnTree1.java                    | 4 ++++
 src/class163/Code01_ColorOnTree2.java                    | 4 ++++
 ...03_ColorBanlance1.java => Code02_ColorBanlance1.java} | 9 +++++++--
 ...03_ColorBanlance2.java => Code02_ColorBanlance2.java} | 7 ++++++-
 ...03_ColorBanlance3.java => Code02_ColorBanlance3.java} | 5 +++++
 ...de04_LomsatGelral1.java => Code03_LomsatGelral1.java} | 8 +++++++-
 ...de04_LomsatGelral2.java => Code03_LomsatGelral2.java} | 6 ++++++
 ...de02_DifferntName1.java => Code04_DifferntName1.java} | 8 +++++++-
 ...de02_DifferntName2.java => Code04_DifferntName2.java} | 6 ++++++
 src/class163/Code05_BloodCousins1.java                   | 9 +++++++++
 src/class163/Code05_BloodCousins2.java                   | 9 +++++++++
 src/class163/Code06_RearrangePalindrome1.java            | 5 +++++
 src/class163/Code06_RearrangePalindrome2.java            | 5 +++++
 src/class163/Code07_Forest1.java                         | 9 +++++++++
 src/class163/Code07_Forest2.java                         | 9 +++++++++
 15 files changed, 98 insertions(+), 5 deletions(-)
 rename src/class163/{Code03_ColorBanlance1.java => Code02_ColorBanlance1.java} (86%)
 rename src/class163/{Code03_ColorBanlance2.java => Code02_ColorBanlance2.java} (92%)
 rename src/class163/{Code03_ColorBanlance3.java => Code02_ColorBanlance3.java} (86%)
 rename src/class163/{Code04_LomsatGelral1.java => Code03_LomsatGelral1.java} (85%)
 rename src/class163/{Code04_LomsatGelral2.java => Code03_LomsatGelral2.java} (85%)
 rename src/class163/{Code02_DifferntName1.java => Code04_DifferntName1.java} (91%)
 rename src/class163/{Code02_DifferntName2.java => Code04_DifferntName2.java} (89%)

diff --git a/src/class163/Code01_ColorOnTree1.java b/src/class163/Code01_ColorOnTree1.java
index d6c15b82c..5d679bbe6 100644
--- a/src/class163/Code01_ColorOnTree1.java
+++ b/src/class163/Code01_ColorOnTree1.java
@@ -1,6 +1,10 @@
 package class163;
 
 // 树上数颜色，java版
+// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
+// 每个节点给定一种颜色值，一共有m条查询，每条查询给定参数x
+// 每条查询打印x为头的子树上，一共有多少种不同的颜色
+// 1 <= n、m、颜色值 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/U41492
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class163/Code01_ColorOnTree2.java b/src/class163/Code01_ColorOnTree2.java
index 403daa8ea..ecc054b7d 100644
--- a/src/class163/Code01_ColorOnTree2.java
+++ b/src/class163/Code01_ColorOnTree2.java
@@ -1,6 +1,10 @@
 package class163;
 
 // 树上数颜色，C++版
+// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
+// 每个节点给定一种颜色值，一共有m条查询，每条查询给定参数x
+// 每条查询打印x为头的子树上，一共有多少种不同的颜色
+// 1 <= n、m、颜色值 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/U41492
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class163/Code03_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
similarity index 86%
rename from src/class163/Code03_ColorBanlance1.java
rename to src/class163/Code02_ColorBanlance1.java
index 86f2458fd..97ed83c32 100644
--- a/src/class163/Code03_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -1,10 +1,15 @@
 package class163;
 
 // 颜色平衡的子树，java实现递归版
+// 一共有n个节点，编号1~n，给定每个节点的颜色值和父亲节点编号
+// 输入保证所有节点一定组成一棵树，并且1号节点是树头
+// 如果一棵子树中，存在的每种颜色的节点个数都相同，这棵子树叫颜色平衡树
+// 打印整棵树中有多少个子树是颜色平衡树
+// 1 <= n、颜色值 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9233
 // 提交以下的code，提交时请把类名改成"Main"
 // 因为树的深度太大，递归函数爆栈了，所以会有两个测试用例无法通过
-// 迭代版可以完全通过，就是本节课Code03_ColorBanlance2文件
+// 迭代版可以完全通过，就是本节课Code02_ColorBanlance2文件
 
 import java.io.BufferedReader;
 import java.io.IOException;
@@ -13,7 +18,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_ColorBanlance1 {
+public class Code02_ColorBanlance1 {
 
 	public static int MAXN = 200001;
 
diff --git a/src/class163/Code03_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
similarity index 92%
rename from src/class163/Code03_ColorBanlance2.java
rename to src/class163/Code02_ColorBanlance2.java
index 8eae184dd..a1fc74999 100644
--- a/src/class163/Code03_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -1,6 +1,11 @@
 package class163;
 
 // 颜色平衡的子树，java实现迭代版
+// 一共有n个节点，编号1~n，给定每个节点的颜色值和父亲节点编号
+// 输入保证所有节点一定组成一棵树，并且1号节点是树头
+// 如果一棵子树中，存在的每种颜色的节点个数都相同，这棵子树叫颜色平衡树
+// 打印整棵树中有多少个子树是颜色平衡树
+// 1 <= n、颜色值 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9233
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -11,7 +16,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_ColorBanlance2 {
+public class Code02_ColorBanlance2 {
 
 	public static int MAXN = 200001;
 	public static int n;
diff --git a/src/class163/Code03_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
similarity index 86%
rename from src/class163/Code03_ColorBanlance3.java
rename to src/class163/Code02_ColorBanlance3.java
index 6811ea1a8..7497f8899 100644
--- a/src/class163/Code03_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -1,6 +1,11 @@
 package class163;
 
 // 颜色平衡的子树，C++版
+// 一共有n个节点，编号1~n，给定每个节点的颜色值和父亲节点编号
+// 输入保证所有节点一定组成一棵树，并且1号节点是树头
+// 如果一棵子树中，存在的每种颜色的节点个数都相同，这棵子树叫颜色平衡树
+// 打印整棵树中有多少个子树是颜色平衡树
+// 1 <= n、颜色值 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9233
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class163/Code04_LomsatGelral1.java b/src/class163/Code03_LomsatGelral1.java
similarity index 85%
rename from src/class163/Code04_LomsatGelral1.java
rename to src/class163/Code03_LomsatGelral1.java
index 005dc53c9..1d86d5a33 100644
--- a/src/class163/Code04_LomsatGelral1.java
+++ b/src/class163/Code03_LomsatGelral1.java
@@ -1,6 +1,12 @@
 package class163;
 
 // 主导颜色累加和，java版
+// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
+// 每个节点给定一种颜色值，主导颜色累加和定义如下
+// 以x为头的子树上，哪种颜色出现最多，那种颜色就是主导颜色，主导颜色可能不止一种
+// 所有主导颜色的值累加起来，每个主导颜色只累加一次，就是该子树的主导颜色累加和
+// 打印1~n每个节点为头的子树的主导颜色累加和
+// 1 <= n、颜色值 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF600E
 // 测试链接 : https://codeforces.com/problemset/problem/600/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -12,7 +18,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code04_LomsatGelral1 {
+public class Code03_LomsatGelral1 {
 
 	public static int MAXN = 100001;
 	public static int n;
diff --git a/src/class163/Code04_LomsatGelral2.java b/src/class163/Code03_LomsatGelral2.java
similarity index 85%
rename from src/class163/Code04_LomsatGelral2.java
rename to src/class163/Code03_LomsatGelral2.java
index c89d90ebc..d19c38e37 100644
--- a/src/class163/Code04_LomsatGelral2.java
+++ b/src/class163/Code03_LomsatGelral2.java
@@ -1,6 +1,12 @@
 package class163;
 
 // 主导颜色累加和，C++版
+// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
+// 每个节点给定一种颜色值，主导颜色累加和定义如下
+// 以x为头的子树上，哪种颜色出现最多，那种颜色就是主导颜色，主导颜色可能不止一种
+// 所有主导颜色的值累加起来，每个主导颜色只累加一次，就是该子树的主导颜色累加和
+// 打印1~n每个节点为头的子树的主导颜色累加和
+// 1 <= n、颜色值 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF600E
 // 测试链接 : https://codeforces.com/problemset/problem/600/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class163/Code02_DifferntName1.java b/src/class163/Code04_DifferntName1.java
similarity index 91%
rename from src/class163/Code02_DifferntName1.java
rename to src/class163/Code04_DifferntName1.java
index ae0ee1356..105b7b549 100644
--- a/src/class163/Code02_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -1,6 +1,12 @@
 package class163;
 
 // 不同名字数量，java版
+// 一共有n个节点，编号1~n，给定每个节点的名字和父亲节点编号
+// 名字是string类型，如果父亲节点编号为0，说明当前节点是某棵树的头节点
+// 注意，n个节点组成的是森林结构，可能有若干棵树
+// 一共有m条查询，每条查询 x k，含义如下
+// 以x为头的子树上，到x距离为k的所有节点中，打印不同名字的数量
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF246E
 // 测试链接 : https://codeforces.com/problemset/problem/246/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -17,7 +23,7 @@
 import java.util.HashSet;
 import java.util.StringTokenizer;
 
-public class Code02_DifferntName1 {
+public class Code04_DifferntName1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class163/Code02_DifferntName2.java b/src/class163/Code04_DifferntName2.java
similarity index 89%
rename from src/class163/Code02_DifferntName2.java
rename to src/class163/Code04_DifferntName2.java
index 2944a19c1..16ce9aea4 100644
--- a/src/class163/Code02_DifferntName2.java
+++ b/src/class163/Code04_DifferntName2.java
@@ -1,6 +1,12 @@
 package class163;
 
 // 不同名字数量，C++版
+// 一共有n个节点，编号1~n，给定每个节点的名字和父亲节点编号
+// 名字是string类型，如果父亲节点编号为0，说明当前节点是某棵树的头节点
+// 注意，n个节点组成的是森林结构，可能有若干棵树
+// 一共有m条查询，每条查询 x k，含义如下
+// 以x为头的子树上，到x距离为k的所有节点中，打印不同名字的数量
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF246E
 // 测试链接 : https://codeforces.com/problemset/problem/246/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 312836d9d..39746f40b 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -1,6 +1,15 @@
 package class163;
 
 // 表亲数量，java版
+// 一共有n个节点，编号1~n，给定每个节点的父亲节点编号
+// 如果父亲节点编号为0，说明当前节点是某棵树的头节点
+// 注意，n个节点组成的是森林结构，可能有若干棵树
+// 一共有m条查询，每条查询 x k，含义如下
+// 如果x往上走k的距离，没有祖先节点，打印0
+// 如果x往上走k的距离，能找到祖先节点a
+// 那么从a往下走k的距离，有可能找到除了x之外，很多其他的节点
+// 这些节点叫做x的k级表亲，打印这个表亲的数量
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF208E
 // 测试链接 : https://codeforces.com/problemset/problem/208/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index e834487f0..a11710610 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -1,6 +1,15 @@
 package class163;
 
 // 表亲数量，C++版
+// 一共有n个节点，编号1~n，给定每个节点的父亲节点编号
+// 如果父亲节点编号为0，说明当前节点是某棵树的头节点
+// 注意，n个节点组成的是森林结构，可能有若干棵树
+// 一共有m条查询，每条查询 x k，含义如下
+// 如果x往上走k的距离，没有祖先节点，打印0
+// 如果x往上走k的距离，能找到祖先节点a
+// 那么从a往下走k的距离，有可能找到除了x之外，很多其他的节点
+// 这些节点叫做x的k级表亲，打印这个表亲的数量
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF208E
 // 测试链接 : https://codeforces.com/problemset/problem/208/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class163/Code06_RearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
index 984140154..99b5f0a90 100644
--- a/src/class163/Code06_RearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -1,6 +1,11 @@
 package class163;
 
 // 最长重排回文路径，java版
+// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
+// 每条边上都有一个字符，字符范围[a~v]，字符一共22种，重排回文路径的定义如下
+// 节点a到节点b的路径，如果所有边的字符收集起来，能重新排列成回文串，该路径是重排回文路径
+// 打印1~n每个节点为头的子树中，最长重排回文路径的长度
+// 1 <= n <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF741D
 // 测试链接 : https://codeforces.com/problemset/problem/741/D
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class163/Code06_RearrangePalindrome2.java b/src/class163/Code06_RearrangePalindrome2.java
index aa9cdb6a7..71f153085 100644
--- a/src/class163/Code06_RearrangePalindrome2.java
+++ b/src/class163/Code06_RearrangePalindrome2.java
@@ -1,6 +1,11 @@
 package class163;
 
 // 最长重排回文路径，C++版
+// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
+// 每条边上都有一个字符，字符范围[a~v]，字符一共22种，重排回文路径的定义如下
+// 节点a到节点b的路径，如果所有边的字符收集起来，能重新排列成回文串，该路径是重排回文路径
+// 打印1~n每个节点为头的子树中，最长重排回文路径的长度
+// 1 <= n <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF741D
 // 测试链接 : https://codeforces.com/problemset/problem/741/D
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class163/Code07_Forest1.java b/src/class163/Code07_Forest1.java
index f244a79be..ed16bab63 100644
--- a/src/class163/Code07_Forest1.java
+++ b/src/class163/Code07_Forest1.java
@@ -1,6 +1,15 @@
 package class163;
 
 // 森林，java版
+// 一共有n个节点，编号1~n，初始时给定m条边，所有节点可能组成森林结构
+// 每个节点都给定非负的点权，一共有t条操作，每条操作是如下两种类型中的一种
+// 操作 Q x y k : 点x到点y路径上所有的权值中，打印第k小的权值是多少
+//                题目保证x和y联通，并且路径上至少有k个点
+// 操作 L x y   : 点x和点y之间连接一条边
+//                题目保证操作后，所有节点仍然是森林
+// 题目要求强制在线，请不要使用离线算法
+// 1 <= n、m、t <= 8 * 10^4
+// 点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3302
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class163/Code07_Forest2.java b/src/class163/Code07_Forest2.java
index 883e82276..648159ee7 100644
--- a/src/class163/Code07_Forest2.java
+++ b/src/class163/Code07_Forest2.java
@@ -1,6 +1,15 @@
 package class163;
 
 // 森林，C++版
+// 一共有n个节点，编号1~n，初始时给定m条边，所有节点可能组成森林结构
+// 每个节点都给定非负的点权，一共有t条操作，每条操作是如下两种类型中的一种
+// 操作 Q x y k : 点x到点y路径上所有的权值中，打印第k小的权值是多少
+//                题目保证x和y联通，并且路径上至少有k个点
+// 操作 L x y   : 点x和点y之间连接一条边
+//                题目保证操作后，所有节点仍然是森林
+// 题目要求强制在线，请不要使用离线算法
+// 1 <= n、m、t <= 8 * 10^4
+//点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3302
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 993ec4688727d2d39054c53d2b54ea6607612724 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 19 Mar 2025 21:12:32 +0800
Subject: [PATCH 0587/1712] modify code

---
 src/class163/Code07_Forest2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class163/Code07_Forest2.java b/src/class163/Code07_Forest2.java
index 648159ee7..769b2377a 100644
--- a/src/class163/Code07_Forest2.java
+++ b/src/class163/Code07_Forest2.java
@@ -9,7 +9,7 @@
 //                题目保证操作后，所有节点仍然是森林
 // 题目要求强制在线，请不要使用离线算法
 // 1 <= n、m、t <= 8 * 10^4
-//点权 <= 10^9
+// 点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3302
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 0eeca7cde3dbd1900183b3cf16667179700e633d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Mar 2025 16:37:28 +0800
Subject: [PATCH 0588/1712] modify code

---
 .../{Code01_ColorOnTree1.java => Code01_DsuOnTree1.java}      | 4 ++--
 .../{Code01_ColorOnTree2.java => Code01_DsuOnTree2.java}      | 2 +-
 src/class163/Code05_BloodCousins1.java                        | 3 +--
 src/class163/Code05_BloodCousins2.java                        | 3 +--
 4 files changed, 5 insertions(+), 7 deletions(-)
 rename src/class163/{Code01_ColorOnTree1.java => Code01_DsuOnTree1.java} (97%)
 rename src/class163/{Code01_ColorOnTree2.java => Code01_DsuOnTree2.java} (98%)

diff --git a/src/class163/Code01_ColorOnTree1.java b/src/class163/Code01_DsuOnTree1.java
similarity index 97%
rename from src/class163/Code01_ColorOnTree1.java
rename to src/class163/Code01_DsuOnTree1.java
index 5d679bbe6..4d81664ce 100644
--- a/src/class163/Code01_ColorOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -1,6 +1,6 @@
 package class163;
 
-// 树上数颜色，java版
+// 树上启发式合并模版题，java版
 // 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
 // 每个节点给定一种颜色值，一共有m条查询，每条查询给定参数x
 // 每条查询打印x为头的子树上，一共有多少种不同的颜色
@@ -15,7 +15,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code01_ColorOnTree1 {
+public class Code01_DsuOnTree1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class163/Code01_ColorOnTree2.java b/src/class163/Code01_DsuOnTree2.java
similarity index 98%
rename from src/class163/Code01_ColorOnTree2.java
rename to src/class163/Code01_DsuOnTree2.java
index ecc054b7d..0f441bfc3 100644
--- a/src/class163/Code01_ColorOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -1,6 +1,6 @@
 package class163;
 
-// 树上数颜色，C++版
+// 树上启发式合并模版题，C++版
 // 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
 // 每个节点给定一种颜色值，一共有m条查询，每条查询给定参数x
 // 每条查询打印x为头的子树上，一共有多少种不同的颜色
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 39746f40b..5e5deb72d 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -6,8 +6,7 @@
 // 注意，n个节点组成的是森林结构，可能有若干棵树
 // 一共有m条查询，每条查询 x k，含义如下
 // 如果x往上走k的距离，没有祖先节点，打印0
-// 如果x往上走k的距离，能找到祖先节点a
-// 那么从a往下走k的距离，有可能找到除了x之外，很多其他的节点
+// 如果x往上走k的距离，能找到祖先节点a，那么从a往下走k的距离，除了x之外，可能还有其他节点
 // 这些节点叫做x的k级表亲，打印这个表亲的数量
 // 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF208E
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index a11710610..9c11eeda8 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -6,8 +6,7 @@
 // 注意，n个节点组成的是森林结构，可能有若干棵树
 // 一共有m条查询，每条查询 x k，含义如下
 // 如果x往上走k的距离，没有祖先节点，打印0
-// 如果x往上走k的距离，能找到祖先节点a
-// 那么从a往下走k的距离，有可能找到除了x之外，很多其他的节点
+// 如果x往上走k的距离，能找到祖先节点a，那么从a往下走k的距离，除了x之外，可能还有其他节点
 // 这些节点叫做x的k级表亲，打印这个表亲的数量
 // 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF208E

From 2d66edc8cfa1e301909dce5f78612841b55fd970 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Mar 2025 16:59:11 +0800
Subject: [PATCH 0589/1712] modify code

---
 src/class163/Code01_DsuOnTree2.java | 260 +++++++++++++++-------------
 src/class163/Code01_DsuOnTree3.java | 127 ++++++++++++++
 2 files changed, 263 insertions(+), 124 deletions(-)
 create mode 100644 src/class163/Code01_DsuOnTree3.java

diff --git a/src/class163/Code01_DsuOnTree2.java b/src/class163/Code01_DsuOnTree2.java
index 0f441bfc3..005564b14 100644
--- a/src/class163/Code01_DsuOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -1,128 +1,140 @@
 package class163;
 
-// 树上启发式合并模版题，C++版
-// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
-// 每个节点给定一种颜色值，一共有m条查询，每条查询给定参数x
-// 每条查询打印x为头的子树上，一共有多少种不同的颜色
-// 1 <= n、m、颜色值 <= 10^5
+// 树上启发式合并模版题，java版
+// 只需要关注有注释的代码
+// 揭示了轻儿子取消自己的影响后
+// 其实全局的信息统计就是空的
+// 所以改成注释的代码也是正确的
 // 测试链接 : https://www.luogu.com.cn/problem/U41492
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//const int MAXN = 100001;
-//int n, m;
-//int arr[MAXN];
-//
-//int head[MAXN];
-//int nxt[MAXN << 1];
-//int to[MAXN << 1];
-//int cnt = 0;
-//
-//int fa[MAXN];
-//int siz[MAXN];
-//int son[MAXN];
-//
-//int colorCnt[MAXN];
-//int ans[MAXN];
-//int total = 0;
-//
-//void addEdge(int u, int v) {
-//    nxt[++cnt] = head[u];
-//    to[cnt] = v;
-//    head[u] = cnt;
-//}
-//
-//void effect(int u) {
-//    if (++colorCnt[arr[u]] == 1) {
-//        total++;
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u]) {
-//            effect(v);
-//        }
-//    }
-//}
-//
-//void cancle(int u) {
-//    if (--colorCnt[arr[u]] == 0) {
-//        total--;
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u]) {
-//            cancle(v);
-//        }
-//    }
-//}
-//
-//void dfs1(int u, int f) {
-//    fa[u] = f;
-//    siz[u] = 1;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
-//        }
-//    }
-//}
-//
-//void dfs2(int u, int keep) {
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
-//            dfs2(v, 0);
-//        }
-//    }
-//    if (son[u] != 0) {
-//        dfs2(son[u], 1);
-//    }
-//    if (++colorCnt[arr[u]] == 1) {
-//        total++;
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
-//            effect(v);
-//        }
-//    }
-//    ans[u] = total;
-//    if (keep == 0) {
-//        cancle(u);
-//    }
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n;
-//    for (int i = 1, u, v; i < n; i++) {
-//        cin >> u >> v;
-//        addEdge(u, v);
-//        addEdge(v, u);
-//    }
-//    for (int i = 1; i <= n; i++) {
-//        cin >> arr[i];
-//    }
-//    dfs1(1, 0);
-//    dfs2(1, 1);
-//    cin >> m;
-//    for (int i = 1, cur; i <= m; i++) {
-//        cin >> cur;
-//        cout << ans[cur] << "\n";
-//    }
-//    return 0;
-//}
\ No newline at end of file
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_DsuOnTree2 {
+
+	public static int MAXN = 100001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt = 0;
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] colorCnt = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+	public static int total = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static void effect(int u) {
+		if (++colorCnt[arr[u]] == 1) {
+			total++;
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				effect(v);
+			}
+		}
+	}
+
+	public static void cancle(int u) {
+		colorCnt[arr[u]] = 0; // 出现任何颜色，直接把该颜色的计数重置为0
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u]) {
+				cancle(v);
+			}
+		}
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int keep) {
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, 0);
+			}
+		}
+		if (son[u] != 0) {
+			dfs2(son[u], 1);
+		}
+		if (++colorCnt[arr[u]] == 1) {
+			total++;
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				effect(v);
+			}
+		}
+		ans[u] = total;
+		if (keep == 0) {
+			total = 0; // 直接把全局的不同颜色数量重置为0
+			cancle(u);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			arr[i] = (int) in.nval;
+		}
+		dfs1(1, 0);
+		dfs2(1, 1);
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, cur; i <= m; i++) {
+			in.nextToken();
+			cur = (int) in.nval;
+			out.println(ans[cur]);
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class163/Code01_DsuOnTree3.java b/src/class163/Code01_DsuOnTree3.java
new file mode 100644
index 000000000..f43318634
--- /dev/null
+++ b/src/class163/Code01_DsuOnTree3.java
@@ -0,0 +1,127 @@
+package class163;
+
+// 树上启发式合并模版题，C++版
+// 一共有n个节点，编号1~n，给定n-1条边，所有节点连成一棵树，1号节点为树头
+// 每个节点给定一种颜色值，一共有m条查询，每条查询给定参数x
+// 每条查询打印x为头的子树上，一共有多少种不同的颜色
+// 1 <= n、m、颜色值 <= 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/U41492
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt = 0;
+//
+//int fa[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//
+//int colorCnt[MAXN];
+//int ans[MAXN];
+//int total = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cnt] = head[u];
+//    to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//void effect(int u) {
+//    if (++colorCnt[arr[u]] == 1) {
+//        total++;
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            effect(v);
+//        }
+//    }
+//}
+//
+//void cancle(int u) {
+//    colorCnt[arr[u]] = 0;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u]) {
+//            cancle(v);
+//        }
+//    }
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int keep) {
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, 0);
+//        }
+//    }
+//    if (son[u] != 0) {
+//        dfs2(son[u], 1);
+//    }
+//    if (++colorCnt[arr[u]] == 1) {
+//        total++;
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            effect(v);
+//        }
+//    }
+//    ans[u] = total;
+//    if (keep == 0) {
+//        total = 0;
+//        cancle(u);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    cin >> m;
+//    for (int i = 1, cur; i <= m; i++) {
+//        cin >> cur;
+//        cout << ans[cur] << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file

From d1b4644cbf18544ad6f177e87f184ababea9d6d7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Mar 2025 17:22:33 +0800
Subject: [PATCH 0590/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java           |  2 +-
 src/class163/Code01_DsuOnTree2.java           |  2 +-
 src/class163/Code01_DsuOnTree3.java           |  2 +-
 src/class163/Code02_ColorBanlance1.java       |  2 +-
 src/class163/Code02_ColorBanlance2.java       | 32 +++++++++----------
 src/class163/Code02_ColorBanlance3.java       |  2 +-
 src/class163/Code03_LomsatGelral1.java        |  2 +-
 src/class163/Code03_LomsatGelral2.java        |  2 +-
 src/class163/Code04_DifferntName1.java        |  4 ---
 src/class163/Code05_BloodCousins1.java        |  4 ---
 src/class163/Code06_RearrangePalindrome1.java |  2 +-
 src/class163/Code06_RearrangePalindrome2.java |  2 +-
 12 files changed, 25 insertions(+), 33 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index 4d81664ce..613a2f775 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -135,7 +135,7 @@ public static void main(String[] args) throws IOException {
 			arr[i] = (int) in.nval;
 		}
 		dfs1(1, 0);
-		dfs2(1, 1);
+		dfs2(1, 0);
 		in.nextToken();
 		m = (int) in.nval;
 		for (int i = 1, cur; i <= m; i++) {
diff --git a/src/class163/Code01_DsuOnTree2.java b/src/class163/Code01_DsuOnTree2.java
index 005564b14..1e0ca0644 100644
--- a/src/class163/Code01_DsuOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -124,7 +124,7 @@ public static void main(String[] args) throws IOException {
 			arr[i] = (int) in.nval;
 		}
 		dfs1(1, 0);
-		dfs2(1, 1);
+		dfs2(1, 0);
 		in.nextToken();
 		m = (int) in.nval;
 		for (int i = 1, cur; i <= m; i++) {
diff --git a/src/class163/Code01_DsuOnTree3.java b/src/class163/Code01_DsuOnTree3.java
index f43318634..ed93e03ce 100644
--- a/src/class163/Code01_DsuOnTree3.java
+++ b/src/class163/Code01_DsuOnTree3.java
@@ -117,7 +117,7 @@
 //        cin >> arr[i];
 //    }
 //    dfs1(1, 0);
-//    dfs2(1, 1);
+//    dfs2(1, 0);
 //    cin >> m;
 //    for (int i = 1, cur; i <= m; i++) {
 //        cin >> cur;
diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index 97ed83c32..df2cd37fa 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -127,7 +127,7 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		dfs1(1);
-		dfs2(1, 1);
+		dfs2(1, 0);
 		out.println(ans);
 		out.flush();
 		out.close();
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index a1fc74999..d81e0c9f2 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -44,7 +44,7 @@ public static void addEdge(int u, int v) {
 
 	// stack2、size2、cur2、edge2、keep2，用于把dfs2改成迭代版
 	public static int[][] stack2 = new int[MAXN][3];
-	public static int size2, cur2, edge2, keep2;
+	public static int size2, cur2, keep2, edge2;
 
 	public static void push1(int u, int e) {
 		stack1[size1][0] = u;
@@ -58,18 +58,18 @@ public static void pop1() {
 		edge1 = stack1[size1][1];
 	}
 
-	public static void push2(int u, int e, int k) {
+	public static void push2(int u, int k, int e) {
 		stack2[size2][0] = u;
-		stack2[size2][1] = e;
-		stack2[size2][2] = k;
+		stack2[size2][1] = k;
+		stack2[size2][2] = e;
 		size2++;
 	}
 
 	public static void pop2() {
 		--size2;
 		cur2 = stack2[size2][0];
-		edge2 = stack2[size2][1];
-		keep2 = stack2[size2][2];
+		keep2 = stack2[size2][1];
+		edge2 = stack2[size2][2];
 	}
 
 	public static void effect(int root) {
@@ -112,9 +112,9 @@ public static void cancle(int root) {
 		}
 	}
 
-	public static void dfs1() {
+	public static void dfs1(int u) {
 		size1 = 0;
-		push1(1, -1);
+		push1(u, -1);
 		while (size1 > 0) {
 			pop1();
 			if (edge1 == -1) {
@@ -143,9 +143,9 @@ public static void dfs1() {
 	// edge2 > 0，表示正在依次处理轻儿子的子树
 	// edge2 == 0，表示处理完了所有轻儿子的子树，接下来处理重儿子的子树
 	// edge2 == -2，表示处理完了重儿子的子树，轮到启发式合并了
-	public static void dfs2() {
+	public static void dfs2(int u, int keep) {
 		size2 = 0;
-		push2(1, -1, 1);
+		push2(u, keep, -1);
 		while (size2 > 0) {
 			pop2();
 			if (edge2 != -2) {
@@ -155,14 +155,14 @@ public static void dfs2() {
 					edge2 = next[edge2];
 				}
 				if (edge2 > 0) {
-					push2(cur2, edge2, keep2);
+					push2(cur2, keep2, edge2);
 					if (to[edge2] != son[cur2]) {
-						push2(to[edge2], -1, 0);
+						push2(to[edge2], 0, -1);
 					}
 				} else {
-					push2(cur2, -2, keep2);
+					push2(cur2, keep2, -2);
 					if (son[cur2] != 0) {
-						push2(son[cur2], -1, 1);
+						push2(son[cur2], 1, -1);
 					}
 				}
 			} else {
@@ -201,8 +201,8 @@ public static void main(String[] args) throws IOException {
 				addEdge(father, i);
 			}
 		}
-		dfs1();
-		dfs2();
+		dfs1(1);
+		dfs2(1, 0);
 		out.println(ans);
 		out.flush();
 		out.close();
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
index 7497f8899..353a5d131 100644
--- a/src/class163/Code02_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -104,7 +104,7 @@
 //        }
 //    }
 //    dfs1(1);
-//    dfs2(1, 1);
+//    dfs2(1, 0);
 //    cout << ans << "\n";
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class163/Code03_LomsatGelral1.java b/src/class163/Code03_LomsatGelral1.java
index 1d86d5a33..b90737671 100644
--- a/src/class163/Code03_LomsatGelral1.java
+++ b/src/class163/Code03_LomsatGelral1.java
@@ -139,7 +139,7 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		dfs1(1, 0);
-		dfs2(1, 1);
+		dfs2(1, 0);
 		for (int i = 1; i <= n; i++) {
 			out.print(ans[i] + " ");
 		}
diff --git a/src/class163/Code03_LomsatGelral2.java b/src/class163/Code03_LomsatGelral2.java
index d19c38e37..495d53a39 100644
--- a/src/class163/Code03_LomsatGelral2.java
+++ b/src/class163/Code03_LomsatGelral2.java
@@ -129,7 +129,7 @@
 //        addEdge(v, u);
 //    }
 //    dfs1(1, 0);
-//    dfs2(1, 1);
+//    dfs2(1, 0);
 //    for (int i = 1; i <= n; i++) {
 //        cout << ans[i] << " ";
 //    }
diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
index 105b7b549..f2ac079b9 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -173,10 +173,6 @@ public static void main(String[] args) throws IOException {
 			addQuestion(node, i, k);
 		}
 		for (int i = 1; i <= n; i++) {
-			// 因为是森林结构，可能有多棵子树彼此是不联通的
-			// 所以认为每一棵树的头都是轻儿子
-			// 这样每棵子树运行完后都会消除影响
-			// 不会影响下一棵子树的答案
 			if (root[i]) {
 				dfs2(i, 0);
 			}
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 5e5deb72d..48bb1033a 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -163,10 +163,6 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		for (int i = 1; i <= n; i++) {
-			// 因为是森林结构，可能有多棵子树彼此是不联通的
-			// 所以认为每一棵树的头都是轻儿子
-			// 这样每棵子树运行完后都会消除影响
-			// 不会影响下一棵子树的答案
 			if (root[i]) {
 				dfs2(i, 0);
 			}
diff --git a/src/class163/Code06_RearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
index 99b5f0a90..9cf26071c 100644
--- a/src/class163/Code06_RearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -136,7 +136,7 @@ public static void main(String[] args) throws IOException {
 			addEdge(fth, i, edg);
 		}
 		dfs1(1, 1, 0);
-		dfs2(1, 1);
+		dfs2(1, 0);
 		for (int i = 1; i <= n; i++) {
 			out.print(ans[i] + " ");
 		}
diff --git a/src/class163/Code06_RearrangePalindrome2.java b/src/class163/Code06_RearrangePalindrome2.java
index 71f153085..c6b520a12 100644
--- a/src/class163/Code06_RearrangePalindrome2.java
+++ b/src/class163/Code06_RearrangePalindrome2.java
@@ -131,7 +131,7 @@
 //        addEdge(fth, i, edg);
 //    }
 //    dfs1(1, 1, 0);
-//    dfs2(1, 1);
+//    dfs2(1, 0);
 //    for (int i = 1; i <= n; i++) {
 //        cout << ans[i] << " ";
 //    }

From a16d35a261035a1d3b3cc765bff227f9b1277ed9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Mar 2025 17:24:42 +0800
Subject: [PATCH 0591/1712] modify code

---
 src/class163/Code04_DifferntName1.java | 2 --
 src/class163/Code05_BloodCousins1.java | 2 --
 2 files changed, 4 deletions(-)

diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
index f2ac079b9..3edb8f405 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -157,8 +157,6 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		for (int i = 1; i <= n; i++) {
-			// 因为是森林结构，可能有多棵子树彼此是不联通的
-			// 所以对每一棵子树进行重链剖分
 			if (root[i]) {
 				dfs1(i, 0);
 			}
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 48bb1033a..a3f1734f4 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -144,8 +144,6 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		for (int i = 1; i <= n; i++) {
-			// 因为是森林结构，可能有多棵子树彼此是不联通的
-			// 所以对每一棵子树进行重链剖分、生成倍增表
 			if (root[i]) {
 				dfs1(i, 0);
 			}

From 895bff5a3f73568de3e56308b4c7b1a1be11ec3d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Mar 2025 17:47:24 +0800
Subject: [PATCH 0592/1712] modify code

---
 ...ee.java => Code03_WidthOfBinaryTree1.java} | 10 ++---
 src/class036/Code03_WidthOfBinaryTree2.java   | 40 +++++++++++++++++++
 2 files changed, 45 insertions(+), 5 deletions(-)
 rename src/class036/{Code03_WidthOfBinaryTree.java => Code03_WidthOfBinaryTree1.java} (81%)
 create mode 100644 src/class036/Code03_WidthOfBinaryTree2.java

diff --git a/src/class036/Code03_WidthOfBinaryTree.java b/src/class036/Code03_WidthOfBinaryTree1.java
similarity index 81%
rename from src/class036/Code03_WidthOfBinaryTree.java
rename to src/class036/Code03_WidthOfBinaryTree1.java
index 3cb369ddb..c315690b7 100644
--- a/src/class036/Code03_WidthOfBinaryTree.java
+++ b/src/class036/Code03_WidthOfBinaryTree1.java
@@ -1,8 +1,8 @@
 package class036;
 
-// 二叉树的最大特殊宽度
+// 二叉树的最大特殊宽度，java版
 // 测试链接 : https://leetcode.cn/problems/maximum-width-of-binary-tree/
-public class Code03_WidthOfBinaryTree {
+public class Code03_WidthOfBinaryTree1 {
 
 	// 不提交这个类
 	public static class TreeNode {
@@ -18,7 +18,7 @@ public static class TreeNode {
 
 	public static TreeNode[] nq = new TreeNode[MAXN];
 
-	public static int[] iq = new int[MAXN];
+	public static long[] iq = new long[MAXN];
 
 	public static int l, r;
 
@@ -29,10 +29,10 @@ public static int widthOfBinaryTree(TreeNode root) {
 		iq[r++] = 1;
 		while (l < r) {
 			int size = r - l;
-			ans = Math.max(ans, iq[r - 1] - iq[l] + 1);
+			ans = Math.max(ans, (int) (iq[r - 1] - iq[l] + 1));
 			for (int i = 0; i < size; i++) {
 				TreeNode node = nq[l];
-				int id = iq[l++];
+				long id = iq[l++];
 				if (node.left != null) {
 					nq[r] = node.left;
 					iq[r++] = id * 2;
diff --git a/src/class036/Code03_WidthOfBinaryTree2.java b/src/class036/Code03_WidthOfBinaryTree2.java
new file mode 100644
index 000000000..420f91ea1
--- /dev/null
+++ b/src/class036/Code03_WidthOfBinaryTree2.java
@@ -0,0 +1,40 @@
+package class036;
+
+// 二叉树的最大特殊宽度，C++版
+// 测试链接 : https://leetcode.cn/problems/maximum-width-of-binary-tree/
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//using ULL = unsigned long long;
+//
+//class Solution {
+//public:
+//   static const int MAXN = 3001;
+//   TreeNode* nq[MAXN];
+//   ULL iq[MAXN];
+//   int l, r;
+//
+//   int widthOfBinaryTree(TreeNode* root) {
+//       int ans = 1;
+//       l = r = 0;
+//       nq[r] = root;
+//       iq[r++] = 1ULL;
+//       while (l < r) {
+//           int size = r - l;
+//           ans = std::max(ans, static_cast<int>(iq[r - 1] - iq[l] + 1ULL));
+//           for (int i = 0; i < size; i++) {
+//               TreeNode* node = nq[l];
+//               ULL id = iq[l++];
+//               if (node->left != nullptr) {
+//                   nq[r] = node->left;
+//                   iq[r++] = id * 2ULL;
+//               }
+//               if (node->right != nullptr) {
+//                   nq[r] = node->right;
+//                   iq[r++] = id * 2ULL + 1ULL;
+//               }
+//           }
+//       }
+//       return ans;
+//   }
+//};
\ No newline at end of file

From fa623f7e98eaf6016323ef588bfab8a566e7ca2b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Mar 2025 18:26:53 +0800
Subject: [PATCH 0593/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java | 10 +++++-----
 src/class163/Code01_DsuOnTree2.java | 10 +++++-----
 src/class163/Code01_DsuOnTree3.java | 10 +++++-----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index 613a2f775..3efba5f90 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -39,7 +39,7 @@ public class Code01_DsuOnTree1 {
 	// colorCnt[i] = j，表示i这种颜色出现了j次
 	public static int[] colorCnt = new int[MAXN];
 	public static int[] ans = new int[MAXN];
-	public static int total = 0;
+	public static int diffColors = 0;
 
 	public static void addEdge(int u, int v) {
 		next[++cnt] = head[u];
@@ -49,7 +49,7 @@ public static void addEdge(int u, int v) {
 
 	public static void effect(int u) {
 		if (++colorCnt[arr[u]] == 1) {
-			total++;
+			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
@@ -61,7 +61,7 @@ public static void effect(int u) {
 
 	public static void cancle(int u) {
 		if (--colorCnt[arr[u]] == 0) {
-			total--;
+			diffColors--;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
@@ -102,7 +102,7 @@ public static void dfs2(int u, int keep) {
 			dfs2(son[u], 1);
 		}
 		if (++colorCnt[arr[u]] == 1) {
-			total++;
+			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
@@ -110,7 +110,7 @@ public static void dfs2(int u, int keep) {
 				effect(v);
 			}
 		}
-		ans[u] = total;
+		ans[u] = diffColors;
 		if (keep == 0) {
 			cancle(u);
 		}
diff --git a/src/class163/Code01_DsuOnTree2.java b/src/class163/Code01_DsuOnTree2.java
index 1e0ca0644..4cb6666a3 100644
--- a/src/class163/Code01_DsuOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -29,7 +29,7 @@ public class Code01_DsuOnTree2 {
 	public static int[] son = new int[MAXN];
 	public static int[] colorCnt = new int[MAXN];
 	public static int[] ans = new int[MAXN];
-	public static int total = 0;
+	public static int diffColors = 0;
 
 	public static void addEdge(int u, int v) {
 		next[++cnt] = head[u];
@@ -39,7 +39,7 @@ public static void addEdge(int u, int v) {
 
 	public static void effect(int u) {
 		if (++colorCnt[arr[u]] == 1) {
-			total++;
+			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
@@ -90,7 +90,7 @@ public static void dfs2(int u, int keep) {
 			dfs2(son[u], 1);
 		}
 		if (++colorCnt[arr[u]] == 1) {
-			total++;
+			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
@@ -98,9 +98,9 @@ public static void dfs2(int u, int keep) {
 				effect(v);
 			}
 		}
-		ans[u] = total;
+		ans[u] = diffColors;
 		if (keep == 0) {
-			total = 0; // 直接把全局的不同颜色数量重置为0
+			diffColors = 0; // 直接把全局的不同颜色数量重置为0
 			cancle(u);
 		}
 	}
diff --git a/src/class163/Code01_DsuOnTree3.java b/src/class163/Code01_DsuOnTree3.java
index ed93e03ce..537cd3929 100644
--- a/src/class163/Code01_DsuOnTree3.java
+++ b/src/class163/Code01_DsuOnTree3.java
@@ -28,7 +28,7 @@
 //
 //int colorCnt[MAXN];
 //int ans[MAXN];
-//int total = 0;
+//int diffColors = 0;
 //
 //void addEdge(int u, int v) {
 //    nxt[++cnt] = head[u];
@@ -38,7 +38,7 @@
 //
 //void effect(int u) {
 //    if (++colorCnt[arr[u]] == 1) {
-//        total++;
+//        diffColors++;
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
@@ -89,7 +89,7 @@
 //        dfs2(son[u], 1);
 //    }
 //    if (++colorCnt[arr[u]] == 1) {
-//        total++;
+//        diffColors++;
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
@@ -97,9 +97,9 @@
 //            effect(v);
 //        }
 //    }
-//    ans[u] = total;
+//    ans[u] = diffColors;
 //    if (keep == 0) {
-//        total = 0;
+//        diffColors = 0;
 //        cancle(u);
 //    }
 //}

From 83ba1b6413160286550bbfbfe6befcbba66060c8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 20 Mar 2025 18:55:19 +0800
Subject: [PATCH 0594/1712] modify code

---
 src/class163/Code05_BloodCousins1.java | 3 +--
 src/class163/Code05_BloodCousins2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index a3f1734f4..bd8ce06a6 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -1,8 +1,7 @@
 package class163;
 
 // 表亲数量，java版
-// 一共有n个节点，编号1~n，给定每个节点的父亲节点编号
-// 如果父亲节点编号为0，说明当前节点是某棵树的头节点
+// 一共有n个节点，编号1~n，给定每个节点的父亲节点编号，父亲节点为0，说明当前节点是某棵树的头
 // 注意，n个节点组成的是森林结构，可能有若干棵树
 // 一共有m条查询，每条查询 x k，含义如下
 // 如果x往上走k的距离，没有祖先节点，打印0
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index 9c11eeda8..37c2a4b6f 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -1,8 +1,7 @@
 package class163;
 
 // 表亲数量，C++版
-// 一共有n个节点，编号1~n，给定每个节点的父亲节点编号
-// 如果父亲节点编号为0，说明当前节点是某棵树的头节点
+// 一共有n个节点，编号1~n，给定每个节点的父亲节点编号，父亲节点为0，说明当前节点是某棵树的头
 // 注意，n个节点组成的是森林结构，可能有若干棵树
 // 一共有m条查询，每条查询 x k，含义如下
 // 如果x往上走k的距离，没有祖先节点，打印0

From b6c6be33ece6c164c19742e2f8935bf7c18986c9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 21 Mar 2025 19:32:53 +0800
Subject: [PATCH 0595/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java     | 10 ++++-----
 src/class163/Code01_DsuOnTree2.java     | 10 ++++-----
 src/class163/Code01_DsuOnTree3.java     | 10 ++++-----
 src/class163/Code02_ColorBanlance1.java | 27 ++++++++++++-------------
 src/class163/Code02_ColorBanlance2.java | 27 ++++++++++++-------------
 src/class163/Code02_ColorBanlance3.java | 27 ++++++++++++-------------
 src/class163/Code04_DifferntName1.java  | 10 ++++-----
 src/class163/Code04_DifferntName2.java  | 10 ++++-----
 8 files changed, 64 insertions(+), 67 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index 3efba5f90..8e8aaa88a 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -22,7 +22,7 @@ public class Code01_DsuOnTree1 {
 	public static int n, m;
 
 	// 每个节点的颜色
-	public static int[] arr = new int[MAXN];
+	public static int[] color = new int[MAXN];
 
 	// 链式前向星
 	public static int[] head = new int[MAXN];
@@ -48,7 +48,7 @@ public static void addEdge(int u, int v) {
 	}
 
 	public static void effect(int u) {
-		if (++colorCnt[arr[u]] == 1) {
+		if (++colorCnt[color[u]] == 1) {
 			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -60,7 +60,7 @@ public static void effect(int u) {
 	}
 
 	public static void cancle(int u) {
-		if (--colorCnt[arr[u]] == 0) {
+		if (--colorCnt[color[u]] == 0) {
 			diffColors--;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -101,7 +101,7 @@ public static void dfs2(int u, int keep) {
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
-		if (++colorCnt[arr[u]] == 1) {
+		if (++colorCnt[color[u]] == 1) {
 			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -132,7 +132,7 @@ public static void main(String[] args) throws IOException {
 		}
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			arr[i] = (int) in.nval;
+			color[i] = (int) in.nval;
 		}
 		dfs1(1, 0);
 		dfs2(1, 0);
diff --git a/src/class163/Code01_DsuOnTree2.java b/src/class163/Code01_DsuOnTree2.java
index 4cb6666a3..44446c9a5 100644
--- a/src/class163/Code01_DsuOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -19,7 +19,7 @@ public class Code01_DsuOnTree2 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
-	public static int[] arr = new int[MAXN];
+	public static int[] color = new int[MAXN];
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
@@ -38,7 +38,7 @@ public static void addEdge(int u, int v) {
 	}
 
 	public static void effect(int u) {
-		if (++colorCnt[arr[u]] == 1) {
+		if (++colorCnt[color[u]] == 1) {
 			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -50,7 +50,7 @@ public static void effect(int u) {
 	}
 
 	public static void cancle(int u) {
-		colorCnt[arr[u]] = 0; // 出现任何颜色，直接把该颜色的计数重置为0
+		colorCnt[color[u]] = 0; // 出现任何颜色，直接把该颜色的计数重置为0
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa[u]) {
@@ -89,7 +89,7 @@ public static void dfs2(int u, int keep) {
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
-		if (++colorCnt[arr[u]] == 1) {
+		if (++colorCnt[color[u]] == 1) {
 			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -121,7 +121,7 @@ public static void main(String[] args) throws IOException {
 		}
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			arr[i] = (int) in.nval;
+			color[i] = (int) in.nval;
 		}
 		dfs1(1, 0);
 		dfs2(1, 0);
diff --git a/src/class163/Code01_DsuOnTree3.java b/src/class163/Code01_DsuOnTree3.java
index 537cd3929..3c1fd3d27 100644
--- a/src/class163/Code01_DsuOnTree3.java
+++ b/src/class163/Code01_DsuOnTree3.java
@@ -15,7 +15,7 @@
 //
 //const int MAXN = 100001;
 //int n, m;
-//int arr[MAXN];
+//int color[MAXN];
 //
 //int head[MAXN];
 //int nxt[MAXN << 1];
@@ -37,7 +37,7 @@
 //}
 //
 //void effect(int u) {
-//    if (++colorCnt[arr[u]] == 1) {
+//    if (++colorCnt[color[u]] == 1) {
 //        diffColors++;
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
@@ -49,7 +49,7 @@
 //}
 //
 //void cancle(int u) {
-//    colorCnt[arr[u]] = 0;
+//    colorCnt[color[u]] = 0;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != fa[u]) {
@@ -88,7 +88,7 @@
 //    if (son[u] != 0) {
 //        dfs2(son[u], 1);
 //    }
-//    if (++colorCnt[arr[u]] == 1) {
+//    if (++colorCnt[color[u]] == 1) {
 //        diffColors++;
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
@@ -114,7 +114,7 @@
 //        addEdge(v, u);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        cin >> arr[i];
+//        cin >> color[i];
 //    }
 //    dfs1(1, 0);
 //    dfs2(1, 0);
diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index df2cd37fa..67d3ad27e 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -25,7 +25,7 @@ public class Code02_ColorBanlance1 {
 	public static int n;
 
 	// 每个节点的颜色
-	public static int[] arr = new int[MAXN];
+	public static int[] color = new int[MAXN];
 
 	// 链式前向星
 	public static int[] head = new int[MAXN];
@@ -52,18 +52,18 @@ public static void addEdge(int u, int v) {
 	}
 
 	public static void effect(int u) {
-		colorCnt[arr[u]]++;
-		cntCnt[colorCnt[arr[u]] - 1]--;
-		cntCnt[colorCnt[arr[u]]]++;
+		colorCnt[color[u]]++;
+		cntCnt[colorCnt[color[u]] - 1]--;
+		cntCnt[colorCnt[color[u]]]++;
 		for (int e = head[u]; e > 0; e = next[e]) {
 			effect(to[e]);
 		}
 	}
 
 	public static void cancle(int u) {
-		colorCnt[arr[u]]--;
-		cntCnt[colorCnt[arr[u]] + 1]--;
-		cntCnt[colorCnt[arr[u]]]++;
+		colorCnt[color[u]]--;
+		cntCnt[colorCnt[color[u]] + 1]--;
+		cntCnt[colorCnt[color[u]]]++;
 		for (int e = head[u]; e > 0; e = next[e]) {
 			cancle(to[e]);
 		}
@@ -93,16 +93,16 @@ public static void dfs2(int u, int keep) {
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
-		colorCnt[arr[u]]++;
-		cntCnt[colorCnt[arr[u]] - 1]--;
-		cntCnt[colorCnt[arr[u]]]++;
+		colorCnt[color[u]]++;
+		cntCnt[colorCnt[color[u]] - 1]--;
+		cntCnt[colorCnt[color[u]]]++;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u]) {
 				effect(v);
 			}
 		}
-		if (colorCnt[arr[u]] * cntCnt[colorCnt[arr[u]]] == siz[u]) {
+		if (colorCnt[color[u]] * cntCnt[colorCnt[color[u]]] == siz[u]) {
 			ans++;
 		}
 		if (keep == 0) {
@@ -116,12 +116,11 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		in.nextToken();
 		n = (int) in.nval;
-		for (int i = 1, color, father; i <= n; i++) {
+		for (int i = 1, father; i <= n; i++) {
 			in.nextToken();
-			color = (int) in.nval;
+			color[i] = (int) in.nval;
 			in.nextToken();
 			father = (int) in.nval;
-			arr[i] = color;
 			if (i != 1) {
 				addEdge(father, i);
 			}
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index d81e0c9f2..b157d70ce 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -20,7 +20,7 @@ public class Code02_ColorBanlance2 {
 
 	public static int MAXN = 200001;
 	public static int n;
-	public static int[] arr = new int[MAXN];
+	public static int[] color = new int[MAXN];
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
 	public static int[] to = new int[MAXN];
@@ -78,9 +78,9 @@ public static void effect(int root) {
 		while (size1 > 0) {
 			pop1();
 			if (edge1 == -1) {
-				colorCnt[arr[cur1]]++;
-				cntCnt[colorCnt[arr[cur1]] - 1]--;
-				cntCnt[colorCnt[arr[cur1]]]++;
+				colorCnt[color[cur1]]++;
+				cntCnt[colorCnt[color[cur1]] - 1]--;
+				cntCnt[colorCnt[color[cur1]]]++;
 				edge1 = head[cur1];
 			} else {
 				edge1 = next[edge1];
@@ -98,9 +98,9 @@ public static void cancle(int root) {
 		while (size1 > 0) {
 			pop1();
 			if (edge1 == -1) {
-				colorCnt[arr[cur1]]--;
-				cntCnt[colorCnt[arr[cur1]] + 1]--;
-				cntCnt[colorCnt[arr[cur1]]]++;
+				colorCnt[color[cur1]]--;
+				cntCnt[colorCnt[color[cur1]] + 1]--;
+				cntCnt[colorCnt[color[cur1]]]++;
 				edge1 = head[cur1];
 			} else {
 				edge1 = next[edge1];
@@ -166,16 +166,16 @@ public static void dfs2(int u, int keep) {
 					}
 				}
 			} else {
-				colorCnt[arr[cur2]]++;
-				cntCnt[colorCnt[arr[cur2]] - 1]--;
-				cntCnt[colorCnt[arr[cur2]]]++;
+				colorCnt[color[cur2]]++;
+				cntCnt[colorCnt[color[cur2]] - 1]--;
+				cntCnt[colorCnt[color[cur2]]]++;
 				for (int e = head[cur2], v; e > 0; e = next[e]) {
 					v = to[e];
 					if (v != son[cur2]) {
 						effect(v);
 					}
 				}
-				if (colorCnt[arr[cur2]] * cntCnt[colorCnt[arr[cur2]]] == siz[cur2]) {
+				if (colorCnt[color[cur2]] * cntCnt[colorCnt[color[cur2]]] == siz[cur2]) {
 					ans++;
 				}
 				if (keep2 == 0) {
@@ -191,12 +191,11 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		in.nextToken();
 		n = (int) in.nval;
-		for (int i = 1, color, father; i <= n; i++) {
+		for (int i = 1, father; i <= n; i++) {
 			in.nextToken();
-			color = (int) in.nval;
+			color[i] = (int) in.nval;
 			in.nextToken();
 			father = (int) in.nval;
-			arr[i] = color;
 			if (i != 1) {
 				addEdge(father, i);
 			}
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
index 353a5d131..72ade8869 100644
--- a/src/class163/Code02_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -16,7 +16,7 @@
 //
 //const int MAXN = 200001;
 //int n;
-//int arr[MAXN];
+//int color[MAXN];
 //int head[MAXN];
 //int nxt[MAXN];
 //int to[MAXN];
@@ -34,18 +34,18 @@
 //}
 //
 //void effect(int u) {
-//    colorCnt[arr[u]]++;
-//    cntCnt[colorCnt[arr[u]] - 1]--;
-//    cntCnt[colorCnt[arr[u]]]++;
+//    colorCnt[color[u]]++;
+//    cntCnt[colorCnt[color[u]] - 1]--;
+//    cntCnt[colorCnt[color[u]]]++;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        effect(to[e]);
 //    }
 //}
 //
 //void cancle(int u) {
-//    colorCnt[arr[u]]--;
-//    cntCnt[colorCnt[arr[u]] + 1]--;
-//    cntCnt[colorCnt[arr[u]]]++;
+//    colorCnt[color[u]]--;
+//    cntCnt[colorCnt[color[u]] + 1]--;
+//    cntCnt[colorCnt[color[u]]]++;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        cancle(to[e]);
 //    }
@@ -75,16 +75,16 @@
 //    if (son[u] != 0) {
 //        dfs2(son[u], 1);
 //    }
-//    colorCnt[arr[u]]++;
-//    cntCnt[colorCnt[arr[u]] - 1]--;
-//    cntCnt[colorCnt[arr[u]]]++;
+//    colorCnt[color[u]]++;
+//    cntCnt[colorCnt[color[u]] - 1]--;
+//    cntCnt[colorCnt[color[u]]]++;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u]) {
 //            effect(v);
 //        }
 //    }
-//    if (colorCnt[arr[u]] * cntCnt[colorCnt[arr[u]]] == siz[u]) {
+//    if (colorCnt[color[u]] * cntCnt[colorCnt[color[u]]] == siz[u]) {
 //        ans++;
 //    }
 //    if (keep == 0) {
@@ -96,9 +96,8 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n;
-//    for (int i = 1, color, father; i <= n; i++) {
-//        cin >> color >> father;
-//        arr[i] = color;
+//    for (int i = 1, father; i <= n; i++) {
+//        cin >> color[i] >> father;
 //        if (i != 1) {
 //            addEdge(father, i);
 //        }
diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
index 3edb8f405..0477bbc86 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -28,7 +28,7 @@ public class Code04_DifferntName1 {
 	public static int MAXN = 100001;
 	public static int n, m;
 	public static boolean[] root = new boolean[MAXN];
-	public static int[] arr = new int[MAXN];
+	public static int[] id = new int[MAXN];
 
 	public static int[] headg = new int[MAXN];
 	public static int[] nextg = new int[MAXN];
@@ -103,14 +103,14 @@ public static void dfs1(int u, int f) {
 	}
 
 	public static void effect(int u) {
-		addId(dep[u], arr[u]);
+		addId(dep[u], id[u]);
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			effect(tog[e]);
 		}
 	}
 
 	public static void cancle(int u) {
-		removeId(dep[u], arr[u]);
+		removeId(dep[u], id[u]);
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			cancle(tog[e]);
 		}
@@ -126,7 +126,7 @@ public static void dfs2(int u, int keep) {
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
-		addId(dep[u], arr[u]);
+		addId(dep[u], id[u]);
 		for (int e = headg[u], v; e > 0; e = nextg[e]) {
 			v = tog[e];
 			if (v != son[u]) {
@@ -149,7 +149,7 @@ public static void main(String[] args) throws IOException {
 		for (int i = 1; i <= n; i++) {
 			name = io.next();
 			father = io.nextInt();
-			arr[i] = nameId(name);
+			id[i] = nameId(name);
 			if (father == 0) {
 				root[i] = true;
 			} else {
diff --git a/src/class163/Code04_DifferntName2.java b/src/class163/Code04_DifferntName2.java
index 16ce9aea4..f2309759c 100644
--- a/src/class163/Code04_DifferntName2.java
+++ b/src/class163/Code04_DifferntName2.java
@@ -19,7 +19,7 @@
 //const int MAXN = 100001;
 //int n, m;
 //bool root[MAXN];
-//int arr[MAXN];
+//int id[MAXN];
 //
 //int headg[MAXN];
 //int nextg[MAXN];
@@ -94,14 +94,14 @@
 //}
 //
 //void effect(int u) {
-//    addId(dep[u], arr[u]);
+//    addId(dep[u], id[u]);
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {
 //        effect(tog[e]);
 //    }
 //}
 //
 //void cancle(int u) {
-//    removeId(dep[u], arr[u]);
+//    removeId(dep[u], id[u]);
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {
 //        cancle(tog[e]);
 //    }
@@ -117,7 +117,7 @@
 //    if (son[u] != 0) {
 //        dfs2(son[u], 1);
 //    }
-//    addId(dep[u], arr[u]);
+//    addId(dep[u], id[u]);
 //    for (int e = headg[u], v; e > 0; e = nextg[e]) {
 //        v = tog[e];
 //        if (v != son[u]) {
@@ -140,7 +140,7 @@
 //    int father;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> name >> father;
-//        arr[i] = nameId(name);
+//        id[i] = nameId(name);
 //        if (father == 0) {
 //        	root[i] = true;
 //        } else {

From cce1c05b2739443b8a4b62f1c2e1db10765883c6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 22 Mar 2025 18:23:20 +0800
Subject: [PATCH 0596/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java | 13 ++++-
 src/class163/Code07_Forest1.java    | 85 ++++++++++++++++-------------
 src/class163/Code07_Forest2.java    | 42 +++++++-------
 3 files changed, 81 insertions(+), 59 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index 8e8aaa88a..5e355926e 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -35,7 +35,7 @@ public class Code01_DsuOnTree1 {
 	public static int[] siz = new int[MAXN];
 	public static int[] son = new int[MAXN];
 
-	// 启发式合并
+	// 树上启发式合并
 	// colorCnt[i] = j，表示i这种颜色出现了j次
 	public static int[] colorCnt = new int[MAXN];
 	public static int[] ans = new int[MAXN];
@@ -47,6 +47,7 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
+	// 子树u每个节点贡献信息
 	public static void effect(int u) {
 		if (++colorCnt[color[u]] == 1) {
 			diffColors++;
@@ -59,6 +60,7 @@ public static void effect(int u) {
 		}
 	}
 
+	// 子树u每个节点取消贡献
 	public static void cancle(int u) {
 		if (--colorCnt[color[u]] == 0) {
 			diffColors--;
@@ -71,6 +73,7 @@ public static void cancle(int u) {
 		}
 	}
 
+	// 重链剖分
 	public static void dfs1(int u, int f) {
 		fa[u] = f;
 		siz[u] = 1;
@@ -91,26 +94,34 @@ public static void dfs1(int u, int f) {
 		}
 	}
 
+	// 树上启发式合并的过程
 	public static void dfs2(int u, int keep) {
+		// 遍历轻儿子的子树，统计子树的答案，然后取消贡献
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa[u] && v != son[u]) {
 				dfs2(v, 0);
 			}
 		}
+		// 遍历重儿子的子树，统计子树的答案，然后保留贡献
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
+		// 当前节点贡献信息
 		if (++colorCnt[color[u]] == 1) {
 			diffColors++;
 		}
+		// 遍历轻儿子的子树，重新贡献一遍
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa[u] && v != son[u]) {
 				effect(v);
 			}
 		}
+		// 记录子树u的答案
 		ans[u] = diffColors;
+		// 如果u是上级节点的轻儿子，子树u的贡献取消
+		// 如果u是上级节点的重儿子，子树u的贡献保留
 		if (keep == 0) {
 			cancle(u);
 		}
diff --git a/src/class163/Code07_Forest1.java b/src/class163/Code07_Forest1.java
index ed16bab63..a49ba4db7 100644
--- a/src/class163/Code07_Forest1.java
+++ b/src/class163/Code07_Forest1.java
@@ -8,8 +8,7 @@
 // 操作 L x y   : 点x和点y之间连接一条边
 //                题目保证操作后，所有节点仍然是森林
 // 题目要求强制在线，请不要使用离线算法
-// 1 <= n、m、t <= 8 * 10^4
-// 点权 <= 10^9
+// 1 <= n、m、t <= 8 * 10^4    点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3302
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -43,10 +42,12 @@ public class Code07_Forest1 {
 	public static int cntt = 0;
 
 	public static int[] dep = new int[MAXN];
-	public static int[] treeHead = new int[MAXN];
-	public static int[] headSiz = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXH];
 
+	public static int[] treeHead = new int[MAXN];
+	public static int[] setSiz = new int[MAXN];
+
+	// 来自讲解158，题目4
 	public static int kth(int num) {
 		int left = 1, right = diff, mid;
 		while (left <= right) {
@@ -62,12 +63,14 @@ public static int kth(int num) {
 		return -1;
 	}
 
+	// 来自讲解158，题目4
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
 		to[cntg] = v;
 		head[u] = cntg;
 	}
 
+	// 来自讲解158，题目4
 	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cntt;
 		left[rt] = left[i];
@@ -84,6 +87,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
+	// 来自讲解158，题目4
 	public static int query(int jobk, int l, int r, int u, int v, int lca, int lcafa) {
 		if (l == r) {
 			return l;
@@ -97,12 +101,44 @@ public static int query(int jobk, int l, int r, int u, int v, int lca, int lcafa
 		}
 	}
 
+	// 来自讲解158，题目4
+	public static int lca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	// 来自讲解158，题目4
+	public static int queryKth(int x, int y, int k) {
+		int xylca = lca(x, y);
+		int lcafa = stjump[xylca][0];
+		int i = query(k, 1, diff, root[x], root[y], root[xylca], root[lcafa]);
+		return sorted[i];
+	}
+
 	// 递归版，C++可以通过，java无法通过，递归会爆栈
 	public static void dfs1(int u, int fa, int treeh) {
 		root[u] = insert(arr[u], 1, diff, root[fa]);
 		dep[u] = dep[fa] + 1;
 		treeHead[u] = treeh;
-		headSiz[treeh]++;
+		setSiz[treeh]++;
 		stjump[u][0] = fa;
 		for (int p = 1; p < MAXH; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -146,7 +182,7 @@ public static void dfs2(int i, int fa, int treeh) {
 				root[cur] = insert(arr[cur], 1, diff, root[father]);
 				dep[cur] = dep[father] + 1;
 				treeHead[cur] = treehead;
-				headSiz[treehead]++;
+				setSiz[treehead]++;
 				stjump[cur][0] = father;
 				for (int p = 1; p < MAXH; p++) {
 					stjump[cur][p] = stjump[stjump[cur][p - 1]][p - 1];
@@ -164,48 +200,23 @@ public static void dfs2(int i, int fa, int treeh) {
 		}
 	}
 
-	public static int lca(int a, int b) {
-		if (dep[a] < dep[b]) {
-			int tmp = a;
-			a = b;
-			b = tmp;
-		}
-		for (int p = MAXH - 1; p >= 0; p--) {
-			if (dep[stjump[a][p]] >= dep[b]) {
-				a = stjump[a][p];
-			}
-		}
-		if (a == b) {
-			return a;
-		}
-		for (int p = MAXH - 1; p >= 0; p--) {
-			if (stjump[a][p] != stjump[b][p]) {
-				a = stjump[a][p];
-				b = stjump[b][p];
-			}
-		}
-		return stjump[a][0];
-	}
-
-	public static int queryKth(int x, int y, int k) {
-		int xylca = lca(x, y);
-		int lcafa = stjump[xylca][0];
-		int i = query(k, 1, diff, root[x], root[y], root[xylca], root[lcafa]);
-		return sorted[i];
-	}
-
+	// x所在的树和y所在的树，合并成一棵树
 	public static void connect(int x, int y) {
 		addEdge(x, y);
 		addEdge(y, x);
 		int fx = treeHead[x];
 		int fy = treeHead[y];
-		if (headSiz[fx] >= headSiz[fy]) {
+		if (setSiz[fx] >= setSiz[fy]) {
 			dfs2(y, x, fx); // 调用dfs1的迭代版
 		} else {
 			dfs2(x, y, fy); // 调用dfs1的迭代版
 		}
 	}
 
+	// 离散化
+	// 每棵子树建立可持久化线段树
+	// 记录每个节点的所在子树的头节点
+	// 记录每棵子树的大小
 	public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			sorted[i] = arr[i];
diff --git a/src/class163/Code07_Forest2.java b/src/class163/Code07_Forest2.java
index 769b2377a..eb44da6fe 100644
--- a/src/class163/Code07_Forest2.java
+++ b/src/class163/Code07_Forest2.java
@@ -8,8 +8,7 @@
 // 操作 L x y   : 点x和点y之间连接一条边
 //                题目保证操作后，所有节点仍然是森林
 // 题目要求强制在线，请不要使用离线算法
-// 1 <= n、m、t <= 8 * 10^4
-// 点权 <= 10^9
+// 1 <= n、m、t <= 8 * 10^4    点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3302
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -40,10 +39,11 @@
 //int cntt = 0;
 //
 //int dep[MAXN];
-//int treeHead[MAXN];
-//int headSiz[MAXN];
 //int stjump[MAXN][MAXH];
 //
+//int treeHead[MAXN];
+//int setSiz[MAXN];
+//
 //int kth(int num) {
 //    int left = 1, right = diff, mid;
 //    while (left <= right) {
@@ -94,22 +94,6 @@
 //    }
 //}
 //
-//void dfs(int u, int fa, int treeh) {
-//    root[u] = insert(arr[u], 1, diff, root[fa]);
-//    dep[u] = dep[fa] + 1;
-//    treeHead[u] = treeh;
-//    headSiz[treeh]++;
-//    stjump[u][0] = fa;
-//    for (int p = 1; p < MAXH; p++) {
-//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
-//    }
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        if (to[e] != fa) {
-//            dfs(to[e], u, treeh);
-//        }
-//    }
-//}
-//
 //int lca(int a, int b) {
 //    if (dep[a] < dep[b]) {
 //        int tmp = a;
@@ -140,12 +124,28 @@
 //    return sorted[i];
 //}
 //
+//void dfs(int u, int fa, int treeh) {
+//    root[u] = insert(arr[u], 1, diff, root[fa]);
+//    dep[u] = dep[fa] + 1;
+//    treeHead[u] = treeh;
+//    setSiz[treeh]++;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        if (to[e] != fa) {
+//            dfs(to[e], u, treeh);
+//        }
+//    }
+//}
+//
 //void connect(int x, int y) {
 //    addEdge(x, y);
 //    addEdge(y, x);
 //    int fx = treeHead[x];
 //    int fy = treeHead[y];
-//    if (headSiz[fx] >= headSiz[fy]) {
+//    if (setSiz[fx] >= setSiz[fy]) {
 //        dfs(y, x, fx);
 //    } else {
 //        dfs(x, y, fy);

From 2a7c0a51f38061e9f1ed2761a3810e3e42202c98 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 22 Mar 2025 18:38:03 +0800
Subject: [PATCH 0597/1712] modify code

---
 src/class163/Code06_RearrangePalindrome1.java | 6 +++---
 src/class163/Code06_RearrangePalindrome2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class163/Code06_RearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
index 9cf26071c..b2a8b6c1a 100644
--- a/src/class163/Code06_RearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -76,7 +76,7 @@ public static void cancle(int u) {
 		}
 	}
 
-	public static int cross(int u, int lcaDep) {
+	public static int answerFromLight(int u, int lcaDep) {
 		int ans = 0;
 		if (maxdep[eor[u]] != 0) {
 			ans = Math.max(ans, maxdep[eor[u]] + dep[u] - lcaDep * 2);
@@ -87,7 +87,7 @@ public static int cross(int u, int lcaDep) {
 			}
 		}
 		for (int e = head[u]; e > 0; e = next[e]) {
-			ans = Math.max(ans, cross(to[e], lcaDep));
+			ans = Math.max(ans, answerFromLight(to[e], lcaDep));
 		}
 		return ans;
 	}
@@ -117,7 +117,7 @@ public static void dfs2(int u, int keep) {
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u]) {
-				ans[u] = Math.max(ans[u], cross(v, dep[u]));
+				ans[u] = Math.max(ans[u], answerFromLight(v, dep[u]));
 				effect(v);
 			}
 		}
diff --git a/src/class163/Code06_RearrangePalindrome2.java b/src/class163/Code06_RearrangePalindrome2.java
index c6b520a12..e21e4e647 100644
--- a/src/class163/Code06_RearrangePalindrome2.java
+++ b/src/class163/Code06_RearrangePalindrome2.java
@@ -67,7 +67,7 @@
 //    }
 //}
 //
-//int cross(int u, int lcaDep) {
+//int answerFromLight(int u, int lcaDep) {
 //    int ret = 0;
 //    if (maxdep[eor[u]] != 0) {
 //        ret = max(ret, maxdep[eor[u]] + dep[u] - lcaDep * 2);
@@ -78,7 +78,7 @@
 //        }
 //    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        ret = max(ret, cross(to[e], lcaDep));
+//        ret = max(ret, answerFromLight(to[e], lcaDep));
 //    }
 //    return ret;
 //}
@@ -108,7 +108,7 @@
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u]) {
-//            ans[u] = max(ans[u], cross(v, dep[u]));
+//            ans[u] = max(ans[u], answerFromLight(v, dep[u]));
 //            effect(v);
 //        }
 //    }

From e41752b2814f0a42e131fc02c76e74a48ecc0dac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 22 Mar 2025 18:54:06 +0800
Subject: [PATCH 0598/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index 5e355926e..bccce3625 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -120,8 +120,7 @@ public static void dfs2(int u, int keep) {
 		}
 		// 记录子树u的答案
 		ans[u] = diffColors;
-		// 如果u是上级节点的轻儿子，子树u的贡献取消
-		// 如果u是上级节点的重儿子，子树u的贡献保留
+		// 如果u是上级节点的轻儿子，子树u的贡献取消，否则保留
 		if (keep == 0) {
 			cancle(u);
 		}

From a3e0920d2d3d30ba7afa7cb80e01174e06622455 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 22 Mar 2025 19:06:13 +0800
Subject: [PATCH 0599/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java     | 42 +++++++++++------------
 src/class163/Code01_DsuOnTree2.java     | 40 +++++++++++-----------
 src/class163/Code01_DsuOnTree3.java     | 40 +++++++++++-----------
 src/class163/Code02_ColorBanlance1.java | 28 +++++++--------
 src/class163/Code02_ColorBanlance2.java | 45 +++++++++++--------------
 src/class163/Code02_ColorBanlance3.java | 28 +++++++--------
 src/class163/Code05_BloodCousins1.java  | 20 +++++------
 src/class163/Code05_BloodCousins2.java  | 20 +++++------
 8 files changed, 129 insertions(+), 134 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index bccce3625..db2fe30d8 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -47,6 +47,27 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
+	// 重链剖分
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
 	// 子树u每个节点贡献信息
 	public static void effect(int u) {
 		if (++colorCnt[color[u]] == 1) {
@@ -73,27 +94,6 @@ public static void cancle(int u) {
 		}
 	}
 
-	// 重链剖分
-	public static void dfs1(int u, int f) {
-		fa[u] = f;
-		siz[u] = 1;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				dfs1(v, u);
-			}
-		}
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				siz[u] += siz[v];
-				if (son[u] == 0 || siz[son[u]] < siz[v]) {
-					son[u] = v;
-				}
-			}
-		}
-	}
-
 	// 树上启发式合并的过程
 	public static void dfs2(int u, int keep) {
 		// 遍历轻儿子的子树，统计子树的答案，然后取消贡献
diff --git a/src/class163/Code01_DsuOnTree2.java b/src/class163/Code01_DsuOnTree2.java
index 44446c9a5..60b104998 100644
--- a/src/class163/Code01_DsuOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -37,6 +37,26 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
 	public static void effect(int u) {
 		if (++colorCnt[color[u]] == 1) {
 			diffColors++;
@@ -59,26 +79,6 @@ public static void cancle(int u) {
 		}
 	}
 
-	public static void dfs1(int u, int f) {
-		fa[u] = f;
-		siz[u] = 1;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				dfs1(v, u);
-			}
-		}
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				siz[u] += siz[v];
-				if (son[u] == 0 || siz[son[u]] < siz[v]) {
-					son[u] = v;
-				}
-			}
-		}
-	}
-
 	public static void dfs2(int u, int keep) {
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
diff --git a/src/class163/Code01_DsuOnTree3.java b/src/class163/Code01_DsuOnTree3.java
index 3c1fd3d27..eccf6300e 100644
--- a/src/class163/Code01_DsuOnTree3.java
+++ b/src/class163/Code01_DsuOnTree3.java
@@ -36,6 +36,26 @@
 //    head[u] = cnt;
 //}
 //
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
 //void effect(int u) {
 //    if (++colorCnt[color[u]] == 1) {
 //        diffColors++;
@@ -58,26 +78,6 @@
 //    }
 //}
 //
-//void dfs1(int u, int f) {
-//    fa[u] = f;
-//    siz[u] = 1;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
-//        }
-//    }
-//}
-//
 //void dfs2(int u, int keep) {
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index 67d3ad27e..ba5ce2a70 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -51,6 +51,20 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
+	public static void dfs1(int u) {
+		siz[u] = 1;
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs1(to[e]);
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			siz[u] += siz[v];
+			if (son[u] == 0 || siz[son[u]] < siz[v]) {
+				son[u] = v;
+			}
+		}
+	}
+
 	public static void effect(int u) {
 		colorCnt[color[u]]++;
 		cntCnt[colorCnt[color[u]] - 1]--;
@@ -69,20 +83,6 @@ public static void cancle(int u) {
 		}
 	}
 
-	public static void dfs1(int u) {
-		siz[u] = 1;
-		for (int e = head[u]; e > 0; e = next[e]) {
-			dfs1(to[e]);
-		}
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			siz[u] += siz[v];
-			if (son[u] == 0 || siz[son[u]] < siz[v]) {
-				son[u] = v;
-			}
-		}
-	}
-
 	public static void dfs2(int u, int keep) {
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index b157d70ce..c5b78e9b6 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -1,11 +1,7 @@
 package class163;
 
 // 颜色平衡的子树，java实现迭代版
-// 一共有n个节点，编号1~n，给定每个节点的颜色值和父亲节点编号
-// 输入保证所有节点一定组成一棵树，并且1号节点是树头
-// 如果一棵子树中，存在的每种颜色的节点个数都相同，这棵子树叫颜色平衡树
-// 打印整棵树中有多少个子树是颜色平衡树
-// 1 <= n、颜色值 <= 2 * 10^5
+// 不会改迭代版，去看讲解118，详解了dfs从递归版改迭代版
 // 测试链接 : https://www.luogu.com.cn/problem/P9233
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -37,7 +33,6 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
-	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
 	// stack1、size1、cur1、edge1，用于把effect、cancle、dfs1改成迭代版
 	public static int[][] stack1 = new int[MAXN][2];
 	public static int size1, cur1, edge1;
@@ -72,15 +67,13 @@ public static void pop2() {
 		edge2 = stack2[size2][2];
 	}
 
-	public static void effect(int root) {
+	public static void dfs1(int u) {
 		size1 = 0;
-		push1(root, -1);
+		push1(u, -1);
 		while (size1 > 0) {
 			pop1();
 			if (edge1 == -1) {
-				colorCnt[color[cur1]]++;
-				cntCnt[colorCnt[color[cur1]] - 1]--;
-				cntCnt[colorCnt[color[cur1]]]++;
+				siz[cur1] = 1;
 				edge1 = head[cur1];
 			} else {
 				edge1 = next[edge1];
@@ -88,18 +81,26 @@ public static void effect(int root) {
 			if (edge1 != 0) {
 				push1(cur1, edge1);
 				push1(to[edge1], -1);
+			} else {
+				for (int e = head[cur1], v; e > 0; e = next[e]) {
+					v = to[e];
+					siz[cur1] += siz[v];
+					if (son[cur1] == 0 || siz[son[cur1]] < siz[v]) {
+						son[cur1] = v;
+					}
+				}
 			}
 		}
 	}
 
-	public static void cancle(int root) {
+	public static void effect(int root) {
 		size1 = 0;
 		push1(root, -1);
 		while (size1 > 0) {
 			pop1();
 			if (edge1 == -1) {
-				colorCnt[color[cur1]]--;
-				cntCnt[colorCnt[color[cur1]] + 1]--;
+				colorCnt[color[cur1]]++;
+				cntCnt[colorCnt[color[cur1]] - 1]--;
 				cntCnt[colorCnt[color[cur1]]]++;
 				edge1 = head[cur1];
 			} else {
@@ -112,13 +113,15 @@ public static void cancle(int root) {
 		}
 	}
 
-	public static void dfs1(int u) {
+	public static void cancle(int root) {
 		size1 = 0;
-		push1(u, -1);
+		push1(root, -1);
 		while (size1 > 0) {
 			pop1();
 			if (edge1 == -1) {
-				siz[cur1] = 1;
+				colorCnt[color[cur1]]--;
+				cntCnt[colorCnt[color[cur1]] + 1]--;
+				cntCnt[colorCnt[color[cur1]]]++;
 				edge1 = head[cur1];
 			} else {
 				edge1 = next[edge1];
@@ -126,14 +129,6 @@ public static void dfs1(int u) {
 			if (edge1 != 0) {
 				push1(cur1, edge1);
 				push1(to[edge1], -1);
-			} else {
-				for (int e = head[cur1], v; e > 0; e = next[e]) {
-					v = to[e];
-					siz[cur1] += siz[v];
-					if (son[cur1] == 0 || siz[son[cur1]] < siz[v]) {
-						son[cur1] = v;
-					}
-				}
 			}
 		}
 	}
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
index 72ade8869..8e79c948a 100644
--- a/src/class163/Code02_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -33,6 +33,20 @@
 //    head[u] = cnt;
 //}
 //
+//void dfs1(int u) {
+//    siz[u] = 1;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs1(to[e]);
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        siz[u] += siz[v];
+//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//            son[u] = v;
+//        }
+//    }
+//}
+//
 //void effect(int u) {
 //    colorCnt[color[u]]++;
 //    cntCnt[colorCnt[color[u]] - 1]--;
@@ -51,20 +65,6 @@
 //    }
 //}
 //
-//void dfs1(int u) {
-//    siz[u] = 1;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        dfs1(to[e]);
-//    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        siz[u] += siz[v];
-//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//            son[u] = v;
-//        }
-//    }
-//}
-//
 //void dfs2(int u, int keep) {
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index bd8ce06a6..545895386 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -59,16 +59,6 @@ public static void addQuestion(int u, int i, int k) {
 		headq[u] = cntq;
 	}
 
-	public static int kAncestor(int u, int k) {
-		for (int p = MAXH - 1; p >= 0; p--) {
-			if (k >= 1 << p) {
-				k -= 1 << p;
-				u = stjump[u][p];
-			}
-		}
-		return u;
-	}
-
 	public static void dfs1(int u, int fa) {
 		siz[u] = 1;
 		dep[u] = dep[fa] + 1;
@@ -88,6 +78,16 @@ public static void dfs1(int u, int fa) {
 		}
 	}
 
+	public static int kAncestor(int u, int k) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (k >= 1 << p) {
+				k -= 1 << p;
+				u = stjump[u][p];
+			}
+		}
+		return u;
+	}
+
 	public static void effect(int u) {
 		nodeCnt[dep[u]]++;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index 37c2a4b6f..842c81745 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -54,16 +54,6 @@
 //    headq[u] = cntq;
 //}
 //
-//int kAncestor(int u, int k) {
-//    for (int p = MAXH - 1; p >= 0; p--) {
-//        if (k >= (1 << p)) {
-//            k -= (1 << p);
-//            u = stjump[u][p];
-//        }
-//    }
-//    return u;
-//}
-//
 //void dfs1(int u, int fa) {
 //    siz[u] = 1;
 //    dep[u] = dep[fa] + 1;
@@ -83,6 +73,16 @@
 //    }
 //}
 //
+//int kAncestor(int u, int k) {
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (k >= (1 << p)) {
+//            k -= (1 << p);
+//            u = stjump[u][p];
+//        }
+//    }
+//    return u;
+//}
+//
 //void effect(int u) {
 //    nodeCnt[dep[u]]++;
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {

From a4140543d3a53cf9df06e8ba5c8a0ca960d370b7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 22 Mar 2025 23:02:44 +0800
Subject: [PATCH 0600/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java | 10 +++++-----
 src/class163/Code01_DsuOnTree2.java | 10 +++++-----
 src/class163/Code01_DsuOnTree3.java | 10 +++++-----
 3 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index db2fe30d8..79bfcf359 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -22,7 +22,7 @@ public class Code01_DsuOnTree1 {
 	public static int n, m;
 
 	// 每个节点的颜色
-	public static int[] color = new int[MAXN];
+	public static int[] arr = new int[MAXN];
 
 	// 链式前向星
 	public static int[] head = new int[MAXN];
@@ -70,7 +70,7 @@ public static void dfs1(int u, int f) {
 
 	// 子树u每个节点贡献信息
 	public static void effect(int u) {
-		if (++colorCnt[color[u]] == 1) {
+		if (++colorCnt[arr[u]] == 1) {
 			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -83,7 +83,7 @@ public static void effect(int u) {
 
 	// 子树u每个节点取消贡献
 	public static void cancle(int u) {
-		if (--colorCnt[color[u]] == 0) {
+		if (--colorCnt[arr[u]] == 0) {
 			diffColors--;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -108,7 +108,7 @@ public static void dfs2(int u, int keep) {
 			dfs2(son[u], 1);
 		}
 		// 当前节点贡献信息
-		if (++colorCnt[color[u]] == 1) {
+		if (++colorCnt[arr[u]] == 1) {
 			diffColors++;
 		}
 		// 遍历轻儿子的子树，重新贡献一遍
@@ -142,7 +142,7 @@ public static void main(String[] args) throws IOException {
 		}
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			color[i] = (int) in.nval;
+			arr[i] = (int) in.nval;
 		}
 		dfs1(1, 0);
 		dfs2(1, 0);
diff --git a/src/class163/Code01_DsuOnTree2.java b/src/class163/Code01_DsuOnTree2.java
index 60b104998..95fbf0763 100644
--- a/src/class163/Code01_DsuOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -19,7 +19,7 @@ public class Code01_DsuOnTree2 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
-	public static int[] color = new int[MAXN];
+	public static int[] arr = new int[MAXN];
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
@@ -58,7 +58,7 @@ public static void dfs1(int u, int f) {
 	}
 
 	public static void effect(int u) {
-		if (++colorCnt[color[u]] == 1) {
+		if (++colorCnt[arr[u]] == 1) {
 			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -70,7 +70,7 @@ public static void effect(int u) {
 	}
 
 	public static void cancle(int u) {
-		colorCnt[color[u]] = 0; // 出现任何颜色，直接把该颜色的计数重置为0
+		colorCnt[arr[u]] = 0; // 出现任何颜色，直接把该颜色的计数重置为0
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa[u]) {
@@ -89,7 +89,7 @@ public static void dfs2(int u, int keep) {
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
-		if (++colorCnt[color[u]] == 1) {
+		if (++colorCnt[arr[u]] == 1) {
 			diffColors++;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
@@ -121,7 +121,7 @@ public static void main(String[] args) throws IOException {
 		}
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			color[i] = (int) in.nval;
+			arr[i] = (int) in.nval;
 		}
 		dfs1(1, 0);
 		dfs2(1, 0);
diff --git a/src/class163/Code01_DsuOnTree3.java b/src/class163/Code01_DsuOnTree3.java
index eccf6300e..5bb8dfebf 100644
--- a/src/class163/Code01_DsuOnTree3.java
+++ b/src/class163/Code01_DsuOnTree3.java
@@ -15,7 +15,7 @@
 //
 //const int MAXN = 100001;
 //int n, m;
-//int color[MAXN];
+//int arr[MAXN];
 //
 //int head[MAXN];
 //int nxt[MAXN << 1];
@@ -57,7 +57,7 @@
 //}
 //
 //void effect(int u) {
-//    if (++colorCnt[color[u]] == 1) {
+//    if (++colorCnt[arr[u]] == 1) {
 //        diffColors++;
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
@@ -69,7 +69,7 @@
 //}
 //
 //void cancle(int u) {
-//    colorCnt[color[u]] = 0;
+//    colorCnt[arr[u]] = 0;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != fa[u]) {
@@ -88,7 +88,7 @@
 //    if (son[u] != 0) {
 //        dfs2(son[u], 1);
 //    }
-//    if (++colorCnt[color[u]] == 1) {
+//    if (++colorCnt[arr[u]] == 1) {
 //        diffColors++;
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
@@ -114,7 +114,7 @@
 //        addEdge(v, u);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        cin >> color[i];
+//        cin >> arr[i];
 //    }
 //    dfs1(1, 0);
 //    dfs2(1, 0);

From 7ca7fbbab7cc835c2fafc8edb2841d429e619021 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 14:51:57 +0800
Subject: [PATCH 0601/1712] modify code

---
 src/class163/Code04_DifferntName1.java | 18 +++++++++---------
 src/class163/Code04_DifferntName2.java | 18 +++++++++---------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
index 0477bbc86..697eca76c 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -46,16 +46,16 @@ public class Code04_DifferntName1 {
 	public static int[] dep = new int[MAXN];
 	public static int[] son = new int[MAXN];
 
-	public static HashMap<String, Integer> nameToId = new HashMap<>();
+	public static HashMap<String, Integer> nameId = new HashMap<>();
 	public static ArrayList<HashSet<Integer>> depSet = new ArrayList<>();
 	public static int[] ans = new int[MAXN];
 
-	public static int nameId(String name) {
-		if (nameToId.containsKey(name)) {
-			return nameToId.get(name);
+	public static int getNameId(String name) {
+		if (nameId.containsKey(name)) {
+			return nameId.get(name);
 		}
-		nameToId.put(name, nameToId.size() + 1);
-		return nameToId.size();
+		nameId.put(name, nameId.size() + 1);
+		return nameId.size();
 	}
 
 	public static void addId(int deep, int id) {
@@ -66,7 +66,7 @@ public static void removeId(int deep, int id) {
 		depSet.get(deep).remove(id);
 	}
 
-	public static int sizeOfId(int deep) {
+	public static int sizeOfDeep(int deep) {
 		if (deep > n) {
 			return 0;
 		}
@@ -134,7 +134,7 @@ public static void dfs2(int u, int keep) {
 			}
 		}
 		for (int i = headq[u]; i > 0; i = nextq[i]) {
-			ans[ansiq[i]] = sizeOfId(dep[u] + kq[i]);
+			ans[ansiq[i]] = sizeOfDeep(dep[u] + kq[i]);
 		}
 		if (keep == 0) {
 			cancle(u);
@@ -149,7 +149,7 @@ public static void main(String[] args) throws IOException {
 		for (int i = 1; i <= n; i++) {
 			name = io.next();
 			father = io.nextInt();
-			id[i] = nameId(name);
+			id[i] = getNameId(name);
 			if (father == 0) {
 				root[i] = true;
 			} else {
diff --git a/src/class163/Code04_DifferntName2.java b/src/class163/Code04_DifferntName2.java
index f2309759c..5cdd045af 100644
--- a/src/class163/Code04_DifferntName2.java
+++ b/src/class163/Code04_DifferntName2.java
@@ -36,16 +36,16 @@
 //int siz[MAXN];
 //int dep[MAXN];
 //int son[MAXN];
-//unordered_map<string, int> nameToId;
+//unordered_map<string, int> nameId;
 //vector<unordered_set<int>> depSet;
 //int ans[MAXN];
 //
-//int nameId(const string &name) {
-//    if (nameToId.find(name) != nameToId.end()) {
-//        return nameToId[name];
+//int getNameId(const string &name) {
+//    if (nameId.find(name) != nameId.end()) {
+//        return nameId[name];
 //    }
-//    int newId = nameToId.size() + 1;
-//    nameToId[name] = newId;
+//    int newId = nameId.size() + 1;
+//    nameId[name] = newId;
 //    return newId;
 //}
 //
@@ -57,7 +57,7 @@
 //    depSet[deep].erase(id);
 //}
 //
-//int sizeOfId(int deep) {
+//int sizeOfDeep(int deep) {
 //    if (deep > n) {
 //        return 0;
 //    }
@@ -125,7 +125,7 @@
 //        }
 //    }
 //    for (int i = headq[u]; i > 0; i = nextq[i]) {
-//    	ans[ansiq[i]] = sizeOfId(dep[u] + kq[i]);
+//    	ans[ansiq[i]] = sizeOfDeep(dep[u] + kq[i]);
 //    }
 //    if (keep == 0) {
 //        cancle(u);
@@ -140,7 +140,7 @@
 //    int father;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> name >> father;
-//        id[i] = nameId(name);
+//        id[i] = getNameId(name);
 //        if (father == 0) {
 //        	root[i] = true;
 //        } else {

From 68675f44a0dce8b4497bfd6e01bc601c8c112bc7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 16:17:43 +0800
Subject: [PATCH 0602/1712] modify code

---
 src/class163/Code02_ColorBanlance1.java | 18 +++++++++---------
 src/class163/Code02_ColorBanlance2.java | 16 ++++++++--------
 src/class163/Code02_ColorBanlance3.java | 16 ++++++++--------
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index ba5ce2a70..97cd88f75 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -40,8 +40,8 @@ public class Code02_ColorBanlance1 {
 	// 启发式合并
 	// colorCnt[i] = j，表示i这种颜色出现了j次
 	public static int[] colorCnt = new int[MAXN];
-	// cntCnt[i] = j，表示出现次数为i的颜色一共有j种
-	public static int[] cntCnt = new int[MAXN];
+	// colorNum[i] = j，表示出现次数为i的颜色一共有j种
+	public static int[] colorNum = new int[MAXN];
 	// 颜色平衡子树的个数
 	public static int ans = 0;
 
@@ -67,8 +67,8 @@ public static void dfs1(int u) {
 
 	public static void effect(int u) {
 		colorCnt[color[u]]++;
-		cntCnt[colorCnt[color[u]] - 1]--;
-		cntCnt[colorCnt[color[u]]]++;
+		colorNum[colorCnt[color[u]] - 1]--;
+		colorNum[colorCnt[color[u]]]++;
 		for (int e = head[u]; e > 0; e = next[e]) {
 			effect(to[e]);
 		}
@@ -76,8 +76,8 @@ public static void effect(int u) {
 
 	public static void cancle(int u) {
 		colorCnt[color[u]]--;
-		cntCnt[colorCnt[color[u]] + 1]--;
-		cntCnt[colorCnt[color[u]]]++;
+		colorNum[colorCnt[color[u]] + 1]--;
+		colorNum[colorCnt[color[u]]]++;
 		for (int e = head[u]; e > 0; e = next[e]) {
 			cancle(to[e]);
 		}
@@ -94,15 +94,15 @@ public static void dfs2(int u, int keep) {
 			dfs2(son[u], 1);
 		}
 		colorCnt[color[u]]++;
-		cntCnt[colorCnt[color[u]] - 1]--;
-		cntCnt[colorCnt[color[u]]]++;
+		colorNum[colorCnt[color[u]] - 1]--;
+		colorNum[colorCnt[color[u]]]++;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u]) {
 				effect(v);
 			}
 		}
-		if (colorCnt[color[u]] * cntCnt[colorCnt[color[u]]] == siz[u]) {
+		if (colorCnt[color[u]] * colorNum[colorCnt[color[u]]] == siz[u]) {
 			ans++;
 		}
 		if (keep == 0) {
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index c5b78e9b6..b18f54cc7 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -24,7 +24,7 @@ public class Code02_ColorBanlance2 {
 	public static int[] siz = new int[MAXN];
 	public static int[] son = new int[MAXN];
 	public static int[] colorCnt = new int[MAXN];
-	public static int[] cntCnt = new int[MAXN];
+	public static int[] colorNum = new int[MAXN];
 	public static int ans = 0;
 
 	public static void addEdge(int u, int v) {
@@ -100,8 +100,8 @@ public static void effect(int root) {
 			pop1();
 			if (edge1 == -1) {
 				colorCnt[color[cur1]]++;
-				cntCnt[colorCnt[color[cur1]] - 1]--;
-				cntCnt[colorCnt[color[cur1]]]++;
+				colorNum[colorCnt[color[cur1]] - 1]--;
+				colorNum[colorCnt[color[cur1]]]++;
 				edge1 = head[cur1];
 			} else {
 				edge1 = next[edge1];
@@ -120,8 +120,8 @@ public static void cancle(int root) {
 			pop1();
 			if (edge1 == -1) {
 				colorCnt[color[cur1]]--;
-				cntCnt[colorCnt[color[cur1]] + 1]--;
-				cntCnt[colorCnt[color[cur1]]]++;
+				colorNum[colorCnt[color[cur1]] + 1]--;
+				colorNum[colorCnt[color[cur1]]]++;
 				edge1 = head[cur1];
 			} else {
 				edge1 = next[edge1];
@@ -162,15 +162,15 @@ public static void dfs2(int u, int keep) {
 				}
 			} else {
 				colorCnt[color[cur2]]++;
-				cntCnt[colorCnt[color[cur2]] - 1]--;
-				cntCnt[colorCnt[color[cur2]]]++;
+				colorNum[colorCnt[color[cur2]] - 1]--;
+				colorNum[colorCnt[color[cur2]]]++;
 				for (int e = head[cur2], v; e > 0; e = next[e]) {
 					v = to[e];
 					if (v != son[cur2]) {
 						effect(v);
 					}
 				}
-				if (colorCnt[color[cur2]] * cntCnt[colorCnt[color[cur2]]] == siz[cur2]) {
+				if (colorCnt[color[cur2]] * colorNum[colorCnt[color[cur2]]] == siz[cur2]) {
 					ans++;
 				}
 				if (keep2 == 0) {
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
index 8e79c948a..d622af603 100644
--- a/src/class163/Code02_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -24,7 +24,7 @@
 //int siz[MAXN];
 //int son[MAXN];
 //int colorCnt[MAXN];
-//int cntCnt[MAXN];
+//int colorNum[MAXN];
 //int ans = 0;
 //
 //void addEdge(int u, int v) {
@@ -49,8 +49,8 @@
 //
 //void effect(int u) {
 //    colorCnt[color[u]]++;
-//    cntCnt[colorCnt[color[u]] - 1]--;
-//    cntCnt[colorCnt[color[u]]]++;
+//    colorNum[colorCnt[color[u]] - 1]--;
+//    colorNum[colorCnt[color[u]]]++;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        effect(to[e]);
 //    }
@@ -58,8 +58,8 @@
 //
 //void cancle(int u) {
 //    colorCnt[color[u]]--;
-//    cntCnt[colorCnt[color[u]] + 1]--;
-//    cntCnt[colorCnt[color[u]]]++;
+//    colorNum[colorCnt[color[u]] + 1]--;
+//    colorNum[colorCnt[color[u]]]++;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        cancle(to[e]);
 //    }
@@ -76,15 +76,15 @@
 //        dfs2(son[u], 1);
 //    }
 //    colorCnt[color[u]]++;
-//    cntCnt[colorCnt[color[u]] - 1]--;
-//    cntCnt[colorCnt[color[u]]]++;
+//    colorNum[colorCnt[color[u]] - 1]--;
+//    colorNum[colorCnt[color[u]]]++;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u]) {
 //            effect(v);
 //        }
 //    }
-//    if (colorCnt[color[u]] * cntCnt[colorCnt[color[u]]] == siz[u]) {
+//    if (colorCnt[color[u]] * colorNum[colorCnt[color[u]]] == siz[u]) {
 //        ans++;
 //    }
 //    if (keep == 0) {

From 9554ea897a292f27c81a89e6017fc72182031efd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 16:20:03 +0800
Subject: [PATCH 0603/1712] modify code

---
 src/class163/Code02_ColorBanlance1.java | 6 ------
 1 file changed, 6 deletions(-)

diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index 97cd88f75..382d19ba8 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -21,23 +21,17 @@
 public class Code02_ColorBanlance1 {
 
 	public static int MAXN = 200001;
-
 	public static int n;
-
-	// 每个节点的颜色
 	public static int[] color = new int[MAXN];
 
-	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
 	public static int[] to = new int[MAXN];
 	public static int cnt = 0;
 
-	// 树链剖分
 	public static int[] siz = new int[MAXN];
 	public static int[] son = new int[MAXN];
 
-	// 启发式合并
 	// colorCnt[i] = j，表示i这种颜色出现了j次
 	public static int[] colorCnt = new int[MAXN];
 	// colorNum[i] = j，表示出现次数为i的颜色一共有j种

From b47251d6bc55f2802c439ae684d994c4649308f2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 16:21:04 +0800
Subject: [PATCH 0604/1712] modify code

---
 src/class163/Code02_ColorBanlance2.java | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index b18f54cc7..721ad2a13 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -33,11 +33,13 @@ public static void addEdge(int u, int v) {
 		head[u] = cnt;
 	}
 
-	// stack1、size1、cur1、edge1，用于把effect、cancle、dfs1改成迭代版
+	// stack1、size1、cur1、edge1
+	// 用于把effect、cancle、dfs1改成迭代版
 	public static int[][] stack1 = new int[MAXN][2];
 	public static int size1, cur1, edge1;
 
-	// stack2、size2、cur2、edge2、keep2，用于把dfs2改成迭代版
+	// stack2、size2、cur2、keep2、edge2
+	// 用于把dfs2改成迭代版
 	public static int[][] stack2 = new int[MAXN][3];
 	public static int size2, cur2, keep2, edge2;
 

From fb02cd96a4c4e3ab4223b7538cef3aedfe491d60 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 18:48:38 +0800
Subject: [PATCH 0605/1712] modify code

---
 src/class163/Code04_DifferntName1.java | 7 ++++++-
 src/class163/Code04_DifferntName2.java | 4 +++-
 2 files changed, 9 insertions(+), 2 deletions(-)

diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
index 697eca76c..1d6d6115d 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -27,26 +27,31 @@ public class Code04_DifferntName1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
+
+	public static HashMap<String, Integer> nameId = new HashMap<>();
 	public static boolean[] root = new boolean[MAXN];
 	public static int[] id = new int[MAXN];
 
+	// 链式前向星
 	public static int[] headg = new int[MAXN];
 	public static int[] nextg = new int[MAXN];
 	public static int[] tog = new int[MAXN];
 	public static int cntg;
 
+	// 问题列表
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN];
 	public static int[] ansiq = new int[MAXN];
 	public static int[] kq = new int[MAXN];
 	public static int cntq;
 
+	// 树链剖分
 	public static int[] fa = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] dep = new int[MAXN];
 	public static int[] son = new int[MAXN];
 
-	public static HashMap<String, Integer> nameId = new HashMap<>();
+	// 树上启发式合并
 	public static ArrayList<HashSet<Integer>> depSet = new ArrayList<>();
 	public static int[] ans = new int[MAXN];
 
diff --git a/src/class163/Code04_DifferntName2.java b/src/class163/Code04_DifferntName2.java
index 5cdd045af..035a3dac8 100644
--- a/src/class163/Code04_DifferntName2.java
+++ b/src/class163/Code04_DifferntName2.java
@@ -18,6 +18,8 @@
 //
 //const int MAXN = 100001;
 //int n, m;
+//
+//unordered_map<string, int> nameId;
 //bool root[MAXN];
 //int id[MAXN];
 //
@@ -36,7 +38,7 @@
 //int siz[MAXN];
 //int dep[MAXN];
 //int son[MAXN];
-//unordered_map<string, int> nameId;
+//
 //vector<unordered_set<int>> depSet;
 //int ans[MAXN];
 //

From 7ade0b3b007e2f98d62b65f09414ef23751b25b3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 18:55:27 +0800
Subject: [PATCH 0606/1712] modify code

---
 src/class163/Code05_BloodCousins1.java | 15 +++++++++------
 src/class163/Code05_BloodCousins2.java | 12 ++++++------
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 545895386..5459c91d5 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -24,26 +24,29 @@ public class Code05_BloodCousins1 {
 	public static int MAXN = 100001;
 	public static int MAXH = 20;
 	public static int n, m;
-
 	public static boolean[] root = new boolean[MAXN];
 
+	// 链式前向星
 	public static int[] headg = new int[MAXN];
 	public static int[] nextg = new int[MAXN];
 	public static int[] tog = new int[MAXN];
 	public static int cntg;
 
+	// 问题列表
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN];
 	public static int[] ansiq = new int[MAXN];
 	public static int[] kq = new int[MAXN];
 	public static int cntq;
 
+	// 树链剖分
 	public static int[] siz = new int[MAXN];
 	public static int[] dep = new int[MAXN];
 	public static int[] son = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXH];
 
-	public static int[] nodeCnt = new int[MAXN];
+	// 树上启发式合并
+	public static int[] depCnt = new int[MAXN];
 	public static int[] ans = new int[MAXN];
 
 	public static void addEdge(int u, int v) {
@@ -89,14 +92,14 @@ public static int kAncestor(int u, int k) {
 	}
 
 	public static void effect(int u) {
-		nodeCnt[dep[u]]++;
+		depCnt[dep[u]]++;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			effect(tog[e]);
 		}
 	}
 
 	public static void cancle(int u) {
-		nodeCnt[dep[u]]--;
+		depCnt[dep[u]]--;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			cancle(tog[e]);
 		}
@@ -112,7 +115,7 @@ public static void dfs2(int u, int keep) {
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
-		nodeCnt[dep[u]]++;
+		depCnt[dep[u]]++;
 		for (int e = headg[u], v; e > 0; e = nextg[e]) {
 			v = tog[e];
 			if (v != son[u]) {
@@ -120,7 +123,7 @@ public static void dfs2(int u, int keep) {
 			}
 		}
 		for (int i = headq[u]; i > 0; i = nextq[i]) {
-			ans[ansiq[i]] = nodeCnt[dep[u] + kq[i]];
+			ans[ansiq[i]] = depCnt[dep[u] + kq[i]];
 		}
 		if (keep == 0) {
 			cancle(u);
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index 842c81745..d991d176a 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -20,8 +20,8 @@
 //const int MAXN = 100001;
 //const int MAXH = 20;
 //int n, m;
-//
 //bool root[MAXN];
+//
 //int headg[MAXN];
 //int nextg[MAXN];
 //int tog[MAXN];
@@ -38,7 +38,7 @@
 //int son[MAXN];
 //int stjump[MAXN][MAXH];
 //
-//int nodeCnt[MAXN];
+//int depCnt[MAXN];
 //int ans[MAXN];
 //
 //void addEdge(int u, int v) {
@@ -84,14 +84,14 @@
 //}
 //
 //void effect(int u) {
-//    nodeCnt[dep[u]]++;
+//    depCnt[dep[u]]++;
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {
 //        effect(tog[e]);
 //    }
 //}
 //
 //void cancle(int u) {
-//    nodeCnt[dep[u]]--;
+//    depCnt[dep[u]]--;
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {
 //        cancle(tog[e]);
 //    }
@@ -107,7 +107,7 @@
 //    if (son[u] != 0) {
 //        dfs2(son[u], 1);
 //    }
-//    nodeCnt[dep[u]]++;
+//    depCnt[dep[u]]++;
 //    for (int e = headg[u], v; e > 0; e = nextg[e]) {
 //        v = tog[e];
 //        if (v != son[u]) {
@@ -115,7 +115,7 @@
 //        }
 //    }
 //    for (int i = headq[u]; i > 0; i = nextq[i]) {
-//    	ans[ansiq[i]] = nodeCnt[dep[u] + kq[i]];
+//    	ans[ansiq[i]] = depCnt[dep[u] + kq[i]];
 //    }
 //    if (keep == 0) {
 //        cancle(u);

From 1ac15b4003e483454544e93e61e9a00681ae9a49 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 20:13:14 +0800
Subject: [PATCH 0607/1712] modify code

---
 src/class163/Code06_RearrangePalindrome1.java | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/class163/Code06_RearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
index b2a8b6c1a..6ac7a625f 100644
--- a/src/class163/Code06_RearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -102,9 +102,12 @@ public static void dfs2(int u, int keep) {
 		if (son[u] != 0) {
 			dfs2(son[u], 1);
 		}
+		// 每一个儿子的子树，里得到的答案
 		for (int e = head[u]; e > 0; e = next[e]) {
 			ans[u] = Math.max(ans[u], ans[to[e]]);
 		}
+		// 选择当前节点，再选择重儿子树上的任意一点，得到的答案
+		// 枚举所有可能得到的异或值
 		if (maxdep[eor[u]] != 0) {
 			ans[u] = Math.max(ans[u], maxdep[eor[u]] - dep[u]);
 		}
@@ -113,7 +116,9 @@ public static void dfs2(int u, int keep) {
 				ans[u] = Math.max(ans[u], maxdep[eor[u] ^ (1 << i)] - dep[u]);
 			}
 		}
+		// 当前点的异或值，更新最大深度信息
 		maxdep[eor[u]] = Math.max(maxdep[eor[u]], dep[u]);
+		// 选择遍历过的部分里的任意一点，再选择当前遍历到的子树里的任意一点，得到的答案
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u]) {

From c90ea6210fca2ddf660e6803b59a329e3401e7b1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 22:56:40 +0800
Subject: [PATCH 0608/1712] modify code

---
 src/class163/Code06_RearrangePalindrome1.java | 14 ++++++--------
 src/class163/Code06_RearrangePalindrome2.java | 12 +++++-------
 2 files changed, 11 insertions(+), 15 deletions(-)

diff --git a/src/class163/Code06_RearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
index 6ac7a625f..fc4a14eff 100644
--- a/src/class163/Code06_RearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -35,7 +35,7 @@ public class Code06_RearrangePalindrome1 {
 	public static int[] eor = new int[MAXN];
 	public static int[] son = new int[MAXN];
 
-	// 统计答案
+	// 树上启发式合并
 	public static int[] maxdep = new int[1 << MAXV];
 	public static int[] ans = new int[MAXN];
 
@@ -76,20 +76,18 @@ public static void cancle(int u) {
 		}
 	}
 
-	public static int answerFromLight(int u, int lcaDep) {
-		int ans = 0;
+	public static void answerFromLight(int u, int h) {
 		if (maxdep[eor[u]] != 0) {
-			ans = Math.max(ans, maxdep[eor[u]] + dep[u] - lcaDep * 2);
+			ans[h] = Math.max(ans[h], maxdep[eor[u]] + dep[u] - dep[h] * 2);
 		}
 		for (int i = 0; i < MAXV; i++) {
 			if (maxdep[eor[u] ^ (1 << i)] != 0) {
-				ans = Math.max(ans, maxdep[eor[u] ^ (1 << i)] + dep[u] - lcaDep * 2);
+				ans[h] = Math.max(ans[h], maxdep[eor[u] ^ (1 << i)] + dep[u] - dep[h] * 2);
 			}
 		}
 		for (int e = head[u]; e > 0; e = next[e]) {
-			ans = Math.max(ans, answerFromLight(to[e], lcaDep));
+			answerFromLight(to[e], h);
 		}
-		return ans;
 	}
 
 	public static void dfs2(int u, int keep) {
@@ -122,7 +120,7 @@ public static void dfs2(int u, int keep) {
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != son[u]) {
-				ans[u] = Math.max(ans[u], answerFromLight(v, dep[u]));
+				answerFromLight(v, u);
 				effect(v);
 			}
 		}
diff --git a/src/class163/Code06_RearrangePalindrome2.java b/src/class163/Code06_RearrangePalindrome2.java
index e21e4e647..9e62d0db8 100644
--- a/src/class163/Code06_RearrangePalindrome2.java
+++ b/src/class163/Code06_RearrangePalindrome2.java
@@ -67,20 +67,18 @@
 //    }
 //}
 //
-//int answerFromLight(int u, int lcaDep) {
-//    int ret = 0;
+//void answerFromLight(int u, int h) {
 //    if (maxdep[eor[u]] != 0) {
-//        ret = max(ret, maxdep[eor[u]] + dep[u] - lcaDep * 2);
+//        ans[h] = max(ans[h], maxdep[eor[u]] + dep[u] - dep[h] * 2);
 //    }
 //    for (int i = 0; i < MAXV; i++) {
 //        if (maxdep[eor[u] ^ (1 << i)] != 0) {
-//            ret = max(ret, maxdep[eor[u] ^ (1 << i)] + dep[u] - lcaDep * 2);
+//            ans[h] = max(ans[h], maxdep[eor[u] ^ (1 << i)] + dep[u] - dep[h] * 2);
 //        }
 //    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        ret = max(ret, answerFromLight(to[e], lcaDep));
+//        answerFromLight(to[e], h);
 //    }
-//    return ret;
 //}
 //
 //void dfs2(int u, int keep) {
@@ -108,7 +106,7 @@
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != son[u]) {
-//            ans[u] = max(ans[u], answerFromLight(v, dep[u]));
+//            answerFromLight(v, u);
 //            effect(v);
 //        }
 //    }

From 7660da6b8f4e8a5f97ab336283df5e8e75ef201c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 22:59:54 +0800
Subject: [PATCH 0609/1712] modify code

---
 src/class163/Code06_RearrangePalindrome1.java | 14 +++++++-------
 src/class163/Code06_RearrangePalindrome2.java | 14 +++++++-------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class163/Code06_RearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
index fc4a14eff..7467426ef 100644
--- a/src/class163/Code06_RearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -76,17 +76,17 @@ public static void cancle(int u) {
 		}
 	}
 
-	public static void answerFromLight(int u, int h) {
-		if (maxdep[eor[u]] != 0) {
-			ans[h] = Math.max(ans[h], maxdep[eor[u]] + dep[u] - dep[h] * 2);
+	public static void answerFromLight(int light, int u) {
+		if (maxdep[eor[light]] != 0) {
+			ans[u] = Math.max(ans[u], maxdep[eor[light]] + dep[light] - dep[u] * 2);
 		}
 		for (int i = 0; i < MAXV; i++) {
-			if (maxdep[eor[u] ^ (1 << i)] != 0) {
-				ans[h] = Math.max(ans[h], maxdep[eor[u] ^ (1 << i)] + dep[u] - dep[h] * 2);
+			if (maxdep[eor[light] ^ (1 << i)] != 0) {
+				ans[u] = Math.max(ans[u], maxdep[eor[light] ^ (1 << i)] + dep[light] - dep[u] * 2);
 			}
 		}
-		for (int e = head[u]; e > 0; e = next[e]) {
-			answerFromLight(to[e], h);
+		for (int e = head[light]; e > 0; e = next[e]) {
+			answerFromLight(to[e], u);
 		}
 	}
 
diff --git a/src/class163/Code06_RearrangePalindrome2.java b/src/class163/Code06_RearrangePalindrome2.java
index 9e62d0db8..9f97f353a 100644
--- a/src/class163/Code06_RearrangePalindrome2.java
+++ b/src/class163/Code06_RearrangePalindrome2.java
@@ -67,17 +67,17 @@
 //    }
 //}
 //
-//void answerFromLight(int u, int h) {
-//    if (maxdep[eor[u]] != 0) {
-//        ans[h] = max(ans[h], maxdep[eor[u]] + dep[u] - dep[h] * 2);
+//void answerFromLight(int light, int u) {
+//    if (maxdep[eor[light]] != 0) {
+//        ans[u] = max(ans[u], maxdep[eor[light]] + dep[light] - dep[u] * 2);
 //    }
 //    for (int i = 0; i < MAXV; i++) {
-//        if (maxdep[eor[u] ^ (1 << i)] != 0) {
-//            ans[h] = max(ans[h], maxdep[eor[u] ^ (1 << i)] + dep[u] - dep[h] * 2);
+//        if (maxdep[eor[light] ^ (1 << i)] != 0) {
+//            ans[u] = max(ans[u], maxdep[eor[light] ^ (1 << i)] + dep[light] - dep[u] * 2);
 //        }
 //    }
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        answerFromLight(to[e], h);
+//    for (int e = head[light]; e > 0; e = nxt[e]) {
+//        answerFromLight(to[e], u);
 //    }
 //}
 //

From a9564aefe5b8e75ab52eaf585e1efd7fb5669c82 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 23 Mar 2025 23:48:32 +0800
Subject: [PATCH 0610/1712] modify code

---
 ...70\345\205\263\351\242\230\347\233\256.pptx" | Bin 0 -> 56040 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243163\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\344\270\212\345\220\257\345\217\221\345\274\217\345\220\210\345\271\266\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243163\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\344\270\212\345\220\257\345\217\221\345\274\217\345\220\210\345\271\266\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243163\343\200\220\346\214\272\351\232\276\343\200\221\346\240\221\344\270\212\345\220\257\345\217\221\345\274\217\345\220\210\345\271\266\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..4f93db08743c2f8e3ff722464770391d5e6a95b3
GIT binary patch
literal 56040
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%0ABoXk#4(<HPgPPfyhFx
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

literal 0
HcmV?d00001


From 10d4547e2467e60d03ea167c13ba2d6359364dd1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 24 Mar 2025 12:33:09 +0800
Subject: [PATCH 0611/1712] modify code

---
 src/class104/Code04_TopKOddLengthProduct.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class104/Code04_TopKOddLengthProduct.java b/src/class104/Code04_TopKOddLengthProduct.java
index 8d483ee79..e7afc2910 100644
--- a/src/class104/Code04_TopKOddLengthProduct.java
+++ b/src/class104/Code04_TopKOddLengthProduct.java
@@ -53,12 +53,12 @@ public static int compute(String s) {
 		}
 		long ans = 1;
 		long sum = 0;
-		for (int len = (m & 1) == 1 ? m : (m - 1); len >= 0 && k >= 0; len -= 2) {
+		for (int len = (m & 1) == 1 ? m : (m - 1); len >= 1 && k > 0; len -= 2) {
 			sum += cnt[len];
 			ans = (ans * power(len, Math.min(k, sum))) % MOD;
 			k -= sum;
 		}
-		return k < 0 ? (int) ans : -1;
+		return k > 0 ? -1 : (int)ans;
 	}
 
 	public static void manacher(String str) {

From fa54d0479ffd15ad05fd053ae82996b53b201451 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 25 Mar 2025 23:14:41 +0800
Subject: [PATCH 0612/1712] modify code

---
 src/class164/Code01_KruskalRebuildTree1.java | 304 +++++++++++++++++++
 src/class164/Code01_KruskalRebuildTree2.java | 142 +++++++++
 2 files changed, 446 insertions(+)
 create mode 100644 src/class164/Code01_KruskalRebuildTree1.java
 create mode 100644 src/class164/Code01_KruskalRebuildTree2.java

diff --git a/src/class164/Code01_KruskalRebuildTree1.java b/src/class164/Code01_KruskalRebuildTree1.java
new file mode 100644
index 000000000..3f2d09274
--- /dev/null
+++ b/src/class164/Code01_KruskalRebuildTree1.java
@@ -0,0 +1,304 @@
+package class164;
+
+// Kruskal重构树模版题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2245
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class Code01_KruskalRebuildTree1 {
+
+	public static int MAXN = 200001;
+	public static int MAXM = 300001;
+	public static int n, m, q;
+	public static int[][] arr = new int[MAXM][3];
+
+	// 并查集
+	public static int[] father = new int[MAXN];
+	public static int[] nodeKey = new int[MAXN];
+	public static int cnth = 0;
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
+	public static int cntg = 0;
+
+	// 树链剖分
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(arr, 1, m + 1, (a, b) -> a[2] - b[2]);
+		cnth = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(arr[i][0]);
+			fy = find(arr[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cnth;
+				father[cnth] = cnth;
+				nodeKey[cnth] = arr[i][2];
+				addEdge(cnth, fx);
+				addEdge(cnth, fy);
+			}
+		}
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3(int u, int f) {
+		stacksize = 0;
+		push(u, f, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4(int u, int t) {
+		stacksize = 0;
+		push(u, t, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		while (top[a] != top[b]) {
+			if (dep[top[a]] <= dep[top[b]]) {
+				b = fa[top[b]];
+			} else {
+				a = fa[top[a]];
+			}
+		}
+		return dep[a] <= dep[b] ? a : b;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1; i <= m; i++) {
+			arr[i][0] = io.nextInt();
+			arr[i][1] = io.nextInt();
+			arr[i][2] = io.nextInt();
+		}
+		kruskalRebuild();
+		for (int i = 1; i <= cnth; i++) {
+			if (i == father[i]) {
+				dfs3(i, 0); // 防止递归爆栈，所以调用dfs1的迭代版
+				dfs4(i, i); // 防止递归爆栈，所以调用dfs2的迭代版
+			}
+		}
+		q = io.nextInt();
+		for (int i = 1, x, y; i <= q; i++) {
+			x = io.nextInt();
+			y = io.nextInt();
+			if (find(x) != find(y)) {
+				io.write("impossible\n");
+			} else {
+				io.writelnInt(nodeKey[lca(x, y)]);
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class164/Code01_KruskalRebuildTree2.java b/src/class164/Code01_KruskalRebuildTree2.java
new file mode 100644
index 000000000..069e9ec6e
--- /dev/null
+++ b/src/class164/Code01_KruskalRebuildTree2.java
@@ -0,0 +1,142 @@
+package class164;
+
+// Kruskal重构树模版题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2245
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//	int u, v, w;
+//};
+//
+//const int MAXN = 200001;
+//const int MAXM = 300001;
+//int n, m, q;
+//Edge arr[MAXM];
+//
+//int father[MAXN];
+//int nodeKey[MAXN];
+//int cnth = 0;
+//
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cntg = 0;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//
+//bool cmp(Edge x, Edge y) {
+//	return x.w < y.w;
+//}
+//
+//int find(int i) {
+//	if(i != father[i]) {
+//		father[i] = find(father[i]);
+//	}
+//	return father[i];
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void kruskalRebuild() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(arr + 1, arr + m + 1, cmp);
+//    cnth = n;
+//    for (int i = 1, fx, fy; i <= m; i++) {
+//        fx = find(arr[i].u);
+//        fy = find(arr[i].v);
+//        if (fx != fy) {
+//            father[fx] = father[fy] = ++cnth;
+//            father[cnth] = cnth;
+//            nodeKey[cnth] = arr[i].w;
+//            addEdge(cnth, fx);
+//            addEdge(cnth, fy);
+//        }
+//    }
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    if (son[u] == 0) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    while (top[a] != top[b]) {
+//        if (dep[top[a]] <= dep[top[b]]) {
+//            b = fa[top[b]];
+//        } else {
+//            a = fa[top[a]];
+//        }
+//    }
+//    return dep[a] <= dep[b] ? a : b;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> arr[i].u >> arr[i].v >> arr[i].w;
+//    }
+//    kruskalRebuild();
+//    for (int i = 1; i <= cnth; i++) {
+//        if (i == father[i]) {
+//            dfs1(i, 0);
+//            dfs2(i, i);
+//        }
+//    }
+//    cin >> q;
+//    for (int i = 1, x, y; i <= q; i++) {
+//        cin >> x >> y;
+//        if (find(x) != find(y)) {
+//            cout << "impossible\n";
+//        } else {
+//            cout << nodeKey[lca(x, y)] << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 8c513e1f346122ccc4b1870fe7f23692b55fcd63 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Mar 2025 15:39:51 +0800
Subject: [PATCH 0613/1712] modify code

---
 ...346\237\245\351\233\206-\344\270\212.pptx" | Bin 47133 -> 47167 bytes
 ...346\237\245\351\233\206-\344\270\213.pptx" | Bin 43666 -> 43628 bytes
 2 files changed, 0 insertions(+), 0 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243056\343\200\220\345\277\205\345\244\207\343\200\221\345\271\266\346\237\245\351\233\206-\344\270\212.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243056\343\200\220\345\277\205\345\244\207\343\200\221\345\271\266\346\237\245\351\233\206-\344\270\212.pptx"
index b1281e2c5a426cb813592f189bdbf4524f024e67..0f5ced922b7df69fbc6438da0ef0fd96aef59234 100644
GIT binary patch
delta 5033
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

delta 5150
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

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243057\343\200\220\345\277\205\345\244\207\343\200\221\345\271\266\346\237\245\351\233\206-\344\270\213.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243057\343\200\220\345\277\205\345\244\207\343\200\221\345\271\266\346\237\245\351\233\206-\344\270\213.pptx"
index 6f571d2284b07112ec60d6827d70952a013dea8b..9d28106e821bd0d529feb70e3c1c686d2e7e9818 100644
GIT binary patch
delta 2860
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
Y0H$OUcx_jL=Boz|mtYX;MDEf510)nHIsgCw

delta 3025
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


From 18d8a53ff85a2d1b7e985e8f57efdfe3b4e401b7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Mar 2025 18:12:09 +0800
Subject: [PATCH 0614/1712] modify code

---
 ...346\237\245\351\233\206-\344\270\212.pptx" | Bin 47167 -> 47166 bytes
 .../Code03_MinimumWindowSubstring.java        |  26 ++++++++----------
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243056\343\200\220\345\277\205\345\244\207\343\200\221\345\271\266\346\237\245\351\233\206-\344\270\212.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243056\343\200\220\345\277\205\345\244\207\343\200\221\345\271\266\346\237\245\351\233\206-\344\270\212.pptx"
index 0f5ced922b7df69fbc6438da0ef0fd96aef59234..c3ac8087d8fe2f536fde9fe3e4a7538137554fb1 100644
GIT binary patch
delta 3084
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

delta 3042
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
R{CAEYwC$b}|4<2R{15i#a-#qM

diff --git a/src/class049/Code03_MinimumWindowSubstring.java b/src/class049/Code03_MinimumWindowSubstring.java
index e58fbf6bc..ed07b95d2 100644
--- a/src/class049/Code03_MinimumWindowSubstring.java
+++ b/src/class049/Code03_MinimumWindowSubstring.java
@@ -12,29 +12,27 @@ public static String minWindow(String str, String tar) {
 		}
 		char[] s = str.toCharArray();
 		char[] t = tar.toCharArray();
-		int[] cnts = new int[256];
+		int[] map = new int[256];
 		for (char cha : t) {
-			cnts[cha]--;
+			map[cha]--;
 		}
 		// 最小覆盖子串的长度
 		int len = Integer.MAX_VALUE;
-		// 从哪个位置开头，发现的这个最小覆盖子串
+		// 从哪个位置开头，发现的最小覆盖子串
 		int start = 0;
-		for (int l = 0, r = 0, debt = t.length; r < s.length; r++) {
-			// s[r] 当前字符 -> int
-			// cnts[s[r]] : 当前字符欠债情况，负数就是欠债，正数就是多给的
-			if (cnts[s[r]]++ < 0) {
+		// 总债务
+		int debt = t.length;
+		for (int l = 0, r = 0; r < s.length; r++) {
+			// 窗口右边界向右，给出字符
+			if (map[s[r]]++ < 0) {
 				debt--;
 			}
 			if (debt == 0) {
-				// r位置结尾，真的有覆盖子串！
-				// 看看这个覆盖子串能不能尽量短
-				while (cnts[s[l]] > 0) {
-					// l位置的字符能拿回
-					cnts[s[l++]]--;
+				// 窗口左边界向右，拿回字符
+				while (map[s[l]] > 0) {
+					map[s[l++]]--;
 				}
-				// 从while里面出来，
-				// l....r就是r位置结尾的最小覆盖子串
+				// 以r位置结尾的达标窗口，更新答案
 				if (r - l + 1 < len) {
 					len = r - l + 1;
 					start = l;

From c8e23f7006cfd57dba7f18dbdd2f4209e3e3ad09 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 26 Mar 2025 18:36:49 +0800
Subject: [PATCH 0615/1712] modify code

---
 src/class049/Code03_MinimumWindowSubstring.java | 16 ++++++++--------
 1 file changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class049/Code03_MinimumWindowSubstring.java b/src/class049/Code03_MinimumWindowSubstring.java
index ed07b95d2..bb685e53f 100644
--- a/src/class049/Code03_MinimumWindowSubstring.java
+++ b/src/class049/Code03_MinimumWindowSubstring.java
@@ -7,14 +7,14 @@
 public class Code03_MinimumWindowSubstring {
 
 	public static String minWindow(String str, String tar) {
-		if (str.length() < tar.length()) {
-			return "";
-		}
 		char[] s = str.toCharArray();
 		char[] t = tar.toCharArray();
-		int[] map = new int[256];
+		// 每种字符的欠债情况
+		// cnts[i] = 负数，代表字符i有负债
+		// cnts[i] = 正数，代表字符i有盈余
+		int[] cnts = new int[256];
 		for (char cha : t) {
-			map[cha]--;
+			cnts[cha]--;
 		}
 		// 最小覆盖子串的长度
 		int len = Integer.MAX_VALUE;
@@ -24,13 +24,13 @@ public static String minWindow(String str, String tar) {
 		int debt = t.length;
 		for (int l = 0, r = 0; r < s.length; r++) {
 			// 窗口右边界向右，给出字符
-			if (map[s[r]]++ < 0) {
+			if (cnts[s[r]]++ < 0) {
 				debt--;
 			}
 			if (debt == 0) {
 				// 窗口左边界向右，拿回字符
-				while (map[s[l]] > 0) {
-					map[s[l++]]--;
+				while (cnts[s[l]] > 0) {
+					cnts[s[l++]]--;
 				}
 				// 以r位置结尾的达标窗口，更新答案
 				if (r - l + 1 < len) {

From 00821c457fa75f62fd2eca7f7563cfdf632f8239 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Mar 2025 20:36:09 +0800
Subject: [PATCH 0616/1712] modify code

---
 src/class164/Code01_KruskalRebuildTree1.java |  73 ++---
 src/class164/Code01_KruskalRebuildTree2.java |  55 ++--
 src/class164/Code02_Journey1.java            | 315 +++++++++++++++++++
 src/class164/Code02_Journey2.java            | 197 ++++++++++++
 4 files changed, 569 insertions(+), 71 deletions(-)
 create mode 100644 src/class164/Code02_Journey1.java
 create mode 100644 src/class164/Code02_Journey2.java

diff --git a/src/class164/Code01_KruskalRebuildTree1.java b/src/class164/Code01_KruskalRebuildTree1.java
index 3f2d09274..246e77530 100644
--- a/src/class164/Code01_KruskalRebuildTree1.java
+++ b/src/class164/Code01_KruskalRebuildTree1.java
@@ -11,28 +11,28 @@
 
 public class Code01_KruskalRebuildTree1 {
 
-	public static int MAXN = 200001;
+	public static int MAXK = 200001;
 	public static int MAXM = 300001;
 	public static int n, m, q;
 	public static int[][] arr = new int[MAXM][3];
 
 	// 并查集
-	public static int[] father = new int[MAXN];
-	public static int[] nodeKey = new int[MAXN];
-	public static int cnth = 0;
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int cntu = 0;
 
 	// 链式前向星
-	public static int[] head = new int[MAXN];
-	public static int[] next = new int[MAXN];
-	public static int[] to = new int[MAXN];
+	public static int[] head = new int[MAXK];
+	public static int[] next = new int[MAXK];
+	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
 
 	// 树链剖分
-	public static int[] fa = new int[MAXN];
-	public static int[] dep = new int[MAXN];
-	public static int[] siz = new int[MAXN];
-	public static int[] son = new int[MAXN];
-	public static int[] top = new int[MAXN];
+	public static int[] fa = new int[MAXK];
+	public static int[] dep = new int[MAXK];
+	public static int[] siz = new int[MAXK];
+	public static int[] son = new int[MAXK];
+	public static int[] top = new int[MAXK];
 
 	public static int find(int i) {
 		if (i != father[i]) {
@@ -52,16 +52,16 @@ public static void kruskalRebuild() {
 			father[i] = i;
 		}
 		Arrays.sort(arr, 1, m + 1, (a, b) -> a[2] - b[2]);
-		cnth = n;
+		cntu = n;
 		for (int i = 1, fx, fy; i <= m; i++) {
 			fx = find(arr[i][0]);
 			fy = find(arr[i][1]);
 			if (fx != fy) {
-				father[fx] = father[fy] = ++cnth;
-				father[cnth] = cnth;
-				nodeKey[cnth] = arr[i][2];
-				addEdge(cnth, fx);
-				addEdge(cnth, fy);
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = arr[i][2];
+				addEdge(cntu, fx);
+				addEdge(cntu, fy);
 			}
 		}
 	}
@@ -70,19 +70,14 @@ public static void dfs1(int u, int f) {
 		fa[u] = f;
 		dep[u] = dep[f] + 1;
 		siz[u] = 1;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				dfs1(v, u);
-			}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs1(to[e], u);
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
-			if (v != f) {
-				siz[u] += siz[v];
-				if (son[u] == 0 || siz[son[u]] < siz[v]) {
-					son[u] = v;
-				}
+			siz[u] += siz[v];
+			if (son[u] == 0 || siz[son[u]] < siz[v]) {
+				son[u] = v;
 			}
 		}
 	}
@@ -95,14 +90,14 @@ public static void dfs2(int u, int t) {
 		dfs2(son[u], t);
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
-			if (v != fa[u] && v != son[u]) {
+			if (v != son[u]) {
 				dfs2(v, v);
 			}
 		}
 	}
 
 	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	public static int[][] fse = new int[MAXN][3];
+	public static int[][] fse = new int[MAXK][3];
 
 	public static int stacksize, first, second, edge;
 
@@ -136,17 +131,13 @@ public static void dfs3(int u, int f) {
 			}
 			if (edge != 0) {
 				push(first, second, edge);
-				if (to[edge] != second) {
-					push(to[edge], first, -1);
-				}
+				push(to[edge], first, -1);
 			} else {
 				for (int e = head[first], v; e > 0; e = next[e]) {
 					v = to[e];
-					if (v != second) {
-						siz[first] += siz[v];
-						if (son[first] == 0 || siz[son[first]] < siz[v]) {
-							son[first] = v;
-						}
+					siz[first] += siz[v];
+					if (son[first] == 0 || siz[son[first]] < siz[v]) {
+						son[first] = v;
 					}
 				}
 			}
@@ -174,7 +165,7 @@ public static void dfs4(int u, int t) {
 			}
 			if (edge != 0) {
 				push(first, second, edge);
-				if (to[edge] != fa[first] && to[edge] != son[first]) {
+				if (to[edge] != son[first]) {
 					push(to[edge], to[edge], -1);
 				}
 			}
@@ -192,7 +183,7 @@ public static int lca(int a, int b) {
 		return dep[a] <= dep[b] ? a : b;
 	}
 
-	public static void main(String[] args) throws IOException {
+	public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
@@ -202,7 +193,7 @@ public static void main(String[] args) throws IOException {
 			arr[i][2] = io.nextInt();
 		}
 		kruskalRebuild();
-		for (int i = 1; i <= cnth; i++) {
+		for (int i = 1; i <= cntu; i++) {
 			if (i == father[i]) {
 				dfs3(i, 0); // 防止递归爆栈，所以调用dfs1的迭代版
 				dfs4(i, i); // 防止递归爆栈，所以调用dfs2的迭代版
diff --git a/src/class164/Code01_KruskalRebuildTree2.java b/src/class164/Code01_KruskalRebuildTree2.java
index 069e9ec6e..4d6ae9ace 100644
--- a/src/class164/Code01_KruskalRebuildTree2.java
+++ b/src/class164/Code01_KruskalRebuildTree2.java
@@ -13,25 +13,25 @@
 //	int u, v, w;
 //};
 //
-//const int MAXN = 200001;
+//const int MAXK = 200001;
 //const int MAXM = 300001;
 //int n, m, q;
 //Edge arr[MAXM];
 //
-//int father[MAXN];
-//int nodeKey[MAXN];
-//int cnth = 0;
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu = 0;
 //
-//int head[MAXN];
-//int nxt[MAXN];
-//int to[MAXN];
+//int head[MAXK];
+//int nxt[MAXK];
+//int to[MAXK];
 //int cntg = 0;
 //
-//int fa[MAXN];
-//int dep[MAXN];
-//int siz[MAXN];
-//int son[MAXN];
-//int top[MAXN];
+//int fa[MAXK];
+//int dep[MAXK];
+//int siz[MAXK];
+//int son[MAXK];
+//int top[MAXK];
 //
 //bool cmp(Edge x, Edge y) {
 //	return x.w < y.w;
@@ -55,16 +55,16 @@
 //        father[i] = i;
 //    }
 //    sort(arr + 1, arr + m + 1, cmp);
-//    cnth = n;
+//    cntu = n;
 //    for (int i = 1, fx, fy; i <= m; i++) {
 //        fx = find(arr[i].u);
 //        fy = find(arr[i].v);
 //        if (fx != fy) {
-//            father[fx] = father[fy] = ++cnth;
-//            father[cnth] = cnth;
-//            nodeKey[cnth] = arr[i].w;
-//            addEdge(cnth, fx);
-//            addEdge(cnth, fy);
+//            father[fx] = father[fy] = ++cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = arr[i].w;
+//            addEdge(cntu, fx);
+//            addEdge(cntu, fy);
 //        }
 //    }
 //}
@@ -73,19 +73,14 @@
 //    fa[u] = f;
 //    dep[u] = dep[f] + 1;
 //    siz[u] = 1;
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs1(to[e], u);
 //    }
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
+//        siz[u] += siz[v];
+//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//            son[u] = v;
 //        }
 //    }
 //}
@@ -98,7 +93,7 @@
 //    dfs2(son[u], t);
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
+//        if (v != son[u]) {
 //            dfs2(v, v);
 //        }
 //    }
@@ -123,7 +118,7 @@
 //        cin >> arr[i].u >> arr[i].v >> arr[i].w;
 //    }
 //    kruskalRebuild();
-//    for (int i = 1; i <= cnth; i++) {
+//    for (int i = 1; i <= cntu; i++) {
 //        if (i == father[i]) {
 //            dfs1(i, 0);
 //            dfs2(i, i);
diff --git a/src/class164/Code02_Journey1.java b/src/class164/Code02_Journey1.java
new file mode 100644
index 000000000..40c6904e6
--- /dev/null
+++ b/src/class164/Code02_Journey1.java
@@ -0,0 +1,315 @@
+package class164;
+
+// 归程，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4768
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Code02_Journey1 {
+
+	public static int MAXN = 200001;
+	public static int MAXK = 400001;
+	public static int MAXM = 400001;
+	public static int MAXH = 20;
+	public static int INF = 2000000001;
+	public static int t, n, m, q, k, s;
+	public static int[][] arr = new int[MAXM][4];
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXM << 1];
+	public static int[] tog = new int[MAXM << 1];
+	public static int[] weightg = new int[MAXM << 1];
+	public static int cntg;
+
+	public static int[] dist = new int[MAXN];
+	public static boolean[] visit = new boolean[MAXN];
+	public static PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
+
+	public static int[] headk = new int[MAXK];
+	public static int[] nextk = new int[MAXK];
+	public static int[] tok = new int[MAXK];
+	public static int cntk;
+
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int[] stack = new int[MAXK];
+	public static int cntu;
+
+	public static int[] dep = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
+	public static int[] mindist = new int[MAXK];
+
+	public static void prepare() {
+		cntg = cntk = 0;
+		Arrays.fill(headg, 1, n + 1, 0);
+		Arrays.fill(headk, 1, n * 2, 0);
+	}
+
+	public static void addEdgeG(int u, int v, int w) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		weightg[cntg] = w;
+		headg[u] = cntg;
+	}
+
+	public static void dijkstra() {
+		for (int i = 1; i <= m; i++) {
+			addEdgeG(arr[i][0], arr[i][1], arr[i][2]);
+			addEdgeG(arr[i][1], arr[i][0], arr[i][2]);
+		}
+		Arrays.fill(dist, 1, n + 1, INF);
+		Arrays.fill(visit, 1, n + 1, false);
+		dist[1] = 0;
+		heap.add(new int[] { 1, 0 });
+		int[] cur;
+		int x, v;
+		while (!heap.isEmpty()) {
+			cur = heap.poll();
+			x = cur[0];
+			v = cur[1];
+			if (!visit[x]) {
+				visit[x] = true;
+				for (int e = headg[x], y, w; e > 0; e = nextg[e]) {
+					y = tog[e];
+					w = weightg[e];
+					if (!visit[y] && dist[y] > v + w) {
+						dist[y] = v + w;
+						heap.add(new int[] { y, dist[y] });
+					}
+				}
+			}
+		}
+	}
+
+	public static void addEdgeK(int u, int v) {
+		nextk[++cntk] = headk[u];
+		tok[cntk] = v;
+		headk[u] = cntk;
+	}
+
+	// 并查集查找集合的代表节点，递归版的实现会爆栈的
+	public static int find(int i) {
+		int size = 0;
+		while (i != father[i]) {
+			stack[size++] = i;
+			i = father[i];
+		}
+		while (size > 0) {
+			father[stack[--size]] = i;
+		}
+		return i;
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(arr, 1, m + 1, (a, b) -> b[3] - a[3]);
+		cntu = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(arr[i][0]);
+			fy = find(arr[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = arr[i][3];
+				addEdgeK(cntu, fx);
+				addEdgeK(cntu, fy);
+			}
+		}
+	}
+
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = headk[u]; e > 0; e = nextk[e]) {
+			dfs1(tok[e], u);
+		}
+		if (u <= n) {
+			mindist[u] = dist[u];
+		} else {
+			mindist[u] = INF;
+		}
+		for (int e = headk[u]; e > 0; e = nextk[e]) {
+			mindist[u] = Math.min(mindist[u], mindist[tok[e]]);
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXK][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs2(int u, int fa) {
+		stacksize = 0;
+		push(u, fa, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				dep[first] = dep[second] + 1;
+				stjump[first][0] = second;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[first][p] = stjump[stjump[first][p - 1]][p - 1];
+				}
+				edge = headk[first];
+			} else {
+				edge = nextk[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				push(tok[edge], first, -1);
+			} else {
+				if (first <= n) {
+					mindist[first] = dist[first];
+				} else {
+					mindist[first] = INF;
+				}
+				for (int e = headk[first]; e > 0; e = nextk[e]) {
+					mindist[first] = Math.min(mindist[first], mindist[tok[e]]);
+				}
+			}
+		}
+	}
+
+	public static int query(int node, int line) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[node][p] > 0 && nodeKey[stjump[node][p]] > line) {
+				node = stjump[node][p];
+			}
+		}
+		return mindist[node];
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		t = io.nextInt();
+		for (int test = 1; test <= t; test++) {
+			n = io.nextInt();
+			m = io.nextInt();
+			prepare();
+			for (int i = 1; i <= m; i++) {
+				arr[i][0] = io.nextInt();
+				arr[i][1] = io.nextInt();
+				arr[i][2] = io.nextInt();
+				arr[i][3] = io.nextInt();
+			}
+			dijkstra();
+			kruskalRebuild();
+			dfs2(cntu, 0);
+			q = io.nextInt();
+			k = io.nextInt();
+			s = io.nextInt();
+			for (int i = 1, node, line, lastAns = 0; i <= q; i++) {
+				node = (io.nextInt() + k * lastAns - 1) % n + 1;
+				line = (io.nextInt() + k * lastAns) % (s + 1);
+				lastAns = query(node, line);
+				io.writelnInt(lastAns);
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
diff --git a/src/class164/Code02_Journey2.java b/src/class164/Code02_Journey2.java
new file mode 100644
index 000000000..b954b0161
--- /dev/null
+++ b/src/class164/Code02_Journey2.java
@@ -0,0 +1,197 @@
+package class164;
+
+// 归程，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4768
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, l, a;
+//};
+//
+//bool EdgeCmp(Edge x, Edge y) {
+//    return x.a > y.a;
+//}
+//
+//struct HeapNode {
+//    int cur, cost;
+//};
+//
+//struct HeapNodeCmp {
+//    bool operator()(const HeapNode &x, const HeapNode &y) const {
+//        return x.cost > y.cost; // 距离大，在堆的下方，C++的设定，其实是距离的小根堆
+//    }
+//};
+//
+//const int MAXN = 200001;
+//const int MAXK = 400001;
+//const int MAXM = 400001;
+//const int MAXH = 20;
+//int INF = 2000000001;
+//int t, n, m, q, k, s;
+//Edge arr[MAXM];
+//
+//int headg[MAXN];
+//int nextg[MAXM << 1];
+//int tog[MAXM << 1];
+//int weightg[MAXM << 1];
+//int cntg;
+//
+//int dist[MAXN];
+//bool visit[MAXN];
+//priority_queue<HeapNode, vector<HeapNode>, HeapNodeCmp> heap;
+//
+//int headk[MAXK];
+//int nextk[MAXK];
+//int tok[MAXK];
+//int cntk;
+//
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu;
+//
+//int dep[MAXK];
+//int stjump[MAXK][MAXH];
+//int mindist[MAXK];
+//
+//void prepare() {
+//    cntg = 0;
+//    cntk = 0;
+//    for(int i = 1; i <= n; i++) {
+//        headg[i] = 0;
+//    }
+//    for(int i = 1; i <= 2 * n; i++) {
+//        headk[i] = 0;
+//    }
+//}
+//
+//void addEdgeG(int u, int v, int w) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    weightg[cntg] = w;
+//    headg[u] = cntg;
+//}
+//
+//void dijkstra() {
+//    for(int i = 1; i <= m; i++) {
+//        addEdgeG(arr[i].u, arr[i].v, arr[i].l);
+//        addEdgeG(arr[i].v, arr[i].u, arr[i].l);
+//    }
+//    for(int i = 1; i <= n; i++) {
+//    	dist[i] = INF;
+//    	visit[i] = false;
+//    }
+//    dist[1] = 0;
+//    heap.push({1, 0});
+//    HeapNode node;
+//    int x, v;
+//    while(!heap.empty()) {
+//        node = heap.top();
+//        heap.pop();
+//        x = node.cur;
+//        v = node.cost;
+//        if(!visit[x]) {
+//        	visit[x] = true;
+//            for(int e = headg[x], y, w; e > 0; e = nextg[e]) {
+//                y = tog[e];
+//                w = weightg[e];
+//                if(!visit[y] && dist[y] > v + w) {
+//                	dist[y] = v + w;
+//                    heap.push({y, dist[y]});
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void addEdgeK(int u, int v) {
+//    nextk[++cntk] = headk[u];
+//    tok[cntk] = v;
+//    headk[u] = cntk;
+//}
+//
+//int find(int i) {
+//    if(father[i] != i) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//void kruskalRebuild() {
+//    for(int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(arr + 1, arr + m + 1, EdgeCmp);
+//    cntu = n;
+//    for(int i = 1, fx, fy; i <= m; i++) {
+//        fx = find(arr[i].u);
+//        fy = find(arr[i].v);
+//        if(fx != fy) {
+//            cntu++;
+//            father[fx] = cntu;
+//            father[fy] = cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = arr[i].a;
+//            addEdgeK(cntu, fx);
+//            addEdgeK(cntu, fy);
+//        }
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for(int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//    }
+//    for(int e = headk[u]; e > 0; e = nextk[e]) {
+//        dfs(tok[e], u);
+//    }
+//    if(u <= n) {
+//        mindist[u] = dist[u];
+//    } else {
+//        mindist[u] = INF;
+//    }
+//    for(int e = headk[u]; e > 0; e = nextk[e]) {
+//        mindist[u] = min(mindist[u], mindist[tok[e]]);
+//    }
+//}
+//
+//int query(int node, int line) {
+//    for(int p = MAXH - 1; p >= 0; p--) {
+//        if(stjump[node][p] > 0 && nodeKey[stjump[node][p]] > line) {
+//            node = stjump[node][p];
+//        }
+//    }
+//    return mindist[node];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> t;
+//    for(int test = 1; test <= t; test++) {
+//        cin >> n >> m;
+//        prepare();
+//        for(int i = 1; i <= m; i++) {
+//            cin >> arr[i].u >> arr[i].v >> arr[i].l >> arr[i].a;
+//        }
+//        dijkstra();
+//        kruskalRebuild();
+//        dfs(cntu, 0);
+//        cin >> q >> k >> s;
+//        int lastAns = 0;
+//        for(int i = 1, node, line; i <= q; i++) {
+//            cin >> node >> line;
+//            node = (node + k * lastAns - 1) % n + 1;
+//            line = (line + k * lastAns) % (s + 1);
+//            lastAns = query(node, line);
+//            cout << lastAns << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 3210e38a996f706d8c112b8ef8bf721c6933284a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Mar 2025 20:37:03 +0800
Subject: [PATCH 0617/1712] modify code

---
 .../{Code02_Journey1.java => Code02_ReturnJourney1.java}        | 2 +-
 .../{Code02_Journey2.java => Code02_ReturnJourney2.java}        | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class164/{Code02_Journey1.java => Code02_ReturnJourney1.java} (99%)
 rename src/class164/{Code02_Journey2.java => Code02_ReturnJourney2.java} (100%)

diff --git a/src/class164/Code02_Journey1.java b/src/class164/Code02_ReturnJourney1.java
similarity index 99%
rename from src/class164/Code02_Journey1.java
rename to src/class164/Code02_ReturnJourney1.java
index 40c6904e6..da8a218dd 100644
--- a/src/class164/Code02_Journey1.java
+++ b/src/class164/Code02_ReturnJourney1.java
@@ -10,7 +10,7 @@
 import java.util.Arrays;
 import java.util.PriorityQueue;
 
-public class Code02_Journey1 {
+public class Code02_ReturnJourney1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 400001;
diff --git a/src/class164/Code02_Journey2.java b/src/class164/Code02_ReturnJourney2.java
similarity index 100%
rename from src/class164/Code02_Journey2.java
rename to src/class164/Code02_ReturnJourney2.java

From d5d27fa4c7515930b5b22997fe1ea80dcb10e316 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Mar 2025 20:37:49 +0800
Subject: [PATCH 0618/1712] modify code

---
 ...e01_KruskalRebuildTree1.java => Code01_KruskalRebuild1.java} | 2 +-
 ...e01_KruskalRebuildTree2.java => Code01_KruskalRebuild2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class164/{Code01_KruskalRebuildTree1.java => Code01_KruskalRebuild1.java} (99%)
 rename src/class164/{Code01_KruskalRebuildTree2.java => Code01_KruskalRebuild2.java} (100%)

diff --git a/src/class164/Code01_KruskalRebuildTree1.java b/src/class164/Code01_KruskalRebuild1.java
similarity index 99%
rename from src/class164/Code01_KruskalRebuildTree1.java
rename to src/class164/Code01_KruskalRebuild1.java
index 246e77530..e7d4f0b74 100644
--- a/src/class164/Code01_KruskalRebuildTree1.java
+++ b/src/class164/Code01_KruskalRebuild1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code01_KruskalRebuildTree1 {
+public class Code01_KruskalRebuild1 {
 
 	public static int MAXK = 200001;
 	public static int MAXM = 300001;
diff --git a/src/class164/Code01_KruskalRebuildTree2.java b/src/class164/Code01_KruskalRebuild2.java
similarity index 100%
rename from src/class164/Code01_KruskalRebuildTree2.java
rename to src/class164/Code01_KruskalRebuild2.java

From d25041ec9de57d4374c5ba2a9169f66f66be1d44 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Mar 2025 20:47:45 +0800
Subject: [PATCH 0619/1712] modify code

---
 src/class164/Code02_ReturnJourney1.java |  76 +---
 src/class164/Code02_ReturnJourney2.java | 484 ++++++++++++++----------
 src/class164/Code02_ReturnJourney3.java | 197 ++++++++++
 3 files changed, 497 insertions(+), 260 deletions(-)
 create mode 100644 src/class164/Code02_ReturnJourney3.java

diff --git a/src/class164/Code02_ReturnJourney1.java b/src/class164/Code02_ReturnJourney1.java
index da8a218dd..57d203978 100644
--- a/src/class164/Code02_ReturnJourney1.java
+++ b/src/class164/Code02_ReturnJourney1.java
@@ -1,8 +1,10 @@
 package class164;
 
-// 归程，java版
+// 归程，java实现递归版
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"
+// 因为树的深度太大，递归函数爆栈了，所以无法全部通过所有测试用例
+// find方法、dfs方法都需要改成迭代版，就是本节课Code02_ReturnJourney2文件
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -37,7 +39,6 @@ public class Code02_ReturnJourney1 {
 
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
-	public static int[] stack = new int[MAXK];
 	public static int cntu;
 
 	public static int[] dep = new int[MAXK];
@@ -92,17 +93,11 @@ public static void addEdgeK(int u, int v) {
 		headk[u] = cntk;
 	}
 
-	// 并查集查找集合的代表节点，递归版的实现会爆栈的
 	public static int find(int i) {
-		int size = 0;
-		while (i != father[i]) {
-			stack[size++] = i;
-			i = father[i];
+		if (i != father[i]) {
+			father[i] = find(father[i]);
 		}
-		while (size > 0) {
-			father[stack[--size]] = i;
-		}
-		return i;
+		return father[i];
 	}
 
 	public static void kruskalRebuild() {
@@ -124,14 +119,14 @@ public static void kruskalRebuild() {
 		}
 	}
 
-	public static void dfs1(int u, int fa) {
+	public static void dfs(int u, int fa) {
 		dep[u] = dep[fa] + 1;
 		stjump[u][0] = fa;
 		for (int p = 1; p < MAXH; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 		}
 		for (int e = headk[u]; e > 0; e = nextk[e]) {
-			dfs1(tok[e], u);
+			dfs(tok[e], u);
 		}
 		if (u <= n) {
 			mindist[u] = dist[u];
@@ -143,57 +138,6 @@ public static void dfs1(int u, int fa) {
 		}
 	}
 
-	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	public static int[][] fse = new int[MAXK][3];
-
-	public static int stacksize, first, second, edge;
-
-	public static void push(int fir, int sec, int edg) {
-		fse[stacksize][0] = fir;
-		fse[stacksize][1] = sec;
-		fse[stacksize][2] = edg;
-		stacksize++;
-	}
-
-	public static void pop() {
-		--stacksize;
-		first = fse[stacksize][0];
-		second = fse[stacksize][1];
-		edge = fse[stacksize][2];
-	}
-
-	// dfs1的迭代版
-	public static void dfs2(int u, int fa) {
-		stacksize = 0;
-		push(u, fa, -1);
-		while (stacksize > 0) {
-			pop();
-			if (edge == -1) {
-				dep[first] = dep[second] + 1;
-				stjump[first][0] = second;
-				for (int p = 1; p < MAXH; p++) {
-					stjump[first][p] = stjump[stjump[first][p - 1]][p - 1];
-				}
-				edge = headk[first];
-			} else {
-				edge = nextk[edge];
-			}
-			if (edge != 0) {
-				push(first, second, edge);
-				push(tok[edge], first, -1);
-			} else {
-				if (first <= n) {
-					mindist[first] = dist[first];
-				} else {
-					mindist[first] = INF;
-				}
-				for (int e = headk[first]; e > 0; e = nextk[e]) {
-					mindist[first] = Math.min(mindist[first], mindist[tok[e]]);
-				}
-			}
-		}
-	}
-
 	public static int query(int node, int line) {
 		for (int p = MAXH - 1; p >= 0; p--) {
 			if (stjump[node][p] > 0 && nodeKey[stjump[node][p]] > line) {
@@ -218,7 +162,7 @@ public static void main(String[] args) {
 			}
 			dijkstra();
 			kruskalRebuild();
-			dfs2(cntu, 0);
+			dfs(cntu, 0);
 			q = io.nextInt();
 			k = io.nextInt();
 			s = io.nextInt();
diff --git a/src/class164/Code02_ReturnJourney2.java b/src/class164/Code02_ReturnJourney2.java
index b954b0161..665d0df44 100644
--- a/src/class164/Code02_ReturnJourney2.java
+++ b/src/class164/Code02_ReturnJourney2.java
@@ -1,197 +1,293 @@
 package class164;
 
-// 归程，C++版
+// 归程，java实现迭代版
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//struct Edge {
-//    int u, v, l, a;
-//};
-//
-//bool EdgeCmp(Edge x, Edge y) {
-//    return x.a > y.a;
-//}
-//
-//struct HeapNode {
-//    int cur, cost;
-//};
-//
-//struct HeapNodeCmp {
-//    bool operator()(const HeapNode &x, const HeapNode &y) const {
-//        return x.cost > y.cost; // 距离大，在堆的下方，C++的设定，其实是距离的小根堆
-//    }
-//};
-//
-//const int MAXN = 200001;
-//const int MAXK = 400001;
-//const int MAXM = 400001;
-//const int MAXH = 20;
-//int INF = 2000000001;
-//int t, n, m, q, k, s;
-//Edge arr[MAXM];
-//
-//int headg[MAXN];
-//int nextg[MAXM << 1];
-//int tog[MAXM << 1];
-//int weightg[MAXM << 1];
-//int cntg;
-//
-//int dist[MAXN];
-//bool visit[MAXN];
-//priority_queue<HeapNode, vector<HeapNode>, HeapNodeCmp> heap;
-//
-//int headk[MAXK];
-//int nextk[MAXK];
-//int tok[MAXK];
-//int cntk;
-//
-//int father[MAXK];
-//int nodeKey[MAXK];
-//int cntu;
-//
-//int dep[MAXK];
-//int stjump[MAXK][MAXH];
-//int mindist[MAXK];
-//
-//void prepare() {
-//    cntg = 0;
-//    cntk = 0;
-//    for(int i = 1; i <= n; i++) {
-//        headg[i] = 0;
-//    }
-//    for(int i = 1; i <= 2 * n; i++) {
-//        headk[i] = 0;
-//    }
-//}
-//
-//void addEdgeG(int u, int v, int w) {
-//    nextg[++cntg] = headg[u];
-//    tog[cntg] = v;
-//    weightg[cntg] = w;
-//    headg[u] = cntg;
-//}
-//
-//void dijkstra() {
-//    for(int i = 1; i <= m; i++) {
-//        addEdgeG(arr[i].u, arr[i].v, arr[i].l);
-//        addEdgeG(arr[i].v, arr[i].u, arr[i].l);
-//    }
-//    for(int i = 1; i <= n; i++) {
-//    	dist[i] = INF;
-//    	visit[i] = false;
-//    }
-//    dist[1] = 0;
-//    heap.push({1, 0});
-//    HeapNode node;
-//    int x, v;
-//    while(!heap.empty()) {
-//        node = heap.top();
-//        heap.pop();
-//        x = node.cur;
-//        v = node.cost;
-//        if(!visit[x]) {
-//        	visit[x] = true;
-//            for(int e = headg[x], y, w; e > 0; e = nextg[e]) {
-//                y = tog[e];
-//                w = weightg[e];
-//                if(!visit[y] && dist[y] > v + w) {
-//                	dist[y] = v + w;
-//                    heap.push({y, dist[y]});
-//                }
-//            }
-//        }
-//    }
-//}
-//
-//void addEdgeK(int u, int v) {
-//    nextk[++cntk] = headk[u];
-//    tok[cntk] = v;
-//    headk[u] = cntk;
-//}
-//
-//int find(int i) {
-//    if(father[i] != i) {
-//        father[i] = find(father[i]);
-//    }
-//    return father[i];
-//}
-//
-//void kruskalRebuild() {
-//    for(int i = 1; i <= n; i++) {
-//        father[i] = i;
-//    }
-//    sort(arr + 1, arr + m + 1, EdgeCmp);
-//    cntu = n;
-//    for(int i = 1, fx, fy; i <= m; i++) {
-//        fx = find(arr[i].u);
-//        fy = find(arr[i].v);
-//        if(fx != fy) {
-//            cntu++;
-//            father[fx] = cntu;
-//            father[fy] = cntu;
-//            father[cntu] = cntu;
-//            nodeKey[cntu] = arr[i].a;
-//            addEdgeK(cntu, fx);
-//            addEdgeK(cntu, fy);
-//        }
-//    }
-//}
-//
-//void dfs(int u, int fa) {
-//    dep[u] = dep[fa] + 1;
-//    stjump[u][0] = fa;
-//    for(int p = 1; p < MAXH; p++) {
-//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
-//    }
-//    for(int e = headk[u]; e > 0; e = nextk[e]) {
-//        dfs(tok[e], u);
-//    }
-//    if(u <= n) {
-//        mindist[u] = dist[u];
-//    } else {
-//        mindist[u] = INF;
-//    }
-//    for(int e = headk[u]; e > 0; e = nextk[e]) {
-//        mindist[u] = min(mindist[u], mindist[tok[e]]);
-//    }
-//}
-//
-//int query(int node, int line) {
-//    for(int p = MAXH - 1; p >= 0; p--) {
-//        if(stjump[node][p] > 0 && nodeKey[stjump[node][p]] > line) {
-//            node = stjump[node][p];
-//        }
-//    }
-//    return mindist[node];
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> t;
-//    for(int test = 1; test <= t; test++) {
-//        cin >> n >> m;
-//        prepare();
-//        for(int i = 1; i <= m; i++) {
-//            cin >> arr[i].u >> arr[i].v >> arr[i].l >> arr[i].a;
-//        }
-//        dijkstra();
-//        kruskalRebuild();
-//        dfs(cntu, 0);
-//        cin >> q >> k >> s;
-//        int lastAns = 0;
-//        for(int i = 1, node, line; i <= q; i++) {
-//            cin >> node >> line;
-//            node = (node + k * lastAns - 1) % n + 1;
-//            line = (line + k * lastAns) % (s + 1);
-//            lastAns = query(node, line);
-//            cout << lastAns << "\n";
-//        }
-//    }
-//    return 0;
-//}
\ No newline at end of file
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+import java.util.PriorityQueue;
+
+public class Code02_ReturnJourney2 {
+
+	public static int MAXN = 200001;
+	public static int MAXK = 400001;
+	public static int MAXM = 400001;
+	public static int MAXH = 20;
+	public static int INF = 2000000001;
+	public static int t, n, m, q, k, s;
+	public static int[][] arr = new int[MAXM][4];
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXM << 1];
+	public static int[] tog = new int[MAXM << 1];
+	public static int[] weightg = new int[MAXM << 1];
+	public static int cntg;
+
+	public static int[] dist = new int[MAXN];
+	public static boolean[] visit = new boolean[MAXN];
+	public static PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
+
+	public static int[] headk = new int[MAXK];
+	public static int[] nextk = new int[MAXK];
+	public static int[] tok = new int[MAXK];
+	public static int cntk;
+
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int[] stack = new int[MAXK];
+	public static int cntu;
+
+	public static int[] dep = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
+	public static int[] mindist = new int[MAXK];
+
+	public static void prepare() {
+		cntg = cntk = 0;
+		Arrays.fill(headg, 1, n + 1, 0);
+		Arrays.fill(headk, 1, n * 2, 0);
+	}
+
+	public static void addEdgeG(int u, int v, int w) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		weightg[cntg] = w;
+		headg[u] = cntg;
+	}
+
+	public static void dijkstra() {
+		for (int i = 1; i <= m; i++) {
+			addEdgeG(arr[i][0], arr[i][1], arr[i][2]);
+			addEdgeG(arr[i][1], arr[i][0], arr[i][2]);
+		}
+		Arrays.fill(dist, 1, n + 1, INF);
+		Arrays.fill(visit, 1, n + 1, false);
+		dist[1] = 0;
+		heap.add(new int[] { 1, 0 });
+		int[] cur;
+		int x, v;
+		while (!heap.isEmpty()) {
+			cur = heap.poll();
+			x = cur[0];
+			v = cur[1];
+			if (!visit[x]) {
+				visit[x] = true;
+				for (int e = headg[x], y, w; e > 0; e = nextg[e]) {
+					y = tog[e];
+					w = weightg[e];
+					if (!visit[y] && dist[y] > v + w) {
+						dist[y] = v + w;
+						heap.add(new int[] { y, dist[y] });
+					}
+				}
+			}
+		}
+	}
+
+	public static void addEdgeK(int u, int v) {
+		nextk[++cntk] = headk[u];
+		tok[cntk] = v;
+		headk[u] = cntk;
+	}
+
+	public static int find(int i) {
+		int size = 0;
+		while (i != father[i]) {
+			stack[size++] = i;
+			i = father[i];
+		}
+		while (size > 0) {
+			father[stack[--size]] = i;
+		}
+		return i;
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(arr, 1, m + 1, (a, b) -> b[3] - a[3]);
+		cntu = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(arr[i][0]);
+			fy = find(arr[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = arr[i][3];
+				addEdgeK(cntu, fx);
+				addEdgeK(cntu, fy);
+			}
+		}
+	}
+
+	public static int[][] fse = new int[MAXK][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	public static void dfs(int u, int fa) {
+		stacksize = 0;
+		push(u, fa, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				dep[first] = dep[second] + 1;
+				stjump[first][0] = second;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[first][p] = stjump[stjump[first][p - 1]][p - 1];
+				}
+				edge = headk[first];
+			} else {
+				edge = nextk[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				push(tok[edge], first, -1);
+			} else {
+				if (first <= n) {
+					mindist[first] = dist[first];
+				} else {
+					mindist[first] = INF;
+				}
+				for (int e = headk[first]; e > 0; e = nextk[e]) {
+					mindist[first] = Math.min(mindist[first], mindist[tok[e]]);
+				}
+			}
+		}
+	}
+
+	public static int query(int node, int line) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[node][p] > 0 && nodeKey[stjump[node][p]] > line) {
+				node = stjump[node][p];
+			}
+		}
+		return mindist[node];
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		t = io.nextInt();
+		for (int test = 1; test <= t; test++) {
+			n = io.nextInt();
+			m = io.nextInt();
+			prepare();
+			for (int i = 1; i <= m; i++) {
+				arr[i][0] = io.nextInt();
+				arr[i][1] = io.nextInt();
+				arr[i][2] = io.nextInt();
+				arr[i][3] = io.nextInt();
+			}
+			dijkstra();
+			kruskalRebuild();
+			dfs(cntu, 0);
+			q = io.nextInt();
+			k = io.nextInt();
+			s = io.nextInt();
+			for (int i = 1, node, line, lastAns = 0; i <= q; i++) {
+				node = (io.nextInt() + k * lastAns - 1) % n + 1;
+				line = (io.nextInt() + k * lastAns) % (s + 1);
+				lastAns = query(node, line);
+				io.writelnInt(lastAns);
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
diff --git a/src/class164/Code02_ReturnJourney3.java b/src/class164/Code02_ReturnJourney3.java
new file mode 100644
index 000000000..b954b0161
--- /dev/null
+++ b/src/class164/Code02_ReturnJourney3.java
@@ -0,0 +1,197 @@
+package class164;
+
+// 归程，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4768
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, l, a;
+//};
+//
+//bool EdgeCmp(Edge x, Edge y) {
+//    return x.a > y.a;
+//}
+//
+//struct HeapNode {
+//    int cur, cost;
+//};
+//
+//struct HeapNodeCmp {
+//    bool operator()(const HeapNode &x, const HeapNode &y) const {
+//        return x.cost > y.cost; // 距离大，在堆的下方，C++的设定，其实是距离的小根堆
+//    }
+//};
+//
+//const int MAXN = 200001;
+//const int MAXK = 400001;
+//const int MAXM = 400001;
+//const int MAXH = 20;
+//int INF = 2000000001;
+//int t, n, m, q, k, s;
+//Edge arr[MAXM];
+//
+//int headg[MAXN];
+//int nextg[MAXM << 1];
+//int tog[MAXM << 1];
+//int weightg[MAXM << 1];
+//int cntg;
+//
+//int dist[MAXN];
+//bool visit[MAXN];
+//priority_queue<HeapNode, vector<HeapNode>, HeapNodeCmp> heap;
+//
+//int headk[MAXK];
+//int nextk[MAXK];
+//int tok[MAXK];
+//int cntk;
+//
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu;
+//
+//int dep[MAXK];
+//int stjump[MAXK][MAXH];
+//int mindist[MAXK];
+//
+//void prepare() {
+//    cntg = 0;
+//    cntk = 0;
+//    for(int i = 1; i <= n; i++) {
+//        headg[i] = 0;
+//    }
+//    for(int i = 1; i <= 2 * n; i++) {
+//        headk[i] = 0;
+//    }
+//}
+//
+//void addEdgeG(int u, int v, int w) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    weightg[cntg] = w;
+//    headg[u] = cntg;
+//}
+//
+//void dijkstra() {
+//    for(int i = 1; i <= m; i++) {
+//        addEdgeG(arr[i].u, arr[i].v, arr[i].l);
+//        addEdgeG(arr[i].v, arr[i].u, arr[i].l);
+//    }
+//    for(int i = 1; i <= n; i++) {
+//    	dist[i] = INF;
+//    	visit[i] = false;
+//    }
+//    dist[1] = 0;
+//    heap.push({1, 0});
+//    HeapNode node;
+//    int x, v;
+//    while(!heap.empty()) {
+//        node = heap.top();
+//        heap.pop();
+//        x = node.cur;
+//        v = node.cost;
+//        if(!visit[x]) {
+//        	visit[x] = true;
+//            for(int e = headg[x], y, w; e > 0; e = nextg[e]) {
+//                y = tog[e];
+//                w = weightg[e];
+//                if(!visit[y] && dist[y] > v + w) {
+//                	dist[y] = v + w;
+//                    heap.push({y, dist[y]});
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void addEdgeK(int u, int v) {
+//    nextk[++cntk] = headk[u];
+//    tok[cntk] = v;
+//    headk[u] = cntk;
+//}
+//
+//int find(int i) {
+//    if(father[i] != i) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//void kruskalRebuild() {
+//    for(int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(arr + 1, arr + m + 1, EdgeCmp);
+//    cntu = n;
+//    for(int i = 1, fx, fy; i <= m; i++) {
+//        fx = find(arr[i].u);
+//        fy = find(arr[i].v);
+//        if(fx != fy) {
+//            cntu++;
+//            father[fx] = cntu;
+//            father[fy] = cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = arr[i].a;
+//            addEdgeK(cntu, fx);
+//            addEdgeK(cntu, fy);
+//        }
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for(int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//    }
+//    for(int e = headk[u]; e > 0; e = nextk[e]) {
+//        dfs(tok[e], u);
+//    }
+//    if(u <= n) {
+//        mindist[u] = dist[u];
+//    } else {
+//        mindist[u] = INF;
+//    }
+//    for(int e = headk[u]; e > 0; e = nextk[e]) {
+//        mindist[u] = min(mindist[u], mindist[tok[e]]);
+//    }
+//}
+//
+//int query(int node, int line) {
+//    for(int p = MAXH - 1; p >= 0; p--) {
+//        if(stjump[node][p] > 0 && nodeKey[stjump[node][p]] > line) {
+//            node = stjump[node][p];
+//        }
+//    }
+//    return mindist[node];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> t;
+//    for(int test = 1; test <= t; test++) {
+//        cin >> n >> m;
+//        prepare();
+//        for(int i = 1; i <= m; i++) {
+//            cin >> arr[i].u >> arr[i].v >> arr[i].l >> arr[i].a;
+//        }
+//        dijkstra();
+//        kruskalRebuild();
+//        dfs(cntu, 0);
+//        cin >> q >> k >> s;
+//        int lastAns = 0;
+//        for(int i = 1, node, line; i <= q; i++) {
+//            cin >> node >> line;
+//            node = (node + k * lastAns - 1) % n + 1;
+//            line = (line + k * lastAns) % (s + 1);
+//            lastAns = query(node, line);
+//            cout << lastAns << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 16e081ed4009a16a9b4cc8cf06bdab7101b034a5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Mar 2025 20:55:33 +0800
Subject: [PATCH 0620/1712] modify code

---
 src/class164/Code02_ReturnJourney3.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class164/Code02_ReturnJourney3.java b/src/class164/Code02_ReturnJourney3.java
index b954b0161..b5edb8f21 100644
--- a/src/class164/Code02_ReturnJourney3.java
+++ b/src/class164/Code02_ReturnJourney3.java
@@ -14,16 +14,16 @@
 //};
 //
 //bool EdgeCmp(Edge x, Edge y) {
-//    return x.a > y.a;
+//    return x.a > y.a; // 海拔高的边，排序排在数组前面
 //}
 //
 //struct HeapNode {
-//    int cur, cost;
+//    int cur, dis;
 //};
 //
 //struct HeapNodeCmp {
 //    bool operator()(const HeapNode &x, const HeapNode &y) const {
-//        return x.cost > y.cost; // 距离大，在堆的下方，C++的设定，其实是距离的小根堆
+//        return x.dis > y.dis; // 谁距离大，谁在堆下方，C++的设定，其实是距离的小根堆
 //    }
 //};
 //
@@ -93,7 +93,7 @@
 //        node = heap.top();
 //        heap.pop();
 //        x = node.cur;
-//        v = node.cost;
+//        v = node.dis;
 //        if(!visit[x]) {
 //        	visit[x] = true;
 //            for(int e = headg[x], y, w; e > 0; e = nextg[e]) {

From efdb4a25953d4bd562ee2e772f4de4278529c7be Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Mar 2025 21:16:32 +0800
Subject: [PATCH 0621/1712] modify code

---
 src/class164/Code01_KruskalRebuild2.java | 10 +++++-----
 src/class164/Code02_ReturnJourney3.java  |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class164/Code01_KruskalRebuild2.java b/src/class164/Code01_KruskalRebuild2.java
index 4d6ae9ace..46bbc372f 100644
--- a/src/class164/Code01_KruskalRebuild2.java
+++ b/src/class164/Code01_KruskalRebuild2.java
@@ -34,14 +34,14 @@
 //int top[MAXK];
 //
 //bool cmp(Edge x, Edge y) {
-//	return x.w < y.w;
+//    return x.w < y.w;
 //}
 //
 //int find(int i) {
-//	if(i != father[i]) {
-//		father[i] = find(father[i]);
-//	}
-//	return father[i];
+//    if(i != father[i]) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
 //}
 //
 //void addEdge(int u, int v) {
diff --git a/src/class164/Code02_ReturnJourney3.java b/src/class164/Code02_ReturnJourney3.java
index b5edb8f21..00ad3beb3 100644
--- a/src/class164/Code02_ReturnJourney3.java
+++ b/src/class164/Code02_ReturnJourney3.java
@@ -82,8 +82,8 @@
 //        addEdgeG(arr[i].v, arr[i].u, arr[i].l);
 //    }
 //    for(int i = 1; i <= n; i++) {
-//    	dist[i] = INF;
-//    	visit[i] = false;
+//        dist[i] = INF;
+//        visit[i] = false;
 //    }
 //    dist[1] = 0;
 //    heap.push({1, 0});
@@ -95,12 +95,12 @@
 //        x = node.cur;
 //        v = node.dis;
 //        if(!visit[x]) {
-//        	visit[x] = true;
+//        	  visit[x] = true;
 //            for(int e = headg[x], y, w; e > 0; e = nextg[e]) {
 //                y = tog[e];
 //                w = weightg[e];
 //                if(!visit[y] && dist[y] > v + w) {
-//                	dist[y] = v + w;
+//                    dist[y] = v + w;
 //                    heap.push({y, dist[y]});
 //                }
 //            }

From 43e399f74c442dc69652396e08e8a821f8ad7e85 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 27 Mar 2025 21:19:54 +0800
Subject: [PATCH 0622/1712] modify code

---
 src/class164/Code02_ReturnJourney3.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/class164/Code02_ReturnJourney3.java b/src/class164/Code02_ReturnJourney3.java
index 00ad3beb3..6ec74f727 100644
--- a/src/class164/Code02_ReturnJourney3.java
+++ b/src/class164/Code02_ReturnJourney3.java
@@ -184,8 +184,7 @@
 //        kruskalRebuild();
 //        dfs(cntu, 0);
 //        cin >> q >> k >> s;
-//        int lastAns = 0;
-//        for(int i = 1, node, line; i <= q; i++) {
+//        for(int i = 1, node, line, lastAns = 0; i <= q; i++) {
 //            cin >> node >> line;
 //            node = (node + k * lastAns - 1) % n + 1;
 //            line = (line + k * lastAns) % (s + 1);

From 8050f61f457f62b025d2ca1f10ac4912c041c1f7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Mar 2025 17:31:28 +0800
Subject: [PATCH 0623/1712] modify code

---
 src/class164/Code02_StampRally1.java          | 218 ++++++++++++++++++
 src/class164/Code02_StampRally2.java          | 140 +++++++++++
 ...urney1.java => Code03_ReturnJourney1.java} |   4 +-
 ...urney2.java => Code03_ReturnJourney2.java} |   2 +-
 ...urney3.java => Code03_ReturnJourney3.java} |   0
 5 files changed, 361 insertions(+), 3 deletions(-)
 create mode 100644 src/class164/Code02_StampRally1.java
 create mode 100644 src/class164/Code02_StampRally2.java
 rename src/class164/{Code02_ReturnJourney1.java => Code03_ReturnJourney1.java} (98%)
 rename src/class164/{Code02_ReturnJourney2.java => Code03_ReturnJourney2.java} (99%)
 rename src/class164/{Code02_ReturnJourney3.java => Code03_ReturnJourney3.java} (100%)

diff --git a/src/class164/Code02_StampRally1.java b/src/class164/Code02_StampRally1.java
new file mode 100644
index 000000000..4bb02f8c0
--- /dev/null
+++ b/src/class164/Code02_StampRally1.java
@@ -0,0 +1,218 @@
+package class164;
+
+// 走过z个点的最大边权最小值，java版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_agc002_d
+// 测试链接 : https://atcoder.jp/contests/agc002/tasks/agc002_d
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class Code02_StampRally1 {
+
+	public static int MAXK = 200001;
+	public static int MAXM = 100001;
+	public static int MAXH = 20;
+	public static int n, m, q;
+	public static int[][] arr = new int[MAXM][3];
+
+	public static int[] head = new int[MAXK];
+	public static int[] next = new int[MAXK];
+	public static int[] to = new int[MAXK];
+	public static int cntg;
+
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int cntu;
+
+	public static int[] dep = new int[MAXK];
+	public static int[] siz = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(arr, 1, m + 1, (a, b) -> a[2] - b[2]);
+		cntu = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(arr[i][0]);
+			fy = find(arr[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = arr[i][2];
+				addEdge(cntu, fx);
+				addEdge(cntu, fy);
+			}
+		}
+	}
+
+	public static void dfs(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs(to[e], u);
+		}
+		if (u <= n) {
+			siz[u] = 1;
+		} else {
+			siz[u] = 0;
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			siz[u] += siz[to[e]];
+		}
+	}
+
+	public static boolean check(int x, int y, int z, int limit) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[x][p] > 0 && nodeKey[stjump[x][p]] <= limit) {
+				x = stjump[x][p];
+			}
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[y][p] > 0 && nodeKey[stjump[y][p]] <= limit) {
+				y = stjump[y][p];
+			}
+		}
+		if (x == y) {
+			return siz[x] >= z;
+		} else {
+			return siz[x] + siz[y] >= z;
+		}
+	}
+
+	public static int query(int x, int y, int z) {
+		int l = 1, r = m, mid, ans = 0;
+		while (l <= r) {
+			mid = (l + r) / 2;
+			if (check(x, y, z, mid)) {
+				ans = mid;
+				r = mid - 1;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1; i <= m; i++) {
+			arr[i][0] = io.nextInt();
+			arr[i][1] = io.nextInt();
+			arr[i][2] = i;
+		}
+		kruskalRebuild();
+		dfs(cntu, 0);
+		q = io.nextInt();
+		for (int i = 1, x, y, z; i <= q; i++) {
+			x = io.nextInt();
+			y = io.nextInt();
+			z = io.nextInt();
+			io.writelnInt(query(x, y, z));
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
diff --git a/src/class164/Code02_StampRally2.java b/src/class164/Code02_StampRally2.java
new file mode 100644
index 000000000..10eae9866
--- /dev/null
+++ b/src/class164/Code02_StampRally2.java
@@ -0,0 +1,140 @@
+package class164;
+
+// 走过z个点的最大边权最小值，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_agc002_d
+// 测试链接 : https://atcoder.jp/contests/agc002/tasks/agc002_d
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, w;
+//};
+//
+//const int MAXK = 200001;
+//const int MAXM = 100001;
+//const int MAXH = 20;
+//int n, m, q;
+//Edge arr[MAXM];
+//
+//int head[MAXK];
+//int nxt[MAXK];
+//int to[MAXK];
+//int cntg;
+//
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu;
+//
+//int dep[MAXK];
+//int siz[MAXK];
+//int stjump[MAXK][MAXH];
+//
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int find(int i) {
+//    if (i != father[i]) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//void kruskalRebuild() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(arr + 1, arr + m + 1, cmp);
+//    cntu = n;
+//    for (int i = 1, fx, fy; i <= m; i++) {
+//        fx = find(arr[i].u);
+//        fy = find(arr[i].v);
+//        if (fx != fy) {
+//            father[fx] = father[fy] = ++cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = arr[i].w;
+//            addEdge(cntu, fx);
+//            addEdge(cntu, fy);
+//        }
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs(to[e], u);
+//    }
+//    if (u <= n) {
+//        siz[u] = 1;
+//    } else {
+//        siz[u] = 0;
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        siz[u] += siz[to[e]];
+//    }
+//}
+//
+//bool check(int x, int y, int z, int limit) {
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[x][p] > 0 && nodeKey[stjump[x][p]] <= limit) {
+//            x = stjump[x][p];
+//        }
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[y][p] > 0 && nodeKey[stjump[y][p]] <= limit) {
+//            y = stjump[y][p];
+//        }
+//    }
+//    if (x == y) {
+//        return siz[x] >= z;
+//    } else {
+//        return siz[x] + siz[y] >= z;
+//    }
+//}
+//
+//int query(int x, int y, int z) {
+//    int l = 1, r = m, ans = 0;
+//    while (l <= r) {
+//        int mid = (l + r) / 2;
+//        if (check(x, y, z, mid)) {
+//            ans = mid;
+//            r = mid - 1;
+//        } else {
+//            l = mid + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> arr[i].u >> arr[i].v;
+//        arr[i].w = i;
+//    }
+//    kruskalRebuild();
+//    dfs(cntu, 0);
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
+//        int x, y, z;
+//        cin >> x >> y >> z;
+//        cout << query(x, y, z) << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class164/Code02_ReturnJourney1.java b/src/class164/Code03_ReturnJourney1.java
similarity index 98%
rename from src/class164/Code02_ReturnJourney1.java
rename to src/class164/Code03_ReturnJourney1.java
index 57d203978..3892225f9 100644
--- a/src/class164/Code02_ReturnJourney1.java
+++ b/src/class164/Code03_ReturnJourney1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
 // 提交以下的code，提交时请把类名改成"Main"
 // 因为树的深度太大，递归函数爆栈了，所以无法全部通过所有测试用例
-// find方法、dfs方法都需要改成迭代版，就是本节课Code02_ReturnJourney2文件
+// find方法、dfs方法都需要改成迭代版，就是本节课Code03_ReturnJourney2文件
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -12,7 +12,7 @@
 import java.util.Arrays;
 import java.util.PriorityQueue;
 
-public class Code02_ReturnJourney1 {
+public class Code03_ReturnJourney1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 400001;
diff --git a/src/class164/Code02_ReturnJourney2.java b/src/class164/Code03_ReturnJourney2.java
similarity index 99%
rename from src/class164/Code02_ReturnJourney2.java
rename to src/class164/Code03_ReturnJourney2.java
index 665d0df44..b28aade10 100644
--- a/src/class164/Code02_ReturnJourney2.java
+++ b/src/class164/Code03_ReturnJourney2.java
@@ -10,7 +10,7 @@
 import java.util.Arrays;
 import java.util.PriorityQueue;
 
-public class Code02_ReturnJourney2 {
+public class Code03_ReturnJourney2 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 400001;
diff --git a/src/class164/Code02_ReturnJourney3.java b/src/class164/Code03_ReturnJourney3.java
similarity index 100%
rename from src/class164/Code02_ReturnJourney3.java
rename to src/class164/Code03_ReturnJourney3.java

From 20b9d3d6ff272b8a934c4d38064527a6922cfcea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Mar 2025 20:30:59 +0800
Subject: [PATCH 0624/1712] modify code

---
 src/class164/Code01_KruskalRebuild1.java |  10 +-
 src/class164/Code01_KruskalRebuild2.java |   8 +-
 src/class164/Code02_StampRally1.java     |   2 +-
 src/class164/Code02_StampRally2.java     |   2 +-
 src/class164/Code04_Peaks1.java          | 307 +++++++++++++++++++++++
 src/class164/Code04_Peaks2.java          | 221 ++++++++++++++++
 6 files changed, 539 insertions(+), 11 deletions(-)
 create mode 100644 src/class164/Code04_Peaks1.java
 create mode 100644 src/class164/Code04_Peaks2.java

diff --git a/src/class164/Code01_KruskalRebuild1.java b/src/class164/Code01_KruskalRebuild1.java
index e7d4f0b74..789f48359 100644
--- a/src/class164/Code01_KruskalRebuild1.java
+++ b/src/class164/Code01_KruskalRebuild1.java
@@ -16,17 +16,17 @@ public class Code01_KruskalRebuild1 {
 	public static int n, m, q;
 	public static int[][] arr = new int[MAXM][3];
 
-	// 并查集
-	public static int[] father = new int[MAXK];
-	public static int[] nodeKey = new int[MAXK];
-	public static int cntu = 0;
-
 	// 链式前向星
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
 
+	// 并查集
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int cntu;
+
 	// 树链剖分
 	public static int[] fa = new int[MAXK];
 	public static int[] dep = new int[MAXK];
diff --git a/src/class164/Code01_KruskalRebuild2.java b/src/class164/Code01_KruskalRebuild2.java
index 46bbc372f..13b74a80a 100644
--- a/src/class164/Code01_KruskalRebuild2.java
+++ b/src/class164/Code01_KruskalRebuild2.java
@@ -18,15 +18,15 @@
 //int n, m, q;
 //Edge arr[MAXM];
 //
-//int father[MAXK];
-//int nodeKey[MAXK];
-//int cntu = 0;
-//
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
 //int cntg = 0;
 //
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu;
+//
 //int fa[MAXK];
 //int dep[MAXK];
 //int siz[MAXK];
diff --git a/src/class164/Code02_StampRally1.java b/src/class164/Code02_StampRally1.java
index 4bb02f8c0..b5c3a8da5 100644
--- a/src/class164/Code02_StampRally1.java
+++ b/src/class164/Code02_StampRally1.java
@@ -21,7 +21,7 @@ public class Code02_StampRally1 {
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
-	public static int cntg;
+	public static int cntg = 0;
 
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
diff --git a/src/class164/Code02_StampRally2.java b/src/class164/Code02_StampRally2.java
index 10eae9866..ea479932e 100644
--- a/src/class164/Code02_StampRally2.java
+++ b/src/class164/Code02_StampRally2.java
@@ -23,7 +23,7 @@
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
-//int cntg;
+//int cntg = 0;
 //
 //int father[MAXK];
 //int nodeKey[MAXK];
diff --git a/src/class164/Code04_Peaks1.java b/src/class164/Code04_Peaks1.java
new file mode 100644
index 000000000..d9482858c
--- /dev/null
+++ b/src/class164/Code04_Peaks1.java
@@ -0,0 +1,307 @@
+package class164;
+
+// 边权上限内第k大点权，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P7834
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是通过不了
+// 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code04_Peaks2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class Code04_Peaks1 {
+
+	public static int MAXN = 100001;
+	public static int MAXK = 200001;
+	public static int MAXM = 500001;
+	public static int MAXT = MAXN * 40;
+	public static int MAXH = 20;
+	public static int n, m, q;
+
+	public static int[] node = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
+	public static int diff;
+
+	public static int[][] edge = new int[MAXM][3];
+
+	public static int[] head = new int[MAXK];
+	public static int[] next = new int[MAXK];
+	public static int[] to = new int[MAXK];
+	public static int cntg = 0;
+
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int cntu;
+
+	public static int[] dfn = new int[MAXK];
+	public static int[] seg = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
+	public static int[] siz = new int[MAXK];
+	public static int cntd = 0;
+
+	public static int[] root = new int[MAXK];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] segsiz = new int[MAXT];
+	public static int cntt = 0;
+
+	public static int kth(int num) {
+		int left = 1, right = diff, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = node[i];
+		}
+		sorted[n + 1] = 0;
+		Arrays.sort(sorted, 1, n + 2);
+		diff = 1;
+		for (int i = 2; i <= n + 1; i++) {
+			if (sorted[diff] != sorted[i]) {
+				sorted[++diff] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			node[i] = kth(node[i]);
+		}
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(edge, 1, m + 1, (a, b) -> a[2] - b[2]);
+		cntu = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(edge[i][0]);
+			fy = find(edge[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = edge[i][2];
+				addEdge(cntu, fx);
+				addEdge(cntu, fy);
+			}
+		}
+	}
+
+	public static void dfs(int u, int fa) {
+		siz[u] = 1;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs(to[e], u);
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			siz[u] += siz[to[e]];
+		}
+	}
+
+	public static int build(int l, int r) {
+		int rt = ++cntt;
+		segsiz[rt] = 0;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			ls[rt] = build(l, mid);
+			rs[rt] = build(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int insert(int jobi, int l, int r, int i) {
+		int rt = ++cntt;
+		ls[rt] = ls[i];
+		rs[rt] = rs[i];
+		segsiz[rt] = segsiz[i] + 1;
+		if (l < r) {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				ls[rt] = insert(jobi, l, mid, ls[rt]);
+			} else {
+				rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static int query(int jobk, int l, int r, int pre, int post) {
+		if (l == r) {
+			return l;
+		}
+		int rsize = segsiz[rs[post]] - segsiz[rs[pre]];
+		int mid = (l + r) / 2;
+		if (rsize >= jobk) {
+			return query(jobk, mid + 1, r, rs[pre], rs[post]);
+		} else {
+			return query(jobk - rsize, l, mid, ls[pre], ls[post]);
+		}
+	}
+
+	public static int compute(int u, int x, int k) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] <= x) {
+				u = stjump[u][p];
+			}
+		}
+		int idx = query(k, 1, diff, root[dfn[u] - 1], root[dfn[u] + siz[u] - 1]);
+		return sorted[idx];
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		q = io.nextInt();
+		for (int i = 1; i <= n; i++) {
+			node[i] = io.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			edge[i][0] = io.nextInt();
+			edge[i][1] = io.nextInt();
+			edge[i][2] = io.nextInt();
+		}
+		prepare();
+		kruskalRebuild();
+		for (int i = 1; i <= cntu; i++) {
+			if (i == father[i]) {
+				dfs(i, 0);
+			}
+		}
+		root[0] = build(1, diff);
+		for (int i = 1; i <= cntd; i++) {
+			if (seg[i] <= n) {
+				root[i] = insert(node[seg[i]], 1, diff, root[i - 1]);
+			} else {
+				root[i] = root[i - 1];
+			}
+		}
+		for (int i = 1, u, x, k, lastAns = 0; i <= q; i++) {
+			u = io.nextInt();
+			x = io.nextInt();
+			k = io.nextInt();
+			u = (u ^ lastAns) % n + 1;
+			x = x ^ lastAns;
+			k = (k ^ lastAns) % n + 1;
+			lastAns = compute(u, x, k);
+			if (lastAns == 0) {
+				io.writelnInt(-1);
+			} else {
+				io.writelnInt(lastAns);
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
diff --git a/src/class164/Code04_Peaks2.java b/src/class164/Code04_Peaks2.java
new file mode 100644
index 000000000..079548226
--- /dev/null
+++ b/src/class164/Code04_Peaks2.java
@@ -0,0 +1,221 @@
+package class164;
+
+// 边权上限内第k大点权，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P7834
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, w;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXK = 200001;
+//const int MAXM = 500001;
+//const int MAXT = MAXN * 40;
+//const int MAXH = 20;
+//int n, m, q;
+//int node[MAXN];
+//int sorted[MAXN];
+//int diff;
+//
+//Edge edge[MAXM];
+//
+//int head[MAXK];
+//int nxt[MAXK];
+//int to[MAXK];
+//int cntg;
+//
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu;
+//
+//int dfn[MAXK];
+//int seg[MAXK];
+//int stjump[MAXK][MAXH];
+//int siz[MAXK];
+//int cntd;
+//
+//int root[MAXK];
+//int ls[MAXT];
+//int rs[MAXT];
+//int segsiz[MAXT];
+//int cntt;
+//
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = diff;
+//    while (left <= right) {
+//        int mid = (left + right) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = node[i];
+//    }
+//    sorted[n + 1] = 0;
+//    sort(sorted + 1, sorted + n + 2);
+//    diff = 1;
+//    for (int i = 2; i <= n + 1; i++) {
+//        if (sorted[diff] != sorted[i]) {
+//            sorted[++diff] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        node[i] = kth(node[i]);
+//    }
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int find(int i) {
+//    if (i != father[i]) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//void kruskalRebuild() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(edge + 1, edge + m + 1, cmp);
+//    cntu = n;
+//    for (int i = 1, fx, fy; i <= m; i++) {
+//        fx = find(edge[i].u);
+//        fy = find(edge[i].v);
+//        if (fx != fy) {
+//            father[fx] = father[fy] = ++cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = edge[i].w;
+//            addEdge(cntu, fx);
+//            addEdge(cntu, fy);
+//        }
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    siz[u] = 1;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs(to[e], u);
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        siz[u] += siz[to[e]];
+//    }
+//}
+//
+//int build(int l, int r) {
+//    int rt = ++cntt;
+//    segsiz[rt] = 0;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        ls[rt] = build(l, mid);
+//        rs[rt] = build(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int insert(int jobi, int l, int r, int i) {
+//    int rt = ++cntt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    segsiz[rt] = segsiz[i] + 1;
+//    if (l < r) {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//int query(int jobk, int l, int r, int pre, int post) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) / 2;
+//    int rsize = segsiz[ rs[post] ] - segsiz[ rs[pre] ];
+//    if (rsize >= jobk) {
+//        return query(jobk, mid + 1, r, rs[pre], rs[post]);
+//    } else {
+//        return query(jobk - rsize, l, mid, ls[pre], ls[post]);
+//    }
+//}
+//
+//int compute(int u, int x, int k) {
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] <= x) {
+//            u = stjump[u][p];
+//        }
+//    }
+//    int idx = query(k, 1, diff, root[dfn[u] - 1], root[dfn[u] + siz[u] - 1]);
+//    return sorted[idx];
+//}
+//
+//int main(){
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> q;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> node[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> edge[i].u >> edge[i].v >> edge[i].w;
+//    }
+//    prepare();
+//    kruskalRebuild();
+//    for (int i = 1; i <= cntu; i++) {
+//        if (i == father[i]) {
+//            dfs(i, 0);
+//        }
+//    }
+//    root[0] = build(1, diff);
+//    for (int i = 1; i <= cntd; i++) {
+//        if (seg[i] <= n) {
+//            root[i] = insert(node[seg[i]], 1, diff, root[i - 1]);
+//        } else {
+//            root[i] = root[i - 1];
+//        }
+//    }
+//    for (int i = 1, u, x, k, lastAns = 0; i <= q; i++) {
+//        cin >> u >> x >> k;
+//        u = ((u ^ lastAns) % n) + 1;
+//        x = x ^ lastAns;
+//        k = ((k ^ lastAns) % n) + 1;
+//        lastAns = compute(u, x, k);
+//        if (lastAns == 0) {
+//            cout << -1 << "\n";
+//        } else {
+//            cout << lastAns << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 322cc21befc8cef746b53cb3af6fad620a7c0fa3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Mar 2025 23:15:09 +0800
Subject: [PATCH 0625/1712] modify code

---
 src/class164/Code02_YouyouTraining1.java      | 266 ++++++++++++++++++
 src/class164/Code02_YouyouTraining2.java      | 130 +++++++++
 src/class164/Code03_ReturnJourney1.java       | 259 -----------------
 ...ampRally1.java => Code04_StampRally1.java} |   2 +-
 ...ampRally2.java => Code04_StampRally2.java} |   0
 ...turnJourney2.java => Code05_Journey1.java} |  78 +++--
 ...turnJourney3.java => Code05_Journey2.java} |   0
 ...{Code04_Peaks1.java => Code06_Peaks1.java} |   4 +-
 ...{Code04_Peaks2.java => Code06_Peaks2.java} |   0
 9 files changed, 449 insertions(+), 290 deletions(-)
 create mode 100644 src/class164/Code02_YouyouTraining1.java
 create mode 100644 src/class164/Code02_YouyouTraining2.java
 delete mode 100644 src/class164/Code03_ReturnJourney1.java
 rename src/class164/{Code02_StampRally1.java => Code04_StampRally1.java} (99%)
 rename src/class164/{Code02_StampRally2.java => Code04_StampRally2.java} (100%)
 rename src/class164/{Code03_ReturnJourney2.java => Code05_Journey1.java} (79%)
 rename src/class164/{Code03_ReturnJourney3.java => Code05_Journey2.java} (100%)
 rename src/class164/{Code04_Peaks1.java => Code06_Peaks1.java} (98%)
 rename src/class164/{Code04_Peaks2.java => Code06_Peaks2.java} (100%)

diff --git a/src/class164/Code02_YouyouTraining1.java b/src/class164/Code02_YouyouTraining1.java
new file mode 100644
index 000000000..ad4e5bb6a
--- /dev/null
+++ b/src/class164/Code02_YouyouTraining1.java
@@ -0,0 +1,266 @@
+package class164;
+
+// youyou的军训，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P9638
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class Code02_YouyouTraining1 {
+
+	public static int MAXK = 800001;
+	public static int MAXM = 400001;
+	public static int MAXH = 20;
+	public static int n, m, q;
+	public static int[][] edge = new int[MAXM][4];
+	public static int[] edgeToTree = new int[MAXM];
+
+	public static int[] head = new int[MAXK];
+	public static int[] next = new int[MAXK];
+	public static int[] to = new int[MAXK];
+	public static int cntg = 0;
+
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int[] stack = new int[MAXK];
+	public static int cntu;
+
+	public static int[] siz = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
+
+	// 并查集的find方法，需要改成迭代版不然会爆栈，C++实现不需要
+	public static int find(int i) {
+		int size = 0;
+		while (i != father[i]) {
+			stack[size++] = i;
+			i = father[i];
+		}
+		while (size > 0) {
+			father[stack[--size]] = i;
+		}
+		return i;
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(edge, 1, m + 1, (a, b) -> b[2] - a[2]);
+		cntu = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(edge[i][0]);
+			fy = find(edge[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = edge[i][2];
+				addEdge(cntu, fx);
+				addEdge(cntu, fy);
+				edgeToTree[edge[i][3]] = cntu;
+			}
+		}
+	}
+
+	// dfs1是递归函数，需要改成迭代版不然会爆栈，C++实现不需要
+	public static void dfs1(int u, int fa) {
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs1(to[e], u);
+		}
+		if (u <= n) {
+			siz[u] = 1;
+		} else {
+			siz[u] = 0;
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			siz[u] += siz[to[e]];
+		}
+	}
+
+	public static int[][] ufe = new int[MAXK][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// dfs2是dfs1的迭代版
+	public static void dfs2(int cur, int fa) {
+		stacksize = 0;
+		push(cur, fa, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				push(to[e], u, -1);
+			} else {
+				if (u <= n) {
+					siz[u] = 1;
+				} else {
+					siz[u] = 0;
+				}
+				for (int ei = head[u]; ei > 0; ei = next[ei]) {
+					siz[u] += siz[to[ei]];
+				}
+			}
+		}
+	}
+
+	public static int query(int u, int limit) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] >= limit) {
+				u = stjump[u][p];
+			}
+		}
+		return siz[u];
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		q = io.nextInt();
+		for (int i = 1; i <= m; i++) {
+			edge[i][0] = io.nextInt();
+			edge[i][1] = io.nextInt();
+			edge[i][2] = io.nextInt();
+			edge[i][3] = i;
+		}
+		kruskalRebuild();
+		for (int i = 1; i <= cntu; i++) {
+			if (i == father[i]) {
+				dfs2(i, 0);
+			}
+		}
+		int op, x, y, limit = 0;
+		for (int i = 1; i <= q; i++) {
+			op = io.nextInt();
+			if (op == 1) {
+				limit = io.nextInt();
+			} else if (op == 2) {
+				x = io.nextInt();
+				io.writelnInt(query(x, limit));
+			} else {
+				x = io.nextInt();
+				y = io.nextInt();
+				if (edgeToTree[x] != 0) {
+					nodeKey[edgeToTree[x]] = y;
+				}
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
diff --git a/src/class164/Code02_YouyouTraining2.java b/src/class164/Code02_YouyouTraining2.java
new file mode 100644
index 000000000..e29892252
--- /dev/null
+++ b/src/class164/Code02_YouyouTraining2.java
@@ -0,0 +1,130 @@
+package class164;
+
+// youyou的军训，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P9638
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, w, i;
+//};
+//
+//const int MAXK = 800001;
+//const int MAXM = 400001;
+//const int MAXH = 20;
+//int n, m, q;
+//Edge edge[MAXM];
+//int edgeToTree[MAXM];
+//
+//int head[MAXK];
+//int nxt[MAXK];
+//int to[MAXK];
+//int cntg;
+//
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int stackArr[MAXK];
+//int cntu;
+//
+//int siz[MAXK];
+//int stjump[MAXK][MAXH];
+//
+//bool cmp(Edge x, Edge y) {
+//    return x.w > y.w;
+//}
+//
+//int find(int i) {
+//    if (i != father[i]) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void kruskalRebuild() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(edge + 1, edge + m + 1, cmp);
+//    cntu = n;
+//    for (int i = 1, fx, fy; i <= m; i++) {
+//        fx = find(edge[i].u);
+//        fy = find(edge[i].v);
+//        if (fx != fy) {
+//            father[fx] = father[fy] = ++cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = edge[i].w;
+//            addEdge(cntu, fx);
+//            addEdge(cntu, fy);
+//            edgeToTree[edge[i].i] = cntu;
+//        }
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs(to[e], u);
+//    }
+//    if (u <= n) {
+//        siz[u] = 1;
+//    } else {
+//        siz[u] = 0;
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        siz[u] += siz[to[e]];
+//    }
+//}
+//
+//int query(int u, int limit) {
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] >= limit) {
+//            u = stjump[u][p];
+//        }
+//    }
+//    return siz[u];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> q;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> edge[i].u >> edge[i].v >> edge[i].w;
+//        edge[i].i = i;
+//    }
+//    kruskalRebuild();
+//    for (int i = 1; i <= cntu; i++) {
+//        if (i == father[i]) {
+//            dfs(i, 0);
+//        }
+//    }
+//    int op, x, y, limit = 0;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> op;
+//        if (op == 1) {
+//            cin >> limit;
+//        } else if (op == 2) {
+//            cin >> x;
+//            cout << query(x, limit) << "\n";
+//        } else {
+//            cin >> x >> y;
+//            if (edgeToTree[x] != 0) {
+//                nodeKey[edgeToTree[x]] = y;
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class164/Code03_ReturnJourney1.java b/src/class164/Code03_ReturnJourney1.java
deleted file mode 100644
index 3892225f9..000000000
--- a/src/class164/Code03_ReturnJourney1.java
+++ /dev/null
@@ -1,259 +0,0 @@
-package class164;
-
-// 归程，java实现递归版
-// 测试链接 : https://www.luogu.com.cn/problem/P4768
-// 提交以下的code，提交时请把类名改成"Main"
-// 因为树的深度太大，递归函数爆栈了，所以无法全部通过所有测试用例
-// find方法、dfs方法都需要改成迭代版，就是本节课Code03_ReturnJourney2文件
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStream;
-import java.util.Arrays;
-import java.util.PriorityQueue;
-
-public class Code03_ReturnJourney1 {
-
-	public static int MAXN = 200001;
-	public static int MAXK = 400001;
-	public static int MAXM = 400001;
-	public static int MAXH = 20;
-	public static int INF = 2000000001;
-	public static int t, n, m, q, k, s;
-	public static int[][] arr = new int[MAXM][4];
-
-	public static int[] headg = new int[MAXN];
-	public static int[] nextg = new int[MAXM << 1];
-	public static int[] tog = new int[MAXM << 1];
-	public static int[] weightg = new int[MAXM << 1];
-	public static int cntg;
-
-	public static int[] dist = new int[MAXN];
-	public static boolean[] visit = new boolean[MAXN];
-	public static PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
-
-	public static int[] headk = new int[MAXK];
-	public static int[] nextk = new int[MAXK];
-	public static int[] tok = new int[MAXK];
-	public static int cntk;
-
-	public static int[] father = new int[MAXK];
-	public static int[] nodeKey = new int[MAXK];
-	public static int cntu;
-
-	public static int[] dep = new int[MAXK];
-	public static int[][] stjump = new int[MAXK][MAXH];
-	public static int[] mindist = new int[MAXK];
-
-	public static void prepare() {
-		cntg = cntk = 0;
-		Arrays.fill(headg, 1, n + 1, 0);
-		Arrays.fill(headk, 1, n * 2, 0);
-	}
-
-	public static void addEdgeG(int u, int v, int w) {
-		nextg[++cntg] = headg[u];
-		tog[cntg] = v;
-		weightg[cntg] = w;
-		headg[u] = cntg;
-	}
-
-	public static void dijkstra() {
-		for (int i = 1; i <= m; i++) {
-			addEdgeG(arr[i][0], arr[i][1], arr[i][2]);
-			addEdgeG(arr[i][1], arr[i][0], arr[i][2]);
-		}
-		Arrays.fill(dist, 1, n + 1, INF);
-		Arrays.fill(visit, 1, n + 1, false);
-		dist[1] = 0;
-		heap.add(new int[] { 1, 0 });
-		int[] cur;
-		int x, v;
-		while (!heap.isEmpty()) {
-			cur = heap.poll();
-			x = cur[0];
-			v = cur[1];
-			if (!visit[x]) {
-				visit[x] = true;
-				for (int e = headg[x], y, w; e > 0; e = nextg[e]) {
-					y = tog[e];
-					w = weightg[e];
-					if (!visit[y] && dist[y] > v + w) {
-						dist[y] = v + w;
-						heap.add(new int[] { y, dist[y] });
-					}
-				}
-			}
-		}
-	}
-
-	public static void addEdgeK(int u, int v) {
-		nextk[++cntk] = headk[u];
-		tok[cntk] = v;
-		headk[u] = cntk;
-	}
-
-	public static int find(int i) {
-		if (i != father[i]) {
-			father[i] = find(father[i]);
-		}
-		return father[i];
-	}
-
-	public static void kruskalRebuild() {
-		for (int i = 1; i <= n; i++) {
-			father[i] = i;
-		}
-		Arrays.sort(arr, 1, m + 1, (a, b) -> b[3] - a[3]);
-		cntu = n;
-		for (int i = 1, fx, fy; i <= m; i++) {
-			fx = find(arr[i][0]);
-			fy = find(arr[i][1]);
-			if (fx != fy) {
-				father[fx] = father[fy] = ++cntu;
-				father[cntu] = cntu;
-				nodeKey[cntu] = arr[i][3];
-				addEdgeK(cntu, fx);
-				addEdgeK(cntu, fy);
-			}
-		}
-	}
-
-	public static void dfs(int u, int fa) {
-		dep[u] = dep[fa] + 1;
-		stjump[u][0] = fa;
-		for (int p = 1; p < MAXH; p++) {
-			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
-		}
-		for (int e = headk[u]; e > 0; e = nextk[e]) {
-			dfs(tok[e], u);
-		}
-		if (u <= n) {
-			mindist[u] = dist[u];
-		} else {
-			mindist[u] = INF;
-		}
-		for (int e = headk[u]; e > 0; e = nextk[e]) {
-			mindist[u] = Math.min(mindist[u], mindist[tok[e]]);
-		}
-	}
-
-	public static int query(int node, int line) {
-		for (int p = MAXH - 1; p >= 0; p--) {
-			if (stjump[node][p] > 0 && nodeKey[stjump[node][p]] > line) {
-				node = stjump[node][p];
-			}
-		}
-		return mindist[node];
-	}
-
-	public static void main(String[] args) {
-		FastIO io = new FastIO(System.in, System.out);
-		t = io.nextInt();
-		for (int test = 1; test <= t; test++) {
-			n = io.nextInt();
-			m = io.nextInt();
-			prepare();
-			for (int i = 1; i <= m; i++) {
-				arr[i][0] = io.nextInt();
-				arr[i][1] = io.nextInt();
-				arr[i][2] = io.nextInt();
-				arr[i][3] = io.nextInt();
-			}
-			dijkstra();
-			kruskalRebuild();
-			dfs(cntu, 0);
-			q = io.nextInt();
-			k = io.nextInt();
-			s = io.nextInt();
-			for (int i = 1, node, line, lastAns = 0; i <= q; i++) {
-				node = (io.nextInt() + k * lastAns - 1) % n + 1;
-				line = (io.nextInt() + k * lastAns) % (s + 1);
-				lastAns = query(node, line);
-				io.writelnInt(lastAns);
-			}
-		}
-		io.flush();
-	}
-
-	// 读写工具类
-	static class FastIO {
-		private final InputStream is;
-		private final OutputStream os;
-		private final byte[] inbuf = new byte[1 << 16];
-		private int lenbuf = 0;
-		private int ptrbuf = 0;
-		private final StringBuilder outBuf = new StringBuilder();
-
-		public FastIO(InputStream is, OutputStream os) {
-			this.is = is;
-			this.os = os;
-		}
-
-		private int readByte() {
-			if (ptrbuf >= lenbuf) {
-				ptrbuf = 0;
-				try {
-					lenbuf = is.read(inbuf);
-				} catch (IOException e) {
-					throw new RuntimeException(e);
-				}
-				if (lenbuf == -1) {
-					return -1;
-				}
-			}
-			return inbuf[ptrbuf++] & 0xff;
-		}
-
-		private int skip() {
-			int b;
-			while ((b = readByte()) != -1) {
-				if (b > ' ') {
-					return b;
-				}
-			}
-			return -1;
-		}
-
-		public int nextInt() {
-			int b = skip();
-			if (b == -1) {
-				throw new RuntimeException("No more integers (EOF)");
-			}
-			boolean negative = false;
-			if (b == '-') {
-				negative = true;
-				b = readByte();
-			}
-			int val = 0;
-			while (b >= '0' && b <= '9') {
-				val = val * 10 + (b - '0');
-				b = readByte();
-			}
-			return negative ? -val : val;
-		}
-
-		public void write(String s) {
-			outBuf.append(s);
-		}
-
-		public void writeInt(int x) {
-			outBuf.append(x);
-		}
-
-		public void writelnInt(int x) {
-			outBuf.append(x).append('\n');
-		}
-
-		public void flush() {
-			try {
-				os.write(outBuf.toString().getBytes());
-				os.flush();
-				outBuf.setLength(0);
-			} catch (IOException e) {
-				throw new RuntimeException(e);
-			}
-		}
-	}
-
-}
diff --git a/src/class164/Code02_StampRally1.java b/src/class164/Code04_StampRally1.java
similarity index 99%
rename from src/class164/Code02_StampRally1.java
rename to src/class164/Code04_StampRally1.java
index b5c3a8da5..9ab183ab0 100644
--- a/src/class164/Code02_StampRally1.java
+++ b/src/class164/Code04_StampRally1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code02_StampRally1 {
+public class Code04_StampRally1 {
 
 	public static int MAXK = 200001;
 	public static int MAXM = 100001;
diff --git a/src/class164/Code02_StampRally2.java b/src/class164/Code04_StampRally2.java
similarity index 100%
rename from src/class164/Code02_StampRally2.java
rename to src/class164/Code04_StampRally2.java
diff --git a/src/class164/Code03_ReturnJourney2.java b/src/class164/Code05_Journey1.java
similarity index 79%
rename from src/class164/Code03_ReturnJourney2.java
rename to src/class164/Code05_Journey1.java
index b28aade10..1eb4c7111 100644
--- a/src/class164/Code03_ReturnJourney2.java
+++ b/src/class164/Code05_Journey1.java
@@ -1,6 +1,6 @@
 package class164;
 
-// 归程，java实现迭代版
+// 归程，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -10,7 +10,7 @@
 import java.util.Arrays;
 import java.util.PriorityQueue;
 
-public class Code03_ReturnJourney2 {
+public class Code05_Journey1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 400001;
@@ -92,6 +92,7 @@ public static void addEdgeK(int u, int v) {
 		headk[u] = cntk;
 	}
 
+	// 并查集的find方法，需要改成迭代版不然会爆栈，C++实现不需要
 	public static int find(int i) {
 		int size = 0;
 		while (i != father[i]) {
@@ -123,50 +124,71 @@ public static void kruskalRebuild() {
 		}
 	}
 
-	public static int[][] fse = new int[MAXK][3];
+	// dfs1是递归函数，需要改成迭代版不然会爆栈，C++实现不需要
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = headk[u]; e > 0; e = nextk[e]) {
+			dfs1(tok[e], u);
+		}
+		if (u <= n) {
+			mindist[u] = dist[u];
+		} else {
+			mindist[u] = INF;
+		}
+		for (int e = headk[u]; e > 0; e = nextk[e]) {
+			mindist[u] = Math.min(mindist[u], mindist[tok[e]]);
+		}
+	}
+
+	public static int[][] ufe = new int[MAXK][3];
 
-	public static int stacksize, first, second, edge;
+	public static int stacksize, u, f, e;
 
-	public static void push(int fir, int sec, int edg) {
-		fse[stacksize][0] = fir;
-		fse[stacksize][1] = sec;
-		fse[stacksize][2] = edg;
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
 		stacksize++;
 	}
 
 	public static void pop() {
 		--stacksize;
-		first = fse[stacksize][0];
-		second = fse[stacksize][1];
-		edge = fse[stacksize][2];
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
 	}
 
-	public static void dfs(int u, int fa) {
+	// dfs2是dfs1的迭代版
+	public static void dfs2(int cur, int fa) {
 		stacksize = 0;
-		push(u, fa, -1);
+		push(cur, fa, -1);
 		while (stacksize > 0) {
 			pop();
-			if (edge == -1) {
-				dep[first] = dep[second] + 1;
-				stjump[first][0] = second;
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				stjump[u][0] = f;
 				for (int p = 1; p < MAXH; p++) {
-					stjump[first][p] = stjump[stjump[first][p - 1]][p - 1];
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 				}
-				edge = headk[first];
+				e = headk[u];
 			} else {
-				edge = nextk[edge];
+				e = nextk[e];
 			}
-			if (edge != 0) {
-				push(first, second, edge);
-				push(tok[edge], first, -1);
+			if (e != 0) {
+				push(u, f, e);
+				push(tok[e], u, -1);
 			} else {
-				if (first <= n) {
-					mindist[first] = dist[first];
+				if (u <= n) {
+					mindist[u] = dist[u];
 				} else {
-					mindist[first] = INF;
+					mindist[u] = INF;
 				}
-				for (int e = headk[first]; e > 0; e = nextk[e]) {
-					mindist[first] = Math.min(mindist[first], mindist[tok[e]]);
+				for (int ei = headk[u]; ei > 0; ei = nextk[ei]) {
+					mindist[u] = Math.min(mindist[u], mindist[tok[ei]]);
 				}
 			}
 		}
@@ -196,7 +218,7 @@ public static void main(String[] args) {
 			}
 			dijkstra();
 			kruskalRebuild();
-			dfs(cntu, 0);
+			dfs2(cntu, 0);
 			q = io.nextInt();
 			k = io.nextInt();
 			s = io.nextInt();
diff --git a/src/class164/Code03_ReturnJourney3.java b/src/class164/Code05_Journey2.java
similarity index 100%
rename from src/class164/Code03_ReturnJourney3.java
rename to src/class164/Code05_Journey2.java
diff --git a/src/class164/Code04_Peaks1.java b/src/class164/Code06_Peaks1.java
similarity index 98%
rename from src/class164/Code04_Peaks1.java
rename to src/class164/Code06_Peaks1.java
index d9482858c..65fdee548 100644
--- a/src/class164/Code04_Peaks1.java
+++ b/src/class164/Code06_Peaks1.java
@@ -5,7 +5,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code04_Peaks2文件就是C++的实现
+// 想通过用C++实现，本节课Code06_Peaks2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -13,7 +13,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code04_Peaks1 {
+public class Code06_Peaks1 {
 
 	public static int MAXN = 100001;
 	public static int MAXK = 200001;
diff --git a/src/class164/Code04_Peaks2.java b/src/class164/Code06_Peaks2.java
similarity index 100%
rename from src/class164/Code04_Peaks2.java
rename to src/class164/Code06_Peaks2.java

From 351d346145bb9e2e0254070e914cd27fefc49b8b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 28 Mar 2025 23:16:31 +0800
Subject: [PATCH 0626/1712] modify code

---
 .../{Code02_YouyouTraining1.java => Code02_Training1.java}      | 2 +-
 .../{Code02_YouyouTraining2.java => Code02_Training2.java}      | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class164/{Code02_YouyouTraining1.java => Code02_Training1.java} (99%)
 rename src/class164/{Code02_YouyouTraining2.java => Code02_Training2.java} (100%)

diff --git a/src/class164/Code02_YouyouTraining1.java b/src/class164/Code02_Training1.java
similarity index 99%
rename from src/class164/Code02_YouyouTraining1.java
rename to src/class164/Code02_Training1.java
index ad4e5bb6a..6b75d97a9 100644
--- a/src/class164/Code02_YouyouTraining1.java
+++ b/src/class164/Code02_Training1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code02_YouyouTraining1 {
+public class Code02_Training1 {
 
 	public static int MAXK = 800001;
 	public static int MAXM = 400001;
diff --git a/src/class164/Code02_YouyouTraining2.java b/src/class164/Code02_Training2.java
similarity index 100%
rename from src/class164/Code02_YouyouTraining2.java
rename to src/class164/Code02_Training2.java

From 67f35e54161ffe4456eada9df41c5ec1f3879966 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 29 Mar 2025 00:49:14 +0800
Subject: [PATCH 0627/1712] modify code

---
 src/class164/Code03_UntilConnect1.java | 257 +++++++++++++++++++++++++
 src/class164/Code03_UntilConnect2.java | 179 +++++++++++++++++
 src/class164/Code05_Journey1.java      |   4 +-
 src/class164/Code05_Journey2.java      |   4 +-
 4 files changed, 440 insertions(+), 4 deletions(-)
 create mode 100644 src/class164/Code03_UntilConnect1.java
 create mode 100644 src/class164/Code03_UntilConnect2.java

diff --git a/src/class164/Code03_UntilConnect1.java b/src/class164/Code03_UntilConnect1.java
new file mode 100644
index 000000000..64075d1a5
--- /dev/null
+++ b/src/class164/Code03_UntilConnect1.java
@@ -0,0 +1,257 @@
+package class164;
+
+// 加边直到连通，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1706E
+// 测试链接 : https://codeforces.com/problemset/problem/1706/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class Code03_UntilConnect1 {
+
+	public static int MAXN = 100001;
+	public static int MAXK = 200001;
+	public static int MAXM = 200001;
+	public static int MAXH = 20;
+	public static int t, n, m, q;
+	public static int[][] edge = new int[MAXM][3];
+
+	public static int[] head = new int[MAXK];
+	public static int[] next = new int[MAXK];
+	public static int[] to = new int[MAXK];
+	public static int cntg;
+
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int cntu;
+
+	public static int[] dep = new int[MAXK];
+	public static int[] dfn = new int[MAXK];
+	public static int[] seg = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
+	public static int cntd;
+
+	public static int[] lg2 = new int[MAXN];
+	public static int[][] stmax = new int[MAXN][MAXH];
+	public static int[][] stmin = new int[MAXN][MAXH];
+
+	public static void clear() {
+		cntg = cntd = 0;
+		Arrays.fill(head, 1, n * 2, 0);
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(edge, 1, m + 1, (a, b) -> a[2] - b[2]);
+		cntu = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(edge[i][0]);
+			fy = find(edge[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = edge[i][2];
+				addEdge(cntu, fx);
+				addEdge(cntu, fy);
+			}
+		}
+	}
+
+	public static void dfs(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs(to[e], u);
+		}
+	}
+
+	public static void buildst() {
+		lg2[0] = -1;
+		for (int i = 1; i <= n; i++) {
+			lg2[i] = lg2[i >> 1] + 1;
+			stmax[i][0] = dfn[i];
+			stmin[i][0] = dfn[i];
+		}
+		for (int p = 1; p <= lg2[n]; p++) {
+			for (int i = 1; i + (1 << p) - 1 <= n; i++) {
+				stmax[i][p] = Math.max(stmax[i][p - 1], stmax[i + (1 << (p - 1))][p - 1]);
+				stmin[i][p] = Math.min(stmin[i][p - 1], stmin[i + (1 << (p - 1))][p - 1]);
+			}
+		}
+	}
+
+	public static int dfnmin(int l, int r) {
+		int p = lg2[r - l + 1];
+		int ans = Math.min(stmin[l][p], stmin[r - (1 << p) + 1][p]);
+		return ans;
+	}
+
+	public static int dfnmax(int l, int r) {
+		int p = lg2[r - l + 1];
+		int ans = Math.max(stmax[l][p], stmax[r - (1 << p) + 1][p]);
+		return ans;
+	}
+
+	public static int lca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int query(int l, int r) {
+		int x = seg[dfnmin(l, r)];
+		int y = seg[dfnmax(l, r)];
+		return nodeKey[lca(x, y)];
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		t = io.nextInt();
+		for (int test = 1; test <= t; test++) {
+			n = io.nextInt();
+			m = io.nextInt();
+			q = io.nextInt();
+			for (int i = 1; i <= m; i++) {
+				edge[i][0] = io.nextInt();
+				edge[i][1] = io.nextInt();
+				edge[i][2] = i;
+			}
+			clear();
+			kruskalRebuild();
+			dfs(cntu, 0);
+			buildst();
+			for (int i = 1, l, r; i <= q; i++) {
+				l = io.nextInt();
+				r = io.nextInt();
+				if (l == r) {
+					io.write("0 ");
+				} else {
+					io.write(query(l, r) + " ");
+				}
+			}
+			io.write("\n");
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
diff --git a/src/class164/Code03_UntilConnect2.java b/src/class164/Code03_UntilConnect2.java
new file mode 100644
index 000000000..c93463933
--- /dev/null
+++ b/src/class164/Code03_UntilConnect2.java
@@ -0,0 +1,179 @@
+package class164;
+
+// 加边直到连通，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1706E
+// 测试链接 : https://codeforces.com/problemset/problem/1706/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, w;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXK = 200001;
+//const int MAXM = 200001;
+//const int MAXH = 20;
+//int t, n, m, q;
+//
+//Edge edge[MAXM];
+//int head[MAXK];
+//int nxt[MAXK];
+//int to[MAXK];
+//int cntg;
+//
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu;
+//
+//int dep[MAXK];
+//int dfn[MAXK];
+//int seg[MAXK];
+//int stjump[MAXK][MAXH];
+//int cntd;
+//
+//int lg2[MAXN];
+//int stmax[MAXN][MAXH];
+//int stmin[MAXN][MAXH];
+//
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
+//void clear() {
+//    cntg = 0;
+//    cntd = 0;
+//    for (int i = 1; i <= n * 2; i++) {
+//        head[i] = 0;
+//    }
+//}
+//
+//int find(int i) {
+//    if (i != father[i]) father[i] = find(father[i]);
+//    return father[i];
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void kruskalRebuild() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(edge + 1, edge + m + 1, cmp);
+//    cntu = n;
+//    for (int i = 1, fx, fy; i <= m; i++) {
+//        fx = find(edge[i].u);
+//        fy = find(edge[i].v);
+//        if (fx != fy) {
+//            father[fx] = father[fy] = ++cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = edge[i].w;
+//            addEdge(cntu, fx);
+//            addEdge(cntu, fy);
+//        }
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs(to[e], u);
+//    }
+//}
+//
+//void buildst() {
+//	lg2[0] = -1;
+//    for (int i = 1; i <= n; i++) {
+//    	lg2[i] = lg2[i >> 1] + 1;
+//        stmax[i][0] = dfn[i];
+//        stmin[i][0] = dfn[i];
+//    }
+//    for (int p = 1; p <= lg2[n]; p++) {
+//        for (int i = 1; i + (1 << p) - 1 <= n; i++) {
+//            stmax[i][p] = max(stmax[i][p - 1], stmax[i + (1 << (p - 1))][p - 1]);
+//            stmin[i][p] = min(stmin[i][p - 1], stmin[i + (1 << (p - 1))][p - 1]);
+//        }
+//    }
+//}
+//
+//int dfnmin(int l, int r) {
+//    int p = lg2[r - l + 1];
+//    int ans = min(stmin[l][p], stmin[r - (1 << p) + 1][p]);
+//    return ans;
+//}
+//
+//int dfnmax(int l, int r) {
+//    int p = lg2[r - l + 1];
+//    int ans = max(stmax[l][p], stmax[r - (1 << p) + 1][p]);
+//    return ans;
+//}
+//
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        int tmp = a;
+//        a = b;
+//        b = tmp;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int query(int l, int r) {
+//    int x = seg[dfnmin(l, r)];
+//    int y = seg[dfnmax(l, r)];
+//    return nodeKey[lca(x, y)];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> t;
+//    for (int test = 1; test <= t; test++) {
+//        cin >> n >> m >> q;
+//        for (int i = 1; i <= m; i++) {
+//            cin >> edge[i].u >> edge[i].v;
+//            edge[i].w = i;
+//        }
+//        clear();
+//        kruskalRebuild();
+//        dfs(cntu, 0);
+//        buildst();
+//        for (int i = 1, l, r; i <= q; i++) {
+//            cin >> l >> r;
+//            if (l == r) {
+//                cout << 0 << " ";
+//            } else {
+//                cout << query(l, r) << " ";
+//            }
+//        }
+//        cout << "\n";
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class164/Code05_Journey1.java b/src/class164/Code05_Journey1.java
index 1eb4c7111..0d2ffa714 100644
--- a/src/class164/Code05_Journey1.java
+++ b/src/class164/Code05_Journey1.java
@@ -44,7 +44,7 @@ public class Code05_Journey1 {
 	public static int[][] stjump = new int[MAXK][MAXH];
 	public static int[] mindist = new int[MAXK];
 
-	public static void prepare() {
+	public static void clear() {
 		cntg = cntk = 0;
 		Arrays.fill(headg, 1, n + 1, 0);
 		Arrays.fill(headk, 1, n * 2, 0);
@@ -209,7 +209,7 @@ public static void main(String[] args) {
 		for (int test = 1; test <= t; test++) {
 			n = io.nextInt();
 			m = io.nextInt();
-			prepare();
+			clear();
 			for (int i = 1; i <= m; i++) {
 				arr[i][0] = io.nextInt();
 				arr[i][1] = io.nextInt();
diff --git a/src/class164/Code05_Journey2.java b/src/class164/Code05_Journey2.java
index 6ec74f727..5d31f304c 100644
--- a/src/class164/Code05_Journey2.java
+++ b/src/class164/Code05_Journey2.java
@@ -58,7 +58,7 @@
 //int stjump[MAXK][MAXH];
 //int mindist[MAXK];
 //
-//void prepare() {
+//void clear() {
 //    cntg = 0;
 //    cntk = 0;
 //    for(int i = 1; i <= n; i++) {
@@ -176,7 +176,7 @@
 //    cin >> t;
 //    for(int test = 1; test <= t; test++) {
 //        cin >> n >> m;
-//        prepare();
+//        clear();
 //        for(int i = 1; i <= m; i++) {
 //            cin >> arr[i].u >> arr[i].v >> arr[i].l >> arr[i].a;
 //        }

From b52d6f32c7e607f736f75da2fdfa2d795ea29ed5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 29 Mar 2025 16:06:26 +0800
Subject: [PATCH 0628/1712] modify code

---
 .../{Code04_StampRally1.java => Code03_StampRally1.java} | 2 +-
 .../{Code04_StampRally2.java => Code03_StampRally2.java} | 0
 .../{Code05_Journey1.java => Code04_Journey1.java}       | 2 +-
 .../{Code05_Journey2.java => Code04_Journey2.java}       | 0
 src/class164/{Code06_Peaks1.java => Code05_Peaks1.java}  | 4 ++--
 src/class164/{Code06_Peaks2.java => Code05_Peaks2.java}  | 0
 ...de03_UntilConnect1.java => Code06_UntilConnect1.java} | 2 +-
 ...de03_UntilConnect2.java => Code06_UntilConnect2.java} | 0
 src/class164/Code07_DeleteAndQueries1.java               | 9 +++++++++
 9 files changed, 14 insertions(+), 5 deletions(-)
 rename src/class164/{Code04_StampRally1.java => Code03_StampRally1.java} (99%)
 rename src/class164/{Code04_StampRally2.java => Code03_StampRally2.java} (100%)
 rename src/class164/{Code05_Journey1.java => Code04_Journey1.java} (99%)
 rename src/class164/{Code05_Journey2.java => Code04_Journey2.java} (100%)
 rename src/class164/{Code06_Peaks1.java => Code05_Peaks1.java} (98%)
 rename src/class164/{Code06_Peaks2.java => Code05_Peaks2.java} (100%)
 rename src/class164/{Code03_UntilConnect1.java => Code06_UntilConnect1.java} (99%)
 rename src/class164/{Code03_UntilConnect2.java => Code06_UntilConnect2.java} (100%)
 create mode 100644 src/class164/Code07_DeleteAndQueries1.java

diff --git a/src/class164/Code04_StampRally1.java b/src/class164/Code03_StampRally1.java
similarity index 99%
rename from src/class164/Code04_StampRally1.java
rename to src/class164/Code03_StampRally1.java
index 9ab183ab0..69f384a43 100644
--- a/src/class164/Code04_StampRally1.java
+++ b/src/class164/Code03_StampRally1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code04_StampRally1 {
+public class Code03_StampRally1 {
 
 	public static int MAXK = 200001;
 	public static int MAXM = 100001;
diff --git a/src/class164/Code04_StampRally2.java b/src/class164/Code03_StampRally2.java
similarity index 100%
rename from src/class164/Code04_StampRally2.java
rename to src/class164/Code03_StampRally2.java
diff --git a/src/class164/Code05_Journey1.java b/src/class164/Code04_Journey1.java
similarity index 99%
rename from src/class164/Code05_Journey1.java
rename to src/class164/Code04_Journey1.java
index 0d2ffa714..a1e4601fb 100644
--- a/src/class164/Code05_Journey1.java
+++ b/src/class164/Code04_Journey1.java
@@ -10,7 +10,7 @@
 import java.util.Arrays;
 import java.util.PriorityQueue;
 
-public class Code05_Journey1 {
+public class Code04_Journey1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 400001;
diff --git a/src/class164/Code05_Journey2.java b/src/class164/Code04_Journey2.java
similarity index 100%
rename from src/class164/Code05_Journey2.java
rename to src/class164/Code04_Journey2.java
diff --git a/src/class164/Code06_Peaks1.java b/src/class164/Code05_Peaks1.java
similarity index 98%
rename from src/class164/Code06_Peaks1.java
rename to src/class164/Code05_Peaks1.java
index 65fdee548..8576fa053 100644
--- a/src/class164/Code06_Peaks1.java
+++ b/src/class164/Code05_Peaks1.java
@@ -5,7 +5,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code06_Peaks2文件就是C++的实现
+// 想通过用C++实现，本节课Code05_Peaks2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -13,7 +13,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code06_Peaks1 {
+public class Code05_Peaks1 {
 
 	public static int MAXN = 100001;
 	public static int MAXK = 200001;
diff --git a/src/class164/Code06_Peaks2.java b/src/class164/Code05_Peaks2.java
similarity index 100%
rename from src/class164/Code06_Peaks2.java
rename to src/class164/Code05_Peaks2.java
diff --git a/src/class164/Code03_UntilConnect1.java b/src/class164/Code06_UntilConnect1.java
similarity index 99%
rename from src/class164/Code03_UntilConnect1.java
rename to src/class164/Code06_UntilConnect1.java
index 64075d1a5..6b8f82491 100644
--- a/src/class164/Code03_UntilConnect1.java
+++ b/src/class164/Code06_UntilConnect1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code03_UntilConnect1 {
+public class Code06_UntilConnect1 {
 
 	public static int MAXN = 100001;
 	public static int MAXK = 200001;
diff --git a/src/class164/Code03_UntilConnect2.java b/src/class164/Code06_UntilConnect2.java
similarity index 100%
rename from src/class164/Code03_UntilConnect2.java
rename to src/class164/Code06_UntilConnect2.java
diff --git a/src/class164/Code07_DeleteAndQueries1.java b/src/class164/Code07_DeleteAndQueries1.java
new file mode 100644
index 000000000..5c28f855a
--- /dev/null
+++ b/src/class164/Code07_DeleteAndQueries1.java
@@ -0,0 +1,9 @@
+package class164;
+
+// 删边和查询，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1416D
+// 测试链接 : https://codeforces.com/problemset/problem/1416/D
+
+public class Code07_DeleteAndQueries1 {
+
+}

From da896a1ee37ca5800f944a2ae89466c9a1b5bbab Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 29 Mar 2025 18:44:47 +0800
Subject: [PATCH 0629/1712] modify code

---
 src/class164/Code06_UntilConnect2.java     |   4 +-
 src/class164/Code07_DeleteAndQueries1.java | 300 +++++++++++++++++++++
 src/class164/Code07_DeleteAndQueries2.java | 230 ++++++++++++++++
 3 files changed, 533 insertions(+), 1 deletion(-)
 create mode 100644 src/class164/Code07_DeleteAndQueries2.java

diff --git a/src/class164/Code06_UntilConnect2.java b/src/class164/Code06_UntilConnect2.java
index c93463933..35e1d7f5b 100644
--- a/src/class164/Code06_UntilConnect2.java
+++ b/src/class164/Code06_UntilConnect2.java
@@ -53,7 +53,9 @@
 //}
 //
 //int find(int i) {
-//    if (i != father[i]) father[i] = find(father[i]);
+//    if (i != father[i]) {
+//        father[i] = find(father[i]);
+//    }
 //    return father[i];
 //}
 //
diff --git a/src/class164/Code07_DeleteAndQueries1.java b/src/class164/Code07_DeleteAndQueries1.java
index 5c28f855a..410856d4a 100644
--- a/src/class164/Code07_DeleteAndQueries1.java
+++ b/src/class164/Code07_DeleteAndQueries1.java
@@ -3,7 +3,307 @@
 // 删边和查询，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF1416D
 // 测试链接 : https://codeforces.com/problemset/problem/1416/D
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
 
 public class Code07_DeleteAndQueries1 {
 
+	public static int MAXN = 200001;
+	public static int MAXK = 400001;
+	public static int MAXM = 300001;
+	public static int MAXQ = 500001;
+	public static int MAXH = 20;
+	public static int INF = 1000000001;
+	public static int n, m, q;
+
+	public static int[] node = new int[MAXN];
+	public static int[][] edge = new int[MAXM][3];
+	public static int[][] ques = new int[MAXQ][2];
+	public static int[] timeline = new int[MAXQ];
+
+	public static int[] head = new int[MAXK];
+	public static int[] next = new int[MAXK];
+	public static int[] to = new int[MAXK];
+	public static int cntg = 0;
+
+	public static int[] father = new int[MAXK];
+	public static int[] nodeKey = new int[MAXK];
+	public static int cntu;
+
+	public static int[][] stjump = new int[MAXK][MAXH];
+	public static int[] leafsiz = new int[MAXK];
+	public static int[] leafstart = new int[MAXK];
+	public static int[] leafseg = new int[MAXK];
+	public static int cntd = 0;
+
+	public static int[] maxval = new int[MAXN << 2];
+	public static int[] maxdfn = new int[MAXN << 2];
+
+	public static int ansMax;
+	public static int updateDfn;
+
+	public static void prepare() {
+		for (int i = 1; i <= q; i++) {
+			if (ques[i][0] == 2) {
+				edge[ques[i][1]][2] = -1;
+			}
+		}
+		int time = 0;
+		for (int i = 1; i <= m; i++) {
+			if (edge[i][2] != -1) {
+				edge[i][2] = ++time;
+			}
+		}
+		for (int i = q; i >= 1; i--) {
+			if (ques[i][0] == 1) {
+				timeline[i] = time;
+			} else {
+				edge[ques[i][1]][2] = ++time;
+			}
+		}
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void kruskalRebuild() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+		}
+		Arrays.sort(edge, 1, m + 1, (a, b) -> a[2] - b[2]);
+		cntu = n;
+		for (int i = 1, fx, fy; i <= m; i++) {
+			fx = find(edge[i][0]);
+			fy = find(edge[i][1]);
+			if (fx != fy) {
+				father[fx] = father[fy] = ++cntu;
+				father[cntu] = cntu;
+				nodeKey[cntu] = edge[i][2];
+				addEdge(cntu, fx);
+				addEdge(cntu, fy);
+			}
+		}
+	}
+
+	public static void dfs(int u, int fa) {
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			dfs(to[e], u);
+		}
+		if (u <= n) {
+			leafsiz[u] = 1;
+			leafstart[u] = ++cntd;
+			leafseg[cntd] = u;
+		} else {
+			leafsiz[u] = 0;
+			leafstart[u] = INF;
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			leafsiz[u] += leafsiz[to[e]];
+			leafstart[u] = Math.min(leafstart[u], leafstart[to[e]]);
+		}
+	}
+
+	public static int getAncestor(int u, int limit) {
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] <= limit) {
+				u = stjump[u][p];
+			}
+		}
+		return u;
+	}
+
+	public static void up(int i) {
+		int l = i << 1;
+		int r = i << 1 | 1;
+		if (maxval[l] > maxval[r]) {
+			maxval[i] = maxval[l];
+			maxdfn[i] = maxdfn[l];
+		} else {
+			maxval[i] = maxval[r];
+			maxdfn[i] = maxdfn[r];
+		}
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			maxval[i] = node[leafseg[l]];
+			maxdfn[i] = l;
+		} else {
+			int mid = (l + r) / 2;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void update(int jobi, int jobv, int l, int r, int i) {
+		if (l == r) {
+			maxval[i] = jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				update(jobi, jobv, l, mid, i << 1);
+			} else {
+				update(jobi, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static void updateAns(int curmax, int curdfn) {
+		if (ansMax < curmax) {
+			ansMax = curmax;
+			updateDfn = curdfn;
+		}
+	}
+
+	public static void queryMax(int jobl, int jobr, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			updateAns(maxval[i], maxdfn[i]);
+		} else {
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				queryMax(jobl, jobr, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				queryMax(jobl, jobr, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		q = io.nextInt();
+		for (int i = 1; i <= n; i++) {
+			node[i] = io.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			edge[i][0] = io.nextInt();
+			edge[i][1] = io.nextInt();
+			edge[i][2] = 0;
+		}
+		for (int i = 1; i <= q; i++) {
+			ques[i][0] = io.nextInt();
+			ques[i][1] = io.nextInt();
+		}
+		prepare();
+		kruskalRebuild();
+		for (int i = 1; i <= cntu; i++) {
+			if (i == father[i]) {
+				dfs(i, 0);
+			}
+		}
+		build(1, n, 1);
+		for (int i = 1, anc; i <= q; i++) {
+			if (ques[i][0] == 1) {
+				ansMax = -INF;
+				anc = getAncestor(ques[i][1], timeline[i]);
+				queryMax(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
+				update(updateDfn, 0, 1, n, 1);
+				io.writelnInt(ansMax);
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
 }
diff --git a/src/class164/Code07_DeleteAndQueries2.java b/src/class164/Code07_DeleteAndQueries2.java
new file mode 100644
index 000000000..01b6d5812
--- /dev/null
+++ b/src/class164/Code07_DeleteAndQueries2.java
@@ -0,0 +1,230 @@
+package class164;
+
+// 删边和查询，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1416D
+// 测试链接 : https://codeforces.com/problemset/problem/1416/D
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, w;
+//};
+//
+//const int MAXN = 200001;
+//const int MAXK = 400001;
+//const int MAXM = 300001;
+//const int MAXQ = 500001;
+//const int MAXH = 20;
+//int INF = 1000000001;
+//int n, m, q;
+//
+//int node[MAXN];
+//Edge edge[MAXM];
+//int ques[MAXQ][2];
+//int timeline[MAXQ];
+//
+//int head[MAXK];
+//int nxt[MAXK];
+//int to[MAXK];
+//int cntg;
+//
+//int father[MAXK];
+//int nodeKey[MAXK];
+//int cntu;
+//
+//int stjump[MAXK][MAXH];
+//int leafsiz[MAXK];
+//int leafstart[MAXK];
+//int leafseg[MAXK];
+//int cntd;
+//
+//int maxval[MAXN << 2];
+//int maxdfn[MAXN << 2];
+//
+//int ansMax;
+//int updateDfn;
+//
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= q; i++) {
+//        if (ques[i][0] == 2) {
+//            edge[ques[i][1]].w = -1;
+//        }
+//    }
+//    int time = 0;
+//    for (int i = 1; i <= m; i++) {
+//        if (edge[i].w != -1) {
+//            edge[i].w = ++time;
+//        }
+//    }
+//    for (int i = q; i >= 1; i--) {
+//        if (ques[i][0] == 1) {
+//            timeline[i] = time;
+//        } else {
+//            edge[ques[i][1]].w = ++time;
+//        }
+//    }
+//}
+//
+//int find(int i) {
+//    if (i != father[i]) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void kruskalRebuild() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//    }
+//    sort(edge + 1, edge + m + 1, cmp);
+//    cntu = n;
+//    for (int i = 1; i <= m; i++) {
+//        int fx = find(edge[i].u);
+//        int fy = find(edge[i].v);
+//        if (fx != fy) {
+//            father[fx] = father[fy] = ++cntu;
+//            father[cntu] = cntu;
+//            nodeKey[cntu] = edge[i].w;
+//            addEdge(cntu, fx);
+//            addEdge(cntu, fy);
+//        }
+//    }
+//}
+//
+//void dfs(int u, int fa) {
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs(to[e], u);
+//    }
+//    if (u <= n) {
+//        leafsiz[u] = 1;
+//        leafstart[u] = ++cntd;
+//        leafseg[cntd] = u;
+//    } else {
+//        leafsiz[u] = 0;
+//        leafstart[u] = INF;
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        leafsiz[u] += leafsiz[to[e]];
+//        leafstart[u] = min(leafstart[u], leafstart[to[e]]);
+//    }
+//}
+//
+//int getAncestor(int u, int limit) {
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] <= limit) {
+//            u = stjump[u][p];
+//        }
+//    }
+//    return u;
+//}
+//
+//void up(int i) {
+//    int l = i << 1;
+//    int r = i << 1 | 1;
+//    if (maxval[l] > maxval[r]) {
+//        maxval[i] = maxval[l];
+//        maxdfn[i] = maxdfn[l];
+//    } else {
+//        maxval[i] = maxval[r];
+//        maxdfn[i] = maxdfn[r];
+//    }
+//}
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//        maxval[i] = node[leafseg[l]];
+//        maxdfn[i] = l;
+//    } else {
+//        int mid = (l + r) / 2;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//        up(i);
+//    }
+//}
+//
+//void update(int jobi, int jobv, int l, int r, int i) {
+//    if (l == r) {
+//        maxval[i] = jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            update(jobi, jobv, l, mid, i << 1);
+//        } else {
+//            update(jobi, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//void updateAns(int curmax, int curdfn) {
+//    if (ansMax < curmax) {
+//        ansMax = curmax;
+//        updateDfn = curdfn;
+//    }
+//}
+//
+//void queryMax(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        updateAns(maxval[i], maxdfn[i]);
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobl <= mid) {
+//        	queryMax(jobl, jobr, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//        	queryMax(jobl, jobr, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> q;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> node[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> edge[i].u >> edge[i].v;
+//        edge[i].w = 0;
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        cin >> ques[i][0] >> ques[i][1];
+//    }
+//    prepare();
+//    kruskalRebuild();
+//    for (int i = 1; i <= cntu; i++) {
+//        if (i == father[i]) {
+//            dfs(i, 0);
+//        }
+//    }
+//    build(1, n, 1);
+//    for (int i = 1, anc; i <= q; i++) {
+//        if (ques[i][0] == 1) {
+//            ansMax = -INF;
+//            anc = getAncestor(ques[i][1], timeline[i]);
+//            queryMax(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
+//            update(updateDfn, 0, 1, n, 1);
+//            cout << ansMax << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 344fb3de4f916e2297ae0b3b0774cf50911197fe Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 29 Mar 2025 18:45:54 +0800
Subject: [PATCH 0630/1712] modify code

---
 ...{Code07_DeleteAndQueries1.java => Code07_GraphQueries1.java} | 2 +-
 ...{Code07_DeleteAndQueries2.java => Code07_GraphQueries2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class164/{Code07_DeleteAndQueries1.java => Code07_GraphQueries1.java} (99%)
 rename src/class164/{Code07_DeleteAndQueries2.java => Code07_GraphQueries2.java} (100%)

diff --git a/src/class164/Code07_DeleteAndQueries1.java b/src/class164/Code07_GraphQueries1.java
similarity index 99%
rename from src/class164/Code07_DeleteAndQueries1.java
rename to src/class164/Code07_GraphQueries1.java
index 410856d4a..b397db6ed 100644
--- a/src/class164/Code07_DeleteAndQueries1.java
+++ b/src/class164/Code07_GraphQueries1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code07_DeleteAndQueries1 {
+public class Code07_GraphQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 400001;
diff --git a/src/class164/Code07_DeleteAndQueries2.java b/src/class164/Code07_GraphQueries2.java
similarity index 100%
rename from src/class164/Code07_DeleteAndQueries2.java
rename to src/class164/Code07_GraphQueries2.java

From f9ca8310896cfc8eeac28da19696655387aec1be Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 30 Mar 2025 23:12:50 +0800
Subject: [PATCH 0631/1712] modify code

---
 src/class164/Code01_KruskalRebuild1.java | 168 +++++++++--------------
 src/class164/Code01_KruskalRebuild2.java |  96 ++++++-------
 src/class164/Code02_Training1.java       |  29 ++--
 src/class164/Code02_Training2.java       |  26 ++--
 src/class164/Code03_StampRally1.java     |  41 +++---
 src/class164/Code03_StampRally2.java     |  44 +++---
 src/class164/Code04_Journey1.java        |  45 +++---
 src/class164/Code04_Journey2.java        |  35 +++--
 src/class164/Code05_Peaks1.java          |  12 ++
 src/class164/Code05_Peaks2.java          |  16 ++-
 src/class164/Code06_UntilConnect1.java   |   9 ++
 src/class164/Code06_UntilConnect2.java   |  13 +-
 src/class164/Code07_GraphQueries1.java   |  15 +-
 src/class164/Code07_GraphQueries2.java   |  18 ++-
 14 files changed, 307 insertions(+), 260 deletions(-)

diff --git a/src/class164/Code01_KruskalRebuild1.java b/src/class164/Code01_KruskalRebuild1.java
index 789f48359..1d7957609 100644
--- a/src/class164/Code01_KruskalRebuild1.java
+++ b/src/class164/Code01_KruskalRebuild1.java
@@ -1,6 +1,10 @@
 package class164;
 
 // Kruskal重构树模版题，java版
+// 图里有n个点，m条无向边，每条边给定边权，图里可能有若干个连通的部分
+// 一共有q条查询，每条查询都是如下的格式
+// 查询 x y : 点x到达点y的路途中，最大的边权希望尽量小，打印这个值
+// 1 <= n <= 10^5    1 <= m <= 3 * 10^5    1 <= q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2245
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -13,10 +17,11 @@ public class Code01_KruskalRebuild1 {
 
 	public static int MAXK = 200001;
 	public static int MAXM = 300001;
+	public static int MAXH = 20;
 	public static int n, m, q;
-	public static int[][] arr = new int[MAXM][3];
+	public static int[][] edge = new int[MAXM][3];
 
-	// 链式前向星
+	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
@@ -27,12 +32,9 @@ public class Code01_KruskalRebuild1 {
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
-	// 树链剖分
-	public static int[] fa = new int[MAXK];
+	// 树上dfs
 	public static int[] dep = new int[MAXK];
-	public static int[] siz = new int[MAXK];
-	public static int[] son = new int[MAXK];
-	public static int[] top = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
 
 	public static int find(int i) {
 		if (i != father[i]) {
@@ -51,136 +53,95 @@ public static void kruskalRebuild() {
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
 		}
-		Arrays.sort(arr, 1, m + 1, (a, b) -> a[2] - b[2]);
+		Arrays.sort(edge, 1, m + 1, (a, b) -> a[2] - b[2]);
 		cntu = n;
 		for (int i = 1, fx, fy; i <= m; i++) {
-			fx = find(arr[i][0]);
-			fy = find(arr[i][1]);
+			fx = find(edge[i][0]);
+			fy = find(edge[i][1]);
 			if (fx != fy) {
 				father[fx] = father[fy] = ++cntu;
 				father[cntu] = cntu;
-				nodeKey[cntu] = arr[i][2];
+				nodeKey[cntu] = edge[i][2];
 				addEdge(cntu, fx);
 				addEdge(cntu, fy);
 			}
 		}
 	}
 
-	public static void dfs1(int u, int f) {
-		fa[u] = f;
-		dep[u] = dep[f] + 1;
-		siz[u] = 1;
+	// dfs1是递归函数，需要改成迭代版，不然会爆栈，C++实现不需要
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
 		for (int e = head[u]; e > 0; e = next[e]) {
 			dfs1(to[e], u);
 		}
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			siz[u] += siz[v];
-			if (son[u] == 0 || siz[son[u]] < siz[v]) {
-				son[u] = v;
-			}
-		}
 	}
 
-	public static void dfs2(int u, int t) {
-		top[u] = t;
-		if (son[u] == 0) {
-			return;
-		}
-		dfs2(son[u], t);
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != son[u]) {
-				dfs2(v, v);
-			}
-		}
-	}
+	public static int[][] ufe = new int[MAXK][3];
 
-	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	public static int[][] fse = new int[MAXK][3];
+	public static int stacksize, u, f, e;
 
-	public static int stacksize, first, second, edge;
-
-	public static void push(int fir, int sec, int edg) {
-		fse[stacksize][0] = fir;
-		fse[stacksize][1] = sec;
-		fse[stacksize][2] = edg;
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
 		stacksize++;
 	}
 
 	public static void pop() {
 		--stacksize;
-		first = fse[stacksize][0];
-		second = fse[stacksize][1];
-		edge = fse[stacksize][2];
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
 	}
 
-	// dfs1的迭代版
-	public static void dfs3(int u, int f) {
+	// dfs2是dfs1的迭代版
+	public static void dfs2(int cur, int fa) {
 		stacksize = 0;
-		push(u, f, -1);
+		push(cur, fa, -1);
 		while (stacksize > 0) {
 			pop();
-			if (edge == -1) {
-				fa[first] = second;
-				dep[first] = dep[second] + 1;
-				siz[first] = 1;
-				edge = head[first];
-			} else {
-				edge = next[edge];
-			}
-			if (edge != 0) {
-				push(first, second, edge);
-				push(to[edge], first, -1);
-			} else {
-				for (int e = head[first], v; e > 0; e = next[e]) {
-					v = to[e];
-					siz[first] += siz[v];
-					if (son[first] == 0 || siz[son[first]] < siz[v]) {
-						son[first] = v;
-					}
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 				}
-			}
-		}
-	}
-
-	// dfs2的迭代版
-	public static void dfs4(int u, int t) {
-		stacksize = 0;
-		push(u, t, -1);
-		while (stacksize > 0) {
-			pop();
-			if (edge == -1) {
-				top[first] = second;
-				if (son[first] == 0) {
-					continue;
-				}
-				push(first, second, -2);
-				push(son[first], second, -1);
-				continue;
-			} else if (edge == -2) {
-				edge = head[first];
+				e = head[u];
 			} else {
-				edge = next[edge];
+				e = next[e];
 			}
-			if (edge != 0) {
-				push(first, second, edge);
-				if (to[edge] != son[first]) {
-					push(to[edge], to[edge], -1);
-				}
+			if (e != 0) {
+				push(u, f, e);
+				push(to[e], u, -1);
 			}
 		}
 	}
 
 	public static int lca(int a, int b) {
-		while (top[a] != top[b]) {
-			if (dep[top[a]] <= dep[top[b]]) {
-				b = fa[top[b]];
-			} else {
-				a = fa[top[a]];
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
 			}
 		}
-		return dep[a] <= dep[b] ? a : b;
+		return stjump[a][0];
 	}
 
 	public static void main(String[] args) {
@@ -188,15 +149,14 @@ public static void main(String[] args) {
 		n = io.nextInt();
 		m = io.nextInt();
 		for (int i = 1; i <= m; i++) {
-			arr[i][0] = io.nextInt();
-			arr[i][1] = io.nextInt();
-			arr[i][2] = io.nextInt();
+			edge[i][0] = io.nextInt();
+			edge[i][1] = io.nextInt();
+			edge[i][2] = io.nextInt();
 		}
 		kruskalRebuild();
 		for (int i = 1; i <= cntu; i++) {
 			if (i == father[i]) {
-				dfs3(i, 0); // 防止递归爆栈，所以调用dfs1的迭代版
-				dfs4(i, i); // 防止递归爆栈，所以调用dfs2的迭代版
+				dfs2(i, 0);
 			}
 		}
 		q = io.nextInt();
diff --git a/src/class164/Code01_KruskalRebuild2.java b/src/class164/Code01_KruskalRebuild2.java
index 13b74a80a..7b57937c7 100644
--- a/src/class164/Code01_KruskalRebuild2.java
+++ b/src/class164/Code01_KruskalRebuild2.java
@@ -1,6 +1,10 @@
 package class164;
 
 // Kruskal重构树模版题，C++版
+// 图里有n个点，m条无向边，每条边给定边权，图里可能有若干个连通的部分
+// 一共有q条查询，每条查询都是如下的格式
+// 查询 x y : 点x到达点y的路途中，最大的边权希望尽量小，打印这个值
+// 1 <= n <= 10^5    1 <= m <= 3 * 10^5    1 <= q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2245
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -10,35 +14,33 @@
 //using namespace std;
 //
 //struct Edge {
-//	int u, v, w;
+//    int u, v, w;
 //};
 //
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
 //const int MAXK = 200001;
 //const int MAXM = 300001;
+//const int MAXH = 20;
 //int n, m, q;
-//Edge arr[MAXM];
+//Edge edge[MAXM];
 //
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
-//int cntg = 0;
+//int cntg;
 //
 //int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //
-//int fa[MAXK];
 //int dep[MAXK];
-//int siz[MAXK];
-//int son[MAXK];
-//int top[MAXK];
-//
-//bool cmp(Edge x, Edge y) {
-//    return x.w < y.w;
-//}
+//int stjump[MAXK][MAXH];
 //
 //int find(int i) {
-//    if(i != father[i]) {
+//    if (i != father[i]) {
 //        father[i] = find(father[i]);
 //    }
 //    return father[i];
@@ -54,60 +56,53 @@
 //    for (int i = 1; i <= n; i++) {
 //        father[i] = i;
 //    }
-//    sort(arr + 1, arr + m + 1, cmp);
+//    sort(edge + 1, edge + m + 1, cmp);
 //    cntu = n;
-//    for (int i = 1, fx, fy; i <= m; i++) {
-//        fx = find(arr[i].u);
-//        fy = find(arr[i].v);
+//    for (int i = 1; i <= m; i++) {
+//        int fx = find(edge[i].u);
+//        int fy = find(edge[i].v);
 //        if (fx != fy) {
 //            father[fx] = father[fy] = ++cntu;
 //            father[cntu] = cntu;
-//            nodeKey[cntu] = arr[i].w;
+//            nodeKey[cntu] = edge[i].w;
 //            addEdge(cntu, fx);
 //            addEdge(cntu, fy);
 //        }
 //    }
 //}
 //
-//void dfs1(int u, int f) {
-//    fa[u] = f;
-//    dep[u] = dep[f] + 1;
-//    siz[u] = 1;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        dfs1(to[e], u);
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 //    }
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        siz[u] += siz[v];
-//        if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//            son[u] = v;
-//        }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        dfs(to[e], u);
 //    }
 //}
 //
-//void dfs2(int u, int t) {
-//    top[u] = t;
-//    if (son[u] == 0) {
-//        return;
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        int tmp = a;
+//        a = b;
+//        b = tmp;
 //    }
-//    dfs2(son[u], t);
-//    for (int e = head[u], v; e > 0; e = nxt[e]) {
-//        v = to[e];
-//        if (v != son[u]) {
-//            dfs2(v, v);
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
 //        }
 //    }
-//}
-//
-//int lca(int a, int b) {
-//    while (top[a] != top[b]) {
-//        if (dep[top[a]] <= dep[top[b]]) {
-//            b = fa[top[b]];
-//        } else {
-//            a = fa[top[a]];
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
 //        }
 //    }
-//    return dep[a] <= dep[b] ? a : b;
+//    return stjump[a][0];
 //}
 //
 //int main() {
@@ -115,20 +110,19 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 1; i <= m; i++) {
-//        cin >> arr[i].u >> arr[i].v >> arr[i].w;
+//        cin >> edge[i].u >> edge[i].v >> edge[i].w;
 //    }
 //    kruskalRebuild();
 //    for (int i = 1; i <= cntu; i++) {
 //        if (i == father[i]) {
-//            dfs1(i, 0);
-//            dfs2(i, i);
+//            dfs(i, 0);
 //        }
 //    }
 //    cin >> q;
 //    for (int i = 1, x, y; i <= q; i++) {
 //        cin >> x >> y;
 //        if (find(x) != find(y)) {
-//            cout << "impossible\n";
+//            cout << "impossible" << "\n";
 //        } else {
 //            cout << nodeKey[lca(x, y)] << "\n";
 //        }
diff --git a/src/class164/Code02_Training1.java b/src/class164/Code02_Training1.java
index 6b75d97a9..7f10db4f8 100644
--- a/src/class164/Code02_Training1.java
+++ b/src/class164/Code02_Training1.java
@@ -1,6 +1,12 @@
 package class164;
 
 // youyou的军训，java版
+// 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
+// 一共有q条操作，每条操作都是如下的三种类型中的一种
+// 操作 1 x   : 限制变量limit，把limit的值改成x
+// 操作 2 x   : 点x不能走过任何边权小于limit的边，打印此时x所在的连通区域大小
+// 操作 3 x y : 第x条边的边权修改为y，题目保证修改之后，第x条边的边权排名不变
+// 1 <= n、m、q <= 4 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9638
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -16,19 +22,24 @@ public class Code02_Training1 {
 	public static int MAXH = 20;
 	public static int n, m, q;
 	public static int[][] edge = new int[MAXM][4];
+
+	// 边的编号对应重构树上的点的编号
 	public static int[] edgeToTree = new int[MAXM];
 
+	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
 
+	// 并查集
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int[] stack = new int[MAXK];
 	public static int cntu;
 
-	public static int[] siz = new int[MAXK];
+	// 树上dfs
+	public static int[] leafsiz = new int[MAXK];
 	public static int[][] stjump = new int[MAXK][MAXH];
 
 	// 并查集的find方法，需要改成迭代版不然会爆栈，C++实现不需要
@@ -70,7 +81,7 @@ public static void kruskalRebuild() {
 		}
 	}
 
-	// dfs1是递归函数，需要改成迭代版不然会爆栈，C++实现不需要
+	// dfs1是递归函数，需要改成迭代版，不然会爆栈，C++实现不需要
 	public static void dfs1(int u, int fa) {
 		stjump[u][0] = fa;
 		for (int p = 1; p < MAXH; p++) {
@@ -80,12 +91,12 @@ public static void dfs1(int u, int fa) {
 			dfs1(to[e], u);
 		}
 		if (u <= n) {
-			siz[u] = 1;
+			leafsiz[u] = 1;
 		} else {
-			siz[u] = 0;
+			leafsiz[u] = 0;
 		}
 		for (int e = head[u]; e > 0; e = next[e]) {
-			siz[u] += siz[to[e]];
+			leafsiz[u] += leafsiz[to[e]];
 		}
 	}
 
@@ -127,12 +138,12 @@ public static void dfs2(int cur, int fa) {
 				push(to[e], u, -1);
 			} else {
 				if (u <= n) {
-					siz[u] = 1;
+					leafsiz[u] = 1;
 				} else {
-					siz[u] = 0;
+					leafsiz[u] = 0;
 				}
 				for (int ei = head[u]; ei > 0; ei = next[ei]) {
-					siz[u] += siz[to[ei]];
+					leafsiz[u] += leafsiz[to[ei]];
 				}
 			}
 		}
@@ -144,7 +155,7 @@ public static int query(int u, int limit) {
 				u = stjump[u][p];
 			}
 		}
-		return siz[u];
+		return leafsiz[u];
 	}
 
 	public static void main(String[] args) {
diff --git a/src/class164/Code02_Training2.java b/src/class164/Code02_Training2.java
index e29892252..19576388d 100644
--- a/src/class164/Code02_Training2.java
+++ b/src/class164/Code02_Training2.java
@@ -1,6 +1,12 @@
 package class164;
 
 // youyou的军训，C++版
+// 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
+// 一共有q条操作，每条操作都是如下的三种类型中的一种
+// 操作 1 x   : 限制变量limit，把limit的值改成x
+// 操作 2 x   : 点x不能走过任何边权小于limit的边，打印此时x所在的连通区域大小
+// 操作 3 x y : 第x条边的边权修改为y，题目保证修改之后，第x条边的边权排名不变
+// 1 <= n、m、q <= 4 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9638
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -13,11 +19,16 @@
 //    int u, v, w, i;
 //};
 //
+//bool cmp(Edge x, Edge y) {
+//    return x.w > y.w;
+//}
+//
 //const int MAXK = 800001;
 //const int MAXM = 400001;
 //const int MAXH = 20;
 //int n, m, q;
 //Edge edge[MAXM];
+//
 //int edgeToTree[MAXM];
 //
 //int head[MAXK];
@@ -27,16 +38,11 @@
 //
 //int father[MAXK];
 //int nodeKey[MAXK];
-//int stackArr[MAXK];
 //int cntu;
 //
-//int siz[MAXK];
+//int leafsiz[MAXK];
 //int stjump[MAXK][MAXH];
 //
-//bool cmp(Edge x, Edge y) {
-//    return x.w > y.w;
-//}
-//
 //int find(int i) {
 //    if (i != father[i]) {
 //        father[i] = find(father[i]);
@@ -79,12 +85,12 @@
 //        dfs(to[e], u);
 //    }
 //    if (u <= n) {
-//        siz[u] = 1;
+//        leafsiz[u] = 1;
 //    } else {
-//        siz[u] = 0;
+//        leafsiz[u] = 0;
 //    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        siz[u] += siz[to[e]];
+//        leafsiz[u] += leafsiz[to[e]];
 //    }
 //}
 //
@@ -94,7 +100,7 @@
 //            u = stjump[u][p];
 //        }
 //    }
-//    return siz[u];
+//    return leafsiz[u];
 //}
 //
 //int main() {
diff --git a/src/class164/Code03_StampRally1.java b/src/class164/Code03_StampRally1.java
index 69f384a43..dd6d6da58 100644
--- a/src/class164/Code03_StampRally1.java
+++ b/src/class164/Code03_StampRally1.java
@@ -1,6 +1,12 @@
 package class164;
 
-// 走过z个点的最大边权最小值，java版
+// 边的最大编号的最小值，java版
+// 图里有n个点，m条无向边，边的编号1~m，没有边权，所有点都连通
+// 一共有q条查询，查询的格式如下
+// 查询 x y z : 从两个点x和y出发，希望经过的点数量等于z
+//              每个点可以重复经过，但是重复经过只计算一次
+//              经过边的最大编号，最小是多少
+// 3 <= n、m、q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc002_d
 // 测试链接 : https://atcoder.jp/contests/agc002/tasks/agc002_d
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -16,20 +22,22 @@ public class Code03_StampRally1 {
 	public static int MAXM = 100001;
 	public static int MAXH = 20;
 	public static int n, m, q;
-	public static int[][] arr = new int[MAXM][3];
+	public static int[][] edge = new int[MAXM][3];
 
+	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
 
+	// 并查集
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
-	public static int[] dep = new int[MAXK];
-	public static int[] siz = new int[MAXK];
+	// 树上dfs
 	public static int[][] stjump = new int[MAXK][MAXH];
+	public static int[] leafsiz = new int[MAXK];
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
@@ -48,15 +56,15 @@ public static void kruskalRebuild() {
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
 		}
-		Arrays.sort(arr, 1, m + 1, (a, b) -> a[2] - b[2]);
+		Arrays.sort(edge, 1, m + 1, (a, b) -> a[2] - b[2]);
 		cntu = n;
 		for (int i = 1, fx, fy; i <= m; i++) {
-			fx = find(arr[i][0]);
-			fy = find(arr[i][1]);
+			fx = find(edge[i][0]);
+			fy = find(edge[i][1]);
 			if (fx != fy) {
 				father[fx] = father[fy] = ++cntu;
 				father[cntu] = cntu;
-				nodeKey[cntu] = arr[i][2];
+				nodeKey[cntu] = edge[i][2];
 				addEdge(cntu, fx);
 				addEdge(cntu, fy);
 			}
@@ -64,7 +72,6 @@ public static void kruskalRebuild() {
 	}
 
 	public static void dfs(int u, int fa) {
-		dep[u] = dep[fa] + 1;
 		stjump[u][0] = fa;
 		for (int p = 1; p < MAXH; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -73,12 +80,12 @@ public static void dfs(int u, int fa) {
 			dfs(to[e], u);
 		}
 		if (u <= n) {
-			siz[u] = 1;
+			leafsiz[u] = 1;
 		} else {
-			siz[u] = 0;
+			leafsiz[u] = 0;
 		}
 		for (int e = head[u]; e > 0; e = next[e]) {
-			siz[u] += siz[to[e]];
+			leafsiz[u] += leafsiz[to[e]];
 		}
 	}
 
@@ -94,9 +101,9 @@ public static boolean check(int x, int y, int z, int limit) {
 			}
 		}
 		if (x == y) {
-			return siz[x] >= z;
+			return leafsiz[x] >= z;
 		} else {
-			return siz[x] + siz[y] >= z;
+			return leafsiz[x] + leafsiz[y] >= z;
 		}
 	}
 
@@ -119,9 +126,9 @@ public static void main(String[] args) {
 		n = io.nextInt();
 		m = io.nextInt();
 		for (int i = 1; i <= m; i++) {
-			arr[i][0] = io.nextInt();
-			arr[i][1] = io.nextInt();
-			arr[i][2] = i;
+			edge[i][0] = io.nextInt();
+			edge[i][1] = io.nextInt();
+			edge[i][2] = i;
 		}
 		kruskalRebuild();
 		dfs(cntu, 0);
diff --git a/src/class164/Code03_StampRally2.java b/src/class164/Code03_StampRally2.java
index ea479932e..fa6066571 100644
--- a/src/class164/Code03_StampRally2.java
+++ b/src/class164/Code03_StampRally2.java
@@ -1,6 +1,12 @@
 package class164;
 
-// 走过z个点的最大边权最小值，C++版
+// 边的最大编号的最小值，C++版
+// 图里有n个点，m条无向边，边的编号1~m，没有边权，所有点都连通
+// 一共有q条查询，查询的格式如下
+// 查询 x y z : 从两个点x和y出发，希望经过的点数量等于z
+//              每个点可以重复经过，但是重复经过只计算一次
+//              经过边的最大编号，最小是多少
+// 3 <= n、m、q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc002_d
 // 测试链接 : https://atcoder.jp/contests/agc002/tasks/agc002_d
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -14,11 +20,15 @@
 //    int u, v, w;
 //};
 //
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
 //const int MAXK = 200001;
 //const int MAXM = 100001;
 //const int MAXH = 20;
 //int n, m, q;
-//Edge arr[MAXM];
+//Edge edge[MAXM];
 //
 //int head[MAXK];
 //int nxt[MAXK];
@@ -29,13 +39,8 @@
 //int nodeKey[MAXK];
 //int cntu;
 //
-//int dep[MAXK];
-//int siz[MAXK];
 //int stjump[MAXK][MAXH];
-//
-//bool cmp(Edge x, Edge y) {
-//    return x.w < y.w;
-//}
+//int leafsiz[MAXK];
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
@@ -54,15 +59,15 @@
 //    for (int i = 1; i <= n; i++) {
 //        father[i] = i;
 //    }
-//    sort(arr + 1, arr + m + 1, cmp);
+//    sort(edge + 1, edge + m + 1, cmp);
 //    cntu = n;
 //    for (int i = 1, fx, fy; i <= m; i++) {
-//        fx = find(arr[i].u);
-//        fy = find(arr[i].v);
+//        fx = find(edge[i].u);
+//        fy = find(edge[i].v);
 //        if (fx != fy) {
 //            father[fx] = father[fy] = ++cntu;
 //            father[cntu] = cntu;
-//            nodeKey[cntu] = arr[i].w;
+//            nodeKey[cntu] = edge[i].w;
 //            addEdge(cntu, fx);
 //            addEdge(cntu, fy);
 //        }
@@ -70,7 +75,6 @@
 //}
 //
 //void dfs(int u, int fa) {
-//    dep[u] = dep[fa] + 1;
 //    stjump[u][0] = fa;
 //    for (int p = 1; p < MAXH; p++) {
 //        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -79,12 +83,12 @@
 //        dfs(to[e], u);
 //    }
 //    if (u <= n) {
-//        siz[u] = 1;
+//        leafsiz[u] = 1;
 //    } else {
-//        siz[u] = 0;
+//        leafsiz[u] = 0;
 //    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        siz[u] += siz[to[e]];
+//        leafsiz[u] += leafsiz[to[e]];
 //    }
 //}
 //
@@ -100,9 +104,9 @@
 //        }
 //    }
 //    if (x == y) {
-//        return siz[x] >= z;
+//        return leafsiz[x] >= z;
 //    } else {
-//        return siz[x] + siz[y] >= z;
+//        return leafsiz[x] + leafsiz[y] >= z;
 //    }
 //}
 //
@@ -125,8 +129,8 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 1; i <= m; i++) {
-//        cin >> arr[i].u >> arr[i].v;
-//        arr[i].w = i;
+//        cin >> edge[i].u >> edge[i].v;
+//        edge[i].w = i;
 //    }
 //    kruskalRebuild();
 //    dfs(cntu, 0);
diff --git a/src/class164/Code04_Journey1.java b/src/class164/Code04_Journey1.java
index a1e4601fb..a40e82c3e 100644
--- a/src/class164/Code04_Journey1.java
+++ b/src/class164/Code04_Journey1.java
@@ -1,6 +1,13 @@
 package class164;
 
 // 归程，java版
+// 图里有n个点，m条无向边，每条边给定长度l和海拔a，所有点都连通
+// 一共有q条查询，查询格式如下
+// 查询 x y : 海拔 > y的边，走过没有代价
+//            海拔 <= y的边，走过的代价为边的长度
+//            从点x出发到达1号点，打印最小的代价
+// 1 <= n <= 2 * 10^5    1 <= m、q <= 4 * 10^5
+// 本题要求强制在线，具体规定请打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -18,29 +25,33 @@ public class Code04_Journey1 {
 	public static int MAXH = 20;
 	public static int INF = 2000000001;
 	public static int t, n, m, q, k, s;
-	public static int[][] arr = new int[MAXM][4];
+	public static int[][] edge = new int[MAXM][4];
 
+	// 建图
 	public static int[] headg = new int[MAXN];
 	public static int[] nextg = new int[MAXM << 1];
 	public static int[] tog = new int[MAXM << 1];
 	public static int[] weightg = new int[MAXM << 1];
 	public static int cntg;
 
+	// dijkstra算法
 	public static int[] dist = new int[MAXN];
 	public static boolean[] visit = new boolean[MAXN];
 	public static PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
 
+	// Kruskal重构树
 	public static int[] headk = new int[MAXK];
 	public static int[] nextk = new int[MAXK];
 	public static int[] tok = new int[MAXK];
 	public static int cntk;
 
+	// 并查集
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int[] stack = new int[MAXK];
 	public static int cntu;
 
-	public static int[] dep = new int[MAXK];
+	// 树上dfs
 	public static int[][] stjump = new int[MAXK][MAXH];
 	public static int[] mindist = new int[MAXK];
 
@@ -59,8 +70,8 @@ public static void addEdgeG(int u, int v, int w) {
 
 	public static void dijkstra() {
 		for (int i = 1; i <= m; i++) {
-			addEdgeG(arr[i][0], arr[i][1], arr[i][2]);
-			addEdgeG(arr[i][1], arr[i][0], arr[i][2]);
+			addEdgeG(edge[i][0], edge[i][1], edge[i][2]);
+			addEdgeG(edge[i][1], edge[i][0], edge[i][2]);
 		}
 		Arrays.fill(dist, 1, n + 1, INF);
 		Arrays.fill(visit, 1, n + 1, false);
@@ -109,15 +120,15 @@ public static void kruskalRebuild() {
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
 		}
-		Arrays.sort(arr, 1, m + 1, (a, b) -> b[3] - a[3]);
+		Arrays.sort(edge, 1, m + 1, (a, b) -> b[3] - a[3]);
 		cntu = n;
 		for (int i = 1, fx, fy; i <= m; i++) {
-			fx = find(arr[i][0]);
-			fy = find(arr[i][1]);
+			fx = find(edge[i][0]);
+			fy = find(edge[i][1]);
 			if (fx != fy) {
 				father[fx] = father[fy] = ++cntu;
 				father[cntu] = cntu;
-				nodeKey[cntu] = arr[i][3];
+				nodeKey[cntu] = edge[i][3];
 				addEdgeK(cntu, fx);
 				addEdgeK(cntu, fy);
 			}
@@ -126,7 +137,6 @@ public static void kruskalRebuild() {
 
 	// dfs1是递归函数，需要改成迭代版不然会爆栈，C++实现不需要
 	public static void dfs1(int u, int fa) {
-		dep[u] = dep[fa] + 1;
 		stjump[u][0] = fa;
 		for (int p = 1; p < MAXH; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -169,7 +179,6 @@ public static void dfs2(int cur, int fa) {
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
-				dep[u] = dep[f] + 1;
 				stjump[u][0] = f;
 				for (int p = 1; p < MAXH; p++) {
 					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -211,10 +220,10 @@ public static void main(String[] args) {
 			m = io.nextInt();
 			clear();
 			for (int i = 1; i <= m; i++) {
-				arr[i][0] = io.nextInt();
-				arr[i][1] = io.nextInt();
-				arr[i][2] = io.nextInt();
-				arr[i][3] = io.nextInt();
+				edge[i][0] = io.nextInt();
+				edge[i][1] = io.nextInt();
+				edge[i][2] = io.nextInt();
+				edge[i][3] = io.nextInt();
 			}
 			dijkstra();
 			kruskalRebuild();
@@ -222,10 +231,10 @@ public static void main(String[] args) {
 			q = io.nextInt();
 			k = io.nextInt();
 			s = io.nextInt();
-			for (int i = 1, node, line, lastAns = 0; i <= q; i++) {
-				node = (io.nextInt() + k * lastAns - 1) % n + 1;
-				line = (io.nextInt() + k * lastAns) % (s + 1);
-				lastAns = query(node, line);
+			for (int i = 1, x, y, lastAns = 0; i <= q; i++) {
+				x = (io.nextInt() + k * lastAns - 1) % n + 1;
+				y = (io.nextInt() + k * lastAns) % (s + 1);
+				lastAns = query(x, y);
 				io.writelnInt(lastAns);
 			}
 		}
diff --git a/src/class164/Code04_Journey2.java b/src/class164/Code04_Journey2.java
index 5d31f304c..bfdc08fdc 100644
--- a/src/class164/Code04_Journey2.java
+++ b/src/class164/Code04_Journey2.java
@@ -1,6 +1,13 @@
 package class164;
 
 // 归程，C++版
+// 图里有n个点，m条无向边，每条边给定长度l和海拔a，所有点都连通
+// 一共有q条查询，查询格式如下
+// 查询 x y : 海拔 > y的边，走过没有代价
+//            海拔 <= y的边，走过的代价为边的长度
+//            从点x出发到达1号点，打印最小的代价
+// 1 <= n <= 2 * 10^5    1 <= m、q <= 4 * 10^5
+// 本题要求强制在线，具体规定请打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -33,7 +40,7 @@
 //const int MAXH = 20;
 //int INF = 2000000001;
 //int t, n, m, q, k, s;
-//Edge arr[MAXM];
+//Edge edge[MAXM];
 //
 //int headg[MAXN];
 //int nextg[MAXM << 1];
@@ -54,7 +61,6 @@
 //int nodeKey[MAXK];
 //int cntu;
 //
-//int dep[MAXK];
 //int stjump[MAXK][MAXH];
 //int mindist[MAXK];
 //
@@ -78,8 +84,8 @@
 //
 //void dijkstra() {
 //    for(int i = 1; i <= m; i++) {
-//        addEdgeG(arr[i].u, arr[i].v, arr[i].l);
-//        addEdgeG(arr[i].v, arr[i].u, arr[i].l);
+//        addEdgeG(edge[i].u, edge[i].v, edge[i].l);
+//        addEdgeG(edge[i].v, edge[i].u, edge[i].l);
 //    }
 //    for(int i = 1; i <= n; i++) {
 //        dist[i] = INF;
@@ -125,17 +131,17 @@
 //    for(int i = 1; i <= n; i++) {
 //        father[i] = i;
 //    }
-//    sort(arr + 1, arr + m + 1, EdgeCmp);
+//    sort(edge + 1, edge + m + 1, EdgeCmp);
 //    cntu = n;
 //    for(int i = 1, fx, fy; i <= m; i++) {
-//        fx = find(arr[i].u);
-//        fy = find(arr[i].v);
+//        fx = find(edge[i].u);
+//        fy = find(edge[i].v);
 //        if(fx != fy) {
 //            cntu++;
 //            father[fx] = cntu;
 //            father[fy] = cntu;
 //            father[cntu] = cntu;
-//            nodeKey[cntu] = arr[i].a;
+//            nodeKey[cntu] = edge[i].a;
 //            addEdgeK(cntu, fx);
 //            addEdgeK(cntu, fy);
 //        }
@@ -143,7 +149,6 @@
 //}
 //
 //void dfs(int u, int fa) {
-//    dep[u] = dep[fa] + 1;
 //    stjump[u][0] = fa;
 //    for(int p = 1; p < MAXH; p++) {
 //        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
@@ -178,17 +183,17 @@
 //        cin >> n >> m;
 //        clear();
 //        for(int i = 1; i <= m; i++) {
-//            cin >> arr[i].u >> arr[i].v >> arr[i].l >> arr[i].a;
+//            cin >> edge[i].u >> edge[i].v >> edge[i].l >> edge[i].a;
 //        }
 //        dijkstra();
 //        kruskalRebuild();
 //        dfs(cntu, 0);
 //        cin >> q >> k >> s;
-//        for(int i = 1, node, line, lastAns = 0; i <= q; i++) {
-//            cin >> node >> line;
-//            node = (node + k * lastAns - 1) % n + 1;
-//            line = (line + k * lastAns) % (s + 1);
-//            lastAns = query(node, line);
+//        for(int i = 1, x, y, lastAns = 0; i <= q; i++) {
+//            cin >> x >> y;
+//            x = (x + k * lastAns - 1) % n + 1;
+//            y = (y + k * lastAns) % (s + 1);
+//            lastAns = query(x, y);
 //            cout << lastAns << "\n";
 //        }
 //    }
diff --git a/src/class164/Code05_Peaks1.java b/src/class164/Code05_Peaks1.java
index 8576fa053..0a055f19c 100644
--- a/src/class164/Code05_Peaks1.java
+++ b/src/class164/Code05_Peaks1.java
@@ -1,6 +1,14 @@
 package class164;
 
 // 边权上限内第k大点权，java版
+// 图里有n个点，m条无向边，点有点权，边有边权，图里可能有若干个连通的部分
+// 一共有q条查询，查询格式如下
+// 查询 u x k : 从点u开始，只能走过权值<=x的边
+//              所有能到达的点中，打印第k大点权，如果不存在打印-1
+// 1 <= n <= 10^5
+// 0 <= m、q <= 5 * 10^5
+// 1 <= 点权、边权 <= 10^9
+// 本题要求强制在线，具体规定请打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P7834
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了
@@ -28,21 +36,25 @@ public class Code05_Peaks1 {
 
 	public static int[][] edge = new int[MAXM][3];
 
+	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
 
+	// 并查集
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
+	// 树上dfs
 	public static int[] dfn = new int[MAXK];
 	public static int[] seg = new int[MAXK];
 	public static int[][] stjump = new int[MAXK][MAXH];
 	public static int[] siz = new int[MAXK];
 	public static int cntd = 0;
 
+	// 可持久化线段树
 	public static int[] root = new int[MAXK];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
diff --git a/src/class164/Code05_Peaks2.java b/src/class164/Code05_Peaks2.java
index 079548226..d2cb70750 100644
--- a/src/class164/Code05_Peaks2.java
+++ b/src/class164/Code05_Peaks2.java
@@ -1,6 +1,14 @@
 package class164;
 
 // 边权上限内第k大点权，C++版
+// 图里有n个点，m条无向边，点有点权，边有边权，图里可能有若干个连通的部分
+// 一共有q条查询，查询格式如下
+// 查询 u x k : 从点u开始，只能走过权值<=x的边
+//              所有能到达的点中，打印第k大点权，如果不存在打印-1
+// 1 <= n <= 10^5
+// 0 <= m、q <= 5 * 10^5
+// 1 <= 点权、边权 <= 10^9
+// 本题要求强制在线，具体规定请打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P7834
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -13,6 +21,10 @@
 //    int u, v, w;
 //};
 //
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
 //const int MAXN = 100001;
 //const int MAXK = 200001;
 //const int MAXM = 500001;
@@ -46,10 +58,6 @@
 //int segsiz[MAXT];
 //int cntt;
 //
-//bool cmp(Edge x, Edge y) {
-//    return x.w < y.w;
-//}
-//
 //int kth(int num) {
 //    int left = 1, right = diff;
 //    while (left <= right) {
diff --git a/src/class164/Code06_UntilConnect1.java b/src/class164/Code06_UntilConnect1.java
index 6b8f82491..e80e161de 100644
--- a/src/class164/Code06_UntilConnect1.java
+++ b/src/class164/Code06_UntilConnect1.java
@@ -1,6 +1,11 @@
 package class164;
 
 // 加边直到连通，java版
+// 图里有n个点，m条无向边，所有点都连通
+// 一共有q条查询，每条查询格式如下
+// 查询 l r : 至少要加完编号前多少的边，才能使得[l, r]中的所有点连通
+// 1 <= n <= 10^5
+// 1 <= m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1706E
 // 测试链接 : https://codeforces.com/problemset/problem/1706/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -19,21 +24,25 @@ public class Code06_UntilConnect1 {
 	public static int t, n, m, q;
 	public static int[][] edge = new int[MAXM][3];
 
+	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg;
 
+	// 并查集
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
+	// 树上dfs
 	public static int[] dep = new int[MAXK];
 	public static int[] dfn = new int[MAXK];
 	public static int[] seg = new int[MAXK];
 	public static int[][] stjump = new int[MAXK][MAXH];
 	public static int cntd;
 
+	// 倍增表查询区间最大值、最小值
 	public static int[] lg2 = new int[MAXN];
 	public static int[][] stmax = new int[MAXN][MAXH];
 	public static int[][] stmin = new int[MAXN][MAXH];
diff --git a/src/class164/Code06_UntilConnect2.java b/src/class164/Code06_UntilConnect2.java
index 35e1d7f5b..3887c2462 100644
--- a/src/class164/Code06_UntilConnect2.java
+++ b/src/class164/Code06_UntilConnect2.java
@@ -1,6 +1,11 @@
 package class164;
 
 // 加边直到连通，C++版
+// 图里有n个点，m条无向边，所有点都连通
+// 一共有q条查询，每条查询格式如下
+// 查询 l r : 至少要加完编号前多少的边，才能使得[l, r]中的所有点连通
+// 1 <= n <= 10^5
+// 1 <= m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1706E
 // 测试链接 : https://codeforces.com/problemset/problem/1706/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -14,6 +19,10 @@
 //    int u, v, w;
 //};
 //
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
 //const int MAXN = 100001;
 //const int MAXK = 200001;
 //const int MAXM = 200001;
@@ -40,10 +49,6 @@
 //int stmax[MAXN][MAXH];
 //int stmin[MAXN][MAXH];
 //
-//bool cmp(Edge x, Edge y) {
-//    return x.w < y.w;
-//}
-//
 //void clear() {
 //    cntg = 0;
 //    cntd = 0;
diff --git a/src/class164/Code07_GraphQueries1.java b/src/class164/Code07_GraphQueries1.java
index b397db6ed..931c0219f 100644
--- a/src/class164/Code07_GraphQueries1.java
+++ b/src/class164/Code07_GraphQueries1.java
@@ -1,6 +1,12 @@
 package class164;
 
 // 删边和查询，java版
+// 图里有n个点，m条无向边，初始时点权都不同，图里可能有若干个连通的部分
+// 一共有q条操作，每条操作是如下两种类型中的一种
+// 操作 1 x : 点x所在的连通区域中，假设点y拥有最大的点权
+//            打印y的点权，然后把y的点权修改为0
+// 操作 2 x : 删掉第x条边
+// 1 <= n <= 2 * 10^5    1 <= m <= 3 * 10^5    1 <= q <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1416D
 // 测试链接 : https://codeforces.com/problemset/problem/1416/D
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -20,26 +26,31 @@ public class Code07_GraphQueries1 {
 	public static int INF = 1000000001;
 	public static int n, m, q;
 
+	// 根据删除操作，给每条边设置边权，给查询操作设置时间线
 	public static int[] node = new int[MAXN];
 	public static int[][] edge = new int[MAXM][3];
 	public static int[][] ques = new int[MAXQ][2];
 	public static int[] timeline = new int[MAXQ];
 
+	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
 
+	// 并查集
 	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
+	// 树上dfs
 	public static int[][] stjump = new int[MAXK][MAXH];
 	public static int[] leafsiz = new int[MAXK];
 	public static int[] leafstart = new int[MAXK];
 	public static int[] leafseg = new int[MAXK];
 	public static int cntd = 0;
 
+	// 线段树维护dfn区间的最大值、最大值来自哪个dfn编号
 	public static int[] maxval = new int[MAXN << 2];
 	public static int[] maxdfn = new int[MAXN << 2];
 
@@ -216,11 +227,11 @@ public static void main(String[] args) {
 		build(1, n, 1);
 		for (int i = 1, anc; i <= q; i++) {
 			if (ques[i][0] == 1) {
-				ansMax = -INF;
 				anc = getAncestor(ques[i][1], timeline[i]);
+				ansMax = -INF;
 				queryMax(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
-				update(updateDfn, 0, 1, n, 1);
 				io.writelnInt(ansMax);
+				update(updateDfn, 0, 1, n, 1);
 			}
 		}
 		io.flush();
diff --git a/src/class164/Code07_GraphQueries2.java b/src/class164/Code07_GraphQueries2.java
index 01b6d5812..b9c894572 100644
--- a/src/class164/Code07_GraphQueries2.java
+++ b/src/class164/Code07_GraphQueries2.java
@@ -1,6 +1,12 @@
 package class164;
 
 // 删边和查询，C++版
+// 图里有n个点，m条无向边，初始时点权都不同，图里可能有若干个连通的部分
+// 一共有q条操作，每条操作是如下两种类型中的一种
+// 操作 1 x : 点x所在的连通区域中，假设点y拥有最大的点权
+//            打印y的点权，然后把y的点权修改为0
+// 操作 2 x : 删掉第x条边
+// 1 <= n <= 2 * 10^5    1 <= m <= 3 * 10^5    1 <= q <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1416D
 // 测试链接 : https://codeforces.com/problemset/problem/1416/D
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -14,6 +20,10 @@
 //    int u, v, w;
 //};
 //
+//bool cmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
 //const int MAXN = 200001;
 //const int MAXK = 400001;
 //const int MAXM = 300001;
@@ -48,10 +58,6 @@
 //int ansMax;
 //int updateDfn;
 //
-//bool cmp(Edge x, Edge y) {
-//    return x.w < y.w;
-//}
-//
 //void prepare() {
 //    for (int i = 1; i <= q; i++) {
 //        if (ques[i][0] == 2) {
@@ -219,11 +225,11 @@
 //    build(1, n, 1);
 //    for (int i = 1, anc; i <= q; i++) {
 //        if (ques[i][0] == 1) {
-//            ansMax = -INF;
 //            anc = getAncestor(ques[i][1], timeline[i]);
+//            ansMax = -INF;
 //            queryMax(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
-//            update(updateDfn, 0, 1, n, 1);
 //            cout << ansMax << "\n";
+//            update(updateDfn, 0, 1, n, 1);
 //        }
 //    }
 //    return 0;

From 9888b83d26f3b7652fa0278764b8b37095201b84 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 30 Mar 2025 23:31:29 +0800
Subject: [PATCH 0632/1712] modify code

---
 src/class164/Code01_KruskalRebuild1.java | 4 +++-
 src/class164/Code01_KruskalRebuild2.java | 4 +++-
 src/class164/Code04_Journey1.java        | 3 ++-
 src/class164/Code04_Journey2.java        | 3 ++-
 4 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/class164/Code01_KruskalRebuild1.java b/src/class164/Code01_KruskalRebuild1.java
index 1d7957609..04714d136 100644
--- a/src/class164/Code01_KruskalRebuild1.java
+++ b/src/class164/Code01_KruskalRebuild1.java
@@ -4,7 +4,9 @@
 // 图里有n个点，m条无向边，每条边给定边权，图里可能有若干个连通的部分
 // 一共有q条查询，每条查询都是如下的格式
 // 查询 x y : 点x到达点y的路途中，最大的边权希望尽量小，打印这个值
-// 1 <= n <= 10^5    1 <= m <= 3 * 10^5    1 <= q <= 10^5
+// 1 <= n <= 10^5
+// 1 <= m <= 3 * 10^5
+// 1 <= q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2245
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class164/Code01_KruskalRebuild2.java b/src/class164/Code01_KruskalRebuild2.java
index 7b57937c7..34478ed99 100644
--- a/src/class164/Code01_KruskalRebuild2.java
+++ b/src/class164/Code01_KruskalRebuild2.java
@@ -4,7 +4,9 @@
 // 图里有n个点，m条无向边，每条边给定边权，图里可能有若干个连通的部分
 // 一共有q条查询，每条查询都是如下的格式
 // 查询 x y : 点x到达点y的路途中，最大的边权希望尽量小，打印这个值
-// 1 <= n <= 10^5    1 <= m <= 3 * 10^5    1 <= q <= 10^5
+// 1 <= n <= 10^5
+// 1 <= m <= 3 * 10^5
+// 1 <= q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2245
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class164/Code04_Journey1.java b/src/class164/Code04_Journey1.java
index a40e82c3e..1b5beb700 100644
--- a/src/class164/Code04_Journey1.java
+++ b/src/class164/Code04_Journey1.java
@@ -6,7 +6,8 @@
 // 查询 x y : 海拔 > y的边，走过没有代价
 //            海拔 <= y的边，走过的代价为边的长度
 //            从点x出发到达1号点，打印最小的代价
-// 1 <= n <= 2 * 10^5    1 <= m、q <= 4 * 10^5
+// 1 <= n <= 2 * 10^5
+// 1 <= m、q <= 4 * 10^5
 // 本题要求强制在线，具体规定请打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class164/Code04_Journey2.java b/src/class164/Code04_Journey2.java
index bfdc08fdc..04db4fe13 100644
--- a/src/class164/Code04_Journey2.java
+++ b/src/class164/Code04_Journey2.java
@@ -6,7 +6,8 @@
 // 查询 x y : 海拔 > y的边，走过没有代价
 //            海拔 <= y的边，走过的代价为边的长度
 //            从点x出发到达1号点，打印最小的代价
-// 1 <= n <= 2 * 10^5    1 <= m、q <= 4 * 10^5
+// 1 <= n <= 2 * 10^5
+// 1 <= m、q <= 4 * 10^5
 // 本题要求强制在线，具体规定请打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4768
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 8b7ee1867f051d357142eb0778fdd0395e43ed93 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 00:27:38 +0800
Subject: [PATCH 0633/1712] modify code

---
 .../{Code06_UntilConnect1.java => Code05_UntilConnect1.java}  | 2 +-
 .../{Code06_UntilConnect2.java => Code05_UntilConnect2.java}  | 0
 .../{Code07_GraphQueries1.java => Code06_GraphQueries1.java}  | 2 +-
 .../{Code07_GraphQueries2.java => Code06_GraphQueries2.java}  | 0
 src/class164/{Code05_Peaks1.java => Code07_Peaks1.java}       | 4 ++--
 src/class164/{Code05_Peaks2.java => Code07_Peaks2.java}       | 0
 6 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class164/{Code06_UntilConnect1.java => Code05_UntilConnect1.java} (99%)
 rename src/class164/{Code06_UntilConnect2.java => Code05_UntilConnect2.java} (100%)
 rename src/class164/{Code07_GraphQueries1.java => Code06_GraphQueries1.java} (99%)
 rename src/class164/{Code07_GraphQueries2.java => Code06_GraphQueries2.java} (100%)
 rename src/class164/{Code05_Peaks1.java => Code07_Peaks1.java} (98%)
 rename src/class164/{Code05_Peaks2.java => Code07_Peaks2.java} (100%)

diff --git a/src/class164/Code06_UntilConnect1.java b/src/class164/Code05_UntilConnect1.java
similarity index 99%
rename from src/class164/Code06_UntilConnect1.java
rename to src/class164/Code05_UntilConnect1.java
index e80e161de..5ae73287e 100644
--- a/src/class164/Code06_UntilConnect1.java
+++ b/src/class164/Code05_UntilConnect1.java
@@ -15,7 +15,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code06_UntilConnect1 {
+public class Code05_UntilConnect1 {
 
 	public static int MAXN = 100001;
 	public static int MAXK = 200001;
diff --git a/src/class164/Code06_UntilConnect2.java b/src/class164/Code05_UntilConnect2.java
similarity index 100%
rename from src/class164/Code06_UntilConnect2.java
rename to src/class164/Code05_UntilConnect2.java
diff --git a/src/class164/Code07_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
similarity index 99%
rename from src/class164/Code07_GraphQueries1.java
rename to src/class164/Code06_GraphQueries1.java
index 931c0219f..c134c78cf 100644
--- a/src/class164/Code07_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -16,7 +16,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code07_GraphQueries1 {
+public class Code06_GraphQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 400001;
diff --git a/src/class164/Code07_GraphQueries2.java b/src/class164/Code06_GraphQueries2.java
similarity index 100%
rename from src/class164/Code07_GraphQueries2.java
rename to src/class164/Code06_GraphQueries2.java
diff --git a/src/class164/Code05_Peaks1.java b/src/class164/Code07_Peaks1.java
similarity index 98%
rename from src/class164/Code05_Peaks1.java
rename to src/class164/Code07_Peaks1.java
index 0a055f19c..13ccfb707 100644
--- a/src/class164/Code05_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -13,7 +13,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行空间，制定通过标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code05_Peaks2文件就是C++的实现
+// 想通过用C++实现，本节课Code07_Peaks2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -21,7 +21,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code05_Peaks1 {
+public class Code07_Peaks1 {
 
 	public static int MAXN = 100001;
 	public static int MAXK = 200001;
diff --git a/src/class164/Code05_Peaks2.java b/src/class164/Code07_Peaks2.java
similarity index 100%
rename from src/class164/Code05_Peaks2.java
rename to src/class164/Code07_Peaks2.java

From 685e762dc2bf7f8b3f73c7230872054701d397f8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 16:38:17 +0800
Subject: [PATCH 0634/1712] modify code

---
 src/class164/Code01_KruskalRebuild1.java | 13 ++++++++-----
 src/class164/Code01_KruskalRebuild2.java |  3 +--
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/class164/Code01_KruskalRebuild1.java b/src/class164/Code01_KruskalRebuild1.java
index 04714d136..d4a51d475 100644
--- a/src/class164/Code01_KruskalRebuild1.java
+++ b/src/class164/Code01_KruskalRebuild1.java
@@ -21,20 +21,23 @@ public class Code01_KruskalRebuild1 {
 	public static int MAXM = 300001;
 	public static int MAXH = 20;
 	public static int n, m, q;
+
+	// 每条边有三个信息，节点u、节点v、边权w
 	public static int[][] edge = new int[MAXM][3];
 
-	// Kruskal重构树
+	// 并查集
+	public static int[] father = new int[MAXK];
+	// Kruskal重构树的建图
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
-
-	// 并查集
-	public static int[] father = new int[MAXK];
+	// Kruskal重构树上，节点的权值
 	public static int[] nodeKey = new int[MAXK];
+	// Kruskal重构树上，点的数量
 	public static int cntu;
 
-	// 树上dfs
+	// Kruskal重构树上，dfs过程建立的信息
 	public static int[] dep = new int[MAXK];
 	public static int[][] stjump = new int[MAXK][MAXH];
 
diff --git a/src/class164/Code01_KruskalRebuild2.java b/src/class164/Code01_KruskalRebuild2.java
index 34478ed99..0f9c2f75c 100644
--- a/src/class164/Code01_KruskalRebuild2.java
+++ b/src/class164/Code01_KruskalRebuild2.java
@@ -29,12 +29,11 @@
 //int n, m, q;
 //Edge edge[MAXM];
 //
+//int father[MAXK];
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
 //int cntg;
-//
-//int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //

From a2822ba45e43a7d0815272d316a96cda9ed87116 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 17:13:29 +0800
Subject: [PATCH 0635/1712] modify code

---
 src/class164/Code01_KruskalRebuild1.java | 3 ++-
 src/class164/Code01_KruskalRebuild2.java | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class164/Code01_KruskalRebuild1.java b/src/class164/Code01_KruskalRebuild1.java
index d4a51d475..831192090 100644
--- a/src/class164/Code01_KruskalRebuild1.java
+++ b/src/class164/Code01_KruskalRebuild1.java
@@ -3,7 +3,8 @@
 // Kruskal重构树模版题，java版
 // 图里有n个点，m条无向边，每条边给定边权，图里可能有若干个连通的部分
 // 一共有q条查询，每条查询都是如下的格式
-// 查询 x y : 点x到达点y的路途中，最大的边权希望尽量小，打印这个值
+// 查询 x y : 点x和点y希望连通起来，其中的最大边权希望尽量小，打印这个值
+//            如果怎样都无法联通，打印"impossible"
 // 1 <= n <= 10^5
 // 1 <= m <= 3 * 10^5
 // 1 <= q <= 10^5
diff --git a/src/class164/Code01_KruskalRebuild2.java b/src/class164/Code01_KruskalRebuild2.java
index 0f9c2f75c..391ae08a5 100644
--- a/src/class164/Code01_KruskalRebuild2.java
+++ b/src/class164/Code01_KruskalRebuild2.java
@@ -3,7 +3,8 @@
 // Kruskal重构树模版题，C++版
 // 图里有n个点，m条无向边，每条边给定边权，图里可能有若干个连通的部分
 // 一共有q条查询，每条查询都是如下的格式
-// 查询 x y : 点x到达点y的路途中，最大的边权希望尽量小，打印这个值
+// 查询 x y : 点x和点y希望连通起来，其中的最大边权希望尽量小，打印这个值
+//            如果怎样都无法联通，打印"impossible"
 // 1 <= n <= 10^5
 // 1 <= m <= 3 * 10^5
 // 1 <= q <= 10^5

From 3fa71d99e6a7a15ef8c82859f05cbcbfe6f57b95 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 19:01:47 +0800
Subject: [PATCH 0636/1712] modify code

---
 src/class164/Code02_Training1.java | 14 ++++++++------
 src/class164/Code02_Training2.java |  5 ++---
 2 files changed, 10 insertions(+), 9 deletions(-)

diff --git a/src/class164/Code02_Training1.java b/src/class164/Code02_Training1.java
index 7f10db4f8..bbb1eea0b 100644
--- a/src/class164/Code02_Training1.java
+++ b/src/class164/Code02_Training1.java
@@ -21,25 +21,27 @@ public class Code02_Training1 {
 	public static int MAXM = 400001;
 	public static int MAXH = 20;
 	public static int n, m, q;
-	public static int[][] edge = new int[MAXM][4];
 
+	// 每条边的信息，节点u、节点v、边权w、边的编号i
+	public static int[][] edge = new int[MAXM][4];
 	// 边的编号对应重构树上的点的编号
 	public static int[] edgeToTree = new int[MAXM];
 
+	// 并查集
+	public static int[] father = new int[MAXK];
+	public static int[] stack = new int[MAXK];
+
 	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
-
-	// 并查集
-	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
-	public static int[] stack = new int[MAXK];
 	public static int cntu;
 
-	// 树上dfs
+	// 树上dfs，Kruskal重构树的节点，子树上面有几个叶节点
 	public static int[] leafsiz = new int[MAXK];
+	// 树上dfs，Kruskal重构树的节点，倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
 
 	// 并查集的find方法，需要改成迭代版不然会爆栈，C++实现不需要
diff --git a/src/class164/Code02_Training2.java b/src/class164/Code02_Training2.java
index 19576388d..2211ff9f3 100644
--- a/src/class164/Code02_Training2.java
+++ b/src/class164/Code02_Training2.java
@@ -28,15 +28,14 @@
 //const int MAXH = 20;
 //int n, m, q;
 //Edge edge[MAXM];
-//
 //int edgeToTree[MAXM];
 //
+//int father[MAXK];
+//
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
 //int cntg;
-//
-//int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //

From 2bb4073e910417f5b4f7f2b6f1f5d521357d538e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 20:46:58 +0800
Subject: [PATCH 0637/1712] modify code

---
 src/class164/Code03_StampRally1.java   |  8 ++++----
 src/class164/Code03_StampRally2.java   |  6 +++---
 src/class164/Code04_Journey1.java      | 13 +++++++------
 src/class164/Code04_Journey2.java      |  6 +++---
 src/class164/Code05_UntilConnect1.java |  6 +++---
 src/class164/Code05_UntilConnect2.java |  6 +++---
 src/class164/Code06_GraphQueries1.java |  6 +++---
 src/class164/Code06_GraphQueries2.java |  4 ++--
 src/class164/Code07_Peaks1.java        |  7 +++----
 src/class164/Code07_Peaks2.java        |  5 ++---
 10 files changed, 33 insertions(+), 34 deletions(-)

diff --git a/src/class164/Code03_StampRally1.java b/src/class164/Code03_StampRally1.java
index dd6d6da58..15b0cc32b 100644
--- a/src/class164/Code03_StampRally1.java
+++ b/src/class164/Code03_StampRally1.java
@@ -24,20 +24,20 @@ public class Code03_StampRally1 {
 	public static int n, m, q;
 	public static int[][] edge = new int[MAXM][3];
 
+	// 并查集
+	public static int[] father = new int[MAXK];
+
 	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
-
-	// 并查集
-	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
 	// 树上dfs
-	public static int[][] stjump = new int[MAXK][MAXH];
 	public static int[] leafsiz = new int[MAXK];
+	public static int[][] stjump = new int[MAXK][MAXH];
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
diff --git a/src/class164/Code03_StampRally2.java b/src/class164/Code03_StampRally2.java
index fa6066571..de890edbe 100644
--- a/src/class164/Code03_StampRally2.java
+++ b/src/class164/Code03_StampRally2.java
@@ -30,17 +30,17 @@
 //int n, m, q;
 //Edge edge[MAXM];
 //
+//int father[MAXK];
+//
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
 //int cntg = 0;
-//
-//int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //
-//int stjump[MAXK][MAXH];
 //int leafsiz[MAXK];
+//int stjump[MAXK][MAXH];
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
diff --git a/src/class164/Code04_Journey1.java b/src/class164/Code04_Journey1.java
index 1b5beb700..9621d5bdc 100644
--- a/src/class164/Code04_Journey1.java
+++ b/src/class164/Code04_Journey1.java
@@ -40,21 +40,22 @@ public class Code04_Journey1 {
 	public static boolean[] visit = new boolean[MAXN];
 	public static PriorityQueue<int[]> heap = new PriorityQueue<>((a, b) -> a[1] - b[1]);
 
+	// 并查集
+	public static int[] father = new int[MAXK];
+	public static int[] stack = new int[MAXK];
+
 	// Kruskal重构树
 	public static int[] headk = new int[MAXK];
 	public static int[] nextk = new int[MAXK];
 	public static int[] tok = new int[MAXK];
 	public static int cntk;
-
-	// 并查集
-	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
-	public static int[] stack = new int[MAXK];
 	public static int cntu;
 
-	// 树上dfs
-	public static int[][] stjump = new int[MAXK][MAXH];
+	// 树上dfs，Kruskal重构树的节点，子树中的所有点，走到1号节点的最小距离
 	public static int[] mindist = new int[MAXK];
+	// 树上dfs，Kruskal重构树的节点，倍增表
+	public static int[][] stjump = new int[MAXK][MAXH];
 
 	public static void clear() {
 		cntg = cntk = 0;
diff --git a/src/class164/Code04_Journey2.java b/src/class164/Code04_Journey2.java
index 04db4fe13..e91df1ecd 100644
--- a/src/class164/Code04_Journey2.java
+++ b/src/class164/Code04_Journey2.java
@@ -53,17 +53,17 @@
 //bool visit[MAXN];
 //priority_queue<HeapNode, vector<HeapNode>, HeapNodeCmp> heap;
 //
+//int father[MAXK];
+//
 //int headk[MAXK];
 //int nextk[MAXK];
 //int tok[MAXK];
 //int cntk;
-//
-//int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //
-//int stjump[MAXK][MAXH];
 //int mindist[MAXK];
+//int stjump[MAXK][MAXH];
 //
 //void clear() {
 //    cntg = 0;
diff --git a/src/class164/Code05_UntilConnect1.java b/src/class164/Code05_UntilConnect1.java
index 5ae73287e..37b263073 100644
--- a/src/class164/Code05_UntilConnect1.java
+++ b/src/class164/Code05_UntilConnect1.java
@@ -24,14 +24,14 @@ public class Code05_UntilConnect1 {
 	public static int t, n, m, q;
 	public static int[][] edge = new int[MAXM][3];
 
+	// 并查集
+	public static int[] father = new int[MAXK];
+
 	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg;
-
-	// 并查集
-	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
diff --git a/src/class164/Code05_UntilConnect2.java b/src/class164/Code05_UntilConnect2.java
index 3887c2462..2fbe9ecd2 100644
--- a/src/class164/Code05_UntilConnect2.java
+++ b/src/class164/Code05_UntilConnect2.java
@@ -28,14 +28,14 @@
 //const int MAXM = 200001;
 //const int MAXH = 20;
 //int t, n, m, q;
-//
 //Edge edge[MAXM];
+//
+//int father[MAXK];
+//
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
 //int cntg;
-//
-//int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //
diff --git a/src/class164/Code06_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
index c134c78cf..32eb42d7c 100644
--- a/src/class164/Code06_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -32,14 +32,14 @@ public class Code06_GraphQueries1 {
 	public static int[][] ques = new int[MAXQ][2];
 	public static int[] timeline = new int[MAXQ];
 
+	// 并查集
+	public static int[] father = new int[MAXK];
+
 	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
-
-	// 并查集
-	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
diff --git a/src/class164/Code06_GraphQueries2.java b/src/class164/Code06_GraphQueries2.java
index b9c894572..6f0a61c41 100644
--- a/src/class164/Code06_GraphQueries2.java
+++ b/src/class164/Code06_GraphQueries2.java
@@ -37,12 +37,12 @@
 //int ques[MAXQ][2];
 //int timeline[MAXQ];
 //
+//int father[MAXK];
+//
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
 //int cntg;
-//
-//int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //
diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index 13ccfb707..658d82fa2 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -33,17 +33,16 @@ public class Code07_Peaks1 {
 	public static int[] node = new int[MAXN];
 	public static int[] sorted = new int[MAXN];
 	public static int diff;
-
 	public static int[][] edge = new int[MAXM][3];
 
+	// 并查集
+	public static int[] father = new int[MAXK];
+
 	// Kruskal重构树
 	public static int[] head = new int[MAXK];
 	public static int[] next = new int[MAXK];
 	public static int[] to = new int[MAXK];
 	public static int cntg = 0;
-
-	// 并查集
-	public static int[] father = new int[MAXK];
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
diff --git a/src/class164/Code07_Peaks2.java b/src/class164/Code07_Peaks2.java
index d2cb70750..0de136e37 100644
--- a/src/class164/Code07_Peaks2.java
+++ b/src/class164/Code07_Peaks2.java
@@ -34,15 +34,14 @@
 //int node[MAXN];
 //int sorted[MAXN];
 //int diff;
-//
 //Edge edge[MAXM];
 //
+//int father[MAXK];
+//
 //int head[MAXK];
 //int nxt[MAXK];
 //int to[MAXK];
 //int cntg;
-//
-//int father[MAXK];
 //int nodeKey[MAXK];
 //int cntu;
 //

From 41e426433620c045a303f938c340f2396f1d9965 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 21:18:09 +0800
Subject: [PATCH 0638/1712] modify code

---
 src/class164/Code03_StampRally1.java | 2 +-
 src/class164/Code03_StampRally2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class164/Code03_StampRally1.java b/src/class164/Code03_StampRally1.java
index 15b0cc32b..8b025bed1 100644
--- a/src/class164/Code03_StampRally1.java
+++ b/src/class164/Code03_StampRally1.java
@@ -7,6 +7,7 @@
 //              每个点可以重复经过，但是重复经过只计算一次
 //              经过边的最大编号，最小是多少
 // 3 <= n、m、q <= 10^5
+// 3 <= z <= n
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc002_d
 // 测试链接 : https://atcoder.jp/contests/agc002/tasks/agc002_d
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -23,7 +24,6 @@ public class Code03_StampRally1 {
 	public static int MAXH = 20;
 	public static int n, m, q;
 	public static int[][] edge = new int[MAXM][3];
-
 	// 并查集
 	public static int[] father = new int[MAXK];
 
diff --git a/src/class164/Code03_StampRally2.java b/src/class164/Code03_StampRally2.java
index de890edbe..c269b243a 100644
--- a/src/class164/Code03_StampRally2.java
+++ b/src/class164/Code03_StampRally2.java
@@ -7,6 +7,7 @@
 //              每个点可以重复经过，但是重复经过只计算一次
 //              经过边的最大编号，最小是多少
 // 3 <= n、m、q <= 10^5
+// 3 <= z <= n
 // 测试链接 : https://www.luogu.com.cn/problem/AT_agc002_d
 // 测试链接 : https://atcoder.jp/contests/agc002/tasks/agc002_d
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -29,7 +30,6 @@
 //const int MAXH = 20;
 //int n, m, q;
 //Edge edge[MAXM];
-//
 //int father[MAXK];
 //
 //int head[MAXK];

From 76b420f4fc1e0d3acb8bd3b417c9c5e01dcd9c67 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 21:59:37 +0800
Subject: [PATCH 0639/1712] modify code

---
 src/class164/Code05_UntilConnect1.java | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/class164/Code05_UntilConnect1.java b/src/class164/Code05_UntilConnect1.java
index 37b263073..9c9b1a7a3 100644
--- a/src/class164/Code05_UntilConnect1.java
+++ b/src/class164/Code05_UntilConnect1.java
@@ -35,11 +35,15 @@ public class Code05_UntilConnect1 {
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
-	// 树上dfs
+	// 树上dfs，Kruskal重构树的节点，深度
 	public static int[] dep = new int[MAXK];
+	// 树上dfs，Kruskal重构树的节点，dfn序
 	public static int[] dfn = new int[MAXK];
+	// 树上dfs，seg[i] = j，代表dfn序号为i的节点，对应的原始节点编号为j
 	public static int[] seg = new int[MAXK];
+	// 树上dfs，Kruskal重构树的节点，倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
+	// 树上dfs，dfn序号的计数
 	public static int cntd;
 
 	// 倍增表查询区间最大值、最小值
@@ -97,6 +101,7 @@ public static void dfs(int u, int fa) {
 		}
 	}
 
+	// 构建数组上的st表，讲解117进行了详细的讲述
 	public static void buildst() {
 		lg2[0] = -1;
 		for (int i = 1; i <= n; i++) {
@@ -112,12 +117,14 @@ public static void buildst() {
 		}
 	}
 
+	// 根据st表，[l..r]范围上的最小值，讲解117进行了详细的讲述
 	public static int dfnmin(int l, int r) {
 		int p = lg2[r - l + 1];
 		int ans = Math.min(stmin[l][p], stmin[r - (1 << p) + 1][p]);
 		return ans;
 	}
 
+	// 根据st表，[l..r]范围上的最大值，讲解117进行了详细的讲述
 	public static int dfnmax(int l, int r) {
 		int p = lg2[r - l + 1];
 		int ans = Math.max(stmax[l][p], stmax[r - (1 << p) + 1][p]);

From 0b1c0e58f9d026eaea45e7df04bad8aa49e4fa12 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 22:03:05 +0800
Subject: [PATCH 0640/1712] modify code

---
 src/class164/Code05_UntilConnect1.java | 2 +-
 src/class164/Code05_UntilConnect2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class164/Code05_UntilConnect1.java b/src/class164/Code05_UntilConnect1.java
index 9c9b1a7a3..62e22ca14 100644
--- a/src/class164/Code05_UntilConnect1.java
+++ b/src/class164/Code05_UntilConnect1.java
@@ -1,7 +1,7 @@
 package class164;
 
 // 加边直到连通，java版
-// 图里有n个点，m条无向边，所有点都连通
+// 图里有n个点，m条无向边，点的编号1~n，边的编号1~m，所有点都连通
 // 一共有q条查询，每条查询格式如下
 // 查询 l r : 至少要加完编号前多少的边，才能使得[l, r]中的所有点连通
 // 1 <= n <= 10^5
diff --git a/src/class164/Code05_UntilConnect2.java b/src/class164/Code05_UntilConnect2.java
index 2fbe9ecd2..43932c98d 100644
--- a/src/class164/Code05_UntilConnect2.java
+++ b/src/class164/Code05_UntilConnect2.java
@@ -1,7 +1,7 @@
 package class164;
 
 // 加边直到连通，C++版
-// 图里有n个点，m条无向边，所有点都连通
+// 图里有n个点，m条无向边，点的编号1~n，边的编号1~m，所有点都连通
 // 一共有q条查询，每条查询格式如下
 // 查询 l r : 至少要加完编号前多少的边，才能使得[l, r]中的所有点连通
 // 1 <= n <= 10^5

From 73fb0a4640862b507ff3f228c0125e591926a12f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 31 Mar 2025 22:09:29 +0800
Subject: [PATCH 0641/1712] modify code

---
 src/class164/Code05_UntilConnect1.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class164/Code05_UntilConnect1.java b/src/class164/Code05_UntilConnect1.java
index 62e22ca14..accb9dc00 100644
--- a/src/class164/Code05_UntilConnect1.java
+++ b/src/class164/Code05_UntilConnect1.java
@@ -35,18 +35,18 @@ public class Code05_UntilConnect1 {
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
-	// 树上dfs，Kruskal重构树的节点，深度
+	// 深度
 	public static int[] dep = new int[MAXK];
-	// 树上dfs，Kruskal重构树的节点，dfn序
+	// dfn序
 	public static int[] dfn = new int[MAXK];
-	// 树上dfs，seg[i] = j，代表dfn序号为i的节点，对应的原始节点编号为j
+	// seg[i] = j，代表树上节点的dfn序号为i，对应原始节点的编号为j
 	public static int[] seg = new int[MAXK];
-	// 树上dfs，Kruskal重构树的节点，倍增表
+	// 树上的倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
-	// 树上dfs，dfn序号的计数
+	// dfn序号的计数
 	public static int cntd;
 
-	// 倍增表查询区间最大值、最小值
+	// 一维数组的倍增表，查询区间最大值、最小值
 	public static int[] lg2 = new int[MAXN];
 	public static int[][] stmax = new int[MAXN][MAXH];
 	public static int[][] stmin = new int[MAXN][MAXH];

From 5623018cdc89db20a7aaae06f8d605df28c6b340 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 12:14:50 +0800
Subject: [PATCH 0642/1712] modify code

---
 src/class164/Code06_GraphQueries1.java | 57 +++++++++++---------------
 src/class164/Code06_GraphQueries2.java | 51 ++++++++++-------------
 2 files changed, 46 insertions(+), 62 deletions(-)

diff --git a/src/class164/Code06_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
index 32eb42d7c..05f967191 100644
--- a/src/class164/Code06_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -26,11 +26,12 @@ public class Code06_GraphQueries1 {
 	public static int INF = 1000000001;
 	public static int n, m, q;
 
-	// 根据删除操作，给每条边设置边权，给查询操作设置时间线
+	// 所有节点的值
 	public static int[] node = new int[MAXN];
+	// 所有边，根据删除操作，设置每条边的权值
 	public static int[][] edge = new int[MAXM][3];
+	// 所有操作
 	public static int[][] ques = new int[MAXQ][2];
-	public static int[] timeline = new int[MAXQ];
 
 	// 并查集
 	public static int[] father = new int[MAXK];
@@ -50,13 +51,9 @@ public class Code06_GraphQueries1 {
 	public static int[] leafseg = new int[MAXK];
 	public static int cntd = 0;
 
-	// 线段树维护dfn区间的最大值、最大值来自哪个dfn编号
-	public static int[] maxval = new int[MAXN << 2];
+	// 线段树维护最大值来自哪个dfn编号
 	public static int[] maxdfn = new int[MAXN << 2];
 
-	public static int ansMax;
-	public static int updateDfn;
-
 	public static void prepare() {
 		for (int i = 1; i <= q; i++) {
 			if (ques[i][0] == 2) {
@@ -70,9 +67,7 @@ public static void prepare() {
 			}
 		}
 		for (int i = q; i >= 1; i--) {
-			if (ques[i][0] == 1) {
-				timeline[i] = time;
-			} else {
+			if (ques[i][0] == 2) {
 				edge[ques[i][1]][2] = ++time;
 			}
 		}
@@ -144,18 +139,15 @@ public static int getAncestor(int u, int limit) {
 	public static void up(int i) {
 		int l = i << 1;
 		int r = i << 1 | 1;
-		if (maxval[l] > maxval[r]) {
-			maxval[i] = maxval[l];
+		if (node[leafseg[maxdfn[l]]] > node[leafseg[maxdfn[r]]]) {
 			maxdfn[i] = maxdfn[l];
 		} else {
-			maxval[i] = maxval[r];
 			maxdfn[i] = maxdfn[r];
 		}
 	}
 
 	public static void build(int l, int r, int i) {
 		if (l == r) {
-			maxval[i] = node[leafseg[l]];
 			maxdfn[i] = l;
 		} else {
 			int mid = (l + r) / 2;
@@ -167,7 +159,7 @@ public static void build(int l, int r, int i) {
 
 	public static void update(int jobi, int jobv, int l, int r, int i) {
 		if (l == r) {
-			maxval[i] = jobv;
+			node[leafseg[jobi]] = jobv;
 		} else {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
@@ -179,23 +171,22 @@ public static void update(int jobi, int jobv, int l, int r, int i) {
 		}
 	}
 
-	public static void updateAns(int curmax, int curdfn) {
-		if (ansMax < curmax) {
-			ansMax = curmax;
-			updateDfn = curdfn;
-		}
-	}
-
-	public static void queryMax(int jobl, int jobr, int l, int r, int i) {
+	public static int queryMaxDfn(int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			updateAns(maxval[i], maxdfn[i]);
+			return maxdfn[i];
 		} else {
 			int mid = (l + r) / 2;
+			int ldfn = 0, rdfn = 0;
 			if (jobl <= mid) {
-				queryMax(jobl, jobr, l, mid, i << 1);
+				ldfn = queryMaxDfn(jobl, jobr, l, mid, i << 1);
 			}
 			if (jobr > mid) {
-				queryMax(jobl, jobr, mid + 1, r, i << 1 | 1);
+				rdfn = queryMaxDfn(jobl, jobr, mid + 1, r, i << 1 | 1);
+			}
+			if (node[leafseg[ldfn]] > node[leafseg[rdfn]]) {
+				return ldfn;
+			} else {
+				return rdfn;
 			}
 		}
 	}
@@ -225,13 +216,15 @@ public static void main(String[] args) {
 			}
 		}
 		build(1, n, 1);
-		for (int i = 1, anc; i <= q; i++) {
+		int limit = m, anc, ansDfn;
+		for (int i = 1; i <= q; i++) {
 			if (ques[i][0] == 1) {
-				anc = getAncestor(ques[i][1], timeline[i]);
-				ansMax = -INF;
-				queryMax(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
-				io.writelnInt(ansMax);
-				update(updateDfn, 0, 1, n, 1);
+				anc = getAncestor(ques[i][1], limit);
+				ansDfn = queryMaxDfn(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
+				io.writelnInt(node[leafseg[ansDfn]]);
+				update(ansDfn, 0, 1, n, 1);
+			} else {
+				limit--;
 			}
 		}
 		io.flush();
diff --git a/src/class164/Code06_GraphQueries2.java b/src/class164/Code06_GraphQueries2.java
index 6f0a61c41..f7e539f69 100644
--- a/src/class164/Code06_GraphQueries2.java
+++ b/src/class164/Code06_GraphQueries2.java
@@ -35,7 +35,6 @@
 //int node[MAXN];
 //Edge edge[MAXM];
 //int ques[MAXQ][2];
-//int timeline[MAXQ];
 //
 //int father[MAXK];
 //
@@ -52,12 +51,8 @@
 //int leafseg[MAXK];
 //int cntd;
 //
-//int maxval[MAXN << 2];
 //int maxdfn[MAXN << 2];
 //
-//int ansMax;
-//int updateDfn;
-//
 //void prepare() {
 //    for (int i = 1; i <= q; i++) {
 //        if (ques[i][0] == 2) {
@@ -71,9 +66,7 @@
 //        }
 //    }
 //    for (int i = q; i >= 1; i--) {
-//        if (ques[i][0] == 1) {
-//            timeline[i] = time;
-//        } else {
+//        if (ques[i][0] == 2) {
 //            edge[ques[i][1]].w = ++time;
 //        }
 //    }
@@ -145,18 +138,15 @@
 //void up(int i) {
 //    int l = i << 1;
 //    int r = i << 1 | 1;
-//    if (maxval[l] > maxval[r]) {
-//        maxval[i] = maxval[l];
+//    if (node[leafseg[maxdfn[l]]] > node[leafseg[maxdfn[r]]]) {
 //        maxdfn[i] = maxdfn[l];
 //    } else {
-//        maxval[i] = maxval[r];
 //        maxdfn[i] = maxdfn[r];
 //    }
 //}
 //
 //void build(int l, int r, int i) {
 //    if (l == r) {
-//        maxval[i] = node[leafseg[l]];
 //        maxdfn[i] = l;
 //    } else {
 //        int mid = (l + r) / 2;
@@ -168,7 +158,7 @@
 //
 //void update(int jobi, int jobv, int l, int r, int i) {
 //    if (l == r) {
-//        maxval[i] = jobv;
+//        node[leafseg[jobi]] = jobv;
 //    } else {
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
@@ -180,23 +170,22 @@
 //    }
 //}
 //
-//void updateAns(int curmax, int curdfn) {
-//    if (ansMax < curmax) {
-//        ansMax = curmax;
-//        updateDfn = curdfn;
-//    }
-//}
-//
-//void queryMax(int jobl, int jobr, int l, int r, int i) {
+//int queryMaxDfn(int jobl, int jobr, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
-//        updateAns(maxval[i], maxdfn[i]);
+//        return maxdfn[i];
 //    } else {
 //        int mid = (l + r) / 2;
+//        int ldfn = 0, rdfn = 0;
 //        if (jobl <= mid) {
-//        	queryMax(jobl, jobr, l, mid, i << 1);
+//        	ldfn = queryMaxDfn(jobl, jobr, l, mid, i << 1);
 //        }
 //        if (jobr > mid) {
-//        	queryMax(jobl, jobr, mid + 1, r, i << 1 | 1);
+//        	rdfn = queryMaxDfn(jobl, jobr, mid + 1, r, i << 1 | 1);
+//        }
+//        if (node[leafseg[ldfn]] > node[leafseg[rdfn]]) {
+//            return ldfn;
+//        } else {
+//            return rdfn;
 //        }
 //    }
 //}
@@ -223,13 +212,15 @@
 //        }
 //    }
 //    build(1, n, 1);
-//    for (int i = 1, anc; i <= q; i++) {
+//    int limit = m, anc, ansDfn;
+//    for (int i = 1; i <= q; i++) {
 //        if (ques[i][0] == 1) {
-//            anc = getAncestor(ques[i][1], timeline[i]);
-//            ansMax = -INF;
-//            queryMax(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
-//            cout << ansMax << "\n";
-//            update(updateDfn, 0, 1, n, 1);
+//            anc = getAncestor(ques[i][1], limit);
+//            ansDfn = queryMaxDfn(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
+//            cout << node[leafseg[ansDfn]] << "\n";
+//            update(ansDfn, 0, 1, n, 1);
+//        } else {
+//            limit--;
 //        }
 //    }
 //    return 0;

From 6e4f50377b1cb016892444c04c4ca5994f51eccb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 12:16:08 +0800
Subject: [PATCH 0643/1712] modify code

---
 src/class164/Code06_GraphQueries1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class164/Code06_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
index 05f967191..f04c752b3 100644
--- a/src/class164/Code06_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -26,7 +26,7 @@ public class Code06_GraphQueries1 {
 	public static int INF = 1000000001;
 	public static int n, m, q;
 
-	// 所有节点的值
+	// 所有节点的值，需要记录，线段树也要使用
 	public static int[] node = new int[MAXN];
 	// 所有边，根据删除操作，设置每条边的权值
 	public static int[][] edge = new int[MAXM][3];

From fe3fe32ef5392e891a5c472f9956f01a1834bba0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 14:37:28 +0800
Subject: [PATCH 0644/1712] modify code

---
 src/class164/Code06_GraphQueries1.java | 52 +++++++++++++++-----------
 src/class164/Code06_GraphQueries2.java | 42 +++++++++++----------
 2 files changed, 54 insertions(+), 40 deletions(-)

diff --git a/src/class164/Code06_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
index f04c752b3..7c941f849 100644
--- a/src/class164/Code06_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -23,7 +23,6 @@ public class Code06_GraphQueries1 {
 	public static int MAXM = 300001;
 	public static int MAXQ = 500001;
 	public static int MAXH = 20;
-	public static int INF = 1000000001;
 	public static int n, m, q;
 
 	// 所有节点的值，需要记录，线段树也要使用
@@ -44,15 +43,19 @@ public class Code06_GraphQueries1 {
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
-	// 树上dfs
+	// 倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
+	// 子树上的叶节点个数
 	public static int[] leafsiz = new int[MAXK];
-	public static int[] leafstart = new int[MAXK];
+	// 子树上叶节点的dfn序号最小值
+	public static int[] leafDfnMin = new int[MAXK];
+	// leafseg[i] = j，表示dfn序号为i的叶节点，原始编号为j
 	public static int[] leafseg = new int[MAXK];
+	// dfn的计数
 	public static int cntd = 0;
 
-	// 线段树维护最大值来自哪个dfn编号
-	public static int[] maxdfn = new int[MAXN << 2];
+	// 线段树的下标是dfn序号，维护范围内，拥有节点最大值的dfn序号
+	public static int[] maxValueDfn = new int[MAXN << 2];
 
 	public static void prepare() {
 		for (int i = 1; i <= q; i++) {
@@ -115,15 +118,15 @@ public static void dfs(int u, int fa) {
 		}
 		if (u <= n) {
 			leafsiz[u] = 1;
-			leafstart[u] = ++cntd;
+			leafDfnMin[u] = ++cntd;
 			leafseg[cntd] = u;
 		} else {
 			leafsiz[u] = 0;
-			leafstart[u] = INF;
+			leafDfnMin[u] = n + 1;
 		}
 		for (int e = head[u]; e > 0; e = next[e]) {
 			leafsiz[u] += leafsiz[to[e]];
-			leafstart[u] = Math.min(leafstart[u], leafstart[to[e]]);
+			leafDfnMin[u] = Math.min(leafDfnMin[u], leafDfnMin[to[e]]);
 		}
 	}
 
@@ -139,16 +142,16 @@ public static int getAncestor(int u, int limit) {
 	public static void up(int i) {
 		int l = i << 1;
 		int r = i << 1 | 1;
-		if (node[leafseg[maxdfn[l]]] > node[leafseg[maxdfn[r]]]) {
-			maxdfn[i] = maxdfn[l];
+		if (node[leafseg[maxValueDfn[l]]] > node[leafseg[maxValueDfn[r]]]) {
+			maxValueDfn[i] = maxValueDfn[l];
 		} else {
-			maxdfn[i] = maxdfn[r];
+			maxValueDfn[i] = maxValueDfn[r];
 		}
 	}
 
 	public static void build(int l, int r, int i) {
 		if (l == r) {
-			maxdfn[i] = l;
+			maxValueDfn[i] = l;
 		} else {
 			int mid = (l + r) / 2;
 			build(l, mid, i << 1);
@@ -157,6 +160,7 @@ public static void build(int l, int r, int i) {
 		}
 	}
 
+	// dfn序号为jobi，节点值更新成jobv
 	public static void update(int jobi, int jobv, int l, int r, int i) {
 		if (l == r) {
 			node[leafseg[jobi]] = jobv;
@@ -171,17 +175,18 @@ public static void update(int jobi, int jobv, int l, int r, int i) {
 		}
 	}
 
-	public static int queryMaxDfn(int jobl, int jobr, int l, int r, int i) {
+	// dfn范围[jobl..jobr]，哪个节点拥有最大值，返回该节点的dfn序号
+	public static int query(int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			return maxdfn[i];
+			return maxValueDfn[i];
 		} else {
 			int mid = (l + r) / 2;
 			int ldfn = 0, rdfn = 0;
 			if (jobl <= mid) {
-				ldfn = queryMaxDfn(jobl, jobr, l, mid, i << 1);
+				ldfn = query(jobl, jobr, l, mid, i << 1);
 			}
 			if (jobr > mid) {
-				rdfn = queryMaxDfn(jobl, jobr, mid + 1, r, i << 1 | 1);
+				rdfn = query(jobl, jobr, mid + 1, r, i << 1 | 1);
 			}
 			if (node[leafseg[ldfn]] > node[leafseg[rdfn]]) {
 				return ldfn;
@@ -191,6 +196,14 @@ public static int queryMaxDfn(int jobl, int jobr, int l, int r, int i) {
 		}
 	}
 
+	public static int queryAndUpdate(int x, int limit) {
+		int anc = getAncestor(x, limit);
+		int dfn = query(leafDfnMin[anc], leafDfnMin[anc] + leafsiz[anc] - 1, 1, n, 1);
+		int ans = node[leafseg[dfn]];
+		update(dfn, 0, 1, n, 1);
+		return ans;
+	}
+
 	public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
@@ -216,13 +229,10 @@ public static void main(String[] args) {
 			}
 		}
 		build(1, n, 1);
-		int limit = m, anc, ansDfn;
+		int limit = m;
 		for (int i = 1; i <= q; i++) {
 			if (ques[i][0] == 1) {
-				anc = getAncestor(ques[i][1], limit);
-				ansDfn = queryMaxDfn(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
-				io.writelnInt(node[leafseg[ansDfn]]);
-				update(ansDfn, 0, 1, n, 1);
+				io.writelnInt(queryAndUpdate(ques[i][1], limit));
 			} else {
 				limit--;
 			}
diff --git a/src/class164/Code06_GraphQueries2.java b/src/class164/Code06_GraphQueries2.java
index f7e539f69..5de91b5f7 100644
--- a/src/class164/Code06_GraphQueries2.java
+++ b/src/class164/Code06_GraphQueries2.java
@@ -29,7 +29,6 @@
 //const int MAXM = 300001;
 //const int MAXQ = 500001;
 //const int MAXH = 20;
-//int INF = 1000000001;
 //int n, m, q;
 //
 //int node[MAXN];
@@ -47,11 +46,11 @@
 //
 //int stjump[MAXK][MAXH];
 //int leafsiz[MAXK];
-//int leafstart[MAXK];
+//int leafDfnMin[MAXK];
 //int leafseg[MAXK];
 //int cntd;
 //
-//int maxdfn[MAXN << 2];
+//int maxValueDfn[MAXN << 2];
 //
 //void prepare() {
 //    for (int i = 1; i <= q; i++) {
@@ -114,15 +113,15 @@
 //    }
 //    if (u <= n) {
 //        leafsiz[u] = 1;
-//        leafstart[u] = ++cntd;
+//        leafDfnMin[u] = ++cntd;
 //        leafseg[cntd] = u;
 //    } else {
 //        leafsiz[u] = 0;
-//        leafstart[u] = INF;
+//        leafDfnMin[u] = n + 1;
 //    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        leafsiz[u] += leafsiz[to[e]];
-//        leafstart[u] = min(leafstart[u], leafstart[to[e]]);
+//        leafDfnMin[u] = min(leafDfnMin[u], leafDfnMin[to[e]]);
 //    }
 //}
 //
@@ -138,16 +137,16 @@
 //void up(int i) {
 //    int l = i << 1;
 //    int r = i << 1 | 1;
-//    if (node[leafseg[maxdfn[l]]] > node[leafseg[maxdfn[r]]]) {
-//        maxdfn[i] = maxdfn[l];
+//    if (node[leafseg[maxValueDfn[l]]] > node[leafseg[maxValueDfn[r]]]) {
+//        maxValueDfn[i] = maxValueDfn[l];
 //    } else {
-//        maxdfn[i] = maxdfn[r];
+//        maxValueDfn[i] = maxValueDfn[r];
 //    }
 //}
 //
 //void build(int l, int r, int i) {
 //    if (l == r) {
-//        maxdfn[i] = l;
+//        maxValueDfn[i] = l;
 //    } else {
 //        int mid = (l + r) / 2;
 //        build(l, mid, i << 1);
@@ -170,17 +169,17 @@
 //    }
 //}
 //
-//int queryMaxDfn(int jobl, int jobr, int l, int r, int i) {
+//int query(int jobl, int jobr, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
-//        return maxdfn[i];
+//        return maxValueDfn[i];
 //    } else {
 //        int mid = (l + r) / 2;
 //        int ldfn = 0, rdfn = 0;
 //        if (jobl <= mid) {
-//        	ldfn = queryMaxDfn(jobl, jobr, l, mid, i << 1);
+//        	ldfn = query(jobl, jobr, l, mid, i << 1);
 //        }
 //        if (jobr > mid) {
-//        	rdfn = queryMaxDfn(jobl, jobr, mid + 1, r, i << 1 | 1);
+//        	rdfn = query(jobl, jobr, mid + 1, r, i << 1 | 1);
 //        }
 //        if (node[leafseg[ldfn]] > node[leafseg[rdfn]]) {
 //            return ldfn;
@@ -190,6 +189,14 @@
 //    }
 //}
 //
+//int queryAndUpdate(int x, int limit) {
+//    int anc = getAncestor(x, limit);
+//    int dfn = query(leafDfnMin[anc], leafDfnMin[anc] + leafsiz[anc] - 1, 1, n, 1);
+//    int ans = node[leafseg[dfn]];
+//    update(dfn, 0, 1, n, 1);
+//    return ans;
+//}
+//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
@@ -212,13 +219,10 @@
 //        }
 //    }
 //    build(1, n, 1);
-//    int limit = m, anc, ansDfn;
+//    int limit = m;
 //    for (int i = 1; i <= q; i++) {
 //        if (ques[i][0] == 1) {
-//            anc = getAncestor(ques[i][1], limit);
-//            ansDfn = queryMaxDfn(leafstart[anc], leafstart[anc] + leafsiz[anc] - 1, 1, n, 1);
-//            cout << node[leafseg[ansDfn]] << "\n";
-//            update(ansDfn, 0, 1, n, 1);
+//            cout << queryAndUpdate(ques[i][1], limit) << "\n";
 //        } else {
 //            limit--;
 //        }

From acb4fd0189c3a2e96b0731916a9becf75a2b4951 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 14:42:22 +0800
Subject: [PATCH 0645/1712] modify code

---
 src/class164/Code07_Peaks1.java | 8 ++++----
 src/class164/Code07_Peaks2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index 658d82fa2..9500870f1 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -57,7 +57,7 @@ public class Code07_Peaks1 {
 	public static int[] root = new int[MAXK];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
-	public static int[] segsiz = new int[MAXT];
+	public static int[] numcnt = new int[MAXT];
 	public static int cntt = 0;
 
 	public static int kth(int num) {
@@ -142,7 +142,7 @@ public static void dfs(int u, int fa) {
 
 	public static int build(int l, int r) {
 		int rt = ++cntt;
-		segsiz[rt] = 0;
+		numcnt[rt] = 0;
 		if (l < r) {
 			int mid = (l + r) / 2;
 			ls[rt] = build(l, mid);
@@ -155,7 +155,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cntt;
 		ls[rt] = ls[i];
 		rs[rt] = rs[i];
-		segsiz[rt] = segsiz[i] + 1;
+		numcnt[rt] = numcnt[i] + 1;
 		if (l < r) {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
@@ -171,7 +171,7 @@ public static int query(int jobk, int l, int r, int pre, int post) {
 		if (l == r) {
 			return l;
 		}
-		int rsize = segsiz[rs[post]] - segsiz[rs[pre]];
+		int rsize = numcnt[rs[post]] - numcnt[rs[pre]];
 		int mid = (l + r) / 2;
 		if (rsize >= jobk) {
 			return query(jobk, mid + 1, r, rs[pre], rs[post]);
diff --git a/src/class164/Code07_Peaks2.java b/src/class164/Code07_Peaks2.java
index 0de136e37..998e76ba2 100644
--- a/src/class164/Code07_Peaks2.java
+++ b/src/class164/Code07_Peaks2.java
@@ -54,7 +54,7 @@
 //int root[MAXK];
 //int ls[MAXT];
 //int rs[MAXT];
-//int segsiz[MAXT];
+//int numcnt[MAXT];
 //int cntt;
 //
 //int kth(int num) {
@@ -139,7 +139,7 @@
 //
 //int build(int l, int r) {
 //    int rt = ++cntt;
-//    segsiz[rt] = 0;
+//    numcnt[rt] = 0;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        ls[rt] = build(l, mid);
@@ -152,7 +152,7 @@
 //    int rt = ++cntt;
 //    ls[rt] = ls[i];
 //    rs[rt] = rs[i];
-//    segsiz[rt] = segsiz[i] + 1;
+//    numcnt[rt] = numcnt[i] + 1;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
@@ -169,7 +169,7 @@
 //        return l;
 //    }
 //    int mid = (l + r) / 2;
-//    int rsize = segsiz[ rs[post] ] - segsiz[ rs[pre] ];
+//    int rsize = numcnt[ rs[post] ] - numcnt[ rs[pre] ];
 //    if (rsize >= jobk) {
 //        return query(jobk, mid + 1, r, rs[pre], rs[post]);
 //    } else {

From 77f464541d1606acf7143f13e8ec3cda058af9e6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 14:48:13 +0800
Subject: [PATCH 0646/1712] modify code

---
 src/class164/Code07_Peaks1.java | 8 +++++++-
 1 file changed, 7 insertions(+), 1 deletion(-)

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index 9500870f1..4c5e6c916 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -46,14 +46,20 @@ public class Code07_Peaks1 {
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
-	// 树上dfs
+	// 节点dfn序号
 	public static int[] dfn = new int[MAXK];
+	// seg[i] = j，代表dfn序号为i的节点，是原始编号为j的节点
 	public static int[] seg = new int[MAXK];
+	// 倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
+	// 子树大小
 	public static int[] siz = new int[MAXK];
+	// dfn计数
 	public static int cntd = 0;
 
 	// 可持久化线段树
+	// 线段树的下标为某个数字，所以是值域线段树
+	// 数值范围[l..r]上，一共有几个数字，就是numcnt的含义
 	public static int[] root = new int[MAXK];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];

From a5130113f1be6fb223de40662675468c64c7162b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 15:05:33 +0800
Subject: [PATCH 0647/1712] modify code

---
 src/class164/Code06_GraphQueries1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class164/Code06_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
index 7c941f849..83771ea7f 100644
--- a/src/class164/Code06_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -25,11 +25,11 @@ public class Code06_GraphQueries1 {
 	public static int MAXH = 20;
 	public static int n, m, q;
 
-	// 所有节点的值，需要记录，线段树也要使用
+	// 节点值的数组，需要记录，线段树也要使用
 	public static int[] node = new int[MAXN];
-	// 所有边，根据删除操作，设置每条边的权值
+	// 所有边的数组，逆序处理删除操作，设置每条边的权值
 	public static int[][] edge = new int[MAXM][3];
-	// 所有操作
+	// 记录所有操作
 	public static int[][] ques = new int[MAXQ][2];
 
 	// 并查集

From 0c6123ce640718a8128aacdcdcbb33267f4faed2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 15:09:28 +0800
Subject: [PATCH 0648/1712] modify code

---
 src/class164/Code06_GraphQueries1.java | 6 +++---
 src/class164/Code06_GraphQueries2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class164/Code06_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
index 83771ea7f..506d9305b 100644
--- a/src/class164/Code06_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -63,15 +63,15 @@ public static void prepare() {
 				edge[ques[i][1]][2] = -1;
 			}
 		}
-		int time = 0;
+		int weight = 0;
 		for (int i = 1; i <= m; i++) {
 			if (edge[i][2] != -1) {
-				edge[i][2] = ++time;
+				edge[i][2] = ++weight;
 			}
 		}
 		for (int i = q; i >= 1; i--) {
 			if (ques[i][0] == 2) {
-				edge[ques[i][1]][2] = ++time;
+				edge[ques[i][1]][2] = ++weight;
 			}
 		}
 	}
diff --git a/src/class164/Code06_GraphQueries2.java b/src/class164/Code06_GraphQueries2.java
index 5de91b5f7..dfd6fe193 100644
--- a/src/class164/Code06_GraphQueries2.java
+++ b/src/class164/Code06_GraphQueries2.java
@@ -58,15 +58,15 @@
 //            edge[ques[i][1]].w = -1;
 //        }
 //    }
-//    int time = 0;
+//    int weight = 0;
 //    for (int i = 1; i <= m; i++) {
 //        if (edge[i].w != -1) {
-//            edge[i].w = ++time;
+//            edge[i].w = ++weight;
 //        }
 //    }
 //    for (int i = q; i >= 1; i--) {
 //        if (ques[i][0] == 2) {
-//            edge[ques[i][1]].w = ++time;
+//            edge[ques[i][1]].w = ++weight;
 //        }
 //    }
 //}

From 45eb116b3a3c01793ce45c0ca09cdc822dfc3988 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 17:03:14 +0800
Subject: [PATCH 0649/1712] modify code

---
 src/class164/Code06_GraphQueries1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class164/Code06_GraphQueries1.java b/src/class164/Code06_GraphQueries1.java
index 506d9305b..8f524ad70 100644
--- a/src/class164/Code06_GraphQueries1.java
+++ b/src/class164/Code06_GraphQueries1.java
@@ -54,7 +54,7 @@ public class Code06_GraphQueries1 {
 	// dfn的计数
 	public static int cntd = 0;
 
-	// 线段树的下标是dfn序号，维护范围内，拥有节点最大值的dfn序号
+	// 线段树的下标是dfn序号，维护范围内，拥有最大点权的dfn序号
 	public static int[] maxValueDfn = new int[MAXN << 2];
 
 	public static void prepare() {
@@ -160,7 +160,7 @@ public static void build(int l, int r, int i) {
 		}
 	}
 
-	// dfn序号为jobi，节点值更新成jobv
+	// dfn序号为jobi，点权更新成jobv
 	public static void update(int jobi, int jobv, int l, int r, int i) {
 		if (l == r) {
 			node[leafseg[jobi]] = jobv;
@@ -175,7 +175,7 @@ public static void update(int jobi, int jobv, int l, int r, int i) {
 		}
 	}
 
-	// dfn范围[jobl..jobr]，哪个节点拥有最大值，返回该节点的dfn序号
+	// dfn范围[jobl..jobr]，哪个节点拥有最大点权，返回该节点的dfn序号
 	public static int query(int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			return maxValueDfn[i];

From e652793a503fc6f7e37374a724e75fb10fd664b0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 17:22:43 +0800
Subject: [PATCH 0650/1712] modify code

---
 src/class164/Code07_Peaks1.java | 38 +++++++++++++++++----------------
 src/class164/Code07_Peaks2.java | 36 ++++++++++++++++---------------
 2 files changed, 39 insertions(+), 35 deletions(-)

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index 4c5e6c916..bbb6c54af 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -46,21 +46,21 @@ public class Code07_Peaks1 {
 	public static int[] nodeKey = new int[MAXK];
 	public static int cntu;
 
-	// 节点dfn序号
-	public static int[] dfn = new int[MAXK];
-	// seg[i] = j，代表dfn序号为i的节点，是原始编号为j的节点
-	public static int[] seg = new int[MAXK];
 	// 倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
-	// 子树大小
-	public static int[] siz = new int[MAXK];
+	// 子树上的叶节点个数
+	public static int[] leafsiz = new int[MAXK];
+	// 子树上叶节点的dfn序号最小值
+	public static int[] leafDfnMin = new int[MAXK];
+	// leafseg[i] = j，表示dfn序号为i的叶节点，原始编号为j
+	public static int[] leafseg = new int[MAXK];
 	// dfn计数
 	public static int cntd = 0;
 
 	// 可持久化线段树
 	// 线段树的下标为某个数字，所以是值域线段树
 	// 数值范围[l..r]上，一共有几个数字，就是numcnt的含义
-	public static int[] root = new int[MAXK];
+	public static int[] root = new int[MAXN];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static int[] numcnt = new int[MAXT];
@@ -131,9 +131,6 @@ public static void kruskalRebuild() {
 	}
 
 	public static void dfs(int u, int fa) {
-		siz[u] = 1;
-		dfn[u] = ++cntd;
-		seg[cntd] = u;
 		stjump[u][0] = fa;
 		for (int p = 1; p < MAXH; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -141,8 +138,17 @@ public static void dfs(int u, int fa) {
 		for (int e = head[u]; e > 0; e = next[e]) {
 			dfs(to[e], u);
 		}
+		if (u <= n) {
+			leafsiz[u] = 1;
+			leafDfnMin[u] = ++cntd;
+			leafseg[cntd] = u;
+		} else {
+			leafsiz[u] = 0;
+			leafDfnMin[u] = n + 1;
+		}
 		for (int e = head[u]; e > 0; e = next[e]) {
-			siz[u] += siz[to[e]];
+			leafsiz[u] += leafsiz[to[e]];
+			leafDfnMin[u] = Math.min(leafDfnMin[u], leafDfnMin[to[e]]);
 		}
 	}
 
@@ -192,7 +198,7 @@ public static int compute(int u, int x, int k) {
 				u = stjump[u][p];
 			}
 		}
-		int idx = query(k, 1, diff, root[dfn[u] - 1], root[dfn[u] + siz[u] - 1]);
+		int idx = query(k, 1, diff, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
 		return sorted[idx];
 	}
 
@@ -217,12 +223,8 @@ public static void main(String[] args) {
 			}
 		}
 		root[0] = build(1, diff);
-		for (int i = 1; i <= cntd; i++) {
-			if (seg[i] <= n) {
-				root[i] = insert(node[seg[i]], 1, diff, root[i - 1]);
-			} else {
-				root[i] = root[i - 1];
-			}
+		for (int i = 1; i <= n; i++) {
+			root[i] = insert(node[leafseg[i]], 1, diff, root[i - 1]);
 		}
 		for (int i = 1, u, x, k, lastAns = 0; i <= q; i++) {
 			u = io.nextInt();
diff --git a/src/class164/Code07_Peaks2.java b/src/class164/Code07_Peaks2.java
index 998e76ba2..c77631155 100644
--- a/src/class164/Code07_Peaks2.java
+++ b/src/class164/Code07_Peaks2.java
@@ -45,13 +45,13 @@
 //int nodeKey[MAXK];
 //int cntu;
 //
-//int dfn[MAXK];
-//int seg[MAXK];
 //int stjump[MAXK][MAXH];
-//int siz[MAXK];
+//int leafsiz[MAXK];
+//int leafDfnMin[MAXK];
+//int leafseg[MAXK];
 //int cntd;
 //
-//int root[MAXK];
+//int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
 //int numcnt[MAXT];
@@ -122,18 +122,24 @@
 //}
 //
 //void dfs(int u, int fa) {
-//    siz[u] = 1;
-//    dfn[u] = ++cntd;
-//    seg[cntd] = u;
 //    stjump[u][0] = fa;
 //    for (int p = 1; p < MAXH; p++) {
-//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 //    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        dfs(to[e], u);
 //    }
+//    if (u <= n) {
+//        leafsiz[u] = 1;
+//        leafDfnMin[u] = ++cntd;
+//        leafseg[cntd] = u;
+//    } else {
+//        leafsiz[u] = 0;
+//        leafDfnMin[u] = n + 1;
+//    }
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        siz[u] += siz[to[e]];
+//        leafsiz[u] += leafsiz[to[e]];
+//        leafDfnMin[u] = min(leafDfnMin[u], leafDfnMin[to[e]]);
 //    }
 //}
 //
@@ -169,7 +175,7 @@
 //        return l;
 //    }
 //    int mid = (l + r) / 2;
-//    int rsize = numcnt[ rs[post] ] - numcnt[ rs[pre] ];
+//    int rsize = numcnt[rs[post]] - numcnt[rs[pre]];
 //    if (rsize >= jobk) {
 //        return query(jobk, mid + 1, r, rs[pre], rs[post]);
 //    } else {
@@ -183,7 +189,7 @@
 //            u = stjump[u][p];
 //        }
 //    }
-//    int idx = query(k, 1, diff, root[dfn[u] - 1], root[dfn[u] + siz[u] - 1]);
+//    int idx = query(k, 1, diff, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
 //    return sorted[idx];
 //}
 //
@@ -205,12 +211,8 @@
 //        }
 //    }
 //    root[0] = build(1, diff);
-//    for (int i = 1; i <= cntd; i++) {
-//        if (seg[i] <= n) {
-//            root[i] = insert(node[seg[i]], 1, diff, root[i - 1]);
-//        } else {
-//            root[i] = root[i - 1];
-//        }
+//    for (int i = 1; i <= n; i++) {
+//        root[i] = insert(node[leafseg[i]], 1, diff, root[i - 1]);
 //    }
 //    for (int i = 1, u, x, k, lastAns = 0; i <= q; i++) {
 //        cin >> u >> x >> k;

From 3cd8e798423bfacb44bef76764c6dbf3b99e6bea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 17:33:11 +0800
Subject: [PATCH 0651/1712] modify code

---
 src/class164/Code07_Peaks1.java | 10 +++++++---
 src/class164/Code07_Peaks2.java |  4 ++--
 2 files changed, 9 insertions(+), 5 deletions(-)

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index bbb6c54af..c7400a28b 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -54,7 +54,7 @@ public class Code07_Peaks1 {
 	public static int[] leafDfnMin = new int[MAXK];
 	// leafseg[i] = j，表示dfn序号为i的叶节点，原始编号为j
 	public static int[] leafseg = new int[MAXK];
-	// dfn计数
+	// dfn的计数
 	public static int cntd = 0;
 
 	// 可持久化线段树
@@ -152,6 +152,7 @@ public static void dfs(int u, int fa) {
 		}
 	}
 
+	// 可持久化线段树的build
 	public static int build(int l, int r) {
 		int rt = ++cntt;
 		numcnt[rt] = 0;
@@ -163,6 +164,7 @@ public static int build(int l, int r) {
 		return rt;
 	}
 
+	// 数值范围[l..r]，加了一个数字jobi，生成新版本的可持久化线段树
 	public static int insert(int jobi, int l, int r, int i) {
 		int rt = ++cntt;
 		ls[rt] = ls[i];
@@ -179,6 +181,8 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
+	// 可持久化线段树，前版本pre，后版本post，两个版本做差，得到数值范围[l..r]的词频
+	// 查询这个数值范围上，第jobk大的数字是什么
 	public static int query(int jobk, int l, int r, int pre, int post) {
 		if (l == r) {
 			return l;
@@ -192,7 +196,7 @@ public static int query(int jobk, int l, int r, int pre, int post) {
 		}
 	}
 
-	public static int compute(int u, int x, int k) {
+	public static int kthMax(int u, int x, int k) {
 		for (int p = MAXH - 1; p >= 0; p--) {
 			if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] <= x) {
 				u = stjump[u][p];
@@ -233,7 +237,7 @@ public static void main(String[] args) {
 			u = (u ^ lastAns) % n + 1;
 			x = x ^ lastAns;
 			k = (k ^ lastAns) % n + 1;
-			lastAns = compute(u, x, k);
+			lastAns = kthMax(u, x, k);
 			if (lastAns == 0) {
 				io.writelnInt(-1);
 			} else {
diff --git a/src/class164/Code07_Peaks2.java b/src/class164/Code07_Peaks2.java
index c77631155..3a2cee25f 100644
--- a/src/class164/Code07_Peaks2.java
+++ b/src/class164/Code07_Peaks2.java
@@ -183,7 +183,7 @@
 //    }
 //}
 //
-//int compute(int u, int x, int k) {
+//int kthMax(int u, int x, int k) {
 //    for (int p = MAXH - 1; p >= 0; p--) {
 //        if (stjump[u][p] > 0 && nodeKey[stjump[u][p]] <= x) {
 //            u = stjump[u][p];
@@ -219,7 +219,7 @@
 //        u = ((u ^ lastAns) % n) + 1;
 //        x = x ^ lastAns;
 //        k = ((k ^ lastAns) % n) + 1;
-//        lastAns = compute(u, x, k);
+//        lastAns = kthMax(u, x, k);
 //        if (lastAns == 0) {
 //            cout << -1 << "\n";
 //        } else {

From d6d3302a8ba8c719e628adfdfbbab2a4bb8b5f90 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 17:36:34 +0800
Subject: [PATCH 0652/1712] modify code

---
 src/class164/Code07_Peaks1.java | 17 ++++++++---------
 src/class164/Code07_Peaks2.java | 17 ++++++++---------
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index c7400a28b..d9d5b17d6 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -28,11 +28,10 @@ public class Code07_Peaks1 {
 	public static int MAXM = 500001;
 	public static int MAXT = MAXN * 40;
 	public static int MAXH = 20;
-	public static int n, m, q;
+	public static int n, m, q, s;
 
 	public static int[] node = new int[MAXN];
 	public static int[] sorted = new int[MAXN];
-	public static int diff;
 	public static int[][] edge = new int[MAXM][3];
 
 	// 并查集
@@ -67,7 +66,7 @@ public class Code07_Peaks1 {
 	public static int cntt = 0;
 
 	public static int kth(int num) {
-		int left = 1, right = diff, mid;
+		int left = 1, right = s, mid;
 		while (left <= right) {
 			mid = (left + right) / 2;
 			if (sorted[mid] == num) {
@@ -87,10 +86,10 @@ public static void prepare() {
 		}
 		sorted[n + 1] = 0;
 		Arrays.sort(sorted, 1, n + 2);
-		diff = 1;
+		s = 1;
 		for (int i = 2; i <= n + 1; i++) {
-			if (sorted[diff] != sorted[i]) {
-				sorted[++diff] = sorted[i];
+			if (sorted[s] != sorted[i]) {
+				sorted[++s] = sorted[i];
 			}
 		}
 		for (int i = 1; i <= n; i++) {
@@ -202,7 +201,7 @@ public static int kthMax(int u, int x, int k) {
 				u = stjump[u][p];
 			}
 		}
-		int idx = query(k, 1, diff, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
+		int idx = query(k, 1, s, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
 		return sorted[idx];
 	}
 
@@ -226,9 +225,9 @@ public static void main(String[] args) {
 				dfs(i, 0);
 			}
 		}
-		root[0] = build(1, diff);
+		root[0] = build(1, s);
 		for (int i = 1; i <= n; i++) {
-			root[i] = insert(node[leafseg[i]], 1, diff, root[i - 1]);
+			root[i] = insert(node[leafseg[i]], 1, s, root[i - 1]);
 		}
 		for (int i = 1, u, x, k, lastAns = 0; i <= q; i++) {
 			u = io.nextInt();
diff --git a/src/class164/Code07_Peaks2.java b/src/class164/Code07_Peaks2.java
index 3a2cee25f..2b764c1f6 100644
--- a/src/class164/Code07_Peaks2.java
+++ b/src/class164/Code07_Peaks2.java
@@ -30,10 +30,9 @@
 //const int MAXM = 500001;
 //const int MAXT = MAXN * 40;
 //const int MAXH = 20;
-//int n, m, q;
+//int n, m, q, s;
 //int node[MAXN];
 //int sorted[MAXN];
-//int diff;
 //Edge edge[MAXM];
 //
 //int father[MAXK];
@@ -58,7 +57,7 @@
 //int cntt;
 //
 //int kth(int num) {
-//    int left = 1, right = diff;
+//    int left = 1, right = s;
 //    while (left <= right) {
 //        int mid = (left + right) / 2;
 //        if (sorted[mid] == num) {
@@ -78,10 +77,10 @@
 //    }
 //    sorted[n + 1] = 0;
 //    sort(sorted + 1, sorted + n + 2);
-//    diff = 1;
+//    s = 1;
 //    for (int i = 2; i <= n + 1; i++) {
-//        if (sorted[diff] != sorted[i]) {
-//            sorted[++diff] = sorted[i];
+//        if (sorted[s] != sorted[i]) {
+//            sorted[++s] = sorted[i];
 //        }
 //    }
 //    for (int i = 1; i <= n; i++) {
@@ -189,7 +188,7 @@
 //            u = stjump[u][p];
 //        }
 //    }
-//    int idx = query(k, 1, diff, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
+//    int idx = query(k, 1, s, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
 //    return sorted[idx];
 //}
 //
@@ -210,9 +209,9 @@
 //            dfs(i, 0);
 //        }
 //    }
-//    root[0] = build(1, diff);
+//    root[0] = build(1, s);
 //    for (int i = 1; i <= n; i++) {
-//        root[i] = insert(node[leafseg[i]], 1, diff, root[i - 1]);
+//        root[i] = insert(node[leafseg[i]], 1, s, root[i - 1]);
 //    }
 //    for (int i = 1, u, x, k, lastAns = 0; i <= q; i++) {
 //        cin >> u >> x >> k;

From 0f712482873b23807eefef7e62b1939a04148cb8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 17:39:50 +0800
Subject: [PATCH 0653/1712] modify code

---
 src/class164/Code07_Peaks1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index d9d5b17d6..af5c31e30 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -84,6 +84,9 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			sorted[i] = node[i];
 		}
+		// 加入0这个数值，这个数值一定排第1名
+		// 如果第k大不存在，那么查到的第k大点权为0，可以用作判断
+		// 题目说了所有点权都大于0，所以不会有问题
 		sorted[n + 1] = 0;
 		Arrays.sort(sorted, 1, n + 2);
 		s = 1;

From 7be47170ebbab01e7f2731415760811cf2b87b03 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 17:41:10 +0800
Subject: [PATCH 0654/1712] modify code

---
 src/class164/Code07_Peaks1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index af5c31e30..9d459d7bf 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -84,9 +84,9 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			sorted[i] = node[i];
 		}
-		// 加入0这个数值，这个数值一定排第1名
-		// 如果第k大不存在，那么查到的第k大点权为0，可以用作判断
-		// 题目说了所有点权都大于0，所以不会有问题
+		// 加入0这个数值，0这个数值一定排第1名
+		// 如果第k大不存在，那么会查出第1名的数值0，可以用作判断
+		// 题目保证所有点权都大于0，所以这么做不会有问题
 		sorted[n + 1] = 0;
 		Arrays.sort(sorted, 1, n + 2);
 		s = 1;

From 9a74687333533c2230e1c9d4d6d2a4f2c94c38b0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Apr 2025 19:02:45 +0800
Subject: [PATCH 0655/1712] modify code

---
 ...70\345\205\263\351\242\230\347\233\256.pptx" | Bin 0 -> 54142 bytes
 src/class164/Code07_Peaks1.java                 |  11 +++++------
 src/class164/Code07_Peaks2.java                 |   8 +++++---
 3 files changed, 10 insertions(+), 9 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..5bb5c6ddf8e296952cf831e9e94f92b06db290b1
GIT binary patch
literal 54142
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

literal 0
HcmV?d00001

diff --git a/src/class164/Code07_Peaks1.java b/src/class164/Code07_Peaks1.java
index 9d459d7bf..b21193373 100644
--- a/src/class164/Code07_Peaks1.java
+++ b/src/class164/Code07_Peaks1.java
@@ -84,13 +84,9 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			sorted[i] = node[i];
 		}
-		// 加入0这个数值，0这个数值一定排第1名
-		// 如果第k大不存在，那么会查出第1名的数值0，可以用作判断
-		// 题目保证所有点权都大于0，所以这么做不会有问题
-		sorted[n + 1] = 0;
-		Arrays.sort(sorted, 1, n + 2);
+		Arrays.sort(sorted, 1, n + 1);
 		s = 1;
-		for (int i = 2; i <= n + 1; i++) {
+		for (int i = 2; i <= n; i++) {
 			if (sorted[s] != sorted[i]) {
 				sorted[++s] = sorted[i];
 			}
@@ -204,6 +200,9 @@ public static int kthMax(int u, int x, int k) {
 				u = stjump[u][p];
 			}
 		}
+		if (leafsiz[u] < k) {
+			return 0;
+		}
 		int idx = query(k, 1, s, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
 		return sorted[idx];
 	}
diff --git a/src/class164/Code07_Peaks2.java b/src/class164/Code07_Peaks2.java
index 2b764c1f6..d3719e31c 100644
--- a/src/class164/Code07_Peaks2.java
+++ b/src/class164/Code07_Peaks2.java
@@ -75,10 +75,9 @@
 //    for (int i = 1; i <= n; i++) {
 //        sorted[i] = node[i];
 //    }
-//    sorted[n + 1] = 0;
-//    sort(sorted + 1, sorted + n + 2);
+//    sort(sorted + 1, sorted + n + 1);
 //    s = 1;
-//    for (int i = 2; i <= n + 1; i++) {
+//    for (int i = 2; i <= n; i++) {
 //        if (sorted[s] != sorted[i]) {
 //            sorted[++s] = sorted[i];
 //        }
@@ -188,6 +187,9 @@
 //            u = stjump[u][p];
 //        }
 //    }
+//    if(leafsiz[u] < k) {
+//        return 0;
+//    }
 //    int idx = query(k, 1, s, root[leafDfnMin[u] - 1], root[leafDfnMin[u] + leafsiz[u] - 1]);
 //    return sorted[idx];
 //}

From 7c9e88d420d05809cdb2eb031f302f4c1a46e7b6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Apr 2025 22:07:01 +0800
Subject: [PATCH 0656/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java | 147 ++++++++++++++++++
 src/class165/Code01_PersistentUnionFind2.java | 126 +++++++++++++++
 2 files changed, 273 insertions(+)
 create mode 100644 src/class165/Code01_PersistentUnionFind1.java
 create mode 100644 src/class165/Code01_PersistentUnionFind2.java

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
new file mode 100644
index 000000000..6da25a3c4
--- /dev/null
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -0,0 +1,147 @@
+package class165;
+
+// 可持久化并查集，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3402
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_PersistentUnionFind1 {
+
+	public static int MAXM = 200001;
+	public static int MAXT = 8000001;
+	public static int n, m;
+
+	public static int[] rootfa = new int[MAXM];
+	public static int[] rootsiz = new int[MAXM];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] val = new int[MAXT];
+	public static int cnt = 0;
+
+	public static int buildfa(int l, int r) {
+		int rt = ++cnt;
+		if (l == r) {
+			val[rt] = l;
+		} else {
+			int mid = (l + r) / 2;
+			ls[rt] = buildfa(l, mid);
+			rs[rt] = buildfa(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int buildsiz(int l, int r) {
+		int rt = ++cnt;
+		if (l == r) {
+			val[rt] = 1;
+		} else {
+			int mid = (l + r) / 2;
+			ls[rt] = buildsiz(l, mid);
+			rs[rt] = buildsiz(mid + 1, r);
+		}
+		return rt;
+	}
+
+	public static int update(int jobi, int jobv, int l, int r, int i) {
+		int rt = ++cnt;
+		ls[rt] = ls[i];
+		rs[rt] = rs[i];
+		if (l == r) {
+			val[rt] = jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+			} else {
+				rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static int query(int jobi, int l, int r, int i) {
+		if (l == r) {
+			return val[i];
+		}
+		int mid = (l + r) / 2;
+		if (jobi <= mid) {
+			return query(jobi, l, mid, ls[i]);
+		} else {
+			return query(jobi, mid + 1, r, rs[i]);
+		}
+	}
+
+	public static int find(int x, int version) {
+		int fa = query(x, 1, n, rootfa[version]);
+		if (x == fa) {
+			return x;
+		}
+		return find(fa, version);
+	}
+
+	public static void merge(int x, int y, int version) {
+		int fx = find(x, version);
+		int fy = find(y, version);
+		if (fx != fy) {
+			int xsiz = query(fx, 1, n, rootsiz[version]);
+			int ysiz = query(fy, 1, n, rootsiz[version]);
+			if (xsiz >= ysiz) {
+				rootfa[version] = update(fy, fx, 1, n, rootfa[version]);
+				rootsiz[version] = update(fx, xsiz + ysiz, 1, n, rootsiz[version]);
+			} else {
+				rootfa[version] = update(fx, fy, 1, n, rootfa[version]);
+				rootsiz[version] = update(fy, xsiz + ysiz, 1, n, rootsiz[version]);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		rootfa[0] = buildfa(1, n);
+		rootsiz[0] = buildsiz(1, n);
+		for (int version = 1, op, x, y; version <= m; version++) {
+			in.nextToken();
+			op = (int) in.nval;
+			rootfa[version] = rootfa[version - 1];
+			rootsiz[version] = rootsiz[version - 1];
+			if (op == 1) {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				merge(x, y, version);
+			} else if (op == 2) {
+				in.nextToken();
+				x = (int) in.nval;
+				rootfa[version] = rootfa[x];
+				rootsiz[version] = rootsiz[x];
+			} else {
+				in.nextToken();
+				x = (int) in.nval;
+				in.nextToken();
+				y = (int) in.nval;
+				if (find(x, version) == find(y, version)) {
+					out.println(1);
+				} else {
+					out.println(0);
+				}
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class165/Code01_PersistentUnionFind2.java b/src/class165/Code01_PersistentUnionFind2.java
new file mode 100644
index 000000000..899bedad3
--- /dev/null
+++ b/src/class165/Code01_PersistentUnionFind2.java
@@ -0,0 +1,126 @@
+package class165;
+
+// 可持久化并查集，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3402
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <iostream>
+//
+//using namespace std;
+//
+//const int MAXM = 200001;
+//const int MAXT = 8000001;
+//int n, m;
+//int rootfa[MAXM];
+//int rootsiz[MAXM];
+//int ls[MAXT];
+//int rs[MAXT];
+//int val[MAXT];
+//int cnt = 0;
+//
+//int buildfa(int l, int r) {
+//    int rt = ++cnt;
+//    if (l == r) {
+//        val[rt] = l;
+//    } else {
+//        int mid = (l + r) / 2;
+//        ls[rt] = buildfa(l, mid);
+//        rs[rt] = buildfa(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int buildsiz(int l, int r) {
+//    int rt = ++cnt;
+//    if (l == r) {
+//        val[rt] = 1;
+//    } else {
+//        int mid = (l + r) / 2;
+//        ls[rt] = buildsiz(l, mid);
+//        rs[rt] = buildsiz(mid + 1, r);
+//    }
+//    return rt;
+//}
+//
+//int update(int jobi, int jobv, int l, int r, int i) {
+//    int rt = ++cnt;
+//    ls[rt] = ls[i];
+//    rs[rt] = rs[i];
+//    if (l == r) {
+//        val[rt] = jobv;
+//    } else {
+//        int mid = (l + r) / 2;
+//        if (jobi <= mid) {
+//            ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//int query(int jobi, int l, int r, int i) {
+//    if (l == r) {
+//        return val[i];
+//    }
+//    int mid = (l + r) / 2;
+//    if (jobi <= mid) {
+//        return query(jobi, l, mid, ls[i]);
+//    } else {
+//        return query(jobi, mid + 1, r, rs[i]);
+//    }
+//}
+//
+//int find(int x, int version) {
+//    int fa = query(x, 1, n, rootfa[version]);
+//    if (x == fa) {
+//        return x;
+//    }
+//    return find(fa, version);
+//}
+//
+//void merge(int x, int y, int version) {
+//    int fx = find(x, version);
+//    int fy = find(y, version);
+//    if (fx != fy) {
+//        int xsiz = query(fx, 1, n, rootsiz[version]);
+//        int ysiz = query(fy, 1, n, rootsiz[version]);
+//        if (xsiz >= ysiz) {
+//            rootfa[version] = update(fy, fx, 1, n, rootfa[version]);
+//            rootsiz[version] = update(fx, xsiz + ysiz, 1, n, rootsiz[version]);
+//        } else {
+//            rootfa[version] = update(fx, fy, 1, n, rootfa[version]);
+//            rootsiz[version] = update(fy, xsiz + ysiz, 1, n, rootsiz[version]);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    rootfa[0] = buildfa(1, n);
+//    rootsiz[0] = buildsiz(1, n);
+//    for (int version = 1, op, x, y; version <= m; version++) {
+//        cin >> op;
+//        rootfa[version] = rootfa[version - 1];
+//        rootsiz[version] = rootsiz[version - 1];
+//        if (op == 1) {
+//            cin >> x >> y;
+//            merge(x, y, version);
+//        } else if (op == 2) {
+//            cin >> x;
+//            rootfa[version] = rootfa[x];
+//            rootsiz[version] = rootsiz[x];
+//        } else {
+//            cin >> x >> y;
+//            if (find(x, version) == find(y, version)) {
+//                cout << 1 << "\n";
+//            } else {
+//                cout << 0 << "\n";
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 0b6762486e608bcd7c6b8e54b37dc6e8dec6f0b4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 3 Apr 2025 16:29:34 +0800
Subject: [PATCH 0657/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java | 38 +++++++++----------
 src/class165/Code01_PersistentUnionFind2.java | 38 +++++++++----------
 2 files changed, 38 insertions(+), 38 deletions(-)

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
index 6da25a3c4..dbc318f70 100644
--- a/src/class165/Code01_PersistentUnionFind1.java
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -77,26 +77,26 @@ public static int query(int jobi, int l, int r, int i) {
 		}
 	}
 
-	public static int find(int x, int version) {
-		int fa = query(x, 1, n, rootfa[version]);
+	public static int find(int x, int v) {
+		int fa = query(x, 1, n, rootfa[v]);
 		if (x == fa) {
 			return x;
 		}
-		return find(fa, version);
+		return find(fa, v);
 	}
 
-	public static void merge(int x, int y, int version) {
-		int fx = find(x, version);
-		int fy = find(y, version);
+	public static void merge(int x, int y, int v) {
+		int fx = find(x, v);
+		int fy = find(y, v);
 		if (fx != fy) {
-			int xsiz = query(fx, 1, n, rootsiz[version]);
-			int ysiz = query(fy, 1, n, rootsiz[version]);
+			int xsiz = query(fx, 1, n, rootsiz[v]);
+			int ysiz = query(fy, 1, n, rootsiz[v]);
 			if (xsiz >= ysiz) {
-				rootfa[version] = update(fy, fx, 1, n, rootfa[version]);
-				rootsiz[version] = update(fx, xsiz + ysiz, 1, n, rootsiz[version]);
+				rootfa[v] = update(fy, fx, 1, n, rootfa[v]);
+				rootsiz[v] = update(fx, xsiz + ysiz, 1, n, rootsiz[v]);
 			} else {
-				rootfa[version] = update(fx, fy, 1, n, rootfa[version]);
-				rootsiz[version] = update(fy, xsiz + ysiz, 1, n, rootsiz[version]);
+				rootfa[v] = update(fx, fy, 1, n, rootfa[v]);
+				rootsiz[v] = update(fy, xsiz + ysiz, 1, n, rootsiz[v]);
 			}
 		}
 	}
@@ -111,28 +111,28 @@ public static void main(String[] args) throws IOException {
 		m = (int) in.nval;
 		rootfa[0] = buildfa(1, n);
 		rootsiz[0] = buildsiz(1, n);
-		for (int version = 1, op, x, y; version <= m; version++) {
+		for (int v = 1, op, x, y; v <= m; v++) {
 			in.nextToken();
 			op = (int) in.nval;
-			rootfa[version] = rootfa[version - 1];
-			rootsiz[version] = rootsiz[version - 1];
+			rootfa[v] = rootfa[v - 1];
+			rootsiz[v] = rootsiz[v - 1];
 			if (op == 1) {
 				in.nextToken();
 				x = (int) in.nval;
 				in.nextToken();
 				y = (int) in.nval;
-				merge(x, y, version);
+				merge(x, y, v);
 			} else if (op == 2) {
 				in.nextToken();
 				x = (int) in.nval;
-				rootfa[version] = rootfa[x];
-				rootsiz[version] = rootsiz[x];
+				rootfa[v] = rootfa[x];
+				rootsiz[v] = rootsiz[x];
 			} else {
 				in.nextToken();
 				x = (int) in.nval;
 				in.nextToken();
 				y = (int) in.nval;
-				if (find(x, version) == find(y, version)) {
+				if (find(x, v) == find(y, v)) {
 					out.println(1);
 				} else {
 					out.println(0);
diff --git a/src/class165/Code01_PersistentUnionFind2.java b/src/class165/Code01_PersistentUnionFind2.java
index 899bedad3..500e67b0f 100644
--- a/src/class165/Code01_PersistentUnionFind2.java
+++ b/src/class165/Code01_PersistentUnionFind2.java
@@ -72,26 +72,26 @@
 //    }
 //}
 //
-//int find(int x, int version) {
-//    int fa = query(x, 1, n, rootfa[version]);
+//int find(int x, int v) {
+//    int fa = query(x, 1, n, rootfa[v]);
 //    if (x == fa) {
 //        return x;
 //    }
-//    return find(fa, version);
+//    return find(fa, v);
 //}
 //
-//void merge(int x, int y, int version) {
-//    int fx = find(x, version);
-//    int fy = find(y, version);
+//void merge(int x, int y, int v) {
+//    int fx = find(x, v);
+//    int fy = find(y, v);
 //    if (fx != fy) {
-//        int xsiz = query(fx, 1, n, rootsiz[version]);
-//        int ysiz = query(fy, 1, n, rootsiz[version]);
+//        int xsiz = query(fx, 1, n, rootsiz[v]);
+//        int ysiz = query(fy, 1, n, rootsiz[v]);
 //        if (xsiz >= ysiz) {
-//            rootfa[version] = update(fy, fx, 1, n, rootfa[version]);
-//            rootsiz[version] = update(fx, xsiz + ysiz, 1, n, rootsiz[version]);
+//            rootfa[v] = update(fy, fx, 1, n, rootfa[v]);
+//            rootsiz[v] = update(fx, xsiz + ysiz, 1, n, rootsiz[v]);
 //        } else {
-//            rootfa[version] = update(fx, fy, 1, n, rootfa[version]);
-//            rootsiz[version] = update(fy, xsiz + ysiz, 1, n, rootsiz[version]);
+//            rootfa[v] = update(fx, fy, 1, n, rootfa[v]);
+//            rootsiz[v] = update(fy, xsiz + ysiz, 1, n, rootsiz[v]);
 //        }
 //    }
 //}
@@ -102,20 +102,20 @@
 //    cin >> n >> m;
 //    rootfa[0] = buildfa(1, n);
 //    rootsiz[0] = buildsiz(1, n);
-//    for (int version = 1, op, x, y; version <= m; version++) {
+//    for (int v = 1, op, x, y; v <= m; v++) {
 //        cin >> op;
-//        rootfa[version] = rootfa[version - 1];
-//        rootsiz[version] = rootsiz[version - 1];
+//        rootfa[v] = rootfa[v - 1];
+//        rootsiz[v] = rootsiz[v - 1];
 //        if (op == 1) {
 //            cin >> x >> y;
-//            merge(x, y, version);
+//            merge(x, y, v);
 //        } else if (op == 2) {
 //            cin >> x;
-//            rootfa[version] = rootfa[x];
-//            rootsiz[version] = rootsiz[x];
+//            rootfa[v] = rootfa[x];
+//            rootsiz[v] = rootsiz[x];
 //        } else {
 //            cin >> x >> y;
-//            if (find(x, version) == find(y, version)) {
+//            if (find(x, v) == find(y, v)) {
 //                cout << 1 << "\n";
 //            } else {
 //                cout << 0 << "\n";

From 6dd32ffe3892e633a5b9714db88f9c561637088d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 3 Apr 2025 16:43:45 +0800
Subject: [PATCH 0658/1712] modify code

---
 src/class165/Code01_PersistentUnionFind2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class165/Code01_PersistentUnionFind2.java b/src/class165/Code01_PersistentUnionFind2.java
index 500e67b0f..7340825aa 100644
--- a/src/class165/Code01_PersistentUnionFind2.java
+++ b/src/class165/Code01_PersistentUnionFind2.java
@@ -5,7 +5,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //

From 3cfed78132f85d59672ad4650aab262d9cdee65e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 3 Apr 2025 18:39:20 +0800
Subject: [PATCH 0659/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java |   9 +-
 src/class165/Code01_PersistentUnionFind2.java |   9 +-
 src/class165/Code02_UndoUnionFind1.java       | 144 ++++++++++++++++++
 src/class165/Code02_UndoUnionFind2.java       | 129 ++++++++++++++++
 4 files changed, 283 insertions(+), 8 deletions(-)
 create mode 100644 src/class165/Code02_UndoUnionFind1.java
 create mode 100644 src/class165/Code02_UndoUnionFind2.java

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
index dbc318f70..29379ba16 100644
--- a/src/class165/Code01_PersistentUnionFind1.java
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -1,6 +1,6 @@
 package class165;
 
-// 可持久化并查集，java版
+// 可持久化并查集模版题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3402
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -79,10 +79,11 @@ public static int query(int jobi, int l, int r, int i) {
 
 	public static int find(int x, int v) {
 		int fa = query(x, 1, n, rootfa[v]);
-		if (x == fa) {
-			return x;
+		while (x != fa) {
+			x = fa;
+			fa = query(x, 1, n, rootfa[v]);
 		}
-		return find(fa, v);
+		return x;
 	}
 
 	public static void merge(int x, int y, int v) {
diff --git a/src/class165/Code01_PersistentUnionFind2.java b/src/class165/Code01_PersistentUnionFind2.java
index 7340825aa..6882f8b7c 100644
--- a/src/class165/Code01_PersistentUnionFind2.java
+++ b/src/class165/Code01_PersistentUnionFind2.java
@@ -1,6 +1,6 @@
 package class165;
 
-// 可持久化并查集，C++版
+// 可持久化并查集模版题，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3402
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -74,10 +74,11 @@
 //
 //int find(int x, int v) {
 //    int fa = query(x, 1, n, rootfa[v]);
-//    if (x == fa) {
-//        return x;
+//    while(x != fa) {
+//        x = fa;
+//        fa = query(x, 1, n, rootfa[v]);
 //    }
-//    return find(fa, v);
+//    return x;
 //}
 //
 //void merge(int x, int y, int v) {
diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
new file mode 100644
index 000000000..517e9ef81
--- /dev/null
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -0,0 +1,144 @@
+package class165;
+
+// 可撤销并查集模版题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
+// 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code02_UndoUnionFind1 {
+
+	public static int MAXN = 200001;
+	public static int[] a = new int[MAXN];
+	public static int[] b = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cnt;
+
+	public static int[] father = new int[MAXN];
+	public static int[] ncnt = new int[MAXN];
+	public static int[] ecnt = new int[MAXN];
+
+	public static int[][] opstack = new int[MAXN][2];
+	public static int stacksiz = 0;
+
+	public static int[] ans = new int[MAXN];
+	public static int ball = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void merge(int h1, int h2) {
+		int big, small;
+		if (ncnt[h1] >= ncnt[h2]) {
+			big = h1;
+			small = h2;
+		} else {
+			big = h2;
+			small = h1;
+		}
+		stacksiz++;
+		opstack[stacksiz][0] = big;
+		opstack[stacksiz][1] = small;
+		father[small] = big;
+		ncnt[big] += ncnt[small];
+		ecnt[big] += ecnt[small] + 1;
+	}
+
+	public static void undo() {
+		int big = opstack[stacksiz][0];
+		int small = opstack[stacksiz][1];
+		stacksiz--;
+		father[small] = small;
+		ncnt[big] -= ncnt[small];
+		ecnt[big] -= ecnt[small] + 1;
+	}
+
+	public static void dfs(int u, int fa) {
+		int h1 = find(a[u]), h2 = find(b[u]);
+		boolean merged = false;
+		int add = 0;
+		if (h1 == h2) {
+			ecnt[h1]++;
+			if (ncnt[h1] == ecnt[h1]) {
+				ball++;
+				add = 1;
+			}
+		} else {
+			if (ecnt[h1] < ncnt[h1] || ecnt[h2] < ncnt[h2]) {
+				ball++;
+				add = 1;
+			}
+			merge(h1, h2);
+			merged = true;
+		}
+		if (u != 1) {
+			ans[u] = ball;
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != fa) {
+				dfs(to[e], u);
+			}
+		}
+		if (merged) {
+			undo();
+		} else {
+			ecnt[h1]--;
+		}
+		ball -= add;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		int n = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			a[i] = (int) in.nval;
+			in.nextToken();
+			b[i] = (int) in.nval;
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			ncnt[i] = 1;
+			ecnt[i] = 0;
+		}
+		dfs(1, 0);
+		for (int i = 2; i < n; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println(ans[n]);
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
new file mode 100644
index 000000000..67a114701
--- /dev/null
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -0,0 +1,129 @@
+package class165;
+
+// 可撤销并查集模版题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
+// 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//int a[MAXN];
+//int b[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cnt;
+//
+//int father[MAXN];
+//int ncnt[MAXN];
+//int ecnt[MAXN];
+//
+//int opstack[MAXN][2];
+//int stacksiz = 0;
+//
+//int ans[MAXN];
+//int ball = 0;
+//
+//void addEdge(int u, int v) {
+//	nxt[++cnt] = head[u];
+//	to[cnt] = v;
+//    head[u] = cnt;
+//}
+//
+//int find(int i) {
+//	while(i != father[i]) {
+//		i = father[i];
+//	}
+//	return i;
+//}
+//
+//void merge(int h1, int h2) {
+//    int big, small;
+//    if (ncnt[h1] >= ncnt[h2]) {
+//        big = h1;
+//        small = h2;
+//    } else {
+//        big = h2;
+//        small = h1;
+//    }
+//    stacksiz++;
+//    opstack[stacksiz][0] = big;
+//    opstack[stacksiz][1] = small;
+//    father[small] = big;
+//    ncnt[big] += ncnt[small];
+//    ecnt[big] += ecnt[small] + 1;
+//}
+//
+//void undo() {
+//    int big = opstack[stacksiz][0];
+//    int small = opstack[stacksiz][1];
+//    stacksiz--;
+//    father[small] = small;
+//    ncnt[big] -= ncnt[small];
+//    ecnt[big] -= ecnt[small] + 1;
+//}
+//
+//void dfs(int u, int fa) {
+//    int h1 = find(a[u]), h2 = find(b[u]);
+//    bool merged = false;
+//    int add = 0;
+//    if (h1 == h2) {
+//        ecnt[h1]++;
+//        if (ncnt[h1] == ecnt[h1]) {
+//            ball++;
+//            add = 1;
+//        }
+//    } else {
+//        if (ecnt[h1] < ncnt[h1] || ecnt[h2] < ncnt[h2]) {
+//            ball++;
+//            add = 1;
+//        }
+//        merge(h1, h2);
+//        merged = true;
+//    }
+//    if (u != 1) {
+//        ans[u] = ball;
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        if (to[e] != fa) {
+//            dfs(to[e], u);
+//        }
+//    }
+//    if (merged) {
+//        undo();
+//    } else {
+//        ecnt[h1]--;
+//    }
+//    ball -= add;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n;
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> a[i] >> b[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        ncnt[i] = 1;
+//        ecnt[i] = 0;
+//    }
+//    dfs(1, 0);
+//    for (int i = 2; i < n; i++) {
+//        cout << ans[i] << " ";
+//    }
+//    cout << ans[n] << "\n";
+//    return 0;
+//}
\ No newline at end of file

From 16475e67795a2483fb8789068c25817b2dc21291 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 3 Apr 2025 18:44:17 +0800
Subject: [PATCH 0660/1712] modify code

---
 src/class165/Code02_UndoUnionFind1.java | 6 +++---
 src/class165/Code02_UndoUnionFind2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index 517e9ef81..c45b0cb2c 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -55,12 +55,12 @@ public static void merge(int h1, int h2) {
 			big = h2;
 			small = h1;
 		}
-		stacksiz++;
-		opstack[stacksiz][0] = big;
-		opstack[stacksiz][1] = small;
 		father[small] = big;
 		ncnt[big] += ncnt[small];
 		ecnt[big] += ecnt[small] + 1;
+		stacksiz++;
+		opstack[stacksiz][0] = big;
+		opstack[stacksiz][1] = small;
 	}
 
 	public static void undo() {
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index 67a114701..df5399bdf 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -51,12 +51,12 @@
 //        big = h2;
 //        small = h1;
 //    }
-//    stacksiz++;
-//    opstack[stacksiz][0] = big;
-//    opstack[stacksiz][1] = small;
 //    father[small] = big;
 //    ncnt[big] += ncnt[small];
 //    ecnt[big] += ecnt[small] + 1;
+//    stacksiz++;
+//    opstack[stacksiz][0] = big;
+//    opstack[stacksiz][1] = small;
 //}
 //
 //void undo() {

From 1446f6f237009e57b81baac374482f9683c91b8b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 3 Apr 2025 19:11:30 +0800
Subject: [PATCH 0661/1712] modify code

---
 ...doUnionFind1.java => Code03_BallCollector1.java} | 13 ++++++-------
 ...doUnionFind2.java => Code03_BallCollector2.java} |  9 ++++-----
 2 files changed, 10 insertions(+), 12 deletions(-)
 rename src/class165/{Code02_UndoUnionFind1.java => Code03_BallCollector1.java} (92%)
 rename src/class165/{Code02_UndoUnionFind2.java => Code03_BallCollector2.java} (94%)

diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code03_BallCollector1.java
similarity index 92%
rename from src/class165/Code02_UndoUnionFind1.java
rename to src/class165/Code03_BallCollector1.java
index c45b0cb2c..cee9ee25b 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code03_BallCollector1.java
@@ -1,6 +1,6 @@
 package class165;
 
-// 可撤销并查集模版题，java版
+// 选球，java版
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
 // 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -12,11 +12,10 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code02_UndoUnionFind1 {
+public class Code03_BallCollector1 {
 
 	public static int MAXN = 200001;
-	public static int[] a = new int[MAXN];
-	public static int[] b = new int[MAXN];
+	public static int[][] arr = new int[MAXN][2];
 
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
@@ -73,7 +72,7 @@ public static void undo() {
 	}
 
 	public static void dfs(int u, int fa) {
-		int h1 = find(a[u]), h2 = find(b[u]);
+		int h1 = find(arr[u][0]), h2 = find(arr[u][1]);
 		boolean merged = false;
 		int add = 0;
 		if (h1 == h2) {
@@ -114,9 +113,9 @@ public static void main(String[] args) throws IOException {
 		int n = (int) in.nval;
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			a[i] = (int) in.nval;
+			arr[i][0] = (int) in.nval;
 			in.nextToken();
-			b[i] = (int) in.nval;
+			arr[i][1] = (int) in.nval;
 		}
 		for (int i = 1, u, v; i < n; i++) {
 			in.nextToken();
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code03_BallCollector2.java
similarity index 94%
rename from src/class165/Code02_UndoUnionFind2.java
rename to src/class165/Code03_BallCollector2.java
index df5399bdf..7aeaf5af1 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code03_BallCollector2.java
@@ -1,6 +1,6 @@
 package class165;
 
-// 可撤销并查集模版题，C++版
+// 选球，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
 // 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -11,8 +11,7 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//int a[MAXN];
-//int b[MAXN];
+//int arr[MAXN][2];
 //
 //int head[MAXN];
 //int nxt[MAXN << 1];
@@ -69,7 +68,7 @@
 //}
 //
 //void dfs(int u, int fa) {
-//    int h1 = find(a[u]), h2 = find(b[u]);
+//    int h1 = find(arr[u][0]), h2 = find(arr[u][1]);
 //    bool merged = false;
 //    int add = 0;
 //    if (h1 == h2) {
@@ -108,7 +107,7 @@
 //    int n;
 //    cin >> n;
 //    for (int i = 1; i <= n; i++) {
-//        cin >> a[i] >> b[i];
+//        cin >> arr[i][0] >> arr[i][1];
 //    }
 //    for (int i = 1, u, v; i < n; i++) {
 //        cin >> u >> v;

From 71d7e87c586b6983d6e45a373d168dbfe16251fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 3 Apr 2025 23:47:03 +0800
Subject: [PATCH 0662/1712] modify code

---
 ...ector1.java => Code02_UndoUnionFind1.java} | 71 ++++++++++---------
 ...ector2.java => Code02_UndoUnionFind2.java} | 71 ++++++++++---------
 2 files changed, 74 insertions(+), 68 deletions(-)
 rename src/class165/{Code03_BallCollector1.java => Code02_UndoUnionFind1.java} (69%)
 rename src/class165/{Code03_BallCollector2.java => Code02_UndoUnionFind2.java} (62%)

diff --git a/src/class165/Code03_BallCollector1.java b/src/class165/Code02_UndoUnionFind1.java
similarity index 69%
rename from src/class165/Code03_BallCollector1.java
rename to src/class165/Code02_UndoUnionFind1.java
index cee9ee25b..f4b41cf88 100644
--- a/src/class165/Code03_BallCollector1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -1,6 +1,6 @@
 package class165;
 
-// 选球，java版
+// 可撤销并查集模版题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
 // 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -12,7 +12,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code03_BallCollector1 {
+public class Code02_UndoUnionFind1 {
 
 	public static int MAXN = 200001;
 	public static int[][] arr = new int[MAXN][2];
@@ -23,11 +23,11 @@ public class Code03_BallCollector1 {
 	public static int cnt;
 
 	public static int[] father = new int[MAXN];
-	public static int[] ncnt = new int[MAXN];
-	public static int[] ecnt = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] edgeCnt = new int[MAXN];
 
 	public static int[][] opstack = new int[MAXN][2];
-	public static int stacksiz = 0;
+	public static int opsize = 0;
 
 	public static int[] ans = new int[MAXN];
 	public static int ball = 0;
@@ -45,48 +45,51 @@ public static int find(int i) {
 		return i;
 	}
 
-	public static void merge(int h1, int h2) {
-		int big, small;
-		if (ncnt[h1] >= ncnt[h2]) {
-			big = h1;
-			small = h2;
+	public static void merge(int x, int y) {
+		int fx = find(x), fy = find(y);
+		if (fx == fy) {
+			opstack[++opsize][0] = 0;
 		} else {
-			big = h2;
-			small = h1;
+			if (siz[fx] < siz[fy]) {
+				int tmp = fx;
+				fx = fy;
+				fy = tmp;
+			}
+			father[fy] = fx;
+			siz[fx] += siz[fy];
+			edgeCnt[fx] += edgeCnt[fy] + 1;
+			opstack[++opsize][0] = fx;
+			opstack[opsize][1] = fy;
 		}
-		father[small] = big;
-		ncnt[big] += ncnt[small];
-		ecnt[big] += ecnt[small] + 1;
-		stacksiz++;
-		opstack[stacksiz][0] = big;
-		opstack[stacksiz][1] = small;
 	}
 
 	public static void undo() {
-		int big = opstack[stacksiz][0];
-		int small = opstack[stacksiz][1];
-		stacksiz--;
-		father[small] = small;
-		ncnt[big] -= ncnt[small];
-		ecnt[big] -= ecnt[small] + 1;
+		if (opsize > 0 && opstack[opsize][0] != 0) {
+			int fx = opstack[opsize][0];
+			int fy = opstack[opsize--][1];
+			father[fy] = fy;
+			siz[fx] -= siz[fy];
+			edgeCnt[fx] -= edgeCnt[fy] + 1;
+		}
 	}
 
 	public static void dfs(int u, int fa) {
-		int h1 = find(arr[u][0]), h2 = find(arr[u][1]);
+		int x = arr[u][0], y = arr[u][1];
+		int fx = find(x), fy = find(y);
 		boolean merged = false;
 		int add = 0;
-		if (h1 == h2) {
-			ecnt[h1]++;
-			if (ncnt[h1] == ecnt[h1]) {
+		if (fx == fy) {
+			if (edgeCnt[fx] < siz[fx]) {
 				ball++;
 				add = 1;
 			}
+			edgeCnt[fx]++;
 		} else {
-			if (ecnt[h1] < ncnt[h1] || ecnt[h2] < ncnt[h2]) {
+			if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
 				ball++;
 				add = 1;
 			}
-			merge(h1, h2);
+			merge(x, y);
 			merged = true;
 		}
 		if (u != 1) {
@@ -97,12 +100,12 @@ public static void dfs(int u, int fa) {
 				dfs(to[e], u);
 			}
 		}
+		ball -= add;
 		if (merged) {
 			undo();
 		} else {
-			ecnt[h1]--;
+			edgeCnt[fx]--;
 		}
-		ball -= add;
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -127,8 +130,8 @@ public static void main(String[] args) throws IOException {
 		}
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
-			ncnt[i] = 1;
-			ecnt[i] = 0;
+			siz[i] = 1;
+			edgeCnt[i] = 0;
 		}
 		dfs(1, 0);
 		for (int i = 2; i < n; i++) {
diff --git a/src/class165/Code03_BallCollector2.java b/src/class165/Code02_UndoUnionFind2.java
similarity index 62%
rename from src/class165/Code03_BallCollector2.java
rename to src/class165/Code02_UndoUnionFind2.java
index 7aeaf5af1..7252c4f10 100644
--- a/src/class165/Code03_BallCollector2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -1,6 +1,6 @@
 package class165;
 
-// 选球，C++版
+// 可撤销并查集模版题，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
 // 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -19,11 +19,11 @@
 //int cnt;
 //
 //int father[MAXN];
-//int ncnt[MAXN];
-//int ecnt[MAXN];
+//int siz[MAXN];
+//int edgeCnt[MAXN];
 //
 //int opstack[MAXN][2];
-//int stacksiz = 0;
+//int opsize = 0;
 //
 //int ans[MAXN];
 //int ball = 0;
@@ -41,48 +41,51 @@
 //	return i;
 //}
 //
-//void merge(int h1, int h2) {
-//    int big, small;
-//    if (ncnt[h1] >= ncnt[h2]) {
-//        big = h1;
-//        small = h2;
+//void merge(int x, int y) {
+//    int fx = find(x), fy = find(y);
+//    if (fx == fy) {
+//        opstack[++opsize][0] = 0;
 //    } else {
-//        big = h2;
-//        small = h1;
+//        if (siz[fx] < siz[fy]) {
+//            int tmp = fx;
+//            fx = fy;
+//            fy = tmp;
+//        }
+//        father[fy] = fx;
+//        siz[fx] += siz[fy];
+//        edgeCnt[fx] += edgeCnt[fy] + 1;
+//        opstack[++opsize][0] = fx;
+//        opstack[opsize][1] = fy;
 //    }
-//    father[small] = big;
-//    ncnt[big] += ncnt[small];
-//    ecnt[big] += ecnt[small] + 1;
-//    stacksiz++;
-//    opstack[stacksiz][0] = big;
-//    opstack[stacksiz][1] = small;
 //}
 //
 //void undo() {
-//    int big = opstack[stacksiz][0];
-//    int small = opstack[stacksiz][1];
-//    stacksiz--;
-//    father[small] = small;
-//    ncnt[big] -= ncnt[small];
-//    ecnt[big] -= ecnt[small] + 1;
+//    if (opsize > 0 && opstack[opsize][0] != 0) {
+//        int fx = opstack[opsize][0];
+//        int fy = opstack[opsize--][1];
+//        father[fy] = fy;
+//        siz[fx] -= siz[fy];
+//        edgeCnt[fx] -= edgeCnt[fy] + 1;
+//    }
 //}
 //
 //void dfs(int u, int fa) {
-//    int h1 = find(arr[u][0]), h2 = find(arr[u][1]);
+//    int x = arr[u][0], y = arr[u][1];
+//    int fx = find(x), fy = find(y);
 //    bool merged = false;
 //    int add = 0;
-//    if (h1 == h2) {
-//        ecnt[h1]++;
-//        if (ncnt[h1] == ecnt[h1]) {
+//    if (fx == fy) {
+//        if (edgeCnt[fx] < siz[fx]) {
 //            ball++;
 //            add = 1;
-//        }
+//		}
+//        edgeCnt[fx]++;
 //    } else {
-//        if (ecnt[h1] < ncnt[h1] || ecnt[h2] < ncnt[h2]) {
+//        if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
 //            ball++;
 //            add = 1;
 //        }
-//        merge(h1, h2);
+//        merge(x, y);
 //        merged = true;
 //    }
 //    if (u != 1) {
@@ -93,12 +96,12 @@
 //            dfs(to[e], u);
 //        }
 //    }
+//    ball -= add;
 //    if (merged) {
 //        undo();
 //    } else {
-//        ecnt[h1]--;
+//        edgeCnt[fx]--;
 //    }
-//    ball -= add;
 //}
 //
 //int main() {
@@ -116,8 +119,8 @@
 //    }
 //    for (int i = 1; i <= n; i++) {
 //        father[i] = i;
-//        ncnt[i] = 1;
-//        ecnt[i] = 0;
+//        siz[i] = 1;
+//        edgeCnt[i] = 0;
 //    }
 //    dfs(1, 0);
 //    for (int i = 2; i < n; i++) {

From d857fd38f06b3cb3ea0e92349e8c432ff1d5ce40 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 4 Apr 2025 15:21:37 +0800
Subject: [PATCH 0663/1712] modify code

---
 src/class120/Code04_LinkCutCentroids.java | 47 ++++++++++++-----------
 1 file changed, 24 insertions(+), 23 deletions(-)

diff --git a/src/class120/Code04_LinkCutCentroids.java b/src/class120/Code04_LinkCutCentroids.java
index 61c0d4086..2305918c5 100644
--- a/src/class120/Code04_LinkCutCentroids.java
+++ b/src/class120/Code04_LinkCutCentroids.java
@@ -10,6 +10,7 @@
 // "3 4"
 // "4 7"
 // 测试链接 : https://www.luogu.com.cn/problem/CF1406C
+// 测试链接 : https://codeforces.com/problemset/problem/1406/C
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有用例
 
 import java.io.BufferedReader;
@@ -43,11 +44,11 @@ public class Code04_LinkCutCentroids {
 	// 收集所有的重心
 	public static int[] centers = new int[2];
 
-	// 任何一个叶节点
-	public static int anyLeaf;
+	// 最大子树上的叶节点
+	public static int leaf;
 
-	// 该叶节点的父亲节点
-	public static int anyLeafFather;
+	// 叶节点的父亲节点
+	public static int leafFather;
 
 	public static void build() {
 		cnt = 1;
@@ -83,8 +84,23 @@ public static void find(int u, int f) {
 				return;
 			}
 		}
-		anyLeaf = u;
-		anyLeafFather = f;
+		leaf = u;
+		leafFather = f;
+	}
+
+	// 返回重心的数量
+	public static int compute() {
+		dfs(1, 0);
+		int m = 0;
+		for (int i = 1; i <= n; i++) {
+			if (maxsub[i] <= n / 2) {
+				centers[m++] = i;
+			}
+		}
+		if (m == 2) {
+			find(centers[1], centers[0]);
+		}
+		return m;
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -109,8 +125,8 @@ public static void main(String[] args) throws IOException {
 				out.println(centers[0] + " " + to[head[centers[0]]]);
 				out.println(centers[0] + " " + to[head[centers[0]]]);
 			} else {
-				out.println(anyLeafFather + " " + anyLeaf);
-				out.println(centers[0] + " " + anyLeaf);
+				out.println(leafFather + " " + leaf);
+				out.println(centers[0] + " " + leaf);
 			}
 		}
 		out.flush();
@@ -118,19 +134,4 @@ public static void main(String[] args) throws IOException {
 		br.close();
 	}
 
-	// 返回重心的数量
-	public static int compute() {
-		dfs(1, 0);
-		int m = 0;
-		for (int i = 1; i <= n; i++) {
-			if (maxsub[i] <= n / 2) {
-				centers[m++] = i;
-			}
-		}
-		if (m == 2) {
-			find(centers[1], centers[0]);
-		}
-		return m;
-	}
-
 }

From 6f8e83ecd63f887ed092337a8c4f4fdc964d7810 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 4 Apr 2025 15:23:18 +0800
Subject: [PATCH 0664/1712] modify code

---
 ...\347\232\204\351\207\215\345\277\203.pptx" | Bin 45348 -> 45540 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243120\343\200\220\346\211\251\345\261\225\343\200\221\346\240\221\344\270\212\351\227\256\351\242\230\344\270\223\351\242\2303-\346\240\221\347\232\204\351\207\215\345\277\203.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243120\343\200\220\346\211\251\345\261\225\343\200\221\346\240\221\344\270\212\351\227\256\351\242\230\344\270\223\351\242\2303-\346\240\221\347\232\204\351\207\215\345\277\203.pptx"
index 207d0351b0159727cde6b77bac19a1ec72339554..87824d7add866907535b884a9ab28358b1a7732e 100644
GIT binary patch
delta 3231
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

delta 2824
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
BjsE}u


From 16ed8ecffd057fc8935bd50109739558931b4f6d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 4 Apr 2025 16:12:11 +0800
Subject: [PATCH 0665/1712] modify code

---
 src/class120/Code04_LinkCutCentroids.java | 10 ++++------
 1 file changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/class120/Code04_LinkCutCentroids.java b/src/class120/Code04_LinkCutCentroids.java
index 2305918c5..9d1e2245c 100644
--- a/src/class120/Code04_LinkCutCentroids.java
+++ b/src/class120/Code04_LinkCutCentroids.java
@@ -89,17 +89,13 @@ public static void find(int u, int f) {
 	}
 
 	// 返回重心的数量
-	public static int compute() {
-		dfs(1, 0);
+	public static int centerCnt() {
 		int m = 0;
 		for (int i = 1; i <= n; i++) {
 			if (maxsub[i] <= n / 2) {
 				centers[m++] = i;
 			}
 		}
-		if (m == 2) {
-			find(centers[1], centers[0]);
-		}
 		return m;
 	}
 
@@ -121,10 +117,12 @@ public static void main(String[] args) throws IOException {
 				addEdge(u, v);
 				addEdge(v, u);
 			}
-			if (compute() == 1) {
+			dfs(1, 0);
+			if (centerCnt() == 1) {
 				out.println(centers[0] + " " + to[head[centers[0]]]);
 				out.println(centers[0] + " " + to[head[centers[0]]]);
 			} else {
+				find(centers[1], centers[0]);
 				out.println(leafFather + " " + leaf);
 				out.println(centers[0] + " " + leaf);
 			}

From 7ab006fce0372759abeb0f71500357b6510d1b0b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 4 Apr 2025 18:19:00 +0800
Subject: [PATCH 0666/1712] modify code

---
 src/class163/Code01_DsuOnTree1.java           | 6 +++---
 src/class163/Code01_DsuOnTree2.java           | 6 +++---
 src/class163/Code01_DsuOnTree3.java           | 6 +++---
 src/class163/Code02_ColorBanlance1.java       | 6 +++---
 src/class163/Code02_ColorBanlance2.java       | 6 +++---
 src/class163/Code02_ColorBanlance3.java       | 6 +++---
 src/class163/Code03_LomsatGelral1.java        | 6 +++---
 src/class163/Code03_LomsatGelral2.java        | 6 +++---
 src/class163/Code04_DifferntName1.java        | 6 +++---
 src/class163/Code04_DifferntName2.java        | 6 +++---
 src/class163/Code05_BloodCousins1.java        | 6 +++---
 src/class163/Code05_BloodCousins2.java        | 6 +++---
 src/class163/Code06_RearrangePalindrome1.java | 6 +++---
 src/class163/Code06_RearrangePalindrome2.java | 6 +++---
 14 files changed, 42 insertions(+), 42 deletions(-)

diff --git a/src/class163/Code01_DsuOnTree1.java b/src/class163/Code01_DsuOnTree1.java
index 79bfcf359..205ae9d5e 100644
--- a/src/class163/Code01_DsuOnTree1.java
+++ b/src/class163/Code01_DsuOnTree1.java
@@ -82,14 +82,14 @@ public static void effect(int u) {
 	}
 
 	// 子树u每个节点取消贡献
-	public static void cancle(int u) {
+	public static void cancel(int u) {
 		if (--colorCnt[arr[u]] == 0) {
 			diffColors--;
 		}
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa[u]) {
-				cancle(v);
+				cancel(v);
 			}
 		}
 	}
@@ -122,7 +122,7 @@ public static void dfs2(int u, int keep) {
 		ans[u] = diffColors;
 		// 如果u是上级节点的轻儿子，子树u的贡献取消，否则保留
 		if (keep == 0) {
-			cancle(u);
+			cancel(u);
 		}
 	}
 
diff --git a/src/class163/Code01_DsuOnTree2.java b/src/class163/Code01_DsuOnTree2.java
index 95fbf0763..ee1b0fad3 100644
--- a/src/class163/Code01_DsuOnTree2.java
+++ b/src/class163/Code01_DsuOnTree2.java
@@ -69,12 +69,12 @@ public static void effect(int u) {
 		}
 	}
 
-	public static void cancle(int u) {
+	public static void cancel(int u) {
 		colorCnt[arr[u]] = 0; // 出现任何颜色，直接把该颜色的计数重置为0
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa[u]) {
-				cancle(v);
+				cancel(v);
 			}
 		}
 	}
@@ -101,7 +101,7 @@ public static void dfs2(int u, int keep) {
 		ans[u] = diffColors;
 		if (keep == 0) {
 			diffColors = 0; // 直接把全局的不同颜色数量重置为0
-			cancle(u);
+			cancel(u);
 		}
 	}
 
diff --git a/src/class163/Code01_DsuOnTree3.java b/src/class163/Code01_DsuOnTree3.java
index 5bb8dfebf..270dcb769 100644
--- a/src/class163/Code01_DsuOnTree3.java
+++ b/src/class163/Code01_DsuOnTree3.java
@@ -68,12 +68,12 @@
 //    }
 //}
 //
-//void cancle(int u) {
+//void cancel(int u) {
 //    colorCnt[arr[u]] = 0;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != fa[u]) {
-//            cancle(v);
+//            cancel(v);
 //        }
 //    }
 //}
@@ -100,7 +100,7 @@
 //    ans[u] = diffColors;
 //    if (keep == 0) {
 //        diffColors = 0;
-//        cancle(u);
+//        cancel(u);
 //    }
 //}
 //
diff --git a/src/class163/Code02_ColorBanlance1.java b/src/class163/Code02_ColorBanlance1.java
index 382d19ba8..0184c3481 100644
--- a/src/class163/Code02_ColorBanlance1.java
+++ b/src/class163/Code02_ColorBanlance1.java
@@ -68,12 +68,12 @@ public static void effect(int u) {
 		}
 	}
 
-	public static void cancle(int u) {
+	public static void cancel(int u) {
 		colorCnt[color[u]]--;
 		colorNum[colorCnt[color[u]] + 1]--;
 		colorNum[colorCnt[color[u]]]++;
 		for (int e = head[u]; e > 0; e = next[e]) {
-			cancle(to[e]);
+			cancel(to[e]);
 		}
 	}
 
@@ -100,7 +100,7 @@ public static void dfs2(int u, int keep) {
 			ans++;
 		}
 		if (keep == 0) {
-			cancle(u);
+			cancel(u);
 		}
 	}
 
diff --git a/src/class163/Code02_ColorBanlance2.java b/src/class163/Code02_ColorBanlance2.java
index 721ad2a13..8d560dc6e 100644
--- a/src/class163/Code02_ColorBanlance2.java
+++ b/src/class163/Code02_ColorBanlance2.java
@@ -34,7 +34,7 @@ public static void addEdge(int u, int v) {
 	}
 
 	// stack1、size1、cur1、edge1
-	// 用于把effect、cancle、dfs1改成迭代版
+	// 用于把effect、cancel、dfs1改成迭代版
 	public static int[][] stack1 = new int[MAXN][2];
 	public static int size1, cur1, edge1;
 
@@ -115,7 +115,7 @@ public static void effect(int root) {
 		}
 	}
 
-	public static void cancle(int root) {
+	public static void cancel(int root) {
 		size1 = 0;
 		push1(root, -1);
 		while (size1 > 0) {
@@ -176,7 +176,7 @@ public static void dfs2(int u, int keep) {
 					ans++;
 				}
 				if (keep2 == 0) {
-					cancle(cur2);
+					cancel(cur2);
 				}
 			}
 		}
diff --git a/src/class163/Code02_ColorBanlance3.java b/src/class163/Code02_ColorBanlance3.java
index d622af603..4eb862357 100644
--- a/src/class163/Code02_ColorBanlance3.java
+++ b/src/class163/Code02_ColorBanlance3.java
@@ -56,12 +56,12 @@
 //    }
 //}
 //
-//void cancle(int u) {
+//void cancel(int u) {
 //    colorCnt[color[u]]--;
 //    colorNum[colorCnt[color[u]] + 1]--;
 //    colorNum[colorCnt[color[u]]]++;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        cancle(to[e]);
+//        cancel(to[e]);
 //    }
 //}
 //
@@ -88,7 +88,7 @@
 //        ans++;
 //    }
 //    if (keep == 0) {
-//        cancle(u);
+//        cancel(u);
 //    }
 //}
 //
diff --git a/src/class163/Code03_LomsatGelral1.java b/src/class163/Code03_LomsatGelral1.java
index b90737671..a6b491efc 100644
--- a/src/class163/Code03_LomsatGelral1.java
+++ b/src/class163/Code03_LomsatGelral1.java
@@ -79,13 +79,13 @@ public static void effect(int u, int h) {
 		}
 	}
 
-	public static void cancle(int u) {
+	public static void cancel(int u) {
 		colorCnt[color[u]] = 0;
 		maxCnt[u] = 0;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != fa[u]) {
-				cancle(v);
+				cancel(v);
 			}
 		}
 	}
@@ -116,7 +116,7 @@ public static void dfs2(int u, int keep) {
 			}
 		}
 		if (keep == 0) {
-			cancle(u);
+			cancel(u);
 		}
 	}
 
diff --git a/src/class163/Code03_LomsatGelral2.java b/src/class163/Code03_LomsatGelral2.java
index 495d53a39..93bb2d797 100644
--- a/src/class163/Code03_LomsatGelral2.java
+++ b/src/class163/Code03_LomsatGelral2.java
@@ -75,13 +75,13 @@
 //    }
 //}
 //
-//void cancle(int u) {
+//void cancel(int u) {
 //    colorCnt[color[u]] = 0;
 //    maxCnt[u] = 0;
 //    for (int e = head[u], v; e > 0; e = nxt[e]) {
 //        v = to[e];
 //        if (v != fa[u]) {
-//            cancle(v);
+//            cancel(v);
 //        }
 //    }
 //}
@@ -112,7 +112,7 @@
 //        }
 //    }
 //    if (keep == 0) {
-//        cancle(u);
+//        cancel(u);
 //    }
 //}
 //
diff --git a/src/class163/Code04_DifferntName1.java b/src/class163/Code04_DifferntName1.java
index 1d6d6115d..ce902ae7a 100644
--- a/src/class163/Code04_DifferntName1.java
+++ b/src/class163/Code04_DifferntName1.java
@@ -114,10 +114,10 @@ public static void effect(int u) {
 		}
 	}
 
-	public static void cancle(int u) {
+	public static void cancel(int u) {
 		removeId(dep[u], id[u]);
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
-			cancle(tog[e]);
+			cancel(tog[e]);
 		}
 	}
 
@@ -142,7 +142,7 @@ public static void dfs2(int u, int keep) {
 			ans[ansiq[i]] = sizeOfDeep(dep[u] + kq[i]);
 		}
 		if (keep == 0) {
-			cancle(u);
+			cancel(u);
 		}
 	}
 
diff --git a/src/class163/Code04_DifferntName2.java b/src/class163/Code04_DifferntName2.java
index 035a3dac8..15cee2fab 100644
--- a/src/class163/Code04_DifferntName2.java
+++ b/src/class163/Code04_DifferntName2.java
@@ -102,10 +102,10 @@
 //    }
 //}
 //
-//void cancle(int u) {
+//void cancel(int u) {
 //    removeId(dep[u], id[u]);
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {
-//        cancle(tog[e]);
+//        cancel(tog[e]);
 //    }
 //}
 //
@@ -130,7 +130,7 @@
 //    	ans[ansiq[i]] = sizeOfDeep(dep[u] + kq[i]);
 //    }
 //    if (keep == 0) {
-//        cancle(u);
+//        cancel(u);
 //    }
 //}
 //
diff --git a/src/class163/Code05_BloodCousins1.java b/src/class163/Code05_BloodCousins1.java
index 5459c91d5..ed02a853a 100644
--- a/src/class163/Code05_BloodCousins1.java
+++ b/src/class163/Code05_BloodCousins1.java
@@ -98,10 +98,10 @@ public static void effect(int u) {
 		}
 	}
 
-	public static void cancle(int u) {
+	public static void cancel(int u) {
 		depCnt[dep[u]]--;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
-			cancle(tog[e]);
+			cancel(tog[e]);
 		}
 	}
 
@@ -126,7 +126,7 @@ public static void dfs2(int u, int keep) {
 			ans[ansiq[i]] = depCnt[dep[u] + kq[i]];
 		}
 		if (keep == 0) {
-			cancle(u);
+			cancel(u);
 		}
 	}
 
diff --git a/src/class163/Code05_BloodCousins2.java b/src/class163/Code05_BloodCousins2.java
index d991d176a..702d58b94 100644
--- a/src/class163/Code05_BloodCousins2.java
+++ b/src/class163/Code05_BloodCousins2.java
@@ -90,10 +90,10 @@
 //    }
 //}
 //
-//void cancle(int u) {
+//void cancel(int u) {
 //    depCnt[dep[u]]--;
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {
-//        cancle(tog[e]);
+//        cancel(tog[e]);
 //    }
 //}
 //
@@ -118,7 +118,7 @@
 //    	ans[ansiq[i]] = depCnt[dep[u] + kq[i]];
 //    }
 //    if (keep == 0) {
-//        cancle(u);
+//        cancel(u);
 //    }
 //}
 //
diff --git a/src/class163/Code06_RearrangePalindrome1.java b/src/class163/Code06_RearrangePalindrome1.java
index 7467426ef..93b194165 100644
--- a/src/class163/Code06_RearrangePalindrome1.java
+++ b/src/class163/Code06_RearrangePalindrome1.java
@@ -69,10 +69,10 @@ public static void effect(int u) {
 		}
 	}
 
-	public static void cancle(int u) {
+	public static void cancel(int u) {
 		maxdep[eor[u]] = 0;
 		for (int e = head[u]; e > 0; e = next[e]) {
-			cancle(to[e]);
+			cancel(to[e]);
 		}
 	}
 
@@ -125,7 +125,7 @@ public static void dfs2(int u, int keep) {
 			}
 		}
 		if (keep == 0) {
-			cancle(u);
+			cancel(u);
 		}
 	}
 
diff --git a/src/class163/Code06_RearrangePalindrome2.java b/src/class163/Code06_RearrangePalindrome2.java
index 9f97f353a..b1839bf76 100644
--- a/src/class163/Code06_RearrangePalindrome2.java
+++ b/src/class163/Code06_RearrangePalindrome2.java
@@ -60,10 +60,10 @@
 //    }
 //}
 //
-//void cancle(int u) {
+//void cancel(int u) {
 //    maxdep[eor[u]] = 0;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        cancle(to[e]);
+//        cancel(to[e]);
 //    }
 //}
 //
@@ -111,7 +111,7 @@
 //        }
 //    }
 //    if (keep == 0) {
-//        cancle(u);
+//        cancel(u);
 //    }
 //}
 //

From 2c090e1b43ddaec0075df12b4fb67f882fc57eb9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 5 Apr 2025 13:43:12 +0800
Subject: [PATCH 0667/1712] modify code

---
 src/class165/Code02_UndoUnionFind1.java | 49 ++++++++++--------------
 src/class165/Code02_UndoUnionFind2.java | 51 +++++++++++--------------
 2 files changed, 43 insertions(+), 57 deletions(-)

diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index f4b41cf88..8fb9a2faf 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -46,36 +46,31 @@ public static int find(int i) {
 	}
 
 	public static void merge(int x, int y) {
-		int fx = find(x), fy = find(y);
-		if (fx == fy) {
-			opstack[++opsize][0] = 0;
-		} else {
-			if (siz[fx] < siz[fy]) {
-				int tmp = fx;
-				fx = fy;
-				fy = tmp;
-			}
-			father[fy] = fx;
-			siz[fx] += siz[fy];
-			edgeCnt[fx] += edgeCnt[fy] + 1;
-			opstack[++opsize][0] = fx;
-			opstack[opsize][1] = fy;
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
 		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		edgeCnt[fx] += edgeCnt[fy] + 1;
+		opstack[++opsize][0] = fx;
+		opstack[opsize][1] = fy;
 	}
 
 	public static void undo() {
-		if (opsize > 0 && opstack[opsize][0] != 0) {
-			int fx = opstack[opsize][0];
-			int fy = opstack[opsize--][1];
-			father[fy] = fy;
-			siz[fx] -= siz[fy];
-			edgeCnt[fx] -= edgeCnt[fy] + 1;
-		}
+		int fx = opstack[opsize][0];
+		int fy = opstack[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+		edgeCnt[fx] -= edgeCnt[fy] + 1;
 	}
 
 	public static void dfs(int u, int fa) {
-		int x = arr[u][0], y = arr[u][1];
-		int fx = find(x), fy = find(y);
+		int fx = find(arr[u][0]);
+		int fy = find(arr[u][1]);
 		boolean merged = false;
 		int add = 0;
 		if (fx == fy) {
@@ -89,23 +84,21 @@ public static void dfs(int u, int fa) {
 				ball++;
 				add = 1;
 			}
-			merge(x, y);
+			merge(fx, fy);
 			merged = true;
 		}
-		if (u != 1) {
-			ans[u] = ball;
-		}
+		ans[u] = ball;
 		for (int e = head[u]; e > 0; e = next[e]) {
 			if (to[e] != fa) {
 				dfs(to[e], u);
 			}
 		}
-		ball -= add;
 		if (merged) {
 			undo();
 		} else {
 			edgeCnt[fx]--;
 		}
+		ball -= add;
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index 7252c4f10..648233424 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -42,66 +42,59 @@
 //}
 //
 //void merge(int x, int y) {
-//    int fx = find(x), fy = find(y);
-//    if (fx == fy) {
-//        opstack[++opsize][0] = 0;
-//    } else {
-//        if (siz[fx] < siz[fy]) {
-//            int tmp = fx;
-//            fx = fy;
-//            fy = tmp;
-//        }
-//        father[fy] = fx;
-//        siz[fx] += siz[fy];
-//        edgeCnt[fx] += edgeCnt[fy] + 1;
-//        opstack[++opsize][0] = fx;
-//        opstack[opsize][1] = fy;
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
 //    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    edgeCnt[fx] += edgeCnt[fy] + 1;
+//    opstack[++opsize][0] = fx;
+//    opstack[opsize][1] = fy;
 //}
 //
 //void undo() {
-//    if (opsize > 0 && opstack[opsize][0] != 0) {
-//        int fx = opstack[opsize][0];
-//        int fy = opstack[opsize--][1];
-//        father[fy] = fy;
-//        siz[fx] -= siz[fy];
-//        edgeCnt[fx] -= edgeCnt[fy] + 1;
-//    }
+//    int fx = opstack[opsize][0];
+//    int fy = opstack[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
+//    edgeCnt[fx] -= edgeCnt[fy] + 1;
 //}
 //
 //void dfs(int u, int fa) {
-//    int x = arr[u][0], y = arr[u][1];
-//    int fx = find(x), fy = find(y);
+//    int fx = find(arr[u][0]);
+//    int fy = find(arr[u][1]);
 //    bool merged = false;
 //    int add = 0;
 //    if (fx == fy) {
 //        if (edgeCnt[fx] < siz[fx]) {
 //            ball++;
 //            add = 1;
-//		}
+//        }
 //        edgeCnt[fx]++;
 //    } else {
 //        if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
 //            ball++;
 //            add = 1;
 //        }
-//        merge(x, y);
+//        merge(fx, fy);
 //        merged = true;
 //    }
-//    if (u != 1) {
-//        ans[u] = ball;
-//    }
+//    ans[u] = ball;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        if (to[e] != fa) {
 //            dfs(to[e], u);
 //        }
 //    }
-//    ball -= add;
 //    if (merged) {
 //        undo();
 //    } else {
 //        edgeCnt[fx]--;
 //    }
+//    ball -= add;
 //}
 //
 //int main() {

From f221129e6087aa38c4bdfdc6565564ebf35a0c8c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 6 Apr 2025 21:50:23 +0800
Subject: [PATCH 0668/1712] modify code

---
 src/class165/Code02_UndoUnionFind1.java |  10 +-
 src/class165/Code02_UndoUnionFind2.java |  10 +-
 src/class165/Code03_Envy1.java          | 148 ++++++++++++++++++++++++
 src/class165/Code03_Envy2.java          | 143 +++++++++++++++++++++++
 4 files changed, 301 insertions(+), 10 deletions(-)
 create mode 100644 src/class165/Code03_Envy1.java
 create mode 100644 src/class165/Code03_Envy2.java

diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index 8fb9a2faf..733270de1 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -26,7 +26,7 @@ public class Code02_UndoUnionFind1 {
 	public static int[] siz = new int[MAXN];
 	public static int[] edgeCnt = new int[MAXN];
 
-	public static int[][] opstack = new int[MAXN][2];
+	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize = 0;
 
 	public static int[] ans = new int[MAXN];
@@ -56,13 +56,13 @@ public static void merge(int x, int y) {
 		father[fy] = fx;
 		siz[fx] += siz[fy];
 		edgeCnt[fx] += edgeCnt[fy] + 1;
-		opstack[++opsize][0] = fx;
-		opstack[opsize][1] = fy;
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
 	}
 
 	public static void undo() {
-		int fx = opstack[opsize][0];
-		int fy = opstack[opsize--][1];
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
 		father[fy] = fy;
 		siz[fx] -= siz[fy];
 		edgeCnt[fx] -= edgeCnt[fy] + 1;
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index 648233424..38a58646e 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -22,7 +22,7 @@
 //int siz[MAXN];
 //int edgeCnt[MAXN];
 //
-//int opstack[MAXN][2];
+//int rollback[MAXN][2];
 //int opsize = 0;
 //
 //int ans[MAXN];
@@ -52,13 +52,13 @@
 //    father[fy] = fx;
 //    siz[fx] += siz[fy];
 //    edgeCnt[fx] += edgeCnt[fy] + 1;
-//    opstack[++opsize][0] = fx;
-//    opstack[opsize][1] = fy;
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
 //}
 //
 //void undo() {
-//    int fx = opstack[opsize][0];
-//    int fy = opstack[opsize--][1];
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
 //    father[fy] = fy;
 //    siz[fx] -= siz[fy];
 //    edgeCnt[fx] -= edgeCnt[fy] + 1;
diff --git a/src/class165/Code03_Envy1.java b/src/class165/Code03_Envy1.java
new file mode 100644
index 000000000..de6d6ce17
--- /dev/null
+++ b/src/class165/Code03_Envy1.java
@@ -0,0 +1,148 @@
+package class165;
+
+// k条边同在最小生成树里，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF891C
+// 测试链接 : https://codeforces.com/problemset/problem/891/C
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code03_Envy1 {
+
+	public static int MAXN = 500001;
+	public static int n, m, q, k;
+
+	// 节点u、节点v、边权w
+	public static int[][] edge = new int[MAXN][3];
+
+	// 节点u、节点v、边权w、问题编号i
+	public static int[][] queryEdge = new int[MAXN][4];
+
+	// 可撤销并查集
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN << 1][2];
+	public static int opsize;
+
+	// 答案数组
+	public static boolean[] ans = new boolean[MAXN];
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static boolean merge(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (fx == fy) {
+			rollback[++opsize][0] = 0;
+			return false;
+		}
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+		return true;
+	}
+
+	public static void undo() {
+		if (rollback[opsize][0] == 0) {
+			opsize--;
+		} else {
+			int fx = rollback[opsize][0];
+			int fy = rollback[opsize--][1];
+			father[fy] = fy;
+			siz[fx] -= siz[fy];
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		Arrays.sort(edge, 1, m + 1, (a, b) -> a[2] - b[2]);
+		Arrays.sort(queryEdge, 1, k + 1, (a, b) -> a[2] != b[2] ? (a[2] - b[2]) : (a[3] - b[3]));
+		Arrays.fill(ans, 1, q + 1, true);
+	}
+
+	public static void compute() {
+		int ei = 1;
+		for (int l = 1, r = 1; l <= k; l = ++r) {
+			for (; ei <= m && edge[ei][2] < queryEdge[l][2]; ei++) {
+				merge(edge[ei][0], edge[ei][1]);
+			}
+			while (r + 1 <= k && queryEdge[l][2] == queryEdge[r + 1][2] && queryEdge[l][3] == queryEdge[r + 1][3]) {
+				r++;
+			}
+			for (int i = l; i <= r; i++) {
+				if (!merge(queryEdge[i][0], queryEdge[i][1])) {
+					ans[queryEdge[i][3]] = false;
+				}
+			}
+			for (int i = l; i <= r; i++) {
+				undo();
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			edge[i][0] = (int) in.nval;
+			in.nextToken();
+			edge[i][1] = (int) in.nval;
+			in.nextToken();
+			edge[i][2] = (int) in.nval;
+		}
+		in.nextToken();
+		q = (int) in.nval;
+		k = 0;
+		for (int i = 1, s; i <= q; i++) {
+			in.nextToken();
+			s = (int) in.nval;
+			for (int j = 1, ei; j <= s; j++) {
+				in.nextToken();
+				ei = (int) in.nval;
+				queryEdge[++k][0] = edge[ei][0];
+				queryEdge[k][1] = edge[ei][1];
+				queryEdge[k][2] = edge[ei][2];
+				queryEdge[k][3] = i;
+			}
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= q; i++) {
+			if (ans[i]) {
+				out.println("YES");
+			} else {
+				out.println("NO");
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class165/Code03_Envy2.java b/src/class165/Code03_Envy2.java
new file mode 100644
index 000000000..01e568048
--- /dev/null
+++ b/src/class165/Code03_Envy2.java
@@ -0,0 +1,143 @@
+package class165;
+
+// k条边同在最小生成树里，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF891C
+// 测试链接 : https://codeforces.com/problemset/problem/891/C
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int u, v, w;
+//};
+//
+//bool EdgeCmp(Edge x, Edge y) {
+//    return x.w < y.w;
+//}
+//
+//struct QueryEdge {
+//    int u, v, w, i;
+//};
+//
+//bool QueryEdgeCmp(QueryEdge x, QueryEdge y) {
+//    if(x.w != y.w) {
+//    	return x.w < y.w;
+//    } else {
+//        return x.i < y.i;
+//    }
+//}
+//
+//const int MAXN = 500001;
+//int n, m, q, k;
+//Edge edge[MAXN];
+//QueryEdge queryEdge[MAXN];
+//
+//int father[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN << 1][2];
+//int opsize;
+//
+//bool ans[MAXN];
+//
+//int find(int i) {
+//    while (i != father[i]) {
+//        i = father[i];
+//    }
+//    return i;
+//}
+//
+//bool merge(int x, int y) {
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (fx == fy) {
+//        rollback[++opsize][0] = 0;
+//        return false;
+//    }
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
+//    return true;
+//}
+//
+//void undo() {
+//    if (rollback[opsize][0] == 0) {
+//        opsize--;
+//    } else {
+//        int fx = rollback[opsize][0];
+//        int fy = rollback[opsize--][1];
+//        father[fy] = fy;
+//        siz[fx] -= siz[fy];
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    sort(edge + 1, edge + m + 1, EdgeCmp);
+//    sort(queryEdge + 1, queryEdge + k + 1, QueryEdgeCmp);
+//    for (int i = 1; i <= q; i++) {
+//        ans[i] = true;
+//    }
+//}
+//
+//void compute() {
+//    int ei = 1;
+//    for (int l = 1, r = 1; l <= k; l = ++r) {
+//        for (; ei <= m && edge[ei].w < queryEdge[l].w; ei++) {
+//            merge(edge[ei].u, edge[ei].v);
+//        }
+//        while (r + 1 <= k && queryEdge[l].w == queryEdge[r + 1].w && queryEdge[l].i == queryEdge[r + 1].i) {
+//            r++;
+//        }
+//        for (int i = l; i <= r; i++) {
+//            if (!merge(queryEdge[i].u, queryEdge[i].v)) {
+//                ans[queryEdge[i].i] = false;
+//            }
+//        }
+//        for (int i = l; i <= r; i++) {
+//            undo();
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> edge[i].u >> edge[i].v >> edge[i].w;
+//    }
+//    cin >> q;
+//    k = 0;
+//    for (int i = 1, s; i <= q; i++) {
+//        cin >> s;
+//        for (int j = 1, ei; j <= s; j++) {
+//            cin >> ei;
+//            queryEdge[++k].u = edge[ei].u;
+//            queryEdge[k].v = edge[ei].v;
+//            queryEdge[k].w = edge[ei].w;
+//            queryEdge[k].i = i;
+//        }
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= q; i++) {
+//        if (ans[i]) {
+//            cout << "YES" << "\n";
+//        } else {
+//            cout << "NO" << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 4a69d218ee846e177b8e32da1cad2b568d7cc27b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 6 Apr 2025 22:01:26 +0800
Subject: [PATCH 0669/1712] modify code

---
 src/class165/Code03_Envy1.java | 2 +-
 src/class165/Code03_Envy2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class165/Code03_Envy1.java b/src/class165/Code03_Envy1.java
index de6d6ce17..7681de0ed 100644
--- a/src/class165/Code03_Envy1.java
+++ b/src/class165/Code03_Envy1.java
@@ -1,6 +1,6 @@
 package class165;
 
-// k条边同在最小生成树里，java版
+// 同在最小生成树里，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF891C
 // 测试链接 : https://codeforces.com/problemset/problem/891/C
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class165/Code03_Envy2.java b/src/class165/Code03_Envy2.java
index 01e568048..aff5a4586 100644
--- a/src/class165/Code03_Envy2.java
+++ b/src/class165/Code03_Envy2.java
@@ -1,6 +1,6 @@
 package class165;
 
-// k条边同在最小生成树里，C++版
+// 同在最小生成树里，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/CF891C
 // 测试链接 : https://codeforces.com/problemset/problem/891/C
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From fe528c0a531c3ef725fd0b5b284f1dd0d3068faf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 8 Apr 2025 16:52:12 +0800
Subject: [PATCH 0670/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java |   4 +-
 src/class165/Code01_PersistentUnionFind2.java |   4 +-
 src/class165/Code02_UndoUnionFind1.java       |  10 +-
 src/class165/Code02_UndoUnionFind2.java       |  10 +-
 src/class165/Code03_Envy1.java                |  33 ++--
 src/class165/Code03_Envy2.java                |  35 ++--
 src/class165/Code04_TeamBuilding1.java        | 153 ++++++++++++++++++
 src/class165/Code04_TeamBuilding2.java        | 147 +++++++++++++++++
 8 files changed, 346 insertions(+), 50 deletions(-)
 create mode 100644 src/class165/Code04_TeamBuilding1.java
 create mode 100644 src/class165/Code04_TeamBuilding2.java

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
index 29379ba16..a04a36597 100644
--- a/src/class165/Code01_PersistentUnionFind1.java
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -86,7 +86,7 @@ public static int find(int x, int v) {
 		return x;
 	}
 
-	public static void merge(int x, int y, int v) {
+	public static void union(int x, int y, int v) {
 		int fx = find(x, v);
 		int fy = find(y, v);
 		if (fx != fy) {
@@ -122,7 +122,7 @@ public static void main(String[] args) throws IOException {
 				x = (int) in.nval;
 				in.nextToken();
 				y = (int) in.nval;
-				merge(x, y, v);
+				union(x, y, v);
 			} else if (op == 2) {
 				in.nextToken();
 				x = (int) in.nval;
diff --git a/src/class165/Code01_PersistentUnionFind2.java b/src/class165/Code01_PersistentUnionFind2.java
index 6882f8b7c..1d58ae11f 100644
--- a/src/class165/Code01_PersistentUnionFind2.java
+++ b/src/class165/Code01_PersistentUnionFind2.java
@@ -81,7 +81,7 @@
 //    return x;
 //}
 //
-//void merge(int x, int y, int v) {
+//void Union(int x, int y, int v) {
 //    int fx = find(x, v);
 //    int fy = find(y, v);
 //    if (fx != fy) {
@@ -109,7 +109,7 @@
 //        rootsiz[v] = rootsiz[v - 1];
 //        if (op == 1) {
 //            cin >> x >> y;
-//            merge(x, y, v);
+//            Union(x, y, v);
 //        } else if (op == 2) {
 //            cin >> x;
 //            rootfa[v] = rootfa[x];
diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index 733270de1..07afc3936 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -45,7 +45,7 @@ public static int find(int i) {
 		return i;
 	}
 
-	public static void merge(int x, int y) {
+	public static void union(int x, int y) {
 		int fx = find(x);
 		int fy = find(y);
 		if (siz[fx] < siz[fy]) {
@@ -71,7 +71,7 @@ public static void undo() {
 	public static void dfs(int u, int fa) {
 		int fx = find(arr[u][0]);
 		int fy = find(arr[u][1]);
-		boolean merged = false;
+		boolean unioned = false;
 		int add = 0;
 		if (fx == fy) {
 			if (edgeCnt[fx] < siz[fx]) {
@@ -84,8 +84,8 @@ public static void dfs(int u, int fa) {
 				ball++;
 				add = 1;
 			}
-			merge(fx, fy);
-			merged = true;
+			union(fx, fy);
+			unioned = true;
 		}
 		ans[u] = ball;
 		for (int e = head[u]; e > 0; e = next[e]) {
@@ -93,7 +93,7 @@ public static void dfs(int u, int fa) {
 				dfs(to[e], u);
 			}
 		}
-		if (merged) {
+		if (unioned) {
 			undo();
 		} else {
 			edgeCnt[fx]--;
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index 38a58646e..f80232477 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -41,7 +41,7 @@
 //	return i;
 //}
 //
-//void merge(int x, int y) {
+//void Union(int x, int y) {
 //    int fx = find(x);
 //    int fy = find(y);
 //    if (siz[fx] < siz[fy]) {
@@ -67,7 +67,7 @@
 //void dfs(int u, int fa) {
 //    int fx = find(arr[u][0]);
 //    int fy = find(arr[u][1]);
-//    bool merged = false;
+//    bool unioned = false;
 //    int add = 0;
 //    if (fx == fy) {
 //        if (edgeCnt[fx] < siz[fx]) {
@@ -80,8 +80,8 @@
 //            ball++;
 //            add = 1;
 //        }
-//        merge(fx, fy);
-//        merged = true;
+//        Union(fx, fy);
+//        unioned = true;
 //    }
 //    ans[u] = ball;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
@@ -89,7 +89,7 @@
 //            dfs(to[e], u);
 //        }
 //    }
-//    if (merged) {
+//    if (unioned) {
 //        undo();
 //    } else {
 //        edgeCnt[fx]--;
diff --git a/src/class165/Code03_Envy1.java b/src/class165/Code03_Envy1.java
index 7681de0ed..f8d2399b8 100644
--- a/src/class165/Code03_Envy1.java
+++ b/src/class165/Code03_Envy1.java
@@ -20,7 +20,6 @@ public class Code03_Envy1 {
 
 	// 节点u、节点v、边权w
 	public static int[][] edge = new int[MAXN][3];
-
 	// 节点u、节点v、边权w、问题编号i
 	public static int[][] queryEdge = new int[MAXN][4];
 
@@ -40,13 +39,9 @@ public static int find(int i) {
 		return i;
 	}
 
-	public static boolean merge(int x, int y) {
+	public static void union(int x, int y) {
 		int fx = find(x);
 		int fy = find(y);
-		if (fx == fy) {
-			rollback[++opsize][0] = 0;
-			return false;
-		}
 		if (siz[fx] < siz[fy]) {
 			int tmp = fx;
 			fx = fy;
@@ -56,18 +51,13 @@ public static boolean merge(int x, int y) {
 		siz[fx] += siz[fy];
 		rollback[++opsize][0] = fx;
 		rollback[opsize][1] = fy;
-		return true;
 	}
 
 	public static void undo() {
-		if (rollback[opsize][0] == 0) {
-			opsize--;
-		} else {
-			int fx = rollback[opsize][0];
-			int fy = rollback[opsize--][1];
-			father[fy] = fy;
-			siz[fx] -= siz[fy];
-		}
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
 	}
 
 	public static void prepare() {
@@ -84,17 +74,24 @@ public static void compute() {
 		int ei = 1;
 		for (int l = 1, r = 1; l <= k; l = ++r) {
 			for (; ei <= m && edge[ei][2] < queryEdge[l][2]; ei++) {
-				merge(edge[ei][0], edge[ei][1]);
+				if (find(edge[ei][0]) != find(edge[ei][1])) {
+					union(edge[ei][0], edge[ei][1]);
+				}
 			}
 			while (r + 1 <= k && queryEdge[l][2] == queryEdge[r + 1][2] && queryEdge[l][3] == queryEdge[r + 1][3]) {
 				r++;
 			}
+			int unionCnt = 0;
 			for (int i = l; i <= r; i++) {
-				if (!merge(queryEdge[i][0], queryEdge[i][1])) {
+				if (find(queryEdge[i][0]) == find(queryEdge[i][1])) {
 					ans[queryEdge[i][3]] = false;
+					break;
+				} else {
+					union(queryEdge[i][0], queryEdge[i][1]);
+					unionCnt++;
 				}
 			}
-			for (int i = l; i <= r; i++) {
+			for (int i = 1; i <= unionCnt; i++) {
 				undo();
 			}
 		}
diff --git a/src/class165/Code03_Envy2.java b/src/class165/Code03_Envy2.java
index aff5a4586..f0fb73b16 100644
--- a/src/class165/Code03_Envy2.java
+++ b/src/class165/Code03_Envy2.java
@@ -24,7 +24,7 @@
 //
 //bool QueryEdgeCmp(QueryEdge x, QueryEdge y) {
 //    if(x.w != y.w) {
-//    	return x.w < y.w;
+//        return x.w < y.w;
 //    } else {
 //        return x.i < y.i;
 //    }
@@ -32,6 +32,7 @@
 //
 //const int MAXN = 500001;
 //int n, m, q, k;
+//
 //Edge edge[MAXN];
 //QueryEdge queryEdge[MAXN];
 //
@@ -49,13 +50,9 @@
 //    return i;
 //}
 //
-//bool merge(int x, int y) {
+//void Union(int x, int y) {
 //    int fx = find(x);
 //    int fy = find(y);
-//    if (fx == fy) {
-//        rollback[++opsize][0] = 0;
-//        return false;
-//    }
 //    if (siz[fx] < siz[fy]) {
 //        int tmp = fx;
 //        fx = fy;
@@ -65,18 +62,13 @@
 //    siz[fx] += siz[fy];
 //    rollback[++opsize][0] = fx;
 //    rollback[opsize][1] = fy;
-//    return true;
 //}
 //
 //void undo() {
-//    if (rollback[opsize][0] == 0) {
-//        opsize--;
-//    } else {
-//        int fx = rollback[opsize][0];
-//        int fy = rollback[opsize--][1];
-//        father[fy] = fy;
-//        siz[fx] -= siz[fy];
-//    }
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
 //}
 //
 //void prepare() {
@@ -95,17 +87,24 @@
 //    int ei = 1;
 //    for (int l = 1, r = 1; l <= k; l = ++r) {
 //        for (; ei <= m && edge[ei].w < queryEdge[l].w; ei++) {
-//            merge(edge[ei].u, edge[ei].v);
+//            if (find(edge[ei].u) != find(edge[ei].v)) {
+//                Union(edge[ei].u, edge[ei].v);
+//            }
 //        }
 //        while (r + 1 <= k && queryEdge[l].w == queryEdge[r + 1].w && queryEdge[l].i == queryEdge[r + 1].i) {
 //            r++;
 //        }
+//        int unionCnt = 0;
 //        for (int i = l; i <= r; i++) {
-//            if (!merge(queryEdge[i].u, queryEdge[i].v)) {
+//            if (find(queryEdge[i].u) == find(queryEdge[i].v)) {
 //                ans[queryEdge[i].i] = false;
+//                break;
+//            } else {
+//                Union(queryEdge[i].u, queryEdge[i].v);
+//                unionCnt++;
 //            }
 //        }
-//        for (int i = l; i <= r; i++) {
+//        for (int i = 1; i <= unionCnt; i++) {
 //            undo();
 //        }
 //    }
diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
new file mode 100644
index 000000000..356ac2353
--- /dev/null
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -0,0 +1,153 @@
+package class165;
+
+// 团建，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1444C
+// 测试链接 : https://codeforces.com/problemset/problem/1444/C
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code04_TeamBuilding1 {
+
+	public static int MAXN = 500001;
+	public static int n, m, k;
+
+	public static int[] color = new int[MAXN];
+	public static int[][] edge = new int[MAXN][2];
+	public static int[][] crossEdge = new int[MAXN][4];
+	public static int cnt = 0;
+
+	public static boolean[] conflict = new boolean[MAXN];
+
+	public static int[] father = new int[MAXN << 1];
+	public static int[] siz = new int[MAXN << 1];
+	public static int[][] rollback = new int[MAXN << 1][2];
+	public static int opsize;
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+	}
+
+	public static void filter() {
+		for (int i = 1; i <= 2 * n; ++i) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		for (int i = 1, u, v; i <= m; i++) {
+			u = edge[i][0];
+			v = edge[i][1];
+			if (color[u] < color[v]) {
+				crossEdge[++cnt][0] = u;
+				crossEdge[cnt][1] = color[u];
+				crossEdge[cnt][2] = v;
+				crossEdge[cnt][3] = color[v];
+			} else if (color[u] > color[v]) {
+				crossEdge[++cnt][0] = v;
+				crossEdge[cnt][1] = color[v];
+				crossEdge[cnt][2] = u;
+				crossEdge[cnt][3] = color[u];
+			} else {
+				if (conflict[color[u]]) {
+					continue;
+				}
+				if (find(u) == find(v)) {
+					k--;
+					conflict[color[u]] = true;
+				} else {
+					union(u, v + n);
+					union(v, u + n);
+				}
+			}
+		}
+	}
+
+	public static long compute() {
+		Arrays.sort(crossEdge, 1, cnt + 1, (a, b) -> a[1] != b[1] ? (a[1] - b[1]) : (a[3] - b[3]));
+		long ans = (long) k * (k - 1) / 2;
+		for (int l = 1, r = 1; l <= cnt; l = ++r) {
+			while (r + 1 <= cnt && crossEdge[r + 1][1] == crossEdge[l][1] && crossEdge[r + 1][3] == crossEdge[l][3]) {
+				r++;
+			}
+			int u, ucolor, v, vcolor, unionCnt = 0;
+			for (int i = l; i <= r; i++) {
+				u = crossEdge[i][0];
+				ucolor = crossEdge[i][1];
+				v = crossEdge[i][2];
+				vcolor = crossEdge[i][3];
+				if (conflict[ucolor] || conflict[vcolor]) {
+					break;
+				}
+				if (find(u) == find(v)) {
+					ans--;
+					break;
+				} else {
+					union(u, v + n);
+					union(v, u + n);
+					unionCnt += 2;
+				}
+			}
+			for (int i = 1; i <= unionCnt; i++) {
+				undo();
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		for (int i = 1; i <= n; i++) {
+			in.nextToken();
+			color[i] = (int) in.nval;
+		}
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			edge[i][0] = (int) in.nval;
+			in.nextToken();
+			edge[i][1] = (int) in.nval;
+		}
+		filter();
+		out.println(compute());
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}
diff --git a/src/class165/Code04_TeamBuilding2.java b/src/class165/Code04_TeamBuilding2.java
new file mode 100644
index 000000000..5e3b6d4c0
--- /dev/null
+++ b/src/class165/Code04_TeamBuilding2.java
@@ -0,0 +1,147 @@
+package class165;
+
+// 团建，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1444C
+// 测试链接 : https://codeforces.com/problemset/problem/1444/C
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct CrossEdge {
+//    int u, ucolor, v, vcolor;
+//};
+//
+//bool CrossEdgeCmp(CrossEdge x, CrossEdge y) {
+//    if(x.ucolor != y.ucolor) {
+//    	return x.ucolor < y.ucolor;
+//    } else {
+//    	return x.vcolor < y.vcolor;
+//    }
+//}
+//
+//const int MAXN = 500001;
+//int n, m, k;
+//
+//int color[MAXN];
+//int edge[MAXN][2];
+//CrossEdge crossEdge[MAXN];
+//int cnt = 0;
+//
+//bool conflict[MAXN];
+//
+//int father[MAXN << 1];
+//int siz[MAXN << 1];
+//int rollback[MAXN << 1][2];
+//int opsize;
+//
+//int find(int i) {
+//    while (i != father[i]) {
+//        i = father[i];
+//    }
+//    return i;
+//}
+//
+//void Union(int x, int y) {
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
+//}
+//
+//void filter() {
+//    for (int i = 1; i <= 2 * n; ++i) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    for (int i = 1, u, v; i <= m; i++) {
+//        u = edge[i][0];
+//        v = edge[i][1];
+//        if (color[u] < color[v]) {
+//            crossEdge[++cnt].u = u;
+//            crossEdge[cnt].ucolor = color[u];
+//            crossEdge[cnt].v = v;
+//            crossEdge[cnt].vcolor = color[v];
+//        } else if (color[u] > color[v]) {
+//            crossEdge[++cnt].u = v;
+//            crossEdge[cnt].ucolor = color[v];
+//            crossEdge[cnt].v = u;
+//            crossEdge[cnt].vcolor = color[u];
+//        } else {
+//            if (conflict[color[u]]) {
+//                continue;
+//            }
+//            if (find(u) == find(v)) {
+//                k--;
+//                conflict[color[u]] = true;
+//            } else {
+//            	Union(u, v + n);
+//            	Union(v, u + n);
+//            }
+//        }
+//    }
+//}
+//
+//long long compute() {
+//    sort(crossEdge + 1, crossEdge + cnt + 1, CrossEdgeCmp);
+//    long long ans = (long long)k * (k - 1) / 2;
+//    for (int l = 1, r = 1; l <= cnt; l = ++r) {
+//        while (r + 1 <= cnt && crossEdge[r + 1].ucolor == crossEdge[l].ucolor
+//                && crossEdge[r + 1].vcolor == crossEdge[l].vcolor) {
+//            r++;
+//        }
+//        int u, v, ucolor, vcolor, unionCnt = 0;
+//        for (int i = l; i <= r; i++) {
+//            u = crossEdge[i].u;
+//            ucolor = crossEdge[i].ucolor;
+//            v = crossEdge[i].v;
+//            vcolor = crossEdge[i].vcolor;
+//            if (conflict[ucolor] || conflict[vcolor]) {
+//                break;
+//            }
+//            if (find(u) == find(v)) {
+//                ans--;
+//                break;
+//            } else {
+//            	Union(u, v + n);
+//            	Union(v, u + n);
+//                unionCnt += 2;
+//            }
+//        }
+//        for (int i = 1; i <= unionCnt; i++) {
+//            undo();
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> color[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> edge[i][0] >> edge[i][1];
+//    }
+//    filter();
+//    cout << compute() << "\n";
+//    return 0;
+//}
\ No newline at end of file

From 6ba39f215d7e6374df886bd9d1bd910e41cc405b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 8 Apr 2025 17:39:45 +0800
Subject: [PATCH 0671/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java | 7 +++++++
 src/class165/Code01_PersistentUnionFind2.java | 7 +++++++
 src/class165/Code02_UndoUnionFind1.java       | 5 +++++
 src/class165/Code02_UndoUnionFind2.java       | 5 +++++
 src/class165/Code03_Envy1.java                | 4 ++++
 src/class165/Code03_Envy2.java                | 4 ++++
 src/class165/Code04_TeamBuilding1.java        | 8 ++++++++
 src/class165/Code04_TeamBuilding2.java        | 8 ++++++++
 8 files changed, 48 insertions(+)

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
index a04a36597..7f518a5be 100644
--- a/src/class165/Code01_PersistentUnionFind1.java
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -1,6 +1,13 @@
 package class165;
 
 // 可持久化并查集模版题，java版
+// 数字从1到n，一开始每个数字所在的集合只有自己
+// 实现如下三种操作，第i条操作发生后，所有数字的状况记为i版本，操作一共发生m次
+// 操作 1 x y : 基于上个操作生成的版本，将x的集合与y的集合合并，生成当前的版本
+// 操作 2 x   : 拷贝第x号版本的状况，生成当前的版本
+// 操作 3 x y : 拷贝上个操作生成的版本，生成当前的版本，查询x和y是否属于一个集合
+// 1 <= n <= 10^5
+// 1 <= m <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3402
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class165/Code01_PersistentUnionFind2.java b/src/class165/Code01_PersistentUnionFind2.java
index 1d58ae11f..a65671c0c 100644
--- a/src/class165/Code01_PersistentUnionFind2.java
+++ b/src/class165/Code01_PersistentUnionFind2.java
@@ -1,6 +1,13 @@
 package class165;
 
 // 可持久化并查集模版题，C++版
+// 数字从1到n，一开始每个数字所在的集合只有自己
+// 实现如下三种操作，第i条操作发生后，所有数字的状况记为i版本，操作一共发生m次
+// 操作 1 x y : 基于上个操作生成的版本，将x的集合与y的集合合并，生成当前的版本
+// 操作 2 x   : 拷贝第x号版本的状况，生成当前的版本
+// 操作 3 x y : 拷贝上个操作生成的版本，生成当前的版本，查询x和y是否属于一个集合
+// 1 <= n <= 10^5
+// 1 <= m <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3402
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index 07afc3936..bf4f02fa1 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -1,6 +1,11 @@
 package class165;
 
 // 可撤销并查集模版题，java版
+// 一共有n个点，每个点有两个小球，每个点给定两个小球的编号
+// 一共有n-1条无向边，所有节点连成一棵树
+// 对i号点，2 <= i <= n，都计算如下问题的答案并打印
+// 从1号点到i号点的最短路径上，每个点只能拿一个小球，最多能拿几个编号不同的小球
+// 1 <= n <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
 // 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index f80232477..e5e752cb1 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -1,6 +1,11 @@
 package class165;
 
 // 可撤销并查集模版题，C++版
+// 一共有n个点，每个点有两个小球，每个点给定两个小球的编号
+// 一共有n-1条无向边，所有节点连成一棵树
+// 对i号点，2 <= i <= n，都计算如下问题的答案并打印
+// 从1号点到i号点的最短路径上，每个点只能拿一个小球，最多能拿几个编号不同的小球
+// 1 <= n <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc302_h
 // 测试链接 : https://atcoder.jp/contests/abc302/tasks/abc302_h
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class165/Code03_Envy1.java b/src/class165/Code03_Envy1.java
index f8d2399b8..17be5e062 100644
--- a/src/class165/Code03_Envy1.java
+++ b/src/class165/Code03_Envy1.java
@@ -1,6 +1,10 @@
 package class165;
 
 // 同在最小生成树里，java版
+// 一共有n个点，m条无向边，每条边有边权
+// 一共有q次查询，每条查询都给定参数k，表示该查询涉及k条边
+// 然后依次给出k条边的编号，打印这k条边能否同时出现在一颗最小生成树上
+// 1 <= n、m、q、所有查询涉及边的总量 <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF891C
 // 测试链接 : https://codeforces.com/problemset/problem/891/C
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class165/Code03_Envy2.java b/src/class165/Code03_Envy2.java
index f0fb73b16..6dcc88e68 100644
--- a/src/class165/Code03_Envy2.java
+++ b/src/class165/Code03_Envy2.java
@@ -1,6 +1,10 @@
 package class165;
 
 // 同在最小生成树里，C++版
+// 一共有n个点，m条无向边，每条边有边权
+// 一共有q次查询，每条查询都给定参数k，表示该查询涉及k条边
+// 然后依次给出k条边的编号，打印这k条边能否同时出现在一颗最小生成树上
+// 1 <= n、m、q、所有查询涉及边的总量 <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF891C
 // 测试链接 : https://codeforces.com/problemset/problem/891/C
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
index 356ac2353..f4e899bfc 100644
--- a/src/class165/Code04_TeamBuilding1.java
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -1,6 +1,14 @@
 package class165;
 
 // 团建，java版
+// 一共有n个人，编号1~n，一共有k种颜色，编号1~k
+// 每个人给定一种颜色，颜色相同的人认为是一个小组，可能有的颜色的组是没人的
+// 给定m条边，每条边连接两个人，代表这两人之间有矛盾
+// 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
+// 目的是所有人最多分成两个集团，并且每个集团的内部不存在矛盾，每人都要参加
+// 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了
+// 一共有k个组，随意选两个组的情况很多，计算一共有多少个"合法组对"
+// 1 <= n、m、k <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1444C
 // 测试链接 : https://codeforces.com/problemset/problem/1444/C
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class165/Code04_TeamBuilding2.java b/src/class165/Code04_TeamBuilding2.java
index 5e3b6d4c0..45dc820f4 100644
--- a/src/class165/Code04_TeamBuilding2.java
+++ b/src/class165/Code04_TeamBuilding2.java
@@ -1,6 +1,14 @@
 package class165;
 
 // 团建，C++版
+// 一共有n个人，编号1~n，一共有k种颜色，编号1~k
+// 每个人给定一种颜色，颜色相同的人认为是一个小组，可能有的颜色的组是没人的
+// 给定m条边，每条边连接两个人，代表这两人之间有矛盾
+// 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
+// 目的是所有人最多分成两个集团，并且每个集团的内部不存在矛盾，每人都要参加
+// 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了
+// 一共有k个组，随意选两个组的情况很多，计算一共有多少个"合法组对"
+// 1 <= n、m、k <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1444C
 // 测试链接 : https://codeforces.com/problemset/problem/1444/C
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 68b4e794999d2402a73b4afe678db98cf670a366 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 15:13:17 +0800
Subject: [PATCH 0672/1712] modify code

---
 src/class165/Code04_TeamBuilding1.java | 23 ++++++++++++++++-------
 src/class165/Code04_TeamBuilding2.java | 17 +++++++++--------
 2 files changed, 25 insertions(+), 15 deletions(-)

diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
index f4e899bfc..27fcac2ad 100644
--- a/src/class165/Code04_TeamBuilding1.java
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -26,13 +26,21 @@ public class Code04_TeamBuilding1 {
 	public static int MAXN = 500001;
 	public static int n, m, k;
 
+	// 每个节点的颜色
 	public static int[] color = new int[MAXN];
+	// 每条边有两个端点
 	public static int[][] edge = new int[MAXN][2];
+
+	// 两个端点为不同颜色的边，u、ucolor、v、vcolor
 	public static int[][] crossEdge = new int[MAXN][4];
+	// 两个端点为不同颜色的边的数量
 	public static int cnt = 0;
 
+	// conflict[i] = true，表示颜色为i的组，组内即便是二分图，也无法调和矛盾
+	// conflict[i] = false，表示颜色为i的组，组内构成二分图，可以调和矛盾
 	public static boolean[] conflict = new boolean[MAXN];
 
+	// 可撤销并查集
 	public static int[] father = new int[MAXN << 1];
 	public static int[] siz = new int[MAXN << 1];
 	public static int[][] rollback = new int[MAXN << 1][2];
@@ -102,19 +110,20 @@ public static void filter() {
 	public static long compute() {
 		Arrays.sort(crossEdge, 1, cnt + 1, (a, b) -> a[1] != b[1] ? (a[1] - b[1]) : (a[3] - b[3]));
 		long ans = (long) k * (k - 1) / 2;
+		int u, ucolor, v, vcolor, unionCnt;
 		for (int l = 1, r = 1; l <= cnt; l = ++r) {
-			while (r + 1 <= cnt && crossEdge[r + 1][1] == crossEdge[l][1] && crossEdge[r + 1][3] == crossEdge[l][3]) {
+			ucolor = crossEdge[l][1];
+			vcolor = crossEdge[l][3];
+			while (r + 1 <= cnt && crossEdge[r + 1][1] == ucolor && crossEdge[r + 1][3] == vcolor) {
 				r++;
 			}
-			int u, ucolor, v, vcolor, unionCnt = 0;
+			if (conflict[ucolor] || conflict[vcolor]) {
+				continue;
+			}
+			unionCnt = 0;
 			for (int i = l; i <= r; i++) {
 				u = crossEdge[i][0];
-				ucolor = crossEdge[i][1];
 				v = crossEdge[i][2];
-				vcolor = crossEdge[i][3];
-				if (conflict[ucolor] || conflict[vcolor]) {
-					break;
-				}
 				if (find(u) == find(v)) {
 					ans--;
 					break;
diff --git a/src/class165/Code04_TeamBuilding2.java b/src/class165/Code04_TeamBuilding2.java
index 45dc820f4..7865fe42c 100644
--- a/src/class165/Code04_TeamBuilding2.java
+++ b/src/class165/Code04_TeamBuilding2.java
@@ -35,6 +35,7 @@
 //
 //int color[MAXN];
 //int edge[MAXN][2];
+//
 //CrossEdge crossEdge[MAXN];
 //int cnt = 0;
 //
@@ -109,20 +110,20 @@
 //long long compute() {
 //    sort(crossEdge + 1, crossEdge + cnt + 1, CrossEdgeCmp);
 //    long long ans = (long long)k * (k - 1) / 2;
+//    int u, ucolor, v, vcolor, unionCnt;
 //    for (int l = 1, r = 1; l <= cnt; l = ++r) {
-//        while (r + 1 <= cnt && crossEdge[r + 1].ucolor == crossEdge[l].ucolor
-//                && crossEdge[r + 1].vcolor == crossEdge[l].vcolor) {
+//        ucolor = crossEdge[l].ucolor;
+//        vcolor = crossEdge[l].vcolor;
+//        while (r + 1 <= cnt && crossEdge[r + 1].ucolor == ucolor && crossEdge[r + 1].vcolor == vcolor) {
 //            r++;
 //        }
-//        int u, v, ucolor, vcolor, unionCnt = 0;
+//        if (conflict[ucolor] || conflict[vcolor]) {
+//            continue;
+//        }
+//        unionCnt = 0;
 //        for (int i = l; i <= r; i++) {
 //            u = crossEdge[i].u;
-//            ucolor = crossEdge[i].ucolor;
 //            v = crossEdge[i].v;
-//            vcolor = crossEdge[i].vcolor;
-//            if (conflict[ucolor] || conflict[vcolor]) {
-//                break;
-//            }
 //            if (find(u) == find(v)) {
 //                ans--;
 //                break;

From 50a2deec6d7e466517d0067f048985deb6d37ec0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 15:43:13 +0800
Subject: [PATCH 0673/1712] modify code

---
 src/class165/Code04_TeamBuilding1.java | 2 +-
 src/class165/Code04_TeamBuilding2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
index 27fcac2ad..c598ba80e 100644
--- a/src/class165/Code04_TeamBuilding1.java
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -5,7 +5,7 @@
 // 每个人给定一种颜色，颜色相同的人认为是一个小组，可能有的颜色的组是没人的
 // 给定m条边，每条边连接两个人，代表这两人之间有矛盾
 // 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
-// 目的是所有人最多分成两个集团，并且每个集团的内部不存在矛盾，每人都要参加
+// 如果所有人最多分成两个集团，每人都要参加划分，并且每个集团的内部不存在矛盾
 // 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了
 // 一共有k个组，随意选两个组的情况很多，计算一共有多少个"合法组对"
 // 1 <= n、m、k <= 5 * 10^5
diff --git a/src/class165/Code04_TeamBuilding2.java b/src/class165/Code04_TeamBuilding2.java
index 7865fe42c..736017613 100644
--- a/src/class165/Code04_TeamBuilding2.java
+++ b/src/class165/Code04_TeamBuilding2.java
@@ -5,7 +5,7 @@
 // 每个人给定一种颜色，颜色相同的人认为是一个小组，可能有的颜色的组是没人的
 // 给定m条边，每条边连接两个人，代表这两人之间有矛盾
 // 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
-// 目的是所有人最多分成两个集团，并且每个集团的内部不存在矛盾，每人都要参加
+// 如果所有人最多分成两个集团，每人都要参加划分，并且每个集团的内部不存在矛盾
 // 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了
 // 一共有k个组，随意选两个组的情况很多，计算一共有多少个"合法组对"
 // 1 <= n、m、k <= 5 * 10^5

From cbcb9853bc6fc9112416f68605a5938d63ac2b71 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 15:52:26 +0800
Subject: [PATCH 0674/1712] modify code

---
 src/class165/Code04_TeamBuilding1.java | 5 ++---
 src/class165/Code04_TeamBuilding2.java | 5 ++---
 2 files changed, 4 insertions(+), 6 deletions(-)

diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
index c598ba80e..5b89d3e7c 100644
--- a/src/class165/Code04_TeamBuilding1.java
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -1,9 +1,8 @@
 package class165;
 
 // 团建，java版
-// 一共有n个人，编号1~n，一共有k种颜色，编号1~k
-// 每个人给定一种颜色，颜色相同的人认为是一个小组，可能有的颜色的组是没人的
-// 给定m条边，每条边连接两个人，代表这两人之间有矛盾
+// 一共有n个人，每个人给定一种颜色，一共有m条边，每条边连接两个人，代表这两人之间有矛盾
+// 一共有k种颜色，颜色相同的人在一个小组，一种颜色代表一个组，可能有的组没人，但组是存在的
 // 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
 // 如果所有人最多分成两个集团，每人都要参加划分，并且每个集团的内部不存在矛盾
 // 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了
diff --git a/src/class165/Code04_TeamBuilding2.java b/src/class165/Code04_TeamBuilding2.java
index 736017613..e415524f9 100644
--- a/src/class165/Code04_TeamBuilding2.java
+++ b/src/class165/Code04_TeamBuilding2.java
@@ -1,9 +1,8 @@
 package class165;
 
 // 团建，C++版
-// 一共有n个人，编号1~n，一共有k种颜色，编号1~k
-// 每个人给定一种颜色，颜色相同的人认为是一个小组，可能有的颜色的组是没人的
-// 给定m条边，每条边连接两个人，代表这两人之间有矛盾
+// 一共有n个人，每个人给定一种颜色，一共有m条边，每条边连接两个人，代表这两人之间有矛盾
+// 一共有k种颜色，颜色相同的人在一个小组，一种颜色代表一个组，可能有的组没人，但组是存在的
 // 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
 // 如果所有人最多分成两个集团，每人都要参加划分，并且每个集团的内部不存在矛盾
 // 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了

From c831d7d02bd411d9d9e5589bca45def8a77ac4d7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 16:06:29 +0800
Subject: [PATCH 0675/1712] modify code

---
 src/class165/Code04_TeamBuilding1.java | 44 +++++++++++++-------------
 src/class165/Code04_TeamBuilding2.java | 42 ++++++++++++------------
 2 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
index 5b89d3e7c..421923c12 100644
--- a/src/class165/Code04_TeamBuilding1.java
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -1,8 +1,8 @@
 package class165;
 
 // 团建，java版
-// 一共有n个人，每个人给定一种颜色，一共有m条边，每条边连接两个人，代表这两人之间有矛盾
-// 一共有k种颜色，颜色相同的人在一个小组，一种颜色代表一个组，可能有的组没人，但组是存在的
+// 一共有n个人，每个人给定组号，一共有m条边，代表两人之间有矛盾
+// 一共有k个小组，可能有的组没人，但是组依然存在
 // 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
 // 如果所有人最多分成两个集团，每人都要参加划分，并且每个集团的内部不存在矛盾
 // 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了
@@ -25,18 +25,18 @@ public class Code04_TeamBuilding1 {
 	public static int MAXN = 500001;
 	public static int n, m, k;
 
-	// 每个节点的颜色
-	public static int[] color = new int[MAXN];
+	// 每个节点的组号
+	public static int[] team = new int[MAXN];
 	// 每条边有两个端点
 	public static int[][] edge = new int[MAXN][2];
 
-	// 两个端点为不同颜色的边，u、ucolor、v、vcolor
+	// 两个端点为不同组的边，u、uteam、v、vteam
 	public static int[][] crossEdge = new int[MAXN][4];
-	// 两个端点为不同颜色的边的数量
+	// 两个端点为不同组的边的数量
 	public static int cnt = 0;
 
-	// conflict[i] = true，表示颜色为i的组，组内即便是二分图，也无法调和矛盾
-	// conflict[i] = false，表示颜色为i的组，组内构成二分图，可以调和矛盾
+	// conflict[i] = true，表示i号组去划分二分图，也无法调和矛盾
+	// conflict[i] = false，表示i号组去划分二分图，可以调和矛盾
 	public static boolean[] conflict = new boolean[MAXN];
 
 	// 可撤销并查集
@@ -81,23 +81,23 @@ public static void filter() {
 		for (int i = 1, u, v; i <= m; i++) {
 			u = edge[i][0];
 			v = edge[i][1];
-			if (color[u] < color[v]) {
+			if (team[u] < team[v]) {
 				crossEdge[++cnt][0] = u;
-				crossEdge[cnt][1] = color[u];
+				crossEdge[cnt][1] = team[u];
 				crossEdge[cnt][2] = v;
-				crossEdge[cnt][3] = color[v];
-			} else if (color[u] > color[v]) {
+				crossEdge[cnt][3] = team[v];
+			} else if (team[u] > team[v]) {
 				crossEdge[++cnt][0] = v;
-				crossEdge[cnt][1] = color[v];
+				crossEdge[cnt][1] = team[v];
 				crossEdge[cnt][2] = u;
-				crossEdge[cnt][3] = color[u];
+				crossEdge[cnt][3] = team[u];
 			} else {
-				if (conflict[color[u]]) {
+				if (conflict[team[u]]) {
 					continue;
 				}
 				if (find(u) == find(v)) {
 					k--;
-					conflict[color[u]] = true;
+					conflict[team[u]] = true;
 				} else {
 					union(u, v + n);
 					union(v, u + n);
@@ -109,14 +109,14 @@ public static void filter() {
 	public static long compute() {
 		Arrays.sort(crossEdge, 1, cnt + 1, (a, b) -> a[1] != b[1] ? (a[1] - b[1]) : (a[3] - b[3]));
 		long ans = (long) k * (k - 1) / 2;
-		int u, ucolor, v, vcolor, unionCnt;
+		int u, uteam, v, vteam, unionCnt;
 		for (int l = 1, r = 1; l <= cnt; l = ++r) {
-			ucolor = crossEdge[l][1];
-			vcolor = crossEdge[l][3];
-			while (r + 1 <= cnt && crossEdge[r + 1][1] == ucolor && crossEdge[r + 1][3] == vcolor) {
+			uteam = crossEdge[l][1];
+			vteam = crossEdge[l][3];
+			while (r + 1 <= cnt && crossEdge[r + 1][1] == uteam && crossEdge[r + 1][3] == vteam) {
 				r++;
 			}
-			if (conflict[ucolor] || conflict[vcolor]) {
+			if (conflict[uteam] || conflict[vteam]) {
 				continue;
 			}
 			unionCnt = 0;
@@ -151,7 +151,7 @@ public static void main(String[] args) throws IOException {
 		k = (int) in.nval;
 		for (int i = 1; i <= n; i++) {
 			in.nextToken();
-			color[i] = (int) in.nval;
+			team[i] = (int) in.nval;
 		}
 		for (int i = 1; i <= m; i++) {
 			in.nextToken();
diff --git a/src/class165/Code04_TeamBuilding2.java b/src/class165/Code04_TeamBuilding2.java
index e415524f9..f7f9d83e5 100644
--- a/src/class165/Code04_TeamBuilding2.java
+++ b/src/class165/Code04_TeamBuilding2.java
@@ -1,8 +1,8 @@
 package class165;
 
 // 团建，C++版
-// 一共有n个人，每个人给定一种颜色，一共有m条边，每条边连接两个人，代表这两人之间有矛盾
-// 一共有k种颜色，颜色相同的人在一个小组，一种颜色代表一个组，可能有的组没人，但组是存在的
+// 一共有n个人，每个人给定组号，一共有m条边，代表两人之间有矛盾
+// 一共有k个小组，可能有的组没人，但是组依然存在
 // 假设组a和组b，两个组的人一起去团建，组a和组b的所有人，可以重新打乱
 // 如果所有人最多分成两个集团，每人都要参加划分，并且每个集团的内部不存在矛盾
 // 那么组a和组b就叫做一个"合法组对"，注意，组b和组a就不用重复计算了
@@ -18,21 +18,21 @@
 //using namespace std;
 //
 //struct CrossEdge {
-//    int u, ucolor, v, vcolor;
+//    int u, uteam, v, vteam;
 //};
 //
 //bool CrossEdgeCmp(CrossEdge x, CrossEdge y) {
-//    if(x.ucolor != y.ucolor) {
-//    	return x.ucolor < y.ucolor;
+//    if(x.uteam != y.uteam) {
+//    	return x.uteam < y.uteam;
 //    } else {
-//    	return x.vcolor < y.vcolor;
+//    	return x.vteam < y.vteam;
 //    }
 //}
 //
 //const int MAXN = 500001;
 //int n, m, k;
 //
-//int color[MAXN];
+//int team[MAXN];
 //int edge[MAXN][2];
 //
 //CrossEdge crossEdge[MAXN];
@@ -81,23 +81,23 @@
 //    for (int i = 1, u, v; i <= m; i++) {
 //        u = edge[i][0];
 //        v = edge[i][1];
-//        if (color[u] < color[v]) {
+//        if (team[u] < team[v]) {
 //            crossEdge[++cnt].u = u;
-//            crossEdge[cnt].ucolor = color[u];
+//            crossEdge[cnt].uteam = team[u];
 //            crossEdge[cnt].v = v;
-//            crossEdge[cnt].vcolor = color[v];
-//        } else if (color[u] > color[v]) {
+//            crossEdge[cnt].vteam = team[v];
+//        } else if (team[u] > team[v]) {
 //            crossEdge[++cnt].u = v;
-//            crossEdge[cnt].ucolor = color[v];
+//            crossEdge[cnt].uteam = team[v];
 //            crossEdge[cnt].v = u;
-//            crossEdge[cnt].vcolor = color[u];
+//            crossEdge[cnt].vteam = team[u];
 //        } else {
-//            if (conflict[color[u]]) {
+//            if (conflict[team[u]]) {
 //                continue;
 //            }
 //            if (find(u) == find(v)) {
 //                k--;
-//                conflict[color[u]] = true;
+//                conflict[team[u]] = true;
 //            } else {
 //            	Union(u, v + n);
 //            	Union(v, u + n);
@@ -109,14 +109,14 @@
 //long long compute() {
 //    sort(crossEdge + 1, crossEdge + cnt + 1, CrossEdgeCmp);
 //    long long ans = (long long)k * (k - 1) / 2;
-//    int u, ucolor, v, vcolor, unionCnt;
+//    int u, uteam, v, vteam, unionCnt;
 //    for (int l = 1, r = 1; l <= cnt; l = ++r) {
-//        ucolor = crossEdge[l].ucolor;
-//        vcolor = crossEdge[l].vcolor;
-//        while (r + 1 <= cnt && crossEdge[r + 1].ucolor == ucolor && crossEdge[r + 1].vcolor == vcolor) {
+//        uteam = crossEdge[l].uteam;
+//        vteam = crossEdge[l].vteam;
+//        while (r + 1 <= cnt && crossEdge[r + 1].uteam == uteam && crossEdge[r + 1].vteam == vteam) {
 //            r++;
 //        }
-//        if (conflict[ucolor] || conflict[vcolor]) {
+//        if (conflict[uteam] || conflict[vteam]) {
 //            continue;
 //        }
 //        unionCnt = 0;
@@ -144,7 +144,7 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m >> k;
 //    for (int i = 1; i <= n; i++) {
-//        cin >> color[i];
+//        cin >> team[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cin >> edge[i][0] >> edge[i][1];

From 674b054012a999a327c4dea03acc50f157815a87 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 16:16:30 +0800
Subject: [PATCH 0676/1712] modify code

---
 src/class165/Code02_UndoUnionFind1.java | 10 ++++++----
 src/class165/Code02_UndoUnionFind2.java | 10 ++++++----
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index bf4f02fa1..610a20d6b 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -76,18 +76,18 @@ public static void undo() {
 	public static void dfs(int u, int fa) {
 		int fx = find(arr[u][0]);
 		int fy = find(arr[u][1]);
+		boolean added = false;
 		boolean unioned = false;
-		int add = 0;
 		if (fx == fy) {
 			if (edgeCnt[fx] < siz[fx]) {
 				ball++;
-				add = 1;
+				added = true;
 			}
 			edgeCnt[fx]++;
 		} else {
 			if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
 				ball++;
-				add = 1;
+				added = true;
 			}
 			union(fx, fy);
 			unioned = true;
@@ -98,12 +98,14 @@ public static void dfs(int u, int fa) {
 				dfs(to[e], u);
 			}
 		}
+		if (added) {
+			ball--;
+		}
 		if (unioned) {
 			undo();
 		} else {
 			edgeCnt[fx]--;
 		}
-		ball -= add;
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index e5e752cb1..d9d5e2528 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -72,18 +72,18 @@
 //void dfs(int u, int fa) {
 //    int fx = find(arr[u][0]);
 //    int fy = find(arr[u][1]);
+//    bool added = false;
 //    bool unioned = false;
-//    int add = 0;
 //    if (fx == fy) {
 //        if (edgeCnt[fx] < siz[fx]) {
 //            ball++;
-//            add = 1;
+//            added = true;
 //        }
 //        edgeCnt[fx]++;
 //    } else {
 //        if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
 //            ball++;
-//            add = 1;
+//            added = true;
 //        }
 //        Union(fx, fy);
 //        unioned = true;
@@ -94,12 +94,14 @@
 //            dfs(to[e], u);
 //        }
 //    }
+//    if (added) {
+//        ball--;
+//    }
 //    if (unioned) {
 //        undo();
 //    } else {
 //        edgeCnt[fx]--;
 //    }
-//    ball -= add;
 //}
 //
 //int main() {

From cbe3da72c0659886ce1247cb43df015f4a15514c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 16:56:52 +0800
Subject: [PATCH 0677/1712] modify code

---
 src/class165/Code02_UndoUnionFind1.java | 4 ++--
 src/class165/Code02_UndoUnionFind2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index 610a20d6b..bbeaca744 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -79,13 +79,13 @@ public static void dfs(int u, int fa) {
 		boolean added = false;
 		boolean unioned = false;
 		if (fx == fy) {
-			if (edgeCnt[fx] < siz[fx]) {
+			if (edgeCnt[fx] == siz[fx] - 1) {
 				ball++;
 				added = true;
 			}
 			edgeCnt[fx]++;
 		} else {
-			if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
+			if (edgeCnt[fx] == siz[fx] - 1 || edgeCnt[fy] == siz[fy] - 1) {
 				ball++;
 				added = true;
 			}
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index d9d5e2528..061c7ef54 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -75,13 +75,13 @@
 //    bool added = false;
 //    bool unioned = false;
 //    if (fx == fy) {
-//        if (edgeCnt[fx] < siz[fx]) {
+//        if (edgeCnt[fx] == siz[fx] - 1) {
 //            ball++;
 //            added = true;
 //        }
 //        edgeCnt[fx]++;
 //    } else {
-//        if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
+//        if (edgeCnt[fx] == siz[fx] - 1 || edgeCnt[fy] == siz[fy] - 1) {
 //            ball++;
 //            added = true;
 //        }

From 3f5acfae1165b3cdd1f3d83d76ea0f8e4602d72d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 17:02:18 +0800
Subject: [PATCH 0678/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
index 7f518a5be..4c2a82baa 100644
--- a/src/class165/Code01_PersistentUnionFind1.java
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -24,6 +24,7 @@ public class Code01_PersistentUnionFind1 {
 	public static int MAXT = 8000001;
 	public static int n, m;
 
+	// 可持久化线段树
 	public static int[] rootfa = new int[MAXM];
 	public static int[] rootsiz = new int[MAXM];
 	public static int[] ls = new int[MAXT];
@@ -31,6 +32,7 @@ public class Code01_PersistentUnionFind1 {
 	public static int[] val = new int[MAXT];
 	public static int cnt = 0;
 
+	// 建立可持久化的father数组
 	public static int buildfa(int l, int r) {
 		int rt = ++cnt;
 		if (l == r) {
@@ -43,6 +45,7 @@ public static int buildfa(int l, int r) {
 		return rt;
 	}
 
+	// 建立可持久化的siz数组
 	public static int buildsiz(int l, int r) {
 		int rt = ++cnt;
 		if (l == r) {
@@ -55,6 +58,7 @@ public static int buildsiz(int l, int r) {
 		return rt;
 	}
 
+	// 来自讲解157，题目1，修改数组中一个位置的值，生成新版本的树
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
 		ls[rt] = ls[i];
@@ -72,6 +76,7 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
+	// 来自讲解157，题目1，查询数组中一个位置的值
 	public static int query(int jobi, int l, int r, int i) {
 		if (l == r) {
 			return val[i];
@@ -84,6 +89,7 @@ public static int query(int jobi, int l, int r, int i) {
 		}
 	}
 
+	// 基于v版本，查询x的集合头节点，不做扁平化
 	public static int find(int x, int v) {
 		int fa = query(x, 1, n, rootfa[v]);
 		while (x != fa) {
@@ -93,6 +99,7 @@ public static int find(int x, int v) {
 		return x;
 	}
 
+	// 基于v版本，合并x所在的集合和y所在的集合，生成新版本的树
 	public static void union(int x, int y, int v) {
 		int fx = find(x, v);
 		int fy = find(y, v);

From bb925b78c98a64e2d1d8dfa4b3211b4e7fa132b7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 17:11:57 +0800
Subject: [PATCH 0679/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java | 15 ++++++++++++---
 1 file changed, 12 insertions(+), 3 deletions(-)

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
index 4c2a82baa..e6879b571 100644
--- a/src/class165/Code01_PersistentUnionFind1.java
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -24,9 +24,14 @@ public class Code01_PersistentUnionFind1 {
 	public static int MAXT = 8000001;
 	public static int n, m;
 
-	// 可持久化线段树
+	// rootfa[i] = j，表示father数组，i版本的头节点编号为j
 	public static int[] rootfa = new int[MAXM];
+
+	// rootsiz[i] = j，表示siz数组，i版本的头节点编号为j
 	public static int[] rootsiz = new int[MAXM];
+
+	// 可持久化father数组和可持久化siz数组，共用一个ls、rs、val
+	// 因为可持久化时，分配的节点编号不同，所以可以共用
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static int[] val = new int[MAXT];
@@ -58,7 +63,9 @@ public static int buildsiz(int l, int r) {
 		return rt;
 	}
 
-	// 来自讲解157，题目1，修改数组中一个位置的值，生成新版本的树
+	// 来自讲解157，题目1，修改数组中一个位置的值，生成新版本的数组
+	// 如果i属于可持久化father数组的节点，那么修改的就是father数组
+	// 如果i属于可持久化siz数组的节点，那么修改的就是siz数组
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = ++cnt;
 		ls[rt] = ls[i];
@@ -77,6 +84,8 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 	}
 
 	// 来自讲解157，题目1，查询数组中一个位置的值
+	// 如果i属于可持久化father数组的节点，那么查询的就是father数组
+	// 如果i属于可持久化siz数组的节点，那么查询的就是siz数组
 	public static int query(int jobi, int l, int r, int i) {
 		if (l == r) {
 			return val[i];
@@ -99,7 +108,7 @@ public static int find(int x, int v) {
 		return x;
 	}
 
-	// 基于v版本，合并x所在的集合和y所在的集合，生成新版本的树
+	// 基于v版本，合并x所在的集合和y所在的集合，生成新版本的数组
 	public static void union(int x, int y, int v) {
 		int fx = find(x, v);
 		int fy = find(y, v);

From 73b477fa24bb7cb57e8c22b6c5749934ea549c48 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Apr 2025 19:30:39 +0800
Subject: [PATCH 0680/1712] modify code

---
 src/class165/Code01_PersistentUnionFind1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class165/Code01_PersistentUnionFind1.java b/src/class165/Code01_PersistentUnionFind1.java
index e6879b571..b13925220 100644
--- a/src/class165/Code01_PersistentUnionFind1.java
+++ b/src/class165/Code01_PersistentUnionFind1.java
@@ -108,7 +108,7 @@ public static int find(int x, int v) {
 		return x;
 	}
 
-	// 基于v版本，合并x所在的集合和y所在的集合，生成新版本的数组
+	// v版本已经拷贝了v-1版本，合并x所在的集合和y所在的集合，去更新v版本
 	public static void union(int x, int y, int v) {
 		int fx = find(x, v);
 		int fy = find(y, v);

From 1066bd60776cc8697e43c0542870f41f7259c603 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Apr 2025 17:53:21 +0800
Subject: [PATCH 0681/1712] modify code

---
 src/class165/Code02_UndoUnionFind1.java | 4 ++--
 src/class165/Code02_UndoUnionFind2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class165/Code02_UndoUnionFind1.java b/src/class165/Code02_UndoUnionFind1.java
index bbeaca744..610a20d6b 100644
--- a/src/class165/Code02_UndoUnionFind1.java
+++ b/src/class165/Code02_UndoUnionFind1.java
@@ -79,13 +79,13 @@ public static void dfs(int u, int fa) {
 		boolean added = false;
 		boolean unioned = false;
 		if (fx == fy) {
-			if (edgeCnt[fx] == siz[fx] - 1) {
+			if (edgeCnt[fx] < siz[fx]) {
 				ball++;
 				added = true;
 			}
 			edgeCnt[fx]++;
 		} else {
-			if (edgeCnt[fx] == siz[fx] - 1 || edgeCnt[fy] == siz[fy] - 1) {
+			if (edgeCnt[fx] < siz[fx] || edgeCnt[fy] < siz[fy]) {
 				ball++;
 				added = true;
 			}
diff --git a/src/class165/Code02_UndoUnionFind2.java b/src/class165/Code02_UndoUnionFind2.java
index 061c7ef54..e72fb93d1 100644
--- a/src/class165/Code02_UndoUnionFind2.java
+++ b/src/class165/Code02_UndoUnionFind2.java
@@ -75,13 +75,13 @@
 //    bool added = false;
 //    bool unioned = false;
 //    if (fx == fy) {
-//        if (edgeCnt[fx] == siz[fx] - 1) {
+//        if (edgeCnt[fx] < siz[fx]) {
 //            ball++;
 //            added = true;
 //        }
 //        edgeCnt[fx]++;
 //    } else {
-//        if (edgeCnt[fx] == siz[fx] - 1 || edgeCnt[fy] == siz[fy] - 1) {
+//        if (edgeCnt[fx] < siz[fx]|| edgeCnt[fy] < siz[fy]) {
 //            ball++;
 //            added = true;
 //        }

From af22f513ab6ed5ce6bd19e78d8936863034ac8c3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Apr 2025 18:45:21 +0800
Subject: [PATCH 0682/1712] modify code

---
 src/class165/Code03_Envy1.java | 33 ++++++++++++++++++-------------
 src/class165/Code03_Envy2.java | 36 +++++++++++++++++++---------------
 2 files changed, 39 insertions(+), 30 deletions(-)

diff --git a/src/class165/Code03_Envy1.java b/src/class165/Code03_Envy1.java
index 17be5e062..fb0226a8c 100644
--- a/src/class165/Code03_Envy1.java
+++ b/src/class165/Code03_Envy1.java
@@ -25,7 +25,7 @@ public class Code03_Envy1 {
 	// 节点u、节点v、边权w
 	public static int[][] edge = new int[MAXN][3];
 	// 节点u、节点v、边权w、问题编号i
-	public static int[][] queryEdge = new int[MAXN][4];
+	public static int[][] queries = new int[MAXN][4];
 
 	// 可撤销并查集
 	public static int[] father = new int[MAXN];
@@ -70,28 +70,33 @@ public static void prepare() {
 			siz[i] = 1;
 		}
 		Arrays.sort(edge, 1, m + 1, (a, b) -> a[2] - b[2]);
-		Arrays.sort(queryEdge, 1, k + 1, (a, b) -> a[2] != b[2] ? (a[2] - b[2]) : (a[3] - b[3]));
+		Arrays.sort(queries, 1, k + 1, (a, b) -> a[2] != b[2] ? (a[2] - b[2]) : (a[3] - b[3]));
 		Arrays.fill(ans, 1, q + 1, true);
 	}
 
 	public static void compute() {
-		int ei = 1;
+		int ei = 1, queryId, unionCnt;
 		for (int l = 1, r = 1; l <= k; l = ++r) {
-			for (; ei <= m && edge[ei][2] < queryEdge[l][2]; ei++) {
+			while (r + 1 <= k && queries[l][2] == queries[r + 1][2] && queries[l][3] == queries[r + 1][3]) {
+				r++;
+			}
+			// 添加小于当前边权的边，利用Kruskal算法增加连通性，ei是不回退的
+			for (; ei <= m && edge[ei][2] < queries[l][2]; ei++) {
 				if (find(edge[ei][0]) != find(edge[ei][1])) {
 					union(edge[ei][0], edge[ei][1]);
 				}
 			}
-			while (r + 1 <= k && queryEdge[l][2] == queryEdge[r + 1][2] && queryEdge[l][3] == queryEdge[r + 1][3]) {
-				r++;
+			queryId = queries[l][3];
+			if (!ans[queryId]) {
+				continue;
 			}
-			int unionCnt = 0;
+			unionCnt = 0;
 			for (int i = l; i <= r; i++) {
-				if (find(queryEdge[i][0]) == find(queryEdge[i][1])) {
-					ans[queryEdge[i][3]] = false;
+				if (find(queries[i][0]) == find(queries[i][1])) {
+					ans[queryId] = false;
 					break;
 				} else {
-					union(queryEdge[i][0], queryEdge[i][1]);
+					union(queries[i][0], queries[i][1]);
 					unionCnt++;
 				}
 			}
@@ -126,10 +131,10 @@ public static void main(String[] args) throws IOException {
 			for (int j = 1, ei; j <= s; j++) {
 				in.nextToken();
 				ei = (int) in.nval;
-				queryEdge[++k][0] = edge[ei][0];
-				queryEdge[k][1] = edge[ei][1];
-				queryEdge[k][2] = edge[ei][2];
-				queryEdge[k][3] = i;
+				queries[++k][0] = edge[ei][0];
+				queries[k][1] = edge[ei][1];
+				queries[k][2] = edge[ei][2];
+				queries[k][3] = i;
 			}
 		}
 		prepare();
diff --git a/src/class165/Code03_Envy2.java b/src/class165/Code03_Envy2.java
index 6dcc88e68..723ac946b 100644
--- a/src/class165/Code03_Envy2.java
+++ b/src/class165/Code03_Envy2.java
@@ -22,11 +22,11 @@
 //    return x.w < y.w;
 //}
 //
-//struct QueryEdge {
+//struct Query {
 //    int u, v, w, i;
 //};
 //
-//bool QueryEdgeCmp(QueryEdge x, QueryEdge y) {
+//bool QueryCmp(Query x, Query y) {
 //    if(x.w != y.w) {
 //        return x.w < y.w;
 //    } else {
@@ -38,7 +38,7 @@
 //int n, m, q, k;
 //
 //Edge edge[MAXN];
-//QueryEdge queryEdge[MAXN];
+//Query queries[MAXN];
 //
 //int father[MAXN];
 //int siz[MAXN];
@@ -81,30 +81,34 @@
 //        siz[i] = 1;
 //    }
 //    sort(edge + 1, edge + m + 1, EdgeCmp);
-//    sort(queryEdge + 1, queryEdge + k + 1, QueryEdgeCmp);
+//    sort(queries + 1, queries + k + 1, QueryCmp);
 //    for (int i = 1; i <= q; i++) {
 //        ans[i] = true;
 //    }
 //}
 //
 //void compute() {
-//    int ei = 1;
+//    int ei = 1, queryId, unionCnt;
 //    for (int l = 1, r = 1; l <= k; l = ++r) {
-//        for (; ei <= m && edge[ei].w < queryEdge[l].w; ei++) {
+//        while (r + 1 <= k && queries[l].w == queries[r + 1].w && queries[l].i == queries[r + 1].i) {
+//            r++;
+//        }
+//        for (; ei <= m && edge[ei].w < queries[l].w; ei++) {
 //            if (find(edge[ei].u) != find(edge[ei].v)) {
 //                Union(edge[ei].u, edge[ei].v);
 //            }
 //        }
-//        while (r + 1 <= k && queryEdge[l].w == queryEdge[r + 1].w && queryEdge[l].i == queryEdge[r + 1].i) {
-//            r++;
+//        queryId = queries[l].i;
+//        if (!ans[queryId]) {
+//            continue;
 //        }
-//        int unionCnt = 0;
+//        unionCnt = 0;
 //        for (int i = l; i <= r; i++) {
-//            if (find(queryEdge[i].u) == find(queryEdge[i].v)) {
-//                ans[queryEdge[i].i] = false;
+//            if (find(queries[i].u) == find(queries[i].v)) {
+//                ans[queryId] = false;
 //                break;
 //            } else {
-//                Union(queryEdge[i].u, queryEdge[i].v);
+//                Union(queries[i].u, queries[i].v);
 //                unionCnt++;
 //            }
 //        }
@@ -127,10 +131,10 @@
 //        cin >> s;
 //        for (int j = 1, ei; j <= s; j++) {
 //            cin >> ei;
-//            queryEdge[++k].u = edge[ei].u;
-//            queryEdge[k].v = edge[ei].v;
-//            queryEdge[k].w = edge[ei].w;
-//            queryEdge[k].i = i;
+//            queries[++k].u = edge[ei].u;
+//            queries[k].v = edge[ei].v;
+//            queries[k].w = edge[ei].w;
+//            queries[k].i = i;
 //        }
 //    }
 //    prepare();

From 6d3b1dae929e73b7792b4e6bb55f99d6582c52c6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Apr 2025 20:09:47 +0800
Subject: [PATCH 0683/1712] modify code

---
 src/class165/Code03_Envy1.java | 2 +-
 src/class165/Code03_Envy2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class165/Code03_Envy1.java b/src/class165/Code03_Envy1.java
index fb0226a8c..0efc5ef15 100644
--- a/src/class165/Code03_Envy1.java
+++ b/src/class165/Code03_Envy1.java
@@ -1,7 +1,7 @@
 package class165;
 
 // 同在最小生成树里，java版
-// 一共有n个点，m条无向边，每条边有边权
+// 一共有n个点，m条无向边，每条边有边权，图保证是连通的
 // 一共有q次查询，每条查询都给定参数k，表示该查询涉及k条边
 // 然后依次给出k条边的编号，打印这k条边能否同时出现在一颗最小生成树上
 // 1 <= n、m、q、所有查询涉及边的总量 <= 5 * 10^5
diff --git a/src/class165/Code03_Envy2.java b/src/class165/Code03_Envy2.java
index 723ac946b..81c651d07 100644
--- a/src/class165/Code03_Envy2.java
+++ b/src/class165/Code03_Envy2.java
@@ -1,7 +1,7 @@
 package class165;
 
 // 同在最小生成树里，C++版
-// 一共有n个点，m条无向边，每条边有边权
+// 一共有n个点，m条无向边，每条边有边权，图保证是连通的
 // 一共有q次查询，每条查询都给定参数k，表示该查询涉及k条边
 // 然后依次给出k条边的编号，打印这k条边能否同时出现在一颗最小生成树上
 // 1 <= n、m、q、所有查询涉及边的总量 <= 5 * 10^5

From 5b552a8672ffe7914ec21cc416d676752e8965c0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Apr 2025 22:23:29 +0800
Subject: [PATCH 0684/1712] modify code

---
 ...00\345\271\266\346\237\245\351\233\206.pptx" | Bin 0 -> 47600 bytes
 src/class165/Code04_TeamBuilding1.java          |   4 ++--
 2 files changed, 2 insertions(+), 2 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243165\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\345\271\266\346\237\245\351\233\206\343\200\201\345\217\257\346\222\244\351\224\200\345\271\266\346\237\245\351\233\206.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243165\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\345\271\266\346\237\245\351\233\206\343\200\201\345\217\257\346\222\244\351\224\200\345\271\266\346\237\245\351\233\206.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243165\343\200\220\346\214\272\351\232\276\343\200\221\345\217\257\346\214\201\344\271\205\345\214\226\345\271\266\346\237\245\351\233\206\343\200\201\345\217\257\346\222\244\351\224\200\345\271\266\346\237\245\351\233\206.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..e1a1c8353254d0175c9aa06fa22f7d5d54be021d
GIT binary patch
literal 47600
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
bV1^<cY}tW7!x0EW;AIW`QJ+)&{nLK|*=w|;

literal 0
HcmV?d00001

diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
index 421923c12..06632f782 100644
--- a/src/class165/Code04_TeamBuilding1.java
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -35,8 +35,8 @@ public class Code04_TeamBuilding1 {
 	// 两个端点为不同组的边的数量
 	public static int cnt = 0;
 
-	// conflict[i] = true，表示i号组去划分二分图，也无法调和矛盾
-	// conflict[i] = false，表示i号组去划分二分图，可以调和矛盾
+	// conflict[i] = true，表示i号组自己去划分二分图，依然有冲突
+	// conflict[i] = false，表示i号组自己去划分二分图，没有冲突
 	public static boolean[] conflict = new boolean[MAXN];
 
 	// 可撤销并查集

From 29dcdb9307349a1a1074e4768a7f1ac43b30282d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Apr 2025 18:13:56 +0800
Subject: [PATCH 0685/1712] modify code

---
 .../Code01_SegmentTreeDivideAndConquer1.java  | 154 ++++++++++++++++++
 1 file changed, 154 insertions(+)
 create mode 100644 src/class166/Code01_SegmentTreeDivideAndConquer1.java

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
new file mode 100644
index 000000000..94d2308ca
--- /dev/null
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
@@ -0,0 +1,154 @@
+package class166;
+
+// 线段树分治模版题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5787
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class Code01_SegmentTreeDivideAndConquer1 {
+
+	public static int MAXN = 100001;
+	public static int MAXM = 200001;
+	public static int MAXT = 3000001;
+	public static int n, m, k;
+	public static int[][] edge = new int[MAXM][2];
+
+	public static int[] father = new int[MAXN << 1];
+	public static int[] siz = new int[MAXN << 1];
+	public static int[][] rollback = new int[MAXN << 1][2];
+	public static int opsize;
+
+	public static int[] head = new int[MAXT];
+	public static int[] next = new int[MAXT];
+	public static int[] to = new int[MAXT];
+	public static int cnt = 0;
+
+	public static boolean[] ans = new boolean[MAXN];
+
+	public static void addQuery(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (l > jobr || r < jobl) {
+			return;
+		}
+		if (jobl <= l && r <= jobr) {
+			addQuery(i, jobv);
+		} else {
+			int mid = (l + r) / 2;
+			add(jobl, jobr, jobv, l, mid, i << 1);
+			add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		boolean check = true;
+		int x, y, fx, fy, unionCnt = 0;
+		for (int e = head[i]; e > 0; e = next[e]) {
+			x = edge[to[e]][0];
+			y = edge[to[e]][1];
+			fx = find(x);
+			fy = find(y);
+			if (fx == fy) {
+				check = false;
+				break;
+			} else {
+				union(x, y + n);
+				union(y, x + n);
+				unionCnt += 2;
+			}
+		}
+		if (check) {
+			if (l == r) {
+				ans[l] = true;
+			} else {
+				int mid = (l + r) / 2;
+				dfs(l, mid, i << 1);
+				dfs(mid + 1, r, i << 1 | 1);
+			}
+		} else {
+			for (int k = l; k <= r; k++) {
+				ans[k] = false;
+			}
+		}
+		for (int k = 1; k <= unionCnt; k++) {
+			undo();
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		in.nextToken();
+		k = (int) in.nval;
+		for (int i = 1, l, r; i <= m; i++) {
+			in.nextToken();
+			edge[i][0] = (int) in.nval;
+			in.nextToken();
+			edge[i][1] = (int) in.nval;
+			in.nextToken();
+			l = (int) in.nval + 1;
+			in.nextToken();
+			r = (int) in.nval;
+			add(l, r, i, 1, k, 1);
+		}
+		for (int i = 1; i <= n * 2; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		dfs(1, k, 1);
+		for (int i = 1; i <= k; i++) {
+			if (ans[i]) {
+				out.println("Yes");
+			} else {
+				out.println("No");
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+}

From 8f5cd23e17ddeacd75a20df86607c08050798f85 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Apr 2025 17:44:49 +0800
Subject: [PATCH 0686/1712] modify code

---
 .../Code01_SegmentTreeDivideAndConquer1.java  | 156 +++++++++----
 src/class166/Code02_MinimumMexTree1.java      | 219 ++++++++++++++++++
 2 files changed, 333 insertions(+), 42 deletions(-)
 create mode 100644 src/class166/Code02_MinimumMexTree1.java

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
index 94d2308ca..9d347d963 100644
--- a/src/class166/Code01_SegmentTreeDivideAndConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
@@ -4,12 +4,9 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P5787
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.StreamTokenizer;
+import java.io.InputStream;
+import java.io.OutputStream;
 
 public class Code01_SegmentTreeDivideAndConquer1 {
 
@@ -17,7 +14,9 @@ public class Code01_SegmentTreeDivideAndConquer1 {
 	public static int MAXM = 200001;
 	public static int MAXT = 3000001;
 	public static int n, m, k;
-	public static int[][] edge = new int[MAXM][2];
+
+	public static int[] x = new int[MAXM];
+	public static int[] y = new int[MAXM];
 
 	public static int[] father = new int[MAXN << 1];
 	public static int[] siz = new int[MAXN << 1];
@@ -31,7 +30,7 @@ public class Code01_SegmentTreeDivideAndConquer1 {
 
 	public static boolean[] ans = new boolean[MAXN];
 
-	public static void addQuery(int u, int v) {
+	public static void addEdge(int u, int v) {
 		next[++cnt] = head[u];
 		to[cnt] = v;
 		head[u] = cnt;
@@ -66,32 +65,36 @@ public static void undo() {
 	}
 
 	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
-		if (l > jobr || r < jobl) {
+		if (jobl > r || jobr < l) {
 			return;
 		}
 		if (jobl <= l && r <= jobr) {
-			addQuery(i, jobv);
+			addEdge(i, jobv);
 		} else {
 			int mid = (l + r) / 2;
-			add(jobl, jobr, jobv, l, mid, i << 1);
-			add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
 		}
 	}
 
 	public static void dfs(int l, int r, int i) {
 		boolean check = true;
-		int x, y, fx, fy, unionCnt = 0;
-		for (int e = head[i]; e > 0; e = next[e]) {
-			x = edge[to[e]][0];
-			y = edge[to[e]][1];
-			fx = find(x);
-			fy = find(y);
-			if (fx == fy) {
+		int u, v, fu, fv, unionCnt = 0;
+		for (int ei = head[i]; ei > 0; ei = next[ei]) {
+			u = x[to[ei]];
+			v = y[to[ei]];
+			fu = find(u);
+			fv = find(v);
+			if (fu == fv) {
 				check = false;
 				break;
 			} else {
-				union(x, y + n);
-				union(y, x + n);
+				union(u, v + n);
+				union(v, u + n);
 				unionCnt += 2;
 			}
 		}
@@ -114,24 +117,15 @@ public static void dfs(int l, int r, int i) {
 	}
 
 	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		n = (int) in.nval;
-		in.nextToken();
-		m = (int) in.nval;
-		in.nextToken();
-		k = (int) in.nval;
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		k = io.nextInt();
 		for (int i = 1, l, r; i <= m; i++) {
-			in.nextToken();
-			edge[i][0] = (int) in.nval;
-			in.nextToken();
-			edge[i][1] = (int) in.nval;
-			in.nextToken();
-			l = (int) in.nval + 1;
-			in.nextToken();
-			r = (int) in.nval;
+			x[i] = io.nextInt();
+			y[i] = io.nextInt();
+			l = io.nextInt() + 1;
+			r = io.nextInt();
 			add(l, r, i, 1, k, 1);
 		}
 		for (int i = 1; i <= n * 2; i++) {
@@ -141,14 +135,92 @@ public static void main(String[] args) throws IOException {
 		dfs(1, k, 1);
 		for (int i = 1; i <= k; i++) {
 			if (ans[i]) {
-				out.println("Yes");
+				io.write("Yes\n");
 			} else {
-				out.println("No");
+				io.write("No\n");
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
 			}
 		}
-		out.flush();
-		out.close();
-		br.close();
 	}
 
 }
diff --git a/src/class166/Code02_MinimumMexTree1.java b/src/class166/Code02_MinimumMexTree1.java
new file mode 100644
index 000000000..d8c1a5f4d
--- /dev/null
+++ b/src/class166/Code02_MinimumMexTree1.java
@@ -0,0 +1,219 @@
+package class166;
+
+// 最小mex生成树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5631
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class Code02_MinimumMexTree1 {
+
+	public static int MAXN = 1000001;
+	public static int MAXM = 2000001;
+	public static int MAXT = 30000001;
+	public static int n, m, v;
+
+	public static int[] x = new int[MAXM];
+	public static int[] y = new int[MAXM];
+	public static int[] w = new int[MAXM];
+
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize;
+
+	public static int[] head = new int[MAXT];
+	public static int[] next = new int[MAXT];
+	public static int[] to = new int[MAXT];
+	public static int cnt = 0;
+
+	public static int part;
+
+	public static void addEdge(int u, int v) {
+		next[++cnt] = head[u];
+		to[cnt] = v;
+		head[u] = cnt;
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl > r || jobr < l) {
+			return;
+		}
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobv);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static int dfs(int l, int r, int i) {
+		int unionCnt = 0;
+		for (int ei = head[i], fx, fy; ei > 0; ei = next[ei]) {
+			fx = find(x[to[ei]]);
+			fy = find(y[to[ei]]);
+			if (fx != fy) {
+				union(fx, fy);
+				part--;
+				unionCnt++;
+			}
+		}
+		int ans = -1;
+		if (l == r) {
+			if (part == 1) {
+				ans = l;
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			ans = dfs(l, mid, i << 1);
+			if (ans == -1) {
+				ans = dfs(mid + 1, r, i << 1 | 1);
+			}
+		}
+		for (int k = 1; k <= unionCnt; k++) {
+			undo();
+			part++;
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		v = 0;
+		for (int i = 1; i <= m; i++) {
+			x[i] = io.nextInt();
+			y[i] = io.nextInt();
+			w[i] = io.nextInt();
+			v = Math.max(v, w[i] + 1);
+		}
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		for (int i = 1; i <= m; i++) {
+			add(0, w[i] - 1, i, 0, v, 1);
+			add(w[i] + 1, v, i, 0, v, 1);
+		}
+		part = n;
+		io.writelnInt(dfs(0, v, 1));
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
\ No newline at end of file

From ff99ad16b373f4943b77a06ffe1cb681c74a343f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Apr 2025 17:52:35 +0800
Subject: [PATCH 0687/1712] modify code

---
 src/class166/Code01_SegmentTreeDivideAndConquer1.java | 3 ---
 src/class166/Code02_MinimumMexTree1.java              | 7 +++----
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
index 9d347d963..27678b108 100644
--- a/src/class166/Code01_SegmentTreeDivideAndConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
@@ -65,9 +65,6 @@ public static void undo() {
 	}
 
 	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
-		if (jobl > r || jobr < l) {
-			return;
-		}
 		if (jobl <= l && r <= jobr) {
 			addEdge(i, jobv);
 		} else {
diff --git a/src/class166/Code02_MinimumMexTree1.java b/src/class166/Code02_MinimumMexTree1.java
index d8c1a5f4d..35586311c 100644
--- a/src/class166/Code02_MinimumMexTree1.java
+++ b/src/class166/Code02_MinimumMexTree1.java
@@ -66,9 +66,6 @@ public static void undo() {
 	}
 
 	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
-		if (jobl > r || jobr < l) {
-			return;
-		}
 		if (jobl <= l && r <= jobr) {
 			addEdge(i, jobv);
 		} else {
@@ -128,7 +125,9 @@ public static void main(String[] args) throws IOException {
 			siz[i] = 1;
 		}
 		for (int i = 1; i <= m; i++) {
-			add(0, w[i] - 1, i, 0, v, 1);
+			if (w[i] > 0) {
+				add(0, w[i] - 1, i, 0, v, 1);
+			}
 			add(w[i] + 1, v, i, 0, v, 1);
 		}
 		part = n;

From 46b250b7eaeb321d16ee6083f786b25a30cdc875 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Apr 2025 21:47:53 +0800
Subject: [PATCH 0688/1712] modify code

---
 .../Code01_SegmentTreeDivideAndConquer1.java  |   2 +-
 src/class166/Code02_MinimumMexTree1.java      |   2 +-
 src/class166/Code03_UniqueOccurrences1.java   | 217 ++++++++++++++++++
 3 files changed, 219 insertions(+), 2 deletions(-)
 create mode 100644 src/class166/Code03_UniqueOccurrences1.java

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
index 27678b108..7392dd07b 100644
--- a/src/class166/Code01_SegmentTreeDivideAndConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
@@ -113,7 +113,7 @@ public static void dfs(int l, int r, int i) {
 		}
 	}
 
-	public static void main(String[] args) throws IOException {
+	public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
diff --git a/src/class166/Code02_MinimumMexTree1.java b/src/class166/Code02_MinimumMexTree1.java
index 35586311c..942958275 100644
--- a/src/class166/Code02_MinimumMexTree1.java
+++ b/src/class166/Code02_MinimumMexTree1.java
@@ -109,7 +109,7 @@ public static int dfs(int l, int r, int i) {
 		return ans;
 	}
 
-	public static void main(String[] args) throws IOException {
+	public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
diff --git a/src/class166/Code03_UniqueOccurrences1.java b/src/class166/Code03_UniqueOccurrences1.java
new file mode 100644
index 000000000..44ee2ddbd
--- /dev/null
+++ b/src/class166/Code03_UniqueOccurrences1.java
@@ -0,0 +1,217 @@
+package class166;
+
+// 独特事件，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1681F
+// 测试链接 : https://codeforces.com/problemset/problem/1681/F
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class Code03_UniqueOccurrences1 {
+
+	public static int MAXN = 500001;
+	public static int MAXT = 10000001;
+	public static int n, m;
+
+	public static int[] x = new int[MAXN];
+	public static int[] y = new int[MAXN];
+	public static int[] c = new int[MAXN];
+
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize;
+
+	public static int[] headc = new int[MAXN];
+	public static int[] nextc = new int[MAXN];
+	public static int[] toc = new int[MAXN];
+	public static int cntc = 0;
+
+	public static int[] heads = new int[MAXT];
+	public static int[] nexts = new int[MAXT];
+	public static int[] tos = new int[MAXT];
+	public static int cnts = 0;
+
+	public static long ans = 0;
+
+	public static void addEdgeC(int u, int v) {
+		nextc[++cntc] = headc[u];
+		toc[cntc] = v;
+		headc[u] = cntc;
+	}
+
+	public static void addEdgeS(int u, int v) {
+		nexts[++cnts] = heads[u];
+		tos[cnts] = v;
+		heads[u] = cnts;
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdgeS(i, jobv);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int unionCnt = 0;
+		for (int ei = heads[i], fx, fy; ei > 0; ei = nexts[ei]) {
+			fx = find(x[tos[ei]]);
+			fy = find(y[tos[ei]]);
+			if (fx != fy) {
+				union(fx, fy);
+				unionCnt++;
+			}
+		}
+		if (l == r) {
+			for (int ei = headc[l], fx, fy; ei > 0; ei = nextc[ei]) {
+				fx = find(x[toc[ei]]);
+				fy = find(y[toc[ei]]);
+				ans += (long) siz[fx] * siz[fy];
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+		for (int k = 1; k <= unionCnt; k++) {
+			undo();
+		}
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		for (int i = 1; i < n; i++) {
+			x[i] = io.nextInt();
+			y[i] = io.nextInt();
+			c[i] = io.nextInt();
+		}
+		for (int i = 1; i < n; i++) {
+			addEdgeC(c[i], i);
+			if (c[i] > 1) {
+				add(1, c[i] - 1, i, 1, n, 1);
+			}
+			if (c[i] < n) {
+				add(c[i] + 1, n, i, 1, n, 1);
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		dfs(1, n, 1);
+		io.writelnLong(ans);
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void writelnLong(long x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}

From c06bb4b4788d55c023fefa5dc8854186c9e6cd81 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 19 Apr 2025 00:24:41 +0800
Subject: [PATCH 0689/1712] modify code

---
 .../Code01_SegmentTreeDivideAndConquer1.java  |  58 +++--
 src/class166/Code02_MinimumMexTree1.java      |  51 ++--
 src/class166/Code03_UniqueOccurrences1.java   |  66 +++--
 src/class166/Code04_GreatIntegration1.java    | 227 ++++++++++++++++++
 4 files changed, 310 insertions(+), 92 deletions(-)
 create mode 100644 src/class166/Code04_GreatIntegration1.java

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
index 7392dd07b..0b70276b4 100644
--- a/src/class166/Code01_SegmentTreeDivideAndConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
@@ -11,29 +11,27 @@
 public class Code01_SegmentTreeDivideAndConquer1 {
 
 	public static int MAXN = 100001;
-	public static int MAXM = 200001;
 	public static int MAXT = 3000001;
 	public static int n, m, k;
 
-	public static int[] x = new int[MAXM];
-	public static int[] y = new int[MAXM];
-
 	public static int[] father = new int[MAXN << 1];
 	public static int[] siz = new int[MAXN << 1];
 	public static int[][] rollback = new int[MAXN << 1][2];
 	public static int opsize;
 
-	public static int[] head = new int[MAXT];
+	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
-	public static int[] to = new int[MAXT];
+	public static int[] tox = new int[MAXT];
+	public static int[] toy = new int[MAXT];
 	public static int cnt = 0;
 
 	public static boolean[] ans = new boolean[MAXN];
 
-	public static void addEdge(int u, int v) {
-		next[++cnt] = head[u];
-		to[cnt] = v;
-		head[u] = cnt;
+	public static void addEdge(int i, int x, int y) {
+		next[++cnt] = head[i];
+		tox[cnt] = x;
+		toy[cnt] = y;
+		head[i] = cnt;
 	}
 
 	public static int find(int i) {
@@ -64,34 +62,34 @@ public static void undo() {
 		siz[fx] -= siz[fy];
 	}
 
-	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+	public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			addEdge(i, jobv);
+			addEdge(i, jobx, joby);
 		} else {
 			int mid = (l + r) / 2;
 			if (jobl <= mid) {
-				add(jobl, jobr, jobv, l, mid, i << 1);
+				add(jobl, jobr, jobx, joby, l, mid, i << 1);
 			}
 			if (jobr > mid) {
-				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+				add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
 			}
 		}
 	}
 
 	public static void dfs(int l, int r, int i) {
 		boolean check = true;
-		int u, v, fu, fv, unionCnt = 0;
-		for (int ei = head[i]; ei > 0; ei = next[ei]) {
-			u = x[to[ei]];
-			v = y[to[ei]];
-			fu = find(u);
-			fv = find(v);
-			if (fu == fv) {
+		int unionCnt = 0;
+		for (int ei = head[i], x, y, fx, fy; ei > 0; ei = next[ei]) {
+			x = tox[ei];
+			y = toy[ei];
+			fx = find(x);
+			fy = find(y);
+			if (fx == fy) {
 				check = false;
 				break;
 			} else {
-				union(u, v + n);
-				union(v, u + n);
+				union(x, y + n);
+				union(y, x + n);
 				unionCnt += 2;
 			}
 		}
@@ -118,17 +116,17 @@ public static void main(String[] args) {
 		n = io.nextInt();
 		m = io.nextInt();
 		k = io.nextInt();
-		for (int i = 1, l, r; i <= m; i++) {
-			x[i] = io.nextInt();
-			y[i] = io.nextInt();
-			l = io.nextInt() + 1;
-			r = io.nextInt();
-			add(l, r, i, 1, k, 1);
-		}
 		for (int i = 1; i <= n * 2; i++) {
 			father[i] = i;
 			siz[i] = 1;
 		}
+		for (int i = 1, x, y, l, r; i <= m; i++) {
+			x = io.nextInt();
+			y = io.nextInt();
+			l = io.nextInt();
+			r = io.nextInt();
+			add(l + 1, r, x, y, 1, k, 1);
+		}
 		dfs(1, k, 1);
 		for (int i = 1; i <= k; i++) {
 			if (ans[i]) {
diff --git a/src/class166/Code02_MinimumMexTree1.java b/src/class166/Code02_MinimumMexTree1.java
index 942958275..bfe7bd89e 100644
--- a/src/class166/Code02_MinimumMexTree1.java
+++ b/src/class166/Code02_MinimumMexTree1.java
@@ -11,30 +11,28 @@
 public class Code02_MinimumMexTree1 {
 
 	public static int MAXN = 1000001;
-	public static int MAXM = 2000001;
+	public static int MAXV = 100001;
 	public static int MAXT = 30000001;
 	public static int n, m, v;
 
-	public static int[] x = new int[MAXM];
-	public static int[] y = new int[MAXM];
-	public static int[] w = new int[MAXM];
-
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize;
 
-	public static int[] head = new int[MAXT];
+	public static int[] head = new int[MAXV << 2];
 	public static int[] next = new int[MAXT];
-	public static int[] to = new int[MAXT];
+	public static int[] tox = new int[MAXT];
+	public static int[] toy = new int[MAXT];
 	public static int cnt = 0;
 
 	public static int part;
 
-	public static void addEdge(int u, int v) {
-		next[++cnt] = head[u];
-		to[cnt] = v;
-		head[u] = cnt;
+	public static void addEdge(int i, int x, int y) {
+		next[++cnt] = head[i];
+		tox[cnt] = x;
+		toy[cnt] = y;
+		head[i] = cnt;
 	}
 
 	public static int find(int i) {
@@ -65,16 +63,16 @@ public static void undo() {
 		siz[fx] -= siz[fy];
 	}
 
-	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+	public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			addEdge(i, jobv);
+			addEdge(i, jobx, joby);
 		} else {
 			int mid = (l + r) >> 1;
 			if (jobl <= mid) {
-				add(jobl, jobr, jobv, l, mid, i << 1);
+				add(jobl, jobr, jobx, joby, l, mid, i << 1);
 			}
 			if (jobr > mid) {
-				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+				add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
 			}
 		}
 	}
@@ -82,8 +80,8 @@ public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
 	public static int dfs(int l, int r, int i) {
 		int unionCnt = 0;
 		for (int ei = head[i], fx, fy; ei > 0; ei = next[ei]) {
-			fx = find(x[to[ei]]);
-			fy = find(y[to[ei]]);
+			fx = find(tox[ei]);
+			fy = find(toy[ei]);
 			if (fx != fy) {
 				union(fx, fy);
 				part--;
@@ -113,22 +111,19 @@ public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
-		v = 0;
-		for (int i = 1; i <= m; i++) {
-			x[i] = io.nextInt();
-			y[i] = io.nextInt();
-			w[i] = io.nextInt();
-			v = Math.max(v, w[i] + 1);
-		}
+		v = MAXV;
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
 			siz[i] = 1;
 		}
-		for (int i = 1; i <= m; i++) {
-			if (w[i] > 0) {
-				add(0, w[i] - 1, i, 0, v, 1);
+		for (int i = 1, x, y, w; i <= m; i++) {
+			x = io.nextInt();
+			y = io.nextInt();
+			w = io.nextInt();
+			if (w > 0) {
+				add(0, w - 1, x, y, 0, v, 1);
 			}
-			add(w[i] + 1, v, i, 0, v, 1);
+			add(w + 1, v, x, y, 0, v, 1);
 		}
 		part = n;
 		io.writelnInt(dfs(0, v, 1));
diff --git a/src/class166/Code03_UniqueOccurrences1.java b/src/class166/Code03_UniqueOccurrences1.java
index 44ee2ddbd..03c6e0b59 100644
--- a/src/class166/Code03_UniqueOccurrences1.java
+++ b/src/class166/Code03_UniqueOccurrences1.java
@@ -15,10 +15,6 @@ public class Code03_UniqueOccurrences1 {
 	public static int MAXT = 10000001;
 	public static int n, m;
 
-	public static int[] x = new int[MAXN];
-	public static int[] y = new int[MAXN];
-	public static int[] c = new int[MAXN];
-
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
@@ -26,26 +22,30 @@ public class Code03_UniqueOccurrences1 {
 
 	public static int[] headc = new int[MAXN];
 	public static int[] nextc = new int[MAXN];
-	public static int[] toc = new int[MAXN];
+	public static int[] xc = new int[MAXN];
+	public static int[] yc = new int[MAXN];
 	public static int cntc = 0;
 
-	public static int[] heads = new int[MAXT];
+	public static int[] heads = new int[MAXN << 2];
 	public static int[] nexts = new int[MAXT];
-	public static int[] tos = new int[MAXT];
+	public static int[] xs = new int[MAXT];
+	public static int[] ys = new int[MAXT];
 	public static int cnts = 0;
 
 	public static long ans = 0;
 
-	public static void addEdgeC(int u, int v) {
-		nextc[++cntc] = headc[u];
-		toc[cntc] = v;
-		headc[u] = cntc;
+	public static void addEdgeC(int i, int x, int y) {
+		nextc[++cntc] = headc[i];
+		xc[cntc] = x;
+		yc[cntc] = y;
+		headc[i] = cntc;
 	}
 
-	public static void addEdgeS(int u, int v) {
-		nexts[++cnts] = heads[u];
-		tos[cnts] = v;
-		heads[u] = cnts;
+	public static void addEdgeS(int i, int x, int y) {
+		nexts[++cnts] = heads[i];
+		xs[cnts] = x;
+		ys[cnts] = y;
+		heads[i] = cnts;
 	}
 
 	public static int find(int i) {
@@ -76,16 +76,16 @@ public static void undo() {
 		siz[fx] -= siz[fy];
 	}
 
-	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+	public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
-			addEdgeS(i, jobv);
+			addEdgeS(i, jobx, joby);
 		} else {
 			int mid = (l + r) >> 1;
 			if (jobl <= mid) {
-				add(jobl, jobr, jobv, l, mid, i << 1);
+				add(jobl, jobr, jobx, joby, l, mid, i << 1);
 			}
 			if (jobr > mid) {
-				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+				add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
 			}
 		}
 	}
@@ -93,8 +93,8 @@ public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
 	public static void dfs(int l, int r, int i) {
 		int unionCnt = 0;
 		for (int ei = heads[i], fx, fy; ei > 0; ei = nexts[ei]) {
-			fx = find(x[tos[ei]]);
-			fy = find(y[tos[ei]]);
+			fx = find(xs[ei]);
+			fy = find(ys[ei]);
 			if (fx != fy) {
 				union(fx, fy);
 				unionCnt++;
@@ -102,8 +102,8 @@ public static void dfs(int l, int r, int i) {
 		}
 		if (l == r) {
 			for (int ei = headc[l], fx, fy; ei > 0; ei = nextc[ei]) {
-				fx = find(x[toc[ei]]);
-				fy = find(y[toc[ei]]);
+				fx = find(xc[ei]);
+				fy = find(yc[ei]);
 				ans += (long) siz[fx] * siz[fy];
 			}
 		} else {
@@ -119,18 +119,16 @@ public static void dfs(int l, int r, int i) {
 	public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
-		for (int i = 1; i < n; i++) {
-			x[i] = io.nextInt();
-			y[i] = io.nextInt();
-			c[i] = io.nextInt();
-		}
-		for (int i = 1; i < n; i++) {
-			addEdgeC(c[i], i);
-			if (c[i] > 1) {
-				add(1, c[i] - 1, i, 1, n, 1);
+		for (int i = 1, x, y, c; i < n; i++) {
+			x = io.nextInt();
+			y = io.nextInt();
+			c = io.nextInt();
+			addEdgeC(c, x, y);
+			if (c > 1) {
+				add(1, c - 1, x, y, 1, n, 1);
 			}
-			if (c[i] < n) {
-				add(c[i] + 1, n, i, 1, n, 1);
+			if (c < n) {
+				add(c + 1, n, x, y, 1, n, 1);
 			}
 		}
 		for (int i = 1; i <= n; i++) {
diff --git a/src/class166/Code04_GreatIntegration1.java b/src/class166/Code04_GreatIntegration1.java
new file mode 100644
index 000000000..b39750fa9
--- /dev/null
+++ b/src/class166/Code04_GreatIntegration1.java
@@ -0,0 +1,227 @@
+package class166;
+
+// 大融合，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4219
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code04_GreatIntegration1 {
+
+	public static int MAXN = 100001;
+	public static int MAXT = 3000001;
+	public static int n, q;
+
+	public static int[][] event = new int[MAXN][3];
+	public static int[][] sorted = new int[MAXN][3];
+
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize;
+
+	public static int[] head = new int[MAXN << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] tox = new int[MAXT];
+	public static int[] toy = new int[MAXT];
+	public static int cnt;
+
+	public static long[] ans = new long[MAXN];
+
+	public static void addEdge(int i, int x, int y) {
+		next[++cnt] = head[i];
+		tox[cnt] = x;
+		toy[cnt] = y;
+		head[i] = cnt;
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+	}
+
+	public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobx, joby);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobx, joby, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int unionCnt = 0;
+		for (int ei = head[i], fx, fy; ei > 0; ei = next[ei]) {
+			fx = find(tox[ei]);
+			fy = find(toy[ei]);
+			if (fx != fy) {
+				union(fx, fy);
+				unionCnt++;
+			}
+		}
+		if (l == r) {
+			if (event[l][0] == 2) {
+				ans[l] = (long) siz[find(event[l][1])] * siz[find(event[l][2])];
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+		for (int k = 1; k <= unionCnt; k++) {
+			undo();
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		for (int i = 1; i <= q; i++) {
+			sorted[i][0] = i;
+			sorted[i][1] = event[i][1];
+			sorted[i][2] = event[i][2];
+		}
+		Arrays.sort(sorted, 1, q + 1,
+				(a, b) -> a[1] != b[1] ? a[1] - b[1] : (a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]));
+		for (int l = 1, r = 1; l <= q; l = ++r) {
+			int t = sorted[l][0];
+			int x = sorted[l][1];
+			int y = sorted[l][2];
+			while (r + 1 <= q && sorted[r + 1][1] == x && sorted[r + 1][2] == y) {
+				r++;
+			}
+			for (int i = l + 1; i <= r; i++) {
+				add(t, sorted[i][0] - 1, x, y, 1, q, 1);
+				t = sorted[i][0] + 1;
+			}
+			if (t <= q) {
+				add(t, q, x, y, 1, q, 1);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		q = in.nextInt();
+		char op;
+		int u, v;
+		for (int i = 1; i <= q; i++) {
+			op = in.nextChar();
+			u = in.nextInt();
+			v = in.nextInt();
+			event[i][0] = op == 'A' ? 1 : 2;
+			event[i][1] = Math.min(u, v);
+			event[i][2] = Math.max(u, v);
+		}
+		prepare();
+		dfs(1, q, 1);
+		for (int i = 1; i <= q; i++) {
+			if (event[i][0] == 2) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}

From 2f3948e80b661f238bf46719e51d86855cd28c94 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 19 Apr 2025 12:23:23 +0800
Subject: [PATCH 0690/1712] modify code

---
 .../Code01_SegmentTreeDivideAndConquer1.java  |   2 +-
 src/class166/Code02_MinimumMexTree1.java      |   2 +-
 src/class166/Code03_UniqueOccurrences1.java   |   2 +-
 src/class166/Code04_GreatIntegration1.java    |   4 +-
 src/class166/Code05_ConnectedGraph1.java      | 263 ++++++++++++++++++
 5 files changed, 268 insertions(+), 5 deletions(-)
 create mode 100644 src/class166/Code05_ConnectedGraph1.java

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
index 0b70276b4..98acb36c9 100644
--- a/src/class166/Code01_SegmentTreeDivideAndConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
@@ -17,7 +17,7 @@ public class Code01_SegmentTreeDivideAndConquer1 {
 	public static int[] father = new int[MAXN << 1];
 	public static int[] siz = new int[MAXN << 1];
 	public static int[][] rollback = new int[MAXN << 1][2];
-	public static int opsize;
+	public static int opsize = 0;
 
 	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
diff --git a/src/class166/Code02_MinimumMexTree1.java b/src/class166/Code02_MinimumMexTree1.java
index bfe7bd89e..fa58c3e8e 100644
--- a/src/class166/Code02_MinimumMexTree1.java
+++ b/src/class166/Code02_MinimumMexTree1.java
@@ -18,7 +18,7 @@ public class Code02_MinimumMexTree1 {
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
-	public static int opsize;
+	public static int opsize = 0;
 
 	public static int[] head = new int[MAXV << 2];
 	public static int[] next = new int[MAXT];
diff --git a/src/class166/Code03_UniqueOccurrences1.java b/src/class166/Code03_UniqueOccurrences1.java
index 03c6e0b59..472e79ec9 100644
--- a/src/class166/Code03_UniqueOccurrences1.java
+++ b/src/class166/Code03_UniqueOccurrences1.java
@@ -18,7 +18,7 @@ public class Code03_UniqueOccurrences1 {
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
-	public static int opsize;
+	public static int opsize = 0;
 
 	public static int[] headc = new int[MAXN];
 	public static int[] nextc = new int[MAXN];
diff --git a/src/class166/Code04_GreatIntegration1.java b/src/class166/Code04_GreatIntegration1.java
index b39750fa9..4c8a07154 100644
--- a/src/class166/Code04_GreatIntegration1.java
+++ b/src/class166/Code04_GreatIntegration1.java
@@ -22,13 +22,13 @@ public class Code04_GreatIntegration1 {
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
-	public static int opsize;
+	public static int opsize = 0;
 
 	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tox = new int[MAXT];
 	public static int[] toy = new int[MAXT];
-	public static int cnt;
+	public static int cnt = 0;
 
 	public static long[] ans = new long[MAXN];
 
diff --git a/src/class166/Code05_ConnectedGraph1.java b/src/class166/Code05_ConnectedGraph1.java
new file mode 100644
index 000000000..df24d1dd8
--- /dev/null
+++ b/src/class166/Code05_ConnectedGraph1.java
@@ -0,0 +1,263 @@
+package class166;
+
+// 连通图
+// 测试链接 : https://www.luogu.com.cn/problem/P5227
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+import java.util.Arrays;
+
+public class Code05_ConnectedGraph1 {
+
+	public static int MAXN = 100001;
+	public static int MAXM = 200001;
+	public static int MAXE = 400001;
+	public static int MAXT = 10000001;
+	public static int n, m, k;
+
+	public static int[] x = new int[MAXM];
+	public static int[] y = new int[MAXM];
+
+	public static int[][] event = new int[MAXE][2];
+	public static int ecnt = 0;
+	public static boolean[] visit = new boolean[MAXM];
+
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize = 0;
+
+	public static int[] head = new int[MAXN << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] tox = new int[MAXT];
+	public static int[] toy = new int[MAXT];
+	public static int cnt = 0;
+
+	public static boolean[] ans = new boolean[MAXN];
+
+	public static void addEdge(int i, int x, int y) {
+		next[++cnt] = head[i];
+		tox[cnt] = x;
+		toy[cnt] = y;
+		head[i] = cnt;
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+	}
+
+	public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobx, joby);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobx, joby, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		boolean check = false;
+		int unionCnt = 0;
+		for (int ei = head[i], x, y, fx, fy; ei > 0; ei = next[ei]) {
+			x = tox[ei];
+			y = toy[ei];
+			fx = find(x);
+			fy = find(y);
+			if (fx != fy) {
+				union(fx, fy);
+				unionCnt++;
+			}
+			if (siz[find(fx)] == n) {
+				check = true;
+				break;
+			}
+		}
+		if (check) {
+			for (int j = l; j <= r; j++) {
+				ans[j] = true;
+			}
+		} else {
+			if (l == r) {
+				ans[l] = false;
+			} else {
+				int mid = (l + r) >> 1;
+				dfs(l, mid, i << 1);
+				dfs(mid + 1, r, i << 1 | 1);
+			}
+		}
+		for (int j = 1; j <= unionCnt; j++) {
+			undo();
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		Arrays.sort(event, 1, ecnt + 1, (a, b) -> a[0] != b[0] ? (a[0] - b[0]) : (a[1] - b[1]));
+		int eid, t;
+		for (int l = 1, r = 1; l <= ecnt; l = ++r) {
+			eid = event[l][0];
+			visit[eid] = true;
+			while (r + 1 <= ecnt && event[r + 1][0] == eid) {
+				r++;
+			}
+			t = 1;
+			for (int i = l; i <= r; i++) {
+				if (t <= event[i][1] - 1) {
+					add(t, event[i][1] - 1, x[eid], y[eid], 1, k, 1);
+				}
+				t = event[i][1] + 1;
+			}
+			if (t <= k) {
+				add(t, k, x[eid], y[eid], 1, k, 1);
+			}
+		}
+		for (int i = 1; i <= m; i++) {
+			if (!visit[i]) {
+				add(1, k, x[i], y[i], 1, k, 1);
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1; i <= m; i++) {
+			x[i] = io.nextInt();
+			y[i] = io.nextInt();
+		}
+		k = io.nextInt();
+		for (int i = 1, s; i <= k; i++) {
+			s = io.nextInt();
+			for (int j = 1; j <= s; j++) {
+				event[++ecnt][0] = io.nextInt();
+				event[ecnt][1] = i;
+			}
+		}
+		prepare();
+		dfs(1, k, 1);
+		for (int i = 1; i <= k; i++) {
+			if (ans[i]) {
+				io.write("Connected\n");
+			} else {
+				io.write("Disconnected\n");
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}

From d9895904b74966c37a946c4df011e02e8ebb3dbf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 20 Apr 2025 17:56:13 +0800
Subject: [PATCH 0691/1712] modify code

---
 src/class166/Code04_GreatIntegration1.java |   3 +-
 src/class166/Code05_ConnectedGraph1.java   |   2 +-
 src/class166/Code06_Connectivity1.java     | 245 +++++++++++++++++++++
 src/class166/Code06_Connectivity2.java     | 157 +++++++++++++
 4 files changed, 404 insertions(+), 3 deletions(-)
 create mode 100644 src/class166/Code06_Connectivity1.java
 create mode 100644 src/class166/Code06_Connectivity2.java

diff --git a/src/class166/Code04_GreatIntegration1.java b/src/class166/Code04_GreatIntegration1.java
index 4c8a07154..050b8a6f3 100644
--- a/src/class166/Code04_GreatIntegration1.java
+++ b/src/class166/Code04_GreatIntegration1.java
@@ -115,8 +115,7 @@ public static void prepare() {
 			sorted[i][1] = event[i][1];
 			sorted[i][2] = event[i][2];
 		}
-		Arrays.sort(sorted, 1, q + 1,
-				(a, b) -> a[1] != b[1] ? a[1] - b[1] : (a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]));
+		Arrays.sort(sorted, 1, q + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
 		for (int l = 1, r = 1; l <= q; l = ++r) {
 			int t = sorted[l][0];
 			int x = sorted[l][1];
diff --git a/src/class166/Code05_ConnectedGraph1.java b/src/class166/Code05_ConnectedGraph1.java
index df24d1dd8..bcfa47abc 100644
--- a/src/class166/Code05_ConnectedGraph1.java
+++ b/src/class166/Code05_ConnectedGraph1.java
@@ -126,7 +126,7 @@ public static void prepare() {
 			father[i] = i;
 			siz[i] = 1;
 		}
-		Arrays.sort(event, 1, ecnt + 1, (a, b) -> a[0] != b[0] ? (a[0] - b[0]) : (a[1] - b[1]));
+		Arrays.sort(event, 1, ecnt + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
 		int eid, t;
 		for (int l = 1, r = 1; l <= ecnt; l = ++r) {
 			eid = event[l][0];
diff --git a/src/class166/Code06_Connectivity1.java b/src/class166/Code06_Connectivity1.java
new file mode 100644
index 000000000..8078b994f
--- /dev/null
+++ b/src/class166/Code06_Connectivity1.java
@@ -0,0 +1,245 @@
+package class166;
+
+// 连通性离线处理，java版
+// 测试链接 : https://loj.ac/p/121
+// 提交以下的code，提交时请把类名改成"Main"
+// 测试平台看似支持java语言，其实无法通过，内存过大跳警告，导致验证失败
+// 想通过用C++实现，本节课Code06_Connectivity2文件就是C++的实现
+// 逻辑完全一样，C++实现可以通过全部测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+public class Code06_Connectivity1 {
+
+	public static int MAXN = 5001;
+	public static int MAXM = 500001;
+	public static int MAXT = 5000001;
+	public static int n, m;
+
+	public static int[] op = new int[MAXM];
+	public static int[] a = new int[MAXM];
+	public static int[] b = new int[MAXM];
+
+	public static int[][] last = new int[MAXN][MAXN];
+
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize = 0;
+
+	public static int[] head = new int[MAXM << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] tox = new int[MAXT];
+	public static int[] toy = new int[MAXT];
+	public static int cnt = 0;
+
+	public static boolean[] ans = new boolean[MAXM];
+
+	public static void addEdge(int i, int x, int y) {
+		next[++cnt] = head[i];
+		tox[cnt] = x;
+		toy[cnt] = y;
+		head[i] = cnt;
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+	}
+
+	public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobx, joby);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobx, joby, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int unionCnt = 0;
+		for (int ei = head[i], x, y, fx, fy; ei > 0; ei = next[ei]) {
+			x = tox[ei];
+			y = toy[ei];
+			fx = find(x);
+			fy = find(y);
+			if (fx != fy) {
+				union(fx, fy);
+				unionCnt++;
+			}
+		}
+		if (l == r) {
+			if (op[l] == 2) {
+				ans[l] = find(a[l]) == find(b[l]);
+			}
+		} else {
+			int mid = (l + r) / 2;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+		for (int j = 1; j <= unionCnt; j++) {
+			undo();
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		for (int i = 1, x, y; i <= m; i++) {
+			x = a[i];
+			y = b[i];
+			if (op[i] == 0) {
+				last[x][y] = i;
+			} else if (op[i] == 1) {
+				add(last[x][y], i - 1, x, y, 1, m, 1);
+				last[x][y] = 0;
+			}
+		}
+		for (int x = 1; x <= n; x++) {
+			for (int y = x + 1; y <= n; y++) {
+				if (last[x][y] != 0) {
+					add(last[x][y], m, x, y, 1, m, 1);
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		for (int i = 1, x, y, t; i <= m; i++) {
+			t = io.nextInt();
+			x = io.nextInt();
+			y = io.nextInt();
+			op[i] = t;
+			a[i] = Math.min(x, y);
+			b[i] = Math.max(x, y);
+		}
+		prepare();
+		dfs(1, m, 1);
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 2) {
+				if (ans[i]) {
+					io.write("Y\n");
+				} else {
+					io.write("N\n");
+				}
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
+}
diff --git a/src/class166/Code06_Connectivity2.java b/src/class166/Code06_Connectivity2.java
new file mode 100644
index 000000000..d942698fa
--- /dev/null
+++ b/src/class166/Code06_Connectivity2.java
@@ -0,0 +1,157 @@
+package class166;
+
+// 连通性离线处理，C++版
+// 测试链接 : https://loj.ac/p/121
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 5001;
+//const int MAXM = 500001;
+//const int MAXT = 5000001;
+//int n, m;
+//
+//int op[MAXM];
+//int a[MAXM];
+//int b[MAXM];
+//
+//int last[MAXN][MAXN];
+//
+//int father[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
+//int head[MAXM << 2];
+//int nxt[MAXT];
+//int tox[MAXT];
+//int toy[MAXT];
+//int cnt = 0;
+//
+//bool ans[MAXM];
+//
+//void addEdge(int i, int x, int y) {
+//    nxt[++cnt] = head[i];
+//    tox[cnt] = x;
+//    toy[cnt] = y;
+//    head[i] = cnt;
+//}
+//
+//int find(int i) {
+//    while (i != father[i]) {
+//        i = father[i];
+//    }
+//    return i;
+//}
+//
+//void Union(int x, int y) {
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobx, joby);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i) {
+//    int unionCnt = 0;
+//    for (int ei = head[i], x, y, fx, fy; ei > 0; ei = nxt[ei]) {
+//        x = tox[ei];
+//        y = toy[ei];
+//        fx = find(x);
+//        fy = find(y);
+//        if (fx != fy) {
+//            Union(fx, fy);
+//            unionCnt++;
+//        }
+//    }
+//    if (l == r) {
+//        if (op[l] == 2) {
+//            ans[l] = find(a[l]) == find(b[l]);
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//    for (int j = 1; j <= unionCnt; j++) {
+//        undo();
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    for (int i = 1, x, y; i <= m; i++) {
+//        x = a[i];
+//        y = b[i];
+//        if (op[i] == 0) {
+//            last[x][y] = i;
+//        } else if (op[i] == 1) {
+//            add(last[x][y], i - 1, x, y, 1, m, 1);
+//            last[x][y] = 0;
+//        }
+//    }
+//    for (int x = 1; x <= n; x++) {
+//        for (int y = x + 1; y <= n; y++) {
+//            if (last[x][y] != 0) {
+//                add(last[x][y], m, x, y, 1, m, 1);
+//            }
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, t, x, y; i <= m; i++) {
+//        cin >> t >> x >> y;
+//        op[i] = t;
+//        a[i] = min(x, y);
+//        b[i] = max(x, y);
+//    }
+//    prepare();
+//    dfs(1, m, 1);
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 2) {
+//            if (ans[i]) {
+//                cout << "Y" << "\n";
+//            } else {
+//                cout << "N" << "\n";
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From ad7bddc33414f94d09b390032e5d0ac4ff89d35a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 20 Apr 2025 18:02:34 +0800
Subject: [PATCH 0692/1712] modify code

---
 .../Code01_SegmentTreeDivideAndConquer1.java  | 117 ++++++++++-------
 ... Code01_SegmentTreeDivideAndConquer2.java} |   2 +-
 ....java => Code02_CheckBipartiteGraph1.java} | 120 +++++++-----------
 ...Tree1.java => Code03_MinimumMexTree1.java} |   2 +-
 ...s1.java => Code04_UniqueOccurrences1.java} |   2 +-
 ...on1.java => Code05_GreatIntegration1.java} |   2 +-
 ...raph1.java => Code06_ConnectedGraph1.java} |   2 +-
 7 files changed, 124 insertions(+), 123 deletions(-)
 rename src/class166/{Code06_Connectivity2.java => Code01_SegmentTreeDivideAndConquer2.java} (98%)
 rename src/class166/{Code06_Connectivity1.java => Code02_CheckBipartiteGraph1.java} (63%)
 rename src/class166/{Code02_MinimumMexTree1.java => Code03_MinimumMexTree1.java} (99%)
 rename src/class166/{Code03_UniqueOccurrences1.java => Code04_UniqueOccurrences1.java} (99%)
 rename src/class166/{Code04_GreatIntegration1.java => Code05_GreatIntegration1.java} (99%)
 rename src/class166/{Code05_ConnectedGraph1.java => Code06_ConnectedGraph1.java} (99%)

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
index 98acb36c9..93edffa2e 100644
--- a/src/class166/Code01_SegmentTreeDivideAndConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer1.java
@@ -1,8 +1,12 @@
 package class166;
 
 // 线段树分治模版题，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P5787
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 测试链接 : https://loj.ac/p/121
+// 提交以下的code，提交时请把类名改成"Main"
+// 测试平台看似支持java语言，其实无法通过
+// 内存过大跳警告，导致验证失败，想通过用C++实现
+// 本节课Code01_SegmentTreeDivideAndConquer2文件就是C++的实现
+// 逻辑完全一样，C++实现可以通过全部测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -10,22 +14,29 @@
 
 public class Code01_SegmentTreeDivideAndConquer1 {
 
-	public static int MAXN = 100001;
-	public static int MAXT = 3000001;
-	public static int n, m, k;
+	public static int MAXN = 5001;
+	public static int MAXM = 500001;
+	public static int MAXT = 5000001;
+	public static int n, m;
 
-	public static int[] father = new int[MAXN << 1];
-	public static int[] siz = new int[MAXN << 1];
-	public static int[][] rollback = new int[MAXN << 1][2];
+	public static int[] op = new int[MAXM];
+	public static int[] a = new int[MAXM];
+	public static int[] b = new int[MAXM];
+
+	public static int[][] last = new int[MAXN][MAXN];
+
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize = 0;
 
-	public static int[] head = new int[MAXN << 2];
+	public static int[] head = new int[MAXM << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tox = new int[MAXT];
 	public static int[] toy = new int[MAXT];
 	public static int cnt = 0;
 
-	public static boolean[] ans = new boolean[MAXN];
+	public static boolean[] ans = new boolean[MAXM];
 
 	public static void addEdge(int i, int x, int y) {
 		next[++cnt] = head[i];
@@ -66,7 +77,7 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 		if (jobl <= l && r <= jobr) {
 			addEdge(i, jobx, joby);
 		} else {
-			int mid = (l + r) / 2;
+			int mid = (l + r) >> 1;
 			if (jobl <= mid) {
 				add(jobl, jobr, jobx, joby, l, mid, i << 1);
 			}
@@ -77,62 +88,76 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 	}
 
 	public static void dfs(int l, int r, int i) {
-		boolean check = true;
 		int unionCnt = 0;
 		for (int ei = head[i], x, y, fx, fy; ei > 0; ei = next[ei]) {
 			x = tox[ei];
 			y = toy[ei];
 			fx = find(x);
 			fy = find(y);
-			if (fx == fy) {
-				check = false;
-				break;
-			} else {
-				union(x, y + n);
-				union(y, x + n);
-				unionCnt += 2;
+			if (fx != fy) {
+				union(fx, fy);
+				unionCnt++;
 			}
 		}
-		if (check) {
-			if (l == r) {
-				ans[l] = true;
-			} else {
-				int mid = (l + r) / 2;
-				dfs(l, mid, i << 1);
-				dfs(mid + 1, r, i << 1 | 1);
+		if (l == r) {
+			if (op[l] == 2) {
+				ans[l] = find(a[l]) == find(b[l]);
 			}
 		} else {
-			for (int k = l; k <= r; k++) {
-				ans[k] = false;
-			}
+			int mid = (l + r) / 2;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
 		}
-		for (int k = 1; k <= unionCnt; k++) {
+		for (int j = 1; j <= unionCnt; j++) {
 			undo();
 		}
 	}
 
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		for (int i = 1, x, y; i <= m; i++) {
+			x = a[i];
+			y = b[i];
+			if (op[i] == 0) {
+				last[x][y] = i;
+			} else if (op[i] == 1) {
+				add(last[x][y], i - 1, x, y, 1, m, 1);
+				last[x][y] = 0;
+			}
+		}
+		for (int x = 1; x <= n; x++) {
+			for (int y = x + 1; y <= n; y++) {
+				if (last[x][y] != 0) {
+					add(last[x][y], m, x, y, 1, m, 1);
+				}
+			}
+		}
+	}
+
 	public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
-		k = io.nextInt();
-		for (int i = 1; i <= n * 2; i++) {
-			father[i] = i;
-			siz[i] = 1;
-		}
-		for (int i = 1, x, y, l, r; i <= m; i++) {
+		for (int i = 1, x, y, t; i <= m; i++) {
+			t = io.nextInt();
 			x = io.nextInt();
 			y = io.nextInt();
-			l = io.nextInt();
-			r = io.nextInt();
-			add(l + 1, r, x, y, 1, k, 1);
-		}
-		dfs(1, k, 1);
-		for (int i = 1; i <= k; i++) {
-			if (ans[i]) {
-				io.write("Yes\n");
-			} else {
-				io.write("No\n");
+			op[i] = t;
+			a[i] = Math.min(x, y);
+			b[i] = Math.max(x, y);
+		}
+		prepare();
+		dfs(1, m, 1);
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 2) {
+				if (ans[i]) {
+					io.write("Y\n");
+				} else {
+					io.write("N\n");
+				}
 			}
 		}
 		io.flush();
diff --git a/src/class166/Code06_Connectivity2.java b/src/class166/Code01_SegmentTreeDivideAndConquer2.java
similarity index 98%
rename from src/class166/Code06_Connectivity2.java
rename to src/class166/Code01_SegmentTreeDivideAndConquer2.java
index d942698fa..4210b40fa 100644
--- a/src/class166/Code06_Connectivity2.java
+++ b/src/class166/Code01_SegmentTreeDivideAndConquer2.java
@@ -1,6 +1,6 @@
 package class166;
 
-// 连通性离线处理，C++版
+// 线段树分治模版题，C++版
 // 测试链接 : https://loj.ac/p/121
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class166/Code06_Connectivity1.java b/src/class166/Code02_CheckBipartiteGraph1.java
similarity index 63%
rename from src/class166/Code06_Connectivity1.java
rename to src/class166/Code02_CheckBipartiteGraph1.java
index 8078b994f..37eae2735 100644
--- a/src/class166/Code06_Connectivity1.java
+++ b/src/class166/Code02_CheckBipartiteGraph1.java
@@ -1,41 +1,31 @@
 package class166;
 
-// 连通性离线处理，java版
-// 测试链接 : https://loj.ac/p/121
-// 提交以下的code，提交时请把类名改成"Main"
-// 测试平台看似支持java语言，其实无法通过，内存过大跳警告，导致验证失败
-// 想通过用C++实现，本节课Code06_Connectivity2文件就是C++的实现
-// 逻辑完全一样，C++实现可以通过全部测试用例
+// 检查二分图，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5787
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
-public class Code06_Connectivity1 {
+public class Code02_CheckBipartiteGraph1 {
 
-	public static int MAXN = 5001;
-	public static int MAXM = 500001;
-	public static int MAXT = 5000001;
-	public static int n, m;
+	public static int MAXN = 100001;
+	public static int MAXT = 3000001;
+	public static int n, m, k;
 
-	public static int[] op = new int[MAXM];
-	public static int[] a = new int[MAXM];
-	public static int[] b = new int[MAXM];
-
-	public static int[][] last = new int[MAXN][MAXN];
-
-	public static int[] father = new int[MAXN];
-	public static int[] siz = new int[MAXN];
-	public static int[][] rollback = new int[MAXN][2];
+	public static int[] father = new int[MAXN << 1];
+	public static int[] siz = new int[MAXN << 1];
+	public static int[][] rollback = new int[MAXN << 1][2];
 	public static int opsize = 0;
 
-	public static int[] head = new int[MAXM << 2];
+	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tox = new int[MAXT];
 	public static int[] toy = new int[MAXT];
 	public static int cnt = 0;
 
-	public static boolean[] ans = new boolean[MAXM];
+	public static boolean[] ans = new boolean[MAXN];
 
 	public static void addEdge(int i, int x, int y) {
 		next[++cnt] = head[i];
@@ -76,7 +66,7 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 		if (jobl <= l && r <= jobr) {
 			addEdge(i, jobx, joby);
 		} else {
-			int mid = (l + r) >> 1;
+			int mid = (l + r) / 2;
 			if (jobl <= mid) {
 				add(jobl, jobr, jobx, joby, l, mid, i << 1);
 			}
@@ -87,52 +77,37 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 	}
 
 	public static void dfs(int l, int r, int i) {
+		boolean check = true;
 		int unionCnt = 0;
 		for (int ei = head[i], x, y, fx, fy; ei > 0; ei = next[ei]) {
 			x = tox[ei];
 			y = toy[ei];
 			fx = find(x);
 			fy = find(y);
-			if (fx != fy) {
-				union(fx, fy);
-				unionCnt++;
+			if (fx == fy) {
+				check = false;
+				break;
+			} else {
+				union(x, y + n);
+				union(y, x + n);
+				unionCnt += 2;
 			}
 		}
-		if (l == r) {
-			if (op[l] == 2) {
-				ans[l] = find(a[l]) == find(b[l]);
+		if (check) {
+			if (l == r) {
+				ans[l] = true;
+			} else {
+				int mid = (l + r) / 2;
+				dfs(l, mid, i << 1);
+				dfs(mid + 1, r, i << 1 | 1);
 			}
 		} else {
-			int mid = (l + r) / 2;
-			dfs(l, mid, i << 1);
-			dfs(mid + 1, r, i << 1 | 1);
-		}
-		for (int j = 1; j <= unionCnt; j++) {
-			undo();
-		}
-	}
-
-	public static void prepare() {
-		for (int i = 1; i <= n; i++) {
-			father[i] = i;
-			siz[i] = 1;
-		}
-		for (int i = 1, x, y; i <= m; i++) {
-			x = a[i];
-			y = b[i];
-			if (op[i] == 0) {
-				last[x][y] = i;
-			} else if (op[i] == 1) {
-				add(last[x][y], i - 1, x, y, 1, m, 1);
-				last[x][y] = 0;
+			for (int k = l; k <= r; k++) {
+				ans[k] = false;
 			}
 		}
-		for (int x = 1; x <= n; x++) {
-			for (int y = x + 1; y <= n; y++) {
-				if (last[x][y] != 0) {
-					add(last[x][y], m, x, y, 1, m, 1);
-				}
-			}
+		for (int k = 1; k <= unionCnt; k++) {
+			undo();
 		}
 	}
 
@@ -140,23 +115,24 @@ public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
-		for (int i = 1, x, y, t; i <= m; i++) {
-			t = io.nextInt();
+		k = io.nextInt();
+		for (int i = 1; i <= n * 2; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		for (int i = 1, x, y, l, r; i <= m; i++) {
 			x = io.nextInt();
 			y = io.nextInt();
-			op[i] = t;
-			a[i] = Math.min(x, y);
-			b[i] = Math.max(x, y);
-		}
-		prepare();
-		dfs(1, m, 1);
-		for (int i = 1; i <= m; i++) {
-			if (op[i] == 2) {
-				if (ans[i]) {
-					io.write("Y\n");
-				} else {
-					io.write("N\n");
-				}
+			l = io.nextInt();
+			r = io.nextInt();
+			add(l + 1, r, x, y, 1, k, 1);
+		}
+		dfs(1, k, 1);
+		for (int i = 1; i <= k; i++) {
+			if (ans[i]) {
+				io.write("Yes\n");
+			} else {
+				io.write("No\n");
 			}
 		}
 		io.flush();
diff --git a/src/class166/Code02_MinimumMexTree1.java b/src/class166/Code03_MinimumMexTree1.java
similarity index 99%
rename from src/class166/Code02_MinimumMexTree1.java
rename to src/class166/Code03_MinimumMexTree1.java
index fa58c3e8e..a3bc7baff 100644
--- a/src/class166/Code02_MinimumMexTree1.java
+++ b/src/class166/Code03_MinimumMexTree1.java
@@ -8,7 +8,7 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
-public class Code02_MinimumMexTree1 {
+public class Code03_MinimumMexTree1 {
 
 	public static int MAXN = 1000001;
 	public static int MAXV = 100001;
diff --git a/src/class166/Code03_UniqueOccurrences1.java b/src/class166/Code04_UniqueOccurrences1.java
similarity index 99%
rename from src/class166/Code03_UniqueOccurrences1.java
rename to src/class166/Code04_UniqueOccurrences1.java
index 472e79ec9..076611cd3 100644
--- a/src/class166/Code03_UniqueOccurrences1.java
+++ b/src/class166/Code04_UniqueOccurrences1.java
@@ -9,7 +9,7 @@
 import java.io.InputStream;
 import java.io.OutputStream;
 
-public class Code03_UniqueOccurrences1 {
+public class Code04_UniqueOccurrences1 {
 
 	public static int MAXN = 500001;
 	public static int MAXT = 10000001;
diff --git a/src/class166/Code04_GreatIntegration1.java b/src/class166/Code05_GreatIntegration1.java
similarity index 99%
rename from src/class166/Code04_GreatIntegration1.java
rename to src/class166/Code05_GreatIntegration1.java
index 050b8a6f3..58f1c7444 100644
--- a/src/class166/Code04_GreatIntegration1.java
+++ b/src/class166/Code05_GreatIntegration1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_GreatIntegration1 {
+public class Code05_GreatIntegration1 {
 
 	public static int MAXN = 100001;
 	public static int MAXT = 3000001;
diff --git a/src/class166/Code05_ConnectedGraph1.java b/src/class166/Code06_ConnectedGraph1.java
similarity index 99%
rename from src/class166/Code05_ConnectedGraph1.java
rename to src/class166/Code06_ConnectedGraph1.java
index bcfa47abc..701e5e094 100644
--- a/src/class166/Code05_ConnectedGraph1.java
+++ b/src/class166/Code06_ConnectedGraph1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStream;
 import java.util.Arrays;
 
-public class Code05_ConnectedGraph1 {
+public class Code06_ConnectedGraph1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;

From 7e1dd30fa7f1d4a0bdd4de8c99b696d772b814bb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 20 Apr 2025 18:17:24 +0800
Subject: [PATCH 0693/1712] modify code

---
 src/class166/Code07_PaintingEdges1.java | 8 ++++++++
 1 file changed, 8 insertions(+)
 create mode 100644 src/class166/Code07_PaintingEdges1.java

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
new file mode 100644
index 000000000..7444e2bad
--- /dev/null
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -0,0 +1,8 @@
+package class166;
+
+// 边的涂色
+// 测试链接 : https://www.luogu.com.cn/problem/CF576E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+public class Code07_PaintingEdges1 {
+
+}

From 45c780aa3a1bd284c0e2792214b17e29b94d0784 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 20 Apr 2025 23:41:39 +0800
Subject: [PATCH 0694/1712] modify code

---
 ...Conquer1.java => Code01_SegmentTreeDivideConquer1.java} | 7 +++----
 ...Conquer2.java => Code01_SegmentTreeDivideConquer2.java} | 0
 2 files changed, 3 insertions(+), 4 deletions(-)
 rename src/class166/{Code01_SegmentTreeDivideAndConquer1.java => Code01_SegmentTreeDivideConquer1.java} (95%)
 rename src/class166/{Code01_SegmentTreeDivideAndConquer2.java => Code01_SegmentTreeDivideConquer2.java} (100%)

diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer1.java b/src/class166/Code01_SegmentTreeDivideConquer1.java
similarity index 95%
rename from src/class166/Code01_SegmentTreeDivideAndConquer1.java
rename to src/class166/Code01_SegmentTreeDivideConquer1.java
index 93edffa2e..32c414968 100644
--- a/src/class166/Code01_SegmentTreeDivideAndConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer1.java
@@ -3,16 +3,15 @@
 // 线段树分治模版题，java版
 // 测试链接 : https://loj.ac/p/121
 // 提交以下的code，提交时请把类名改成"Main"
-// 测试平台看似支持java语言，其实无法通过
-// 内存过大跳警告，导致验证失败，想通过用C++实现
-// 本节课Code01_SegmentTreeDivideAndConquer2文件就是C++的实现
+// 测试平台看似支持java语言，其实无法通过，内存过大报警，导致验证失败
+// 想通过用C++实现，就是Code01_SegmentTreeDivideConquer2文件
 // 逻辑完全一样，C++实现可以通过全部测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.OutputStream;
 
-public class Code01_SegmentTreeDivideAndConquer1 {
+public class Code01_SegmentTreeDivideConquer1 {
 
 	public static int MAXN = 5001;
 	public static int MAXM = 500001;
diff --git a/src/class166/Code01_SegmentTreeDivideAndConquer2.java b/src/class166/Code01_SegmentTreeDivideConquer2.java
similarity index 100%
rename from src/class166/Code01_SegmentTreeDivideAndConquer2.java
rename to src/class166/Code01_SegmentTreeDivideConquer2.java

From 24824fdbf1899563ba75cd7fef0d5ebe0dc2e15a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 20 Apr 2025 23:47:21 +0800
Subject: [PATCH 0695/1712] modify code

---
 src/class166/Code06_ConnectedGraph1.java | 2 +-
 src/class166/Code07_PaintingEdges1.java  | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class166/Code06_ConnectedGraph1.java b/src/class166/Code06_ConnectedGraph1.java
index 701e5e094..4f1409c73 100644
--- a/src/class166/Code06_ConnectedGraph1.java
+++ b/src/class166/Code06_ConnectedGraph1.java
@@ -1,6 +1,6 @@
 package class166;
 
-// 连通图
+// 连通图，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5227
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index 7444e2bad..112b088ac 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -1,6 +1,6 @@
 package class166;
 
-// 边的涂色
+// 边的涂色，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF576E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 public class Code07_PaintingEdges1 {

From bd24218884ab509cb0a0c4332ab9fb5d81106d0f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 21 Apr 2025 00:00:45 +0800
Subject: [PATCH 0696/1712] modify code

---
 .../Code01_SegmentTreeDivideConquer1.java     | 35 ++++++++++---------
 .../Code01_SegmentTreeDivideConquer2.java     | 35 ++++++++++---------
 2 files changed, 36 insertions(+), 34 deletions(-)

diff --git a/src/class166/Code01_SegmentTreeDivideConquer1.java b/src/class166/Code01_SegmentTreeDivideConquer1.java
index 32c414968..162154c13 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer1.java
@@ -18,10 +18,7 @@ public class Code01_SegmentTreeDivideConquer1 {
 	public static int MAXT = 5000001;
 	public static int n, m;
 
-	public static int[] op = new int[MAXM];
-	public static int[] a = new int[MAXM];
-	public static int[] b = new int[MAXM];
-
+	public static int[][] event = new int[MAXM][3];
 	public static int[][] last = new int[MAXN][MAXN];
 
 	public static int[] father = new int[MAXN];
@@ -99,8 +96,11 @@ public static void dfs(int l, int r, int i) {
 			}
 		}
 		if (l == r) {
-			if (op[l] == 2) {
-				ans[l] = find(a[l]) == find(b[l]);
+			int op = event[l][0];
+			int x = event[l][1];
+			int y = event[l][2];
+			if (op == 2) {
+				ans[l] = find(x) == find(y);
 			}
 		} else {
 			int mid = (l + r) / 2;
@@ -117,12 +117,13 @@ public static void prepare() {
 			father[i] = i;
 			siz[i] = 1;
 		}
-		for (int i = 1, x, y; i <= m; i++) {
-			x = a[i];
-			y = b[i];
-			if (op[i] == 0) {
+		for (int i = 1, op, x, y; i <= m; i++) {
+			op = event[i][0];
+			x = event[i][1];
+			y = event[i][2];
+			if (op == 0) {
 				last[x][y] = i;
-			} else if (op[i] == 1) {
+			} else if (op == 1) {
 				add(last[x][y], i - 1, x, y, 1, m, 1);
 				last[x][y] = 0;
 			}
@@ -140,18 +141,18 @@ public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
-		for (int i = 1, x, y, t; i <= m; i++) {
-			t = io.nextInt();
+		for (int i = 1, op, x, y; i <= m; i++) {
+			op = io.nextInt();
 			x = io.nextInt();
 			y = io.nextInt();
-			op[i] = t;
-			a[i] = Math.min(x, y);
-			b[i] = Math.max(x, y);
+			event[i][0] = op;
+			event[i][1] = Math.min(x, y);
+			event[i][2] = Math.max(x, y);
 		}
 		prepare();
 		dfs(1, m, 1);
 		for (int i = 1; i <= m; i++) {
-			if (op[i] == 2) {
+			if (event[i][0] == 2) {
 				if (ans[i]) {
 					io.write("Y\n");
 				} else {
diff --git a/src/class166/Code01_SegmentTreeDivideConquer2.java b/src/class166/Code01_SegmentTreeDivideConquer2.java
index 4210b40fa..b555f675b 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer2.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer2.java
@@ -14,10 +14,7 @@
 //const int MAXT = 5000001;
 //int n, m;
 //
-//int op[MAXM];
-//int a[MAXM];
-//int b[MAXM];
-//
+//int event[MAXM][3];
 //int last[MAXN][MAXN];
 //
 //int father[MAXN];
@@ -95,8 +92,11 @@
 //        }
 //    }
 //    if (l == r) {
-//        if (op[l] == 2) {
-//            ans[l] = find(a[l]) == find(b[l]);
+//        int op = event[l][0];
+//        int x = event[l][1];
+//        int y = event[l][2];
+//        if (op == 2) {
+//            ans[l] = find(x) == find(y);
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
@@ -113,12 +113,13 @@
 //        father[i] = i;
 //        siz[i] = 1;
 //    }
-//    for (int i = 1, x, y; i <= m; i++) {
-//        x = a[i];
-//        y = b[i];
-//        if (op[i] == 0) {
+//    for (int i = 1, op, x, y; i <= m; i++) {
+//        op = event[i][0];
+//        x = event[i][1];
+//        y = event[i][2];
+//        if (op == 0) {
 //            last[x][y] = i;
-//        } else if (op[i] == 1) {
+//        } else if (op == 1) {
 //            add(last[x][y], i - 1, x, y, 1, m, 1);
 //            last[x][y] = 0;
 //        }
@@ -136,16 +137,16 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m;
-//    for (int i = 1, t, x, y; i <= m; i++) {
-//        cin >> t >> x >> y;
-//        op[i] = t;
-//        a[i] = min(x, y);
-//        b[i] = max(x, y);
+//    for (int i = 1, op, x, y; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        event[i][0] = op;
+//        event[i][1] = min(x, y);
+//        event[i][2] = max(x, y);
 //    }
 //    prepare();
 //    dfs(1, m, 1);
 //    for (int i = 1; i <= m; i++) {
-//        if (op[i] == 2) {
+//        if (event[i][0] == 2) {
 //            if (ans[i]) {
 //                cout << "Y" << "\n";
 //            } else {

From 0bd1694f1fa3cd4d3cb138e040864f440a8c9ea9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 21 Apr 2025 21:32:49 +0800
Subject: [PATCH 0697/1712] modify code

---
 src/class166/Code07_PaintingEdges1.java | 242 ++++++++++++++++++++++++
 src/class166/Code07_PaintingEdges2.java | 163 ++++++++++++++++
 2 files changed, 405 insertions(+)
 create mode 100644 src/class166/Code07_PaintingEdges2.java

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index 112b088ac..f4ea844dd 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -2,7 +2,249 @@
 
 // 边的涂色，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF576E
+// 测试链接 : https://codeforces.com/problemset/problem/576/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
 public class Code07_PaintingEdges1 {
 
+	public static int MAXN = 500001;
+	public static int MAXK = 51;
+	public static int MAXT = 10000001;
+	public static int n, m, k, q;
+
+	public static int[] u = new int[MAXN];
+	public static int[] v = new int[MAXN];
+	public static int[] e = new int[MAXN];
+	public static int[] c = new int[MAXN];
+
+	public static int[] pos = new int[MAXN];
+
+	public static int[][] father = new int[MAXK][MAXN << 1];
+	public static int[][] siz = new int[MAXK][MAXN << 1];
+	public static int[][] rollback = new int[MAXN << 1][3];
+	public static int opsize = 0;
+
+	public static int[] head = new int[MAXN << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] qid = new int[MAXT];
+	public static int cnt = 0;
+
+	public static boolean[] ans = new boolean[MAXN];
+
+	public static void addEdge(int i, int qi) {
+		next[++cnt] = head[i];
+		qid[cnt] = qi;
+		head[i] = cnt;
+	}
+
+	public static int find(int color, int i) {
+		while (i != father[color][i]) {
+			i = father[color][i];
+		}
+		return i;
+	}
+
+	public static void union(int color, int x, int y) {
+		int fx = find(color, x);
+		int fy = find(color, y);
+		if (siz[color][fx] < siz[color][fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[color][fy] = fx;
+		siz[color][fx] += siz[color][fy];
+		rollback[++opsize][0] = color;
+		rollback[opsize][1] = fx;
+		rollback[opsize][2] = fy;
+	}
+
+	public static void undo() {
+		int color = rollback[opsize][0];
+		int fx = rollback[opsize][1];
+		int fy = rollback[opsize--][2];
+		father[color][fy] = fy;
+		siz[color][fx] -= siz[color][fy];
+	}
+
+	public static void add(int jobl, int jobr, int jobq, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobq);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobq, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobq, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int unionCnt = 0;
+		for (int ei = head[i]; ei > 0; ei = next[ei]) {
+			int color = c[qid[ei]];
+			int x = u[e[qid[ei]]], xn = x + n, fx = find(color, x), fxn = find(color, xn);
+			int y = v[e[qid[ei]]], yn = y + n, fy = find(color, y), fyn = find(color, yn);
+			if (fx != fyn) {
+				union(color, fx, fyn);
+				unionCnt++;
+			}
+			if (fy != fxn) {
+				union(color, fy, fxn);
+				unionCnt++;
+			}
+		}
+		if (l == r) {
+			if (find(c[l], u[e[l]]) == find(c[l], v[e[l]])) {
+				ans[l] = false;
+				c[l] = pos[e[l]];
+			} else {
+				ans[l] = true;
+				pos[e[l]] = c[l];
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+		for (int j = 1; j <= unionCnt; j++) {
+			undo();
+		}
+	}
+
+	public static void prepare() {
+		for (int color = 1; color <= k; color++) {
+			for (int i = 1; i <= n; i++) {
+				father[color][i] = i;
+				father[color][i + n] = i + n;
+				siz[color][i] = 1;
+				siz[color][i + n] = 1;
+			}
+		}
+		for (int i = 1; i <= m; i++) {
+			pos[i] = q + 1;
+		}
+		for (int i = q; i >= 1; i--) {
+			if (i + 1 <= pos[e[i]] - 1) {
+				add(i + 1, pos[e[i]] - 1, i, 1, q, 1);
+			}
+			pos[e[i]] = i;
+		}
+		for (int i = 1; i <= m; i++) {
+			pos[i] = 0;
+		}
+	}
+
+	public static void main(String[] args) {
+		FastIO io = new FastIO(System.in, System.out);
+		n = io.nextInt();
+		m = io.nextInt();
+		k = io.nextInt();
+		q = io.nextInt();
+		for (int i = 1; i <= m; i++) {
+			u[i] = io.nextInt();
+			v[i] = io.nextInt();
+		}
+		for (int i = 1; i <= q; i++) {
+			e[i] = io.nextInt();
+			c[i] = io.nextInt();
+		}
+		prepare();
+		dfs(1, q, 1);
+		for (int i = 1; i <= q; i++) {
+			if (ans[i]) {
+				io.write("YES\n");
+			} else {
+				io.write("NO\n");
+			}
+		}
+		io.flush();
+	}
+
+	// 读写工具类
+	static class FastIO {
+		private final InputStream is;
+		private final OutputStream os;
+		private final byte[] inbuf = new byte[1 << 16];
+		private int lenbuf = 0;
+		private int ptrbuf = 0;
+		private final StringBuilder outBuf = new StringBuilder();
+
+		public FastIO(InputStream is, OutputStream os) {
+			this.is = is;
+			this.os = os;
+		}
+
+		private int readByte() {
+			if (ptrbuf >= lenbuf) {
+				ptrbuf = 0;
+				try {
+					lenbuf = is.read(inbuf);
+				} catch (IOException e) {
+					throw new RuntimeException(e);
+				}
+				if (lenbuf == -1) {
+					return -1;
+				}
+			}
+			return inbuf[ptrbuf++] & 0xff;
+		}
+
+		private int skip() {
+			int b;
+			while ((b = readByte()) != -1) {
+				if (b > ' ') {
+					return b;
+				}
+			}
+			return -1;
+		}
+
+		public int nextInt() {
+			int b = skip();
+			if (b == -1) {
+				throw new RuntimeException("No more integers (EOF)");
+			}
+			boolean negative = false;
+			if (b == '-') {
+				negative = true;
+				b = readByte();
+			}
+			int val = 0;
+			while (b >= '0' && b <= '9') {
+				val = val * 10 + (b - '0');
+				b = readByte();
+			}
+			return negative ? -val : val;
+		}
+
+		public void write(String s) {
+			outBuf.append(s);
+		}
+
+		public void writeInt(int x) {
+			outBuf.append(x);
+		}
+
+		public void writelnInt(int x) {
+			outBuf.append(x).append('\n');
+		}
+
+		public void flush() {
+			try {
+				os.write(outBuf.toString().getBytes());
+				os.flush();
+				outBuf.setLength(0);
+			} catch (IOException e) {
+				throw new RuntimeException(e);
+			}
+		}
+	}
+
 }
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
new file mode 100644
index 000000000..9483bebf5
--- /dev/null
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -0,0 +1,163 @@
+package class166;
+
+// 边的涂色，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF576E
+// 测试链接 : https://codeforces.com/problemset/problem/576/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//const int MAXK = 51;
+//const int MAXT = 10000001;
+//int n, m, k, q;
+//
+//int u[MAXN];
+//int v[MAXN];
+//int e[MAXN];
+//int c[MAXN];
+//
+//int pos[MAXN];
+//
+//int father[MAXK][MAXN << 1];
+//int siz[MAXK][MAXN << 1];
+//int rollback[MAXN << 1][3];
+//int opsize = 0;
+//
+//int head[MAXN << 2];
+//int nxt[MAXT];
+//int qid[MAXT];
+//int cnt = 0;
+//
+//bool ans[MAXN];
+//
+//void addEdge(int i, int qi) {
+//    nxt[++cnt] = head[i];
+//    qid[cnt] = qi;
+//    head[i] = cnt;
+//}
+//
+//int find(int color, int i) {
+//    while (i != father[color][i]) {
+//        i = father[color][i];
+//    }
+//    return i;
+//}
+//
+//void Union(int color, int x, int y) {
+//    int fx = find(color, x);
+//    int fy = find(color, y);
+//    if (siz[color][fx] < siz[color][fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[color][fy] = fx;
+//    siz[color][fx] += siz[color][fy];
+//    rollback[++opsize][0] = color;
+//    rollback[opsize][1] = fx;
+//    rollback[opsize][2] = fy;
+//}
+//
+//void undo() {
+//    int color = rollback[opsize][0];
+//    int fx = rollback[opsize][1];
+//    int fy = rollback[opsize--][2];
+//    father[color][fy] = fy;
+//    siz[color][fx] -= siz[color][fy];
+//}
+//
+//void add(int jobl, int jobr, int jobq, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobq);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobq, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobq, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i) {
+//    int unionCnt = 0;
+//    for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
+//        int color = c[qid[ei]];
+//        int x = u[e[qid[ei]]], xn = x + n, fx = find(color, x), fxn = find(color, xn);
+//        int y = v[e[qid[ei]]], yn = y + n, fy = find(color, y), fyn = find(color, yn);
+//        if (fx != fyn) {
+//        	Union(color, fx, fyn);
+//            unionCnt++;
+//        }
+//        if (fy != fxn) {
+//        	Union(color, fy, fxn);
+//            unionCnt++;
+//        }
+//    }
+//    if (l == r) {
+//        if (find(c[l], u[e[l]]) == find(c[l], v[e[l]])) {
+//            ans[l] = false;
+//            c[l] = pos[e[l]];
+//        } else {
+//            ans[l] = true;
+//            pos[e[l]] = c[l];
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//    for (int j = 1; j <= unionCnt; j++) {
+//    	undo();
+//    }
+//}
+//
+//void prepare() {
+//    for (int color = 1; color <= k; color++) {
+//        for (int i = 1; i <= n; i++) {
+//            father[color][i] = i;
+//            father[color][i + n] = i + n;
+//            siz[color][i] = 1;
+//            siz[color][i + n] = 1;
+//        }
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        pos[i] = q + 1;
+//    }
+//    for (int i = q; i >= 1; i--) {
+//        if (i + 1 <= pos[e[i]] - 1) {
+//            add(i + 1, pos[e[i]] - 1, i, 1, q, 1);
+//        }
+//        pos[e[i]] = i;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        pos[i] = 0;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> k >> q;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> u[i] >> v[i];
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        cin >> e[i] >> c[i];
+//    }
+//    prepare();
+//    dfs(1, q, 1);
+//    for (int i = 1; i <= q; i++) {
+//        if (ans[i]) {
+//            cout << "YES" << "\n";
+//        } else {
+//            cout << "NO" << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 236f26bc3430c20fb17b0e1528d5b0758704c881 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 21 Apr 2025 22:04:42 +0800
Subject: [PATCH 0698/1712] modify code

---
 .../Code01_SegmentTreeDivideConquer1.java     | 41 ++++++++---------
 .../Code01_SegmentTreeDivideConquer2.java     | 36 +++++++--------
 src/class166/Code05_GreatIntegration1.java    | 45 ++++++++++---------
 src/class166/Code06_ConnectedGraph1.java      | 14 +++---
 4 files changed, 67 insertions(+), 69 deletions(-)

diff --git a/src/class166/Code01_SegmentTreeDivideConquer1.java b/src/class166/Code01_SegmentTreeDivideConquer1.java
index 162154c13..e8deaac52 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer1.java
@@ -2,10 +2,7 @@
 
 // 线段树分治模版题，java版
 // 测试链接 : https://loj.ac/p/121
-// 提交以下的code，提交时请把类名改成"Main"
-// 测试平台看似支持java语言，其实无法通过，内存过大报警，导致验证失败
-// 想通过用C++实现，就是Code01_SegmentTreeDivideConquer2文件
-// 逻辑完全一样，C++实现可以通过全部测试用例
+// 提交以下的code，提交时类名改成"Main"，多提交几次，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -18,7 +15,10 @@ public class Code01_SegmentTreeDivideConquer1 {
 	public static int MAXT = 5000001;
 	public static int n, m;
 
-	public static int[][] event = new int[MAXM][3];
+	public static int[] op = new int[MAXM];
+	public static int[] u = new int[MAXM];
+	public static int[] v = new int[MAXM];
+
 	public static int[][] last = new int[MAXN][MAXN];
 
 	public static int[] father = new int[MAXN];
@@ -96,11 +96,8 @@ public static void dfs(int l, int r, int i) {
 			}
 		}
 		if (l == r) {
-			int op = event[l][0];
-			int x = event[l][1];
-			int y = event[l][2];
-			if (op == 2) {
-				ans[l] = find(x) == find(y);
+			if (op[l] == 2) {
+				ans[l] = find(u[l]) == find(v[l]);
 			}
 		} else {
 			int mid = (l + r) / 2;
@@ -117,13 +114,13 @@ public static void prepare() {
 			father[i] = i;
 			siz[i] = 1;
 		}
-		for (int i = 1, op, x, y; i <= m; i++) {
-			op = event[i][0];
-			x = event[i][1];
-			y = event[i][2];
-			if (op == 0) {
+		for (int i = 1, t, x, y; i <= m; i++) {
+			t = op[i];
+			x = u[i];
+			y = v[i];
+			if (t == 0) {
 				last[x][y] = i;
-			} else if (op == 1) {
+			} else if (t == 1) {
 				add(last[x][y], i - 1, x, y, 1, m, 1);
 				last[x][y] = 0;
 			}
@@ -141,18 +138,18 @@ public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
 		m = io.nextInt();
-		for (int i = 1, op, x, y; i <= m; i++) {
-			op = io.nextInt();
+		for (int i = 1, t, x, y; i <= m; i++) {
+			t = io.nextInt();
 			x = io.nextInt();
 			y = io.nextInt();
-			event[i][0] = op;
-			event[i][1] = Math.min(x, y);
-			event[i][2] = Math.max(x, y);
+			op[i] = t;
+			u[i] = Math.min(x, y);
+			v[i] = Math.max(x, y);
 		}
 		prepare();
 		dfs(1, m, 1);
 		for (int i = 1; i <= m; i++) {
-			if (event[i][0] == 2) {
+			if (op[i] == 2) {
 				if (ans[i]) {
 					io.write("Y\n");
 				} else {
diff --git a/src/class166/Code01_SegmentTreeDivideConquer2.java b/src/class166/Code01_SegmentTreeDivideConquer2.java
index b555f675b..04cff0615 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer2.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer2.java
@@ -14,7 +14,10 @@
 //const int MAXT = 5000001;
 //int n, m;
 //
-//int event[MAXM][3];
+//int op[MAXM];
+//int u[MAXM];
+//int v[MAXM];
+//
 //int last[MAXN][MAXN];
 //
 //int father[MAXN];
@@ -92,11 +95,8 @@
 //        }
 //    }
 //    if (l == r) {
-//        int op = event[l][0];
-//        int x = event[l][1];
-//        int y = event[l][2];
-//        if (op == 2) {
-//            ans[l] = find(x) == find(y);
+//        if (op[l] == 2) {
+//            ans[l] = find(u[l]) == find(v[l]);
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
@@ -113,13 +113,13 @@
 //        father[i] = i;
 //        siz[i] = 1;
 //    }
-//    for (int i = 1, op, x, y; i <= m; i++) {
-//        op = event[i][0];
-//        x = event[i][1];
-//        y = event[i][2];
-//        if (op == 0) {
+//    for (int i = 1, t, x, y; i <= m; i++) {
+//        t = op[i];
+//        x = u[i];
+//        y = v[i];
+//        if (t == 0) {
 //            last[x][y] = i;
-//        } else if (op == 1) {
+//        } else if (t == 1) {
 //            add(last[x][y], i - 1, x, y, 1, m, 1);
 //            last[x][y] = 0;
 //        }
@@ -137,16 +137,16 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m;
-//    for (int i = 1, op, x, y; i <= m; i++) {
-//        cin >> op >> x >> y;
-//        event[i][0] = op;
-//        event[i][1] = min(x, y);
-//        event[i][2] = max(x, y);
+//    for (int i = 1, t, x, y; i <= m; i++) {
+//        cin >> t >> x >> y;
+//        op[i] = t;
+//        u[i] = min(x, y);
+//        v[i] = max(x, y);
 //    }
 //    prepare();
 //    dfs(1, m, 1);
 //    for (int i = 1; i <= m; i++) {
-//        if (event[i][0] == 2) {
+//        if (op[i] == 2) {
 //            if (ans[i]) {
 //                cout << "Y" << "\n";
 //            } else {
diff --git a/src/class166/Code05_GreatIntegration1.java b/src/class166/Code05_GreatIntegration1.java
index 58f1c7444..fecf87f25 100644
--- a/src/class166/Code05_GreatIntegration1.java
+++ b/src/class166/Code05_GreatIntegration1.java
@@ -16,7 +16,10 @@ public class Code05_GreatIntegration1 {
 	public static int MAXT = 3000001;
 	public static int n, q;
 
-	public static int[][] event = new int[MAXN][3];
+	public static int[] op = new int[MAXN];
+	public static int[] u = new int[MAXN];
+	public static int[] v = new int[MAXN];
+
 	public static int[][] sorted = new int[MAXN][3];
 
 	public static int[] father = new int[MAXN];
@@ -92,8 +95,8 @@ public static void dfs(int l, int r, int i) {
 			}
 		}
 		if (l == r) {
-			if (event[l][0] == 2) {
-				ans[l] = (long) siz[find(event[l][1])] * siz[find(event[l][2])];
+			if (op[l] == 2) {
+				ans[l] = (long) siz[find(u[l])] * siz[find(v[l])];
 			}
 		} else {
 			int mid = (l + r) >> 1;
@@ -111,21 +114,19 @@ public static void prepare() {
 			siz[i] = 1;
 		}
 		for (int i = 1; i <= q; i++) {
-			sorted[i][0] = i;
-			sorted[i][1] = event[i][1];
-			sorted[i][2] = event[i][2];
+			sorted[i][0] = u[i];
+			sorted[i][1] = v[i];
+			sorted[i][2] = i;
 		}
-		Arrays.sort(sorted, 1, q + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
+		Arrays.sort(sorted, 1, q + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] != b[1] ? a[1] - b[1] : a[2] - b[2]);
 		for (int l = 1, r = 1; l <= q; l = ++r) {
-			int t = sorted[l][0];
-			int x = sorted[l][1];
-			int y = sorted[l][2];
-			while (r + 1 <= q && sorted[r + 1][1] == x && sorted[r + 1][2] == y) {
+			int x = sorted[l][0], y = sorted[l][1], t = sorted[l][2];
+			while (r + 1 <= q && sorted[r + 1][0] == x && sorted[r + 1][1] == y) {
 				r++;
 			}
 			for (int i = l + 1; i <= r; i++) {
-				add(t, sorted[i][0] - 1, x, y, 1, q, 1);
-				t = sorted[i][0] + 1;
+				add(t, sorted[i][2] - 1, x, y, 1, q, 1);
+				t = sorted[i][2] + 1;
 			}
 			if (t <= q) {
 				add(t, q, x, y, 1, q, 1);
@@ -138,20 +139,20 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		q = in.nextInt();
-		char op;
-		int u, v;
+		char t;
+		int x, y;
 		for (int i = 1; i <= q; i++) {
-			op = in.nextChar();
-			u = in.nextInt();
-			v = in.nextInt();
-			event[i][0] = op == 'A' ? 1 : 2;
-			event[i][1] = Math.min(u, v);
-			event[i][2] = Math.max(u, v);
+			t = in.nextChar();
+			x = in.nextInt();
+			y = in.nextInt();
+			op[i] = t == 'A' ? 1 : 2;
+			u[i] = Math.min(x, y);
+			v[i] = Math.max(x, y);
 		}
 		prepare();
 		dfs(1, q, 1);
 		for (int i = 1; i <= q; i++) {
-			if (event[i][0] == 2) {
+			if (op[i] == 2) {
 				out.println(ans[i]);
 			}
 		}
diff --git a/src/class166/Code06_ConnectedGraph1.java b/src/class166/Code06_ConnectedGraph1.java
index 4f1409c73..53f39e061 100644
--- a/src/class166/Code06_ConnectedGraph1.java
+++ b/src/class166/Code06_ConnectedGraph1.java
@@ -17,8 +17,8 @@ public class Code06_ConnectedGraph1 {
 	public static int MAXT = 10000001;
 	public static int n, m, k;
 
-	public static int[] x = new int[MAXM];
-	public static int[] y = new int[MAXM];
+	public static int[] u = new int[MAXM];
+	public static int[] v = new int[MAXM];
 
 	public static int[][] event = new int[MAXE][2];
 	public static int ecnt = 0;
@@ -137,17 +137,17 @@ public static void prepare() {
 			t = 1;
 			for (int i = l; i <= r; i++) {
 				if (t <= event[i][1] - 1) {
-					add(t, event[i][1] - 1, x[eid], y[eid], 1, k, 1);
+					add(t, event[i][1] - 1, u[eid], v[eid], 1, k, 1);
 				}
 				t = event[i][1] + 1;
 			}
 			if (t <= k) {
-				add(t, k, x[eid], y[eid], 1, k, 1);
+				add(t, k, u[eid], v[eid], 1, k, 1);
 			}
 		}
 		for (int i = 1; i <= m; i++) {
 			if (!visit[i]) {
-				add(1, k, x[i], y[i], 1, k, 1);
+				add(1, k, u[i], v[i], 1, k, 1);
 			}
 		}
 	}
@@ -157,8 +157,8 @@ public static void main(String[] args) {
 		n = io.nextInt();
 		m = io.nextInt();
 		for (int i = 1; i <= m; i++) {
-			x[i] = io.nextInt();
-			y[i] = io.nextInt();
+			u[i] = io.nextInt();
+			v[i] = io.nextInt();
 		}
 		k = io.nextInt();
 		for (int i = 1, s; i <= k; i++) {

From f02297918aad6cdece7e940a1a32388cf6d352ba Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 21 Apr 2025 22:30:26 +0800
Subject: [PATCH 0699/1712] modify code

---
 src/class166/Code02_CheckBipartiteGraph1.java |   7 +-
 src/class166/Code02_CheckBipartiteGraph2.java | 131 +++++++++++++++++
 src/class166/Code03_MinimumMexTree2.java      | 128 +++++++++++++++++
 src/class166/Code04_UniqueOccurrences2.java   | 135 ++++++++++++++++++
 4 files changed, 396 insertions(+), 5 deletions(-)
 create mode 100644 src/class166/Code02_CheckBipartiteGraph2.java
 create mode 100644 src/class166/Code03_MinimumMexTree2.java
 create mode 100644 src/class166/Code04_UniqueOccurrences2.java

diff --git a/src/class166/Code02_CheckBipartiteGraph1.java b/src/class166/Code02_CheckBipartiteGraph1.java
index 37eae2735..82d3c29e4 100644
--- a/src/class166/Code02_CheckBipartiteGraph1.java
+++ b/src/class166/Code02_CheckBipartiteGraph1.java
@@ -79,11 +79,8 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 	public static void dfs(int l, int r, int i) {
 		boolean check = true;
 		int unionCnt = 0;
-		for (int ei = head[i], x, y, fx, fy; ei > 0; ei = next[ei]) {
-			x = tox[ei];
-			y = toy[ei];
-			fx = find(x);
-			fy = find(y);
+		for (int ei = head[i]; ei > 0; ei = next[ei]) {
+			int x = tox[ei], y = toy[ei], fx = find(x), fy = find(y);
 			if (fx == fy) {
 				check = false;
 				break;
diff --git a/src/class166/Code02_CheckBipartiteGraph2.java b/src/class166/Code02_CheckBipartiteGraph2.java
new file mode 100644
index 000000000..31d1359dd
--- /dev/null
+++ b/src/class166/Code02_CheckBipartiteGraph2.java
@@ -0,0 +1,131 @@
+package class166;
+
+// 检查二分图，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5787
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXT = 3000001;
+//int n, m, k;
+//
+//int father[MAXN << 1];
+//int siz[MAXN << 1];
+//int rollback[MAXN << 1][2];
+//int opsize = 0;
+//
+//int head[MAXN << 2];
+//int nxt[MAXT];
+//int tox[MAXT];
+//int toy[MAXT];
+//int cnt = 0;
+//
+//bool ans[MAXN];
+//
+//void addEdge(int i, int x, int y) {
+//	nxt[++cnt] = head[i];
+//	tox[cnt] = x;
+//	toy[cnt] = y;
+//	head[i] = cnt;
+//}
+//
+//int find(int i) {
+//	while (i != father[i]) {
+//        i = father[i];
+//    }
+//	return i;
+//}
+//
+//void Union(int x, int y) {
+//	int fx = find(x);
+//	int fy = find(y);
+//	if (siz[fx] < siz[fy]) {
+//		int tmp = fx;
+//		fx = fy;
+//		fy = tmp;
+//	}
+//	father[fy] = fx;
+//	siz[fx] += siz[fy];
+//	rollback[++opsize][0] = fx;
+//	rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//	int fx = rollback[opsize][0];
+//	int fy = rollback[opsize--][1];
+//	father[fy] = fy;
+//	siz[fx] -= siz[fy];
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+//	if (jobl <= l && r <= jobr) {
+//		addEdge(i, jobx, joby);
+//	} else {
+//		int mid = (l + r) >> 1;
+//		if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, l, mid, i << 1);
+//        }
+//		if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+//        }
+//	}
+//}
+//
+//void dfs(int l, int r, int i) {
+//	bool check = true;
+//	int unionCnt = 0;
+//	for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
+//		int x = tox[ei], y = toy[ei], fx = find(x), fy = find(y);
+//		if (fx == fy) {
+//			check = false;
+//			break;
+//		} else {
+//			Union(x, y + n);
+//			Union(y, x + n);
+//			unionCnt += 2;
+//		}
+//	}
+//	if (check) {
+//		if (l == r) {
+//			ans[l] = true;
+//		} else {
+//			int mid = (l + r) >> 1;
+//			dfs(l, mid, i << 1);
+//			dfs(mid + 1, r, i << 1 | 1);
+//		}
+//	} else {
+//		for (int k = l; k <= r; k++) {
+//            ans[k] = false;
+//        }
+//	}
+//	for (int k = 1; k <= unionCnt; k++) {
+//		undo();
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> k;
+//	for (int i = 1; i <= n * 2; i++) {
+//		father[i] = i;
+//		siz[i] = 1;
+//	}
+//	for (int i = 1, x, y, l, r; i <= m; i++) {
+//        cin >> x >> y >> l >> r;
+//		add(l + 1, r, x, y, 1, k, 1);
+//	}
+//	dfs(1, k, 1);
+//	for (int i = 1; i <= k; i++) {
+//		if (ans[i]) {
+//            cout << "Yes" << "\n";
+//        } else {
+//        	cout << "No" << "\n";
+//        }
+//	}
+//	return 0;
+//}
\ No newline at end of file
diff --git a/src/class166/Code03_MinimumMexTree2.java b/src/class166/Code03_MinimumMexTree2.java
new file mode 100644
index 000000000..7c771c5a8
--- /dev/null
+++ b/src/class166/Code03_MinimumMexTree2.java
@@ -0,0 +1,128 @@
+package class166;
+
+// 最小mex生成树，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5631
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//const int MAXV = 100001;
+//const int MAXT = 30000001;
+//
+//int n, m, v;
+//
+//int father[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
+//int head[MAXV << 2];
+//int nxt[MAXT];
+//int tox[MAXT];
+//int toy[MAXT];
+//int cnt = 0;
+//
+//int part;
+//
+//void addEdge(int i, int x, int y) {
+//	nxt[++cnt] = head[i];
+//	tox[cnt] = x;
+//	toy[cnt] = y;
+//	head[i] = cnt;
+//}
+//
+//int find(int i) {
+//	while (i != father[i]) {
+//        i = father[i];
+//    }
+//	return i;
+//}
+//
+//void Union(int x, int y) {
+//	int fx = find(x);
+//	int fy = find(y);
+//	if (siz[fx] < siz[fy]) {
+//		int tmp = fx;
+//		fx = fy;
+//		fy = tmp;
+//	}
+//	father[fy] = fx;
+//	siz[fx] += siz[fy];
+//	rollback[++opsize][0] = fx;
+//	rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//	int fx = rollback[opsize][0];
+//	int fy = rollback[opsize--][1];
+//	father[fy] = fy;
+//	siz[fx] -= siz[fy];
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+//	if (jobl <= l && r <= jobr) {
+//		addEdge(i, jobx, joby);
+//	} else {
+//		int mid = (l + r) >> 1;
+//		if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, l, mid, i << 1);
+//        }
+//		if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+//        }
+//	}
+//}
+//
+//int dfs(int l, int r, int i) {
+//	int unionCnt = 0;
+//	for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
+//		int fx = find(tox[ei]);
+//		int fy = find(toy[ei]);
+//		if (fx != fy) {
+//			Union(fx, fy);
+//			part--;
+//			unionCnt++;
+//		}
+//	}
+//	int ans = -1;
+//	if (l == r) {
+//		if (part == 1) {
+//            ans = l;
+//        }
+//	} else {
+//		int mid = (l + r) >> 1;
+//		ans = dfs(l, mid, i << 1);
+//		if (ans == -1) {
+//            ans = dfs(mid + 1, r, i << 1 | 1);
+//        }
+//	}
+//	for (int k = 1; k <= unionCnt; k++) {
+//		undo();
+//		part++;
+//	}
+//	return ans;
+//}
+//
+//int main() {
+//	ios::sync_with_stdio(false);
+//	cin.tie(nullptr);
+//	cin >> n >> m;
+//	v = MAXV;
+//	for (int i = 1; i <= n; i++) {
+//		father[i] = i;
+//		siz[i] = 1;
+//	}
+//	for (int i = 1; i <= m; i++) {
+//		int x, y, w;
+//		cin >> x >> y >> w;
+//		if (w > 0) add(0, w - 1, x, y, 0, v, 1);
+//		add(w + 1, v, x, y, 0, v, 1);
+//	}
+//	part = n;
+//	cout << dfs(0, v, 1) << '\n';
+//	return 0;
+//}
\ No newline at end of file
diff --git a/src/class166/Code04_UniqueOccurrences2.java b/src/class166/Code04_UniqueOccurrences2.java
new file mode 100644
index 000000000..77514bb68
--- /dev/null
+++ b/src/class166/Code04_UniqueOccurrences2.java
@@ -0,0 +1,135 @@
+package class166;
+
+// 独特事件，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1681F
+// 测试链接 : https://codeforces.com/problemset/problem/1681/F
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//const int MAXT = 10000001;
+//int n, m;
+//
+//int father[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
+//int headc[MAXN];
+//int nxtc[MAXN];
+//int xc[MAXN];
+//int yc[MAXN];
+//int cntc = 0;
+//
+//int heads[MAXN << 2];
+//int nxts[MAXT];
+//int xs[MAXT];
+//int ys[MAXT];
+//int cnts = 0;
+//
+//long long ans = 0;
+//
+//void addEdgeC(int i, int x, int y) {
+//	nxtc[++cntc] = headc[i];
+//	xc[cntc] = x;
+//	yc[cntc] = y;
+//	headc[i] = cntc;
+//}
+//
+//void addEdgeS(int i, int x, int y) {
+//	nxts[++cnts] = heads[i];
+//	xs[cnts] = x;
+//	ys[cnts] = y;
+//	heads[i] = cnts;
+//}
+//
+//int find(int i) {
+//	while (i != father[i]) {
+//        i = father[i];
+//    }
+//	return i;
+//}
+//
+//void Union(int x, int y) {
+//	int fx = find(x);
+//	int fy = find(y);
+//	if (siz[fx] < siz[fy]) swap(fx, fy);
+//	father[fy] = fx;
+//	siz[fx] += siz[fy];
+//	rollback[++opsize][0] = fx;
+//	rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//	int fx = rollback[opsize][0];
+//	int fy = rollback[opsize--][1];
+//	father[fy] = fy;
+//	siz[fx] -= siz[fy];
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+//	if (jobl <= l && r <= jobr) {
+//		addEdgeS(i, jobx, joby);
+//	} else {
+//		int mid = (l + r) >> 1;
+//		if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, l, mid, i << 1);
+//        }
+//		if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+//        }
+//	}
+//}
+//
+//void dfs(int l, int r, int i) {
+//	int unionCnt = 0;
+//	for (int ei = heads[i], fx, fy; ei > 0; ei = nxts[ei]) {
+//		fx = find(xs[ei]);
+//		fy = find(ys[ei]);
+//		if (fx != fy) {
+//			Union(fx, fy);
+//			unionCnt++;
+//		}
+//	}
+//	if (l == r) {
+//		for (int ei = headc[l], fx, fy; ei > 0; ei = nxtc[ei]) {
+//			fx = find(xc[ei]);
+//			fy = find(yc[ei]);
+//			ans += 1LL * siz[fx] * siz[fy];
+//		}
+//	} else {
+//		int mid = (l + r) >> 1;
+//		dfs(l, mid, i << 1);
+//		dfs(mid + 1, r, i << 1 | 1);
+//	}
+//	for (int k = 1; k <= unionCnt; k++) {
+//		undo();
+//    }
+//}
+//
+//int main() {
+//	ios::sync_with_stdio(false);
+//	cin.tie(nullptr);
+//	cin >> n;
+//	for (int i = 1, x, y, c; i < n; i++) {
+//		cin >> x >> y >> c;
+//		addEdgeC(c, x, y);
+//		if (c > 1) {
+//            add(1, c - 1, x, y, 1, n, 1);
+//        }
+//		if (c < n) {
+//            add(c + 1, n, x, y, 1, n, 1);
+//        }
+//	}
+//	for (int i = 1; i <= n; i++) {
+//		father[i] = i;
+//		siz[i] = 1;
+//	}
+//	dfs(1, n, 1);
+//	cout << ans << '\n';
+//	return 0;
+//}
\ No newline at end of file

From af69d96aead230f27a641d3c25e705fa216659de Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 21 Apr 2025 22:54:24 +0800
Subject: [PATCH 0700/1712] modify code

---
 src/class166/Code05_GreatIntegration1.java |  18 +--
 src/class166/Code05_GreatIntegration2.java | 168 +++++++++++++++++++++
 2 files changed, 177 insertions(+), 9 deletions(-)
 create mode 100644 src/class166/Code05_GreatIntegration2.java

diff --git a/src/class166/Code05_GreatIntegration1.java b/src/class166/Code05_GreatIntegration1.java
index fecf87f25..e05954a51 100644
--- a/src/class166/Code05_GreatIntegration1.java
+++ b/src/class166/Code05_GreatIntegration1.java
@@ -20,7 +20,7 @@ public class Code05_GreatIntegration1 {
 	public static int[] u = new int[MAXN];
 	public static int[] v = new int[MAXN];
 
-	public static int[][] sorted = new int[MAXN][3];
+	public static int[][] event = new int[MAXN][3];
 
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
@@ -114,19 +114,19 @@ public static void prepare() {
 			siz[i] = 1;
 		}
 		for (int i = 1; i <= q; i++) {
-			sorted[i][0] = u[i];
-			sorted[i][1] = v[i];
-			sorted[i][2] = i;
+			event[i][0] = u[i];
+			event[i][1] = v[i];
+			event[i][2] = i;
 		}
-		Arrays.sort(sorted, 1, q + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] != b[1] ? a[1] - b[1] : a[2] - b[2]);
+		Arrays.sort(event, 1, q + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] != b[1] ? a[1] - b[1] : a[2] - b[2]);
 		for (int l = 1, r = 1; l <= q; l = ++r) {
-			int x = sorted[l][0], y = sorted[l][1], t = sorted[l][2];
-			while (r + 1 <= q && sorted[r + 1][0] == x && sorted[r + 1][1] == y) {
+			int x = event[l][0], y = event[l][1], t = event[l][2];
+			while (r + 1 <= q && event[r + 1][0] == x && event[r + 1][1] == y) {
 				r++;
 			}
 			for (int i = l + 1; i <= r; i++) {
-				add(t, sorted[i][2] - 1, x, y, 1, q, 1);
-				t = sorted[i][2] + 1;
+				add(t, event[i][2] - 1, x, y, 1, q, 1);
+				t = event[i][2] + 1;
 			}
 			if (t <= q) {
 				add(t, q, x, y, 1, q, 1);
diff --git a/src/class166/Code05_GreatIntegration2.java b/src/class166/Code05_GreatIntegration2.java
new file mode 100644
index 000000000..6c8e79d41
--- /dev/null
+++ b/src/class166/Code05_GreatIntegration2.java
@@ -0,0 +1,168 @@
+package class166;
+
+// 大融合，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4219
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Event {
+//    int x, y, t;
+//};
+//
+//bool EventCmp(Event a, Event b) {
+//    if (a.x != b.x) {
+//        return a.x < b.x;
+//    } else if (a.y != b.y) {
+//        return a.y < b.y;
+//    } else {
+//        return a.t < b.t;
+//    }
+//}
+//
+//const int MAXN = 100001;
+//const int MAXT = 3000001;
+//int n, q;
+//
+//int op[MAXN];
+//int u[MAXN];
+//int v[MAXN];
+//
+//Event event[MAXN];
+//
+//int father[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
+//int head[MAXN << 2];
+//int nxt[MAXT];
+//int tox[MAXT];
+//int toy[MAXT];
+//int cnt = 0;
+//
+//long long ans[MAXN];
+//
+//void addEdge(int i, int x, int y) {
+//	nxt[++cnt] = head[i];
+//	tox[cnt] = x;
+//	toy[cnt] = y;
+//	head[i] = cnt;
+//}
+//
+//int find(int i) {
+//	while (i != father[i]) {
+//        i = father[i];
+//    }
+//	return i;
+//}
+//
+//void Union(int x, int y) {
+//	int fx = find(x);
+//	int fy = find(y);
+//	if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//	father[fy] = fx;
+//	siz[fx] += siz[fy];
+//	rollback[++opsize][0] = fx;
+//	rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//	int fx = rollback[opsize][0];
+//	int fy = rollback[opsize--][1];
+//	father[fy] = fy;
+//	siz[fx] -= siz[fy];
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+//	if (jobl <= l && r <= jobr) {
+//		addEdge(i, jobx, joby);
+//	} else {
+//		int mid = (l + r) >> 1;
+//		if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, l, mid, i << 1);
+//        }
+//		if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+//        }
+//	}
+//}
+//
+//void dfs(int l, int r, int i) {
+//	int unionCnt = 0;
+//	for (int ei = head[i], fx, fy; ei > 0; ei = nxt[ei]) {
+//		fx = find(tox[ei]);
+//		fy = find(toy[ei]);
+//		if (fx != fy) {
+//			Union(fx, fy);
+//			unionCnt++;
+//		}
+//	}
+//	if (l == r) {
+//		if (op[l] == 2) {
+//			ans[l] = 1LL * siz[find(u[l])] * siz[find(v[l])];
+//		}
+//	} else {
+//		int mid = (l + r) >> 1;
+//		dfs(l, mid, i << 1);
+//		dfs(mid + 1, r, i << 1 | 1);
+//	}
+//	for (int k = 1; k <= unionCnt; k++) {
+//		undo();
+//    }
+//}
+//
+//void prepare() {
+//	for (int i = 1; i <= n; i++) {
+//		father[i] = i;
+//		siz[i] = 1;
+//	}
+//	for (int i = 1; i <= q; i++) {
+//        event[i].x = u[i];
+//        event[i].y = v[i];
+//        event[i].t = i;
+//	}
+//	sort(event + 1, event + q + 1, EventCmp);
+//	for (int l = 1, r = 1; l <= q; l = ++r) {
+//		int x = event[l].x, y = event[l].y, t = event[l].t;
+//		while (r + 1 <= q && event[r + 1].x == x && event[r + 1].y == y) {
+//            r++;
+//        }
+//		for (int j = l + 1; j <= r; j++) {
+//			add(t, event[j].t - 1, x, y, 1, q, 1);
+//			t = event[j].t + 1;
+//		}
+//		if (t <= q) {
+//            add(t, q, x, y, 1, q, 1);
+//        }
+//	}
+//}
+//
+//int main() {
+//	ios::sync_with_stdio(false);
+//	cin.tie(nullptr);
+//	cin >> n >> q;
+//    char t;
+//    int x, y;
+//	for (int i = 1; i <= q; i++) {
+//		cin >> t >> x >> y;
+//		op[i] = (t == 'A') ? 1 : 2;
+//		u[i] = min(x, y);
+//		v[i] = max(x, y);
+//	}
+//	prepare();
+//	dfs(1, q, 1);
+//	for (int i = 1; i <= q; i++) {
+//		if (op[i] == 2) {
+//            cout << ans[i] << '\n';
+//        }
+//	}
+//	return 0;
+//}
\ No newline at end of file

From ec04b2220ab4c46a1cb9a047b4fb231859e524a1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 21 Apr 2025 23:39:59 +0800
Subject: [PATCH 0701/1712] modify code

---
 .../Code01_SegmentTreeDivideConquer2.java     |   1 +
 src/class166/Code02_CheckBipartiteGraph2.java | 134 ++++++-------
 src/class166/Code03_MinimumMexTree2.java      | 138 ++++++-------
 src/class166/Code04_UniqueOccurrences2.java   | 136 ++++++-------
 src/class166/Code05_GreatIntegration2.java    | 150 +++++++-------
 src/class166/Code06_ConnectedGraph1.java      |   7 +-
 src/class166/Code06_ConnectedGraph2.java      | 187 ++++++++++++++++++
 src/class166/Code07_PaintingEdges2.java       |   6 +-
 8 files changed, 475 insertions(+), 284 deletions(-)
 create mode 100644 src/class166/Code06_ConnectedGraph2.java

diff --git a/src/class166/Code01_SegmentTreeDivideConquer2.java b/src/class166/Code01_SegmentTreeDivideConquer2.java
index 04cff0615..073bdc8b8 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer2.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer2.java
@@ -12,6 +12,7 @@
 //const int MAXN = 5001;
 //const int MAXM = 500001;
 //const int MAXT = 5000001;
+//
 //int n, m;
 //
 //int op[MAXM];
diff --git a/src/class166/Code02_CheckBipartiteGraph2.java b/src/class166/Code02_CheckBipartiteGraph2.java
index 31d1359dd..6c774b585 100644
--- a/src/class166/Code02_CheckBipartiteGraph2.java
+++ b/src/class166/Code02_CheckBipartiteGraph2.java
@@ -27,83 +27,83 @@
 //bool ans[MAXN];
 //
 //void addEdge(int i, int x, int y) {
-//	nxt[++cnt] = head[i];
-//	tox[cnt] = x;
-//	toy[cnt] = y;
-//	head[i] = cnt;
+//    nxt[++cnt] = head[i];
+//    tox[cnt] = x;
+//    toy[cnt] = y;
+//    head[i] = cnt;
 //}
 //
 //int find(int i) {
-//	while (i != father[i]) {
+//    while (i != father[i]) {
 //        i = father[i];
 //    }
-//	return i;
+//    return i;
 //}
 //
 //void Union(int x, int y) {
-//	int fx = find(x);
-//	int fy = find(y);
-//	if (siz[fx] < siz[fy]) {
-//		int tmp = fx;
-//		fx = fy;
-//		fy = tmp;
-//	}
-//	father[fy] = fx;
-//	siz[fx] += siz[fy];
-//	rollback[++opsize][0] = fx;
-//	rollback[opsize][1] = fy;
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
 //}
 //
 //void undo() {
-//	int fx = rollback[opsize][0];
-//	int fy = rollback[opsize--][1];
-//	father[fy] = fy;
-//	siz[fx] -= siz[fy];
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
 //}
 //
 //void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
-//	if (jobl <= l && r <= jobr) {
-//		addEdge(i, jobx, joby);
-//	} else {
-//		int mid = (l + r) >> 1;
-//		if (jobl <= mid) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobx, joby);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
 //            add(jobl, jobr, jobx, joby, l, mid, i << 1);
 //        }
-//		if (jobr > mid) {
+//        if (jobr > mid) {
 //            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
 //        }
-//	}
+//    }
 //}
 //
 //void dfs(int l, int r, int i) {
-//	bool check = true;
-//	int unionCnt = 0;
-//	for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
-//		int x = tox[ei], y = toy[ei], fx = find(x), fy = find(y);
-//		if (fx == fy) {
-//			check = false;
-//			break;
-//		} else {
-//			Union(x, y + n);
-//			Union(y, x + n);
-//			unionCnt += 2;
-//		}
-//	}
-//	if (check) {
-//		if (l == r) {
-//			ans[l] = true;
-//		} else {
-//			int mid = (l + r) >> 1;
-//			dfs(l, mid, i << 1);
-//			dfs(mid + 1, r, i << 1 | 1);
-//		}
-//	} else {
-//		for (int k = l; k <= r; k++) {
+//    bool check = true;
+//    int unionCnt = 0;
+//    for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
+//        int x = tox[ei], y = toy[ei], fx = find(x), fy = find(y);
+//        if (fx == fy) {
+//            check = false;
+//            break;
+//        } else {
+//            Union(x, y + n);
+//            Union(y, x + n);
+//            unionCnt += 2;
+//        }
+//    }
+//    if (check) {
+//        if (l == r) {
+//            ans[l] = true;
+//        } else {
+//            int mid = (l + r) >> 1;
+//            dfs(l, mid, i << 1);
+//            dfs(mid + 1, r, i << 1 | 1);
+//        }
+//    } else {
+//        for (int k = l; k <= r; k++) {
 //            ans[k] = false;
 //        }
-//	}
-//	for (int k = 1; k <= unionCnt; k++) {
-//		undo();
+//    }
+//    for (int k = 1; k <= unionCnt; k++) {
+//        undo();
 //    }
 //}
 //
@@ -111,21 +111,21 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m >> k;
-//	for (int i = 1; i <= n * 2; i++) {
-//		father[i] = i;
-//		siz[i] = 1;
-//	}
-//	for (int i = 1, x, y, l, r; i <= m; i++) {
+//    for (int i = 1; i <= n * 2; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    for (int i = 1, x, y, l, r; i <= m; i++) {
 //        cin >> x >> y >> l >> r;
-//		add(l + 1, r, x, y, 1, k, 1);
-//	}
-//	dfs(1, k, 1);
-//	for (int i = 1; i <= k; i++) {
-//		if (ans[i]) {
+//        add(l + 1, r, x, y, 1, k, 1);
+//    }
+//    dfs(1, k, 1);
+//    for (int i = 1; i <= k; i++) {
+//        if (ans[i]) {
 //            cout << "Yes" << "\n";
 //        } else {
-//        	cout << "No" << "\n";
+//            cout << "No" << "\n";
 //        }
-//	}
-//	return 0;
+//    }
+//    return 0;
 //}
\ No newline at end of file
diff --git a/src/class166/Code03_MinimumMexTree2.java b/src/class166/Code03_MinimumMexTree2.java
index 7c771c5a8..bfc96fb96 100644
--- a/src/class166/Code03_MinimumMexTree2.java
+++ b/src/class166/Code03_MinimumMexTree2.java
@@ -29,100 +29,102 @@
 //int part;
 //
 //void addEdge(int i, int x, int y) {
-//	nxt[++cnt] = head[i];
-//	tox[cnt] = x;
-//	toy[cnt] = y;
-//	head[i] = cnt;
+//    nxt[++cnt] = head[i];
+//    tox[cnt] = x;
+//    toy[cnt] = y;
+//    head[i] = cnt;
 //}
 //
 //int find(int i) {
-//	while (i != father[i]) {
+//    while (i != father[i]) {
 //        i = father[i];
 //    }
-//	return i;
+//    return i;
 //}
 //
 //void Union(int x, int y) {
-//	int fx = find(x);
-//	int fy = find(y);
-//	if (siz[fx] < siz[fy]) {
-//		int tmp = fx;
-//		fx = fy;
-//		fy = tmp;
-//	}
-//	father[fy] = fx;
-//	siz[fx] += siz[fy];
-//	rollback[++opsize][0] = fx;
-//	rollback[opsize][1] = fy;
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
 //}
 //
 //void undo() {
-//	int fx = rollback[opsize][0];
-//	int fy = rollback[opsize--][1];
-//	father[fy] = fy;
-//	siz[fx] -= siz[fy];
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
 //}
 //
 //void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
-//	if (jobl <= l && r <= jobr) {
-//		addEdge(i, jobx, joby);
-//	} else {
-//		int mid = (l + r) >> 1;
-//		if (jobl <= mid) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobx, joby);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
 //            add(jobl, jobr, jobx, joby, l, mid, i << 1);
 //        }
-//		if (jobr > mid) {
+//        if (jobr > mid) {
 //            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
 //        }
-//	}
+//    }
 //}
 //
 //int dfs(int l, int r, int i) {
-//	int unionCnt = 0;
-//	for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
-//		int fx = find(tox[ei]);
-//		int fy = find(toy[ei]);
-//		if (fx != fy) {
-//			Union(fx, fy);
-//			part--;
-//			unionCnt++;
-//		}
-//	}
-//	int ans = -1;
-//	if (l == r) {
-//		if (part == 1) {
+//    int unionCnt = 0;
+//    for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
+//        int fx = find(tox[ei]);
+//        int fy = find(toy[ei]);
+//        if (fx != fy) {
+//            Union(fx, fy);
+//            part--;
+//            unionCnt++;
+//        }
+//    }
+//    int ans = -1;
+//    if (l == r) {
+//        if (part == 1) {
 //            ans = l;
 //        }
-//	} else {
-//		int mid = (l + r) >> 1;
-//		ans = dfs(l, mid, i << 1);
-//		if (ans == -1) {
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ans = dfs(l, mid, i << 1);
+//        if (ans == -1) {
 //            ans = dfs(mid + 1, r, i << 1 | 1);
 //        }
-//	}
-//	for (int k = 1; k <= unionCnt; k++) {
-//		undo();
-//		part++;
-//	}
-//	return ans;
+//    }
+//    for (int k = 1; k <= unionCnt; k++) {
+//        undo();
+//        part++;
+//    }
+//    return ans;
 //}
 //
 //int main() {
-//	ios::sync_with_stdio(false);
-//	cin.tie(nullptr);
-//	cin >> n >> m;
-//	v = MAXV;
-//	for (int i = 1; i <= n; i++) {
-//		father[i] = i;
-//		siz[i] = 1;
-//	}
-//	for (int i = 1; i <= m; i++) {
-//		int x, y, w;
-//		cin >> x >> y >> w;
-//		if (w > 0) add(0, w - 1, x, y, 0, v, 1);
-//		add(w + 1, v, x, y, 0, v, 1);
-//	}
-//	part = n;
-//	cout << dfs(0, v, 1) << '\n';
-//	return 0;
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    v = MAXV;
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        int x, y, w;
+//        cin >> x >> y >> w;
+//        if (w > 0) {
+//            add(0, w - 1, x, y, 0, v, 1);
+//        }
+//        add(w + 1, v, x, y, 0, v, 1);
+//    }
+//    part = n;
+//    cout << dfs(0, v, 1) << '\n';
+//    return 0;
 //}
\ No newline at end of file
diff --git a/src/class166/Code04_UniqueOccurrences2.java b/src/class166/Code04_UniqueOccurrences2.java
index 77514bb68..aba2f9a0f 100644
--- a/src/class166/Code04_UniqueOccurrences2.java
+++ b/src/class166/Code04_UniqueOccurrences2.java
@@ -34,102 +34,106 @@
 //long long ans = 0;
 //
 //void addEdgeC(int i, int x, int y) {
-//	nxtc[++cntc] = headc[i];
-//	xc[cntc] = x;
-//	yc[cntc] = y;
-//	headc[i] = cntc;
+//    nxtc[++cntc] = headc[i];
+//    xc[cntc] = x;
+//    yc[cntc] = y;
+//    headc[i] = cntc;
 //}
 //
 //void addEdgeS(int i, int x, int y) {
-//	nxts[++cnts] = heads[i];
-//	xs[cnts] = x;
-//	ys[cnts] = y;
-//	heads[i] = cnts;
+//    nxts[++cnts] = heads[i];
+//    xs[cnts] = x;
+//    ys[cnts] = y;
+//    heads[i] = cnts;
 //}
 //
 //int find(int i) {
-//	while (i != father[i]) {
+//    while (i != father[i]) {
 //        i = father[i];
 //    }
-//	return i;
+//    return i;
 //}
 //
 //void Union(int x, int y) {
-//	int fx = find(x);
-//	int fy = find(y);
-//	if (siz[fx] < siz[fy]) swap(fx, fy);
-//	father[fy] = fx;
-//	siz[fx] += siz[fy];
-//	rollback[++opsize][0] = fx;
-//	rollback[opsize][1] = fy;
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fx = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
 //}
 //
 //void undo() {
-//	int fx = rollback[opsize][0];
-//	int fy = rollback[opsize--][1];
-//	father[fy] = fy;
-//	siz[fx] -= siz[fy];
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
 //}
 //
 //void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
-//	if (jobl <= l && r <= jobr) {
-//		addEdgeS(i, jobx, joby);
-//	} else {
-//		int mid = (l + r) >> 1;
-//		if (jobl <= mid) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdgeS(i, jobx, joby);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
 //            add(jobl, jobr, jobx, joby, l, mid, i << 1);
 //        }
-//		if (jobr > mid) {
+//        if (jobr > mid) {
 //            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
 //        }
-//	}
+//    }
 //}
 //
 //void dfs(int l, int r, int i) {
-//	int unionCnt = 0;
-//	for (int ei = heads[i], fx, fy; ei > 0; ei = nxts[ei]) {
-//		fx = find(xs[ei]);
-//		fy = find(ys[ei]);
-//		if (fx != fy) {
-//			Union(fx, fy);
-//			unionCnt++;
-//		}
-//	}
-//	if (l == r) {
-//		for (int ei = headc[l], fx, fy; ei > 0; ei = nxtc[ei]) {
-//			fx = find(xc[ei]);
-//			fy = find(yc[ei]);
-//			ans += 1LL * siz[fx] * siz[fy];
-//		}
-//	} else {
-//		int mid = (l + r) >> 1;
-//		dfs(l, mid, i << 1);
-//		dfs(mid + 1, r, i << 1 | 1);
-//	}
-//	for (int k = 1; k <= unionCnt; k++) {
-//		undo();
+//    int unionCnt = 0;
+//    for (int ei = heads[i], fx, fy; ei > 0; ei = nxts[ei]) {
+//        fx = find(xs[ei]);
+//        fy = find(ys[ei]);
+//        if (fx != fy) {
+//            Union(fx, fy);
+//            unionCnt++;
+//        }
+//    }
+//    if (l == r) {
+//        for (int ei = headc[l], fx, fy; ei > 0; ei = nxtc[ei]) {
+//            fx = find(xc[ei]);
+//            fy = find(yc[ei]);
+//            ans += 1LL * siz[fx] * siz[fy];
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//    for (int k = 1; k <= unionCnt; k++) {
+//        undo();
 //    }
 //}
 //
 //int main() {
-//	ios::sync_with_stdio(false);
-//	cin.tie(nullptr);
-//	cin >> n;
-//	for (int i = 1, x, y, c; i < n; i++) {
-//		cin >> x >> y >> c;
-//		addEdgeC(c, x, y);
-//		if (c > 1) {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, x, y, c; i < n; i++) {
+//        cin >> x >> y >> c;
+//        addEdgeC(c, x, y);
+//        if (c > 1) {
 //            add(1, c - 1, x, y, 1, n, 1);
 //        }
-//		if (c < n) {
+//        if (c < n) {
 //            add(c + 1, n, x, y, 1, n, 1);
 //        }
-//	}
-//	for (int i = 1; i <= n; i++) {
-//		father[i] = i;
-//		siz[i] = 1;
-//	}
-//	dfs(1, n, 1);
-//	cout << ans << '\n';
-//	return 0;
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    dfs(1, n, 1);
+//    cout << ans << '\n';
+//    return 0;
 //}
\ No newline at end of file
diff --git a/src/class166/Code05_GreatIntegration2.java b/src/class166/Code05_GreatIntegration2.java
index 6c8e79d41..3c9c60ea0 100644
--- a/src/class166/Code05_GreatIntegration2.java
+++ b/src/class166/Code05_GreatIntegration2.java
@@ -47,122 +47,122 @@
 //long long ans[MAXN];
 //
 //void addEdge(int i, int x, int y) {
-//	nxt[++cnt] = head[i];
-//	tox[cnt] = x;
-//	toy[cnt] = y;
-//	head[i] = cnt;
+//    nxt[++cnt] = head[i];
+//    tox[cnt] = x;
+//    toy[cnt] = y;
+//    head[i] = cnt;
 //}
 //
 //int find(int i) {
-//	while (i != father[i]) {
+//    while (i != father[i]) {
 //        i = father[i];
 //    }
-//	return i;
+//    return i;
 //}
 //
 //void Union(int x, int y) {
-//	int fx = find(x);
-//	int fy = find(y);
-//	if (siz[fx] < siz[fy]) {
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
 //        int tmp = fx;
 //        fx = fy;
 //        fy = tmp;
 //    }
-//	father[fy] = fx;
-//	siz[fx] += siz[fy];
-//	rollback[++opsize][0] = fx;
-//	rollback[opsize][1] = fy;
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
 //}
 //
 //void undo() {
-//	int fx = rollback[opsize][0];
-//	int fy = rollback[opsize--][1];
-//	father[fy] = fy;
-//	siz[fx] -= siz[fy];
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
 //}
 //
 //void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
-//	if (jobl <= l && r <= jobr) {
-//		addEdge(i, jobx, joby);
-//	} else {
-//		int mid = (l + r) >> 1;
-//		if (jobl <= mid) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobx, joby);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
 //            add(jobl, jobr, jobx, joby, l, mid, i << 1);
 //        }
-//		if (jobr > mid) {
+//        if (jobr > mid) {
 //            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
 //        }
-//	}
+//    }
 //}
 //
 //void dfs(int l, int r, int i) {
-//	int unionCnt = 0;
-//	for (int ei = head[i], fx, fy; ei > 0; ei = nxt[ei]) {
-//		fx = find(tox[ei]);
-//		fy = find(toy[ei]);
-//		if (fx != fy) {
-//			Union(fx, fy);
-//			unionCnt++;
-//		}
-//	}
-//	if (l == r) {
-//		if (op[l] == 2) {
-//			ans[l] = 1LL * siz[find(u[l])] * siz[find(v[l])];
-//		}
-//	} else {
-//		int mid = (l + r) >> 1;
-//		dfs(l, mid, i << 1);
-//		dfs(mid + 1, r, i << 1 | 1);
-//	}
-//	for (int k = 1; k <= unionCnt; k++) {
-//		undo();
+//    int unionCnt = 0;
+//    for (int ei = head[i], fx, fy; ei > 0; ei = nxt[ei]) {
+//        fx = find(tox[ei]);
+//        fy = find(toy[ei]);
+//        if (fx != fy) {
+//            Union(fx, fy);
+//            unionCnt++;
+//        }
+//    }
+//    if (l == r) {
+//        if (op[l] == 2) {
+//            ans[l] = 1LL * siz[find(u[l])] * siz[find(v[l])];
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//    for (int k = 1; k <= unionCnt; k++) {
+//        undo();
 //    }
 //}
 //
 //void prepare() {
-//	for (int i = 1; i <= n; i++) {
-//		father[i] = i;
-//		siz[i] = 1;
-//	}
-//	for (int i = 1; i <= q; i++) {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    for (int i = 1; i <= q; i++) {
 //        event[i].x = u[i];
 //        event[i].y = v[i];
 //        event[i].t = i;
-//	}
-//	sort(event + 1, event + q + 1, EventCmp);
-//	for (int l = 1, r = 1; l <= q; l = ++r) {
-//		int x = event[l].x, y = event[l].y, t = event[l].t;
-//		while (r + 1 <= q && event[r + 1].x == x && event[r + 1].y == y) {
+//    }
+//    sort(event + 1, event + q + 1, EventCmp);
+//    for (int l = 1, r = 1; l <= q; l = ++r) {
+//        int x = event[l].x, y = event[l].y, t = event[l].t;
+//        while (r + 1 <= q && event[r + 1].x == x && event[r + 1].y == y) {
 //            r++;
 //        }
-//		for (int j = l + 1; j <= r; j++) {
-//			add(t, event[j].t - 1, x, y, 1, q, 1);
-//			t = event[j].t + 1;
-//		}
-//		if (t <= q) {
+//        for (int j = l + 1; j <= r; j++) {
+//            add(t, event[j].t - 1, x, y, 1, q, 1);
+//            t = event[j].t + 1;
+//        }
+//        if (t <= q) {
 //            add(t, q, x, y, 1, q, 1);
 //        }
-//	}
+//    }
 //}
 //
 //int main() {
-//	ios::sync_with_stdio(false);
-//	cin.tie(nullptr);
-//	cin >> n >> q;
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
 //    char t;
 //    int x, y;
-//	for (int i = 1; i <= q; i++) {
-//		cin >> t >> x >> y;
-//		op[i] = (t == 'A') ? 1 : 2;
-//		u[i] = min(x, y);
-//		v[i] = max(x, y);
-//	}
-//	prepare();
-//	dfs(1, q, 1);
-//	for (int i = 1; i <= q; i++) {
-//		if (op[i] == 2) {
+//    for (int i = 1; i <= q; i++) {
+//        cin >> t >> x >> y;
+//        op[i] = (t == 'A') ? 1 : 2;
+//        u[i] = min(x, y);
+//        v[i] = max(x, y);
+//    }
+//    prepare();
+//    dfs(1, q, 1);
+//    for (int i = 1; i <= q; i++) {
+//        if (op[i] == 2) {
 //            cout << ans[i] << '\n';
 //        }
-//	}
-//	return 0;
+//    }
+//    return 0;
 //}
\ No newline at end of file
diff --git a/src/class166/Code06_ConnectedGraph1.java b/src/class166/Code06_ConnectedGraph1.java
index 53f39e061..0a2166462 100644
--- a/src/class166/Code06_ConnectedGraph1.java
+++ b/src/class166/Code06_ConnectedGraph1.java
@@ -89,11 +89,8 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 	public static void dfs(int l, int r, int i) {
 		boolean check = false;
 		int unionCnt = 0;
-		for (int ei = head[i], x, y, fx, fy; ei > 0; ei = next[ei]) {
-			x = tox[ei];
-			y = toy[ei];
-			fx = find(x);
-			fy = find(y);
+		for (int ei = head[i]; ei > 0; ei = next[ei]) {
+			int x = tox[ei], y = toy[ei], fx = find(x), fy = find(y);
 			if (fx != fy) {
 				union(fx, fy);
 				unionCnt++;
diff --git a/src/class166/Code06_ConnectedGraph2.java b/src/class166/Code06_ConnectedGraph2.java
new file mode 100644
index 000000000..eeb421d37
--- /dev/null
+++ b/src/class166/Code06_ConnectedGraph2.java
@@ -0,0 +1,187 @@
+package class166;
+
+// 连通图，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5227
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Event {
+//    int ei, t;
+//};
+//
+//bool EventCmp(Event a, Event b) {
+//    if (a.ei != b.ei) {
+//        return a.ei < b.ei;
+//    } else {
+//        return a.t < b.t;
+//    }
+//}
+//
+//const int MAXN = 100001;
+//const int MAXM = 200001;
+//const int MAXE = 400001;
+//const int MAXT = 10000001;
+//
+//int n, m, k;
+//
+//int u[MAXM];
+//int v[MAXM];
+//
+//Event event[MAXE];
+//int ecnt = 0;
+//bool vis[MAXM];
+//
+//int father[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
+//int head[MAXN << 2];
+//int nxt[MAXT];
+//int tox[MAXT];
+//int toy[MAXT];
+//int cnt = 0;
+//
+//bool ans[MAXN];
+//
+//void addEdge(int i, int x, int y) {
+//    nxt[++cnt] = head[i];
+//    tox[cnt] = x;
+//    toy[cnt] = y;
+//    head[i] = cnt;
+//}
+//
+//int find(int i) {
+//    while (i != father[i]) {
+//        i = father[i];
+//    }
+//    return i;
+//}
+//
+//void Union(int x, int y) {
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobx, joby);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i) {
+//    bool check = false;
+//    int unionCnt = 0;
+//    for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
+//        int x = tox[ei], y = toy[ei], fx = find(x), fy = find(y);
+//        if (fx != fy) {
+//            Union(fx, fy);
+//            unionCnt++;
+//        }
+//        if (siz[find(fx)] == n) {
+//            check = true;
+//            break;
+//        }
+//    }
+//    if (check) {
+//        for (int j = l; j <= r; j++) {
+//            ans[j] = true;
+//        }
+//    } else {
+//        if (l == r) {
+//            ans[l] = false;
+//        } else {
+//            int mid = (l + r) >> 1;
+//            dfs(l, mid, i << 1);
+//            dfs(mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//    for (int j = 1; j <= unionCnt; j++) {
+//        undo();
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    sort(event + 1, event + ecnt + 1, EventCmp);
+//    for (int l = 1, r = 1, eid; l <= ecnt; l = ++r) {
+//        eid = event[l].ei;
+//        vis[eid] = true;
+//        while (r + 1 <= ecnt && event[r + 1].ei == eid) {
+//            r++;
+//        }
+//        int t = 1;
+//        for (int i = l; i <= r; i++) {
+//            if (t <= event[i].t - 1) {
+//                add(t, event[i].t - 1, u[eid], v[eid], 1, k, 1);
+//            }
+//            t = event[i].t + 1;
+//        }
+//        if (t <= k) {
+//            add(t, k, u[eid], v[eid], 1, k, 1);
+//        }
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (!vis[i]) {
+//            add(1, k, u[i], v[i], 1, k, 1);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> u[i] >> v[i];
+//    }
+//    cin >> k;
+//    for (int i = 1, s; i <= k; i++) {
+//        cin >> s;
+//        for (int j = 1; j <= s; j++) {
+//            cin >> event[++ecnt].ei;
+//            event[ecnt].t = i;
+//        }
+//    }
+//    prepare();
+//    dfs(1, k, 1);
+//    for (int i = 1; i <= k; i++) {
+//        if (ans[i]) {
+//            cout << "Connected" << "\n";
+//        } else {
+//            cout << "Disconnected" << "\n";
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
index 9483bebf5..f2fb575e0 100644
--- a/src/class166/Code07_PaintingEdges2.java
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -91,11 +91,11 @@
 //        int x = u[e[qid[ei]]], xn = x + n, fx = find(color, x), fxn = find(color, xn);
 //        int y = v[e[qid[ei]]], yn = y + n, fy = find(color, y), fyn = find(color, yn);
 //        if (fx != fyn) {
-//        	Union(color, fx, fyn);
+//            Union(color, fx, fyn);
 //            unionCnt++;
 //        }
 //        if (fy != fxn) {
-//        	Union(color, fy, fxn);
+//            Union(color, fy, fxn);
 //            unionCnt++;
 //        }
 //    }
@@ -113,7 +113,7 @@
 //        dfs(mid + 1, r, i << 1 | 1);
 //    }
 //    for (int j = 1; j <= unionCnt; j++) {
-//    	undo();
+//        undo();
 //    }
 //}
 //

From d57f4732560589e12c3b4f79d3eeaf117e5e1553 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 22 Apr 2025 16:37:06 +0800
Subject: [PATCH 0702/1712] modify code

---
 src/class166/Code07_PaintingEdges1.java | 16 ++++++++--------
 src/class166/Code07_PaintingEdges2.java | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index f4ea844dd..1d4830ee3 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -21,7 +21,7 @@ public class Code07_PaintingEdges1 {
 	public static int[] e = new int[MAXN];
 	public static int[] c = new int[MAXN];
 
-	public static int[] pos = new int[MAXN];
+	public static int[] help = new int[MAXN];
 
 	public static int[][] father = new int[MAXK][MAXN << 1];
 	public static int[][] siz = new int[MAXK][MAXN << 1];
@@ -103,10 +103,10 @@ public static void dfs(int l, int r, int i) {
 		if (l == r) {
 			if (find(c[l], u[e[l]]) == find(c[l], v[e[l]])) {
 				ans[l] = false;
-				c[l] = pos[e[l]];
+				c[l] = help[e[l]];
 			} else {
 				ans[l] = true;
-				pos[e[l]] = c[l];
+				help[e[l]] = c[l];
 			}
 		} else {
 			int mid = (l + r) >> 1;
@@ -128,16 +128,16 @@ public static void prepare() {
 			}
 		}
 		for (int i = 1; i <= m; i++) {
-			pos[i] = q + 1;
+			help[i] = q + 1;
 		}
 		for (int i = q; i >= 1; i--) {
-			if (i + 1 <= pos[e[i]] - 1) {
-				add(i + 1, pos[e[i]] - 1, i, 1, q, 1);
+			if (i + 1 <= help[e[i]] - 1) {
+				add(i + 1, help[e[i]] - 1, i, 1, q, 1);
 			}
-			pos[e[i]] = i;
+			help[e[i]] = i;
 		}
 		for (int i = 1; i <= m; i++) {
-			pos[i] = 0;
+			help[i] = 0;
 		}
 	}
 
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
index f2fb575e0..6ee448f2a 100644
--- a/src/class166/Code07_PaintingEdges2.java
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -20,7 +20,7 @@
 //int e[MAXN];
 //int c[MAXN];
 //
-//int pos[MAXN];
+//int help[MAXN];
 //
 //int father[MAXK][MAXN << 1];
 //int siz[MAXK][MAXN << 1];
@@ -102,10 +102,10 @@
 //    if (l == r) {
 //        if (find(c[l], u[e[l]]) == find(c[l], v[e[l]])) {
 //            ans[l] = false;
-//            c[l] = pos[e[l]];
+//            c[l] = help[e[l]];
 //        } else {
 //            ans[l] = true;
-//            pos[e[l]] = c[l];
+//            help[e[l]] = c[l];
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
@@ -127,16 +127,16 @@
 //        }
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        pos[i] = q + 1;
+//        help[i] = q + 1;
 //    }
 //    for (int i = q; i >= 1; i--) {
-//        if (i + 1 <= pos[e[i]] - 1) {
-//            add(i + 1, pos[e[i]] - 1, i, 1, q, 1);
+//        if (i + 1 <= help[e[i]] - 1) {
+//            add(i + 1, help[e[i]] - 1, i, 1, q, 1);
 //        }
-//        pos[e[i]] = i;
+//        help[e[i]] = i;
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        pos[i] = 0;
+//        help[i] = 0;
 //    }
 //}
 //

From bed9acc9f8e1796f73e0987cad9d6a659d8b91ca Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 22 Apr 2025 18:01:40 +0800
Subject: [PATCH 0703/1712] modify code

---
 src/class166/Code01_SegmentTreeDivideConquer1.java |  7 +++++++
 src/class166/Code01_SegmentTreeDivideConquer2.java |  7 +++++++
 src/class166/Code02_CheckBipartiteGraph1.java      |  8 +++++++-
 src/class166/Code02_CheckBipartiteGraph2.java      |  8 +++++++-
 src/class166/Code03_MinimumMexTree1.java           |  6 ++++++
 src/class166/Code03_MinimumMexTree2.java           |  6 ++++++
 src/class166/Code04_UniqueOccurrences1.java        |  4 ++++
 src/class166/Code04_UniqueOccurrences2.java        |  4 ++++
 src/class166/Code05_GreatIntegration1.java         |  5 +++++
 src/class166/Code05_GreatIntegration2.java         |  5 +++++
 src/class166/Code06_ConnectedGraph1.java           | 14 +++++++++++---
 src/class166/Code06_ConnectedGraph2.java           | 14 +++++++++++---
 src/class166/Code07_PaintingEdges1.java            | 10 +++++++++-
 src/class166/Code07_PaintingEdges2.java            | 10 +++++++++-
 14 files changed, 98 insertions(+), 10 deletions(-)

diff --git a/src/class166/Code01_SegmentTreeDivideConquer1.java b/src/class166/Code01_SegmentTreeDivideConquer1.java
index e8deaac52..dc0ee630c 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer1.java
@@ -1,6 +1,13 @@
 package class166;
 
 // 线段树分治模版题，java版
+// 一共有n个节点，一共有m条操作，每条操作是如下三种类型中的一种
+// 操作 0 x y : 点x和点y之间一定没有边，现在增加一条边
+// 操作 1 x y : 点x和点y之间一定存在边，现在删除这条边
+// 操作 2 x y : 查询点x和点y是否联通
+// 1 <= n <= 5000
+// 1 <= m <= 500000
+// 不强制在线，可以离线处理
 // 测试链接 : https://loj.ac/p/121
 // 提交以下的code，提交时类名改成"Main"，多提交几次，可以通过所有测试用例
 
diff --git a/src/class166/Code01_SegmentTreeDivideConquer2.java b/src/class166/Code01_SegmentTreeDivideConquer2.java
index 073bdc8b8..914398566 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer2.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer2.java
@@ -1,6 +1,13 @@
 package class166;
 
 // 线段树分治模版题，C++版
+// 一共有n个节点，一共有m条操作，每条操作是如下三种类型中的一种
+// 操作 0 x y : 点x和点y之间一定没有边，现在增加一条边
+// 操作 1 x y : 点x和点y之间一定存在边，现在删除这条边
+// 操作 2 x y : 查询点x和点y是否联通
+// 1 <= n <= 5000
+// 1 <= m <= 500000
+// 不强制在线，可以离线处理
 // 测试链接 : https://loj.ac/p/121
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class166/Code02_CheckBipartiteGraph1.java b/src/class166/Code02_CheckBipartiteGraph1.java
index 82d3c29e4..e16af6191 100644
--- a/src/class166/Code02_CheckBipartiteGraph1.java
+++ b/src/class166/Code02_CheckBipartiteGraph1.java
@@ -1,6 +1,12 @@
 package class166;
 
-// 检查二分图，java版
+// 判断二分图，java版
+// 一共有n个节点，时刻的范围0~k，一共有m条操作，每条操作含义如下
+// 操作 x y l r : 点x到点y之间连一条边，该边在l时刻出现，在r时刻消失
+// 分别打印1时刻以内、2时刻以内..k时刻以内，图是不是二分图
+// 注意i时刻以内是0~i-1时间段的意思
+// 1 <= n、k <= 10^5    1 <= m <= 2 * 10^5
+// 1 <= x、y <= n       0 <= l、r <= k
 // 测试链接 : https://www.luogu.com.cn/problem/P5787
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class166/Code02_CheckBipartiteGraph2.java b/src/class166/Code02_CheckBipartiteGraph2.java
index 6c774b585..daa1460a7 100644
--- a/src/class166/Code02_CheckBipartiteGraph2.java
+++ b/src/class166/Code02_CheckBipartiteGraph2.java
@@ -1,6 +1,12 @@
 package class166;
 
-// 检查二分图，C++版
+// 判断二分图，C++版
+// 一共有n个节点，时刻的范围0~k，一共有m条操作，每条操作含义如下
+// 操作 x y l r : 点x到点y之间连一条边，该边在l时刻出现，在r时刻消失
+// 分别打印1时刻以内、2时刻以内..k时刻以内，图是不是二分图
+// 注意i时刻以内是0~i-1时间段的意思
+// 1 <= n、k <= 10^5    1 <= m <= 2 * 10^5
+// 1 <= x、y <= n       0 <= l、r <= k
 // 测试链接 : https://www.luogu.com.cn/problem/P5787
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class166/Code03_MinimumMexTree1.java b/src/class166/Code03_MinimumMexTree1.java
index a3bc7baff..b64f603fe 100644
--- a/src/class166/Code03_MinimumMexTree1.java
+++ b/src/class166/Code03_MinimumMexTree1.java
@@ -1,6 +1,12 @@
 package class166;
 
 // 最小mex生成树，java版
+// 给定n个点，m条边的无向连通图，边有边权
+// 自然数集合S的mex含义为：最小的、没有出现在S中的自然数
+// 现在你要求出一个这个图的生成树，使得其边权集合的mex尽可能小
+// 1 <= n <= 10^6
+// 1 <= m <= 2 * 10^6
+// 0 <= 边权 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5631
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class166/Code03_MinimumMexTree2.java b/src/class166/Code03_MinimumMexTree2.java
index bfc96fb96..06a522729 100644
--- a/src/class166/Code03_MinimumMexTree2.java
+++ b/src/class166/Code03_MinimumMexTree2.java
@@ -1,6 +1,12 @@
 package class166;
 
 // 最小mex生成树，C++版
+// 给定n个点，m条边的无向连通图，边有边权
+// 自然数集合S的mex含义为：最小的、没有出现在S中的自然数
+// 现在你要求出一个这个图的生成树，使得其边权集合的mex尽可能小
+// 1 <= n <= 10^6
+// 1 <= m <= 2 * 10^6
+// 0 <= 边权 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5631
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class166/Code04_UniqueOccurrences1.java b/src/class166/Code04_UniqueOccurrences1.java
index 076611cd3..d33ac34a7 100644
--- a/src/class166/Code04_UniqueOccurrences1.java
+++ b/src/class166/Code04_UniqueOccurrences1.java
@@ -1,6 +1,10 @@
 package class166;
 
 // 独特事件，java版
+// 一共有n个节点，n-1条无向边，边给定颜色值，所有节点连成一棵树
+// 定义f(u, v) : 点u到点v的简单路径上恰好出现一次的颜色的数量
+// 打印 ∑(u = 1..n) ∑(v = u + 1..n) f(u, v) 的结果
+// 1 <= 颜色值 <= n <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1681F
 // 测试链接 : https://codeforces.com/problemset/problem/1681/F
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class166/Code04_UniqueOccurrences2.java b/src/class166/Code04_UniqueOccurrences2.java
index aba2f9a0f..604107900 100644
--- a/src/class166/Code04_UniqueOccurrences2.java
+++ b/src/class166/Code04_UniqueOccurrences2.java
@@ -1,6 +1,10 @@
 package class166;
 
 // 独特事件，C++版
+// 一共有n个节点，n-1条无向边，边给定颜色值，所有节点连成一棵树
+// 定义f(u, v) : 点u到点v的简单路径上恰好出现一次的颜色的数量
+// 打印 ∑(u = 1..n) ∑(v = u + 1..n) f(u, v) 的结果
+// 1 <= 颜色值 <= n <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1681F
 // 测试链接 : https://codeforces.com/problemset/problem/1681/F
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class166/Code05_GreatIntegration1.java b/src/class166/Code05_GreatIntegration1.java
index e05954a51..c9cf44d51 100644
--- a/src/class166/Code05_GreatIntegration1.java
+++ b/src/class166/Code05_GreatIntegration1.java
@@ -1,6 +1,11 @@
 package class166;
 
 // 大融合，java版
+// 一共有n个点，一共有q条操作，每条操作是如下两种类型中的一种
+// 操作 A x y : 点x和点y之间连一条边，保证之前x和y是不联通的
+// 操作 Q x y : 打印点x和点y之间这条边的负载，保证x和y之间有一条边
+// 边负载定义为，假设去掉这条边之后，端点1联通区大小 * 端点2联通区大小
+// 1 <= n、q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4219
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class166/Code05_GreatIntegration2.java b/src/class166/Code05_GreatIntegration2.java
index 3c9c60ea0..283ae2223 100644
--- a/src/class166/Code05_GreatIntegration2.java
+++ b/src/class166/Code05_GreatIntegration2.java
@@ -1,6 +1,11 @@
 package class166;
 
 // 大融合，C++版
+// 一共有n个点，一共有q条操作，每条操作是如下两种类型中的一种
+// 操作 A x y : 点x和点y之间连一条边，保证之前x和y是不联通的
+// 操作 Q x y : 打印点x和点y之间这条边的负载，保证x和y之间有一条边
+// 边负载定义为，假设去掉这条边之后，端点1联通区大小 * 端点2联通区大小
+// 1 <= n、q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4219
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class166/Code06_ConnectedGraph1.java b/src/class166/Code06_ConnectedGraph1.java
index 0a2166462..fe0282500 100644
--- a/src/class166/Code06_ConnectedGraph1.java
+++ b/src/class166/Code06_ConnectedGraph1.java
@@ -1,6 +1,14 @@
 package class166;
 
 // 连通图，java版
+// 一共有n个点，给定m条边，所有点一定组成一个连通图
+// 一共有k条操作，每条操作格式如下
+// 操作 c ... : 操作涉及c条边，这些边的编号 ... 一共c个
+//              假设删掉这些边，打印整张图是否联通
+// 每条操作都是独立的，相互之间没有任何关系
+// 1 <= n、k <= 10^5
+// 1 <= m <= 2 * 10^5
+// 1 <= c <= 4
 // 测试链接 : https://www.luogu.com.cn/problem/P5227
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -158,9 +166,9 @@ public static void main(String[] args) {
 			v[i] = io.nextInt();
 		}
 		k = io.nextInt();
-		for (int i = 1, s; i <= k; i++) {
-			s = io.nextInt();
-			for (int j = 1; j <= s; j++) {
+		for (int i = 1, c; i <= k; i++) {
+			c = io.nextInt();
+			for (int j = 1; j <= c; j++) {
 				event[++ecnt][0] = io.nextInt();
 				event[ecnt][1] = i;
 			}
diff --git a/src/class166/Code06_ConnectedGraph2.java b/src/class166/Code06_ConnectedGraph2.java
index eeb421d37..2c5273cb9 100644
--- a/src/class166/Code06_ConnectedGraph2.java
+++ b/src/class166/Code06_ConnectedGraph2.java
@@ -1,6 +1,14 @@
 package class166;
 
 // 连通图，C++版
+// 一共有n个点，给定m条边，所有点一定组成一个连通图
+// 一共有k条操作，每条操作格式如下
+// 操作 c ... : 操作涉及c条边，这些边的编号 ... 一共c个
+//              假设删掉这些边，打印整张图是否联通
+// 每条操作都是独立的，相互之间没有任何关系
+// 1 <= n、k <= 10^5
+// 1 <= m <= 2 * 10^5
+// 1 <= c <= 4
 // 测试链接 : https://www.luogu.com.cn/problem/P5227
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -167,9 +175,9 @@
 //        cin >> u[i] >> v[i];
 //    }
 //    cin >> k;
-//    for (int i = 1, s; i <= k; i++) {
-//        cin >> s;
-//        for (int j = 1; j <= s; j++) {
+//    for (int i = 1, c; i <= k; i++) {
+//        cin >> c;
+//        for (int j = 1; j <= c; j++) {
 //            cin >> event[++ecnt].ei;
 //            event[ecnt].t = i;
 //        }
diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index 1d4830ee3..c281d23b6 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -1,6 +1,14 @@
 package class166;
 
-// 边的涂色，java版
+// 给边涂色，java版
+// 一共有n个点，给定m条无向边，一开始每条边无颜色，一共有k种颜色
+// 合法状态的定义为，仅保留染成k种颜色中的任何一种颜色的边，图都是一张二分图
+// 一共有q条操作，每条操作格式如下
+// 操作 e c : 第e条边，现在要涂成c颜色
+//           如果执行此操作之后，整张图还是合法状态，那么执行并打印"YES"
+//           如果执行此操作之后，整张图不再是合法状态，那么不执行并打印"NO"
+// 1 <= n、m、q <= 5 * 10^5
+// 1 <= k <= 50
 // 测试链接 : https://www.luogu.com.cn/problem/CF576E
 // 测试链接 : https://codeforces.com/problemset/problem/576/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
index 6ee448f2a..b6fc0dd7f 100644
--- a/src/class166/Code07_PaintingEdges2.java
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -1,6 +1,14 @@
 package class166;
 
-// 边的涂色，C++版
+// 给边涂色，C++版
+// 一共有n个点，给定m条无向边，一开始每条边无颜色，一共有k种颜色
+// 合法状态的定义为，仅保留染成k种颜色中的任何一种颜色的边，图都是一张二分图
+// 一共有q条操作，每条操作格式如下
+// 操作 e c : 第e条边，现在要涂成c颜色
+//           如果执行此操作之后，整张图还是合法状态，那么执行并打印"YES"
+//           如果执行此操作之后，整张图不再是合法状态，那么不执行并打印"NO"
+// 1 <= n、m、q <= 5 * 10^5
+// 1 <= k <= 50
 // 测试链接 : https://www.luogu.com.cn/problem/CF576E
 // 测试链接 : https://codeforces.com/problemset/problem/576/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 63d7c9aae5fd8bca5f06249a08dc19580fa3f2c1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 22 Apr 2025 19:18:28 +0800
Subject: [PATCH 0704/1712] modify code

---
 src/class166/Code07_PaintingEdges1.java | 3 +--
 src/class166/Code07_PaintingEdges2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index c281d23b6..dca4e555e 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -7,8 +7,7 @@
 // 操作 e c : 第e条边，现在要涂成c颜色
 //           如果执行此操作之后，整张图还是合法状态，那么执行并打印"YES"
 //           如果执行此操作之后，整张图不再是合法状态，那么不执行并打印"NO"
-// 1 <= n、m、q <= 5 * 10^5
-// 1 <= k <= 50
+// 1 <= n、m、q <= 5 * 10^5    1 <= k <= 50
 // 测试链接 : https://www.luogu.com.cn/problem/CF576E
 // 测试链接 : https://codeforces.com/problemset/problem/576/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
index b6fc0dd7f..c0fc1931e 100644
--- a/src/class166/Code07_PaintingEdges2.java
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -7,8 +7,7 @@
 // 操作 e c : 第e条边，现在要涂成c颜色
 //           如果执行此操作之后，整张图还是合法状态，那么执行并打印"YES"
 //           如果执行此操作之后，整张图不再是合法状态，那么不执行并打印"NO"
-// 1 <= n、m、q <= 5 * 10^5
-// 1 <= k <= 50
+// 1 <= n、m、q <= 5 * 10^5    1 <= k <= 50
 // 测试链接 : https://www.luogu.com.cn/problem/CF576E
 // 测试链接 : https://codeforces.com/problemset/problem/576/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 3c653908f964ce6ee201d77fb89ff79af44018c9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 23 Apr 2025 11:40:43 +0800
Subject: [PATCH 0705/1712] modify code

---
 src/class166/Code07_PaintingEdges1.java | 13 ++++++++++---
 src/class166/Code07_PaintingEdges2.java | 13 ++++++++++---
 2 files changed, 20 insertions(+), 6 deletions(-)

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index dca4e555e..05b64b722 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -94,10 +94,17 @@ public static void add(int jobl, int jobr, int jobq, int l, int r, int i) {
 
 	public static void dfs(int l, int r, int i) {
 		int unionCnt = 0;
+		int color, x, y, xn, yn, fx, fy, fxn, fyn;
 		for (int ei = head[i]; ei > 0; ei = next[ei]) {
-			int color = c[qid[ei]];
-			int x = u[e[qid[ei]]], xn = x + n, fx = find(color, x), fxn = find(color, xn);
-			int y = v[e[qid[ei]]], yn = y + n, fy = find(color, y), fyn = find(color, yn);
+			color = c[qid[ei]];
+			x = u[e[qid[ei]]];
+			y = v[e[qid[ei]]];
+			xn = x + n;
+			yn = y + n;
+			fx = find(color, x);
+			fy = find(color, y);
+			fxn = find(color, xn);
+			fyn = find(color, yn);
 			if (fx != fyn) {
 				union(color, fx, fyn);
 				unionCnt++;
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
index c0fc1931e..229c4a0a5 100644
--- a/src/class166/Code07_PaintingEdges2.java
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -93,10 +93,17 @@
 //
 //void dfs(int l, int r, int i) {
 //    int unionCnt = 0;
+//    int color, x, y, xn, yn, fx, fy, fxn, fyn;
 //    for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
-//        int color = c[qid[ei]];
-//        int x = u[e[qid[ei]]], xn = x + n, fx = find(color, x), fxn = find(color, xn);
-//        int y = v[e[qid[ei]]], yn = y + n, fy = find(color, y), fyn = find(color, yn);
+//        color = c[qid[ei]];
+//        x = u[e[qid[ei]]];
+//        y = v[e[qid[ei]]];
+//        xn = x + n;
+//        yn = y + n;
+//        fx = find(color, x);
+//        fy = find(color, y);
+//        fxn = find(color, xn);
+//        fyn = find(color, yn);
 //        if (fx != fyn) {
 //            Union(color, fx, fyn);
 //            unionCnt++;

From c89aa20d3119d68062d9bd880a5a8e36c72ca082 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 23 Apr 2025 17:40:00 +0800
Subject: [PATCH 0706/1712] modify code

---
 src/class166/Code01_SegmentTreeDivideConquer1.java | 9 +++++++++
 src/class166/Code03_MinimumMexTree1.java           | 1 +
 src/class166/Code03_MinimumMexTree2.java           | 1 +
 3 files changed, 11 insertions(+)

diff --git a/src/class166/Code01_SegmentTreeDivideConquer1.java b/src/class166/Code01_SegmentTreeDivideConquer1.java
index dc0ee630c..eec51da17 100644
--- a/src/class166/Code01_SegmentTreeDivideConquer1.java
+++ b/src/class166/Code01_SegmentTreeDivideConquer1.java
@@ -17,28 +17,37 @@
 
 public class Code01_SegmentTreeDivideConquer1 {
 
+	// 点的数量最大值
 	public static int MAXN = 5001;
+	// 操作数量最大值
 	public static int MAXM = 500001;
+	// 任务数量最大值
 	public static int MAXT = 5000001;
+
 	public static int n, m;
 
+	// 操作类型op、端点u、端点v
 	public static int[] op = new int[MAXM];
 	public static int[] u = new int[MAXM];
 	public static int[] v = new int[MAXM];
 
+	// last[x][y] : 点x和点y的边，上次出现的时间点
 	public static int[][] last = new int[MAXN][MAXN];
 
+	// 可撤销并查集
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize = 0;
 
+	// 线段树每个区间拥有哪些任务的列表，链式前向星表示
 	public static int[] head = new int[MAXM << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tox = new int[MAXT];
 	public static int[] toy = new int[MAXT];
 	public static int cnt = 0;
 
+	// ans[i]为第i条操作的答案，只有查询操作才有答案
 	public static boolean[] ans = new boolean[MAXM];
 
 	public static void addEdge(int i, int x, int y) {
diff --git a/src/class166/Code03_MinimumMexTree1.java b/src/class166/Code03_MinimumMexTree1.java
index b64f603fe..8ccfe76f7 100644
--- a/src/class166/Code03_MinimumMexTree1.java
+++ b/src/class166/Code03_MinimumMexTree1.java
@@ -4,6 +4,7 @@
 // 给定n个点，m条边的无向连通图，边有边权
 // 自然数集合S的mex含义为：最小的、没有出现在S中的自然数
 // 现在你要求出一个这个图的生成树，使得其边权集合的mex尽可能小
+// 对本题来说，注意0是自然数
 // 1 <= n <= 10^6
 // 1 <= m <= 2 * 10^6
 // 0 <= 边权 <= 10^5
diff --git a/src/class166/Code03_MinimumMexTree2.java b/src/class166/Code03_MinimumMexTree2.java
index 06a522729..1bc400eed 100644
--- a/src/class166/Code03_MinimumMexTree2.java
+++ b/src/class166/Code03_MinimumMexTree2.java
@@ -4,6 +4,7 @@
 // 给定n个点，m条边的无向连通图，边有边权
 // 自然数集合S的mex含义为：最小的、没有出现在S中的自然数
 // 现在你要求出一个这个图的生成树，使得其边权集合的mex尽可能小
+// 对本题来说，注意0是自然数
 // 1 <= n <= 10^6
 // 1 <= m <= 2 * 10^6
 // 0 <= 边权 <= 10^5

From f6d6c9ba9dbee431216e23a3b1db685f0981be64 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 11:17:25 +0800
Subject: [PATCH 0707/1712] modify code

---
 src/class166/Code04_UniqueOccurrences1.java | 11 ++++++-----
 src/class166/Code04_UniqueOccurrences2.java | 13 +++++++------
 2 files changed, 13 insertions(+), 11 deletions(-)

diff --git a/src/class166/Code04_UniqueOccurrences1.java b/src/class166/Code04_UniqueOccurrences1.java
index d33ac34a7..c61d42d39 100644
--- a/src/class166/Code04_UniqueOccurrences1.java
+++ b/src/class166/Code04_UniqueOccurrences1.java
@@ -17,7 +17,7 @@ public class Code04_UniqueOccurrences1 {
 
 	public static int MAXN = 500001;
 	public static int MAXT = 10000001;
-	public static int n, m;
+	public static int n, v;
 
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
@@ -123,23 +123,24 @@ public static void dfs(int l, int r, int i) {
 	public static void main(String[] args) {
 		FastIO io = new FastIO(System.in, System.out);
 		n = io.nextInt();
+		v = n;
 		for (int i = 1, x, y, c; i < n; i++) {
 			x = io.nextInt();
 			y = io.nextInt();
 			c = io.nextInt();
 			addEdgeC(c, x, y);
 			if (c > 1) {
-				add(1, c - 1, x, y, 1, n, 1);
+				add(1, c - 1, x, y, 1, v, 1);
 			}
-			if (c < n) {
-				add(c + 1, n, x, y, 1, n, 1);
+			if (c < v) {
+				add(c + 1, v, x, y, 1, v, 1);
 			}
 		}
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
 			siz[i] = 1;
 		}
-		dfs(1, n, 1);
+		dfs(1, v, 1);
 		io.writelnLong(ans);
 		io.flush();
 	}
diff --git a/src/class166/Code04_UniqueOccurrences2.java b/src/class166/Code04_UniqueOccurrences2.java
index 604107900..b92d28a42 100644
--- a/src/class166/Code04_UniqueOccurrences2.java
+++ b/src/class166/Code04_UniqueOccurrences2.java
@@ -16,7 +16,7 @@
 //
 //const int MAXN = 500001;
 //const int MAXT = 10000001;
-//int n, m;
+//int n, v;
 //
 //int father[MAXN];
 //int siz[MAXN];
@@ -64,7 +64,7 @@
 //    if (siz[fx] < siz[fy]) {
 //        int tmp = fx;
 //        fx = fy;
-//        fx = tmp;
+//        fy = tmp;
 //    }
 //    father[fy] = fx;
 //    siz[fx] += siz[fy];
@@ -123,21 +123,22 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n;
+//    v = n;
 //    for (int i = 1, x, y, c; i < n; i++) {
 //        cin >> x >> y >> c;
 //        addEdgeC(c, x, y);
 //        if (c > 1) {
-//            add(1, c - 1, x, y, 1, n, 1);
+//            add(1, c - 1, x, y, 1, v, 1);
 //        }
-//        if (c < n) {
-//            add(c + 1, n, x, y, 1, n, 1);
+//        if (c < v) {
+//            add(c + 1, v, x, y, 1, v, 1);
 //        }
 //    }
 //    for (int i = 1; i <= n; i++) {
 //        father[i] = i;
 //        siz[i] = 1;
 //    }
-//    dfs(1, n, 1);
+//    dfs(1, v, 1);
 //    cout << ans << '\n';
 //    return 0;
 //}
\ No newline at end of file

From 85eb17c4a532fbde6dd9601807d6b48842475ab3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 12:07:14 +0800
Subject: [PATCH 0708/1712] modify code

---
 src/class166/Code04_UniqueOccurrences1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class166/Code04_UniqueOccurrences1.java b/src/class166/Code04_UniqueOccurrences1.java
index c61d42d39..bbfc49a35 100644
--- a/src/class166/Code04_UniqueOccurrences1.java
+++ b/src/class166/Code04_UniqueOccurrences1.java
@@ -24,12 +24,14 @@ public class Code04_UniqueOccurrences1 {
 	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize = 0;
 
+	// 每种颜色的边的列表
 	public static int[] headc = new int[MAXN];
 	public static int[] nextc = new int[MAXN];
 	public static int[] xc = new int[MAXN];
 	public static int[] yc = new int[MAXN];
 	public static int cntc = 0;
 
+	// 线段树区间上的任务列表
 	public static int[] heads = new int[MAXN << 2];
 	public static int[] nexts = new int[MAXT];
 	public static int[] xs = new int[MAXT];

From f1876701df91eaa0624db5ca457f955cb40a46a5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 12:54:49 +0800
Subject: [PATCH 0709/1712] modify code

---
 src/class166/Code04_UniqueOccurrences1.java | 28 ++++++++++-----------
 src/class166/Code04_UniqueOccurrences2.java | 24 +++++++++---------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/src/class166/Code04_UniqueOccurrences1.java b/src/class166/Code04_UniqueOccurrences1.java
index bbfc49a35..c54802836 100644
--- a/src/class166/Code04_UniqueOccurrences1.java
+++ b/src/class166/Code04_UniqueOccurrences1.java
@@ -24,19 +24,19 @@ public class Code04_UniqueOccurrences1 {
 	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize = 0;
 
-	// 每种颜色的边的列表
+	// 每种颜色拥有哪些边的列表
 	public static int[] headc = new int[MAXN];
 	public static int[] nextc = new int[MAXN];
 	public static int[] xc = new int[MAXN];
 	public static int[] yc = new int[MAXN];
 	public static int cntc = 0;
 
-	// 线段树区间上的任务列表
-	public static int[] heads = new int[MAXN << 2];
-	public static int[] nexts = new int[MAXT];
-	public static int[] xs = new int[MAXT];
-	public static int[] ys = new int[MAXT];
-	public static int cnts = 0;
+	// 颜色轴线段树的区间任务列表
+	public static int[] headt = new int[MAXN << 2];
+	public static int[] nextt = new int[MAXT];
+	public static int[] xt = new int[MAXT];
+	public static int[] yt = new int[MAXT];
+	public static int cntt = 0;
 
 	public static long ans = 0;
 
@@ -48,10 +48,10 @@ public static void addEdgeC(int i, int x, int y) {
 	}
 
 	public static void addEdgeS(int i, int x, int y) {
-		nexts[++cnts] = heads[i];
-		xs[cnts] = x;
-		ys[cnts] = y;
-		heads[i] = cnts;
+		nextt[++cntt] = headt[i];
+		xt[cntt] = x;
+		yt[cntt] = y;
+		headt[i] = cntt;
 	}
 
 	public static int find(int i) {
@@ -98,9 +98,9 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 
 	public static void dfs(int l, int r, int i) {
 		int unionCnt = 0;
-		for (int ei = heads[i], fx, fy; ei > 0; ei = nexts[ei]) {
-			fx = find(xs[ei]);
-			fy = find(ys[ei]);
+		for (int ei = headt[i], fx, fy; ei > 0; ei = nextt[ei]) {
+			fx = find(xt[ei]);
+			fy = find(yt[ei]);
 			if (fx != fy) {
 				union(fx, fy);
 				unionCnt++;
diff --git a/src/class166/Code04_UniqueOccurrences2.java b/src/class166/Code04_UniqueOccurrences2.java
index b92d28a42..8f2d13544 100644
--- a/src/class166/Code04_UniqueOccurrences2.java
+++ b/src/class166/Code04_UniqueOccurrences2.java
@@ -29,11 +29,11 @@
 //int yc[MAXN];
 //int cntc = 0;
 //
-//int heads[MAXN << 2];
-//int nxts[MAXT];
-//int xs[MAXT];
-//int ys[MAXT];
-//int cnts = 0;
+//int headt[MAXN << 2];
+//int nxtt[MAXT];
+//int xt[MAXT];
+//int yt[MAXT];
+//int cntt = 0;
 //
 //long long ans = 0;
 //
@@ -45,10 +45,10 @@
 //}
 //
 //void addEdgeS(int i, int x, int y) {
-//    nxts[++cnts] = heads[i];
-//    xs[cnts] = x;
-//    ys[cnts] = y;
-//    heads[i] = cnts;
+//    nxtt[++cntt] = headt[i];
+//    xt[cntt] = x;
+//    yt[cntt] = y;
+//    headt[i] = cntt;
 //}
 //
 //int find(int i) {
@@ -95,9 +95,9 @@
 //
 //void dfs(int l, int r, int i) {
 //    int unionCnt = 0;
-//    for (int ei = heads[i], fx, fy; ei > 0; ei = nxts[ei]) {
-//        fx = find(xs[ei]);
-//        fy = find(ys[ei]);
+//    for (int ei = headt[i], fx, fy; ei > 0; ei = nxtt[ei]) {
+//        fx = find(xt[ei]);
+//        fy = find(yt[ei]);
 //        if (fx != fy) {
 //            Union(fx, fy);
 //            unionCnt++;

From fd848bf42aee9f9ae01db5fb0c30dddeb8842983 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 13:03:42 +0800
Subject: [PATCH 0710/1712] modify code

---
 src/class166/Code04_UniqueOccurrences1.java | 10 +++-------
 src/class166/Code04_UniqueOccurrences2.java | 10 +++-------
 2 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/src/class166/Code04_UniqueOccurrences1.java b/src/class166/Code04_UniqueOccurrences1.java
index c54802836..cb467154a 100644
--- a/src/class166/Code04_UniqueOccurrences1.java
+++ b/src/class166/Code04_UniqueOccurrences1.java
@@ -98,13 +98,9 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 
 	public static void dfs(int l, int r, int i) {
 		int unionCnt = 0;
-		for (int ei = headt[i], fx, fy; ei > 0; ei = nextt[ei]) {
-			fx = find(xt[ei]);
-			fy = find(yt[ei]);
-			if (fx != fy) {
-				union(fx, fy);
-				unionCnt++;
-			}
+		for (int ei = headt[i]; ei > 0; ei = nextt[ei]) {
+			union(xt[ei], yt[ei]);
+			unionCnt++;
 		}
 		if (l == r) {
 			for (int ei = headc[l], fx, fy; ei > 0; ei = nextc[ei]) {
diff --git a/src/class166/Code04_UniqueOccurrences2.java b/src/class166/Code04_UniqueOccurrences2.java
index 8f2d13544..01b2df10a 100644
--- a/src/class166/Code04_UniqueOccurrences2.java
+++ b/src/class166/Code04_UniqueOccurrences2.java
@@ -95,13 +95,9 @@
 //
 //void dfs(int l, int r, int i) {
 //    int unionCnt = 0;
-//    for (int ei = headt[i], fx, fy; ei > 0; ei = nxtt[ei]) {
-//        fx = find(xt[ei]);
-//        fy = find(yt[ei]);
-//        if (fx != fy) {
-//            Union(fx, fy);
-//            unionCnt++;
-//        }
+//    for (int ei = headt[i]; ei > 0; ei = nxtt[ei]) {
+//        Union(xt[ei], yt[ei]);
+//        unionCnt++;
 //    }
 //    if (l == r) {
 //        for (int ei = headc[l], fx, fy; ei > 0; ei = nxtc[ei]) {

From 99ed67bae50ba4df7c17934441abad590993d572 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 13:25:26 +0800
Subject: [PATCH 0711/1712] modify code

---
 src/class166/Code05_GreatIntegration1.java | 3 ++-
 src/class166/Code05_GreatIntegration2.java | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class166/Code05_GreatIntegration1.java b/src/class166/Code05_GreatIntegration1.java
index c9cf44d51..9fe4320c9 100644
--- a/src/class166/Code05_GreatIntegration1.java
+++ b/src/class166/Code05_GreatIntegration1.java
@@ -4,7 +4,7 @@
 // 一共有n个点，一共有q条操作，每条操作是如下两种类型中的一种
 // 操作 A x y : 点x和点y之间连一条边，保证之前x和y是不联通的
 // 操作 Q x y : 打印点x和点y之间这条边的负载，保证x和y之间有一条边
-// 边负载定义为，假设去掉这条边之后，端点1联通区大小 * 端点2联通区大小
+// 边负载定义为，这条边两侧端点各自连通区大小的乘积
 // 1 <= n、q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4219
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -25,6 +25,7 @@ public class Code05_GreatIntegration1 {
 	public static int[] u = new int[MAXN];
 	public static int[] v = new int[MAXN];
 
+	// 端点x、端点y、操作序号t
 	public static int[][] event = new int[MAXN][3];
 
 	public static int[] father = new int[MAXN];
diff --git a/src/class166/Code05_GreatIntegration2.java b/src/class166/Code05_GreatIntegration2.java
index 283ae2223..d4082f022 100644
--- a/src/class166/Code05_GreatIntegration2.java
+++ b/src/class166/Code05_GreatIntegration2.java
@@ -4,7 +4,7 @@
 // 一共有n个点，一共有q条操作，每条操作是如下两种类型中的一种
 // 操作 A x y : 点x和点y之间连一条边，保证之前x和y是不联通的
 // 操作 Q x y : 打印点x和点y之间这条边的负载，保证x和y之间有一条边
-// 边负载定义为，假设去掉这条边之后，端点1联通区大小 * 端点2联通区大小
+// 边负载定义为，这条边两侧端点各自连通区大小的乘积
 // 1 <= n、q <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4219
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From b65c0d73f64491740f82b19fd1388d24d4eab1f3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 14:59:41 +0800
Subject: [PATCH 0712/1712] modify code

---
 src/class166/Code05_GreatIntegration1.java | 10 +++-------
 src/class166/Code05_GreatIntegration2.java | 10 +++-------
 2 files changed, 6 insertions(+), 14 deletions(-)

diff --git a/src/class166/Code05_GreatIntegration1.java b/src/class166/Code05_GreatIntegration1.java
index 9fe4320c9..63d561598 100644
--- a/src/class166/Code05_GreatIntegration1.java
+++ b/src/class166/Code05_GreatIntegration1.java
@@ -92,13 +92,9 @@ public static void add(int jobl, int jobr, int jobx, int joby, int l, int r, int
 
 	public static void dfs(int l, int r, int i) {
 		int unionCnt = 0;
-		for (int ei = head[i], fx, fy; ei > 0; ei = next[ei]) {
-			fx = find(tox[ei]);
-			fy = find(toy[ei]);
-			if (fx != fy) {
-				union(fx, fy);
-				unionCnt++;
-			}
+		for (int ei = head[i]; ei > 0; ei = next[ei]) {
+			union(tox[ei], toy[ei]);
+			unionCnt++;
 		}
 		if (l == r) {
 			if (op[l] == 2) {
diff --git a/src/class166/Code05_GreatIntegration2.java b/src/class166/Code05_GreatIntegration2.java
index d4082f022..20c527718 100644
--- a/src/class166/Code05_GreatIntegration2.java
+++ b/src/class166/Code05_GreatIntegration2.java
@@ -102,13 +102,9 @@
 //
 //void dfs(int l, int r, int i) {
 //    int unionCnt = 0;
-//    for (int ei = head[i], fx, fy; ei > 0; ei = nxt[ei]) {
-//        fx = find(tox[ei]);
-//        fy = find(toy[ei]);
-//        if (fx != fy) {
-//            Union(fx, fy);
-//            unionCnt++;
-//        }
+//    for (int ei = head[i]; ei > 0; ei = nxt[ei]) {
+//        Union(tox[ei], toy[ei]);
+//        unionCnt++;
 //    }
 //    if (l == r) {
 //        if (op[l] == 2) {

From 0a1ef9d47fa8ae8b56356deb63992c3114de0688 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 15:19:49 +0800
Subject: [PATCH 0713/1712] modify code

---
 src/class166/Code06_ConnectedGraph1.java | 2 +-
 src/class166/Code06_ConnectedGraph2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class166/Code06_ConnectedGraph1.java b/src/class166/Code06_ConnectedGraph1.java
index fe0282500..b420aa46d 100644
--- a/src/class166/Code06_ConnectedGraph1.java
+++ b/src/class166/Code06_ConnectedGraph1.java
@@ -1,7 +1,7 @@
 package class166;
 
 // 连通图，java版
-// 一共有n个点，给定m条边，所有点一定组成一个连通图
+// 一共有n个点，给定m条边，所有点一开始就连通在一起了
 // 一共有k条操作，每条操作格式如下
 // 操作 c ... : 操作涉及c条边，这些边的编号 ... 一共c个
 //              假设删掉这些边，打印整张图是否联通
diff --git a/src/class166/Code06_ConnectedGraph2.java b/src/class166/Code06_ConnectedGraph2.java
index 2c5273cb9..baddb24a8 100644
--- a/src/class166/Code06_ConnectedGraph2.java
+++ b/src/class166/Code06_ConnectedGraph2.java
@@ -1,7 +1,7 @@
 package class166;
 
 // 连通图，C++版
-// 一共有n个点，给定m条边，所有点一定组成一个连通图
+// 一共有n个点，给定m条边，所有点一开始就连通在一起了
 // 一共有k条操作，每条操作格式如下
 // 操作 c ... : 操作涉及c条边，这些边的编号 ... 一共c个
 //              假设删掉这些边，打印整张图是否联通

From 378ed54e39106279afe8d868073835010eeeff16 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 15:41:28 +0800
Subject: [PATCH 0714/1712] modify code

---
 src/class166/Code07_PaintingEdges1.java | 20 +++++++++-----------
 src/class166/Code07_PaintingEdges2.java | 20 +++++++++-----------
 2 files changed, 18 insertions(+), 22 deletions(-)

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index 05b64b722..3fc5e05da 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -27,8 +27,7 @@ public class Code07_PaintingEdges1 {
 	public static int[] v = new int[MAXN];
 	public static int[] e = new int[MAXN];
 	public static int[] c = new int[MAXN];
-
-	public static int[] help = new int[MAXN];
+	public static int[] post = new int[MAXN];
 
 	public static int[][] father = new int[MAXK][MAXN << 1];
 	public static int[][] siz = new int[MAXK][MAXN << 1];
@@ -40,6 +39,8 @@ public class Code07_PaintingEdges1 {
 	public static int[] qid = new int[MAXT];
 	public static int cnt = 0;
 
+	public static int[] lastColor = new int[MAXN];
+
 	public static boolean[] ans = new boolean[MAXN];
 
 	public static void addEdge(int i, int qi) {
@@ -117,10 +118,10 @@ public static void dfs(int l, int r, int i) {
 		if (l == r) {
 			if (find(c[l], u[e[l]]) == find(c[l], v[e[l]])) {
 				ans[l] = false;
-				c[l] = help[e[l]];
+				c[l] = lastColor[e[l]];
 			} else {
 				ans[l] = true;
-				help[e[l]] = c[l];
+				lastColor[e[l]] = c[l];
 			}
 		} else {
 			int mid = (l + r) >> 1;
@@ -142,16 +143,13 @@ public static void prepare() {
 			}
 		}
 		for (int i = 1; i <= m; i++) {
-			help[i] = q + 1;
+			post[i] = q + 1;
 		}
 		for (int i = q; i >= 1; i--) {
-			if (i + 1 <= help[e[i]] - 1) {
-				add(i + 1, help[e[i]] - 1, i, 1, q, 1);
+			if (i + 1 <= post[e[i]] - 1) {
+				add(i + 1, post[e[i]] - 1, i, 1, q, 1);
 			}
-			help[e[i]] = i;
-		}
-		for (int i = 1; i <= m; i++) {
-			help[i] = 0;
+			post[e[i]] = i;
 		}
 	}
 
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
index 229c4a0a5..f14e9342f 100644
--- a/src/class166/Code07_PaintingEdges2.java
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -26,8 +26,7 @@
 //int v[MAXN];
 //int e[MAXN];
 //int c[MAXN];
-//
-//int help[MAXN];
+//int post[MAXN];
 //
 //int father[MAXK][MAXN << 1];
 //int siz[MAXK][MAXN << 1];
@@ -39,6 +38,8 @@
 //int qid[MAXT];
 //int cnt = 0;
 //
+//int lastColor[MAXN];
+//
 //bool ans[MAXN];
 //
 //void addEdge(int i, int qi) {
@@ -116,10 +117,10 @@
 //    if (l == r) {
 //        if (find(c[l], u[e[l]]) == find(c[l], v[e[l]])) {
 //            ans[l] = false;
-//            c[l] = help[e[l]];
+//            c[l] = lastColor[e[l]];
 //        } else {
 //            ans[l] = true;
-//            help[e[l]] = c[l];
+//            lastColor[e[l]] = c[l];
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
@@ -141,16 +142,13 @@
 //        }
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        help[i] = q + 1;
+//        post[i] = q + 1;
 //    }
 //    for (int i = q; i >= 1; i--) {
-//        if (i + 1 <= help[e[i]] - 1) {
-//            add(i + 1, help[e[i]] - 1, i, 1, q, 1);
+//        if (i + 1 <= post[e[i]] - 1) {
+//            add(i + 1, post[e[i]] - 1, i, 1, q, 1);
 //        }
-//        help[e[i]] = i;
-//    }
-//    for (int i = 1; i <= m; i++) {
-//        help[i] = 0;
+//        post[e[i]] = i;
 //    }
 //}
 //

From fab9d8082b7cb8e669bf9d28fb4eb623496a242e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 17:17:14 +0800
Subject: [PATCH 0715/1712] modify code

---
 src/class166/Code07_PaintingEdges1.java | 9 ++++++---
 src/class166/Code07_PaintingEdges2.java | 7 ++++---
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index 3fc5e05da..41a22e0ee 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -25,6 +25,7 @@ public class Code07_PaintingEdges1 {
 
 	public static int[] u = new int[MAXN];
 	public static int[] v = new int[MAXN];
+
 	public static int[] e = new int[MAXN];
 	public static int[] c = new int[MAXN];
 	public static int[] post = new int[MAXN];
@@ -34,11 +35,13 @@ public class Code07_PaintingEdges1 {
 	public static int[][] rollback = new int[MAXN << 1][3];
 	public static int opsize = 0;
 
+	// 时间轴线段树的区间上的任务列表
 	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] qid = new int[MAXT];
 	public static int cnt = 0;
 
+	// lastColor[i] : 第i号边上次成功涂上的颜色
 	public static int[] lastColor = new int[MAXN];
 
 	public static boolean[] ans = new boolean[MAXN];
@@ -143,11 +146,11 @@ public static void prepare() {
 			}
 		}
 		for (int i = 1; i <= m; i++) {
-			post[i] = q + 1;
+			post[i] = q;
 		}
 		for (int i = q; i >= 1; i--) {
-			if (i + 1 <= post[e[i]] - 1) {
-				add(i + 1, post[e[i]] - 1, i, 1, q, 1);
+			if (i + 1 <= post[e[i]]) {
+				add(i + 1, post[e[i]], i, 1, q, 1);
 			}
 			post[e[i]] = i;
 		}
diff --git a/src/class166/Code07_PaintingEdges2.java b/src/class166/Code07_PaintingEdges2.java
index f14e9342f..eba8fb20e 100644
--- a/src/class166/Code07_PaintingEdges2.java
+++ b/src/class166/Code07_PaintingEdges2.java
@@ -24,6 +24,7 @@
 //
 //int u[MAXN];
 //int v[MAXN];
+//
 //int e[MAXN];
 //int c[MAXN];
 //int post[MAXN];
@@ -142,11 +143,11 @@
 //        }
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        post[i] = q + 1;
+//        post[i] = q;
 //    }
 //    for (int i = q; i >= 1; i--) {
-//        if (i + 1 <= post[e[i]] - 1) {
-//            add(i + 1, post[e[i]] - 1, i, 1, q, 1);
+//        if (i + 1 <= post[e[i]]) {
+//            add(i + 1, post[e[i]], i, 1, q, 1);
 //        }
 //        post[e[i]] = i;
 //    }

From 363cb7799130bf8ae8c26310e1146add05190dcf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Apr 2025 18:59:06 +0800
Subject: [PATCH 0716/1712] modify code

---
 ...1\345\210\206\346\262\273-\344\270\212.pptx" | Bin 0 -> 54093 bytes
 src/class166/Code07_PaintingEdges1.java         |   1 +
 2 files changed, 1 insertion(+)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243166\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\345\210\206\346\262\273-\344\270\212.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243166\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\345\210\206\346\262\273-\344\270\212.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243166\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\345\210\206\346\262\273-\344\270\212.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..2210c9654a931078bda58ae3bc38200c596fea5b
GIT binary patch
literal 54093
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%0D?^BAZ5f4
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
EKb7A9B>(^b

literal 0
HcmV?d00001

diff --git a/src/class166/Code07_PaintingEdges1.java b/src/class166/Code07_PaintingEdges1.java
index 41a22e0ee..5f4d48dd8 100644
--- a/src/class166/Code07_PaintingEdges1.java
+++ b/src/class166/Code07_PaintingEdges1.java
@@ -36,6 +36,7 @@ public class Code07_PaintingEdges1 {
 	public static int opsize = 0;
 
 	// 时间轴线段树的区间上的任务列表
+	// 尤其注意qid的设置，课上进行了重点解释
 	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] qid = new int[MAXT];

From 84d943017ff4c109c4c62b1f1a9b72130903c120 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 27 Apr 2025 20:52:59 +0800
Subject: [PATCH 0717/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java | 305 ++++++++++++++++++
 src/class167/Code01_ShortestPathQueries2.java | 222 +++++++++++++
 2 files changed, 527 insertions(+)
 create mode 100644 src/class167/Code01_ShortestPathQueries1.java
 create mode 100644 src/class167/Code01_ShortestPathQueries2.java

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
new file mode 100644
index 000000000..c40f0d0ab
--- /dev/null
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -0,0 +1,305 @@
+package class167;
+
+// 异或最短路，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF938G
+// 测试链接 : https://codeforces.com/problemset/problem/938/G
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_ShortestPathQueries1 {
+
+	public static int MAXN = 200001;
+	public static int MAXT = 5000001;
+	public static int LIMIT = 20;
+	public static int BIT = 29;
+	public static int n, m, q;
+
+	// 端点x、端点y、时间点t、边权w
+	public static int[][] event = new int[MAXN << 1][4];
+	public static int eventCnt;
+
+	// 操作记录下来
+	public static int[] op = new int[MAXN];
+	public static int[] x = new int[MAXN];
+	public static int[] y = new int[MAXN];
+	public static int[] d = new int[MAXN];
+
+	// 异或空间线性基
+	public static int[] basis = new int[BIT + 1];
+	public static int[][] backup = new int[LIMIT][BIT + 1];
+
+	// 时间轴线段树上的区间任务列表
+	public static int[] head = new int[MAXN << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] tox = new int[MAXT];
+	public static int[] toy = new int[MAXT];
+	public static int[] tow = new int[MAXT];
+	public static int cnt = 0;
+
+	// 可撤销并查集 + 带权并查集
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] eor = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize = 0;
+
+	// 查询操作的答案
+	public static int[] ans = new int[MAXN];
+
+	// 当前数字插入线性基
+	public static void insert(int num) {
+		for (int i = BIT; i >= 0; i--) {
+			if (num >> i == 1) {
+				if (basis[i] == 0) {
+					basis[i] = num;
+					return;
+				}
+				num ^= basis[i];
+			}
+		}
+	}
+
+	// 根据线性基，返回num能结合出的最小异或和
+	public static int minEor(int num) {
+		for (int i = BIT; i >= 0; i--) {
+			num = Math.min(num, num ^ basis[i]);
+		}
+		return num;
+	}
+
+	// a把b的内容拷贝过来，用于线性基的撤销
+	public static void clone(int[] a, int[] b) {
+		for (int i = 0; i <= BIT; i++) {
+			a[i] = b[i];
+		}
+	}
+
+	// 可撤销并查集找集合代表点
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	// 返回i到集合代表点的异或和
+	public static int getEor(int i) {
+		int ans = 0;
+		while (i != father[i]) {
+			ans ^= eor[i];
+			i = father[i];
+		}
+		return ans;
+	}
+
+	// 可撤销并查集的合并，增加a和b之间，权值为w的边
+	// 集合合并的过程中，还要更新eor数组
+	// 这种更新eor的方式，参考讲解156，带权并查集
+	public static boolean union(int a, int b, int w) {
+		int eora = getEor(a);
+		int eorb = getEor(b);
+		int fa = find(a);
+		int fb = find(b);
+		w = eora ^ eorb ^ w;
+		if (fa == fb) {
+			insert(w);
+			return false;
+		}
+		if (siz[fa] < siz[fb]) {
+			int tmp = fa;
+			fa = fb;
+			fb = tmp;
+		}
+		father[fb] = fa;
+		siz[fa] += siz[fb];
+		eor[fb] = w;
+		rollback[++opsize][0] = fa;
+		rollback[opsize][1] = fb;
+		return true;
+	}
+
+	// 并查集的撤销操作
+	public static void undo() {
+		int fa = rollback[opsize][0];
+		int fb = rollback[opsize--][1];
+		father[fb] = fb;
+		eor[fb] = 0;
+		siz[fa] -= siz[fb];
+	}
+
+	// 给某个线段树区间增加任务，点x到点y之间，增加权值为w的边
+	public static void addEdge(int i, int x, int y, int w) {
+		next[++cnt] = head[i];
+		tox[cnt] = x;
+		toy[cnt] = y;
+		tow[cnt] = w;
+		head[i] = cnt;
+	}
+
+	public static void add(int jobl, int jobr, int jobx, int joby, int jobw, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobx, joby, jobw);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobx, joby, jobw, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobx, joby, jobw, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i, int deep) {
+		clone(backup[deep], basis);
+		int unionCnt = 0;
+		for (int e = head[i]; e > 0; e = next[e]) {
+			if (union(tox[e], toy[e], tow[e])) {
+				unionCnt++;
+			}
+		}
+		if (l == r) {
+			if (op[l] == 3) {
+				ans[l] = minEor(getEor(x[l]) ^ getEor(y[l]));
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1, deep + 1);
+			dfs(mid + 1, r, i << 1 | 1, deep + 1);
+		}
+		clone(basis, backup[deep]);
+		for (int k = 1; k <= unionCnt; k++) {
+			undo();
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		Arrays.sort(event, 1, eventCnt + 1,
+				(a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] != b[1] ? a[1] - b[1] : a[2] - b[2]);
+		for (int l = 1, r = 1; l <= eventCnt; l = ++r) {
+			int x = event[l][0];
+			int y = event[l][1];
+			while (r + 1 <= eventCnt && event[r + 1][0] == x && event[r + 1][1] == y) {
+				r++;
+			}
+			for (int i = l; i <= r; i += 2) {
+				int start = event[i][2];
+				int end = i + 1 <= r ? (event[i + 1][2] - 1) : q;
+				int d = event[i][3];
+				add(start, end, x, y, d, 0, q, 1);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= m; i++) {
+			event[i][0] = in.nextInt();
+			event[i][1] = in.nextInt();
+			event[i][2] = 0;
+			event[i][3] = in.nextInt();
+		}
+		eventCnt = m;
+		q = in.nextInt();
+		for (int i = 1; i <= q; i++) {
+			op[i] = in.nextInt();
+			x[i] = in.nextInt();
+			y[i] = in.nextInt();
+			if (op[i] == 1) {
+				d[i] = in.nextInt();
+			}
+			if (op[i] != 3) {
+				event[++eventCnt][0] = x[i];
+				event[eventCnt][1] = y[i];
+				event[eventCnt][2] = i;
+				event[eventCnt][3] = d[i];
+			}
+		}
+		prepare();
+		dfs(0, q, 1, 0);
+		for (int i = 1; i <= q; i++) {
+			if (op[i] == 3) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
new file mode 100644
index 000000000..21410f484
--- /dev/null
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -0,0 +1,222 @@
+package class167;
+
+// 异或最短路，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF938G
+// 测试链接 : https://codeforces.com/problemset/problem/938/G
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Event {
+//    int x, y, t, w;
+//};
+//
+//bool EventCmp(Event a, Event b) {
+//    if (a.x != b.x) {
+//        return a.x < b.x;
+//    } else if (a.y != b.y) {
+//        return a.y < b.y;
+//    } else {
+//        return a.t < b.t;
+//    }
+//}
+//
+//const int MAXN = 200001;
+//const int MAXT = 5000001;
+//const int LIMIT = 20;
+//const int BIT = 29;
+//int n, m, q;
+//
+//Event event[MAXN << 1];
+//int eventCnt = 0;
+//
+//int op[MAXN];
+//int x[MAXN];
+//int y[MAXN];
+//int d[MAXN];
+//
+//int basis[BIT + 1];
+//int backup[LIMIT][BIT + 1];
+//
+//int head[MAXN << 2];
+//int nxt[MAXT];
+//int tox[MAXT];
+//int toy[MAXT];
+//int tow[MAXT];
+//int cnt = 0;
+//
+//int father[MAXN];
+//int siz[MAXN];
+//int eor[MAXN];
+//int rollbackArr[MAXN][2];
+//int opsize = 0;
+//
+//int ans[MAXN];
+//
+//void insert(int num) {
+//    for (int i = BIT; i >= 0; --i) {
+//        if (num >> i == 1) {
+//            if (basis[i] == 0) {
+//                basis[i] = num;
+//                return;
+//            }
+//            num ^= basis[i];
+//        }
+//    }
+//}
+//
+//int minEor(int num) {
+//    for (int i = BIT; i >= 0; --i) {
+//        num = min(num, num ^ basis[i]);
+//    }
+//    return num;
+//}
+//
+//int find(int i) {
+//    while (i != father[i]) {
+//        i = father[i];
+//    }
+//    return i;
+//}
+//
+//int getEor(int i) {
+//    int res = 0;
+//    while (i != father[i]) {
+//        res ^= eor[i];
+//        i = father[i];
+//    }
+//    return res;
+//}
+//
+//bool Union(int a, int b, int w) {
+//    int eora = getEor(a);
+//    int eorb = getEor(b);
+//    int fa = find(a);
+//    int fb = find(b);
+//    w ^= eora ^ eorb;
+//    if (fa == fb) {
+//    	insert(w);
+//        return false;
+//    }
+//    if (siz[fa] < siz[fb]) {
+//        int tmp = fa;
+//        fa = fb;
+//        fb = tmp;
+//    }
+//    father[fb] = fa;
+//    siz[fa] += siz[fb];
+//    eor[fb] = w;
+//    rollbackArr[++opsize][0] = fa;
+//    rollbackArr[opsize][1] = fb;
+//    return true;
+//}
+//
+//void undo() {
+//    int fa = rollbackArr[opsize][0];
+//    int fb = rollbackArr[opsize--][1];
+//    father[fb] = fb;
+//    eor[fb] = 0;
+//    siz[fa] -= siz[fb];
+//}
+//
+//void addEdge(int idx, int u, int v, int w) {
+//    nxt[++cnt] = head[idx];
+//    tox[cnt] = u;
+//    toy[cnt] = v;
+//    tow[cnt] = w;
+//    head[idx] = cnt;
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, int jobw, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobx, joby, jobw);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, jobw, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, jobw, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i, int dep) {
+//    memcpy(backup[dep], basis, sizeof(backup[dep]));
+//    int unionCnt = 0;
+//    for (int e = head[i]; e; e = nxt[e]) {
+//        if (Union(tox[e], toy[e], tow[e])) {
+//            ++unionCnt;
+//        }
+//    }
+//    if (l == r) {
+//        if (op[l] == 3) {
+//        	ans[l] = minEor(getEor(x[l]) ^ getEor(y[l]));
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1, dep + 1);
+//        dfs(mid + 1, r, i << 1 | 1, dep + 1);
+//    }
+//    memcpy(basis, backup[dep], sizeof(basis));
+//    for (int k = 1; k <= unionCnt; k++) {
+//        undo();
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    sort(event + 1, event + eventCnt + 1, EventCmp);
+//    for (int l = 1, r = 1; l <= eventCnt; l = ++r) {
+//        int x = event[l].x;
+//        int y = event[l].y;
+//        while (r + 1 <= eventCnt && event[r + 1].x == x && event[r + 1].y == y) {
+//            ++r;
+//        }
+//        for (int i = l; i <= r; i += 2) {
+//            int start = event[i].t;
+//            int end = (i + 1 <= r) ? (event[i + 1].t - 1) : q;
+//            int w = event[i].w;
+//            add(start, end, x, y, w, 0, q, 1);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> event[i].x >> event[i].y >> event[i].w;
+//        event[i].t = 0;
+//    }
+//    eventCnt = m;
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> op[i] >> x[i] >> y[i];
+//        if (op[i] == 1) {
+//            cin >> d[i];
+//        }
+//        if (op[i] != 3) {
+//            ++eventCnt;
+//            event[eventCnt].x = x[i];
+//            event[eventCnt].y = y[i];
+//            event[eventCnt].t = i;
+//            event[eventCnt].w = d[i];
+//        }
+//    }
+//    prepare();
+//    dfs(0, q, 1, 0);
+//    for (int i = 1; i <= q; i++) {
+//        if (op[i] == 3) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From ef7181fbd97e743288a316380f3cb5487c3e8e4b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 27 Apr 2025 21:01:07 +0800
Subject: [PATCH 0718/1712] modify code

---
 src/class167/Code01_ShortestPathQueries2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index 21410f484..26db33e0b 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -98,7 +98,7 @@
 //    int fb = find(b);
 //    w ^= eora ^ eorb;
 //    if (fa == fb) {
-//    	insert(w);
+//        insert(w);
 //        return false;
 //    }
 //    if (siz[fa] < siz[fb]) {

From 21c52333f33f52336ab8aa23655dad65b1f04ffd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 27 Apr 2025 21:04:51 +0800
Subject: [PATCH 0719/1712] modify code

---
 src/class167/Code01_ShortestPathQueries2.java | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index 26db33e0b..e90be7bff 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -149,7 +149,7 @@
 //    int unionCnt = 0;
 //    for (int e = head[i]; e; e = nxt[e]) {
 //        if (Union(tox[e], toy[e], tow[e])) {
-//            ++unionCnt;
+//            unionCnt++;
 //        }
 //    }
 //    if (l == r) {
@@ -177,7 +177,7 @@
 //        int x = event[l].x;
 //        int y = event[l].y;
 //        while (r + 1 <= eventCnt && event[r + 1].x == x && event[r + 1].y == y) {
-//            ++r;
+//            r++;
 //        }
 //        for (int i = l; i <= r; i += 2) {
 //            int start = event[i].t;
@@ -204,8 +204,7 @@
 //            cin >> d[i];
 //        }
 //        if (op[i] != 3) {
-//            ++eventCnt;
-//            event[eventCnt].x = x[i];
+//            event[++eventCnt].x = x[i];
 //            event[eventCnt].y = y[i];
 //            event[eventCnt].t = i;
 //            event[eventCnt].w = d[i];

From fce75339769b4cb12d220909633281ed40ab0120 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 27 Apr 2025 21:08:32 +0800
Subject: [PATCH 0720/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java | 11 ++++++-----
 src/class167/Code01_ShortestPathQueries2.java | 15 ++++++++-------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
index c40f0d0ab..9b66dce70 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -185,16 +185,17 @@ public static void prepare() {
 		}
 		Arrays.sort(event, 1, eventCnt + 1,
 				(a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] != b[1] ? a[1] - b[1] : a[2] - b[2]);
+		int x, y, start, end, d;
 		for (int l = 1, r = 1; l <= eventCnt; l = ++r) {
-			int x = event[l][0];
-			int y = event[l][1];
+			x = event[l][0];
+			y = event[l][1];
 			while (r + 1 <= eventCnt && event[r + 1][0] == x && event[r + 1][1] == y) {
 				r++;
 			}
 			for (int i = l; i <= r; i += 2) {
-				int start = event[i][2];
-				int end = i + 1 <= r ? (event[i + 1][2] - 1) : q;
-				int d = event[i][3];
+				start = event[i][2];
+				end = i + 1 <= r ? (event[i + 1][2] - 1) : q;
+				d = event[i][3];
 				add(start, end, x, y, d, 0, q, 1);
 			}
 		}
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index e90be7bff..59ec766d6 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -96,7 +96,7 @@
 //    int eorb = getEor(b);
 //    int fa = find(a);
 //    int fb = find(b);
-//    w ^= eora ^ eorb;
+//    w = eora ^ eorb ^ w;
 //    if (fa == fb) {
 //        insert(w);
 //        return false;
@@ -173,17 +173,18 @@
 //        siz[i] = 1;
 //    }
 //    sort(event + 1, event + eventCnt + 1, EventCmp);
+//    int x, y, start, end, d;
 //    for (int l = 1, r = 1; l <= eventCnt; l = ++r) {
-//        int x = event[l].x;
-//        int y = event[l].y;
+//        x = event[l].x;
+//        y = event[l].y;
 //        while (r + 1 <= eventCnt && event[r + 1].x == x && event[r + 1].y == y) {
 //            r++;
 //        }
 //        for (int i = l; i <= r; i += 2) {
-//            int start = event[i].t;
-//            int end = (i + 1 <= r) ? (event[i + 1].t - 1) : q;
-//            int w = event[i].w;
-//            add(start, end, x, y, w, 0, q, 1);
+//            start = event[i].t;
+//            end = (i + 1 <= r) ? (event[i + 1].t - 1) : q;
+//            d = event[i].w;
+//            add(start, end, x, y, d, 0, q, 1);
 //        }
 //    }
 //}

From 921a05b21aa3adc6846fce333d0299120c8d5064 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 27 Apr 2025 21:11:35 +0800
Subject: [PATCH 0721/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java | 14 +++++++-------
 src/class167/Code01_ShortestPathQueries2.java |  4 ++--
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
index 9b66dce70..a4f6cc5af 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -15,7 +15,7 @@ public class Code01_ShortestPathQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXT = 5000001;
-	public static int LIMIT = 20;
+	public static int DEEP = 20;
 	public static int BIT = 29;
 	public static int n, m, q;
 
@@ -31,7 +31,7 @@ public class Code01_ShortestPathQueries1 {
 
 	// 异或空间线性基
 	public static int[] basis = new int[BIT + 1];
-	public static int[][] backup = new int[LIMIT][BIT + 1];
+	public static int[][] backup = new int[DEEP][BIT + 1];
 
 	// 时间轴线段树上的区间任务列表
 	public static int[] head = new int[MAXN << 2];
@@ -155,8 +155,8 @@ public static void add(int jobl, int jobr, int jobx, int joby, int jobw, int l,
 		}
 	}
 
-	public static void dfs(int l, int r, int i, int deep) {
-		clone(backup[deep], basis);
+	public static void dfs(int l, int r, int i, int dep) {
+		clone(backup[dep], basis);
 		int unionCnt = 0;
 		for (int e = head[i]; e > 0; e = next[e]) {
 			if (union(tox[e], toy[e], tow[e])) {
@@ -169,10 +169,10 @@ public static void dfs(int l, int r, int i, int deep) {
 			}
 		} else {
 			int mid = (l + r) >> 1;
-			dfs(l, mid, i << 1, deep + 1);
-			dfs(mid + 1, r, i << 1 | 1, deep + 1);
+			dfs(l, mid, i << 1, dep + 1);
+			dfs(mid + 1, r, i << 1 | 1, dep + 1);
 		}
-		clone(basis, backup[deep]);
+		clone(basis, backup[dep]);
 		for (int k = 1; k <= unionCnt; k++) {
 			undo();
 		}
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index 59ec766d6..d5498ebc3 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -26,7 +26,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXT = 5000001;
-//const int LIMIT = 20;
+//const int DEEP = 20;
 //const int BIT = 29;
 //int n, m, q;
 //
@@ -39,7 +39,7 @@
 //int d[MAXN];
 //
 //int basis[BIT + 1];
-//int backup[LIMIT][BIT + 1];
+//int backup[DEEP][BIT + 1];
 //
 //int head[MAXN << 2];
 //int nxt[MAXT];

From 05fb83d52e563a8c838536cec03028944feb1963 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 27 Apr 2025 21:13:38 +0800
Subject: [PATCH 0722/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java | 2 +-
 src/class167/Code01_ShortestPathQueries2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
index a4f6cc5af..c6de9a468 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -15,8 +15,8 @@ public class Code01_ShortestPathQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXT = 5000001;
-	public static int DEEP = 20;
 	public static int BIT = 29;
+	public static int DEEP = 20;
 	public static int n, m, q;
 
 	// 端点x、端点y、时间点t、边权w
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index d5498ebc3..40825445f 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -26,8 +26,8 @@
 //
 //const int MAXN = 200001;
 //const int MAXT = 5000001;
-//const int DEEP = 20;
 //const int BIT = 29;
+//const int DEEP = 20;
 //int n, m, q;
 //
 //Event event[MAXN << 1];

From f323a7faec282550ece7f8f192959fc7328762a7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 28 Apr 2025 11:37:56 +0800
Subject: [PATCH 0723/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java     | 4 ++--
 src/class167/Code02_EightVerticalHorizontal1.java | 9 +++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)
 create mode 100644 src/class167/Code02_EightVerticalHorizontal1.java

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
index c6de9a468..76d746aaa 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -51,7 +51,7 @@ public class Code01_ShortestPathQueries1 {
 	// 查询操作的答案
 	public static int[] ans = new int[MAXN];
 
-	// 当前数字插入线性基
+	// num插入线性基
 	public static void insert(int num) {
 		for (int i = BIT; i >= 0; i--) {
 			if (num >> i == 1) {
@@ -99,7 +99,7 @@ public static int getEor(int i) {
 
 	// 可撤销并查集的合并，增加a和b之间，权值为w的边
 	// 集合合并的过程中，还要更新eor数组
-	// 这种更新eor的方式，参考讲解156，带权并查集
+	// 更新eor的方式，参考讲解156，带权并查集
 	public static boolean union(int a, int b, int w) {
 		int eora = getEor(a);
 		int eorb = getEor(b);
diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code02_EightVerticalHorizontal1.java
new file mode 100644
index 000000000..06257d87e
--- /dev/null
+++ b/src/class167/Code02_EightVerticalHorizontal1.java
@@ -0,0 +1,9 @@
+package class167;
+
+// 八纵八横
+// 测试链接 : https://www.luogu.com.cn/problem/P3733
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code02_EightVerticalHorizontal1 {
+
+}

From 1a9a25b0729842e3afad4c8035f7b7b951e35a79 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 28 Apr 2025 11:47:28 +0800
Subject: [PATCH 0724/1712] modify code

---
 ...01_SmallSum.java => Code01_SmallSum1.java} |  4 +-
 src/class022/Code01_SmallSum2.java            | 60 +++++++++++++++++++
 2 files changed, 62 insertions(+), 2 deletions(-)
 rename src/class022/{Code01_SmallSum.java => Code01_SmallSum1.java} (97%)
 create mode 100644 src/class022/Code01_SmallSum2.java

diff --git a/src/class022/Code01_SmallSum.java b/src/class022/Code01_SmallSum1.java
similarity index 97%
rename from src/class022/Code01_SmallSum.java
rename to src/class022/Code01_SmallSum1.java
index f7a1d0ecc..0830a55b9 100644
--- a/src/class022/Code01_SmallSum.java
+++ b/src/class022/Code01_SmallSum1.java
@@ -1,6 +1,6 @@
 package class022;
 
-// 小和问题
+// 小和问题，java版
 // 测试链接 : https://www.nowcoder.com/practice/edfe05a1d45c4ea89101d936cac32469
 // 请同学们务必参考如下代码中关于输入、输出的处理
 // 这是输入输出处理效率很高的写法
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.io.StreamTokenizer;
 
-public class Code01_SmallSum {
+public class Code01_SmallSum1 {
 
 	public static int MAXN = 100001;
 
diff --git a/src/class022/Code01_SmallSum2.java b/src/class022/Code01_SmallSum2.java
new file mode 100644
index 000000000..66838103e
--- /dev/null
+++ b/src/class022/Code01_SmallSum2.java
@@ -0,0 +1,60 @@
+package class022;
+
+// 小和问题，C++版
+// 测试链接 : https://www.nowcoder.com/practice/edfe05a1d45c4ea89101d936cac32469
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n;
+//
+//int arr[MAXN];
+//int help[MAXN];
+//
+//long long merge(int l, int m, int r) {
+//    long long ans = 0;
+//    for (int j = m + 1, i = l, sum = 0; j <= r; j++) {
+//        while (i <= m && arr[i] <= arr[j]) {
+//            sum += arr[i++];
+//        }
+//        ans += sum;
+//    }
+//    int i = l, a = l, b = m + 1;
+//    while (a <= m && b <= r) {
+//        help[i++] = (arr[a] <= arr[b] ? arr[a++] : arr[b++]);
+//    }
+//    while (a <= m) {
+//        help[i++] = arr[a++];
+//    }
+//    while (b <= r) {
+//        help[i++] = arr[b++];
+//    }
+//    for (i = l; i <= r; i++) {
+//        arr[i] = help[i];
+//    }
+//    return ans;
+//}
+//
+//long long smallSum(int l, int r) {
+//    if (l == r) {
+//        return 0;
+//    }
+//    int m = (l + r) >> 1;
+//    return smallSum(l, m) + smallSum(m + 1, r) + merge(l, m, r);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    while (cin >> n) {
+//        for (int i = 0; i < n; i++) {
+//            cin >> arr[i];
+//        }
+//        cout << smallSum(0, n - 1) << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 2da4d66ea2fd202b5cd27a00cd52d5c51a5b314e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 28 Apr 2025 11:57:56 +0800
Subject: [PATCH 0725/1712] modify code

---
 src/class167/Code02_EightVerticalHorizontal1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code02_EightVerticalHorizontal1.java
index 06257d87e..bee657e1c 100644
--- a/src/class167/Code02_EightVerticalHorizontal1.java
+++ b/src/class167/Code02_EightVerticalHorizontal1.java
@@ -6,4 +6,4 @@
 
 public class Code02_EightVerticalHorizontal1 {
 
-}
+}
\ No newline at end of file

From 2e1f5031ca748627185ab107244899727da8a833 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 29 Apr 2025 11:37:20 +0800
Subject: [PATCH 0726/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java | 91 ++++++++++---------
 src/class167/Code01_ShortestPathQueries2.java | 91 +++++++++++--------
 .../Code02_EightVerticalHorizontal1.java      |  9 --
 3 files changed, 99 insertions(+), 92 deletions(-)
 delete mode 100644 src/class167/Code02_EightVerticalHorizontal1.java

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
index 76d746aaa..336855b0b 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -15,8 +15,7 @@ public class Code01_ShortestPathQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXT = 5000001;
-	public static int BIT = 29;
-	public static int DEEP = 20;
+	public static int BIT = 30;
 	public static int n, m, q;
 
 	// 端点x、端点y、时间点t、边权w
@@ -29,9 +28,10 @@ public class Code01_ShortestPathQueries1 {
 	public static int[] y = new int[MAXN];
 	public static int[] d = new int[MAXN];
 
-	// 异或空间线性基
-	public static int[] basis = new int[BIT + 1];
-	public static int[][] backup = new int[DEEP][BIT + 1];
+	// 可撤销线性基
+	public static int[] basis = new int[BIT];
+	public static int[] inspos = new int[BIT];
+	public static int basiz = 0;
 
 	// 时间轴线段树上的区间任务列表
 	public static int[] head = new int[MAXN << 2];
@@ -53,10 +53,11 @@ public class Code01_ShortestPathQueries1 {
 
 	// num插入线性基
 	public static void insert(int num) {
-		for (int i = BIT; i >= 0; i--) {
+		for (int i = BIT - 1; i >= 0; i--) {
 			if (num >> i == 1) {
 				if (basis[i] == 0) {
 					basis[i] = num;
+					inspos[basiz++] = i;
 					return;
 				}
 				num ^= basis[i];
@@ -66,16 +67,16 @@ public static void insert(int num) {
 
 	// 根据线性基，返回num能结合出的最小异或和
 	public static int minEor(int num) {
-		for (int i = BIT; i >= 0; i--) {
+		for (int i = BIT - 1; i >= 0; i--) {
 			num = Math.min(num, num ^ basis[i]);
 		}
 		return num;
 	}
 
-	// a把b的内容拷贝过来，用于线性基的撤销
-	public static void clone(int[] a, int[] b) {
-		for (int i = 0; i <= BIT; i++) {
-			a[i] = b[i];
+	// 线性基的撤销，让空间大小回到之前的规模
+	public static void cancel(int oldsiz) {
+		while (basiz > oldsiz) {
+			basis[inspos[--basiz]] = 0;
 		}
 	}
 
@@ -100,36 +101,29 @@ public static int getEor(int i) {
 	// 可撤销并查集的合并，增加a和b之间，权值为w的边
 	// 集合合并的过程中，还要更新eor数组
 	// 更新eor的方式，参考讲解156，带权并查集
-	public static boolean union(int a, int b, int w) {
-		int eora = getEor(a);
-		int eorb = getEor(b);
-		int fa = find(a);
-		int fb = find(b);
-		w = eora ^ eorb ^ w;
-		if (fa == fb) {
-			insert(w);
-			return false;
+	public static void union(int u, int v, int w) {
+		int fu = find(u);
+		int fv = find(v);
+		w = getEor(u) ^ getEor(v) ^ w;
+		if (siz[fu] < siz[fv]) {
+			int tmp = fu;
+			fu = fv;
+			fv = tmp;
 		}
-		if (siz[fa] < siz[fb]) {
-			int tmp = fa;
-			fa = fb;
-			fb = tmp;
-		}
-		father[fb] = fa;
-		siz[fa] += siz[fb];
-		eor[fb] = w;
-		rollback[++opsize][0] = fa;
-		rollback[opsize][1] = fb;
-		return true;
+		father[fv] = fu;
+		siz[fu] += siz[fv];
+		eor[fv] = w;
+		rollback[++opsize][0] = fu;
+		rollback[opsize][1] = fv;
 	}
 
 	// 并查集的撤销操作
 	public static void undo() {
-		int fa = rollback[opsize][0];
-		int fb = rollback[opsize--][1];
-		father[fb] = fb;
-		eor[fb] = 0;
-		siz[fa] -= siz[fb];
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		eor[fy] = 0;
+		siz[fx] -= siz[fy];
 	}
 
 	// 给某个线段树区间增加任务，点x到点y之间，增加权值为w的边
@@ -155,11 +149,22 @@ public static void add(int jobl, int jobr, int jobx, int joby, int jobw, int l,
 		}
 	}
 
-	public static void dfs(int l, int r, int i, int dep) {
-		clone(backup[dep], basis);
+	public static void dfs(int l, int r, int i) {
+		int oldsiz = basiz;
 		int unionCnt = 0;
+		int u, v, w, fu, fv, eoru, eorv;
 		for (int e = head[i]; e > 0; e = next[e]) {
-			if (union(tox[e], toy[e], tow[e])) {
+			u = tox[e];
+			v = toy[e];
+			w = tow[e];
+			fu = find(u);
+			fv = find(v);
+			eoru = getEor(u);
+			eorv = getEor(v);
+			if (fu == fv) {
+				insert(eoru ^ eorv ^ w);
+			} else {
+				union(u, v, w);
 				unionCnt++;
 			}
 		}
@@ -169,10 +174,10 @@ public static void dfs(int l, int r, int i, int dep) {
 			}
 		} else {
 			int mid = (l + r) >> 1;
-			dfs(l, mid, i << 1, dep + 1);
-			dfs(mid + 1, r, i << 1 | 1, dep + 1);
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
 		}
-		clone(basis, backup[dep]);
+		cancel(oldsiz);
 		for (int k = 1; k <= unionCnt; k++) {
 			undo();
 		}
@@ -229,7 +234,7 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		prepare();
-		dfs(0, q, 1, 0);
+		dfs(0, q, 1);
 		for (int i = 1; i <= q; i++) {
 			if (op[i] == 3) {
 				out.println(ans[i]);
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index 40825445f..3b8ccb5f2 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -26,8 +26,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXT = 5000001;
-//const int BIT = 29;
-//const int DEEP = 20;
+//const int BIT = 30;
 //int n, m, q;
 //
 //Event event[MAXN << 1];
@@ -38,8 +37,9 @@
 //int y[MAXN];
 //int d[MAXN];
 //
-//int basis[BIT + 1];
-//int backup[DEEP][BIT + 1];
+//int basis[BIT];
+//int inspos[BIT];
+//int basiz = 0;
 //
 //int head[MAXN << 2];
 //int nxt[MAXT];
@@ -51,16 +51,17 @@
 //int father[MAXN];
 //int siz[MAXN];
 //int eor[MAXN];
-//int rollbackArr[MAXN][2];
+//int rollback[MAXN][2];
 //int opsize = 0;
 //
 //int ans[MAXN];
 //
 //void insert(int num) {
-//    for (int i = BIT; i >= 0; --i) {
+//    for (int i = BIT - 1; i >= 0; --i) {
 //        if (num >> i == 1) {
 //            if (basis[i] == 0) {
 //                basis[i] = num;
+//                inspos[basiz++] = i;
 //                return;
 //            }
 //            num ^= basis[i];
@@ -69,12 +70,18 @@
 //}
 //
 //int minEor(int num) {
-//    for (int i = BIT; i >= 0; --i) {
+//    for (int i = BIT - 1; i >= 0; --i) {
 //        num = min(num, num ^ basis[i]);
 //    }
 //    return num;
 //}
 //
+//void cancel(int oldsiz) {
+//    while (basiz > oldsiz) {
+//        basis[inspos[--basiz]] = 0;
+//    }
+//}
+//
 //int find(int i) {
 //    while (i != father[i]) {
 //        i = father[i];
@@ -91,35 +98,28 @@
 //    return res;
 //}
 //
-//bool Union(int a, int b, int w) {
-//    int eora = getEor(a);
-//    int eorb = getEor(b);
-//    int fa = find(a);
-//    int fb = find(b);
-//    w = eora ^ eorb ^ w;
-//    if (fa == fb) {
-//        insert(w);
-//        return false;
-//    }
-//    if (siz[fa] < siz[fb]) {
-//        int tmp = fa;
-//        fa = fb;
-//        fb = tmp;
-//    }
-//    father[fb] = fa;
-//    siz[fa] += siz[fb];
-//    eor[fb] = w;
-//    rollbackArr[++opsize][0] = fa;
-//    rollbackArr[opsize][1] = fb;
-//    return true;
+//void Union(int u, int v, int w) {
+//    int fu = find(u);
+//    int fv = find(v);
+//    w = getEor(u) ^ getEor(v) ^ w;
+//    if (siz[fu] < siz[fv]) {
+//        int tmp = fu;
+//        fu = fv;
+//        fv = tmp;
+//    }
+//    father[fv] = fu;
+//    siz[fu] += siz[fv];
+//    eor[fv] = w;
+//    rollback[++opsize][0] = fu;
+//    rollback[opsize][1] = fv;
 //}
 //
 //void undo() {
-//    int fa = rollbackArr[opsize][0];
-//    int fb = rollbackArr[opsize--][1];
-//    father[fb] = fb;
-//    eor[fb] = 0;
-//    siz[fa] -= siz[fb];
+//    int fu = rollback[opsize][0];
+//    int fv = rollback[opsize--][1];
+//    father[fv] = fv;
+//    eor[fv] = 0;
+//    siz[fu] -= siz[fv];
 //}
 //
 //void addEdge(int idx, int u, int v, int w) {
@@ -144,11 +144,22 @@
 //    }
 //}
 //
-//void dfs(int l, int r, int i, int dep) {
-//    memcpy(backup[dep], basis, sizeof(backup[dep]));
+//void dfs(int l, int r, int i) {
+//    int oldsiz = basiz;
 //    int unionCnt = 0;
+//    int u, v, w, fu, fv, eoru, eorv;
 //    for (int e = head[i]; e; e = nxt[e]) {
-//        if (Union(tox[e], toy[e], tow[e])) {
+//        u = tox[e];
+//        v = toy[e];
+//        w = tow[e];
+//        fu = find(u);
+//        fv = find(v);
+//        eoru = getEor(u);
+//        eorv = getEor(v);
+//        if (fu == fv) {
+//            insert(eoru ^ eorv ^ w);
+//        } else {
+//            Union(u, v, w);
 //            unionCnt++;
 //        }
 //    }
@@ -158,10 +169,10 @@
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
-//        dfs(l, mid, i << 1, dep + 1);
-//        dfs(mid + 1, r, i << 1 | 1, dep + 1);
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
 //    }
-//    memcpy(basis, backup[dep], sizeof(basis));
+//    cancel(oldsiz);
 //    for (int k = 1; k <= unionCnt; k++) {
 //        undo();
 //    }
@@ -212,7 +223,7 @@
 //        }
 //    }
 //    prepare();
-//    dfs(0, q, 1, 0);
+//    dfs(0, q, 1);
 //    for (int i = 1; i <= q; i++) {
 //        if (op[i] == 3) {
 //            cout << ans[i] << '\n';
diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code02_EightVerticalHorizontal1.java
deleted file mode 100644
index bee657e1c..000000000
--- a/src/class167/Code02_EightVerticalHorizontal1.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package class167;
-
-// 八纵八横
-// 测试链接 : https://www.luogu.com.cn/problem/P3733
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code02_EightVerticalHorizontal1 {
-
-}
\ No newline at end of file

From 7aad7737750c28ab139ea8749992d38cfafd260c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 29 Apr 2025 17:18:44 +0800
Subject: [PATCH 0727/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java |  36 +-
 src/class167/Code01_ShortestPathQueries2.java |  34 +-
 .../Code02_EightVerticalHorizontal1.java      | 382 ++++++++++++++++++
 3 files changed, 411 insertions(+), 41 deletions(-)
 create mode 100644 src/class167/Code02_EightVerticalHorizontal1.java

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
index 336855b0b..56df48243 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -33,6 +33,13 @@ public class Code01_ShortestPathQueries1 {
 	public static int[] inspos = new int[BIT];
 	public static int basiz = 0;
 
+	// 可撤销并查集 + 带权并查集
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] eor = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize = 0;
+
 	// 时间轴线段树上的区间任务列表
 	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
@@ -41,13 +48,6 @@ public class Code01_ShortestPathQueries1 {
 	public static int[] tow = new int[MAXT];
 	public static int cnt = 0;
 
-	// 可撤销并查集 + 带权并查集
-	public static int[] father = new int[MAXN];
-	public static int[] siz = new int[MAXN];
-	public static int[] eor = new int[MAXN];
-	public static int[][] rollback = new int[MAXN][2];
-	public static int opsize = 0;
-
 	// 查询操作的答案
 	public static int[] ans = new int[MAXN];
 
@@ -65,7 +65,7 @@ public static void insert(int num) {
 		}
 	}
 
-	// 根据线性基，返回num能结合出的最小异或和
+	// num结合线性基，能得到的最小异或值返回
 	public static int minEor(int num) {
 		for (int i = BIT - 1; i >= 0; i--) {
 			num = Math.min(num, num ^ basis[i]);
@@ -101,10 +101,14 @@ public static int getEor(int i) {
 	// 可撤销并查集的合并，增加a和b之间，权值为w的边
 	// 集合合并的过程中，还要更新eor数组
 	// 更新eor的方式，参考讲解156，带权并查集
-	public static void union(int u, int v, int w) {
+	public static boolean union(int u, int v, int w) {
 		int fu = find(u);
 		int fv = find(v);
 		w = getEor(u) ^ getEor(v) ^ w;
+		if (fu == fv) {
+			insert(w);
+			return false;
+		}
 		if (siz[fu] < siz[fv]) {
 			int tmp = fu;
 			fu = fv;
@@ -115,6 +119,7 @@ public static void union(int u, int v, int w) {
 		eor[fv] = w;
 		rollback[++opsize][0] = fu;
 		rollback[opsize][1] = fv;
+		return true;
 	}
 
 	// 并查集的撤销操作
@@ -152,19 +157,8 @@ public static void add(int jobl, int jobr, int jobx, int joby, int jobw, int l,
 	public static void dfs(int l, int r, int i) {
 		int oldsiz = basiz;
 		int unionCnt = 0;
-		int u, v, w, fu, fv, eoru, eorv;
 		for (int e = head[i]; e > 0; e = next[e]) {
-			u = tox[e];
-			v = toy[e];
-			w = tow[e];
-			fu = find(u);
-			fv = find(v);
-			eoru = getEor(u);
-			eorv = getEor(v);
-			if (fu == fv) {
-				insert(eoru ^ eorv ^ w);
-			} else {
-				union(u, v, w);
+			if (union(tox[e], toy[e], tow[e])) {
 				unionCnt++;
 			}
 		}
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index 3b8ccb5f2..003e5b229 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -41,6 +41,12 @@
 //int inspos[BIT];
 //int basiz = 0;
 //
+//int father[MAXN];
+//int siz[MAXN];
+//int eor[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
 //int head[MAXN << 2];
 //int nxt[MAXT];
 //int tox[MAXT];
@@ -48,12 +54,6 @@
 //int tow[MAXT];
 //int cnt = 0;
 //
-//int father[MAXN];
-//int siz[MAXN];
-//int eor[MAXN];
-//int rollback[MAXN][2];
-//int opsize = 0;
-//
 //int ans[MAXN];
 //
 //void insert(int num) {
@@ -98,10 +98,14 @@
 //    return res;
 //}
 //
-//void Union(int u, int v, int w) {
+//bool Union(int u, int v, int w) {
 //    int fu = find(u);
 //    int fv = find(v);
 //    w = getEor(u) ^ getEor(v) ^ w;
+//    if (fu == fv) {
+//        insert(w);
+//        return false;
+//    }
 //    if (siz[fu] < siz[fv]) {
 //        int tmp = fu;
 //        fu = fv;
@@ -112,6 +116,7 @@
 //    eor[fv] = w;
 //    rollback[++opsize][0] = fu;
 //    rollback[opsize][1] = fv;
+//    return true;
 //}
 //
 //void undo() {
@@ -147,25 +152,14 @@
 //void dfs(int l, int r, int i) {
 //    int oldsiz = basiz;
 //    int unionCnt = 0;
-//    int u, v, w, fu, fv, eoru, eorv;
 //    for (int e = head[i]; e; e = nxt[e]) {
-//        u = tox[e];
-//        v = toy[e];
-//        w = tow[e];
-//        fu = find(u);
-//        fv = find(v);
-//        eoru = getEor(u);
-//        eorv = getEor(v);
-//        if (fu == fv) {
-//            insert(eoru ^ eorv ^ w);
-//        } else {
-//            Union(u, v, w);
+//        if (Union(tox[e], toy[e], tow[e])) {
 //            unionCnt++;
 //        }
 //    }
 //    if (l == r) {
 //        if (op[l] == 3) {
-//        	ans[l] = minEor(getEor(x[l]) ^ getEor(y[l]));
+//            ans[l] = minEor(getEor(x[l]) ^ getEor(y[l]));
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code02_EightVerticalHorizontal1.java
new file mode 100644
index 000000000..487df775a
--- /dev/null
+++ b/src/class167/Code02_EightVerticalHorizontal1.java
@@ -0,0 +1,382 @@
+package class167;
+
+// 八纵八横，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3733
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code02_EightVerticalHorizontal1 {
+
+	// 位图
+	static class BitSet {
+
+		public int len;
+
+		public int[] arr;
+
+		public BitSet(int size) {
+			len = (size + 31) / 32;
+			arr = new int[len];
+		}
+
+		public BitSet(String s, int size) {
+			len = (size + 31) / 32;
+			arr = new int[len];
+			for (int i = 0, j = s.length() - 1; i < s.length(); i++, j--) {
+				set(i, s.charAt(j) - '0');
+			}
+		}
+
+		// 返回第i位的状态
+		public int get(int i) {
+			return (arr[i / 32] >> (i % 32)) & 1;
+		}
+
+		// 设置第i位的状态
+		public void set(int i, int v) {
+			if (v == 0) {
+				arr[i / 32] &= ~(1 << (i % 32));
+			} else {
+				arr[i / 32] |= 1 << (i % 32);
+			}
+		}
+
+		// 拷贝other每一位
+		public void copy(BitSet other) {
+			for (int i = 0; i < len; i++) {
+				arr[i] = other.arr[i];
+			}
+		}
+
+		// 异或other每一位
+		public void eor(BitSet other) {
+			for (int i = 0; i < len; i++) {
+				arr[i] ^= other.arr[i];
+			}
+		}
+
+		// 清空每一位
+		public void clear() {
+			for (int i = 0; i < len; i++) {
+				arr[i] = 0;
+			}
+		}
+
+	}
+
+	public static int MAXN = 501;
+	public static int MAXQ = 1001;
+	public static int MAXT = 10001;
+	public static int BIT = 1000;
+	public static int n, m, q;
+
+	// 记录每条操作
+	public static int[] x = new int[MAXQ];
+	public static int[] y = new int[MAXQ];
+	public static BitSet[] w = new BitSet[MAXQ];
+	public static int edgeCnt = 0;
+	public static int[] last = new int[MAXQ];
+
+	// 可撤销线性基
+	public static BitSet[] basis = new BitSet[BIT];
+	public static int[] inspos = new int[BIT];
+	public static int basiz = 0;
+
+	// 可撤销并查集 + 带权并查集
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static BitSet[] eor = new BitSet[MAXN];
+	public static int[][] rollback = new int[MAXT][2];
+	public static int opsize = 0;
+
+	// 时间轴线段树上的区间任务列表
+	public static int[] head = new int[MAXQ << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] tox = new int[MAXT];
+	public static int[] toy = new int[MAXT];
+	public static BitSet[] tow = new BitSet[MAXT];
+	public static int cnt = 0;
+
+	// 每一步的最大异或值
+	public static BitSet[] ans = new BitSet[MAXQ];
+
+	public static void insert(BitSet num) {
+		for (int i = BIT - 1; i >= 0; i--) {
+			if (num.get(i) == 1) {
+				if (basis[i].get(i) == 0) {
+					basis[i].copy(num);
+					inspos[basiz++] = i;
+					return;
+				}
+				num.eor(basis[i]);
+			}
+		}
+	}
+
+	// 0这个数字结合线性基，得到的最大异或值返回
+	public static BitSet maxEor() {
+		BitSet ans = new BitSet(BIT);
+		for (int i = BIT - 1; i >= 0; i--) {
+			if (ans.get(i) == 0 && basis[i].get(i) == 1) {
+				ans.eor(basis[i]);
+			}
+		}
+		return ans;
+	}
+
+	public static void cancel(int oldsiz) {
+		while (basiz > oldsiz) {
+			basis[inspos[--basiz]].clear();
+		}
+	}
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static BitSet getEor(int i) {
+		BitSet ans = new BitSet(BIT);
+		while (i != father[i]) {
+			ans.eor(eor[i]);
+			i = father[i];
+		}
+		return ans;
+	}
+
+	public static boolean union(int u, int v, BitSet w) {
+		int fu = find(u);
+		int fv = find(v);
+		BitSet weight = new BitSet(BIT);
+		weight.eor(getEor(u));
+		weight.eor(getEor(v));
+		weight.eor(w);
+		if (fu == fv) {
+			insert(weight);
+			return false;
+		}
+		if (siz[fu] < siz[fv]) {
+			int tmp = fu;
+			fu = fv;
+			fv = tmp;
+		}
+		father[fv] = fu;
+		siz[fu] += siz[fv];
+		eor[fv].copy(weight);
+		rollback[++opsize][0] = fu;
+		rollback[opsize][1] = fv;
+		return true;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		eor[fy].clear();
+		siz[fx] -= siz[fy];
+	}
+
+	public static void addEdge(int i, int x, int y, BitSet w) {
+		next[++cnt] = head[i];
+		tox[cnt] = x;
+		toy[cnt] = y;
+		tow[cnt] = w;
+		head[i] = cnt;
+	}
+
+	public static void add(int jobl, int jobr, int jobx, int joby, BitSet jobw, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobx, joby, jobw);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobx, joby, jobw, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobx, joby, jobw, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int oldsiz = basiz;
+		int unionCnt = 0;
+		for (int e = head[i]; e > 0; e = next[e]) {
+			if (union(tox[e], toy[e], tow[e])) {
+				unionCnt++;
+			}
+		}
+		if (l == r) {
+			ans[l] = maxEor();
+		} else {
+			int mid = (l + r) / 2;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+		cancel(oldsiz);
+		for (int k = 1; k <= unionCnt; k++) {
+			undo();
+		}
+	}
+
+	public static void print(BitSet bs, PrintWriter out) {
+		boolean flag = false;
+		for (int i = BIT - 1, s; i >= 0; i--) {
+			s = bs.get(i);
+			if (s == 1) {
+				flag = true;
+			}
+			if (flag) {
+				out.print(s);
+			}
+		}
+		if (!flag) {
+			out.print(0);
+		}
+		out.println();
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		q = in.nextInt();
+		for (int i = 0; i < BIT; i++) {
+			basis[i] = new BitSet(BIT);
+		}
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+			eor[i] = new BitSet(BIT);
+		}
+		for (int i = 1; i <= m; i++) {
+			int u = in.nextInt();
+			int v = in.nextInt();
+			BitSet w = new BitSet(in.nextString(), BIT);
+			union(u, v, w);
+		}
+		ans[0] = maxEor();
+		String op;
+		for (int i = 1; i <= q; i++) {
+			op = in.nextString();
+			if (op.equals("Add")) {
+				edgeCnt++;
+				x[edgeCnt] = in.nextInt();
+				y[edgeCnt] = in.nextInt();
+				w[edgeCnt] = new BitSet(in.nextString(), BIT);
+				last[edgeCnt] = i;
+			} else if (op.equals("Cancel")) {
+				int k = in.nextInt();
+				add(last[k], i - 1, x[k], y[k], w[k], 1, q, 1);
+				last[k] = 0;
+			} else {
+				int k = in.nextInt();
+				add(last[k], i - 1, x[k], y[k], w[k], 1, q, 1);
+				w[k] = new BitSet(in.nextString(), BIT);
+				last[k] = i;
+			}
+		}
+		for (int i = 1; i <= edgeCnt; i++) {
+			if (last[i] != 0) {
+				add(last[i], q, x[i], y[i], w[i], 1, q, 1);
+			}
+		}
+		if (q > 0) {
+			dfs(1, q, 1);
+		}
+		for (int i = 0; i <= q; i++) {
+			print(ans[i], out);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private static final int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len) {
+				return true;
+			}
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte()) {
+				return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1) {
+					return 0;
+				}
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b)) {
+				b = readByte();
+			}
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public String nextString() throws IOException {
+			byte b = readByte();
+			while (isWhitespace(b)) {
+				b = readByte();
+			}
+			StringBuilder sb = new StringBuilder(1000);
+			while (!isWhitespace(b) && b != -1) {
+				sb.append((char) b);
+				b = readByte();
+			}
+			return sb.toString();
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
\ No newline at end of file

From e3d49dbd5af508a21eaed3d5f0e7a1ae76c58d2a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 29 Apr 2025 18:18:52 +0800
Subject: [PATCH 0728/1712] modify code

---
 .../Code02_EightVerticalHorizontal2.java      | 276 ++++++++++++++++++
 1 file changed, 276 insertions(+)
 create mode 100644 src/class167/Code02_EightVerticalHorizontal2.java

diff --git a/src/class167/Code02_EightVerticalHorizontal2.java b/src/class167/Code02_EightVerticalHorizontal2.java
new file mode 100644
index 000000000..44996eda4
--- /dev/null
+++ b/src/class167/Code02_EightVerticalHorizontal2.java
@@ -0,0 +1,276 @@
+package class167;
+
+// 八纵八横，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3733
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct BitSet {
+//    int len;
+//    vector<int> arr;
+//
+//    BitSet(int size = 0) {
+//        len = (size + 31) / 32;
+//        arr.assign(len, 0);
+//    }
+//
+//    BitSet(const string& s, int size) {
+//        len = (size + 31) / 32;
+//        arr.assign(len, 0);
+//        for (int i = 0, j = (int)s.size() - 1; i < (int)s.size(); i++, j--) {
+//            set(i, s[j] - '0');
+//        }
+//    }
+//
+//    int get(int i) const {
+//        return (arr[i / 32] >> (i % 32)) & 1;
+//    }
+//
+//    void set(int i, int v) {
+//        if (v) {
+//            arr[i / 32] |= 1 << (i % 32);
+//        } else {
+//            arr[i / 32] &= ~(1 << (i % 32));
+//        }
+//    }
+//
+//    void copy(const BitSet& other) {
+//        arr = other.arr;
+//    }
+//
+//    void eor(const BitSet& other) {
+//        for (int i = 0; i < len; i++) {
+//            arr[i] ^= other.arr[i];
+//        }
+//    }
+//
+//    void clear() {
+//        fill(arr.begin(), arr.end(), 0);
+//    }
+//};
+//
+//const int MAXN = 501;
+//const int MAXQ = 1001;
+//const int MAXT = 10001;
+//const int BIT = 1000;
+//
+//int n, m, q;
+//int x[MAXQ];
+//int y[MAXQ];
+//BitSet w[MAXQ];
+//int edgeCnt = 0;
+//int last[MAXQ];
+//
+//BitSet basis[BIT];
+//int inspos[BIT];
+//int basiz = 0;
+//
+//int father[MAXN];
+//int siz[MAXN];
+//BitSet eor[MAXN];
+//int rollback[MAXT][2];
+//int opsize = 0;
+//
+//int head[MAXQ << 2];
+//int nxt[MAXT];
+//int tox[MAXT];
+//int toy[MAXT];
+//BitSet tow[MAXT];
+//int cnt = 0;
+//
+//BitSet ans[MAXQ];
+//
+//void insert(BitSet num) {
+//    for (int i = BIT - 1; i >= 0; i--) {
+//        if (num.get(i)) {
+//            if (basis[i].get(i) == 0) {
+//                basis[i].copy(num);
+//                inspos[basiz++] = i;
+//                return;
+//            }
+//            num.eor(basis[i]);
+//        }
+//    }
+//}
+//
+//BitSet maxEor() {
+//    BitSet res(BIT);
+//    for (int i = BIT - 1; i >= 0; i--) {
+//        if (res.get(i) == 0 && basis[i].get(i) == 1) {
+//            res.eor(basis[i]);
+//        }
+//    }
+//    return res;
+//}
+//
+//void cancel(int oldsiz) {
+//    while (basiz > oldsiz) {
+//        basis[inspos[--basiz]].clear();
+//    }
+//}
+//
+//int find(int i) {
+//    while (i != father[i]) {
+//        i = father[i];
+//    }
+//    return i;
+//}
+//
+//BitSet getEor(int i) {
+//    BitSet res(BIT);
+//    while (i != father[i]) {
+//        res.eor(eor[i]);
+//        i = father[i];
+//    }
+//    return res;
+//}
+//
+//bool Union(int u, int v, const BitSet& w) {
+//    int fu = find(u), fv = find(v);
+//    BitSet weight(BIT);
+//    weight.eor(getEor(u));
+//    weight.eor(getEor(v));
+//    weight.eor(w);
+//    if (fu == fv) {
+//        insert(weight);
+//        return false;
+//    }
+//    if (siz[fu] < siz[fv]) {
+//        int tmp = fu;
+//        fu = fv;
+//        fv = tmp;
+//    }
+//    father[fv] = fu;
+//    siz[fu] += siz[fv];
+//    eor[fv].copy(weight);
+//    rollback[++opsize][0] = fu;
+//    rollback[opsize][1] = fv;
+//    return true;
+//}
+//
+//void undo() {
+//    int fu = rollback[opsize][0];
+//    int fv = rollback[opsize--][1];
+//    father[fv] = fv;
+//    eor[fv].clear();
+//    siz[fu] -= siz[fv];
+//}
+//
+//void addEdge(int i, int u, int v, const BitSet& w) {
+//    nxt[++cnt] = head[i];
+//    tox[cnt] = u;
+//    toy[cnt] = v;
+//    tow[cnt].copy(w);
+//    head[i] = cnt;
+//}
+//
+//void add(int jobl, int jobr, int jobx, int joby, const BitSet& jobw, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobx, joby, jobw);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobx, joby, jobw, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobx, joby, jobw, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i) {
+//    int oldsiz = basiz;
+//    int unionCnt = 0;
+//    for (int e = head[i]; e > 0; e = nxt[e]) {
+//        if (Union(tox[e], toy[e], tow[e])) {
+//            unionCnt++;
+//        }
+//    }
+//    if (l == r) {
+//        ans[l] = maxEor();
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//    cancel(oldsiz);
+//    for (int k = 1; k <= unionCnt; k++) {
+//        undo();
+//    }
+//}
+//
+//void print(const BitSet& bs) {
+//    bool flag = false;
+//    for (int i = BIT - 1, s; i >= 0; i--) {
+//        s = bs.get(i);
+//        if (s == 1) {
+//            flag = true;
+//        }
+//        if (flag) {
+//            cout << s;
+//        }
+//    }
+//    if (!flag) {
+//        cout << '0';
+//    }
+//    cout << '\n';
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> q;
+//    for (int i = 0; i < BIT; i++) {
+//        basis[i] = BitSet(BIT);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//        eor[i] = BitSet(BIT);
+//    }
+//    int u, v;
+//    string str;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> u >> v >> str;
+//        Union(u, v, BitSet(str, BIT));
+//    }
+//    ans[0] = maxEor();
+//    string op;
+//    int k;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> op;
+//        if (op == "Add") {
+//            ++edgeCnt;
+//            cin >> x[edgeCnt] >> y[edgeCnt];
+//            cin >> str;
+//            w[edgeCnt] = BitSet(str, BIT);
+//            last[edgeCnt] = i;
+//        } else if (op == "Cancel") {
+//            cin >> k;
+//            add(last[k], i - 1, x[k], y[k], w[k], 1, q, 1);
+//            last[k] = 0;
+//        } else {
+//            cin >> k;
+//            add(last[k], i - 1, x[k], y[k], w[k], 1, q, 1);
+//            cin >> str;
+//            w[k] = BitSet(str, BIT);
+//            last[k] = i;
+//        }
+//    }
+//    for (int i = 1; i <= edgeCnt; i++) {
+//        if (last[i] > 0) {
+//            add(last[i], q, x[i], y[i], w[i], 1, q, 1);
+//        }
+//    }
+//    if (q > 0) {
+//        dfs(1, q, 1);
+//    }
+//    for (int i = 0; i <= q; i++) {
+//        print(ans[i]);
+//    }
+//    return 0;
+//}
\ No newline at end of file

From b001292550d38764027f32f9fa931d04da689bd1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 30 Apr 2025 12:07:39 +0800
Subject: [PATCH 0729/1712] modify code

---
 src/class167/Code01_ShortestPathQueries1.java | 10 ++---
 src/class167/Code01_ShortestPathQueries2.java | 10 ++---
 .../Code02_EightVerticalHorizontal1.java      | 38 ++++++++---------
 .../Code02_EightVerticalHorizontal2.java      | 41 ++++++++++---------
 4 files changed, 50 insertions(+), 49 deletions(-)

diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code01_ShortestPathQueries1.java
index 56df48243..e85069f8e 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code01_ShortestPathQueries1.java
@@ -15,7 +15,7 @@ public class Code01_ShortestPathQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXT = 5000001;
-	public static int BIT = 30;
+	public static int BIT = 29;
 	public static int n, m, q;
 
 	// 端点x、端点y、时间点t、边权w
@@ -29,8 +29,8 @@ public class Code01_ShortestPathQueries1 {
 	public static int[] d = new int[MAXN];
 
 	// 可撤销线性基
-	public static int[] basis = new int[BIT];
-	public static int[] inspos = new int[BIT];
+	public static int[] basis = new int[BIT + 1];
+	public static int[] inspos = new int[BIT + 1];
 	public static int basiz = 0;
 
 	// 可撤销并查集 + 带权并查集
@@ -53,7 +53,7 @@ public class Code01_ShortestPathQueries1 {
 
 	// num插入线性基
 	public static void insert(int num) {
-		for (int i = BIT - 1; i >= 0; i--) {
+		for (int i = BIT; i >= 0; i--) {
 			if (num >> i == 1) {
 				if (basis[i] == 0) {
 					basis[i] = num;
@@ -67,7 +67,7 @@ public static void insert(int num) {
 
 	// num结合线性基，能得到的最小异或值返回
 	public static int minEor(int num) {
-		for (int i = BIT - 1; i >= 0; i--) {
+		for (int i = BIT; i >= 0; i--) {
 			num = Math.min(num, num ^ basis[i]);
 		}
 		return num;
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code01_ShortestPathQueries2.java
index 003e5b229..f99f9ef4f 100644
--- a/src/class167/Code01_ShortestPathQueries2.java
+++ b/src/class167/Code01_ShortestPathQueries2.java
@@ -26,7 +26,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXT = 5000001;
-//const int BIT = 30;
+//const int BIT = 29;
 //int n, m, q;
 //
 //Event event[MAXN << 1];
@@ -37,8 +37,8 @@
 //int y[MAXN];
 //int d[MAXN];
 //
-//int basis[BIT];
-//int inspos[BIT];
+//int basis[BIT + 1];
+//int inspos[BIT + 1];
 //int basiz = 0;
 //
 //int father[MAXN];
@@ -57,7 +57,7 @@
 //int ans[MAXN];
 //
 //void insert(int num) {
-//    for (int i = BIT - 1; i >= 0; --i) {
+//    for (int i = BIT; i >= 0; --i) {
 //        if (num >> i == 1) {
 //            if (basis[i] == 0) {
 //                basis[i] = num;
@@ -70,7 +70,7 @@
 //}
 //
 //int minEor(int num) {
-//    for (int i = BIT - 1; i >= 0; --i) {
+//    for (int i = BIT; i >= 0; --i) {
 //        num = min(num, num ^ basis[i]);
 //    }
 //    return num;
diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code02_EightVerticalHorizontal1.java
index 487df775a..ba2398bad 100644
--- a/src/class167/Code02_EightVerticalHorizontal1.java
+++ b/src/class167/Code02_EightVerticalHorizontal1.java
@@ -18,13 +18,13 @@ static class BitSet {
 
 		public int[] arr;
 
-		public BitSet(int size) {
-			len = (size + 31) / 32;
+		public BitSet() {
+			len = (1000 + 31) / 32;
 			arr = new int[len];
 		}
 
-		public BitSet(String s, int size) {
-			len = (size + 31) / 32;
+		public BitSet(String s) {
+			len = (1000 + 31) / 32;
 			arr = new int[len];
 			for (int i = 0, j = s.length() - 1; i < s.length(); i++, j--) {
 				set(i, s.charAt(j) - '0');
@@ -71,7 +71,7 @@ public void clear() {
 	public static int MAXN = 501;
 	public static int MAXQ = 1001;
 	public static int MAXT = 10001;
-	public static int BIT = 1000;
+	public static int BIT = 999;
 	public static int n, m, q;
 
 	// 记录每条操作
@@ -82,8 +82,8 @@ public void clear() {
 	public static int[] last = new int[MAXQ];
 
 	// 可撤销线性基
-	public static BitSet[] basis = new BitSet[BIT];
-	public static int[] inspos = new int[BIT];
+	public static BitSet[] basis = new BitSet[BIT + 1];
+	public static int[] inspos = new int[BIT + 1];
 	public static int basiz = 0;
 
 	// 可撤销并查集 + 带权并查集
@@ -105,7 +105,7 @@ public void clear() {
 	public static BitSet[] ans = new BitSet[MAXQ];
 
 	public static void insert(BitSet num) {
-		for (int i = BIT - 1; i >= 0; i--) {
+		for (int i = BIT; i >= 0; i--) {
 			if (num.get(i) == 1) {
 				if (basis[i].get(i) == 0) {
 					basis[i].copy(num);
@@ -119,8 +119,8 @@ public static void insert(BitSet num) {
 
 	// 0这个数字结合线性基，得到的最大异或值返回
 	public static BitSet maxEor() {
-		BitSet ans = new BitSet(BIT);
-		for (int i = BIT - 1; i >= 0; i--) {
+		BitSet ans = new BitSet();
+		for (int i = BIT; i >= 0; i--) {
 			if (ans.get(i) == 0 && basis[i].get(i) == 1) {
 				ans.eor(basis[i]);
 			}
@@ -142,7 +142,7 @@ public static int find(int i) {
 	}
 
 	public static BitSet getEor(int i) {
-		BitSet ans = new BitSet(BIT);
+		BitSet ans = new BitSet();
 		while (i != father[i]) {
 			ans.eor(eor[i]);
 			i = father[i];
@@ -153,7 +153,7 @@ public static BitSet getEor(int i) {
 	public static boolean union(int u, int v, BitSet w) {
 		int fu = find(u);
 		int fv = find(v);
-		BitSet weight = new BitSet(BIT);
+		BitSet weight = new BitSet();
 		weight.eor(getEor(u));
 		weight.eor(getEor(v));
 		weight.eor(w);
@@ -227,7 +227,7 @@ public static void dfs(int l, int r, int i) {
 
 	public static void print(BitSet bs, PrintWriter out) {
 		boolean flag = false;
-		for (int i = BIT - 1, s; i >= 0; i--) {
+		for (int i = BIT, s; i >= 0; i--) {
 			s = bs.get(i);
 			if (s == 1) {
 				flag = true;
@@ -248,18 +248,18 @@ public static void main(String[] args) throws IOException {
 		n = in.nextInt();
 		m = in.nextInt();
 		q = in.nextInt();
-		for (int i = 0; i < BIT; i++) {
-			basis[i] = new BitSet(BIT);
+		for (int i = 0; i <= BIT; i++) {
+			basis[i] = new BitSet();
 		}
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
 			siz[i] = 1;
-			eor[i] = new BitSet(BIT);
+			eor[i] = new BitSet();
 		}
 		for (int i = 1; i <= m; i++) {
 			int u = in.nextInt();
 			int v = in.nextInt();
-			BitSet w = new BitSet(in.nextString(), BIT);
+			BitSet w = new BitSet(in.nextString());
 			union(u, v, w);
 		}
 		ans[0] = maxEor();
@@ -270,7 +270,7 @@ public static void main(String[] args) throws IOException {
 				edgeCnt++;
 				x[edgeCnt] = in.nextInt();
 				y[edgeCnt] = in.nextInt();
-				w[edgeCnt] = new BitSet(in.nextString(), BIT);
+				w[edgeCnt] = new BitSet(in.nextString());
 				last[edgeCnt] = i;
 			} else if (op.equals("Cancel")) {
 				int k = in.nextInt();
@@ -279,7 +279,7 @@ public static void main(String[] args) throws IOException {
 			} else {
 				int k = in.nextInt();
 				add(last[k], i - 1, x[k], y[k], w[k], 1, q, 1);
-				w[k] = new BitSet(in.nextString(), BIT);
+				w[k] = new BitSet(in.nextString());
 				last[k] = i;
 			}
 		}
diff --git a/src/class167/Code02_EightVerticalHorizontal2.java b/src/class167/Code02_EightVerticalHorizontal2.java
index 44996eda4..4335a3d7c 100644
--- a/src/class167/Code02_EightVerticalHorizontal2.java
+++ b/src/class167/Code02_EightVerticalHorizontal2.java
@@ -13,13 +13,13 @@
 //    int len;
 //    vector<int> arr;
 //
-//    BitSet(int size = 0) {
-//        len = (size + 31) / 32;
+//    BitSet() {
+//        len = (1000 + 31) / 32;
 //        arr.assign(len, 0);
 //    }
 //
-//    BitSet(const string& s, int size) {
-//        len = (size + 31) / 32;
+//    BitSet(const string& s) {
+//        len = (1000 + 31) / 32;
 //        arr.assign(len, 0);
 //        for (int i = 0, j = (int)s.size() - 1; i < (int)s.size(); i++, j--) {
 //            set(i, s[j] - '0');
@@ -56,7 +56,7 @@
 //const int MAXN = 501;
 //const int MAXQ = 1001;
 //const int MAXT = 10001;
-//const int BIT = 1000;
+//const int BIT = 999;
 //
 //int n, m, q;
 //int x[MAXQ];
@@ -65,8 +65,8 @@
 //int edgeCnt = 0;
 //int last[MAXQ];
 //
-//BitSet basis[BIT];
-//int inspos[BIT];
+//BitSet basis[BIT + 1];
+//int inspos[BIT + 1];
 //int basiz = 0;
 //
 //int father[MAXN];
@@ -85,7 +85,7 @@
 //BitSet ans[MAXQ];
 //
 //void insert(BitSet num) {
-//    for (int i = BIT - 1; i >= 0; i--) {
+//    for (int i = BIT; i >= 0; i--) {
 //        if (num.get(i)) {
 //            if (basis[i].get(i) == 0) {
 //                basis[i].copy(num);
@@ -98,8 +98,8 @@
 //}
 //
 //BitSet maxEor() {
-//    BitSet res(BIT);
-//    for (int i = BIT - 1; i >= 0; i--) {
+//    BitSet res = BitSet();
+//    for (int i = BIT; i >= 0; i--) {
 //        if (res.get(i) == 0 && basis[i].get(i) == 1) {
 //            res.eor(basis[i]);
 //        }
@@ -121,7 +121,7 @@
 //}
 //
 //BitSet getEor(int i) {
-//    BitSet res(BIT);
+//    BitSet res = BitSet();
 //    while (i != father[i]) {
 //        res.eor(eor[i]);
 //        i = father[i];
@@ -130,8 +130,9 @@
 //}
 //
 //bool Union(int u, int v, const BitSet& w) {
-//    int fu = find(u), fv = find(v);
-//    BitSet weight(BIT);
+//    int fu = find(u);
+//    int fv = find(v);
+//    BitSet weight = BitSet();
 //    weight.eor(getEor(u));
 //    weight.eor(getEor(v));
 //    weight.eor(w);
@@ -205,7 +206,7 @@
 //
 //void print(const BitSet& bs) {
 //    bool flag = false;
-//    for (int i = BIT - 1, s; i >= 0; i--) {
+//    for (int i = BIT, s; i >= 0; i--) {
 //        s = bs.get(i);
 //        if (s == 1) {
 //            flag = true;
@@ -224,19 +225,19 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m >> q;
-//    for (int i = 0; i < BIT; i++) {
-//        basis[i] = BitSet(BIT);
+//    for (int i = 0; i <= BIT; i++) {
+//        basis[i] = BitSet();
 //    }
 //    for (int i = 1; i <= n; i++) {
 //        father[i] = i;
 //        siz[i] = 1;
-//        eor[i] = BitSet(BIT);
+//        eor[i] = BitSet();
 //    }
 //    int u, v;
 //    string str;
 //    for (int i = 1; i <= m; i++) {
 //        cin >> u >> v >> str;
-//        Union(u, v, BitSet(str, BIT));
+//        Union(u, v, BitSet(str));
 //    }
 //    ans[0] = maxEor();
 //    string op;
@@ -247,7 +248,7 @@
 //            ++edgeCnt;
 //            cin >> x[edgeCnt] >> y[edgeCnt];
 //            cin >> str;
-//            w[edgeCnt] = BitSet(str, BIT);
+//            w[edgeCnt] = BitSet(str);
 //            last[edgeCnt] = i;
 //        } else if (op == "Cancel") {
 //            cin >> k;
@@ -257,7 +258,7 @@
 //            cin >> k;
 //            add(last[k], i - 1, x[k], y[k], w[k], 1, q, 1);
 //            cin >> str;
-//            w[k] = BitSet(str, BIT);
+//            w[k] = BitSet(str);
 //            last[k] = i;
 //        }
 //    }

From 98ebfdb545841f7db6ab2a4e75e23a25b8767400 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 1 May 2025 01:13:28 +0800
Subject: [PATCH 0730/1712] modify code

---
 src/class167/Code04_MarsStore1.java | 288 ++++++++++++++++++++++++++++
 src/class167/Code04_MarsStore2.java | 221 +++++++++++++++++++++
 2 files changed, 509 insertions(+)
 create mode 100644 src/class167/Code04_MarsStore1.java
 create mode 100644 src/class167/Code04_MarsStore2.java

diff --git a/src/class167/Code04_MarsStore1.java b/src/class167/Code04_MarsStore1.java
new file mode 100644
index 000000000..3a46fb0cd
--- /dev/null
+++ b/src/class167/Code04_MarsStore1.java
@@ -0,0 +1,288 @@
+package class167;
+
+// 火星商店，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4585
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code04_MarsStore1 {
+
+	public static int MAXN = 100001;
+	public static int MAXP = MAXN * 20;
+	public static int MAXT = 1000001;
+	public static int BIT = 16;
+	public static int n, m, t;
+
+	public static int[] arr = new int[MAXN];
+	public static int[] op = new int[MAXN];
+	public static int[] s = new int[MAXN];
+	public static int[] v = new int[MAXN];
+	public static int[] sl = new int[MAXN];
+	public static int[] sr = new int[MAXN];
+	public static int[] x = new int[MAXN];
+	public static int[] d = new int[MAXN];
+	public static int[] tim = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+	public static int[][] tree = new int[MAXP][2];
+	public static int[] pass = new int[MAXP];
+	public static int cntt = 0;
+
+	public static int[] headp = new int[MAXN << 2];
+	public static int[] nextp = new int[MAXT];
+	public static int[] pid = new int[MAXT];
+	public static int cntp = 0;
+
+	public static int[] headb = new int[MAXN << 2];
+	public static int[] nextb = new int[MAXT];
+	public static int[] bid = new int[MAXT];
+	public static int cntb = 0;
+
+	public static int[][] product = new int[MAXN][2];
+	public static int[] ans = new int[MAXN];
+
+	public static int insert(int num, int i) {
+		int rt = ++cntt;
+		tree[rt][0] = tree[i][0];
+		tree[rt][1] = tree[i][1];
+		pass[rt] = pass[i] + 1;
+		for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+			path = (num >> b) & 1;
+			i = tree[i][path];
+			cur = ++cntt;
+			tree[cur][0] = tree[i][0];
+			tree[cur][1] = tree[i][1];
+			pass[cur] = pass[i] + 1;
+			tree[pre][path] = cur;
+		}
+		return rt;
+	}
+
+	public static int query(int num, int u, int v) {
+		int ans = 0;
+		for (int b = BIT, path, best; b >= 0; b--) {
+			path = (num >> b) & 1;
+			best = path ^ 1;
+			if (pass[tree[v][best]] > pass[tree[u][best]]) {
+				ans += 1 << b;
+				u = tree[u][best];
+				v = tree[v][best];
+			} else {
+				u = tree[u][path];
+				v = tree[v][path];
+			}
+		}
+		return ans;
+	}
+
+	public static void addInfoP(int i, int pi) {
+		nextp[++cntp] = headp[i];
+		pid[cntp] = pi;
+		headp[i] = cntp;
+	}
+
+	public static void addInfoB(int i, int bi) {
+		nextb[++cntb] = headb[i];
+		bid[cntb] = bi;
+		headb[i] = cntb;
+	}
+
+	public static void addProduct(int jobi, int pi, int l, int r, int i) {
+		addInfoP(i, pi);
+		if (l < r) {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				addProduct(jobi, pi, l, mid, i << 1);
+			} else {
+				addProduct(jobi, pi, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void addBuy(int jobl, int jobr, int bi, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addInfoB(i, bi);
+		} else {
+			int mid = (l + r) / 2;
+			if (jobl <= mid) {
+				addBuy(jobl, jobr, bi, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				addBuy(jobl, jobr, bi, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static int lower(int size, int num) {
+		int l = 1, r = size, ans = size + 1;
+		while (l <= r) {
+			int mid = (l + r) >> 1;
+			if (product[mid][0] >= num) {
+				ans = mid;
+				r = mid - 1;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static int upper(int size, int num) {
+		int l = 1, r = size, ans = 0;
+		while (l <= r) {
+			int mid = (l + r) >> 1;
+			if (product[mid][0] <= num) {
+				ans = mid;
+				l = mid + 1;
+			} else {
+				r = mid - 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int pcnt = 0;
+		for (int e = headp[i]; e > 0; e = nextp[e]) {
+			product[++pcnt][0] = s[pid[e]];
+			product[pcnt][1] = v[pid[e]];
+		}
+		Arrays.sort(product, 1, pcnt + 1, (a, b) -> a[0] - b[0]);
+		cntt = 0;
+		for (int k = 1; k <= pcnt; k++) {
+			root[k] = insert(product[k][1], root[k - 1]);
+		}
+		for (int e = headb[i], id, pre, post; e > 0; e = nextb[e]) {
+			id = bid[e];
+			pre = lower(pcnt, sl[id]) - 1;
+			post = upper(pcnt, sr[id]);
+			ans[id] = Math.max(ans[id], query(x[id], root[pre], root[post]));
+		}
+		if (l < r) {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			root[i] = insert(arr[i], root[i - 1]);
+		}
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 0) {
+				addProduct(tim[i], i, 1, t, 1);
+			} else {
+				ans[i] = query(x[i], root[sl[i] - 1], root[sr[i]]);
+				int start = Math.max(tim[i] - d[i] + 1, 1);
+				if (start <= tim[i]) {
+					addBuy(start, tim[i], i, 1, t, 1);
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		t = 0;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			op[i] = in.nextInt();
+			if (op[i] == 0) {
+				t++;
+				s[i] = in.nextInt();
+				v[i] = in.nextInt();
+			} else {
+				sl[i] = in.nextInt();
+				sr[i] = in.nextInt();
+				x[i] = in.nextInt();
+				d[i] = in.nextInt();
+			}
+			tim[i] = t;
+		}
+		prepare();
+		dfs(1, t, 1);
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 1) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class167/Code04_MarsStore2.java b/src/class167/Code04_MarsStore2.java
new file mode 100644
index 000000000..a60826f81
--- /dev/null
+++ b/src/class167/Code04_MarsStore2.java
@@ -0,0 +1,221 @@
+package class167;
+
+// 火星商店，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4585
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Product {
+//    int s, v;
+//};
+//
+//bool ProductCmp(Product a, Product b) {
+//    return a.s < b.s;
+//}
+//
+//const int MAXN = 100001;
+//const int MAXP = MAXN * 20;
+//const int MAXT = 1000001;
+//const int BIT = 16;
+//int n, m, t;
+//
+//int arr[MAXN];
+//int op[MAXN];
+//int s[MAXN];
+//int v[MAXN];
+//int sl[MAXN];
+//int sr[MAXN];
+//int x[MAXN];
+//int d[MAXN];
+//int tim[MAXN];
+//
+//int root[MAXN];
+//int tree[MAXP][2];
+//int pass[MAXP];
+//int cntt;
+//
+//int headp[MAXN << 2];
+//int nextp[MAXT];
+//int pid[MAXT];
+//int cntp;
+//
+//int headb[MAXN << 2];
+//int nextb[MAXT];
+//int bid[MAXT];
+//int cntb;
+//
+//Product product[MAXN];
+//int ans[MAXN];
+//
+//int insert(int num, int i) {
+//    int rt = ++cntt;
+//    tree[rt][0] = tree[i][0];
+//    tree[rt][1] = tree[i][1];
+//    pass[rt] = pass[i] + 1;
+//    for (int b = BIT, path, pre = rt, cur; b >= 0; b--, pre = cur) {
+//        path = (num >> b) & 1;
+//        i = tree[i][path];
+//        cur = ++cntt;
+//        tree[cur][0] = tree[i][0];
+//        tree[cur][1] = tree[i][1];
+//        pass[cur] = pass[i] + 1;
+//        tree[pre][path] = cur;
+//    }
+//    return rt;
+//}
+//
+//int query(int num, int u, int v) {
+//    int ansv = 0;
+//    for (int b = BIT, path, best; b >= 0; b--) {
+//        path = (num >> b) & 1;
+//        best = path ^ 1;
+//        if (pass[tree[v][best]] > pass[tree[u][best]]) {
+//            ansv += 1 << b;
+//            u = tree[u][best];
+//            v = tree[v][best];
+//        } else {
+//            u = tree[u][path];
+//            v = tree[v][path];
+//        }
+//    }
+//    return ansv;
+//}
+//
+//void addInfoP(int i, int pi) {
+//    nextp[++cntp] = headp[i];
+//    pid[cntp] = pi;
+//    headp[i] = cntp;
+//}
+//
+//void addInfoB(int i, int bi) {
+//    nextb[++cntb] = headb[i];
+//    bid[cntb] = bi;
+//    headb[i] = cntb;
+//}
+//
+//void addProduct(int jobi, int pi, int l, int r, int i) {
+//    addInfoP(i, pi);
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            addProduct(jobi, pi, l, mid, i << 1);
+//        } else {
+//            addProduct(jobi, pi, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void addBuy(int jobl, int jobr, int bi, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addInfoB(i, bi);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            addBuy(jobl, jobr, bi, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            addBuy(jobl, jobr, bi, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//int lower(int size, int num) {
+//    int l = 1, r = size, ansv = size + 1;
+//    while (l <= r) {
+//        int mid = (l + r) >> 1;
+//        if (product[mid].s >= num) {
+//            ansv = mid;
+//            r = mid - 1;
+//        } else {
+//            l = mid + 1;
+//        }
+//    }
+//    return ansv;
+//}
+//
+//int upper(int size, int num) {
+//    int l = 1, r = size, ansv = 0;
+//    while (l <= r) {
+//        int mid = (l + r) >> 1;
+//        if (product[mid].s <= num) {
+//            ansv = mid;
+//            l = mid + 1;
+//        } else {
+//            r = mid - 1;
+//        }
+//    }
+//    return ansv;
+//}
+//
+//void dfs(int l, int r, int i) {
+//    int pcnt = 0;
+//    for (int e = headp[i]; e > 0; e = nextp[e]) {
+//        product[++pcnt].s = s[pid[e]];
+//        product[pcnt].v = v[pid[e]];
+//    }
+//    sort(product + 1, product + pcnt + 1, ProductCmp);
+//    cntt = 0;
+//    for (int k = 1; k <= pcnt; k++) {
+//        root[k] = insert(product[k].v, root[k - 1]);
+//    }
+//    for (int e = headb[i], id, pre, post; e > 0; e = nextb[e]) {
+//        id = bid[e];
+//        pre = lower(pcnt, sl[id]) - 1;
+//        post = upper(pcnt, sr[id]);
+//        ans[id] = max(ans[id], query(x[id], root[pre], root[post]));
+//    }
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        root[i] = insert(arr[i], root[i - 1]);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 0) {
+//            addProduct(tim[i], i, 1, t, 1);
+//        } else {
+//            ans[i] = query(x[i], root[sl[i] - 1], root[sr[i]]);
+//            int start = max(tim[i] - d[i] + 1, 1);
+//            if (start <= tim[i]) {
+//                addBuy(start, tim[i], i, 1, t, 1);
+//            }
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    t = 0;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op[i];
+//        if (op[i] == 0) {
+//            t++;
+//            cin >> s[i] >> v[i];
+//        } else {
+//            cin >> sl[i] >> sr[i] >> x[i] >> d[i];
+//        }
+//        tim[i] = t;
+//    }
+//    prepare();
+//    dfs(1, t, 1);
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 1) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 5758da26a24f2e4f93cad376908fdf094f487e75 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 1 May 2025 01:18:53 +0800
Subject: [PATCH 0731/1712] modify code

---
 src/class167/Code04_MarsStore1.java | 7 +++----
 src/class167/Code04_MarsStore2.java | 7 +++----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/class167/Code04_MarsStore1.java b/src/class167/Code04_MarsStore1.java
index 3a46fb0cd..4c3b86841 100644
--- a/src/class167/Code04_MarsStore1.java
+++ b/src/class167/Code04_MarsStore1.java
@@ -13,8 +13,7 @@
 public class Code04_MarsStore1 {
 
 	public static int MAXN = 100001;
-	public static int MAXP = MAXN * 20;
-	public static int MAXT = 1000001;
+	public static int MAXT = 2000001;
 	public static int BIT = 16;
 	public static int n, m, t;
 
@@ -29,8 +28,8 @@ public class Code04_MarsStore1 {
 	public static int[] tim = new int[MAXN];
 
 	public static int[] root = new int[MAXN];
-	public static int[][] tree = new int[MAXP][2];
-	public static int[] pass = new int[MAXP];
+	public static int[][] tree = new int[MAXT][2];
+	public static int[] pass = new int[MAXT];
 	public static int cntt = 0;
 
 	public static int[] headp = new int[MAXN << 2];
diff --git a/src/class167/Code04_MarsStore2.java b/src/class167/Code04_MarsStore2.java
index a60826f81..7c9e60a8b 100644
--- a/src/class167/Code04_MarsStore2.java
+++ b/src/class167/Code04_MarsStore2.java
@@ -18,8 +18,7 @@
 //}
 //
 //const int MAXN = 100001;
-//const int MAXP = MAXN * 20;
-//const int MAXT = 1000001;
+//const int MAXT = 2000001;
 //const int BIT = 16;
 //int n, m, t;
 //
@@ -34,8 +33,8 @@
 //int tim[MAXN];
 //
 //int root[MAXN];
-//int tree[MAXP][2];
-//int pass[MAXP];
+//int tree[MAXT][2];
+//int pass[MAXT];
 //int cntt;
 //
 //int headp[MAXN << 2];

From 3b50129d506b2ae45c76bc2a6b6031f451a3220d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 1 May 2025 19:09:55 +0800
Subject: [PATCH 0732/1712] modify code

---
 src/class167/Code03_MinimumXor1.java | 125 +++++++++++++++++++++++++++
 1 file changed, 125 insertions(+)
 create mode 100644 src/class167/Code03_MinimumXor1.java

diff --git a/src/class167/Code03_MinimumXor1.java b/src/class167/Code03_MinimumXor1.java
new file mode 100644
index 000000000..094d3befd
--- /dev/null
+++ b/src/class167/Code03_MinimumXor1.java
@@ -0,0 +1,125 @@
+package class167;
+
+// 最小异或查询，java版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_abc308_g
+// 测试链接 : https://atcoder.jp/contests/abc308/tasks/abc308_g
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_MinimumXor1 {
+
+	public static int MAXN = 10000001;
+	public static int BIT = 29;
+	public static int INF = 1 << 30;
+
+	public static int[] fa = new int[MAXN];
+	public static int[][] tree = new int[MAXN][2];
+	public static int[] pass = new int[MAXN];
+	public static int[] eor = new int[MAXN];
+	public static int[] data = new int[MAXN];
+	public static int cnt = 1;
+
+	public static int insert(int num, int changeCnt) {
+		int cur = 1;
+		pass[cur] += changeCnt;
+		for (int b = BIT, path; b >= 0; b--) {
+			path = (num >> b) & 1;
+			if (tree[cur][path] == 0) {
+				tree[cur][path] = ++cnt;
+				fa[tree[cur][path]] = cur;
+			}
+			cur = tree[cur][path];
+			pass[cur] += changeCnt;
+		}
+		eor[cur] = (pass[cur] >= 2 ? 0 : INF);
+		data[cur] = (pass[cur] == 1 ? num : 0);
+		return cur;
+	}
+
+	public static void compute(int num, int changeCnt) {
+		int bottom = insert(num, changeCnt);
+		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
+			l = tree[i][0];
+			r = tree[i][1];
+			if (pass[i] < 2) {
+				eor[i] = INF;
+			} else if ((l > 0 ? 1 : 0) + (r > 0 ? 1 : 0) == 1) {
+				eor[i] = (l > 0 ? eor[l] : eor[r]);
+			} else if (Math.max(pass[l], pass[r]) == 1) {
+				eor[i] = data[l] ^ data[r];
+			} else {
+				eor[i] = Math.min(eor[l], eor[r]);
+			}
+			if (pass[l] + pass[r] == 1) {
+				data[i] = (pass[l] == 1 ? data[l] : data[r]);
+			} else {
+				data[i] = 0;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		int q = in.nextInt();
+		for (int i = 1, op, num; i <= q; i++) {
+			op = in.nextInt();
+			if (op == 3) {
+				out.println(eor[1]);
+			} else {
+				num = in.nextInt();
+				if (op == 1) {
+					compute(num, 1);
+				} else {
+					compute(num, -1);
+				}
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file

From 6ee239f76754c5043e5c43792886a5fb3e5a4f75 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 1 May 2025 19:58:00 +0800
Subject: [PATCH 0733/1712] modify code

---
 src/class167/Code03_MinimumXor1.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code03_MinimumXor1.java b/src/class167/Code03_MinimumXor1.java
index 094d3befd..4c203ec67 100644
--- a/src/class167/Code03_MinimumXor1.java
+++ b/src/class167/Code03_MinimumXor1.java
@@ -19,9 +19,10 @@ public class Code03_MinimumXor1 {
 	public static int[] fa = new int[MAXN];
 	public static int[][] tree = new int[MAXN][2];
 	public static int[] pass = new int[MAXN];
+	public static int cnt = 1;
+
 	public static int[] eor = new int[MAXN];
 	public static int[] data = new int[MAXN];
-	public static int cnt = 1;
 
 	public static int insert(int num, int changeCnt) {
 		int cur = 1;
@@ -35,19 +36,19 @@ public static int insert(int num, int changeCnt) {
 			cur = tree[cur][path];
 			pass[cur] += changeCnt;
 		}
-		eor[cur] = (pass[cur] >= 2 ? 0 : INF);
-		data[cur] = (pass[cur] == 1 ? num : 0);
 		return cur;
 	}
 
 	public static void compute(int num, int changeCnt) {
 		int bottom = insert(num, changeCnt);
+		eor[bottom] = (pass[bottom] >= 2 ? 0 : INF);
+		data[bottom] = (pass[bottom] == 1 ? num : 0);
 		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 			l = tree[i][0];
 			r = tree[i][1];
 			if (pass[i] < 2) {
 				eor[i] = INF;
-			} else if ((l > 0 ? 1 : 0) + (r > 0 ? 1 : 0) == 1) {
+			} else if (l != 0 ^ r != 0) {
 				eor[i] = (l > 0 ? eor[l] : eor[r]);
 			} else if (Math.max(pass[l], pass[r]) == 1) {
 				eor[i] = data[l] ^ data[r];

From edf6835e8448f8d2d9f2016e70095f7923821c4a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 1 May 2025 20:05:26 +0800
Subject: [PATCH 0734/1712] modify code

---
 src/class167/Code03_MinimumXor1.java | 26 ++++-----
 src/class167/Code03_MinimumXor2.java | 83 ++++++++++++++++++++++++++++
 2 files changed, 96 insertions(+), 13 deletions(-)
 create mode 100644 src/class167/Code03_MinimumXor2.java

diff --git a/src/class167/Code03_MinimumXor1.java b/src/class167/Code03_MinimumXor1.java
index 4c203ec67..ff4ce0cb7 100644
--- a/src/class167/Code03_MinimumXor1.java
+++ b/src/class167/Code03_MinimumXor1.java
@@ -22,13 +22,13 @@ public class Code03_MinimumXor1 {
 	public static int cnt = 1;
 
 	public static int[] eor = new int[MAXN];
-	public static int[] data = new int[MAXN];
+	public static int[] num = new int[MAXN];
 
-	public static int insert(int num, int changeCnt) {
+	public static int insert(int x, int changeCnt) {
 		int cur = 1;
 		pass[cur] += changeCnt;
 		for (int b = BIT, path; b >= 0; b--) {
-			path = (num >> b) & 1;
+			path = (x >> b) & 1;
 			if (tree[cur][path] == 0) {
 				tree[cur][path] = ++cnt;
 				fa[tree[cur][path]] = cur;
@@ -39,10 +39,10 @@ public static int insert(int num, int changeCnt) {
 		return cur;
 	}
 
-	public static void compute(int num, int changeCnt) {
-		int bottom = insert(num, changeCnt);
+	public static void compute(int x, int changeCnt) {
+		int bottom = insert(x, changeCnt);
 		eor[bottom] = (pass[bottom] >= 2 ? 0 : INF);
-		data[bottom] = (pass[bottom] == 1 ? num : 0);
+		num[bottom] = (pass[bottom] == 1 ? x : 0);
 		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 			l = tree[i][0];
 			r = tree[i][1];
@@ -51,14 +51,14 @@ public static void compute(int num, int changeCnt) {
 			} else if (l != 0 ^ r != 0) {
 				eor[i] = (l > 0 ? eor[l] : eor[r]);
 			} else if (Math.max(pass[l], pass[r]) == 1) {
-				eor[i] = data[l] ^ data[r];
+				eor[i] = num[l] ^ num[r];
 			} else {
 				eor[i] = Math.min(eor[l], eor[r]);
 			}
 			if (pass[l] + pass[r] == 1) {
-				data[i] = (pass[l] == 1 ? data[l] : data[r]);
+				num[i] = (pass[l] == 1 ? num[l] : num[r]);
 			} else {
-				data[i] = 0;
+				num[i] = 0;
 			}
 		}
 	}
@@ -67,16 +67,16 @@ public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		int q = in.nextInt();
-		for (int i = 1, op, num; i <= q; i++) {
+		for (int i = 1, op, x; i <= q; i++) {
 			op = in.nextInt();
 			if (op == 3) {
 				out.println(eor[1]);
 			} else {
-				num = in.nextInt();
+				x = in.nextInt();
 				if (op == 1) {
-					compute(num, 1);
+					compute(x, 1);
 				} else {
-					compute(num, -1);
+					compute(x, -1);
 				}
 			}
 		}
diff --git a/src/class167/Code03_MinimumXor2.java b/src/class167/Code03_MinimumXor2.java
new file mode 100644
index 000000000..a9634289b
--- /dev/null
+++ b/src/class167/Code03_MinimumXor2.java
@@ -0,0 +1,83 @@
+package class167;
+
+// 最小异或查询，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_abc308_g
+// 测试链接 : https://atcoder.jp/contests/abc308/tasks/abc308_g
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 10000001;
+//const int BIT = 29;
+//const int INF = 1 << 30;
+//
+//int fa[MAXN];
+//int tree[MAXN][2];
+//int pass[MAXN];
+//int cnt = 1;
+//
+//int eor[MAXN];
+//int num[MAXN];
+//
+//int insert(int x, int changeCnt) {
+//    int cur = 1;
+//    pass[cur] += changeCnt;
+//    for (int b = BIT, path; b >= 0; b--) {
+//        path = (x >> b) & 1;
+//        if (tree[cur][path] == 0) {
+//            tree[cur][path] = ++cnt;
+//            fa[tree[cur][path]] = cur;
+//        }
+//        cur = tree[cur][path];
+//        pass[cur] += changeCnt;
+//    }
+//    return cur;
+//}
+//
+//void compute(int x, int changeCnt) {
+//    int bottom = insert(x, changeCnt);
+//    eor[bottom] = (pass[bottom] >= 2 ? 0 : INF);
+//    num[bottom] = (pass[bottom] == 1 ? x : 0);
+//    for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
+//        l = tree[i][0];
+//        r = tree[i][1];
+//        if (pass[i] < 2) {
+//            eor[i] = INF;
+//        } else if ((l != 0) ^ (r != 0)) {
+//            eor[i] = (l > 0 ? eor[l] : eor[r]);
+//        } else if (max(pass[l], pass[r]) == 1) {
+//            eor[i] = num[l] ^ num[r];
+//        } else {
+//            eor[i] = min(eor[l], eor[r]);
+//        }
+//        if (pass[l] + pass[r] == 1) {
+//        	num[i] = (pass[l] == 1 ? num[l] : num[r]);
+//        } else {
+//        	num[i] = 0;
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int q;
+//    cin >> q;
+//    for (int i = 1, op, x; i <= q; i++) {
+//        cin >> op;
+//        if (op == 3) {
+//            cout << eor[1] << '\n';
+//        } else {
+//            cin >> x;
+//            if (op == 1) {
+//                compute(x, 1);
+//            } else {
+//                compute(x, -1);
+//            }
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 139492d6e6f5c66d3fc2316642f97b5f41f1d9cd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 1 May 2025 20:09:54 +0800
Subject: [PATCH 0735/1712] modify code

---
 src/class167/Code03_MinimumXor1.java | 10 +++++-----
 src/class167/Code03_MinimumXor2.java |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class167/Code03_MinimumXor1.java b/src/class167/Code03_MinimumXor1.java
index ff4ce0cb7..8b34db95d 100644
--- a/src/class167/Code03_MinimumXor1.java
+++ b/src/class167/Code03_MinimumXor1.java
@@ -41,22 +41,22 @@ public static int insert(int x, int changeCnt) {
 
 	public static void compute(int x, int changeCnt) {
 		int bottom = insert(x, changeCnt);
-		eor[bottom] = (pass[bottom] >= 2 ? 0 : INF);
-		num[bottom] = (pass[bottom] == 1 ? x : 0);
+		eor[bottom] = pass[bottom] >= 2 ? 0 : INF;
+		num[bottom] = pass[bottom] == 1 ? x : 0;
 		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 			l = tree[i][0];
 			r = tree[i][1];
 			if (pass[i] < 2) {
 				eor[i] = INF;
-			} else if (l != 0 ^ r != 0) {
-				eor[i] = (l > 0 ? eor[l] : eor[r]);
+			} else if ((l != 0) ^ (r != 0)) {
+				eor[i] = l > 0 ? eor[l] : eor[r];
 			} else if (Math.max(pass[l], pass[r]) == 1) {
 				eor[i] = num[l] ^ num[r];
 			} else {
 				eor[i] = Math.min(eor[l], eor[r]);
 			}
 			if (pass[l] + pass[r] == 1) {
-				num[i] = (pass[l] == 1 ? num[l] : num[r]);
+				num[i] = pass[l] == 1 ? num[l] : num[r];
 			} else {
 				num[i] = 0;
 			}
diff --git a/src/class167/Code03_MinimumXor2.java b/src/class167/Code03_MinimumXor2.java
index a9634289b..378dd3df0 100644
--- a/src/class167/Code03_MinimumXor2.java
+++ b/src/class167/Code03_MinimumXor2.java
@@ -39,22 +39,22 @@
 //
 //void compute(int x, int changeCnt) {
 //    int bottom = insert(x, changeCnt);
-//    eor[bottom] = (pass[bottom] >= 2 ? 0 : INF);
-//    num[bottom] = (pass[bottom] == 1 ? x : 0);
+//    eor[bottom] = pass[bottom] >= 2 ? 0 : INF;
+//    num[bottom] = pass[bottom] == 1 ? x : 0;
 //    for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 //        l = tree[i][0];
 //        r = tree[i][1];
 //        if (pass[i] < 2) {
 //            eor[i] = INF;
 //        } else if ((l != 0) ^ (r != 0)) {
-//            eor[i] = (l > 0 ? eor[l] : eor[r]);
+//            eor[i] = l > 0 ? eor[l] : eor[r];
 //        } else if (max(pass[l], pass[r]) == 1) {
 //            eor[i] = num[l] ^ num[r];
 //        } else {
 //            eor[i] = min(eor[l], eor[r]);
 //        }
 //        if (pass[l] + pass[r] == 1) {
-//        	num[i] = (pass[l] == 1 ? num[l] : num[r]);
+//        	num[i] = pass[l] == 1 ? num[l] : num[r];
 //        } else {
 //        	num[i] = 0;
 //        }

From c8c2f3fa3bd67eae7b53c0dd7e8d02b003c26515 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 2 May 2025 13:21:58 +0800
Subject: [PATCH 0736/1712] modify code

---
 src/class167/Code05_AdditionOnSegments1.java | 206 +++++++++++++++++++
 src/class167/Code05_AdditionOnSegments2.java | 153 ++++++++++++++
 2 files changed, 359 insertions(+)
 create mode 100644 src/class167/Code05_AdditionOnSegments1.java
 create mode 100644 src/class167/Code05_AdditionOnSegments2.java

diff --git a/src/class167/Code05_AdditionOnSegments1.java b/src/class167/Code05_AdditionOnSegments1.java
new file mode 100644
index 000000000..6e05a129a
--- /dev/null
+++ b/src/class167/Code05_AdditionOnSegments1.java
@@ -0,0 +1,206 @@
+package class167;
+
+// 能达到的最大值，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF981E
+// 测试链接 : https://codeforces.com/problemset/problem/981/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code05_AdditionOnSegments1 {
+
+	public static int MAXN = 10001;
+	public static int MAXT = 500001;
+	public static int BIT = 10000;
+	public static int INTBIT = 32;
+	public static int LEN = (BIT + INTBIT - 1) / INTBIT;
+	public static int n, q;
+
+	public static int[] help = new int[LEN];
+	public static int[] path = new int[LEN];
+	public static int[] ans = new int[LEN];
+
+	public static int[] head = new int[MAXN << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] to = new int[MAXT];
+	public static int cnt = 0;
+
+	// 清空位图
+	public static void clear(int[] bitset) {
+		for (int i = 0; i < LEN; i++) {
+			bitset[i] = 0;
+		}
+	}
+
+	// 位图set1 拷贝 位图set2的所有状态
+	public static void clone(int[] set1, int[] set2) {
+		for (int i = 0; i < LEN; i++) {
+			set1[i] = set2[i];
+		}
+	}
+
+	// 返回位图第i位的状态
+	public static int getBit(int[] bitset, int i) {
+		return (bitset[i / INTBIT] >> (i % INTBIT)) & 1;
+	}
+
+	// 第i位的状态设置成v
+	public static void setBit(int[] bitset, int i, int v) {
+		if (v == 0) {
+			bitset[i / INTBIT] &= ~(1 << (i % INTBIT));
+		} else {
+			bitset[i / INTBIT] |= 1 << (i % INTBIT);
+		}
+	}
+
+	// 位图set1 或 位图set2的所有状态
+	public static void bitOr(int[] set1, int[] set2) {
+		for (int i = 0; i < LEN; i++) {
+			set1[i] |= set2[i];
+		}
+	}
+
+	// 位图ret 变成 位图bitset左移left位之后的状态
+	// 不使用一位一位拷贝的方式，因为太慢了
+	// 采用整块左移的方式，这样比较快
+	public static void bitLeft(int[] ret, int[] bitset, int left) {
+		clear(ret);
+		if (left >= BIT) {
+			return;
+		}
+		if (left <= 0) {
+			clone(ret, bitset);
+			return;
+		}
+		int shift = left / INTBIT;
+		int offset = left % INTBIT;
+		if (offset == 0) {
+			for (int i = LEN - 1; i >= shift; i--) {
+				ret[i] = bitset[i - shift];
+			}
+		} else {
+			int carry = INTBIT - offset, high, low;
+			for (int i = LEN - 1; i > shift; i--) {
+				high = bitset[i - shift] << offset;
+				low = bitset[i - shift - 1] >>> carry;
+				ret[i] = high | low;
+			}
+			ret[shift] = bitset[0] << offset;
+		}
+		int extra = LEN * INTBIT - BIT - 1;
+		if (extra > 0) {
+			int mask = -1 >>> extra;
+			ret[LEN - 1] &= mask;
+		}
+	}
+
+	public static void addEdge(int i, int v) {
+		next[++cnt] = head[i];
+		to[cnt] = v;
+		head[i] = cnt;
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobv);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int[] backup = new int[LEN];
+		clone(backup, path);
+		for (int e = head[i]; e > 0; e = next[e]) {
+			bitLeft(help, path, to[e]);
+			bitOr(path, help);
+		}
+		if (l == r) {
+			bitOr(ans, path);
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+		clone(path, backup);
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1, l, r, k; i <= q; i++) {
+			l = in.nextInt();
+			r = in.nextInt();
+			k = in.nextInt();
+			add(l, r, k, 1, n, 1);
+		}
+		setBit(path, 0, 1);
+		dfs(1, n, 1);
+		int ansCnt = 0;
+		for (int i = 1; i <= n; i++) {
+			if (getBit(ans, i) == 1) {
+				ansCnt++;
+			}
+		}
+		out.println(ansCnt);
+		for (int i = 1; i <= n; i++) {
+			if (getBit(ans, i) == 1) {
+				out.print(i + " ");
+			}
+		}
+		out.println();
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class167/Code05_AdditionOnSegments2.java b/src/class167/Code05_AdditionOnSegments2.java
new file mode 100644
index 000000000..7ee88aff3
--- /dev/null
+++ b/src/class167/Code05_AdditionOnSegments2.java
@@ -0,0 +1,153 @@
+package class167;
+
+// 能达到的最大值，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF981E
+// 测试链接 : https://codeforces.com/problemset/problem/981/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//using ui = unsigned int;
+//
+//const int MAXN = 10001;
+//const int MAXT = 500001;
+//const int BIT = 10000;
+//const int INTBIT = 32;
+//const int LEN = (BIT + INTBIT - 1) / INTBIT;
+//int n, q;
+//
+//ui help[LEN];
+//ui path[LEN];
+//ui ans[LEN];
+//
+//int head[MAXN << 2];
+//int nxt[MAXT];
+//int to[MAXT];
+//int cnt = 0;
+//
+//void clear(ui* bitset) {
+//    for (int i = 0; i < LEN; i++) {
+//        bitset[i] = 0;
+//    }
+//}
+//
+//void clone(ui* set1, ui* set2) {
+//    for (int i = 0; i < LEN; i++) {
+//        set1[i] = set2[i];
+//    }
+//}
+//
+//int getBit(ui* bitset, int i) {
+//    return (bitset[i / INTBIT] >> (i % INTBIT)) & 1;
+//}
+//
+//void setBit(ui* bitset, int i, int v) {
+//    if (v == 0) {
+//        bitset[i / INTBIT] &= ~(1u << (i % INTBIT));
+//    } else {
+//        bitset[i / INTBIT] |= 1u << (i % INTBIT);
+//    }
+//}
+//
+//void bitOr(ui* set1, ui* set2) {
+//    for (int i = 0; i < LEN; i++) {
+//        set1[i] |= set2[i];
+//    }
+//}
+//
+//void bitLeft(ui* ret, ui* bitset, int left) {
+//    clear(ret);
+//    if (left >= BIT) {
+//        return;
+//    }
+//    if (left <= 0) {
+//        clone(ret, bitset);
+//        return;
+//    }
+//    int shift = left / INTBIT;
+//    int offset = left % INTBIT;
+//    if (offset == 0) {
+//        for (int i = LEN - 1; i >= shift; i--) {
+//            ret[i] = bitset[i - shift];
+//        }
+//    } else {
+//        int carry = INTBIT - offset;
+//        for (int i = LEN - 1; i > shift; i--) {
+//            ui high = bitset[i - shift] << offset;
+//            ui low = bitset[i - shift - 1] >> carry;
+//            ret[i] = high | low;
+//        }
+//        ret[shift] = bitset[0] << offset;
+//    }
+//    int extra = LEN * INTBIT - BIT - 1;
+//    if (extra > 0) {
+//        ui mask = ~0u >> extra;
+//        ret[LEN - 1] &= mask;
+//    }
+//}
+//
+//void addEdge(int i, int v) {
+//    nxt[++cnt] = head[i];
+//    to[cnt] = v;
+//    head[i] = cnt;
+//}
+//
+//void add(int jobl, int jobr, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobv);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i) {
+//    ui backup[LEN];
+//    clone(backup, path);
+//    for (int e = head[i]; e > 0; e = nxt[e]) {
+//        bitLeft(help, path, to[e]);
+//        bitOr(path, help);
+//    }
+//    if (l == r) {
+//        bitOr(ans, path);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//    clone(path, backup);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1, l, r, k; i <= q; i++) {
+//        cin >> l >> r >> k;
+//        add(l, r, k, 1, n, 1);
+//    }
+//    setBit(path, 0, 1);
+//    dfs(1, n, 1);
+//    int ansCnt = 0;
+//    for (int i = 1; i <= n; i++) {
+//        if (getBit(ans, i) == 1) {
+//            ansCnt++;
+//        }
+//    }
+//    cout << ansCnt << '\n';
+//    for (int i = 1; i <= n; i++) {
+//        if (getBit(ans, i) == 1) {
+//            cout << i << ' ';
+//        }
+//    }
+//    cout << '\n';
+//    return 0;
+//}
\ No newline at end of file

From d1c8f7899711fa4587355ef114164fd216f0875a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 2 May 2025 14:10:43 +0800
Subject: [PATCH 0737/1712] modify code

---
 .../Code02_EightVerticalHorizontal1.java      | 20 +++++++++--------
 .../Code02_EightVerticalHorizontal2.java      | 22 ++++++++++---------
 src/class167/Code05_AdditionOnSegments1.java  | 10 ++++-----
 src/class167/Code05_AdditionOnSegments2.java  |  2 +-
 4 files changed, 29 insertions(+), 25 deletions(-)

diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code02_EightVerticalHorizontal1.java
index ba2398bad..8b527e9bc 100644
--- a/src/class167/Code02_EightVerticalHorizontal1.java
+++ b/src/class167/Code02_EightVerticalHorizontal1.java
@@ -11,6 +11,12 @@
 
 public class Code02_EightVerticalHorizontal1 {
 
+	public static int MAXN = 501;
+	public static int MAXQ = 1001;
+	public static int MAXT = 10001;
+	public static int BIT = 1000;
+	public static int INTBIT = 32;
+
 	// 位图
 	static class BitSet {
 
@@ -19,12 +25,12 @@ static class BitSet {
 		public int[] arr;
 
 		public BitSet() {
-			len = (1000 + 31) / 32;
+			len = BIT / INTBIT + 1;
 			arr = new int[len];
 		}
 
 		public BitSet(String s) {
-			len = (1000 + 31) / 32;
+			len = BIT / INTBIT + 1;
 			arr = new int[len];
 			for (int i = 0, j = s.length() - 1; i < s.length(); i++, j--) {
 				set(i, s.charAt(j) - '0');
@@ -33,15 +39,15 @@ public BitSet(String s) {
 
 		// 返回第i位的状态
 		public int get(int i) {
-			return (arr[i / 32] >> (i % 32)) & 1;
+			return (arr[i / INTBIT] >> (i % INTBIT)) & 1;
 		}
 
 		// 设置第i位的状态
 		public void set(int i, int v) {
 			if (v == 0) {
-				arr[i / 32] &= ~(1 << (i % 32));
+				arr[i / INTBIT] &= ~(1 << (i % INTBIT));
 			} else {
-				arr[i / 32] |= 1 << (i % 32);
+				arr[i / INTBIT] |= 1 << (i % INTBIT);
 			}
 		}
 
@@ -68,10 +74,6 @@ public void clear() {
 
 	}
 
-	public static int MAXN = 501;
-	public static int MAXQ = 1001;
-	public static int MAXT = 10001;
-	public static int BIT = 999;
 	public static int n, m, q;
 
 	// 记录每条操作
diff --git a/src/class167/Code02_EightVerticalHorizontal2.java b/src/class167/Code02_EightVerticalHorizontal2.java
index 4335a3d7c..a3fcd630a 100644
--- a/src/class167/Code02_EightVerticalHorizontal2.java
+++ b/src/class167/Code02_EightVerticalHorizontal2.java
@@ -9,17 +9,23 @@
 //
 //using namespace std;
 //
+//const int MAXN = 501;
+//const int MAXQ = 1001;
+//const int MAXT = 10001;
+//const int BIT = 1000;
+//const int INTBIT = 32;
+//
 //struct BitSet {
 //    int len;
 //    vector<int> arr;
 //
 //    BitSet() {
-//        len = (1000 + 31) / 32;
+//        len = BIT / INTBIT + 1;
 //        arr.assign(len, 0);
 //    }
 //
 //    BitSet(const string& s) {
-//        len = (1000 + 31) / 32;
+//        len = BIT / INTBIT + 1;
 //        arr.assign(len, 0);
 //        for (int i = 0, j = (int)s.size() - 1; i < (int)s.size(); i++, j--) {
 //            set(i, s[j] - '0');
@@ -27,14 +33,14 @@
 //    }
 //
 //    int get(int i) const {
-//        return (arr[i / 32] >> (i % 32)) & 1;
+//        return (arr[i / INTBIT] >> (i % INTBIT)) & 1;
 //    }
 //
 //    void set(int i, int v) {
 //        if (v) {
-//            arr[i / 32] |= 1 << (i % 32);
+//            arr[i / INTBIT] |= 1 << (i % INTBIT);
 //        } else {
-//            arr[i / 32] &= ~(1 << (i % 32));
+//            arr[i / INTBIT] &= ~(1 << (i % INTBIT));
 //        }
 //    }
 //
@@ -53,12 +59,8 @@
 //    }
 //};
 //
-//const int MAXN = 501;
-//const int MAXQ = 1001;
-//const int MAXT = 10001;
-//const int BIT = 999;
-//
 //int n, m, q;
+//
 //int x[MAXQ];
 //int y[MAXQ];
 //BitSet w[MAXQ];
diff --git a/src/class167/Code05_AdditionOnSegments1.java b/src/class167/Code05_AdditionOnSegments1.java
index 6e05a129a..5e9a5bc72 100644
--- a/src/class167/Code05_AdditionOnSegments1.java
+++ b/src/class167/Code05_AdditionOnSegments1.java
@@ -16,7 +16,7 @@ public class Code05_AdditionOnSegments1 {
 	public static int MAXT = 500001;
 	public static int BIT = 10000;
 	public static int INTBIT = 32;
-	public static int LEN = (BIT + INTBIT - 1) / INTBIT;
+	public static int LEN = BIT / INTBIT + 1;
 	public static int n, q;
 
 	public static int[] help = new int[LEN];
@@ -28,14 +28,14 @@ public class Code05_AdditionOnSegments1 {
 	public static int[] to = new int[MAXT];
 	public static int cnt = 0;
 
-	// 清空位图
+	// 清空
 	public static void clear(int[] bitset) {
 		for (int i = 0; i < LEN; i++) {
 			bitset[i] = 0;
 		}
 	}
 
-	// 位图set1 拷贝 位图set2的所有状态
+	// 位图set1 拷贝 位图set2
 	public static void clone(int[] set1, int[] set2) {
 		for (int i = 0; i < LEN; i++) {
 			set1[i] = set2[i];
@@ -56,14 +56,14 @@ public static void setBit(int[] bitset, int i, int v) {
 		}
 	}
 
-	// 位图set1 或 位图set2的所有状态
+	// 位图set1 或 位图set2
 	public static void bitOr(int[] set1, int[] set2) {
 		for (int i = 0; i < LEN; i++) {
 			set1[i] |= set2[i];
 		}
 	}
 
-	// 位图ret 变成 位图bitset左移left位之后的状态
+	// 位图ret 变成 位图bitset左移left之后的状态
 	// 不使用一位一位拷贝的方式，因为太慢了
 	// 采用整块左移的方式，这样比较快
 	public static void bitLeft(int[] ret, int[] bitset, int left) {
diff --git a/src/class167/Code05_AdditionOnSegments2.java b/src/class167/Code05_AdditionOnSegments2.java
index 7ee88aff3..3ca7b4ee9 100644
--- a/src/class167/Code05_AdditionOnSegments2.java
+++ b/src/class167/Code05_AdditionOnSegments2.java
@@ -16,7 +16,7 @@
 //const int MAXT = 500001;
 //const int BIT = 10000;
 //const int INTBIT = 32;
-//const int LEN = (BIT + INTBIT - 1) / INTBIT;
+//const int LEN = BIT / INTBIT + 1;
 //int n, q;
 //
 //ui help[LEN];

From d6b00d1f18a2db1a17f27c8b603d159c2eb58dc8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 2 May 2025 21:47:27 +0800
Subject: [PATCH 0738/1712] modify code

---
 src/class167/Code05_AdditionOnSegments1.java | 50 ++++++++++----------
 src/class167/Code05_AdditionOnSegments2.java | 48 +++++++++----------
 2 files changed, 49 insertions(+), 49 deletions(-)

diff --git a/src/class167/Code05_AdditionOnSegments1.java b/src/class167/Code05_AdditionOnSegments1.java
index 5e9a5bc72..8535e7d67 100644
--- a/src/class167/Code05_AdditionOnSegments1.java
+++ b/src/class167/Code05_AdditionOnSegments1.java
@@ -17,17 +17,19 @@ public class Code05_AdditionOnSegments1 {
 	public static int BIT = 10000;
 	public static int INTBIT = 32;
 	public static int LEN = BIT / INTBIT + 1;
+	public static int DEEP = 20;
 	public static int n, q;
 
-	public static int[] help = new int[LEN];
-	public static int[] path = new int[LEN];
-	public static int[] ans = new int[LEN];
-
 	public static int[] head = new int[MAXN << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] to = new int[MAXT];
 	public static int cnt = 0;
 
+	public static int[] tmp = new int[LEN];
+	public static int[] path = new int[LEN];
+	public static int[][] backup = new int[DEEP][LEN];
+	public static int[] ans = new int[LEN];
+
 	// 清空
 	public static void clear(int[] bitset) {
 		for (int i = 0; i < LEN; i++) {
@@ -63,23 +65,23 @@ public static void bitOr(int[] set1, int[] set2) {
 		}
 	}
 
-	// 位图ret 变成 位图bitset左移left之后的状态
+	// 位图ret 变成 位图bitset左移move位的状态
 	// 不使用一位一位拷贝的方式，因为太慢了
 	// 采用整块左移的方式，这样比较快
-	public static void bitLeft(int[] ret, int[] bitset, int left) {
+	public static void bitLeft(int[] ret, int[] bitset, int move) {
 		clear(ret);
-		if (left >= BIT) {
+		if (move > BIT) {
 			return;
 		}
-		if (left <= 0) {
+		if (move <= 0) {
 			clone(ret, bitset);
 			return;
 		}
-		int shift = left / INTBIT;
-		int offset = left % INTBIT;
+		int shift = move / INTBIT;
+		int offset = move % INTBIT;
 		if (offset == 0) {
-			for (int i = LEN - 1; i >= shift; i--) {
-				ret[i] = bitset[i - shift];
+			for (int i = LEN - 1, j = i - shift; j >= 0; i--, j--) {
+				ret[i] = bitset[j];
 			}
 		} else {
 			int carry = INTBIT - offset, high, low;
@@ -90,10 +92,9 @@ public static void bitLeft(int[] ret, int[] bitset, int left) {
 			}
 			ret[shift] = bitset[0] << offset;
 		}
-		int extra = LEN * INTBIT - BIT - 1;
-		if (extra > 0) {
-			int mask = -1 >>> extra;
-			ret[LEN - 1] &= mask;
+		int rest = LEN * INTBIT - (BIT + 1);
+		if (rest > 0) {
+			ret[LEN - 1] &= (1 << (INTBIT - rest)) - 1;
 		}
 	}
 
@@ -117,21 +118,20 @@ public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
 		}
 	}
 
-	public static void dfs(int l, int r, int i) {
-		int[] backup = new int[LEN];
-		clone(backup, path);
+	public static void dfs(int l, int r, int i, int dep) {
+		clone(backup[dep], path);
 		for (int e = head[i]; e > 0; e = next[e]) {
-			bitLeft(help, path, to[e]);
-			bitOr(path, help);
+			bitLeft(tmp, path, to[e]);
+			bitOr(path, tmp);
 		}
 		if (l == r) {
 			bitOr(ans, path);
 		} else {
 			int mid = (l + r) >> 1;
-			dfs(l, mid, i << 1);
-			dfs(mid + 1, r, i << 1 | 1);
+			dfs(l, mid, i << 1, dep + 1);
+			dfs(mid + 1, r, i << 1 | 1, dep + 1);
 		}
-		clone(path, backup);
+		clone(path, backup[dep]);
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -146,7 +146,7 @@ public static void main(String[] args) throws Exception {
 			add(l, r, k, 1, n, 1);
 		}
 		setBit(path, 0, 1);
-		dfs(1, n, 1);
+		dfs(1, n, 1, 1);
 		int ansCnt = 0;
 		for (int i = 1; i <= n; i++) {
 			if (getBit(ans, i) == 1) {
diff --git a/src/class167/Code05_AdditionOnSegments2.java b/src/class167/Code05_AdditionOnSegments2.java
index 3ca7b4ee9..f51b0bff6 100644
--- a/src/class167/Code05_AdditionOnSegments2.java
+++ b/src/class167/Code05_AdditionOnSegments2.java
@@ -17,17 +17,19 @@
 //const int BIT = 10000;
 //const int INTBIT = 32;
 //const int LEN = BIT / INTBIT + 1;
+//const int DEEP = 20;
 //int n, q;
 //
-//ui help[LEN];
-//ui path[LEN];
-//ui ans[LEN];
-//
 //int head[MAXN << 2];
 //int nxt[MAXT];
 //int to[MAXT];
 //int cnt = 0;
 //
+//ui tmp[LEN];
+//ui path[LEN];
+//ui backup[DEEP][LEN];
+//ui ans[LEN];
+//
 //void clear(ui* bitset) {
 //    for (int i = 0; i < LEN; i++) {
 //        bitset[i] = 0;
@@ -58,20 +60,20 @@
 //    }
 //}
 //
-//void bitLeft(ui* ret, ui* bitset, int left) {
+//void bitLeft(ui* ret, ui* bitset, int move) {
 //    clear(ret);
-//    if (left >= BIT) {
+//    if (move > BIT) {
 //        return;
 //    }
-//    if (left <= 0) {
+//    if (move <= 0) {
 //        clone(ret, bitset);
 //        return;
 //    }
-//    int shift = left / INTBIT;
-//    int offset = left % INTBIT;
+//    int shift = move / INTBIT;
+//    int offset = move % INTBIT;
 //    if (offset == 0) {
-//        for (int i = LEN - 1; i >= shift; i--) {
-//            ret[i] = bitset[i - shift];
+//        for (int i = LEN - 1, j = i - shift; j >= 0; i--, j--) {
+//            ret[i] = bitset[j];
 //        }
 //    } else {
 //        int carry = INTBIT - offset;
@@ -82,10 +84,9 @@
 //        }
 //        ret[shift] = bitset[0] << offset;
 //    }
-//    int extra = LEN * INTBIT - BIT - 1;
-//    if (extra > 0) {
-//        ui mask = ~0u >> extra;
-//        ret[LEN - 1] &= mask;
+//    int rest = LEN * INTBIT - (BIT + 1);
+//    if (rest > 0) {
+//        ret[LEN - 1] &= (1u << (INTBIT - rest)) - 1u;
 //    }
 //}
 //
@@ -109,21 +110,20 @@
 //    }
 //}
 //
-//void dfs(int l, int r, int i) {
-//    ui backup[LEN];
-//    clone(backup, path);
+//void dfs(int l, int r, int i, int dep) {
+//    clone(backup[dep], path);
 //    for (int e = head[i]; e > 0; e = nxt[e]) {
-//        bitLeft(help, path, to[e]);
-//        bitOr(path, help);
+//        bitLeft(tmp, path, to[e]);
+//        bitOr(path, tmp);
 //    }
 //    if (l == r) {
 //        bitOr(ans, path);
 //    } else {
 //        int mid = (l + r) >> 1;
-//        dfs(l, mid, i << 1);
-//        dfs(mid + 1, r, i << 1 | 1);
+//        dfs(l, mid, i << 1, dep + 1);
+//        dfs(mid + 1, r, i << 1 | 1, dep + 1);
 //    }
-//    clone(path, backup);
+//    clone(path, backup[dep]);
 //}
 //
 //int main() {
@@ -135,7 +135,7 @@
 //        add(l, r, k, 1, n, 1);
 //    }
 //    setBit(path, 0, 1);
-//    dfs(1, n, 1);
+//    dfs(1, n, 1, 1);
 //    int ansCnt = 0;
 //    for (int i = 1; i <= n; i++) {
 //        if (getBit(ans, i) == 1) {

From d5e41fbcaa310ef1721d85d8836900cd2a4cb10b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 2 May 2025 22:35:47 +0800
Subject: [PATCH 0739/1712] modify code

---
 .../Code02_EightVerticalHorizontal1.java      |   2 -
 .../Code02_EightVerticalHorizontal2.java      | 157 ++++++------------
 2 files changed, 53 insertions(+), 106 deletions(-)

diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code02_EightVerticalHorizontal1.java
index 8b527e9bc..b1e0c53ab 100644
--- a/src/class167/Code02_EightVerticalHorizontal1.java
+++ b/src/class167/Code02_EightVerticalHorizontal1.java
@@ -75,8 +75,6 @@ public void clear() {
 	}
 
 	public static int n, m, q;
-
-	// 记录每条操作
 	public static int[] x = new int[MAXQ];
 	public static int[] y = new int[MAXQ];
 	public static BitSet[] w = new BitSet[MAXQ];
diff --git a/src/class167/Code02_EightVerticalHorizontal2.java b/src/class167/Code02_EightVerticalHorizontal2.java
index a3fcd630a..1def385ed 100644
--- a/src/class167/Code02_EightVerticalHorizontal2.java
+++ b/src/class167/Code02_EightVerticalHorizontal2.java
@@ -12,68 +12,24 @@
 //const int MAXN = 501;
 //const int MAXQ = 1001;
 //const int MAXT = 10001;
-//const int BIT = 1000;
-//const int INTBIT = 32;
+//const int BIT  = 1000;
 //
-//struct BitSet {
-//    int len;
-//    vector<int> arr;
-//
-//    BitSet() {
-//        len = BIT / INTBIT + 1;
-//        arr.assign(len, 0);
-//    }
-//
-//    BitSet(const string& s) {
-//        len = BIT / INTBIT + 1;
-//        arr.assign(len, 0);
-//        for (int i = 0, j = (int)s.size() - 1; i < (int)s.size(); i++, j--) {
-//            set(i, s[j] - '0');
-//        }
-//    }
-//
-//    int get(int i) const {
-//        return (arr[i / INTBIT] >> (i % INTBIT)) & 1;
-//    }
-//
-//    void set(int i, int v) {
-//        if (v) {
-//            arr[i / INTBIT] |= 1 << (i % INTBIT);
-//        } else {
-//            arr[i / INTBIT] &= ~(1 << (i % INTBIT));
-//        }
-//    }
-//
-//    void copy(const BitSet& other) {
-//        arr = other.arr;
-//    }
-//
-//    void eor(const BitSet& other) {
-//        for (int i = 0; i < len; i++) {
-//            arr[i] ^= other.arr[i];
-//        }
-//    }
-//
-//    void clear() {
-//        fill(arr.begin(), arr.end(), 0);
-//    }
-//};
+//typedef bitset<BIT + 1> bs;
 //
 //int n, m, q;
-//
 //int x[MAXQ];
 //int y[MAXQ];
-//BitSet w[MAXQ];
+//bs w[MAXQ];
 //int edgeCnt = 0;
 //int last[MAXQ];
 //
-//BitSet basis[BIT + 1];
+//bs basis[BIT + 1];
 //int inspos[BIT + 1];
 //int basiz = 0;
 //
 //int father[MAXN];
 //int siz[MAXN];
-//BitSet eor[MAXN];
+//bs eor[MAXN];
 //int rollback[MAXT][2];
 //int opsize = 0;
 //
@@ -81,63 +37,60 @@
 //int nxt[MAXT];
 //int tox[MAXT];
 //int toy[MAXT];
-//BitSet tow[MAXT];
+//bs tow[MAXT];
 //int cnt = 0;
 //
-//BitSet ans[MAXQ];
+//bs ans[MAXQ];
 //
-//void insert(BitSet num) {
-//    for (int i = BIT; i >= 0; i--) {
-//        if (num.get(i)) {
-//            if (basis[i].get(i) == 0) {
-//                basis[i].copy(num);
+//void insert(bs& num) {
+//    for (int i = BIT; i >= 0; --i) {
+//        if (num[i] == 1) {
+//            if (basis[i][i] == 0) {
+//                basis[i] = num;
 //                inspos[basiz++] = i;
 //                return;
 //            }
-//            num.eor(basis[i]);
+//            num ^= basis[i];
 //        }
 //    }
 //}
 //
-//BitSet maxEor() {
-//    BitSet res = BitSet();
+//bs maxEor() {
+//    bs ret;
 //    for (int i = BIT; i >= 0; i--) {
-//        if (res.get(i) == 0 && basis[i].get(i) == 1) {
-//            res.eor(basis[i]);
+//        if (ret[i] == 0 && basis[i][i] == 1) {
+//            ret ^= basis[i];
 //        }
 //    }
-//    return res;
+//    return ret;
 //}
 //
 //void cancel(int oldsiz) {
 //    while (basiz > oldsiz) {
-//        basis[inspos[--basiz]].clear();
+//        basis[inspos[--basiz]].reset();
 //    }
 //}
 //
-//int find(int i) {
-//    while (i != father[i]) {
-//        i = father[i];
+//int find(int v) {
+//    while (v != father[v]) {
+//        v = father[v];
 //    }
-//    return i;
+//    return v;
 //}
 //
-//BitSet getEor(int i) {
-//    BitSet res = BitSet();
-//    while (i != father[i]) {
-//        res.eor(eor[i]);
-//        i = father[i];
+//bs getEor(int v) {
+//    bs ret;
+//    while (v != father[v]) {
+//        ret ^= eor[v];
+//        v = father[v];
 //    }
-//    return res;
+//    return ret;
 //}
 //
-//bool Union(int u, int v, const BitSet& w) {
+//bool Union(int u, int v, bs& w) {
 //    int fu = find(u);
 //    int fv = find(v);
-//    BitSet weight = BitSet();
-//    weight.eor(getEor(u));
-//    weight.eor(getEor(v));
-//    weight.eor(w);
+//    bs weight = getEor(u) ^ getEor(v) ^ w;
 //    if (fu == fv) {
 //        insert(weight);
 //        return false;
@@ -149,7 +102,7 @@
 //    }
 //    father[fv] = fu;
 //    siz[fu] += siz[fv];
-//    eor[fv].copy(weight);
+//    eor[fv] = weight;
 //    rollback[++opsize][0] = fu;
 //    rollback[opsize][1] = fv;
 //    return true;
@@ -159,19 +112,19 @@
 //    int fu = rollback[opsize][0];
 //    int fv = rollback[opsize--][1];
 //    father[fv] = fv;
-//    eor[fv].clear();
+//    eor[fv].reset();
 //    siz[fu] -= siz[fv];
 //}
 //
-//void addEdge(int i, int u, int v, const BitSet& w) {
+//void addEdge(int i, int u, int v, bs& w) {
 //    nxt[++cnt] = head[i];
 //    tox[cnt] = u;
 //    toy[cnt] = v;
-//    tow[cnt].copy(w);
+//    tow[cnt] = w;
 //    head[i] = cnt;
 //}
 //
-//void add(int jobl, int jobr, int jobx, int joby, const BitSet& jobw, int l, int r, int i) {
+//void add(int jobl, int jobr, int jobx, int joby, bs& jobw, int l, int r, int i) {
 //    if (jobl <= l && r <= jobr) {
 //        addEdge(i, jobx, joby, jobw);
 //    } else {
@@ -188,9 +141,9 @@
 //void dfs(int l, int r, int i) {
 //    int oldsiz = basiz;
 //    int unionCnt = 0;
-//    for (int e = head[i]; e > 0; e = nxt[e]) {
+//    for (int e = head[i]; e; e = nxt[e]) {
 //        if (Union(tox[e], toy[e], tow[e])) {
-//            unionCnt++;
+//            ++unionCnt;
 //        }
 //    }
 //    if (l == r) {
@@ -206,15 +159,14 @@
 //    }
 //}
 //
-//void print(const BitSet& bs) {
+//void print(const bs& ret) {
 //    bool flag = false;
-//    for (int i = BIT, s; i >= 0; i--) {
-//        s = bs.get(i);
-//        if (s == 1) {
+//    for (int i = BIT; i >= 0; i--) {
+//        if (ret[i] == 1) {
 //            flag = true;
 //        }
 //        if (flag) {
-//            cout << s;
+//            cout << ret[i];
 //        }
 //    }
 //    if (!flag) {
@@ -227,19 +179,19 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m >> q;
-//    for (int i = 0; i <= BIT; i++) {
-//        basis[i] = BitSet();
+//    for (int i = 0; i <= BIT; ++i) {
+//        basis[i].reset();
 //    }
-//    for (int i = 1; i <= n; i++) {
+//    for (int i = 1; i <= n; ++i) {
 //        father[i] = i;
 //        siz[i] = 1;
-//        eor[i] = BitSet();
+//        eor[i].reset();
 //    }
 //    int u, v;
-//    string str;
-//    for (int i = 1; i <= m; i++) {
-//        cin >> u >> v >> str;
-//        Union(u, v, BitSet(str));
+//    bs weight;
+//    for (int i = 1; i <= m; ++i) {
+//        cin >> u >> v >> weight;
+//        Union(u, v, weight);
 //    }
 //    ans[0] = maxEor();
 //    string op;
@@ -248,9 +200,7 @@
 //        cin >> op;
 //        if (op == "Add") {
 //            ++edgeCnt;
-//            cin >> x[edgeCnt] >> y[edgeCnt];
-//            cin >> str;
-//            w[edgeCnt] = BitSet(str);
+//            cin >> x[edgeCnt] >> y[edgeCnt] >> w[edgeCnt];
 //            last[edgeCnt] = i;
 //        } else if (op == "Cancel") {
 //            cin >> k;
@@ -259,13 +209,12 @@
 //        } else {
 //            cin >> k;
 //            add(last[k], i - 1, x[k], y[k], w[k], 1, q, 1);
-//            cin >> str;
-//            w[k] = BitSet(str);
+//            cin >> w[k];
 //            last[k] = i;
 //        }
 //    }
 //    for (int i = 1; i <= edgeCnt; i++) {
-//        if (last[i] > 0) {
+//        if (last[i] != 0) {
 //            add(last[i], q, x[i], y[i], w[i], 1, q, 1);
 //        }
 //    }

From bb80a8b80a11dde327a2a519e5580b4780f84b8f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 2 May 2025 22:50:51 +0800
Subject: [PATCH 0740/1712] modify code

---
 src/class167/Code05_AdditionOnSegments2.java | 90 +++-----------------
 1 file changed, 13 insertions(+), 77 deletions(-)

diff --git a/src/class167/Code05_AdditionOnSegments2.java b/src/class167/Code05_AdditionOnSegments2.java
index f51b0bff6..3c7c5100c 100644
--- a/src/class167/Code05_AdditionOnSegments2.java
+++ b/src/class167/Code05_AdditionOnSegments2.java
@@ -10,85 +10,22 @@
 //
 //using namespace std;
 //
-//using ui = unsigned int;
-//
 //const int MAXN = 10001;
 //const int MAXT = 500001;
 //const int BIT = 10000;
-//const int INTBIT = 32;
-//const int LEN = BIT / INTBIT + 1;
 //const int DEEP = 20;
-//int n, q;
 //
+//typedef bitset<BIT + 1> bs;
+//
+//int n, q;
 //int head[MAXN << 2];
 //int nxt[MAXT];
 //int to[MAXT];
 //int cnt = 0;
 //
-//ui tmp[LEN];
-//ui path[LEN];
-//ui backup[DEEP][LEN];
-//ui ans[LEN];
-//
-//void clear(ui* bitset) {
-//    for (int i = 0; i < LEN; i++) {
-//        bitset[i] = 0;
-//    }
-//}
-//
-//void clone(ui* set1, ui* set2) {
-//    for (int i = 0; i < LEN; i++) {
-//        set1[i] = set2[i];
-//    }
-//}
-//
-//int getBit(ui* bitset, int i) {
-//    return (bitset[i / INTBIT] >> (i % INTBIT)) & 1;
-//}
-//
-//void setBit(ui* bitset, int i, int v) {
-//    if (v == 0) {
-//        bitset[i / INTBIT] &= ~(1u << (i % INTBIT));
-//    } else {
-//        bitset[i / INTBIT] |= 1u << (i % INTBIT);
-//    }
-//}
-//
-//void bitOr(ui* set1, ui* set2) {
-//    for (int i = 0; i < LEN; i++) {
-//        set1[i] |= set2[i];
-//    }
-//}
-//
-//void bitLeft(ui* ret, ui* bitset, int move) {
-//    clear(ret);
-//    if (move > BIT) {
-//        return;
-//    }
-//    if (move <= 0) {
-//        clone(ret, bitset);
-//        return;
-//    }
-//    int shift = move / INTBIT;
-//    int offset = move % INTBIT;
-//    if (offset == 0) {
-//        for (int i = LEN - 1, j = i - shift; j >= 0; i--, j--) {
-//            ret[i] = bitset[j];
-//        }
-//    } else {
-//        int carry = INTBIT - offset;
-//        for (int i = LEN - 1; i > shift; i--) {
-//            ui high = bitset[i - shift] << offset;
-//            ui low = bitset[i - shift - 1] >> carry;
-//            ret[i] = high | low;
-//        }
-//        ret[shift] = bitset[0] << offset;
-//    }
-//    int rest = LEN * INTBIT - (BIT + 1);
-//    if (rest > 0) {
-//        ret[LEN - 1] &= (1u << (INTBIT - rest)) - 1u;
-//    }
-//}
+//bs path;
+//bs backup[DEEP];
+//bs ans;
 //
 //void addEdge(int i, int v) {
 //    nxt[++cnt] = head[i];
@@ -111,19 +48,18 @@
 //}
 //
 //void dfs(int l, int r, int i, int dep) {
-//    clone(backup[dep], path);
+//    backup[dep] = path;
 //    for (int e = head[i]; e > 0; e = nxt[e]) {
-//        bitLeft(tmp, path, to[e]);
-//        bitOr(path, tmp);
+//        path |= path << to[e];
 //    }
 //    if (l == r) {
-//        bitOr(ans, path);
+//        ans |= path;
 //    } else {
 //        int mid = (l + r) >> 1;
 //        dfs(l, mid, i << 1, dep + 1);
 //        dfs(mid + 1, r, i << 1 | 1, dep + 1);
 //    }
-//    clone(path, backup[dep]);
+//    path = backup[dep];
 //}
 //
 //int main() {
@@ -134,17 +70,17 @@
 //        cin >> l >> r >> k;
 //        add(l, r, k, 1, n, 1);
 //    }
-//    setBit(path, 0, 1);
+//    path[0] = 1;
 //    dfs(1, n, 1, 1);
 //    int ansCnt = 0;
 //    for (int i = 1; i <= n; i++) {
-//        if (getBit(ans, i) == 1) {
+//        if (ans[i] == 1) {
 //            ansCnt++;
 //        }
 //    }
 //    cout << ansCnt << '\n';
 //    for (int i = 1; i <= n; i++) {
-//        if (getBit(ans, i) == 1) {
+//        if (ans[i] == 1) {
 //            cout << i << ' ';
 //        }
 //    }

From d8ab2b073d993095555495a4a975cc67f61a1544 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 10:56:36 +0800
Subject: [PATCH 0741/1712] modify code

---
 ...AdditionOnSegments1.java => Code01_AdditionOnSegments1.java} | 2 +-
 ...AdditionOnSegments2.java => Code01_AdditionOnSegments2.java} | 0
 ...ortestPathQueries1.java => Code04_ShortestPathQueries1.java} | 2 +-
 ...ortestPathQueries2.java => Code04_ShortestPathQueries2.java} | 0
 ...calHorizontal1.java => Code05_EightVerticalHorizontal1.java} | 2 +-
 ...calHorizontal2.java => Code05_EightVerticalHorizontal2.java} | 0
 .../{Code03_MinimumXor1.java => Code06_MinimumXor1.java}        | 2 +-
 .../{Code03_MinimumXor2.java => Code06_MinimumXor2.java}        | 0
 src/class167/{Code04_MarsStore1.java => Code07_MarsStore1.java} | 2 +-
 src/class167/{Code04_MarsStore2.java => Code07_MarsStore2.java} | 0
 10 files changed, 5 insertions(+), 5 deletions(-)
 rename src/class167/{Code05_AdditionOnSegments1.java => Code01_AdditionOnSegments1.java} (99%)
 rename src/class167/{Code05_AdditionOnSegments2.java => Code01_AdditionOnSegments2.java} (100%)
 rename src/class167/{Code01_ShortestPathQueries1.java => Code04_ShortestPathQueries1.java} (99%)
 rename src/class167/{Code01_ShortestPathQueries2.java => Code04_ShortestPathQueries2.java} (100%)
 rename src/class167/{Code02_EightVerticalHorizontal1.java => Code05_EightVerticalHorizontal1.java} (99%)
 rename src/class167/{Code02_EightVerticalHorizontal2.java => Code05_EightVerticalHorizontal2.java} (100%)
 rename src/class167/{Code03_MinimumXor1.java => Code06_MinimumXor1.java} (98%)
 rename src/class167/{Code03_MinimumXor2.java => Code06_MinimumXor2.java} (100%)
 rename src/class167/{Code04_MarsStore1.java => Code07_MarsStore1.java} (99%)
 rename src/class167/{Code04_MarsStore2.java => Code07_MarsStore2.java} (100%)

diff --git a/src/class167/Code05_AdditionOnSegments1.java b/src/class167/Code01_AdditionOnSegments1.java
similarity index 99%
rename from src/class167/Code05_AdditionOnSegments1.java
rename to src/class167/Code01_AdditionOnSegments1.java
index 8535e7d67..ad2ffcb1d 100644
--- a/src/class167/Code05_AdditionOnSegments1.java
+++ b/src/class167/Code01_AdditionOnSegments1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_AdditionOnSegments1 {
+public class Code01_AdditionOnSegments1 {
 
 	public static int MAXN = 10001;
 	public static int MAXT = 500001;
diff --git a/src/class167/Code05_AdditionOnSegments2.java b/src/class167/Code01_AdditionOnSegments2.java
similarity index 100%
rename from src/class167/Code05_AdditionOnSegments2.java
rename to src/class167/Code01_AdditionOnSegments2.java
diff --git a/src/class167/Code01_ShortestPathQueries1.java b/src/class167/Code04_ShortestPathQueries1.java
similarity index 99%
rename from src/class167/Code01_ShortestPathQueries1.java
rename to src/class167/Code04_ShortestPathQueries1.java
index e85069f8e..e7105f56d 100644
--- a/src/class167/Code01_ShortestPathQueries1.java
+++ b/src/class167/Code04_ShortestPathQueries1.java
@@ -11,7 +11,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code01_ShortestPathQueries1 {
+public class Code04_ShortestPathQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXT = 5000001;
diff --git a/src/class167/Code01_ShortestPathQueries2.java b/src/class167/Code04_ShortestPathQueries2.java
similarity index 100%
rename from src/class167/Code01_ShortestPathQueries2.java
rename to src/class167/Code04_ShortestPathQueries2.java
diff --git a/src/class167/Code02_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
similarity index 99%
rename from src/class167/Code02_EightVerticalHorizontal1.java
rename to src/class167/Code05_EightVerticalHorizontal1.java
index b1e0c53ab..4d3110df4 100644
--- a/src/class167/Code02_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_EightVerticalHorizontal1 {
+public class Code05_EightVerticalHorizontal1 {
 
 	public static int MAXN = 501;
 	public static int MAXQ = 1001;
diff --git a/src/class167/Code02_EightVerticalHorizontal2.java b/src/class167/Code05_EightVerticalHorizontal2.java
similarity index 100%
rename from src/class167/Code02_EightVerticalHorizontal2.java
rename to src/class167/Code05_EightVerticalHorizontal2.java
diff --git a/src/class167/Code03_MinimumXor1.java b/src/class167/Code06_MinimumXor1.java
similarity index 98%
rename from src/class167/Code03_MinimumXor1.java
rename to src/class167/Code06_MinimumXor1.java
index 8b34db95d..b8ad05e0b 100644
--- a/src/class167/Code03_MinimumXor1.java
+++ b/src/class167/Code06_MinimumXor1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_MinimumXor1 {
+public class Code06_MinimumXor1 {
 
 	public static int MAXN = 10000001;
 	public static int BIT = 29;
diff --git a/src/class167/Code03_MinimumXor2.java b/src/class167/Code06_MinimumXor2.java
similarity index 100%
rename from src/class167/Code03_MinimumXor2.java
rename to src/class167/Code06_MinimumXor2.java
diff --git a/src/class167/Code04_MarsStore1.java b/src/class167/Code07_MarsStore1.java
similarity index 99%
rename from src/class167/Code04_MarsStore1.java
rename to src/class167/Code07_MarsStore1.java
index 4c3b86841..472b13314 100644
--- a/src/class167/Code04_MarsStore1.java
+++ b/src/class167/Code07_MarsStore1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_MarsStore1 {
+public class Code07_MarsStore1 {
 
 	public static int MAXN = 100001;
 	public static int MAXT = 2000001;
diff --git a/src/class167/Code04_MarsStore2.java b/src/class167/Code07_MarsStore2.java
similarity index 100%
rename from src/class167/Code04_MarsStore2.java
rename to src/class167/Code07_MarsStore2.java

From 719692670facd0f9e00b6ca773f529ffea863042 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 12:28:31 +0800
Subject: [PATCH 0742/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java       | 186 ++++++++++++++++++
 src/class167/Code01_MuseumRobbery2.java       | 140 +++++++++++++
 ...1.java => Code02_AdditionOnSegments1.java} |   2 +-
 ...2.java => Code02_AdditionOnSegments2.java} |   0
 4 files changed, 327 insertions(+), 1 deletion(-)
 create mode 100644 src/class167/Code01_MuseumRobbery1.java
 create mode 100644 src/class167/Code01_MuseumRobbery2.java
 rename src/class167/{Code01_AdditionOnSegments1.java => Code02_AdditionOnSegments1.java} (99%)
 rename src/class167/{Code01_AdditionOnSegments2.java => Code02_AdditionOnSegments2.java} (100%)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
new file mode 100644
index 000000000..c1f8328d9
--- /dev/null
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -0,0 +1,186 @@
+package class167;
+
+// 博物馆抢劫案，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF601E
+// 测试链接 : https://codeforces.com/problemset/problem/601/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code01_MuseumRobbery1 {
+
+	public static int MAXN = 40001;
+	public static int MAXQ = 30001;
+	public static int MAXT = 1000001;
+	public static int MAXK = 1001;
+	public static int DEEP = 20;
+	public static int MOD = 1000000007;
+	public static int BASE = 10000019;
+	public static int n, k, q;
+
+	public static int[] v = new int[MAXN];
+	public static int[] w = new int[MAXN];
+	public static int[] from = new int[MAXN];
+	public static int[] to = new int[MAXN];
+
+	public static int[] op = new int[MAXQ];
+	public static int[] x = new int[MAXQ];
+	public static int[] y = new int[MAXQ];
+
+	public static int[] head = new int[MAXQ << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] tov = new int[MAXT];
+	public static int[] tow = new int[MAXT];
+	public static int cnt = 0;
+
+	public static long[] dp = new long[MAXK];
+	public static long[][] backup = new long[DEEP][MAXK];
+
+	public static long[] ans = new long[MAXQ];
+
+	public static void clone(long[] a, long[] b) {
+		for (int i = 0; i <= k; i++) {
+			a[i] = b[i];
+		}
+	}
+
+	public static void addEdge(int i, int v, int w) {
+		next[++cnt] = head[i];
+		tov[cnt] = v;
+		tow[cnt] = w;
+		head[i] = cnt;
+	}
+
+	public static void add(int jobl, int jobr, int jobv, int jobw, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobv, jobw);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobv, jobw, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobv, jobw, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i, int dep) {
+		clone(backup[dep], dp);
+		for (int e = head[i]; e > 0; e = next[e]) {
+			int v = tov[e];
+			int w = tow[e];
+			for (int j = k; j >= w; j--) {
+				dp[j] = Math.max(dp[j], dp[j - w] + v);
+			}
+		}
+		if (l == r) {
+			if (op[l] == 3) {
+				long b = 1;
+				for (int j = 1; j <= k; j++) {
+					ans[l] = (ans[l] + dp[j] * b) % MOD;
+					b = (b * BASE) % MOD;
+				}
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1, dep + 1);
+			dfs(mid + 1, r, i << 1 | 1, dep + 1);
+		}
+		clone(dp, backup[dep]);
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			from[i] = 1;
+			to[i] = q;
+		}
+		for (int i = 1; i <= q; i++) {
+			if (op[i] == 1) {
+				n++;
+				v[n] = x[i];
+				w[n] = y[i];
+				from[n] = i;
+				to[n] = q;
+			} else if (op[i] == 2) {
+				to[x[i]] = i;
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			add(from[i], to[i], v[i], w[i], 1, q, 1);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			v[i] = in.nextInt();
+			w[i] = in.nextInt();
+		}
+		q = in.nextInt();
+		for (int i = 1; i <= q; i++) {
+			op[i] = in.nextInt();
+			if (op[i] == 1) {
+				x[i] = in.nextInt();
+				y[i] = in.nextInt();
+			} else if (op[i] == 2) {
+				x[i] = in.nextInt();
+			}
+		}
+		prepare();
+		dfs(1, q, 1, 1);
+		for (int i = 1; i <= q; i++) {
+			if (op[i] == 3) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
new file mode 100644
index 000000000..7dd2247c2
--- /dev/null
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -0,0 +1,140 @@
+package class167;
+
+// 博物馆抢劫案，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF601E
+// 测试链接 : https://codeforces.com/problemset/problem/601/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 40001;
+//const int MAXQ = 30001;
+//const int MAXT = 1000001;
+//const int MAXK = 1001;
+//const int DEEP = 20;
+//const long long MOD = 1000000007LL;
+//const long long BASE = 10000019LL;
+//
+//int n, k, q;
+//
+//int v[MAXN];
+//int w[MAXN];
+//int from[MAXN];
+//int to[MAXN];
+//
+//int op[MAXQ];
+//int x[MAXQ];
+//int y[MAXQ];
+//
+//int head[MAXQ << 2];
+//int nxt[MAXT];
+//int tov[MAXT];
+//int tow[MAXT];
+//int cnt = 0;
+//
+//long long dp[MAXK];
+//long long backup[DEEP][MAXK];
+//
+//long long ans[MAXQ];
+//
+//void clone(long long* a, long long* b) {
+//    for (int i = 0; i <= k; i++) {
+//        a[i] = b[i];
+//    }
+//}
+//
+//void addEdge(int i, int v, int w) {
+//    nxt[++cnt] = head[i];
+//    tov[cnt] = v;
+//    tow[cnt] = w;
+//    head[i] = cnt;
+//}
+//
+//void add(int jobl, int jobr, int jobv, int jobw, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobv, jobw);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobv, jobw, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobv, jobw, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i, int dep) {
+//    clone(backup[dep], dp);
+//    for (int e = head[i]; e > 0; e = nxt[e]) {
+//        int v = tov[e];
+//        int w = tow[e];
+//        for (int j = k; j >= w; j--) {
+//            dp[j] = max(dp[j], dp[j - w] + v);
+//        }
+//    }
+//    if (l == r) {
+//        if (op[l] == 3) {
+//            long long b = 1;
+//            for (int j = 1; j <= k; j++) {
+//                ans[l] = (ans[l] + dp[j] * b) % MOD;
+//                b = (b * BASE) % MOD;
+//            }
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1, dep + 1);
+//        dfs(mid + 1, r, i << 1 | 1, dep + 1);
+//    }
+//    clone(dp, backup[dep]);
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//    	from[i] = 1;
+//    	to[i] = q;
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        if (op[i] == 1) {
+//            n++;
+//            v[n] = x[i];
+//            w[n] = y[i];
+//            from[n] = i;
+//            to[n] = q;
+//        } else if (op[i] == 2) {
+//        	to[x[i]] = i;
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        add(from[i], to[i], v[i], w[i], 1, q, 1);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> v[i] >> w[i];
+//    }
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> op[i];
+//        if (op[i] == 1) {
+//            cin >> x[i] >> y[i];
+//        } else if (op[i] == 2) {
+//            cin >> x[i];
+//        }
+//    }
+//    prepare();
+//    dfs(1, q, 1, 1);
+//    for (int i = 1; i <= q; i++) {
+//        if (op[i] == 3) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class167/Code01_AdditionOnSegments1.java b/src/class167/Code02_AdditionOnSegments1.java
similarity index 99%
rename from src/class167/Code01_AdditionOnSegments1.java
rename to src/class167/Code02_AdditionOnSegments1.java
index ad2ffcb1d..dcd7355ac 100644
--- a/src/class167/Code01_AdditionOnSegments1.java
+++ b/src/class167/Code02_AdditionOnSegments1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code01_AdditionOnSegments1 {
+public class Code02_AdditionOnSegments1 {
 
 	public static int MAXN = 10001;
 	public static int MAXT = 500001;
diff --git a/src/class167/Code01_AdditionOnSegments2.java b/src/class167/Code02_AdditionOnSegments2.java
similarity index 100%
rename from src/class167/Code01_AdditionOnSegments2.java
rename to src/class167/Code02_AdditionOnSegments2.java

From ee55078bbca64dc9253e987b54709d3d6732c79c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 12:29:58 +0800
Subject: [PATCH 0743/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java | 3 +--
 src/class167/Code01_MuseumRobbery2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index c1f8328d9..8284d29eb 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -1,6 +1,6 @@
 package class167;
 
-// 博物馆抢劫案，java版
+// 博物馆劫案，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
 // 测试链接 : https://codeforces.com/problemset/problem/601/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -38,7 +38,6 @@ public class Code01_MuseumRobbery1 {
 
 	public static long[] dp = new long[MAXK];
 	public static long[][] backup = new long[DEEP][MAXK];
-
 	public static long[] ans = new long[MAXQ];
 
 	public static void clone(long[] a, long[] b) {
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index 7dd2247c2..e05e1e59b 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -1,6 +1,6 @@
 package class167;
 
-// 博物馆抢劫案，C++版
+// 博物馆劫案，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
 // 测试链接 : https://codeforces.com/problemset/problem/601/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -37,7 +37,6 @@
 //
 //long long dp[MAXK];
 //long long backup[DEEP][MAXK];
-//
 //long long ans[MAXQ];
 //
 //void clone(long long* a, long long* b) {

From b4c3c891455a56b8583b96213e02c355c99d02fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 12:36:03 +0800
Subject: [PATCH 0744/1712] modify code

---
 src/class167/Code03_BlueMoon1.java            | 87 +++++++++++++++++++
 .../Code05_EightVerticalHorizontal1.java      | 16 ----
 2 files changed, 87 insertions(+), 16 deletions(-)
 create mode 100644 src/class167/Code03_BlueMoon1.java

diff --git a/src/class167/Code03_BlueMoon1.java b/src/class167/Code03_BlueMoon1.java
new file mode 100644
index 000000000..6cc990aa9
--- /dev/null
+++ b/src/class167/Code03_BlueMoon1.java
@@ -0,0 +1,87 @@
+package class167;
+
+// 贪玩蓝月，java版
+// 测试链接 : https://loj.ac/p/6515
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_BlueMoon1 {
+	
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private static final int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len) {
+				return true;
+			}
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte()) {
+				return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b)) {
+				b = readByte();
+			}
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		public String nextString() throws IOException {
+			byte b = readByte();
+			while (isWhitespace(b)) {
+				b = readByte();
+			}
+			StringBuilder sb = new StringBuilder(1000);
+			while (!isWhitespace(b) && b != -1) {
+				sb.append((char) b);
+				b = readByte();
+			}
+			return sb.toString();
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index 4d3110df4..e7931b773 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -327,22 +327,6 @@ private byte readByte() throws IOException {
 			return buffer[ptr++];
 		}
 
-		public char nextChar() throws IOException {
-			byte c;
-			do {
-				c = readByte();
-				if (c == -1) {
-					return 0;
-				}
-			} while (c <= ' ');
-			char ans = 0;
-			while (c > ' ') {
-				ans = (char) c;
-				c = readByte();
-			}
-			return ans;
-		}
-
 		public int nextInt() throws IOException {
 			int num = 0;
 			byte b = readByte();

From ea59ff56bbd7e4ac2a98f03236398dd64d909f92 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 12:39:55 +0800
Subject: [PATCH 0745/1712] modify code

---
 src/class167/{Code07_MarsStore1.java => Code06_MarsStore1.java} | 2 +-
 src/class167/{Code07_MarsStore2.java => Code06_MarsStore2.java} | 0
 .../{Code06_MinimumXor1.java => Code07_MinimumXor1.java}        | 2 +-
 .../{Code06_MinimumXor2.java => Code07_MinimumXor2.java}        | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class167/{Code07_MarsStore1.java => Code06_MarsStore1.java} (99%)
 rename src/class167/{Code07_MarsStore2.java => Code06_MarsStore2.java} (100%)
 rename src/class167/{Code06_MinimumXor1.java => Code07_MinimumXor1.java} (98%)
 rename src/class167/{Code06_MinimumXor2.java => Code07_MinimumXor2.java} (100%)

diff --git a/src/class167/Code07_MarsStore1.java b/src/class167/Code06_MarsStore1.java
similarity index 99%
rename from src/class167/Code07_MarsStore1.java
rename to src/class167/Code06_MarsStore1.java
index 472b13314..a44118266 100644
--- a/src/class167/Code07_MarsStore1.java
+++ b/src/class167/Code06_MarsStore1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code07_MarsStore1 {
+public class Code06_MarsStore1 {
 
 	public static int MAXN = 100001;
 	public static int MAXT = 2000001;
diff --git a/src/class167/Code07_MarsStore2.java b/src/class167/Code06_MarsStore2.java
similarity index 100%
rename from src/class167/Code07_MarsStore2.java
rename to src/class167/Code06_MarsStore2.java
diff --git a/src/class167/Code06_MinimumXor1.java b/src/class167/Code07_MinimumXor1.java
similarity index 98%
rename from src/class167/Code06_MinimumXor1.java
rename to src/class167/Code07_MinimumXor1.java
index b8ad05e0b..c0d53c1c1 100644
--- a/src/class167/Code06_MinimumXor1.java
+++ b/src/class167/Code07_MinimumXor1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code06_MinimumXor1 {
+public class Code07_MinimumXor1 {
 
 	public static int MAXN = 10000001;
 	public static int BIT = 29;
diff --git a/src/class167/Code06_MinimumXor2.java b/src/class167/Code07_MinimumXor2.java
similarity index 100%
rename from src/class167/Code06_MinimumXor2.java
rename to src/class167/Code07_MinimumXor2.java

From 4b722721ad3a0c66f532face2216a38564cc0b29 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 15:16:31 +0800
Subject: [PATCH 0746/1712] modify code

---
 src/class167/Code03_BlueMoon1.java | 146 +++++++++++++++++++++++++++-
 src/class167/Code03_BlueMoon2.java | 149 +++++++++++++++++++++++++++++
 2 files changed, 292 insertions(+), 3 deletions(-)
 create mode 100644 src/class167/Code03_BlueMoon2.java

diff --git a/src/class167/Code03_BlueMoon1.java b/src/class167/Code03_BlueMoon1.java
index 6cc990aa9..2701fd2de 100644
--- a/src/class167/Code03_BlueMoon1.java
+++ b/src/class167/Code03_BlueMoon1.java
@@ -8,13 +8,153 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
+import java.util.ArrayDeque;
+import java.util.Deque;
 
 public class Code03_BlueMoon1 {
-	
+
+	public static int MAXM = 50001;
+	public static int MAXP = 501;
+	public static int MAXT = 1000001;
+	public static long INF = 1000000000001L;
+	public static int m, p;
+
+	public static int[] op = new int[MAXM];
+	public static int[] x = new int[MAXM];
+	public static int[] y = new int[MAXM];
+
+	public static int[] head = new int[MAXM << 2];
+	public static int[] next = new int[MAXT];
+	public static int[] tow = new int[MAXT];
+	public static int[] tov = new int[MAXT];
+	public static int cnt = 0;
+
+	public static int used = 0;
+	public static long[][] dp = new long[MAXM][MAXP];
+	public static long[] ans = new long[MAXM];
+
+	public static void addEdge(int i, int w, int v) {
+		next[++cnt] = head[i];
+		tow[cnt] = w;
+		tov[cnt] = v;
+		head[i] = cnt;
+	}
+
+	public static void add(int jobl, int jobr, int jobw, int jobv, int l, int r, int i) {
+		if (jobl <= l && r <= jobr) {
+			addEdge(i, jobw, jobv);
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobl <= mid) {
+				add(jobl, jobr, jobw, jobv, l, mid, i << 1);
+			}
+			if (jobr > mid) {
+				add(jobl, jobr, jobw, jobv, mid + 1, r, i << 1 | 1);
+			}
+		}
+	}
+
+	public static void dfs(int l, int r, int i) {
+		int siz = 0;
+		for (int e = head[i], w, v; e > 0; e = next[e]) {
+			w = tow[e];
+			v = tov[e];
+			for (int j = 0; j < p; j++) {
+				dp[used + siz + 1][j] = dp[used + siz][j];
+			}
+			for (int j = 0; j < p; j++) {
+				if (dp[used + siz][j] != -INF) {
+					dp[used + siz + 1][(j + w) % p] = Math.max(dp[used + siz + 1][(j + w) % p], dp[used + siz][j] + v);
+				}
+			}
+			siz++;
+		}
+		used += siz;
+		if (l == r) {
+			if (op[l] == 5) {
+				long ret = -INF;
+				for (int j = x[l]; j <= y[l]; j++) {
+					ret = Math.max(ret, dp[used][j]);
+				}
+				if (ret == -INF) {
+					ans[l] = -1;
+				} else {
+					ans[l] = ret;
+				}
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(l, mid, i << 1);
+			dfs(mid + 1, r, i << 1 | 1);
+		}
+		used -= siz;
+	}
+
+	public static void prepare() {
+		Deque<int[]> deque = new ArrayDeque<>();
+		int[] data;
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 1) {
+				deque.addFirst(new int[] { x[i] % p, y[i], i });
+			} else if (op[i] == 2) {
+				deque.addLast(new int[] { x[i] % p, y[i], i });
+			} else if (op[i] == 3) {
+				data = deque.peekFirst();
+				add(data[2], i - 1, data[0], data[1], 1, m, 1);
+				deque.pollFirst();
+			} else if (op[i] == 4) {
+				data = deque.peekLast();
+				add(data[2], i - 1, data[0], data[1], 1, m, 1);
+				deque.pollLast();
+			}
+		}
+		while (!deque.isEmpty()) {
+			data = deque.peekFirst();
+			add(data[2], m, data[0], data[1], 1, m, 1);
+			deque.pollFirst();
+		}
+		for (int i = 0; i < MAXM; i++) {
+			for (int j = 0; j < MAXP; j++) {
+				dp[i][j] = -INF;
+			}
+		}
+		dp[0][0] = 0;
+	}
+
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader();
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		
+		in.nextInt();
+		m = in.nextInt();
+		p = in.nextInt();
+		String t;
+		for (int i = 1; i <= m; i++) {
+			t = in.nextString();
+			if (t.equals("IF")) {
+				op[i] = 1;
+				x[i] = in.nextInt();
+				y[i] = in.nextInt();
+			} else if (t.equals("IG")) {
+				op[i] = 2;
+				x[i] = in.nextInt();
+				y[i] = in.nextInt();
+			} else if (t.equals("DF")) {
+				op[i] = 3;
+			} else if (t.equals("DG")) {
+				op[i] = 4;
+			} else {
+				op[i] = 5;
+				x[i] = in.nextInt();
+				y[i] = in.nextInt();
+			}
+		}
+		prepare();
+		dfs(1, m, 1);
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 5) {
+				out.println(ans[i]);
+			}
+		}
 		out.flush();
 		out.close();
 	}
@@ -84,4 +224,4 @@ private boolean isWhitespace(byte b) {
 		}
 	}
 
-}
+}
\ No newline at end of file
diff --git a/src/class167/Code03_BlueMoon2.java b/src/class167/Code03_BlueMoon2.java
new file mode 100644
index 000000000..934e1f4be
--- /dev/null
+++ b/src/class167/Code03_BlueMoon2.java
@@ -0,0 +1,149 @@
+package class167;
+
+// 贪玩蓝月，C++版
+// 测试链接 : https://loj.ac/p/6515
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXM = 50001;
+//const int MAXP = 501;
+//const int MAXT = 1000001;
+//const long long INF = 1000000000001LL;
+//
+//int m, p;
+//
+//int op[MAXM];
+//int x[MAXM];
+//int y[MAXM];
+//
+//int head[MAXM << 2];
+//int nxt[MAXT];
+//int tow[MAXT];
+//int tov[MAXT];
+//int cnt = 0;
+//
+//int used = 0;
+//long long dp[MAXM][MAXP];
+//long long ans[MAXM];
+//
+//void addEdge(int i, int w, int v) {
+//    nxt[++cnt] = head[i];
+//    tow[cnt] = w;
+//    tov[cnt] = v;
+//    head[i] = cnt;
+//}
+//
+//void add(int jobl, int jobr, int jobw, int jobv, int l, int r, int i) {
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(i, jobw, jobv);
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobl <= mid) {
+//            add(jobl, jobr, jobw, jobv, l, mid, i << 1);
+//        }
+//        if (jobr > mid) {
+//            add(jobl, jobr, jobw, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//    }
+//}
+//
+//void dfs(int l, int r, int i) {
+//    int siz = 0;
+//    for (int e = head[i], w, v; e > 0; e = nxt[e]) {
+//        w = tow[e];
+//        v = tov[e];
+//        for (int j = 0; j < p; j++) {
+//            dp[used + siz + 1][j] = dp[used + siz][j];
+//        }
+//        for (int j = 0; j < p; j++) {
+//            if (dp[used + siz][j] != -INF) {
+//                int nj = (j + w) % p;
+//                dp[used + siz + 1][nj] = max(dp[used + siz + 1][nj], dp[used + siz][j] + v);
+//            }
+//        }
+//        siz++;
+//    }
+//    used += siz;
+//    if (l == r) {
+//        if (op[l] == 5) {
+//            long long ret = -INF;
+//            for (int j = x[l]; j <= y[l]; j++) {
+//                ret = max(ret, dp[used][j]);
+//            }
+//            ans[l] = (ret == -INF ? -1 : ret);
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(l, mid, i << 1);
+//        dfs(mid + 1, r, i << 1 | 1);
+//    }
+//    used -= siz;
+//}
+//
+//void prepare() {
+//    deque<array<int,3>> dq;
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 1) {
+//            dq.push_front({x[i] % p, y[i], i});
+//        } else if (op[i] == 2) {
+//            dq.push_back({x[i] % p, y[i], i});
+//        } else if (op[i] == 3) {
+//            auto data = dq.front();
+//            add(data[2], i - 1, data[0], data[1], 1, m, 1);
+//            dq.pop_front();
+//        } else if (op[i] == 4) {
+//            auto data = dq.back();
+//            add(data[2], i - 1, data[0], data[1], 1, m, 1);
+//            dq.pop_back();
+//        }
+//    }
+//    while (!dq.empty()) {
+//        auto data = dq.front();
+//        add(data[2], m, data[0], data[1], 1, m, 1);
+//        dq.pop_front();
+//    }
+//    for (int i = 0; i < MAXM; i++) {
+//        for (int j = 0; j < MAXP; j++) {
+//            dp[i][j] = -INF;
+//        }
+//    }
+//    dp[0][0] = 0;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int tmp;
+//    cin >> tmp;
+//    cin >> m >> p;
+//    string t;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> t;
+//        if (t == "IF") {
+//            op[i] = 1;
+//            cin >> x[i] >> y[i];
+//        } else if (t == "IG") {
+//            op[i] = 2;
+//            cin >> x[i] >> y[i];
+//        } else if (t == "DF") {
+//            op[i] = 3;
+//        } else if (t == "DG") {
+//            op[i] = 4;
+//        } else {
+//            op[i] = 5;
+//            cin >> x[i] >> y[i];
+//        }
+//    }
+//    prepare();
+//    dfs(1, m, 1);
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 5) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 4cff3ee798b602479899844ceda3f980ff12fb4b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 18:34:42 +0800
Subject: [PATCH 0747/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java           | 11 +++++++++++
 src/class167/Code01_MuseumRobbery2.java           | 11 +++++++++++
 src/class167/Code02_AdditionOnSegments1.java      |  8 +++++++-
 src/class167/Code02_AdditionOnSegments2.java      |  8 +++++++-
 src/class167/Code03_BlueMoon1.java                | 10 ++++++++++
 src/class167/Code03_BlueMoon2.java                | 10 ++++++++++
 src/class167/Code04_ShortestPathQueries1.java     |  8 ++++++++
 src/class167/Code04_ShortestPathQueries2.java     |  8 ++++++++
 src/class167/Code05_EightVerticalHorizontal1.java | 12 +++++++++++-
 src/class167/Code05_EightVerticalHorizontal2.java | 12 +++++++++++-
 src/class167/Code06_MarsStore1.java               |  7 +++++++
 src/class167/Code06_MarsStore2.java               |  7 +++++++
 src/class167/Code07_MinimumXor1.java              |  6 ++++++
 src/class167/Code07_MinimumXor2.java              |  6 ++++++
 14 files changed, 120 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index 8284d29eb..743ec009f 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -1,6 +1,17 @@
 package class167;
 
 // 博物馆劫案，java版
+// 给定一个正数k，假设当前商品集合为s，可以随意挑选商品
+// 总重量不超过m的情况下，能得到的最大价值，定义为best(m)
+// 定义，f(s) = ∑(m = 1...k) ( best(m) * BASE的m-1次方 % MOD )
+// 其中BASE = 10000019，MOD = 1000000007
+// 给定n件商品，编号1~n，每种商品给定v和w，每件商品都加入商品集合s
+// 接下来有q个操作，每种操作是如下三种类型中的一种
+// 操作 1 x y : 集合s中增加价值x、重量y的商品，编号自增即可
+// 操作 2 x   : 集合s中删除编号为x的商品
+// 操作 3     : 查询当前的f(s)
+// 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
+// 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
 // 测试链接 : https://codeforces.com/problemset/problem/601/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index e05e1e59b..8c527cdb6 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -1,6 +1,17 @@
 package class167;
 
 // 博物馆劫案，C++版
+// 给定一个正数k，假设当前商品集合为s，可以随意挑选商品
+// 总重量不超过m的情况下，能得到的最大价值，定义为best(m)
+// 定义，f(s) = ∑(m = 1...k) ( best(m) * BASE的m-1次方 % MOD )
+// 其中BASE = 10000019，MOD = 1000000007
+// 给定n件商品，编号1~n，每种商品给定v和w，每件商品都加入商品集合s
+// 接下来有q个操作，每种操作是如下三种类型中的一种
+// 操作 1 x y : 集合s中增加价值x、重量y的商品，编号自增即可
+// 操作 2 x   : 集合s中删除编号为x的商品
+// 操作 3     : 查询当前的f(s)
+// 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
+// 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
 // 测试链接 : https://codeforces.com/problemset/problem/601/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class167/Code02_AdditionOnSegments1.java b/src/class167/Code02_AdditionOnSegments1.java
index dcd7355ac..136b6786a 100644
--- a/src/class167/Code02_AdditionOnSegments1.java
+++ b/src/class167/Code02_AdditionOnSegments1.java
@@ -1,6 +1,12 @@
 package class167;
 
-// 能达到的最大值，java版
+// 打印所有合法数，java版
+// 一个长度为n的序列，一开始所有值都是0
+// 一共有q条操作，每条操作为 l r k : 序列[l..r]范围上，每个数字加k
+// 你可以随意选择操作来执行，但是每条操作只能执行一次
+// 如果你能让序列中的最大值正好为v，那么v就算一个合法数
+// 打印1~n范围内有多少合法数，并且从小到大打印所有的合法数
+// 1 <= k <= n、q <= 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/CF981E
 // 测试链接 : https://codeforces.com/problemset/problem/981/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class167/Code02_AdditionOnSegments2.java b/src/class167/Code02_AdditionOnSegments2.java
index 3c7c5100c..4416dc887 100644
--- a/src/class167/Code02_AdditionOnSegments2.java
+++ b/src/class167/Code02_AdditionOnSegments2.java
@@ -1,6 +1,12 @@
 package class167;
 
-// 能达到的最大值，C++版
+// 打印所有合法数，C++版
+// 一个长度为n的序列，一开始所有值都是0
+// 一共有q条操作，每条操作为 l r k : 序列[l..r]范围上，每个数字加k
+// 你可以随意选择操作来执行，但是每条操作只能执行一次
+// 如果你能让序列中的最大值正好为v，那么v就算一个合法数
+// 打印1~n范围内有多少合法数，并且从小到大打印所有的合法数
+// 1 <= k <= n、q <= 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/CF981E
 // 测试链接 : https://codeforces.com/problemset/problem/981/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class167/Code03_BlueMoon1.java b/src/class167/Code03_BlueMoon1.java
index 2701fd2de..c01ea0197 100644
--- a/src/class167/Code03_BlueMoon1.java
+++ b/src/class167/Code03_BlueMoon1.java
@@ -1,6 +1,16 @@
 package class167;
 
 // 贪玩蓝月，java版
+// 每件装备都有特征值w和战斗力v，放装备的背包是一个双端队列
+// 给定数值p，接下来有m条操作，每种操作是如下五种类型中的一种
+// 操作 IF x y : 背包前端加入一件特征值x、战斗力y的装备
+// 操作 IG x y : 背包后端加入一件特征值x、战斗力y的装备
+// 操作 DF     : 删除背包前端的装备
+// 操作 DG     : 删除背包后端的装备
+// 操作 QU x y : 选择装备的特征值累加和 % p，必须在[x, y]范围
+//               打印能得到的最大战斗力是多少，没有合法方案打印-1
+// 1 <= m <= 5 * 10^4    1 <= p <= 500
+// 0 <= 每件装备特征值、每件装备战斗力 <= 10^9
 // 测试链接 : https://loj.ac/p/6515
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class167/Code03_BlueMoon2.java b/src/class167/Code03_BlueMoon2.java
index 934e1f4be..07d74dd44 100644
--- a/src/class167/Code03_BlueMoon2.java
+++ b/src/class167/Code03_BlueMoon2.java
@@ -1,6 +1,16 @@
 package class167;
 
 // 贪玩蓝月，C++版
+// 每件装备都有特征值w和战斗力v，放装备的背包是一个双端队列
+// 给定数值p，接下来有m条操作，每种操作是如下五种类型中的一种
+// 操作 IF x y : 背包前端加入一件特征值x、战斗力y的装备
+// 操作 IG x y : 背包后端加入一件特征值x、战斗力y的装备
+// 操作 DF     : 删除背包前端的装备
+// 操作 DG     : 删除背包后端的装备
+// 操作 QU x y : 选择装备的特征值累加和 % p，必须在[x, y]范围
+//               打印能得到的最大战斗力是多少，没有合法方案打印-1
+// 1 <= m <= 5 * 10^4    1 <= p <= 500
+// 0 <= 每件装备特征值、每件装备战斗力 <= 10^9
 // 测试链接 : https://loj.ac/p/6515
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class167/Code04_ShortestPathQueries1.java b/src/class167/Code04_ShortestPathQueries1.java
index e7105f56d..7f66f4468 100644
--- a/src/class167/Code04_ShortestPathQueries1.java
+++ b/src/class167/Code04_ShortestPathQueries1.java
@@ -1,6 +1,14 @@
 package class167;
 
 // 异或最短路，java版
+// 一共有n个节点，m条边，每条边有边权
+// 接下来有q条操作，每种操作是如下三种类型中的一种
+// 操作 1 x y d : 原图中加入，点x到点y，权值为d的边
+// 操作 2 x y   : 原图中删除，点x到点y的边
+// 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来
+//                打印能取得的异或最小值
+// 保证任意操作后，图连通、无重边、无自环，所有操作均合法
+// 1 <= n、m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF938G
 // 测试链接 : https://codeforces.com/problemset/problem/938/G
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class167/Code04_ShortestPathQueries2.java b/src/class167/Code04_ShortestPathQueries2.java
index f99f9ef4f..0bf523f3a 100644
--- a/src/class167/Code04_ShortestPathQueries2.java
+++ b/src/class167/Code04_ShortestPathQueries2.java
@@ -1,6 +1,14 @@
 package class167;
 
 // 异或最短路，C++版
+// 一共有n个节点，m条边，每条边有边权
+// 接下来有q条操作，每种操作是如下三种类型中的一种
+// 操作 1 x y d : 原图中加入，点x到点y，权值为d的边
+// 操作 2 x y   : 原图中删除，点x到点y的边
+// 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来
+//                打印能取得的异或最小值
+// 保证任意操作后，图连通、无重边、无自环，所有操作均合法
+// 1 <= n、m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF938G
 // 测试链接 : https://codeforces.com/problemset/problem/938/G
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index e7931b773..bb3d163c3 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -1,6 +1,16 @@
 package class167;
 
 // 八纵八横，java版
+// 一共有n个点，给定m条边，每条边的边权，用01字符串表达
+// 初始的m条边永不删除，接下来有q条操作，每种操作是如下三种类型中的一种
+// 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串
+//                   如果这是第k条添加操作，那么这条边编号为k
+// 操作 Cancel k   : 删除编号为k的边
+// 操作 Change k z : 编号为k的边，边权修改成z，z为01字符串
+// 从1号点出发，最后回到1号点，边随便走，沿途所有边的边权异或起来
+// 打印只有初始m条边的情况下，异或最大值为多少
+// 每一条操作结束后，都打印异或最大值为多少
+// 1 <= n、m <= 500    0 <= q <= 1000    1 <= 边权字符串长度 <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/P3733
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,7 +24,7 @@ public class Code05_EightVerticalHorizontal1 {
 	public static int MAXN = 501;
 	public static int MAXQ = 1001;
 	public static int MAXT = 10001;
-	public static int BIT = 1000;
+	public static int BIT = 999;
 	public static int INTBIT = 32;
 
 	// 位图
diff --git a/src/class167/Code05_EightVerticalHorizontal2.java b/src/class167/Code05_EightVerticalHorizontal2.java
index 1def385ed..88dff9a61 100644
--- a/src/class167/Code05_EightVerticalHorizontal2.java
+++ b/src/class167/Code05_EightVerticalHorizontal2.java
@@ -1,6 +1,16 @@
 package class167;
 
 // 八纵八横，C++版
+// 一共有n个点，给定m条边，每条边的边权，用01字符串表达
+// 初始的m条边永不删除，接下来有q条操作，每种操作是如下三种类型中的一种
+// 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串
+//                   如果这是第k条添加操作，那么这条边编号为k
+// 操作 Cancel k   : 删除编号为k的边
+// 操作 Change k z : 编号为k的边，边权修改成z，z为01字符串
+// 从1号点出发，最后回到1号点，边随便走，沿途所有边的边权异或起来
+// 打印只有初始m条边的情况下，异或最大值为多少
+// 每一条操作结束后，都打印异或最大值为多少
+// 1 <= n、m <= 500    0 <= q <= 1000    1 <= 边权字符串长度 <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/P3733
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -12,7 +22,7 @@
 //const int MAXN = 501;
 //const int MAXQ = 1001;
 //const int MAXT = 10001;
-//const int BIT  = 1000;
+//const int BIT  = 999;
 //
 //typedef bitset<BIT + 1> bs;
 //
diff --git a/src/class167/Code06_MarsStore1.java b/src/class167/Code06_MarsStore1.java
index a44118266..3252a11ea 100644
--- a/src/class167/Code06_MarsStore1.java
+++ b/src/class167/Code06_MarsStore1.java
@@ -1,6 +1,13 @@
 package class167;
 
 // 火星商店，java版
+// 有n个商店，编号1~n，初始时每个商店只有一种商品，给定每个商店中唯一商品的价格
+// 有m条操作，每种操作是如下两种类型中的一种
+// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，这天新增了价格为v的商品
+// 操作 1 l r x d : 客人只在商店[l..r]中选择一件商品，只购买d天内的出现的商品
+//                  所有符合要求的商品中，打印 商品的价格 ^ x 的最大值
+// 注意，只有操作0能让天数+1，操作1不会增加天数
+// 0 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4585
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class167/Code06_MarsStore2.java b/src/class167/Code06_MarsStore2.java
index 7c9e60a8b..8060913ab 100644
--- a/src/class167/Code06_MarsStore2.java
+++ b/src/class167/Code06_MarsStore2.java
@@ -1,6 +1,13 @@
 package class167;
 
 // 火星商店，C++版
+// 有n个商店，编号1~n，初始时每个商店只有一种商品，给定每个商店中唯一商品的价格
+// 有m条操作，每种操作是如下两种类型中的一种
+// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，这天新增了价格为v的商品
+// 操作 1 l r x d : 客人只在商店[l..r]中选择一件商品，只购买d天内的出现的商品
+//                  所有符合要求的商品中，打印 商品的价格 ^ x 的最大值
+// 注意，只有操作0能让天数+1，操作1不会增加天数
+// 0 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4585
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class167/Code07_MinimumXor1.java b/src/class167/Code07_MinimumXor1.java
index c0d53c1c1..41b3f1e51 100644
--- a/src/class167/Code07_MinimumXor1.java
+++ b/src/class167/Code07_MinimumXor1.java
@@ -1,6 +1,12 @@
 package class167;
 
 // 最小异或查询，java版
+// 一共有q条操作，每种操作是如下三种类型中的一种
+// 操作 1 x : 黑板上写上一个数字x，同一种数字可以出现多次
+// 操作 2 x : 将一个x从黑板上擦掉，操作前保证至少有一个x在黑板上
+// 操作 3   : 打印任意两个数的最小异或值，操作前保证黑板上至少有两个数
+// 1 <= q <= 3 * 10^5
+// 0 <= x <= 2^30
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc308_g
 // 测试链接 : https://atcoder.jp/contests/abc308/tasks/abc308_g
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class167/Code07_MinimumXor2.java b/src/class167/Code07_MinimumXor2.java
index 378dd3df0..e664267a2 100644
--- a/src/class167/Code07_MinimumXor2.java
+++ b/src/class167/Code07_MinimumXor2.java
@@ -1,6 +1,12 @@
 package class167;
 
 // 最小异或查询，C++版
+// 一共有q条操作，每种操作是如下三种类型中的一种
+// 操作 1 x : 黑板上写上一个数字x，同一种数字可以出现多次
+// 操作 2 x : 将一个x从黑板上擦掉，操作前保证至少有一个x在黑板上
+// 操作 3   : 打印任意两个数的最小异或值，操作前保证黑板上至少有两个数
+// 1 <= q <= 3 * 10^5
+// 0 <= x <= 2^30
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc308_g
 // 测试链接 : https://atcoder.jp/contests/abc308/tasks/abc308_g
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From ed49a3c060cbbcff8dd9cb8934095118269a7df8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 3 May 2025 19:02:22 +0800
Subject: [PATCH 0748/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java           | 8 +++-----
 src/class167/Code01_MuseumRobbery2.java           | 8 +++-----
 src/class167/Code03_BlueMoon1.java                | 2 +-
 src/class167/Code03_BlueMoon2.java                | 2 +-
 src/class167/Code05_EightVerticalHorizontal1.java | 3 +--
 src/class167/Code05_EightVerticalHorizontal2.java | 3 +--
 6 files changed, 10 insertions(+), 16 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index 743ec009f..67f118754 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -1,13 +1,11 @@
 package class167;
 
 // 博物馆劫案，java版
-// 给定一个正数k，假设当前商品集合为s，可以随意挑选商品
-// 总重量不超过m的情况下，能得到的最大价值，定义为best(m)
-// 定义，f(s) = ∑(m = 1...k) ( best(m) * BASE的m-1次方 % MOD )
-// 其中BASE = 10000019，MOD = 1000000007
+// 给定正数k、BASE、MOD，定义a(m) = 当前商品集合s中，挑选商品总重量<=m，能获得的最大价值
+// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
 // 给定n件商品，编号1~n，每种商品给定v和w，每件商品都加入商品集合s
 // 接下来有q个操作，每种操作是如下三种类型中的一种
-// 操作 1 x y : 集合s中增加价值x、重量y的商品，编号自增即可
+// 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
 // 操作 2 x   : 集合s中删除编号为x的商品
 // 操作 3     : 查询当前的f(s)
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index 8c527cdb6..acf34670c 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -1,13 +1,11 @@
 package class167;
 
 // 博物馆劫案，C++版
-// 给定一个正数k，假设当前商品集合为s，可以随意挑选商品
-// 总重量不超过m的情况下，能得到的最大价值，定义为best(m)
-// 定义，f(s) = ∑(m = 1...k) ( best(m) * BASE的m-1次方 % MOD )
-// 其中BASE = 10000019，MOD = 1000000007
+// 给定正数k、BASE、MOD，定义a(m) = 当前商品集合s中，挑选商品总重量<=m，能获得的最大价值
+// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
 // 给定n件商品，编号1~n，每种商品给定v和w，每件商品都加入商品集合s
 // 接下来有q个操作，每种操作是如下三种类型中的一种
-// 操作 1 x y : 集合s中增加价值x、重量y的商品，编号自增即可
+// 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
 // 操作 2 x   : 集合s中删除编号为x的商品
 // 操作 3     : 查询当前的f(s)
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
diff --git a/src/class167/Code03_BlueMoon1.java b/src/class167/Code03_BlueMoon1.java
index c01ea0197..8cbc2d2bf 100644
--- a/src/class167/Code03_BlueMoon1.java
+++ b/src/class167/Code03_BlueMoon1.java
@@ -1,7 +1,7 @@
 package class167;
 
 // 贪玩蓝月，java版
-// 每件装备都有特征值w和战斗力v，放装备的背包是一个双端队列
+// 每件装备都有特征值w和战斗力v，放装备的背包是一个双端队列，只有背包中的装备是可选的
 // 给定数值p，接下来有m条操作，每种操作是如下五种类型中的一种
 // 操作 IF x y : 背包前端加入一件特征值x、战斗力y的装备
 // 操作 IG x y : 背包后端加入一件特征值x、战斗力y的装备
diff --git a/src/class167/Code03_BlueMoon2.java b/src/class167/Code03_BlueMoon2.java
index 07d74dd44..740212e10 100644
--- a/src/class167/Code03_BlueMoon2.java
+++ b/src/class167/Code03_BlueMoon2.java
@@ -1,7 +1,7 @@
 package class167;
 
 // 贪玩蓝月，C++版
-// 每件装备都有特征值w和战斗力v，放装备的背包是一个双端队列
+// 每件装备都有特征值w和战斗力v，放装备的背包是一个双端队列，只有背包中的装备是可选的
 // 给定数值p，接下来有m条操作，每种操作是如下五种类型中的一种
 // 操作 IF x y : 背包前端加入一件特征值x、战斗力y的装备
 // 操作 IG x y : 背包后端加入一件特征值x、战斗力y的装备
diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index bb3d163c3..dba6be8ba 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -8,8 +8,7 @@
 // 操作 Cancel k   : 删除编号为k的边
 // 操作 Change k z : 编号为k的边，边权修改成z，z为01字符串
 // 从1号点出发，最后回到1号点，边随便走，沿途所有边的边权异或起来
-// 打印只有初始m条边的情况下，异或最大值为多少
-// 每一条操作结束后，都打印异或最大值为多少
+// 打印只有初始m条边的情况下，异或最大值为多少，每一条操作结束后，都打印异或最大值为多少
 // 1 <= n、m <= 500    0 <= q <= 1000    1 <= 边权字符串长度 <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/P3733
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class167/Code05_EightVerticalHorizontal2.java b/src/class167/Code05_EightVerticalHorizontal2.java
index 88dff9a61..3d9a5e22e 100644
--- a/src/class167/Code05_EightVerticalHorizontal2.java
+++ b/src/class167/Code05_EightVerticalHorizontal2.java
@@ -8,8 +8,7 @@
 // 操作 Cancel k   : 删除编号为k的边
 // 操作 Change k z : 编号为k的边，边权修改成z，z为01字符串
 // 从1号点出发，最后回到1号点，边随便走，沿途所有边的边权异或起来
-// 打印只有初始m条边的情况下，异或最大值为多少
-// 每一条操作结束后，都打印异或最大值为多少
+// 打印只有初始m条边的情况下，异或最大值为多少，每一条操作结束后，都打印异或最大值为多少
 // 1 <= n、m <= 500    0 <= q <= 1000    1 <= 边权字符串长度 <= 1000
 // 测试链接 : https://www.luogu.com.cn/problem/P3733
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From ce0935bf17740ce807ffd8366e94466c9605f0d4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 11:39:24 +0800
Subject: [PATCH 0749/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java       |  2 +-
 src/class167/Code01_MuseumRobbery2.java       |  2 +-
 src/class167/Code02_AdditionOnSegments1.java  | 20 +++++++++----------
 .../Code05_EightVerticalHorizontal1.java      | 12 +++++------
 4 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index 67f118754..1aaeaa7b4 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -23,8 +23,8 @@ public class Code01_MuseumRobbery1 {
 
 	public static int MAXN = 40001;
 	public static int MAXQ = 30001;
-	public static int MAXT = 1000001;
 	public static int MAXK = 1001;
+	public static int MAXT = 1000001;
 	public static int DEEP = 20;
 	public static int MOD = 1000000007;
 	public static int BASE = 10000019;
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index acf34670c..1550d3bb2 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -21,8 +21,8 @@
 //
 //const int MAXN = 40001;
 //const int MAXQ = 30001;
-//const int MAXT = 1000001;
 //const int MAXK = 1001;
+//const int MAXT = 1000001;
 //const int DEEP = 20;
 //const long long MOD = 1000000007LL;
 //const long long BASE = 10000019LL;
diff --git a/src/class167/Code02_AdditionOnSegments1.java b/src/class167/Code02_AdditionOnSegments1.java
index 136b6786a..a1aec5403 100644
--- a/src/class167/Code02_AdditionOnSegments1.java
+++ b/src/class167/Code02_AdditionOnSegments1.java
@@ -21,8 +21,8 @@ public class Code02_AdditionOnSegments1 {
 	public static int MAXN = 10001;
 	public static int MAXT = 500001;
 	public static int BIT = 10000;
-	public static int INTBIT = 32;
-	public static int LEN = BIT / INTBIT + 1;
+	public static int INT_BIT = 32;
+	public static int LEN = BIT / INT_BIT + 1;
 	public static int DEEP = 20;
 	public static int n, q;
 
@@ -52,15 +52,15 @@ public static void clone(int[] set1, int[] set2) {
 
 	// 返回位图第i位的状态
 	public static int getBit(int[] bitset, int i) {
-		return (bitset[i / INTBIT] >> (i % INTBIT)) & 1;
+		return (bitset[i / INT_BIT] >> (i % INT_BIT)) & 1;
 	}
 
 	// 第i位的状态设置成v
 	public static void setBit(int[] bitset, int i, int v) {
 		if (v == 0) {
-			bitset[i / INTBIT] &= ~(1 << (i % INTBIT));
+			bitset[i / INT_BIT] &= ~(1 << (i % INT_BIT));
 		} else {
-			bitset[i / INTBIT] |= 1 << (i % INTBIT);
+			bitset[i / INT_BIT] |= 1 << (i % INT_BIT);
 		}
 	}
 
@@ -83,14 +83,14 @@ public static void bitLeft(int[] ret, int[] bitset, int move) {
 			clone(ret, bitset);
 			return;
 		}
-		int shift = move / INTBIT;
-		int offset = move % INTBIT;
+		int shift = move / INT_BIT;
+		int offset = move % INT_BIT;
 		if (offset == 0) {
 			for (int i = LEN - 1, j = i - shift; j >= 0; i--, j--) {
 				ret[i] = bitset[j];
 			}
 		} else {
-			int carry = INTBIT - offset, high, low;
+			int carry = INT_BIT - offset, high, low;
 			for (int i = LEN - 1; i > shift; i--) {
 				high = bitset[i - shift] << offset;
 				low = bitset[i - shift - 1] >>> carry;
@@ -98,9 +98,9 @@ public static void bitLeft(int[] ret, int[] bitset, int move) {
 			}
 			ret[shift] = bitset[0] << offset;
 		}
-		int rest = LEN * INTBIT - (BIT + 1);
+		int rest = LEN * INT_BIT - (BIT + 1);
 		if (rest > 0) {
-			ret[LEN - 1] &= (1 << (INTBIT - rest)) - 1;
+			ret[LEN - 1] &= (1 << (INT_BIT - rest)) - 1;
 		}
 	}
 
diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index dba6be8ba..977754c79 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -24,7 +24,7 @@ public class Code05_EightVerticalHorizontal1 {
 	public static int MAXQ = 1001;
 	public static int MAXT = 10001;
 	public static int BIT = 999;
-	public static int INTBIT = 32;
+	public static int INT_BIT = 32;
 
 	// 位图
 	static class BitSet {
@@ -34,12 +34,12 @@ static class BitSet {
 		public int[] arr;
 
 		public BitSet() {
-			len = BIT / INTBIT + 1;
+			len = BIT / INT_BIT + 1;
 			arr = new int[len];
 		}
 
 		public BitSet(String s) {
-			len = BIT / INTBIT + 1;
+			len = BIT / INT_BIT + 1;
 			arr = new int[len];
 			for (int i = 0, j = s.length() - 1; i < s.length(); i++, j--) {
 				set(i, s.charAt(j) - '0');
@@ -48,15 +48,15 @@ public BitSet(String s) {
 
 		// 返回第i位的状态
 		public int get(int i) {
-			return (arr[i / INTBIT] >> (i % INTBIT)) & 1;
+			return (arr[i / INT_BIT] >> (i % INT_BIT)) & 1;
 		}
 
 		// 设置第i位的状态
 		public void set(int i, int v) {
 			if (v == 0) {
-				arr[i / INTBIT] &= ~(1 << (i % INTBIT));
+				arr[i / INT_BIT] &= ~(1 << (i % INT_BIT));
 			} else {
-				arr[i / INTBIT] |= 1 << (i % INTBIT);
+				arr[i / INT_BIT] |= 1 << (i % INT_BIT);
 			}
 		}
 

From 06b723271817628ee13175b40bd6fd9cae9494e0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 13:05:44 +0800
Subject: [PATCH 0750/1712] modify code

---
 src/class167/Code03_BlueMoon1.java | 10 ++++------
 src/class167/Code03_BlueMoon2.java | 10 ++++------
 2 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/class167/Code03_BlueMoon1.java b/src/class167/Code03_BlueMoon1.java
index 8cbc2d2bf..d7cfab9f7 100644
--- a/src/class167/Code03_BlueMoon1.java
+++ b/src/class167/Code03_BlueMoon1.java
@@ -39,7 +39,6 @@ public class Code03_BlueMoon1 {
 	public static int[] tov = new int[MAXT];
 	public static int cnt = 0;
 
-	public static int used = 0;
 	public static long[][] dp = new long[MAXM][MAXP];
 	public static long[] ans = new long[MAXM];
 
@@ -64,7 +63,7 @@ public static void add(int jobl, int jobr, int jobw, int jobv, int l, int r, int
 		}
 	}
 
-	public static void dfs(int l, int r, int i) {
+	public static void dfs(int l, int r, int i, int used) {
 		int siz = 0;
 		for (int e = head[i], w, v; e > 0; e = next[e]) {
 			w = tow[e];
@@ -94,10 +93,9 @@ public static void dfs(int l, int r, int i) {
 			}
 		} else {
 			int mid = (l + r) >> 1;
-			dfs(l, mid, i << 1);
-			dfs(mid + 1, r, i << 1 | 1);
+			dfs(l, mid, i << 1, used);
+			dfs(mid + 1, r, i << 1 | 1, used);
 		}
-		used -= siz;
 	}
 
 	public static void prepare() {
@@ -159,7 +157,7 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		prepare();
-		dfs(1, m, 1);
+		dfs(1, m, 1, 0);
 		for (int i = 1; i <= m; i++) {
 			if (op[i] == 5) {
 				out.println(ans[i]);
diff --git a/src/class167/Code03_BlueMoon2.java b/src/class167/Code03_BlueMoon2.java
index 740212e10..396bbedfa 100644
--- a/src/class167/Code03_BlueMoon2.java
+++ b/src/class167/Code03_BlueMoon2.java
@@ -36,7 +36,6 @@
 //int tov[MAXT];
 //int cnt = 0;
 //
-//int used = 0;
 //long long dp[MAXM][MAXP];
 //long long ans[MAXM];
 //
@@ -61,7 +60,7 @@
 //    }
 //}
 //
-//void dfs(int l, int r, int i) {
+//void dfs(int l, int r, int i, int used) {
 //    int siz = 0;
 //    for (int e = head[i], w, v; e > 0; e = nxt[e]) {
 //        w = tow[e];
@@ -88,10 +87,9 @@
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
-//        dfs(l, mid, i << 1);
-//        dfs(mid + 1, r, i << 1 | 1);
+//        dfs(l, mid, i << 1, used);
+//        dfs(mid + 1, r, i << 1 | 1, used);
 //    }
-//    used -= siz;
 //}
 //
 //void prepare() {
@@ -149,7 +147,7 @@
 //        }
 //    }
 //    prepare();
-//    dfs(1, m, 1);
+//    dfs(1, m, 1, 0);
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 5) {
 //            cout << ans[i] << '\n';

From 63df660abb6282b1186f052354ecb39480c28117 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 13:18:34 +0800
Subject: [PATCH 0751/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java | 8 ++++----
 src/class167/Code01_MuseumRobbery2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index 1aaeaa7b4..d887a4e8a 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -1,13 +1,13 @@
 package class167;
 
 // 博物馆劫案，java版
-// 给定正数k、BASE、MOD，定义a(m) = 当前商品集合s中，挑选商品总重量<=m，能获得的最大价值
-// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
-// 给定n件商品，编号1~n，每种商品给定v和w，每件商品都加入商品集合s
+// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BASE、MOD
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
-// 操作 2 x   : 集合s中删除编号为x的商品
+// 操作 2 x   : 集合s中删除编号为x的商品，保证编号x的商品之前没有删除
 // 操作 3     : 查询当前的f(s)
+// 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
+// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
 // 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index 1550d3bb2..4a331b66d 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -1,13 +1,13 @@
 package class167;
 
 // 博物馆劫案，C++版
-// 给定正数k、BASE、MOD，定义a(m) = 当前商品集合s中，挑选商品总重量<=m，能获得的最大价值
-// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
-// 给定n件商品，编号1~n，每种商品给定v和w，每件商品都加入商品集合s
+// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BASE、MOD
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
-// 操作 2 x   : 集合s中删除编号为x的商品
+// 操作 2 x   : 集合s中删除编号为x的商品，保证编号x的商品之前没有删除
 // 操作 3     : 查询当前的f(s)
+// 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
+// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
 // 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E

From 46a514a6c3e61108deba2028c85e87a3039718af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 13:21:07 +0800
Subject: [PATCH 0752/1712] modify code

---
 src/class167/Code04_ShortestPathQueries1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class167/Code04_ShortestPathQueries1.java b/src/class167/Code04_ShortestPathQueries1.java
index 7f66f4468..d21e2dd8b 100644
--- a/src/class167/Code04_ShortestPathQueries1.java
+++ b/src/class167/Code04_ShortestPathQueries1.java
@@ -41,7 +41,7 @@ public class Code04_ShortestPathQueries1 {
 	public static int[] inspos = new int[BIT + 1];
 	public static int basiz = 0;
 
-	// 可撤销并查集 + 带权并查集
+	// 带权并查集 + 可撤销并查集
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] eor = new int[MAXN];

From 574212f824e40aadf3cd1110913ad903832a821c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 15:53:53 +0800
Subject: [PATCH 0753/1712] modify code

---
 src/class167/Code07_MinimumXor1.java | 22 +++++++++++-----------
 src/class167/Code07_MinimumXor2.java | 22 +++++++++++-----------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/class167/Code07_MinimumXor1.java b/src/class167/Code07_MinimumXor1.java
index 41b3f1e51..8f3482e88 100644
--- a/src/class167/Code07_MinimumXor1.java
+++ b/src/class167/Code07_MinimumXor1.java
@@ -27,8 +27,8 @@ public class Code07_MinimumXor1 {
 	public static int[] pass = new int[MAXN];
 	public static int cnt = 1;
 
-	public static int[] eor = new int[MAXN];
-	public static int[] num = new int[MAXN];
+	public static int[] mineor = new int[MAXN];
+	public static int[] only = new int[MAXN];
 
 	public static int insert(int x, int changeCnt) {
 		int cur = 1;
@@ -47,24 +47,24 @@ public static int insert(int x, int changeCnt) {
 
 	public static void compute(int x, int changeCnt) {
 		int bottom = insert(x, changeCnt);
-		eor[bottom] = pass[bottom] >= 2 ? 0 : INF;
-		num[bottom] = pass[bottom] == 1 ? x : 0;
+		mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
+		only[bottom] = pass[bottom] == 1 ? x : 0;
 		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 			l = tree[i][0];
 			r = tree[i][1];
 			if (pass[i] < 2) {
-				eor[i] = INF;
+				mineor[i] = INF;
 			} else if ((l != 0) ^ (r != 0)) {
-				eor[i] = l > 0 ? eor[l] : eor[r];
+				mineor[i] = l > 0 ? mineor[l] : mineor[r];
 			} else if (Math.max(pass[l], pass[r]) == 1) {
-				eor[i] = num[l] ^ num[r];
+				mineor[i] = only[l] ^ only[r];
 			} else {
-				eor[i] = Math.min(eor[l], eor[r]);
+				mineor[i] = Math.min(mineor[l], mineor[r]);
 			}
 			if (pass[l] + pass[r] == 1) {
-				num[i] = pass[l] == 1 ? num[l] : num[r];
+				only[i] = pass[l] == 1 ? only[l] : only[r];
 			} else {
-				num[i] = 0;
+				only[i] = 0;
 			}
 		}
 	}
@@ -76,7 +76,7 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1, op, x; i <= q; i++) {
 			op = in.nextInt();
 			if (op == 3) {
-				out.println(eor[1]);
+				out.println(mineor[1]);
 			} else {
 				x = in.nextInt();
 				if (op == 1) {
diff --git a/src/class167/Code07_MinimumXor2.java b/src/class167/Code07_MinimumXor2.java
index e664267a2..a33df8e2a 100644
--- a/src/class167/Code07_MinimumXor2.java
+++ b/src/class167/Code07_MinimumXor2.java
@@ -25,8 +25,8 @@
 //int pass[MAXN];
 //int cnt = 1;
 //
-//int eor[MAXN];
-//int num[MAXN];
+//int mineor[MAXN];
+//int only[MAXN];
 //
 //int insert(int x, int changeCnt) {
 //    int cur = 1;
@@ -45,24 +45,24 @@
 //
 //void compute(int x, int changeCnt) {
 //    int bottom = insert(x, changeCnt);
-//    eor[bottom] = pass[bottom] >= 2 ? 0 : INF;
-//    num[bottom] = pass[bottom] == 1 ? x : 0;
+//    mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
+//    only[bottom] = pass[bottom] == 1 ? x : 0;
 //    for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 //        l = tree[i][0];
 //        r = tree[i][1];
 //        if (pass[i] < 2) {
-//            eor[i] = INF;
+//            mineor[i] = INF;
 //        } else if ((l != 0) ^ (r != 0)) {
-//            eor[i] = l > 0 ? eor[l] : eor[r];
+//            mineor[i] = l > 0 ? mineor[l] : mineor[r];
 //        } else if (max(pass[l], pass[r]) == 1) {
-//            eor[i] = num[l] ^ num[r];
+//            mineor[i] = only[l] ^ only[r];
 //        } else {
-//            eor[i] = min(eor[l], eor[r]);
+//            mineor[i] = min(mineor[l], mineor[r]);
 //        }
 //        if (pass[l] + pass[r] == 1) {
-//        	num[i] = pass[l] == 1 ? num[l] : num[r];
+//        	only[i] = pass[l] == 1 ? only[l] : only[r];
 //        } else {
-//        	num[i] = 0;
+//        	only[i] = 0;
 //        }
 //    }
 //}
@@ -75,7 +75,7 @@
 //    for (int i = 1, op, x; i <= q; i++) {
 //        cin >> op;
 //        if (op == 3) {
-//            cout << eor[1] << '\n';
+//            cout << mineor[1] << '\n';
 //        } else {
 //            cin >> x;
 //            if (op == 1) {

From f04b9c0cde3b6f9641c0d49caf350cbeb99b10dc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 16:20:40 +0800
Subject: [PATCH 0754/1712] modify code

---
 ...3_BlueMoon1.java => Code02_BlueMoon1.java} | 28 +++++++++----------
 ...3_BlueMoon2.java => Code02_BlueMoon2.java} | 27 +++++++++---------
 ...1.java => Code03_AdditionOnSegments1.java} |  2 +-
 ...2.java => Code03_AdditionOnSegments2.java} |  0
 4 files changed, 28 insertions(+), 29 deletions(-)
 rename src/class167/{Code03_BlueMoon1.java => Code02_BlueMoon1.java} (90%)
 rename src/class167/{Code03_BlueMoon2.java => Code02_BlueMoon2.java} (86%)
 rename src/class167/{Code02_AdditionOnSegments1.java => Code03_AdditionOnSegments1.java} (99%)
 rename src/class167/{Code02_AdditionOnSegments2.java => Code03_AdditionOnSegments2.java} (100%)

diff --git a/src/class167/Code03_BlueMoon1.java b/src/class167/Code02_BlueMoon1.java
similarity index 90%
rename from src/class167/Code03_BlueMoon1.java
rename to src/class167/Code02_BlueMoon1.java
index d7cfab9f7..66550e3d9 100644
--- a/src/class167/Code03_BlueMoon1.java
+++ b/src/class167/Code02_BlueMoon1.java
@@ -21,7 +21,7 @@
 import java.util.ArrayDeque;
 import java.util.Deque;
 
-public class Code03_BlueMoon1 {
+public class Code02_BlueMoon1 {
 
 	public static int MAXM = 50001;
 	public static int MAXP = 501;
@@ -99,27 +99,25 @@ public static void dfs(int l, int r, int i, int used) {
 	}
 
 	public static void prepare() {
-		Deque<int[]> deque = new ArrayDeque<>();
-		int[] data;
+		// 背包<装备特征值、装备战斗力、装备出现时间点>
+		Deque<int[]> knapsack = new ArrayDeque<>();
+		int[] equip;
 		for (int i = 1; i <= m; i++) {
 			if (op[i] == 1) {
-				deque.addFirst(new int[] { x[i] % p, y[i], i });
+				knapsack.addFirst(new int[] { x[i] % p, y[i], i });
 			} else if (op[i] == 2) {
-				deque.addLast(new int[] { x[i] % p, y[i], i });
+				knapsack.addLast(new int[] { x[i] % p, y[i], i });
 			} else if (op[i] == 3) {
-				data = deque.peekFirst();
-				add(data[2], i - 1, data[0], data[1], 1, m, 1);
-				deque.pollFirst();
+				equip = knapsack.pollFirst();
+				add(equip[2], i - 1, equip[0], equip[1], 1, m, 1);
 			} else if (op[i] == 4) {
-				data = deque.peekLast();
-				add(data[2], i - 1, data[0], data[1], 1, m, 1);
-				deque.pollLast();
+				equip = knapsack.pollLast();
+				add(equip[2], i - 1, equip[0], equip[1], 1, m, 1);
 			}
 		}
-		while (!deque.isEmpty()) {
-			data = deque.peekFirst();
-			add(data[2], m, data[0], data[1], 1, m, 1);
-			deque.pollFirst();
+		while (!knapsack.isEmpty()) {
+			equip = knapsack.pollFirst();
+			add(equip[2], m, equip[0], equip[1], 1, m, 1);
 		}
 		for (int i = 0; i < MAXM; i++) {
 			for (int j = 0; j < MAXP; j++) {
diff --git a/src/class167/Code03_BlueMoon2.java b/src/class167/Code02_BlueMoon2.java
similarity index 86%
rename from src/class167/Code03_BlueMoon2.java
rename to src/class167/Code02_BlueMoon2.java
index 396bbedfa..c32269704 100644
--- a/src/class167/Code03_BlueMoon2.java
+++ b/src/class167/Code02_BlueMoon2.java
@@ -93,26 +93,27 @@
 //}
 //
 //void prepare() {
-//    deque<array<int,3>> dq;
+//    deque<array<int,3>> knapsack;
+//    array<int,3> equip;
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 1) {
-//            dq.push_front({x[i] % p, y[i], i});
+//            knapsack.push_front({x[i] % p, y[i], i});
 //        } else if (op[i] == 2) {
-//            dq.push_back({x[i] % p, y[i], i});
+//            knapsack.push_back({x[i] % p, y[i], i});
 //        } else if (op[i] == 3) {
-//            auto data = dq.front();
-//            add(data[2], i - 1, data[0], data[1], 1, m, 1);
-//            dq.pop_front();
+//            equip = knapsack.front();
+//            add(equip[2], i - 1, equip[0], equip[1], 1, m, 1);
+//            knapsack.pop_front();
 //        } else if (op[i] == 4) {
-//            auto data = dq.back();
-//            add(data[2], i - 1, data[0], data[1], 1, m, 1);
-//            dq.pop_back();
+//            equip = knapsack.back();
+//            add(equip[2], i - 1, equip[0], equip[1], 1, m, 1);
+//            knapsack.pop_back();
 //        }
 //    }
-//    while (!dq.empty()) {
-//        auto data = dq.front();
-//        add(data[2], m, data[0], data[1], 1, m, 1);
-//        dq.pop_front();
+//    while (!knapsack.empty()) {
+//        equip = knapsack.front();
+//        add(equip[2], m, equip[0], equip[1], 1, m, 1);
+//        knapsack.pop_front();
 //    }
 //    for (int i = 0; i < MAXM; i++) {
 //        for (int j = 0; j < MAXP; j++) {
diff --git a/src/class167/Code02_AdditionOnSegments1.java b/src/class167/Code03_AdditionOnSegments1.java
similarity index 99%
rename from src/class167/Code02_AdditionOnSegments1.java
rename to src/class167/Code03_AdditionOnSegments1.java
index a1aec5403..26b6467e5 100644
--- a/src/class167/Code02_AdditionOnSegments1.java
+++ b/src/class167/Code03_AdditionOnSegments1.java
@@ -16,7 +16,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_AdditionOnSegments1 {
+public class Code03_AdditionOnSegments1 {
 
 	public static int MAXN = 10001;
 	public static int MAXT = 500001;
diff --git a/src/class167/Code02_AdditionOnSegments2.java b/src/class167/Code03_AdditionOnSegments2.java
similarity index 100%
rename from src/class167/Code02_AdditionOnSegments2.java
rename to src/class167/Code03_AdditionOnSegments2.java

From eba83eace67cee198d308c4bc19531c35dd722d3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 16:30:05 +0800
Subject: [PATCH 0755/1712] modify code

---
 src/class167/Code02_BlueMoon1.java | 5 +++--
 src/class167/Code02_BlueMoon2.java | 3 ++-
 2 files changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/class167/Code02_BlueMoon1.java b/src/class167/Code02_BlueMoon1.java
index 66550e3d9..803691e5e 100644
--- a/src/class167/Code02_BlueMoon1.java
+++ b/src/class167/Code02_BlueMoon1.java
@@ -33,6 +33,9 @@ public class Code02_BlueMoon1 {
 	public static int[] x = new int[MAXM];
 	public static int[] y = new int[MAXM];
 
+	// 背包<装备特征值、装备战斗力、装备出现时间点>
+	public static Deque<int[]> knapsack = new ArrayDeque<>();
+
 	public static int[] head = new int[MAXM << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tow = new int[MAXT];
@@ -99,8 +102,6 @@ public static void dfs(int l, int r, int i, int used) {
 	}
 
 	public static void prepare() {
-		// 背包<装备特征值、装备战斗力、装备出现时间点>
-		Deque<int[]> knapsack = new ArrayDeque<>();
 		int[] equip;
 		for (int i = 1; i <= m; i++) {
 			if (op[i] == 1) {
diff --git a/src/class167/Code02_BlueMoon2.java b/src/class167/Code02_BlueMoon2.java
index c32269704..8e00cbeaf 100644
--- a/src/class167/Code02_BlueMoon2.java
+++ b/src/class167/Code02_BlueMoon2.java
@@ -30,6 +30,8 @@
 //int x[MAXM];
 //int y[MAXM];
 //
+//deque<array<int,3>> knapsack;
+//
 //int head[MAXM << 2];
 //int nxt[MAXT];
 //int tow[MAXT];
@@ -93,7 +95,6 @@
 //}
 //
 //void prepare() {
-//    deque<array<int,3>> knapsack;
 //    array<int,3> equip;
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 1) {

From 779414fe54730dcdc5e85d405864f36c3b4da059 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 16:36:53 +0800
Subject: [PATCH 0756/1712] modify code

---
 src/class167/Code02_BlueMoon1.java | 13 ++++---------
 src/class167/Code02_BlueMoon2.java | 10 ++++------
 2 files changed, 8 insertions(+), 15 deletions(-)

diff --git a/src/class167/Code02_BlueMoon1.java b/src/class167/Code02_BlueMoon1.java
index 803691e5e..b4088f208 100644
--- a/src/class167/Code02_BlueMoon1.java
+++ b/src/class167/Code02_BlueMoon1.java
@@ -26,7 +26,6 @@ public class Code02_BlueMoon1 {
 	public static int MAXM = 50001;
 	public static int MAXP = 501;
 	public static int MAXT = 1000001;
-	public static long INF = 1000000000001L;
 	public static int m, p;
 
 	public static int[] op = new int[MAXM];
@@ -75,7 +74,7 @@ public static void dfs(int l, int r, int i, int used) {
 				dp[used + siz + 1][j] = dp[used + siz][j];
 			}
 			for (int j = 0; j < p; j++) {
-				if (dp[used + siz][j] != -INF) {
+				if (dp[used + siz][j] != -1) {
 					dp[used + siz + 1][(j + w) % p] = Math.max(dp[used + siz + 1][(j + w) % p], dp[used + siz][j] + v);
 				}
 			}
@@ -84,15 +83,11 @@ public static void dfs(int l, int r, int i, int used) {
 		used += siz;
 		if (l == r) {
 			if (op[l] == 5) {
-				long ret = -INF;
+				long ret = -1;
 				for (int j = x[l]; j <= y[l]; j++) {
 					ret = Math.max(ret, dp[used][j]);
 				}
-				if (ret == -INF) {
-					ans[l] = -1;
-				} else {
-					ans[l] = ret;
-				}
+				ans[l] = ret;
 			}
 		} else {
 			int mid = (l + r) >> 1;
@@ -122,7 +117,7 @@ public static void prepare() {
 		}
 		for (int i = 0; i < MAXM; i++) {
 			for (int j = 0; j < MAXP; j++) {
-				dp[i][j] = -INF;
+				dp[i][j] = -1;
 			}
 		}
 		dp[0][0] = 0;
diff --git a/src/class167/Code02_BlueMoon2.java b/src/class167/Code02_BlueMoon2.java
index 8e00cbeaf..8679b76e5 100644
--- a/src/class167/Code02_BlueMoon2.java
+++ b/src/class167/Code02_BlueMoon2.java
@@ -22,8 +22,6 @@
 //const int MAXM = 50001;
 //const int MAXP = 501;
 //const int MAXT = 1000001;
-//const long long INF = 1000000000001LL;
-//
 //int m, p;
 //
 //int op[MAXM];
@@ -71,7 +69,7 @@
 //            dp[used + siz + 1][j] = dp[used + siz][j];
 //        }
 //        for (int j = 0; j < p; j++) {
-//            if (dp[used + siz][j] != -INF) {
+//            if (dp[used + siz][j] != -1) {
 //                int nj = (j + w) % p;
 //                dp[used + siz + 1][nj] = max(dp[used + siz + 1][nj], dp[used + siz][j] + v);
 //            }
@@ -81,11 +79,11 @@
 //    used += siz;
 //    if (l == r) {
 //        if (op[l] == 5) {
-//            long long ret = -INF;
+//            long long ret = -1;
 //            for (int j = x[l]; j <= y[l]; j++) {
 //                ret = max(ret, dp[used][j]);
 //            }
-//            ans[l] = (ret == -INF ? -1 : ret);
+//            ans[l] = ret;
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
@@ -118,7 +116,7 @@
 //    }
 //    for (int i = 0; i < MAXM; i++) {
 //        for (int j = 0; j < MAXP; j++) {
-//            dp[i][j] = -INF;
+//            dp[i][j] = -1;
 //        }
 //    }
 //    dp[0][0] = 0;

From 971aa9c08585ec6e12aadaec89c72aead6dea878 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 16:41:22 +0800
Subject: [PATCH 0757/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java | 2 +-
 src/class167/Code01_MuseumRobbery2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index d887a4e8a..d1c79d950 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -4,7 +4,7 @@
 // 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BASE、MOD
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
-// 操作 2 x   : 集合s中删除编号为x的商品，保证编号x的商品之前没有删除
+// 操作 2 x   : 集合s中删除编号为x的商品，删除时保证x号商品存在
 // 操作 3     : 查询当前的f(s)
 // 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
 // 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index 4a331b66d..9d4d7dc50 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -4,7 +4,7 @@
 // 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BASE、MOD
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
-// 操作 2 x   : 集合s中删除编号为x的商品，保证编号x的商品之前没有删除
+// 操作 2 x   : 集合s中删除编号为x的商品，删除时保证x号商品存在
 // 操作 3     : 查询当前的f(s)
 // 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
 // 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )

From 2ed63c1371342779c28b85832dd793e0b5487804 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 16:53:30 +0800
Subject: [PATCH 0758/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java | 19 ++++++++++--------
 src/class167/Code01_MuseumRobbery2.java | 26 +++++++++++++------------
 2 files changed, 25 insertions(+), 20 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index d1c79d950..d21b660de 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -1,13 +1,13 @@
 package class167;
 
 // 博物馆劫案，java版
-// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BASE、MOD
+// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BAS、MOD
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
 // 操作 2 x   : 集合s中删除编号为x的商品，删除时保证x号商品存在
 // 操作 3     : 查询当前的f(s)
 // 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
-// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
+// 定义f(s) = ∑(m = 1...k) ( a(m) * BAS的m-1次方 % MOD )
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
 // 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
@@ -26,19 +26,20 @@ public class Code01_MuseumRobbery1 {
 	public static int MAXK = 1001;
 	public static int MAXT = 1000001;
 	public static int DEEP = 20;
+	public static int BAS = 10000019;
 	public static int MOD = 1000000007;
-	public static int BASE = 10000019;
 	public static int n, k, q;
 
 	public static int[] v = new int[MAXN];
 	public static int[] w = new int[MAXN];
-	public static int[] from = new int[MAXN];
-	public static int[] to = new int[MAXN];
 
 	public static int[] op = new int[MAXQ];
 	public static int[] x = new int[MAXQ];
 	public static int[] y = new int[MAXQ];
 
+	public static int[] from = new int[MAXN];
+	public static int[] to = new int[MAXN];
+
 	public static int[] head = new int[MAXQ << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tov = new int[MAXT];
@@ -87,11 +88,13 @@ public static void dfs(int l, int r, int i, int dep) {
 		}
 		if (l == r) {
 			if (op[l] == 3) {
-				long b = 1;
+				long ret = 0;
+				long base = 1;
 				for (int j = 1; j <= k; j++) {
-					ans[l] = (ans[l] + dp[j] * b) % MOD;
-					b = (b * BASE) % MOD;
+					ret = (ret + dp[j] * base) % MOD;
+					base = (base * BAS) % MOD;
 				}
+				ans[l] = ret;
 			}
 		} else {
 			int mid = (l + r) >> 1;
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index 9d4d7dc50..af48ba0d2 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -1,13 +1,13 @@
 package class167;
 
 // 博物馆劫案，C++版
-// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BASE、MOD
+// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BAS、MOD
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
 // 操作 2 x   : 集合s中删除编号为x的商品，删除时保证x号商品存在
 // 操作 3     : 查询当前的f(s)
 // 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
-// 定义f(s) = ∑(m = 1...k) ( a(m) * BASE的m-1次方 % MOD )
+// 定义f(s) = ∑(m = 1...k) ( a(m) * BAS的m-1次方 % MOD )
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
 // 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
@@ -24,20 +24,20 @@
 //const int MAXK = 1001;
 //const int MAXT = 1000001;
 //const int DEEP = 20;
+//const long long BAS = 10000019LL;
 //const long long MOD = 1000000007LL;
-//const long long BASE = 10000019LL;
-//
 //int n, k, q;
 //
 //int v[MAXN];
 //int w[MAXN];
-//int from[MAXN];
-//int to[MAXN];
 //
 //int op[MAXQ];
 //int x[MAXQ];
 //int y[MAXQ];
 //
+//int from[MAXN];
+//int to[MAXN];
+//
 //int head[MAXQ << 2];
 //int nxt[MAXT];
 //int tov[MAXT];
@@ -86,11 +86,13 @@
 //    }
 //    if (l == r) {
 //        if (op[l] == 3) {
-//            long long b = 1;
+//            long long ret = 0;
+//            long long base = 1;
 //            for (int j = 1; j <= k; j++) {
-//                ans[l] = (ans[l] + dp[j] * b) % MOD;
-//                b = (b * BASE) % MOD;
+//                ret = (ret + dp[j] * base) % MOD;
+//                base = (base * BAS) % MOD;
 //            }
+//            ans[l] = ret;
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
@@ -102,8 +104,8 @@
 //
 //void prepare() {
 //    for (int i = 1; i <= n; i++) {
-//    	from[i] = 1;
-//    	to[i] = q;
+//        from[i] = 1;
+//        to[i] = q;
 //    }
 //    for (int i = 1; i <= q; i++) {
 //        if (op[i] == 1) {
@@ -113,7 +115,7 @@
 //            from[n] = i;
 //            to[n] = q;
 //        } else if (op[i] == 2) {
-//        	to[x[i]] = i;
+//            to[x[i]] = i;
 //        }
 //    }
 //    for (int i = 1; i <= n; i++) {

From 9a5c70099a11d8ff1f38fe5ea5c066c8895da513 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 17:01:55 +0800
Subject: [PATCH 0759/1712] modify code

---
 src/class167/Code02_BlueMoon1.java                | 3 +--
 src/class167/Code02_BlueMoon2.java                | 3 +--
 src/class167/Code05_EightVerticalHorizontal1.java | 3 +--
 src/class167/Code05_EightVerticalHorizontal2.java | 3 +--
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/class167/Code02_BlueMoon1.java b/src/class167/Code02_BlueMoon1.java
index b4088f208..a706a7c03 100644
--- a/src/class167/Code02_BlueMoon1.java
+++ b/src/class167/Code02_BlueMoon1.java
@@ -7,8 +7,7 @@
 // 操作 IG x y : 背包后端加入一件特征值x、战斗力y的装备
 // 操作 DF     : 删除背包前端的装备
 // 操作 DG     : 删除背包后端的装备
-// 操作 QU x y : 选择装备的特征值累加和 % p，必须在[x, y]范围
-//               打印能得到的最大战斗力是多少，没有合法方案打印-1
+// 操作 QU x y : 选择装备的特征值累加和 % p，必须在[x, y]范围，打印最大战斗力，无方案打印-1
 // 1 <= m <= 5 * 10^4    1 <= p <= 500
 // 0 <= 每件装备特征值、每件装备战斗力 <= 10^9
 // 测试链接 : https://loj.ac/p/6515
diff --git a/src/class167/Code02_BlueMoon2.java b/src/class167/Code02_BlueMoon2.java
index 8679b76e5..67ad8490f 100644
--- a/src/class167/Code02_BlueMoon2.java
+++ b/src/class167/Code02_BlueMoon2.java
@@ -7,8 +7,7 @@
 // 操作 IG x y : 背包后端加入一件特征值x、战斗力y的装备
 // 操作 DF     : 删除背包前端的装备
 // 操作 DG     : 删除背包后端的装备
-// 操作 QU x y : 选择装备的特征值累加和 % p，必须在[x, y]范围
-//               打印能得到的最大战斗力是多少，没有合法方案打印-1
+// 操作 QU x y : 选择装备的特征值累加和 % p，必须在[x, y]范围，打印最大战斗力，无方案打印-1
 // 1 <= m <= 5 * 10^4    1 <= p <= 500
 // 0 <= 每件装备特征值、每件装备战斗力 <= 10^9
 // 测试链接 : https://loj.ac/p/6515
diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index 977754c79..f03aac151 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -3,8 +3,7 @@
 // 八纵八横，java版
 // 一共有n个点，给定m条边，每条边的边权，用01字符串表达
 // 初始的m条边永不删除，接下来有q条操作，每种操作是如下三种类型中的一种
-// 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串
-//                   如果这是第k条添加操作，那么这条边编号为k
+// 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串，第k条添加操作，边的编号为k
 // 操作 Cancel k   : 删除编号为k的边
 // 操作 Change k z : 编号为k的边，边权修改成z，z为01字符串
 // 从1号点出发，最后回到1号点，边随便走，沿途所有边的边权异或起来
diff --git a/src/class167/Code05_EightVerticalHorizontal2.java b/src/class167/Code05_EightVerticalHorizontal2.java
index 3d9a5e22e..df9556618 100644
--- a/src/class167/Code05_EightVerticalHorizontal2.java
+++ b/src/class167/Code05_EightVerticalHorizontal2.java
@@ -3,8 +3,7 @@
 // 八纵八横，C++版
 // 一共有n个点，给定m条边，每条边的边权，用01字符串表达
 // 初始的m条边永不删除，接下来有q条操作，每种操作是如下三种类型中的一种
-// 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串
-//                   如果这是第k条添加操作，那么这条边编号为k
+// 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串，第k条添加操作，边的编号为k
 // 操作 Cancel k   : 删除编号为k的边
 // 操作 Change k z : 编号为k的边，边权修改成z，z为01字符串
 // 从1号点出发，最后回到1号点，边随便走，沿途所有边的边权异或起来

From 17221f84fc83c0e69142a1b8ddd571522f8891cc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 17:03:42 +0800
Subject: [PATCH 0760/1712] modify code

---
 src/class167/Code04_ShortestPathQueries1.java | 3 +--
 src/class167/Code04_ShortestPathQueries2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code04_ShortestPathQueries1.java b/src/class167/Code04_ShortestPathQueries1.java
index d21e2dd8b..271792ab5 100644
--- a/src/class167/Code04_ShortestPathQueries1.java
+++ b/src/class167/Code04_ShortestPathQueries1.java
@@ -5,8 +5,7 @@
 // 接下来有q条操作，每种操作是如下三种类型中的一种
 // 操作 1 x y d : 原图中加入，点x到点y，权值为d的边
 // 操作 2 x y   : 原图中删除，点x到点y的边
-// 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来
-//                打印能取得的异或最小值
+// 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来，打印能取得的异或最小值
 // 保证任意操作后，图连通、无重边、无自环，所有操作均合法
 // 1 <= n、m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF938G
diff --git a/src/class167/Code04_ShortestPathQueries2.java b/src/class167/Code04_ShortestPathQueries2.java
index 0bf523f3a..9272b84ef 100644
--- a/src/class167/Code04_ShortestPathQueries2.java
+++ b/src/class167/Code04_ShortestPathQueries2.java
@@ -5,8 +5,7 @@
 // 接下来有q条操作，每种操作是如下三种类型中的一种
 // 操作 1 x y d : 原图中加入，点x到点y，权值为d的边
 // 操作 2 x y   : 原图中删除，点x到点y的边
-// 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来
-//                打印能取得的异或最小值
+// 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来，打印能取得的异或最小值
 // 保证任意操作后，图连通、无重边、无自环，所有操作均合法
 // 1 <= n、m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF938G

From df66d3b4eca85dd27d584b453e775a79ae440ea2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 17:32:40 +0800
Subject: [PATCH 0761/1712] modify code

---
 src/class167/Code06_MarsStore1.java | 8 ++++----
 src/class167/Code06_MarsStore2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class167/Code06_MarsStore1.java b/src/class167/Code06_MarsStore1.java
index 3252a11ea..dd8bc6815 100644
--- a/src/class167/Code06_MarsStore1.java
+++ b/src/class167/Code06_MarsStore1.java
@@ -1,11 +1,11 @@
 package class167;
 
 // 火星商店，java版
-// 有n个商店，编号1~n，初始时每个商店只有一种商品，给定每个商店中唯一商品的价格
+// 有n个商店，每个商店只有一种初始商品，给出每个商店的初始商品价格
 // 有m条操作，每种操作是如下两种类型中的一种
-// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，这天新增了价格为v的商品
-// 操作 1 l r x d : 客人只在商店[l..r]中选择一件商品，只购买d天内的出现的商品
-//                  所有符合要求的商品中，打印 商品的价格 ^ x 的最大值
+// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，在新的一天增加了价格为v的新商品
+// 操作 1 l r x d : 只能在商店[l..r]中挑选，只能挑选初始商品或d天内出现的新商品
+//                  只能挑选一件商品，打印 商品的价格 ^ x 的最大值
 // 注意，只有操作0能让天数+1，操作1不会增加天数
 // 0 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4585
diff --git a/src/class167/Code06_MarsStore2.java b/src/class167/Code06_MarsStore2.java
index 8060913ab..b70bf0ab5 100644
--- a/src/class167/Code06_MarsStore2.java
+++ b/src/class167/Code06_MarsStore2.java
@@ -1,11 +1,11 @@
 package class167;
 
 // 火星商店，C++版
-// 有n个商店，编号1~n，初始时每个商店只有一种商品，给定每个商店中唯一商品的价格
+// 有n个商店，每个商店只有一种初始商品，给出每个商店的初始商品价格
 // 有m条操作，每种操作是如下两种类型中的一种
-// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，这天新增了价格为v的商品
-// 操作 1 l r x d : 客人只在商店[l..r]中选择一件商品，只购买d天内的出现的商品
-//                  所有符合要求的商品中，打印 商品的价格 ^ x 的最大值
+// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，在新的一天增加了价格为v的新商品
+// 操作 1 l r x d : 只能在商店[l..r]中挑选，只能挑选初始商品或d天内出现的新商品
+//                  只能挑选一件商品，打印 商品的价格 ^ x 的最大值
 // 注意，只有操作0能让天数+1，操作1不会增加天数
 // 0 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4585

From 1b0159b7e0b78c965b6e23744458646264432468 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 17:37:20 +0800
Subject: [PATCH 0762/1712] modify code

---
 src/class167/Code06_MarsStore1.java | 4 ++--
 src/class167/Code06_MarsStore2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code06_MarsStore1.java b/src/class167/Code06_MarsStore1.java
index dd8bc6815..4cccefdcf 100644
--- a/src/class167/Code06_MarsStore1.java
+++ b/src/class167/Code06_MarsStore1.java
@@ -3,10 +3,10 @@
 // 火星商店，java版
 // 有n个商店，每个商店只有一种初始商品，给出每个商店的初始商品价格
 // 有m条操作，每种操作是如下两种类型中的一种
-// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，在新的一天增加了价格为v的新商品
+// 操作 0 s v     : 操作0会让天数+1，第s号商店，在这天增加了价格为v的新商品
 // 操作 1 l r x d : 只能在商店[l..r]中挑选，只能挑选初始商品或d天内出现的新商品
 //                  只能挑选一件商品，打印 商品的价格 ^ x 的最大值
-// 注意，只有操作0能让天数+1，操作1不会增加天数
+// 注意，只有操作0能让天数+1，操作1不会
 // 0 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4585
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class167/Code06_MarsStore2.java b/src/class167/Code06_MarsStore2.java
index b70bf0ab5..e4a01b850 100644
--- a/src/class167/Code06_MarsStore2.java
+++ b/src/class167/Code06_MarsStore2.java
@@ -3,10 +3,10 @@
 // 火星商店，C++版
 // 有n个商店，每个商店只有一种初始商品，给出每个商店的初始商品价格
 // 有m条操作，每种操作是如下两种类型中的一种
-// 操作 0 s v     : 只有操作0能让天数+1，第s号商店，在新的一天增加了价格为v的新商品
+// 操作 0 s v     : 操作0会让天数+1，第s号商店，在这天增加了价格为v的新商品
 // 操作 1 l r x d : 只能在商店[l..r]中挑选，只能挑选初始商品或d天内出现的新商品
 //                  只能挑选一件商品，打印 商品的价格 ^ x 的最大值
-// 注意，只有操作0能让天数+1，操作1不会增加天数
+// 注意，只有操作0能让天数+1，操作1不会
 // 0 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4585
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 5318d6ea576b7ec8e0936926c740bc8b987f301a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 17:55:20 +0800
Subject: [PATCH 0763/1712] modify code

---
 src/class167/Code07_MinimumXor1.java | 4 ++--
 src/class167/Code07_MinimumXor2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code07_MinimumXor1.java b/src/class167/Code07_MinimumXor1.java
index 8f3482e88..f8eb21de0 100644
--- a/src/class167/Code07_MinimumXor1.java
+++ b/src/class167/Code07_MinimumXor1.java
@@ -3,8 +3,8 @@
 // 最小异或查询，java版
 // 一共有q条操作，每种操作是如下三种类型中的一种
 // 操作 1 x : 黑板上写上一个数字x，同一种数字可以出现多次
-// 操作 2 x : 将一个x从黑板上擦掉，操作前保证至少有一个x在黑板上
-// 操作 3   : 打印任意两个数的最小异或值，操作前保证黑板上至少有两个数
+// 操作 2 x : 将一个x从黑板上擦掉，操作时保证至少有一个x在黑板上
+// 操作 3   : 打印黑板上任意两数的最小异或值，操作时保证黑板上至少有两个数
 // 1 <= q <= 3 * 10^5
 // 0 <= x <= 2^30
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc308_g
diff --git a/src/class167/Code07_MinimumXor2.java b/src/class167/Code07_MinimumXor2.java
index a33df8e2a..17a641718 100644
--- a/src/class167/Code07_MinimumXor2.java
+++ b/src/class167/Code07_MinimumXor2.java
@@ -3,8 +3,8 @@
 // 最小异或查询，C++版
 // 一共有q条操作，每种操作是如下三种类型中的一种
 // 操作 1 x : 黑板上写上一个数字x，同一种数字可以出现多次
-// 操作 2 x : 将一个x从黑板上擦掉，操作前保证至少有一个x在黑板上
-// 操作 3   : 打印任意两个数的最小异或值，操作前保证黑板上至少有两个数
+// 操作 2 x : 将一个x从黑板上擦掉，操作时保证至少有一个x在黑板上
+// 操作 3   : 打印黑板上任意两数的最小异或值，操作时保证黑板上至少有两个数
 // 1 <= q <= 3 * 10^5
 // 0 <= x <= 2^30
 // 测试链接 : https://www.luogu.com.cn/problem/AT_abc308_g

From 398e367bd88363929a637c29a4313697458170b5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 4 May 2025 18:08:50 +0800
Subject: [PATCH 0764/1712] modify code

---
 src/class167/Code02_BlueMoon1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class167/Code02_BlueMoon1.java b/src/class167/Code02_BlueMoon1.java
index a706a7c03..1547d8a85 100644
--- a/src/class167/Code02_BlueMoon1.java
+++ b/src/class167/Code02_BlueMoon1.java
@@ -31,7 +31,7 @@ public class Code02_BlueMoon1 {
 	public static int[] x = new int[MAXM];
 	public static int[] y = new int[MAXM];
 
-	// 背包<装备特征值、装备战斗力、装备出现时间点>
+	// 背包<装备特征值%p、装备战斗力、装备出现时间点>
 	public static Deque<int[]> knapsack = new ArrayDeque<>();
 
 	public static int[] head = new int[MAXM << 2];

From dca11d036547deda477b5008daa448b3599e558a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 5 May 2025 12:32:36 +0800
Subject: [PATCH 0765/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java |  6 ++++
 src/class167/Code02_BlueMoon1.java      | 48 +++++++++++++++----------
 src/class167/Code02_BlueMoon2.java      | 44 ++++++++++++-----------
 3 files changed, 59 insertions(+), 39 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index d21b660de..658130c85 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -37,17 +37,23 @@ public class Code01_MuseumRobbery1 {
 	public static int[] x = new int[MAXQ];
 	public static int[] y = new int[MAXQ];
 
+	// 第i号商品的生效时间段，从from[i]持续到to[i]
 	public static int[] from = new int[MAXN];
 	public static int[] to = new int[MAXN];
 
+	// 时间轴线段树的区间上挂上生效的商品，价值v，重量w
 	public static int[] head = new int[MAXQ << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tov = new int[MAXT];
 	public static int[] tow = new int[MAXT];
 	public static int cnt = 0;
 
+	// 动态规划表
 	public static long[] dp = new long[MAXK];
+	// 动态规划表的备份
 	public static long[][] backup = new long[DEEP][MAXK];
+
+	// 答案
 	public static long[] ans = new long[MAXQ];
 
 	public static void clone(long[] a, long[] b) {
diff --git a/src/class167/Code02_BlueMoon1.java b/src/class167/Code02_BlueMoon1.java
index 1547d8a85..f8c010f43 100644
--- a/src/class167/Code02_BlueMoon1.java
+++ b/src/class167/Code02_BlueMoon1.java
@@ -25,6 +25,7 @@ public class Code02_BlueMoon1 {
 	public static int MAXM = 50001;
 	public static int MAXP = 501;
 	public static int MAXT = 1000001;
+	public static int DEEP = 20;
 	public static int m, p;
 
 	public static int[] op = new int[MAXM];
@@ -34,15 +35,29 @@ public class Code02_BlueMoon1 {
 	// 背包<装备特征值%p、装备战斗力、装备出现时间点>
 	public static Deque<int[]> knapsack = new ArrayDeque<>();
 
+	// 时间轴线段树的区间上挂上生效的商品，(特征值 % p)记为w，战斗力记为v
 	public static int[] head = new int[MAXM << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tow = new int[MAXT];
 	public static int[] tov = new int[MAXT];
 	public static int cnt = 0;
 
-	public static long[][] dp = new long[MAXM][MAXP];
+	// 动态规划表不考虑当前商品的状态，上一行的状态
+	public static long[] pre = new long[MAXP];
+	// 动态规划表考虑当前商品的状态，本行的状态，需要更新
+	public static long[] dp = new long[MAXP];
+	// 动态规划表的备份
+	public static long[][] backup = new long[DEEP][MAXP];
+
+	// 答案
 	public static long[] ans = new long[MAXM];
 
+	public static void clone(long[] a, long[] b) {
+		for (int i = 0; i < p; i++) {
+			a[i] = b[i];
+		}
+	}
+
 	public static void addEdge(int i, int w, int v) {
 		next[++cnt] = head[i];
 		tow[cnt] = w;
@@ -64,35 +79,32 @@ public static void add(int jobl, int jobr, int jobw, int jobv, int l, int r, int
 		}
 	}
 
-	public static void dfs(int l, int r, int i, int used) {
-		int siz = 0;
+	public static void dfs(int l, int r, int i, int dep) {
+		clone(backup[dep], dp);
 		for (int e = head[i], w, v; e > 0; e = next[e]) {
 			w = tow[e];
 			v = tov[e];
+			clone(pre, dp);
 			for (int j = 0; j < p; j++) {
-				dp[used + siz + 1][j] = dp[used + siz][j];
-			}
-			for (int j = 0; j < p; j++) {
-				if (dp[used + siz][j] != -1) {
-					dp[used + siz + 1][(j + w) % p] = Math.max(dp[used + siz + 1][(j + w) % p], dp[used + siz][j] + v);
+				if (pre[j] != -1) {
+					dp[(j + w) % p] = Math.max(dp[(j + w) % p], pre[j] + v);
 				}
 			}
-			siz++;
 		}
-		used += siz;
 		if (l == r) {
 			if (op[l] == 5) {
 				long ret = -1;
 				for (int j = x[l]; j <= y[l]; j++) {
-					ret = Math.max(ret, dp[used][j]);
+					ret = Math.max(ret, dp[j]);
 				}
 				ans[l] = ret;
 			}
 		} else {
 			int mid = (l + r) >> 1;
-			dfs(l, mid, i << 1, used);
-			dfs(mid + 1, r, i << 1 | 1, used);
+			dfs(l, mid, i << 1, dep + 1);
+			dfs(mid + 1, r, i << 1 | 1, dep + 1);
 		}
+		clone(dp, backup[dep]);
 	}
 
 	public static void prepare() {
@@ -114,12 +126,10 @@ public static void prepare() {
 			equip = knapsack.pollFirst();
 			add(equip[2], m, equip[0], equip[1], 1, m, 1);
 		}
-		for (int i = 0; i < MAXM; i++) {
-			for (int j = 0; j < MAXP; j++) {
-				dp[i][j] = -1;
-			}
+		for (int i = 0; i < p; i++) {
+			dp[i] = -1;
 		}
-		dp[0][0] = 0;
+		dp[0] = 0;
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -150,7 +160,7 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		prepare();
-		dfs(1, m, 1, 0);
+		dfs(1, m, 1, 1);
 		for (int i = 1; i <= m; i++) {
 			if (op[i] == 5) {
 				out.println(ans[i]);
diff --git a/src/class167/Code02_BlueMoon2.java b/src/class167/Code02_BlueMoon2.java
index 67ad8490f..aa120a168 100644
--- a/src/class167/Code02_BlueMoon2.java
+++ b/src/class167/Code02_BlueMoon2.java
@@ -21,6 +21,7 @@
 //const int MAXM = 50001;
 //const int MAXP = 501;
 //const int MAXT = 1000001;
+//const int DEEP = 20;
 //int m, p;
 //
 //int op[MAXM];
@@ -35,9 +36,18 @@
 //int tov[MAXT];
 //int cnt = 0;
 //
-//long long dp[MAXM][MAXP];
+//long long pre[MAXP];
+//long long dp[MAXP];
+//long long backup[DEEP][MAXP];
+//
 //long long ans[MAXM];
 //
+//void clone(long long* a, long long* b) {
+//    for (int i = 0; i <= p; i++) {
+//        a[i] = b[i];
+//    }
+//}
+//
 //void addEdge(int i, int w, int v) {
 //    nxt[++cnt] = head[i];
 //    tow[cnt] = w;
@@ -59,36 +69,32 @@
 //    }
 //}
 //
-//void dfs(int l, int r, int i, int used) {
-//    int siz = 0;
+//void dfs(int l, int r, int i, int dep) {
+//    clone(backup[dep], dp);
 //    for (int e = head[i], w, v; e > 0; e = nxt[e]) {
 //        w = tow[e];
 //        v = tov[e];
+//        clone(pre, dp);
 //        for (int j = 0; j < p; j++) {
-//            dp[used + siz + 1][j] = dp[used + siz][j];
-//        }
-//        for (int j = 0; j < p; j++) {
-//            if (dp[used + siz][j] != -1) {
-//                int nj = (j + w) % p;
-//                dp[used + siz + 1][nj] = max(dp[used + siz + 1][nj], dp[used + siz][j] + v);
+//            if (pre[j] != -1) {
+//                dp[(j + w) % p] = max(dp[(j + w) % p], pre[j] + v);
 //            }
 //        }
-//        siz++;
 //    }
-//    used += siz;
 //    if (l == r) {
 //        if (op[l] == 5) {
 //            long long ret = -1;
 //            for (int j = x[l]; j <= y[l]; j++) {
-//                ret = max(ret, dp[used][j]);
+//                ret = max(ret, dp[j]);
 //            }
 //            ans[l] = ret;
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;
-//        dfs(l, mid, i << 1, used);
-//        dfs(mid + 1, r, i << 1 | 1, used);
+//        dfs(l, mid, i << 1, dep + 1);
+//        dfs(mid + 1, r, i << 1 | 1, dep + 1);
 //    }
+//    clone(dp, backup[dep]);
 //}
 //
 //void prepare() {
@@ -113,12 +119,10 @@
 //        add(equip[2], m, equip[0], equip[1], 1, m, 1);
 //        knapsack.pop_front();
 //    }
-//    for (int i = 0; i < MAXM; i++) {
-//        for (int j = 0; j < MAXP; j++) {
-//            dp[i][j] = -1;
-//        }
+//    for (int i = 0; i < p; i++) {
+//        dp[i] = -1;
 //    }
-//    dp[0][0] = 0;
+//    dp[0] = 0;
 //}
 //
 //int main() {
@@ -146,7 +150,7 @@
 //        }
 //    }
 //    prepare();
-//    dfs(1, m, 1, 0);
+//    dfs(1, m, 1, 1);
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 5) {
 //            cout << ans[i] << '\n';

From b54186505b33f88b1935a434d33ee1e9455b3866 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 5 May 2025 13:09:38 +0800
Subject: [PATCH 0766/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java | 6 +++---
 src/class167/Code01_MuseumRobbery2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index 658130c85..b76f7d8e0 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -1,13 +1,13 @@
 package class167;
 
 // 博物馆劫案，java版
-// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BAS、MOD
+// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
 // 操作 2 x   : 集合s中删除编号为x的商品，删除时保证x号商品存在
 // 操作 3     : 查询当前的f(s)
-// 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
-// 定义f(s) = ∑(m = 1...k) ( a(m) * BAS的m-1次方 % MOD )
+// 定义a(s, m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
+// 给定正数k、BAS、MOD，定义f(s) = ∑(m = 1...k) (a(s, m) * BAS的m-1次方 % MOD)
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
 // 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index af48ba0d2..c75b93ca0 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -1,13 +1,13 @@
 package class167;
 
 // 博物馆劫案，C++版
-// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s，给定正数k、BAS、MOD
+// 给定n件商品，商品有价值v和重量w，1~n号商品加入集合s
 // 接下来有q个操作，每种操作是如下三种类型中的一种
 // 操作 1 x y : 集合s中增加价值x、重量y的商品，商品编号自增得到
 // 操作 2 x   : 集合s中删除编号为x的商品，删除时保证x号商品存在
 // 操作 3     : 查询当前的f(s)
-// 定义a(m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
-// 定义f(s) = ∑(m = 1...k) ( a(m) * BAS的m-1次方 % MOD )
+// 定义a(s, m) = 集合s中，挑选商品总重量<=m，能获得的最大价值
+// 给定正数k、BAS、MOD，定义f(s) = ∑(m = 1...k) (a(s, m) * BAS的m-1次方 % MOD)
 // 1 <= n <= 5 * 10^3    1 <= q <= 3 * 10^4
 // 1 <= k、每件商品重量 <= 10^3    1 <= 每件商品价值 <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF601E

From 7cac4f6d372a0edf87fd7f8eaa2039c2abab8255 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 5 May 2025 14:10:12 +0800
Subject: [PATCH 0767/1712] modify code

---
 src/class167/Code01_MuseumRobbery1.java | 6 ++++--
 src/class167/Code01_MuseumRobbery2.java | 6 ++++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/class167/Code01_MuseumRobbery1.java b/src/class167/Code01_MuseumRobbery1.java
index b76f7d8e0..35c63ad3a 100644
--- a/src/class167/Code01_MuseumRobbery1.java
+++ b/src/class167/Code01_MuseumRobbery1.java
@@ -123,11 +123,13 @@ public static void prepare() {
 				from[n] = i;
 				to[n] = q;
 			} else if (op[i] == 2) {
-				to[x[i]] = i;
+				to[x[i]] = i - 1;
 			}
 		}
 		for (int i = 1; i <= n; i++) {
-			add(from[i], to[i], v[i], w[i], 1, q, 1);
+			if (from[i] <= to[i]) {
+				add(from[i], to[i], v[i], w[i], 1, q, 1);
+			}
 		}
 	}
 
diff --git a/src/class167/Code01_MuseumRobbery2.java b/src/class167/Code01_MuseumRobbery2.java
index c75b93ca0..9d43315ce 100644
--- a/src/class167/Code01_MuseumRobbery2.java
+++ b/src/class167/Code01_MuseumRobbery2.java
@@ -115,11 +115,13 @@
 //            from[n] = i;
 //            to[n] = q;
 //        } else if (op[i] == 2) {
-//            to[x[i]] = i;
+//            to[x[i]] = i - 1;
 //        }
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        add(from[i], to[i], v[i], w[i], 1, q, 1);
+//        if (from[i] <= to[i]) {
+//            add(from[i], to[i], v[i], w[i], 1, q, 1);
+//        }
 //    }
 //}
 //

From 58b83d3392cd2f859686537667c4b01a1e4152c9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 5 May 2025 15:52:14 +0800
Subject: [PATCH 0768/1712] modify code

---
 src/class167/Code03_AdditionOnSegments1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class167/Code03_AdditionOnSegments1.java b/src/class167/Code03_AdditionOnSegments1.java
index 26b6467e5..1ecc9dea4 100644
--- a/src/class167/Code03_AdditionOnSegments1.java
+++ b/src/class167/Code03_AdditionOnSegments1.java
@@ -98,6 +98,8 @@ public static void bitLeft(int[] ret, int[] bitset, int move) {
 			}
 			ret[shift] = bitset[0] << offset;
 		}
+		// 最高位BIT到最低位0，一共BIT+1个有效位
+		// 其他更高位信息需要清空，rest就是有多少无效的更高位
 		int rest = LEN * INT_BIT - (BIT + 1);
 		if (rest > 0) {
 			ret[LEN - 1] &= (1 << (INT_BIT - rest)) - 1;

From 2d55a5d36c0cfdecc870da33de7cebec1962cae7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 5 May 2025 16:14:52 +0800
Subject: [PATCH 0769/1712] modify code

---
 src/class167/Code02_BlueMoon1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class167/Code02_BlueMoon1.java b/src/class167/Code02_BlueMoon1.java
index f8c010f43..f07a1fefc 100644
--- a/src/class167/Code02_BlueMoon1.java
+++ b/src/class167/Code02_BlueMoon1.java
@@ -35,16 +35,16 @@ public class Code02_BlueMoon1 {
 	// 背包<装备特征值%p、装备战斗力、装备出现时间点>
 	public static Deque<int[]> knapsack = new ArrayDeque<>();
 
-	// 时间轴线段树的区间上挂上生效的商品，(特征值 % p)记为w，战斗力记为v
+	// 时间轴线段树的区间上挂上生效的装备，(特征值 % p)记为w，战斗力记为v
 	public static int[] head = new int[MAXM << 2];
 	public static int[] next = new int[MAXT];
 	public static int[] tow = new int[MAXT];
 	public static int[] tov = new int[MAXT];
 	public static int cnt = 0;
 
-	// 动态规划表不考虑当前商品的状态，上一行的状态
+	// 动态规划表不考虑当前装备的状态，上一行的状态
 	public static long[] pre = new long[MAXP];
-	// 动态规划表考虑当前商品的状态，本行的状态，需要更新
+	// 动态规划表考虑当前装备的状态，本行的状态，需要更新
 	public static long[] dp = new long[MAXP];
 	// 动态规划表的备份
 	public static long[][] backup = new long[DEEP][MAXP];

From f20c88c6cccefc5452baf047a3478954b4784b5b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 5 May 2025 17:10:09 +0800
Subject: [PATCH 0770/1712] modify code

---
 src/class167/Code03_AdditionOnSegments1.java | 16 ++++++++--------
 src/class167/Code03_AdditionOnSegments2.java | 12 ++++++------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class167/Code03_AdditionOnSegments1.java b/src/class167/Code03_AdditionOnSegments1.java
index 1ecc9dea4..9d52fa8b4 100644
--- a/src/class167/Code03_AdditionOnSegments1.java
+++ b/src/class167/Code03_AdditionOnSegments1.java
@@ -21,9 +21,9 @@ public class Code03_AdditionOnSegments1 {
 	public static int MAXN = 10001;
 	public static int MAXT = 500001;
 	public static int BIT = 10000;
+	public static int DEEP = 20;
 	public static int INT_BIT = 32;
 	public static int LEN = BIT / INT_BIT + 1;
-	public static int DEEP = 20;
 	public static int n, q;
 
 	public static int[] head = new int[MAXN << 2];
@@ -32,7 +32,7 @@ public class Code03_AdditionOnSegments1 {
 	public static int cnt = 0;
 
 	public static int[] tmp = new int[LEN];
-	public static int[] path = new int[LEN];
+	public static int[] dp = new int[LEN];
 	public static int[][] backup = new int[DEEP][LEN];
 	public static int[] ans = new int[LEN];
 
@@ -127,19 +127,19 @@ public static void add(int jobl, int jobr, int jobv, int l, int r, int i) {
 	}
 
 	public static void dfs(int l, int r, int i, int dep) {
-		clone(backup[dep], path);
+		clone(backup[dep], dp);
 		for (int e = head[i]; e > 0; e = next[e]) {
-			bitLeft(tmp, path, to[e]);
-			bitOr(path, tmp);
+			bitLeft(tmp, dp, to[e]);
+			bitOr(dp, tmp);
 		}
 		if (l == r) {
-			bitOr(ans, path);
+			bitOr(ans, dp);
 		} else {
 			int mid = (l + r) >> 1;
 			dfs(l, mid, i << 1, dep + 1);
 			dfs(mid + 1, r, i << 1 | 1, dep + 1);
 		}
-		clone(path, backup[dep]);
+		clone(dp, backup[dep]);
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -153,7 +153,7 @@ public static void main(String[] args) throws Exception {
 			k = in.nextInt();
 			add(l, r, k, 1, n, 1);
 		}
-		setBit(path, 0, 1);
+		setBit(dp, 0, 1);
 		dfs(1, n, 1, 1);
 		int ansCnt = 0;
 		for (int i = 1; i <= n; i++) {
diff --git a/src/class167/Code03_AdditionOnSegments2.java b/src/class167/Code03_AdditionOnSegments2.java
index 4416dc887..cc4b33abd 100644
--- a/src/class167/Code03_AdditionOnSegments2.java
+++ b/src/class167/Code03_AdditionOnSegments2.java
@@ -29,7 +29,7 @@
 //int to[MAXT];
 //int cnt = 0;
 //
-//bs path;
+//bs dp;
 //bs backup[DEEP];
 //bs ans;
 //
@@ -54,18 +54,18 @@
 //}
 //
 //void dfs(int l, int r, int i, int dep) {
-//    backup[dep] = path;
+//    backup[dep] = dp;
 //    for (int e = head[i]; e > 0; e = nxt[e]) {
-//        path |= path << to[e];
+//        dp |= dp << to[e];
 //    }
 //    if (l == r) {
-//        ans |= path;
+//        ans |= dp;
 //    } else {
 //        int mid = (l + r) >> 1;
 //        dfs(l, mid, i << 1, dep + 1);
 //        dfs(mid + 1, r, i << 1 | 1, dep + 1);
 //    }
-//    path = backup[dep];
+//    dp = backup[dep];
 //}
 //
 //int main() {
@@ -76,7 +76,7 @@
 //        cin >> l >> r >> k;
 //        add(l, r, k, 1, n, 1);
 //    }
-//    path[0] = 1;
+//    dp[0] = 1;
 //    dfs(1, n, 1, 1);
 //    int ansCnt = 0;
 //    for (int i = 1; i <= n; i++) {

From 580cee127a64b304d9c4a42336a7042227bbf19b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 5 May 2025 17:48:07 +0800
Subject: [PATCH 0771/1712] modify code

---
 src/class167/Code04_ShortestPathQueries1.java |  2 +-
 src/class167/Code04_ShortestPathQueries2.java |  2 +-
 .../Code05_EightVerticalHorizontal1.java      | 47 ++++++-------------
 .../Code05_EightVerticalHorizontal2.java      | 45 +++++-------------
 4 files changed, 30 insertions(+), 66 deletions(-)

diff --git a/src/class167/Code04_ShortestPathQueries1.java b/src/class167/Code04_ShortestPathQueries1.java
index 271792ab5..ce1103c29 100644
--- a/src/class167/Code04_ShortestPathQueries1.java
+++ b/src/class167/Code04_ShortestPathQueries1.java
@@ -6,7 +6,7 @@
 // 操作 1 x y d : 原图中加入，点x到点y，权值为d的边
 // 操作 2 x y   : 原图中删除，点x到点y的边
 // 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来，打印能取得的异或最小值
-// 保证任意操作后，图连通、无重边、无自环，所有操作均合法
+// 保证x < y，并且任意操作后，图连通、无重边、无自环，所有操作均合法
 // 1 <= n、m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF938G
 // 测试链接 : https://codeforces.com/problemset/problem/938/G
diff --git a/src/class167/Code04_ShortestPathQueries2.java b/src/class167/Code04_ShortestPathQueries2.java
index 9272b84ef..dc4999a8a 100644
--- a/src/class167/Code04_ShortestPathQueries2.java
+++ b/src/class167/Code04_ShortestPathQueries2.java
@@ -6,7 +6,7 @@
 // 操作 1 x y d : 原图中加入，点x到点y，权值为d的边
 // 操作 2 x y   : 原图中删除，点x到点y的边
 // 操作 3 x y   : 点x到点y，所有路随便走，沿途边权都异或起来，打印能取得的异或最小值
-// 保证任意操作后，图连通、无重边、无自环，所有操作均合法
+// 保证x < y，并且任意操作后，图连通、无重边、无自环，所有操作均合法
 // 1 <= n、m、q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF938G
 // 测试链接 : https://codeforces.com/problemset/problem/938/G
diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index f03aac151..fd2ca71a9 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -1,7 +1,7 @@
 package class167;
 
 // 八纵八横，java版
-// 一共有n个点，给定m条边，每条边的边权，用01字符串表达
+// 一共有n个点，给定m条边，每条边的边权，用01字符串表达，初始时就保证图连通
 // 初始的m条边永不删除，接下来有q条操作，每种操作是如下三种类型中的一种
 // 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串，第k条添加操作，边的编号为k
 // 操作 Cancel k   : 删除编号为k的边
@@ -94,12 +94,10 @@ public void clear() {
 	public static int[] inspos = new int[BIT + 1];
 	public static int basiz = 0;
 
-	// 可撤销并查集 + 带权并查集
+	// 带权并查集
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static BitSet[] eor = new BitSet[MAXN];
-	public static int[][] rollback = new int[MAXT][2];
-	public static int opsize = 0;
 
 	// 时间轴线段树上的区间任务列表
 	public static int[] head = new int[MAXQ << 2];
@@ -112,6 +110,7 @@ public void clear() {
 	// 每一步的最大异或值
 	public static BitSet[] ans = new BitSet[MAXQ];
 
+	// num插入线性基
 	public static void insert(BitSet num) {
 		for (int i = BIT; i >= 0; i--) {
 			if (num.get(i) == 1) {
@@ -136,6 +135,7 @@ public static BitSet maxEor() {
 		return ans;
 	}
 
+	// 线性基的撤销
 	public static void cancel(int oldsiz) {
 		while (basiz > oldsiz) {
 			basis[inspos[--basiz]].clear();
@@ -158,7 +158,7 @@ public static BitSet getEor(int i) {
 		return ans;
 	}
 
-	public static boolean union(int u, int v, BitSet w) {
+	public static void union(int u, int v, BitSet w) {
 		int fu = find(u);
 		int fv = find(v);
 		BitSet weight = new BitSet();
@@ -167,27 +167,16 @@ public static boolean union(int u, int v, BitSet w) {
 		weight.eor(w);
 		if (fu == fv) {
 			insert(weight);
-			return false;
-		}
-		if (siz[fu] < siz[fv]) {
-			int tmp = fu;
-			fu = fv;
-			fv = tmp;
+		} else {
+			if (siz[fu] < siz[fv]) {
+				int tmp = fu;
+				fu = fv;
+				fv = tmp;
+			}
+			father[fv] = fu;
+			siz[fu] += siz[fv];
+			eor[fv].copy(weight);
 		}
-		father[fv] = fu;
-		siz[fu] += siz[fv];
-		eor[fv].copy(weight);
-		rollback[++opsize][0] = fu;
-		rollback[opsize][1] = fv;
-		return true;
-	}
-
-	public static void undo() {
-		int fx = rollback[opsize][0];
-		int fy = rollback[opsize--][1];
-		father[fy] = fy;
-		eor[fy].clear();
-		siz[fx] -= siz[fy];
 	}
 
 	public static void addEdge(int i, int x, int y, BitSet w) {
@@ -214,11 +203,8 @@ public static void add(int jobl, int jobr, int jobx, int joby, BitSet jobw, int
 
 	public static void dfs(int l, int r, int i) {
 		int oldsiz = basiz;
-		int unionCnt = 0;
 		for (int e = head[i]; e > 0; e = next[e]) {
-			if (union(tox[e], toy[e], tow[e])) {
-				unionCnt++;
-			}
+			union(tox[e], toy[e], tow[e]);
 		}
 		if (l == r) {
 			ans[l] = maxEor();
@@ -228,9 +214,6 @@ public static void dfs(int l, int r, int i) {
 			dfs(mid + 1, r, i << 1 | 1);
 		}
 		cancel(oldsiz);
-		for (int k = 1; k <= unionCnt; k++) {
-			undo();
-		}
 	}
 
 	public static void print(BitSet bs, PrintWriter out) {
diff --git a/src/class167/Code05_EightVerticalHorizontal2.java b/src/class167/Code05_EightVerticalHorizontal2.java
index df9556618..969e393ba 100644
--- a/src/class167/Code05_EightVerticalHorizontal2.java
+++ b/src/class167/Code05_EightVerticalHorizontal2.java
@@ -1,7 +1,7 @@
 package class167;
 
 // 八纵八横，C++版
-// 一共有n个点，给定m条边，每条边的边权，用01字符串表达
+// 一共有n个点，给定m条边，每条边的边权，用01字符串表达，初始时就保证图连通
 // 初始的m条边永不删除，接下来有q条操作，每种操作是如下三种类型中的一种
 // 操作 Add x y z  : 加入点x到点y的边，边权是z，z为01字符串，第k条添加操作，边的编号为k
 // 操作 Cancel k   : 删除编号为k的边
@@ -38,8 +38,6 @@
 //int father[MAXN];
 //int siz[MAXN];
 //bs eor[MAXN];
-//int rollback[MAXT][2];
-//int opsize = 0;
 //
 //int head[MAXQ << 2];
 //int nxt[MAXT];
@@ -95,33 +93,22 @@
 //    return ret;
 //}
 //
-//bool Union(int u, int v, bs& w) {
+//void Union(int u, int v, bs& w) {
 //    int fu = find(u);
 //    int fv = find(v);
 //    bs weight = getEor(u) ^ getEor(v) ^ w;
 //    if (fu == fv) {
 //        insert(weight);
-//        return false;
-//    }
-//    if (siz[fu] < siz[fv]) {
-//        int tmp = fu;
-//        fu = fv;
-//        fv = tmp;
-//    }
-//    father[fv] = fu;
-//    siz[fu] += siz[fv];
-//    eor[fv] = weight;
-//    rollback[++opsize][0] = fu;
-//    rollback[opsize][1] = fv;
-//    return true;
-//}
-//
-//void undo() {
-//    int fu = rollback[opsize][0];
-//    int fv = rollback[opsize--][1];
-//    father[fv] = fv;
-//    eor[fv].reset();
-//    siz[fu] -= siz[fv];
+//    } else {
+//        if (siz[fu] < siz[fv]) {
+//            int tmp = fu;
+//            fu = fv;
+//            fv = tmp;
+//        }
+//        father[fv] = fu;
+//        siz[fu] += siz[fv];
+//        eor[fv] = weight;
+//    }
 //}
 //
 //void addEdge(int i, int u, int v, bs& w) {
@@ -148,11 +135,8 @@
 //
 //void dfs(int l, int r, int i) {
 //    int oldsiz = basiz;
-//    int unionCnt = 0;
 //    for (int e = head[i]; e; e = nxt[e]) {
-//        if (Union(tox[e], toy[e], tow[e])) {
-//            ++unionCnt;
-//        }
+//        Union(tox[e], toy[e], tow[e]);
 //    }
 //    if (l == r) {
 //        ans[l] = maxEor();
@@ -162,9 +146,6 @@
 //        dfs(mid + 1, r, i << 1 | 1);
 //    }
 //    cancel(oldsiz);
-//    for (int k = 1; k <= unionCnt; k++) {
-//        undo();
-//    }
 //}
 //
 //void print(const bs& ret) {

From 93faa66e25319097e7198de529cfd0fc84b75eb5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 6 May 2025 13:22:52 +0800
Subject: [PATCH 0772/1712] modify code

---
 .../Code05_EightVerticalHorizontal1.java      | 38 ++++++-------------
 .../Code05_EightVerticalHorizontal2.java      | 28 +++++---------
 2 files changed, 20 insertions(+), 46 deletions(-)

diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index fd2ca71a9..3cc5b4805 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -59,13 +59,6 @@ public void set(int i, int v) {
 			}
 		}
 
-		// 拷贝other每一位
-		public void copy(BitSet other) {
-			for (int i = 0; i < len; i++) {
-				arr[i] = other.arr[i];
-			}
-		}
-
 		// 异或other每一位
 		public void eor(BitSet other) {
 			for (int i = 0; i < len; i++) {
@@ -94,9 +87,8 @@ public void clear() {
 	public static int[] inspos = new int[BIT + 1];
 	public static int basiz = 0;
 
-	// 带权并查集
+	// 经典带权并查集，只做扁平化，不做小挂大
 	public static int[] father = new int[MAXN];
-	public static int[] siz = new int[MAXN];
 	public static BitSet[] eor = new BitSet[MAXN];
 
 	// 时间轴线段树上的区间任务列表
@@ -115,7 +107,7 @@ public static void insert(BitSet num) {
 		for (int i = BIT; i >= 0; i--) {
 			if (num.get(i) == 1) {
 				if (basis[i].get(i) == 0) {
-					basis[i].copy(num);
+					basis[i] = num;
 					inspos[basiz++] = i;
 					return;
 				}
@@ -142,20 +134,19 @@ public static void cancel(int oldsiz) {
 		}
 	}
 
+	// 带权并查集，扁平化优化，find的同时修改eor
 	public static int find(int i) {
-		while (i != father[i]) {
-			i = father[i];
+		if (i != father[i]) {
+			int tmp = father[i];
+			father[i] = find(tmp);
+			eor[i].eor(eor[tmp]);
 		}
-		return i;
+		return father[i];
 	}
 
 	public static BitSet getEor(int i) {
-		BitSet ans = new BitSet();
-		while (i != father[i]) {
-			ans.eor(eor[i]);
-			i = father[i];
-		}
-		return ans;
+		find(i);
+		return eor[i];
 	}
 
 	public static void union(int u, int v, BitSet w) {
@@ -168,14 +159,8 @@ public static void union(int u, int v, BitSet w) {
 		if (fu == fv) {
 			insert(weight);
 		} else {
-			if (siz[fu] < siz[fv]) {
-				int tmp = fu;
-				fu = fv;
-				fv = tmp;
-			}
 			father[fv] = fu;
-			siz[fu] += siz[fv];
-			eor[fv].copy(weight);
+			eor[fv] = weight;
 		}
 	}
 
@@ -244,7 +229,6 @@ public static void main(String[] args) throws IOException {
 		}
 		for (int i = 1; i <= n; i++) {
 			father[i] = i;
-			siz[i] = 1;
 			eor[i] = new BitSet();
 		}
 		for (int i = 1; i <= m; i++) {
diff --git a/src/class167/Code05_EightVerticalHorizontal2.java b/src/class167/Code05_EightVerticalHorizontal2.java
index 969e393ba..762f79888 100644
--- a/src/class167/Code05_EightVerticalHorizontal2.java
+++ b/src/class167/Code05_EightVerticalHorizontal2.java
@@ -36,7 +36,6 @@
 //int basiz = 0;
 //
 //int father[MAXN];
-//int siz[MAXN];
 //bs eor[MAXN];
 //
 //int head[MAXQ << 2];
@@ -77,20 +76,18 @@
 //    }
 //}
 //
-//int find(int v) {
-//    while (v != father[v]) {
-//        v = father[v];
+//int find(int i) {
+//    if (i != father[i]) {
+//        int tmp = father[i];
+//        father[i] = find(tmp);
+//        eor[i] ^= eor[tmp];
 //    }
-//    return v;
+//    return father[i];
 //}
 //
-//bs getEor(int v) {
-//    bs ret;
-//    while (v != father[v]) {
-//        ret ^= eor[v];
-//        v = father[v];
-//    }
-//    return ret;
+//bs getEor(int i) {
+//    find(i);
+//    return eor[i];
 //}
 //
 //void Union(int u, int v, bs& w) {
@@ -100,13 +97,7 @@
 //    if (fu == fv) {
 //        insert(weight);
 //    } else {
-//        if (siz[fu] < siz[fv]) {
-//            int tmp = fu;
-//            fu = fv;
-//            fv = tmp;
-//        }
 //        father[fv] = fu;
-//        siz[fu] += siz[fv];
 //        eor[fv] = weight;
 //    }
 //}
@@ -173,7 +164,6 @@
 //    }
 //    for (int i = 1; i <= n; ++i) {
 //        father[i] = i;
-//        siz[i] = 1;
 //        eor[i].reset();
 //    }
 //    int u, v;

From f272bc8d5ae1eb8de945cbf3efbc22af4b0ec4b1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 6 May 2025 13:24:35 +0800
Subject: [PATCH 0773/1712] modify code

---
 src/class167/Code05_EightVerticalHorizontal1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class167/Code05_EightVerticalHorizontal1.java b/src/class167/Code05_EightVerticalHorizontal1.java
index 3cc5b4805..78012fbaf 100644
--- a/src/class167/Code05_EightVerticalHorizontal1.java
+++ b/src/class167/Code05_EightVerticalHorizontal1.java
@@ -134,7 +134,7 @@ public static void cancel(int oldsiz) {
 		}
 	}
 
-	// 带权并查集，扁平化优化，find的同时修改eor
+	// 扁平化优化，find的同时修改eor，就是经典的带权并查集
 	public static int find(int i) {
 		if (i != father[i]) {
 			int tmp = father[i];

From baef3d372e2b31bd95e2731183bd30968261a891 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 6 May 2025 17:47:37 +0800
Subject: [PATCH 0774/1712] modify code

---
 src/class167/Code06_MarsStore1.java | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/src/class167/Code06_MarsStore1.java b/src/class167/Code06_MarsStore1.java
index 4cccefdcf..96a389408 100644
--- a/src/class167/Code06_MarsStore1.java
+++ b/src/class167/Code06_MarsStore1.java
@@ -49,9 +49,12 @@ public class Code06_MarsStore1 {
 	public static int[] bid = new int[MAXT];
 	public static int cntb = 0;
 
+	// 每个商品(所属的商店编号，该商品的价格)
 	public static int[][] product = new int[MAXN][2];
 	public static int[] ans = new int[MAXN];
 
+	// 可持久化前缀树
+	// 基于i版本的树，添加num，返回新版本的编号
 	public static int insert(int num, int i) {
 		int rt = ++cntt;
 		tree[rt][0] = tree[i][0];
@@ -69,6 +72,8 @@ public static int insert(int num, int i) {
 		return rt;
 	}
 
+	// 可持久化前缀树
+	// 根据(v版本 - u版本)的数据状况，看看哪个数字 ^ num能得到最大值并返回
 	public static int query(int num, int u, int v) {
 		int ans = 0;
 		for (int b = BIT, path, best; b >= 0; b--) {
@@ -98,6 +103,7 @@ public static void addInfoB(int i, int bi) {
 		headb[i] = cntb;
 	}
 
+	// 当前商品编号pi，沿途经过的所有区间，都把该商品加上
 	public static void addProduct(int jobi, int pi, int l, int r, int i) {
 		addInfoP(i, pi);
 		if (l < r) {
@@ -110,6 +116,7 @@ public static void addProduct(int jobi, int pi, int l, int r, int i) {
 		}
 	}
 
+	// 当前购买行为编号bi，命中的线段树区间，把该购买行为加上
 	public static void addBuy(int jobl, int jobr, int bi, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			addInfoB(i, bi);

From f60591ce1404de0c0005b77d761a5380405ee6df Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 6 May 2025 18:04:36 +0800
Subject: [PATCH 0775/1712] modify code

---
 src/class167/Code07_MinimumXor1.java | 10 +++++-----
 src/class167/Code07_MinimumXor2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class167/Code07_MinimumXor1.java b/src/class167/Code07_MinimumXor1.java
index f8eb21de0..af6468a6e 100644
--- a/src/class167/Code07_MinimumXor1.java
+++ b/src/class167/Code07_MinimumXor1.java
@@ -30,7 +30,7 @@ public class Code07_MinimumXor1 {
 	public static int[] mineor = new int[MAXN];
 	public static int[] only = new int[MAXN];
 
-	public static int insert(int x, int changeCnt) {
+	public static int change(int x, int changeCnt) {
 		int cur = 1;
 		pass[cur] += changeCnt;
 		for (int b = BIT, path; b >= 0; b--) {
@@ -46,7 +46,7 @@ public static int insert(int x, int changeCnt) {
 	}
 
 	public static void compute(int x, int changeCnt) {
-		int bottom = insert(x, changeCnt);
+		int bottom = change(x, changeCnt);
 		mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
 		only[bottom] = pass[bottom] == 1 ? x : 0;
 		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
@@ -54,10 +54,10 @@ public static void compute(int x, int changeCnt) {
 			r = tree[i][1];
 			if (pass[i] < 2) {
 				mineor[i] = INF;
-			} else if ((l != 0) ^ (r != 0)) {
-				mineor[i] = l > 0 ? mineor[l] : mineor[r];
-			} else if (Math.max(pass[l], pass[r]) == 1) {
+			} else if (pass[l] == 1 && pass[r] == 1) {
 				mineor[i] = only[l] ^ only[r];
+			} else if (pass[l] == 0 ^ pass[r] == 0) {
+				mineor[i] = pass[l] == 0 ? mineor[r] : mineor[l];
 			} else {
 				mineor[i] = Math.min(mineor[l], mineor[r]);
 			}
diff --git a/src/class167/Code07_MinimumXor2.java b/src/class167/Code07_MinimumXor2.java
index 17a641718..33cd9d7ec 100644
--- a/src/class167/Code07_MinimumXor2.java
+++ b/src/class167/Code07_MinimumXor2.java
@@ -28,7 +28,7 @@
 //int mineor[MAXN];
 //int only[MAXN];
 //
-//int insert(int x, int changeCnt) {
+//int change(int x, int changeCnt) {
 //    int cur = 1;
 //    pass[cur] += changeCnt;
 //    for (int b = BIT, path; b >= 0; b--) {
@@ -44,7 +44,7 @@
 //}
 //
 //void compute(int x, int changeCnt) {
-//    int bottom = insert(x, changeCnt);
+//    int bottom = change(x, changeCnt);
 //    mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
 //    only[bottom] = pass[bottom] == 1 ? x : 0;
 //    for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
@@ -52,10 +52,10 @@
 //        r = tree[i][1];
 //        if (pass[i] < 2) {
 //            mineor[i] = INF;
-//        } else if ((l != 0) ^ (r != 0)) {
-//            mineor[i] = l > 0 ? mineor[l] : mineor[r];
-//        } else if (max(pass[l], pass[r]) == 1) {
+//        } else if (pass[l] == 1 && pass[r] == 1) {
 //            mineor[i] = only[l] ^ only[r];
+//        } else if (pass[l] == 0 ^ pass[r] == 0) {
+//            mineor[i] = pass[l] == 0 ? mineor[r] : mineor[l];
 //        } else {
 //            mineor[i] = min(mineor[l], mineor[r]);
 //        }

From 62eb0a9b8afb363cdc8266cbfc241d1d0cd333ac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 6 May 2025 18:27:06 +0800
Subject: [PATCH 0776/1712] modify code

---
 src/class167/Code07_MinimumXor1.java | 2 +-
 src/class167/Code07_MinimumXor2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class167/Code07_MinimumXor1.java b/src/class167/Code07_MinimumXor1.java
index af6468a6e..6e3e3f05a 100644
--- a/src/class167/Code07_MinimumXor1.java
+++ b/src/class167/Code07_MinimumXor1.java
@@ -48,7 +48,7 @@ public static int change(int x, int changeCnt) {
 	public static void compute(int x, int changeCnt) {
 		int bottom = change(x, changeCnt);
 		mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
-		only[bottom] = pass[bottom] == 1 ? x : 0;
+		only[bottom] = pass[bottom] >= 1 ? x : 0;
 		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 			l = tree[i][0];
 			r = tree[i][1];
diff --git a/src/class167/Code07_MinimumXor2.java b/src/class167/Code07_MinimumXor2.java
index 33cd9d7ec..61689441e 100644
--- a/src/class167/Code07_MinimumXor2.java
+++ b/src/class167/Code07_MinimumXor2.java
@@ -46,7 +46,7 @@
 //void compute(int x, int changeCnt) {
 //    int bottom = change(x, changeCnt);
 //    mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
-//    only[bottom] = pass[bottom] == 1 ? x : 0;
+//    only[bottom] = pass[bottom] >= 1 ? x : 0;
 //    for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 //        l = tree[i][0];
 //        r = tree[i][1];

From 17a284599333a063ec1aa3ef8d70937f1e403577 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 6 May 2025 18:50:26 +0800
Subject: [PATCH 0777/1712] modify code

---
 src/class167/Code07_MinimumXor1.java | 4 +++-
 src/class167/Code07_MinimumXor2.java | 2 +-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class167/Code07_MinimumXor1.java b/src/class167/Code07_MinimumXor1.java
index 6e3e3f05a..2c738b5d5 100644
--- a/src/class167/Code07_MinimumXor1.java
+++ b/src/class167/Code07_MinimumXor1.java
@@ -27,7 +27,9 @@ public class Code07_MinimumXor1 {
 	public static int[] pass = new int[MAXN];
 	public static int cnt = 1;
 
+	// 整棵树上最小异或值
 	public static int[] mineor = new int[MAXN];
+	// 整棵树上如果只有一个数x，才有记录，否则记录是0
 	public static int[] only = new int[MAXN];
 
 	public static int change(int x, int changeCnt) {
@@ -48,7 +50,7 @@ public static int change(int x, int changeCnt) {
 	public static void compute(int x, int changeCnt) {
 		int bottom = change(x, changeCnt);
 		mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
-		only[bottom] = pass[bottom] >= 1 ? x : 0;
+		only[bottom] = pass[bottom] == 1 ? x : 0;
 		for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 			l = tree[i][0];
 			r = tree[i][1];
diff --git a/src/class167/Code07_MinimumXor2.java b/src/class167/Code07_MinimumXor2.java
index 61689441e..33cd9d7ec 100644
--- a/src/class167/Code07_MinimumXor2.java
+++ b/src/class167/Code07_MinimumXor2.java
@@ -46,7 +46,7 @@
 //void compute(int x, int changeCnt) {
 //    int bottom = change(x, changeCnt);
 //    mineor[bottom] = pass[bottom] >= 2 ? 0 : INF;
-//    only[bottom] = pass[bottom] >= 1 ? x : 0;
+//    only[bottom] = pass[bottom] == 1 ? x : 0;
 //    for (int i = fa[bottom], l, r; i > 0; i = fa[i]) {
 //        l = tree[i][0];
 //        r = tree[i][1];

From d873183ab83c2e2c854f5e374f276e9e1bef98c9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 6 May 2025 19:30:22 +0800
Subject: [PATCH 0778/1712] modify code

---
 ...1\345\210\206\346\262\273-\344\270\213.pptx" | Bin 0 -> 49862 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243167\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\345\210\206\346\262\273-\344\270\213.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243167\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\345\210\206\346\262\273-\344\270\213.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243167\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\345\210\206\346\262\273-\344\270\213.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..a1bd74b722975164d6c5a9a147743ceefa23676e
GIT binary patch
literal 49862
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%0A}(9^5=>k=E$D<%Ts
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
G?tcKY_S{4O

literal 0
HcmV?d00001


From eebc090547df53e55e9f61ecc2a6338b9b7a82d8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 8 May 2025 12:19:10 +0800
Subject: [PATCH 0779/1712] modify code

---
 src/class168/Code07_Network1.java | 335 ++++++++++++++++++++++++++++++
 1 file changed, 335 insertions(+)
 create mode 100644 src/class168/Code07_Network1.java

diff --git a/src/class168/Code07_Network1.java b/src/class168/Code07_Network1.java
new file mode 100644
index 000000000..6291e0006
--- /dev/null
+++ b/src/class168/Code07_Network1.java
@@ -0,0 +1,335 @@
+package class168;
+
+// 网络，java版
+// 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
+// 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
+// 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
+// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
+// 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
+// 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
+// 关于操作2，如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
+// 2 <= n <= 10^5    1 <= m <= 2 * 10^5    1 <= 重要度 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3250
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
+public class Code07_Network1 {
+
+	public static int MAXN = 100001;
+	public static int MAXM = 200001;
+	public static int MAXH = 20;
+	public static int n, m;
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	// 树上点差分 + 树上倍增
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXH];
+	public static int cntd;
+
+	// 树状数组
+	public static int[] tree = new int[MAXN];
+
+	// 从早到晚发生的事件
+	public static int[][] events = new int[MAXM][4];
+	public static int[] sorted = new int[MAXM];
+	public static int s = 0;
+
+	// 整体二分
+	public static int[][] lset = new int[MAXM][4];
+	public static int[][] rset = new int[MAXM][4];
+	public static int[] ans = new int[MAXM];
+	public static int cntans = 0;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		dfn[u] = ++cntd;
+		stjump[u][0] = f;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e != 0; e = next[e]) {
+			if (to[e] != f) {
+				dfs1(to[e], u);
+			}
+		}
+		for (int e = head[u]; e != 0; e = next[e]) {
+			if (to[e] != f) {
+				siz[u] += siz[to[e]];
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				fa[u] = f;
+				dep[u] = dep[f] + 1;
+				siz[u] = 1;
+				dfn[u] = ++cntd;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				for (int e = head[u]; e != 0; e = next[e]) {
+					if (to[e] != f) {
+						siz[u] += siz[to[e]];
+					}
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static void add(int i, int v) {
+		for (; i <= n; i += i & -i) {
+			tree[i] += v;
+		}
+	}
+
+	public static int query(int i) {
+		int sum = 0;
+		for (; i > 0; i -= i & -i) {
+			sum += tree[i];
+		}
+		return sum;
+	}
+
+	public static void pathAdd(int x, int y, int v) {
+		int xylca = lca(x, y);
+		int lcafa = fa[xylca];
+		add(dfn[x], v);
+		add(dfn[y], v);
+		add(dfn[xylca], -v);
+		if (lcafa != 0) {
+			add(dfn[lcafa], -v);
+		}
+	}
+
+	public static int pointQuery(int x) {
+		return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = s, mid;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] == num) {
+				return mid;
+			} else if (sorted[mid] < num) {
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return -1;
+	}
+
+	public static void clone(int[] event1, int[] event2) {
+		event1[0] = event2[0];
+		event1[1] = event2[1];
+		event1[2] = event2[2];
+		event1[3] = event2[3];
+	}
+
+	public static void prepare() {
+		dfs2(); // 为了防止爆栈调用迭代版
+		sorted[0] = -1;
+		for (int i = 1; i <= m; i++) {
+			if (events[i][0] == 0) {
+				sorted[++s] = events[i][3];
+			}
+		}
+		Arrays.sort(sorted, 1, s + 1);
+		int len = 1;
+		for (int i = 2; i <= s; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		s = len;
+		for (int i = 1; i <= m; i++) {
+			if (events[i][0] == 0) {
+				events[i][3] = kth(events[i][3]);
+			} else if (events[i][0] == 1) {
+				clone(events[i], events[events[i][1]]);
+				events[i][0] = -1;
+			} else {
+				events[i][0] = ++cntans;
+			}
+		}
+	}
+
+	public static void compute(int evtl, int evtr, int impl, int impr) {
+		if (evtl > evtr) {
+			return;
+		}
+		if (impl == impr) {
+			for (int i = evtl; i <= evtr; i++) {
+				if (events[i][0] > 0) {
+					ans[events[i][0]] = impl;
+				}
+			}
+		} else {
+			int impm = (impl + impr) / 2;
+			int lsize = 0, rsize = 0, request = 0;
+			for (int i = evtl; i <= evtr; i++) {
+				if (events[i][0] == 0) {
+					if (events[i][3] > impm) {
+						pathAdd(events[i][1], events[i][2], 1);
+						clone(rset[++rsize], events[i]);
+						request++;
+					} else {
+						clone(lset[++lsize], events[i]);
+					}
+				} else if (events[i][0] == -1) {
+					if (events[i][3] > impm) {
+						pathAdd(events[i][1], events[i][2], -1);
+						clone(rset[++rsize], events[i]);
+						request--;
+					} else {
+						clone(lset[++lsize], events[i]);
+					}
+				} else {
+					if (pointQuery(events[i][1]) != request) {
+						clone(rset[++rsize], events[i]);
+					} else {
+						clone(lset[++lsize], events[i]);
+					}
+				}
+			}
+			for (int i = 1; i <= rsize; i++) {
+				if (rset[i][0] == 0 && rset[i][3] > impm) {
+					pathAdd(rset[i][1], rset[i][2], -1);
+				}
+				if (rset[i][0] == -1 && rset[i][3] > impm) {
+					pathAdd(rset[i][1], rset[i][2], 1);
+				}
+			}
+			for (int i = evtl, j = 1; j <= lsize; i++, j++) {
+				clone(events[i], lset[j]);
+			}
+			for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
+				clone(events[i], rset[j]);
+			}
+			compute(evtl, evtl + lsize - 1, impl, impm);
+			compute(evtl + lsize, evtr, impm + 1, impr);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m = (int) in.nval;
+		for (int i = 1, u, v; i < n; i++) {
+			in.nextToken();
+			u = (int) in.nval;
+			in.nextToken();
+			v = (int) in.nval;
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= m; i++) {
+			in.nextToken();
+			events[i][0] = (int) in.nval;
+			in.nextToken();
+			events[i][1] = (int) in.nval;
+			if (events[i][0] == 0) {
+				in.nextToken();
+				events[i][2] = (int) in.nval;
+				in.nextToken();
+				events[i][3] = (int) in.nval;
+			}
+		}
+		prepare();
+		compute(1, m, 0, s);
+		for (int i = 1; i <= cntans; i++) {
+			out.println(sorted[ans[i]]);
+		}
+		out.flush();
+		out.close();
+	}
+
+}

From c642c257492c60b17a5d63b9794b276f0cec632c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 8 May 2025 12:36:45 +0800
Subject: [PATCH 0780/1712] modify code

---
 src/class168/Code07_Network2.java | 256 ++++++++++++++++++++++++++++++
 1 file changed, 256 insertions(+)
 create mode 100644 src/class168/Code07_Network2.java

diff --git a/src/class168/Code07_Network2.java b/src/class168/Code07_Network2.java
new file mode 100644
index 000000000..7394bf1f5
--- /dev/null
+++ b/src/class168/Code07_Network2.java
@@ -0,0 +1,256 @@
+package class168;
+
+// 网络，C++版
+// 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
+// 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
+// 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
+// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
+// 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
+// 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
+// 关于操作2，如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
+// 2 <= n <= 10^5    1 <= m <= 2 * 10^5    1 <= 重要度 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3250
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXM = 200001;
+//const int MAXH = 20;
+//
+//int n, m;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int dfn[MAXN];
+//int stjump[MAXN][MAXH];
+//int cntd = 0;
+//
+//int tree[MAXN];
+//
+//int events[MAXM][4];
+//int sorted[MAXM];
+//int s = 0;
+//
+//int lset[MAXM][4];
+//int rset[MAXM][4];
+//int ans[MAXM];
+//int cntans = 0;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    dfn[u] = ++cntd;
+//    stjump[u][0] = f;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e != 0; e = nxt[e]) {
+//        if (to[e] != f) {
+//            dfs(to[e], u);
+//        }
+//    }
+//    for (int e = head[u]; e != 0; e = nxt[e]) {
+//        if (to[e] != f) {
+//            siz[u] += siz[to[e]];
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        int tmp = a;
+//        a = b;
+//        b = tmp;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//void add(int i, int v) {
+//    for (; i <= n; i += i & -i) {
+//        tree[i] += v;
+//    }
+//}
+//
+//int query(int i) {
+//    int sum = 0;
+//    for (; i > 0; i -= i & -i) {
+//        sum += tree[i];
+//    }
+//    return sum;
+//}
+//
+//void pathAdd(int x, int y, int v) {
+//    int xylca = lca(x, y);
+//    int lcafa = fa[xylca];
+//    add(dfn[x], v);
+//    add(dfn[y], v);
+//    add(dfn[xylca], -v);
+//    if (lcafa != 0) {
+//        add(dfn[lcafa], -v);
+//    }
+//}
+//
+//int pointQuery(int x) {
+//    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = s, mid;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] == num) {
+//            return mid;
+//        } else if (sorted[mid] < num) {
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return -1;
+//}
+//
+//void clone(int* e1, int* e2) {
+//    e1[0] = e2[0];
+//    e1[1] = e2[1];
+//    e1[2] = e2[2];
+//    e1[3] = e2[3];
+//}
+//
+//void prepare() {
+//    dfs(1, 0);
+//    sorted[0] = -1;
+//    for (int i = 1; i <= m; i++) {
+//        if (events[i][0] == 0) {
+//            sorted[++s] = events[i][3];
+//        }
+//    }
+//    sort(sorted + 1, sorted + s + 1);
+//    int len = 1;
+//    for (int i = 2; i <= s; i++) {
+//        if (sorted[len] != sorted[i]) {
+//            sorted[++len] = sorted[i];
+//        }
+//    }
+//    s = len;
+//    for (int i = 1; i <= m; i++) {
+//        if (events[i][0] == 0) {
+//            events[i][3] = kth(events[i][3]);
+//        } else if (events[i][0] == 1) {
+//            clone(events[i], events[events[i][1]]);
+//            events[i][0] = -1;
+//        } else {
+//            events[i][0] = ++cntans;
+//        }
+//    }
+//}
+//
+//void compute(int evtl, int evtr, int impl, int impr) {
+//    if (evtl > evtr) {
+//        return;
+//    }
+//    if (impl == impr) {
+//        for (int i = evtl; i <= evtr; i++) {
+//            if (events[i][0] > 0) {
+//                ans[events[i][0]] = impl;
+//            }
+//        }
+//    } else {
+//        int impm = (impl + impr) / 2;
+//        int lsize = 0, rsize = 0, request = 0;
+//        for (int i = evtl; i <= evtr; i++) {
+//            if (events[i][0] == 0) {
+//                if (events[i][3] > impm) {
+//                    pathAdd(events[i][1], events[i][2], 1);
+//                    clone(rset[++rsize], events[i]);
+//                    request++;
+//                } else {
+//                    clone(lset[++lsize], events[i]);
+//                }
+//            } else if (events[i][0] == -1) {
+//                if (events[i][3] > impm) {
+//                    pathAdd(events[i][1], events[i][2], -1);
+//                    clone(rset[++rsize], events[i]);
+//                    request--;
+//                } else {
+//                    clone(lset[++lsize], events[i]);
+//                }
+//            } else {
+//                if (pointQuery(events[i][1]) != request) {
+//                    clone(rset[++rsize], events[i]);
+//                } else {
+//                    clone(lset[++lsize], events[i]);
+//                }
+//            }
+//        }
+//        for (int i = 1; i <= rsize; i++) {
+//            if (rset[i][0] == 0 && rset[i][3] > impm) {
+//                pathAdd(rset[i][1], rset[i][2], -1);
+//            }
+//            if (rset[i][0] == -1 && rset[i][3] > impm) {
+//                pathAdd(rset[i][1], rset[i][2], 1);
+//            }
+//        }
+//        for (int i = evtl, j = 1; j <= lsize; i++, j++) {
+//            clone(events[i], lset[j]);
+//        }
+//        for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
+//            clone(events[i], rset[j]);
+//        }
+//        compute(evtl, evtl + lsize - 1, impl, impm);
+//        compute(evtl + lsize, evtr, impm + 1, impr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> events[i][0] >> events[i][1];
+//        if (events[i][0] == 0) {
+//            cin >> events[i][2] >> events[i][3];
+//        }
+//    }
+//    prepare();
+//    compute(1, m, 0, s);
+//    for (int i = 1; i <= cntans; i++) {
+//        cout << sorted[ans[i]] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 0061aead887356be9c82bf047d2cf46410d0703a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 8 May 2025 14:09:34 +0800
Subject: [PATCH 0781/1712] modify code

---
 src/class168/{Code07_Network1.java => Code05_Network1.java} | 2 +-
 src/class168/{Code07_Network2.java => Code05_Network2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class168/{Code07_Network1.java => Code05_Network1.java} (99%)
 rename src/class168/{Code07_Network2.java => Code05_Network2.java} (100%)

diff --git a/src/class168/Code07_Network1.java b/src/class168/Code05_Network1.java
similarity index 99%
rename from src/class168/Code07_Network1.java
rename to src/class168/Code05_Network1.java
index 6291e0006..8bc47b4e7 100644
--- a/src/class168/Code07_Network1.java
+++ b/src/class168/Code05_Network1.java
@@ -20,7 +20,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code07_Network1 {
+public class Code05_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class168/Code07_Network2.java b/src/class168/Code05_Network2.java
similarity index 100%
rename from src/class168/Code07_Network2.java
rename to src/class168/Code05_Network2.java

From 1efcfd487b2d65d83b1f8f91aa5ee0c40c1df244 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 8 May 2025 14:14:18 +0800
Subject: [PATCH 0782/1712] modify code

---
 src/class168/{Code05_Network1.java => Code06_Network1.java} | 2 +-
 src/class168/{Code05_Network2.java => Code06_Network2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class168/{Code05_Network1.java => Code06_Network1.java} (99%)
 rename src/class168/{Code05_Network2.java => Code06_Network2.java} (100%)

diff --git a/src/class168/Code05_Network1.java b/src/class168/Code06_Network1.java
similarity index 99%
rename from src/class168/Code05_Network1.java
rename to src/class168/Code06_Network1.java
index 8bc47b4e7..279253d22 100644
--- a/src/class168/Code05_Network1.java
+++ b/src/class168/Code06_Network1.java
@@ -20,7 +20,7 @@
 import java.io.StreamTokenizer;
 import java.util.Arrays;
 
-public class Code05_Network1 {
+public class Code06_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class168/Code05_Network2.java b/src/class168/Code06_Network2.java
similarity index 100%
rename from src/class168/Code05_Network2.java
rename to src/class168/Code06_Network2.java

From da124ae8742c9cc72a6a518c3b782d3c84ad984c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 8 May 2025 21:25:42 +0800
Subject: [PATCH 0783/1712] modify code

---
 src/class168/Code01_MixedJuice1.java | 9 +++++++++
 src/class168/Code05_Meteors1.java    | 9 +++++++++
 2 files changed, 18 insertions(+)
 create mode 100644 src/class168/Code01_MixedJuice1.java
 create mode 100644 src/class168/Code05_Meteors1.java

diff --git a/src/class168/Code01_MixedJuice1.java b/src/class168/Code01_MixedJuice1.java
new file mode 100644
index 000000000..df4cc292f
--- /dev/null
+++ b/src/class168/Code01_MixedJuice1.java
@@ -0,0 +1,9 @@
+package class168;
+
+// 混合果汁，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4602
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code01_MixedJuice1 {
+
+}
diff --git a/src/class168/Code05_Meteors1.java b/src/class168/Code05_Meteors1.java
new file mode 100644
index 000000000..5f1a75dcc
--- /dev/null
+++ b/src/class168/Code05_Meteors1.java
@@ -0,0 +1,9 @@
+package class168;
+
+// 陨石雨，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3527
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code05_Meteors1 {
+
+}

From 76ff39e6508100108eb8106ef318cf1262e50072 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 9 May 2025 00:31:14 +0800
Subject: [PATCH 0784/1712] modify code

---
 src/class168/Code01_Meteors1.java             | 187 ++++++++++++++++++
 src/class168/Code01_Meteors2.java             | 137 +++++++++++++
 ...xedJuice1.java => Code02_MixedJuice1.java} |   2 +-
 src/class168/Code05_Meteors1.java             |   9 -
 src/class168/Code06_Network1.java             |  70 +++++--
 5 files changed, 374 insertions(+), 31 deletions(-)
 create mode 100644 src/class168/Code01_Meteors1.java
 create mode 100644 src/class168/Code01_Meteors2.java
 rename src/class168/{Code01_MixedJuice1.java => Code02_MixedJuice1.java} (85%)
 delete mode 100644 src/class168/Code05_Meteors1.java

diff --git a/src/class168/Code01_Meteors1.java b/src/class168/Code01_Meteors1.java
new file mode 100644
index 000000000..99746af28
--- /dev/null
+++ b/src/class168/Code01_Meteors1.java
@@ -0,0 +1,187 @@
+package class168;
+
+// 陨石雨，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3527
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是通过不了，空间使用过大
+// 这道题只考虑C++能通过的空间极限，根本没考虑java的用户
+// 想通过用C++实现，本节课Code01_Meteors2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code01_Meteors1 {
+
+	public static int MAXN = 300001;
+	public static int n, m, k;
+
+	public static int[] arr = new int[MAXN];
+	public static int[] need = new int[MAXN];
+
+	public static int[] rainl = new int[MAXN];
+	public static int[] rainr = new int[MAXN];
+	public static int[] num = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
+	public static int cnt = 0;
+
+	public static long[] tree = new long[MAXN << 1];
+
+	public static int[] lset = new int[MAXN];
+	public static int[] rset = new int[MAXN];
+
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdge(int i, int v) {
+		next[++cnt] = head[i];
+		to[cnt] = v;
+		head[i] = cnt;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		int siz = m * 2;
+		while (i <= siz) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static void add(int l, int r, int v) {
+		add(l, v);
+		add(r + 1, -v);
+	}
+
+	public static long query(int i) {
+		long ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void compute(int al, int ar, int tl, int tr) {
+		if (tl == tr) {
+			for (int i = al; i <= ar; i++) {
+				ans[arr[i]] = tl;
+			}
+		} else {
+			int mid = (tl + tr) >> 1;
+			int lsiz = 0, rsiz = 0, nation;
+			long times;
+			for (int i = tl; i <= mid; i++) {
+				add(rainl[i], rainr[i], num[i]);
+			}
+			for (int i = al; i <= ar; i++) {
+				nation = arr[i];
+				times = 0;
+				for (int e = head[nation]; e > 0; e = next[e]) {
+					times += query(to[e]) + query(to[e] + m);
+					if (times >= need[nation]) {
+						break;
+					}
+				}
+				if (times >= need[nation]) {
+					lset[++lsiz] = nation;
+				} else {
+					need[nation] -= times;
+					rset[++rsiz] = nation;
+				}
+			}
+			for (int i = tl; i <= mid; i++) {
+				add(rainl[i], rainr[i], -num[i]);
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				arr[al + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				arr[al + lsiz + i - 1] = rset[i];
+			}
+			compute(al, al + lsiz - 1, tl, mid);
+			compute(al + lsiz, ar, mid + 1, tr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, nation; i <= m; i++) {
+			nation = in.nextInt();
+			addEdge(nation, i);
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = i;
+			need[i] = in.nextInt();
+		}
+		k = in.nextInt();
+		for (int i = 1; i <= k; i++) {
+			rainl[i] = in.nextInt();
+			rainr[i] = in.nextInt();
+			if (rainr[i] < rainl[i]) {
+				rainr[i] += m;
+			}
+			num[i] = in.nextInt();
+		}
+		compute(1, n, 1, k + 1);
+		for (int i = 1; i <= n; i++) {
+			if (ans[i] == k + 1) {
+				out.println("NIE");
+			} else {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code01_Meteors2.java b/src/class168/Code01_Meteors2.java
new file mode 100644
index 000000000..f92c223aa
--- /dev/null
+++ b/src/class168/Code01_Meteors2.java
@@ -0,0 +1,137 @@
+package class168;
+
+// 陨石雨，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3527
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//
+//int n, m, k;
+//
+//int arr[MAXN];
+//int need[MAXN];
+//
+//int rainl[MAXN];
+//int rainr[MAXN];
+//int num[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cnt = 0;
+//
+//long long tree[MAXN << 1];
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//
+//int ans[MAXN];
+//
+//void addEdge(int i, int v) {
+//    nxt[++cnt] = head[i];
+//    to[cnt] = v;
+//    head[i] = cnt;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    int siz = m * 2;
+//    while (i <= siz) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void add(int l, int r, int v) {
+//    add(l, v);
+//    add(r + 1, -v);
+//}
+//
+//long long query(int i) {
+//    long long ret = 0;
+//    while (i > 0) {
+//    	ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void compute(int al, int ar, int tl, int tr) {
+//    if (tl == tr) {
+//        for (int i = al; i <= ar; i++) {
+//            ans[arr[i]] = tl;
+//        }
+//    } else {
+//        int mid = (tl + tr) >> 1;
+//        int lsiz = 0, rsiz = 0, nation;
+//        long long times;
+//        for (int i = tl; i <= mid; i++) {
+//            add(rainl[i], rainr[i], num[i]);
+//        }
+//        for (int i = al; i <= ar; i++) {
+//            nation = arr[i];
+//            times = 0;
+//            for (int e = head[nation]; e > 0; e = nxt[e]) {
+//                times += query(to[e]) + query(to[e] + m);
+//                if (times >= need[nation]) {
+//                    break;
+//                }
+//            }
+//            if (times >= need[nation]) {
+//                lset[++lsiz] = nation;
+//            } else {
+//                need[nation] -= static_cast<int>(times);
+//                rset[++rsiz] = nation;
+//            }
+//        }
+//        for (int i = tl; i <= mid; i++) {
+//            add(rainl[i], rainr[i], -num[i]);
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            arr[al + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            arr[al + lsiz + i - 1] = rset[i];
+//        }
+//        compute(al, al + lsiz - 1, tl, mid);
+//        compute(al + lsiz, ar, mid + 1, tr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, nation; i <= m; i++) {
+//        cin >> nation;
+//        addEdge(nation, i);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = i;
+//        cin >> need[i];
+//    }
+//    cin >> k;
+//    for (int i = 1; i <= k; i++) {
+//        cin >> rainl[i] >> rainr[i] >> num[i];
+//        if (rainr[i] < rainl[i]) {
+//            rainr[i] += m;
+//        }
+//    }
+//    compute(1, n, 1, k + 1);
+//    for (int i = 1; i <= n; i++) {
+//        if (ans[i] == k + 1) {
+//            cout << "NIE" << '\n';
+//        } else {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code01_MixedJuice1.java b/src/class168/Code02_MixedJuice1.java
similarity index 85%
rename from src/class168/Code01_MixedJuice1.java
rename to src/class168/Code02_MixedJuice1.java
index df4cc292f..45add820c 100644
--- a/src/class168/Code01_MixedJuice1.java
+++ b/src/class168/Code02_MixedJuice1.java
@@ -4,6 +4,6 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4602
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-public class Code01_MixedJuice1 {
+public class Code02_MixedJuice1 {
 
 }
diff --git a/src/class168/Code05_Meteors1.java b/src/class168/Code05_Meteors1.java
deleted file mode 100644
index 5f1a75dcc..000000000
--- a/src/class168/Code05_Meteors1.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package class168;
-
-// 陨石雨，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P3527
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code05_Meteors1 {
-
-}
diff --git a/src/class168/Code06_Network1.java b/src/class168/Code06_Network1.java
index 279253d22..320619cf3 100644
--- a/src/class168/Code06_Network1.java
+++ b/src/class168/Code06_Network1.java
@@ -12,12 +12,10 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3250
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
+import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.io.StreamTokenizer;
 import java.util.Arrays;
 
 public class Code06_Network1 {
@@ -296,31 +294,22 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 	}
 
 	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
+		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken();
-		n = (int) in.nval;
-		in.nextToken();
-		m = (int) in.nval;
+		n = in.nextInt();
+		m = in.nextInt();
 		for (int i = 1, u, v; i < n; i++) {
-			in.nextToken();
-			u = (int) in.nval;
-			in.nextToken();
-			v = (int) in.nval;
+			u = in.nextInt();
+			v = in.nextInt();
 			addEdge(u, v);
 			addEdge(v, u);
 		}
 		for (int i = 1; i <= m; i++) {
-			in.nextToken();
-			events[i][0] = (int) in.nval;
-			in.nextToken();
-			events[i][1] = (int) in.nval;
+			events[i][0] = in.nextInt();
+			events[i][1] = in.nextInt();
 			if (events[i][0] == 0) {
-				in.nextToken();
-				events[i][2] = (int) in.nval;
-				in.nextToken();
-				events[i][3] = (int) in.nval;
+				events[i][2] = in.nextInt();
+				events[i][3] = in.nextInt();
 			}
 		}
 		prepare();
@@ -332,4 +321,43 @@ public static void main(String[] args) throws IOException {
 		out.close();
 	}
 
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }

From 444e52647f07fccfa6fb82f15b553f884a78a1d1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 9 May 2025 00:35:07 +0800
Subject: [PATCH 0785/1712] modify code

---
 src/class168/Code01_Meteors1.java | 12 ++++++------
 src/class168/Code01_Meteors2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class168/Code01_Meteors1.java b/src/class168/Code01_Meteors1.java
index 99746af28..a441bc983 100644
--- a/src/class168/Code01_Meteors1.java
+++ b/src/class168/Code01_Meteors1.java
@@ -77,23 +77,23 @@ public static void compute(int al, int ar, int tl, int tr) {
 		} else {
 			int mid = (tl + tr) >> 1;
 			int lsiz = 0, rsiz = 0, nation;
-			long times;
+			long satisfy;
 			for (int i = tl; i <= mid; i++) {
 				add(rainl[i], rainr[i], num[i]);
 			}
 			for (int i = al; i <= ar; i++) {
 				nation = arr[i];
-				times = 0;
+				satisfy = 0;
 				for (int e = head[nation]; e > 0; e = next[e]) {
-					times += query(to[e]) + query(to[e] + m);
-					if (times >= need[nation]) {
+					satisfy += query(to[e]) + query(to[e] + m);
+					if (satisfy >= need[nation]) {
 						break;
 					}
 				}
-				if (times >= need[nation]) {
+				if (satisfy >= need[nation]) {
 					lset[++lsiz] = nation;
 				} else {
-					need[nation] -= times;
+					need[nation] -= satisfy;
 					rset[++rsiz] = nation;
 				}
 			}
diff --git a/src/class168/Code01_Meteors2.java b/src/class168/Code01_Meteors2.java
index f92c223aa..f04f66767 100644
--- a/src/class168/Code01_Meteors2.java
+++ b/src/class168/Code01_Meteors2.java
@@ -72,23 +72,23 @@
 //    } else {
 //        int mid = (tl + tr) >> 1;
 //        int lsiz = 0, rsiz = 0, nation;
-//        long long times;
+//        long long satisfy;
 //        for (int i = tl; i <= mid; i++) {
 //            add(rainl[i], rainr[i], num[i]);
 //        }
 //        for (int i = al; i <= ar; i++) {
 //            nation = arr[i];
-//            times = 0;
+//            satisfy = 0;
 //            for (int e = head[nation]; e > 0; e = nxt[e]) {
-//                times += query(to[e]) + query(to[e] + m);
-//                if (times >= need[nation]) {
+//                satisfy += query(to[e]) + query(to[e] + m);
+//                if (satisfy >= need[nation]) {
 //                    break;
 //                }
 //            }
-//            if (times >= need[nation]) {
+//            if (satisfy >= need[nation]) {
 //                lset[++lsiz] = nation;
 //            } else {
-//                need[nation] -= static_cast<int>(times);
+//                need[nation] -= static_cast<int>(satisfy);
 //                rset[++rsiz] = nation;
 //            }
 //        }

From 2943dbb65d387cddfa232f38ae5250e77899fe9c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 9 May 2025 15:58:02 +0800
Subject: [PATCH 0786/1712] modify code

---
 src/class168/Code02_MixedJuice1.java | 185 +++++++++++++++++++++++++++
 src/class168/Code02_MixedJuice2.java | 127 ++++++++++++++++++
 src/class168/Code06_Network1.java    |   3 -
 src/class168/Code06_Network2.java    |   3 -
 4 files changed, 312 insertions(+), 6 deletions(-)
 create mode 100644 src/class168/Code02_MixedJuice2.java

diff --git a/src/class168/Code02_MixedJuice1.java b/src/class168/Code02_MixedJuice1.java
index 45add820c..0b6fa7122 100644
--- a/src/class168/Code02_MixedJuice1.java
+++ b/src/class168/Code02_MixedJuice1.java
@@ -4,6 +4,191 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4602
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code02_MixedJuice1 {
 
+	public static int MAXN = 100001;
+	public static int n, m;
+	// 果汁参数 : 美味度d、每升价格p、添加上限l
+	public static int[][] juice = new int[MAXN][3];
+	// 记录所有小朋友的编号
+	public static int[] arr = new int[MAXN];
+	// 小朋友的钱数
+	public static long[] money = new long[MAXN];
+	// 小朋友需要至少多少升果汁
+	public static long[] least = new long[MAXN];
+
+	// 线段树
+	public static int maxp = 0;
+	public static long[] suml = new long[MAXN << 2];
+	public static long[] cost = new long[MAXN << 2];
+	// 多少种果汁参数加入了线段树
+	public static int used = 0;
+
+	// 整体二分的过程需要
+	public static int[] lset = new int[MAXN];
+	public static int[] rset = new int[MAXN];
+
+	// 每个小朋友的答案，是第几号果汁的美味度
+	public static int[] ans = new int[MAXN];
+
+	public static void up(int i) {
+		suml[i] = suml[i << 1] + suml[i << 1 | 1];
+		cost[i] = cost[i << 1] + cost[i << 1 | 1];
+	}
+
+	public static void add(int jobi, int jobv, int l, int r, int i) {
+		if (l == r) {
+			suml[i] += jobv;
+			cost[i] = suml[i] * l;
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				add(jobi, jobv, l, mid, i << 1);
+			} else {
+				add(jobi, jobv, mid + 1, r, i << 1 | 1);
+			}
+			up(i);
+		}
+	}
+
+	public static long query(long volume, int l, int r, int i) {
+		if (l == r) {
+			return volume * l;
+		}
+		int mid = (l + r) >> 1;
+		if (suml[i << 1] >= volume) {
+			return query(volume, l, mid, i << 1);
+		} else {
+			return cost[i << 1] + query(volume - suml[i << 1], mid + 1, r, i << 1 | 1);
+		}
+	}
+
+	public static void compute(int al, int ar, int jl, int jr) {
+		if (jl == jr) {
+			for (int i = al; i <= ar; i++) {
+				ans[arr[i]] = jl;
+			}
+		} else {
+			int mid = (jl + jr) >> 1;
+			while (used < mid) {
+				used++;
+				add(juice[used][1], juice[used][2], 1, maxp, 1);
+			}
+			while (used > mid) {
+				add(juice[used][1], -juice[used][2], 1, maxp, 1);
+				used--;
+			}
+			int lsiz = 0, rsiz = 0;
+			for (int i = al, id; i <= ar; i++) {
+				id = arr[i];
+				if (suml[1] >= least[id] && query(least[id], 1, maxp, 1) <= money[id]) {
+					lset[++lsiz] = id;
+				} else {
+					rset[++rsiz] = id;
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				arr[al + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				arr[al + lsiz + i - 1] = rset[i];
+			}
+			compute(al, al + lsiz - 1, jl, mid);
+			compute(al + lsiz, ar, mid + 1, jr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			juice[i][0] = in.nextInt();
+			juice[i][1] = in.nextInt();
+			juice[i][2] = in.nextInt();
+			maxp = Math.max(maxp, juice[i][1]);
+		}
+		for (int i = 1; i <= m; i++) {
+			arr[i] = i;
+			money[i] = in.nextLong();
+			least[i] = in.nextLong();
+		}
+		Arrays.sort(juice, 1, n + 1, (a, b) -> b[0] - a[0]);
+		compute(1, m, 1, n + 1);
+		for (int i = 1; i <= m; i++) {
+			if (ans[i] == n + 1) {
+				out.println(-1);
+			} else {
+				out.println(juice[ans[i]][0]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+
+		long nextLong() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			long val = 0L;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+
+	}
+
 }
diff --git a/src/class168/Code02_MixedJuice2.java b/src/class168/Code02_MixedJuice2.java
new file mode 100644
index 000000000..fb01de2a6
--- /dev/null
+++ b/src/class168/Code02_MixedJuice2.java
@@ -0,0 +1,127 @@
+package class168;
+
+// 混合果汁，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4602
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Juice {
+//    int d, p, l;
+//};
+//
+//bool JuiceCmp(Juice x, Juice y) {
+//    return x.d > y.d;
+//}
+//
+//const int MAXN = 100001;
+//int n, m;
+//
+//Juice juice[MAXN];
+//int arr[MAXN];
+//long long money[MAXN];
+//long long least[MAXN];
+//
+//int maxp = 0;
+//long long suml[MAXN << 2];
+//long long cost[MAXN << 2];
+//int used = 0;
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//
+//int ans[MAXN];
+//
+//void up(int i) {
+//    suml[i] = suml[i << 1] + suml[i << 1 | 1];
+//    cost[i] = cost[i << 1] + cost[i << 1 | 1];
+//}
+//
+//void add(int jobi, int jobv, int l, int r, int i) {
+//    if (l == r) {
+//        suml[i] += jobv;
+//        cost[i] = suml[i] * l;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            add(jobi, jobv, l, mid, i << 1);
+//        } else {
+//            add(jobi, jobv, mid + 1, r, i << 1 | 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//long long query(long long volume, int l, int r, int i) {
+//    if (l == r) {
+//        return volume * l;
+//    }
+//    int mid = (l + r) >> 1;
+//    if (suml[i << 1] >= volume) {
+//        return query(volume, l, mid, i << 1);
+//    } else {
+//        return cost[i << 1] + query(volume - suml[i << 1], mid + 1, r, i << 1 | 1);
+//    }
+//}
+//
+//void compute(int al, int ar, int jl, int jr) {
+//    if (jl == jr) {
+//        for (int i = al; i <= ar; i++) {
+//            ans[arr[i]] = jl;
+//        }
+//    } else {
+//        int mid = (jl + jr) >> 1;
+//        while (used < mid) {
+//            used++;
+//            add(juice[used].p, juice[used].l, 1, maxp, 1);
+//        }
+//        while (used > mid) {
+//            add(juice[used].p, -juice[used].l, 1, maxp, 1);
+//            used--;
+//        }
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = al, id; i <= ar; i++) {
+//            id = arr[i];
+//            if (suml[1] >= least[id] && query(least[id], 1, maxp, 1) <= money[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            arr[al + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            arr[al + lsiz + i - 1] = rset[i];
+//        }
+//        compute(al, al + lsiz - 1, jl, mid);
+//        compute(al + lsiz, ar, mid + 1, jr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> juice[i].d >> juice[i].p >> juice[i].l;
+//        maxp = max(maxp, juice[i].p);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        arr[i] = i;
+//        cin >> money[i] >> least[i];
+//    }
+//    sort(juice + 1, juice + n + 1, JuiceCmp);
+//    compute(1, m, 1, n + 1);
+//    for (int i = 1; i <= m; i++) {
+//        if (ans[i] == n + 1) {
+//            cout << -1 << '\n';
+//        } else {
+//            cout << juice[ans[i]].d << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code06_Network1.java b/src/class168/Code06_Network1.java
index 320619cf3..5226931cf 100644
--- a/src/class168/Code06_Network1.java
+++ b/src/class168/Code06_Network1.java
@@ -237,9 +237,6 @@ public static void prepare() {
 	}
 
 	public static void compute(int evtl, int evtr, int impl, int impr) {
-		if (evtl > evtr) {
-			return;
-		}
 		if (impl == impr) {
 			for (int i = evtl; i <= evtr; i++) {
 				if (events[i][0] > 0) {
diff --git a/src/class168/Code06_Network2.java b/src/class168/Code06_Network2.java
index 7394bf1f5..dcae9f688 100644
--- a/src/class168/Code06_Network2.java
+++ b/src/class168/Code06_Network2.java
@@ -176,9 +176,6 @@
 //}
 //
 //void compute(int evtl, int evtr, int impl, int impr) {
-//    if (evtl > evtr) {
-//        return;
-//    }
 //    if (impl == impr) {
 //        for (int i = evtl; i <= evtr; i++) {
 //            if (events[i][0] > 0) {

From a457fe4c04f513bea6e64bfb7bae3e92886fa126 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 9 May 2025 16:03:34 +0800
Subject: [PATCH 0787/1712] modify code

---
 src/class168/Code02_MixedJuice1.java | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/class168/Code02_MixedJuice1.java b/src/class168/Code02_MixedJuice1.java
index 0b6fa7122..ad549269f 100644
--- a/src/class168/Code02_MixedJuice1.java
+++ b/src/class168/Code02_MixedJuice1.java
@@ -14,20 +14,23 @@ public class Code02_MixedJuice1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
-	// 果汁参数 : 美味度d、每升价格p、添加上限l
+	// 果汁有三个参数，美味度d、每升价格p、添加上限l
 	public static int[][] juice = new int[MAXN][3];
 	// 记录所有小朋友的编号
 	public static int[] arr = new int[MAXN];
-	// 小朋友的钱数
+	// 小朋友能花的钱数
 	public static long[] money = new long[MAXN];
-	// 小朋友需要至少多少升果汁
+	// 小朋友至少的果汁量
 	public static long[] least = new long[MAXN];
 
-	// 线段树
+	// 果汁单价作为下标的线段树
+	// maxp为单价的最大上限
 	public static int maxp = 0;
+	// suml[i] : 线段树某单价区间上，总果汁的量
 	public static long[] suml = new long[MAXN << 2];
+	// cost[i] : 线段树某单价区间上，如果总果汁的量全买，花费多少钱
 	public static long[] cost = new long[MAXN << 2];
-	// 多少种果汁参数加入了线段树
+	// 多少种果汁加入了线段树
 	public static int used = 0;
 
 	// 整体二分的过程需要

From 66eab4e42cb96c1cc4c4ad07bf2e3e5033157ab0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 9 May 2025 16:09:13 +0800
Subject: [PATCH 0788/1712] modify code

---
 src/class168/Code01_Meteors1.java        | 4 ++--
 src/class168/Code02_MixedJuice1.java     | 2 ++
 src/class168/Code03_Multiplication1.java | 9 +++++++++
 3 files changed, 13 insertions(+), 2 deletions(-)
 create mode 100644 src/class168/Code03_Multiplication1.java

diff --git a/src/class168/Code01_Meteors1.java b/src/class168/Code01_Meteors1.java
index a441bc983..4d2ffae0a 100644
--- a/src/class168/Code01_Meteors1.java
+++ b/src/class168/Code01_Meteors1.java
@@ -3,8 +3,8 @@
 // 陨石雨，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3527
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是通过不了，空间使用过大
-// 这道题只考虑C++能通过的空间极限，根本没考虑java的用户
+// java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
+// 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
 // 想通过用C++实现，本节课Code01_Meteors2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
diff --git a/src/class168/Code02_MixedJuice1.java b/src/class168/Code02_MixedJuice1.java
index ad549269f..b4cd638ef 100644
--- a/src/class168/Code02_MixedJuice1.java
+++ b/src/class168/Code02_MixedJuice1.java
@@ -79,10 +79,12 @@ public static void compute(int al, int ar, int jl, int jr) {
 			}
 		} else {
 			int mid = (jl + jr) >> 1;
+			// 线段树包含果汁的种类少就添加
 			while (used < mid) {
 				used++;
 				add(juice[used][1], juice[used][2], 1, maxp, 1);
 			}
+			// 线段树包含果汁的种类多就撤销
 			while (used > mid) {
 				add(juice[used][1], -juice[used][2], 1, maxp, 1);
 				used--;
diff --git a/src/class168/Code03_Multiplication1.java b/src/class168/Code03_Multiplication1.java
new file mode 100644
index 000000000..9b844c148
--- /dev/null
+++ b/src/class168/Code03_Multiplication1.java
@@ -0,0 +1,9 @@
+package class168;
+
+// 矩阵乘法，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1527
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code03_Multiplication1 {
+
+}

From 0c7908420fe0c6b925a03e976caec4eadbf8e837 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 9 May 2025 16:09:55 +0800
Subject: [PATCH 0789/1712] modify code

---
 src/class168/{Code02_MixedJuice1.java => Code02_Juice1.java} | 2 +-
 src/class168/{Code02_MixedJuice2.java => Code02_Juice2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class168/{Code02_MixedJuice1.java => Code02_Juice1.java} (99%)
 rename src/class168/{Code02_MixedJuice2.java => Code02_Juice2.java} (100%)

diff --git a/src/class168/Code02_MixedJuice1.java b/src/class168/Code02_Juice1.java
similarity index 99%
rename from src/class168/Code02_MixedJuice1.java
rename to src/class168/Code02_Juice1.java
index b4cd638ef..936b7b910 100644
--- a/src/class168/Code02_MixedJuice1.java
+++ b/src/class168/Code02_Juice1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_MixedJuice1 {
+public class Code02_Juice1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class168/Code02_MixedJuice2.java b/src/class168/Code02_Juice2.java
similarity index 100%
rename from src/class168/Code02_MixedJuice2.java
rename to src/class168/Code02_Juice2.java

From 8c71a60deb16cba67dada8bae1442e87488562b3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 10 May 2025 22:55:13 +0800
Subject: [PATCH 0790/1712] modify code

---
 src/class168/Code01_KthSmall1.java            | 179 ++++++++++++++++++
 src/class168/Code01_KthSmall2.java            | 129 +++++++++++++
 ...e01_Meteors1.java => Code02_Meteors1.java} |  62 +++---
 ...e01_Meteors2.java => Code02_Meteors2.java} |  58 +++---
 ...{Code02_Juice1.java => Code03_Juice1.java} |  31 +--
 ...{Code02_Juice2.java => Code03_Juice2.java} |  29 +--
 src/class168/Code03_Multiplication1.java      |   9 -
 src/class168/Code06_Network1.java             |  31 +--
 src/class168/Code06_Network2.java             |  31 +--
 9 files changed, 439 insertions(+), 120 deletions(-)
 create mode 100644 src/class168/Code01_KthSmall1.java
 create mode 100644 src/class168/Code01_KthSmall2.java
 rename src/class168/{Code01_Meteors1.java => Code02_Meteors1.java} (77%)
 rename src/class168/{Code01_Meteors2.java => Code02_Meteors2.java} (67%)
 rename src/class168/{Code02_Juice1.java => Code03_Juice1.java} (90%)
 rename src/class168/{Code02_Juice2.java => Code03_Juice2.java} (84%)
 delete mode 100644 src/class168/Code03_Multiplication1.java

diff --git a/src/class168/Code01_KthSmall1.java b/src/class168/Code01_KthSmall1.java
new file mode 100644
index 000000000..58b3a7540
--- /dev/null
+++ b/src/class168/Code01_KthSmall1.java
@@ -0,0 +1,179 @@
+package class168;
+
+// 子矩阵第k小，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1527
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_KthSmall1 {
+
+	public static int MAXN = 501;
+	public static int MAXQ = 1000001;
+	public static int INF = 1000000001;
+	public static int n, q;
+
+	// 矩阵中的每个数字，所在行x、所在列y、数值v
+	public static int[][] xyv = new int[MAXN * MAXN][3];
+	public static int cntv = 0;
+	public static int used = 0;
+
+	// 查询任务的编号
+	public static int[] qid = new int[MAXQ];
+	// 查询范围的左上角坐标
+	public static int[] a = new int[MAXQ];
+	public static int[] b = new int[MAXQ];
+	// 查询范围的右下角坐标
+	public static int[] c = new int[MAXQ];
+	public static int[] d = new int[MAXQ];
+	// 查询任务的第几小值
+	public static int[] k = new int[MAXQ];
+
+	// 二维树状数组
+	public static int[][] tree = new int[MAXN][MAXN];
+
+	// 整体二分
+	public static int[] lset = new int[MAXQ];
+	public static int[] rset = new int[MAXQ];
+
+	// 每条查询的答案
+	public static int[] ans = new int[MAXQ];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int x, int y, int v) {
+		for (int i = x; i <= n; i += lowbit(i)) {
+			for (int j = y; j <= n; j += lowbit(j)) {
+				tree[i][j] += v;
+			}
+		}
+	}
+
+	public static int query(int x, int y) {
+		int ret = 0;
+		for (int i = x; i > 0; i -= lowbit(i)) {
+			for (int j = y; j > 0; j -= lowbit(j)) {
+				ret += tree[i][j];
+			}
+		}
+		return ret;
+	}
+
+	public static int query(int a, int b, int c, int d) {
+		return query(c, d) - query(a - 1, d) - query(c, b - 1) + query(a - 1, b - 1);
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = vl;
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			int lsiz = 0, rsiz = 0;
+			while (used + 1 <= cntv && xyv[used + 1][2] <= mid) {
+				used++;
+				add(xyv[used][0], xyv[used][1], 1);
+			}
+			while (used >= 1 && xyv[used][2] > mid) {
+				add(xyv[used][0], xyv[used][1], -1);
+				used--;
+			}
+			for (int i = ql; i <= qr; i++) {
+				int id = qid[i];
+				int check = query(a[id], b[id], c[id], d[id]);
+				if (check >= k[id]) {
+					lset[++lsiz] = id;
+				} else {
+					rset[++rsiz] = id;
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				qid[ql + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				qid[ql + lsiz + i - 1] = rset[i];
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				xyv[++cntv][0] = i;
+				xyv[cntv][1] = j;
+				xyv[cntv][2] = in.nextInt();
+			}
+		}
+		for (int i = 1; i <= q; i++) {
+			qid[i] = i;
+			a[i] = in.nextInt();
+			b[i] = in.nextInt();
+			c[i] = in.nextInt();
+			d[i] = in.nextInt();
+			k[i] = in.nextInt();
+		}
+		Arrays.sort(xyv, 1, cntv + 1, (a, b) -> a[2] - b[2]);
+		compute(1, q, 0, INF);
+		for (int i = 1; i <= q; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code01_KthSmall2.java b/src/class168/Code01_KthSmall2.java
new file mode 100644
index 000000000..2e1dd4109
--- /dev/null
+++ b/src/class168/Code01_KthSmall2.java
@@ -0,0 +1,129 @@
+package class168;
+
+// 子矩阵第k小，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P1527
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int x, y, v;
+//};
+//
+//bool NumberCmp(Number a, Number b) {
+//    return a.v < b.v;
+//}
+//
+//const int MAXN = 501;
+//const int MAXQ = 1000001;
+//const int INF  = 1000000001;
+//int n, q;
+//
+//Number xyv[MAXN * MAXN];
+//int cntv = 0;
+//int used = 0;
+//
+//int qid[MAXQ];
+//int a[MAXQ];
+//int b[MAXQ];
+//int c[MAXQ];
+//int d[MAXQ];
+//int k[MAXQ];
+//
+//int tree[MAXN][MAXN];
+//
+//int lset[MAXQ];
+//int rset[MAXQ];
+//
+//int ans[MAXQ];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int x, int y, int v) {
+//    for (int i = x; i <= n; i += lowbit(i)) {
+//        for (int j = y; j <= n; j += lowbit(j)) {
+//            tree[i][j] += v;
+//        }
+//    }
+//}
+//
+//int query(int x, int y) {
+//    int ret = 0;
+//    for (int i = x; i > 0; i -= lowbit(i)) {
+//        for (int j = y; j > 0; j -= lowbit(j)) {
+//            ret += tree[i][j];
+//        }
+//    }
+//    return ret;
+//}
+//
+//int query(int a, int b, int c, int d) {
+//    return query(c, d) - query(a - 1, d) - query(c, b - 1) + query(a - 1, b - 1);
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        int lsiz = 0, rsiz = 0;
+//        while (used + 1 <= cntv && xyv[used + 1].v <= mid) {
+//            used++;
+//            add(xyv[used].x, xyv[used].y, 1);
+//        }
+//        while (used >= 1 && xyv[used].v > mid) {
+//            add(xyv[used].x, xyv[used].y, -1);
+//            used--;
+//        }
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            int check = query(a[id], b[id], c[id], d[id]);
+//            if (check >= k[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        for (int j = 1; j <= n; j++) {
+//            xyv[++cntv].x = i;
+//            xyv[cntv].y = j;
+//            cin >> xyv[cntv].v;
+//        }
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        qid[i] = i;
+//        cin >> a[i] >> b[i] >> c[i] >> d[i] >> k[i];
+//    }
+//    sort(xyv + 1, xyv + cntv + 1, NumberCmp);
+//    compute(1, q, 0, INF);
+//    for (int i = 1; i <= q; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code01_Meteors1.java b/src/class168/Code02_Meteors1.java
similarity index 77%
rename from src/class168/Code01_Meteors1.java
rename to src/class168/Code02_Meteors1.java
index 4d2ffae0a..8dbfaa7c8 100644
--- a/src/class168/Code01_Meteors1.java
+++ b/src/class168/Code02_Meteors1.java
@@ -5,7 +5,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
 // 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
-// 想通过用C++实现，本节课Code01_Meteors2文件就是C++的实现
+// 想通过用C++实现，本节课Code02_Meteors2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -13,17 +13,18 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code01_Meteors1 {
+public class Code02_Meteors1 {
 
 	public static int MAXN = 300001;
 	public static int n, m, k;
 
-	public static int[] arr = new int[MAXN];
+	public static int[] qid = new int[MAXN];
 	public static int[] need = new int[MAXN];
 
 	public static int[] rainl = new int[MAXN];
 	public static int[] rainr = new int[MAXN];
 	public static int[] num = new int[MAXN];
+	public static int used = 0;
 
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
@@ -69,45 +70,48 @@ public static long query(int i) {
 		return ret;
 	}
 
-	public static void compute(int al, int ar, int tl, int tr) {
-		if (tl == tr) {
-			for (int i = al; i <= ar; i++) {
-				ans[arr[i]] = tl;
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = vl;
 			}
 		} else {
-			int mid = (tl + tr) >> 1;
-			int lsiz = 0, rsiz = 0, nation;
-			long satisfy;
-			for (int i = tl; i <= mid; i++) {
-				add(rainl[i], rainr[i], num[i]);
+			int mid = (vl + vr) >> 1;
+			int lsiz = 0, rsiz = 0;
+			while (used < mid) {
+				used++;
+				add(rainl[used], rainr[used], num[used]);
+			}
+			while (used > mid) {
+				add(rainl[used], rainr[used], -num[used]);
+				used--;
 			}
-			for (int i = al; i <= ar; i++) {
-				nation = arr[i];
-				satisfy = 0;
-				for (int e = head[nation]; e > 0; e = next[e]) {
+			for (int i = ql; i <= qr; i++) {
+				int id = qid[i];
+				long satisfy = 0;
+				for (int e = head[id]; e > 0; e = next[e]) {
 					satisfy += query(to[e]) + query(to[e] + m);
-					if (satisfy >= need[nation]) {
+					if (satisfy >= need[id]) {
 						break;
 					}
 				}
-				if (satisfy >= need[nation]) {
-					lset[++lsiz] = nation;
+				if (satisfy >= need[id]) {
+					lset[++lsiz] = id;
 				} else {
-					need[nation] -= satisfy;
-					rset[++rsiz] = nation;
+					rset[++rsiz] = id;
 				}
 			}
-			for (int i = tl; i <= mid; i++) {
-				add(rainl[i], rainr[i], -num[i]);
-			}
 			for (int i = 1; i <= lsiz; i++) {
-				arr[al + i - 1] = lset[i];
+				qid[ql + i - 1] = lset[i];
 			}
 			for (int i = 1; i <= rsiz; i++) {
-				arr[al + lsiz + i - 1] = rset[i];
+				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			compute(al, al + lsiz - 1, tl, mid);
-			compute(al + lsiz, ar, mid + 1, tr);
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
 		}
 	}
 
@@ -121,7 +125,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(nation, i);
 		}
 		for (int i = 1; i <= n; i++) {
-			arr[i] = i;
+			qid[i] = i;
 			need[i] = in.nextInt();
 		}
 		k = in.nextInt();
diff --git a/src/class168/Code01_Meteors2.java b/src/class168/Code02_Meteors2.java
similarity index 67%
rename from src/class168/Code01_Meteors2.java
rename to src/class168/Code02_Meteors2.java
index f04f66767..b677b3dcd 100644
--- a/src/class168/Code01_Meteors2.java
+++ b/src/class168/Code02_Meteors2.java
@@ -13,12 +13,13 @@
 //
 //int n, m, k;
 //
-//int arr[MAXN];
+//int qid[MAXN];
 //int need[MAXN];
 //
 //int rainl[MAXN];
 //int rainr[MAXN];
 //int num[MAXN];
+//int used = 0;
 //
 //int head[MAXN];
 //int nxt[MAXN];
@@ -64,45 +65,48 @@
 //    return ret;
 //}
 //
-//void compute(int al, int ar, int tl, int tr) {
-//    if (tl == tr) {
-//        for (int i = al; i <= ar; i++) {
-//            ans[arr[i]] = tl;
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
 //        }
 //    } else {
-//        int mid = (tl + tr) >> 1;
-//        int lsiz = 0, rsiz = 0, nation;
-//        long long satisfy;
-//        for (int i = tl; i <= mid; i++) {
-//            add(rainl[i], rainr[i], num[i]);
+//        int mid = (vl + vr) >> 1;
+//        int lsiz = 0, rsiz = 0;
+//        while (used < mid) {
+//            used++;
+//            add(rainl[used], rainr[used], num[used]);
+//        }
+//        while (used > mid) {
+//            add(rainl[used], rainr[used], -num[used]);
+//            used--;
 //        }
-//        for (int i = al; i <= ar; i++) {
-//            nation = arr[i];
-//            satisfy = 0;
-//            for (int e = head[nation]; e > 0; e = nxt[e]) {
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            long long satisfy = 0;
+//            for (int e = head[id]; e > 0; e = nxt[e]) {
 //                satisfy += query(to[e]) + query(to[e] + m);
-//                if (satisfy >= need[nation]) {
+//                if (satisfy >= need[id]) {
 //                    break;
 //                }
 //            }
-//            if (satisfy >= need[nation]) {
-//                lset[++lsiz] = nation;
+//            if (satisfy >= need[id]) {
+//                lset[++lsiz] = id;
 //            } else {
-//                need[nation] -= static_cast<int>(satisfy);
-//                rset[++rsiz] = nation;
+//                rset[++rsiz] = id;
 //            }
 //        }
-//        for (int i = tl; i <= mid; i++) {
-//            add(rainl[i], rainr[i], -num[i]);
-//        }
 //        for (int i = 1; i <= lsiz; i++) {
-//            arr[al + i - 1] = lset[i];
+//            qid[ql + i - 1] = lset[i];
 //        }
 //        for (int i = 1; i <= rsiz; i++) {
-//            arr[al + lsiz + i - 1] = rset[i];
+//            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(al, al + lsiz - 1, tl, mid);
-//        compute(al + lsiz, ar, mid + 1, tr);
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
 //    }
 //}
 //
@@ -115,7 +119,7 @@
 //        addEdge(nation, i);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        arr[i] = i;
+//        qid[i] = i;
 //        cin >> need[i];
 //    }
 //    cin >> k;
diff --git a/src/class168/Code02_Juice1.java b/src/class168/Code03_Juice1.java
similarity index 90%
rename from src/class168/Code02_Juice1.java
rename to src/class168/Code03_Juice1.java
index 936b7b910..9566f275a 100644
--- a/src/class168/Code02_Juice1.java
+++ b/src/class168/Code03_Juice1.java
@@ -10,14 +10,14 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_Juice1 {
+public class Code03_Juice1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
 	// 果汁有三个参数，美味度d、每升价格p、添加上限l
 	public static int[][] juice = new int[MAXN][3];
 	// 记录所有小朋友的编号
-	public static int[] arr = new int[MAXN];
+	public static int[] qid = new int[MAXN];
 	// 小朋友能花的钱数
 	public static long[] money = new long[MAXN];
 	// 小朋友至少的果汁量
@@ -72,13 +72,16 @@ public static long query(long volume, int l, int r, int i) {
 		}
 	}
 
-	public static void compute(int al, int ar, int jl, int jr) {
-		if (jl == jr) {
-			for (int i = al; i <= ar; i++) {
-				ans[arr[i]] = jl;
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = vl;
 			}
 		} else {
-			int mid = (jl + jr) >> 1;
+			int mid = (vl + vr) >> 1;
 			// 线段树包含果汁的种类少就添加
 			while (used < mid) {
 				used++;
@@ -90,8 +93,8 @@ public static void compute(int al, int ar, int jl, int jr) {
 				used--;
 			}
 			int lsiz = 0, rsiz = 0;
-			for (int i = al, id; i <= ar; i++) {
-				id = arr[i];
+			for (int i = ql, id; i <= qr; i++) {
+				id = qid[i];
 				if (suml[1] >= least[id] && query(least[id], 1, maxp, 1) <= money[id]) {
 					lset[++lsiz] = id;
 				} else {
@@ -99,13 +102,13 @@ public static void compute(int al, int ar, int jl, int jr) {
 				}
 			}
 			for (int i = 1; i <= lsiz; i++) {
-				arr[al + i - 1] = lset[i];
+				qid[ql + i - 1] = lset[i];
 			}
 			for (int i = 1; i <= rsiz; i++) {
-				arr[al + lsiz + i - 1] = rset[i];
+				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			compute(al, al + lsiz - 1, jl, mid);
-			compute(al + lsiz, ar, mid + 1, jr);
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
 		}
 	}
 
@@ -121,7 +124,7 @@ public static void main(String[] args) throws Exception {
 			maxp = Math.max(maxp, juice[i][1]);
 		}
 		for (int i = 1; i <= m; i++) {
-			arr[i] = i;
+			qid[i] = i;
 			money[i] = in.nextLong();
 			least[i] = in.nextLong();
 		}
diff --git a/src/class168/Code02_Juice2.java b/src/class168/Code03_Juice2.java
similarity index 84%
rename from src/class168/Code02_Juice2.java
rename to src/class168/Code03_Juice2.java
index fb01de2a6..2319998e9 100644
--- a/src/class168/Code02_Juice2.java
+++ b/src/class168/Code03_Juice2.java
@@ -21,7 +21,7 @@
 //int n, m;
 //
 //Juice juice[MAXN];
-//int arr[MAXN];
+//int qid[MAXN];
 //long long money[MAXN];
 //long long least[MAXN];
 //
@@ -67,13 +67,16 @@
 //    }
 //}
 //
-//void compute(int al, int ar, int jl, int jr) {
-//    if (jl == jr) {
-//        for (int i = al; i <= ar; i++) {
-//            ans[arr[i]] = jl;
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
 //        }
 //    } else {
-//        int mid = (jl + jr) >> 1;
+//        int mid = (vl + vr) >> 1;
 //        while (used < mid) {
 //            used++;
 //            add(juice[used].p, juice[used].l, 1, maxp, 1);
@@ -83,8 +86,8 @@
 //            used--;
 //        }
 //        int lsiz = 0, rsiz = 0;
-//        for (int i = al, id; i <= ar; i++) {
-//            id = arr[i];
+//        for (int i = ql, id; i <= qr; i++) {
+//            id = qid[i];
 //            if (suml[1] >= least[id] && query(least[id], 1, maxp, 1) <= money[id]) {
 //                lset[++lsiz] = id;
 //            } else {
@@ -92,13 +95,13 @@
 //            }
 //        }
 //        for (int i = 1; i <= lsiz; i++) {
-//            arr[al + i - 1] = lset[i];
+//            qid[ql + i - 1] = lset[i];
 //        }
 //        for (int i = 1; i <= rsiz; i++) {
-//            arr[al + lsiz + i - 1] = rset[i];
+//            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(al, al + lsiz - 1, jl, mid);
-//        compute(al + lsiz, ar, mid + 1, jr);
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
 //    }
 //}
 //
@@ -111,7 +114,7 @@
 //        maxp = max(maxp, juice[i].p);
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        arr[i] = i;
+//        qid[i] = i;
 //        cin >> money[i] >> least[i];
 //    }
 //    sort(juice + 1, juice + n + 1, JuiceCmp);
diff --git a/src/class168/Code03_Multiplication1.java b/src/class168/Code03_Multiplication1.java
deleted file mode 100644
index 9b844c148..000000000
--- a/src/class168/Code03_Multiplication1.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package class168;
-
-// 矩阵乘法，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P1527
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code03_Multiplication1 {
-
-}
diff --git a/src/class168/Code06_Network1.java b/src/class168/Code06_Network1.java
index 5226931cf..688518678 100644
--- a/src/class168/Code06_Network1.java
+++ b/src/class168/Code06_Network1.java
@@ -236,19 +236,22 @@ public static void prepare() {
 		}
 	}
 
-	public static void compute(int evtl, int evtr, int impl, int impr) {
-		if (impl == impr) {
-			for (int i = evtl; i <= evtr; i++) {
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
 				if (events[i][0] > 0) {
-					ans[events[i][0]] = impl;
+					ans[events[i][0]] = vl;
 				}
 			}
 		} else {
-			int impm = (impl + impr) / 2;
+			int mid = (vl + vr) / 2;
 			int lsize = 0, rsize = 0, request = 0;
-			for (int i = evtl; i <= evtr; i++) {
+			for (int i = ql; i <= qr; i++) {
 				if (events[i][0] == 0) {
-					if (events[i][3] > impm) {
+					if (events[i][3] > mid) {
 						pathAdd(events[i][1], events[i][2], 1);
 						clone(rset[++rsize], events[i]);
 						request++;
@@ -256,7 +259,7 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 						clone(lset[++lsize], events[i]);
 					}
 				} else if (events[i][0] == -1) {
-					if (events[i][3] > impm) {
+					if (events[i][3] > mid) {
 						pathAdd(events[i][1], events[i][2], -1);
 						clone(rset[++rsize], events[i]);
 						request--;
@@ -272,21 +275,21 @@ public static void compute(int evtl, int evtr, int impl, int impr) {
 				}
 			}
 			for (int i = 1; i <= rsize; i++) {
-				if (rset[i][0] == 0 && rset[i][3] > impm) {
+				if (rset[i][0] == 0 && rset[i][3] > mid) {
 					pathAdd(rset[i][1], rset[i][2], -1);
 				}
-				if (rset[i][0] == -1 && rset[i][3] > impm) {
+				if (rset[i][0] == -1 && rset[i][3] > mid) {
 					pathAdd(rset[i][1], rset[i][2], 1);
 				}
 			}
-			for (int i = evtl, j = 1; j <= lsize; i++, j++) {
+			for (int i = ql, j = 1; j <= lsize; i++, j++) {
 				clone(events[i], lset[j]);
 			}
-			for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
+			for (int i = ql + lsize, j = 1; j <= rsize; i++, j++) {
 				clone(events[i], rset[j]);
 			}
-			compute(evtl, evtl + lsize - 1, impl, impm);
-			compute(evtl + lsize, evtr, impm + 1, impr);
+			compute(ql, ql + lsize - 1, vl, mid);
+			compute(ql + lsize, qr, mid + 1, vr);
 		}
 	}
 
diff --git a/src/class168/Code06_Network2.java b/src/class168/Code06_Network2.java
index dcae9f688..e3180b3c6 100644
--- a/src/class168/Code06_Network2.java
+++ b/src/class168/Code06_Network2.java
@@ -175,19 +175,22 @@
 //    }
 //}
 //
-//void compute(int evtl, int evtr, int impl, int impr) {
-//    if (impl == impr) {
-//        for (int i = evtl; i <= evtr; i++) {
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
 //            if (events[i][0] > 0) {
-//                ans[events[i][0]] = impl;
+//                ans[events[i][0]] = vl;
 //            }
 //        }
 //    } else {
-//        int impm = (impl + impr) / 2;
+//        int mid = (vl + vr) / 2;
 //        int lsize = 0, rsize = 0, request = 0;
-//        for (int i = evtl; i <= evtr; i++) {
+//        for (int i = ql; i <= qr; i++) {
 //            if (events[i][0] == 0) {
-//                if (events[i][3] > impm) {
+//                if (events[i][3] > mid) {
 //                    pathAdd(events[i][1], events[i][2], 1);
 //                    clone(rset[++rsize], events[i]);
 //                    request++;
@@ -195,7 +198,7 @@
 //                    clone(lset[++lsize], events[i]);
 //                }
 //            } else if (events[i][0] == -1) {
-//                if (events[i][3] > impm) {
+//                if (events[i][3] > mid) {
 //                    pathAdd(events[i][1], events[i][2], -1);
 //                    clone(rset[++rsize], events[i]);
 //                    request--;
@@ -211,21 +214,21 @@
 //            }
 //        }
 //        for (int i = 1; i <= rsize; i++) {
-//            if (rset[i][0] == 0 && rset[i][3] > impm) {
+//            if (rset[i][0] == 0 && rset[i][3] > mid) {
 //                pathAdd(rset[i][1], rset[i][2], -1);
 //            }
-//            if (rset[i][0] == -1 && rset[i][3] > impm) {
+//            if (rset[i][0] == -1 && rset[i][3] > mid) {
 //                pathAdd(rset[i][1], rset[i][2], 1);
 //            }
 //        }
-//        for (int i = evtl, j = 1; j <= lsize; i++, j++) {
+//        for (int i = ql, j = 1; j <= lsize; i++, j++) {
 //            clone(events[i], lset[j]);
 //        }
-//        for (int i = evtl + lsize, j = 1; j <= rsize; i++, j++) {
+//        for (int i = ql + lsize, j = 1; j <= rsize; i++, j++) {
 //            clone(events[i], rset[j]);
 //        }
-//        compute(evtl, evtl + lsize - 1, impl, impm);
-//        compute(evtl + lsize, evtr, impm + 1, impr);
+//        compute(ql, ql + lsize - 1, vl, mid);
+//        compute(ql + lsize, qr, mid + 1, vr);
 //    }
 //}
 //

From 39c57b31fd3a469aa3d58f14e2f6db5cbe510db1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 12:26:56 +0800
Subject: [PATCH 0791/1712] modify code

---
 src/class168/Code04_Fruit1.java                       | 11 +++++++++++
 .../{Code06_Network1.java => Code05_Network1.java}    |  2 +-
 .../{Code06_Network2.java => Code05_Network2.java}    |  0
 3 files changed, 12 insertions(+), 1 deletion(-)
 create mode 100644 src/class168/Code04_Fruit1.java
 rename src/class168/{Code06_Network1.java => Code05_Network1.java} (99%)
 rename src/class168/{Code06_Network2.java => Code05_Network2.java} (100%)

diff --git a/src/class168/Code04_Fruit1.java b/src/class168/Code04_Fruit1.java
new file mode 100644
index 000000000..1da4ad0eb
--- /dev/null
+++ b/src/class168/Code04_Fruit1.java
@@ -0,0 +1,11 @@
+package class168;
+
+// 接水果，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3242
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code04_Fruit1 {
+
+	
+	
+}
diff --git a/src/class168/Code06_Network1.java b/src/class168/Code05_Network1.java
similarity index 99%
rename from src/class168/Code06_Network1.java
rename to src/class168/Code05_Network1.java
index 688518678..f38fbf7e5 100644
--- a/src/class168/Code06_Network1.java
+++ b/src/class168/Code05_Network1.java
@@ -18,7 +18,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code06_Network1 {
+public class Code05_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class168/Code06_Network2.java b/src/class168/Code05_Network2.java
similarity index 100%
rename from src/class168/Code06_Network2.java
rename to src/class168/Code05_Network2.java

From 423dacef869140cc35e0dcc9f59f04784ad8252d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 19:26:46 +0800
Subject: [PATCH 0792/1712] modify code

---
 src/class168/Code04_Fruit1.java         |  11 -
 src/class168/Code04_PlateAndFruit1.java | 338 ++++++++++++++++++++++++
 src/class168/Code04_PlateAndFruit2.java | 244 +++++++++++++++++
 src/class168/Code05_Network1.java       |  67 ++---
 src/class168/Code05_Network2.java       |  47 +---
 5 files changed, 610 insertions(+), 97 deletions(-)
 delete mode 100644 src/class168/Code04_Fruit1.java
 create mode 100644 src/class168/Code04_PlateAndFruit1.java
 create mode 100644 src/class168/Code04_PlateAndFruit2.java

diff --git a/src/class168/Code04_Fruit1.java b/src/class168/Code04_Fruit1.java
deleted file mode 100644
index 1da4ad0eb..000000000
--- a/src/class168/Code04_Fruit1.java
+++ /dev/null
@@ -1,11 +0,0 @@
-package class168;
-
-// 接水果，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P3242
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code04_Fruit1 {
-
-	
-	
-}
diff --git a/src/class168/Code04_PlateAndFruit1.java b/src/class168/Code04_PlateAndFruit1.java
new file mode 100644
index 000000000..3c2ae73c4
--- /dev/null
+++ b/src/class168/Code04_PlateAndFruit1.java
@@ -0,0 +1,338 @@
+package class168;
+
+// 接水果，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3242
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code04_PlateAndFruit1 {
+
+	public static int MAXN = 40001;
+	public static int MAXH = 16;
+	public static int INF = 1000000001;
+	public static int n, p, q;
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] ldfn = new int[MAXN];
+	public static int[] rdfn = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXH];
+	public static int cntd = 0;
+
+	public static int[] tree = new int[MAXN];
+
+	// event[i][0]代表事件的类型，1为盘子类型，2为水果类型
+	// event[i][1]表示x轴的位置
+	// 如果是盘子类型，那么event[i][2..5]分别代表 : yl、yr、权值v、产生的影响d
+	// 如果是水果类型，那么event[i][2..5]分别代表 : y、空缺、要求v、问题的编号d
+	public static int[][] event = new int[MAXN << 3][6];
+	public static int cnte = 0;
+
+	public static int[][] lset = new int[MAXN << 3][6];
+	public static int[][] rset = new int[MAXN << 3][6];
+
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		ldfn[u] = ++cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXH; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != fa) {
+				dfs1(to[e], u);
+			}
+		}
+		rdfn[u] = cntd;
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				ldfn[u] = ++cntd;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXH; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				rdfn[u] = cntd;
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int lcaSon(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXH - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] > dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		return a;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static void add(int l, int r, int v) {
+		add(l, v);
+		add(r + 1, -v);
+	}
+
+	public static int query(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void addPlate(int x, int yl, int yr, int v, int d) {
+		event[++cnte][0] = 1;
+		event[cnte][1] = x;
+		event[cnte][2] = yl;
+		event[cnte][3] = yr;
+		event[cnte][4] = v;
+		event[cnte][5] = d;
+	}
+
+	public static void addFruit(int x, int y, int v, int d) {
+		event[++cnte][0] = 2;
+		event[cnte][1] = x;
+		event[cnte][2] = y;
+		event[cnte][4] = v;
+		event[cnte][5] = d;
+	}
+
+	public static void clone(int[] a, int[] b) {
+		a[0] = b[0];
+		a[1] = b[1];
+		a[2] = b[2];
+		a[3] = b[3];
+		a[4] = b[4];
+		a[5] = b[5];
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				if (event[i][0] == 2) {
+					ans[event[i][5]] = vl;
+				}
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			int lsiz = 0, rsiz = 0;
+			for (int i = ql; i <= qr; i++) {
+				if (event[i][0] == 1) {
+					if (event[i][4] <= mid) {
+						add(event[i][2], event[i][3], event[i][5]);
+						clone(lset[++lsiz], event[i]);
+					} else {
+						clone(rset[++rsiz], event[i]);
+					}
+				} else {
+					int check = query(event[i][2]);
+					if (check >= event[i][4]) {
+						clone(lset[++lsiz], event[i]);
+					} else {
+						event[i][4] -= check;
+						clone(rset[++rsiz], event[i]);
+					}
+				}
+			}
+			for (int i = ql; i <= qr; i++) {
+				if (event[i][0] == 1 && event[i][4] <= mid) {
+					add(event[i][2], event[i][3], -event[i][5]);
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				clone(event[ql + i - 1], lset[i]);
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				clone(event[ql + lsiz + i - 1], rset[i]);
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		p = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs2();
+		for (int i = 1; i <= p; i++) {
+			int a = in.nextInt();
+			int b = in.nextInt();
+			int c = in.nextInt();
+			if (ldfn[a] > ldfn[b]) {
+				int tmp = a;
+				a = b;
+				b = tmp;
+			}
+			int ablca = lca(a, b);
+			if (ablca == a) {
+				int son = lcaSon(a, b);
+				addPlate(1, ldfn[b], rdfn[b], c, 1);
+				addPlate(ldfn[son], ldfn[b], rdfn[b], c, -1);
+				addPlate(ldfn[b], rdfn[son] + 1, n, c, 1);
+				addPlate(rdfn[b] + 1, rdfn[son] + 1, n, c, -1);
+			} else {
+				addPlate(ldfn[a], ldfn[b], rdfn[b], c, 1);
+				addPlate(rdfn[a] + 1, ldfn[b], rdfn[b], c, -1);
+			}
+		}
+		for (int i = 1; i <= q; i++) {
+			int u = in.nextInt();
+			int v = in.nextInt();
+			int k = in.nextInt();
+			addFruit(Math.min(ldfn[u], ldfn[v]), Math.max(ldfn[u], ldfn[v]), k, i);
+		}
+		Arrays.sort(event, 1, cnte + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[0] - b[0]);
+		compute(1, cnte, 0, INF);
+		for (int i = 1; i <= q; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+
+	}
+
+}
diff --git a/src/class168/Code04_PlateAndFruit2.java b/src/class168/Code04_PlateAndFruit2.java
new file mode 100644
index 000000000..5e1bd50e1
--- /dev/null
+++ b/src/class168/Code04_PlateAndFruit2.java
@@ -0,0 +1,244 @@
+package class168;
+
+// 接水果，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3242
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Event {
+//    int op, x, yl, yr, v, d;
+//};
+//
+//bool EventCmp(Event e1, Event e2) {
+//    if (e1.x != e2.x) {
+//        return e1.x < e2.x;
+//    }
+//    return e1.op < e2.op;
+//}
+//
+//const int MAXN = 40001;
+//const int MAXH = 16;
+//const int INF = 1000000001;
+//int n, p, q;
+//
+//int head[MAXN];
+//int nxtt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int dep[MAXN];
+//int ldfn[MAXN];
+//int rdfn[MAXN];
+//int stjump[MAXN][MAXH];
+//int cntd = 0;
+//
+//int tree[MAXN];
+//
+//Event event[MAXN << 3];
+//int cnte = 0;
+//
+//Event lset[MAXN << 3];
+//Event rset[MAXN << 3];
+//
+//int ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxtt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    ldfn[u] = ++cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXH; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxtt[e]) {
+//        if (to[e] != fa) {
+//            dfs(to[e], u);
+//        }
+//    }
+//    rdfn[u] = cntd;
+//}
+//
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        int tmp = a;
+//        a = b;
+//        b = tmp;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int lcaSon(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        int tmp = a;
+//        a = b;
+//        b = tmp;
+//    }
+//    for (int p = MAXH - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] > dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    return a;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= n) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void add(int l, int r, int v) {
+//    add(l, v);
+//    add(r + 1, -v);
+//}
+//
+//int query(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void addPlate(int x, int yl, int yr, int v, int d) {
+//    event[++cnte].op = 1;
+//    event[cnte].x = x;
+//    event[cnte].yl = yl;
+//    event[cnte].yr = yr;
+//    event[cnte].v = v;
+//    event[cnte].d = d;
+//}
+//
+//void addFruit(int x, int y, int v, int d) {
+//    event[++cnte].op = 2;
+//    event[cnte].x = x;
+//    event[cnte].yl = y;
+//    event[cnte].v = v;
+//    event[cnte].d = d;
+//}
+//
+//void clone(Event& e1, Event& e2) {
+//    e1.op = e2.op;
+//    e1.x = e2.x;
+//    e1.yl = e2.yl;
+//    e1.yr = e2.yr;
+//    e1.v = e2.v;
+//    e1.d = e2.d;
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            if (event[i].op == 2) {
+//                ans[event[i].d] = vl;
+//            }
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = ql; i <= qr; i++) {
+//            if (event[i].op == 1) {
+//                if (event[i].v <= mid) {
+//                    add(event[i].yl, event[i].yr, event[i].d);
+//                    clone(lset[++lsiz], event[i]);
+//                } else {
+//                    clone(rset[++rsiz], event[i]);
+//                }
+//            } else {
+//                int check = query(event[i].yl);
+//                if (check >= event[i].v) {
+//                    clone(lset[++lsiz], event[i]);
+//                } else {
+//                    event[i].v -= check;
+//                    clone(rset[++rsiz], event[i]);
+//                }
+//            }
+//        }
+//        for (int i = ql; i <= qr; i++) {
+//            if (event[i].op == 1 && event[i].v <= mid) {
+//                add(event[i].yl, event[i].yr, -event[i].d);
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            clone(event[ql + i - 1], lset[i]);
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            clone(event[ql + lsiz + i - 1], rset[i]);
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> p >> q;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs(1, 0);
+//    for (int i = 1, a, b, c; i <= p; i++) {
+//        cin >> a >> b >> c;
+//        if (ldfn[a] > ldfn[b]) {
+//            int tmp = a;
+//            a = b;
+//            b = tmp;
+//        }
+//        int ablca = lca(a, b);
+//        if (ablca == a) {
+//            int son = lcaSon(a, b);
+//            addPlate(1, ldfn[b], rdfn[b], c, 1);
+//            addPlate(ldfn[son], ldfn[b], rdfn[b], c, -1);
+//            addPlate(ldfn[b], rdfn[son] + 1, n, c, 1);
+//            addPlate(rdfn[b] + 1, rdfn[son] + 1, n, c, -1);
+//        } else {
+//            addPlate(ldfn[a], ldfn[b], rdfn[b], c, 1);
+//            addPlate(rdfn[a] + 1, ldfn[b], rdfn[b], c, -1);
+//        }
+//    }
+//    for (int i = 1, u, v, k; i <= q; i++) {
+//        cin >> u >> v >> k;
+//        addFruit(min(ldfn[u], ldfn[v]), max(ldfn[u], ldfn[v]), k, i);
+//    }
+//    sort(event + 1, event + cnte + 1, EventCmp);
+//    compute(1, cnte, 0, INF);
+//    for (int i = 1; i <= q; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code05_Network1.java b/src/class168/Code05_Network1.java
index f38fbf7e5..596bae652 100644
--- a/src/class168/Code05_Network1.java
+++ b/src/class168/Code05_Network1.java
@@ -16,13 +16,13 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.util.Arrays;
 
 public class Code05_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
 	public static int MAXH = 20;
+	public static int INF = 1000000001;
 	public static int n, m;
 
 	// 链式前向星
@@ -44,8 +44,6 @@ public class Code05_Network1 {
 
 	// 从早到晚发生的事件
 	public static int[][] events = new int[MAXM][4];
-	public static int[] sorted = new int[MAXM];
-	public static int s = 0;
 
 	// 整体二分
 	public static int[][] lset = new int[MAXM][4];
@@ -186,21 +184,6 @@ public static int pointQuery(int x) {
 		return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 	}
 
-	public static int kth(int num) {
-		int left = 1, right = s, mid;
-		while (left <= right) {
-			mid = (left + right) / 2;
-			if (sorted[mid] == num) {
-				return mid;
-			} else if (sorted[mid] < num) {
-				left = mid + 1;
-			} else {
-				right = mid - 1;
-			}
-		}
-		return -1;
-	}
-
 	public static void clone(int[] event1, int[] event2) {
 		event1[0] = event2[0];
 		event1[1] = event2[1];
@@ -208,34 +191,6 @@ public static void clone(int[] event1, int[] event2) {
 		event1[3] = event2[3];
 	}
 
-	public static void prepare() {
-		dfs2(); // 为了防止爆栈调用迭代版
-		sorted[0] = -1;
-		for (int i = 1; i <= m; i++) {
-			if (events[i][0] == 0) {
-				sorted[++s] = events[i][3];
-			}
-		}
-		Arrays.sort(sorted, 1, s + 1);
-		int len = 1;
-		for (int i = 2; i <= s; i++) {
-			if (sorted[len] != sorted[i]) {
-				sorted[++len] = sorted[i];
-			}
-		}
-		s = len;
-		for (int i = 1; i <= m; i++) {
-			if (events[i][0] == 0) {
-				events[i][3] = kth(events[i][3]);
-			} else if (events[i][0] == 1) {
-				clone(events[i], events[events[i][1]]);
-				events[i][0] = -1;
-			} else {
-				events[i][0] = ++cntans;
-			}
-		}
-	}
-
 	public static void compute(int ql, int qr, int vl, int vr) {
 		if (ql > qr) {
 			return;
@@ -293,6 +248,18 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 	}
 
+	public static void prepare() {
+		dfs2();
+		for (int i = 1; i <= m; i++) {
+			if (events[i][0] == 1) {
+				clone(events[i], events[events[i][1]]);
+				events[i][0] = -1;
+			} else if (events[i][0] == 2) {
+				events[i][0] = ++cntans;
+			}
+		}
+	}
+
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -313,9 +280,13 @@ public static void main(String[] args) throws IOException {
 			}
 		}
 		prepare();
-		compute(1, m, 0, s);
+		compute(1, m, 0, INF);
 		for (int i = 1; i <= cntans; i++) {
-			out.println(sorted[ans[i]]);
+			if (ans[i] == 0) {
+				out.println(-1);
+			} else {
+				out.println(ans[i]);
+			}
 		}
 		out.flush();
 		out.close();
diff --git a/src/class168/Code05_Network2.java b/src/class168/Code05_Network2.java
index e3180b3c6..e602f47e9 100644
--- a/src/class168/Code05_Network2.java
+++ b/src/class168/Code05_Network2.java
@@ -20,7 +20,7 @@
 //const int MAXN = 100001;
 //const int MAXM = 200001;
 //const int MAXH = 20;
-//
+//const int INF = 1000000001;
 //int n, m;
 //
 //int head[MAXN];
@@ -38,8 +38,6 @@
 //int tree[MAXN];
 //
 //int events[MAXM][4];
-//int sorted[MAXM];
-//int s = 0;
 //
 //int lset[MAXM][4];
 //int rset[MAXM][4];
@@ -125,21 +123,6 @@
 //    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 //}
 //
-//int kth(int num) {
-//    int left = 1, right = s, mid;
-//    while (left <= right) {
-//        mid = (left + right) / 2;
-//        if (sorted[mid] == num) {
-//            return mid;
-//        } else if (sorted[mid] < num) {
-//            left = mid + 1;
-//        } else {
-//            right = mid - 1;
-//        }
-//    }
-//    return -1;
-//}
-//
 //void clone(int* e1, int* e2) {
 //    e1[0] = e2[0];
 //    e1[1] = e2[1];
@@ -149,27 +132,11 @@
 //
 //void prepare() {
 //    dfs(1, 0);
-//    sorted[0] = -1;
-//    for (int i = 1; i <= m; i++) {
-//        if (events[i][0] == 0) {
-//            sorted[++s] = events[i][3];
-//        }
-//    }
-//    sort(sorted + 1, sorted + s + 1);
-//    int len = 1;
-//    for (int i = 2; i <= s; i++) {
-//        if (sorted[len] != sorted[i]) {
-//            sorted[++len] = sorted[i];
-//        }
-//    }
-//    s = len;
 //    for (int i = 1; i <= m; i++) {
-//        if (events[i][0] == 0) {
-//            events[i][3] = kth(events[i][3]);
-//        } else if (events[i][0] == 1) {
+//        if (events[i][0] == 1) {
 //            clone(events[i], events[events[i][1]]);
 //            events[i][0] = -1;
-//        } else {
+//        } else if (events[i][0] == 2){
 //            events[i][0] = ++cntans;
 //        }
 //    }
@@ -248,9 +215,13 @@
 //        }
 //    }
 //    prepare();
-//    compute(1, m, 0, s);
+//    compute(1, m, 0, INF);
 //    for (int i = 1; i <= cntans; i++) {
-//        cout << sorted[ans[i]] << '\n';
+//        if (ans[i] == 0) {
+//            cout << -1 << '\n';
+//        } else {
+//            cout << ans[i] << '\n';
+//        }
 //    }
 //    return 0;
 //}
\ No newline at end of file

From 16c19af8d70daca94b3c17a5ec90d6153129aa3c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 19:31:32 +0800
Subject: [PATCH 0793/1712] modify code

---
 src/class168/Code05_Network1.java | 56 +++++++++++++++----------------
 src/class168/Code05_Network2.java | 52 ++++++++++++++--------------
 2 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/src/class168/Code05_Network1.java b/src/class168/Code05_Network1.java
index 596bae652..3a7abe27d 100644
--- a/src/class168/Code05_Network1.java
+++ b/src/class168/Code05_Network1.java
@@ -43,7 +43,7 @@ public class Code05_Network1 {
 	public static int[] tree = new int[MAXN];
 
 	// 从早到晚发生的事件
-	public static int[][] events = new int[MAXM][4];
+	public static int[][] event = new int[MAXM][4];
 
 	// 整体二分
 	public static int[][] lset = new int[MAXM][4];
@@ -197,35 +197,35 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = ql; i <= qr; i++) {
-				if (events[i][0] > 0) {
-					ans[events[i][0]] = vl;
+				if (event[i][0] > 0) {
+					ans[event[i][0]] = vl;
 				}
 			}
 		} else {
 			int mid = (vl + vr) / 2;
 			int lsize = 0, rsize = 0, request = 0;
 			for (int i = ql; i <= qr; i++) {
-				if (events[i][0] == 0) {
-					if (events[i][3] > mid) {
-						pathAdd(events[i][1], events[i][2], 1);
-						clone(rset[++rsize], events[i]);
+				if (event[i][0] == 0) {
+					if (event[i][3] > mid) {
+						pathAdd(event[i][1], event[i][2], 1);
+						clone(rset[++rsize], event[i]);
 						request++;
 					} else {
-						clone(lset[++lsize], events[i]);
+						clone(lset[++lsize], event[i]);
 					}
-				} else if (events[i][0] == -1) {
-					if (events[i][3] > mid) {
-						pathAdd(events[i][1], events[i][2], -1);
-						clone(rset[++rsize], events[i]);
+				} else if (event[i][0] == -1) {
+					if (event[i][3] > mid) {
+						pathAdd(event[i][1], event[i][2], -1);
+						clone(rset[++rsize], event[i]);
 						request--;
 					} else {
-						clone(lset[++lsize], events[i]);
+						clone(lset[++lsize], event[i]);
 					}
 				} else {
-					if (pointQuery(events[i][1]) != request) {
-						clone(rset[++rsize], events[i]);
+					if (pointQuery(event[i][1]) != request) {
+						clone(rset[++rsize], event[i]);
 					} else {
-						clone(lset[++lsize], events[i]);
+						clone(lset[++lsize], event[i]);
 					}
 				}
 			}
@@ -238,10 +238,10 @@ public static void compute(int ql, int qr, int vl, int vr) {
 				}
 			}
 			for (int i = ql, j = 1; j <= lsize; i++, j++) {
-				clone(events[i], lset[j]);
+				clone(event[i], lset[j]);
 			}
 			for (int i = ql + lsize, j = 1; j <= rsize; i++, j++) {
-				clone(events[i], rset[j]);
+				clone(event[i], rset[j]);
 			}
 			compute(ql, ql + lsize - 1, vl, mid);
 			compute(ql + lsize, qr, mid + 1, vr);
@@ -251,11 +251,11 @@ public static void compute(int ql, int qr, int vl, int vr) {
 	public static void prepare() {
 		dfs2();
 		for (int i = 1; i <= m; i++) {
-			if (events[i][0] == 1) {
-				clone(events[i], events[events[i][1]]);
-				events[i][0] = -1;
-			} else if (events[i][0] == 2) {
-				events[i][0] = ++cntans;
+			if (event[i][0] == 1) {
+				clone(event[i], event[event[i][1]]);
+				event[i][0] = -1;
+			} else if (event[i][0] == 2) {
+				event[i][0] = ++cntans;
 			}
 		}
 	}
@@ -272,11 +272,11 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		for (int i = 1; i <= m; i++) {
-			events[i][0] = in.nextInt();
-			events[i][1] = in.nextInt();
-			if (events[i][0] == 0) {
-				events[i][2] = in.nextInt();
-				events[i][3] = in.nextInt();
+			event[i][0] = in.nextInt();
+			event[i][1] = in.nextInt();
+			if (event[i][0] == 0) {
+				event[i][2] = in.nextInt();
+				event[i][3] = in.nextInt();
 			}
 		}
 		prepare();
diff --git a/src/class168/Code05_Network2.java b/src/class168/Code05_Network2.java
index e602f47e9..5fa68cab3 100644
--- a/src/class168/Code05_Network2.java
+++ b/src/class168/Code05_Network2.java
@@ -37,7 +37,7 @@
 //
 //int tree[MAXN];
 //
-//int events[MAXM][4];
+//int event[MAXM][4];
 //
 //int lset[MAXM][4];
 //int rset[MAXM][4];
@@ -133,11 +133,11 @@
 //void prepare() {
 //    dfs(1, 0);
 //    for (int i = 1; i <= m; i++) {
-//        if (events[i][0] == 1) {
-//            clone(events[i], events[events[i][1]]);
-//            events[i][0] = -1;
-//        } else if (events[i][0] == 2){
-//            events[i][0] = ++cntans;
+//        if (event[i][0] == 1) {
+//            clone(event[i], event[event[i][1]]);
+//            event[i][0] = -1;
+//        } else if (event[i][0] == 2){
+//            event[i][0] = ++cntans;
 //        }
 //    }
 //}
@@ -148,35 +148,35 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = ql; i <= qr; i++) {
-//            if (events[i][0] > 0) {
-//                ans[events[i][0]] = vl;
+//            if (event[i][0] > 0) {
+//                ans[event[i][0]] = vl;
 //            }
 //        }
 //    } else {
 //        int mid = (vl + vr) / 2;
 //        int lsize = 0, rsize = 0, request = 0;
 //        for (int i = ql; i <= qr; i++) {
-//            if (events[i][0] == 0) {
-//                if (events[i][3] > mid) {
-//                    pathAdd(events[i][1], events[i][2], 1);
-//                    clone(rset[++rsize], events[i]);
+//            if (event[i][0] == 0) {
+//                if (event[i][3] > mid) {
+//                    pathAdd(event[i][1], event[i][2], 1);
+//                    clone(rset[++rsize], event[i]);
 //                    request++;
 //                } else {
-//                    clone(lset[++lsize], events[i]);
+//                    clone(lset[++lsize], event[i]);
 //                }
-//            } else if (events[i][0] == -1) {
-//                if (events[i][3] > mid) {
-//                    pathAdd(events[i][1], events[i][2], -1);
-//                    clone(rset[++rsize], events[i]);
+//            } else if (event[i][0] == -1) {
+//                if (event[i][3] > mid) {
+//                    pathAdd(event[i][1], event[i][2], -1);
+//                    clone(rset[++rsize], event[i]);
 //                    request--;
 //                } else {
-//                    clone(lset[++lsize], events[i]);
+//                    clone(lset[++lsize], event[i]);
 //                }
 //            } else {
-//                if (pointQuery(events[i][1]) != request) {
-//                    clone(rset[++rsize], events[i]);
+//                if (pointQuery(event[i][1]) != request) {
+//                    clone(rset[++rsize], event[i]);
 //                } else {
-//                    clone(lset[++lsize], events[i]);
+//                    clone(lset[++lsize], event[i]);
 //                }
 //            }
 //        }
@@ -189,10 +189,10 @@
 //            }
 //        }
 //        for (int i = ql, j = 1; j <= lsize; i++, j++) {
-//            clone(events[i], lset[j]);
+//            clone(event[i], lset[j]);
 //        }
 //        for (int i = ql + lsize, j = 1; j <= rsize; i++, j++) {
-//            clone(events[i], rset[j]);
+//            clone(event[i], rset[j]);
 //        }
 //        compute(ql, ql + lsize - 1, vl, mid);
 //        compute(ql + lsize, qr, mid + 1, vr);
@@ -209,9 +209,9 @@
 //        addEdge(v, u);
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> events[i][0] >> events[i][1];
-//        if (events[i][0] == 0) {
-//            cin >> events[i][2] >> events[i][3];
+//        cin >> event[i][0] >> event[i][1];
+//        if (event[i][0] == 0) {
+//            cin >> event[i][2] >> event[i][3];
 //        }
 //    }
 //    prepare();

From c8bd577e6d9fa9b215382692c3f57efc048292ce Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 19:33:17 +0800
Subject: [PATCH 0794/1712] modify code

---
 src/class168/Code04_PlateAndFruit2.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class168/Code04_PlateAndFruit2.java b/src/class168/Code04_PlateAndFruit2.java
index 5e1bd50e1..25a6a800c 100644
--- a/src/class168/Code04_PlateAndFruit2.java
+++ b/src/class168/Code04_PlateAndFruit2.java
@@ -26,7 +26,7 @@
 //int n, p, q;
 //
 //int head[MAXN];
-//int nxtt[MAXN << 1];
+//int nxt[MAXN << 1];
 //int to[MAXN << 1];
 //int cntg = 0;
 //
@@ -47,7 +47,7 @@
 //int ans[MAXN];
 //
 //void addEdge(int u, int v) {
-//    nxtt[++cntg] = head[u];
+//    nxt[++cntg] = head[u];
 //    to[cntg] = v;
 //    head[u] = cntg;
 //}
@@ -59,7 +59,7 @@
 //    for (int p = 1; p < MAXH; p++) {
 //        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 //    }
-//    for (int e = head[u]; e > 0; e = nxtt[e]) {
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        if (to[e] != fa) {
 //            dfs(to[e], u);
 //        }

From 31059298231c862ca9f9a006ad61ea24bff8794f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 20:17:52 +0800
Subject: [PATCH 0795/1712] modify code

---
 src/class168/Code04_PlateAndFruit1.java | 11 ++++++-----
 src/class168/Code04_PlateAndFruit2.java |  5 -----
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/class168/Code04_PlateAndFruit1.java b/src/class168/Code04_PlateAndFruit1.java
index 3c2ae73c4..06a86194c 100644
--- a/src/class168/Code04_PlateAndFruit1.java
+++ b/src/class168/Code04_PlateAndFruit1.java
@@ -230,11 +230,12 @@ public static void compute(int ql, int qr, int vl, int vr) {
 					}
 				}
 			}
-			for (int i = ql; i <= qr; i++) {
-				if (event[i][0] == 1 && event[i][4] <= mid) {
-					add(event[i][2], event[i][3], -event[i][5]);
-				}
-			}
+			// 这里为什么不用做撤销？
+			// 因为任何一个盘子，一定有两条扫描线
+			// 一条扫描线会增加yl..yr的计数
+			// 另外一条扫描线会减少计数
+			// 并且同一个盘子的两条扫描线不可能分开
+			// 所以此时树状数组就是清空的，并不需要做撤销了
 			for (int i = 1; i <= lsiz; i++) {
 				clone(event[ql + i - 1], lset[i]);
 			}
diff --git a/src/class168/Code04_PlateAndFruit2.java b/src/class168/Code04_PlateAndFruit2.java
index 25a6a800c..de4f0ae7a 100644
--- a/src/class168/Code04_PlateAndFruit2.java
+++ b/src/class168/Code04_PlateAndFruit2.java
@@ -186,11 +186,6 @@
 //                }
 //            }
 //        }
-//        for (int i = ql; i <= qr; i++) {
-//            if (event[i].op == 1 && event[i].v <= mid) {
-//                add(event[i].yl, event[i].yr, -event[i].d);
-//            }
-//        }
 //        for (int i = 1; i <= lsiz; i++) {
 //            clone(event[ql + i - 1], lset[i]);
 //        }

From 8983e05185d1d1a24ca8d52fd7f729257a6ae612 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 20:20:07 +0800
Subject: [PATCH 0796/1712] modify code

---
 src/class168/Code04_PlateAndFruit1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class168/Code04_PlateAndFruit1.java b/src/class168/Code04_PlateAndFruit1.java
index 06a86194c..1cce01e88 100644
--- a/src/class168/Code04_PlateAndFruit1.java
+++ b/src/class168/Code04_PlateAndFruit1.java
@@ -234,8 +234,8 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			// 因为任何一个盘子，一定有两条扫描线
 			// 一条扫描线会增加yl..yr的计数
 			// 另外一条扫描线会减少计数
-			// 并且同一个盘子的两条扫描线不可能分开
-			// 所以此时树状数组就是清空的，并不需要做撤销了
+			// 同一个盘子的两条扫描线，一定会在一起，是不可能分开的
+			// 所以此时树状数组就是清空的，不需要再做撤销操作
 			for (int i = 1; i <= lsiz; i++) {
 				clone(event[ql + i - 1], lset[i]);
 			}

From abfc6bc672414d0e105db31b3a05293b8ca62952 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 20:24:09 +0800
Subject: [PATCH 0797/1712] modify code

---
 src/class168/Code04_PlateAndFruit1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class168/Code04_PlateAndFruit1.java b/src/class168/Code04_PlateAndFruit1.java
index 1cce01e88..7e9e7e1c1 100644
--- a/src/class168/Code04_PlateAndFruit1.java
+++ b/src/class168/Code04_PlateAndFruit1.java
@@ -233,7 +233,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			// 这里为什么不用做撤销？
 			// 因为任何一个盘子，一定有两条扫描线
 			// 一条扫描线会增加yl..yr的计数
-			// 另外一条扫描线会减少计数
+			// 一条扫描线会减少yl..yr的计数
 			// 同一个盘子的两条扫描线，一定会在一起，是不可能分开的
 			// 所以此时树状数组就是清空的，不需要再做撤销操作
 			for (int i = 1; i <= lsiz; i++) {

From 8e2753d94f01fa2060da328ff9e562d3e7298b3a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 11 May 2025 20:51:08 +0800
Subject: [PATCH 0798/1712] modify code

---
 src/class168/Code04_PlateAndFruit2.java | 21 ++----
 src/class168/Code05_Network1.java       |  8 ++-
 src/class168/Code05_Network2.java       | 90 ++++++++++++-------------
 3 files changed, 56 insertions(+), 63 deletions(-)

diff --git a/src/class168/Code04_PlateAndFruit2.java b/src/class168/Code04_PlateAndFruit2.java
index de4f0ae7a..60a2cb904 100644
--- a/src/class168/Code04_PlateAndFruit2.java
+++ b/src/class168/Code04_PlateAndFruit2.java
@@ -146,15 +146,6 @@
 //    event[cnte].d = d;
 //}
 //
-//void clone(Event& e1, Event& e2) {
-//    e1.op = e2.op;
-//    e1.x = e2.x;
-//    e1.yl = e2.yl;
-//    e1.yr = e2.yr;
-//    e1.v = e2.v;
-//    e1.d = e2.d;
-//}
-//
 //void compute(int ql, int qr, int vl, int vr) {
 //    if (ql > qr) {
 //        return;
@@ -172,25 +163,25 @@
 //            if (event[i].op == 1) {
 //                if (event[i].v <= mid) {
 //                    add(event[i].yl, event[i].yr, event[i].d);
-//                    clone(lset[++lsiz], event[i]);
+//                    lset[++lsiz] = event[i];
 //                } else {
-//                    clone(rset[++rsiz], event[i]);
+//                    rset[++rsiz] = event[i];
 //                }
 //            } else {
 //                int check = query(event[i].yl);
 //                if (check >= event[i].v) {
-//                    clone(lset[++lsiz], event[i]);
+//                    lset[++lsiz] = event[i];
 //                } else {
 //                    event[i].v -= check;
-//                    clone(rset[++rsiz], event[i]);
+//                    rset[++rsiz] = event[i];
 //                }
 //            }
 //        }
 //        for (int i = 1; i <= lsiz; i++) {
-//            clone(event[ql + i - 1], lset[i]);
+//            event[ql + i - 1] = lset[i];
 //        }
 //        for (int i = 1; i <= rsiz; i++) {
-//            clone(event[ql + lsiz + i - 1], rset[i]);
+//            event[ql + lsiz + i - 1] = rset[i];
 //        }
 //        compute(ql, ql + lsiz - 1, vl, mid);
 //        compute(ql + lsiz, qr, mid + 1, vr);
diff --git a/src/class168/Code05_Network1.java b/src/class168/Code05_Network1.java
index 3a7abe27d..cf17dbce2 100644
--- a/src/class168/Code05_Network1.java
+++ b/src/class168/Code05_Network1.java
@@ -4,7 +4,7 @@
 // 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
 // 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
 // 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
-// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
+// 操作 0 x y v : x号服务器到y号服务器的路径上，增加了一个重要度为v的请求
 // 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
 // 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
 // 关于操作2，如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
@@ -42,12 +42,16 @@ public class Code05_Network1 {
 	// 树状数组
 	public static int[] tree = new int[MAXN];
 
-	// 从早到晚发生的事件
+	// 从早到晚发生的事件，op、x、y、v
+	// op == 0，添加点x到点y，重要度为v的路径
+	// op == -1，删除点x到点y，重要度为v的路径
+	// op > 0，那么op表示问题的编号，查询和x相关的答案
 	public static int[][] event = new int[MAXM][4];
 
 	// 整体二分
 	public static int[][] lset = new int[MAXM][4];
 	public static int[][] rset = new int[MAXM][4];
+
 	public static int[] ans = new int[MAXM];
 	public static int cntans = 0;
 
diff --git a/src/class168/Code05_Network2.java b/src/class168/Code05_Network2.java
index 5fa68cab3..625c3bcf8 100644
--- a/src/class168/Code05_Network2.java
+++ b/src/class168/Code05_Network2.java
@@ -4,7 +4,7 @@
 // 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
 // 某两个服务器之间的路径上，可能接受一条请求，路径上的所有服务器都需要保存该请求的重要度
 // 一共有m条操作，每条操作是如下3种类型中的一种，操作依次发生，第i条操作发生的时间为i
-// 操作 0 a b v : a号服务器到b号服务器的路径上，增加了一个重要度为v的请求
+// 操作 0 x y v : x号服务器到y号服务器的路径上，增加了一个重要度为v的请求
 // 操作 1 t     : 当初时间为t的操作，一定是增加请求的操作，现在这个请求结束了
 // 操作 2 x     : 当前时间下，和x号服务器无关的所有请求中，打印最大的重要度
 // 关于操作2，如果当前时间下，没有任何请求、或者所有请求都和x号服务器有关，打印-1
@@ -17,6 +17,10 @@
 //
 //using namespace std;
 //
+//struct Event {
+//    int op, x, y, v;
+//};
+//
 //const int MAXN = 100001;
 //const int MAXM = 200001;
 //const int MAXH = 20;
@@ -37,10 +41,11 @@
 //
 //int tree[MAXN];
 //
-//int event[MAXM][4];
+//Event event[MAXM];
+//
+//Event lset[MAXM];
+//Event rset[MAXM];
 //
-//int lset[MAXM][4];
-//int rset[MAXM][4];
 //int ans[MAXM];
 //int cntans = 0;
 //
@@ -123,21 +128,14 @@
 //    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 //}
 //
-//void clone(int* e1, int* e2) {
-//    e1[0] = e2[0];
-//    e1[1] = e2[1];
-//    e1[2] = e2[2];
-//    e1[3] = e2[3];
-//}
-//
 //void prepare() {
 //    dfs(1, 0);
 //    for (int i = 1; i <= m; i++) {
-//        if (event[i][0] == 1) {
-//            clone(event[i], event[event[i][1]]);
-//            event[i][0] = -1;
-//        } else if (event[i][0] == 2){
-//            event[i][0] = ++cntans;
+//        if (event[i].op == 1) {
+//            event[i] = event[event[i].x];
+//            event[i].op = -1;
+//        } else if (event[i].op == 2){
+//            event[i].op = ++cntans;
 //        }
 //    }
 //}
@@ -148,54 +146,54 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = ql; i <= qr; i++) {
-//            if (event[i][0] > 0) {
-//                ans[event[i][0]] = vl;
+//            if (event[i].op > 0) {
+//                ans[event[i].op] = vl;
 //            }
 //        }
 //    } else {
 //        int mid = (vl + vr) / 2;
-//        int lsize = 0, rsize = 0, request = 0;
+//        int lsiz = 0, rsiz = 0, request = 0;
 //        for (int i = ql; i <= qr; i++) {
-//            if (event[i][0] == 0) {
-//                if (event[i][3] > mid) {
-//                    pathAdd(event[i][1], event[i][2], 1);
-//                    clone(rset[++rsize], event[i]);
+//            if (event[i].op == 0) {
+//                if (event[i].v > mid) {
+//                    pathAdd(event[i].x, event[i].y, 1);
+//                    rset[++rsiz] = event[i];
 //                    request++;
 //                } else {
-//                    clone(lset[++lsize], event[i]);
+//                    lset[++lsiz] = event[i];
 //                }
-//            } else if (event[i][0] == -1) {
-//                if (event[i][3] > mid) {
-//                    pathAdd(event[i][1], event[i][2], -1);
-//                    clone(rset[++rsize], event[i]);
+//            } else if (event[i].op == -1) {
+//                if (event[i].v > mid) {
+//                    pathAdd(event[i].x, event[i].y, -1);
+//                    rset[++rsiz] = event[i];
 //                    request--;
 //                } else {
-//                    clone(lset[++lsize], event[i]);
+//                    lset[++lsiz] = event[i];
 //                }
 //            } else {
-//                if (pointQuery(event[i][1]) != request) {
-//                    clone(rset[++rsize], event[i]);
+//                if (pointQuery(event[i].x) != request) {
+//                    rset[++rsiz] = event[i];
 //                } else {
-//                    clone(lset[++lsize], event[i]);
+//                    lset[++lsiz] = event[i];
 //                }
 //            }
 //        }
-//        for (int i = 1; i <= rsize; i++) {
-//            if (rset[i][0] == 0 && rset[i][3] > mid) {
-//                pathAdd(rset[i][1], rset[i][2], -1);
+//        for (int i = 1; i <= rsiz; i++) {
+//            if (rset[i].op == 0 && rset[i].v > mid) {
+//                pathAdd(rset[i].x, rset[i].y, -1);
 //            }
-//            if (rset[i][0] == -1 && rset[i][3] > mid) {
-//                pathAdd(rset[i][1], rset[i][2], 1);
+//            if (rset[i].op == -1 && rset[i].v > mid) {
+//                pathAdd(rset[i].x, rset[i].y, 1);
 //            }
 //        }
-//        for (int i = ql, j = 1; j <= lsize; i++, j++) {
-//            clone(event[i], lset[j]);
+//        for (int i = 1; i <= lsiz; i++) {
+//            event[ql + i - 1] = lset[i];
 //        }
-//        for (int i = ql + lsize, j = 1; j <= rsize; i++, j++) {
-//            clone(event[i], rset[j]);
+//        for (int i = 1; i <= rsiz; i++) {
+//            event[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql, ql + lsize - 1, vl, mid);
-//        compute(ql + lsize, qr, mid + 1, vr);
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
 //    }
 //}
 //
@@ -209,9 +207,9 @@
 //        addEdge(v, u);
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> event[i][0] >> event[i][1];
-//        if (event[i][0] == 0) {
-//            cin >> event[i][2] >> event[i][3];
+//        cin >> event[i].op >> event[i].x;
+//        if (event[i].op == 0) {
+//            cin >> event[i].y >> event[i].v;
 //        }
 //    }
 //    prepare();

From 91da612c63c80abf94754612131013ce867d9026 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 12 May 2025 18:54:24 +0800
Subject: [PATCH 0799/1712] modify code

---
 src/class168/Code04_IvanAndBurgers1.java      | 173 ++++++++++++++++++
 src/class168/Code04_IvanAndBurgers2.java      | 128 +++++++++++++
 ...Fruit1.java => Code06_PlateAndFruit1.java} |   2 +-
 ...Fruit2.java => Code06_PlateAndFruit2.java} |   0
 ...e05_Network1.java => Code07_Network1.java} |   2 +-
 ...e05_Network2.java => Code07_Network2.java} |   0
 6 files changed, 303 insertions(+), 2 deletions(-)
 create mode 100644 src/class168/Code04_IvanAndBurgers1.java
 create mode 100644 src/class168/Code04_IvanAndBurgers2.java
 rename src/class168/{Code04_PlateAndFruit1.java => Code06_PlateAndFruit1.java} (99%)
 rename src/class168/{Code04_PlateAndFruit2.java => Code06_PlateAndFruit2.java} (100%)
 rename src/class168/{Code05_Network1.java => Code07_Network1.java} (99%)
 rename src/class168/{Code05_Network2.java => Code07_Network2.java} (100%)

diff --git a/src/class168/Code04_IvanAndBurgers1.java b/src/class168/Code04_IvanAndBurgers1.java
new file mode 100644
index 000000000..11229890b
--- /dev/null
+++ b/src/class168/Code04_IvanAndBurgers1.java
@@ -0,0 +1,173 @@
+package class168;
+
+// 范围内最大异或和，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1100F
+// 测试链接 : https://codeforces.com/problemset/problem/1100/F
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code04_IvanAndBurgers1 {
+
+	public static int MAXN = 500001;
+	public static int BIT = 21;
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+	public static int[] qid = new int[MAXN];
+	public static int[] l = new int[MAXN];
+	public static int[] r = new int[MAXN];
+
+	public static int[][] baset = new int[MAXN][BIT + 1];
+	public static int[] tmp = new int[BIT + 1];
+
+	public static int[] lset = new int[MAXN];
+	public static int[] rset = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static void insert(int[] basis, int num) {
+		for (int i = BIT; i >= 0; i--) {
+			if (num >> i == 1) {
+				if (basis[i] == 0) {
+					basis[i] = num;
+					return;
+				}
+				num ^= basis[i];
+			}
+		}
+	}
+
+	public static void clear(int[] basis) {
+		for (int i = 0; i <= BIT; i++) {
+			basis[i] = 0;
+		}
+	}
+
+	public static int maxEor(int[] basis) {
+		int ret = 0;
+		for (int i = BIT; i >= 0; i--) {
+			ret = Math.max(ret, ret ^ basis[i]);
+		}
+		return ret;
+	}
+
+	public static void clone(int[] b1, int[] b2) {
+		for (int i = 0; i <= BIT; i++) {
+			b1[i] = b2[i];
+		}
+	}
+
+	public static void merge(int[] b1, int[] b2) {
+		clone(tmp, b1);
+		for (int i = 0; i <= BIT; i++) {
+			insert(tmp, b2[i]);
+		}
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = arr[vl];
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			clear(baset[mid]);
+			insert(baset[mid], arr[mid]);
+			for (int i = mid - 1; i >= vl; i--) {
+				clone(baset[i], baset[i + 1]);
+				insert(baset[i], arr[i]);
+			}
+			for (int i = mid + 1; i <= vr; i++) {
+				clone(baset[i], baset[i - 1]);
+				insert(baset[i], arr[i]);
+			}
+			int lsiz = 0, rsiz = 0, id;
+			for (int i = ql; i <= qr; i++) {
+				id = qid[i];
+				if (r[id] < mid) {
+					lset[++lsiz] = id;
+				} else if (l[id] > mid) {
+					rset[++rsiz] = id;
+				} else {
+					merge(baset[l[id]], baset[r[id]]);
+					ans[id] = maxEor(tmp);
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				qid[ql + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				qid[ql + lsiz + i - 1] = rset[i];
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, ql + lsiz + rsiz - 1, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		m = in.nextInt();
+		for (int i = 1; i <= m; i++) {
+			qid[i] = i;
+			l[i] = in.nextInt();
+			r[i] = in.nextInt();
+		}
+		compute(1, m, 1, n);
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code04_IvanAndBurgers2.java b/src/class168/Code04_IvanAndBurgers2.java
new file mode 100644
index 000000000..b2ca5dff2
--- /dev/null
+++ b/src/class168/Code04_IvanAndBurgers2.java
@@ -0,0 +1,128 @@
+package class168;
+
+// 范围内最大异或和，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1100F
+// 测试链接 : https://codeforces.com/problemset/problem/1100/F
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//const int BIT = 21;
+//int n, m;
+//
+//int arr[MAXN];
+//int qid[MAXN];
+//int l[MAXN];
+//int r[MAXN];
+//
+//int baset[MAXN][BIT + 1];
+//int tmp[BIT + 1];
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//int ans[MAXN];
+//
+//void insert(int* basis, int num) {
+//    for (int i = BIT; i >= 0; i--) {
+//        if ((num >> i) & 1) {
+//            if (basis[i] == 0) {
+//                basis[i] = num;
+//                return;
+//            }
+//            num ^= basis[i];
+//        }
+//    }
+//}
+//
+//void clear(int* basis) {
+//    for (int i = 0; i <= BIT; i++) {
+//        basis[i] = 0;
+//    }
+//}
+//
+//int maxEor(int* basis) {
+//    int ret = 0;
+//    for (int i = BIT; i >= 0; i--) {
+//        ret = max(ret, ret ^ basis[i]);
+//    }
+//    return ret;
+//}
+//
+//void clone(int* b1, int* b2) {
+//    for (int i = 0; i <= BIT; i++) {
+//        b1[i] = b2[i];
+//    }
+//}
+//
+//void merge(int* b1, int* b2) {
+//    clone(tmp, b1);
+//    for (int i = 0; i <= BIT; i++) {
+//        insert(tmp, b2[i]);
+//    }
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = arr[vl];
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        clear(baset[mid]);
+//        insert(baset[mid], arr[mid]);
+//        for (int i = mid - 1; i >= vl; i--) {
+//            clone(baset[i], baset[i + 1]);
+//            insert(baset[i], arr[i]);
+//        }
+//        for (int i = mid + 1; i <= vr; i++) {
+//            clone(baset[i], baset[i - 1]);
+//            insert(baset[i], arr[i]);
+//        }
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = ql, id; i <= qr; i++) {
+//            id = qid[i];
+//            if (r[id] < mid) {
+//                lset[++lsiz] = id;
+//            } else if (l[id] > mid) {
+//                rset[++rsiz] = id;
+//            } else {
+//                merge(baset[l[id]], baset[r[id]]);
+//                ans[id] = maxEor(tmp);
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, ql + lsiz + rsiz - 1, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    cin >> m;
+//    for (int i = 1; i <= m; i++) {
+//        qid[i] = i;
+//        cin >> l[i] >> r[i];
+//    }
+//    compute(1, m, 1, n);
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code04_PlateAndFruit1.java b/src/class168/Code06_PlateAndFruit1.java
similarity index 99%
rename from src/class168/Code04_PlateAndFruit1.java
rename to src/class168/Code06_PlateAndFruit1.java
index 7e9e7e1c1..dffd4dd09 100644
--- a/src/class168/Code04_PlateAndFruit1.java
+++ b/src/class168/Code06_PlateAndFruit1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_PlateAndFruit1 {
+public class Code06_PlateAndFruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class168/Code04_PlateAndFruit2.java b/src/class168/Code06_PlateAndFruit2.java
similarity index 100%
rename from src/class168/Code04_PlateAndFruit2.java
rename to src/class168/Code06_PlateAndFruit2.java
diff --git a/src/class168/Code05_Network1.java b/src/class168/Code07_Network1.java
similarity index 99%
rename from src/class168/Code05_Network1.java
rename to src/class168/Code07_Network1.java
index cf17dbce2..afa669476 100644
--- a/src/class168/Code05_Network1.java
+++ b/src/class168/Code07_Network1.java
@@ -17,7 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_Network1 {
+public class Code07_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class168/Code05_Network2.java b/src/class168/Code07_Network2.java
similarity index 100%
rename from src/class168/Code05_Network2.java
rename to src/class168/Code07_Network2.java

From e5b1a898621904f0060f231fa06911c1b1cd81a7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 12 May 2025 18:59:10 +0800
Subject: [PATCH 0800/1712] modify code

---
 src/class168/Code05_PastoralOddities1.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 src/class168/Code05_PastoralOddities1.java

diff --git a/src/class168/Code05_PastoralOddities1.java b/src/class168/Code05_PastoralOddities1.java
new file mode 100644
index 000000000..2d62931d3
--- /dev/null
+++ b/src/class168/Code05_PastoralOddities1.java
@@ -0,0 +1,9 @@
+package class168;
+
+// 度为奇数的最大边权，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF603E
+// 测试链接 : https://codeforces.com/problemset/problem/603/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+public class Code05_PastoralOddities1 {
+
+}

From f9a03884db62fe14baa167d606a20152965b858e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 12 May 2025 20:32:24 +0800
Subject: [PATCH 0801/1712] modify code

---
 ...ode04_IvanAndBurgers1.java => Code02_IvanAndBurgers1.java} | 2 +-
 ...ode04_IvanAndBurgers2.java => Code02_IvanAndBurgers2.java} | 0
 src/class168/{Code02_Meteors1.java => Code03_Meteors1.java}   | 4 ++--
 src/class168/{Code02_Meteors2.java => Code03_Meteors2.java}   | 0
 src/class168/{Code03_Juice1.java => Code04_Juice1.java}       | 2 +-
 src/class168/{Code03_Juice2.java => Code04_Juice2.java}       | 0
 6 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class168/{Code04_IvanAndBurgers1.java => Code02_IvanAndBurgers1.java} (99%)
 rename src/class168/{Code04_IvanAndBurgers2.java => Code02_IvanAndBurgers2.java} (100%)
 rename src/class168/{Code02_Meteors1.java => Code03_Meteors1.java} (97%)
 rename src/class168/{Code02_Meteors2.java => Code03_Meteors2.java} (100%)
 rename src/class168/{Code03_Juice1.java => Code04_Juice1.java} (99%)
 rename src/class168/{Code03_Juice2.java => Code04_Juice2.java} (100%)

diff --git a/src/class168/Code04_IvanAndBurgers1.java b/src/class168/Code02_IvanAndBurgers1.java
similarity index 99%
rename from src/class168/Code04_IvanAndBurgers1.java
rename to src/class168/Code02_IvanAndBurgers1.java
index 11229890b..4a65d40a2 100644
--- a/src/class168/Code04_IvanAndBurgers1.java
+++ b/src/class168/Code02_IvanAndBurgers1.java
@@ -10,7 +10,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_IvanAndBurgers1 {
+public class Code02_IvanAndBurgers1 {
 
 	public static int MAXN = 500001;
 	public static int BIT = 21;
diff --git a/src/class168/Code04_IvanAndBurgers2.java b/src/class168/Code02_IvanAndBurgers2.java
similarity index 100%
rename from src/class168/Code04_IvanAndBurgers2.java
rename to src/class168/Code02_IvanAndBurgers2.java
diff --git a/src/class168/Code02_Meteors1.java b/src/class168/Code03_Meteors1.java
similarity index 97%
rename from src/class168/Code02_Meteors1.java
rename to src/class168/Code03_Meteors1.java
index 8dbfaa7c8..5c95ed8fb 100644
--- a/src/class168/Code02_Meteors1.java
+++ b/src/class168/Code03_Meteors1.java
@@ -5,7 +5,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
 // 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
-// 想通过用C++实现，本节课Code02_Meteors2文件就是C++的实现
+// 想通过用C++实现，本节课Code03_Meteors2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -13,7 +13,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_Meteors1 {
+public class Code03_Meteors1 {
 
 	public static int MAXN = 300001;
 	public static int n, m, k;
diff --git a/src/class168/Code02_Meteors2.java b/src/class168/Code03_Meteors2.java
similarity index 100%
rename from src/class168/Code02_Meteors2.java
rename to src/class168/Code03_Meteors2.java
diff --git a/src/class168/Code03_Juice1.java b/src/class168/Code04_Juice1.java
similarity index 99%
rename from src/class168/Code03_Juice1.java
rename to src/class168/Code04_Juice1.java
index 9566f275a..6e4002ea3 100644
--- a/src/class168/Code03_Juice1.java
+++ b/src/class168/Code04_Juice1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_Juice1 {
+public class Code04_Juice1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class168/Code03_Juice2.java b/src/class168/Code04_Juice2.java
similarity index 100%
rename from src/class168/Code03_Juice2.java
rename to src/class168/Code04_Juice2.java

From 10dcbbf9fb58448e256ebd53e50c4debf913ac1f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 12 May 2025 22:34:37 +0800
Subject: [PATCH 0802/1712] modify code

---
 src/class168/Code05_PastoralOddities1.java | 191 +++++++++++++++++++++
 src/class168/Code05_PastoralOddities2.java | 154 +++++++++++++++++
 2 files changed, 345 insertions(+)
 create mode 100644 src/class168/Code05_PastoralOddities2.java

diff --git a/src/class168/Code05_PastoralOddities1.java b/src/class168/Code05_PastoralOddities1.java
index 2d62931d3..55d870a47 100644
--- a/src/class168/Code05_PastoralOddities1.java
+++ b/src/class168/Code05_PastoralOddities1.java
@@ -4,6 +4,197 @@
 // 测试链接 : https://www.luogu.com.cn/problem/CF603E
 // 测试链接 : https://codeforces.com/problemset/problem/603/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code05_PastoralOddities1 {
 
+	public static int MAXN = 100001;
+	public static int MAXM = 300002;
+	public static int n, m;
+
+	// 边的编号i、端点x、端点y、权值w
+	public static int[][] edge = new int[MAXM][4];
+	public static int[][] sorted = new int[MAXM][4];
+
+	// 节点数为奇数的联通区数量
+	public static int oddnum;
+	// 可撤销并查集
+	public static int[] father = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize = 0;
+
+	public static int[] ans = new int[MAXM];
+
+	public static int find(int i) {
+		while (i != father[i]) {
+			i = father[i];
+		}
+		return i;
+	}
+
+	public static boolean union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (fx == fy) {
+			return false;
+		}
+		if ((siz[fx] & 1) == 1 && (siz[fy] & 1) == 1) {
+			oddnum -= 2;
+		}
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		father[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+		return true;
+	}
+
+	public static void undo() {
+		int fx = rollback[opsize][0];
+		int fy = rollback[opsize--][1];
+		father[fy] = fy;
+		siz[fx] -= siz[fy];
+		if ((siz[fx] & 1) == 1 && (siz[fy] & 1) == 1) {
+			oddnum += 2;
+		}
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[i] = sorted[vl][3];
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			int unionCnt1 = 0;
+			for (int i = vl; i <= mid; i++) {
+				if (sorted[i][0] < ql) {
+					if (union(sorted[i][1], sorted[i][2])) {
+						unionCnt1++;
+					}
+				}
+			}
+			int unionCnt2 = 0;
+			int split = qr + 1;
+			for (int i = ql; i <= qr; i++) {
+				if (edge[i][3] <= sorted[mid][3]) {
+					if (union(edge[i][1], edge[i][2])) {
+						unionCnt2++;
+					}
+				}
+				if (oddnum == 0) {
+					split = i;
+					break;
+				}
+			}
+			for (int i = 1; i <= unionCnt2; i++) {
+				undo();
+			}
+			compute(ql, split - 1, mid + 1, vr);
+			for (int i = 1; i <= unionCnt1; i++) {
+				undo();
+			}
+			int unionCnt3 = 0;
+			for (int i = ql; i <= split - 1; i++) {
+				if (edge[i][3] <= sorted[vl][3]) {
+					if (union(edge[i][1], edge[i][2])) {
+						unionCnt3++;
+					}
+				}
+			}
+			compute(split, qr, vl, mid);
+			for (int i = 1; i <= unionCnt3; i++) {
+				undo();
+			}
+		}
+	}
+
+	public static void prepare() {
+		oddnum = n;
+		for (int i = 1; i <= n; i++) {
+			father[i] = i;
+			siz[i] = 1;
+		}
+		for (int i = 1; i <= m; i++) {
+			sorted[i][0] = edge[i][0];
+			sorted[i][1] = edge[i][1];
+			sorted[i][2] = edge[i][2];
+			sorted[i][3] = edge[i][3];
+		}
+		Arrays.sort(sorted, 1, m + 1, (a, b) -> a[3] - b[3]);
+		sorted[m + 1][3] = -1;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= m; i++) {
+			edge[i][0] = i;
+			edge[i][1] = in.nextInt();
+			edge[i][2] = in.nextInt();
+			edge[i][3] = in.nextInt();
+		}
+		prepare();
+		compute(1, m, 1, m + 1);
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class168/Code05_PastoralOddities2.java b/src/class168/Code05_PastoralOddities2.java
new file mode 100644
index 000000000..b1d935721
--- /dev/null
+++ b/src/class168/Code05_PastoralOddities2.java
@@ -0,0 +1,154 @@
+package class168;
+
+// 度为奇数的最大边权，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF603E
+// 测试链接 : https://codeforces.com/problemset/problem/603/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Edge {
+//    int i, x, y, w;
+//};
+//
+//bool EdgeCmp(Edge a, Edge b) {
+//    return a.w < b.w;
+//}
+//
+//const int MAXN = 100001;
+//const int MAXM = 300002;
+//int n, m;
+//
+//Edge edge[MAXM];
+//Edge sorted[MAXM];
+//
+//int oddnum;
+//int father[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
+//int ans[MAXM];
+//
+//int find(int i) {
+//    while (i != father[i]) {
+//        i = father[i];
+//    }
+//    return i;
+//}
+//
+//bool Union(int x, int y) {
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (fx == fy) {
+//        return false;
+//    }
+//    if ((siz[fx] & 1) == 1 && (siz[fy] & 1) == 1) {
+//        oddnum -= 2;
+//    }
+//    if (siz[fx] < siz[fy]) {
+//        int tmp = fx;
+//        fx = fy;
+//        fy = tmp;
+//    }
+//    father[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
+//    return true;
+//}
+//
+//void undo() {
+//    int fx = rollback[opsize][0];
+//    int fy = rollback[opsize--][1];
+//    father[fy] = fy;
+//    siz[fx] -= siz[fy];
+//    if ((siz[fx] & 1) == 1 && (siz[fy] & 1) == 1) {
+//        oddnum += 2;
+//    }
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[i] = sorted[vl].w;
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        int unionCnt1 = 0;
+//        for (int i = vl; i <= mid; i++) {
+//            if (sorted[i].i < ql) {
+//                if (Union(sorted[i].x, sorted[i].y)) {
+//                    unionCnt1++;
+//                }
+//            }
+//        }
+//        int unionCnt2 = 0;
+//        int split = qr + 1;
+//        for (int i = ql; i <= qr; i++) {
+//            if (edge[i].w <= sorted[mid].w) {
+//                if (Union(edge[i].x, edge[i].y)) {
+//                    unionCnt2++;
+//                }
+//            }
+//            if (oddnum == 0) {
+//                split = i;
+//                break;
+//            }
+//        }
+//        for (int i = 1; i <= unionCnt2; i++) {
+//            undo();
+//        }
+//        compute(ql, split - 1, mid + 1, vr);
+//        for (int i = 1; i <= unionCnt1; i++) {
+//            undo();
+//        }
+//        int unionCnt3 = 0;
+//        for (int i = ql; i <= split - 1; i++) {
+//            if (edge[i].w <= sorted[vl].w) {
+//                if (Union(edge[i].x, edge[i].y)) {
+//                    unionCnt3++;
+//                }
+//            }
+//        }
+//        compute(split, qr, vl, mid);
+//        for (int i = 1; i <= unionCnt3; i++) {
+//            undo();
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    oddnum = n;
+//    for (int i = 1; i <= n; i++) {
+//        father[i] = i;
+//        siz[i] = 1;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        sorted[i] = edge[i];
+//    }
+//    sort(sorted + 1, sorted + m + 1, EdgeCmp);
+//    sorted[m + 1].w = -1;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        edge[i].i = i;
+//        cin >> edge[i].x >> edge[i].y >> edge[i].w;
+//    }
+//    prepare();
+//    compute(1, m, 1, m + 1);
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 59f05c28cf2212ccbe8b73ee2cbcfb1a0a163a49 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 14 May 2025 11:41:44 +0800
Subject: [PATCH 0803/1712] modify code

---
 src/class168/Code01_KthSmall1.java         |  5 ++++
 src/class168/Code01_KthSmall2.java         |  5 ++++
 src/class168/Code02_IvanAndBurgers1.java   | 14 ++++++----
 src/class168/Code02_IvanAndBurgers2.java   | 14 ++++++----
 src/class168/Code03_Meteors1.java          |  7 +++++
 src/class168/Code03_Meteors2.java          |  7 +++++
 src/class168/Code04_Juice1.java            |  6 ++++
 src/class168/Code04_Juice2.java            |  6 ++++
 src/class168/Code05_PastoralOddities1.java | 32 +++++++++++++---------
 src/class168/Code05_PastoralOddities2.java | 26 +++++++++++-------
 10 files changed, 89 insertions(+), 33 deletions(-)

diff --git a/src/class168/Code01_KthSmall1.java b/src/class168/Code01_KthSmall1.java
index 58b3a7540..dd41b0399 100644
--- a/src/class168/Code01_KthSmall1.java
+++ b/src/class168/Code01_KthSmall1.java
@@ -1,6 +1,11 @@
 package class168;
 
 // 子矩阵第k小，java版
+// 给定一个n * n的矩阵，接下来有q条查询，格式如下
+// 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
+// 1 <= n <= 500
+// 1 <= q <= 6 * 10^4
+// 0 <= 矩阵中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1527
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class168/Code01_KthSmall2.java b/src/class168/Code01_KthSmall2.java
index 2e1dd4109..49d6073bd 100644
--- a/src/class168/Code01_KthSmall2.java
+++ b/src/class168/Code01_KthSmall2.java
@@ -1,6 +1,11 @@
 package class168;
 
 // 子矩阵第k小，C++版
+// 给定一个n * n的矩阵，接下来有q条查询，格式如下
+// 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
+// 1 <= n <= 500
+// 1 <= q <= 6 * 10^4
+// 0 <= 矩阵中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1527
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class168/Code02_IvanAndBurgers1.java b/src/class168/Code02_IvanAndBurgers1.java
index 4a65d40a2..f42ae111b 100644
--- a/src/class168/Code02_IvanAndBurgers1.java
+++ b/src/class168/Code02_IvanAndBurgers1.java
@@ -1,6 +1,10 @@
 package class168;
 
 // 范围内最大异或和，java版
+// 给定一个长度为n的数组arr，下标1~n，接下来有q条查询，格式如下
+// 查询 l r : arr[l..r]中选若干个数，打印最大的异或和
+// 1 <= n、q <= 5 * 10^5
+// 0 <= arr[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1100F
 // 测试链接 : https://codeforces.com/problemset/problem/1100/F
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -14,7 +18,7 @@ public class Code02_IvanAndBurgers1 {
 
 	public static int MAXN = 500001;
 	public static int BIT = 21;
-	public static int n, m;
+	public static int n, q;
 
 	public static int[] arr = new int[MAXN];
 	public static int[] qid = new int[MAXN];
@@ -117,14 +121,14 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
-		m = in.nextInt();
-		for (int i = 1; i <= m; i++) {
+		q = in.nextInt();
+		for (int i = 1; i <= q; i++) {
 			qid[i] = i;
 			l[i] = in.nextInt();
 			r[i] = in.nextInt();
 		}
-		compute(1, m, 1, n);
-		for (int i = 1; i <= m; i++) {
+		compute(1, q, 1, n);
+		for (int i = 1; i <= q; i++) {
 			out.println(ans[i]);
 		}
 		out.flush();
diff --git a/src/class168/Code02_IvanAndBurgers2.java b/src/class168/Code02_IvanAndBurgers2.java
index b2ca5dff2..104c1e4e6 100644
--- a/src/class168/Code02_IvanAndBurgers2.java
+++ b/src/class168/Code02_IvanAndBurgers2.java
@@ -1,6 +1,10 @@
 package class168;
 
 // 范围内最大异或和，C++版
+// 给定一个长度为n的数组arr，下标1~n，接下来有q条查询，格式如下
+// 查询 l r : arr[l..r]中选若干个数，打印最大的异或和
+// 1 <= n、q <= 5 * 10^5
+// 0 <= arr[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/CF1100F
 // 测试链接 : https://codeforces.com/problemset/problem/1100/F
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -12,7 +16,7 @@
 //
 //const int MAXN = 500001;
 //const int BIT = 21;
-//int n, m;
+//int n, q;
 //
 //int arr[MAXN];
 //int qid[MAXN];
@@ -115,13 +119,13 @@
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
-//    cin >> m;
-//    for (int i = 1; i <= m; i++) {
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
 //        qid[i] = i;
 //        cin >> l[i] >> r[i];
 //    }
-//    compute(1, m, 1, n);
-//    for (int i = 1; i <= m; i++) {
+//    compute(1, q, 1, n);
+//    for (int i = 1; i <= q; i++) {
 //        cout << ans[i] << '\n';
 //    }
 //    return 0;
diff --git a/src/class168/Code03_Meteors1.java b/src/class168/Code03_Meteors1.java
index 5c95ed8fb..3b2e09019 100644
--- a/src/class168/Code03_Meteors1.java
+++ b/src/class168/Code03_Meteors1.java
@@ -1,6 +1,13 @@
 package class168;
 
 // 陨石雨，java版
+// 一共有n个国家，给定n个数字，表示每个国家希望收集到的陨石数量
+// 一共有m个区域，1号区顺时针到2号区...m号区顺时针到1号区，即环形相连
+// 每个区域只属于某一个国家，给定m个数字，表示每个区域归属给哪个国家
+// 接下来会依次发生k场陨石雨，陨石雨格式 l r num，含义如下
+// 从l号区顺时针到r号区发生了陨石雨，每个区域都增加num个陨石
+// 打印每个国家经历前几场陨石雨，可以达到收集要求，如果无法满足，打印"NIE"
+// 1 <= n、m、k <= 3 * 10^5    1 <= 陨石数量 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3527
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code03_Meteors2.java
index b677b3dcd..458d40b0f 100644
--- a/src/class168/Code03_Meteors2.java
+++ b/src/class168/Code03_Meteors2.java
@@ -1,6 +1,13 @@
 package class168;
 
 // 陨石雨，C++版
+// 一共有n个国家，给定n个数字，表示每个国家希望收集到的陨石数量
+// 一共有m个区域，1号区顺时针到2号区...m号区顺时针到1号区，即环形相连
+// 每个区域只属于某一个国家，给定m个数字，表示每个区域归属给哪个国家
+// 接下来会依次发生k场陨石雨，陨石雨格式 l r num，含义如下
+// 从l号区顺时针到r号区发生了陨石雨，每个区域都增加num个陨石
+// 打印每个国家经历前几场陨石雨，可以达到收集要求，如果无法满足，打印"NIE"
+// 1 <= n、m、k <= 3 * 10^5    1 <= 陨石数量 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3527
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class168/Code04_Juice1.java b/src/class168/Code04_Juice1.java
index 6e4002ea3..9b4d59a42 100644
--- a/src/class168/Code04_Juice1.java
+++ b/src/class168/Code04_Juice1.java
@@ -1,6 +1,12 @@
 package class168;
 
 // 混合果汁，java版
+// 一共有n种果汁，每种果汁给定，美味度d、每升价格p、添加上限l
+// 制作混合果汁时每种果汁不能超过添加上限，其中美味度最低的果汁，决定混合果汁的美味度
+// 一共有m个小朋友，给每位制作混合果汁时，钱数不超过money[i]，体积不少于least[i]
+// 打印每个小朋友能得到的混合果汁最大美味度，如果无法满足，打印-1
+// 1 <= n、m、d、p、l <= 10^5
+// 1 <= money[i]、least[i] <= 10^18
 // 测试链接 : https://www.luogu.com.cn/problem/P4602
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class168/Code04_Juice2.java b/src/class168/Code04_Juice2.java
index 2319998e9..cd8b90296 100644
--- a/src/class168/Code04_Juice2.java
+++ b/src/class168/Code04_Juice2.java
@@ -1,6 +1,12 @@
 package class168;
 
 // 混合果汁，C++版
+// 一共有n种果汁，每种果汁给定，美味度d、每升价格p、添加上限l
+// 制作混合果汁时每种果汁不能超过添加上限，其中美味度最低的果汁，决定混合果汁的美味度
+// 一共有m个小朋友，给每位制作混合果汁时，钱数不超过money[i]，体积不少于least[i]
+// 打印每个小朋友能得到的混合果汁最大美味度，如果无法满足，打印-1
+// 1 <= n、m、d、p、l <= 10^5
+// 1 <= money[i]、least[i] <= 10^18
 // 测试链接 : https://www.luogu.com.cn/problem/P4602
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class168/Code05_PastoralOddities1.java b/src/class168/Code05_PastoralOddities1.java
index 55d870a47..071a4444c 100644
--- a/src/class168/Code05_PastoralOddities1.java
+++ b/src/class168/Code05_PastoralOddities1.java
@@ -1,6 +1,12 @@
 package class168;
 
-// 度为奇数的最大边权，java版
+// 度为奇的最小瓶颈边，java版
+// 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
+// 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
+// 如果存在，希望边集的最大边权，尽可能小，打印该值
+// 2 <= n <= 10^5
+// 1 <= m <= 3 * 10^5
+// 1 <= 边权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF603E
 // 测试链接 : https://codeforces.com/problemset/problem/603/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -19,7 +25,7 @@ public class Code05_PastoralOddities1 {
 
 	// 边的编号i、端点x、端点y、权值w
 	public static int[][] edge = new int[MAXM][4];
-	public static int[][] sorted = new int[MAXM][4];
+	public static int[][] wsort = new int[MAXM][4];
 
 	// 节点数为奇数的联通区数量
 	public static int oddnum;
@@ -75,14 +81,14 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = ql; i <= qr; i++) {
-				ans[i] = sorted[vl][3];
+				ans[i] = wsort[vl][3];
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
 			int unionCnt1 = 0;
 			for (int i = vl; i <= mid; i++) {
-				if (sorted[i][0] < ql) {
-					if (union(sorted[i][1], sorted[i][2])) {
+				if (wsort[i][0] < ql) {
+					if (union(wsort[i][1], wsort[i][2])) {
 						unionCnt1++;
 					}
 				}
@@ -90,7 +96,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			int unionCnt2 = 0;
 			int split = qr + 1;
 			for (int i = ql; i <= qr; i++) {
-				if (edge[i][3] <= sorted[mid][3]) {
+				if (edge[i][3] <= wsort[mid][3]) {
 					if (union(edge[i][1], edge[i][2])) {
 						unionCnt2++;
 					}
@@ -109,7 +115,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			}
 			int unionCnt3 = 0;
 			for (int i = ql; i <= split - 1; i++) {
-				if (edge[i][3] <= sorted[vl][3]) {
+				if (edge[i][3] <= wsort[vl][3]) {
 					if (union(edge[i][1], edge[i][2])) {
 						unionCnt3++;
 					}
@@ -129,13 +135,13 @@ public static void prepare() {
 			siz[i] = 1;
 		}
 		for (int i = 1; i <= m; i++) {
-			sorted[i][0] = edge[i][0];
-			sorted[i][1] = edge[i][1];
-			sorted[i][2] = edge[i][2];
-			sorted[i][3] = edge[i][3];
+			wsort[i][0] = edge[i][0];
+			wsort[i][1] = edge[i][1];
+			wsort[i][2] = edge[i][2];
+			wsort[i][3] = edge[i][3];
 		}
-		Arrays.sort(sorted, 1, m + 1, (a, b) -> a[3] - b[3]);
-		sorted[m + 1][3] = -1;
+		Arrays.sort(wsort, 1, m + 1, (a, b) -> a[3] - b[3]);
+		wsort[m + 1][3] = -1;
 	}
 
 	public static void main(String[] args) throws Exception {
diff --git a/src/class168/Code05_PastoralOddities2.java b/src/class168/Code05_PastoralOddities2.java
index b1d935721..45dd60b81 100644
--- a/src/class168/Code05_PastoralOddities2.java
+++ b/src/class168/Code05_PastoralOddities2.java
@@ -1,6 +1,12 @@
 package class168;
 
-// 度为奇数的最大边权，C++版
+// 度为奇的最小瓶颈边，C++版
+// 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
+// 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
+// 如果存在，希望边集的最大边权，尽可能小，打印该值
+// 2 <= n <= 10^5
+// 1 <= m <= 3 * 10^5
+// 1 <= 边权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF603E
 // 测试链接 : https://codeforces.com/problemset/problem/603/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -23,7 +29,7 @@
 //int n, m;
 //
 //Edge edge[MAXM];
-//Edge sorted[MAXM];
+//Edge wsort[MAXM];
 //
 //int oddnum;
 //int father[MAXN];
@@ -77,14 +83,14 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = ql; i <= qr; i++) {
-//            ans[i] = sorted[vl].w;
+//            ans[i] = wsort[vl].w;
 //        }
 //    } else {
 //        int mid = (vl + vr) >> 1;
 //        int unionCnt1 = 0;
 //        for (int i = vl; i <= mid; i++) {
-//            if (sorted[i].i < ql) {
-//                if (Union(sorted[i].x, sorted[i].y)) {
+//            if (wsort[i].i < ql) {
+//                if (Union(wsort[i].x, wsort[i].y)) {
 //                    unionCnt1++;
 //                }
 //            }
@@ -92,7 +98,7 @@
 //        int unionCnt2 = 0;
 //        int split = qr + 1;
 //        for (int i = ql; i <= qr; i++) {
-//            if (edge[i].w <= sorted[mid].w) {
+//            if (edge[i].w <= wsort[mid].w) {
 //                if (Union(edge[i].x, edge[i].y)) {
 //                    unionCnt2++;
 //                }
@@ -111,7 +117,7 @@
 //        }
 //        int unionCnt3 = 0;
 //        for (int i = ql; i <= split - 1; i++) {
-//            if (edge[i].w <= sorted[vl].w) {
+//            if (edge[i].w <= wsort[vl].w) {
 //                if (Union(edge[i].x, edge[i].y)) {
 //                    unionCnt3++;
 //                }
@@ -131,10 +137,10 @@
 //        siz[i] = 1;
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        sorted[i] = edge[i];
+//        wsort[i] = edge[i];
 //    }
-//    sort(sorted + 1, sorted + m + 1, EdgeCmp);
-//    sorted[m + 1].w = -1;
+//    sort(wsort + 1, wsort + m + 1, EdgeCmp);
+//    wsort[m + 1].w = -1;
 //}
 //
 //int main() {

From 0bab68b5c4a24720908d674e98881ff1f7b671ef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 14 May 2025 17:28:23 +0800
Subject: [PATCH 0804/1712] modify code

---
 src/class168/Code05_PastoralOddities1.java | 4 ++--
 src/class168/Code05_PastoralOddities2.java | 4 ++--
 src/class168/Code06_PlateAndFruit1.java    | 7 +++++++
 src/class168/Code06_PlateAndFruit2.java    | 7 +++++++
 4 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/class168/Code05_PastoralOddities1.java b/src/class168/Code05_PastoralOddities1.java
index 071a4444c..065daf323 100644
--- a/src/class168/Code05_PastoralOddities1.java
+++ b/src/class168/Code05_PastoralOddities1.java
@@ -1,9 +1,9 @@
 package class168;
 
-// 度为奇的最小瓶颈边，java版
+// 度为奇最小瓶颈，java版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
 // 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
-// 如果存在，希望边集的最大边权，尽可能小，打印该值
+// 如果存在，希望边集的最大边权，尽可能小，一共有m条打印
 // 2 <= n <= 10^5
 // 1 <= m <= 3 * 10^5
 // 1 <= 边权 <= 10^9
diff --git a/src/class168/Code05_PastoralOddities2.java b/src/class168/Code05_PastoralOddities2.java
index 45dd60b81..bd46af12d 100644
--- a/src/class168/Code05_PastoralOddities2.java
+++ b/src/class168/Code05_PastoralOddities2.java
@@ -1,9 +1,9 @@
 package class168;
 
-// 度为奇的最小瓶颈边，C++版
+// 度为奇最小瓶颈，C++版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
 // 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
-// 如果存在，希望边集的最大边权，尽可能小，打印该值
+// 如果存在，希望边集的最大边权，尽可能小，一共有m条打印
 // 2 <= n <= 10^5
 // 1 <= m <= 3 * 10^5
 // 1 <= 边权 <= 10^9
diff --git a/src/class168/Code06_PlateAndFruit1.java b/src/class168/Code06_PlateAndFruit1.java
index dffd4dd09..57e3ef3dd 100644
--- a/src/class168/Code06_PlateAndFruit1.java
+++ b/src/class168/Code06_PlateAndFruit1.java
@@ -1,6 +1,13 @@
 package class168;
 
 // 接水果，java版
+// 一共有n个点，给定n-1条无向边，所有点连成一棵树
+// 一共有p个盘子，每个盘子格式 a b c : 盘子是点a到点b的路径，盘子权值为c
+// 一共有q个水果，每个水果格式 u v k : 水果是点u到点v的路径，k含义如下
+// 如果一个盘子路径完全在一个水果路径的内部，那么该盘子可以接住该水果
+// 那么对于每个水果，可能有很多盘子都可以将其接住，打印其中第k小的权值
+// 1 <= n、p、q <= 4 * 10^4
+// 0 <= 盘子权值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3242
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class168/Code06_PlateAndFruit2.java b/src/class168/Code06_PlateAndFruit2.java
index 60a2cb904..27c43fde3 100644
--- a/src/class168/Code06_PlateAndFruit2.java
+++ b/src/class168/Code06_PlateAndFruit2.java
@@ -1,6 +1,13 @@
 package class168;
 
 // 接水果，C++版
+// 一共有n个点，给定n-1条无向边，所有点连成一棵树
+// 一共有p个盘子，每个盘子格式 a b c : 盘子是点a到点b的路径，盘子权值为c
+// 一共有q个水果，每个水果格式 u v k : 水果是点u到点v的路径，k含义如下
+// 如果一个盘子路径完全在一个水果路径的内部，那么该盘子可以接住该水果
+// 那么对于每个水果，可能有很多盘子都可以将其接住，打印其中第k小的权值
+// 1 <= n、p、q <= 4 * 10^4
+// 0 <= 盘子权值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3242
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 6d6461e25123889e8aff66c9f3d9d1dabe084cf4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 14 May 2025 17:29:03 +0800
Subject: [PATCH 0805/1712] modify code

---
 src/class168/{Code06_PlateAndFruit1.java => Code06_Fruit1.java} | 2 +-
 src/class168/{Code06_PlateAndFruit2.java => Code06_Fruit2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class168/{Code06_PlateAndFruit1.java => Code06_Fruit1.java} (99%)
 rename src/class168/{Code06_PlateAndFruit2.java => Code06_Fruit2.java} (100%)

diff --git a/src/class168/Code06_PlateAndFruit1.java b/src/class168/Code06_Fruit1.java
similarity index 99%
rename from src/class168/Code06_PlateAndFruit1.java
rename to src/class168/Code06_Fruit1.java
index 57e3ef3dd..39064bf2e 100644
--- a/src/class168/Code06_PlateAndFruit1.java
+++ b/src/class168/Code06_Fruit1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code06_PlateAndFruit1 {
+public class Code06_Fruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class168/Code06_PlateAndFruit2.java b/src/class168/Code06_Fruit2.java
similarity index 100%
rename from src/class168/Code06_PlateAndFruit2.java
rename to src/class168/Code06_Fruit2.java

From 69b4bccd13a3994fef0c5386559382f4c91e0eb5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 14 May 2025 17:37:00 +0800
Subject: [PATCH 0806/1712] modify code

---
 src/class168/Code01_KthSmall1.java       | 2 +-
 src/class168/Code01_KthSmall2.java       | 2 +-
 src/class168/Code02_IvanAndBurgers1.java | 2 +-
 src/class168/Code02_IvanAndBurgers2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class168/Code01_KthSmall1.java b/src/class168/Code01_KthSmall1.java
index dd41b0399..1eb041245 100644
--- a/src/class168/Code01_KthSmall1.java
+++ b/src/class168/Code01_KthSmall1.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 子矩阵第k小，java版
+// 区域第k小，java版
 // 给定一个n * n的矩阵，接下来有q条查询，格式如下
 // 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
 // 1 <= n <= 500
diff --git a/src/class168/Code01_KthSmall2.java b/src/class168/Code01_KthSmall2.java
index 49d6073bd..a44d472e2 100644
--- a/src/class168/Code01_KthSmall2.java
+++ b/src/class168/Code01_KthSmall2.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 子矩阵第k小，C++版
+// 区域第k小，C++版
 // 给定一个n * n的矩阵，接下来有q条查询，格式如下
 // 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
 // 1 <= n <= 500
diff --git a/src/class168/Code02_IvanAndBurgers1.java b/src/class168/Code02_IvanAndBurgers1.java
index f42ae111b..6a0340655 100644
--- a/src/class168/Code02_IvanAndBurgers1.java
+++ b/src/class168/Code02_IvanAndBurgers1.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 范围内最大异或和，java版
+// 范围最大异或和，java版
 // 给定一个长度为n的数组arr，下标1~n，接下来有q条查询，格式如下
 // 查询 l r : arr[l..r]中选若干个数，打印最大的异或和
 // 1 <= n、q <= 5 * 10^5
diff --git a/src/class168/Code02_IvanAndBurgers2.java b/src/class168/Code02_IvanAndBurgers2.java
index 104c1e4e6..e00d24623 100644
--- a/src/class168/Code02_IvanAndBurgers2.java
+++ b/src/class168/Code02_IvanAndBurgers2.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 范围内最大异或和，C++版
+// 范围最大异或和，C++版
 // 给定一个长度为n的数组arr，下标1~n，接下来有q条查询，格式如下
 // 查询 l r : arr[l..r]中选若干个数，打印最大的异或和
 // 1 <= n、q <= 5 * 10^5

From 793032dede539f32e8afe85d0cd74bb33082fd55 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 14 May 2025 18:17:56 +0800
Subject: [PATCH 0807/1712] modify code

---
 src/class168/{Code03_Meteors1.java => Code02_Meteors1.java}   | 4 ++--
 src/class168/{Code03_Meteors2.java => Code02_Meteors2.java}   | 0
 src/class168/{Code04_Juice1.java => Code03_Juice1.java}       | 2 +-
 src/class168/{Code04_Juice2.java => Code03_Juice2.java}       | 0
 ...5_PastoralOddities1.java => Code04_PastoralOddities1.java} | 2 +-
 ...5_PastoralOddities2.java => Code04_PastoralOddities2.java} | 0
 src/class168/{Code06_Fruit1.java => Code05_Fruit1.java}       | 2 +-
 src/class168/{Code06_Fruit2.java => Code05_Fruit2.java}       | 0
 src/class168/{Code07_Network1.java => Code06_Network1.java}   | 2 +-
 src/class168/{Code07_Network2.java => Code06_Network2.java}   | 0
 ...ode02_IvanAndBurgers1.java => Code07_IvanAndBurgers1.java} | 2 +-
 ...ode02_IvanAndBurgers2.java => Code07_IvanAndBurgers2.java} | 0
 12 files changed, 7 insertions(+), 7 deletions(-)
 rename src/class168/{Code03_Meteors1.java => Code02_Meteors1.java} (98%)
 rename src/class168/{Code03_Meteors2.java => Code02_Meteors2.java} (100%)
 rename src/class168/{Code04_Juice1.java => Code03_Juice1.java} (99%)
 rename src/class168/{Code04_Juice2.java => Code03_Juice2.java} (100%)
 rename src/class168/{Code05_PastoralOddities1.java => Code04_PastoralOddities1.java} (99%)
 rename src/class168/{Code05_PastoralOddities2.java => Code04_PastoralOddities2.java} (100%)
 rename src/class168/{Code06_Fruit1.java => Code05_Fruit1.java} (99%)
 rename src/class168/{Code06_Fruit2.java => Code05_Fruit2.java} (100%)
 rename src/class168/{Code07_Network1.java => Code06_Network1.java} (99%)
 rename src/class168/{Code07_Network2.java => Code06_Network2.java} (100%)
 rename src/class168/{Code02_IvanAndBurgers1.java => Code07_IvanAndBurgers1.java} (99%)
 rename src/class168/{Code02_IvanAndBurgers2.java => Code07_IvanAndBurgers2.java} (100%)

diff --git a/src/class168/Code03_Meteors1.java b/src/class168/Code02_Meteors1.java
similarity index 98%
rename from src/class168/Code03_Meteors1.java
rename to src/class168/Code02_Meteors1.java
index 3b2e09019..45420cbcb 100644
--- a/src/class168/Code03_Meteors1.java
+++ b/src/class168/Code02_Meteors1.java
@@ -12,7 +12,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
 // 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
-// 想通过用C++实现，本节课Code03_Meteors2文件就是C++的实现
+// 想通过用C++实现，本节课Code02_Meteors2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -20,7 +20,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_Meteors1 {
+public class Code02_Meteors1 {
 
 	public static int MAXN = 300001;
 	public static int n, m, k;
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code02_Meteors2.java
similarity index 100%
rename from src/class168/Code03_Meteors2.java
rename to src/class168/Code02_Meteors2.java
diff --git a/src/class168/Code04_Juice1.java b/src/class168/Code03_Juice1.java
similarity index 99%
rename from src/class168/Code04_Juice1.java
rename to src/class168/Code03_Juice1.java
index 9b4d59a42..7cdf7cb57 100644
--- a/src/class168/Code04_Juice1.java
+++ b/src/class168/Code03_Juice1.java
@@ -16,7 +16,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_Juice1 {
+public class Code03_Juice1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class168/Code04_Juice2.java b/src/class168/Code03_Juice2.java
similarity index 100%
rename from src/class168/Code04_Juice2.java
rename to src/class168/Code03_Juice2.java
diff --git a/src/class168/Code05_PastoralOddities1.java b/src/class168/Code04_PastoralOddities1.java
similarity index 99%
rename from src/class168/Code05_PastoralOddities1.java
rename to src/class168/Code04_PastoralOddities1.java
index 065daf323..f4561d084 100644
--- a/src/class168/Code05_PastoralOddities1.java
+++ b/src/class168/Code04_PastoralOddities1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_PastoralOddities1 {
+public class Code04_PastoralOddities1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 300002;
diff --git a/src/class168/Code05_PastoralOddities2.java b/src/class168/Code04_PastoralOddities2.java
similarity index 100%
rename from src/class168/Code05_PastoralOddities2.java
rename to src/class168/Code04_PastoralOddities2.java
diff --git a/src/class168/Code06_Fruit1.java b/src/class168/Code05_Fruit1.java
similarity index 99%
rename from src/class168/Code06_Fruit1.java
rename to src/class168/Code05_Fruit1.java
index 39064bf2e..e0f5ffaeb 100644
--- a/src/class168/Code06_Fruit1.java
+++ b/src/class168/Code05_Fruit1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code06_Fruit1 {
+public class Code05_Fruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class168/Code06_Fruit2.java b/src/class168/Code05_Fruit2.java
similarity index 100%
rename from src/class168/Code06_Fruit2.java
rename to src/class168/Code05_Fruit2.java
diff --git a/src/class168/Code07_Network1.java b/src/class168/Code06_Network1.java
similarity index 99%
rename from src/class168/Code07_Network1.java
rename to src/class168/Code06_Network1.java
index afa669476..c076eeef1 100644
--- a/src/class168/Code07_Network1.java
+++ b/src/class168/Code06_Network1.java
@@ -17,7 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code07_Network1 {
+public class Code06_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class168/Code07_Network2.java b/src/class168/Code06_Network2.java
similarity index 100%
rename from src/class168/Code07_Network2.java
rename to src/class168/Code06_Network2.java
diff --git a/src/class168/Code02_IvanAndBurgers1.java b/src/class168/Code07_IvanAndBurgers1.java
similarity index 99%
rename from src/class168/Code02_IvanAndBurgers1.java
rename to src/class168/Code07_IvanAndBurgers1.java
index 6a0340655..97a84adbd 100644
--- a/src/class168/Code02_IvanAndBurgers1.java
+++ b/src/class168/Code07_IvanAndBurgers1.java
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_IvanAndBurgers1 {
+public class Code07_IvanAndBurgers1 {
 
 	public static int MAXN = 500001;
 	public static int BIT = 21;
diff --git a/src/class168/Code02_IvanAndBurgers2.java b/src/class168/Code07_IvanAndBurgers2.java
similarity index 100%
rename from src/class168/Code02_IvanAndBurgers2.java
rename to src/class168/Code07_IvanAndBurgers2.java

From f9cbbd0cce23146ef40aa58cc1e5f6380647e0eb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 15 May 2025 11:18:30 +0800
Subject: [PATCH 0808/1712] modify code

---
 src/class168/Code01_RangeKth1.java            | 170 ++++++++++++++++++
 src/class168/Code01_RangeKth2.java            | 125 +++++++++++++
 ..._KthSmall1.java => Code02_MatrixKth1.java} |   8 +-
 ..._KthSmall2.java => Code02_MatrixKth2.java} |   6 +-
 ...e02_Meteors1.java => Code03_Meteors1.java} |   4 +-
 ...e02_Meteors2.java => Code03_Meteors2.java} |   0
 ...{Code03_Juice1.java => Code04_Juice1.java} |   2 +-
 ...{Code03_Juice2.java => Code04_Juice2.java} |   0
 ...es1.java => Code05_PastoralOddities1.java} |   2 +-
 ...es2.java => Code05_PastoralOddities2.java} |   0
 ...{Code05_Fruit1.java => Code06_Fruit1.java} |   2 +-
 ...{Code05_Fruit2.java => Code06_Fruit2.java} |   0
 ...e06_Network1.java => Code07_Network1.java} |   2 +-
 ...e06_Network2.java => Code07_Network2.java} |   0
 ...gers1.java => Code08_IvanAndBurgers1.java} |   2 +-
 ...gers2.java => Code08_IvanAndBurgers2.java} |   0
 16 files changed, 309 insertions(+), 14 deletions(-)
 create mode 100644 src/class168/Code01_RangeKth1.java
 create mode 100644 src/class168/Code01_RangeKth2.java
 rename src/class168/{Code01_KthSmall1.java => Code02_MatrixKth1.java} (95%)
 rename src/class168/{Code01_KthSmall2.java => Code02_MatrixKth2.java} (95%)
 rename src/class168/{Code02_Meteors1.java => Code03_Meteors1.java} (98%)
 rename src/class168/{Code02_Meteors2.java => Code03_Meteors2.java} (100%)
 rename src/class168/{Code03_Juice1.java => Code04_Juice1.java} (99%)
 rename src/class168/{Code03_Juice2.java => Code04_Juice2.java} (100%)
 rename src/class168/{Code04_PastoralOddities1.java => Code05_PastoralOddities1.java} (99%)
 rename src/class168/{Code04_PastoralOddities2.java => Code05_PastoralOddities2.java} (100%)
 rename src/class168/{Code05_Fruit1.java => Code06_Fruit1.java} (99%)
 rename src/class168/{Code05_Fruit2.java => Code06_Fruit2.java} (100%)
 rename src/class168/{Code06_Network1.java => Code07_Network1.java} (99%)
 rename src/class168/{Code06_Network2.java => Code07_Network2.java} (100%)
 rename src/class168/{Code07_IvanAndBurgers1.java => Code08_IvanAndBurgers1.java} (99%)
 rename src/class168/{Code07_IvanAndBurgers2.java => Code08_IvanAndBurgers2.java} (100%)

diff --git a/src/class168/Code01_RangeKth1.java b/src/class168/Code01_RangeKth1.java
new file mode 100644
index 000000000..2e57e9843
--- /dev/null
+++ b/src/class168/Code01_RangeKth1.java
@@ -0,0 +1,170 @@
+package class168;
+
+// 区间第k小，java版
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
+// 给定一个长度为n的数组，接下来有m条查询，格式如下
+// 查询 l r k : 打印[l..r]范围内第k小的值
+// 1 <= n、m <= 2 * 10^5
+// 1 <= 数组中的数字 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_RangeKth1 {
+
+	public static int MAXN = 200001;
+	public static int INF = 1000000001;
+	public static int n, m;
+
+	// 位置i，数值v
+	public static int[][] arr = new int[MAXN][2];
+
+	// 查询
+	public static int[] qid = new int[MAXN];
+	public static int[] l = new int[MAXN];
+	public static int[] r = new int[MAXN];
+	public static int[] k = new int[MAXN];
+
+	// 树状数组
+	public static int[] tree = new int[MAXN];
+	public static int used = 0;
+
+	// 整体二分
+	public static int[] lset = new int[MAXN];
+	public static int[] rset = new int[MAXN];
+
+	// 查询的答案
+	public static int[] ans = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static int query(int l, int r) {
+		return sum(r) - sum(l - 1);
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = vl;
+			}
+		} else {
+			int mid = (vl + vr) / 2;
+			while (used + 1 <= n && arr[used + 1][1] <= mid) {
+				used++;
+				add(arr[used][0], 1);
+			}
+			while (used >= 1 && arr[used][1] > mid) {
+				add(arr[used][0], -1);
+				used--;
+			}
+			int lsiz = 0, rsiz = 0;
+			for (int i = ql; i <= qr; i++) {
+				int id = qid[i];
+				int check = query(l[id], r[id]);
+				if (check >= k[id]) {
+					lset[++lsiz] = id;
+				} else {
+					rset[++rsiz] = id;
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				qid[ql + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				qid[ql + lsiz + i - 1] = rset[i];
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = i;
+			arr[i][1] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			qid[i] = i;
+			l[i] = in.nextInt();
+			r[i] = in.nextInt();
+			k[i] = in.nextInt();
+		}
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
+		compute(1, m, 0, INF);
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
new file mode 100644
index 000000000..f29518ebb
--- /dev/null
+++ b/src/class168/Code01_RangeKth2.java
@@ -0,0 +1,125 @@
+package class168;
+
+// 区间第k小，C++版
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
+// 给定一个长度为n的数组，接下来有m条查询，格式如下
+// 查询 l r k : 打印[l..r]范围内第k小的值
+// 1 <= n、m <= 2 * 10^5
+// 1 <= 数组中的数字 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int i, v;
+//};
+//
+//bool NumberCmp(Number x, Number y) {
+//    return x.v < y.v;
+//}
+//
+//const int MAXN = 200001;
+//const int INF = 1000000001;
+//int n, m;
+//
+//Number arr[MAXN];
+//
+//int qid[MAXN];
+//int l[MAXN];
+//int r[MAXN];
+//int k[MAXN];
+//
+//int tree[MAXN];
+//int used = 0;
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//
+//int ans[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= n) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//int query(int l, int r) {
+//    return sum(r) - sum(l - 1);
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
+//        }
+//    } else {
+//        int mid = (vl + vr) / 2;
+//        while (used + 1 <= n && arr[used + 1].v <= mid) {
+//            used++;
+//            add(arr[used].i, 1);
+//        }
+//        while (used >= 1 && arr[used].v > mid) {
+//            add(arr[used].i, -1);
+//            used--;
+//        }
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            int check = query(l[id], r[id]);
+//            if (check >= k[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].i = i;
+//        cin >> arr[i].v;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        qid[i] = i;
+//        cin >> l[i] >> r[i] >> k[i];
+//    }
+//    sort(arr + 1, arr + n + 1, NumberCmp);
+//    compute(1, m, 0, INF);
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code01_KthSmall1.java b/src/class168/Code02_MatrixKth1.java
similarity index 95%
rename from src/class168/Code01_KthSmall1.java
rename to src/class168/Code02_MatrixKth1.java
index 1eb041245..1582bf779 100644
--- a/src/class168/Code01_KthSmall1.java
+++ b/src/class168/Code02_MatrixKth1.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 区域第k小，java版
+// 矩阵第k小，java版
 // 给定一个n * n的矩阵，接下来有q条查询，格式如下
 // 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
 // 1 <= n <= 500
@@ -15,7 +15,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code01_KthSmall1 {
+public class Code02_MatrixKth1 {
 
 	public static int MAXN = 501;
 	public static int MAXQ = 1000001;
@@ -60,7 +60,7 @@ public static void add(int x, int y, int v) {
 		}
 	}
 
-	public static int query(int x, int y) {
+	public static int sum(int x, int y) {
 		int ret = 0;
 		for (int i = x; i > 0; i -= lowbit(i)) {
 			for (int j = y; j > 0; j -= lowbit(j)) {
@@ -71,7 +71,7 @@ public static int query(int x, int y) {
 	}
 
 	public static int query(int a, int b, int c, int d) {
-		return query(c, d) - query(a - 1, d) - query(c, b - 1) + query(a - 1, b - 1);
+		return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
 	}
 
 	public static void compute(int ql, int qr, int vl, int vr) {
diff --git a/src/class168/Code01_KthSmall2.java b/src/class168/Code02_MatrixKth2.java
similarity index 95%
rename from src/class168/Code01_KthSmall2.java
rename to src/class168/Code02_MatrixKth2.java
index a44d472e2..c7c55cf09 100644
--- a/src/class168/Code01_KthSmall2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 区域第k小，C++版
+// 矩阵第k小，C++版
 // 给定一个n * n的矩阵，接下来有q条查询，格式如下
 // 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
 // 1 <= n <= 500
@@ -57,7 +57,7 @@
 //    }
 //}
 //
-//int query(int x, int y) {
+//int sum(int x, int y) {
 //    int ret = 0;
 //    for (int i = x; i > 0; i -= lowbit(i)) {
 //        for (int j = y; j > 0; j -= lowbit(j)) {
@@ -68,7 +68,7 @@
 //}
 //
 //int query(int a, int b, int c, int d) {
-//    return query(c, d) - query(a - 1, d) - query(c, b - 1) + query(a - 1, b - 1);
+//    return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
 //}
 //
 //void compute(int ql, int qr, int vl, int vr) {
diff --git a/src/class168/Code02_Meteors1.java b/src/class168/Code03_Meteors1.java
similarity index 98%
rename from src/class168/Code02_Meteors1.java
rename to src/class168/Code03_Meteors1.java
index 45420cbcb..3b2e09019 100644
--- a/src/class168/Code02_Meteors1.java
+++ b/src/class168/Code03_Meteors1.java
@@ -12,7 +12,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
 // 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
-// 想通过用C++实现，本节课Code02_Meteors2文件就是C++的实现
+// 想通过用C++实现，本节课Code03_Meteors2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -20,7 +20,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_Meteors1 {
+public class Code03_Meteors1 {
 
 	public static int MAXN = 300001;
 	public static int n, m, k;
diff --git a/src/class168/Code02_Meteors2.java b/src/class168/Code03_Meteors2.java
similarity index 100%
rename from src/class168/Code02_Meteors2.java
rename to src/class168/Code03_Meteors2.java
diff --git a/src/class168/Code03_Juice1.java b/src/class168/Code04_Juice1.java
similarity index 99%
rename from src/class168/Code03_Juice1.java
rename to src/class168/Code04_Juice1.java
index 7cdf7cb57..9b4d59a42 100644
--- a/src/class168/Code03_Juice1.java
+++ b/src/class168/Code04_Juice1.java
@@ -16,7 +16,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_Juice1 {
+public class Code04_Juice1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class168/Code03_Juice2.java b/src/class168/Code04_Juice2.java
similarity index 100%
rename from src/class168/Code03_Juice2.java
rename to src/class168/Code04_Juice2.java
diff --git a/src/class168/Code04_PastoralOddities1.java b/src/class168/Code05_PastoralOddities1.java
similarity index 99%
rename from src/class168/Code04_PastoralOddities1.java
rename to src/class168/Code05_PastoralOddities1.java
index f4561d084..065daf323 100644
--- a/src/class168/Code04_PastoralOddities1.java
+++ b/src/class168/Code05_PastoralOddities1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_PastoralOddities1 {
+public class Code05_PastoralOddities1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 300002;
diff --git a/src/class168/Code04_PastoralOddities2.java b/src/class168/Code05_PastoralOddities2.java
similarity index 100%
rename from src/class168/Code04_PastoralOddities2.java
rename to src/class168/Code05_PastoralOddities2.java
diff --git a/src/class168/Code05_Fruit1.java b/src/class168/Code06_Fruit1.java
similarity index 99%
rename from src/class168/Code05_Fruit1.java
rename to src/class168/Code06_Fruit1.java
index e0f5ffaeb..39064bf2e 100644
--- a/src/class168/Code05_Fruit1.java
+++ b/src/class168/Code06_Fruit1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_Fruit1 {
+public class Code06_Fruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class168/Code05_Fruit2.java b/src/class168/Code06_Fruit2.java
similarity index 100%
rename from src/class168/Code05_Fruit2.java
rename to src/class168/Code06_Fruit2.java
diff --git a/src/class168/Code06_Network1.java b/src/class168/Code07_Network1.java
similarity index 99%
rename from src/class168/Code06_Network1.java
rename to src/class168/Code07_Network1.java
index c076eeef1..afa669476 100644
--- a/src/class168/Code06_Network1.java
+++ b/src/class168/Code07_Network1.java
@@ -17,7 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code06_Network1 {
+public class Code07_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class168/Code06_Network2.java b/src/class168/Code07_Network2.java
similarity index 100%
rename from src/class168/Code06_Network2.java
rename to src/class168/Code07_Network2.java
diff --git a/src/class168/Code07_IvanAndBurgers1.java b/src/class168/Code08_IvanAndBurgers1.java
similarity index 99%
rename from src/class168/Code07_IvanAndBurgers1.java
rename to src/class168/Code08_IvanAndBurgers1.java
index 97a84adbd..815d9067c 100644
--- a/src/class168/Code07_IvanAndBurgers1.java
+++ b/src/class168/Code08_IvanAndBurgers1.java
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code07_IvanAndBurgers1 {
+public class Code08_IvanAndBurgers1 {
 
 	public static int MAXN = 500001;
 	public static int BIT = 21;
diff --git a/src/class168/Code07_IvanAndBurgers2.java b/src/class168/Code08_IvanAndBurgers2.java
similarity index 100%
rename from src/class168/Code07_IvanAndBurgers2.java
rename to src/class168/Code08_IvanAndBurgers2.java

From 4f4b4071ff38b699948020ccecdd3af3bd253e3c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 15 May 2025 11:20:33 +0800
Subject: [PATCH 0809/1712] modify code

---
 src/class168/Code01_RangeKth1.java  | 2 +-
 src/class168/Code01_RangeKth2.java  | 2 +-
 src/class168/Code02_MatrixKth1.java | 2 +-
 src/class168/Code02_MatrixKth2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class168/Code01_RangeKth1.java b/src/class168/Code01_RangeKth1.java
index 2e57e9843..5807d6aae 100644
--- a/src/class168/Code01_RangeKth1.java
+++ b/src/class168/Code01_RangeKth1.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 区间第k小，java版
+// 区间内第k小，java版
 // 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index f29518ebb..771f55791 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 区间第k小，C++版
+// 区间内第k小，C++版
 // 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
diff --git a/src/class168/Code02_MatrixKth1.java b/src/class168/Code02_MatrixKth1.java
index 1582bf779..87b88fc9e 100644
--- a/src/class168/Code02_MatrixKth1.java
+++ b/src/class168/Code02_MatrixKth1.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 矩阵第k小，java版
+// 矩阵内第k小，java版
 // 给定一个n * n的矩阵，接下来有q条查询，格式如下
 // 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
 // 1 <= n <= 500
diff --git a/src/class168/Code02_MatrixKth2.java b/src/class168/Code02_MatrixKth2.java
index c7c55cf09..5f89826ed 100644
--- a/src/class168/Code02_MatrixKth2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 矩阵第k小，C++版
+// 矩阵内第k小，C++版
 // 给定一个n * n的矩阵，接下来有q条查询，格式如下
 // 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
 // 1 <= n <= 500

From 8ae4070b6c4548c64b6cce0c68f7520322451267 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 15 May 2025 19:38:03 +0800
Subject: [PATCH 0810/1712] modify code

---
 .../Code04_Juice1.java => class169/Code01_Juice1.java}        | 4 ++--
 .../Code04_Juice2.java => class169/Code01_Juice2.java}        | 2 +-
 .../Code02_PastoralOddities1.java}                            | 4 ++--
 .../Code02_PastoralOddities2.java}                            | 2 +-
 .../Code06_Fruit1.java => class169/Code03_Fruit1.java}        | 4 ++--
 .../Code06_Fruit2.java => class169/Code03_Fruit2.java}        | 2 +-
 .../Code07_Network1.java => class169/Code04_Network1.java}    | 4 ++--
 .../Code07_Network2.java => class169/Code04_Network2.java}    | 2 +-
 .../Code05_IvanAndBurgers1.java}                              | 4 ++--
 .../Code05_IvanAndBurgers2.java}                              | 2 +-
 10 files changed, 15 insertions(+), 15 deletions(-)
 rename src/{class168/Code04_Juice1.java => class169/Code01_Juice1.java} (99%)
 rename src/{class168/Code04_Juice2.java => class169/Code01_Juice2.java} (99%)
 rename src/{class168/Code05_PastoralOddities1.java => class169/Code02_PastoralOddities1.java} (98%)
 rename src/{class168/Code05_PastoralOddities2.java => class169/Code02_PastoralOddities2.java} (99%)
 rename src/{class168/Code06_Fruit1.java => class169/Code03_Fruit1.java} (99%)
 rename src/{class168/Code06_Fruit2.java => class169/Code03_Fruit2.java} (99%)
 rename src/{class168/Code07_Network1.java => class169/Code04_Network1.java} (99%)
 rename src/{class168/Code07_Network2.java => class169/Code04_Network2.java} (99%)
 rename src/{class168/Code08_IvanAndBurgers1.java => class169/Code05_IvanAndBurgers1.java} (98%)
 rename src/{class168/Code08_IvanAndBurgers2.java => class169/Code05_IvanAndBurgers2.java} (99%)

diff --git a/src/class168/Code04_Juice1.java b/src/class169/Code01_Juice1.java
similarity index 99%
rename from src/class168/Code04_Juice1.java
rename to src/class169/Code01_Juice1.java
index 9b4d59a42..36209772d 100644
--- a/src/class168/Code04_Juice1.java
+++ b/src/class169/Code01_Juice1.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 混合果汁，java版
 // 一共有n种果汁，每种果汁给定，美味度d、每升价格p、添加上限l
@@ -16,7 +16,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_Juice1 {
+public class Code01_Juice1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class168/Code04_Juice2.java b/src/class169/Code01_Juice2.java
similarity index 99%
rename from src/class168/Code04_Juice2.java
rename to src/class169/Code01_Juice2.java
index cd8b90296..ba7207068 100644
--- a/src/class168/Code04_Juice2.java
+++ b/src/class169/Code01_Juice2.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 混合果汁，C++版
 // 一共有n种果汁，每种果汁给定，美味度d、每升价格p、添加上限l
diff --git a/src/class168/Code05_PastoralOddities1.java b/src/class169/Code02_PastoralOddities1.java
similarity index 98%
rename from src/class168/Code05_PastoralOddities1.java
rename to src/class169/Code02_PastoralOddities1.java
index 065daf323..7df208e19 100644
--- a/src/class168/Code05_PastoralOddities1.java
+++ b/src/class169/Code02_PastoralOddities1.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 度为奇最小瓶颈，java版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_PastoralOddities1 {
+public class Code02_PastoralOddities1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 300002;
diff --git a/src/class168/Code05_PastoralOddities2.java b/src/class169/Code02_PastoralOddities2.java
similarity index 99%
rename from src/class168/Code05_PastoralOddities2.java
rename to src/class169/Code02_PastoralOddities2.java
index bd46af12d..606c75a30 100644
--- a/src/class168/Code05_PastoralOddities2.java
+++ b/src/class169/Code02_PastoralOddities2.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 度为奇最小瓶颈，C++版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
diff --git a/src/class168/Code06_Fruit1.java b/src/class169/Code03_Fruit1.java
similarity index 99%
rename from src/class168/Code06_Fruit1.java
rename to src/class169/Code03_Fruit1.java
index 39064bf2e..c17a4e92f 100644
--- a/src/class168/Code06_Fruit1.java
+++ b/src/class169/Code03_Fruit1.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 接水果，java版
 // 一共有n个点，给定n-1条无向边，所有点连成一棵树
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code06_Fruit1 {
+public class Code03_Fruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class168/Code06_Fruit2.java b/src/class169/Code03_Fruit2.java
similarity index 99%
rename from src/class168/Code06_Fruit2.java
rename to src/class169/Code03_Fruit2.java
index 27c43fde3..f05b53be3 100644
--- a/src/class168/Code06_Fruit2.java
+++ b/src/class169/Code03_Fruit2.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 接水果，C++版
 // 一共有n个点，给定n-1条无向边，所有点连成一棵树
diff --git a/src/class168/Code07_Network1.java b/src/class169/Code04_Network1.java
similarity index 99%
rename from src/class168/Code07_Network1.java
rename to src/class169/Code04_Network1.java
index afa669476..8be1de6e4 100644
--- a/src/class168/Code07_Network1.java
+++ b/src/class169/Code04_Network1.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 网络，java版
 // 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
@@ -17,7 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code07_Network1 {
+public class Code04_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class168/Code07_Network2.java b/src/class169/Code04_Network2.java
similarity index 99%
rename from src/class168/Code07_Network2.java
rename to src/class169/Code04_Network2.java
index 625c3bcf8..ea4b11131 100644
--- a/src/class168/Code07_Network2.java
+++ b/src/class169/Code04_Network2.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 网络，C++版
 // 一共有n个服务器，给定n-1条边，所有服务器连成一棵树
diff --git a/src/class168/Code08_IvanAndBurgers1.java b/src/class169/Code05_IvanAndBurgers1.java
similarity index 98%
rename from src/class168/Code08_IvanAndBurgers1.java
rename to src/class169/Code05_IvanAndBurgers1.java
index 815d9067c..e1fffe19b 100644
--- a/src/class168/Code08_IvanAndBurgers1.java
+++ b/src/class169/Code05_IvanAndBurgers1.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 范围最大异或和，java版
 // 给定一个长度为n的数组arr，下标1~n，接下来有q条查询，格式如下
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code08_IvanAndBurgers1 {
+public class Code05_IvanAndBurgers1 {
 
 	public static int MAXN = 500001;
 	public static int BIT = 21;
diff --git a/src/class168/Code08_IvanAndBurgers2.java b/src/class169/Code05_IvanAndBurgers2.java
similarity index 99%
rename from src/class168/Code08_IvanAndBurgers2.java
rename to src/class169/Code05_IvanAndBurgers2.java
index e00d24623..c9606fc42 100644
--- a/src/class168/Code08_IvanAndBurgers2.java
+++ b/src/class169/Code05_IvanAndBurgers2.java
@@ -1,4 +1,4 @@
-package class168;
+package class169;
 
 // 范围最大异或和，C++版
 // 给定一个长度为n的数组arr，下标1~n，接下来有q条查询，格式如下

From bd07e8e723a592d307f141b82515b8defa74c9f9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 15 May 2025 20:58:03 +0800
Subject: [PATCH 0811/1712] modify code

---
 src/class168/Code01_RangeKth1.java  |  29 +--
 src/class168/Code01_RangeKth2.java  | 279 ++++++++++++++-----------
 src/class168/Code01_RangeKth3.java  | 122 +++++++++++
 src/class168/Code01_RangeKth4.java  | 125 ++++++++++++
 src/class168/Code02_MatrixKth1.java | 184 -----------------
 src/class168/Code02_MatrixKth2.java | 302 ++++++++++++++++------------
 src/class168/Code02_MatrixKth4.java | 134 ++++++++++++
 src/class169/Code03_Fruit1.java     |   6 +-
 src/class169/Code03_Fruit2.java     |   6 +-
 9 files changed, 740 insertions(+), 447 deletions(-)
 create mode 100644 src/class168/Code01_RangeKth3.java
 create mode 100644 src/class168/Code01_RangeKth4.java
 delete mode 100644 src/class168/Code02_MatrixKth1.java
 create mode 100644 src/class168/Code02_MatrixKth4.java

diff --git a/src/class168/Code01_RangeKth1.java b/src/class168/Code01_RangeKth1.java
index 5807d6aae..c457172ba 100644
--- a/src/class168/Code01_RangeKth1.java
+++ b/src/class168/Code01_RangeKth1.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 区间内第k小，java版
+// 区间内第k小，第一种写法，java版
 // 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
@@ -18,7 +18,6 @@
 public class Code01_RangeKth1 {
 
 	public static int MAXN = 200001;
-	public static int INF = 1000000001;
 	public static int n, m;
 
 	// 位置i，数值v
@@ -32,7 +31,6 @@ public class Code01_RangeKth1 {
 
 	// 树状数组
 	public static int[] tree = new int[MAXN];
-	public static int used = 0;
 
 	// 整体二分
 	public static int[] lset = new int[MAXN];
@@ -71,25 +69,23 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = ql; i <= qr; i++) {
-				ans[qid[i]] = vl;
+				ans[qid[i]] = arr[vl][1];
 			}
 		} else {
+			// 修改数据状况
 			int mid = (vl + vr) / 2;
-			while (used + 1 <= n && arr[used + 1][1] <= mid) {
-				used++;
-				add(arr[used][0], 1);
-			}
-			while (used >= 1 && arr[used][1] > mid) {
-				add(arr[used][0], -1);
-				used--;
+			for (int i = vl; i <= mid; i++) {
+				add(arr[i][0], 1);
 			}
+			// 检查每个问题并划分左右
 			int lsiz = 0, rsiz = 0;
 			for (int i = ql; i <= qr; i++) {
 				int id = qid[i];
-				int check = query(l[id], r[id]);
-				if (check >= k[id]) {
+				int satisfy = query(l[id], r[id]);
+				if (satisfy >= k[id]) {
 					lset[++lsiz] = id;
 				} else {
+					k[id] -= satisfy;
 					rset[++rsiz] = id;
 				}
 			}
@@ -99,6 +95,11 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
+			// 撤回数据状况
+			for (int i = vl; i <= mid; i++) {
+				add(arr[i][0], -1);
+			}
+			// 左右两侧各自递归
 			compute(ql, ql + lsiz - 1, vl, mid);
 			compute(ql + lsiz, qr, mid + 1, vr);
 		}
@@ -120,7 +121,7 @@ public static void main(String[] args) throws Exception {
 			k[i] = in.nextInt();
 		}
 		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
-		compute(1, m, 0, INF);
+		compute(1, m, 1, n);
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index 771f55791..98d0f010a 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -1,125 +1,170 @@
 package class168;
 
-// 区间内第k小，C++版
+// 区间内第k小，第二种写法，java版
 // 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
 // 1 <= n、m <= 2 * 10^5
 // 1 <= 数组中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//struct Number {
-//    int i, v;
-//};
-//
-//bool NumberCmp(Number x, Number y) {
-//    return x.v < y.v;
-//}
-//
-//const int MAXN = 200001;
-//const int INF = 1000000001;
-//int n, m;
-//
-//Number arr[MAXN];
-//
-//int qid[MAXN];
-//int l[MAXN];
-//int r[MAXN];
-//int k[MAXN];
-//
-//int tree[MAXN];
-//int used = 0;
-//
-//int lset[MAXN];
-//int rset[MAXN];
-//
-//int ans[MAXN];
-//
-//int lowbit(int i) {
-//    return i & -i;
-//}
-//
-//void add(int i, int v) {
-//    while (i <= n) {
-//        tree[i] += v;
-//        i += lowbit(i);
-//    }
-//}
-//
-//int sum(int i) {
-//    int ret = 0;
-//    while (i > 0) {
-//        ret += tree[i];
-//        i -= lowbit(i);
-//    }
-//    return ret;
-//}
-//
-//int query(int l, int r) {
-//    return sum(r) - sum(l - 1);
-//}
-//
-//void compute(int ql, int qr, int vl, int vr) {
-//    if (ql > qr) {
-//        return;
-//    }
-//    if (vl == vr) {
-//        for (int i = ql; i <= qr; i++) {
-//            ans[qid[i]] = vl;
-//        }
-//    } else {
-//        int mid = (vl + vr) / 2;
-//        while (used + 1 <= n && arr[used + 1].v <= mid) {
-//            used++;
-//            add(arr[used].i, 1);
-//        }
-//        while (used >= 1 && arr[used].v > mid) {
-//            add(arr[used].i, -1);
-//            used--;
-//        }
-//        int lsiz = 0, rsiz = 0;
-//        for (int i = ql; i <= qr; i++) {
-//            int id = qid[i];
-//            int check = query(l[id], r[id]);
-//            if (check >= k[id]) {
-//                lset[++lsiz] = id;
-//            } else {
-//                rset[++rsiz] = id;
-//            }
-//        }
-//        for (int i = 1; i <= lsiz; i++) {
-//            qid[ql + i - 1] = lset[i];
-//        }
-//        for (int i = 1; i <= rsiz; i++) {
-//            qid[ql + lsiz + i - 1] = rset[i];
-//        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
-//        compute(ql + lsiz, qr, mid + 1, vr);
-//    }
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n >> m;
-//    for (int i = 1; i <= n; i++) {
-//        arr[i].i = i;
-//        cin >> arr[i].v;
-//    }
-//    for (int i = 1; i <= m; i++) {
-//        qid[i] = i;
-//        cin >> l[i] >> r[i] >> k[i];
-//    }
-//    sort(arr + 1, arr + n + 1, NumberCmp);
-//    compute(1, m, 0, INF);
-//    for (int i = 1; i <= m; i++) {
-//        cout << ans[i] << '\n';
-//    }
-//    return 0;
-//}
\ No newline at end of file
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_RangeKth2 {
+
+	public static int MAXN = 200001;
+	public static int INF = 1000000001;
+	public static int n, m;
+
+	// 位置i，数值v
+	public static int[][] arr = new int[MAXN][2];
+
+	// 查询
+	public static int[] qid = new int[MAXN];
+	public static int[] l = new int[MAXN];
+	public static int[] r = new int[MAXN];
+	public static int[] k = new int[MAXN];
+
+	// 树状数组
+	public static int[] tree = new int[MAXN];
+	public static int used = 0;
+
+	// 整体二分
+	public static int[] lset = new int[MAXN];
+	public static int[] rset = new int[MAXN];
+
+	// 查询的答案
+	public static int[] ans = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static int query(int l, int r) {
+		return sum(r) - sum(l - 1);
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = vl;
+			}
+		} else {
+			int mid = (vl + vr) / 2;
+			while (used + 1 <= n && arr[used + 1][1] <= mid) {
+				used++;
+				add(arr[used][0], 1);
+			}
+			while (used >= 1 && arr[used][1] > mid) {
+				add(arr[used][0], -1);
+				used--;
+			}
+			int lsiz = 0, rsiz = 0;
+			for (int i = ql; i <= qr; i++) {
+				int id = qid[i];
+				int satisfy = query(l[id], r[id]);
+				if (satisfy >= k[id]) {
+					lset[++lsiz] = id;
+				} else {
+					rset[++rsiz] = id;
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				qid[ql + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				qid[ql + lsiz + i - 1] = rset[i];
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = i;
+			arr[i][1] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			qid[i] = i;
+			l[i] = in.nextInt();
+			r[i] = in.nextInt();
+			k[i] = in.nextInt();
+		}
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
+		compute(1, m, 0, INF);
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code01_RangeKth3.java b/src/class168/Code01_RangeKth3.java
new file mode 100644
index 000000000..dba9e5465
--- /dev/null
+++ b/src/class168/Code01_RangeKth3.java
@@ -0,0 +1,122 @@
+package class168;
+
+// 区间内第k小，第一种写法，C++版
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
+// 给定一个长度为n的数组，接下来有m条查询，格式如下
+// 查询 l r k : 打印[l..r]范围内第k小的值
+// 1 <= n、m <= 2 * 10^5
+// 1 <= 数组中的数字 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int i, v;
+//};
+//
+//bool NumberCmp(Number x, Number y) {
+//    return x.v < y.v;
+//}
+//
+//const int MAXN = 200001;
+//int n, m;
+//
+//Number arr[MAXN];
+//
+//int qid[MAXN];
+//int l[MAXN];
+//int r[MAXN];
+//int k[MAXN];
+//
+//int tree[MAXN];
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//
+//int ans[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= n) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//int query(int l, int r) {
+//    return sum(r) - sum(l - 1);
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = arr[vl].v;
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        for (int i = vl; i <= mid; i++) {
+//            add(arr[i].i, 1);
+//        }
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            int satisfy = query(l[id], r[id]);
+//            if (satisfy >= k[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                k[id] -= satisfy;
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        for (int i = vl; i <= mid; i++) {
+//            add(arr[i].i, -1);
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].i = i;
+//        cin >> arr[i].v;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        qid[i] = i;
+//        cin >> l[i] >> r[i] >> k[i];
+//    }
+//    sort(arr + 1, arr + n + 1, NumberCmp);
+//    compute(1, m, 1, n);
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code01_RangeKth4.java b/src/class168/Code01_RangeKth4.java
new file mode 100644
index 000000000..b869d9fc4
--- /dev/null
+++ b/src/class168/Code01_RangeKth4.java
@@ -0,0 +1,125 @@
+package class168;
+
+// 区间内第k小，第二种写法，C++版
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
+// 给定一个长度为n的数组，接下来有m条查询，格式如下
+// 查询 l r k : 打印[l..r]范围内第k小的值
+// 1 <= n、m <= 2 * 10^5
+// 1 <= 数组中的数字 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int i, v;
+//};
+//
+//bool NumberCmp(Number x, Number y) {
+//    return x.v < y.v;
+//}
+//
+//const int MAXN = 200001;
+//const int INF = 1000000001;
+//int n, m;
+//
+//Number arr[MAXN];
+//
+//int qid[MAXN];
+//int l[MAXN];
+//int r[MAXN];
+//int k[MAXN];
+//
+//int tree[MAXN];
+//int used = 0;
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//
+//int ans[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= n) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//int query(int l, int r) {
+//    return sum(r) - sum(l - 1);
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
+//        }
+//    } else {
+//        int mid = (vl + vr) / 2;
+//        while (used + 1 <= n && arr[used + 1].v <= mid) {
+//            used++;
+//            add(arr[used].i, 1);
+//        }
+//        while (used >= 1 && arr[used].v > mid) {
+//            add(arr[used].i, -1);
+//            used--;
+//        }
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            int satisfy = query(l[id], r[id]);
+//            if (satisfy >= k[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].i = i;
+//        cin >> arr[i].v;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        qid[i] = i;
+//        cin >> l[i] >> r[i] >> k[i];
+//    }
+//    sort(arr + 1, arr + n + 1, NumberCmp);
+//    compute(1, m, 0, INF);
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code02_MatrixKth1.java b/src/class168/Code02_MatrixKth1.java
deleted file mode 100644
index 87b88fc9e..000000000
--- a/src/class168/Code02_MatrixKth1.java
+++ /dev/null
@@ -1,184 +0,0 @@
-package class168;
-
-// 矩阵内第k小，java版
-// 给定一个n * n的矩阵，接下来有q条查询，格式如下
-// 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
-// 1 <= n <= 500
-// 1 <= q <= 6 * 10^4
-// 0 <= 矩阵中的数字 <= 10^9
-// 测试链接 : https://www.luogu.com.cn/problem/P1527
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.util.Arrays;
-
-public class Code02_MatrixKth1 {
-
-	public static int MAXN = 501;
-	public static int MAXQ = 1000001;
-	public static int INF = 1000000001;
-	public static int n, q;
-
-	// 矩阵中的每个数字，所在行x、所在列y、数值v
-	public static int[][] xyv = new int[MAXN * MAXN][3];
-	public static int cntv = 0;
-	public static int used = 0;
-
-	// 查询任务的编号
-	public static int[] qid = new int[MAXQ];
-	// 查询范围的左上角坐标
-	public static int[] a = new int[MAXQ];
-	public static int[] b = new int[MAXQ];
-	// 查询范围的右下角坐标
-	public static int[] c = new int[MAXQ];
-	public static int[] d = new int[MAXQ];
-	// 查询任务的第几小值
-	public static int[] k = new int[MAXQ];
-
-	// 二维树状数组
-	public static int[][] tree = new int[MAXN][MAXN];
-
-	// 整体二分
-	public static int[] lset = new int[MAXQ];
-	public static int[] rset = new int[MAXQ];
-
-	// 每条查询的答案
-	public static int[] ans = new int[MAXQ];
-
-	public static int lowbit(int i) {
-		return i & -i;
-	}
-
-	public static void add(int x, int y, int v) {
-		for (int i = x; i <= n; i += lowbit(i)) {
-			for (int j = y; j <= n; j += lowbit(j)) {
-				tree[i][j] += v;
-			}
-		}
-	}
-
-	public static int sum(int x, int y) {
-		int ret = 0;
-		for (int i = x; i > 0; i -= lowbit(i)) {
-			for (int j = y; j > 0; j -= lowbit(j)) {
-				ret += tree[i][j];
-			}
-		}
-		return ret;
-	}
-
-	public static int query(int a, int b, int c, int d) {
-		return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
-	}
-
-	public static void compute(int ql, int qr, int vl, int vr) {
-		if (ql > qr) {
-			return;
-		}
-		if (vl == vr) {
-			for (int i = ql; i <= qr; i++) {
-				ans[qid[i]] = vl;
-			}
-		} else {
-			int mid = (vl + vr) >> 1;
-			int lsiz = 0, rsiz = 0;
-			while (used + 1 <= cntv && xyv[used + 1][2] <= mid) {
-				used++;
-				add(xyv[used][0], xyv[used][1], 1);
-			}
-			while (used >= 1 && xyv[used][2] > mid) {
-				add(xyv[used][0], xyv[used][1], -1);
-				used--;
-			}
-			for (int i = ql; i <= qr; i++) {
-				int id = qid[i];
-				int check = query(a[id], b[id], c[id], d[id]);
-				if (check >= k[id]) {
-					lset[++lsiz] = id;
-				} else {
-					rset[++rsiz] = id;
-				}
-			}
-			for (int i = 1; i <= lsiz; i++) {
-				qid[ql + i - 1] = lset[i];
-			}
-			for (int i = 1; i <= rsiz; i++) {
-				qid[ql + lsiz + i - 1] = rset[i];
-			}
-			compute(ql, ql + lsiz - 1, vl, mid);
-			compute(ql + lsiz, qr, mid + 1, vr);
-		}
-	}
-
-	public static void main(String[] args) throws Exception {
-		FastReader in = new FastReader(System.in);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		n = in.nextInt();
-		q = in.nextInt();
-		for (int i = 1; i <= n; i++) {
-			for (int j = 1; j <= n; j++) {
-				xyv[++cntv][0] = i;
-				xyv[cntv][1] = j;
-				xyv[cntv][2] = in.nextInt();
-			}
-		}
-		for (int i = 1; i <= q; i++) {
-			qid[i] = i;
-			a[i] = in.nextInt();
-			b[i] = in.nextInt();
-			c[i] = in.nextInt();
-			d[i] = in.nextInt();
-			k[i] = in.nextInt();
-		}
-		Arrays.sort(xyv, 1, cntv + 1, (a, b) -> a[2] - b[2]);
-		compute(1, q, 0, INF);
-		for (int i = 1; i <= q; i++) {
-			out.println(ans[i]);
-		}
-		out.flush();
-		out.close();
-	}
-
-	// 读写工具类
-	static class FastReader {
-		private final byte[] buffer = new byte[1 << 16];
-		private int ptr = 0, len = 0;
-		private final InputStream in;
-
-		FastReader(InputStream in) {
-			this.in = in;
-		}
-
-		private int readByte() throws IOException {
-			if (ptr >= len) {
-				len = in.read(buffer);
-				ptr = 0;
-				if (len <= 0)
-					return -1;
-			}
-			return buffer[ptr++];
-		}
-
-		int nextInt() throws IOException {
-			int c;
-			do {
-				c = readByte();
-			} while (c <= ' ' && c != -1);
-			boolean neg = false;
-			if (c == '-') {
-				neg = true;
-				c = readByte();
-			}
-			int val = 0;
-			while (c > ' ' && c != -1) {
-				val = val * 10 + (c - '0');
-				c = readByte();
-			}
-			return neg ? -val : val;
-		}
-	}
-
-}
diff --git a/src/class168/Code02_MatrixKth2.java b/src/class168/Code02_MatrixKth2.java
index 5f89826ed..e7f749dbe 100644
--- a/src/class168/Code02_MatrixKth2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -1,134 +1,184 @@
 package class168;
 
-// 矩阵内第k小，C++版
+// 矩阵内第k小，第二种写法，java版
 // 给定一个n * n的矩阵，接下来有q条查询，格式如下
 // 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
 // 1 <= n <= 500
 // 1 <= q <= 6 * 10^4
 // 0 <= 矩阵中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P1527
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//struct Number {
-//    int x, y, v;
-//};
-//
-//bool NumberCmp(Number a, Number b) {
-//    return a.v < b.v;
-//}
-//
-//const int MAXN = 501;
-//const int MAXQ = 1000001;
-//const int INF  = 1000000001;
-//int n, q;
-//
-//Number xyv[MAXN * MAXN];
-//int cntv = 0;
-//int used = 0;
-//
-//int qid[MAXQ];
-//int a[MAXQ];
-//int b[MAXQ];
-//int c[MAXQ];
-//int d[MAXQ];
-//int k[MAXQ];
-//
-//int tree[MAXN][MAXN];
-//
-//int lset[MAXQ];
-//int rset[MAXQ];
-//
-//int ans[MAXQ];
-//
-//int lowbit(int i) {
-//    return i & -i;
-//}
-//
-//void add(int x, int y, int v) {
-//    for (int i = x; i <= n; i += lowbit(i)) {
-//        for (int j = y; j <= n; j += lowbit(j)) {
-//            tree[i][j] += v;
-//        }
-//    }
-//}
-//
-//int sum(int x, int y) {
-//    int ret = 0;
-//    for (int i = x; i > 0; i -= lowbit(i)) {
-//        for (int j = y; j > 0; j -= lowbit(j)) {
-//            ret += tree[i][j];
-//        }
-//    }
-//    return ret;
-//}
-//
-//int query(int a, int b, int c, int d) {
-//    return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
-//}
-//
-//void compute(int ql, int qr, int vl, int vr) {
-//    if (ql > qr) {
-//        return;
-//    }
-//    if (vl == vr) {
-//        for (int i = ql; i <= qr; i++) {
-//            ans[qid[i]] = vl;
-//        }
-//    } else {
-//        int mid = (vl + vr) >> 1;
-//        int lsiz = 0, rsiz = 0;
-//        while (used + 1 <= cntv && xyv[used + 1].v <= mid) {
-//            used++;
-//            add(xyv[used].x, xyv[used].y, 1);
-//        }
-//        while (used >= 1 && xyv[used].v > mid) {
-//            add(xyv[used].x, xyv[used].y, -1);
-//            used--;
-//        }
-//        for (int i = ql; i <= qr; i++) {
-//            int id = qid[i];
-//            int check = query(a[id], b[id], c[id], d[id]);
-//            if (check >= k[id]) {
-//                lset[++lsiz] = id;
-//            } else {
-//                rset[++rsiz] = id;
-//            }
-//        }
-//        for (int i = 1; i <= lsiz; i++) {
-//            qid[ql + i - 1] = lset[i];
-//        }
-//        for (int i = 1; i <= rsiz; i++) {
-//            qid[ql + lsiz + i - 1] = rset[i];
-//        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
-//        compute(ql + lsiz, qr, mid + 1, vr);
-//    }
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n >> q;
-//    for (int i = 1; i <= n; i++) {
-//        for (int j = 1; j <= n; j++) {
-//            xyv[++cntv].x = i;
-//            xyv[cntv].y = j;
-//            cin >> xyv[cntv].v;
-//        }
-//    }
-//    for (int i = 1; i <= q; i++) {
-//        qid[i] = i;
-//        cin >> a[i] >> b[i] >> c[i] >> d[i] >> k[i];
-//    }
-//    sort(xyv + 1, xyv + cntv + 1, NumberCmp);
-//    compute(1, q, 0, INF);
-//    for (int i = 1; i <= q; i++) {
-//        cout << ans[i] << '\n';
-//    }
-//    return 0;
-//}
\ No newline at end of file
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_MatrixKth2 {
+
+	public static int MAXN = 501;
+	public static int MAXQ = 1000001;
+	public static int INF = 1000000001;
+	public static int n, q;
+
+	// 矩阵中的每个数字，所在行x、所在列y、数值v
+	public static int[][] xyv = new int[MAXN * MAXN][3];
+	public static int cntv = 0;
+	public static int used = 0;
+
+	// 查询任务的编号
+	public static int[] qid = new int[MAXQ];
+	// 查询范围的左上角坐标
+	public static int[] a = new int[MAXQ];
+	public static int[] b = new int[MAXQ];
+	// 查询范围的右下角坐标
+	public static int[] c = new int[MAXQ];
+	public static int[] d = new int[MAXQ];
+	// 查询任务的第几小值
+	public static int[] k = new int[MAXQ];
+
+	// 二维树状数组
+	public static int[][] tree = new int[MAXN][MAXN];
+
+	// 整体二分
+	public static int[] lset = new int[MAXQ];
+	public static int[] rset = new int[MAXQ];
+
+	// 每条查询的答案
+	public static int[] ans = new int[MAXQ];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int x, int y, int v) {
+		for (int i = x; i <= n; i += lowbit(i)) {
+			for (int j = y; j <= n; j += lowbit(j)) {
+				tree[i][j] += v;
+			}
+		}
+	}
+
+	public static int sum(int x, int y) {
+		int ret = 0;
+		for (int i = x; i > 0; i -= lowbit(i)) {
+			for (int j = y; j > 0; j -= lowbit(j)) {
+				ret += tree[i][j];
+			}
+		}
+		return ret;
+	}
+
+	public static int query(int a, int b, int c, int d) {
+		return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = vl;
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			int lsiz = 0, rsiz = 0;
+			while (used + 1 <= cntv && xyv[used + 1][2] <= mid) {
+				used++;
+				add(xyv[used][0], xyv[used][1], 1);
+			}
+			while (used >= 1 && xyv[used][2] > mid) {
+				add(xyv[used][0], xyv[used][1], -1);
+				used--;
+			}
+			for (int i = ql; i <= qr; i++) {
+				int id = qid[i];
+				int satisfy = query(a[id], b[id], c[id], d[id]);
+				if (satisfy >= k[id]) {
+					lset[++lsiz] = id;
+				} else {
+					rset[++rsiz] = id;
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				qid[ql + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				qid[ql + lsiz + i - 1] = rset[i];
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				xyv[++cntv][0] = i;
+				xyv[cntv][1] = j;
+				xyv[cntv][2] = in.nextInt();
+			}
+		}
+		for (int i = 1; i <= q; i++) {
+			qid[i] = i;
+			a[i] = in.nextInt();
+			b[i] = in.nextInt();
+			c[i] = in.nextInt();
+			d[i] = in.nextInt();
+			k[i] = in.nextInt();
+		}
+		Arrays.sort(xyv, 1, cntv + 1, (a, b) -> a[2] - b[2]);
+		compute(1, q, 0, INF);
+		for (int i = 1; i <= q; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code02_MatrixKth4.java b/src/class168/Code02_MatrixKth4.java
new file mode 100644
index 000000000..329b5b61b
--- /dev/null
+++ b/src/class168/Code02_MatrixKth4.java
@@ -0,0 +1,134 @@
+package class168;
+
+// 矩阵内第k小，第二种写法，C++版
+// 给定一个n * n的矩阵，接下来有q条查询，格式如下
+// 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
+// 1 <= n <= 500
+// 1 <= q <= 6 * 10^4
+// 0 <= 矩阵中的数字 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P1527
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int x, y, v;
+//};
+//
+//bool NumberCmp(Number a, Number b) {
+//    return a.v < b.v;
+//}
+//
+//const int MAXN = 501;
+//const int MAXQ = 1000001;
+//const int INF  = 1000000001;
+//int n, q;
+//
+//Number xyv[MAXN * MAXN];
+//int cntv = 0;
+//int used = 0;
+//
+//int qid[MAXQ];
+//int a[MAXQ];
+//int b[MAXQ];
+//int c[MAXQ];
+//int d[MAXQ];
+//int k[MAXQ];
+//
+//int tree[MAXN][MAXN];
+//
+//int lset[MAXQ];
+//int rset[MAXQ];
+//
+//int ans[MAXQ];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int x, int y, int v) {
+//    for (int i = x; i <= n; i += lowbit(i)) {
+//        for (int j = y; j <= n; j += lowbit(j)) {
+//            tree[i][j] += v;
+//        }
+//    }
+//}
+//
+//int sum(int x, int y) {
+//    int ret = 0;
+//    for (int i = x; i > 0; i -= lowbit(i)) {
+//        for (int j = y; j > 0; j -= lowbit(j)) {
+//            ret += tree[i][j];
+//        }
+//    }
+//    return ret;
+//}
+//
+//int query(int a, int b, int c, int d) {
+//    return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        int lsiz = 0, rsiz = 0;
+//        while (used + 1 <= cntv && xyv[used + 1].v <= mid) {
+//            used++;
+//            add(xyv[used].x, xyv[used].y, 1);
+//        }
+//        while (used >= 1 && xyv[used].v > mid) {
+//            add(xyv[used].x, xyv[used].y, -1);
+//            used--;
+//        }
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            int satisfy = query(a[id], b[id], c[id], d[id]);
+//            if (satisfy >= k[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        for (int j = 1; j <= n; j++) {
+//            xyv[++cntv].x = i;
+//            xyv[cntv].y = j;
+//            cin >> xyv[cntv].v;
+//        }
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        qid[i] = i;
+//        cin >> a[i] >> b[i] >> c[i] >> d[i] >> k[i];
+//    }
+//    sort(xyv + 1, xyv + cntv + 1, NumberCmp);
+//    compute(1, q, 0, INF);
+//    for (int i = 1; i <= q; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class169/Code03_Fruit1.java b/src/class169/Code03_Fruit1.java
index c17a4e92f..db0f585eb 100644
--- a/src/class169/Code03_Fruit1.java
+++ b/src/class169/Code03_Fruit1.java
@@ -228,11 +228,11 @@ public static void compute(int ql, int qr, int vl, int vr) {
 						clone(rset[++rsiz], event[i]);
 					}
 				} else {
-					int check = query(event[i][2]);
-					if (check >= event[i][4]) {
+					int satisfy = query(event[i][2]);
+					if (satisfy >= event[i][4]) {
 						clone(lset[++lsiz], event[i]);
 					} else {
-						event[i][4] -= check;
+						event[i][4] -= satisfy;
 						clone(rset[++rsiz], event[i]);
 					}
 				}
diff --git a/src/class169/Code03_Fruit2.java b/src/class169/Code03_Fruit2.java
index f05b53be3..e3150f87e 100644
--- a/src/class169/Code03_Fruit2.java
+++ b/src/class169/Code03_Fruit2.java
@@ -175,11 +175,11 @@
 //                    rset[++rsiz] = event[i];
 //                }
 //            } else {
-//                int check = query(event[i].yl);
-//                if (check >= event[i].v) {
+//                int satisfy = query(event[i].yl);
+//                if (satisfy >= event[i].v) {
 //                    lset[++lsiz] = event[i];
 //                } else {
-//                    event[i].v -= check;
+//                    event[i].v -= satisfy;
 //                    rset[++rsiz] = event[i];
 //                }
 //            }

From 73645cd5cd2a0da87298b4f4eda9b509f74e71aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 15 May 2025 21:13:56 +0800
Subject: [PATCH 0812/1712] modify code

---
 src/class168/Code02_MatrixKth1.java | 181 ++++++++++++++++++++++++++++
 src/class168/Code02_MatrixKth3.java | 131 ++++++++++++++++++++
 2 files changed, 312 insertions(+)
 create mode 100644 src/class168/Code02_MatrixKth1.java
 create mode 100644 src/class168/Code02_MatrixKth3.java

diff --git a/src/class168/Code02_MatrixKth1.java b/src/class168/Code02_MatrixKth1.java
new file mode 100644
index 000000000..a183d7247
--- /dev/null
+++ b/src/class168/Code02_MatrixKth1.java
@@ -0,0 +1,181 @@
+package class168;
+
+// 矩阵内第k小，第一种写法，java版
+// 给定一个n * n的矩阵，接下来有q条查询，格式如下
+// 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
+// 1 <= n <= 500
+// 1 <= q <= 6 * 10^4
+// 0 <= 矩阵中的数字 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P1527
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_MatrixKth1 {
+
+	public static int MAXN = 501;
+	public static int MAXQ = 1000001;
+	public static int n, q;
+
+	// 矩阵中的每个数字，所在行x、所在列y、数值v
+	public static int[][] xyv = new int[MAXN * MAXN][3];
+	public static int cntv = 0;
+
+	// 查询任务的编号
+	public static int[] qid = new int[MAXQ];
+	// 查询范围的左上角坐标
+	public static int[] a = new int[MAXQ];
+	public static int[] b = new int[MAXQ];
+	// 查询范围的右下角坐标
+	public static int[] c = new int[MAXQ];
+	public static int[] d = new int[MAXQ];
+	// 查询任务的第几小值
+	public static int[] k = new int[MAXQ];
+
+	// 二维树状数组
+	public static int[][] tree = new int[MAXN][MAXN];
+
+	// 整体二分
+	public static int[] lset = new int[MAXQ];
+	public static int[] rset = new int[MAXQ];
+
+	// 每条查询的答案
+	public static int[] ans = new int[MAXQ];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int x, int y, int v) {
+		for (int i = x; i <= n; i += lowbit(i)) {
+			for (int j = y; j <= n; j += lowbit(j)) {
+				tree[i][j] += v;
+			}
+		}
+	}
+
+	public static int sum(int x, int y) {
+		int ret = 0;
+		for (int i = x; i > 0; i -= lowbit(i)) {
+			for (int j = y; j > 0; j -= lowbit(j)) {
+				ret += tree[i][j];
+			}
+		}
+		return ret;
+	}
+
+	public static int query(int a, int b, int c, int d) {
+		return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = xyv[vl][2];
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			for (int i = vl; i <= mid; i++) {
+				add(xyv[i][0], xyv[i][1], 1);
+			}
+			int lsiz = 0, rsiz = 0;
+			for (int i = ql; i <= qr; i++) {
+				int id = qid[i];
+				int satisfy = query(a[id], b[id], c[id], d[id]);
+				if (satisfy >= k[id]) {
+					lset[++lsiz] = id;
+				} else {
+					k[id] -= satisfy;
+					rset[++rsiz] = id;
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				qid[ql + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				qid[ql + lsiz + i - 1] = rset[i];
+			}
+			for (int i = vl; i <= mid; i++) {
+				add(xyv[i][0], xyv[i][1], -1);
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= n; j++) {
+				xyv[++cntv][0] = i;
+				xyv[cntv][1] = j;
+				xyv[cntv][2] = in.nextInt();
+			}
+		}
+		for (int i = 1; i <= q; i++) {
+			qid[i] = i;
+			a[i] = in.nextInt();
+			b[i] = in.nextInt();
+			c[i] = in.nextInt();
+			d[i] = in.nextInt();
+			k[i] = in.nextInt();
+		}
+		Arrays.sort(xyv, 1, cntv + 1, (a, b) -> a[2] - b[2]);
+		compute(1, q, 1, cntv);
+		for (int i = 1; i <= q; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code02_MatrixKth3.java b/src/class168/Code02_MatrixKth3.java
new file mode 100644
index 000000000..1bd6212b7
--- /dev/null
+++ b/src/class168/Code02_MatrixKth3.java
@@ -0,0 +1,131 @@
+package class168;
+
+// 矩阵内第k小，第一种写法，C++版
+// 给定一个n * n的矩阵，接下来有q条查询，格式如下
+// 查询 a b c d k : 左上角(a, b)，右下角(c, d)，打印该区域中第k小的数
+// 1 <= n <= 500
+// 1 <= q <= 6 * 10^4
+// 0 <= 矩阵中的数字 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P1527
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int x, y, v;
+//};
+//
+//bool NumberCmp(Number a, Number b) {
+//    return a.v < b.v;
+//}
+//
+//const int MAXN = 501;
+//const int MAXQ = 1000001;
+//int n, q;
+//
+//Number xyv[MAXN * MAXN];
+//int cntv = 0;
+//
+//int qid[MAXQ];
+//int a[MAXQ];
+//int b[MAXQ];
+//int c[MAXQ];
+//int d[MAXQ];
+//int k[MAXQ];
+//
+//int tree[MAXN][MAXN];
+//
+//int lset[MAXQ];
+//int rset[MAXQ];
+//
+//int ans[MAXQ];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int x, int y, int v) {
+//    for (int i = x; i <= n; i += lowbit(i)) {
+//        for (int j = y; j <= n; j += lowbit(j)) {
+//            tree[i][j] += v;
+//        }
+//    }
+//}
+//
+//int sum(int x, int y) {
+//    int ret = 0;
+//    for (int i = x; i > 0; i -= lowbit(i)) {
+//        for (int j = y; j > 0; j -= lowbit(j)) {
+//            ret += tree[i][j];
+//        }
+//    }
+//    return ret;
+//}
+//
+//int query(int a, int b, int c, int d) {
+//    return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = xyv[vl].v;
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        for (int i = vl; i <= mid; i++) {
+//            add(xyv[i].x, xyv[i].y, 1);
+//        }
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            int satisfy = query(a[id], b[id], c[id], d[id]);
+//            if (satisfy >= k[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                k[id] -= satisfy;
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        for (int i = vl; i <= mid; i++) {
+//            add(xyv[i].x, xyv[i].y, -1);
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        for (int j = 1; j <= n; j++) {
+//            xyv[++cntv].x = i;
+//            xyv[cntv].y = j;
+//            cin >> xyv[cntv].v;
+//        }
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        qid[i] = i;
+//        cin >> a[i] >> b[i] >> c[i] >> d[i] >> k[i];
+//    }
+//    sort(xyv + 1, xyv + cntv + 1, NumberCmp);
+//    compute(1, q, 1, cntv);
+//    for (int i = 1; i <= q; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 59d682e04f9a58c2c3e8a22b512b00e52b340880 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 15 May 2025 21:29:11 +0800
Subject: [PATCH 0813/1712] modify code

---
 src/class168/Code03_Meteors1.java |  20 +-
 src/class168/Code03_Meteors2.java | 326 +++++++++++++++++-------------
 src/class168/Code03_Meteors3.java | 145 +++++++++++++
 src/class168/Code03_Meteors4.java | 147 ++++++++++++++
 4 files changed, 489 insertions(+), 149 deletions(-)
 create mode 100644 src/class168/Code03_Meteors3.java
 create mode 100644 src/class168/Code03_Meteors4.java

diff --git a/src/class168/Code03_Meteors1.java b/src/class168/Code03_Meteors1.java
index 3b2e09019..494feccc6 100644
--- a/src/class168/Code03_Meteors1.java
+++ b/src/class168/Code03_Meteors1.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 陨石雨，java版
+// 陨石雨，第一种写法，java版
 // 一共有n个国家，给定n个数字，表示每个国家希望收集到的陨石数量
 // 一共有m个区域，1号区顺时针到2号区...m号区顺时针到1号区，即环形相连
 // 每个区域只属于某一个国家，给定m个数字，表示每个区域归属给哪个国家
@@ -12,7 +12,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
 // 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
-// 想通过用C++实现，本节课Code03_Meteors2文件就是C++的实现
+// 想通过用C++实现，本节课Code03_Meteors3文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -31,7 +31,6 @@ public class Code03_Meteors1 {
 	public static int[] rainl = new int[MAXN];
 	public static int[] rainr = new int[MAXN];
 	public static int[] num = new int[MAXN];
-	public static int used = 0;
 
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
@@ -87,15 +86,10 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
-			int lsiz = 0, rsiz = 0;
-			while (used < mid) {
-				used++;
-				add(rainl[used], rainr[used], num[used]);
-			}
-			while (used > mid) {
-				add(rainl[used], rainr[used], -num[used]);
-				used--;
+			for (int i = vl; i <= mid; i++) {
+				add(rainl[i], rainr[i], num[i]);
 			}
+			int lsiz = 0, rsiz = 0;
 			for (int i = ql; i <= qr; i++) {
 				int id = qid[i];
 				long satisfy = 0;
@@ -108,6 +102,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 				if (satisfy >= need[id]) {
 					lset[++lsiz] = id;
 				} else {
+					need[id] -= satisfy;
 					rset[++rsiz] = id;
 				}
 			}
@@ -117,6 +112,9 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
+			for (int i = vl; i <= mid; i++) {
+				add(rainl[i], rainr[i], -num[i]);
+			}
 			compute(ql, ql + lsiz - 1, vl, mid);
 			compute(ql + lsiz, qr, mid + 1, vr);
 		}
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code03_Meteors2.java
index 458d40b0f..1b25d9408 100644
--- a/src/class168/Code03_Meteors2.java
+++ b/src/class168/Code03_Meteors2.java
@@ -1,6 +1,6 @@
 package class168;
 
-// 陨石雨，C++版
+// 陨石雨，第二种写法，java版
 // 一共有n个国家，给定n个数字，表示每个国家希望收集到的陨石数量
 // 一共有m个区域，1号区顺时针到2号区...m号区顺时针到1号区，即环形相连
 // 每个区域只属于某一个国家，给定m个数字，表示每个区域归属给哪个国家
@@ -9,140 +9,190 @@
 // 打印每个国家经历前几场陨石雨，可以达到收集要求，如果无法满足，打印"NIE"
 // 1 <= n、m、k <= 3 * 10^5    1 <= 陨石数量 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3527
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//const int MAXN = 300001;
-//
-//int n, m, k;
-//
-//int qid[MAXN];
-//int need[MAXN];
-//
-//int rainl[MAXN];
-//int rainr[MAXN];
-//int num[MAXN];
-//int used = 0;
-//
-//int head[MAXN];
-//int nxt[MAXN];
-//int to[MAXN];
-//int cnt = 0;
-//
-//long long tree[MAXN << 1];
-//
-//int lset[MAXN];
-//int rset[MAXN];
-//
-//int ans[MAXN];
-//
-//void addEdge(int i, int v) {
-//    nxt[++cnt] = head[i];
-//    to[cnt] = v;
-//    head[i] = cnt;
-//}
-//
-//int lowbit(int i) {
-//    return i & -i;
-//}
-//
-//void add(int i, int v) {
-//    int siz = m * 2;
-//    while (i <= siz) {
-//        tree[i] += v;
-//        i += lowbit(i);
-//    }
-//}
-//
-//void add(int l, int r, int v) {
-//    add(l, v);
-//    add(r + 1, -v);
-//}
-//
-//long long query(int i) {
-//    long long ret = 0;
-//    while (i > 0) {
-//    	ret += tree[i];
-//        i -= lowbit(i);
-//    }
-//    return ret;
-//}
-//
-//void compute(int ql, int qr, int vl, int vr) {
-//    if (ql > qr) {
-//        return;
-//    }
-//    if (vl == vr) {
-//        for (int i = ql; i <= qr; i++) {
-//            ans[qid[i]] = vl;
-//        }
-//    } else {
-//        int mid = (vl + vr) >> 1;
-//        int lsiz = 0, rsiz = 0;
-//        while (used < mid) {
-//            used++;
-//            add(rainl[used], rainr[used], num[used]);
-//        }
-//        while (used > mid) {
-//            add(rainl[used], rainr[used], -num[used]);
-//            used--;
-//        }
-//        for (int i = ql; i <= qr; i++) {
-//            int id = qid[i];
-//            long long satisfy = 0;
-//            for (int e = head[id]; e > 0; e = nxt[e]) {
-//                satisfy += query(to[e]) + query(to[e] + m);
-//                if (satisfy >= need[id]) {
-//                    break;
-//                }
-//            }
-//            if (satisfy >= need[id]) {
-//                lset[++lsiz] = id;
-//            } else {
-//                rset[++rsiz] = id;
-//            }
-//        }
-//        for (int i = 1; i <= lsiz; i++) {
-//            qid[ql + i - 1] = lset[i];
-//        }
-//        for (int i = 1; i <= rsiz; i++) {
-//            qid[ql + lsiz + i - 1] = rset[i];
-//        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
-//        compute(ql + lsiz, qr, mid + 1, vr);
-//    }
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n >> m;
-//    for (int i = 1, nation; i <= m; i++) {
-//        cin >> nation;
-//        addEdge(nation, i);
-//    }
-//    for (int i = 1; i <= n; i++) {
-//        qid[i] = i;
-//        cin >> need[i];
-//    }
-//    cin >> k;
-//    for (int i = 1; i <= k; i++) {
-//        cin >> rainl[i] >> rainr[i] >> num[i];
-//        if (rainr[i] < rainl[i]) {
-//            rainr[i] += m;
-//        }
-//    }
-//    compute(1, n, 1, k + 1);
-//    for (int i = 1; i <= n; i++) {
-//        if (ans[i] == k + 1) {
-//            cout << "NIE" << '\n';
-//        } else {
-//            cout << ans[i] << '\n';
-//        }
-//    }
-//    return 0;
-//}
\ No newline at end of file
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
+// 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
+// 想通过用C++实现，本节课Code03_Meteors4文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_Meteors2 {
+
+	public static int MAXN = 300001;
+	public static int n, m, k;
+
+	public static int[] qid = new int[MAXN];
+	public static int[] need = new int[MAXN];
+
+	public static int[] rainl = new int[MAXN];
+	public static int[] rainr = new int[MAXN];
+	public static int[] num = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
+	public static int cnt = 0;
+
+	public static long[] tree = new long[MAXN << 1];
+	public static int used = 0;
+
+	public static int[] lset = new int[MAXN];
+	public static int[] rset = new int[MAXN];
+
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdge(int i, int v) {
+		next[++cnt] = head[i];
+		to[cnt] = v;
+		head[i] = cnt;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		int siz = m * 2;
+		while (i <= siz) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static void add(int l, int r, int v) {
+		add(l, v);
+		add(r + 1, -v);
+	}
+
+	public static long query(int i) {
+		long ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void compute(int ql, int qr, int vl, int vr) {
+		if (ql > qr) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = ql; i <= qr; i++) {
+				ans[qid[i]] = vl;
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			int lsiz = 0, rsiz = 0;
+			while (used < mid) {
+				used++;
+				add(rainl[used], rainr[used], num[used]);
+			}
+			while (used > mid) {
+				add(rainl[used], rainr[used], -num[used]);
+				used--;
+			}
+			for (int i = ql; i <= qr; i++) {
+				int id = qid[i];
+				long satisfy = 0;
+				for (int e = head[id]; e > 0; e = next[e]) {
+					satisfy += query(to[e]) + query(to[e] + m);
+					if (satisfy >= need[id]) {
+						break;
+					}
+				}
+				if (satisfy >= need[id]) {
+					lset[++lsiz] = id;
+				} else {
+					rset[++rsiz] = id;
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				qid[ql + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				qid[ql + lsiz + i - 1] = rset[i];
+			}
+			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, nation; i <= m; i++) {
+			nation = in.nextInt();
+			addEdge(nation, i);
+		}
+		for (int i = 1; i <= n; i++) {
+			qid[i] = i;
+			need[i] = in.nextInt();
+		}
+		k = in.nextInt();
+		for (int i = 1; i <= k; i++) {
+			rainl[i] = in.nextInt();
+			rainr[i] = in.nextInt();
+			if (rainr[i] < rainl[i]) {
+				rainr[i] += m;
+			}
+			num[i] = in.nextInt();
+		}
+		compute(1, n, 1, k + 1);
+		for (int i = 1; i <= n; i++) {
+			if (ans[i] == k + 1) {
+				out.println("NIE");
+			} else {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class168/Code03_Meteors3.java b/src/class168/Code03_Meteors3.java
new file mode 100644
index 000000000..ad30c4a14
--- /dev/null
+++ b/src/class168/Code03_Meteors3.java
@@ -0,0 +1,145 @@
+package class168;
+
+// 陨石雨，第一种写法，C++版
+// 一共有n个国家，给定n个数字，表示每个国家希望收集到的陨石数量
+// 一共有m个区域，1号区顺时针到2号区...m号区顺时针到1号区，即环形相连
+// 每个区域只属于某一个国家，给定m个数字，表示每个区域归属给哪个国家
+// 接下来会依次发生k场陨石雨，陨石雨格式 l r num，含义如下
+// 从l号区顺时针到r号区发生了陨石雨，每个区域都增加num个陨石
+// 打印每个国家经历前几场陨石雨，可以达到收集要求，如果无法满足，打印"NIE"
+// 1 <= n、m、k <= 3 * 10^5    1 <= 陨石数量 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3527
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//int n, m, k;
+//
+//int qid[MAXN];
+//int need[MAXN];
+//
+//int rainl[MAXN];
+//int rainr[MAXN];
+//int num[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cnt = 0;
+//
+//long long tree[MAXN << 1];
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//
+//int ans[MAXN];
+//
+//void addEdge(int i, int v) {
+//    nxt[++cnt] = head[i];
+//    to[cnt] = v;
+//    head[i] = cnt;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    int siz = m * 2;
+//    while (i <= siz) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void add(int l, int r, int v) {
+//    add(l, v);
+//    add(r + 1, -v);
+//}
+//
+//long long query(int i) {
+//    long long ret = 0;
+//    while (i > 0) {
+//    	ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        for (int i = vl; i <= mid; i++) {
+//            add(rainl[i], rainr[i], num[i]);
+//        }
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            long long satisfy = 0;
+//            for (int e = head[id]; e > 0; e = nxt[e]) {
+//                satisfy += query(to[e]) + query(to[e] + m);
+//                if (satisfy >= need[id]) {
+//                    break;
+//                }
+//            }
+//            if (satisfy >= need[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                need[id] -= satisfy;
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        for (int i = vl; i <= mid; i++) {
+//            add(rainl[i], rainr[i], -num[i]);
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, nation; i <= m; i++) {
+//        cin >> nation;
+//        addEdge(nation, i);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        qid[i] = i;
+//        cin >> need[i];
+//    }
+//    cin >> k;
+//    for (int i = 1; i <= k; i++) {
+//        cin >> rainl[i] >> rainr[i] >> num[i];
+//        if (rainr[i] < rainl[i]) {
+//            rainr[i] += m;
+//        }
+//    }
+//    compute(1, n, 1, k + 1);
+//    for (int i = 1; i <= n; i++) {
+//        if (ans[i] == k + 1) {
+//            cout << "NIE" << '\n';
+//        } else {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class168/Code03_Meteors4.java b/src/class168/Code03_Meteors4.java
new file mode 100644
index 000000000..5353778a0
--- /dev/null
+++ b/src/class168/Code03_Meteors4.java
@@ -0,0 +1,147 @@
+package class168;
+
+// 陨石雨，第二种写法，C++版
+// 一共有n个国家，给定n个数字，表示每个国家希望收集到的陨石数量
+// 一共有m个区域，1号区顺时针到2号区...m号区顺时针到1号区，即环形相连
+// 每个区域只属于某一个国家，给定m个数字，表示每个区域归属给哪个国家
+// 接下来会依次发生k场陨石雨，陨石雨格式 l r num，含义如下
+// 从l号区顺时针到r号区发生了陨石雨，每个区域都增加num个陨石
+// 打印每个国家经历前几场陨石雨，可以达到收集要求，如果无法满足，打印"NIE"
+// 1 <= n、m、k <= 3 * 10^5    1 <= 陨石数量 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P3527
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//int n, m, k;
+//
+//int qid[MAXN];
+//int need[MAXN];
+//
+//int rainl[MAXN];
+//int rainr[MAXN];
+//int num[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cnt = 0;
+//
+//long long tree[MAXN << 1];
+//int used = 0;
+//
+//int lset[MAXN];
+//int rset[MAXN];
+//
+//int ans[MAXN];
+//
+//void addEdge(int i, int v) {
+//    nxt[++cnt] = head[i];
+//    to[cnt] = v;
+//    head[i] = cnt;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    int siz = m * 2;
+//    while (i <= siz) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void add(int l, int r, int v) {
+//    add(l, v);
+//    add(r + 1, -v);
+//}
+//
+//long long query(int i) {
+//    long long ret = 0;
+//    while (i > 0) {
+//    	ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void compute(int ql, int qr, int vl, int vr) {
+//    if (ql > qr) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = ql; i <= qr; i++) {
+//            ans[qid[i]] = vl;
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        int lsiz = 0, rsiz = 0;
+//        while (used < mid) {
+//            used++;
+//            add(rainl[used], rainr[used], num[used]);
+//        }
+//        while (used > mid) {
+//            add(rainl[used], rainr[used], -num[used]);
+//            used--;
+//        }
+//        for (int i = ql; i <= qr; i++) {
+//            int id = qid[i];
+//            long long satisfy = 0;
+//            for (int e = head[id]; e > 0; e = nxt[e]) {
+//                satisfy += query(to[e]) + query(to[e] + m);
+//                if (satisfy >= need[id]) {
+//                    break;
+//                }
+//            }
+//            if (satisfy >= need[id]) {
+//                lset[++lsiz] = id;
+//            } else {
+//                rset[++rsiz] = id;
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            qid[ql + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            qid[ql + lsiz + i - 1] = rset[i];
+//        }
+//        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, nation; i <= m; i++) {
+//        cin >> nation;
+//        addEdge(nation, i);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        qid[i] = i;
+//        cin >> need[i];
+//    }
+//    cin >> k;
+//    for (int i = 1; i <= k; i++) {
+//        cin >> rainl[i] >> rainr[i] >> num[i];
+//        if (rainr[i] < rainl[i]) {
+//            rainr[i] += m;
+//        }
+//    }
+//    compute(1, n, 1, k + 1);
+//    for (int i = 1; i <= n; i++) {
+//        if (ans[i] == k + 1) {
+//            cout << "NIE" << '\n';
+//        } else {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From fb26df198480d10cab1948653373ba0aba7e7f05 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 12:18:11 +0800
Subject: [PATCH 0814/1712] modify code

---
 src/class168/Code01_RangeKth2.java  | 3 ++-
 src/class168/Code01_RangeKth4.java  | 2 +-
 src/class168/Code02_MatrixKth2.java | 3 ++-
 src/class168/Code02_MatrixKth4.java | 2 +-
 src/class168/Code03_Meteors2.java   | 3 ++-
 src/class168/Code03_Meteors4.java   | 2 +-
 6 files changed, 9 insertions(+), 6 deletions(-)

diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index 98d0f010a..1e40503a4 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -99,8 +99,9 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			compute(ql, ql + lsiz - 1, vl, mid);
+			// 先右后左
 			compute(ql + lsiz, qr, mid + 1, vr);
+			compute(ql, ql + lsiz - 1, vl, mid);
 		}
 	}
 
diff --git a/src/class168/Code01_RangeKth4.java b/src/class168/Code01_RangeKth4.java
index b869d9fc4..dd0bf1f8d 100644
--- a/src/class168/Code01_RangeKth4.java
+++ b/src/class168/Code01_RangeKth4.java
@@ -99,8 +99,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
 //        compute(ql + lsiz, qr, mid + 1, vr);
+//        compute(ql, ql + lsiz - 1, vl, mid);
 //    }
 //}
 //
diff --git a/src/class168/Code02_MatrixKth2.java b/src/class168/Code02_MatrixKth2.java
index e7f749dbe..20dc6e7a8 100644
--- a/src/class168/Code02_MatrixKth2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -108,8 +108,9 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			compute(ql, ql + lsiz - 1, vl, mid);
+			// 先右后左
 			compute(ql + lsiz, qr, mid + 1, vr);
+			compute(ql, ql + lsiz - 1, vl, mid);
 		}
 	}
 
diff --git a/src/class168/Code02_MatrixKth4.java b/src/class168/Code02_MatrixKth4.java
index 329b5b61b..344259cd2 100644
--- a/src/class168/Code02_MatrixKth4.java
+++ b/src/class168/Code02_MatrixKth4.java
@@ -105,8 +105,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
 //        compute(ql + lsiz, qr, mid + 1, vr);
+//        compute(ql, ql + lsiz - 1, vl, mid);
 //    }
 //}
 //
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code03_Meteors2.java
index 1b25d9408..0eb9db33d 100644
--- a/src/class168/Code03_Meteors2.java
+++ b/src/class168/Code03_Meteors2.java
@@ -117,8 +117,9 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			compute(ql, ql + lsiz - 1, vl, mid);
+			// 先右后左
 			compute(ql + lsiz, qr, mid + 1, vr);
+			compute(ql, ql + lsiz - 1, vl, mid);
 		}
 	}
 
diff --git a/src/class168/Code03_Meteors4.java b/src/class168/Code03_Meteors4.java
index 5353778a0..868277333 100644
--- a/src/class168/Code03_Meteors4.java
+++ b/src/class168/Code03_Meteors4.java
@@ -111,8 +111,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
 //        compute(ql + lsiz, qr, mid + 1, vr);
+//        compute(ql, ql + lsiz - 1, vl, mid);
 //    }
 //}
 //

From 04d6fe1c8989cb92e76449a5f0026ff91eabecdf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 12:22:38 +0800
Subject: [PATCH 0815/1712] modify code

---
 src/class168/Code01_RangeKth2.java  |  6 +-----
 src/class168/Code02_MatrixKth2.java | 11 ++---------
 src/class168/Code02_MatrixKth4.java |  2 +-
 src/class168/Code03_Meteors2.java   |  1 +
 4 files changed, 5 insertions(+), 15 deletions(-)

diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index 1e40503a4..011579bc7 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -21,24 +21,20 @@ public class Code01_RangeKth2 {
 	public static int INF = 1000000001;
 	public static int n, m;
 
-	// 位置i，数值v
 	public static int[][] arr = new int[MAXN][2];
 
-	// 查询
 	public static int[] qid = new int[MAXN];
 	public static int[] l = new int[MAXN];
 	public static int[] r = new int[MAXN];
 	public static int[] k = new int[MAXN];
 
-	// 树状数组
 	public static int[] tree = new int[MAXN];
+	// 操作使用的数量
 	public static int used = 0;
 
-	// 整体二分
 	public static int[] lset = new int[MAXN];
 	public static int[] rset = new int[MAXN];
 
-	// 查询的答案
 	public static int[] ans = new int[MAXN];
 
 	public static int lowbit(int i) {
diff --git a/src/class168/Code02_MatrixKth2.java b/src/class168/Code02_MatrixKth2.java
index 20dc6e7a8..8aa39ae66 100644
--- a/src/class168/Code02_MatrixKth2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -22,30 +22,23 @@ public class Code02_MatrixKth2 {
 	public static int INF = 1000000001;
 	public static int n, q;
 
-	// 矩阵中的每个数字，所在行x、所在列y、数值v
 	public static int[][] xyv = new int[MAXN * MAXN][3];
 	public static int cntv = 0;
-	public static int used = 0;
 
-	// 查询任务的编号
 	public static int[] qid = new int[MAXQ];
-	// 查询范围的左上角坐标
 	public static int[] a = new int[MAXQ];
 	public static int[] b = new int[MAXQ];
-	// 查询范围的右下角坐标
 	public static int[] c = new int[MAXQ];
 	public static int[] d = new int[MAXQ];
-	// 查询任务的第几小值
 	public static int[] k = new int[MAXQ];
 
-	// 二维树状数组
 	public static int[][] tree = new int[MAXN][MAXN];
+	// 操作使用的数量
+	public static int used = 0;
 
-	// 整体二分
 	public static int[] lset = new int[MAXQ];
 	public static int[] rset = new int[MAXQ];
 
-	// 每条查询的答案
 	public static int[] ans = new int[MAXQ];
 
 	public static int lowbit(int i) {
diff --git a/src/class168/Code02_MatrixKth4.java b/src/class168/Code02_MatrixKth4.java
index 344259cd2..3b530c101 100644
--- a/src/class168/Code02_MatrixKth4.java
+++ b/src/class168/Code02_MatrixKth4.java
@@ -29,7 +29,6 @@
 //
 //Number xyv[MAXN * MAXN];
 //int cntv = 0;
-//int used = 0;
 //
 //int qid[MAXQ];
 //int a[MAXQ];
@@ -39,6 +38,7 @@
 //int k[MAXQ];
 //
 //int tree[MAXN][MAXN];
+//int used = 0;
 //
 //int lset[MAXQ];
 //int rset[MAXQ];
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code03_Meteors2.java
index 0eb9db33d..183eb2cbd 100644
--- a/src/class168/Code03_Meteors2.java
+++ b/src/class168/Code03_Meteors2.java
@@ -38,6 +38,7 @@ public class Code03_Meteors2 {
 	public static int cnt = 0;
 
 	public static long[] tree = new long[MAXN << 1];
+	// 操作使用的数量
 	public static int used = 0;
 
 	public static int[] lset = new int[MAXN];

From 987ee2a34de153e2c019c1cafa446157ad5edf28 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 12:26:19 +0800
Subject: [PATCH 0816/1712] modify code

---
 src/class168/Code01_RangeKth1.java | 2 +-
 src/class168/Code01_RangeKth2.java | 2 +-
 src/class168/Code01_RangeKth3.java | 2 +-
 src/class168/Code01_RangeKth4.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class168/Code01_RangeKth1.java b/src/class168/Code01_RangeKth1.java
index c457172ba..d4625a808 100644
--- a/src/class168/Code01_RangeKth1.java
+++ b/src/class168/Code01_RangeKth1.java
@@ -1,12 +1,12 @@
 package class168;
 
 // 区间内第k小，第一种写法，java版
-// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
 // 1 <= n、m <= 2 * 10^5
 // 1 <= 数组中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index 011579bc7..0d024bd6e 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -1,12 +1,12 @@
 package class168;
 
 // 区间内第k小，第二种写法，java版
-// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
 // 1 <= n、m <= 2 * 10^5
 // 1 <= 数组中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
diff --git a/src/class168/Code01_RangeKth3.java b/src/class168/Code01_RangeKth3.java
index dba9e5465..b80ce20a0 100644
--- a/src/class168/Code01_RangeKth3.java
+++ b/src/class168/Code01_RangeKth3.java
@@ -1,12 +1,12 @@
 package class168;
 
 // 区间内第k小，第一种写法，C++版
-// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
 // 1 <= n、m <= 2 * 10^5
 // 1 <= 数组中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
diff --git a/src/class168/Code01_RangeKth4.java b/src/class168/Code01_RangeKth4.java
index dd0bf1f8d..4ecd937ed 100644
--- a/src/class168/Code01_RangeKth4.java
+++ b/src/class168/Code01_RangeKth4.java
@@ -1,12 +1,12 @@
 package class168;
 
 // 区间内第k小，第二种写法，C++版
-// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 给定一个长度为n的数组，接下来有m条查询，格式如下
 // 查询 l r k : 打印[l..r]范围内第k小的值
 // 1 <= n、m <= 2 * 10^5
 // 1 <= 数组中的数字 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3834
+// 本题是讲解157，可持久化线段树模版题，现在作为整体二分的模版题
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 

From 6c2e8aa0e86bb9501a3bc3ceb88747c9c48dbc9c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 15:32:45 +0800
Subject: [PATCH 0817/1712] modify code

---
 src/class169/Code04_Network1.java | 47 ++++++++++++------------
 src/class169/Code04_Network2.java | 59 ++++++++++++++++---------------
 2 files changed, 55 insertions(+), 51 deletions(-)

diff --git a/src/class169/Code04_Network1.java b/src/class169/Code04_Network1.java
index 8be1de6e4..ac3caf07f 100644
--- a/src/class169/Code04_Network1.java
+++ b/src/class169/Code04_Network1.java
@@ -44,16 +44,17 @@ public class Code04_Network1 {
 
 	// 从早到晚发生的事件，op、x、y、v
 	// op == 0，添加点x到点y，重要度为v的路径
-	// op == -1，删除点x到点y，重要度为v的路径
-	// op > 0，那么op表示问题的编号，查询和x相关的答案
+	// op == 1，删除点x到点y，重要度为v的路径
+	// op == 2，查询和x相关的答案，y表示问题的编号
 	public static int[][] event = new int[MAXM][4];
+	// 查询问题的数量
+	public static int cntq = 0;
 
 	// 整体二分
 	public static int[][] lset = new int[MAXM][4];
 	public static int[][] rset = new int[MAXM][4];
 
 	public static int[] ans = new int[MAXM];
-	public static int cntans = 0;
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
@@ -201,8 +202,8 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = ql; i <= qr; i++) {
-				if (event[i][0] > 0) {
-					ans[event[i][0]] = vl;
+				if (event[i][0] == 2) {
+					ans[event[i][2]] = vl;
 				}
 			}
 		} else {
@@ -210,26 +211,27 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			int lsize = 0, rsize = 0, request = 0;
 			for (int i = ql; i <= qr; i++) {
 				if (event[i][0] == 0) {
-					if (event[i][3] > mid) {
+					if (event[i][3] <= mid) {
+						clone(lset[++lsize], event[i]);
+					} else {
 						pathAdd(event[i][1], event[i][2], 1);
-						clone(rset[++rsize], event[i]);
 						request++;
-					} else {
-						clone(lset[++lsize], event[i]);
+						clone(rset[++rsize], event[i]);
+
 					}
-				} else if (event[i][0] == -1) {
-					if (event[i][3] > mid) {
+				} else if (event[i][0] == 1) {
+					if (event[i][3] <= mid) {
+						clone(lset[++lsize], event[i]);
+					} else {
 						pathAdd(event[i][1], event[i][2], -1);
-						clone(rset[++rsize], event[i]);
 						request--;
-					} else {
-						clone(lset[++lsize], event[i]);
+						clone(rset[++rsize], event[i]);
 					}
 				} else {
-					if (pointQuery(event[i][1]) != request) {
-						clone(rset[++rsize], event[i]);
-					} else {
+					if (pointQuery(event[i][1]) == request) {
 						clone(lset[++lsize], event[i]);
+					} else {
+						clone(rset[++rsize], event[i]);
 					}
 				}
 			}
@@ -237,7 +239,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 				if (rset[i][0] == 0 && rset[i][3] > mid) {
 					pathAdd(rset[i][1], rset[i][2], -1);
 				}
-				if (rset[i][0] == -1 && rset[i][3] > mid) {
+				if (rset[i][0] == 1 && rset[i][3] > mid) {
 					pathAdd(rset[i][1], rset[i][2], 1);
 				}
 			}
@@ -257,9 +259,10 @@ public static void prepare() {
 		for (int i = 1; i <= m; i++) {
 			if (event[i][0] == 1) {
 				clone(event[i], event[event[i][1]]);
-				event[i][0] = -1;
-			} else if (event[i][0] == 2) {
-				event[i][0] = ++cntans;
+				event[i][0] = 1;
+			}
+			if (event[i][0] == 2) {
+				event[i][2] = ++cntq;
 			}
 		}
 	}
@@ -285,7 +288,7 @@ public static void main(String[] args) throws IOException {
 		}
 		prepare();
 		compute(1, m, 0, INF);
-		for (int i = 1; i <= cntans; i++) {
+		for (int i = 1; i <= cntq; i++) {
 			if (ans[i] == 0) {
 				out.println(-1);
 			} else {
diff --git a/src/class169/Code04_Network2.java b/src/class169/Code04_Network2.java
index ea4b11131..26c91f39a 100644
--- a/src/class169/Code04_Network2.java
+++ b/src/class169/Code04_Network2.java
@@ -42,12 +42,12 @@
 //int tree[MAXN];
 //
 //Event event[MAXM];
+//int cntq = 0;
 //
 //Event lset[MAXM];
 //Event rset[MAXM];
 //
 //int ans[MAXM];
-//int cntans = 0;
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
@@ -128,26 +128,14 @@
 //    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 //}
 //
-//void prepare() {
-//    dfs(1, 0);
-//    for (int i = 1; i <= m; i++) {
-//        if (event[i].op == 1) {
-//            event[i] = event[event[i].x];
-//            event[i].op = -1;
-//        } else if (event[i].op == 2){
-//            event[i].op = ++cntans;
-//        }
-//    }
-//}
-//
 //void compute(int ql, int qr, int vl, int vr) {
 //    if (ql > qr) {
 //        return;
 //    }
 //    if (vl == vr) {
 //        for (int i = ql; i <= qr; i++) {
-//            if (event[i].op > 0) {
-//                ans[event[i].op] = vl;
+//            if (event[i].op == 2) {
+//                ans[event[i].y] = vl;
 //            }
 //        }
 //    } else {
@@ -155,26 +143,26 @@
 //        int lsiz = 0, rsiz = 0, request = 0;
 //        for (int i = ql; i <= qr; i++) {
 //            if (event[i].op == 0) {
-//                if (event[i].v > mid) {
+//                if (event[i].v <= mid) {
+//                    lset[++lsiz] = event[i];
+//                } else {
 //                    pathAdd(event[i].x, event[i].y, 1);
-//                    rset[++rsiz] = event[i];
 //                    request++;
-//                } else {
-//                    lset[++lsiz] = event[i];
+//                    rset[++rsiz] = event[i];
 //                }
-//            } else if (event[i].op == -1) {
-//                if (event[i].v > mid) {
+//            } else if (event[i].op == 1) {
+//                if (event[i].v <= mid) {
+//                    lset[++lsiz] = event[i];
+//                } else {
 //                    pathAdd(event[i].x, event[i].y, -1);
-//                    rset[++rsiz] = event[i];
 //                    request--;
-//                } else {
-//                    lset[++lsiz] = event[i];
+//                    rset[++rsiz] = event[i];
 //                }
 //            } else {
-//                if (pointQuery(event[i].x) != request) {
-//                    rset[++rsiz] = event[i];
-//                } else {
+//                if (pointQuery(event[i].x) == request) {
 //                    lset[++lsiz] = event[i];
+//                } else {
+//                    rset[++rsiz] = event[i];
 //                }
 //            }
 //        }
@@ -182,7 +170,7 @@
 //            if (rset[i].op == 0 && rset[i].v > mid) {
 //                pathAdd(rset[i].x, rset[i].y, -1);
 //            }
-//            if (rset[i].op == -1 && rset[i].v > mid) {
+//            if (rset[i].op == 1 && rset[i].v > mid) {
 //                pathAdd(rset[i].x, rset[i].y, 1);
 //            }
 //        }
@@ -197,6 +185,19 @@
 //    }
 //}
 //
+//void prepare() {
+//    dfs(1, 0);
+//    for (int i = 1; i <= m; i++) {
+//        if (event[i].op == 1) {
+//            event[i] = event[event[i].x];
+//            event[i].op = 1;
+//        }
+//        if (event[i].op == 2){
+//            event[i].y = ++cntq;
+//        }
+//    }
+//}
+//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
@@ -214,7 +215,7 @@
 //    }
 //    prepare();
 //    compute(1, m, 0, INF);
-//    for (int i = 1; i <= cntans; i++) {
+//    for (int i = 1; i <= cntq; i++) {
 //        if (ans[i] == 0) {
 //            cout << -1 << '\n';
 //        } else {

From a753a6049733ecb2cc666a50a5525d02437ddd8e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 15:38:06 +0800
Subject: [PATCH 0818/1712] modify code

---
 src/class168/Code02_MatrixKth1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class168/Code02_MatrixKth1.java b/src/class168/Code02_MatrixKth1.java
index a183d7247..bc4d2a6bc 100644
--- a/src/class168/Code02_MatrixKth1.java
+++ b/src/class168/Code02_MatrixKth1.java
@@ -33,7 +33,7 @@ public class Code02_MatrixKth1 {
 	// 查询范围的右下角坐标
 	public static int[] c = new int[MAXQ];
 	public static int[] d = new int[MAXQ];
-	// 查询任务的第几小值
+	// 查询矩阵内第k小
 	public static int[] k = new int[MAXQ];
 
 	// 二维树状数组

From b73283250cd64ba6bba86192b2b97d5d74516617 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 16:34:59 +0800
Subject: [PATCH 0819/1712] modify code

---
 src/class168/Code01_RangeKth2.java | 9 ++++-----
 src/class168/Code01_RangeKth4.java | 9 ++++-----
 2 files changed, 8 insertions(+), 10 deletions(-)

diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index 0d024bd6e..f74c20c68 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -18,7 +18,6 @@
 public class Code01_RangeKth2 {
 
 	public static int MAXN = 200001;
-	public static int INF = 1000000001;
 	public static int n, m;
 
 	public static int[][] arr = new int[MAXN][2];
@@ -67,15 +66,15 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = ql; i <= qr; i++) {
-				ans[qid[i]] = vl;
+				ans[qid[i]] = arr[vl][1];
 			}
 		} else {
 			int mid = (vl + vr) / 2;
-			while (used + 1 <= n && arr[used + 1][1] <= mid) {
+			while (used + 1 <= mid) {
 				used++;
 				add(arr[used][0], 1);
 			}
-			while (used >= 1 && arr[used][1] > mid) {
+			while (used > mid) {
 				add(arr[used][0], -1);
 				used--;
 			}
@@ -117,7 +116,7 @@ public static void main(String[] args) throws Exception {
 			k[i] = in.nextInt();
 		}
 		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] - b[1]);
-		compute(1, m, 0, INF);
+		compute(1, m, 1, n);
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class168/Code01_RangeKth4.java b/src/class168/Code01_RangeKth4.java
index 4ecd937ed..df66d4e86 100644
--- a/src/class168/Code01_RangeKth4.java
+++ b/src/class168/Code01_RangeKth4.java
@@ -23,7 +23,6 @@
 //}
 //
 //const int MAXN = 200001;
-//const int INF = 1000000001;
 //int n, m;
 //
 //Number arr[MAXN];
@@ -71,15 +70,15 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = ql; i <= qr; i++) {
-//            ans[qid[i]] = vl;
+//            ans[qid[i]] = arr[vl].v;
 //        }
 //    } else {
 //        int mid = (vl + vr) / 2;
-//        while (used + 1 <= n && arr[used + 1].v <= mid) {
+//        while (used + 1 <= mid) {
 //            used++;
 //            add(arr[used].i, 1);
 //        }
-//        while (used >= 1 && arr[used].v > mid) {
+//        while (used > mid) {
 //            add(arr[used].i, -1);
 //            used--;
 //        }
@@ -117,7 +116,7 @@
 //        cin >> l[i] >> r[i] >> k[i];
 //    }
 //    sort(arr + 1, arr + n + 1, NumberCmp);
-//    compute(1, m, 0, INF);
+//    compute(1, m, 1, n);
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';
 //    }

From 58531babb5dbe330ea639f364ef89fe50eb22451 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 16:40:43 +0800
Subject: [PATCH 0820/1712] modify code

---
 src/class168/Code01_RangeKth2.java  | 2 +-
 src/class168/Code01_RangeKth4.java  | 2 +-
 src/class168/Code02_MatrixKth2.java | 9 ++++-----
 src/class168/Code02_MatrixKth4.java | 9 ++++-----
 4 files changed, 10 insertions(+), 12 deletions(-)

diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index f74c20c68..c24230c02 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -70,7 +70,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			}
 		} else {
 			int mid = (vl + vr) / 2;
-			while (used + 1 <= mid) {
+			while (used < mid) {
 				used++;
 				add(arr[used][0], 1);
 			}
diff --git a/src/class168/Code01_RangeKth4.java b/src/class168/Code01_RangeKth4.java
index df66d4e86..1c055ad23 100644
--- a/src/class168/Code01_RangeKth4.java
+++ b/src/class168/Code01_RangeKth4.java
@@ -74,7 +74,7 @@
 //        }
 //    } else {
 //        int mid = (vl + vr) / 2;
-//        while (used + 1 <= mid) {
+//        while (used < mid) {
 //            used++;
 //            add(arr[used].i, 1);
 //        }
diff --git a/src/class168/Code02_MatrixKth2.java b/src/class168/Code02_MatrixKth2.java
index 8aa39ae66..fcd096a58 100644
--- a/src/class168/Code02_MatrixKth2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -19,7 +19,6 @@ public class Code02_MatrixKth2 {
 
 	public static int MAXN = 501;
 	public static int MAXQ = 1000001;
-	public static int INF = 1000000001;
 	public static int n, q;
 
 	public static int[][] xyv = new int[MAXN * MAXN][3];
@@ -73,16 +72,16 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = ql; i <= qr; i++) {
-				ans[qid[i]] = vl;
+				ans[qid[i]] = xyv[vl][2];
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
 			int lsiz = 0, rsiz = 0;
-			while (used + 1 <= cntv && xyv[used + 1][2] <= mid) {
+			while (used < mid) {
 				used++;
 				add(xyv[used][0], xyv[used][1], 1);
 			}
-			while (used >= 1 && xyv[used][2] > mid) {
+			while (used > mid) {
 				add(xyv[used][0], xyv[used][1], -1);
 				used--;
 			}
@@ -128,7 +127,7 @@ public static void main(String[] args) throws Exception {
 			k[i] = in.nextInt();
 		}
 		Arrays.sort(xyv, 1, cntv + 1, (a, b) -> a[2] - b[2]);
-		compute(1, q, 0, INF);
+		compute(1, q, 1, cntv);
 		for (int i = 1; i <= q; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class168/Code02_MatrixKth4.java b/src/class168/Code02_MatrixKth4.java
index 3b530c101..8dd693ef3 100644
--- a/src/class168/Code02_MatrixKth4.java
+++ b/src/class168/Code02_MatrixKth4.java
@@ -24,7 +24,6 @@
 //
 //const int MAXN = 501;
 //const int MAXQ = 1000001;
-//const int INF  = 1000000001;
 //int n, q;
 //
 //Number xyv[MAXN * MAXN];
@@ -77,16 +76,16 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = ql; i <= qr; i++) {
-//            ans[qid[i]] = vl;
+//            ans[qid[i]] = xyv[vl].v;
 //        }
 //    } else {
 //        int mid = (vl + vr) >> 1;
 //        int lsiz = 0, rsiz = 0;
-//        while (used + 1 <= cntv && xyv[used + 1].v <= mid) {
+//        while (used < mid) {
 //            used++;
 //            add(xyv[used].x, xyv[used].y, 1);
 //        }
-//        while (used >= 1 && xyv[used].v > mid) {
+//        while (used > mid) {
 //            add(xyv[used].x, xyv[used].y, -1);
 //            used--;
 //        }
@@ -126,7 +125,7 @@
 //        cin >> a[i] >> b[i] >> c[i] >> d[i] >> k[i];
 //    }
 //    sort(xyv + 1, xyv + cntv + 1, NumberCmp);
-//    compute(1, q, 0, INF);
+//    compute(1, q, 1, cntv);
 //    for (int i = 1; i <= q; i++) {
 //        cout << ans[i] << '\n';
 //    }

From 2250e4e49b35f0e6c6726f2c27d4e129f019710f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 16:47:47 +0800
Subject: [PATCH 0821/1712] modify code

---
 src/class169/Code01_Juice1.java | 3 ++-
 src/class169/Code01_Juice2.java | 2 +-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class169/Code01_Juice1.java b/src/class169/Code01_Juice1.java
index 36209772d..b43325071 100644
--- a/src/class169/Code01_Juice1.java
+++ b/src/class169/Code01_Juice1.java
@@ -113,8 +113,9 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			compute(ql, ql + lsiz - 1, vl, mid);
+			// 先右后左
 			compute(ql + lsiz, qr, mid + 1, vr);
+			compute(ql, ql + lsiz - 1, vl, mid);
 		}
 	}
 
diff --git a/src/class169/Code01_Juice2.java b/src/class169/Code01_Juice2.java
index ba7207068..a9162a17c 100644
--- a/src/class169/Code01_Juice2.java
+++ b/src/class169/Code01_Juice2.java
@@ -106,8 +106,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
 //        compute(ql + lsiz, qr, mid + 1, vr);
+//        compute(ql, ql + lsiz - 1, vl, mid);
 //    }
 //}
 //

From 9297daec87a1b425e640224e3499b60dae35baeb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 19:33:18 +0800
Subject: [PATCH 0822/1712] modify code

---
 src/class168/Code01_RangeKth1.java | 6 ++++++
 src/class168/Code01_RangeKth2.java | 1 +
 2 files changed, 7 insertions(+)

diff --git a/src/class168/Code01_RangeKth1.java b/src/class168/Code01_RangeKth1.java
index d4625a808..6b1ecaf07 100644
--- a/src/class168/Code01_RangeKth1.java
+++ b/src/class168/Code01_RangeKth1.java
@@ -39,10 +39,12 @@ public class Code01_RangeKth1 {
 	// 查询的答案
 	public static int[] ans = new int[MAXN];
 
+	// 树状数组中的lowbit
 	public static int lowbit(int i) {
 		return i & -i;
 	}
 
+	// 树状数组中增加i位置的词频
 	public static void add(int i, int v) {
 		while (i <= n) {
 			tree[i] += v;
@@ -50,6 +52,7 @@ public static void add(int i, int v) {
 		}
 	}
 
+	// 树状数组中查询[1~i]范围的词频累加和
 	public static int sum(int i) {
 		int ret = 0;
 		while (i > 0) {
@@ -59,10 +62,13 @@ public static int sum(int i) {
 		return ret;
 	}
 
+	// 树状数组中查询[l~r]范围的词频累加和
 	public static int query(int l, int r) {
 		return sum(r) - sum(l - 1);
 	}
 
+	// 整体二分的第一种写法
+	// 问题范围[ql..qr]，答案范围[vl..vr]，答案范围的每个下标都是数字的排名
 	public static void compute(int ql, int qr, int vl, int vr) {
 		if (ql > qr) {
 			return;
diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index c24230c02..3a2fed440 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -60,6 +60,7 @@ public static int query(int l, int r) {
 		return sum(r) - sum(l - 1);
 	}
 
+	// 整体二分的第二种写法
 	public static void compute(int ql, int qr, int vl, int vr) {
 		if (ql > qr) {
 			return;

From e2d8cabc7e4bd9f07b904342bddb4cb4a23250db Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 19:34:31 +0800
Subject: [PATCH 0823/1712] modify code

---
 src/class168/Code01_RangeKth2.java  | 2 +-
 src/class168/Code02_MatrixKth2.java | 2 +-
 src/class168/Code03_Meteors2.java   | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index 3a2fed440..c0ef0fbca 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -28,7 +28,7 @@ public class Code01_RangeKth2 {
 	public static int[] k = new int[MAXN];
 
 	public static int[] tree = new int[MAXN];
-	// 操作使用的数量
+	// 数据的使用数量
 	public static int used = 0;
 
 	public static int[] lset = new int[MAXN];
diff --git a/src/class168/Code02_MatrixKth2.java b/src/class168/Code02_MatrixKth2.java
index fcd096a58..3ba82cacd 100644
--- a/src/class168/Code02_MatrixKth2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -32,7 +32,7 @@ public class Code02_MatrixKth2 {
 	public static int[] k = new int[MAXQ];
 
 	public static int[][] tree = new int[MAXN][MAXN];
-	// 操作使用的数量
+	// 数据的使用数量
 	public static int used = 0;
 
 	public static int[] lset = new int[MAXQ];
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code03_Meteors2.java
index 183eb2cbd..c8e249b38 100644
--- a/src/class168/Code03_Meteors2.java
+++ b/src/class168/Code03_Meteors2.java
@@ -38,7 +38,7 @@ public class Code03_Meteors2 {
 	public static int cnt = 0;
 
 	public static long[] tree = new long[MAXN << 1];
-	// 操作使用的数量
+	// 数据的使用数量
 	public static int used = 0;
 
 	public static int[] lset = new int[MAXN];

From 416a39bbcf42e36f313d7900fd6bf16f09763f09 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 20:24:33 +0800
Subject: [PATCH 0824/1712] modify code

---
 src/class168/Code01_RangeKth2.java  | 3 +--
 src/class168/Code01_RangeKth4.java  | 2 +-
 src/class168/Code02_MatrixKth2.java | 3 +--
 src/class168/Code02_MatrixKth4.java | 2 +-
 src/class168/Code03_Meteors2.java   | 3 +--
 src/class168/Code03_Meteors4.java   | 2 +-
 src/class169/Code01_Juice1.java     | 3 +--
 src/class169/Code01_Juice2.java     | 2 +-
 8 files changed, 8 insertions(+), 12 deletions(-)

diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index c0ef0fbca..77c2f7727 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -95,9 +95,8 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			// 先右后左
-			compute(ql + lsiz, qr, mid + 1, vr);
 			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
 		}
 	}
 
diff --git a/src/class168/Code01_RangeKth4.java b/src/class168/Code01_RangeKth4.java
index 1c055ad23..046158681 100644
--- a/src/class168/Code01_RangeKth4.java
+++ b/src/class168/Code01_RangeKth4.java
@@ -98,8 +98,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql + lsiz, qr, mid + 1, vr);
 //        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
 //    }
 //}
 //
diff --git a/src/class168/Code02_MatrixKth2.java b/src/class168/Code02_MatrixKth2.java
index 3ba82cacd..48ed9fd54 100644
--- a/src/class168/Code02_MatrixKth2.java
+++ b/src/class168/Code02_MatrixKth2.java
@@ -100,9 +100,8 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			// 先右后左
-			compute(ql + lsiz, qr, mid + 1, vr);
 			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
 		}
 	}
 
diff --git a/src/class168/Code02_MatrixKth4.java b/src/class168/Code02_MatrixKth4.java
index 8dd693ef3..9cc524ce5 100644
--- a/src/class168/Code02_MatrixKth4.java
+++ b/src/class168/Code02_MatrixKth4.java
@@ -104,8 +104,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql + lsiz, qr, mid + 1, vr);
 //        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
 //    }
 //}
 //
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code03_Meteors2.java
index c8e249b38..d823aa0fa 100644
--- a/src/class168/Code03_Meteors2.java
+++ b/src/class168/Code03_Meteors2.java
@@ -118,9 +118,8 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			// 先右后左
-			compute(ql + lsiz, qr, mid + 1, vr);
 			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
 		}
 	}
 
diff --git a/src/class168/Code03_Meteors4.java b/src/class168/Code03_Meteors4.java
index 868277333..5353778a0 100644
--- a/src/class168/Code03_Meteors4.java
+++ b/src/class168/Code03_Meteors4.java
@@ -111,8 +111,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql + lsiz, qr, mid + 1, vr);
 //        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
 //    }
 //}
 //
diff --git a/src/class169/Code01_Juice1.java b/src/class169/Code01_Juice1.java
index b43325071..36209772d 100644
--- a/src/class169/Code01_Juice1.java
+++ b/src/class169/Code01_Juice1.java
@@ -113,9 +113,8 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= rsiz; i++) {
 				qid[ql + lsiz + i - 1] = rset[i];
 			}
-			// 先右后左
-			compute(ql + lsiz, qr, mid + 1, vr);
 			compute(ql, ql + lsiz - 1, vl, mid);
+			compute(ql + lsiz, qr, mid + 1, vr);
 		}
 	}
 
diff --git a/src/class169/Code01_Juice2.java b/src/class169/Code01_Juice2.java
index a9162a17c..ba7207068 100644
--- a/src/class169/Code01_Juice2.java
+++ b/src/class169/Code01_Juice2.java
@@ -106,8 +106,8 @@
 //        for (int i = 1; i <= rsiz; i++) {
 //            qid[ql + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql + lsiz, qr, mid + 1, vr);
 //        compute(ql, ql + lsiz - 1, vl, mid);
+//        compute(ql + lsiz, qr, mid + 1, vr);
 //    }
 //}
 //

From 89f03e2cacabde5cf270f8218828024f56e3da5a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 20:28:38 +0800
Subject: [PATCH 0825/1712] modify code

---
 src/class168/Code01_RangeKth2.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class168/Code01_RangeKth2.java b/src/class168/Code01_RangeKth2.java
index 77c2f7727..088a3dfd5 100644
--- a/src/class168/Code01_RangeKth2.java
+++ b/src/class168/Code01_RangeKth2.java
@@ -71,10 +71,12 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			}
 		} else {
 			int mid = (vl + vr) / 2;
+			// 数据不够就叠加
 			while (used < mid) {
 				used++;
 				add(arr[used][0], 1);
 			}
+			// 数据超了就撤销
 			while (used > mid) {
 				add(arr[used][0], -1);
 				used--;

From fe0252540436dbcc649c38d582f45209f207c1b5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 21:19:56 +0800
Subject: [PATCH 0826/1712] modify code

---
 src/class168/Code02_MatrixKth1.java | 4 ++++
 src/class168/Code03_Meteors1.java   | 7 +++++++
 src/class168/Code03_Meteors2.java   | 2 +-
 3 files changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/class168/Code02_MatrixKth1.java b/src/class168/Code02_MatrixKth1.java
index bc4d2a6bc..76bdc6387 100644
--- a/src/class168/Code02_MatrixKth1.java
+++ b/src/class168/Code02_MatrixKth1.java
@@ -23,6 +23,7 @@ public class Code02_MatrixKth1 {
 
 	// 矩阵中的每个数字，所在行x、所在列y、数值v
 	public static int[][] xyv = new int[MAXN * MAXN][3];
+	// 矩阵中一共有多少个数字，cntv就是矩阵的规模
 	public static int cntv = 0;
 
 	// 查询任务的编号
@@ -50,6 +51,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
+	// 二维空间中，(x,y)位置的词频加v
 	public static void add(int x, int y, int v) {
 		for (int i = x; i <= n; i += lowbit(i)) {
 			for (int j = y; j <= n; j += lowbit(j)) {
@@ -58,6 +60,7 @@ public static void add(int x, int y, int v) {
 		}
 	}
 
+	// 二维空间中，左上角(1,1)到右下角(x,y)范围上的词频累加和
 	public static int sum(int x, int y) {
 		int ret = 0;
 		for (int i = x; i > 0; i -= lowbit(i)) {
@@ -68,6 +71,7 @@ public static int sum(int x, int y) {
 		return ret;
 	}
 
+	// 二维空间中，左上角(a,b)到右下角(c,d)范围上的词频累加和
 	public static int query(int a, int b, int c, int d) {
 		return sum(c, d) - sum(a - 1, d) - sum(c, b - 1) + sum(a - 1, b - 1);
 	}
diff --git a/src/class168/Code03_Meteors1.java b/src/class168/Code03_Meteors1.java
index 494feccc6..6cb1521a8 100644
--- a/src/class168/Code03_Meteors1.java
+++ b/src/class168/Code03_Meteors1.java
@@ -25,23 +25,30 @@ public class Code03_Meteors1 {
 	public static int MAXN = 300001;
 	public static int n, m, k;
 
+	// 国家编号
 	public static int[] qid = new int[MAXN];
+	// 国家的需求
 	public static int[] need = new int[MAXN];
 
+	// 陨石雨的参数
 	public static int[] rainl = new int[MAXN];
 	public static int[] rainr = new int[MAXN];
 	public static int[] num = new int[MAXN];
 
+	// 国家拥有的区域列表
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
 	public static int[] to = new int[MAXN];
 	public static int cnt = 0;
 
+	// 树状数组，支持范围修改、单点查询
 	public static long[] tree = new long[MAXN << 1];
 
+	// 整体二分
 	public static int[] lset = new int[MAXN];
 	public static int[] rset = new int[MAXN];
 
+	// 每个国家的答案
 	public static int[] ans = new int[MAXN];
 
 	public static void addEdge(int i, int v) {
diff --git a/src/class168/Code03_Meteors2.java b/src/class168/Code03_Meteors2.java
index d823aa0fa..95b7eb369 100644
--- a/src/class168/Code03_Meteors2.java
+++ b/src/class168/Code03_Meteors2.java
@@ -38,7 +38,7 @@ public class Code03_Meteors2 {
 	public static int cnt = 0;
 
 	public static long[] tree = new long[MAXN << 1];
-	// 数据的使用数量
+	// 下了多少场陨石雨
 	public static int used = 0;
 
 	public static int[] lset = new int[MAXN];

From 2050e2e6e8b4c773d30af220cff61c562252b62c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 16 May 2025 22:07:27 +0800
Subject: [PATCH 0827/1712] modify code

---
 ...3\344\272\214\345\210\206-\344\270\212.pptx" | Bin 0 -> 45995 bytes
 src/class168/Code03_Meteors1.java               |   1 +
 2 files changed, 1 insertion(+)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243168\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\212.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243168\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\212.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243168\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\212.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..6e3c91d83a203c62d828309a250d666b739789ad
GIT binary patch
literal 45995
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
G@BRXfulX1N

literal 0
HcmV?d00001

diff --git a/src/class168/Code03_Meteors1.java b/src/class168/Code03_Meteors1.java
index 6cb1521a8..b8bfaf6a8 100644
--- a/src/class168/Code03_Meteors1.java
+++ b/src/class168/Code03_Meteors1.java
@@ -149,6 +149,7 @@ public static void main(String[] args) throws Exception {
 			}
 			num[i] = in.nextInt();
 		}
+		// 答案范围[1..k+1]，第k+1场陨石雨认为满足不了要求
 		compute(1, n, 1, k + 1);
 		for (int i = 1; i <= n; i++) {
 			if (ans[i] == k + 1) {

From 70fdf771b3b1e53e7324aca423c5c30c87e5245c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 19 May 2025 21:23:44 +0800
Subject: [PATCH 0828/1712] modify code

---
 src/class169/Code04_Network1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class169/Code04_Network1.java b/src/class169/Code04_Network1.java
index ac3caf07f..9c2e1314c 100644
--- a/src/class169/Code04_Network1.java
+++ b/src/class169/Code04_Network1.java
@@ -217,7 +217,6 @@ public static void compute(int ql, int qr, int vl, int vr) {
 						pathAdd(event[i][1], event[i][2], 1);
 						request++;
 						clone(rset[++rsize], event[i]);
-
 					}
 				} else if (event[i][0] == 1) {
 					if (event[i][3] <= mid) {

From df000bb472d9136e6606b3f384eab7dc03230c2e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 19 May 2025 21:54:07 +0800
Subject: [PATCH 0829/1712] modify code

---
 src/class169/{Code04_Network1.java => Code03_Network1.java} | 2 +-
 src/class169/{Code04_Network2.java => Code03_Network2.java} | 0
 src/class169/{Code03_Fruit1.java => Code04_Fruit1.java}     | 2 +-
 src/class169/{Code03_Fruit2.java => Code04_Fruit2.java}     | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class169/{Code04_Network1.java => Code03_Network1.java} (99%)
 rename src/class169/{Code04_Network2.java => Code03_Network2.java} (100%)
 rename src/class169/{Code03_Fruit1.java => Code04_Fruit1.java} (99%)
 rename src/class169/{Code03_Fruit2.java => Code04_Fruit2.java} (100%)

diff --git a/src/class169/Code04_Network1.java b/src/class169/Code03_Network1.java
similarity index 99%
rename from src/class169/Code04_Network1.java
rename to src/class169/Code03_Network1.java
index 9c2e1314c..89174db4c 100644
--- a/src/class169/Code04_Network1.java
+++ b/src/class169/Code03_Network1.java
@@ -17,7 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_Network1 {
+public class Code03_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class169/Code04_Network2.java b/src/class169/Code03_Network2.java
similarity index 100%
rename from src/class169/Code04_Network2.java
rename to src/class169/Code03_Network2.java
diff --git a/src/class169/Code03_Fruit1.java b/src/class169/Code04_Fruit1.java
similarity index 99%
rename from src/class169/Code03_Fruit1.java
rename to src/class169/Code04_Fruit1.java
index db0f585eb..b5ecbe81d 100644
--- a/src/class169/Code03_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_Fruit1 {
+public class Code04_Fruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class169/Code03_Fruit2.java b/src/class169/Code04_Fruit2.java
similarity index 100%
rename from src/class169/Code03_Fruit2.java
rename to src/class169/Code04_Fruit2.java

From ba032faf06fdfc777569dc9efb7cefb3ad243461 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 19 May 2025 23:05:27 +0800
Subject: [PATCH 0830/1712] modify code

---
 src/class169/Code03_CrbQueries1.java          | 39 +++++++++++++++++++
 ...e03_Network1.java => Code04_Network1.java} | 18 ++++++---
 ...e03_Network2.java => Code04_Network2.java} | 16 +++++---
 ...{Code04_Fruit1.java => Code05_Fruit1.java} |  2 +-
 ...{Code04_Fruit2.java => Code05_Fruit2.java} |  0
 ...gers1.java => Code06_IvanAndBurgers1.java} |  2 +-
 ...gers2.java => Code06_IvanAndBurgers2.java} |  0
 7 files changed, 64 insertions(+), 13 deletions(-)
 create mode 100644 src/class169/Code03_CrbQueries1.java
 rename src/class169/{Code03_Network1.java => Code04_Network1.java} (97%)
 rename src/class169/{Code03_Network2.java => Code04_Network2.java} (96%)
 rename src/class169/{Code04_Fruit1.java => Code05_Fruit1.java} (99%)
 rename src/class169/{Code04_Fruit2.java => Code05_Fruit2.java} (100%)
 rename src/class169/{Code05_IvanAndBurgers1.java => Code06_IvanAndBurgers1.java} (99%)
 rename src/class169/{Code05_IvanAndBurgers2.java => Code06_IvanAndBurgers2.java} (100%)

diff --git a/src/class169/Code03_CrbQueries1.java b/src/class169/Code03_CrbQueries1.java
new file mode 100644
index 000000000..f199671dc
--- /dev/null
+++ b/src/class169/Code03_CrbQueries1.java
@@ -0,0 +1,39 @@
+package class169;
+
+// 动态查询第k小，java版
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5412
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code03_CrbQueries1 {
+
+	public static int MAXN = 100001;
+
+	public static int n;
+
+	public static int[] tree = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static int query(int l, int r) {
+		return sum(r) - sum(l - 1);
+	}
+
+}
diff --git a/src/class169/Code03_Network1.java b/src/class169/Code04_Network1.java
similarity index 97%
rename from src/class169/Code03_Network1.java
rename to src/class169/Code04_Network1.java
index 89174db4c..239d3c743 100644
--- a/src/class169/Code03_Network1.java
+++ b/src/class169/Code04_Network1.java
@@ -17,7 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_Network1 {
+public class Code04_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
@@ -160,18 +160,24 @@ public static int lca(int a, int b) {
 		return stjump[a][0];
 	}
 
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
 	public static void add(int i, int v) {
-		for (; i <= n; i += i & -i) {
+		while (i <= n) {
 			tree[i] += v;
+			i += lowbit(i);
 		}
 	}
 
 	public static int query(int i) {
-		int sum = 0;
-		for (; i > 0; i -= i & -i) {
-			sum += tree[i];
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
 		}
-		return sum;
+		return ret;
 	}
 
 	public static void pathAdd(int x, int y, int v) {
diff --git a/src/class169/Code03_Network2.java b/src/class169/Code04_Network2.java
similarity index 96%
rename from src/class169/Code03_Network2.java
rename to src/class169/Code04_Network2.java
index 26c91f39a..7f0c3e9d3 100644
--- a/src/class169/Code03_Network2.java
+++ b/src/class169/Code04_Network2.java
@@ -99,18 +99,24 @@
 //    return stjump[a][0];
 //}
 //
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
 //void add(int i, int v) {
-//    for (; i <= n; i += i & -i) {
+//    while (i <= n) {
 //        tree[i] += v;
+//        i += lowbit(i);
 //    }
 //}
 //
 //int query(int i) {
-//    int sum = 0;
-//    for (; i > 0; i -= i & -i) {
-//        sum += tree[i];
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
 //    }
-//    return sum;
+//    return ret;
 //}
 //
 //void pathAdd(int x, int y, int v) {
diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code05_Fruit1.java
similarity index 99%
rename from src/class169/Code04_Fruit1.java
rename to src/class169/Code05_Fruit1.java
index b5ecbe81d..433c37d16 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code05_Fruit1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_Fruit1 {
+public class Code05_Fruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class169/Code04_Fruit2.java b/src/class169/Code05_Fruit2.java
similarity index 100%
rename from src/class169/Code04_Fruit2.java
rename to src/class169/Code05_Fruit2.java
diff --git a/src/class169/Code05_IvanAndBurgers1.java b/src/class169/Code06_IvanAndBurgers1.java
similarity index 99%
rename from src/class169/Code05_IvanAndBurgers1.java
rename to src/class169/Code06_IvanAndBurgers1.java
index e1fffe19b..01b51188a 100644
--- a/src/class169/Code05_IvanAndBurgers1.java
+++ b/src/class169/Code06_IvanAndBurgers1.java
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_IvanAndBurgers1 {
+public class Code06_IvanAndBurgers1 {
 
 	public static int MAXN = 500001;
 	public static int BIT = 21;
diff --git a/src/class169/Code05_IvanAndBurgers2.java b/src/class169/Code06_IvanAndBurgers2.java
similarity index 100%
rename from src/class169/Code05_IvanAndBurgers2.java
rename to src/class169/Code06_IvanAndBurgers2.java

From eb62869eba97e55780855e70dddbcc1daa476b58 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 00:20:31 +0800
Subject: [PATCH 0831/1712] modify code

---
 src/class169/Code03_CrbQueries1.java | 147 ++++++++++++++++++++++++-
 src/class169/Code03_CrbQueries2.java | 153 +++++++++++++++++++++++++++
 2 files changed, 298 insertions(+), 2 deletions(-)
 create mode 100644 src/class169/Code03_CrbQueries2.java

diff --git a/src/class169/Code03_CrbQueries1.java b/src/class169/Code03_CrbQueries1.java
index f199671dc..81838bc14 100644
--- a/src/class169/Code03_CrbQueries1.java
+++ b/src/class169/Code03_CrbQueries1.java
@@ -1,17 +1,50 @@
 package class169;
 
-// 动态查询第k小，java版
+// 带修改的区间第k小，java版
+// 给定一个长度为n的数组arr，接下来是m条操作，每种操作是如下两种类型的一种
+// 操作 1 x y   : 把x位置的值修改成y
+// 操作 2 x y v : 查询arr[x..y]范围上第v小的值
+// 1 <= n、m <= 10^5
+// 1 <= 数组中的值 <= 10^9
 // 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5412
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+import java.util.Arrays;
+
 public class Code03_CrbQueries1 {
 
 	public static int MAXN = 100001;
+	public static int INF = 1000000001;
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
 
-	public static int n;
+	// 事件编号组成的数组
+	public static int[] eid = new int[MAXN << 2];
+	// op == 1，代表修改事件，x处，值y，效果v
+	// op == 2，代表查询事件，[x..y]范围上查询第v小，答案填入q位置
+	public static int[] op = new int[MAXN << 2];
+	public static int[] x = new int[MAXN << 2];
+	public static int[] y = new int[MAXN << 2];
+	public static int[] v = new int[MAXN << 2];
+	public static int[] q = new int[MAXN << 2];
 
+	// 树状数组
 	public static int[] tree = new int[MAXN];
 
+	// 整体二分
+	public static int[] lset = new int[MAXN << 2];
+	public static int[] rset = new int[MAXN << 2];
+
+	// 查询的答案
+	public static int[] ans = new int[MAXN];
+
 	public static int lowbit(int i) {
 		return i & -i;
 	}
@@ -36,4 +69,114 @@ public static int query(int l, int r) {
 		return sum(r) - sum(l - 1);
 	}
 
+	public static void compute(int el, int er, int vl, int vr) {
+		if (el > er) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = el; i <= er; i++) {
+				int id = eid[i];
+				if (op[id] == 2) {
+					ans[q[id]] = vl;
+				}
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			int lsiz = 0, rsiz = 0;
+			for (int i = el; i <= er; i++) {
+				int id = eid[i];
+				if (op[id] == 1) {
+					if (y[id] <= mid) {
+						add(x[id], v[id]);
+						lset[++lsiz] = id;
+					} else {
+						rset[++rsiz] = id;
+					}
+				} else {
+					int satisfy = query(x[id], y[id]);
+					if (v[id] <= satisfy) {
+						lset[++lsiz] = id;
+					} else {
+						v[id] -= satisfy;
+						rset[++rsiz] = id;
+					}
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				eid[el + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				eid[el + lsiz + i - 1] = rset[i];
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				int id = lset[i];
+				if (op[id] == 1 && y[id] <= mid) {
+					add(x[id], -v[id]);
+				}
+			}
+			compute(el, el + lsiz - 1, vl, mid);
+			compute(el + lsiz, er, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			n = (int) in.nval;
+			Arrays.fill(tree, 1, n + 1, 0);
+			int eventCnt = 0;
+			for (int i = 1; i <= n; i++) {
+				in.nextToken();
+				arr[i] = (int) in.nval;
+				op[++eventCnt] = 1;
+				x[eventCnt] = i;
+				y[eventCnt] = arr[i];
+				v[eventCnt] = 1;
+			}
+			in.nextToken();
+			m = (int) in.nval;
+			int queryCnt = 0;
+			for (int i = 1; i <= m; i++) {
+				in.nextToken();
+				op[++eventCnt] = (int) in.nval;
+				if (op[eventCnt] == 1) {
+					in.nextToken();
+					int a = (int) in.nval;
+					in.nextToken();
+					int b = (int) in.nval;
+					// 前面的值取消
+					x[eventCnt] = a;
+					y[eventCnt] = arr[a];
+					v[eventCnt] = -1;
+					// 当前的值生效
+					op[++eventCnt] = 1;
+					x[eventCnt] = a;
+					y[eventCnt] = b;
+					v[eventCnt] = 1;
+					arr[a] = b;
+				} else {
+					in.nextToken();
+					x[eventCnt] = (int) in.nval;
+					in.nextToken();
+					y[eventCnt] = (int) in.nval;
+					in.nextToken();
+					v[eventCnt] = (int) in.nval;
+					q[eventCnt] = ++queryCnt;
+				}
+			}
+			for (int i = 1; i <= eventCnt; i++) {
+				eid[i] = i;
+			}
+			compute(1, eventCnt, 1, INF);
+			for (int i = 1; i <= queryCnt; i++) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
 }
diff --git a/src/class169/Code03_CrbQueries2.java b/src/class169/Code03_CrbQueries2.java
new file mode 100644
index 000000000..c142c38d6
--- /dev/null
+++ b/src/class169/Code03_CrbQueries2.java
@@ -0,0 +1,153 @@
+package class169;
+
+// 带修改的区间第k小，C++版
+// 给定一个长度为n的数组arr，接下来是m条操作，每种操作是如下两种类型的一种
+// 操作 1 x y   : 把x位置的值修改成y
+// 操作 2 x y v : 查询arr[x..y]范围上第v小的值
+// 1 <= n、m <= 10^5
+// 1 <= 数组中的值 <= 10^9
+// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5412
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int INF = 1000000001;
+//int n, m;
+//
+//int arr[MAXN];
+//
+//int eid[MAXN << 2];
+//int op[MAXN << 2];
+//int x[MAXN << 2];
+//int y[MAXN << 2];
+//int v[MAXN << 2];
+//int q[MAXN << 2];
+//
+//int tree[MAXN];
+//
+//int lset[MAXN << 2];
+//int rset[MAXN << 2];
+//
+//int ans[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= n) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//int query(int l, int r) {
+//    return sum(r) - sum(l - 1);
+//}
+//
+//void compute(int el, int er, int vl, int vr) {
+//    if (el > er) {
+//        return;
+//    }
+//    if (vl == vr) {
+//        for (int i = el; i <= er; i++) {
+//            int id = eid[i];
+//            if (op[id] == 2) {
+//                ans[q[id]] = vl;
+//            }
+//        }
+//    } else {
+//        int mid = (vl + vr) >> 1;
+//        int lsiz = 0, rsiz = 0;
+//        for (int i = el; i <= er; i++) {
+//            int id = eid[i];
+//            if (op[id] == 1) {
+//                if (y[id] <= mid) {
+//                    add(x[id], v[id]);
+//                    lset[++lsiz] = id;
+//                } else {
+//                    rset[++rsiz] = id;
+//                }
+//            } else {
+//                int satisfy = query(x[id], y[id]);
+//                if (v[id] <= satisfy) {
+//                    lset[++lsiz] = id;
+//                } else {
+//                    v[id] -= satisfy;
+//                    rset[++rsiz] = id;
+//                }
+//            }
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            eid[el + i - 1] = lset[i];
+//        }
+//        for (int i = 1; i <= rsiz; i++) {
+//            eid[el + lsiz + i - 1] = rset[i];
+//        }
+//        for (int i = 1; i <= lsiz; i++) {
+//            int id = lset[i];
+//            if (op[id] == 1 && y[id] <= mid) {
+//                add(x[id], -v[id]);
+//            }
+//        }
+//        compute(el, el + lsiz - 1, vl, mid);
+//        compute(el + lsiz, er, mid + 1, vr);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    while (cin >> n) {
+//        fill(tree + 1, tree + n + 1, 0);
+//        int eventCnt = 0;
+//        for (int i = 1; i <= n; i++) {
+//            cin >> arr[i];
+//            op[++eventCnt] = 1;
+//            x[eventCnt] = i;
+//            y[eventCnt] = arr[i];
+//            v[eventCnt] = 1;
+//        }
+//        cin >> m;
+//        int queryCnt = 0;
+//        for (int i = 1; i <= m; i++) {
+//            cin >> op[++eventCnt];
+//            if (op[eventCnt] == 1) {
+//                int a, b;
+//                cin >> a >> b;
+//                x[eventCnt] = a;
+//                y[eventCnt] = arr[a];
+//                v[eventCnt] = -1;
+//                op[++eventCnt] = 1;
+//                x[eventCnt] = a;
+//                y[eventCnt] = b;
+//                v[eventCnt] = 1;
+//                arr[a] = b;
+//            } else {
+//                cin >> x[eventCnt] >> y[eventCnt] >> v[eventCnt];
+//                q[eventCnt] = ++queryCnt;
+//            }
+//        }
+//        for (int i = 1; i <= eventCnt; i++) {
+//            eid[i] = i;
+//        }
+//        compute(1, eventCnt, 1, INF);
+//        for (int i = 1; i <= queryCnt; i++) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From e0ff0b1d59b9663f5bb9db696b503599fea55fdd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 00:59:22 +0800
Subject: [PATCH 0832/1712] modify code

---
 src/class169/Code03_CrbQueries1.java |   2 +-
 src/class169/Code04_Network1.java    | 120 ++++++++++++++-------------
 src/class169/Code04_Network2.java    | 100 ++++++++++++----------
 3 files changed, 117 insertions(+), 105 deletions(-)

diff --git a/src/class169/Code03_CrbQueries1.java b/src/class169/Code03_CrbQueries1.java
index 81838bc14..04c97ac70 100644
--- a/src/class169/Code03_CrbQueries1.java
+++ b/src/class169/Code03_CrbQueries1.java
@@ -28,7 +28,7 @@ public class Code03_CrbQueries1 {
 	// 事件编号组成的数组
 	public static int[] eid = new int[MAXN << 2];
 	// op == 1，代表修改事件，x处，值y，效果v
-	// op == 2，代表查询事件，[x..y]范围上查询第v小，答案填入q位置
+	// op == 2，代表查询事件，[x..y]范围上查询第v小，q表示问题的编号
 	public static int[] op = new int[MAXN << 2];
 	public static int[] x = new int[MAXN << 2];
 	public static int[] y = new int[MAXN << 2];
diff --git a/src/class169/Code04_Network1.java b/src/class169/Code04_Network1.java
index 239d3c743..8dd4afafa 100644
--- a/src/class169/Code04_Network1.java
+++ b/src/class169/Code04_Network1.java
@@ -42,17 +42,20 @@ public class Code04_Network1 {
 	// 树状数组
 	public static int[] tree = new int[MAXN];
 
-	// 从早到晚发生的事件，op、x、y、v
-	// op == 0，添加点x到点y，重要度为v的路径
-	// op == 1，删除点x到点y，重要度为v的路径
-	// op == 2，查询和x相关的答案，y表示问题的编号
-	public static int[][] event = new int[MAXM][4];
-	// 查询问题的数量
+	// 事件编号组成的数组
+	public static int[] eid = new int[MAXM];
+	// 如果op == 0，添加点x到点y，重要度为v的路径
+	// 如果op == 1，删除点x到点y，重要度为v的路径
+	// 如果op == 2，查询和x相关的答案，y表示问题的编号
+	public static int[] op = new int[MAXM];
+	public static int[] x = new int[MAXM];
+	public static int[] y = new int[MAXM];
+	public static int[] v = new int[MAXM];
 	public static int cntq = 0;
 
 	// 整体二分
-	public static int[][] lset = new int[MAXM][4];
-	public static int[][] rset = new int[MAXM][4];
+	public static int[] lset = new int[MAXM];
+	public static int[] rset = new int[MAXM];
 
 	public static int[] ans = new int[MAXM];
 
@@ -195,81 +198,82 @@ public static int pointQuery(int x) {
 		return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 	}
 
-	public static void clone(int[] event1, int[] event2) {
-		event1[0] = event2[0];
-		event1[1] = event2[1];
-		event1[2] = event2[2];
-		event1[3] = event2[3];
-	}
-
-	public static void compute(int ql, int qr, int vl, int vr) {
-		if (ql > qr) {
+	public static void compute(int el, int er, int vl, int vr) {
+		if (el > er) {
 			return;
 		}
 		if (vl == vr) {
-			for (int i = ql; i <= qr; i++) {
-				if (event[i][0] == 2) {
-					ans[event[i][2]] = vl;
+			for (int i = el; i <= er; i++) {
+				int id = eid[i];
+				if (op[id] == 2) {
+					ans[y[id]] = vl;
 				}
 			}
 		} else {
 			int mid = (vl + vr) / 2;
-			int lsize = 0, rsize = 0, request = 0;
-			for (int i = ql; i <= qr; i++) {
-				if (event[i][0] == 0) {
-					if (event[i][3] <= mid) {
-						clone(lset[++lsize], event[i]);
+			int lsiz = 0, rsiz = 0, request = 0;
+			for (int i = el; i <= er; i++) {
+				int id = eid[i];
+				if (op[id] == 0) {
+					if (v[id] <= mid) {
+						lset[++lsiz] = id;
 					} else {
-						pathAdd(event[i][1], event[i][2], 1);
+						pathAdd(x[id], y[id], 1);
 						request++;
-						clone(rset[++rsize], event[i]);
+						rset[++rsiz] = id;
 					}
-				} else if (event[i][0] == 1) {
-					if (event[i][3] <= mid) {
-						clone(lset[++lsize], event[i]);
+				} else if (op[id] == 1) {
+					if (v[id] <= mid) {
+						lset[++lsiz] = id;
 					} else {
-						pathAdd(event[i][1], event[i][2], -1);
+						pathAdd(x[id], y[id], -1);
 						request--;
-						clone(rset[++rsize], event[i]);
+						rset[++rsiz] = id;
 					}
 				} else {
-					if (pointQuery(event[i][1]) == request) {
-						clone(lset[++lsize], event[i]);
+					if (pointQuery(x[id]) == request) {
+						lset[++lsiz] = id;
 					} else {
-						clone(rset[++rsize], event[i]);
+						rset[++rsiz] = id;
 					}
 				}
 			}
-			for (int i = 1; i <= rsize; i++) {
-				if (rset[i][0] == 0 && rset[i][3] > mid) {
-					pathAdd(rset[i][1], rset[i][2], -1);
-				}
-				if (rset[i][0] == 1 && rset[i][3] > mid) {
-					pathAdd(rset[i][1], rset[i][2], 1);
-				}
+			for (int i = 1; i <= lsiz; i++) {
+				eid[el + i - 1] = lset[i];
 			}
-			for (int i = ql, j = 1; j <= lsize; i++, j++) {
-				clone(event[i], lset[j]);
+			for (int i = 1; i <= rsiz; i++) {
+				eid[el + lsiz + i - 1] = rset[i];
 			}
-			for (int i = ql + lsize, j = 1; j <= rsize; i++, j++) {
-				clone(event[i], rset[j]);
+			for (int i = 1; i <= rsiz; i++) {
+				int id = rset[i];
+				if (op[id] == 0 && v[id] > mid) {
+					pathAdd(x[id], y[id], -1);
+				}
+				if (op[id] == 1 && v[id] > mid) {
+					pathAdd(x[id], y[id], 1);
+				}
 			}
-			compute(ql, ql + lsize - 1, vl, mid);
-			compute(ql + lsize, qr, mid + 1, vr);
+			compute(el, el + lsiz - 1, vl, mid);
+			compute(el + lsiz, er, mid + 1, vr);
 		}
 	}
 
 	public static void prepare() {
 		dfs2();
 		for (int i = 1; i <= m; i++) {
-			if (event[i][0] == 1) {
-				clone(event[i], event[event[i][1]]);
-				event[i][0] = 1;
+			if (op[i] == 1) {
+				int pre = x[i];
+				x[i] = x[pre];
+				y[i] = y[pre];
+				v[i] = v[pre];
 			}
-			if (event[i][0] == 2) {
-				event[i][2] = ++cntq;
+			if (op[i] == 2) {
+				y[i] = ++cntq;
 			}
 		}
+		for (int i = 1; i <= m; i++) {
+			eid[i] = i;
+		}
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -284,11 +288,11 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		for (int i = 1; i <= m; i++) {
-			event[i][0] = in.nextInt();
-			event[i][1] = in.nextInt();
-			if (event[i][0] == 0) {
-				event[i][2] = in.nextInt();
-				event[i][3] = in.nextInt();
+			op[i] = in.nextInt();
+			x[i] = in.nextInt();
+			if (op[i] == 0) {
+				y[i] = in.nextInt();
+				v[i] = in.nextInt();
 			}
 		}
 		prepare();
diff --git a/src/class169/Code04_Network2.java b/src/class169/Code04_Network2.java
index 7f0c3e9d3..272271811 100644
--- a/src/class169/Code04_Network2.java
+++ b/src/class169/Code04_Network2.java
@@ -17,10 +17,6 @@
 //
 //using namespace std;
 //
-//struct Event {
-//    int op, x, y, v;
-//};
-//
 //const int MAXN = 100001;
 //const int MAXM = 200001;
 //const int MAXH = 20;
@@ -41,11 +37,15 @@
 //
 //int tree[MAXN];
 //
-//Event event[MAXM];
+//int eid[MAXM];
+//int op[MAXM];
+//int x[MAXM];
+//int y[MAXM];
+//int v[MAXM];
 //int cntq = 0;
 //
-//Event lset[MAXM];
-//Event rset[MAXM];
+//int lset[MAXM];
+//int rset[MAXM];
 //
 //int ans[MAXM];
 //
@@ -134,74 +134,82 @@
 //    return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 //}
 //
-//void compute(int ql, int qr, int vl, int vr) {
-//    if (ql > qr) {
+//void compute(int el, int er, int vl, int vr) {
+//    if (el > er) {
 //        return;
 //    }
 //    if (vl == vr) {
-//        for (int i = ql; i <= qr; i++) {
-//            if (event[i].op == 2) {
-//                ans[event[i].y] = vl;
+//        for (int i = el; i <= er; i++) {
+//            int id = eid[i];
+//            if (op[id] == 2) {
+//                ans[y[id]] = vl;
 //            }
 //        }
 //    } else {
 //        int mid = (vl + vr) / 2;
 //        int lsiz = 0, rsiz = 0, request = 0;
-//        for (int i = ql; i <= qr; i++) {
-//            if (event[i].op == 0) {
-//                if (event[i].v <= mid) {
-//                    lset[++lsiz] = event[i];
+//        for (int i = el; i <= er; i++) {
+//            int id = eid[i];
+//            if (op[id] == 0) {
+//                if (v[id] <= mid) {
+//                    lset[++lsiz] = id;
 //                } else {
-//                    pathAdd(event[i].x, event[i].y, 1);
+//                    pathAdd(x[id], y[id], 1);
 //                    request++;
-//                    rset[++rsiz] = event[i];
+//                    rset[++rsiz] = id;
 //                }
-//            } else if (event[i].op == 1) {
-//                if (event[i].v <= mid) {
-//                    lset[++lsiz] = event[i];
+//            } else if (op[id] == 1) {
+//                if (v[id] <= mid) {
+//                    lset[++lsiz] = id;
 //                } else {
-//                    pathAdd(event[i].x, event[i].y, -1);
+//                    pathAdd(x[id], y[id], -1);
 //                    request--;
-//                    rset[++rsiz] = event[i];
+//                    rset[++rsiz] = id;
 //                }
 //            } else {
-//                if (pointQuery(event[i].x) == request) {
-//                    lset[++lsiz] = event[i];
+//                if (pointQuery(x[id]) == request) {
+//                    lset[++lsiz] = id;
 //                } else {
-//                    rset[++rsiz] = event[i];
+//                    rset[++rsiz] = id;
 //                }
 //            }
 //        }
-//        for (int i = 1; i <= rsiz; i++) {
-//            if (rset[i].op == 0 && rset[i].v > mid) {
-//                pathAdd(rset[i].x, rset[i].y, -1);
-//            }
-//            if (rset[i].op == 1 && rset[i].v > mid) {
-//                pathAdd(rset[i].x, rset[i].y, 1);
-//            }
-//        }
 //        for (int i = 1; i <= lsiz; i++) {
-//            event[ql + i - 1] = lset[i];
+//            eid[el + i - 1] = lset[i];
 //        }
 //        for (int i = 1; i <= rsiz; i++) {
-//            event[ql + lsiz + i - 1] = rset[i];
+//            eid[el + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
-//        compute(ql + lsiz, qr, mid + 1, vr);
+//        for (int i = 1; i <= rsiz; i++) {
+//            int id = rset[i];
+//            if (op[id] == 0 && v[id] > mid) {
+//                pathAdd(x[id], y[id], -1);
+//            }
+//            if (op[id] == 1 && v[id] > mid) {
+//                pathAdd(x[id], y[id], 1);
+//            }
+//        }
+//        compute(el, el + lsiz - 1, vl, mid);
+//        compute(el + lsiz, er, mid + 1, vr);
 //    }
 //}
 //
 //void prepare() {
 //    dfs(1, 0);
 //    for (int i = 1; i <= m; i++) {
-//        if (event[i].op == 1) {
-//            event[i] = event[event[i].x];
-//            event[i].op = 1;
+//        if (op[i] == 1) {
+//            int pre = x[i];
+//            x[i] = x[pre];
+//            y[i] = y[pre];
+//            v[i] = v[pre];
 //        }
-//        if (event[i].op == 2){
-//            event[i].y = ++cntq;
+//        if (op[i] == 2) {
+//            y[i] = ++cntq;
 //        }
 //    }
+//    for (int i = 1; i <= m; i++) {
+//        eid[i] = i;
+//    }
 //}
 //
 //int main() {
@@ -214,9 +222,9 @@
 //        addEdge(v, u);
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> event[i].op >> event[i].x;
-//        if (event[i].op == 0) {
-//            cin >> event[i].y >> event[i].v;
+//        cin >> op[i] >> x[i];
+//        if (op[i] == 0) {
+//            cin >> y[i] >> v[i];
 //        }
 //    }
 //    prepare();

From f05fdcf4691f09282971cab62fba911c7ec16db2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 10:16:06 +0800
Subject: [PATCH 0833/1712] modify code

---
 src/class169/Code03_CrbQueries1.java          | 182 --------------
 src/class169/Code03_DynamicRankings1.java     | 233 ++++++++++++++++++
 ...ies2.java => Code03_DynamicRankings2.java} | 111 ++++-----
 3 files changed, 289 insertions(+), 237 deletions(-)
 delete mode 100644 src/class169/Code03_CrbQueries1.java
 create mode 100644 src/class169/Code03_DynamicRankings1.java
 rename src/class169/{Code03_CrbQueries2.java => Code03_DynamicRankings2.java} (60%)

diff --git a/src/class169/Code03_CrbQueries1.java b/src/class169/Code03_CrbQueries1.java
deleted file mode 100644
index 04c97ac70..000000000
--- a/src/class169/Code03_CrbQueries1.java
+++ /dev/null
@@ -1,182 +0,0 @@
-package class169;
-
-// 带修改的区间第k小，java版
-// 给定一个长度为n的数组arr，接下来是m条操作，每种操作是如下两种类型的一种
-// 操作 1 x y   : 把x位置的值修改成y
-// 操作 2 x y v : 查询arr[x..y]范围上第v小的值
-// 1 <= n、m <= 10^5
-// 1 <= 数组中的值 <= 10^9
-// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5412
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-import java.io.BufferedReader;
-import java.io.IOException;
-import java.io.InputStreamReader;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.io.StreamTokenizer;
-import java.util.Arrays;
-
-public class Code03_CrbQueries1 {
-
-	public static int MAXN = 100001;
-	public static int INF = 1000000001;
-	public static int n, m;
-
-	public static int[] arr = new int[MAXN];
-
-	// 事件编号组成的数组
-	public static int[] eid = new int[MAXN << 2];
-	// op == 1，代表修改事件，x处，值y，效果v
-	// op == 2，代表查询事件，[x..y]范围上查询第v小，q表示问题的编号
-	public static int[] op = new int[MAXN << 2];
-	public static int[] x = new int[MAXN << 2];
-	public static int[] y = new int[MAXN << 2];
-	public static int[] v = new int[MAXN << 2];
-	public static int[] q = new int[MAXN << 2];
-
-	// 树状数组
-	public static int[] tree = new int[MAXN];
-
-	// 整体二分
-	public static int[] lset = new int[MAXN << 2];
-	public static int[] rset = new int[MAXN << 2];
-
-	// 查询的答案
-	public static int[] ans = new int[MAXN];
-
-	public static int lowbit(int i) {
-		return i & -i;
-	}
-
-	public static void add(int i, int v) {
-		while (i <= n) {
-			tree[i] += v;
-			i += lowbit(i);
-		}
-	}
-
-	public static int sum(int i) {
-		int ret = 0;
-		while (i > 0) {
-			ret += tree[i];
-			i -= lowbit(i);
-		}
-		return ret;
-	}
-
-	public static int query(int l, int r) {
-		return sum(r) - sum(l - 1);
-	}
-
-	public static void compute(int el, int er, int vl, int vr) {
-		if (el > er) {
-			return;
-		}
-		if (vl == vr) {
-			for (int i = el; i <= er; i++) {
-				int id = eid[i];
-				if (op[id] == 2) {
-					ans[q[id]] = vl;
-				}
-			}
-		} else {
-			int mid = (vl + vr) >> 1;
-			int lsiz = 0, rsiz = 0;
-			for (int i = el; i <= er; i++) {
-				int id = eid[i];
-				if (op[id] == 1) {
-					if (y[id] <= mid) {
-						add(x[id], v[id]);
-						lset[++lsiz] = id;
-					} else {
-						rset[++rsiz] = id;
-					}
-				} else {
-					int satisfy = query(x[id], y[id]);
-					if (v[id] <= satisfy) {
-						lset[++lsiz] = id;
-					} else {
-						v[id] -= satisfy;
-						rset[++rsiz] = id;
-					}
-				}
-			}
-			for (int i = 1; i <= lsiz; i++) {
-				eid[el + i - 1] = lset[i];
-			}
-			for (int i = 1; i <= rsiz; i++) {
-				eid[el + lsiz + i - 1] = rset[i];
-			}
-			for (int i = 1; i <= lsiz; i++) {
-				int id = lset[i];
-				if (op[id] == 1 && y[id] <= mid) {
-					add(x[id], -v[id]);
-				}
-			}
-			compute(el, el + lsiz - 1, vl, mid);
-			compute(el + lsiz, er, mid + 1, vr);
-		}
-	}
-
-	public static void main(String[] args) throws IOException {
-		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
-		StreamTokenizer in = new StreamTokenizer(br);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		while (in.nextToken() != StreamTokenizer.TT_EOF) {
-			n = (int) in.nval;
-			Arrays.fill(tree, 1, n + 1, 0);
-			int eventCnt = 0;
-			for (int i = 1; i <= n; i++) {
-				in.nextToken();
-				arr[i] = (int) in.nval;
-				op[++eventCnt] = 1;
-				x[eventCnt] = i;
-				y[eventCnt] = arr[i];
-				v[eventCnt] = 1;
-			}
-			in.nextToken();
-			m = (int) in.nval;
-			int queryCnt = 0;
-			for (int i = 1; i <= m; i++) {
-				in.nextToken();
-				op[++eventCnt] = (int) in.nval;
-				if (op[eventCnt] == 1) {
-					in.nextToken();
-					int a = (int) in.nval;
-					in.nextToken();
-					int b = (int) in.nval;
-					// 前面的值取消
-					x[eventCnt] = a;
-					y[eventCnt] = arr[a];
-					v[eventCnt] = -1;
-					// 当前的值生效
-					op[++eventCnt] = 1;
-					x[eventCnt] = a;
-					y[eventCnt] = b;
-					v[eventCnt] = 1;
-					arr[a] = b;
-				} else {
-					in.nextToken();
-					x[eventCnt] = (int) in.nval;
-					in.nextToken();
-					y[eventCnt] = (int) in.nval;
-					in.nextToken();
-					v[eventCnt] = (int) in.nval;
-					q[eventCnt] = ++queryCnt;
-				}
-			}
-			for (int i = 1; i <= eventCnt; i++) {
-				eid[i] = i;
-			}
-			compute(1, eventCnt, 1, INF);
-			for (int i = 1; i <= queryCnt; i++) {
-				out.println(ans[i]);
-			}
-		}
-		out.flush();
-		out.close();
-		br.close();
-	}
-
-}
diff --git a/src/class169/Code03_DynamicRankings1.java b/src/class169/Code03_DynamicRankings1.java
new file mode 100644
index 000000000..339d8d1d3
--- /dev/null
+++ b/src/class169/Code03_DynamicRankings1.java
@@ -0,0 +1,233 @@
+package class169;
+
+// 带修改的区间第k小，java版
+// 给定一个长度为n的数组arr，接下来是m条操作，每种操作是如下两种类型的一种
+// 操作 Q x y v : 查询arr[x..y]范围上第v小的值
+// 操作 C x y   : 把x位置的值修改成y
+// 1 <= n、m <= 10^5
+// 1 <= 数组中的值 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P2617
+// 本题是讲解160，树套树模版题，现在作为带修改的整体二分模版题
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_DynamicRankings1 {
+
+	public static int MAXN = 100001;
+	public static int MAXE = MAXN << 2;
+	public static int INF = 1000000001;
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+
+	// 事件编号组成的数组
+	public static int[] eid = new int[MAXE];
+	// op == 1，代表查询事件，[x..y]范围上查询第v小，q表示问题的编号
+	// op == 2，代表修改事件，x处，值y，效果v
+	public static int[] op = new int[MAXE];
+	public static int[] x = new int[MAXE];
+	public static int[] y = new int[MAXE];
+	public static int[] v = new int[MAXE];
+	public static int[] q = new int[MAXE];
+	public static int cnte = 0;
+	public static int cntq = 0;
+
+	// 树状数组
+	public static int[] tree = new int[MAXN];
+
+	// 整体二分
+	public static int[] lset = new int[MAXE];
+	public static int[] rset = new int[MAXE];
+
+	// 查询的答案
+	public static int[] ans = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static int query(int l, int r) {
+		return sum(r) - sum(l - 1);
+	}
+
+	public static void compute(int el, int er, int vl, int vr) {
+		if (el > er) {
+			return;
+		}
+		if (vl == vr) {
+			for (int i = el; i <= er; i++) {
+				int id = eid[i];
+				if (op[id] == 1) {
+					ans[q[id]] = vl;
+				}
+			}
+		} else {
+			int mid = (vl + vr) >> 1;
+			int lsiz = 0, rsiz = 0;
+			for (int i = el; i <= er; i++) {
+				int id = eid[i];
+				if (op[id] == 1) {
+					int satisfy = query(x[id], y[id]);
+					if (v[id] <= satisfy) {
+						lset[++lsiz] = id;
+					} else {
+						v[id] -= satisfy;
+						rset[++rsiz] = id;
+					}
+				} else {
+					if (y[id] <= mid) {
+						add(x[id], v[id]);
+						lset[++lsiz] = id;
+					} else {
+						rset[++rsiz] = id;
+					}
+				}
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				eid[el + i - 1] = lset[i];
+			}
+			for (int i = 1; i <= rsiz; i++) {
+				eid[el + lsiz + i - 1] = rset[i];
+			}
+			for (int i = 1; i <= lsiz; i++) {
+				int id = lset[i];
+				if (op[id] == 2 && y[id] <= mid) {
+					add(x[id], -v[id]);
+				}
+			}
+			compute(el, el + lsiz - 1, vl, mid);
+			compute(el + lsiz, er, mid + 1, vr);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+			op[++cnte] = 2;
+			x[cnte] = i;
+			y[cnte] = arr[i];
+			v[cnte] = 1;
+		}
+		char type;
+		for (int i = 1; i <= m; i++) {
+			type = in.nextChar();
+			if (type == 'Q') {
+				op[++cnte] = 1;
+				x[cnte] = in.nextInt();
+				y[cnte] = in.nextInt();
+				v[cnte] = in.nextInt();
+				q[cnte] = ++cntq;
+			} else {
+				int a = in.nextInt();
+				int b = in.nextInt();
+				op[++cnte] = 2;
+				x[cnte] = a;
+				y[cnte] = arr[a];
+				v[cnte] = -1;
+				op[++cnte] = 2;
+				x[cnte] = a;
+				y[cnte] = b;
+				v[cnte] = 1;
+				arr[a] = b;
+			}
+		}
+		for (int i = 1; i <= cnte; i++) {
+			eid[i] = i;
+		}
+		compute(1, cnte, 0, INF);
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class169/Code03_CrbQueries2.java b/src/class169/Code03_DynamicRankings2.java
similarity index 60%
rename from src/class169/Code03_CrbQueries2.java
rename to src/class169/Code03_DynamicRankings2.java
index c142c38d6..df251c7ed 100644
--- a/src/class169/Code03_CrbQueries2.java
+++ b/src/class169/Code03_DynamicRankings2.java
@@ -2,11 +2,12 @@
 
 // 带修改的区间第k小，C++版
 // 给定一个长度为n的数组arr，接下来是m条操作，每种操作是如下两种类型的一种
-// 操作 1 x y   : 把x位置的值修改成y
-// 操作 2 x y v : 查询arr[x..y]范围上第v小的值
+// 操作 Q x y v : 查询arr[x..y]范围上第v小的值
+// 操作 C x y   : 把x位置的值修改成y
 // 1 <= n、m <= 10^5
 // 1 <= 数组中的值 <= 10^9
-// 测试链接 : https://acm.hdu.edu.cn/showproblem.php?pid=5412
+// 测试链接 : https://www.luogu.com.cn/problem/P2617
+// 本题是讲解160，树套树模版题，现在作为带修改的整体二分模版题
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
@@ -15,22 +16,24 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
+//const int MAXE = MAXN << 2;
 //const int INF = 1000000001;
 //int n, m;
 //
 //int arr[MAXN];
-//
-//int eid[MAXN << 2];
-//int op[MAXN << 2];
-//int x[MAXN << 2];
-//int y[MAXN << 2];
-//int v[MAXN << 2];
-//int q[MAXN << 2];
+//int eid[MAXE];
+//int op[MAXE];
+//int x[MAXE];
+//int y[MAXE];
+//int v[MAXE];
+//int q[MAXE];
+//int cnte = 0;
+//int cntq = 0;
 //
 //int tree[MAXN];
 //
-//int lset[MAXN << 2];
-//int rset[MAXN << 2];
+//int lset[MAXE];
+//int rset[MAXE];
 //
 //int ans[MAXN];
 //
@@ -65,7 +68,7 @@
 //    if (vl == vr) {
 //        for (int i = el; i <= er; i++) {
 //            int id = eid[i];
-//            if (op[id] == 2) {
+//            if (op[id] == 1) {
 //                ans[q[id]] = vl;
 //            }
 //        }
@@ -75,18 +78,18 @@
 //        for (int i = el; i <= er; i++) {
 //            int id = eid[i];
 //            if (op[id] == 1) {
-//                if (y[id] <= mid) {
-//                    add(x[id], v[id]);
+//                int satisfy = query(x[id], y[id]);
+//                if (v[id] <= satisfy) {
 //                    lset[++lsiz] = id;
 //                } else {
+//                    v[id] -= satisfy;
 //                    rset[++rsiz] = id;
 //                }
 //            } else {
-//                int satisfy = query(x[id], y[id]);
-//                if (v[id] <= satisfy) {
+//                if (y[id] <= mid) {
+//                    add(x[id], v[id]);
 //                    lset[++lsiz] = id;
 //                } else {
-//                    v[id] -= satisfy;
 //                    rset[++rsiz] = id;
 //                }
 //            }
@@ -99,7 +102,7 @@
 //        }
 //        for (int i = 1; i <= lsiz; i++) {
 //            int id = lset[i];
-//            if (op[id] == 1 && y[id] <= mid) {
+//            if (op[id] == 2 && y[id] <= mid) {
 //                add(x[id], -v[id]);
 //            }
 //        }
@@ -111,43 +114,41 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    while (cin >> n) {
-//        fill(tree + 1, tree + n + 1, 0);
-//        int eventCnt = 0;
-//        for (int i = 1; i <= n; i++) {
-//            cin >> arr[i];
-//            op[++eventCnt] = 1;
-//            x[eventCnt] = i;
-//            y[eventCnt] = arr[i];
-//            v[eventCnt] = 1;
-//        }
-//        cin >> m;
-//        int queryCnt = 0;
-//        for (int i = 1; i <= m; i++) {
-//            cin >> op[++eventCnt];
-//            if (op[eventCnt] == 1) {
-//                int a, b;
-//                cin >> a >> b;
-//                x[eventCnt] = a;
-//                y[eventCnt] = arr[a];
-//                v[eventCnt] = -1;
-//                op[++eventCnt] = 1;
-//                x[eventCnt] = a;
-//                y[eventCnt] = b;
-//                v[eventCnt] = 1;
-//                arr[a] = b;
-//            } else {
-//                cin >> x[eventCnt] >> y[eventCnt] >> v[eventCnt];
-//                q[eventCnt] = ++queryCnt;
-//            }
-//        }
-//        for (int i = 1; i <= eventCnt; i++) {
-//            eid[i] = i;
-//        }
-//        compute(1, eventCnt, 1, INF);
-//        for (int i = 1; i <= queryCnt; i++) {
-//            cout << ans[i] << '\n';
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//        op[++cnte] = 2;
+//        x[cnte] = i;
+//        y[cnte] = arr[i];
+//        v[cnte] = 1;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        char type;
+//        cin >> type;
+//        if (type == 'Q') {
+//            op[++cnte] = 1;
+//            cin >> x[cnte] >> y[cnte] >> v[cnte];
+//            q[cnte] = ++cntq;
+//        } else {
+//            int a, b;
+//            cin >> a >> b;
+//            op[++cnte] = 2;
+//            x[cnte] = a;
+//            y[cnte] = arr[a];
+//            v[cnte] = -1;
+//            op[++cnte] = 2;
+//            x[cnte] = a;
+//            y[cnte] = b;
+//            v[cnte] = 1;
+//            arr[a] = b;
 //        }
 //    }
+//    for (int i = 1; i <= cnte; i++) {
+//        eid[i] = i;
+//    }
+//    compute(1, cnte, 0, INF);
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
 //    return 0;
 //}
\ No newline at end of file

From 260b97b621acc0d034b29369892cd316522a3c36 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 10:40:50 +0800
Subject: [PATCH 0834/1712] modify code

---
 src/class169/Code05_Fruit1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class169/Code05_Fruit1.java b/src/class169/Code05_Fruit1.java
index 433c37d16..d199a9399 100644
--- a/src/class169/Code05_Fruit1.java
+++ b/src/class169/Code05_Fruit1.java
@@ -39,7 +39,7 @@ public class Code05_Fruit1 {
 
 	// event[i][0]代表事件的类型，1为盘子类型，2为水果类型
 	// event[i][1]表示x轴的位置
-	// 如果是盘子类型，那么event[i][2..5]分别代表 : yl、yr、权值v、产生的影响d
+	// 如果是盘子类型，那么event[i][2..5]分别代表 : yl、yr、权值v、产生的效果d
 	// 如果是水果类型，那么event[i][2..5]分别代表 : y、空缺、要求v、问题的编号d
 	public static int[][] event = new int[MAXN << 3][6];
 	public static int cnte = 0;

From cade44cb4e52e8e9e46d559ce462f252b2533fd1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 11:16:47 +0800
Subject: [PATCH 0835/1712] modify code

---
 src/class169/Code05_Fruit1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class169/Code05_Fruit1.java b/src/class169/Code05_Fruit1.java
index d199a9399..4dcfa45dd 100644
--- a/src/class169/Code05_Fruit1.java
+++ b/src/class169/Code05_Fruit1.java
@@ -37,10 +37,10 @@ public class Code05_Fruit1 {
 
 	public static int[] tree = new int[MAXN];
 
-	// event[i][0]代表事件的类型，1为盘子类型，2为水果类型
-	// event[i][1]表示x轴的位置
-	// 如果是盘子类型，那么event[i][2..5]分别代表 : yl、yr、权值v、产生的效果d
-	// 如果是水果类型，那么event[i][2..5]分别代表 : y、空缺、要求v、问题的编号d
+	// event[i][0] == 1为盘子类型
+	// 如果是盘子类型，event[i][1..5]分别代表 : x、yl、yr、权值v、产生的效果d
+	// event[i][0] == 2为水果类型
+	// 如果是水果类型，event[i][1..5]分别代表 : x、y、空缺、要求v、问题的编号d
 	public static int[][] event = new int[MAXN << 3][6];
 	public static int cnte = 0;
 

From 2b5587353707605449597b1f6286bd38b52b9f41 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 12:47:53 +0800
Subject: [PATCH 0836/1712] modify code

---
 src/class169/Code01_Juice1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class169/Code01_Juice1.java b/src/class169/Code01_Juice1.java
index 36209772d..84b963e7a 100644
--- a/src/class169/Code01_Juice1.java
+++ b/src/class169/Code01_Juice1.java
@@ -32,9 +32,9 @@ public class Code01_Juice1 {
 	// 果汁单价作为下标的线段树
 	// maxp为单价的最大上限
 	public static int maxp = 0;
-	// suml[i] : 线段树某单价区间上，总果汁的量
+	// suml[i] : 线段树某单价区间上，允许添加的总量
 	public static long[] suml = new long[MAXN << 2];
-	// cost[i] : 线段树某单价区间上，如果总果汁的量全买，花费多少钱
+	// cost[i] : 线段树某单价区间上，如果允许添加的总量全要，花费多少钱
 	public static long[] cost = new long[MAXN << 2];
 	// 多少种果汁加入了线段树
 	public static int used = 0;

From 9ad36438785f317d0ac6e468c71e6335f66916dd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 13:37:30 +0800
Subject: [PATCH 0837/1712] modify code

---
 src/class169/Code01_Juice1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class169/Code01_Juice1.java b/src/class169/Code01_Juice1.java
index 84b963e7a..dc31a44c2 100644
--- a/src/class169/Code01_Juice1.java
+++ b/src/class169/Code01_Juice1.java
@@ -30,7 +30,7 @@ public class Code01_Juice1 {
 	public static long[] least = new long[MAXN];
 
 	// 果汁单价作为下标的线段树
-	// maxp为单价的最大上限
+	// maxp为最大的果汁单价
 	public static int maxp = 0;
 	// suml[i] : 线段树某单价区间上，允许添加的总量
 	public static long[] suml = new long[MAXN << 2];

From 9f6c4201aaff5f06e963df0e73f2513085347f8e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 13:44:49 +0800
Subject: [PATCH 0838/1712] modify code

---
 src/class169/Code01_Juice1.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/class169/Code01_Juice1.java b/src/class169/Code01_Juice1.java
index dc31a44c2..0d6cf24fa 100644
--- a/src/class169/Code01_Juice1.java
+++ b/src/class169/Code01_Juice1.java
@@ -51,6 +51,7 @@ public static void up(int i) {
 		cost[i] = cost[i << 1] + cost[i << 1 | 1];
 	}
 
+	// 单价为jobi，现在允许添加的量增加了jobv
 	public static void add(int jobi, int jobv, int l, int r, int i) {
 		if (l == r) {
 			suml[i] += jobv;
@@ -66,6 +67,8 @@ public static void add(int jobi, int jobv, int l, int r, int i) {
 		}
 	}
 
+	// 总体积一共volume，已知总体积一定能耗尽
+	// 返回总体积耗尽的情况下，能花的最少钱数
 	public static long query(long volume, int l, int r, int i) {
 		if (l == r) {
 			return volume * l;
@@ -134,7 +137,10 @@ public static void main(String[] args) throws Exception {
 			money[i] = in.nextLong();
 			least[i] = in.nextLong();
 		}
+		// 所有果汁按照美味度排序，美味度大的在前，美味度小的在后
 		Arrays.sort(juice, 1, n + 1, (a, b) -> b[0] - a[0]);
+		// 答案范围就是美味度范围，从最美味的第1名，到最难喝的第n名
+		// 如果小朋友答案为n+1，说明无法满足这个小朋友
 		compute(1, m, 1, n + 1);
 		for (int i = 1; i <= m; i++) {
 			if (ans[i] == n + 1) {

From cf0ecb496d6bed7fdc500bf789a62b889f1ed018 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 20 May 2025 15:41:50 +0800
Subject: [PATCH 0839/1712] modify code

---
 src/class169/Code02_PastoralOddities1.java | 4 ++--
 src/class169/Code02_PastoralOddities2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class169/Code02_PastoralOddities1.java b/src/class169/Code02_PastoralOddities1.java
index 7df208e19..0eca2ceb0 100644
--- a/src/class169/Code02_PastoralOddities1.java
+++ b/src/class169/Code02_PastoralOddities1.java
@@ -81,7 +81,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = ql; i <= qr; i++) {
-				ans[i] = wsort[vl][3];
+				ans[i] = vl;
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
@@ -158,7 +158,7 @@ public static void main(String[] args) throws Exception {
 		prepare();
 		compute(1, m, 1, m + 1);
 		for (int i = 1; i <= m; i++) {
-			out.println(ans[i]);
+			out.println(wsort[ans[i]][3]);
 		}
 		out.flush();
 		out.close();
diff --git a/src/class169/Code02_PastoralOddities2.java b/src/class169/Code02_PastoralOddities2.java
index 606c75a30..3a7ce06bc 100644
--- a/src/class169/Code02_PastoralOddities2.java
+++ b/src/class169/Code02_PastoralOddities2.java
@@ -83,7 +83,7 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = ql; i <= qr; i++) {
-//            ans[i] = wsort[vl].w;
+//            ans[i] = vl;
 //        }
 //    } else {
 //        int mid = (vl + vr) >> 1;
@@ -154,7 +154,7 @@
 //    prepare();
 //    compute(1, m, 1, m + 1);
 //    for (int i = 1; i <= m; i++) {
-//        cout << ans[i] << '\n';
+//        cout << wsort[ans[i]].w << '\n';
 //    }
 //    return 0;
 //}
\ No newline at end of file

From 23289aa2864309be721c087835b8b8230c27f300 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 13:48:58 +0800
Subject: [PATCH 0840/1712] modify code

---
 ...Rankings1.java => Code02_DynamicRankings1.java} |  2 +-
 ...Rankings2.java => Code02_DynamicRankings2.java} |  0
 .../{Code04_Network1.java => Code03_Network1.java} |  2 +-
 .../{Code04_Network2.java => Code03_Network2.java} |  0
 .../{Code05_Fruit1.java => Code04_Fruit1.java}     |  2 +-
 .../{Code05_Fruit2.java => Code04_Fruit2.java}     |  0
 ...ddities1.java => Code05_PastoralOddities1.java} | 14 ++++++++++----
 ...ddities2.java => Code05_PastoralOddities2.java} |  2 +-
 8 files changed, 14 insertions(+), 8 deletions(-)
 rename src/class169/{Code03_DynamicRankings1.java => Code02_DynamicRankings1.java} (99%)
 rename src/class169/{Code03_DynamicRankings2.java => Code02_DynamicRankings2.java} (100%)
 rename src/class169/{Code04_Network1.java => Code03_Network1.java} (99%)
 rename src/class169/{Code04_Network2.java => Code03_Network2.java} (100%)
 rename src/class169/{Code05_Fruit1.java => Code04_Fruit1.java} (99%)
 rename src/class169/{Code05_Fruit2.java => Code04_Fruit2.java} (100%)
 rename src/class169/{Code02_PastoralOddities1.java => Code05_PastoralOddities1.java} (91%)
 rename src/class169/{Code02_PastoralOddities2.java => Code05_PastoralOddities2.java} (100%)

diff --git a/src/class169/Code03_DynamicRankings1.java b/src/class169/Code02_DynamicRankings1.java
similarity index 99%
rename from src/class169/Code03_DynamicRankings1.java
rename to src/class169/Code02_DynamicRankings1.java
index 339d8d1d3..178655215 100644
--- a/src/class169/Code03_DynamicRankings1.java
+++ b/src/class169/Code02_DynamicRankings1.java
@@ -15,7 +15,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_DynamicRankings1 {
+public class Code02_DynamicRankings1 {
 
 	public static int MAXN = 100001;
 	public static int MAXE = MAXN << 2;
diff --git a/src/class169/Code03_DynamicRankings2.java b/src/class169/Code02_DynamicRankings2.java
similarity index 100%
rename from src/class169/Code03_DynamicRankings2.java
rename to src/class169/Code02_DynamicRankings2.java
diff --git a/src/class169/Code04_Network1.java b/src/class169/Code03_Network1.java
similarity index 99%
rename from src/class169/Code04_Network1.java
rename to src/class169/Code03_Network1.java
index 8dd4afafa..2706c5db7 100644
--- a/src/class169/Code04_Network1.java
+++ b/src/class169/Code03_Network1.java
@@ -17,7 +17,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_Network1 {
+public class Code03_Network1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 200001;
diff --git a/src/class169/Code04_Network2.java b/src/class169/Code03_Network2.java
similarity index 100%
rename from src/class169/Code04_Network2.java
rename to src/class169/Code03_Network2.java
diff --git a/src/class169/Code05_Fruit1.java b/src/class169/Code04_Fruit1.java
similarity index 99%
rename from src/class169/Code05_Fruit1.java
rename to src/class169/Code04_Fruit1.java
index 4dcfa45dd..5d36518a3 100644
--- a/src/class169/Code05_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -17,7 +17,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_Fruit1 {
+public class Code04_Fruit1 {
 
 	public static int MAXN = 40001;
 	public static int MAXH = 16;
diff --git a/src/class169/Code05_Fruit2.java b/src/class169/Code04_Fruit2.java
similarity index 100%
rename from src/class169/Code05_Fruit2.java
rename to src/class169/Code04_Fruit2.java
diff --git a/src/class169/Code02_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
similarity index 91%
rename from src/class169/Code02_PastoralOddities1.java
rename to src/class169/Code05_PastoralOddities1.java
index 0eca2ceb0..67dee7a8e 100644
--- a/src/class169/Code02_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -17,23 +17,25 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_PastoralOddities1 {
+public class Code05_PastoralOddities1 {
 
 	public static int MAXN = 100001;
 	public static int MAXM = 300002;
 	public static int n, m;
 
-	// 边的编号i、端点x、端点y、权值w
+	// edge是按时序组织的边数组
+	// wsort是按权值组织的边数组
+	// 边的时序i、端点x、端点y、权值w
 	public static int[][] edge = new int[MAXM][4];
 	public static int[][] wsort = new int[MAXM][4];
 
-	// 节点数为奇数的联通区数量
-	public static int oddnum;
 	// 可撤销并查集
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize = 0;
+	// 节点数为奇数的联通区数量
+	public static int oddnum;
 
 	public static int[] ans = new int[MAXM];
 
@@ -75,6 +77,10 @@ public static void undo() {
 		}
 	}
 
+	// 按时序组织的边在edge里，当前来到[ql..qr]范围
+	// 按权值组织的边在wsort里，答案范围[vl..vr]
+	// 前提 : ql之前的边里，边权 <= wsort[vl].w 的所有边，都已经加到图上了
+	// 利用整体二分得到所有边的答案
 	public static void compute(int ql, int qr, int vl, int vr) {
 		if (ql > qr) {
 			return;
diff --git a/src/class169/Code02_PastoralOddities2.java b/src/class169/Code05_PastoralOddities2.java
similarity index 100%
rename from src/class169/Code02_PastoralOddities2.java
rename to src/class169/Code05_PastoralOddities2.java
index 3a7ce06bc..992907023 100644
--- a/src/class169/Code02_PastoralOddities2.java
+++ b/src/class169/Code05_PastoralOddities2.java
@@ -31,11 +31,11 @@
 //Edge edge[MAXM];
 //Edge wsort[MAXM];
 //
-//int oddnum;
 //int father[MAXN];
 //int siz[MAXN];
 //int rollback[MAXN][2];
 //int opsize = 0;
+//int oddnum;
 //
 //int ans[MAXM];
 //

From b68a9f225c2b1cf59f916918a569485a2537010b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 15:53:47 +0800
Subject: [PATCH 0841/1712] modify code

---
 src/class169/Code02_DynamicRankings1.java | 40 +++++++++++------------
 src/class169/Code02_DynamicRankings2.java | 32 +++++++++---------
 2 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/class169/Code02_DynamicRankings1.java b/src/class169/Code02_DynamicRankings1.java
index 178655215..31b4a0b73 100644
--- a/src/class169/Code02_DynamicRankings1.java
+++ b/src/class169/Code02_DynamicRankings1.java
@@ -2,8 +2,8 @@
 
 // 带修改的区间第k小，java版
 // 给定一个长度为n的数组arr，接下来是m条操作，每种操作是如下两种类型的一种
-// 操作 Q x y v : 查询arr[x..y]范围上第v小的值
 // 操作 C x y   : 把x位置的值修改成y
+// 操作 Q x y v : 查询arr[x..y]范围上第v小的值
 // 1 <= n、m <= 10^5
 // 1 <= 数组中的值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2617
@@ -26,8 +26,8 @@ public class Code02_DynamicRankings1 {
 
 	// 事件编号组成的数组
 	public static int[] eid = new int[MAXE];
-	// op == 1，代表查询事件，[x..y]范围上查询第v小，q表示问题的编号
-	// op == 2，代表修改事件，x处，值y，效果v
+	// op == 1，代表修改事件，x处，值y，效果v
+	// op == 2，代表查询事件，[x..y]范围上查询第v小，q表示问题的编号
 	public static int[] op = new int[MAXE];
 	public static int[] x = new int[MAXE];
 	public static int[] y = new int[MAXE];
@@ -77,7 +77,7 @@ public static void compute(int el, int er, int vl, int vr) {
 		if (vl == vr) {
 			for (int i = el; i <= er; i++) {
 				int id = eid[i];
-				if (op[id] == 1) {
+				if (op[id] == 2) {
 					ans[q[id]] = vl;
 				}
 			}
@@ -87,18 +87,18 @@ public static void compute(int el, int er, int vl, int vr) {
 			for (int i = el; i <= er; i++) {
 				int id = eid[i];
 				if (op[id] == 1) {
-					int satisfy = query(x[id], y[id]);
-					if (v[id] <= satisfy) {
+					if (y[id] <= mid) {
+						add(x[id], v[id]);
 						lset[++lsiz] = id;
 					} else {
-						v[id] -= satisfy;
 						rset[++rsiz] = id;
 					}
 				} else {
-					if (y[id] <= mid) {
-						add(x[id], v[id]);
+					int satisfy = query(x[id], y[id]);
+					if (v[id] <= satisfy) {
 						lset[++lsiz] = id;
 					} else {
+						v[id] -= satisfy;
 						rset[++rsiz] = id;
 					}
 				}
@@ -111,7 +111,7 @@ public static void compute(int el, int er, int vl, int vr) {
 			}
 			for (int i = 1; i <= lsiz; i++) {
 				int id = lset[i];
-				if (op[id] == 2 && y[id] <= mid) {
+				if (op[id] == 1 && y[id] <= mid) {
 					add(x[id], -v[id]);
 				}
 			}
@@ -127,7 +127,7 @@ public static void main(String[] args) throws IOException {
 		m = in.nextInt();
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
-			op[++cnte] = 2;
+			op[++cnte] = 1;
 			x[cnte] = i;
 			y[cnte] = arr[i];
 			v[cnte] = 1;
@@ -135,24 +135,24 @@ public static void main(String[] args) throws IOException {
 		char type;
 		for (int i = 1; i <= m; i++) {
 			type = in.nextChar();
-			if (type == 'Q') {
-				op[++cnte] = 1;
-				x[cnte] = in.nextInt();
-				y[cnte] = in.nextInt();
-				v[cnte] = in.nextInt();
-				q[cnte] = ++cntq;
-			} else {
+			if (type == 'C') {
 				int a = in.nextInt();
 				int b = in.nextInt();
-				op[++cnte] = 2;
+				op[++cnte] = 1;
 				x[cnte] = a;
 				y[cnte] = arr[a];
 				v[cnte] = -1;
-				op[++cnte] = 2;
+				op[++cnte] = 1;
 				x[cnte] = a;
 				y[cnte] = b;
 				v[cnte] = 1;
 				arr[a] = b;
+			} else {
+				op[++cnte] = 2;
+				x[cnte] = in.nextInt();
+				y[cnte] = in.nextInt();
+				v[cnte] = in.nextInt();
+				q[cnte] = ++cntq;
 			}
 		}
 		for (int i = 1; i <= cnte; i++) {
diff --git a/src/class169/Code02_DynamicRankings2.java b/src/class169/Code02_DynamicRankings2.java
index df251c7ed..4bbc856fa 100644
--- a/src/class169/Code02_DynamicRankings2.java
+++ b/src/class169/Code02_DynamicRankings2.java
@@ -2,8 +2,8 @@
 
 // 带修改的区间第k小，C++版
 // 给定一个长度为n的数组arr，接下来是m条操作，每种操作是如下两种类型的一种
-// 操作 Q x y v : 查询arr[x..y]范围上第v小的值
 // 操作 C x y   : 把x位置的值修改成y
+// 操作 Q x y v : 查询arr[x..y]范围上第v小的值
 // 1 <= n、m <= 10^5
 // 1 <= 数组中的值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2617
@@ -68,7 +68,7 @@
 //    if (vl == vr) {
 //        for (int i = el; i <= er; i++) {
 //            int id = eid[i];
-//            if (op[id] == 1) {
+//            if (op[id] == 2) {
 //                ans[q[id]] = vl;
 //            }
 //        }
@@ -78,18 +78,18 @@
 //        for (int i = el; i <= er; i++) {
 //            int id = eid[i];
 //            if (op[id] == 1) {
-//                int satisfy = query(x[id], y[id]);
-//                if (v[id] <= satisfy) {
+//                if (y[id] <= mid) {
+//                    add(x[id], v[id]);
 //                    lset[++lsiz] = id;
 //                } else {
-//                    v[id] -= satisfy;
 //                    rset[++rsiz] = id;
 //                }
 //            } else {
-//                if (y[id] <= mid) {
-//                    add(x[id], v[id]);
+//                int satisfy = query(x[id], y[id]);
+//                if (v[id] <= satisfy) {
 //                    lset[++lsiz] = id;
 //                } else {
+//                    v[id] -= satisfy;
 //                    rset[++rsiz] = id;
 //                }
 //            }
@@ -102,7 +102,7 @@
 //        }
 //        for (int i = 1; i <= lsiz; i++) {
 //            int id = lset[i];
-//            if (op[id] == 2 && y[id] <= mid) {
+//            if (op[id] == 1 && y[id] <= mid) {
 //                add(x[id], -v[id]);
 //            }
 //        }
@@ -117,7 +117,7 @@
 //    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
-//        op[++cnte] = 2;
+//        op[++cnte] = 1;
 //        x[cnte] = i;
 //        y[cnte] = arr[i];
 //        v[cnte] = 1;
@@ -125,22 +125,22 @@
 //    for (int i = 1; i <= m; i++) {
 //        char type;
 //        cin >> type;
-//        if (type == 'Q') {
-//            op[++cnte] = 1;
-//            cin >> x[cnte] >> y[cnte] >> v[cnte];
-//            q[cnte] = ++cntq;
-//        } else {
+//        if (type == 'C') {
 //            int a, b;
 //            cin >> a >> b;
-//            op[++cnte] = 2;
+//            op[++cnte] = 1;
 //            x[cnte] = a;
 //            y[cnte] = arr[a];
 //            v[cnte] = -1;
-//            op[++cnte] = 2;
+//            op[++cnte] = 1;
 //            x[cnte] = a;
 //            y[cnte] = b;
 //            v[cnte] = 1;
 //            arr[a] = b;
+//        } else {
+//            op[++cnte] = 2;
+//            cin >> x[cnte] >> y[cnte] >> v[cnte];
+//            q[cnte] = ++cntq;
 //        }
 //    }
 //    for (int i = 1; i <= cnte; i++) {

From 8ea691b268b43bde1e87f7cee1362f94417c55c3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 17:43:00 +0800
Subject: [PATCH 0842/1712] modify code

---
 src/class169/Code03_Network1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class169/Code03_Network1.java b/src/class169/Code03_Network1.java
index 2706c5db7..72e2cd1bc 100644
--- a/src/class169/Code03_Network1.java
+++ b/src/class169/Code03_Network1.java
@@ -183,6 +183,7 @@ public static int query(int i) {
 		return ret;
 	}
 
+	// 点x到点y的路径上，每个点增加v个请求数量
 	public static void pathAdd(int x, int y, int v) {
 		int xylca = lca(x, y);
 		int lcafa = fa[xylca];
@@ -194,6 +195,7 @@ public static void pathAdd(int x, int y, int v) {
 		}
 	}
 
+	// 查询和x点相关的请求数量
 	public static int pointQuery(int x) {
 		return query(dfn[x] + siz[x] - 1) - query(dfn[x] - 1);
 	}

From a9e5c65d1a57eafd5eb68add33a08281b7159a90 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 17:50:11 +0800
Subject: [PATCH 0843/1712] modify code

---
 src/class169/Code04_Fruit1.java            | 16 ++++++++--------
 src/class169/Code04_Fruit2.java            | 16 ++++++++--------
 src/class169/Code05_PastoralOddities1.java | 18 +++++++++---------
 src/class169/Code05_PastoralOddities2.java | 18 +++++++++---------
 4 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index 5d36518a3..b1107c6f6 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -206,12 +206,12 @@ public static void clone(int[] a, int[] b) {
 		a[5] = b[5];
 	}
 
-	public static void compute(int ql, int qr, int vl, int vr) {
-		if (ql > qr) {
+	public static void compute(int el, int er, int vl, int vr) {
+		if (el > er) {
 			return;
 		}
 		if (vl == vr) {
-			for (int i = ql; i <= qr; i++) {
+			for (int i = el; i <= er; i++) {
 				if (event[i][0] == 2) {
 					ans[event[i][5]] = vl;
 				}
@@ -219,7 +219,7 @@ public static void compute(int ql, int qr, int vl, int vr) {
 		} else {
 			int mid = (vl + vr) >> 1;
 			int lsiz = 0, rsiz = 0;
-			for (int i = ql; i <= qr; i++) {
+			for (int i = el; i <= er; i++) {
 				if (event[i][0] == 1) {
 					if (event[i][4] <= mid) {
 						add(event[i][2], event[i][3], event[i][5]);
@@ -244,13 +244,13 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			// 同一个盘子的两条扫描线，一定会在一起，是不可能分开的
 			// 所以此时树状数组就是清空的，不需要再做撤销操作
 			for (int i = 1; i <= lsiz; i++) {
-				clone(event[ql + i - 1], lset[i]);
+				clone(event[el + i - 1], lset[i]);
 			}
 			for (int i = 1; i <= rsiz; i++) {
-				clone(event[ql + lsiz + i - 1], rset[i]);
+				clone(event[el + lsiz + i - 1], rset[i]);
 			}
-			compute(ql, ql + lsiz - 1, vl, mid);
-			compute(ql + lsiz, qr, mid + 1, vr);
+			compute(el, el + lsiz - 1, vl, mid);
+			compute(el + lsiz, er, mid + 1, vr);
 		}
 	}
 
diff --git a/src/class169/Code04_Fruit2.java b/src/class169/Code04_Fruit2.java
index e3150f87e..875faafb5 100644
--- a/src/class169/Code04_Fruit2.java
+++ b/src/class169/Code04_Fruit2.java
@@ -153,12 +153,12 @@
 //    event[cnte].d = d;
 //}
 //
-//void compute(int ql, int qr, int vl, int vr) {
-//    if (ql > qr) {
+//void compute(int el, int er, int vl, int vr) {
+//    if (el > er) {
 //        return;
 //    }
 //    if (vl == vr) {
-//        for (int i = ql; i <= qr; i++) {
+//        for (int i = el; i <= er; i++) {
 //            if (event[i].op == 2) {
 //                ans[event[i].d] = vl;
 //            }
@@ -166,7 +166,7 @@
 //    } else {
 //        int mid = (vl + vr) >> 1;
 //        int lsiz = 0, rsiz = 0;
-//        for (int i = ql; i <= qr; i++) {
+//        for (int i = el; i <= er; i++) {
 //            if (event[i].op == 1) {
 //                if (event[i].v <= mid) {
 //                    add(event[i].yl, event[i].yr, event[i].d);
@@ -185,13 +185,13 @@
 //            }
 //        }
 //        for (int i = 1; i <= lsiz; i++) {
-//            event[ql + i - 1] = lset[i];
+//            event[el + i - 1] = lset[i];
 //        }
 //        for (int i = 1; i <= rsiz; i++) {
-//            event[ql + lsiz + i - 1] = rset[i];
+//            event[el + lsiz + i - 1] = rset[i];
 //        }
-//        compute(ql, ql + lsiz - 1, vl, mid);
-//        compute(ql + lsiz, qr, mid + 1, vr);
+//        compute(el, el + lsiz - 1, vl, mid);
+//        compute(el + lsiz, er, mid + 1, vr);
 //    }
 //}
 //
diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index 67dee7a8e..55f247375 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -81,27 +81,27 @@ public static void undo() {
 	// 按权值组织的边在wsort里，答案范围[vl..vr]
 	// 前提 : ql之前的边里，边权 <= wsort[vl].w 的所有边，都已经加到图上了
 	// 利用整体二分得到所有边的答案
-	public static void compute(int ql, int qr, int vl, int vr) {
-		if (ql > qr) {
+	public static void compute(int el, int er, int vl, int vr) {
+		if (el > er) {
 			return;
 		}
 		if (vl == vr) {
-			for (int i = ql; i <= qr; i++) {
+			for (int i = el; i <= er; i++) {
 				ans[i] = vl;
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
 			int unionCnt1 = 0;
 			for (int i = vl; i <= mid; i++) {
-				if (wsort[i][0] < ql) {
+				if (wsort[i][0] < el) {
 					if (union(wsort[i][1], wsort[i][2])) {
 						unionCnt1++;
 					}
 				}
 			}
 			int unionCnt2 = 0;
-			int split = qr + 1;
-			for (int i = ql; i <= qr; i++) {
+			int split = er + 1;
+			for (int i = el; i <= er; i++) {
 				if (edge[i][3] <= wsort[mid][3]) {
 					if (union(edge[i][1], edge[i][2])) {
 						unionCnt2++;
@@ -115,19 +115,19 @@ public static void compute(int ql, int qr, int vl, int vr) {
 			for (int i = 1; i <= unionCnt2; i++) {
 				undo();
 			}
-			compute(ql, split - 1, mid + 1, vr);
+			compute(el, split - 1, mid + 1, vr);
 			for (int i = 1; i <= unionCnt1; i++) {
 				undo();
 			}
 			int unionCnt3 = 0;
-			for (int i = ql; i <= split - 1; i++) {
+			for (int i = el; i <= split - 1; i++) {
 				if (edge[i][3] <= wsort[vl][3]) {
 					if (union(edge[i][1], edge[i][2])) {
 						unionCnt3++;
 					}
 				}
 			}
-			compute(split, qr, vl, mid);
+			compute(split, er, vl, mid);
 			for (int i = 1; i <= unionCnt3; i++) {
 				undo();
 			}
diff --git a/src/class169/Code05_PastoralOddities2.java b/src/class169/Code05_PastoralOddities2.java
index 992907023..a8a99a0b1 100644
--- a/src/class169/Code05_PastoralOddities2.java
+++ b/src/class169/Code05_PastoralOddities2.java
@@ -77,27 +77,27 @@
 //    }
 //}
 //
-//void compute(int ql, int qr, int vl, int vr) {
-//    if (ql > qr) {
+//void compute(int el, int er, int vl, int vr) {
+//    if (el > er) {
 //        return;
 //    }
 //    if (vl == vr) {
-//        for (int i = ql; i <= qr; i++) {
+//        for (int i = el; i <= er; i++) {
 //            ans[i] = vl;
 //        }
 //    } else {
 //        int mid = (vl + vr) >> 1;
 //        int unionCnt1 = 0;
 //        for (int i = vl; i <= mid; i++) {
-//            if (wsort[i].i < ql) {
+//            if (wsort[i].i < el) {
 //                if (Union(wsort[i].x, wsort[i].y)) {
 //                    unionCnt1++;
 //                }
 //            }
 //        }
 //        int unionCnt2 = 0;
-//        int split = qr + 1;
-//        for (int i = ql; i <= qr; i++) {
+//        int split = er + 1;
+//        for (int i = el; i <= er; i++) {
 //            if (edge[i].w <= wsort[mid].w) {
 //                if (Union(edge[i].x, edge[i].y)) {
 //                    unionCnt2++;
@@ -111,19 +111,19 @@
 //        for (int i = 1; i <= unionCnt2; i++) {
 //            undo();
 //        }
-//        compute(ql, split - 1, mid + 1, vr);
+//        compute(el, split - 1, mid + 1, vr);
 //        for (int i = 1; i <= unionCnt1; i++) {
 //            undo();
 //        }
 //        int unionCnt3 = 0;
-//        for (int i = ql; i <= split - 1; i++) {
+//        for (int i = el; i <= split - 1; i++) {
 //            if (edge[i].w <= wsort[vl].w) {
 //                if (Union(edge[i].x, edge[i].y)) {
 //                    unionCnt3++;
 //                }
 //            }
 //        }
-//        compute(split, qr, vl, mid);
+//        compute(split, er, vl, mid);
 //        for (int i = 1; i <= unionCnt3; i++) {
 //            undo();
 //        }

From 18527b93f8e09d42ff7683d7d30a27786809d9ed Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 19:20:40 +0800
Subject: [PATCH 0844/1712] modify code

---
 src/class169/Code04_Fruit1.java | 1 +
 src/class169/Code04_Fruit2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index b1107c6f6..7f7f86dd4 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -8,6 +8,7 @@
 // 那么对于每个水果，可能有很多盘子都可以将其接住，打印其中第k小的权值
 // 1 <= n、p、q <= 4 * 10^4
 // 0 <= 盘子权值 <= 10^9
+// 内存可用空间500MB
 // 测试链接 : https://www.luogu.com.cn/problem/P3242
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class169/Code04_Fruit2.java b/src/class169/Code04_Fruit2.java
index 875faafb5..0a4597d9a 100644
--- a/src/class169/Code04_Fruit2.java
+++ b/src/class169/Code04_Fruit2.java
@@ -8,6 +8,7 @@
 // 那么对于每个水果，可能有很多盘子都可以将其接住，打印其中第k小的权值
 // 1 <= n、p、q <= 4 * 10^4
 // 0 <= 盘子权值 <= 10^9
+// 内存可用空间500MB
 // 测试链接 : https://www.luogu.com.cn/problem/P3242
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From d441e7f641d4ace15da90d26c03b68138a215f4e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 22:14:49 +0800
Subject: [PATCH 0845/1712] modify code

---
 ...kets.java => Code03_GroupBuyTickets1.java} |   2 +-
 src/class091/Code03_GroupBuyTickets2.java     | 129 ++++++++++++++++++
 2 files changed, 130 insertions(+), 1 deletion(-)
 rename src/class091/{Code03_GroupBuyTickets.java => Code03_GroupBuyTickets1.java} (99%)
 create mode 100644 src/class091/Code03_GroupBuyTickets2.java

diff --git a/src/class091/Code03_GroupBuyTickets.java b/src/class091/Code03_GroupBuyTickets1.java
similarity index 99%
rename from src/class091/Code03_GroupBuyTickets.java
rename to src/class091/Code03_GroupBuyTickets1.java
index 62a90da3c..fa987d966 100644
--- a/src/class091/Code03_GroupBuyTickets.java
+++ b/src/class091/Code03_GroupBuyTickets1.java
@@ -22,7 +22,7 @@
 // 数据量描述 : 
 // 1 <= M、N、Ki、Bi <= 10^5
 // 来自真实大厂笔试，没有在线测试，对数器验证
-public class Code03_GroupBuyTickets {
+public class Code03_GroupBuyTickets1 {
 
 	// 暴力方法
 	// 为了验证
diff --git a/src/class091/Code03_GroupBuyTickets2.java b/src/class091/Code03_GroupBuyTickets2.java
new file mode 100644
index 000000000..0312b6ced
--- /dev/null
+++ b/src/class091/Code03_GroupBuyTickets2.java
@@ -0,0 +1,129 @@
+package class091;
+
+// 组团买票找到了在线测试
+// 逻辑和课上讲的一样，做了一些小优化
+// 测试链接 : https://www.luogu.com.cn/problem/P12331
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.util.PriorityQueue;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_GroupBuyTickets2 {
+
+	public static class Game {
+		public long ki;
+		public long bi;
+		public int people;
+
+		public Game(long k, long b) {
+			ki = k;
+			bi = b;
+		}
+
+		public long earn() {
+			return cost(people + 1) - cost(people);
+		}
+
+		public long cost(long p) {
+			long price = ki * p + bi;
+			if (price < 0) {
+				price = 0;
+			}
+			return p * price;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		int n = in.nextInt();
+		int m = in.nextInt();
+		PriorityQueue<Game> heap = new PriorityQueue<>((a, b) -> Long.compare(b.earn(), a.earn()));
+		for (int i = 0; i < m; i++) {
+			Game cur = new Game(in.nextLong(), in.nextLong());
+			// 初始增费<=0的项目直接忽略
+			if (cur.earn() > 0) {
+				heap.add(cur);
+			}
+		}
+		long ans = 0;
+		for (int i = 0; i < n && !heap.isEmpty(); i++) {
+			Game cur = heap.poll();
+			long money = cur.earn();
+			if (money <= 0) {
+				// 没有正向增费，那么可以结束了
+				break;
+			}
+			ans += money;
+			cur.people++;
+			if (cur.earn() > 0) {
+				heap.add(cur);
+			}
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+
+		long nextLong() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			long val = 0L;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+
+	}
+
+}

From ff1789bf51d7a949bb8e4082219b8377e4bffff6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 22:37:46 +0800
Subject: [PATCH 0846/1712] modify code

---
 src/class169/Code04_Fruit1.java | 60 ++++++++++++++++++++-------------
 src/class169/Code04_Fruit2.java | 48 ++++++++++++++++----------
 2 files changed, 67 insertions(+), 41 deletions(-)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index 7f7f86dd4..c81577e2a 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -38,15 +38,14 @@ public class Code04_Fruit1 {
 
 	public static int[] tree = new int[MAXN];
 
-	// event[i][0] == 1为盘子类型
-	// 如果是盘子类型，event[i][1..5]分别代表 : x、yl、yr、权值v、产生的效果d
-	// event[i][0] == 2为水果类型
-	// 如果是水果类型，event[i][1..5]分别代表 : x、y、空缺、要求v、问题的编号d
-	public static int[][] event = new int[MAXN << 3][6];
+	// event[i][0] == 1为加盘子事件，x处加，yl..yr词频+1，盘子权值v
+	// event[i][0] == 2为删盘子事件，x处减，yl..yr词频+1，盘子权值v
+	// event[i][0] == 3为水果事件，x、yl、要求yr、问题编号v
+	public static int[][] event = new int[MAXN << 3][5];
 	public static int cnte = 0;
 
-	public static int[][] lset = new int[MAXN << 3][6];
-	public static int[][] rset = new int[MAXN << 3][6];
+	public static int[][] lset = new int[MAXN << 3][5];
+	public static int[][] rset = new int[MAXN << 3][5];
 
 	public static int[] ans = new int[MAXN];
 
@@ -181,21 +180,28 @@ public static int query(int i) {
 		return ret;
 	}
 
-	public static void addPlate(int x, int yl, int yr, int v, int d) {
+	public static void addPlate(int x, int yl, int yr, int v) {
 		event[++cnte][0] = 1;
 		event[cnte][1] = x;
 		event[cnte][2] = yl;
 		event[cnte][3] = yr;
 		event[cnte][4] = v;
-		event[cnte][5] = d;
 	}
 
-	public static void addFruit(int x, int y, int v, int d) {
+	public static void delPlate(int x, int yl, int yr, int v) {
 		event[++cnte][0] = 2;
 		event[cnte][1] = x;
-		event[cnte][2] = y;
+		event[cnte][2] = yl;
+		event[cnte][3] = yr;
 		event[cnte][4] = v;
-		event[cnte][5] = d;
+	}
+
+	public static void addFruit(int x, int y, int v, int i) {
+		event[++cnte][0] = 3;
+		event[cnte][1] = x;
+		event[cnte][2] = y;
+		event[cnte][3] = v;
+		event[cnte][4] = i;
 	}
 
 	public static void clone(int[] a, int[] b) {
@@ -204,7 +210,6 @@ public static void clone(int[] a, int[] b) {
 		a[2] = b[2];
 		a[3] = b[3];
 		a[4] = b[4];
-		a[5] = b[5];
 	}
 
 	public static void compute(int el, int er, int vl, int vr) {
@@ -213,8 +218,8 @@ public static void compute(int el, int er, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = el; i <= er; i++) {
-				if (event[i][0] == 2) {
-					ans[event[i][5]] = vl;
+				if (event[i][0] == 3) {
+					ans[event[i][4]] = vl;
 				}
 			}
 		} else {
@@ -223,17 +228,24 @@ public static void compute(int el, int er, int vl, int vr) {
 			for (int i = el; i <= er; i++) {
 				if (event[i][0] == 1) {
 					if (event[i][4] <= mid) {
-						add(event[i][2], event[i][3], event[i][5]);
+						add(event[i][2], event[i][3], 1);
+						clone(lset[++lsiz], event[i]);
+					} else {
+						clone(rset[++rsiz], event[i]);
+					}
+				} else if (event[i][0] == 2) {
+					if (event[i][4] <= mid) {
+						add(event[i][2], event[i][3], -1);
 						clone(lset[++lsiz], event[i]);
 					} else {
 						clone(rset[++rsiz], event[i]);
 					}
 				} else {
 					int satisfy = query(event[i][2]);
-					if (satisfy >= event[i][4]) {
+					if (satisfy >= event[i][3]) {
 						clone(lset[++lsiz], event[i]);
 					} else {
-						event[i][4] -= satisfy;
+						event[i][3] -= satisfy;
 						clone(rset[++rsiz], event[i]);
 					}
 				}
@@ -280,13 +292,13 @@ public static void main(String[] args) throws Exception {
 			int ablca = lca(a, b);
 			if (ablca == a) {
 				int son = lcaSon(a, b);
-				addPlate(1, ldfn[b], rdfn[b], c, 1);
-				addPlate(ldfn[son], ldfn[b], rdfn[b], c, -1);
-				addPlate(ldfn[b], rdfn[son] + 1, n, c, 1);
-				addPlate(rdfn[b] + 1, rdfn[son] + 1, n, c, -1);
+				addPlate(1, ldfn[b], rdfn[b], c);
+				delPlate(ldfn[son], ldfn[b], rdfn[b], c);
+				addPlate(ldfn[b], rdfn[son] + 1, n, c);
+				delPlate(rdfn[b] + 1, rdfn[son] + 1, n, c);
 			} else {
-				addPlate(ldfn[a], ldfn[b], rdfn[b], c, 1);
-				addPlate(rdfn[a] + 1, ldfn[b], rdfn[b], c, -1);
+				addPlate(ldfn[a], ldfn[b], rdfn[b], c);
+				delPlate(rdfn[a] + 1, ldfn[b], rdfn[b], c);
 			}
 		}
 		for (int i = 1; i <= q; i++) {
diff --git a/src/class169/Code04_Fruit2.java b/src/class169/Code04_Fruit2.java
index 0a4597d9a..3ce666ea2 100644
--- a/src/class169/Code04_Fruit2.java
+++ b/src/class169/Code04_Fruit2.java
@@ -18,7 +18,7 @@
 //using namespace std;
 //
 //struct Event {
-//    int op, x, yl, yr, v, d;
+//    int op, x, yl, yr, v;
 //};
 //
 //bool EventCmp(Event e1, Event e2) {
@@ -137,21 +137,28 @@
 //    return ret;
 //}
 //
-//void addPlate(int x, int yl, int yr, int v, int d) {
+//void addPlate(int x, int yl, int yr, int v) {
 //    event[++cnte].op = 1;
 //    event[cnte].x = x;
 //    event[cnte].yl = yl;
 //    event[cnte].yr = yr;
 //    event[cnte].v = v;
-//    event[cnte].d = d;
 //}
 //
-//void addFruit(int x, int y, int v, int d) {
+//void delPlate(int x, int yl, int yr, int v) {
 //    event[++cnte].op = 2;
 //    event[cnte].x = x;
-//    event[cnte].yl = y;
+//    event[cnte].yl = yl;
+//    event[cnte].yr = yr;
 //    event[cnte].v = v;
-//    event[cnte].d = d;
+//}
+//
+//void addFruit(int x, int y, int k, int i) {
+//    event[++cnte].op = 3;
+//    event[cnte].x = x;
+//    event[cnte].yl = y;
+//    event[cnte].yr = k;
+//    event[cnte].v = i;
 //}
 //
 //void compute(int el, int er, int vl, int vr) {
@@ -160,8 +167,8 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = el; i <= er; i++) {
-//            if (event[i].op == 2) {
-//                ans[event[i].d] = vl;
+//            if (event[i].op == 3) {
+//                ans[event[i].v] = vl;
 //            }
 //        }
 //    } else {
@@ -170,17 +177,24 @@
 //        for (int i = el; i <= er; i++) {
 //            if (event[i].op == 1) {
 //                if (event[i].v <= mid) {
-//                    add(event[i].yl, event[i].yr, event[i].d);
+//                    add(event[i].yl, event[i].yr, 1);
+//                    lset[++lsiz] = event[i];
+//                } else {
+//                    rset[++rsiz] = event[i];
+//                }
+//            } else if (event[i].op == 2) {
+//                if (event[i].v <= mid) {
+//                    add(event[i].yl, event[i].yr, -1);
 //                    lset[++lsiz] = event[i];
 //                } else {
 //                    rset[++rsiz] = event[i];
 //                }
 //            } else {
 //                int satisfy = query(event[i].yl);
-//                if (satisfy >= event[i].v) {
+//                if (satisfy >= event[i].yr) {
 //                    lset[++lsiz] = event[i];
 //                } else {
-//                    event[i].v -= satisfy;
+//                    event[i].yr -= satisfy;
 //                    rset[++rsiz] = event[i];
 //                }
 //            }
@@ -216,13 +230,13 @@
 //        int ablca = lca(a, b);
 //        if (ablca == a) {
 //            int son = lcaSon(a, b);
-//            addPlate(1, ldfn[b], rdfn[b], c, 1);
-//            addPlate(ldfn[son], ldfn[b], rdfn[b], c, -1);
-//            addPlate(ldfn[b], rdfn[son] + 1, n, c, 1);
-//            addPlate(rdfn[b] + 1, rdfn[son] + 1, n, c, -1);
+//            addPlate(1, ldfn[b], rdfn[b], c);
+//            delPlate(ldfn[son], ldfn[b], rdfn[b], c);
+//            addPlate(ldfn[b], rdfn[son] + 1, n, c);
+//            delPlate(rdfn[b] + 1, rdfn[son] + 1, n, c);
 //        } else {
-//            addPlate(ldfn[a], ldfn[b], rdfn[b], c, 1);
-//            addPlate(rdfn[a] + 1, ldfn[b], rdfn[b], c, -1);
+//            addPlate(ldfn[a], ldfn[b], rdfn[b], c);
+//            delPlate(rdfn[a] + 1, ldfn[b], rdfn[b], c);
 //        }
 //    }
 //    for (int i = 1, u, v, k; i <= q; i++) {

From 4332e9198dea8a1cdc90c2f04189aeda92052721 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 21 May 2025 22:55:06 +0800
Subject: [PATCH 0847/1712] modify code

---
 src/class091/Code03_GroupBuyTickets2.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class091/Code03_GroupBuyTickets2.java b/src/class091/Code03_GroupBuyTickets2.java
index 0312b6ced..8800d4adb 100644
--- a/src/class091/Code03_GroupBuyTickets2.java
+++ b/src/class091/Code03_GroupBuyTickets2.java
@@ -1,7 +1,8 @@
 package class091;
 
 // 组团买票找到了在线测试
-// 逻辑和课上讲的一样，做了一些小优化
+// 逻辑和课上讲的一样，但是测试中设定的ki为负数
+// 实现做了一些小优化，具体可以看注释
 // 测试链接 : https://www.luogu.com.cn/problem/P12331
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 2ae065cedb5efdc33ea6e4648ce3add184a4d5d8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 22 May 2025 13:18:12 +0800
Subject: [PATCH 0848/1712] modify code

---
 src/class169/Code04_Fruit1.java | 86 +++++++++++++++++++--------------
 src/class169/Code04_Fruit2.java | 56 +++++++++++----------
 2 files changed, 80 insertions(+), 62 deletions(-)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index c81577e2a..429a3cd97 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -25,28 +25,37 @@ public class Code04_Fruit1 {
 	public static int INF = 1000000001;
 	public static int n, p, q;
 
+	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
+	// 树上倍增 + 每棵子树上的ldfn和rdfn
 	public static int[] dep = new int[MAXN];
 	public static int[] ldfn = new int[MAXN];
 	public static int[] rdfn = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXH];
 	public static int cntd = 0;
 
+	// 只有y维度的树状数组
 	public static int[] tree = new int[MAXN];
 
-	// event[i][0] == 1为加盘子事件，x处加，yl..yr词频+1，盘子权值v
-	// event[i][0] == 2为删盘子事件，x处减，yl..yr词频+1，盘子权值v
-	// event[i][0] == 3为水果事件，x、yl、要求yr、问题编号v
-	public static int[][] event = new int[MAXN << 3][5];
+	// 所有事件编号的数组
+	public static int[] eid = new int[MAXN << 3];
+	// 所有事件对象的数组，每个对象有8个属性值
+	// event[i][0] == 1为加盘子事件，x处加，yl..yr词频+1，盘子权值v、空缺、空缺、空缺
+	// event[i][0] == 2为删盘子事件，x处减，yl..yr词频+1，盘子权值v、空缺、空缺、空缺
+	// event[i][0] == 3为水果事件，x、空缺、空缺、空缺、y、要求k、问题编号i
+	public static int[][] event = new int[MAXN << 3][8];
+	// 事件的总数
 	public static int cnte = 0;
 
-	public static int[][] lset = new int[MAXN << 3][5];
-	public static int[][] rset = new int[MAXN << 3][5];
+	// 整体二分
+	public static int[] lset = new int[MAXN << 3];
+	public static int[] rset = new int[MAXN << 3];
 
+	// 每个水果的答案
 	public static int[] ans = new int[MAXN];
 
 	public static void addEdge(int u, int v) {
@@ -141,6 +150,8 @@ public static int lca(int a, int b) {
 		return stjump[a][0];
 	}
 
+	// 已知a和b的最低公共祖先一定是a或b
+	// 假设祖先为x，后代为y，返回x的哪个儿子的子树里有y
 	public static int lcaSon(int a, int b) {
 		if (dep[a] < dep[b]) {
 			int tmp = a;
@@ -166,11 +177,13 @@ public static void add(int i, int v) {
 		}
 	}
 
+	// 树状数组中[l..r]范围上的每个数增加v
 	public static void add(int l, int r, int v) {
 		add(l, v);
 		add(r + 1, -v);
 	}
 
+	// 树状数组中查询单点的值
 	public static int query(int i) {
 		int ret = 0;
 		while (i > 0) {
@@ -196,20 +209,13 @@ public static void delPlate(int x, int yl, int yr, int v) {
 		event[cnte][4] = v;
 	}
 
-	public static void addFruit(int x, int y, int v, int i) {
+	public static void addFruit(int x, int y, int k, int i) {
 		event[++cnte][0] = 3;
 		event[cnte][1] = x;
-		event[cnte][2] = y;
-		event[cnte][3] = v;
-		event[cnte][4] = i;
-	}
-
-	public static void clone(int[] a, int[] b) {
-		a[0] = b[0];
-		a[1] = b[1];
-		a[2] = b[2];
-		a[3] = b[3];
-		a[4] = b[4];
+		// 2、3、4位空缺
+		event[cnte][5] = y;
+		event[cnte][6] = k;
+		event[cnte][7] = i;
 	}
 
 	public static void compute(int el, int er, int vl, int vr) {
@@ -218,35 +224,37 @@ public static void compute(int el, int er, int vl, int vr) {
 		}
 		if (vl == vr) {
 			for (int i = el; i <= er; i++) {
-				if (event[i][0] == 3) {
-					ans[event[i][4]] = vl;
+				int id = eid[i];
+				if (event[id][0] == 3) {
+					ans[event[id][7]] = vl;
 				}
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
 			int lsiz = 0, rsiz = 0;
 			for (int i = el; i <= er; i++) {
-				if (event[i][0] == 1) {
-					if (event[i][4] <= mid) {
-						add(event[i][2], event[i][3], 1);
-						clone(lset[++lsiz], event[i]);
+				int id = eid[i];
+				if (event[id][0] == 1) {
+					if (event[id][4] <= mid) {
+						add(event[id][2], event[id][3], 1);
+						lset[++lsiz] = id;
 					} else {
-						clone(rset[++rsiz], event[i]);
+						rset[++rsiz] = id;
 					}
-				} else if (event[i][0] == 2) {
-					if (event[i][4] <= mid) {
-						add(event[i][2], event[i][3], -1);
-						clone(lset[++lsiz], event[i]);
+				} else if (event[id][0] == 2) {
+					if (event[id][4] <= mid) {
+						add(event[id][2], event[id][3], -1);
+						lset[++lsiz] = id;
 					} else {
-						clone(rset[++rsiz], event[i]);
+						rset[++rsiz] = id;
 					}
 				} else {
-					int satisfy = query(event[i][2]);
-					if (satisfy >= event[i][3]) {
-						clone(lset[++lsiz], event[i]);
+					int satisfy = query(event[id][5]);
+					if (satisfy >= event[id][6]) {
+						lset[++lsiz] = id;
 					} else {
-						event[i][3] -= satisfy;
-						clone(rset[++rsiz], event[i]);
+						event[id][6] -= satisfy;
+						rset[++rsiz] = id;
 					}
 				}
 			}
@@ -257,10 +265,10 @@ public static void compute(int el, int er, int vl, int vr) {
 			// 同一个盘子的两条扫描线，一定会在一起，是不可能分开的
 			// 所以此时树状数组就是清空的，不需要再做撤销操作
 			for (int i = 1; i <= lsiz; i++) {
-				clone(event[el + i - 1], lset[i]);
+				eid[el + i - 1] = lset[i];
 			}
 			for (int i = 1; i <= rsiz; i++) {
-				clone(event[el + lsiz + i - 1], rset[i]);
+				eid[el + lsiz + i - 1] = rset[i];
 			}
 			compute(el, el + lsiz - 1, vl, mid);
 			compute(el + lsiz, er, mid + 1, vr);
@@ -307,7 +315,11 @@ public static void main(String[] args) throws Exception {
 			int k = in.nextInt();
 			addFruit(Math.min(ldfn[u], ldfn[v]), Math.max(ldfn[u], ldfn[v]), k, i);
 		}
+		// 根据x排序，如果x一样，加盘子排最前、删盘子其次、水果最后
 		Arrays.sort(event, 1, cnte + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[0] - b[0]);
+		for (int i = 1; i <= cnte; i++) {
+			eid[i] = i;
+		}
 		compute(1, cnte, 0, INF);
 		for (int i = 1; i <= q; i++) {
 			out.println(ans[i]);
diff --git a/src/class169/Code04_Fruit2.java b/src/class169/Code04_Fruit2.java
index 3ce666ea2..792e30012 100644
--- a/src/class169/Code04_Fruit2.java
+++ b/src/class169/Code04_Fruit2.java
@@ -18,7 +18,7 @@
 //using namespace std;
 //
 //struct Event {
-//    int op, x, yl, yr, v;
+//    int op, x, yl, yr, v, y, k, i;
 //};
 //
 //bool EventCmp(Event e1, Event e2) {
@@ -46,11 +46,12 @@
 //
 //int tree[MAXN];
 //
+//int eid[MAXN << 3];
 //Event event[MAXN << 3];
 //int cnte = 0;
 //
-//Event lset[MAXN << 3];
-//Event rset[MAXN << 3];
+//int lset[MAXN << 3];
+//int rset[MAXN << 3];
 //
 //int ans[MAXN];
 //
@@ -156,9 +157,9 @@
 //void addFruit(int x, int y, int k, int i) {
 //    event[++cnte].op = 3;
 //    event[cnte].x = x;
-//    event[cnte].yl = y;
-//    event[cnte].yr = k;
-//    event[cnte].v = i;
+//    event[cnte].y = y;
+//    event[cnte].k = k;
+//    event[cnte].i = i;
 //}
 //
 //void compute(int el, int er, int vl, int vr) {
@@ -167,43 +168,45 @@
 //    }
 //    if (vl == vr) {
 //        for (int i = el; i <= er; i++) {
-//            if (event[i].op == 3) {
-//                ans[event[i].v] = vl;
+//            int id = eid[i];
+//            if (event[id].op == 3) {
+//                ans[event[id].i] = vl;
 //            }
 //        }
 //    } else {
 //        int mid = (vl + vr) >> 1;
 //        int lsiz = 0, rsiz = 0;
 //        for (int i = el; i <= er; i++) {
-//            if (event[i].op == 1) {
-//                if (event[i].v <= mid) {
-//                    add(event[i].yl, event[i].yr, 1);
-//                    lset[++lsiz] = event[i];
+//            int id = eid[i];
+//            if (event[id].op == 1) {
+//                if (event[id].v <= mid) {
+//                    add(event[id].yl, event[id].yr, 1);
+//                    lset[++lsiz] = id;
 //                } else {
-//                    rset[++rsiz] = event[i];
+//                    rset[++rsiz] = id;
 //                }
-//            } else if (event[i].op == 2) {
-//                if (event[i].v <= mid) {
-//                    add(event[i].yl, event[i].yr, -1);
-//                    lset[++lsiz] = event[i];
+//            } else if (event[id].op == 2) {
+//                if (event[id].v <= mid) {
+//                    add(event[id].yl, event[id].yr, -1);
+//                    lset[++lsiz] = id;
 //                } else {
-//                    rset[++rsiz] = event[i];
+//                    rset[++rsiz] = id;
 //                }
 //            } else {
-//                int satisfy = query(event[i].yl);
-//                if (satisfy >= event[i].yr) {
-//                    lset[++lsiz] = event[i];
+//                int satisfy = query(event[id].y);
+//                if (satisfy >= event[id].k) {
+//                    lset[++lsiz] = id;
 //                } else {
-//                    event[i].yr -= satisfy;
-//                    rset[++rsiz] = event[i];
+//                    event[id].k -= satisfy;
+//                    rset[++rsiz] = id;
 //                }
 //            }
 //        }
 //        for (int i = 1; i <= lsiz; i++) {
-//            event[el + i - 1] = lset[i];
+//            eid[el + i - 1] = lset[i];
 //        }
 //        for (int i = 1; i <= rsiz; i++) {
-//            event[el + lsiz + i - 1] = rset[i];
+//            eid[el + lsiz + i - 1] = rset[i];
 //        }
 //        compute(el, el + lsiz - 1, vl, mid);
 //        compute(el + lsiz, er, mid + 1, vr);
@@ -244,6 +247,9 @@
 //        addFruit(min(ldfn[u], ldfn[v]), max(ldfn[u], ldfn[v]), k, i);
 //    }
 //    sort(event + 1, event + cnte + 1, EventCmp);
+//    for (int i = 1; i <= cnte; i++) {
+//        eid[i] = i;
+//    }
 //    compute(1, cnte, 0, INF);
 //    for (int i = 1; i <= q; i++) {
 //        cout << ans[i] << '\n';

From cb0d474add4b6cdff0eaf9c43fe6f5879560e96c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 22 May 2025 13:19:59 +0800
Subject: [PATCH 0849/1712] modify code

---
 src/class169/Code04_Fruit1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index 429a3cd97..747e21db6 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -43,7 +43,7 @@ public class Code04_Fruit1 {
 
 	// 所有事件编号的数组
 	public static int[] eid = new int[MAXN << 3];
-	// 所有事件对象的数组，每个对象有8个属性值
+	// 每个对象有8个属性值
 	// event[i][0] == 1为加盘子事件，x处加，yl..yr词频+1，盘子权值v、空缺、空缺、空缺
 	// event[i][0] == 2为删盘子事件，x处减，yl..yr词频+1，盘子权值v、空缺、空缺、空缺
 	// event[i][0] == 3为水果事件，x、空缺、空缺、空缺、y、要求k、问题编号i

From cbbe6a2daea693d6b12e285788d0348d2a2b81be Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 22 May 2025 15:43:06 +0800
Subject: [PATCH 0850/1712] modify code

---
 src/class169/Code04_Fruit1.java | 13 ++++++++-----
 1 file changed, 8 insertions(+), 5 deletions(-)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index 747e21db6..586cf7eb8 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -41,12 +41,12 @@ public class Code04_Fruit1 {
 	// 只有y维度的树状数组
 	public static int[] tree = new int[MAXN];
 
-	// 所有事件编号的数组
+	// 所有事件排完序之后，依次把下标放入eid数组
 	public static int[] eid = new int[MAXN << 3];
-	// 每个对象有8个属性值
-	// event[i][0] == 1为加盘子事件，x处加，yl..yr词频+1，盘子权值v、空缺、空缺、空缺
-	// event[i][0] == 2为删盘子事件，x处减，yl..yr词频+1，盘子权值v、空缺、空缺、空缺
-	// event[i][0] == 3为水果事件，x、空缺、空缺、空缺、y、要求k、问题编号i
+	// 每个事件有8个属性值
+	// op==1加盘子，x处加、yl、yr，盘子权值v、空缺、空缺、空缺
+	// op==2删盘子，x处删、yl、yr，盘子权值v、空缺、空缺、空缺
+	// op==3为水果，x、空缺、空缺、空缺、y、要求k、问题编号i
 	public static int[][] event = new int[MAXN << 3][8];
 	// 事件的总数
 	public static int cnte = 0;
@@ -300,11 +300,14 @@ public static void main(String[] args) throws Exception {
 			int ablca = lca(a, b);
 			if (ablca == a) {
 				int son = lcaSon(a, b);
+				// (1 ~ dfn[son]-1) (b子树上的dfn范围)
 				addPlate(1, ldfn[b], rdfn[b], c);
 				delPlate(ldfn[son], ldfn[b], rdfn[b], c);
+				// (b子树上的dfn范围) (son子树上最大的dfn序号+1 ~ n)
 				addPlate(ldfn[b], rdfn[son] + 1, n, c);
 				delPlate(rdfn[b] + 1, rdfn[son] + 1, n, c);
 			} else {
+				// (a子树上的dfn范围) (b子树上的dfn范围)
 				addPlate(ldfn[a], ldfn[b], rdfn[b], c);
 				delPlate(rdfn[a] + 1, ldfn[b], rdfn[b], c);
 			}

From 0a2c6450cef1e98a1ae96ac14d55fb4bba28de61 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 22 May 2025 15:46:47 +0800
Subject: [PATCH 0851/1712] modify code

---
 src/class169/Code04_Fruit1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index 586cf7eb8..cf5ad6cad 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -298,6 +298,8 @@ public static void main(String[] args) throws Exception {
 				b = tmp;
 			}
 			int ablca = lca(a, b);
+			// 类型1，a和b的lca是a或b，2个区域，4个事件产生
+			// 类型2，a和b的lca不是a或b，1个区域，2个事件产生
 			if (ablca == a) {
 				int son = lcaSon(a, b);
 				// (1 ~ dfn[son]-1) (b子树上的dfn范围)

From b0e8a99db37c685107b60bc9e09fab0c36d4678c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 22 May 2025 16:10:34 +0800
Subject: [PATCH 0852/1712] modify code

---
 src/class169/Code04_Fruit1.java | 2 +-
 src/class169/Code04_Fruit2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class169/Code04_Fruit1.java b/src/class169/Code04_Fruit1.java
index cf5ad6cad..8ef093a86 100644
--- a/src/class169/Code04_Fruit1.java
+++ b/src/class169/Code04_Fruit1.java
@@ -300,7 +300,7 @@ public static void main(String[] args) throws Exception {
 			int ablca = lca(a, b);
 			// 类型1，a和b的lca是a或b，2个区域，4个事件产生
 			// 类型2，a和b的lca不是a或b，1个区域，2个事件产生
-			if (ablca == a) {
+			if (ablca == a || ablca == b) {
 				int son = lcaSon(a, b);
 				// (1 ~ dfn[son]-1) (b子树上的dfn范围)
 				addPlate(1, ldfn[b], rdfn[b], c);
diff --git a/src/class169/Code04_Fruit2.java b/src/class169/Code04_Fruit2.java
index 792e30012..1a16cbc3d 100644
--- a/src/class169/Code04_Fruit2.java
+++ b/src/class169/Code04_Fruit2.java
@@ -231,7 +231,7 @@
 //            b = tmp;
 //        }
 //        int ablca = lca(a, b);
-//        if (ablca == a) {
+//        if (ablca == a || ablca == b) {
 //            int son = lcaSon(a, b);
 //            addPlate(1, ldfn[b], rdfn[b], c);
 //            delPlate(ldfn[son], ldfn[b], rdfn[b], c);

From a3d334fe752d90072776d4839ac30403a630f7b8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 22 May 2025 17:01:29 +0800
Subject: [PATCH 0853/1712] modify code

---
 src/class169/Code05_PastoralOddities1.java | 2 +-
 src/class169/Code05_PastoralOddities2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index 55f247375..86bd5ed2e 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -3,7 +3,7 @@
 // 度为奇最小瓶颈，java版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
 // 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
-// 如果存在，希望边集的最大边权，尽可能小，一共有m条打印
+// 如果存在，希望边集的最大边权，尽可能小，如果不存在打印-1
 // 2 <= n <= 10^5
 // 1 <= m <= 3 * 10^5
 // 1 <= 边权 <= 10^9
diff --git a/src/class169/Code05_PastoralOddities2.java b/src/class169/Code05_PastoralOddities2.java
index a8a99a0b1..40d131642 100644
--- a/src/class169/Code05_PastoralOddities2.java
+++ b/src/class169/Code05_PastoralOddities2.java
@@ -3,7 +3,7 @@
 // 度为奇最小瓶颈，C++版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
 // 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
-// 如果存在，希望边集的最大边权，尽可能小，一共有m条打印
+// 如果存在，希望边集的最大边权，尽可能小，如果不存在打印-1
 // 2 <= n <= 10^5
 // 1 <= m <= 3 * 10^5
 // 1 <= 边权 <= 10^9

From 5571c829f7e466e0a84249efa91776391bbd2cad Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 22 May 2025 17:07:50 +0800
Subject: [PATCH 0854/1712] modify code

---
 src/class169/Code05_PastoralOddities1.java | 2 +-
 src/class169/Code05_PastoralOddities2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index 86bd5ed2e..6fa8dc0fd 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -1,6 +1,6 @@
 package class169;
 
-// 度为奇最小瓶颈，java版
+// 点的度都是奇数的最小瓶颈，java版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
 // 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
 // 如果存在，希望边集的最大边权，尽可能小，如果不存在打印-1
diff --git a/src/class169/Code05_PastoralOddities2.java b/src/class169/Code05_PastoralOddities2.java
index 40d131642..261867549 100644
--- a/src/class169/Code05_PastoralOddities2.java
+++ b/src/class169/Code05_PastoralOddities2.java
@@ -1,6 +1,6 @@
 package class169;
 
-// 度为奇最小瓶颈，C++版
+// 点的度都是奇数的最小瓶颈，C++版
 // 一共有n个点，初始没有边，依次加入m条无向边，每条边有边权
 // 每次加入后，询问是否存在一个边集，满足每个点连接的边的数量都是奇数
 // 如果存在，希望边集的最大边权，尽可能小，如果不存在打印-1

From acd9263392cdcfdee3020526179f31c882a2000d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 23 May 2025 18:25:10 +0800
Subject: [PATCH 0855/1712] modify code

---
 src/class169/Code05_PastoralOddities1.java | 55 ++++++++++++++--------
 src/class169/Code05_PastoralOddities2.java | 30 ++++++++----
 2 files changed, 55 insertions(+), 30 deletions(-)

diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index 6fa8dc0fd..191d397a4 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -20,22 +20,21 @@
 public class Code05_PastoralOddities1 {
 
 	public static int MAXN = 100001;
-	public static int MAXM = 300002;
+	public static int MAXM = 300001;
 	public static int n, m;
 
 	// edge是按时序组织的边数组
 	// wsort是按权值组织的边数组
-	// 边的时序i、端点x、端点y、权值w
-	public static int[][] edge = new int[MAXM][4];
-	public static int[][] wsort = new int[MAXM][4];
+	// 每条边有：端点x、端点y、权值w、时序tim、排名rak
+	public static int[][] edge = new int[MAXM][5];
+	public static int[][] wsort = new int[MAXM][5];
 
-	// 可撤销并查集
+	// 可撤销并查集 + 维护节点数为奇数的连通区数量oddnum
+	public static int oddnum;
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXN][2];
 	public static int opsize = 0;
-	// 节点数为奇数的联通区数量
-	public static int oddnum;
 
 	public static int[] ans = new int[MAXM];
 
@@ -77,9 +76,9 @@ public static void undo() {
 		}
 	}
 
-	// 按时序组织的边在edge里，当前来到[ql..qr]范围
+	// 按时序组织的边在edge里，当前来到[el..er]范围
 	// 按权值组织的边在wsort里，答案范围[vl..vr]
-	// 前提 : ql之前的边里，边权 <= wsort[vl].w 的所有边，都已经加到图上了
+	// 调用递归的前提 : el之前，边权排名<vl的边，已经加到图里了
 	// 利用整体二分得到所有边的答案
 	public static void compute(int el, int er, int vl, int vr) {
 		if (el > er) {
@@ -91,19 +90,21 @@ public static void compute(int el, int er, int vl, int vr) {
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
+			// 1) el之前，边权排名在[vl..mid]之间的边，加到图里，遍历wsort[vl..mid]来加速
 			int unionCnt1 = 0;
 			for (int i = vl; i <= mid; i++) {
-				if (wsort[i][0] < el) {
-					if (union(wsort[i][1], wsort[i][2])) {
+				if (wsort[i][3] < el) {
+					if (union(wsort[i][0], wsort[i][1])) {
 						unionCnt1++;
 					}
 				}
 			}
+			// 2) 从el开始，边权排名<=mid的边，加到图里，找到第一个达标的边split
 			int unionCnt2 = 0;
 			int split = er + 1;
 			for (int i = el; i <= er; i++) {
-				if (edge[i][3] <= wsort[mid][3]) {
-					if (union(edge[i][1], edge[i][2])) {
+				if (edge[i][4] <= mid) {
+					if (union(edge[i][0], edge[i][1])) {
 						unionCnt2++;
 					}
 				}
@@ -112,22 +113,28 @@ public static void compute(int el, int er, int vl, int vr) {
 					break;
 				}
 			}
+			// 3) 撤销2)的效果，el之前，边权排名<=mid的边，都在图中
 			for (int i = 1; i <= unionCnt2; i++) {
 				undo();
 			}
+			// 4) 执行compute(el, split - 1, mid + 1, vr)，此时满足子递归的前提
 			compute(el, split - 1, mid + 1, vr);
+			// 5) 撤销1)的效果，此时只剩下前提了，el之前，边权排名<vl的边，都在图中
 			for (int i = 1; i <= unionCnt1; i++) {
 				undo();
 			}
+			// 6) 从el开始到split之前，边权排名<vl的边，加到图里
 			int unionCnt3 = 0;
 			for (int i = el; i <= split - 1; i++) {
-				if (edge[i][3] <= wsort[vl][3]) {
-					if (union(edge[i][1], edge[i][2])) {
+				if (edge[i][4] < vl) {
+					if (union(edge[i][0], edge[i][1])) {
 						unionCnt3++;
 					}
 				}
 			}
+			// 7) 执行compute(split, er, vl, mid)，此时满足子递归的前提
 			compute(split, er, vl, mid);
+			// 8) 撤销6)的效果，回到了前提
 			for (int i = 1; i <= unionCnt3; i++) {
 				undo();
 			}
@@ -146,8 +153,12 @@ public static void prepare() {
 			wsort[i][2] = edge[i][2];
 			wsort[i][3] = edge[i][3];
 		}
-		Arrays.sort(wsort, 1, m + 1, (a, b) -> a[3] - b[3]);
-		wsort[m + 1][3] = -1;
+		Arrays.sort(wsort, 1, m + 1, (a, b) -> a[2] - b[2]);
+		// edge数组和wsort数组里的每条边，设置排名信息
+		for (int i = 1; i <= m; i++) {
+			wsort[i][4] = i;
+			edge[wsort[i][3]][4] = i;
+		}
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -156,15 +167,19 @@ public static void main(String[] args) throws Exception {
 		n = in.nextInt();
 		m = in.nextInt();
 		for (int i = 1; i <= m; i++) {
-			edge[i][0] = i;
+			edge[i][0] = in.nextInt();
 			edge[i][1] = in.nextInt();
 			edge[i][2] = in.nextInt();
-			edge[i][3] = in.nextInt();
+			edge[i][3] = i;
 		}
 		prepare();
 		compute(1, m, 1, m + 1);
 		for (int i = 1; i <= m; i++) {
-			out.println(wsort[ans[i]][3]);
+			if (ans[i] == m + 1) {
+				out.println(-1);
+			} else {
+				out.println(wsort[ans[i]][2]);
+			}
 		}
 		out.flush();
 		out.close();
diff --git a/src/class169/Code05_PastoralOddities2.java b/src/class169/Code05_PastoralOddities2.java
index 261867549..806c535f3 100644
--- a/src/class169/Code05_PastoralOddities2.java
+++ b/src/class169/Code05_PastoralOddities2.java
@@ -17,7 +17,7 @@
 //using namespace std;
 //
 //struct Edge {
-//    int i, x, y, w;
+//    int x, y, w, tim, rak;
 //};
 //
 //bool EdgeCmp(Edge a, Edge b) {
@@ -25,17 +25,17 @@
 //}
 //
 //const int MAXN = 100001;
-//const int MAXM = 300002;
+//const int MAXM = 300001;
 //int n, m;
 //
 //Edge edge[MAXM];
 //Edge wsort[MAXM];
 //
+//int oddnum;
 //int father[MAXN];
 //int siz[MAXN];
 //int rollback[MAXN][2];
 //int opsize = 0;
-//int oddnum;
 //
 //int ans[MAXM];
 //
@@ -89,7 +89,7 @@
 //        int mid = (vl + vr) >> 1;
 //        int unionCnt1 = 0;
 //        for (int i = vl; i <= mid; i++) {
-//            if (wsort[i].i < el) {
+//            if (wsort[i].tim < el) {
 //                if (Union(wsort[i].x, wsort[i].y)) {
 //                    unionCnt1++;
 //                }
@@ -98,7 +98,7 @@
 //        int unionCnt2 = 0;
 //        int split = er + 1;
 //        for (int i = el; i <= er; i++) {
-//            if (edge[i].w <= wsort[mid].w) {
+//            if (edge[i].rak <= mid) {
 //                if (Union(edge[i].x, edge[i].y)) {
 //                    unionCnt2++;
 //                }
@@ -117,7 +117,7 @@
 //        }
 //        int unionCnt3 = 0;
 //        for (int i = el; i <= split - 1; i++) {
-//            if (edge[i].w <= wsort[vl].w) {
+//            if (edge[i].rak < vl) {
 //                if (Union(edge[i].x, edge[i].y)) {
 //                    unionCnt3++;
 //                }
@@ -137,10 +137,16 @@
 //        siz[i] = 1;
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        wsort[i] = edge[i];
+//        wsort[i].x = edge[i].x;
+//        wsort[i].y = edge[i].y;
+//        wsort[i].w = edge[i].w;
+//        wsort[i].tim = edge[i].tim;
 //    }
 //    sort(wsort + 1, wsort + m + 1, EdgeCmp);
-//    wsort[m + 1].w = -1;
+//    for (int i = 1; i <= m; i++) {
+//        wsort[i].rak = i;
+//        edge[wsort[i].tim].rak = i;
+//    }
 //}
 //
 //int main() {
@@ -148,13 +154,17 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 1; i <= m; i++) {
-//        edge[i].i = i;
 //        cin >> edge[i].x >> edge[i].y >> edge[i].w;
+//        edge[i].tim = i;
 //    }
 //    prepare();
 //    compute(1, m, 1, m + 1);
 //    for (int i = 1; i <= m; i++) {
-//        cout << wsort[ans[i]].w << '\n';
+//        if (ans[i] == m + 1) {
+//            cout << -1 << '\n';
+//        } else {
+//            cout << wsort[ans[i]].w << '\n';
+//        }
 //    }
 //    return 0;
 //}
\ No newline at end of file

From 83c0f60cd7f456173eecee6bc41816687d133153 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 23 May 2025 18:29:45 +0800
Subject: [PATCH 0856/1712] modify code

---
 src/class169/Code05_PastoralOddities1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index 191d397a4..e2aaac269 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -90,7 +90,7 @@ public static void compute(int el, int er, int vl, int vr) {
 			}
 		} else {
 			int mid = (vl + vr) >> 1;
-			// 1) el之前，边权排名在[vl..mid]之间的边，加到图里，遍历wsort[vl..mid]来加速
+			// 1) el之前，边权排名在[vl..mid]之间的边，加到图里，通过遍历wsort[vl..mid]来加速
 			int unionCnt1 = 0;
 			for (int i = vl; i <= mid; i++) {
 				if (wsort[i][3] < el) {
@@ -99,7 +99,7 @@ public static void compute(int el, int er, int vl, int vr) {
 					}
 				}
 			}
-			// 2) 从el开始，边权排名<=mid的边，加到图里，找到第一个达标的边split
+			// 2) 从el开始遍历，边权排名<=mid的边，加到图里，找到第一个达标的边split
 			int unionCnt2 = 0;
 			int split = er + 1;
 			for (int i = el; i <= er; i++) {
@@ -117,7 +117,7 @@ public static void compute(int el, int er, int vl, int vr) {
 			for (int i = 1; i <= unionCnt2; i++) {
 				undo();
 			}
-			// 4) 执行compute(el, split - 1, mid + 1, vr)，此时满足子递归的前提
+			// 4) 执行 compute(el, split - 1, mid + 1, vr)，此时满足子递归的前提
 			compute(el, split - 1, mid + 1, vr);
 			// 5) 撤销1)的效果，此时只剩下前提了，el之前，边权排名<vl的边，都在图中
 			for (int i = 1; i <= unionCnt1; i++) {
@@ -132,7 +132,7 @@ public static void compute(int el, int er, int vl, int vr) {
 					}
 				}
 			}
-			// 7) 执行compute(split, er, vl, mid)，此时满足子递归的前提
+			// 7) 执行 compute(split, er, vl, mid)，此时满足子递归的前提
 			compute(split, er, vl, mid);
 			// 8) 撤销6)的效果，回到了前提
 			for (int i = 1; i <= unionCnt3; i++) {

From dd5f60a543907264f90dd2780f7a24e9d0ddac4a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 23 May 2025 18:33:33 +0800
Subject: [PATCH 0857/1712] modify code

---
 src/class169/Code05_PastoralOddities1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index e2aaac269..04fbb6eb0 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -25,7 +25,7 @@ public class Code05_PastoralOddities1 {
 
 	// edge是按时序组织的边数组
 	// wsort是按权值组织的边数组
-	// 每条边有：端点x、端点y、权值w、时序tim、排名rak
+	// 每条边有：端点x、端点y、边权w、时序tim、边权排名rak
 	public static int[][] edge = new int[MAXM][5];
 	public static int[][] wsort = new int[MAXM][5];
 
@@ -154,7 +154,7 @@ public static void prepare() {
 			wsort[i][3] = edge[i][3];
 		}
 		Arrays.sort(wsort, 1, m + 1, (a, b) -> a[2] - b[2]);
-		// edge数组和wsort数组里的每条边，设置排名信息
+		// edge数组、wsort数组，每条边设置排名信息
 		for (int i = 1; i <= m; i++) {
 			wsort[i][4] = i;
 			edge[wsort[i][3]][4] = i;

From b3641c888682a4d317f198e3a658bddab3d0d5a0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 23 May 2025 18:50:07 +0800
Subject: [PATCH 0858/1712] modify code

---
 src/class169/Code05_PastoralOddities1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index 04fbb6eb0..a89ae24fc 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -23,8 +23,8 @@ public class Code05_PastoralOddities1 {
 	public static int MAXM = 300001;
 	public static int n, m;
 
-	// edge是按时序组织的边数组
-	// wsort是按权值组织的边数组
+	// edge代表所有边依次出现
+	// wsort代表所有边按边权排序
 	// 每条边有：端点x、端点y、边权w、时序tim、边权排名rak
 	public static int[][] edge = new int[MAXM][5];
 	public static int[][] wsort = new int[MAXM][5];
@@ -76,8 +76,8 @@ public static void undo() {
 		}
 	}
 
-	// 按时序组织的边在edge里，当前来到[el..er]范围
-	// 按权值组织的边在wsort里，答案范围[vl..vr]
+	// 依次出现的边在edge里，当前来到[el..er]范围
+	// 权值排序后的边在wsort里，答案范围[vl..vr]，同时也是排名范围
 	// 调用递归的前提 : el之前，边权排名<vl的边，已经加到图里了
 	// 利用整体二分得到所有边的答案
 	public static void compute(int el, int er, int vl, int vr) {

From 9250a94754eadcd1f6a4c27578c44105779d3aef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 23 May 2025 21:27:50 +0800
Subject: [PATCH 0859/1712] modify code

---
 src/class169/Code05_PastoralOddities1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class169/Code05_PastoralOddities1.java b/src/class169/Code05_PastoralOddities1.java
index a89ae24fc..e028ad6b3 100644
--- a/src/class169/Code05_PastoralOddities1.java
+++ b/src/class169/Code05_PastoralOddities1.java
@@ -29,7 +29,7 @@ public class Code05_PastoralOddities1 {
 	public static int[][] edge = new int[MAXM][5];
 	public static int[][] wsort = new int[MAXM][5];
 
-	// 可撤销并查集 + 维护节点数为奇数的连通区数量oddnum
+	// 可撤销并查集 + 节点数为奇数的连通区数量为oddnum
 	public static int oddnum;
 	public static int[] father = new int[MAXN];
 	public static int[] siz = new int[MAXN];

From 3b65e1a1a8bd3caf95e80ad7f33a29567ce8e779 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 23 May 2025 22:05:57 +0800
Subject: [PATCH 0860/1712] modify code

---
 ...3\344\272\214\345\210\206-\344\270\213.pptx" | Bin 0 -> 48349 bytes
 src/class169/Code06_IvanAndBurgers1.java        |   1 +
 2 files changed, 1 insertion(+)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243169\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\213.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243169\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\213.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243169\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\213.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..9b01581dc1d378f2330b68b63b00b9022c063423
GIT binary patch
literal 48349
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
GpZ)_oCO5YL

literal 0
HcmV?d00001

diff --git a/src/class169/Code06_IvanAndBurgers1.java b/src/class169/Code06_IvanAndBurgers1.java
index 01b51188a..7cbb79d17 100644
--- a/src/class169/Code06_IvanAndBurgers1.java
+++ b/src/class169/Code06_IvanAndBurgers1.java
@@ -30,6 +30,7 @@ public class Code06_IvanAndBurgers1 {
 
 	public static int[] lset = new int[MAXN];
 	public static int[] rset = new int[MAXN];
+
 	public static int[] ans = new int[MAXN];
 
 	public static void insert(int[] basis, int num) {

From 5e17eb625cd3fefb219a70caadbf91c3e0d7973c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 23 May 2025 22:06:22 +0800
Subject: [PATCH 0861/1712] modify code

---
 src/class169/Code06_IvanAndBurgers2.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class169/Code06_IvanAndBurgers2.java b/src/class169/Code06_IvanAndBurgers2.java
index c9606fc42..5b9c607ea 100644
--- a/src/class169/Code06_IvanAndBurgers2.java
+++ b/src/class169/Code06_IvanAndBurgers2.java
@@ -28,6 +28,7 @@
 //
 //int lset[MAXN];
 //int rset[MAXN];
+//
 //int ans[MAXN];
 //
 //void insert(int* basis, int num) {

From 92c3dcd5c2f9c14cf39078e93e202f619d81295a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 26 May 2025 15:24:37 +0800
Subject: [PATCH 0862/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java | 177 +++++++++++++++++++++++
 src/class170/Code01_3DPartialOrder2.java | 123 ++++++++++++++++
 2 files changed, 300 insertions(+)
 create mode 100644 src/class170/Code01_3DPartialOrder1.java
 create mode 100644 src/class170/Code01_3DPartialOrder2.java

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
new file mode 100644
index 000000000..6b6cb0b68
--- /dev/null
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -0,0 +1,177 @@
+package class170;
+
+// 三维偏序，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3810
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_3DPartialOrder1 {
+
+	public static int MAXN = 200001;
+	public static int n, k;
+
+	// 位置i、属性a、属性b、属性c
+	public static int[][] arr = new int[MAXN][4];
+	// 归并排序辅助数组
+	public static int[][] help = new int[MAXN][4];
+	// 树状数组
+	public static int[] tree = new int[MAXN];
+	// 每个位置统计f(i)
+	public static int[] f = new int[MAXN];
+	// 答案
+	public static int[] ans = new int[MAXN];
+
+	public static void clone(int[] a, int[] b) {
+		a[0] = b[0];
+		a[1] = b[1];
+		a[2] = b[2];
+		a[3] = b[3];
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= k) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int query(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void merge(int l, int m, int r) {
+		// 利用左右各自有序，进行不回退的统计
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][2] <= arr[p2][2]) {
+				p1++;
+				add(arr[p1][3], 1);
+			}
+			f[arr[p2][0]] += query(arr[p2][3]);
+		}
+		// 清空树状数组
+		for (int i = l; i <= p1; i++) {
+			add(arr[i][3], -1);
+		}
+		p1 = l;
+		p2 = m + 1;
+		int i = l;
+		while (p1 <= m && p2 <= r) {
+			clone(help[i++], arr[p1][2] <= arr[p2][2] ? arr[p1++] : arr[p2++]);
+		}
+		while (p1 <= m) {
+			clone(help[i++], arr[p1++]);
+		}
+		while (p2 <= r) {
+			clone(help[i++], arr[p2++]);
+		}
+		for (i = l; i <= r; i++) {
+			clone(arr[i], help[i]);
+		}
+	}
+
+	public static void compute(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		compute(l, mid);
+		compute(mid + 1, r);
+		merge(l, mid, r);
+	}
+
+	public static void prepare() {
+		// 根据a排序，a一样根据b排序，b一样根据c排序
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[3] - b[3]);
+		// 排序后，a、b、c都一样的同一组内，组前的下标会得不到组后的下标统计
+		// 所以需要先设置f的初始值
+		for (int l = 1, r = 1; l <= n; l = ++r) {
+			while (r + 1 <= n && arr[l][1] == arr[r + 1][1] && arr[l][2] == arr[r + 1][2]
+					&& arr[l][3] == arr[r + 1][3]) {
+				r++;
+			}
+			for (int i = l; i <= r; i++) {
+				f[arr[i][0]] = r - i;
+			}
+		}
+		// 清空答案数组
+		Arrays.fill(ans, 0, n, 0);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = i;
+			arr[i][1] = in.nextInt();
+			arr[i][2] = in.nextInt();
+			arr[i][3] = in.nextInt();
+		}
+		prepare();
+		compute(1, n);
+		for (int i = 1; i <= n; i++) {
+			ans[f[i]]++;
+		}
+		for (int i = 0; i < n; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class170/Code01_3DPartialOrder2.java b/src/class170/Code01_3DPartialOrder2.java
new file mode 100644
index 000000000..3d61394a2
--- /dev/null
+++ b/src/class170/Code01_3DPartialOrder2.java
@@ -0,0 +1,123 @@
+package class170;
+
+// 三维偏序，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3810
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int i, a, b, c;
+//};
+//
+//bool NumberCmp(Number x, Number y) {
+//    if (x.a != y.a) {
+//        return x.a < y.a;
+//    }
+//    if (x.b != y.b) {
+//        return x.b < y.b;
+//    }
+//    return x.c < y.c;
+//}
+//
+//const int MAXN = 200001;
+//int n, k;
+//Number arr[MAXN];
+//Number help[MAXN];
+//int tree[MAXN];
+//int f[MAXN];
+//int ans[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= k) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int query(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void merge(int l, int m, int r) {
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].b <= arr[p2].b) {
+//            p1++;
+//            add(arr[p1].c, 1);
+//        }
+//        f[arr[p2].i] += query(arr[p2].c);
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        add(arr[i].c, -1);
+//    }
+//    p1 = l;
+//    p2 = m + 1;
+//    int i = l;
+//    while (p1 <= m && p2 <= r) {
+//        help[i++] = arr[p1].b <= arr[p2].b ? arr[p1++] : arr[p2++];
+//    }
+//    while (p1 <= m) {
+//        help[i++] = arr[p1++];
+//    }
+//    while (p2 <= r) {
+//        help[i++] = arr[p2++];
+//    }
+//    for (i = l; i <= r; i++) {
+//        arr[i] = help[i];
+//    }
+//}
+//
+//void compute(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int mid = (l + r) / 2;
+//    compute(l, mid);
+//    compute(mid + 1, r);
+//    merge(l, mid, r);
+//}
+//
+//void prepare() {
+//    sort(arr + 1, arr + n + 1, NumberCmp);
+//    for (int l = 1, r = 1; l <= n; l = ++r) {
+//        while (r + 1 <= n && arr[l].a == arr[r + 1].a && arr[l].b == arr[r + 1].b && arr[l].c == arr[r + 1].c) {
+//            r++;
+//        }
+//        for (int i = l; i <= r; i++) {
+//            f[arr[i].i] = r - i;
+//        }
+//    }
+//    fill(ans, ans + n, 0);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].i = i;
+//        cin >> arr[i].a >> arr[i].b >> arr[i].c;
+//    }
+//    prepare();
+//    compute(1, n);
+//    for (int i = 1; i <= n; i++) {
+//        ans[f[i]]++;
+//    }
+//    for (int i = 0; i < n; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 0860aa42ba730a90ad87d4e20892ac6dea4139b4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 26 May 2025 15:32:23 +0800
Subject: [PATCH 0863/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index 6b6cb0b68..1d2075cb1 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -97,8 +97,8 @@ public static void compute(int l, int r) {
 	public static void prepare() {
 		// 根据a排序，a一样根据b排序，b一样根据c排序
 		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[3] - b[3]);
-		// 排序后，a、b、c都一样的同一组内，组前的下标会得不到组后的下标统计
-		// 所以需要先设置f的初始值
+		// 排序后，a、b、c都一样的同一组内，组前的下标，得不到同组后面的统计量
+		// 所以先设置f的初始值，把这部分补偿给组前的下标
 		for (int l = 1, r = 1; l <= n; l = ++r) {
 			while (r + 1 <= n && arr[l][1] == arr[r + 1][1] && arr[l][2] == arr[r + 1][2]
 					&& arr[l][3] == arr[r + 1][3]) {

From 71aa11512fa6d707915fc9581627e25a99b9b799 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 11:20:54 +0800
Subject: [PATCH 0864/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java | 3 ---
 src/class170/Code01_3DPartialOrder2.java | 1 -
 2 files changed, 4 deletions(-)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index 1d2075cb1..e3917b454 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -14,7 +14,6 @@ public class Code01_3DPartialOrder1 {
 
 	public static int MAXN = 200001;
 	public static int n, k;
-
 	// 位置i、属性a、属性b、属性c
 	public static int[][] arr = new int[MAXN][4];
 	// 归并排序辅助数组
@@ -108,8 +107,6 @@ public static void prepare() {
 				f[arr[i][0]] = r - i;
 			}
 		}
-		// 清空答案数组
-		Arrays.fill(ans, 0, n, 0);
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class170/Code01_3DPartialOrder2.java b/src/class170/Code01_3DPartialOrder2.java
index 3d61394a2..580850e49 100644
--- a/src/class170/Code01_3DPartialOrder2.java
+++ b/src/class170/Code01_3DPartialOrder2.java
@@ -100,7 +100,6 @@
 //            f[arr[i].i] = r - i;
 //        }
 //    }
-//    fill(ans, ans + n, 0);
 //}
 //
 //int main() {

From dfed03e3130ffab7be139a2621a7e767402fc528 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 11:44:24 +0800
Subject: [PATCH 0865/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java  | 4 ++--
 src/class170/Code02_GardenerTrouble1.java | 9 +++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)
 create mode 100644 src/class170/Code02_GardenerTrouble1.java

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index e3917b454..bca7bf4e5 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -95,9 +95,9 @@ public static void compute(int l, int r) {
 
 	public static void prepare() {
 		// 根据a排序，a一样根据b排序，b一样根据c排序
+		// 排序后a、b、c一样的同组内，组前的下标得不到同组后面的统计量
+		// 所以先设置f的初始值，把这部分提前补偿给组前的下标，然后跑CDQ分治
 		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[3] - b[3]);
-		// 排序后，a、b、c都一样的同一组内，组前的下标，得不到同组后面的统计量
-		// 所以先设置f的初始值，把这部分补偿给组前的下标
 		for (int l = 1, r = 1; l <= n; l = ++r) {
 			while (r + 1 <= n && arr[l][1] == arr[r + 1][1] && arr[l][2] == arr[r + 1][2]
 					&& arr[l][3] == arr[r + 1][3]) {
diff --git a/src/class170/Code02_GardenerTrouble1.java b/src/class170/Code02_GardenerTrouble1.java
new file mode 100644
index 000000000..be4393749
--- /dev/null
+++ b/src/class170/Code02_GardenerTrouble1.java
@@ -0,0 +1,9 @@
+package class170;
+
+// 园丁的烦恼，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2163
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code02_GardenerTrouble1 {
+
+}

From 7176d6371fdbe254aeb451b347167ac4d49499e4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 15:57:40 +0800
Subject: [PATCH 0866/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java  |  18 +--
 src/class170/Code01_3DPartialOrder2.java  |  18 +--
 src/class170/Code02_GardenerTrouble1.java | 158 +++++++++++++++++++++-
 src/class170/Code02_GardenerTrouble2.java | 113 ++++++++++++++++
 4 files changed, 288 insertions(+), 19 deletions(-)
 create mode 100644 src/class170/Code02_GardenerTrouble2.java

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index bca7bf4e5..2b560ad23 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -17,7 +17,7 @@ public class Code01_3DPartialOrder1 {
 	// 位置i、属性a、属性b、属性c
 	public static int[][] arr = new int[MAXN][4];
 	// 归并排序辅助数组
-	public static int[][] help = new int[MAXN][4];
+	public static int[][] tmp = new int[MAXN][4];
 	// 树状数组
 	public static int[] tree = new int[MAXN];
 	// 每个位置统计f(i)
@@ -70,26 +70,26 @@ public static void merge(int l, int m, int r) {
 		p2 = m + 1;
 		int i = l;
 		while (p1 <= m && p2 <= r) {
-			clone(help[i++], arr[p1][2] <= arr[p2][2] ? arr[p1++] : arr[p2++]);
+			clone(tmp[i++], arr[p1][2] <= arr[p2][2] ? arr[p1++] : arr[p2++]);
 		}
 		while (p1 <= m) {
-			clone(help[i++], arr[p1++]);
+			clone(tmp[i++], arr[p1++]);
 		}
 		while (p2 <= r) {
-			clone(help[i++], arr[p2++]);
+			clone(tmp[i++], arr[p2++]);
 		}
 		for (i = l; i <= r; i++) {
-			clone(arr[i], help[i]);
+			clone(arr[i], tmp[i]);
 		}
 	}
 
-	public static void compute(int l, int r) {
+	public static void cdq(int l, int r) {
 		if (l == r) {
 			return;
 		}
 		int mid = (l + r) / 2;
-		compute(l, mid);
-		compute(mid + 1, r);
+		cdq(l, mid);
+		cdq(mid + 1, r);
 		merge(l, mid, r);
 	}
 
@@ -121,7 +121,7 @@ public static void main(String[] args) throws IOException {
 			arr[i][3] = in.nextInt();
 		}
 		prepare();
-		compute(1, n);
+		cdq(1, n);
 		for (int i = 1; i <= n; i++) {
 			ans[f[i]]++;
 		}
diff --git a/src/class170/Code01_3DPartialOrder2.java b/src/class170/Code01_3DPartialOrder2.java
index 580850e49..721e39c65 100644
--- a/src/class170/Code01_3DPartialOrder2.java
+++ b/src/class170/Code01_3DPartialOrder2.java
@@ -26,7 +26,7 @@
 //const int MAXN = 200001;
 //int n, k;
 //Number arr[MAXN];
-//Number help[MAXN];
+//Number tmp[MAXN];
 //int tree[MAXN];
 //int f[MAXN];
 //int ans[MAXN];
@@ -67,26 +67,26 @@
 //    p2 = m + 1;
 //    int i = l;
 //    while (p1 <= m && p2 <= r) {
-//        help[i++] = arr[p1].b <= arr[p2].b ? arr[p1++] : arr[p2++];
+//        tmp[i++] = arr[p1].b <= arr[p2].b ? arr[p1++] : arr[p2++];
 //    }
 //    while (p1 <= m) {
-//        help[i++] = arr[p1++];
+//        tmp[i++] = arr[p1++];
 //    }
 //    while (p2 <= r) {
-//        help[i++] = arr[p2++];
+//        tmp[i++] = arr[p2++];
 //    }
 //    for (i = l; i <= r; i++) {
-//        arr[i] = help[i];
+//        arr[i] = tmp[i];
 //    }
 //}
 //
-//void compute(int l, int r) {
+//void cdq(int l, int r) {
 //    if (l == r) {
 //        return;
 //    }
 //    int mid = (l + r) / 2;
-//    compute(l, mid);
-//    compute(mid + 1, r);
+//    cdq(l, mid);
+//    cdq(mid + 1, r);
 //    merge(l, mid, r);
 //}
 //
@@ -111,7 +111,7 @@
 //        cin >> arr[i].a >> arr[i].b >> arr[i].c;
 //    }
 //    prepare();
-//    compute(1, n);
+//    cdq(1, n);
 //    for (int i = 1; i <= n; i++) {
 //        ans[f[i]]++;
 //    }
diff --git a/src/class170/Code02_GardenerTrouble1.java b/src/class170/Code02_GardenerTrouble1.java
index be4393749..15b6f988b 100644
--- a/src/class170/Code02_GardenerTrouble1.java
+++ b/src/class170/Code02_GardenerTrouble1.java
@@ -2,8 +2,164 @@
 
 // 园丁的烦恼，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2163
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
+// 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
+// 想通过用C++实现，本节课Code02_GardenerTrouble2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
 
 public class Code02_GardenerTrouble1 {
 
+	public static int MAXN = 500001 * 5;
+	public static int n, m, p;
+
+	// op == 1代表树木，x、y、后面空缺
+	// op == 2代表查询，x、y、效果v、隶属的问题q、树木量num
+	public static int[][] arr = new int[MAXN][6];
+	public static int[][] tmp = new int[MAXN][6];
+	public static int[] ans = new int[MAXN];
+
+	public static void clone(int[] a, int[] b) {
+		a[0] = b[0];
+		a[1] = b[1];
+		a[2] = b[2];
+		a[3] = b[3];
+		a[4] = b[4];
+		a[5] = b[5];
+	}
+
+	public static void addTree(int x, int y) {
+		arr[++p][0] = 1;
+		arr[p][1] = x;
+		arr[p][2] = y;
+	}
+
+	public static void addQuery(int x, int y, int v, int q) {
+		arr[++p][0] = 2;
+		arr[p][1] = x;
+		arr[p][2] = y;
+		arr[p][3] = v;
+		arr[p][4] = q;
+		arr[p][5] = 0;
+	}
+
+	public static void merge(int l, int m, int r) {
+		int p1, p2, tree = 0;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][2] <= arr[p2][2]) {
+				p1++;
+				if (arr[p1][0] == 1) {
+					tree++;
+				}
+			}
+			if (arr[p2][0] == 2) {
+				arr[p2][5] += tree;
+			}
+		}
+		p1 = l;
+		p2 = m + 1;
+		int i = l;
+		while (p1 <= m && p2 <= r) {
+			clone(tmp[i++], arr[p1][2] <= arr[p2][2] ? arr[p1++] : arr[p2++]);
+		}
+		while (p1 <= m) {
+			clone(tmp[i++], arr[p1++]);
+		}
+		while (p2 <= r) {
+			clone(tmp[i++], arr[p2++]);
+		}
+		for (i = l; i <= r; i++) {
+			clone(arr[i], tmp[i]);
+		}
+	}
+
+	public static void cdq(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = l + r >> 1;
+		cdq(l, mid);
+		cdq(mid + 1, r);
+		merge(l, mid, r);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, x, y; i <= n; i++) {
+			x = in.nextInt();
+			y = in.nextInt();
+			addTree(x, y);
+		}
+		for (int i = 1, a, b, c, d; i <= m; i++) {
+			a = in.nextInt();
+			b = in.nextInt();
+			c = in.nextInt();
+			d = in.nextInt();
+			addQuery(c, d, 1, i);
+			addQuery(a - 1, b - 1, 1, i);
+			addQuery(a - 1, d, -1, i);
+			addQuery(c, b - 1, -1, i);
+		}
+		Arrays.sort(arr, 1, p + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
+		cdq(1, p);
+		for (int i = 1; i <= p; i++) {
+			if (arr[i][0] == 2) {
+				ans[arr[i][4]] += arr[i][3] * arr[i][5];
+			}
+		}
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class170/Code02_GardenerTrouble2.java b/src/class170/Code02_GardenerTrouble2.java
new file mode 100644
index 000000000..1b1048b01
--- /dev/null
+++ b/src/class170/Code02_GardenerTrouble2.java
@@ -0,0 +1,113 @@
+package class170;
+
+// 园丁的烦恼，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2163
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int op, x, y, v, q, num;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    if (a.x != b.x) {
+//        return a.x < b.x;
+//    }
+//    if (a.y != b.y) {
+//        return a.y < b.y;
+//    }
+//    return a.op < b.op;
+//}
+//
+//const int MAXN = 500001 * 5;
+//int n, m, p = 0;
+//Node arr[MAXN];
+//Node tmp[MAXN];
+//int ans[MAXN];
+//
+//void addTree(int x, int y) {
+//    arr[++p].op = 1;
+//    arr[p].x = x;
+//    arr[p].y = y;
+//}
+//
+//void addQuery(int x, int y, int v, int q) {
+//    arr[++p].op = 2;
+//    arr[p].x = x;
+//    arr[p].y = y;
+//    arr[p].v = v;
+//    arr[p].q = q;
+//    arr[p].num = 0;
+//}
+//
+//void merge(int l, int m, int r) {
+//    int p1, p2, tree = 0;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].y <= arr[p2].y) {
+//            p1++;
+//            if (arr[p1].op == 1) {
+//                tree++;
+//            }
+//        }
+//        if (arr[p2].op == 2) {
+//            arr[p2].num += tree;
+//        }
+//    }
+//    p1 = l;
+//    p2 = m + 1;
+//    int i = l;
+//    while (p1 <= m && p2 <= r) {
+//        tmp[i++] = arr[p1].y <= arr[p2].y ? arr[p1++] : arr[p2++];
+//    }
+//    while (p1 <= m) {
+//        tmp[i++] = arr[p1++];
+//    }
+//    while (p2 <= r) {
+//        tmp[i++] = arr[p2++];
+//    }
+//    for (i = l; i <= r; i++) {
+//        arr[i] = tmp[i];
+//    }
+//}
+//
+//void cdq(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int mid = (l + r) >> 1;
+//    cdq(l, mid);
+//    cdq(mid + 1, r);
+//    merge(l, mid, r);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, x, y; i <= n; i++) {
+//        cin >> x >> y;
+//        addTree(x, y);
+//    }
+//    for (int i = 1, a, b, c, d; i <= m; i++) {
+//        cin >> a >> b >> c >> d;
+//        addQuery(c, d, 1, i);
+//        addQuery(a - 1, b - 1, 1, i);
+//        addQuery(a - 1, d, -1, i);
+//        addQuery(c, b - 1, -1, i);
+//    }
+//    sort(arr + 1, arr + p + 1, NodeCmp);
+//    cdq(1, p);
+//    for (int i = 1; i <= p; i++) {
+//        if (arr[i].op == 2) {
+//            ans[arr[i].q] += arr[i].v * arr[i].num;
+//        }
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 5956811842bf424871ca82b8c268eac70a0f3399 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 16:00:23 +0800
Subject: [PATCH 0867/1712] modify code

---
 src/class170/Code02_GardenerTrouble1.java | 4 ++--
 src/class170/Code02_GardenerTrouble2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class170/Code02_GardenerTrouble1.java b/src/class170/Code02_GardenerTrouble1.java
index 15b6f988b..d4e54321d 100644
--- a/src/class170/Code02_GardenerTrouble1.java
+++ b/src/class170/Code02_GardenerTrouble1.java
@@ -3,7 +3,7 @@
 // 园丁的烦恼，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2163
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但无法通过所有测试用例，内存使用过大
+// java实现的逻辑一定是正确的，但无法通过测试用例，内存使用过大
 // 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
 // 想通过用C++实现，本节课Code02_GardenerTrouble2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
@@ -83,7 +83,7 @@ public static void cdq(int l, int r) {
 		if (l == r) {
 			return;
 		}
-		int mid = l + r >> 1;
+		int mid = (l + r) / 2;
 		cdq(l, mid);
 		cdq(mid + 1, r);
 		merge(l, mid, r);
diff --git a/src/class170/Code02_GardenerTrouble2.java b/src/class170/Code02_GardenerTrouble2.java
index 1b1048b01..39ee9f94f 100644
--- a/src/class170/Code02_GardenerTrouble2.java
+++ b/src/class170/Code02_GardenerTrouble2.java
@@ -78,7 +78,7 @@
 //    if (l == r) {
 //        return;
 //    }
-//    int mid = (l + r) >> 1;
+//    int mid = (l + r) / 2;
 //    cdq(l, mid);
 //    cdq(mid + 1, r);
 //    merge(l, mid, r);

From 6b74204afd032a8cc7e81280ffc248cf7537e3eb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 16:04:43 +0800
Subject: [PATCH 0868/1712] modify code

---
 src/class170/Code02_GardenerTrouble2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class170/Code02_GardenerTrouble2.java b/src/class170/Code02_GardenerTrouble2.java
index 39ee9f94f..6105d7325 100644
--- a/src/class170/Code02_GardenerTrouble2.java
+++ b/src/class170/Code02_GardenerTrouble2.java
@@ -10,7 +10,7 @@
 //using namespace std;
 //
 //struct Node {
-//    int op, x, y, v, q, num;
+//    int op, x, y, v, q, num; // 类型、x、y、效果v、问题q、树木量num
 //};
 //
 //bool NodeCmp(Node a, Node b) {

From 0ed737b07d382a49b5172869e5ca141afb54c0ac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 19:46:05 +0800
Subject: [PATCH 0869/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java      |  7 +-
 ...erTrouble1.java => Code02_RegionSum1.java} | 73 +++++++++----------
 ...erTrouble2.java => Code02_RegionSum2.java} | 55 +++++++-------
 3 files changed, 67 insertions(+), 68 deletions(-)
 rename src/class170/{Code02_GardenerTrouble1.java => Code02_RegionSum1.java} (62%)
 rename src/class170/{Code02_GardenerTrouble2.java => Code02_RegionSum2.java} (67%)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index 2b560ad23..aef8c0020 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -14,14 +14,19 @@ public class Code01_3DPartialOrder1 {
 
 	public static int MAXN = 200001;
 	public static int n, k;
+
 	// 位置i、属性a、属性b、属性c
 	public static int[][] arr = new int[MAXN][4];
-	// 归并排序辅助数组
+
+	// 归并排序需要
 	public static int[][] tmp = new int[MAXN][4];
+
 	// 树状数组
 	public static int[] tree = new int[MAXN];
+
 	// 每个位置统计f(i)
 	public static int[] f = new int[MAXN];
+
 	// 答案
 	public static int[] ans = new int[MAXN];
 
diff --git a/src/class170/Code02_GardenerTrouble1.java b/src/class170/Code02_RegionSum1.java
similarity index 62%
rename from src/class170/Code02_GardenerTrouble1.java
rename to src/class170/Code02_RegionSum1.java
index d4e54321d..49dd7a400 100644
--- a/src/class170/Code02_GardenerTrouble1.java
+++ b/src/class170/Code02_RegionSum1.java
@@ -1,12 +1,8 @@
 package class170;
 
-// 园丁的烦恼，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P2163
-// 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但无法通过测试用例，内存使用过大
-// 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
-// 想通过用C++实现，本节课Code02_GardenerTrouble2文件就是C++的实现
-// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+// 二维空间查询经典模版，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3755
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -14,16 +10,21 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_GardenerTrouble1 {
+public class Code02_RegionSum1 {
 
-	public static int MAXN = 500001 * 5;
-	public static int n, m, p;
+	public static int MAXN = 500001;
+	public static int n, m;
 
-	// op == 1代表树木，x、y、后面空缺
-	// op == 2代表查询，x、y、效果v、隶属的问题q、树木量num
-	public static int[][] arr = new int[MAXN][6];
-	public static int[][] tmp = new int[MAXN][6];
-	public static int[] ans = new int[MAXN];
+	// op == 1代表基站，x、y、功率v
+	// op == 2代表查询，x、y、效果v、问题q
+	public static int[][] arr = new int[MAXN][5];
+	public static int cnt = 0;
+
+	// 归并排序需要
+	public static int[][] tmp = new int[MAXN][5];
+
+	// 问题的答案
+	public static long[] ans = new long[MAXN];
 
 	public static void clone(int[] a, int[] b) {
 		a[0] = b[0];
@@ -31,35 +32,35 @@ public static void clone(int[] a, int[] b) {
 		a[2] = b[2];
 		a[3] = b[3];
 		a[4] = b[4];
-		a[5] = b[5];
 	}
 
-	public static void addTree(int x, int y) {
-		arr[++p][0] = 1;
-		arr[p][1] = x;
-		arr[p][2] = y;
+	public static void addStation(int x, int y, int v) {
+		arr[++cnt][0] = 1;
+		arr[cnt][1] = x;
+		arr[cnt][2] = y;
+		arr[cnt][3] = v;
 	}
 
 	public static void addQuery(int x, int y, int v, int q) {
-		arr[++p][0] = 2;
-		arr[p][1] = x;
-		arr[p][2] = y;
-		arr[p][3] = v;
-		arr[p][4] = q;
-		arr[p][5] = 0;
+		arr[++cnt][0] = 2;
+		arr[cnt][1] = x;
+		arr[cnt][2] = y;
+		arr[cnt][3] = v;
+		arr[cnt][4] = q;
 	}
 
 	public static void merge(int l, int m, int r) {
-		int p1, p2, tree = 0;
+		int p1, p2;
+		long sum = 0;
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][2] <= arr[p2][2]) {
 				p1++;
 				if (arr[p1][0] == 1) {
-					tree++;
+					sum += arr[p1][3];
 				}
 			}
 			if (arr[p2][0] == 2) {
-				arr[p2][5] += tree;
+				ans[arr[p2][4]] += sum * arr[p2][3];
 			}
 		}
 		p1 = l;
@@ -94,10 +95,11 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		m = in.nextInt();
-		for (int i = 1, x, y; i <= n; i++) {
+		for (int i = 1, x, y, v; i <= n; i++) {
 			x = in.nextInt();
 			y = in.nextInt();
-			addTree(x, y);
+			v = in.nextInt();
+			addStation(x, y, v);
 		}
 		for (int i = 1, a, b, c, d; i <= m; i++) {
 			a = in.nextInt();
@@ -109,13 +111,8 @@ public static void main(String[] args) throws IOException {
 			addQuery(a - 1, d, -1, i);
 			addQuery(c, b - 1, -1, i);
 		}
-		Arrays.sort(arr, 1, p + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
-		cdq(1, p);
-		for (int i = 1; i <= p; i++) {
-			if (arr[i][0] == 2) {
-				ans[arr[i][4]] += arr[i][3] * arr[i][5];
-			}
-		}
+		Arrays.sort(arr, 1, cnt + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
+		cdq(1, cnt);
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class170/Code02_GardenerTrouble2.java b/src/class170/Code02_RegionSum2.java
similarity index 67%
rename from src/class170/Code02_GardenerTrouble2.java
rename to src/class170/Code02_RegionSum2.java
index 6105d7325..d9af3bd83 100644
--- a/src/class170/Code02_GardenerTrouble2.java
+++ b/src/class170/Code02_RegionSum2.java
@@ -1,7 +1,7 @@
 package class170;
 
-// 园丁的烦恼，C++版
-// 测试链接 : https://www.luogu.com.cn/problem/P2163
+// 二维空间查询经典模版，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
@@ -10,7 +10,7 @@
 //using namespace std;
 //
 //struct Node {
-//    int op, x, y, v, q, num; // 类型、x、y、效果v、问题q、树木量num
+//    int op, x, y, v, q;
 //};
 //
 //bool NodeCmp(Node a, Node b) {
@@ -23,38 +23,40 @@
 //    return a.op < b.op;
 //}
 //
-//const int MAXN = 500001 * 5;
-//int n, m, p = 0;
+//const int MAXN = 500001;
+//int n, m;
 //Node arr[MAXN];
+//int cnt = 0;
 //Node tmp[MAXN];
-//int ans[MAXN];
+//long long ans[MAXN];
 //
-//void addTree(int x, int y) {
-//    arr[++p].op = 1;
-//    arr[p].x = x;
-//    arr[p].y = y;
+//void addStation(int x, int y, int v) {
+//    arr[++cnt].op = 1;
+//    arr[cnt].x = x;
+//    arr[cnt].y = y;
+//    arr[cnt].v = v;
 //}
 //
 //void addQuery(int x, int y, int v, int q) {
-//    arr[++p].op = 2;
-//    arr[p].x = x;
-//    arr[p].y = y;
-//    arr[p].v = v;
-//    arr[p].q = q;
-//    arr[p].num = 0;
+//    arr[++cnt].op = 2;
+//    arr[cnt].x = x;
+//    arr[cnt].y = y;
+//    arr[cnt].v = v;
+//    arr[cnt].q = q;
 //}
 //
 //void merge(int l, int m, int r) {
-//    int p1, p2, tree = 0;
+//    int p1, p2;
+//    long long sum = 0;
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && arr[p1 + 1].y <= arr[p2].y) {
 //            p1++;
 //            if (arr[p1].op == 1) {
-//                tree++;
+//                sum += arr[p1].v;
 //            }
 //        }
 //        if (arr[p2].op == 2) {
-//            arr[p2].num += tree;
+//            ans[arr[p2].q] += sum * arr[p2].v;
 //        }
 //    }
 //    p1 = l;
@@ -88,9 +90,9 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m;
-//    for (int i = 1, x, y; i <= n; i++) {
-//        cin >> x >> y;
-//        addTree(x, y);
+//    for (int i = 1, x, y, v; i <= n; i++) {
+//        cin >> x >> y >> v;
+//        addStation(x, y, v);
 //    }
 //    for (int i = 1, a, b, c, d; i <= m; i++) {
 //        cin >> a >> b >> c >> d;
@@ -99,13 +101,8 @@
 //        addQuery(a - 1, d, -1, i);
 //        addQuery(c, b - 1, -1, i);
 //    }
-//    sort(arr + 1, arr + p + 1, NodeCmp);
-//    cdq(1, p);
-//    for (int i = 1; i <= p; i++) {
-//        if (arr[i].op == 2) {
-//            ans[arr[i].q] += arr[i].v * arr[i].num;
-//        }
-//    }
+//    sort(arr + 1, arr + cnt + 1, NodeCmp);
+//    cdq(1, cnt);
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';
 //    }

From 675b94d8e9ec5ef61dc4404ed5e9ed9de9c2c844 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 19:51:01 +0800
Subject: [PATCH 0870/1712] modify code

---
 src/class170/Code02_RegionSum1.java | 2 +-
 src/class170/Code02_RegionSum2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class170/Code02_RegionSum1.java b/src/class170/Code02_RegionSum1.java
index 49dd7a400..8f56bf6c4 100644
--- a/src/class170/Code02_RegionSum1.java
+++ b/src/class170/Code02_RegionSum1.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 二维空间查询经典模版，java版
+// 二维空间查询经典模型，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class170/Code02_RegionSum2.java b/src/class170/Code02_RegionSum2.java
index d9af3bd83..beef3051b 100644
--- a/src/class170/Code02_RegionSum2.java
+++ b/src/class170/Code02_RegionSum2.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 二维空间查询经典模版，C++版
+// 二维空间查询经典模型，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 5b1b8d969d3c49b6b2aaabb528f0358ee03abb3d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 19:51:53 +0800
Subject: [PATCH 0871/1712] modify code

---
 src/class170/Code02_RegionSum1.java | 2 +-
 src/class170/Code02_RegionSum2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class170/Code02_RegionSum1.java b/src/class170/Code02_RegionSum1.java
index 8f56bf6c4..121bd550a 100644
--- a/src/class170/Code02_RegionSum1.java
+++ b/src/class170/Code02_RegionSum1.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 二维空间查询经典模型，java版
+// 二维空间查询计数模版题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class170/Code02_RegionSum2.java b/src/class170/Code02_RegionSum2.java
index beef3051b..0f3a9b307 100644
--- a/src/class170/Code02_RegionSum2.java
+++ b/src/class170/Code02_RegionSum2.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 二维空间查询经典模型，C++版
+// 二维空间查询计数模版题，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From a626793148469775035afab5d1c22e208c3d75e2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 19:52:25 +0800
Subject: [PATCH 0872/1712] modify code

---
 src/class170/Code02_RegionSum1.java | 2 +-
 src/class170/Code02_RegionSum2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class170/Code02_RegionSum1.java b/src/class170/Code02_RegionSum1.java
index 121bd550a..a379d4919 100644
--- a/src/class170/Code02_RegionSum1.java
+++ b/src/class170/Code02_RegionSum1.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 二维空间查询计数模版题，java版
+// 空间查询计数cdq模版题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class170/Code02_RegionSum2.java b/src/class170/Code02_RegionSum2.java
index 0f3a9b307..17509661f 100644
--- a/src/class170/Code02_RegionSum2.java
+++ b/src/class170/Code02_RegionSum2.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 二维空间查询计数模版题，C++版
+// 空间查询计数cdq模版题，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From d6b8133108874acce35952d26e1922f006f94d6c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 21:30:46 +0800
Subject: [PATCH 0873/1712] modify code

---
 src/class170/{Code02_RegionSum1.java => Code05_RegionSum1.java} | 2 +-
 src/class170/{Code02_RegionSum2.java => Code05_RegionSum2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class170/{Code02_RegionSum1.java => Code05_RegionSum1.java} (99%)
 rename src/class170/{Code02_RegionSum2.java => Code05_RegionSum2.java} (100%)

diff --git a/src/class170/Code02_RegionSum1.java b/src/class170/Code05_RegionSum1.java
similarity index 99%
rename from src/class170/Code02_RegionSum1.java
rename to src/class170/Code05_RegionSum1.java
index a379d4919..62f7151b8 100644
--- a/src/class170/Code02_RegionSum1.java
+++ b/src/class170/Code05_RegionSum1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_RegionSum1 {
+public class Code05_RegionSum1 {
 
 	public static int MAXN = 500001;
 	public static int n, m;
diff --git a/src/class170/Code02_RegionSum2.java b/src/class170/Code05_RegionSum2.java
similarity index 100%
rename from src/class170/Code02_RegionSum2.java
rename to src/class170/Code05_RegionSum2.java

From 789344628774a3882a822d96f0469488c13fe8dd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 21:47:36 +0800
Subject: [PATCH 0874/1712] modify code

---
 src/class170/Code04_GardenerTrouble1.java     | 163 ++++++++++++++++++
 src/class170/Code04_GardenerTrouble2.java     | 108 ++++++++++++
 ...egionSum1.java => Code05_MissionOfC1.java} |   4 +-
 ...egionSum2.java => Code05_MissionOfC2.java} |   2 +-
 4 files changed, 274 insertions(+), 3 deletions(-)
 create mode 100644 src/class170/Code04_GardenerTrouble1.java
 create mode 100644 src/class170/Code04_GardenerTrouble2.java
 rename src/class170/{Code05_RegionSum1.java => Code05_MissionOfC1.java} (97%)
 rename src/class170/{Code05_RegionSum2.java => Code05_MissionOfC2.java} (98%)

diff --git a/src/class170/Code04_GardenerTrouble1.java b/src/class170/Code04_GardenerTrouble1.java
new file mode 100644
index 000000000..bf2b0395f
--- /dev/null
+++ b/src/class170/Code04_GardenerTrouble1.java
@@ -0,0 +1,163 @@
+package class170;
+
+// 园丁的烦恼，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2163
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但无法通过测试用例，内存使用过大
+// 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
+// 想通过用C++实现，本节课Code04_GardenerTrouble2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code04_GardenerTrouble1 {
+
+	public static int MAXN = 500001 * 5;
+	public static int n, m;
+
+	// op == 1代表树木，x、y
+	// op == 2代表查询，x、y、效果v、问题q
+	public static int[][] arr = new int[MAXN][5];
+	public static int cnt = 0;
+
+	// 归并排序需要
+	public static int[][] tmp = new int[MAXN][5];
+
+	// 问题的答案
+	public static int[] ans = new int[MAXN];
+
+	public static void clone(int[] a, int[] b) {
+		a[0] = b[0];
+		a[1] = b[1];
+		a[2] = b[2];
+		a[3] = b[3];
+		a[4] = b[4];
+	}
+
+	public static void addTree(int x, int y) {
+		arr[++cnt][0] = 1;
+		arr[cnt][1] = x;
+		arr[cnt][2] = y;
+	}
+
+	public static void addQuery(int x, int y, int v, int q) {
+		arr[++cnt][0] = 2;
+		arr[cnt][1] = x;
+		arr[cnt][2] = y;
+		arr[cnt][3] = v;
+		arr[cnt][4] = q;
+	}
+
+	public static void merge(int l, int m, int r) {
+		int p1, p2, tree = 0;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][2] <= arr[p2][2]) {
+				p1++;
+				if (arr[p1][0] == 1) {
+					tree++;
+				}
+			}
+			if (arr[p2][0] == 2) {
+				ans[arr[p2][4]] += tree * arr[p2][3];
+			}
+		}
+		p1 = l;
+		p2 = m + 1;
+		int i = l;
+		while (p1 <= m && p2 <= r) {
+			clone(tmp[i++], arr[p1][2] <= arr[p2][2] ? arr[p1++] : arr[p2++]);
+		}
+		while (p1 <= m) {
+			clone(tmp[i++], arr[p1++]);
+		}
+		while (p2 <= r) {
+			clone(tmp[i++], arr[p2++]);
+		}
+		for (i = l; i <= r; i++) {
+			clone(arr[i], tmp[i]);
+		}
+	}
+
+	public static void cdq(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq(l, mid);
+		cdq(mid + 1, r);
+		merge(l, mid, r);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, x, y; i <= n; i++) {
+			x = in.nextInt();
+			y = in.nextInt();
+			addTree(x, y);
+		}
+		for (int i = 1, a, b, c, d; i <= m; i++) {
+			a = in.nextInt();
+			b = in.nextInt();
+			c = in.nextInt();
+			d = in.nextInt();
+			addQuery(c, d, 1, i);
+			addQuery(a - 1, b - 1, 1, i);
+			addQuery(a - 1, d, -1, i);
+			addQuery(c, b - 1, -1, i);
+		}
+		Arrays.sort(arr, 1, cnt + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
+		cdq(1, cnt);
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class170/Code04_GardenerTrouble2.java b/src/class170/Code04_GardenerTrouble2.java
new file mode 100644
index 000000000..1fb008b9d
--- /dev/null
+++ b/src/class170/Code04_GardenerTrouble2.java
@@ -0,0 +1,108 @@
+package class170;
+
+// 园丁的烦恼，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2163
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int op, x, y, v, q;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    if (a.x != b.x) {
+//        return a.x < b.x;
+//    }
+//    if (a.y != b.y) {
+//        return a.y < b.y;
+//    }
+//    return a.op < b.op;
+//}
+//
+//const int MAXN = 500001 * 5;
+//int n, m;
+//Node arr[MAXN];
+//int cnt = 0;
+//Node tmp[MAXN];
+//int ans[MAXN];
+//
+//void addTree(int x, int y) {
+//    arr[++cnt].op = 1;
+//    arr[cnt].x = x;
+//    arr[cnt].y = y;
+//}
+//
+//void addQuery(int x, int y, int v, int q) {
+//    arr[++cnt].op = 2;
+//    arr[cnt].x = x;
+//    arr[cnt].y = y;
+//    arr[cnt].v = v;
+//    arr[cnt].q = q;
+//}
+//
+//void merge(int l, int m, int r) {
+//    int p1, p2, tree = 0;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].y <= arr[p2].y) {
+//            p1++;
+//            if (arr[p1].op == 1) {
+//                tree++;
+//            }
+//        }
+//        if (arr[p2].op == 2) {
+//            ans[arr[p2].q] += tree * arr[p2].v;
+//        }
+//    }
+//    p1 = l;
+//    p2 = m + 1;
+//    int i = l;
+//    while (p1 <= m && p2 <= r) {
+//        tmp[i++] = arr[p1].y <= arr[p2].y ? arr[p1++] : arr[p2++];
+//    }
+//    while (p1 <= m) {
+//        tmp[i++] = arr[p1++];
+//    }
+//    while (p2 <= r) {
+//        tmp[i++] = arr[p2++];
+//    }
+//    for (i = l; i <= r; i++) {
+//        arr[i] = tmp[i];
+//    }
+//}
+//
+//void cdq(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int mid = (l + r) / 2;
+//    cdq(l, mid);
+//    cdq(mid + 1, r);
+//    merge(l, mid, r);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, x, y; i <= n; i++) {
+//        cin >> x >> y;
+//        addTree(x, y);
+//    }
+//    for (int i = 1, a, b, c, d; i <= m; i++) {
+//        cin >> a >> b >> c >> d;
+//        addQuery(c, d, 1, i);
+//        addQuery(a - 1, b - 1, 1, i);
+//        addQuery(a - 1, d, -1, i);
+//        addQuery(c, b - 1, -1, i);
+//    }
+//    sort(arr + 1, arr + cnt + 1, NodeCmp);
+//    cdq(1, cnt);
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class170/Code05_RegionSum1.java b/src/class170/Code05_MissionOfC1.java
similarity index 97%
rename from src/class170/Code05_RegionSum1.java
rename to src/class170/Code05_MissionOfC1.java
index 62f7151b8..a2b2c45f7 100644
--- a/src/class170/Code05_RegionSum1.java
+++ b/src/class170/Code05_MissionOfC1.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 空间查询计数cdq模版题，java版
+// 老C的任务，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_RegionSum1 {
+public class Code05_MissionOfC1 {
 
 	public static int MAXN = 500001;
 	public static int n, m;
diff --git a/src/class170/Code05_RegionSum2.java b/src/class170/Code05_MissionOfC2.java
similarity index 98%
rename from src/class170/Code05_RegionSum2.java
rename to src/class170/Code05_MissionOfC2.java
index 17509661f..cbcc3d37b 100644
--- a/src/class170/Code05_RegionSum2.java
+++ b/src/class170/Code05_MissionOfC2.java
@@ -1,6 +1,6 @@
 package class170;
 
-// 空间查询计数cdq模版题，C++版
+// 老C的任务，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From a4d03e54d16a150ac13462d5cc5476464c89225d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 22:01:03 +0800
Subject: [PATCH 0875/1712] modify code

---
 src/class170/{Code05_MissionOfC1.java => Code05_TaskOfC1.java} | 2 +-
 src/class170/{Code05_MissionOfC2.java => Code05_TaskOfC2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class170/{Code05_MissionOfC1.java => Code05_TaskOfC1.java} (99%)
 rename src/class170/{Code05_MissionOfC2.java => Code05_TaskOfC2.java} (100%)

diff --git a/src/class170/Code05_MissionOfC1.java b/src/class170/Code05_TaskOfC1.java
similarity index 99%
rename from src/class170/Code05_MissionOfC1.java
rename to src/class170/Code05_TaskOfC1.java
index a2b2c45f7..82ede170c 100644
--- a/src/class170/Code05_MissionOfC1.java
+++ b/src/class170/Code05_TaskOfC1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_MissionOfC1 {
+public class Code05_TaskOfC1 {
 
 	public static int MAXN = 500001;
 	public static int n, m;
diff --git a/src/class170/Code05_MissionOfC2.java b/src/class170/Code05_TaskOfC2.java
similarity index 100%
rename from src/class170/Code05_MissionOfC2.java
rename to src/class170/Code05_TaskOfC2.java

From 8068170377587932368bb2ff34c2ca878aa2ddd7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 27 May 2025 22:02:50 +0800
Subject: [PATCH 0876/1712] modify code

---
 src/class170/Code02_DynamicInversion1.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 src/class170/Code02_DynamicInversion1.java

diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
new file mode 100644
index 000000000..29ac13278
--- /dev/null
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -0,0 +1,9 @@
+package class170;
+
+// 动态逆序对，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3157
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code02_DynamicInversion1 {
+
+}

From 4b700b4eb04afa7cb41b2066c974917353554bd7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 12:26:38 +0800
Subject: [PATCH 0877/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java      | 31 ++++---------------
 src/class170/Code01_3DPartialOrder2.java      | 25 +++++----------
 ...ble1.java => Code05_GardenerTrouble1.java} |  2 +-
 ...ble2.java => Code05_GardenerTrouble2.java} |  0
 ...e05_TaskOfC1.java => Code06_TaskOfC1.java} |  2 +-
 ...e05_TaskOfC2.java => Code06_TaskOfC2.java} |  0
 6 files changed, 15 insertions(+), 45 deletions(-)
 rename src/class170/{Code04_GardenerTrouble1.java => Code05_GardenerTrouble1.java} (98%)
 rename src/class170/{Code04_GardenerTrouble2.java => Code05_GardenerTrouble2.java} (100%)
 rename src/class170/{Code05_TaskOfC1.java => Code06_TaskOfC1.java} (99%)
 rename src/class170/{Code05_TaskOfC2.java => Code06_TaskOfC2.java} (100%)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index aef8c0020..dc5684434 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -18,9 +18,6 @@ public class Code01_3DPartialOrder1 {
 	// 位置i、属性a、属性b、属性c
 	public static int[][] arr = new int[MAXN][4];
 
-	// 归并排序需要
-	public static int[][] tmp = new int[MAXN][4];
-
 	// 树状数组
 	public static int[] tree = new int[MAXN];
 
@@ -30,13 +27,6 @@ public class Code01_3DPartialOrder1 {
 	// 答案
 	public static int[] ans = new int[MAXN];
 
-	public static void clone(int[] a, int[] b) {
-		a[0] = b[0];
-		a[1] = b[1];
-		a[2] = b[2];
-		a[3] = b[3];
-	}
-
 	public static int lowbit(int i) {
 		return i & -i;
 	}
@@ -71,21 +61,12 @@ public static void merge(int l, int m, int r) {
 		for (int i = l; i <= p1; i++) {
 			add(arr[i][3], -1);
 		}
-		p1 = l;
-		p2 = m + 1;
-		int i = l;
-		while (p1 <= m && p2 <= r) {
-			clone(tmp[i++], arr[p1][2] <= arr[p2][2] ? arr[p1++] : arr[p2++]);
-		}
-		while (p1 <= m) {
-			clone(tmp[i++], arr[p1++]);
-		}
-		while (p2 <= r) {
-			clone(tmp[i++], arr[p2++]);
-		}
-		for (i = l; i <= r; i++) {
-			clone(arr[i], tmp[i]);
-		}
+		// 上面的过程，有树状数组的操作，O(n * log n)
+		// 复杂度表达式，t(n) = 2 * t(n / 2) + O(n * log n)
+		// 时间复杂度O(n * log n * log n)
+		// 既然复杂度已经如此，接下来根据b属性来归并，执行O(n)的过程就显得无所谓了
+		// 不如直接排序了，还更容易写
+		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
 	}
 
 	public static void cdq(int l, int r) {
diff --git a/src/class170/Code01_3DPartialOrder2.java b/src/class170/Code01_3DPartialOrder2.java
index 721e39c65..212248f5a 100644
--- a/src/class170/Code01_3DPartialOrder2.java
+++ b/src/class170/Code01_3DPartialOrder2.java
@@ -13,7 +13,7 @@
 //    int i, a, b, c;
 //};
 //
-//bool NumberCmp(Number x, Number y) {
+//bool CmpAbc(Number x, Number y) {
 //    if (x.a != y.a) {
 //        return x.a < y.a;
 //    }
@@ -23,10 +23,13 @@
 //    return x.c < y.c;
 //}
 //
+//bool CmpB(Number x, Number y) {
+//    return x.b < y.b;
+//}
+//
 //const int MAXN = 200001;
 //int n, k;
 //Number arr[MAXN];
-//Number tmp[MAXN];
 //int tree[MAXN];
 //int f[MAXN];
 //int ans[MAXN];
@@ -63,21 +66,7 @@
 //    for (int i = l; i <= p1; i++) {
 //        add(arr[i].c, -1);
 //    }
-//    p1 = l;
-//    p2 = m + 1;
-//    int i = l;
-//    while (p1 <= m && p2 <= r) {
-//        tmp[i++] = arr[p1].b <= arr[p2].b ? arr[p1++] : arr[p2++];
-//    }
-//    while (p1 <= m) {
-//        tmp[i++] = arr[p1++];
-//    }
-//    while (p2 <= r) {
-//        tmp[i++] = arr[p2++];
-//    }
-//    for (i = l; i <= r; i++) {
-//        arr[i] = tmp[i];
-//    }
+//    sort(arr + l, arr + r + 1, CmpB);
 //}
 //
 //void cdq(int l, int r) {
@@ -91,7 +80,7 @@
 //}
 //
 //void prepare() {
-//    sort(arr + 1, arr + n + 1, NumberCmp);
+//    sort(arr + 1, arr + n + 1, CmpAbc);
 //    for (int l = 1, r = 1; l <= n; l = ++r) {
 //        while (r + 1 <= n && arr[l].a == arr[r + 1].a && arr[l].b == arr[r + 1].b && arr[l].c == arr[r + 1].c) {
 //            r++;
diff --git a/src/class170/Code04_GardenerTrouble1.java b/src/class170/Code05_GardenerTrouble1.java
similarity index 98%
rename from src/class170/Code04_GardenerTrouble1.java
rename to src/class170/Code05_GardenerTrouble1.java
index bf2b0395f..8c392d60d 100644
--- a/src/class170/Code04_GardenerTrouble1.java
+++ b/src/class170/Code05_GardenerTrouble1.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_GardenerTrouble1 {
+public class Code05_GardenerTrouble1 {
 
 	public static int MAXN = 500001 * 5;
 	public static int n, m;
diff --git a/src/class170/Code04_GardenerTrouble2.java b/src/class170/Code05_GardenerTrouble2.java
similarity index 100%
rename from src/class170/Code04_GardenerTrouble2.java
rename to src/class170/Code05_GardenerTrouble2.java
diff --git a/src/class170/Code05_TaskOfC1.java b/src/class170/Code06_TaskOfC1.java
similarity index 99%
rename from src/class170/Code05_TaskOfC1.java
rename to src/class170/Code06_TaskOfC1.java
index 82ede170c..13f49de4c 100644
--- a/src/class170/Code05_TaskOfC1.java
+++ b/src/class170/Code06_TaskOfC1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_TaskOfC1 {
+public class Code06_TaskOfC1 {
 
 	public static int MAXN = 500001;
 	public static int n, m;
diff --git a/src/class170/Code05_TaskOfC2.java b/src/class170/Code06_TaskOfC2.java
similarity index 100%
rename from src/class170/Code05_TaskOfC2.java
rename to src/class170/Code06_TaskOfC2.java

From c7285884551b58cbfd1a8b55a50a746bae070c4d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 12:55:21 +0800
Subject: [PATCH 0878/1712] modify code

---
 ...ode05_GardenerTrouble1.java => Code04_GardenerTrouble1.java} | 2 +-
 ...ode05_GardenerTrouble2.java => Code04_GardenerTrouble2.java} | 0
 src/class170/{Code06_TaskOfC1.java => Code05_TaskOfC1.java}     | 2 +-
 src/class170/{Code06_TaskOfC2.java => Code05_TaskOfC2.java}     | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class170/{Code05_GardenerTrouble1.java => Code04_GardenerTrouble1.java} (98%)
 rename src/class170/{Code05_GardenerTrouble2.java => Code04_GardenerTrouble2.java} (100%)
 rename src/class170/{Code06_TaskOfC1.java => Code05_TaskOfC1.java} (99%)
 rename src/class170/{Code06_TaskOfC2.java => Code05_TaskOfC2.java} (100%)

diff --git a/src/class170/Code05_GardenerTrouble1.java b/src/class170/Code04_GardenerTrouble1.java
similarity index 98%
rename from src/class170/Code05_GardenerTrouble1.java
rename to src/class170/Code04_GardenerTrouble1.java
index 8c392d60d..bf2b0395f 100644
--- a/src/class170/Code05_GardenerTrouble1.java
+++ b/src/class170/Code04_GardenerTrouble1.java
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_GardenerTrouble1 {
+public class Code04_GardenerTrouble1 {
 
 	public static int MAXN = 500001 * 5;
 	public static int n, m;
diff --git a/src/class170/Code05_GardenerTrouble2.java b/src/class170/Code04_GardenerTrouble2.java
similarity index 100%
rename from src/class170/Code05_GardenerTrouble2.java
rename to src/class170/Code04_GardenerTrouble2.java
diff --git a/src/class170/Code06_TaskOfC1.java b/src/class170/Code05_TaskOfC1.java
similarity index 99%
rename from src/class170/Code06_TaskOfC1.java
rename to src/class170/Code05_TaskOfC1.java
index 13f49de4c..82ede170c 100644
--- a/src/class170/Code06_TaskOfC1.java
+++ b/src/class170/Code05_TaskOfC1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code06_TaskOfC1 {
+public class Code05_TaskOfC1 {
 
 	public static int MAXN = 500001;
 	public static int n, m;
diff --git a/src/class170/Code06_TaskOfC2.java b/src/class170/Code05_TaskOfC2.java
similarity index 100%
rename from src/class170/Code06_TaskOfC2.java
rename to src/class170/Code05_TaskOfC2.java

From 1b0555c6fac37992aab70f48efe6cdb7ea214c3e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 14:20:08 +0800
Subject: [PATCH 0879/1712] modify code

---
 src/class170/Code02_DynamicInversion1.java | 155 +++++++++++++++++++++
 src/class170/Code02_DynamicInversion2.java | 125 +++++++++++++++++
 2 files changed, 280 insertions(+)
 create mode 100644 src/class170/Code02_DynamicInversion2.java

diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index 29ac13278..995cb1a48 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -4,6 +4,161 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3157
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code02_DynamicInversion1 {
 
+	public static int MAXN = 100001;
+	public static int MAXM = 50001;
+	public static int n, m;
+
+	public static int[] num = new int[MAXN];
+	public static int[] pos = new int[MAXN];
+	public static int[] del = new int[MAXM];
+
+	// 位置i、数值v、效果d、问题q
+	public static int[][] arr = new int[MAXN + MAXM][4];
+	public static int cnt = 0;
+
+	public static int[] tree = new int[MAXN];
+
+	public static long[] ans = new long[MAXM];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int query(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void merge(int l, int m, int r) {
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][0] <= arr[p2][0]) {
+				p1++;
+				add(arr[p1][1], arr[p1][2]);
+			}
+			ans[arr[p2][3]] += arr[p2][2] * (query(n) - query(arr[p2][1]));
+		}
+		for (int i = l; i <= p1; i++) {
+			add(arr[i][1], -arr[i][2]);
+		}
+		for (p1 = m + 1, p2 = r; p2 > m; p2--) {
+			while (p1 - 1 >= l && arr[p1 - 1][0] >= arr[p2][0]) {
+				p1--;
+				add(arr[p1][1], arr[p1][2]);
+			}
+			ans[arr[p2][3]] += arr[p2][2] * query(arr[p2][1] - 1);
+		}
+		for (int i = m; i >= p1; i--) {
+			add(arr[i][1], -arr[i][2]);
+		}
+		Arrays.sort(arr, l, r + 1, (a, b) -> a[0] - b[0]);
+	}
+
+	public static void cdq(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq(l, mid);
+		cdq(mid + 1, r);
+		merge(l, mid, r);
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			arr[++cnt][0] = i;
+			arr[cnt][1] = num[i];
+			arr[cnt][2] = 1;
+			arr[cnt][3] = 0;
+		}
+		for (int i = 1; i <= m; i++) {
+			arr[++cnt][0] = pos[del[i]];
+			arr[cnt][1] = del[i];
+			arr[cnt][2] = -1;
+			arr[cnt][3] = i;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			num[i] = in.nextInt();
+			pos[num[i]] = i;
+		}
+		for (int i = 1; i <= m; i++) {
+			del[i] = in.nextInt();
+		}
+		prepare();
+		cdq(1, cnt);
+		for (int i = 1; i < m; i++) {
+			ans[i] += ans[i - 1];
+		}
+		for (int i = 0; i < m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class170/Code02_DynamicInversion2.java b/src/class170/Code02_DynamicInversion2.java
new file mode 100644
index 000000000..7d33c1b39
--- /dev/null
+++ b/src/class170/Code02_DynamicInversion2.java
@@ -0,0 +1,125 @@
+package class170;
+
+// 动态逆序对，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3157
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Number {
+//    int i, v, d, q;
+//};
+//
+//bool CmpIndex(Number x, Number y) {
+//    return x.i < y.i;
+//}
+//
+//const int MAXN = 100001;
+//const int MAXM = 50001;
+//int n, m;
+//
+//int num[MAXN];
+//int pos[MAXN];
+//int del[MAXM];
+//
+//Number arr[MAXN + MAXM];
+//int cnt = 0;
+//
+//int tree[MAXN];
+//
+//long long ans[MAXM];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= n) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int query(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void merge(int l, int m, int r) {
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].i <= arr[p2].i) {
+//            p1++;
+//            add(arr[p1].v, arr[p1].d);
+//        }
+//        ans[arr[p2].q] += arr[p2].d * (query(n) - query(arr[p2].v));
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        add(arr[i].v, -arr[i].d);
+//    }
+//    for (p1 = m + 1, p2 = r; p2 > m; p2--) {
+//        while (p1 - 1 >= l && arr[p1 - 1].i >= arr[p2].i) {
+//            p1--;
+//            add(arr[p1].v, arr[p1].d);
+//        }
+//        ans[arr[p2].q] += arr[p2].d * query(arr[p2].v - 1);
+//    }
+//    for (int i = m; i >= p1; i--) {
+//        add(arr[i].v, -arr[i].d);
+//    }
+//    sort(arr + l, arr + r + 1, CmpIndex);
+//}
+//
+//void cdq(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int mid = (l + r) / 2;
+//    cdq(l, mid);
+//    cdq(mid + 1, r);
+//    merge(l, mid, r);
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        arr[++cnt].i = i;
+//        arr[cnt].v = num[i];
+//        arr[cnt].d = 1;
+//        arr[cnt].q = 0;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        arr[++cnt].i = pos[del[i]];
+//        arr[cnt].v = del[i];
+//        arr[cnt].d = -1;
+//        arr[cnt].q = i;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> num[i];
+//        pos[num[i]] = i;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> del[i];
+//    }
+//    prepare();
+//    cdq(1, cnt);
+//    for (int i = 1; i < m; i++) {
+//        ans[i] += ans[i - 1];
+//    }
+//    for (int i = 0; i < m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 5c54b2c9d1b2242bf93392330a4023a63d318430 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 14:25:49 +0800
Subject: [PATCH 0880/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index dc5684434..d3fb75295 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -61,11 +61,11 @@ public static void merge(int l, int m, int r) {
 		for (int i = l; i <= p1; i++) {
 			add(arr[i][3], -1);
 		}
-		// 上面的过程，有树状数组的操作，O(n * log n)
-		// 复杂度表达式，t(n) = 2 * t(n / 2) + O(n * log n)
-		// 时间复杂度O(n * log n * log n)
-		// 既然复杂度已经如此，接下来根据b属性来归并，执行O(n)的过程就显得无所谓了
-		// 不如直接排序了，还更容易写
+		// 上面的过程有树状数组的操作，时间复杂度，O(n * log n)
+		// 复杂度表达式为 t(n) = 2 * t(n / 2) + O(n * log n)
+		// 上面表达式的复杂度为 O(n * log n * log n)
+		// 既然复杂度已经如此，接下来根据b属性来归并，做到O(n)的归并过程就不重要了
+		// 不如直接排序，更容易写，还省了辅助数组的空间
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
 	}
 

From 1e2b3739dd3a2f0e9e622aacfdf9aec79de88ed6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 14:26:53 +0800
Subject: [PATCH 0881/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index d3fb75295..3b4456306 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -65,7 +65,7 @@ public static void merge(int l, int m, int r) {
 		// 复杂度表达式为 t(n) = 2 * t(n / 2) + O(n * log n)
 		// 上面表达式的复杂度为 O(n * log n * log n)
 		// 既然复杂度已经如此，接下来根据b属性来归并，做到O(n)的归并过程就不重要了
-		// 不如直接排序，更容易写，还省了辅助数组的空间
+		// 不如直接根据b属性排序，更容易写，还省了辅助数组的空间
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
 	}
 

From de055bd170a425a0f9269b4896f3163ebd971e09 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 14:34:21 +0800
Subject: [PATCH 0882/1712] modify code

---
 src/class170/Code03_AngelDoll1.java | 9 +++++++++
 1 file changed, 9 insertions(+)
 create mode 100644 src/class170/Code03_AngelDoll1.java

diff --git a/src/class170/Code03_AngelDoll1.java b/src/class170/Code03_AngelDoll1.java
new file mode 100644
index 000000000..2d039ac92
--- /dev/null
+++ b/src/class170/Code03_AngelDoll1.java
@@ -0,0 +1,9 @@
+package class170;
+
+// 天使玩偶，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4169
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code03_AngelDoll1 {
+
+}

From ebbf05bcf0d719972819e9d1ca2d12c8b551f3e8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 16:02:33 +0800
Subject: [PATCH 0883/1712] modify code

---
 ...e04_GardenerTrouble1.java => Code03_GardenerTrouble1.java} | 4 ++--
 ...e04_GardenerTrouble2.java => Code03_GardenerTrouble2.java} | 0
 src/class170/{Code05_TaskOfC1.java => Code04_TaskOfC1.java}   | 2 +-
 src/class170/{Code05_TaskOfC2.java => Code04_TaskOfC2.java}   | 0
 .../{Code03_AngelDoll1.java => Code05_AngelDoll1.java}        | 2 +-
 5 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class170/{Code04_GardenerTrouble1.java => Code03_GardenerTrouble1.java} (97%)
 rename src/class170/{Code04_GardenerTrouble2.java => Code03_GardenerTrouble2.java} (100%)
 rename src/class170/{Code05_TaskOfC1.java => Code04_TaskOfC1.java} (99%)
 rename src/class170/{Code05_TaskOfC2.java => Code04_TaskOfC2.java} (100%)
 rename src/class170/{Code03_AngelDoll1.java => Code05_AngelDoll1.java} (85%)

diff --git a/src/class170/Code04_GardenerTrouble1.java b/src/class170/Code03_GardenerTrouble1.java
similarity index 97%
rename from src/class170/Code04_GardenerTrouble1.java
rename to src/class170/Code03_GardenerTrouble1.java
index bf2b0395f..0cc0c7f18 100644
--- a/src/class170/Code04_GardenerTrouble1.java
+++ b/src/class170/Code03_GardenerTrouble1.java
@@ -5,7 +5,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过测试用例，内存使用过大
 // 因为这道题只考虑C++能通过的空间极限，根本没考虑java的用户
-// 想通过用C++实现，本节课Code04_GardenerTrouble2文件就是C++的实现
+// 想通过用C++实现，本节课Code03_GardenerTrouble2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code04_GardenerTrouble1 {
+public class Code03_GardenerTrouble1 {
 
 	public static int MAXN = 500001 * 5;
 	public static int n, m;
diff --git a/src/class170/Code04_GardenerTrouble2.java b/src/class170/Code03_GardenerTrouble2.java
similarity index 100%
rename from src/class170/Code04_GardenerTrouble2.java
rename to src/class170/Code03_GardenerTrouble2.java
diff --git a/src/class170/Code05_TaskOfC1.java b/src/class170/Code04_TaskOfC1.java
similarity index 99%
rename from src/class170/Code05_TaskOfC1.java
rename to src/class170/Code04_TaskOfC1.java
index 82ede170c..4eda9cb8a 100644
--- a/src/class170/Code05_TaskOfC1.java
+++ b/src/class170/Code04_TaskOfC1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_TaskOfC1 {
+public class Code04_TaskOfC1 {
 
 	public static int MAXN = 500001;
 	public static int n, m;
diff --git a/src/class170/Code05_TaskOfC2.java b/src/class170/Code04_TaskOfC2.java
similarity index 100%
rename from src/class170/Code05_TaskOfC2.java
rename to src/class170/Code04_TaskOfC2.java
diff --git a/src/class170/Code03_AngelDoll1.java b/src/class170/Code05_AngelDoll1.java
similarity index 85%
rename from src/class170/Code03_AngelDoll1.java
rename to src/class170/Code05_AngelDoll1.java
index 2d039ac92..a65d56bd8 100644
--- a/src/class170/Code03_AngelDoll1.java
+++ b/src/class170/Code05_AngelDoll1.java
@@ -4,6 +4,6 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4169
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-public class Code03_AngelDoll1 {
+public class Code05_AngelDoll1 {
 
 }

From 9852a529988d2ee6ec2b6540939e59fba084b801 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 17:45:28 +0800
Subject: [PATCH 0884/1712] modify code

---
 src/class170/Code05_AngelDoll1.java | 203 ++++++++++++++++++++++++++++
 src/class170/Code05_AngelDoll2.java | 151 +++++++++++++++++++++
 2 files changed, 354 insertions(+)
 create mode 100644 src/class170/Code05_AngelDoll2.java

diff --git a/src/class170/Code05_AngelDoll1.java b/src/class170/Code05_AngelDoll1.java
index a65d56bd8..5a03cbd1c 100644
--- a/src/class170/Code05_AngelDoll1.java
+++ b/src/class170/Code05_AngelDoll1.java
@@ -4,6 +4,209 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4169
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code05_AngelDoll1 {
 
+	public static int MAXN = 300001;
+	public static int MAXV = 1000001;
+	public static int INF = 1000000001;
+	public static int n, m, v;
+
+	// op == 1代表添加事件，x、y、空缺
+	// op == 1代表查询事件，x、y、问题q
+	public static int[][] tim = new int[MAXN << 1][4];
+	public static int cnte = 0;
+	public static int cntq = 0;
+
+	// tim永远保持原始时序，每次执行cdq时，让arr去变动
+	public static int[][] arr = new int[MAXN << 1][4];
+
+	public static int[] tree = new int[MAXV];
+
+	public static int[] ans = new int[MAXN];
+
+	public static void clone(int[] a, int[] b) {
+		a[0] = b[0];
+		a[1] = b[1];
+		a[2] = b[2];
+		a[3] = b[3];
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void update(int i, int num) {
+		while (i <= v) {
+			tree[i] = Math.max(tree[i], num);
+			i += lowbit(i);
+		}
+	}
+
+	public static int query(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret = Math.max(ret, tree[i]);
+			i -= lowbit(i);
+		}
+		// 如果左下没有点，那么返回无效答案
+		return ret != 0 ? ret : -INF;
+	}
+
+	public static void clear(int i) {
+		while (i <= v) {
+			tree[i] = 0;
+			i += lowbit(i);
+		}
+	}
+
+	// 所有点变到第一象限
+	public static void to1() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+		}
+	}
+
+	// 所有点变到第二象限
+	public static void to2() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+			arr[i][1] = v - arr[i][1];
+		}
+	}
+
+	// 所有点变到第三象限
+	public static void to3() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+			arr[i][1] = v - arr[i][1];
+			arr[i][2] = v - arr[i][2];
+		}
+	}
+
+	// 所有点变到第四象限
+	public static void to4() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+			arr[i][2] = v - arr[i][2];
+		}
+	}
+
+	public static void merge(int l, int m, int r) {
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
+				p1++;
+				if (arr[p1][0] == 1) {
+					update(arr[p1][2], arr[p1][1] + arr[p1][2]);
+				}
+			}
+			if (arr[p2][0] == 2) {
+				ans[arr[p2][3]] = Math.min(ans[arr[p2][3]], arr[p2][1] + arr[p2][2] - query(arr[p2][2]));
+			}
+		}
+		for (int i = l; i <= p1; i++) {
+			if (arr[i][0] == 1) {
+				clear(arr[i][2]);
+			}
+		}
+		Arrays.sort(arr, l, r + 1, (a, b) -> a[1] - b[1]);
+	}
+
+	public static void cdq(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq(l, mid);
+		cdq(mid + 1, r);
+		merge(l, mid, r);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		// 树状数组下标从1开始，所以x和y都要自增一下
+		for (int i = 1, x, y; i <= n; i++) {
+			x = in.nextInt();
+			y = in.nextInt();
+			tim[++cnte][0] = 1;
+			tim[cnte][1] = ++x;
+			tim[cnte][2] = ++y;
+			v = Math.max(v, Math.max(x, y));
+		}
+		for (int i = 1, op, x, y; i <= m; i++) {
+			op = in.nextInt();
+			x = in.nextInt();
+			y = in.nextInt();
+			tim[++cnte][0] = op;
+			tim[cnte][1] = ++x;
+			tim[cnte][2] = ++y;
+			if (op == 2) {
+				tim[cnte][3] = ++cntq;
+			}
+			v = Math.max(v, Math.max(x, y));
+		}
+		// 变换象限时，防止 v - (x或y) 出现0，所以v再自增一下
+		v++;
+		for (int i = 1; i <= cntq; i++) {
+			ans[i] = INF;
+		}
+		to1(); cdq(1, cnte);
+		to2(); cdq(1, cnte);
+		to3(); cdq(1, cnte);
+		to4(); cdq(1, cnte);
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class170/Code05_AngelDoll2.java b/src/class170/Code05_AngelDoll2.java
new file mode 100644
index 000000000..2bcf87602
--- /dev/null
+++ b/src/class170/Code05_AngelDoll2.java
@@ -0,0 +1,151 @@
+package class170;
+
+// 天使玩偶，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4169
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int op, x, y, q;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    return a.x < b.x;
+//}
+//
+//const int MAXN = 300001;
+//const int MAXV = 1000001;
+//const int INF = 1000000001;
+//int n, m, v;
+//
+//Node tim[MAXN << 1];
+//int cnte = 0;
+//int cntq = 0;
+//Node arr[MAXN << 1];
+//int tree[MAXV];
+//int ans[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void update(int i, int num) {
+//    while (i <= v) {
+//        tree[i] = max(tree[i], num);
+//        i += lowbit(i);
+//    }
+//}
+//
+//int query(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret = max(ret, tree[i]);
+//        i -= lowbit(i);
+//    }
+//    return ret ? ret : -INF;
+//}
+//
+//void clear(int i) {
+//    while (i <= v) {
+//        tree[i] = 0;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void to1() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//    }
+//}
+//
+//void to2() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//        arr[i].x = v - arr[i].x;
+//    }
+//}
+//
+//void to3() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//        arr[i].x = v - arr[i].x;
+//        arr[i].y = v - arr[i].y;
+//    }
+//}
+//
+//void to4() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//        arr[i].y = v - arr[i].y;
+//    }
+//}
+//
+//void merge(int l, int m, int r) {
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].x <= arr[p2].x) {
+//            p1++;
+//            if (arr[p1].op == 1) {
+//                update(arr[p1].y, arr[p1].x + arr[p1].y);
+//            }
+//        }
+//        if (arr[p2].op == 2) {
+//            ans[arr[p2].q] = min(ans[arr[p2].q], arr[p2].x + arr[p2].y - query(arr[p2].y));
+//        }
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        if (arr[i].op == 1) {
+//            clear(arr[i].y);
+//        }
+//    }
+//    sort(arr + l, arr + r + 1, NodeCmp);
+//}
+//
+//void cdq(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int mid = (l + r) >> 1;
+//    cdq(l, mid);
+//    cdq(mid + 1, r);
+//    merge(l, mid, r);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, x, y; i <= n; i++) {
+//        cin >> x >> y;
+//        tim[++cnte].op = 1;
+//        tim[cnte].x = ++x;
+//        tim[cnte].y = ++y;
+//        v = max(v, max(x, y));
+//    }
+//    for (int i = 1, op, x, y; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        tim[++cnte].op = op;
+//        tim[cnte].x = ++x;
+//        tim[cnte].y = ++y;
+//        if (op == 2) {
+//            tim[cnte].q = ++cntq;
+//        }
+//        v = max(v, max(x, y));
+//    }
+//    v++;
+//    for (int i = 1; i <= cntq; i++) {
+//        ans[i] = INF;
+//    }
+//    to1(); cdq(1, cnte);
+//    to2(); cdq(1, cnte);
+//    to3(); cdq(1, cnte);
+//    to4(); cdq(1, cnte);
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From ab316bdf032448141e956b21eb87cdc53e05bb64 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 18:14:38 +0800
Subject: [PATCH 0885/1712] modify code

---
 src/class170/Code05_Mokia1.java                          | 9 +++++++++
 .../{Code05_AngelDoll1.java => Code06_AngelDoll1.java}   | 2 +-
 .../{Code05_AngelDoll2.java => Code06_AngelDoll2.java}   | 0
 3 files changed, 10 insertions(+), 1 deletion(-)
 create mode 100644 src/class170/Code05_Mokia1.java
 rename src/class170/{Code05_AngelDoll1.java => Code06_AngelDoll1.java} (99%)
 rename src/class170/{Code05_AngelDoll2.java => Code06_AngelDoll2.java} (100%)

diff --git a/src/class170/Code05_Mokia1.java b/src/class170/Code05_Mokia1.java
new file mode 100644
index 000000000..1e83389bb
--- /dev/null
+++ b/src/class170/Code05_Mokia1.java
@@ -0,0 +1,9 @@
+package class170;
+
+// 摩基亚，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4390
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code05_Mokia1 {
+
+}
diff --git a/src/class170/Code05_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
similarity index 99%
rename from src/class170/Code05_AngelDoll1.java
rename to src/class170/Code06_AngelDoll1.java
index 5a03cbd1c..cb75f0a41 100644
--- a/src/class170/Code05_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_AngelDoll1 {
+public class Code06_AngelDoll1 {
 
 	public static int MAXN = 300001;
 	public static int MAXV = 1000001;
diff --git a/src/class170/Code05_AngelDoll2.java b/src/class170/Code06_AngelDoll2.java
similarity index 100%
rename from src/class170/Code05_AngelDoll2.java
rename to src/class170/Code06_AngelDoll2.java

From 4a8137977e6dc64d0be77a75046946af6afa93cf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 21:43:46 +0800
Subject: [PATCH 0886/1712] modify code

---
 src/class170/Code05_Mokia1.java     | 158 ++++++++++++++++++++++++++++
 src/class170/Code05_Mokia2.java     | 127 ++++++++++++++++++++++
 src/class170/Code06_AngelDoll1.java |   2 +-
 src/class170/Code06_AngelDoll2.java |   2 +-
 4 files changed, 287 insertions(+), 2 deletions(-)
 create mode 100644 src/class170/Code05_Mokia2.java

diff --git a/src/class170/Code05_Mokia1.java b/src/class170/Code05_Mokia1.java
index 1e83389bb..d72f8ea61 100644
--- a/src/class170/Code05_Mokia1.java
+++ b/src/class170/Code05_Mokia1.java
@@ -4,6 +4,164 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4390
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code05_Mokia1 {
 
+	public static int MAXN = 200001;
+	public static int MAXV = 2000002;
+	public static int w;
+
+	// op == 1表示增加事件，x、y、人数v
+	// op == 1表示查询事件，x、y、效果v、问题q
+	public static int[][] arr = new int[MAXN][5];
+	public static int cnte = 0;
+	public static int cntq = 0;
+
+	public static int[] tree = new int[MAXV];
+
+	public static int[] ans = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= w) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int query(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void addPeople(int x, int y, int v) {
+		arr[++cnte][0] = 1;
+		arr[cnte][1] = x;
+		arr[cnte][2] = y;
+		arr[cnte][3] = v;
+	}
+
+	public static void addQuery(int x, int y, int v, int q) {
+		arr[++cnte][0] = 2;
+		arr[cnte][1] = x;
+		arr[cnte][2] = y;
+		arr[cnte][3] = v;
+		arr[cnte][4] = q;
+	}
+
+	public static void merge(int l, int m, int r) {
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
+				p1++;
+				if (arr[p1][0] == 1) {
+					add(arr[p1][2], arr[p1][3]);
+				}
+			}
+			if (arr[p2][0] == 2) {
+				ans[arr[p2][4]] += arr[p2][3] * query(arr[p2][2]);
+			}
+		}
+		for (int i = l; i <= p1; i++) {
+			if (arr[i][0] == 1) {
+				add(arr[i][2], -arr[i][3]);
+			}
+		}
+		Arrays.sort(arr, l, r + 1, (a, b) -> a[1] - b[1]);
+	}
+
+	public static void cdq(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq(l, mid);
+		cdq(mid + 1, r);
+		merge(l, mid, r);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		in.nextInt();
+		w = in.nextInt() + 1;
+		int op, x, y, v, a, b, c, d;
+		op = in.nextInt();
+		while (op != 3) {
+			if (op == 1) {
+				x = in.nextInt() + 1;
+				y = in.nextInt() + 1;
+				v = in.nextInt();
+				addPeople(x, y, v);
+			} else {
+				a = in.nextInt() + 1;
+				b = in.nextInt() + 1;
+				c = in.nextInt() + 1;
+				d = in.nextInt() + 1;
+				addQuery(c, d, 1, ++cntq);
+				addQuery(a - 1, b - 1, 1, cntq);
+				addQuery(a - 1, d, -1, cntq);
+				addQuery(c, b - 1, -1, cntq);
+			}
+			op = in.nextInt();
+		}
+		cdq(1, cnte);
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class170/Code05_Mokia2.java b/src/class170/Code05_Mokia2.java
new file mode 100644
index 000000000..f7c97f09e
--- /dev/null
+++ b/src/class170/Code05_Mokia2.java
@@ -0,0 +1,127 @@
+package class170;
+
+// 摩基亚，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4390
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int op, x, y, v, q;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    return a.x < b.x;
+//}
+//
+//const int MAXN = 200001;
+//const int MAXV = 2000002;
+//const int INF = 1000000001;
+//int w;
+//
+//Node arr[MAXN];
+//int cnte = 0;
+//int cntq = 0;
+//
+//int tree[MAXV];
+//
+//int ans[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= w) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int query(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void addPeople(int x, int y, int v) {
+//    arr[++cnte].op = 1;
+//    arr[cnte].x = x;
+//    arr[cnte].y = y;
+//    arr[cnte].v = v;
+//}
+//
+//void addQuery(int x, int y, int v, int q) {
+//    arr[++cnte].op = 2;
+//    arr[cnte].x = x;
+//    arr[cnte].y = y;
+//    arr[cnte].v = v;
+//    arr[cnte].q = q;
+//}
+//
+//void merge(int l, int m, int r) {
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].x <= arr[p2].x) {
+//            p1++;
+//            if (arr[p1].op == 1) {
+//                add(arr[p1].y, arr[p1].v);
+//            }
+//        }
+//        if (arr[p2].op == 2) {
+//            ans[arr[p2].q] += arr[p2].v * query(arr[p2].y);
+//        }
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        if (arr[i].op == 1) {
+//            add(arr[i].y, -arr[i].v);
+//        }
+//    }
+//    sort(arr + l, arr + r + 1, NodeCmp);
+//}
+//
+//void cdq(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int mid = (l + r) / 2;
+//    cdq(l, mid);
+//    cdq(mid + 1, r);
+//    merge(l, mid, r);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int tmp;
+//    cin >> tmp >> w;
+//    w++;
+//    int op, x, y, v, a, b, c, d;
+//    cin >> op;
+//    while (op != 3) {
+//        if (op == 1) {
+//            cin >> x >> y >> v;
+//            x++; y++;
+//            addPeople(x, y, v);
+//        } else {
+//            cin >> a >> b >> c >> d;
+//            a++; b++; c++; d++;
+//            addQuery(c, d, 1, ++cntq);
+//            addQuery(a - 1, b - 1, 1, cntq);
+//            addQuery(a - 1, d, -1, cntq);
+//            addQuery(c, b - 1, -1, cntq);
+//        }
+//        cin >> op;
+//    }
+//    cdq(1, cnte);
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index cb75f0a41..1e296d1c2 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -13,7 +13,7 @@
 public class Code06_AngelDoll1 {
 
 	public static int MAXN = 300001;
-	public static int MAXV = 1000001;
+	public static int MAXV = 1000002;
 	public static int INF = 1000000001;
 	public static int n, m, v;
 
diff --git a/src/class170/Code06_AngelDoll2.java b/src/class170/Code06_AngelDoll2.java
index 2bcf87602..7eaf21012 100644
--- a/src/class170/Code06_AngelDoll2.java
+++ b/src/class170/Code06_AngelDoll2.java
@@ -18,7 +18,7 @@
 //}
 //
 //const int MAXN = 300001;
-//const int MAXV = 1000001;
+//const int MAXV = 1000002;
 //const int INF = 1000000001;
 //int n, m, v;
 //

From 628860f9d0f4cee7dc0d1a948ca0ead670579c86 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 21:51:17 +0800
Subject: [PATCH 0887/1712] modify code

---
 src/class170/Code01_3DPartialOrder2.java   | 8 ++++----
 src/class170/Code02_DynamicInversion2.java | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class170/Code01_3DPartialOrder2.java b/src/class170/Code01_3DPartialOrder2.java
index 212248f5a..99a29a35f 100644
--- a/src/class170/Code01_3DPartialOrder2.java
+++ b/src/class170/Code01_3DPartialOrder2.java
@@ -9,11 +9,11 @@
 //
 //using namespace std;
 //
-//struct Number {
+//struct Node {
 //    int i, a, b, c;
 //};
 //
-//bool CmpAbc(Number x, Number y) {
+//bool CmpAbc(Node x, Node y) {
 //    if (x.a != y.a) {
 //        return x.a < y.a;
 //    }
@@ -23,13 +23,13 @@
 //    return x.c < y.c;
 //}
 //
-//bool CmpB(Number x, Number y) {
+//bool CmpB(Node x, Node y) {
 //    return x.b < y.b;
 //}
 //
 //const int MAXN = 200001;
 //int n, k;
-//Number arr[MAXN];
+//Node arr[MAXN];
 //int tree[MAXN];
 //int f[MAXN];
 //int ans[MAXN];
diff --git a/src/class170/Code02_DynamicInversion2.java b/src/class170/Code02_DynamicInversion2.java
index 7d33c1b39..eaf3960d1 100644
--- a/src/class170/Code02_DynamicInversion2.java
+++ b/src/class170/Code02_DynamicInversion2.java
@@ -9,11 +9,11 @@
 //
 //using namespace std;
 //
-//struct Number {
+//struct Node {
 //    int i, v, d, q;
 //};
 //
-//bool CmpIndex(Number x, Number y) {
+//bool CmpIndex(Node x, Node y) {
 //    return x.i < y.i;
 //}
 //
@@ -25,7 +25,7 @@
 //int pos[MAXN];
 //int del[MAXM];
 //
-//Number arr[MAXN + MAXM];
+//Node arr[MAXN + MAXM];
 //int cnt = 0;
 //
 //int tree[MAXN];

From 010fb3b8907e1902647de3bd3307cd6e265c1319 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 28 May 2025 21:58:47 +0800
Subject: [PATCH 0888/1712] modify code

---
 src/class170/Code02_DynamicInversion2.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class170/Code02_DynamicInversion2.java b/src/class170/Code02_DynamicInversion2.java
index eaf3960d1..d0d5bcaba 100644
--- a/src/class170/Code02_DynamicInversion2.java
+++ b/src/class170/Code02_DynamicInversion2.java
@@ -13,7 +13,7 @@
 //    int i, v, d, q;
 //};
 //
-//bool CmpIndex(Node x, Node y) {
+//bool NodeCmp(Node x, Node y) {
 //    return x.i < y.i;
 //}
 //
@@ -74,7 +74,7 @@
 //    for (int i = m; i >= p1; i--) {
 //        add(arr[i].v, -arr[i].d);
 //    }
-//    sort(arr + l, arr + r + 1, CmpIndex);
+//    sort(arr + l, arr + r + 1, NodeCmp);
 //}
 //
 //void cdq(int l, int r) {

From a96f357a9268fbc254fe65668d3e82060622664e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 29 May 2025 11:27:45 +0800
Subject: [PATCH 0889/1712] modify code

---
 src/class170/Code06_AngelDoll1.java | 15 ++++++++-------
 src/class170/Code06_AngelDoll2.java | 13 +++++++++----
 2 files changed, 17 insertions(+), 11 deletions(-)

diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index 1e296d1c2..796009a7b 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -19,13 +19,12 @@ public class Code06_AngelDoll1 {
 
 	// op == 1代表添加事件，x、y、空缺
 	// op == 1代表查询事件，x、y、问题q
+	// tim永远保持原始时序，每次执行cdq时，让arr去变动
 	public static int[][] tim = new int[MAXN << 1][4];
+	public static int[][] arr = new int[MAXN << 1][4];
 	public static int cnte = 0;
 	public static int cntq = 0;
 
-	// tim永远保持原始时序，每次执行cdq时，让arr去变动
-	public static int[][] arr = new int[MAXN << 1][4];
-
 	public static int[] tree = new int[MAXV];
 
 	public static int[] ans = new int[MAXN];
@@ -49,18 +48,17 @@ public static void update(int i, int num) {
 	}
 
 	public static int query(int i) {
-		int ret = 0;
+		int ret = -INF;
 		while (i > 0) {
 			ret = Math.max(ret, tree[i]);
 			i -= lowbit(i);
 		}
-		// 如果左下没有点，那么返回无效答案
-		return ret != 0 ? ret : -INF;
+		return ret;
 	}
 
 	public static void clear(int i) {
 		while (i <= v) {
-			tree[i] = 0;
+			tree[i] = -INF;
 			i += lowbit(i);
 		}
 	}
@@ -156,6 +154,9 @@ public static void main(String[] args) throws IOException {
 		}
 		// 变换象限时，防止 v - (x或y) 出现0，所以v再自增一下
 		v++;
+		for (int i = 1; i <= v; i++) {
+			tree[i] = -INF;
+		}
 		for (int i = 1; i <= cntq; i++) {
 			ans[i] = INF;
 		}
diff --git a/src/class170/Code06_AngelDoll2.java b/src/class170/Code06_AngelDoll2.java
index 7eaf21012..9f7ac4f6b 100644
--- a/src/class170/Code06_AngelDoll2.java
+++ b/src/class170/Code06_AngelDoll2.java
@@ -23,10 +23,12 @@
 //int n, m, v;
 //
 //Node tim[MAXN << 1];
+//Node arr[MAXN << 1];
 //int cnte = 0;
 //int cntq = 0;
-//Node arr[MAXN << 1];
+//
 //int tree[MAXV];
+//
 //int ans[MAXN];
 //
 //int lowbit(int i) {
@@ -41,17 +43,17 @@
 //}
 //
 //int query(int i) {
-//    int ret = 0;
+//    int ret = -INF;
 //    while (i > 0) {
 //        ret = max(ret, tree[i]);
 //        i -= lowbit(i);
 //    }
-//    return ret ? ret : -INF;
+//    return ret;
 //}
 //
 //void clear(int i) {
 //    while (i <= v) {
-//        tree[i] = 0;
+//        tree[i] = -INF;
 //        i += lowbit(i);
 //    }
 //}
@@ -137,6 +139,9 @@
 //        v = max(v, max(x, y));
 //    }
 //    v++;
+//    for (int i = 1; i <= v; i++) {
+//        tree[i] = -INF;
+//    }
 //    for (int i = 1; i <= cntq; i++) {
 //        ans[i] = INF;
 //    }

From 9ed8b6ca1d5409afd72b7111ade98a648951020d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 29 May 2025 11:40:11 +0800
Subject: [PATCH 0890/1712] modify code

---
 src/class170/Code06_AngelDoll1.java | 79 +++++++++++++++--------------
 src/class170/Code06_AngelDoll2.java | 68 +++++++++++++------------
 2 files changed, 78 insertions(+), 69 deletions(-)

diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index 796009a7b..e8735a569 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -63,38 +63,6 @@ public static void clear(int i) {
 		}
 	}
 
-	// 所有点变到第一象限
-	public static void to1() {
-		for (int i = 1; i <= cnte; i++) {
-			clone(arr[i], tim[i]);
-		}
-	}
-
-	// 所有点变到第二象限
-	public static void to2() {
-		for (int i = 1; i <= cnte; i++) {
-			clone(arr[i], tim[i]);
-			arr[i][1] = v - arr[i][1];
-		}
-	}
-
-	// 所有点变到第三象限
-	public static void to3() {
-		for (int i = 1; i <= cnte; i++) {
-			clone(arr[i], tim[i]);
-			arr[i][1] = v - arr[i][1];
-			arr[i][2] = v - arr[i][2];
-		}
-	}
-
-	// 所有点变到第四象限
-	public static void to4() {
-		for (int i = 1; i <= cnte; i++) {
-			clone(arr[i], tim[i]);
-			arr[i][2] = v - arr[i][2];
-		}
-	}
-
 	public static void merge(int l, int m, int r) {
 		int p1, p2;
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
@@ -126,12 +94,50 @@ public static void cdq(int l, int r) {
 		merge(l, mid, r);
 	}
 
+	// 点变换到第一象限进行cdq分治
+	public static void to1() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+		}
+		cdq(1, cnte);
+	}
+
+	// 点变换到第二象限进行cdq分治
+	public static void to2() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+			arr[i][1] = v - arr[i][1];
+		}
+		cdq(1, cnte);
+	}
+
+	// 点变换到第三象限进行cdq分治
+	public static void to3() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+			arr[i][1] = v - arr[i][1];
+			arr[i][2] = v - arr[i][2];
+		}
+		cdq(1, cnte);
+	}
+
+	// 点变换到第四象限进行cdq分治
+	public static void to4() {
+		for (int i = 1; i <= cnte; i++) {
+			clone(arr[i], tim[i]);
+			arr[i][2] = v - arr[i][2];
+		}
+		cdq(1, cnte);
+	}
+
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		m = in.nextInt();
 		// 树状数组下标从1开始，所以x和y都要自增一下
+		// x或y的最大值用v记录，变换象限时，防止 v - (x或y) 出现0
+		// 所以最后v再自增一下
 		for (int i = 1, x, y; i <= n; i++) {
 			x = in.nextInt();
 			y = in.nextInt();
@@ -152,7 +158,6 @@ public static void main(String[] args) throws IOException {
 			}
 			v = Math.max(v, Math.max(x, y));
 		}
-		// 变换象限时，防止 v - (x或y) 出现0，所以v再自增一下
 		v++;
 		for (int i = 1; i <= v; i++) {
 			tree[i] = -INF;
@@ -160,10 +165,10 @@ public static void main(String[] args) throws IOException {
 		for (int i = 1; i <= cntq; i++) {
 			ans[i] = INF;
 		}
-		to1(); cdq(1, cnte);
-		to2(); cdq(1, cnte);
-		to3(); cdq(1, cnte);
-		to4(); cdq(1, cnte);
+		to1();
+		to2();
+		to3();
+		to4();
 		for (int i = 1; i <= cntq; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class170/Code06_AngelDoll2.java b/src/class170/Code06_AngelDoll2.java
index 9f7ac4f6b..7b183edac 100644
--- a/src/class170/Code06_AngelDoll2.java
+++ b/src/class170/Code06_AngelDoll2.java
@@ -58,34 +58,6 @@
 //    }
 //}
 //
-//void to1() {
-//    for (int i = 1; i <= cnte; i++) {
-//        arr[i] = tim[i];
-//    }
-//}
-//
-//void to2() {
-//    for (int i = 1; i <= cnte; i++) {
-//        arr[i] = tim[i];
-//        arr[i].x = v - arr[i].x;
-//    }
-//}
-//
-//void to3() {
-//    for (int i = 1; i <= cnte; i++) {
-//        arr[i] = tim[i];
-//        arr[i].x = v - arr[i].x;
-//        arr[i].y = v - arr[i].y;
-//    }
-//}
-//
-//void to4() {
-//    for (int i = 1; i <= cnte; i++) {
-//        arr[i] = tim[i];
-//        arr[i].y = v - arr[i].y;
-//    }
-//}
-//
 //void merge(int l, int m, int r) {
 //    int p1, p2;
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
@@ -117,6 +89,38 @@
 //    merge(l, mid, r);
 //}
 //
+//void to1() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//    }
+//    cdq(1, cnte);
+//}
+//
+//void to2() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//        arr[i].x = v - arr[i].x;
+//    }
+//    cdq(1, cnte);
+//}
+//
+//void to3() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//        arr[i].x = v - arr[i].x;
+//        arr[i].y = v - arr[i].y;
+//    }
+//    cdq(1, cnte);
+//}
+//
+//void to4() {
+//    for (int i = 1; i <= cnte; i++) {
+//        arr[i] = tim[i];
+//        arr[i].y = v - arr[i].y;
+//    }
+//    cdq(1, cnte);
+//}
+//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
@@ -145,10 +149,10 @@
 //    for (int i = 1; i <= cntq; i++) {
 //        ans[i] = INF;
 //    }
-//    to1(); cdq(1, cnte);
-//    to2(); cdq(1, cnte);
-//    to3(); cdq(1, cnte);
-//    to4(); cdq(1, cnte);
+//    to1();
+//    to2();
+//    to3();
+//    to4();
 //    for (int i = 1; i <= cntq; i++) {
 //        cout << ans[i] << '\n';
 //    }

From a3e4d5e69cdff0800d56f855026a1064017e4f00 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 29 May 2025 19:55:00 +0800
Subject: [PATCH 0891/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java   | 14 +++++++-------
 src/class170/Code01_3DPartialOrder2.java   |  6 ++++++
 src/class170/Code02_DynamicInversion1.java |  6 ++++++
 src/class170/Code02_DynamicInversion2.java |  6 ++++++
 src/class170/Code03_GardenerTrouble1.java  |  5 +++++
 src/class170/Code03_GardenerTrouble2.java  |  5 +++++
 src/class170/Code04_TaskOfC1.java          |  5 +++++
 src/class170/Code04_TaskOfC2.java          |  5 +++++
 src/class170/Code05_Mokia1.java            |  7 +++++++
 src/class170/Code05_Mokia2.java            |  7 +++++++
 src/class170/Code06_AngelDoll1.java        |  6 ++++++
 src/class170/Code06_AngelDoll2.java        |  6 ++++++
 12 files changed, 71 insertions(+), 7 deletions(-)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index 3b4456306..08817696a 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -1,6 +1,12 @@
 package class170;
 
 // 三维偏序，java版
+// 一共有n个对象，属性值范围[1, k]，每个对象有a属性、b属性、c属性
+// f(i)表示，aj <= ai 且 bj <= bi 且 cj <= ci 且 j != i 的j的数量
+// ans(d)表示，f(i) == d 的i的数量
+// 打印所有的ans[d]，d的范围[0, n)
+// 1 <= n <= 10^5
+// 1 <= k <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3810
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -21,10 +27,8 @@ public class Code01_3DPartialOrder1 {
 	// 树状数组
 	public static int[] tree = new int[MAXN];
 
-	// 每个位置统计f(i)
 	public static int[] f = new int[MAXN];
 
-	// 答案
 	public static int[] ans = new int[MAXN];
 
 	public static int lowbit(int i) {
@@ -61,11 +65,7 @@ public static void merge(int l, int m, int r) {
 		for (int i = l; i <= p1; i++) {
 			add(arr[i][3], -1);
 		}
-		// 上面的过程有树状数组的操作，时间复杂度，O(n * log n)
-		// 复杂度表达式为 t(n) = 2 * t(n / 2) + O(n * log n)
-		// 上面表达式的复杂度为 O(n * log n * log n)
-		// 既然复杂度已经如此，接下来根据b属性来归并，做到O(n)的归并过程就不重要了
-		// 不如直接根据b属性排序，更容易写，还省了辅助数组的空间
+		// 直接排序，课上重点解释了这么做的理由
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
 	}
 
diff --git a/src/class170/Code01_3DPartialOrder2.java b/src/class170/Code01_3DPartialOrder2.java
index 99a29a35f..f392dc1fc 100644
--- a/src/class170/Code01_3DPartialOrder2.java
+++ b/src/class170/Code01_3DPartialOrder2.java
@@ -1,6 +1,12 @@
 package class170;
 
 // 三维偏序，C++版
+// 一共有n个对象，属性值范围[1, k]，每个对象有a属性、b属性、c属性
+// f(i)表示，aj <= ai 且 bj <= bi 且 cj <= ci 且 j != i 的j的数量
+// ans(d)表示，f(i) == d 的i的数量
+// 打印所有的ans[d]，d的范围[0, n)
+// 1 <= n <= 10^5
+// 1 <= k <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3810
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index 995cb1a48..82156ac90 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -1,6 +1,12 @@
 package class170;
 
 // 动态逆序对，java版
+// 给定一个长度为n的排列，1~n所有数字都出现一次
+// 如果，前面的数 > 后面的数，那么这两个数就组成一个逆序对
+// 给定一个长度为m的数组，表示依次删除的数字
+// 打印每次删除数字前，排列中一共有多少逆序对，一共m条打印
+// 1 <= n <= 10^5
+// 1 <= m <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P3157
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class170/Code02_DynamicInversion2.java b/src/class170/Code02_DynamicInversion2.java
index d0d5bcaba..79fec7567 100644
--- a/src/class170/Code02_DynamicInversion2.java
+++ b/src/class170/Code02_DynamicInversion2.java
@@ -1,6 +1,12 @@
 package class170;
 
 // 动态逆序对，C++版
+// 给定一个长度为n的排列，1~n所有数字都出现一次
+// 如果，前面的数 > 后面的数，那么这两个数就组成一个逆序对
+// 给定一个长度为m的数组，表示依次删除的数字
+// 打印每次删除数字前，排列中一共有多少逆序对，一共m条打印
+// 1 <= n <= 10^5
+// 1 <= m <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P3157
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class170/Code03_GardenerTrouble1.java b/src/class170/Code03_GardenerTrouble1.java
index 0cc0c7f18..d29084219 100644
--- a/src/class170/Code03_GardenerTrouble1.java
+++ b/src/class170/Code03_GardenerTrouble1.java
@@ -1,6 +1,11 @@
 package class170;
 
 // 园丁的烦恼，java版
+// 有n棵树，每棵树给定位置坐标(x, y)，接下来有m条查询，格式如下
+// 查询 a b c d : 打印左上角(a, b)、右下角(c, d)的区域里有几棵树
+// 0 <= n <= 5 * 10^5
+// 1 <= m <= 5 * 10^5
+// 0 <= 坐标值 <= 10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P2163
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但无法通过测试用例，内存使用过大
diff --git a/src/class170/Code03_GardenerTrouble2.java b/src/class170/Code03_GardenerTrouble2.java
index 1fb008b9d..7a80680b1 100644
--- a/src/class170/Code03_GardenerTrouble2.java
+++ b/src/class170/Code03_GardenerTrouble2.java
@@ -1,6 +1,11 @@
 package class170;
 
 // 园丁的烦恼，C++版
+// 有n棵树，每棵树给定位置坐标(x, y)，接下来有m条查询，格式如下
+// 查询 a b c d : 打印左上角(a, b)、右下角(c, d)的区域里有几棵树
+// 0 <= n <= 5 * 10^5
+// 1 <= m <= 5 * 10^5
+// 0 <= 坐标值 <= 10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P2163
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class170/Code04_TaskOfC1.java b/src/class170/Code04_TaskOfC1.java
index 4eda9cb8a..12fdbff4f 100644
--- a/src/class170/Code04_TaskOfC1.java
+++ b/src/class170/Code04_TaskOfC1.java
@@ -1,6 +1,11 @@
 package class170;
 
 // 老C的任务，java版
+// 有n个基站，每个基站给定x、y、v，表示基站在(x, y)位置，功率为v
+// 接下来有m条查询，每条查询格式如下
+// 查询 a b c d : 打印左上角(a, b)、右下角(c, d)的区域里基站的功率和
+// 1 <= n、m <= 10^5
+// 其余数值都在int类型的范围
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class170/Code04_TaskOfC2.java b/src/class170/Code04_TaskOfC2.java
index cbcc3d37b..6b00b2949 100644
--- a/src/class170/Code04_TaskOfC2.java
+++ b/src/class170/Code04_TaskOfC2.java
@@ -1,6 +1,11 @@
 package class170;
 
 // 老C的任务，C++版
+// 有n个基站，每个基站给定x、y、v，表示基站在(x, y)位置，功率为v
+// 接下来有m条查询，每条查询格式如下
+// 查询 a b c d : 打印左上角(a, b)、右下角(c, d)的区域里基站的功率和
+// 1 <= n、m <= 10^5
+// 其余数值都在int类型的范围
 // 测试链接 : https://www.luogu.com.cn/problem/P3755
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class170/Code05_Mokia1.java b/src/class170/Code05_Mokia1.java
index d72f8ea61..36cfd8c20 100644
--- a/src/class170/Code05_Mokia1.java
+++ b/src/class170/Code05_Mokia1.java
@@ -1,6 +1,13 @@
 package class170;
 
 // 摩基亚，java版
+// 给定数字w，表示一个w * w的正方形区域，所有位置都在其中
+// 接下来有m条操作，每种操作是如下两种类型中的一种
+// 操作 1 x y v   : 坐标(x, y)位置增加了v个人
+// 操作 2 a b c d : 打印左上角(a, b)、右下角(c, d)区域里的人数
+// 1 <= w <= 2 * 10^6
+// 1 <= m <= 2 * 10^5
+// 0 <= v <= 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P4390
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class170/Code05_Mokia2.java b/src/class170/Code05_Mokia2.java
index f7c97f09e..800255c5d 100644
--- a/src/class170/Code05_Mokia2.java
+++ b/src/class170/Code05_Mokia2.java
@@ -1,6 +1,13 @@
 package class170;
 
 // 摩基亚，C++版
+// 给定数字w，表示一个w * w的正方形区域，所有位置都在其中
+// 接下来有m条操作，每种操作是如下两种类型中的一种
+// 操作 1 x y v   : 坐标(x, y)位置增加了v个人
+// 操作 2 a b c d : 打印左上角(a, b)、右下角(c, d)区域里的人数
+// 1 <= w <= 2 * 10^6
+// 1 <= m <= 2 * 10^5
+// 0 <= v <= 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P4390
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index e8735a569..137ee2139 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -1,6 +1,12 @@
 package class170;
 
 // 天使玩偶，java版
+// 规定(x1, y1)和(x2, y2)之间的距离 = | x1 - x2 | + | y1 - y2 |
+// 一开始先给定n个点的位置，接下来有m条操作，每种操作是如下两种类型中的一种
+// 操作 1 x y : 在(x, y)位置添加一个点
+// 操作 2 x y : 打印已经添加的所有点中，到(x, y)位置最短距离的点是多远
+// 1 <= n、m <= 3 * 10^5
+// 0 <= x、y <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P4169
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class170/Code06_AngelDoll2.java b/src/class170/Code06_AngelDoll2.java
index 7b183edac..05bcce6ec 100644
--- a/src/class170/Code06_AngelDoll2.java
+++ b/src/class170/Code06_AngelDoll2.java
@@ -1,6 +1,12 @@
 package class170;
 
 // 天使玩偶，C++版
+// 规定(x1, y1)和(x2, y2)之间的距离 = | x1 - x2 | + | y1 - y2 |
+// 一开始先给定n个点的位置，接下来有m条操作，每种操作是如下两种类型中的一种
+// 操作 1 x y : 在(x, y)位置添加一个点
+// 操作 2 x y : 打印已经添加的所有点中，到(x, y)位置最短距离的点是多远
+// 1 <= n、m <= 3 * 10^5
+// 0 <= x、y <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P4169
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 3f6d6d539e2959abe332997b6998b0856272f46a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 14:47:13 +0800
Subject: [PATCH 0892/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index 08817696a..6d2c041d9 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -65,7 +65,7 @@ public static void merge(int l, int m, int r) {
 		for (int i = l; i <= p1; i++) {
 			add(arr[i][3], -1);
 		}
-		// 直接排序，课上重点解释了这么做的理由
+		// 直接排序，课上重点解释了原因
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
 	}
 
@@ -82,7 +82,7 @@ public static void cdq(int l, int r) {
 	public static void prepare() {
 		// 根据a排序，a一样根据b排序，b一样根据c排序
 		// 排序后a、b、c一样的同组内，组前的下标得不到同组后面的统计量
-		// 所以先设置f的初始值，把这部分提前补偿给组前的下标，然后跑CDQ分治
+		// 所以把这部分的贡献，提前补偿给组前的下标，然后再跑CDQ分治
 		Arrays.sort(arr, 1, n + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[3] - b[3]);
 		for (int l = 1, r = 1; l <= n; l = ++r) {
 			while (r + 1 <= n && arr[l][1] == arr[r + 1][1] && arr[l][2] == arr[r + 1][2]

From 20833ab745751f8740483db4ff4804c276ddf4e5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 17:37:36 +0800
Subject: [PATCH 0893/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java | 16 ++++++++++------
 src/class170/Code01_3DPartialOrder2.java |  6 ++++--
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index 6d2c041d9..670bd31f2 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -18,17 +18,20 @@
 
 public class Code01_3DPartialOrder1 {
 
-	public static int MAXN = 200001;
+	public static int MAXN = 100001;
+	public static int MAXK = 200001;
 	public static int n, k;
 
-	// 位置i、属性a、属性b、属性c
+	// 对象的编号i、属性a、属性b、属性c
 	public static int[][] arr = new int[MAXN][4];
 
-	// 树状数组
-	public static int[] tree = new int[MAXN];
+	// 树状数组，根据属性c的值增加词频，查询 <= 某个数的词频累加和
+	public static int[] tree = new int[MAXK];
 
+	// 每个对象的答案
 	public static int[] f = new int[MAXN];
 
+	// 题目要求的ans[d]
 	public static int[] ans = new int[MAXN];
 
 	public static int lowbit(int i) {
@@ -52,7 +55,8 @@ public static int query(int i) {
 	}
 
 	public static void merge(int l, int m, int r) {
-		// 利用左右各自有序，进行不回退的统计
+		// 利用左、右各自b属性有序
+		// 不回退的找，当前右组对象包括了几个左组的对象
 		int p1, p2;
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][2] <= arr[p2][2]) {
@@ -65,7 +69,7 @@ public static void merge(int l, int m, int r) {
 		for (int i = l; i <= p1; i++) {
 			add(arr[i][3], -1);
 		}
-		// 直接排序，课上重点解释了原因
+		// 直接根据b属性排序，无需写经典的归并过程，课上重点解释了原因
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
 	}
 
diff --git a/src/class170/Code01_3DPartialOrder2.java b/src/class170/Code01_3DPartialOrder2.java
index f392dc1fc..9d3a07a20 100644
--- a/src/class170/Code01_3DPartialOrder2.java
+++ b/src/class170/Code01_3DPartialOrder2.java
@@ -33,10 +33,12 @@
 //    return x.b < y.b;
 //}
 //
-//const int MAXN = 200001;
+//const int MAXN = 100001;
+//const int MAXK = 200001;
 //int n, k;
+//
 //Node arr[MAXN];
-//int tree[MAXN];
+//int tree[MAXK];
 //int f[MAXN];
 //int ans[MAXN];
 //

From ef19f092e988c312bb13a40a656c98884187097c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 17:39:49 +0800
Subject: [PATCH 0894/1712] modify code

---
 src/class170/Code02_DynamicInversion1.java | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index 82156ac90..aa244094f 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -26,7 +26,7 @@ public class Code02_DynamicInversion1 {
 	public static int[] pos = new int[MAXN];
 	public static int[] del = new int[MAXM];
 
-	// 位置i、数值v、效果d、问题q
+	// 位置i、数值v、效果d、问题编号q
 	public static int[][] arr = new int[MAXN + MAXM][4];
 	public static int cnt = 0;
 
@@ -56,6 +56,7 @@ public static int query(int i) {
 
 	public static void merge(int l, int m, int r) {
 		int p1, p2;
+		// 从左到右获得贡献
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][0] <= arr[p2][0]) {
 				p1++;
@@ -63,9 +64,11 @@ public static void merge(int l, int m, int r) {
 			}
 			ans[arr[p2][3]] += arr[p2][2] * (query(n) - query(arr[p2][1]));
 		}
+		// 清除树状数组
 		for (int i = l; i <= p1; i++) {
 			add(arr[i][1], -arr[i][2]);
 		}
+		// 从右到左获得贡献
 		for (p1 = m + 1, p2 = r; p2 > m; p2--) {
 			while (p1 - 1 >= l && arr[p1 - 1][0] >= arr[p2][0]) {
 				p1--;
@@ -73,9 +76,11 @@ public static void merge(int l, int m, int r) {
 			}
 			ans[arr[p2][3]] += arr[p2][2] * query(arr[p2][1] - 1);
 		}
+		// 清除树状数组
 		for (int i = m; i >= p1; i--) {
 			add(arr[i][1], -arr[i][2]);
 		}
+		// 直接排序
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[0] - b[0]);
 	}
 

From d25b5a77d67f446fc0ddfb3d80f1e3228d7ef14e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 17:41:57 +0800
Subject: [PATCH 0895/1712] modify code

---
 src/class170/Code01_3DPartialOrder1.java   | 1 +
 src/class170/Code02_DynamicInversion1.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class170/Code01_3DPartialOrder1.java b/src/class170/Code01_3DPartialOrder1.java
index 670bd31f2..e8814ab18 100644
--- a/src/class170/Code01_3DPartialOrder1.java
+++ b/src/class170/Code01_3DPartialOrder1.java
@@ -73,6 +73,7 @@ public static void merge(int l, int m, int r) {
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
 	}
 
+	// 大顺序已经按a属性排序，cdq分治里按b属性重新排序
 	public static void cdq(int l, int r) {
 		if (l == r) {
 			return;
diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index aa244094f..116d6ba2f 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -84,6 +84,7 @@ public static void merge(int l, int m, int r) {
 		Arrays.sort(arr, l, r + 1, (a, b) -> a[0] - b[0]);
 	}
 
+	// 整体按时序组织，cdq分治里根据下标重新排序
 	public static void cdq(int l, int r) {
 		if (l == r) {
 			return;

From c23628853af5ff661e4770c94b5cdb6846ed51ee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 18:31:15 +0800
Subject: [PATCH 0896/1712] modify code

---
 src/class170/Code02_DynamicInversion1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index 116d6ba2f..d1d509b41 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -30,8 +30,10 @@ public class Code02_DynamicInversion1 {
 	public static int[][] arr = new int[MAXN + MAXM][4];
 	public static int cnt = 0;
 
+	// 树状数组
 	public static int[] tree = new int[MAXN];
 
+	// 每次逆序对的变化量
 	public static long[] ans = new long[MAXM];
 
 	public static int lowbit(int i) {

From 79a5f8efc5154e73f3b87f3a4d278b234139b1c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 19:22:48 +0800
Subject: [PATCH 0897/1712] modify code

---
 src/class170/Code02_DynamicInversion1.java | 32 +++++++++++-----------
 src/class170/Code02_DynamicInversion2.java | 10 +++----
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index d1d509b41..7869b3f28 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -26,7 +26,7 @@ public class Code02_DynamicInversion1 {
 	public static int[] pos = new int[MAXN];
 	public static int[] del = new int[MAXM];
 
-	// 位置i、数值v、效果d、问题编号q
+	// 数值v、位置i、效果d、问题编号q
 	public static int[][] arr = new int[MAXN + MAXM][4];
 	public static int cnt = 0;
 
@@ -58,32 +58,32 @@ public static int query(int i) {
 
 	public static void merge(int l, int m, int r) {
 		int p1, p2;
-		// 从左到右获得贡献
+		// 从左到右统计左侧值大的数量
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
-			while (p1 + 1 <= m && arr[p1 + 1][0] <= arr[p2][0]) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
 				p1++;
-				add(arr[p1][1], arr[p1][2]);
+				add(arr[p1][0], arr[p1][2]);
 			}
-			ans[arr[p2][3]] += arr[p2][2] * (query(n) - query(arr[p2][1]));
+			ans[arr[p2][3]] += arr[p2][2] * (query(n) - query(arr[p2][0]));
 		}
 		// 清除树状数组
 		for (int i = l; i <= p1; i++) {
-			add(arr[i][1], -arr[i][2]);
+			add(arr[i][0], -arr[i][2]);
 		}
-		// 从右到左获得贡献
+		// 从右到左统计右侧值小的数量
 		for (p1 = m + 1, p2 = r; p2 > m; p2--) {
-			while (p1 - 1 >= l && arr[p1 - 1][0] >= arr[p2][0]) {
+			while (p1 - 1 >= l && arr[p1 - 1][1] >= arr[p2][1]) {
 				p1--;
-				add(arr[p1][1], arr[p1][2]);
+				add(arr[p1][0], arr[p1][2]);
 			}
-			ans[arr[p2][3]] += arr[p2][2] * query(arr[p2][1] - 1);
+			ans[arr[p2][3]] += arr[p2][2] * query(arr[p2][0] - 1);
 		}
 		// 清除树状数组
 		for (int i = m; i >= p1; i--) {
-			add(arr[i][1], -arr[i][2]);
+			add(arr[i][0], -arr[i][2]);
 		}
 		// 直接排序
-		Arrays.sort(arr, l, r + 1, (a, b) -> a[0] - b[0]);
+		Arrays.sort(arr, l, r + 1, (a, b) -> a[1] - b[1]);
 	}
 
 	// 整体按时序组织，cdq分治里根据下标重新排序
@@ -99,14 +99,14 @@ public static void cdq(int l, int r) {
 
 	public static void prepare() {
 		for (int i = 1; i <= n; i++) {
-			arr[++cnt][0] = i;
-			arr[cnt][1] = num[i];
+			arr[++cnt][0] = num[i];
+			arr[cnt][1] = i;
 			arr[cnt][2] = 1;
 			arr[cnt][3] = 0;
 		}
 		for (int i = 1; i <= m; i++) {
-			arr[++cnt][0] = pos[del[i]];
-			arr[cnt][1] = del[i];
+			arr[++cnt][0] = del[i];
+			arr[cnt][1] = pos[del[i]];
 			arr[cnt][2] = -1;
 			arr[cnt][3] = i;
 		}
diff --git a/src/class170/Code02_DynamicInversion2.java b/src/class170/Code02_DynamicInversion2.java
index 79fec7567..4ab28b025 100644
--- a/src/class170/Code02_DynamicInversion2.java
+++ b/src/class170/Code02_DynamicInversion2.java
@@ -16,7 +16,7 @@
 //using namespace std;
 //
 //struct Node {
-//    int i, v, d, q;
+//    int v, i, d, q;
 //};
 //
 //bool NodeCmp(Node x, Node y) {
@@ -95,14 +95,14 @@
 //
 //void prepare() {
 //    for (int i = 1; i <= n; i++) {
-//        arr[++cnt].i = i;
-//        arr[cnt].v = num[i];
+//        arr[++cnt].v = num[i];
+//        arr[cnt].i = i;
 //        arr[cnt].d = 1;
 //        arr[cnt].q = 0;
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        arr[++cnt].i = pos[del[i]];
-//        arr[cnt].v = del[i];
+//        arr[++cnt].v = del[i];
+//        arr[cnt].i = pos[del[i]];
 //        arr[cnt].d = -1;
 //        arr[cnt].q = i;
 //    }

From 1dba19e7fb11e6f0fea96118e91599ca82523060 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 20:50:58 +0800
Subject: [PATCH 0898/1712] modify code

---
 src/class170/Code02_DynamicInversion1.java | 4 ++--
 src/class170/Code02_DynamicInversion2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index 7869b3f28..20688fc00 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -60,7 +60,7 @@ public static void merge(int l, int m, int r) {
 		int p1, p2;
 		// 从左到右统计左侧值大的数量
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
-			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] < arr[p2][1]) {
 				p1++;
 				add(arr[p1][0], arr[p1][2]);
 			}
@@ -72,7 +72,7 @@ public static void merge(int l, int m, int r) {
 		}
 		// 从右到左统计右侧值小的数量
 		for (p1 = m + 1, p2 = r; p2 > m; p2--) {
-			while (p1 - 1 >= l && arr[p1 - 1][1] >= arr[p2][1]) {
+			while (p1 - 1 >= l && arr[p1 - 1][1] > arr[p2][1]) {
 				p1--;
 				add(arr[p1][0], arr[p1][2]);
 			}
diff --git a/src/class170/Code02_DynamicInversion2.java b/src/class170/Code02_DynamicInversion2.java
index 4ab28b025..0a0320fc8 100644
--- a/src/class170/Code02_DynamicInversion2.java
+++ b/src/class170/Code02_DynamicInversion2.java
@@ -61,7 +61,7 @@
 //void merge(int l, int m, int r) {
 //    int p1, p2;
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
-//        while (p1 + 1 <= m && arr[p1 + 1].i <= arr[p2].i) {
+//        while (p1 + 1 <= m && arr[p1 + 1].i < arr[p2].i) {
 //            p1++;
 //            add(arr[p1].v, arr[p1].d);
 //        }
@@ -71,7 +71,7 @@
 //        add(arr[i].v, -arr[i].d);
 //    }
 //    for (p1 = m + 1, p2 = r; p2 > m; p2--) {
-//        while (p1 - 1 >= l && arr[p1 - 1].i >= arr[p2].i) {
+//        while (p1 - 1 >= l && arr[p1 - 1].i > arr[p2].i) {
 //            p1--;
 //            add(arr[p1].v, arr[p1].d);
 //        }

From b19b1e35e7404c9fc6444524bddf36e39457faf8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 21:13:53 +0800
Subject: [PATCH 0899/1712] modify code

---
 src/class170/Code02_DynamicInversion1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class170/Code02_DynamicInversion1.java b/src/class170/Code02_DynamicInversion1.java
index 20688fc00..179315f6f 100644
--- a/src/class170/Code02_DynamicInversion1.java
+++ b/src/class170/Code02_DynamicInversion1.java
@@ -22,6 +22,9 @@ public class Code02_DynamicInversion1 {
 	public static int MAXM = 50001;
 	public static int n, m;
 
+	// num : 原始序列依次的值
+	// pos : 每个值在什么位置
+	// del : 每一步删掉的值
 	public static int[] num = new int[MAXN];
 	public static int[] pos = new int[MAXN];
 	public static int[] del = new int[MAXM];

From d6e4fa36a5c9bac0039a32bff29f8bfabd728d08 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 21:16:00 +0800
Subject: [PATCH 0900/1712] modify code

---
 src/class170/Code03_GardenerTrouble1.java | 2 +-
 src/class170/Code04_TaskOfC1.java         | 2 +-
 src/class170/Code05_Mokia1.java           | 2 +-
 src/class170/Code06_AngelDoll1.java       | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class170/Code03_GardenerTrouble1.java b/src/class170/Code03_GardenerTrouble1.java
index d29084219..0d8982206 100644
--- a/src/class170/Code03_GardenerTrouble1.java
+++ b/src/class170/Code03_GardenerTrouble1.java
@@ -25,7 +25,7 @@ public class Code03_GardenerTrouble1 {
 	public static int n, m;
 
 	// op == 1代表树木，x、y
-	// op == 2代表查询，x、y、效果v、问题q
+	// op == 2代表查询，x、y、效果v、查询编号q
 	public static int[][] arr = new int[MAXN][5];
 	public static int cnt = 0;
 
diff --git a/src/class170/Code04_TaskOfC1.java b/src/class170/Code04_TaskOfC1.java
index 12fdbff4f..909e69967 100644
--- a/src/class170/Code04_TaskOfC1.java
+++ b/src/class170/Code04_TaskOfC1.java
@@ -21,7 +21,7 @@ public class Code04_TaskOfC1 {
 	public static int n, m;
 
 	// op == 1代表基站，x、y、功率v
-	// op == 2代表查询，x、y、效果v、问题q
+	// op == 2代表查询，x、y、效果v、查询编号q
 	public static int[][] arr = new int[MAXN][5];
 	public static int cnt = 0;
 
diff --git a/src/class170/Code05_Mokia1.java b/src/class170/Code05_Mokia1.java
index 36cfd8c20..eb676313c 100644
--- a/src/class170/Code05_Mokia1.java
+++ b/src/class170/Code05_Mokia1.java
@@ -24,7 +24,7 @@ public class Code05_Mokia1 {
 	public static int w;
 
 	// op == 1表示增加事件，x、y、人数v
-	// op == 1表示查询事件，x、y、效果v、问题q
+	// op == 1表示查询事件，x、y、效果v、查询编号q
 	public static int[][] arr = new int[MAXN][5];
 	public static int cnte = 0;
 	public static int cntq = 0;
diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index 137ee2139..f88efe12a 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -24,7 +24,7 @@ public class Code06_AngelDoll1 {
 	public static int n, m, v;
 
 	// op == 1代表添加事件，x、y、空缺
-	// op == 1代表查询事件，x、y、问题q
+	// op == 1代表查询事件，x、y、查询编号q
 	// tim永远保持原始时序，每次执行cdq时，让arr去变动
 	public static int[][] tim = new int[MAXN << 1][4];
 	public static int[][] arr = new int[MAXN << 1][4];

From 645937ea4b6f41d53683d8f9b5878bf3f8a5d0b9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 21:22:55 +0800
Subject: [PATCH 0901/1712] modify code

---
 src/class170/Code03_GardenerTrouble1.java | 5 ++++-
 src/class170/Code03_GardenerTrouble2.java | 3 ---
 src/class170/Code04_TaskOfC1.java         | 2 +-
 src/class170/Code04_TaskOfC2.java         | 3 ---
 4 files changed, 5 insertions(+), 8 deletions(-)

diff --git a/src/class170/Code03_GardenerTrouble1.java b/src/class170/Code03_GardenerTrouble1.java
index 0d8982206..e448738e4 100644
--- a/src/class170/Code03_GardenerTrouble1.java
+++ b/src/class170/Code03_GardenerTrouble1.java
@@ -70,6 +70,9 @@ public static void merge(int l, int m, int r) {
 				ans[arr[p2][4]] += tree * arr[p2][3];
 			}
 		}
+		// 下面是经典归并的过程，为啥不排序了？
+		// 因为没有用到高级数据结构，复杂度可以做到O(n * log n)
+		// 那么就维持最好的复杂度，不用排序
 		p1 = l;
 		p2 = m + 1;
 		int i = l;
@@ -117,7 +120,7 @@ public static void main(String[] args) throws IOException {
 			addQuery(a - 1, d, -1, i);
 			addQuery(c, b - 1, -1, i);
 		}
-		Arrays.sort(arr, 1, cnt + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
+		Arrays.sort(arr, 1, cnt + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[0] - b[0]);
 		cdq(1, cnt);
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class170/Code03_GardenerTrouble2.java b/src/class170/Code03_GardenerTrouble2.java
index 7a80680b1..bdaf8ae38 100644
--- a/src/class170/Code03_GardenerTrouble2.java
+++ b/src/class170/Code03_GardenerTrouble2.java
@@ -22,9 +22,6 @@
 //    if (a.x != b.x) {
 //        return a.x < b.x;
 //    }
-//    if (a.y != b.y) {
-//        return a.y < b.y;
-//    }
 //    return a.op < b.op;
 //}
 //
diff --git a/src/class170/Code04_TaskOfC1.java b/src/class170/Code04_TaskOfC1.java
index 909e69967..704cc2276 100644
--- a/src/class170/Code04_TaskOfC1.java
+++ b/src/class170/Code04_TaskOfC1.java
@@ -116,7 +116,7 @@ public static void main(String[] args) throws IOException {
 			addQuery(a - 1, d, -1, i);
 			addQuery(c, b - 1, -1, i);
 		}
-		Arrays.sort(arr, 1, cnt + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] != b[2] ? a[2] - b[2] : a[0] - b[0]);
+		Arrays.sort(arr, 1, cnt + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[0] - b[0]);
 		cdq(1, cnt);
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class170/Code04_TaskOfC2.java b/src/class170/Code04_TaskOfC2.java
index 6b00b2949..7830d8452 100644
--- a/src/class170/Code04_TaskOfC2.java
+++ b/src/class170/Code04_TaskOfC2.java
@@ -22,9 +22,6 @@
 //    if (a.x != b.x) {
 //        return a.x < b.x;
 //    }
-//    if (a.y != b.y) {
-//        return a.y < b.y;
-//    }
 //    return a.op < b.op;
 //}
 //

From e0307f88ceae3c203e8ab8f2e30ad347d7d0a3cf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 31 May 2025 21:24:06 +0800
Subject: [PATCH 0902/1712] modify code

---
 src/class170/Code03_GardenerTrouble1.java | 2 +-
 src/class170/Code04_TaskOfC1.java         | 3 +++
 2 files changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/class170/Code03_GardenerTrouble1.java b/src/class170/Code03_GardenerTrouble1.java
index e448738e4..88450d940 100644
--- a/src/class170/Code03_GardenerTrouble1.java
+++ b/src/class170/Code03_GardenerTrouble1.java
@@ -70,7 +70,7 @@ public static void merge(int l, int m, int r) {
 				ans[arr[p2][4]] += tree * arr[p2][3];
 			}
 		}
-		// 下面是经典归并的过程，为啥不排序了？
+		// 下面是经典归并的过程，为啥不直接排序了？
 		// 因为没有用到高级数据结构，复杂度可以做到O(n * log n)
 		// 那么就维持最好的复杂度，不用排序
 		p1 = l;
diff --git a/src/class170/Code04_TaskOfC1.java b/src/class170/Code04_TaskOfC1.java
index 704cc2276..acb8db1f7 100644
--- a/src/class170/Code04_TaskOfC1.java
+++ b/src/class170/Code04_TaskOfC1.java
@@ -68,6 +68,9 @@ public static void merge(int l, int m, int r) {
 				ans[arr[p2][4]] += sum * arr[p2][3];
 			}
 		}
+		// 下面是经典归并的过程，为啥不直接排序了？
+		// 因为没有用到高级数据结构，复杂度可以做到O(n * log n)
+		// 那么就维持最好的复杂度，不用排序
 		p1 = l;
 		p2 = m + 1;
 		int i = l;

From fa6e3488d2811caeae825347c122bd84292fb0c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 1 Jun 2025 13:41:48 +0800
Subject: [PATCH 0903/1712] modify code

---
 src/class170/Code05_Mokia1.java     | 1 +
 src/class170/Code06_AngelDoll1.java | 7 +++++++
 2 files changed, 8 insertions(+)

diff --git a/src/class170/Code05_Mokia1.java b/src/class170/Code05_Mokia1.java
index eb676313c..43696b7e4 100644
--- a/src/class170/Code05_Mokia1.java
+++ b/src/class170/Code05_Mokia1.java
@@ -29,6 +29,7 @@ public class Code05_Mokia1 {
 	public static int cnte = 0;
 	public static int cntq = 0;
 
+	// 树状数组
 	public static int[] tree = new int[MAXV];
 
 	public static int[] ans = new int[MAXN];
diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index f88efe12a..efc9a0ee3 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -31,6 +31,7 @@ public class Code06_AngelDoll1 {
 	public static int cnte = 0;
 	public static int cntq = 0;
 
+	// 树状数组，下标是y的值，维护前缀范围上的最大值
 	public static int[] tree = new int[MAXV];
 
 	public static int[] ans = new int[MAXN];
@@ -46,6 +47,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
+	// i位置的值设置成num，类似累加和操作，这里变成取最大值操作即可
 	public static void update(int i, int num) {
 		while (i <= v) {
 			tree[i] = Math.max(tree[i], num);
@@ -53,6 +55,7 @@ public static void update(int i, int num) {
 		}
 	}
 
+	// 查询1~i范围上的最大值
 	public static int query(int i) {
 		int ret = -INF;
 		while (i > 0) {
@@ -62,6 +65,8 @@ public static int query(int i) {
 		return ret;
 	}
 
+	// 因为本题的特殊性，树状数组一定需要全部清空的
+	// 所以当初更新时，i位置碰过哪些位置，一律设置无效值即可
 	public static void clear(int i) {
 		while (i <= v) {
 			tree[i] = -INF;
@@ -165,9 +170,11 @@ public static void main(String[] args) throws IOException {
 			v = Math.max(v, Math.max(x, y));
 		}
 		v++;
+		// 初始化树状数组
 		for (int i = 1; i <= v; i++) {
 			tree[i] = -INF;
 		}
+		// 初始化答案数组
 		for (int i = 1; i <= cntq; i++) {
 			ans[i] = INF;
 		}

From 654d0c6c661a59d33cb55535d35a495a04fb907d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 1 Jun 2025 13:46:09 +0800
Subject: [PATCH 0904/1712] modify code

---
 src/class170/Code06_AngelDoll1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index efc9a0ee3..1ac84cbe1 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -25,7 +25,7 @@ public class Code06_AngelDoll1 {
 
 	// op == 1代表添加事件，x、y、空缺
 	// op == 1代表查询事件，x、y、查询编号q
-	// tim永远保持原始时序，每次执行cdq时，让arr去变动
+	// tim永远保持原始时序，每次变换象限都拷贝给arr，然后执行cdq分治
 	public static int[][] tim = new int[MAXN << 1][4];
 	public static int[][] arr = new int[MAXN << 1][4];
 	public static int cnte = 0;
@@ -65,7 +65,7 @@ public static int query(int i) {
 		return ret;
 	}
 
-	// 因为本题的特殊性，树状数组一定需要全部清空的
+	// 因为本题的特殊性，树状数组一定全部清空
 	// 所以当初更新时，i位置碰过哪些位置，一律设置无效值即可
 	public static void clear(int i) {
 		while (i <= v) {

From 99f9a375351909b6dfadb5838a4882f1a177f13b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 1 Jun 2025 14:32:58 +0800
Subject: [PATCH 0905/1712] modify code

---
 src/class170/Code05_Mokia1.java | 6 +++---
 src/class170/Code05_Mokia2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class170/Code05_Mokia1.java b/src/class170/Code05_Mokia1.java
index 43696b7e4..f27f33352 100644
--- a/src/class170/Code05_Mokia1.java
+++ b/src/class170/Code05_Mokia1.java
@@ -19,20 +19,20 @@
 
 public class Code05_Mokia1 {
 
-	public static int MAXN = 200001;
+	public static int MAXM = 200001;
 	public static int MAXV = 2000002;
 	public static int w;
 
 	// op == 1表示增加事件，x、y、人数v
 	// op == 1表示查询事件，x、y、效果v、查询编号q
-	public static int[][] arr = new int[MAXN][5];
+	public static int[][] arr = new int[MAXM][5];
 	public static int cnte = 0;
 	public static int cntq = 0;
 
 	// 树状数组
 	public static int[] tree = new int[MAXV];
 
-	public static int[] ans = new int[MAXN];
+	public static int[] ans = new int[MAXM];
 
 	public static int lowbit(int i) {
 		return i & -i;
diff --git a/src/class170/Code05_Mokia2.java b/src/class170/Code05_Mokia2.java
index 800255c5d..2070eed08 100644
--- a/src/class170/Code05_Mokia2.java
+++ b/src/class170/Code05_Mokia2.java
@@ -24,18 +24,18 @@
 //    return a.x < b.x;
 //}
 //
-//const int MAXN = 200001;
+//const int MAXM = 200001;
 //const int MAXV = 2000002;
 //const int INF = 1000000001;
 //int w;
 //
-//Node arr[MAXN];
+//Node arr[MAXM];
 //int cnte = 0;
 //int cntq = 0;
 //
 //int tree[MAXV];
 //
-//int ans[MAXN];
+//int ans[MAXM];
 //
 //int lowbit(int i) {
 //    return i & -i;

From 535465ddb0854c44f348e9523d275313baf81da3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 1 Jun 2025 14:54:45 +0800
Subject: [PATCH 0906/1712] modify code

---
 src/class170/Code05_Mokia1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class170/Code05_Mokia1.java b/src/class170/Code05_Mokia1.java
index f27f33352..f4c516973 100644
--- a/src/class170/Code05_Mokia1.java
+++ b/src/class170/Code05_Mokia1.java
@@ -24,7 +24,7 @@ public class Code05_Mokia1 {
 	public static int w;
 
 	// op == 1表示增加事件，x、y、人数v
-	// op == 1表示查询事件，x、y、效果v、查询编号q
+	// op == 2表示查询事件，x、y、效果v、查询编号q
 	public static int[][] arr = new int[MAXM][5];
 	public static int cnte = 0;
 	public static int cntq = 0;

From bd63bc119a0fbb58b3b4d24d80f291d3b57a7f5a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 1 Jun 2025 17:17:38 +0800
Subject: [PATCH 0907/1712] modify code

---
 ...Q\345\210\206\346\262\273-\344\270\212.pptx" | Bin 0 -> 50348 bytes
 src/class170/Code06_AngelDoll1.java             |  10 +++++-----
 src/class170/Code06_AngelDoll2.java             |   4 ++--
 3 files changed, 7 insertions(+), 7 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243170\343\200\220\346\214\272\351\232\276\343\200\221CDQ\345\210\206\346\262\273-\344\270\212.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243170\343\200\220\346\214\272\351\232\276\343\200\221CDQ\345\210\206\346\262\273-\344\270\212.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243170\343\200\220\346\214\272\351\232\276\343\200\221CDQ\345\210\206\346\262\273-\344\270\212.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..8355427c2ddf14bbeed18b3b5fb4cae8a14746c6
GIT binary patch
literal 50348
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
aw?{RUF@R4?z`_&YIRV^dXsr76?tcIU#ZSKg

literal 0
HcmV?d00001

diff --git a/src/class170/Code06_AngelDoll1.java b/src/class170/Code06_AngelDoll1.java
index 1ac84cbe1..eeadf751b 100644
--- a/src/class170/Code06_AngelDoll1.java
+++ b/src/class170/Code06_AngelDoll1.java
@@ -24,7 +24,7 @@ public class Code06_AngelDoll1 {
 	public static int n, m, v;
 
 	// op == 1代表添加事件，x、y、空缺
-	// op == 1代表查询事件，x、y、查询编号q
+	// op == 2代表查询事件，x、y、查询编号q
 	// tim永远保持原始时序，每次变换象限都拷贝给arr，然后执行cdq分治
 	public static int[][] tim = new int[MAXN << 1][4];
 	public static int[][] arr = new int[MAXN << 1][4];
@@ -47,15 +47,15 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	// i位置的值设置成num，类似累加和操作，这里变成取最大值操作即可
-	public static void update(int i, int num) {
+	// 树状数组，如果i位置之前的值更大，忽略，num更大才更新
+	public static void more(int i, int num) {
 		while (i <= v) {
 			tree[i] = Math.max(tree[i], num);
 			i += lowbit(i);
 		}
 	}
 
-	// 查询1~i范围上的最大值
+	// 树状数组，查询1~i范围上的最大值
 	public static int query(int i) {
 		int ret = -INF;
 		while (i > 0) {
@@ -80,7 +80,7 @@ public static void merge(int l, int m, int r) {
 			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
 				p1++;
 				if (arr[p1][0] == 1) {
-					update(arr[p1][2], arr[p1][1] + arr[p1][2]);
+					more(arr[p1][2], arr[p1][1] + arr[p1][2]);
 				}
 			}
 			if (arr[p2][0] == 2) {
diff --git a/src/class170/Code06_AngelDoll2.java b/src/class170/Code06_AngelDoll2.java
index 05bcce6ec..33a106e6e 100644
--- a/src/class170/Code06_AngelDoll2.java
+++ b/src/class170/Code06_AngelDoll2.java
@@ -41,7 +41,7 @@
 //    return i & -i;
 //}
 //
-//void update(int i, int num) {
+//void more(int i, int num) {
 //    while (i <= v) {
 //        tree[i] = max(tree[i], num);
 //        i += lowbit(i);
@@ -70,7 +70,7 @@
 //        while (p1 + 1 <= m && arr[p1 + 1].x <= arr[p2].x) {
 //            p1++;
 //            if (arr[p1].op == 1) {
-//                update(arr[p1].y, arr[p1].x + arr[p1].y);
+//                more(arr[p1].y, arr[p1].x + arr[p1].y);
 //            }
 //        }
 //        if (arr[p2].op == 2) {

From 3265e832076a2660da648936685c1e3ca1cf470a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 2 Jun 2025 15:17:39 +0800
Subject: [PATCH 0908/1712] modify code

---
 src/class171/Code01_MooFest1.java | 120 ++++++++++++++++++++++++++++++
 src/class171/Code01_MooFest2.java |  75 +++++++++++++++++++
 2 files changed, 195 insertions(+)
 create mode 100644 src/class171/Code01_MooFest1.java
 create mode 100644 src/class171/Code01_MooFest2.java

diff --git a/src/class171/Code01_MooFest1.java b/src/class171/Code01_MooFest1.java
new file mode 100644
index 000000000..868c4fe27
--- /dev/null
+++ b/src/class171/Code01_MooFest1.java
@@ -0,0 +1,120 @@
+package class171;
+
+// 奶牛音量和，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2345
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_MooFest1 {
+
+	public static int MAXN = 20001;
+	public static int n;
+	// 听力v、位置x
+	public static int[][] arr = new int[MAXN][2];
+	// 归并排序需要
+	public static int[][] tmp = new int[MAXN][2];
+
+	public static void clone(int[] a, int[] b) {
+		a[0] = b[0];
+		a[1] = b[1];
+	}
+
+	public static long merge(int l, int m, int r) {
+		int p1, p2;
+		long sum1 = 0, sum2 = 0, ans = 0;
+		for (p1 = l; p1 <= m; p1++) {
+			sum1 += arr[p1][1];
+		}
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] < arr[p2][1]) {
+				p1++;
+				sum1 -= arr[p1][1];
+				sum2 += arr[p1][1];
+			}
+			ans += (1L * (p1 - l + 1) * arr[p2][1] - sum2 + sum1 - 1L * (m - p1) * arr[p2][1]) * arr[p2][0];
+		}
+		p1 = l;
+		p2 = m + 1;
+		int i = l;
+		while (p1 <= m && p2 <= r) {
+			clone(tmp[i++], arr[p1][1] <= arr[p2][1] ? arr[p1++] : arr[p2++]);
+		}
+		while (p1 <= m) {
+			clone(tmp[i++], arr[p1++]);
+		}
+		while (p2 <= r) {
+			clone(tmp[i++], arr[p2++]);
+		}
+		for (i = l; i <= r; i++) {
+			clone(arr[i], tmp[i]);
+		}
+		return ans;
+	}
+
+	public static long cdq(int l, int r) {
+		if (l == r) {
+			return 0;
+		}
+		int mid = (l + r) / 2;
+		return cdq(l, mid) + cdq(mid + 1, r) + merge(l, mid, r);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = in.nextInt();
+			arr[i][1] = in.nextInt();
+		}
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a[0] - b[0]);
+		out.println(cdq(1, n));
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class171/Code01_MooFest2.java b/src/class171/Code01_MooFest2.java
new file mode 100644
index 000000000..4f0508bf6
--- /dev/null
+++ b/src/class171/Code01_MooFest2.java
@@ -0,0 +1,75 @@
+package class171;
+
+// 奶牛音量和，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2345
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int v, x;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    return a.v < b.v;
+//}
+//
+//const int MAXN = 20001;
+//int n;
+//Node arr[MAXN];
+//Node tmp[MAXN];
+//
+//long long merge(int l, int m, int r) {
+//    int p1, p2;
+//    long long sum1 = 0, sum2 = 0, ans = 0;
+//    for (p1 = l; p1 <= m; p1++) {
+//        sum1 += arr[p1].x;
+//    }
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].x < arr[p2].x) {
+//            p1++;
+//            sum1 -= arr[p1].x;
+//            sum2 += arr[p1].x;
+//        }
+//        ans += (1LL * (p1 - l + 1) * arr[p2].x - sum2 + sum1 - 1LL * (m - p1) * arr[p2].x) * arr[p2].v;
+//    }
+//    p1 = l;
+//    p2 = m + 1;
+//    int i = l;
+//    while (p1 <= m && p2 <= r) {
+//        tmp[i++] = arr[p1].x <= arr[p2].x ? arr[p1++] : arr[p2++];
+//    }
+//    while (p1 <= m) {
+//        tmp[i++] = arr[p1++];
+//    }
+//    while (p2 <= r) {
+//        tmp[i++] = arr[p2++];
+//    }
+//    for (i = l; i <= r; i++) {
+//        arr[i] = tmp[i];
+//    }
+//    return ans;
+//}
+//
+//long long cdq(int l, int r) {
+//    if (l == r) {
+//        return 0;
+//    }
+//    int mid = (l + r) / 2;
+//    return cdq(l, mid) + cdq(mid + 1, r) + merge(l, mid, r);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i].v >> arr[i].x;
+//    }
+//    sort(arr + 1, arr + n + 1, NodeCmp);
+//    cout << cdq(1, n) << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 278122ca3a6de848579245bdb84163b3f10d9398 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 2 Jun 2025 15:26:02 +0800
Subject: [PATCH 0909/1712] modify code

---
 src/class171/Code01_MooFest1.java | 4 ++--
 src/class171/Code01_MooFest2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class171/Code01_MooFest1.java b/src/class171/Code01_MooFest1.java
index 868c4fe27..9924e6958 100644
--- a/src/class171/Code01_MooFest1.java
+++ b/src/class171/Code01_MooFest1.java
@@ -1,7 +1,7 @@
 package class171;
 
 // 奶牛音量和，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P2345
+// 测试链接 : https://www.luogu.com.cn/problem/P5094
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
@@ -12,7 +12,7 @@
 
 public class Code01_MooFest1 {
 
-	public static int MAXN = 20001;
+	public static int MAXN = 50001;
 	public static int n;
 	// 听力v、位置x
 	public static int[][] arr = new int[MAXN][2];
diff --git a/src/class171/Code01_MooFest2.java b/src/class171/Code01_MooFest2.java
index 4f0508bf6..c5dab7ed3 100644
--- a/src/class171/Code01_MooFest2.java
+++ b/src/class171/Code01_MooFest2.java
@@ -1,7 +1,7 @@
 package class171;
 
 // 奶牛音量和，C++版
-// 测试链接 : https://www.luogu.com.cn/problem/P2345
+// 测试链接 : https://www.luogu.com.cn/problem/P5094
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
@@ -17,7 +17,7 @@
 //    return a.v < b.v;
 //}
 //
-//const int MAXN = 20001;
+//const int MAXN = 50001;
 //int n;
 //Node arr[MAXN];
 //Node tmp[MAXN];

From eb6cd4d8317e7358ed74ca5acdee20c7b92240a9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 2 Jun 2025 22:02:02 +0800
Subject: [PATCH 0910/1712] modify code

---
 src/class171/Code02_AiRobots1.java | 180 +++++++++++++++++++++++++++++
 src/class171/Code02_AiRobots2.java | 141 ++++++++++++++++++++++
 2 files changed, 321 insertions(+)
 create mode 100644 src/class171/Code02_AiRobots1.java
 create mode 100644 src/class171/Code02_AiRobots2.java

diff --git a/src/class171/Code02_AiRobots1.java b/src/class171/Code02_AiRobots1.java
new file mode 100644
index 000000000..8b7384fd3
--- /dev/null
+++ b/src/class171/Code02_AiRobots1.java
@@ -0,0 +1,180 @@
+package class171;
+
+// 机器人可见对，java版
+// 测试链接 : https://codeforces.com/problemset/problem/1045/G
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_AiRobots1 {
+
+	public static int MAXN = 100001;
+	public static int n, k, s;
+
+	// 位置x、视野y、智商q、左边界l、右边界r
+	public static int[][] arr = new int[MAXN][5];
+	// 所有x坐标组成的数组
+	public static int[] x = new int[MAXN];
+
+	public static int[] tree = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= s) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static int query(int l, int r) {
+		return sum(r) - sum(l - 1);
+	}
+
+	public static long merge(int l, int m, int r) {
+		int winl = l, winr = l - 1;
+		long ans = 0;
+		for (int i = m + 1; i <= r; i++) {
+			while (winl <= m && arr[winl][2] < arr[i][2] - k) {
+				add(arr[winl][0], -1);
+				winl++;
+			}
+			while (winr + 1 <= m && arr[winr + 1][2] <= arr[i][2] + k) {
+				winr++;
+				add(arr[winr][0], 1);
+			}
+			ans += query(arr[i][3], arr[i][4]);
+		}
+		for (int i = winl; i <= winr; i++) {
+			add(arr[i][0], -1);
+		}
+		Arrays.sort(arr, l, r + 1, (a, b) -> a[2] - b[2]);
+		return ans;
+	}
+
+	public static long cdq(int l, int r) {
+		if (l == r) {
+			return 0;
+		}
+		int mid = (l + r) / 2;
+		return cdq(l, mid) + cdq(mid + 1, r) + merge(l, mid, r);
+	}
+
+	public static int lower(int num) {
+		int l = 1, r = s, m, ans = 1;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (x[m] >= num) {
+				ans = m;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static int upper(int num) {
+		int l = 1, r = s, m, ans = s + 1;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (x[m] > num) {
+				ans = m;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			x[i] = arr[i][0];
+		}
+		Arrays.sort(x, 1, n + 1);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (x[s] != x[i]) {
+				x[++s] = x[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i][3] = lower(arr[i][0] - arr[i][1]);
+			arr[i][4] = upper(arr[i][0] + arr[i][1]) - 1;
+			arr[i][0] = lower(arr[i][0]);
+		}
+		Arrays.sort(arr, 1, n + 1, (a, b) -> b[1] - a[1]);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = in.nextInt();
+			arr[i][1] = in.nextInt();
+			arr[i][2] = in.nextInt();
+		}
+		prepare();
+		out.println(cdq(1, n));
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class171/Code02_AiRobots2.java b/src/class171/Code02_AiRobots2.java
new file mode 100644
index 000000000..5f3640bcc
--- /dev/null
+++ b/src/class171/Code02_AiRobots2.java
@@ -0,0 +1,141 @@
+package class171;
+
+// 机器人可见对，C++版
+// 测试链接 : https://codeforces.com/problemset/problem/1045/G
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int x, y, q, l, r;
+//};
+//
+//bool CmpY(Node a, Node b) {
+//    return a.y > b.y;
+//}
+//
+//bool CmpQ(Node a, Node b) {
+//    return a.q < b.q;
+//}
+//
+//const int MAXN = 100001;
+//int n, k, s;
+//
+//Node arr[MAXN];
+//int x[MAXN];
+//int tree[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= s) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//int query(int l, int r) {
+//    return sum(r) - sum(l - 1);
+//}
+//
+//long long merge(int l, int m, int r) {
+//    int winl = l, winr = l - 1;
+//    long long ans = 0;
+//    for (int i = m + 1; i <= r; i++) {
+//        while (winl <= m && arr[winl].q < arr[i].q - k) {
+//            add(arr[winl].x, -1);
+//            winl++;
+//        }
+//        while (winr + 1 <= m && arr[winr + 1].q <= arr[i].q + k) {
+//            winr++;
+//            add(arr[winr].x, 1);
+//        }
+//        ans += query(arr[i].l, arr[i].r);
+//    }
+//    for (int i = winl; i <= winr; i++) {
+//        add(arr[i].x, -1);
+//    }
+//    sort(arr + l, arr + r + 1, CmpQ);
+//    return ans;
+//}
+//
+//long long cdq(int l, int r) {
+//    if (l == r) {
+//        return 0;
+//    }
+//    int mid = (l + r) / 2;
+//    return cdq(l, mid) + cdq(mid + 1, r) + merge(l, mid, r);
+//}
+//
+//int lower(int num) {
+//    int l = 1, r = s, m, ans = 1;
+//    while (l <= r) {
+//        m = (l + r) / 2;
+//        if (x[m] >= num) {
+//            ans = m;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int upper(int num) {
+//    int l = 1, r = s, m, ans = s + 1;
+//    while (l <= r) {
+//        m = (l + r) / 2;
+//        if (x[m] > num) {
+//            ans = m;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        x[i] = arr[i].x;
+//    }
+//    sort(x + 1, x + n + 1);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (x[s] != x[i]) {
+//            x[++s] = x[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].l = lower(arr[i].x - arr[i].y);
+//        arr[i].r = upper(arr[i].x + arr[i].y) - 1;
+//        arr[i].x = lower(arr[i].x);
+//    }
+//    sort(arr + 1, arr + n + 1, CmpY);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i].x >> arr[i].y >> arr[i].q;
+//    }
+//    prepare();
+//    cout << cdq(1, n) << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 5eaa4960c652e0f183caa322d1cccb0ee5e2c963 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 2 Jun 2025 22:03:29 +0800
Subject: [PATCH 0911/1712] modify code

---
 src/class171/Code02_AiRobots1.java | 1 +
 src/class171/Code02_AiRobots2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class171/Code02_AiRobots1.java b/src/class171/Code02_AiRobots1.java
index 8b7384fd3..204696710 100644
--- a/src/class171/Code02_AiRobots1.java
+++ b/src/class171/Code02_AiRobots1.java
@@ -1,6 +1,7 @@
 package class171;
 
 // 机器人可见对，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1045G
 // 测试链接 : https://codeforces.com/problemset/problem/1045/G
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class171/Code02_AiRobots2.java b/src/class171/Code02_AiRobots2.java
index 5f3640bcc..fd64540fd 100644
--- a/src/class171/Code02_AiRobots2.java
+++ b/src/class171/Code02_AiRobots2.java
@@ -1,6 +1,7 @@
 package class171;
 
 // 机器人可见对，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1045G
 // 测试链接 : https://codeforces.com/problemset/problem/1045/G
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 44e981f9c7da2252f73510d4d1eaac7c89ed04cb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 14:39:35 +0800
Subject: [PATCH 0912/1712] modify code

---
 src/class171/Code03_Sequence1.java | 146 +++++++++++++++++++++++++++++
 src/class171/Code03_Sequence2.java | 111 ++++++++++++++++++++++
 2 files changed, 257 insertions(+)
 create mode 100644 src/class171/Code03_Sequence1.java
 create mode 100644 src/class171/Code03_Sequence2.java

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
new file mode 100644
index 000000000..f719ebeca
--- /dev/null
+++ b/src/class171/Code03_Sequence1.java
@@ -0,0 +1,146 @@
+package class171;
+
+// 序列，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4093
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code03_Sequence1 {
+
+	public static int MAXN = 100001;
+	public static int n, m;
+	// 位置i、数值v、最小值minv、最大值maxv
+	public static int[][] arr = new int[MAXN][4];
+	public static int[] tree = new int[MAXN];
+	public static int[] dp = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void more(int i, int num) {
+		while (i <= n) {
+			tree[i] = Math.max(tree[i], num);
+			i += lowbit(i);
+		}
+	}
+
+	public static int query(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret = Math.max(ret, tree[i]);
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void clear(int i) {
+		while (i <= n) {
+			tree[i] = 0;
+			i += lowbit(i);
+		}
+	}
+
+	public static void merge(int l, int m, int r) {
+		Arrays.sort(arr, l, m + 1, (a, b) -> a[1] - b[1]);
+		Arrays.sort(arr, m + 1, r + 1, (a, b) -> a[2] - b[2]);
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][2]) {
+				p1++;
+				more(arr[p1][3], dp[arr[p1][0]]);
+			}
+			dp[arr[p2][0]] = Math.max(dp[arr[p2][0]], query(arr[p2][1]) + 1);
+		}
+		for (int i = l; i <= p1; i++) {
+			clear(arr[i][3]);
+		}
+		Arrays.sort(arr, l, r + 1, (a, b) -> a[0] - b[0]);
+	}
+
+	public static void cdq(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		// 为什么不是经典顺序，左、右、整合左右
+		// 因为右侧dp需要先获得左侧dp的值，获得部分的可能性
+		// 然后才能在右侧范围上把剩下的可能性算完
+		cdq(l, mid);
+		merge(l, mid, r);
+		cdq(mid + 1, r);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i][0] = i;
+			arr[i][1] = in.nextInt();
+			arr[i][2] = arr[i][1];
+			arr[i][3] = arr[i][1];
+			dp[i] = 1;
+		}
+		for (int i = 1, idx, num; i <= m; i++) {
+			idx = in.nextInt();
+			num = in.nextInt();
+			arr[idx][2] = Math.min(arr[idx][2], num);
+			arr[idx][3] = Math.max(arr[idx][3], num);
+		}
+		cdq(1, n);
+		int ans = 0;
+		for (int i = 1; i <= n; i++) {
+			ans = Math.max(ans, dp[i]);
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class171/Code03_Sequence2.java b/src/class171/Code03_Sequence2.java
new file mode 100644
index 000000000..35c4ebcb1
--- /dev/null
+++ b/src/class171/Code03_Sequence2.java
@@ -0,0 +1,111 @@
+package class171;
+
+// 序列，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4093
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int i, v, minv, maxv;
+//};
+//
+//bool CmpI(Node a, Node b) {
+//    return a.i < b.i;
+//}
+//
+//bool CmpV(Node a, Node b) {
+//    return a.v < b.v;
+//}
+//
+//bool CmpMinv(Node a, Node b) {
+//    return a.minv < b.minv;
+//}
+//
+//const int MAXN = 100001;
+//int n, m;
+//Node arr[MAXN];
+//int tree[MAXN];
+//int dp[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void more(int i, int num) {
+//    while (i <= n) {
+//        tree[i] = max(tree[i], num);
+//        i += lowbit(i);
+//    }
+//}
+//
+//int query(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret = max(ret, tree[i]);
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void clear(int i) {
+//    while (i <= n) {
+//        tree[i] = 0;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void merge(int l, int m, int r) {
+//    sort(arr + l, arr + m + 1, CmpV);
+//    sort(arr + m + 1, arr + r + 1, CmpMinv);
+//    int p1 = l - 1, p2 = m + 1;
+//    for (; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].v <= arr[p2].minv) {
+//            p1++;
+//            more(arr[p1].maxv, dp[arr[p1].i]);
+//        }
+//        dp[arr[p2].i] = max(dp[arr[p2].i], query(arr[p2].v) + 1);
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        clear(arr[i].maxv);
+//    }
+//    sort(arr + l, arr + r + 1, CmpI);
+//}
+//
+//void cdq(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int mid = (l + r) / 2;
+//    cdq(l, mid);
+//    merge(l, mid, r);
+//    cdq(mid + 1, r);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].i = i;
+//        cin >> arr[i].v;
+//        arr[i].minv = arr[i].v;
+//        arr[i].maxv = arr[i].v;
+//        dp[i] = 1;
+//    }
+//    for (int i = 1, idx, num; i <= m; i++) {
+//        cin >> idx >> num;
+//        arr[idx].minv = min(arr[idx].minv, num);
+//        arr[idx].maxv = max(arr[idx].maxv, num);
+//    }
+//    cdq(1, n);
+//    int ans = 0;
+//    for (int i = 1; i <= n; i++) {
+//        ans = max(ans, dp[i]);
+//    }
+//    cout << ans << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 00c3cb2289c9ee1a814c000717418885ea75de42 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 14:59:32 +0800
Subject: [PATCH 0913/1712] modify code

---
 src/class171/Code03_Sequence1.java | 8 +++++---
 1 file changed, 5 insertions(+), 3 deletions(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index f719ebeca..7599fdaec 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -68,9 +68,11 @@ public static void cdq(int l, int r) {
 			return;
 		}
 		int mid = (l + r) / 2;
-		// 为什么不是经典顺序，左、右、整合左右
-		// 因为右侧dp需要先获得左侧dp的值，获得部分的可能性
-		// 然后才能在右侧范围上把剩下的可能性算完
+		// 为什么不是经典顺序，左、右、再整合？
+		// 因为右侧dp的计算依赖左侧dp的结果
+		// 需要先处理左侧范围，得到部分状态转移的可能性
+		// 然后左右范围合并时，先把左边dp的影响传递到右边
+		// 需要再处理右侧范围，才能彻底把右侧dp计算正确
 		cdq(l, mid);
 		merge(l, mid, r);
 		cdq(mid + 1, r);

From 48dcea508798e0e6b0a296b7c7c2952ae2dcc34d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 15:01:45 +0800
Subject: [PATCH 0914/1712] modify code

---
 src/class171/Code03_Sequence1.java | 1 +
 src/class171/Code03_Sequence2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 7599fdaec..f899a2cb9 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -14,6 +14,7 @@ public class Code03_Sequence1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
+
 	// 位置i、数值v、最小值minv、最大值maxv
 	public static int[][] arr = new int[MAXN][4];
 	public static int[] tree = new int[MAXN];
diff --git a/src/class171/Code03_Sequence2.java b/src/class171/Code03_Sequence2.java
index 35c4ebcb1..00159322a 100644
--- a/src/class171/Code03_Sequence2.java
+++ b/src/class171/Code03_Sequence2.java
@@ -27,6 +27,7 @@
 //
 //const int MAXN = 100001;
 //int n, m;
+//
 //Node arr[MAXN];
 //int tree[MAXN];
 //int dp[MAXN];

From 5db71b8019abce20ccdb097b061273fd9a11f7c9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 15:08:35 +0800
Subject: [PATCH 0915/1712] modify code

---
 src/class171/Code03_Sequence1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index f899a2cb9..d38e0a5fc 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -72,8 +72,8 @@ public static void cdq(int l, int r) {
 		// 为什么不是经典顺序，左、右、再整合？
 		// 因为右侧dp的计算依赖左侧dp的结果
 		// 需要先处理左侧范围，得到部分状态转移的可能性
-		// 然后左右范围合并时，先把左边dp的影响传递到右边
-		// 需要再处理右侧范围，才能彻底把右侧dp计算正确
+		// 然后再进行左右合并，把左边dp的影响传递到右边
+		// 最后再处理右侧范围，才能彻底把右侧dp计算正确
 		cdq(l, mid);
 		merge(l, mid, r);
 		cdq(mid + 1, r);

From 1baf4cacebfe96356be600b29f9898726f71392f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 15:10:31 +0800
Subject: [PATCH 0916/1712] modify code

---
 src/class171/Code03_Sequence1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index d38e0a5fc..3d828d00d 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -72,7 +72,7 @@ public static void cdq(int l, int r) {
 		// 为什么不是经典顺序，左、右、再整合？
 		// 因为右侧dp的计算依赖左侧dp的结果
 		// 需要先处理左侧范围，得到部分状态转移的可能性
-		// 然后再进行左右合并，把左边dp的影响传递到右边
+		// 然后把左侧dp结果推送到右侧，右侧先获得这些结果
 		// 最后再处理右侧范围，才能彻底把右侧dp计算正确
 		cdq(l, mid);
 		merge(l, mid, r);

From 2af58e3ef9389be88007bee49565ad15c28e5de1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 15:12:25 +0800
Subject: [PATCH 0917/1712] modify code

---
 src/class171/Code03_Sequence1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 3d828d00d..d8bfd7e61 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -69,7 +69,7 @@ public static void cdq(int l, int r) {
 			return;
 		}
 		int mid = (l + r) / 2;
-		// 为什么不是经典顺序，左、右、再整合？
+		// 为什么顺序是左、merge、右，而不是经典顺序，左、右、merge？
 		// 因为右侧dp的计算依赖左侧dp的结果
 		// 需要先处理左侧范围，得到部分状态转移的可能性
 		// 然后把左侧dp结果推送到右侧，右侧先获得这些结果

From 64fcdb7936cf988cdfc35a4aef8486a6563be2f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 15:13:07 +0800
Subject: [PATCH 0918/1712] modify code

---
 src/class171/Code03_Sequence1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index d8bfd7e61..5369a1865 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -73,7 +73,7 @@ public static void cdq(int l, int r) {
 		// 因为右侧dp的计算依赖左侧dp的结果
 		// 需要先处理左侧范围，得到部分状态转移的可能性
 		// 然后把左侧dp结果推送到右侧，右侧先获得这些结果
-		// 最后再处理右侧范围，才能彻底把右侧dp计算正确
+		// 在此基础上，最后处理右侧范围，才能把右侧dp计算正确
 		cdq(l, mid);
 		merge(l, mid, r);
 		cdq(mid + 1, r);

From cea60ae6d88c84dacf1dec9d2b777eb7e7276a80 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 16:19:31 +0800
Subject: [PATCH 0919/1712] modify code

---
 src/class171/Code03_Sequence1.java |  2 +-
 src/class171/Code03_Sequence2.java | 22 +++++++++++-----------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 5369a1865..893eb5b91 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -15,7 +15,7 @@ public class Code03_Sequence1 {
 	public static int MAXN = 100001;
 	public static int n, m;
 
-	// 位置i、数值v、最小值minv、最大值maxv
+	// 位置i、数值v、最小值min、最大值max
 	public static int[][] arr = new int[MAXN][4];
 	public static int[] tree = new int[MAXN];
 	public static int[] dp = new int[MAXN];
diff --git a/src/class171/Code03_Sequence2.java b/src/class171/Code03_Sequence2.java
index 00159322a..16c3669ad 100644
--- a/src/class171/Code03_Sequence2.java
+++ b/src/class171/Code03_Sequence2.java
@@ -10,7 +10,7 @@
 //using namespace std;
 //
 //struct Node {
-//    int i, v, minv, maxv;
+//    int i, v, min, max;
 //};
 //
 //bool CmpI(Node a, Node b) {
@@ -21,8 +21,8 @@
 //    return a.v < b.v;
 //}
 //
-//bool CmpMinv(Node a, Node b) {
-//    return a.minv < b.minv;
+//bool CmpMin(Node a, Node b) {
+//    return a.min < b.min;
 //}
 //
 //const int MAXN = 100001;
@@ -61,17 +61,17 @@
 //
 //void merge(int l, int m, int r) {
 //    sort(arr + l, arr + m + 1, CmpV);
-//    sort(arr + m + 1, arr + r + 1, CmpMinv);
+//    sort(arr + m + 1, arr + r + 1, CmpMin);
 //    int p1 = l - 1, p2 = m + 1;
 //    for (; p2 <= r; p2++) {
-//        while (p1 + 1 <= m && arr[p1 + 1].v <= arr[p2].minv) {
+//        while (p1 + 1 <= m && arr[p1 + 1].v <= arr[p2].min) {
 //            p1++;
-//            more(arr[p1].maxv, dp[arr[p1].i]);
+//            more(arr[p1].max, dp[arr[p1].i]);
 //        }
 //        dp[arr[p2].i] = max(dp[arr[p2].i], query(arr[p2].v) + 1);
 //    }
 //    for (int i = l; i <= p1; i++) {
-//        clear(arr[i].maxv);
+//        clear(arr[i].max);
 //    }
 //    sort(arr + l, arr + r + 1, CmpI);
 //}
@@ -93,14 +93,14 @@
 //    for (int i = 1; i <= n; i++) {
 //        arr[i].i = i;
 //        cin >> arr[i].v;
-//        arr[i].minv = arr[i].v;
-//        arr[i].maxv = arr[i].v;
+//        arr[i].min = arr[i].v;
+//        arr[i].max = arr[i].v;
 //        dp[i] = 1;
 //    }
 //    for (int i = 1, idx, num; i <= m; i++) {
 //        cin >> idx >> num;
-//        arr[idx].minv = min(arr[idx].minv, num);
-//        arr[idx].maxv = max(arr[idx].maxv, num);
+//        arr[idx].min = min(arr[idx].min, num);
+//        arr[idx].max = max(arr[idx].max, num);
 //    }
 //    cdq(1, n);
 //    int ans = 0;

From 8ccd9d40e6902d558911d3198deaffeac6b329e1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 20:43:20 +0800
Subject: [PATCH 0920/1712] modify code

---
 .../Code04_MinimumCostToCutAStick.java        |   4 +-
 src/class093/Code02_MinimumTaps.java          |   2 +-
 src/class127/Code06_FrogCrossRiver.java       |   2 +-
 src/class151/Code06_RemovingBlocks.java       |   2 +-
 src/class152/Code05_PersistentFHQTreap2.java  |   2 +-
 src/class155/Code04_Blocks2.java              |  10 +-
 src/class165/Code04_TeamBuilding1.java        |   2 +-
 src/class165/Code04_TeamBuilding2.java        |   2 +-
 src/class167/Code04_ShortestPathQueries2.java |   4 +-
 .../Code05_EightVerticalHorizontal2.java      |   8 +-
 src/class171/Code04_Interceptor1.java         | 127 ++++++++++++++++++
 11 files changed, 146 insertions(+), 19 deletions(-)
 create mode 100644 src/class171/Code04_Interceptor1.java

diff --git a/src/class076/Code04_MinimumCostToCutAStick.java b/src/class076/Code04_MinimumCostToCutAStick.java
index a3ac6ad08..97e640704 100644
--- a/src/class076/Code04_MinimumCostToCutAStick.java
+++ b/src/class076/Code04_MinimumCostToCutAStick.java
@@ -19,7 +19,7 @@ public static int minCost1(int n, int[] cuts) {
 		Arrays.sort(cuts);
 		int[] arr = new int[m + 2];
 		arr[0] = 0;
-		for (int i = 1; i <= m; ++i) {
+		for (int i = 1; i <= m; i++) {
 			arr[i] = cuts[i - 1];
 		}
 		arr[m + 1] = n;
@@ -59,7 +59,7 @@ public static int minCost2(int n, int[] cuts) {
 		Arrays.sort(cuts);
 		int[] arr = new int[m + 2];
 		arr[0] = 0;
-		for (int i = 1; i <= m; ++i) {
+		for (int i = 1; i <= m; i++) {
 			arr[i] = cuts[i - 1];
 		}
 		arr[m + 1] = n;
diff --git a/src/class093/Code02_MinimumTaps.java b/src/class093/Code02_MinimumTaps.java
index b9256c4ef..00ce7c044 100644
--- a/src/class093/Code02_MinimumTaps.java
+++ b/src/class093/Code02_MinimumTaps.java
@@ -15,7 +15,7 @@ public static int minTaps(int n, int[] ranges) {
 		// right[i] = j
 		// 所有左边界在i的水龙头里，影响到的最右右边界是j
 		int[] right = new int[n + 1];
-		for (int i = 0, start; i <= n; ++i) {
+		for (int i = 0, start; i <= n; i++) {
 			start = Math.max(0, i - ranges[i]);
 			right[start] = Math.max(right[start], i + ranges[i]);
 		}
diff --git a/src/class127/Code06_FrogCrossRiver.java b/src/class127/Code06_FrogCrossRiver.java
index c324ab1b5..9b473eb5c 100644
--- a/src/class127/Code06_FrogCrossRiver.java
+++ b/src/class127/Code06_FrogCrossRiver.java
@@ -51,7 +51,7 @@ public static void main(String[] args) throws IOException {
 		t = (int) in.nval;
 		in.nextToken();
 		m = (int) in.nval;
-		for (int i = 1; i <= m; ++i) {
+		for (int i = 1; i <= m; i++) {
 			in.nextToken();
 			arr[i] = (int) in.nval;
 		}
diff --git a/src/class151/Code06_RemovingBlocks.java b/src/class151/Code06_RemovingBlocks.java
index 346fda77e..c992c896b 100644
--- a/src/class151/Code06_RemovingBlocks.java
+++ b/src/class151/Code06_RemovingBlocks.java
@@ -53,7 +53,7 @@ public static long compute() {
 		for (int i = 1; i <= n; i++) {
 			ans = (ans + (long) (sum[i] + sum[n - i + 1] - 1) * arr[i]) % MOD;
 		}
-		for (int i = 1; i <= n; ++i) {
+		for (int i = 1; i <= n; i++) {
 			ans = ans * i % MOD;
 		}
 		return ans;
diff --git a/src/class152/Code05_PersistentFHQTreap2.java b/src/class152/Code05_PersistentFHQTreap2.java
index 04e262a99..6ae238d6f 100644
--- a/src/class152/Code05_PersistentFHQTreap2.java
+++ b/src/class152/Code05_PersistentFHQTreap2.java
@@ -155,7 +155,7 @@
 //    srand(time(0));
 //    int n;
 //    cin >> n;
-//    for (int i = 1; i <= n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        int version, op, x;
 //        cin >> version >> op >> x;
 //        if (op == 1) {
diff --git a/src/class155/Code04_Blocks2.java b/src/class155/Code04_Blocks2.java
index c4011e9ba..96001b00c 100644
--- a/src/class155/Code04_Blocks2.java
+++ b/src/class155/Code04_Blocks2.java
@@ -113,13 +113,13 @@
 //
 //void compute() {
 //    int first = 0;
-//    for (int i = 1; i <= n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        sort(arr + start[i], arr + boundary[i]);
 //        first += arr[start[i]];
 //    }
 //    dist[0] = -1;
 //    int head = 0;
-//    for (int i = 1; i <= n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        head = merge(head, init(i, start[i]));
 //    }
 //    pre[head] = first;
@@ -146,17 +146,17 @@
 //    cin.tie(nullptr);
 //    cin >> n >> k;
 //    int ai = 0;
-//    for (int i = 1; i <= n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        int m;
 //        cin >> m;
 //        start[i] = ai + 1;
-//        for (int j = 1; j <= m; ++j) {
+//        for (int j = 1; j <= m; j++) {
 //            cin >> arr[++ai];
 //        }
 //        boundary[i] = start[i] + m;
 //    }
 //    compute();
-//    for (int i = 1; i <= k; ++i) {
+//    for (int i = 1; i <= k; i++) {
 //        cout << ans[i] << " ";
 //    }
 //    cout << endl;
diff --git a/src/class165/Code04_TeamBuilding1.java b/src/class165/Code04_TeamBuilding1.java
index 06632f782..b17811682 100644
--- a/src/class165/Code04_TeamBuilding1.java
+++ b/src/class165/Code04_TeamBuilding1.java
@@ -74,7 +74,7 @@ public static void undo() {
 	}
 
 	public static void filter() {
-		for (int i = 1; i <= 2 * n; ++i) {
+		for (int i = 1; i <= 2 * n; i++) {
 			father[i] = i;
 			siz[i] = 1;
 		}
diff --git a/src/class165/Code04_TeamBuilding2.java b/src/class165/Code04_TeamBuilding2.java
index f7f9d83e5..8d020b931 100644
--- a/src/class165/Code04_TeamBuilding2.java
+++ b/src/class165/Code04_TeamBuilding2.java
@@ -74,7 +74,7 @@
 //}
 //
 //void filter() {
-//    for (int i = 1; i <= 2 * n; ++i) {
+//    for (int i = 1; i <= 2 * n; i++) {
 //        father[i] = i;
 //        siz[i] = 1;
 //    }
diff --git a/src/class167/Code04_ShortestPathQueries2.java b/src/class167/Code04_ShortestPathQueries2.java
index dc4999a8a..492aa380c 100644
--- a/src/class167/Code04_ShortestPathQueries2.java
+++ b/src/class167/Code04_ShortestPathQueries2.java
@@ -64,7 +64,7 @@
 //int ans[MAXN];
 //
 //void insert(int num) {
-//    for (int i = BIT; i >= 0; --i) {
+//    for (int i = BIT; i >= 0; i--) {
 //        if (num >> i == 1) {
 //            if (basis[i] == 0) {
 //                basis[i] = num;
@@ -77,7 +77,7 @@
 //}
 //
 //int minEor(int num) {
-//    for (int i = BIT; i >= 0; --i) {
+//    for (int i = BIT; i >= 0; i--) {
 //        num = min(num, num ^ basis[i]);
 //    }
 //    return num;
diff --git a/src/class167/Code05_EightVerticalHorizontal2.java b/src/class167/Code05_EightVerticalHorizontal2.java
index 762f79888..d7e950199 100644
--- a/src/class167/Code05_EightVerticalHorizontal2.java
+++ b/src/class167/Code05_EightVerticalHorizontal2.java
@@ -48,7 +48,7 @@
 //bs ans[MAXQ];
 //
 //void insert(bs& num) {
-//    for (int i = BIT; i >= 0; --i) {
+//    for (int i = BIT; i >= 0; i--) {
 //        if (num[i] == 1) {
 //            if (basis[i][i] == 0) {
 //                basis[i] = num;
@@ -159,16 +159,16 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m >> q;
-//    for (int i = 0; i <= BIT; ++i) {
+//    for (int i = 0; i <= BIT; i++) {
 //        basis[i].reset();
 //    }
-//    for (int i = 1; i <= n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        father[i] = i;
 //        eor[i].reset();
 //    }
 //    int u, v;
 //    bs weight;
-//    for (int i = 1; i <= m; ++i) {
+//    for (int i = 1; i <= m; i++) {
 //        cin >> u >> v >> weight;
 //        Union(u, v, weight);
 //    }
diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
new file mode 100644
index 000000000..b98d14222
--- /dev/null
+++ b/src/class171/Code04_Interceptor1.java
@@ -0,0 +1,127 @@
+package class171;
+
+// 拦截导弹，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2487
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code04_Interceptor1 {
+
+	public static int MAXN = 50001;
+
+	public static int n, s;
+
+	// 位置i、高度h、速度v
+	public static int[][] arr = new int[MAXN][3];
+	public static int[] sortv = new int[MAXN];
+
+	public static int[] max1 = new int[MAXN];
+	public static double[] cnt1 = new double[MAXN];
+
+	public static int[] max2 = new int[MAXN];
+	public static double[] cnt2 = new double[MAXN];
+
+	public static int[] treemax = new int[MAXN];
+	public static double[] treecnt = new double[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int max, double cnt) {
+		while (i <= s) {
+			if (max > treemax[i]) {
+				treemax[i] = max;
+				treecnt[i] = cnt;
+			} else if (max == treemax[i]) {
+				treecnt[i] += cnt;
+			}
+			i += lowbit(i);
+		}
+	}
+
+	public static int querymax;
+
+	public static double querycnt;
+
+	public static void query(int i) {
+		querymax = 0;
+		querycnt = 0;
+		while (i > 0) {
+			if (treemax[i] > querymax) {
+				querymax = treemax[i];
+				querycnt = treecnt[i];
+			} else if (treemax[i] == querymax) {
+				querycnt += treecnt[i];
+			}
+			i -= lowbit(i);
+		}
+	}
+
+	public static void clear(int i) {
+		while (i <= s) {
+			treemax[i] = 0;
+			treecnt[i] = 0;
+			i += lowbit(i);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for(int i = 1; i <= n; i++) {
+			arr[i][0] = i;
+			arr[i][1] = in.nextInt();
+			arr[i][2] = in.nextInt();
+			sortv[i] = arr[i][2];
+		}
+		
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From e9ee87a117ad24f45b32e378c47cdcb2bd3d20d8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 23:38:27 +0800
Subject: [PATCH 0921/1712] modify code

---
 src/class171/Code04_Interceptor1.java | 204 +++++++++++++++++++----
 src/class171/Code04_Interceptor2.java | 230 ++++++++++++++++++++++++++
 2 files changed, 406 insertions(+), 28 deletions(-)
 create mode 100644 src/class171/Code04_Interceptor2.java

diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
index b98d14222..05c3e1872 100644
--- a/src/class171/Code04_Interceptor1.java
+++ b/src/class171/Code04_Interceptor1.java
@@ -8,54 +8,56 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
+import java.util.Arrays;
 
 public class Code04_Interceptor1 {
 
 	public static int MAXN = 50001;
-
 	public static int n, s;
+	public static int[] h = new int[MAXN];
+	public static int[] v = new int[MAXN];
+	public static int[] sortv = new int[MAXN];
 
 	// 位置i、高度h、速度v
 	public static int[][] arr = new int[MAXN][3];
-	public static int[] sortv = new int[MAXN];
 
-	public static int[] max1 = new int[MAXN];
-	public static double[] cnt1 = new double[MAXN];
+	// 树状数组，维护最大长度、最大长度出现的次数
+	public static int[] treelen = new int[MAXN];
+	public static double[] treecnt = new double[MAXN];
 
-	public static int[] max2 = new int[MAXN];
-	public static double[] cnt2 = new double[MAXN];
+	public static int[] f1 = new int[MAXN];
+	public static double[] g1 = new double[MAXN];
 
-	public static int[] treemax = new int[MAXN];
-	public static double[] treecnt = new double[MAXN];
+	public static int[] f2 = new int[MAXN];
+	public static double[] g2 = new double[MAXN];
 
-	public static int lowbit(int i) {
-		return i & -i;
+	public static int lowbit(int x) {
+		return x & -x;
 	}
 
-	public static void add(int i, int max, double cnt) {
+	public static void add(int i, int len, double cnt) {
 		while (i <= s) {
-			if (max > treemax[i]) {
-				treemax[i] = max;
+			if (len > treelen[i]) {
+				treelen[i] = len;
 				treecnt[i] = cnt;
-			} else if (max == treemax[i]) {
+			} else if (len == treelen[i]) {
 				treecnt[i] += cnt;
 			}
 			i += lowbit(i);
 		}
 	}
 
-	public static int querymax;
-
+	public static int querylen;
 	public static double querycnt;
 
 	public static void query(int i) {
-		querymax = 0;
+		querylen = 0;
 		querycnt = 0;
 		while (i > 0) {
-			if (treemax[i] > querymax) {
-				querymax = treemax[i];
+			if (treelen[i] > querylen) {
+				querylen = treelen[i];
 				querycnt = treecnt[i];
-			} else if (treemax[i] == querymax) {
+			} else if (treelen[i] == querylen) {
 				querycnt += treecnt[i];
 			}
 			i -= lowbit(i);
@@ -64,25 +66,171 @@ public static void query(int i) {
 
 	public static void clear(int i) {
 		while (i <= s) {
-			treemax[i] = 0;
+			treelen[i] = 0;
 			treecnt[i] = 0;
 			i += lowbit(i);
 		}
 	}
 
+	public static void merge1(int l, int m, int r) {
+		for (int i = l; i <= r; i++) {
+			arr[i][0] = i;
+			arr[i][1] = h[i];
+			arr[i][2] = v[i];
+		}
+		Arrays.sort(arr, l, m + 1, (a, b) -> b[1] - a[1]);
+		Arrays.sort(arr, m + 1, r + 1, (a, b) -> b[1] - a[1]);
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] >= arr[p2][1]) {
+				p1++;
+				add(s - arr[p1][2] + 1, f1[arr[p1][0]], g1[arr[p1][0]]);
+			}
+			query(s - arr[p2][2] + 1);
+			if (querylen + 1 > f1[arr[p2][0]]) {
+				f1[arr[p2][0]] = querylen + 1;
+				g1[arr[p2][0]] = querycnt;
+			} else if (querylen + 1 == f1[arr[p2][0]]) {
+				g1[arr[p2][0]] += querycnt;
+			}
+		}
+		for (int i = l; i <= p1; i++) {
+			clear(s - arr[i][2] + 1);
+		}
+	}
+
+	public static void cdq1(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq1(l, mid);
+		merge1(l, mid, r);
+		cdq1(mid + 1, r);
+	}
+
+	public static void merge2(int l, int m, int r) {
+		for (int i = l; i <= r; i++) {
+			arr[i][0] = i;
+			arr[i][1] = h[i];
+			arr[i][2] = v[i];
+		}
+		Arrays.sort(arr, l, m + 1, (a, b) -> a[1] - b[1]);
+		Arrays.sort(arr, m + 1, r + 1, (a, b) -> a[1] - b[1]);
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
+				p1++;
+				add(arr[p1][2], f2[arr[p1][0]], g2[arr[p1][0]]);
+			}
+			query(arr[p2][2]);
+			if (querylen + 1 > f2[arr[p2][0]]) {
+				f2[arr[p2][0]] = querylen + 1;
+				g2[arr[p2][0]] = querycnt;
+			} else if (querylen + 1 == f2[arr[p2][0]]) {
+				g2[arr[p2][0]] += querycnt;
+			}
+		}
+		for (int i = l; i <= p1; i++) {
+			clear(arr[i][2]);
+		}
+	}
+
+	public static void cdq2(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int m = (l + r) / 2;
+		cdq2(l, m);
+		merge2(l, m, r);
+		cdq2(m + 1, r);
+	}
+
+	public static int lower(int num) {
+		int l = 1, r = s, ans = 1;
+		while (l <= r) {
+			int mid = (l + r) / 2;
+			if (sortv[mid] >= num) {
+				ans = mid;
+				r = mid - 1;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sortv[i] = v[i];
+		}
+		Arrays.sort(sortv, 1, n + 1);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sortv[s] != sortv[i]) {
+				sortv[++s] = sortv[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			v[i] = lower(v[i]);
+		}
+		for (int i = 1; i <= n; i++) {
+			f1[i] = f2[i] = 1;
+			g1[i] = g2[i] = 1.0;
+		}
+	}
+
+	public static void compute() {
+		cdq1(1, n);
+		for (int l = 1, r = n; l < r; l++, r--) {
+			int a = h[l];
+			h[l] = h[r];
+			h[r] = a;
+			int b = v[l];
+			v[l] = v[r];
+			v[r] = b;
+		}
+		cdq2(1, n);
+		for (int l = 1, r = n; l < r; l++, r--) {
+			int a = f2[l];
+			f2[l] = f2[r];
+			f2[r] = a;
+			double b = g2[l];
+			g2[l] = g2[r];
+			g2[r] = b;
+		}
+	}
+
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
-		for(int i = 1; i <= n; i++) {
-			arr[i][0] = i;
-			arr[i][1] = in.nextInt();
-			arr[i][2] = in.nextInt();
-			sortv[i] = arr[i][2];
+		for (int i = 1; i <= n; i++) {
+			h[i] = in.nextInt();
+			v[i] = in.nextInt();
+		}
+		prepare();
+		compute();
+		int len = 0;
+		double cnt = 0;
+		for (int i = 1; i <= n; i++) {
+			len = Math.max(len, f1[i]);
+		}
+		for (int i = 1; i <= n; i++) {
+			if (f1[i] == len) {
+				cnt += g1[i];
+			}
+		}
+		out.println(len);
+		for (int i = 1; i <= n; i++) {
+			if (f1[i] + f2[i] - 1 < len) {
+				out.print("0 ");
+			} else {
+				out.printf("%.5f ", g1[i] * g2[i] / cnt);
+			}
 		}
-		
+		out.println();
 		out.flush();
-		out.close();
 	}
 
 	// 读写工具类
diff --git a/src/class171/Code04_Interceptor2.java b/src/class171/Code04_Interceptor2.java
new file mode 100644
index 000000000..e5b3b2148
--- /dev/null
+++ b/src/class171/Code04_Interceptor2.java
@@ -0,0 +1,230 @@
+package class171;
+
+// 拦截导弹，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2487
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int i, h, v;
+//};
+//
+//bool Cmp1(Node a, Node b) {
+//    return a.h > b.h;
+//}
+//
+//bool Cmp2(Node a, Node b) {
+//    return a.h < b.h;
+//}
+//
+//const int MAXN = 50001;
+//int n, s;
+//int h[MAXN];
+//int v[MAXN];
+//int sortv[MAXN];
+//
+//Node arr[MAXN];
+//
+//int treelen[MAXN];
+//double treecnt[MAXN];
+//
+//int f1[MAXN];
+//double g1[MAXN];
+//
+//int f2[MAXN];
+//double g2[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int len, double cnt) {
+//    while (i <= s) {
+//        if (len > treelen[i]) {
+//            treelen[i] = len;
+//            treecnt[i] = cnt;
+//        } else if (len == treelen[i]) {
+//            treecnt[i] += cnt;
+//        }
+//        i += lowbit(i);
+//    }
+//}
+//
+//int querylen;
+//double querycnt;
+//
+//void query(int i) {
+//    querylen = 0;
+//    querycnt = 0;
+//    while (i > 0) {
+//        if (treelen[i] > querylen) {
+//            querylen = treelen[i];
+//            querycnt = treecnt[i];
+//        } else if (treelen[i] == querylen) {
+//            querycnt += treecnt[i];
+//        }
+//        i -= lowbit(i);
+//    }
+//}
+//
+//void clear(int i) {
+//    while (i <= s) {
+//        treelen[i] = 0;
+//        treecnt[i] = 0;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void merge1(int l, int m, int r) {
+//    for (int i = l; i <= r; i++) {
+//        arr[i].i = i;
+//        arr[i].h = h[i];
+//        arr[i].v = v[i];
+//    }
+//    sort(arr + l, arr + m + 1, Cmp1);
+//    sort(arr + m + 1, arr + r + 1, Cmp1);
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].h >= arr[p2].h) {
+//            p1++;
+//            add(s - arr[p1].v + 1, f1[arr[p1].i], g1[arr[p1].i]);
+//        }
+//        query(s - arr[p2].v + 1);
+//        if (querylen + 1 > f1[arr[p2].i]) {
+//            f1[arr[p2].i] = querylen + 1;
+//            g1[arr[p2].i] = querycnt;
+//        } else if (querylen + 1 == f1[arr[p2].i]) {
+//            g1[arr[p2].i] += querycnt;
+//        }
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        clear(s - arr[i].v + 1);
+//    }
+//}
+//
+//void cdq1(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int m = (l + r) / 2;
+//    cdq1(l, m);
+//    merge1(l, m, r);
+//    cdq1(m + 1, r);
+//}
+//
+//void merge2(int l, int m, int r) {
+//    for (int i = l; i <= r; i++) {
+//        arr[i].i = i;
+//        arr[i].h = h[i];
+//        arr[i].v = v[i];
+//    }
+//    sort(arr + l, arr + m + 1, Cmp2);
+//    sort(arr + m + 1, arr + r + 1, Cmp2);
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].h <= arr[p2].h) {
+//            p1++;
+//            add(arr[p1].v, f2[arr[p1].i], g2[arr[p1].i]);
+//        }
+//        query(arr[p2].v);
+//        if (querylen + 1 > f2[arr[p2].i]) {
+//            f2[arr[p2].i] = querylen + 1;
+//            g2[arr[p2].i] = querycnt;
+//        } else if (querylen + 1 == f2[arr[p2].i]) {
+//            g2[arr[p2].i] += querycnt;
+//        }
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        clear(arr[i].v);
+//    }
+//}
+//
+//void cdq2(int l, int r) {
+//    if (l == r) {
+//        return;
+//    }
+//    int m = (l + r) / 2;
+//    cdq2(l, m);
+//    merge2(l, m, r);
+//    cdq2(m + 1, r);
+//}
+//
+//int lower(int num) {
+//    int l = 1, r = s, ans = 1;
+//    while (l <= r) {
+//        int mid = (l + r) / 2;
+//        if (sortv[mid] >= num) {
+//            ans = mid;
+//            r = mid - 1;
+//        } else {
+//            l = mid + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sortv[i] = v[i];
+//    }
+//    sort(sortv + 1, sortv + n + 1);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sortv[s] != sortv[i]) {
+//            sortv[++s] = sortv[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        v[i] = lower(v[i]);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        f1[i] = f2[i] = 1;
+//        g1[i] = g2[i] = 1.0;
+//    }
+//}
+//
+//void compute() {
+//    cdq1(1, n);
+//    for (int l = 1, r = n; l < r; l++, r--) {
+//        swap(h[l], h[r]);
+//        swap(v[l], v[r]);
+//    }
+//    cdq2(1, n);
+//    for (int l = 1, r = n; l < r; l++, r--) {
+//        swap(f2[l], f2[r]);
+//        swap(g2[l], g2[r]);
+//    }
+//}
+//
+//int main() {
+//    scanf("%d", &n);
+//    for (int i = 1; i <= n; i++) {
+//        scanf("%d%d", &h[i], &v[i]);
+//    }
+//    prepare();
+//    compute();
+//    int len = 0;
+//    double cnt = 0.0;
+//    for (int i = 1; i <= n; i++) {
+//        len = max(len, f1[i]);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        if (f1[i] == len) {
+//            cnt += g1[i];
+//        }
+//    }
+//    printf("%d\n", len);
+//    for (int i = 1; i <= n; i++) {
+//        if (f1[i] + f2[i] - 1 < len) {
+//            printf("0 ");
+//        } else {
+//            printf("%.5f ", g1[i] * g2[i] / cnt);
+//        }
+//    }
+//    printf("\n");
+//    return 0;
+//}
\ No newline at end of file

From a834493b32c2ae7c56d879249a627eea6bae2efa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 3 Jun 2025 23:42:41 +0800
Subject: [PATCH 0922/1712] modify code

---
 src/class171/Code04_Interceptor1.java | 58 +++++++++++++--------------
 src/class171/Code04_Interceptor2.java | 50 +++++++++++------------
 2 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
index 05c3e1872..290ef225a 100644
--- a/src/class171/Code04_Interceptor1.java
+++ b/src/class171/Code04_Interceptor1.java
@@ -25,11 +25,11 @@ public class Code04_Interceptor1 {
 	public static int[] treelen = new int[MAXN];
 	public static double[] treecnt = new double[MAXN];
 
-	public static int[] f1 = new int[MAXN];
-	public static double[] g1 = new double[MAXN];
+	public static int[] len1 = new int[MAXN];
+	public static double[] cnt1 = new double[MAXN];
 
-	public static int[] f2 = new int[MAXN];
-	public static double[] g2 = new double[MAXN];
+	public static int[] len2 = new int[MAXN];
+	public static double[] cnt2 = new double[MAXN];
 
 	public static int lowbit(int x) {
 		return x & -x;
@@ -84,14 +84,14 @@ public static void merge1(int l, int m, int r) {
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][1] >= arr[p2][1]) {
 				p1++;
-				add(s - arr[p1][2] + 1, f1[arr[p1][0]], g1[arr[p1][0]]);
+				add(s - arr[p1][2] + 1, len1[arr[p1][0]], cnt1[arr[p1][0]]);
 			}
 			query(s - arr[p2][2] + 1);
-			if (querylen + 1 > f1[arr[p2][0]]) {
-				f1[arr[p2][0]] = querylen + 1;
-				g1[arr[p2][0]] = querycnt;
-			} else if (querylen + 1 == f1[arr[p2][0]]) {
-				g1[arr[p2][0]] += querycnt;
+			if (querylen + 1 > len1[arr[p2][0]]) {
+				len1[arr[p2][0]] = querylen + 1;
+				cnt1[arr[p2][0]] = querycnt;
+			} else if (querylen + 1 == len1[arr[p2][0]]) {
+				cnt1[arr[p2][0]] += querycnt;
 			}
 		}
 		for (int i = l; i <= p1; i++) {
@@ -121,14 +121,14 @@ public static void merge2(int l, int m, int r) {
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
 				p1++;
-				add(arr[p1][2], f2[arr[p1][0]], g2[arr[p1][0]]);
+				add(arr[p1][2], len2[arr[p1][0]], cnt2[arr[p1][0]]);
 			}
 			query(arr[p2][2]);
-			if (querylen + 1 > f2[arr[p2][0]]) {
-				f2[arr[p2][0]] = querylen + 1;
-				g2[arr[p2][0]] = querycnt;
-			} else if (querylen + 1 == f2[arr[p2][0]]) {
-				g2[arr[p2][0]] += querycnt;
+			if (querylen + 1 > len2[arr[p2][0]]) {
+				len2[arr[p2][0]] = querylen + 1;
+				cnt2[arr[p2][0]] = querycnt;
+			} else if (querylen + 1 == len2[arr[p2][0]]) {
+				cnt2[arr[p2][0]] += querycnt;
 			}
 		}
 		for (int i = l; i <= p1; i++) {
@@ -175,8 +175,8 @@ public static void prepare() {
 			v[i] = lower(v[i]);
 		}
 		for (int i = 1; i <= n; i++) {
-			f1[i] = f2[i] = 1;
-			g1[i] = g2[i] = 1.0;
+			len1[i] = len2[i] = 1;
+			cnt1[i] = cnt2[i] = 1.0;
 		}
 	}
 
@@ -192,12 +192,12 @@ public static void compute() {
 		}
 		cdq2(1, n);
 		for (int l = 1, r = n; l < r; l++, r--) {
-			int a = f2[l];
-			f2[l] = f2[r];
-			f2[r] = a;
-			double b = g2[l];
-			g2[l] = g2[r];
-			g2[r] = b;
+			int a = len2[l];
+			len2[l] = len2[r];
+			len2[r] = a;
+			double b = cnt2[l];
+			cnt2[l] = cnt2[r];
+			cnt2[r] = b;
 		}
 	}
 
@@ -214,19 +214,19 @@ public static void main(String[] args) throws IOException {
 		int len = 0;
 		double cnt = 0;
 		for (int i = 1; i <= n; i++) {
-			len = Math.max(len, f1[i]);
+			len = Math.max(len, len1[i]);
 		}
 		for (int i = 1; i <= n; i++) {
-			if (f1[i] == len) {
-				cnt += g1[i];
+			if (len1[i] == len) {
+				cnt += cnt1[i];
 			}
 		}
 		out.println(len);
 		for (int i = 1; i <= n; i++) {
-			if (f1[i] + f2[i] - 1 < len) {
+			if (len1[i] + len2[i] - 1 < len) {
 				out.print("0 ");
 			} else {
-				out.printf("%.5f ", g1[i] * g2[i] / cnt);
+				out.printf("%.5f ", cnt1[i] * cnt2[i] / cnt);
 			}
 		}
 		out.println();
diff --git a/src/class171/Code04_Interceptor2.java b/src/class171/Code04_Interceptor2.java
index e5b3b2148..a97774069 100644
--- a/src/class171/Code04_Interceptor2.java
+++ b/src/class171/Code04_Interceptor2.java
@@ -32,11 +32,11 @@
 //int treelen[MAXN];
 //double treecnt[MAXN];
 //
-//int f1[MAXN];
-//double g1[MAXN];
+//int len1[MAXN];
+//double cnt1[MAXN];
 //
-//int f2[MAXN];
-//double g2[MAXN];
+//int len2[MAXN];
+//double cnt2[MAXN];
 //
 //int lowbit(int i) {
 //    return i & -i;
@@ -91,14 +91,14 @@
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && arr[p1 + 1].h >= arr[p2].h) {
 //            p1++;
-//            add(s - arr[p1].v + 1, f1[arr[p1].i], g1[arr[p1].i]);
+//            add(s - arr[p1].v + 1, len1[arr[p1].i], cnt1[arr[p1].i]);
 //        }
 //        query(s - arr[p2].v + 1);
-//        if (querylen + 1 > f1[arr[p2].i]) {
-//            f1[arr[p2].i] = querylen + 1;
-//            g1[arr[p2].i] = querycnt;
-//        } else if (querylen + 1 == f1[arr[p2].i]) {
-//            g1[arr[p2].i] += querycnt;
+//        if (querylen + 1 > len1[arr[p2].i]) {
+//            len1[arr[p2].i] = querylen + 1;
+//            cnt1[arr[p2].i] = querycnt;
+//        } else if (querylen + 1 == len1[arr[p2].i]) {
+//            cnt1[arr[p2].i] += querycnt;
 //        }
 //    }
 //    for (int i = l; i <= p1; i++) {
@@ -128,14 +128,14 @@
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && arr[p1 + 1].h <= arr[p2].h) {
 //            p1++;
-//            add(arr[p1].v, f2[arr[p1].i], g2[arr[p1].i]);
+//            add(arr[p1].v, len2[arr[p1].i], cnt2[arr[p1].i]);
 //        }
 //        query(arr[p2].v);
-//        if (querylen + 1 > f2[arr[p2].i]) {
-//            f2[arr[p2].i] = querylen + 1;
-//            g2[arr[p2].i] = querycnt;
-//        } else if (querylen + 1 == f2[arr[p2].i]) {
-//            g2[arr[p2].i] += querycnt;
+//        if (querylen + 1 > len2[arr[p2].i]) {
+//            len2[arr[p2].i] = querylen + 1;
+//            cnt2[arr[p2].i] = querycnt;
+//        } else if (querylen + 1 == len2[arr[p2].i]) {
+//            cnt2[arr[p2].i] += querycnt;
 //        }
 //    }
 //    for (int i = l; i <= p1; i++) {
@@ -182,8 +182,8 @@
 //        v[i] = lower(v[i]);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        f1[i] = f2[i] = 1;
-//        g1[i] = g2[i] = 1.0;
+//        len1[i] = len2[i] = 1;
+//        cnt1[i] = cnt2[i] = 1.0;
 //    }
 //}
 //
@@ -195,8 +195,8 @@
 //    }
 //    cdq2(1, n);
 //    for (int l = 1, r = n; l < r; l++, r--) {
-//        swap(f2[l], f2[r]);
-//        swap(g2[l], g2[r]);
+//        swap(len2[l], len2[r]);
+//        swap(cnt2[l], cnt2[r]);
 //    }
 //}
 //
@@ -210,19 +210,19 @@
 //    int len = 0;
 //    double cnt = 0.0;
 //    for (int i = 1; i <= n; i++) {
-//        len = max(len, f1[i]);
+//        len = max(len, len1[i]);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        if (f1[i] == len) {
-//            cnt += g1[i];
+//        if (len1[i] == len) {
+//            cnt += cnt1[i];
 //        }
 //    }
 //    printf("%d\n", len);
 //    for (int i = 1; i <= n; i++) {
-//        if (f1[i] + f2[i] - 1 < len) {
+//        if (len1[i] + len2[i] - 1 < len) {
 //            printf("0 ");
 //        } else {
-//            printf("%.5f ", g1[i] * g2[i] / cnt);
+//            printf("%.5f ", cnt1[i] * cnt2[i] / cnt);
 //        }
 //    }
 //    printf("\n");

From 655e60487953d23f990db569b3f5d59b74d869b6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 4 Jun 2025 14:40:49 +0800
Subject: [PATCH 0923/1712] modify code

---
 src/class171/Code03_Sequence1.java | 31 ++++++++++------
 src/class171/Code03_Sequence2.java | 59 ++++++++++++++++--------------
 2 files changed, 52 insertions(+), 38 deletions(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 893eb5b91..2bd55e3bc 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -14,8 +14,11 @@ public class Code03_Sequence1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
+	public static int[] num = new int[MAXN];
+	public static int[] lv = new int[MAXN];
+	public static int[] rv = new int[MAXN];
 
-	// 位置i、数值v、最小值min、最大值max
+	// 位置i、数值num、最小值lv、最大值rv
 	public static int[][] arr = new int[MAXN][4];
 	public static int[] tree = new int[MAXN];
 	public static int[] dp = new int[MAXN];
@@ -48,6 +51,12 @@ public static void clear(int i) {
 	}
 
 	public static void merge(int l, int m, int r) {
+		for (int i = l; i <= r; i++) {
+			arr[i][0] = i;
+			arr[i][1] = num[i];
+			arr[i][2] = lv[i];
+			arr[i][3] = rv[i];
+		}
 		Arrays.sort(arr, l, m + 1, (a, b) -> a[1] - b[1]);
 		Arrays.sort(arr, m + 1, r + 1, (a, b) -> a[2] - b[2]);
 		int p1, p2;
@@ -61,7 +70,6 @@ public static void merge(int l, int m, int r) {
 		for (int i = l; i <= p1; i++) {
 			clear(arr[i][3]);
 		}
-		Arrays.sort(arr, l, r + 1, (a, b) -> a[0] - b[0]);
 	}
 
 	public static void cdq(int l, int r) {
@@ -85,17 +93,18 @@ public static void main(String[] args) throws IOException {
 		n = in.nextInt();
 		m = in.nextInt();
 		for (int i = 1; i <= n; i++) {
-			arr[i][0] = i;
-			arr[i][1] = in.nextInt();
-			arr[i][2] = arr[i][1];
-			arr[i][3] = arr[i][1];
-			dp[i] = 1;
+			num[i] = in.nextInt();
+			lv[i] = num[i];
+			rv[i] = num[i];
 		}
-		for (int i = 1, idx, num; i <= m; i++) {
+		for (int i = 1, idx, val; i <= m; i++) {
 			idx = in.nextInt();
-			num = in.nextInt();
-			arr[idx][2] = Math.min(arr[idx][2], num);
-			arr[idx][3] = Math.max(arr[idx][3], num);
+			val = in.nextInt();
+			lv[idx] = Math.min(lv[idx], val);
+			rv[idx] = Math.max(rv[idx], val);
+		}
+		for (int i = 1; i <= n; i++) {
+			dp[i] = 1;
 		}
 		cdq(1, n);
 		int ans = 0;
diff --git a/src/class171/Code03_Sequence2.java b/src/class171/Code03_Sequence2.java
index 16c3669ad..e8f9472b4 100644
--- a/src/class171/Code03_Sequence2.java
+++ b/src/class171/Code03_Sequence2.java
@@ -10,23 +10,22 @@
 //using namespace std;
 //
 //struct Node {
-//    int i, v, min, max;
+//    int i, num, lv, rv;
 //};
 //
-//bool CmpI(Node a, Node b) {
-//    return a.i < b.i;
+//bool CmpNum(Node a, Node b) {
+//    return a.num < b.num;
 //}
 //
-//bool CmpV(Node a, Node b) {
-//    return a.v < b.v;
-//}
-//
-//bool CmpMin(Node a, Node b) {
-//    return a.min < b.min;
+//bool CmpLv(Node a, Node b) {
+//    return a.lv < b.lv;
 //}
 //
 //const int MAXN = 100001;
 //int n, m;
+//int num[MAXN];
+//int lv[MAXN];
+//int rv[MAXN];
 //
 //Node arr[MAXN];
 //int tree[MAXN];
@@ -60,20 +59,25 @@
 //}
 //
 //void merge(int l, int m, int r) {
-//    sort(arr + l, arr + m + 1, CmpV);
-//    sort(arr + m + 1, arr + r + 1, CmpMin);
-//    int p1 = l - 1, p2 = m + 1;
-//    for (; p2 <= r; p2++) {
-//        while (p1 + 1 <= m && arr[p1 + 1].v <= arr[p2].min) {
+//    for (int i = l; i <= r; i++) {
+//        arr[i].i = i;
+//        arr[i].num = num[i];
+//        arr[i].lv = lv[i];
+//        arr[i].rv = rv[i];
+//    }
+//    sort(arr + l, arr + m + 1, CmpNum);
+//    sort(arr + m + 1, arr + r + 1, CmpLv);
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && arr[p1 + 1].num <= arr[p2].lv) {
 //            p1++;
-//            more(arr[p1].max, dp[arr[p1].i]);
+//            more(arr[p1].rv, dp[arr[p1].i]);
 //        }
-//        dp[arr[p2].i] = max(dp[arr[p2].i], query(arr[p2].v) + 1);
+//        dp[arr[p2].i] = max(dp[arr[p2].i], query(arr[p2].num) + 1);
 //    }
 //    for (int i = l; i <= p1; i++) {
-//        clear(arr[i].max);
+//        clear(arr[i].rv);
 //    }
-//    sort(arr + l, arr + r + 1, CmpI);
 //}
 //
 //void cdq(int l, int r) {
@@ -91,16 +95,17 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
-//        arr[i].i = i;
-//        cin >> arr[i].v;
-//        arr[i].min = arr[i].v;
-//        arr[i].max = arr[i].v;
-//        dp[i] = 1;
+//        cin >> num[i];
+//        lv[i] = num[i];
+//        rv[i] = num[i];
+//    }
+//    for (int i = 1, idx, val; i <= m; i++) {
+//        cin >> idx >> val;
+//        lv[idx] = min(lv[idx], val);
+//        rv[idx] = max(rv[idx], val);
 //    }
-//    for (int i = 1, idx, num; i <= m; i++) {
-//        cin >> idx >> num;
-//        arr[idx].min = min(arr[idx].min, num);
-//        arr[idx].max = max(arr[idx].max, num);
+//    for (int i = 1; i <= n; i++) {
+//        dp[i] = 1;
 //    }
 //    cdq(1, n);
 //    int ans = 0;

From 5ffe74a1e8fdaedd8be0ec406590a209f4c2e5c5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 4 Jun 2025 14:47:01 +0800
Subject: [PATCH 0924/1712] modify code

---
 src/class171/Code03_Sequence1.java | 12 ++++++------
 src/class171/Code03_Sequence2.java | 22 +++++++++++-----------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 2bd55e3bc..3339e48f4 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -14,11 +14,11 @@ public class Code03_Sequence1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
-	public static int[] num = new int[MAXN];
+	public static int[] v = new int[MAXN];
 	public static int[] lv = new int[MAXN];
 	public static int[] rv = new int[MAXN];
 
-	// 位置i、数值num、最小值lv、最大值rv
+	// 位置i、数值v、最小值lv、最大值rv
 	public static int[][] arr = new int[MAXN][4];
 	public static int[] tree = new int[MAXN];
 	public static int[] dp = new int[MAXN];
@@ -53,7 +53,7 @@ public static void clear(int i) {
 	public static void merge(int l, int m, int r) {
 		for (int i = l; i <= r; i++) {
 			arr[i][0] = i;
-			arr[i][1] = num[i];
+			arr[i][1] = v[i];
 			arr[i][2] = lv[i];
 			arr[i][3] = rv[i];
 		}
@@ -93,9 +93,9 @@ public static void main(String[] args) throws IOException {
 		n = in.nextInt();
 		m = in.nextInt();
 		for (int i = 1; i <= n; i++) {
-			num[i] = in.nextInt();
-			lv[i] = num[i];
-			rv[i] = num[i];
+			v[i] = in.nextInt();
+			lv[i] = v[i];
+			rv[i] = v[i];
 		}
 		for (int i = 1, idx, val; i <= m; i++) {
 			idx = in.nextInt();
diff --git a/src/class171/Code03_Sequence2.java b/src/class171/Code03_Sequence2.java
index e8f9472b4..a830ec707 100644
--- a/src/class171/Code03_Sequence2.java
+++ b/src/class171/Code03_Sequence2.java
@@ -10,11 +10,11 @@
 //using namespace std;
 //
 //struct Node {
-//    int i, num, lv, rv;
+//    int i, v, lv, rv;
 //};
 //
-//bool CmpNum(Node a, Node b) {
-//    return a.num < b.num;
+//bool CmpV(Node a, Node b) {
+//    return a.v < b.v;
 //}
 //
 //bool CmpLv(Node a, Node b) {
@@ -23,7 +23,7 @@
 //
 //const int MAXN = 100001;
 //int n, m;
-//int num[MAXN];
+//int v[MAXN];
 //int lv[MAXN];
 //int rv[MAXN];
 //
@@ -61,19 +61,19 @@
 //void merge(int l, int m, int r) {
 //    for (int i = l; i <= r; i++) {
 //        arr[i].i = i;
-//        arr[i].num = num[i];
+//        arr[i].v = v[i];
 //        arr[i].lv = lv[i];
 //        arr[i].rv = rv[i];
 //    }
-//    sort(arr + l, arr + m + 1, CmpNum);
+//    sort(arr + l, arr + m + 1, CmpV);
 //    sort(arr + m + 1, arr + r + 1, CmpLv);
 //    int p1, p2;
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
-//        while (p1 + 1 <= m && arr[p1 + 1].num <= arr[p2].lv) {
+//        while (p1 + 1 <= m && arr[p1 + 1].v <= arr[p2].lv) {
 //            p1++;
 //            more(arr[p1].rv, dp[arr[p1].i]);
 //        }
-//        dp[arr[p2].i] = max(dp[arr[p2].i], query(arr[p2].num) + 1);
+//        dp[arr[p2].i] = max(dp[arr[p2].i], query(arr[p2].v) + 1);
 //    }
 //    for (int i = l; i <= p1; i++) {
 //        clear(arr[i].rv);
@@ -95,9 +95,9 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
-//        cin >> num[i];
-//        lv[i] = num[i];
-//        rv[i] = num[i];
+//        cin >> v[i];
+//        lv[i] = v[i];
+//        rv[i] = v[i];
 //    }
 //    for (int i = 1, idx, val; i <= m; i++) {
 //        cin >> idx >> val;

From 0946188fcc9cd28d06222efcac2ec7aa9ada372b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Jun 2025 17:58:45 +0800
Subject: [PATCH 0925/1712] modify code

---
 src/class171/Code05_Theresa1.java | 284 ++++++++++++++++++++++++++++++
 src/class171/Code05_Theresa2.java | 192 ++++++++++++++++++++
 2 files changed, 476 insertions(+)
 create mode 100644 src/class171/Code05_Theresa1.java
 create mode 100644 src/class171/Code05_Theresa2.java

diff --git a/src/class171/Code05_Theresa1.java b/src/class171/Code05_Theresa1.java
new file mode 100644
index 000000000..d79d3e178
--- /dev/null
+++ b/src/class171/Code05_Theresa1.java
@@ -0,0 +1,284 @@
+package class171;
+
+// 德丽莎世界第一可爱，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5621
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是有两个测试用例超时
+// 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code05_Theresa2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code05_Theresa1 {
+
+	public static class Node {
+		int a, b, c, d;
+		int i;
+		long v;
+		boolean left;
+
+		public Node(int a_, int b_, int c_, int d_, long v_) {
+			a = a_;
+			b = b_;
+			c = c_;
+			d = d_;
+			v = v_;
+		}
+	}
+
+	public static class CmpAbcdv implements Comparator<Node> {
+		@Override
+		public int compare(Node x, Node y) {
+			if (x.a != y.a) {
+				return x.a - y.a;
+			}
+			if (x.b != y.b) {
+				return x.b - y.b;
+			}
+			if (x.c != y.c) {
+				return x.c - y.c;
+			}
+			if (x.d != y.d) {
+				return x.d - y.d;
+			}
+			return Long.compare(y.v, x.v);
+		}
+	}
+
+	public static class CmpB implements Comparator<Node> {
+		@Override
+		public int compare(Node x, Node y) {
+			return x.b - y.b;
+		}
+	}
+
+	public static class CmpC implements Comparator<Node> {
+		@Override
+		public int compare(Node x, Node y) {
+			return x.c - y.c;
+		}
+	}
+
+	public static CmpAbcdv cmpAbcdv = new CmpAbcdv();
+	public static CmpB cmpB = new CmpB();
+	public static CmpC cmpC = new CmpC();
+
+	public static int MAXN = 100001;
+	public static int n, s;
+	public static long INF = 1000000000000000001L;
+
+	public static Node[] arr = new Node[MAXN];
+	public static int[] abcd = new int[MAXN << 2];
+
+	public static Node[] tmp1 = new Node[MAXN];
+	public static Node[] tmp2 = new Node[MAXN];
+
+	public static long[] tree = new long[MAXN << 2];
+	public static long[] dp = new long[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void more(int i, long num) {
+		while (i <= s) {
+			tree[i] = Math.max(tree[i], num);
+			i += lowbit(i);
+		}
+	}
+
+	public static long query(int i) {
+		long ret = -INF;
+		while (i > 0) {
+			ret = Math.max(ret, tree[i]);
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void clear(int i) {
+		while (i <= s) {
+			tree[i] = -INF;
+			i += lowbit(i);
+		}
+	}
+
+	public static void merge(int l, int m, int r) {
+		for (int i = l; i <= r; i++) {
+			tmp2[i] = tmp1[i];
+		}
+		Arrays.sort(tmp2, l, m + 1, cmpC);
+		Arrays.sort(tmp2, m + 1, r + 1, cmpC);
+		int p1, p2;
+		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= m && tmp2[p1 + 1].c <= tmp2[p2].c) {
+				p1++;
+				if (tmp2[p1].left) {
+					more(tmp2[p1].d, dp[tmp2[p1].i]);
+				}
+			}
+			if (!tmp2[p2].left) {
+				dp[tmp2[p2].i] = Math.max(dp[tmp2[p2].i], query(tmp2[p2].d) + tmp2[p2].v);
+			}
+		}
+		for (int i = l; i <= p1; i++) {
+			if (tmp2[i].left) {
+				clear(tmp2[i].d);
+			}
+		}
+	}
+
+	public static void cdq2(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq2(l, mid);
+		merge(l, mid, r);
+		cdq2(mid + 1, r);
+	}
+
+	public static void cdq1(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq1(l, mid);
+		for (int i = l; i <= r; i++) {
+			tmp1[i] = arr[i];
+			tmp1[i].left = i <= mid;
+		}
+		Arrays.sort(tmp1, l, r + 1, cmpB);
+		cdq2(l, r);
+		cdq1(mid + 1, r);
+	}
+
+	public static int lower(long num) {
+		int l = 1, r = s, m, ans = 1;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (abcd[m] >= num) {
+				ans = m;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		// a、b、c、d离散化
+		for (int i = 1; i <= n; i++) {
+			abcd[++s] = arr[i].a;
+			abcd[++s] = arr[i].b;
+			abcd[++s] = arr[i].c;
+			abcd[++s] = arr[i].d;
+		}
+		Arrays.sort(abcd, 1, s + 1);
+		int m = 1;
+		for (int i = 2; i <= s; i++) {
+			if (abcd[m] != abcd[i]) {
+				abcd[++m] = abcd[i];
+			}
+		}
+		s = m;
+		for (int i = 1; i <= n; i++) {
+			arr[i].a = lower(arr[i].a);
+			arr[i].b = lower(arr[i].b);
+			arr[i].c = lower(arr[i].c);
+			arr[i].d = lower(arr[i].d);
+		}
+		// 合并a、b、c、d都相等的对象成为一组对象
+		Arrays.sort(arr, 1, n + 1, cmpAbcdv);
+		m = 1;
+		for (int i = 2; i <= n; i++) {
+			if (arr[m].a == arr[i].a && arr[m].b == arr[i].b && arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
+				if (arr[i].v > 0) {
+					arr[m].v += arr[i].v;
+				}
+			} else {
+				arr[++m] = arr[i];
+			}
+		}
+		n = m;
+		// 设置组号i、dp初始值
+		for (int i = 1; i <= n; i++) {
+			arr[i].i = i;
+			dp[i] = arr[i].v;
+		}
+		// 初始化树状数组
+		for (int i = 1; i <= s; i++) {
+			tree[i] = -INF;
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1, a, b, c, d, v; i <= n; i++) {
+			a = in.nextInt();
+			b = in.nextInt();
+			c = in.nextInt();
+			d = in.nextInt();
+			v = in.nextInt();
+			arr[i] = new Node(a, b, c, d, v);
+		}
+		prepare();
+		cdq1(1, n);
+		long ans = -INF;
+		for (int i = 1; i <= n; i++) {
+			ans = Math.max(ans, dp[i]);
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class171/Code05_Theresa2.java b/src/class171/Code05_Theresa2.java
new file mode 100644
index 000000000..66fb8954c
--- /dev/null
+++ b/src/class171/Code05_Theresa2.java
@@ -0,0 +1,192 @@
+package class171;
+
+// 德丽莎世界第一可爱，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5621
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int a, b, c, d;
+//    long long v;
+//    int i;
+//    bool left;
+//};
+//
+//bool CmpAbcdv(Node x, Node y) {
+//    if (x.a != y.a) return x.a < y.a;
+//    if (x.b != y.b) return x.b < y.b;
+//    if (x.c != y.c) return x.c < y.c;
+//    if (x.d != y.d) return x.d < y.d;
+//    return x.v > y.v;
+//}
+//
+//bool CmpB(Node x, Node y) {
+//    return x.b < y.b;
+//}
+//
+//bool CmpC(Node x, Node y) {
+//    return x.c < y.c;
+//}
+//
+//const int MAXN = 100001;
+//const long long INF = 1e18 + 1;
+//int n, s;
+//
+//Node arr[MAXN];
+//int abcd[MAXN << 2];
+//
+//Node tmp1[MAXN];
+//Node tmp2[MAXN];
+//long long tree[MAXN << 2];
+//long long dp[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void more(int i, long long num) {
+//    while (i <= s) {
+//        tree[i] = max(tree[i], num);
+//        i += lowbit(i);
+//    }
+//}
+//
+//long long query(int i) {
+//    long long ret = -INF;
+//    while (i > 0) {
+//        ret = max(ret, tree[i]);
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void clear(int i) {
+//    while (i <= s) {
+//        tree[i] = -INF;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void merge(int l, int m, int r) {
+//    for (int i = l; i <= r; i++) {
+//        tmp2[i] = tmp1[i];
+//    }
+//    sort(tmp2 + l, tmp2 + m + 1, CmpC);
+//    sort(tmp2 + m + 1, tmp2 + r + 1, CmpC);
+//    int p1, p2;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && tmp2[p1 + 1].c <= tmp2[p2].c) {
+//            p1++;
+//            if (tmp2[p1].left) {
+//                more(tmp2[p1].d, dp[tmp2[p1].i]);
+//            }
+//        }
+//        if (!tmp2[p2].left) {
+//            dp[tmp2[p2].i] = max(dp[tmp2[p2].i], query(tmp2[p2].d) + tmp2[p2].v);
+//        }
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        if (tmp2[i].left) {
+//            clear(tmp2[i].d);
+//        }
+//    }
+//}
+//
+//void cdq2(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq2(l, mid);
+//    merge(l, mid, r);
+//    cdq2(mid + 1, r);
+//}
+//
+//void cdq1(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq1(l, mid);
+//    for (int i = l; i <= r; i++) {
+//        tmp1[i] = arr[i];
+//        tmp1[i].left = i <= mid;
+//    }
+//    sort(tmp1 + l, tmp1 + r + 1, CmpB);
+//    cdq2(l, r);
+//    cdq1(mid + 1, r);
+//}
+//
+//int lower(long long num) {
+//    int l = 1, r = s, ans = 1;
+//    while (l <= r) {
+//        int m = (l + r) / 2;
+//        if (abcd[m] >= num) {
+//            ans = m;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        abcd[++s] = arr[i].a;
+//        abcd[++s] = arr[i].b;
+//        abcd[++s] = arr[i].c;
+//        abcd[++s] = arr[i].d;
+//    }
+//    sort(abcd + 1, abcd + s + 1);
+//    int m = 1;
+//    for (int i = 2; i <= s; i++) {
+//        if (abcd[m] != abcd[i]) {
+//            abcd[++m] = abcd[i];
+//        }
+//    }
+//    s = m;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].a = lower(arr[i].a);
+//        arr[i].b = lower(arr[i].b);
+//        arr[i].c = lower(arr[i].c);
+//        arr[i].d = lower(arr[i].d);
+//    }
+//    sort(arr + 1, arr + n + 1, CmpAbcdv);
+//    m = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (arr[m].a == arr[i].a && arr[m].b == arr[i].b &&
+//            arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
+//            if (arr[i].v > 0) {
+//                arr[m].v += arr[i].v;
+//            }
+//        } else {
+//            arr[++m] = arr[i];
+//        }
+//    }
+//    n = m;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].i = i;
+//        dp[i] = arr[i].v;
+//    }
+//    for (int i = 1; i <= s; i++) {
+//        tree[i] = -INF;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i].a >> arr[i].b >> arr[i].c >> arr[i].d >> arr[i].v;
+//    }
+//    prepare();
+//    cdq1(1, n);
+//    long long ans = -INF;
+//    for (int i = 1; i <= n; i++) {
+//        ans = max(ans, dp[i]);
+//    }
+//    cout << ans << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 17cad14a06d69c4f8faa28fd0139bfa439dac39a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Jun 2025 18:13:18 +0800
Subject: [PATCH 0926/1712] modify code

---
 src/class171/{Code05_Theresa1.java => Code05_Cute1.java} | 4 ++--
 src/class171/{Code05_Theresa2.java => Code05_Cute2.java} | 0
 src/class171/Code06_Treasure1.java                       | 9 +++++++++
 3 files changed, 11 insertions(+), 2 deletions(-)
 rename src/class171/{Code05_Theresa1.java => Code05_Cute1.java} (98%)
 rename src/class171/{Code05_Theresa2.java => Code05_Cute2.java} (100%)
 create mode 100644 src/class171/Code06_Treasure1.java

diff --git a/src/class171/Code05_Theresa1.java b/src/class171/Code05_Cute1.java
similarity index 98%
rename from src/class171/Code05_Theresa1.java
rename to src/class171/Code05_Cute1.java
index d79d3e178..678bb4a54 100644
--- a/src/class171/Code05_Theresa1.java
+++ b/src/class171/Code05_Cute1.java
@@ -5,7 +5,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是有两个测试用例超时
 // 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code05_Theresa2文件就是C++的实现
+// 想通过用C++实现，本节课Code05_Cute2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -15,7 +15,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code05_Theresa1 {
+public class Code05_Cute1 {
 
 	public static class Node {
 		int a, b, c, d;
diff --git a/src/class171/Code05_Theresa2.java b/src/class171/Code05_Cute2.java
similarity index 100%
rename from src/class171/Code05_Theresa2.java
rename to src/class171/Code05_Cute2.java
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
new file mode 100644
index 000000000..f75412060
--- /dev/null
+++ b/src/class171/Code06_Treasure1.java
@@ -0,0 +1,9 @@
+package class171;
+
+// 寻找宝藏，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4849
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code06_Treasure1 {
+
+}

From b52dacf9fb0a8cfbe71f1a5e73d9e0325af0705b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 5 Jun 2025 21:31:34 +0800
Subject: [PATCH 0927/1712] modify code

---
 src/class171/Code05_Cute1.java     |  55 ++---
 src/class171/Code05_Cute2.java     |  37 ++--
 src/class171/Code06_Treasure1.java | 310 +++++++++++++++++++++++++++++
 src/class171/Code06_Treasure2.java | 223 +++++++++++++++++++++
 4 files changed, 582 insertions(+), 43 deletions(-)
 create mode 100644 src/class171/Code06_Treasure2.java

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index 678bb4a54..0f8cfaef9 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -54,14 +54,32 @@ public int compare(Node x, Node y) {
 	public static class CmpB implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
-			return x.b - y.b;
+			if (x.b != y.b) {
+				return x.b - y.b;
+			}
+			if (x.c != y.c) {
+				return x.c - y.c;
+			}
+			if (x.d != y.d) {
+				return x.d - y.d;
+			}
+			return x.a - y.a;
 		}
 	}
 
 	public static class CmpC implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
-			return x.c - y.c;
+			if (x.c != y.c) {
+				return x.c - y.c;
+			}
+			if (x.d != y.d) {
+				return x.d - y.d;
+			}
+			if (x.a != y.a) {
+				return x.a - y.a;
+			}
+			return x.b - y.b;
 		}
 	}
 
@@ -70,16 +88,16 @@ public int compare(Node x, Node y) {
 	public static CmpC cmpC = new CmpC();
 
 	public static int MAXN = 100001;
+	public static long INF = (long) (1e18 + 1);
 	public static int n, s;
-	public static long INF = 1000000000000000001L;
 
 	public static Node[] arr = new Node[MAXN];
-	public static int[] abcd = new int[MAXN << 2];
+	public static int[] sortd = new int[MAXN];
 
 	public static Node[] tmp1 = new Node[MAXN];
 	public static Node[] tmp2 = new Node[MAXN];
 
-	public static long[] tree = new long[MAXN << 2];
+	public static long[] tree = new long[MAXN];
 	public static long[] dp = new long[MAXN];
 
 	public static int lowbit(int i) {
@@ -163,7 +181,7 @@ public static int lower(long num) {
 		int l = 1, r = s, m, ans = 1;
 		while (l <= r) {
 			m = (l + r) / 2;
-			if (abcd[m] >= num) {
+			if (sortd[m] >= num) {
 				ans = m;
 				r = m - 1;
 			} else {
@@ -174,30 +192,21 @@ public static int lower(long num) {
 	}
 
 	public static void prepare() {
-		// a、b、c、d离散化
 		for (int i = 1; i <= n; i++) {
-			abcd[++s] = arr[i].a;
-			abcd[++s] = arr[i].b;
-			abcd[++s] = arr[i].c;
-			abcd[++s] = arr[i].d;
+			sortd[i] = arr[i].d;
 		}
-		Arrays.sort(abcd, 1, s + 1);
-		int m = 1;
-		for (int i = 2; i <= s; i++) {
-			if (abcd[m] != abcd[i]) {
-				abcd[++m] = abcd[i];
+		Arrays.sort(sortd, 1, n + 1);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sortd[s] != sortd[i]) {
+				sortd[++s] = sortd[i];
 			}
 		}
-		s = m;
 		for (int i = 1; i <= n; i++) {
-			arr[i].a = lower(arr[i].a);
-			arr[i].b = lower(arr[i].b);
-			arr[i].c = lower(arr[i].c);
 			arr[i].d = lower(arr[i].d);
 		}
-		// 合并a、b、c、d都相等的对象成为一组对象
 		Arrays.sort(arr, 1, n + 1, cmpAbcdv);
-		m = 1;
+		int m = 1;
 		for (int i = 2; i <= n; i++) {
 			if (arr[m].a == arr[i].a && arr[m].b == arr[i].b && arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
 				if (arr[i].v > 0) {
@@ -208,12 +217,10 @@ public static void prepare() {
 			}
 		}
 		n = m;
-		// 设置组号i、dp初始值
 		for (int i = 1; i <= n; i++) {
 			arr[i].i = i;
 			dp[i] = arr[i].v;
 		}
-		// 初始化树状数组
 		for (int i = 1; i <= s; i++) {
 			tree[i] = -INF;
 		}
diff --git a/src/class171/Code05_Cute2.java b/src/class171/Code05_Cute2.java
index 66fb8954c..40f1054ab 100644
--- a/src/class171/Code05_Cute2.java
+++ b/src/class171/Code05_Cute2.java
@@ -25,11 +25,17 @@
 //}
 //
 //bool CmpB(Node x, Node y) {
-//    return x.b < y.b;
+//    if (x.b != y.b) return x.b < y.b;
+//    if (x.c != y.c) return x.c < y.c;
+//    if (x.d != y.d) return x.d < y.d;
+//    return x.a < y.a;
 //}
 //
 //bool CmpC(Node x, Node y) {
-//    return x.c < y.c;
+//    if (x.c != y.c) return x.c < y.c;
+//    if (x.d != y.d) return x.d < y.d;
+//    if (x.a != y.a) return x.a < y.a;
+//    return x.b < y.b;
 //}
 //
 //const int MAXN = 100001;
@@ -37,11 +43,11 @@
 //int n, s;
 //
 //Node arr[MAXN];
-//int abcd[MAXN << 2];
+//int sortd[MAXN];
 //
 //Node tmp1[MAXN];
 //Node tmp2[MAXN];
-//long long tree[MAXN << 2];
+//long long tree[MAXN];
 //long long dp[MAXN];
 //
 //int lowbit(int i) {
@@ -121,7 +127,7 @@
 //    int l = 1, r = s, ans = 1;
 //    while (l <= r) {
 //        int m = (l + r) / 2;
-//        if (abcd[m] >= num) {
+//        if (sortd[m] >= num) {
 //            ans = m;
 //            r = m - 1;
 //        } else {
@@ -133,27 +139,20 @@
 //
 //void prepare() {
 //    for (int i = 1; i <= n; i++) {
-//        abcd[++s] = arr[i].a;
-//        abcd[++s] = arr[i].b;
-//        abcd[++s] = arr[i].c;
-//        abcd[++s] = arr[i].d;
+//        sortd[i] = arr[i].d;
 //    }
-//    sort(abcd + 1, abcd + s + 1);
-//    int m = 1;
-//    for (int i = 2; i <= s; i++) {
-//        if (abcd[m] != abcd[i]) {
-//            abcd[++m] = abcd[i];
+//    sort(sortd + 1, sortd + n + 1);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sortd[s] != sortd[i]) {
+//            sortd[++s] = sortd[i];
 //        }
 //    }
-//    s = m;
 //    for (int i = 1; i <= n; i++) {
-//        arr[i].a = lower(arr[i].a);
-//        arr[i].b = lower(arr[i].b);
-//        arr[i].c = lower(arr[i].c);
 //        arr[i].d = lower(arr[i].d);
 //    }
 //    sort(arr + 1, arr + n + 1, CmpAbcdv);
-//    m = 1;
+//    int m = 1;
 //    for (int i = 2; i <= n; i++) {
 //        if (arr[m].a == arr[i].a && arr[m].b == arr[i].b &&
 //            arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index f75412060..25808b928 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -4,6 +4,316 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
 public class Code06_Treasure1 {
 
+	public static int MAXN = 80001;
+	public static long INF = (long) (1e18 + 1);
+	public static int MOD = 998244353;
+
+	public static class Node {
+		int a, b, c, d;
+		int i;
+		long v;
+		boolean left;
+
+		public Node(int a_, int b_, int c_, int d_, long v_) {
+			a = a_;
+			b = b_;
+			c = c_;
+			d = d_;
+			v = v_;
+		}
+	}
+
+	public static class CmpAbcdv implements Comparator<Node> {
+		@Override
+		public int compare(Node x, Node y) {
+			if (x.a != y.a) {
+				return x.a - y.a;
+			}
+			if (x.b != y.b) {
+				return x.b - y.b;
+			}
+			if (x.c != y.c) {
+				return x.c - y.c;
+			}
+			if (x.d != y.d) {
+				return x.d - y.d;
+			}
+			return Long.compare(y.v, x.v);
+		}
+	}
+
+	public static class CmpB implements Comparator<Node> {
+		@Override
+		public int compare(Node x, Node y) {
+			if (x.b != y.b) {
+				return x.b - y.b;
+			}
+			if (x.c != y.c) {
+				return x.c - y.c;
+			}
+			if (x.d != y.d) {
+				return x.d - y.d;
+			}
+			return x.a - y.a;
+		}
+	}
+
+	public static class CmpC implements Comparator<Node> {
+		@Override
+		public int compare(Node x, Node y) {
+			if (x.c != y.c) {
+				return x.c - y.c;
+			}
+			if (x.d != y.d) {
+				return x.d - y.d;
+			}
+			if (x.a != y.a) {
+				return x.a - y.a;
+			}
+			return x.b - y.b;
+		}
+	}
+
+	public static CmpAbcdv cmpAbcdv = new CmpAbcdv();
+	public static CmpB cmpB = new CmpB();
+	public static CmpC cmpC = new CmpC();
+
+	public static int n, s;
+	public static Node[] arr = new Node[MAXN];
+	public static Node[] tmp1 = new Node[MAXN];
+	public static Node[] tmp2 = new Node[MAXN];
+	public static int[] sortd = new int[MAXN];
+
+	public static long[] treeVal = new long[MAXN];
+	public static int[] treeCnt = new int[MAXN];
+
+	public static long[] dp = new long[MAXN];
+	public static int[] cnt = new int[MAXN];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, long v, int c) {
+		while (i <= s) {
+			if (v > treeVal[i]) {
+				treeVal[i] = v;
+				treeCnt[i] = c % MOD;
+			} else if (v == treeVal[i]) {
+				treeCnt[i] = (treeCnt[i] + c) % MOD;
+			}
+			i += lowbit(i);
+		}
+	}
+
+	public static long queryVal;
+	public static int queryCnt;
+
+	public static void query(int i) {
+		queryVal = -INF;
+		queryCnt = 0;
+		while (i > 0) {
+			if (treeVal[i] > queryVal) {
+				queryVal = treeVal[i];
+				queryCnt = treeCnt[i];
+			} else if (treeVal[i] == queryVal) {
+				queryCnt = (queryCnt + treeCnt[i]) % MOD;
+			}
+			i -= lowbit(i);
+		}
+	}
+
+	public static void clear(int i) {
+		while (i <= s) {
+			treeVal[i] = -INF;
+			treeCnt[i] = 0;
+			i += lowbit(i);
+		}
+	}
+
+	public static void merge(int l, int mid, int r) {
+		for (int i = l; i <= r; i++) {
+			tmp2[i] = tmp1[i];
+		}
+		Arrays.sort(tmp2, l, mid + 1, cmpC);
+		Arrays.sort(tmp2, mid + 1, r + 1, cmpC);
+		int p1, p2, id;
+		for (p1 = l - 1, p2 = mid + 1; p2 <= r; p2++) {
+			while (p1 + 1 <= mid && tmp2[p1 + 1].c <= tmp2[p2].c) {
+				p1++;
+				if (tmp2[p1].left) {
+					add(tmp2[p1].d, dp[tmp2[p1].i], cnt[tmp2[p1].i]);
+				}
+			}
+			if (!tmp2[p2].left) {
+				query(tmp2[p2].d);
+				id = tmp2[p2].i;
+				if (queryVal + tmp2[p2].v > dp[id]) {
+					dp[id] = queryVal + tmp2[p2].v;
+					cnt[id] = queryCnt;
+				} else if (queryVal + tmp2[p2].v == dp[id]) {
+					cnt[id] = (cnt[id] + queryCnt) % MOD;
+				}
+			}
+		}
+		for (int i = l; i <= p1; i++) {
+			if (tmp2[i].left) {
+				clear(tmp2[i].d);
+			}
+		}
+	}
+
+	public static void cdq2(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq2(l, mid);
+		merge(l, mid, r);
+		cdq2(mid + 1, r);
+	}
+
+	public static void cdq1(int l, int r) {
+		if (l == r) {
+			return;
+		}
+		int mid = (l + r) / 2;
+		cdq1(l, mid);
+		for (int i = l; i <= r; i++) {
+			tmp1[i] = arr[i];
+			tmp1[i].left = (i <= mid);
+		}
+		Arrays.sort(tmp1, l, r + 1, cmpB);
+		cdq2(l, r);
+		cdq1(mid + 1, r);
+	}
+
+	public static int lower(int x) {
+		int l = 1, r = s, ans = 1;
+		while (l <= r) {
+			int mid = (l + r) / 2;
+			if (sortd[mid] >= x) {
+				ans = mid;
+				r = mid - 1;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sortd[i] = arr[i].d;
+		}
+		Arrays.sort(sortd, 1, n + 1);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sortd[s] != sortd[i]) {
+				sortd[++s] = sortd[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i].d = lower(arr[i].d);
+		}
+		Arrays.sort(arr, 1, n + 1, cmpAbcdv);
+		int m = 1;
+		for (int i = 2; i <= n; i++) {
+			if (arr[m].a == arr[i].a && arr[m].b == arr[i].b && arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
+				arr[m].v += arr[i].v;
+			} else {
+				arr[++m] = arr[i];
+			}
+		}
+		n = m;
+		for (int i = 1; i <= n; i++) {
+			arr[i].i = i;
+			dp[i] = arr[i].v;
+			cnt[i] = 1;
+		}
+		for (int i = 1; i <= s; i++) {
+			treeVal[i] = -INF;
+			treeCnt[i] = 0;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		in.nextInt();
+		for (int i = 1, a, b, c, d, v; i <= n; i++) {
+			a = in.nextInt();
+			b = in.nextInt();
+			c = in.nextInt();
+			d = in.nextInt();
+			v = in.nextInt();
+			arr[i] = new Node(a, b, c, d, v);
+		}
+		prepare();
+		cdq1(1, n);
+		long best = 0;
+		int ways = 0;
+		for (int i = 1; i <= n; i++) {
+			best = Math.max(best, dp[i]);
+		}
+		for (int i = 1; i <= n; i++) {
+			if (dp[i] == best) {
+				ways = (ways + cnt[i]) % MOD;
+			}
+		}
+		out.println(best);
+		out.println(ways % MOD);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 12];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
new file mode 100644
index 000000000..e78c4f559
--- /dev/null
+++ b/src/class171/Code06_Treasure2.java
@@ -0,0 +1,223 @@
+package class171;
+
+// 寻找宝藏，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4849
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int a, b, c, d;
+//    long long v;
+//    int i;
+//    bool left;
+//};
+//
+//bool CmpAbcdv(Node x, Node y) {
+//    if (x.a != y.a) return x.a < y.a;
+//    if (x.b != y.b) return x.b < y.b;
+//    if (x.c != y.c) return x.c < y.c;
+//    if (x.d != y.d) return x.d < y.d;
+//    return x.v > y.v;
+//}
+//
+//bool CmpB(Node x, Node y) {
+//    if (x.b != y.b) return x.b < y.b;
+//    if (x.c != y.c) return x.c < y.c;
+//    if (x.d != y.d) return x.d < y.d;
+//    return x.a < y.a;
+//}
+//
+//bool CmpC(Node x, Node y) {
+//    if (x.c != y.c) return x.c < y.c;
+//    if (x.d != y.d) return x.d < y.d;
+//    if (x.a != y.a) return x.a < y.a;
+//    return x.b < y.b;
+//}
+//
+//const int MAXN = 80001;
+//const long long INF = 1e18 + 1;
+//const int MOD = 998244353;
+//int n, s;
+//
+//Node arr[MAXN];
+//Node tmp1[MAXN];
+//Node tmp2[MAXN];
+//int sortd[MAXN];
+//
+//long long treeVal[MAXN];
+//int treeCnt[MAXN];
+//
+//long long dp[MAXN];
+//int cnt[MAXN];
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, long long v, int c) {
+//    while (i <= s) {
+//        if (v > treeVal[i]) {
+//            treeVal[i] = v;
+//            treeCnt[i] = c % MOD;
+//        } else if (v == treeVal[i]) {
+//            treeCnt[i] = (treeCnt[i] + c) % MOD;
+//        }
+//        i += lowbit(i);
+//    }
+//}
+//
+//long long queryVal;
+//int queryCnt;
+//
+//void query(int i) {
+//    queryVal = -INF;
+//    queryCnt = 0;
+//    while (i > 0) {
+//        if (treeVal[i] > queryVal) {
+//            queryVal = treeVal[i];
+//            queryCnt = treeCnt[i];
+//        } else if (treeVal[i] == queryVal) {
+//            queryCnt = (queryCnt + treeCnt[i]) % MOD;
+//        }
+//        i -= lowbit(i);
+//    }
+//}
+//
+//void clear(int i) {
+//    while (i <= s) {
+//        treeVal[i] = -INF;
+//        treeCnt[i] = 0;
+//        i += lowbit(i);
+//    }
+//}
+//
+//void merge(int l, int m, int r) {
+//    for (int i = l; i <= r; i++) {
+//        tmp2[i] = tmp1[i];
+//    }
+//    sort(tmp2 + l, tmp2 + m + 1, CmpC);
+//    sort(tmp2 + m + 1, tmp2 + r + 1, CmpC);
+//    int p1, p2, id;
+//    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+//        while (p1 + 1 <= m && tmp2[p1 + 1].c <= tmp2[p2].c) {
+//            p1++;
+//            if (tmp2[p1].left) {
+//                add(tmp2[p1].d, dp[tmp2[p1].i], cnt[tmp2[p1].i]);
+//            }
+//        }
+//        if (!tmp2[p2].left) {
+//            query(tmp2[p2].d);
+//            id = tmp2[p2].i;
+//            if (queryVal + tmp2[p2].v > dp[id]) {
+//                dp[id] = queryVal + tmp2[p2].v;
+//                cnt[id] = queryCnt;
+//            } else if (queryVal + tmp2[p2].v == dp[id]) {
+//                cnt[id] = (cnt[id] + queryCnt) % MOD;
+//            }
+//        }
+//    }
+//    for (int i = l; i <= p1; i++) {
+//        if (tmp2[i].left) {
+//            clear(tmp2[i].d);
+//        }
+//    }
+//}
+//
+//void cdq2(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq2(l, mid);
+//    merge(l, mid, r);
+//    cdq2(mid + 1, r);
+//}
+//
+//void cdq1(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq1(l, mid);
+//    for (int i = l; i <= r; i++) {
+//        tmp1[i] = arr[i];
+//        tmp1[i].left = (i <= mid);
+//    }
+//    sort(tmp1 + l, tmp1 + r + 1, CmpB);
+//    cdq2(l, r);
+//    cdq1(mid + 1, r);
+//}
+//
+//int lower(int num) {
+//    int l = 1, r = s, ans = 1;
+//    while (l <= r) {
+//        int mid = (l + r) / 2;
+//        if (sortd[mid] >= num) {
+//            ans = mid;
+//            r = mid - 1;
+//        } else {
+//            l = mid + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sortd[i] = arr[i].d;
+//    }
+//    sort(sortd + 1, sortd + n + 1);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sortd[s] != sortd[i]) {
+//            sortd[++s] = sortd[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].d = lower(arr[i].d);
+//    }
+//    sort(arr + 1, arr + n + 1, CmpAbcdv);
+//    int m = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (arr[m].a == arr[i].a && arr[m].b == arr[i].b &&
+//            arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
+//            arr[m].v += arr[i].v;
+//        } else {
+//            arr[++m] = arr[i];
+//        }
+//    }
+//    n = m;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i].i = i;
+//        dp[i] = arr[i].v;
+//        cnt[i] = 1;
+//    }
+//    for (int i = 1; i <= s; i++) {
+//        treeVal[i] = -INF;
+//        treeCnt[i] = 0;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int m;
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i].a >> arr[i].b >> arr[i].c >> arr[i].d >> arr[i].v;
+//    }
+//    prepare();
+//    cdq1(1, n);
+//    long long best = 0;
+//    int ways = 0;
+//    for (int i = 1; i <= n; i++) {
+//        best = max(best, dp[i]);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        if (dp[i] == best) {
+//            ways = (ways + cnt[i]) % MOD;
+//        }
+//    }
+//    cout << best << '\n' << ways << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 4d7870926608033a31899b838f0101079cb9fdd6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 6 Jun 2025 12:04:27 +0800
Subject: [PATCH 0928/1712] modify code

---
 src/class171/Code05_Cute1.java     | 20 ++++++++++----------
 src/class171/Code05_Cute2.java     | 14 +++++++-------
 src/class171/Code06_Treasure1.java | 22 +++++++++++-----------
 src/class171/Code06_Treasure2.java | 17 +++++++++--------
 4 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index 0f8cfaef9..5b985315b 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -32,7 +32,7 @@ public Node(int a_, int b_, int c_, int d_, long v_) {
 		}
 	}
 
-	public static class CmpAbcdv implements Comparator<Node> {
+	public static class Cmp1 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.a != y.a) {
@@ -51,7 +51,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	public static class CmpB implements Comparator<Node> {
+	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.b != y.b) {
@@ -67,7 +67,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	public static class CmpC implements Comparator<Node> {
+	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.c != y.c) {
@@ -83,9 +83,9 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	public static CmpAbcdv cmpAbcdv = new CmpAbcdv();
-	public static CmpB cmpB = new CmpB();
-	public static CmpC cmpC = new CmpC();
+	public static Cmp1 cmp1 = new Cmp1();
+	public static Cmp2 cmp2 = new Cmp2();
+	public static Cmp3 cmp3 = new Cmp3();
 
 	public static int MAXN = 100001;
 	public static long INF = (long) (1e18 + 1);
@@ -131,8 +131,8 @@ public static void merge(int l, int m, int r) {
 		for (int i = l; i <= r; i++) {
 			tmp2[i] = tmp1[i];
 		}
-		Arrays.sort(tmp2, l, m + 1, cmpC);
-		Arrays.sort(tmp2, m + 1, r + 1, cmpC);
+		Arrays.sort(tmp2, l, m + 1, cmp3);
+		Arrays.sort(tmp2, m + 1, r + 1, cmp3);
 		int p1, p2;
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && tmp2[p1 + 1].c <= tmp2[p2].c) {
@@ -172,7 +172,7 @@ public static void cdq1(int l, int r) {
 			tmp1[i] = arr[i];
 			tmp1[i].left = i <= mid;
 		}
-		Arrays.sort(tmp1, l, r + 1, cmpB);
+		Arrays.sort(tmp1, l, r + 1, cmp2);
 		cdq2(l, r);
 		cdq1(mid + 1, r);
 	}
@@ -205,7 +205,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			arr[i].d = lower(arr[i].d);
 		}
-		Arrays.sort(arr, 1, n + 1, cmpAbcdv);
+		Arrays.sort(arr, 1, n + 1, cmp1);
 		int m = 1;
 		for (int i = 2; i <= n; i++) {
 			if (arr[m].a == arr[i].a && arr[m].b == arr[i].b && arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
diff --git a/src/class171/Code05_Cute2.java b/src/class171/Code05_Cute2.java
index 40f1054ab..92286cf41 100644
--- a/src/class171/Code05_Cute2.java
+++ b/src/class171/Code05_Cute2.java
@@ -16,7 +16,7 @@
 //    bool left;
 //};
 //
-//bool CmpAbcdv(Node x, Node y) {
+//bool Cmp1(Node x, Node y) {
 //    if (x.a != y.a) return x.a < y.a;
 //    if (x.b != y.b) return x.b < y.b;
 //    if (x.c != y.c) return x.c < y.c;
@@ -24,14 +24,14 @@
 //    return x.v > y.v;
 //}
 //
-//bool CmpB(Node x, Node y) {
+//bool Cmp2(Node x, Node y) {
 //    if (x.b != y.b) return x.b < y.b;
 //    if (x.c != y.c) return x.c < y.c;
 //    if (x.d != y.d) return x.d < y.d;
 //    return x.a < y.a;
 //}
 //
-//bool CmpC(Node x, Node y) {
+//bool Cmp3(Node x, Node y) {
 //    if (x.c != y.c) return x.c < y.c;
 //    if (x.d != y.d) return x.d < y.d;
 //    if (x.a != y.a) return x.a < y.a;
@@ -81,8 +81,8 @@
 //    for (int i = l; i <= r; i++) {
 //        tmp2[i] = tmp1[i];
 //    }
-//    sort(tmp2 + l, tmp2 + m + 1, CmpC);
-//    sort(tmp2 + m + 1, tmp2 + r + 1, CmpC);
+//    sort(tmp2 + l, tmp2 + m + 1, Cmp3);
+//    sort(tmp2 + m + 1, tmp2 + r + 1, Cmp3);
 //    int p1, p2;
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && tmp2[p1 + 1].c <= tmp2[p2].c) {
@@ -118,7 +118,7 @@
 //        tmp1[i] = arr[i];
 //        tmp1[i].left = i <= mid;
 //    }
-//    sort(tmp1 + l, tmp1 + r + 1, CmpB);
+//    sort(tmp1 + l, tmp1 + r + 1, Cmp2);
 //    cdq2(l, r);
 //    cdq1(mid + 1, r);
 //}
@@ -151,7 +151,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        arr[i].d = lower(arr[i].d);
 //    }
-//    sort(arr + 1, arr + n + 1, CmpAbcdv);
+//    sort(arr + 1, arr + n + 1, Cmp1);
 //    int m = 1;
 //    for (int i = 2; i <= n; i++) {
 //        if (arr[m].a == arr[i].a && arr[m].b == arr[i].b &&
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index 25808b928..b5433acfa 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -2,7 +2,7 @@
 
 // 寻找宝藏，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"，多提交几次，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -32,7 +32,7 @@ public Node(int a_, int b_, int c_, int d_, long v_) {
 		}
 	}
 
-	public static class CmpAbcdv implements Comparator<Node> {
+	public static class Cmp1 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.a != y.a) {
@@ -51,7 +51,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	public static class CmpB implements Comparator<Node> {
+	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.b != y.b) {
@@ -67,7 +67,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	public static class CmpC implements Comparator<Node> {
+	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.c != y.c) {
@@ -83,9 +83,9 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	public static CmpAbcdv cmpAbcdv = new CmpAbcdv();
-	public static CmpB cmpB = new CmpB();
-	public static CmpC cmpC = new CmpC();
+	public static Cmp1 cmp1 = new Cmp1();
+	public static Cmp2 cmp2 = new Cmp2();
+	public static Cmp3 cmp3 = new Cmp3();
 
 	public static int n, s;
 	public static Node[] arr = new Node[MAXN];
@@ -144,8 +144,8 @@ public static void merge(int l, int mid, int r) {
 		for (int i = l; i <= r; i++) {
 			tmp2[i] = tmp1[i];
 		}
-		Arrays.sort(tmp2, l, mid + 1, cmpC);
-		Arrays.sort(tmp2, mid + 1, r + 1, cmpC);
+		Arrays.sort(tmp2, l, mid + 1, cmp3);
+		Arrays.sort(tmp2, mid + 1, r + 1, cmp3);
 		int p1, p2, id;
 		for (p1 = l - 1, p2 = mid + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= mid && tmp2[p1 + 1].c <= tmp2[p2].c) {
@@ -192,7 +192,7 @@ public static void cdq1(int l, int r) {
 			tmp1[i] = arr[i];
 			tmp1[i].left = (i <= mid);
 		}
-		Arrays.sort(tmp1, l, r + 1, cmpB);
+		Arrays.sort(tmp1, l, r + 1, cmp2);
 		cdq2(l, r);
 		cdq1(mid + 1, r);
 	}
@@ -225,7 +225,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			arr[i].d = lower(arr[i].d);
 		}
-		Arrays.sort(arr, 1, n + 1, cmpAbcdv);
+		Arrays.sort(arr, 1, n + 1, cmp1);
 		int m = 1;
 		for (int i = 2; i <= n; i++) {
 			if (arr[m].a == arr[i].a && arr[m].b == arr[i].b && arr[m].c == arr[i].c && arr[m].d == arr[i].d) {
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index e78c4f559..5882975b9 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -16,7 +16,7 @@
 //    bool left;
 //};
 //
-//bool CmpAbcdv(Node x, Node y) {
+//bool Cmp1(Node x, Node y) {
 //    if (x.a != y.a) return x.a < y.a;
 //    if (x.b != y.b) return x.b < y.b;
 //    if (x.c != y.c) return x.c < y.c;
@@ -24,14 +24,14 @@
 //    return x.v > y.v;
 //}
 //
-//bool CmpB(Node x, Node y) {
+//bool Cmp2(Node x, Node y) {
 //    if (x.b != y.b) return x.b < y.b;
 //    if (x.c != y.c) return x.c < y.c;
 //    if (x.d != y.d) return x.d < y.d;
 //    return x.a < y.a;
 //}
 //
-//bool CmpC(Node x, Node y) {
+//bool Cmp3(Node x, Node y) {
 //    if (x.c != y.c) return x.c < y.c;
 //    if (x.d != y.d) return x.d < y.d;
 //    if (x.a != y.a) return x.a < y.a;
@@ -99,8 +99,8 @@
 //    for (int i = l; i <= r; i++) {
 //        tmp2[i] = tmp1[i];
 //    }
-//    sort(tmp2 + l, tmp2 + m + 1, CmpC);
-//    sort(tmp2 + m + 1, tmp2 + r + 1, CmpC);
+//    sort(tmp2 + l, tmp2 + m + 1, Cmp3);
+//    sort(tmp2 + m + 1, tmp2 + r + 1, Cmp3);
 //    int p1, p2, id;
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && tmp2[p1 + 1].c <= tmp2[p2].c) {
@@ -143,7 +143,7 @@
 //        tmp1[i] = arr[i];
 //        tmp1[i].left = (i <= mid);
 //    }
-//    sort(tmp1 + l, tmp1 + r + 1, CmpB);
+//    sort(tmp1 + l, tmp1 + r + 1, Cmp2);
 //    cdq2(l, r);
 //    cdq1(mid + 1, r);
 //}
@@ -176,7 +176,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        arr[i].d = lower(arr[i].d);
 //    }
-//    sort(arr + 1, arr + n + 1, CmpAbcdv);
+//    sort(arr + 1, arr + n + 1, Cmp1);
 //    int m = 1;
 //    for (int i = 2; i <= n; i++) {
 //        if (arr[m].a == arr[i].a && arr[m].b == arr[i].b &&
@@ -218,6 +218,7 @@
 //            ways = (ways + cnt[i]) % MOD;
 //        }
 //    }
-//    cout << best << '\n' << ways << '\n';
+//    cout << best << '\n';
+//    cout << ways << '\n';
 //    return 0;
 //}
\ No newline at end of file

From 1e482d0a0dddd09270f18c48027b74af12001d9f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 6 Jun 2025 18:10:46 +0800
Subject: [PATCH 0929/1712] modify code

---
 src/class171/Code01_MooFest1.java     | 4 ++++
 src/class171/Code01_MooFest2.java     | 4 ++++
 src/class171/Code02_AiRobots1.java    | 9 ++++++++-
 src/class171/Code02_AiRobots2.java    | 9 ++++++++-
 src/class171/Code03_Sequence1.java    | 5 +++++
 src/class171/Code03_Sequence2.java    | 5 +++++
 src/class171/Code04_Interceptor1.java | 7 +++++++
 src/class171/Code04_Interceptor2.java | 7 +++++++
 src/class171/Code05_Cute1.java        | 8 +++++++-
 src/class171/Code05_Cute2.java        | 8 +++++++-
 src/class171/Code06_Treasure1.java    | 5 +++++
 src/class171/Code06_Treasure2.java    | 5 +++++
 12 files changed, 72 insertions(+), 4 deletions(-)

diff --git a/src/class171/Code01_MooFest1.java b/src/class171/Code01_MooFest1.java
index 9924e6958..0705956d0 100644
--- a/src/class171/Code01_MooFest1.java
+++ b/src/class171/Code01_MooFest1.java
@@ -1,6 +1,10 @@
 package class171;
 
 // 奶牛音量和，java版
+// 一共有n只奶牛，每只奶牛给定，听力v、坐标x
+// 任何一对奶牛产生的音量 = max(vi, vj) * 两只奶牛的距离
+// 一共有n * (n - 1) / 2对奶牛，打印音量总和
+// 1 <= n、v、x <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P5094
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class171/Code01_MooFest2.java b/src/class171/Code01_MooFest2.java
index c5dab7ed3..f101326c0 100644
--- a/src/class171/Code01_MooFest2.java
+++ b/src/class171/Code01_MooFest2.java
@@ -1,6 +1,10 @@
 package class171;
 
 // 奶牛音量和，C++版
+// 一共有n只奶牛，每只奶牛给定，听力v、坐标x
+// 任何一对奶牛产生的音量 = max(vi, vj) * 两只奶牛的距离
+// 一共有n * (n - 1) / 2对奶牛，打印音量总和
+// 1 <= n、v、x <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P5094
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class171/Code02_AiRobots1.java b/src/class171/Code02_AiRobots1.java
index 204696710..ed44087e0 100644
--- a/src/class171/Code02_AiRobots1.java
+++ b/src/class171/Code02_AiRobots1.java
@@ -1,6 +1,13 @@
 package class171;
 
-// 机器人可见对，java版
+// 机器人聊天对，java版
+// 一共有n个机器人，每个机器人给定，位置x、视野y、智商q
+// 第i个机器人可以看见的范围是[xi − yi, xi + yi]
+// 如果两个机器人相互之间可以看见，并且智商差距不大于k，那么它们会开始聊天
+// 打印有多少对机器人可以聊天
+// 1 <= n <= 10^5
+// 0 <= k <= 20
+// 0 <= x、y、q <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF1045G
 // 测试链接 : https://codeforces.com/problemset/problem/1045/G
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class171/Code02_AiRobots2.java b/src/class171/Code02_AiRobots2.java
index fd64540fd..fdf28ca16 100644
--- a/src/class171/Code02_AiRobots2.java
+++ b/src/class171/Code02_AiRobots2.java
@@ -1,6 +1,13 @@
 package class171;
 
-// 机器人可见对，C++版
+// 机器人聊天对，C++版
+// 一共有n个机器人，每个机器人给定，位置x、视野y、智商q
+// 第i个机器人可以看见的范围是[xi − yi, xi + yi]
+// 如果两个机器人相互之间可以看见，并且智商差距不大于k，那么它们会开始聊天
+// 打印有多少对机器人可以聊天
+// 1 <= n <= 10^5
+// 0 <= k <= 20
+// 0 <= x、y、q <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF1045G
 // 测试链接 : https://codeforces.com/problemset/problem/1045/G
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 3339e48f4..0988f7609 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -1,6 +1,11 @@
 package class171;
 
 // 序列，java版
+// 给定一个长度为n的数组arr，一共有m条操作，格式为 x v 表示x位置的数变成v
+// 你可以选择不执行任何操作，或者只选择一个操作来执行，然后arr不再变动
+// 请在原始的arr中选出一组下标序列，不管你做出什么选择，下标序列上的数字都是不下降的
+// 打印序列能达到的最大长度
+// 1 <= 所有数字 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4093
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class171/Code03_Sequence2.java b/src/class171/Code03_Sequence2.java
index a830ec707..58b303c73 100644
--- a/src/class171/Code03_Sequence2.java
+++ b/src/class171/Code03_Sequence2.java
@@ -1,6 +1,11 @@
 package class171;
 
 // 序列，C++版
+// 给定一个长度为n的数组arr，一共有m条操作，格式为 x v 表示x位置的数变成v
+// 你可以选择不执行任何操作，或者只选择一个操作来执行，然后arr不再变动
+// 请在原始的arr中选出一组下标序列，不管你做出什么选择，下标序列上的数字都是不下降的
+// 打印序列能达到的最大长度
+// 1 <= 所有数字 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4093
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
index 290ef225a..c45b7630e 100644
--- a/src/class171/Code04_Interceptor1.java
+++ b/src/class171/Code04_Interceptor1.java
@@ -1,6 +1,13 @@
 package class171;
 
 // 拦截导弹，java版
+// 一共有n个导弹，编号1~n，表示导弹从早到晚依次到达，每个导弹给定，高度h、速度v
+// 你有导弹拦截系统，第1次可以拦截任意参数的导弹
+// 但是之后拦截的导弹，高度和速度都不能比前一次拦截的导弹大
+// 你的目的是尽可能多的拦截导弹，如果有多个最优方案，会随机选一个执行
+// 打印最多能拦截几个导弹，并且打印每个导弹被拦截的概率
+// 1 <= n <= 5 * 10^4
+// 1 <= h、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2487
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class171/Code04_Interceptor2.java b/src/class171/Code04_Interceptor2.java
index a97774069..f78d843e7 100644
--- a/src/class171/Code04_Interceptor2.java
+++ b/src/class171/Code04_Interceptor2.java
@@ -1,6 +1,13 @@
 package class171;
 
 // 拦截导弹，C++版
+// 一共有n个导弹，编号1~n，表示导弹从早到晚依次到达，每个导弹给定，高度h、速度v
+// 你有导弹拦截系统，第1次可以拦截任意参数的导弹
+// 但是之后拦截的导弹，高度和速度都不能比前一次拦截的导弹大
+// 你的目的是尽可能多的拦截导弹，如果有多个最优方案，会随机选一个执行
+// 打印最多能拦截几个导弹，并且打印每个导弹被拦截的概率
+// 1 <= n <= 5 * 10^4
+// 1 <= h、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2487
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index 5b985315b..cdc55994b 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -1,6 +1,12 @@
 package class171;
 
 // 德丽莎世界第一可爱，java版
+// 一共有n个怪兽，每个怪兽有a、b、c、d四个能力值，以及打败之后的收益v
+// 你可以选择任意顺序打怪兽，每次打的怪兽的四种能力值都不能小于上次打的怪兽
+// 打印你能获得的最大收益
+// 1 <= n <= 5 * 10^4
+// -10^5 <= a、b、c、d <= +10^5
+// -10^9 <= v <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5621
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是有两个测试用例超时
@@ -87,7 +93,7 @@ public int compare(Node x, Node y) {
 	public static Cmp2 cmp2 = new Cmp2();
 	public static Cmp3 cmp3 = new Cmp3();
 
-	public static int MAXN = 100001;
+	public static int MAXN = 50001;
 	public static long INF = (long) (1e18 + 1);
 	public static int n, s;
 
diff --git a/src/class171/Code05_Cute2.java b/src/class171/Code05_Cute2.java
index 92286cf41..78be3fa0f 100644
--- a/src/class171/Code05_Cute2.java
+++ b/src/class171/Code05_Cute2.java
@@ -1,6 +1,12 @@
 package class171;
 
 // 德丽莎世界第一可爱，C++版
+// 一共有n个怪兽，每个怪兽有a、b、c、d四个能力值，以及打败之后的收益v
+// 你可以选择任意顺序打怪兽，每次打的怪兽的四种能力值都不能小于上次打的怪兽
+// 打印你能获得的最大收益
+// 1 <= n <= 5 * 10^4
+// -10^5 <= a、b、c、d <= +10^5
+// -10^9 <= v <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5621
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -38,7 +44,7 @@
 //    return x.b < y.b;
 //}
 //
-//const int MAXN = 100001;
+//const int MAXN = 50001;
 //const long long INF = 1e18 + 1;
 //int n, s;
 //
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index b5433acfa..c0473dd64 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -1,6 +1,11 @@
 package class171;
 
 // 寻找宝藏，java版
+// 一共有n个宝藏，每个宝藏有a、b、c、d四个属性值，以及拿取之后的收益v
+// 你可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
+// 打印你能获得的最大收益，打印有多少种拿取方法能获得最大的收益
+// 1 <= n <= 8 * 10^4
+// 1 <= a、b、c、d、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
 // 提交以下的code，提交时请把类名改成"Main"，多提交几次，可以通过所有测试用例
 
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index 5882975b9..d9ac462e3 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -1,6 +1,11 @@
 package class171;
 
 // 寻找宝藏，C++版
+// 一共有n个宝藏，每个宝藏有a、b、c、d四个属性值，以及拿取之后的收益v
+// 你可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
+// 打印你能获得的最大收益，打印有多少种拿取方法能获得最大的收益
+// 1 <= n <= 8 * 10^4
+// 1 <= a、b、c、d、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 288f3d7c07804fe24617be34253cbc9bb20bc2e7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 6 Jun 2025 18:15:07 +0800
Subject: [PATCH 0930/1712] modify code

---
 src/class171/Code03_Sequence1.java | 2 +-
 src/class171/Code03_Sequence2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 0988f7609..8ddf9073f 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -3,7 +3,7 @@
 // 序列，java版
 // 给定一个长度为n的数组arr，一共有m条操作，格式为 x v 表示x位置的数变成v
 // 你可以选择不执行任何操作，或者只选择一个操作来执行，然后arr不再变动
-// 请在原始的arr中选出一组下标序列，不管你做出什么选择，下标序列上的数字都是不下降的
+// 请在arr中选出一组下标序列，不管你做出什么选择，下标序列所代表的数字都是不下降的
 // 打印序列能达到的最大长度
 // 1 <= 所有数字 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4093
diff --git a/src/class171/Code03_Sequence2.java b/src/class171/Code03_Sequence2.java
index 58b303c73..f9dd1f9c7 100644
--- a/src/class171/Code03_Sequence2.java
+++ b/src/class171/Code03_Sequence2.java
@@ -3,7 +3,7 @@
 // 序列，C++版
 // 给定一个长度为n的数组arr，一共有m条操作，格式为 x v 表示x位置的数变成v
 // 你可以选择不执行任何操作，或者只选择一个操作来执行，然后arr不再变动
-// 请在原始的arr中选出一组下标序列，不管你做出什么选择，下标序列上的数字都是不下降的
+// 请在arr中选出一组下标序列，不管你做出什么选择，下标序列所代表的数字都是不下降的
 // 打印序列能达到的最大长度
 // 1 <= 所有数字 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4093

From 39184a9d7967bfcfd1793e956d5c5fbdc9f732ef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 6 Jun 2025 18:20:52 +0800
Subject: [PATCH 0931/1712] modify code

---
 src/class171/Code06_Treasure1.java | 2 +-
 src/class171/Code06_Treasure2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index c0473dd64..768a2ac0c 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -3,7 +3,7 @@
 // 寻找宝藏，java版
 // 一共有n个宝藏，每个宝藏有a、b、c、d四个属性值，以及拿取之后的收益v
 // 你可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
-// 打印你能获得的最大收益，打印有多少种拿取方法能获得最大的收益
+// 打印你能获得的最大收益，打印有多少种最佳拿取方法，方法数对 998244353 取余
 // 1 <= n <= 8 * 10^4
 // 1 <= a、b、c、d、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index d9ac462e3..e16344c81 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -3,7 +3,7 @@
 // 寻找宝藏，C++版
 // 一共有n个宝藏，每个宝藏有a、b、c、d四个属性值，以及拿取之后的收益v
 // 你可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
-// 打印你能获得的最大收益，打印有多少种拿取方法能获得最大的收益
+// 打印你能获得的最大收益，打印有多少种最佳拿取方法，方法数对 998244353 取余
 // 1 <= n <= 8 * 10^4
 // 1 <= a、b、c、d、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4849

From c3be1d6e39316f1338047c9ea2b1ef26cf5f2696 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 6 Jun 2025 18:31:06 +0800
Subject: [PATCH 0932/1712] modify code

---
 src/class171/Code04_Interceptor1.java | 63 +++++++++++++--------------
 src/class171/Code04_Interceptor2.java | 58 ++++++++++++------------
 src/class171/Code06_Treasure1.java    |  8 ++--
 3 files changed, 64 insertions(+), 65 deletions(-)

diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
index c45b7630e..2b6e9b73b 100644
--- a/src/class171/Code04_Interceptor1.java
+++ b/src/class171/Code04_Interceptor1.java
@@ -28,9 +28,8 @@ public class Code04_Interceptor1 {
 	// 位置i、高度h、速度v
 	public static int[][] arr = new int[MAXN][3];
 
-	// 树状数组，维护最大长度、最大长度出现的次数
-	public static int[] treelen = new int[MAXN];
-	public static double[] treecnt = new double[MAXN];
+	public static int[] treeVal = new int[MAXN];
+	public static double[] treeCnt = new double[MAXN];
 
 	public static int[] len1 = new int[MAXN];
 	public static double[] cnt1 = new double[MAXN];
@@ -38,34 +37,34 @@ public class Code04_Interceptor1 {
 	public static int[] len2 = new int[MAXN];
 	public static double[] cnt2 = new double[MAXN];
 
-	public static int lowbit(int x) {
-		return x & -x;
+	public static int lowbit(int i) {
+		return i & -i;
 	}
 
-	public static void add(int i, int len, double cnt) {
+	public static void add(int i, int val, double cnt) {
 		while (i <= s) {
-			if (len > treelen[i]) {
-				treelen[i] = len;
-				treecnt[i] = cnt;
-			} else if (len == treelen[i]) {
-				treecnt[i] += cnt;
+			if (val > treeVal[i]) {
+				treeVal[i] = val;
+				treeCnt[i] = cnt;
+			} else if (val == treeVal[i]) {
+				treeCnt[i] += cnt;
 			}
 			i += lowbit(i);
 		}
 	}
 
-	public static int querylen;
-	public static double querycnt;
+	public static int queryVal;
+	public static double queryCnt;
 
 	public static void query(int i) {
-		querylen = 0;
-		querycnt = 0;
+		queryVal = 0;
+		queryCnt = 0;
 		while (i > 0) {
-			if (treelen[i] > querylen) {
-				querylen = treelen[i];
-				querycnt = treecnt[i];
-			} else if (treelen[i] == querylen) {
-				querycnt += treecnt[i];
+			if (treeVal[i] > queryVal) {
+				queryVal = treeVal[i];
+				queryCnt = treeCnt[i];
+			} else if (treeVal[i] == queryVal) {
+				queryCnt += treeCnt[i];
 			}
 			i -= lowbit(i);
 		}
@@ -73,8 +72,8 @@ public static void query(int i) {
 
 	public static void clear(int i) {
 		while (i <= s) {
-			treelen[i] = 0;
-			treecnt[i] = 0;
+			treeVal[i] = 0;
+			treeCnt[i] = 0;
 			i += lowbit(i);
 		}
 	}
@@ -94,11 +93,11 @@ public static void merge1(int l, int m, int r) {
 				add(s - arr[p1][2] + 1, len1[arr[p1][0]], cnt1[arr[p1][0]]);
 			}
 			query(s - arr[p2][2] + 1);
-			if (querylen + 1 > len1[arr[p2][0]]) {
-				len1[arr[p2][0]] = querylen + 1;
-				cnt1[arr[p2][0]] = querycnt;
-			} else if (querylen + 1 == len1[arr[p2][0]]) {
-				cnt1[arr[p2][0]] += querycnt;
+			if (queryVal + 1 > len1[arr[p2][0]]) {
+				len1[arr[p2][0]] = queryVal + 1;
+				cnt1[arr[p2][0]] = queryCnt;
+			} else if (queryVal + 1 == len1[arr[p2][0]]) {
+				cnt1[arr[p2][0]] += queryCnt;
 			}
 		}
 		for (int i = l; i <= p1; i++) {
@@ -131,11 +130,11 @@ public static void merge2(int l, int m, int r) {
 				add(arr[p1][2], len2[arr[p1][0]], cnt2[arr[p1][0]]);
 			}
 			query(arr[p2][2]);
-			if (querylen + 1 > len2[arr[p2][0]]) {
-				len2[arr[p2][0]] = querylen + 1;
-				cnt2[arr[p2][0]] = querycnt;
-			} else if (querylen + 1 == len2[arr[p2][0]]) {
-				cnt2[arr[p2][0]] += querycnt;
+			if (queryVal + 1 > len2[arr[p2][0]]) {
+				len2[arr[p2][0]] = queryVal + 1;
+				cnt2[arr[p2][0]] = queryCnt;
+			} else if (queryVal + 1 == len2[arr[p2][0]]) {
+				cnt2[arr[p2][0]] += queryCnt;
 			}
 		}
 		for (int i = l; i <= p1; i++) {
diff --git a/src/class171/Code04_Interceptor2.java b/src/class171/Code04_Interceptor2.java
index f78d843e7..3587c55ff 100644
--- a/src/class171/Code04_Interceptor2.java
+++ b/src/class171/Code04_Interceptor2.java
@@ -36,8 +36,8 @@
 //
 //Node arr[MAXN];
 //
-//int treelen[MAXN];
-//double treecnt[MAXN];
+//int treeVal[MAXN];
+//double treeCnt[MAXN];
 //
 //int len1[MAXN];
 //double cnt1[MAXN];
@@ -49,30 +49,30 @@
 //    return i & -i;
 //}
 //
-//void add(int i, int len, double cnt) {
+//void add(int i, int val, double cnt) {
 //    while (i <= s) {
-//        if (len > treelen[i]) {
-//            treelen[i] = len;
-//            treecnt[i] = cnt;
-//        } else if (len == treelen[i]) {
-//            treecnt[i] += cnt;
+//        if (val > treeVal[i]) {
+//            treeVal[i] = val;
+//            treeCnt[i] = cnt;
+//        } else if (val == treeVal[i]) {
+//            treeCnt[i] += cnt;
 //        }
 //        i += lowbit(i);
 //    }
 //}
 //
-//int querylen;
-//double querycnt;
+//int queryVal;
+//double queryCnt;
 //
 //void query(int i) {
-//    querylen = 0;
-//    querycnt = 0;
+//    queryVal = 0;
+//    queryCnt = 0;
 //    while (i > 0) {
-//        if (treelen[i] > querylen) {
-//            querylen = treelen[i];
-//            querycnt = treecnt[i];
-//        } else if (treelen[i] == querylen) {
-//            querycnt += treecnt[i];
+//        if (treeVal[i] > queryVal) {
+//            queryVal = treeVal[i];
+//            queryCnt = treeCnt[i];
+//        } else if (treeVal[i] == queryVal) {
+//            queryCnt += treeCnt[i];
 //        }
 //        i -= lowbit(i);
 //    }
@@ -80,8 +80,8 @@
 //
 //void clear(int i) {
 //    while (i <= s) {
-//        treelen[i] = 0;
-//        treecnt[i] = 0;
+//        treeVal[i] = 0;
+//        treeCnt[i] = 0;
 //        i += lowbit(i);
 //    }
 //}
@@ -101,11 +101,11 @@
 //            add(s - arr[p1].v + 1, len1[arr[p1].i], cnt1[arr[p1].i]);
 //        }
 //        query(s - arr[p2].v + 1);
-//        if (querylen + 1 > len1[arr[p2].i]) {
-//            len1[arr[p2].i] = querylen + 1;
-//            cnt1[arr[p2].i] = querycnt;
-//        } else if (querylen + 1 == len1[arr[p2].i]) {
-//            cnt1[arr[p2].i] += querycnt;
+//        if (queryVal + 1 > len1[arr[p2].i]) {
+//            len1[arr[p2].i] = queryVal + 1;
+//            cnt1[arr[p2].i] = queryCnt;
+//        } else if (queryVal + 1 == len1[arr[p2].i]) {
+//            cnt1[arr[p2].i] += queryCnt;
 //        }
 //    }
 //    for (int i = l; i <= p1; i++) {
@@ -138,11 +138,11 @@
 //            add(arr[p1].v, len2[arr[p1].i], cnt2[arr[p1].i]);
 //        }
 //        query(arr[p2].v);
-//        if (querylen + 1 > len2[arr[p2].i]) {
-//            len2[arr[p2].i] = querylen + 1;
-//            cnt2[arr[p2].i] = querycnt;
-//        } else if (querylen + 1 == len2[arr[p2].i]) {
-//            cnt2[arr[p2].i] += querycnt;
+//        if (queryVal + 1 > len2[arr[p2].i]) {
+//            len2[arr[p2].i] = queryVal + 1;
+//            cnt2[arr[p2].i] = queryCnt;
+//        } else if (queryVal + 1 == len2[arr[p2].i]) {
+//            cnt2[arr[p2].i] += queryCnt;
 //        }
 //    }
 //    for (int i = l; i <= p1; i++) {
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index 768a2ac0c..7359a3bef 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -18,10 +18,6 @@
 
 public class Code06_Treasure1 {
 
-	public static int MAXN = 80001;
-	public static long INF = (long) (1e18 + 1);
-	public static int MOD = 998244353;
-
 	public static class Node {
 		int a, b, c, d;
 		int i;
@@ -92,7 +88,11 @@ public int compare(Node x, Node y) {
 	public static Cmp2 cmp2 = new Cmp2();
 	public static Cmp3 cmp3 = new Cmp3();
 
+	public static int MAXN = 80001;
+	public static long INF = (long) (1e18 + 1);
+	public static int MOD = 998244353;
 	public static int n, s;
+
 	public static Node[] arr = new Node[MAXN];
 	public static Node[] tmp1 = new Node[MAXN];
 	public static Node[] tmp2 = new Node[MAXN];

From 1ca240977ce1934ceb657eac383fb6d7f73cc762 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 7 Jun 2025 13:51:43 +0800
Subject: [PATCH 0933/1712] modify code

---
 src/class171/Code05_Cute1.java     |  6 ++++--
 src/class171/Code05_Cute2.java     |  4 ++--
 src/class171/Code06_Treasure1.java | 11 +++++------
 src/class171/Code06_Treasure2.java |  7 +++----
 4 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index cdc55994b..a7f244961 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -2,8 +2,8 @@
 
 // 德丽莎世界第一可爱，java版
 // 一共有n个怪兽，每个怪兽有a、b、c、d四个能力值，以及打败之后的收益v
-// 你可以选择任意顺序打怪兽，每次打的怪兽的四种能力值都不能小于上次打的怪兽
-// 打印你能获得的最大收益
+// 可以选择任意顺序打怪兽，每次打的怪兽的四种能力值都不能小于上次打的怪兽
+// 打印能获得的最大收益，可能所有怪兽收益都是负数，那也需要至少打一只怪兽
 // 1 <= n <= 5 * 10^4
 // -10^5 <= a、b、c、d <= +10^5
 // -10^9 <= v <= +10^9
@@ -57,6 +57,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
+	// 需要排序的稳定性
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
@@ -73,6 +74,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
+	// 需要排序的稳定性
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
diff --git a/src/class171/Code05_Cute2.java b/src/class171/Code05_Cute2.java
index 78be3fa0f..1e65b770c 100644
--- a/src/class171/Code05_Cute2.java
+++ b/src/class171/Code05_Cute2.java
@@ -2,8 +2,8 @@
 
 // 德丽莎世界第一可爱，C++版
 // 一共有n个怪兽，每个怪兽有a、b、c、d四个能力值，以及打败之后的收益v
-// 你可以选择任意顺序打怪兽，每次打的怪兽的四种能力值都不能小于上次打的怪兽
-// 打印你能获得的最大收益
+// 可以选择任意顺序打怪兽，每次打的怪兽的四种能力值都不能小于上次打的怪兽
+// 打印能获得的最大收益，可能所有怪兽收益都是负数，那也需要至少打一只怪兽
 // 1 <= n <= 5 * 10^4
 // -10^5 <= a、b、c、d <= +10^5
 // -10^9 <= v <= +10^9
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index 7359a3bef..c3caea7da 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -2,8 +2,8 @@
 
 // 寻找宝藏，java版
 // 一共有n个宝藏，每个宝藏有a、b、c、d四个属性值，以及拿取之后的收益v
-// 你可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
-// 打印你能获得的最大收益，打印有多少种最佳拿取方法，方法数对 998244353 取余
+// 可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
+// 打印能获得的最大收益，打印有多少种最佳拿取方法，方法数对 998244353 取余
 // 1 <= n <= 8 * 10^4
 // 1 <= a、b、c、d、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
@@ -45,13 +45,11 @@ public int compare(Node x, Node y) {
 			if (x.c != y.c) {
 				return x.c - y.c;
 			}
-			if (x.d != y.d) {
-				return x.d - y.d;
-			}
-			return Long.compare(y.v, x.v);
+			return x.d - y.d;
 		}
 	}
 
+	// 需要排序的稳定性
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
@@ -68,6 +66,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
+	// 需要排序的稳定性
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index e16344c81..a4bc32ee9 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -2,8 +2,8 @@
 
 // 寻找宝藏，C++版
 // 一共有n个宝藏，每个宝藏有a、b、c、d四个属性值，以及拿取之后的收益v
-// 你可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
-// 打印你能获得的最大收益，打印有多少种最佳拿取方法，方法数对 998244353 取余
+// 可以选择任意顺序拿取宝藏，每次拿的宝藏的四种属性值都不能小于上次拿的宝藏
+// 打印能获得的最大收益，打印有多少种最佳拿取方法，方法数对 998244353 取余
 // 1 <= n <= 8 * 10^4
 // 1 <= a、b、c、d、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
@@ -25,8 +25,7 @@
 //    if (x.a != y.a) return x.a < y.a;
 //    if (x.b != y.b) return x.b < y.b;
 //    if (x.c != y.c) return x.c < y.c;
-//    if (x.d != y.d) return x.d < y.d;
-//    return x.v > y.v;
+//    return x.d < y.d;
 //}
 //
 //bool Cmp2(Node x, Node y) {

From ac14b0565bbb29295ffdcf8c0364e03ee984884c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 7 Jun 2025 13:54:58 +0800
Subject: [PATCH 0934/1712] modify code

---
 src/class171/Code06_Treasure1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index c3caea7da..93d819986 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -7,7 +7,7 @@
 // 1 <= n <= 8 * 10^4
 // 1 <= a、b、c、d、v <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4849
-// 提交以下的code，提交时请把类名改成"Main"，多提交几次，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;

From f77282149949c1296ba2bc40e63f82c5b6a5afcf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 7 Jun 2025 14:18:38 +0800
Subject: [PATCH 0935/1712] modify code

---
 src/class171/Code04_Interceptor1.java | 6 +++---
 src/class171/Code04_Interceptor2.java | 6 +++---
 src/class171/Code06_Treasure1.java    | 4 ++--
 src/class171/Code06_Treasure2.java    | 4 ++--
 4 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
index 2b6e9b73b..60955ea10 100644
--- a/src/class171/Code04_Interceptor1.java
+++ b/src/class171/Code04_Interceptor1.java
@@ -41,7 +41,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	public static void add(int i, int val, double cnt) {
+	public static void more(int i, int val, double cnt) {
 		while (i <= s) {
 			if (val > treeVal[i]) {
 				treeVal[i] = val;
@@ -90,7 +90,7 @@ public static void merge1(int l, int m, int r) {
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][1] >= arr[p2][1]) {
 				p1++;
-				add(s - arr[p1][2] + 1, len1[arr[p1][0]], cnt1[arr[p1][0]]);
+				more(s - arr[p1][2] + 1, len1[arr[p1][0]], cnt1[arr[p1][0]]);
 			}
 			query(s - arr[p2][2] + 1);
 			if (queryVal + 1 > len1[arr[p2][0]]) {
@@ -127,7 +127,7 @@ public static void merge2(int l, int m, int r) {
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][1]) {
 				p1++;
-				add(arr[p1][2], len2[arr[p1][0]], cnt2[arr[p1][0]]);
+				more(arr[p1][2], len2[arr[p1][0]], cnt2[arr[p1][0]]);
 			}
 			query(arr[p2][2]);
 			if (queryVal + 1 > len2[arr[p2][0]]) {
diff --git a/src/class171/Code04_Interceptor2.java b/src/class171/Code04_Interceptor2.java
index 3587c55ff..c2d253fb4 100644
--- a/src/class171/Code04_Interceptor2.java
+++ b/src/class171/Code04_Interceptor2.java
@@ -49,7 +49,7 @@
 //    return i & -i;
 //}
 //
-//void add(int i, int val, double cnt) {
+//void more(int i, int val, double cnt) {
 //    while (i <= s) {
 //        if (val > treeVal[i]) {
 //            treeVal[i] = val;
@@ -98,7 +98,7 @@
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && arr[p1 + 1].h >= arr[p2].h) {
 //            p1++;
-//            add(s - arr[p1].v + 1, len1[arr[p1].i], cnt1[arr[p1].i]);
+//            more(s - arr[p1].v + 1, len1[arr[p1].i], cnt1[arr[p1].i]);
 //        }
 //        query(s - arr[p2].v + 1);
 //        if (queryVal + 1 > len1[arr[p2].i]) {
@@ -135,7 +135,7 @@
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && arr[p1 + 1].h <= arr[p2].h) {
 //            p1++;
-//            add(arr[p1].v, len2[arr[p1].i], cnt2[arr[p1].i]);
+//            more(arr[p1].v, len2[arr[p1].i], cnt2[arr[p1].i]);
 //        }
 //        query(arr[p2].v);
 //        if (queryVal + 1 > len2[arr[p2].i]) {
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index 93d819986..b3a3a9c6a 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -107,7 +107,7 @@ public static int lowbit(int i) {
 		return i & -i;
 	}
 
-	public static void add(int i, long v, int c) {
+	public static void more(int i, long v, int c) {
 		while (i <= s) {
 			if (v > treeVal[i]) {
 				treeVal[i] = v;
@@ -155,7 +155,7 @@ public static void merge(int l, int mid, int r) {
 			while (p1 + 1 <= mid && tmp2[p1 + 1].c <= tmp2[p2].c) {
 				p1++;
 				if (tmp2[p1].left) {
-					add(tmp2[p1].d, dp[tmp2[p1].i], cnt[tmp2[p1].i]);
+					more(tmp2[p1].d, dp[tmp2[p1].i], cnt[tmp2[p1].i]);
 				}
 			}
 			if (!tmp2[p2].left) {
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index a4bc32ee9..c39740ccc 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -62,7 +62,7 @@
 //    return i & -i;
 //}
 //
-//void add(int i, long long v, int c) {
+//void more(int i, long long v, int c) {
 //    while (i <= s) {
 //        if (v > treeVal[i]) {
 //            treeVal[i] = v;
@@ -110,7 +110,7 @@
 //        while (p1 + 1 <= m && tmp2[p1 + 1].c <= tmp2[p2].c) {
 //            p1++;
 //            if (tmp2[p1].left) {
-//                add(tmp2[p1].d, dp[tmp2[p1].i], cnt[tmp2[p1].i]);
+//                more(tmp2[p1].d, dp[tmp2[p1].i], cnt[tmp2[p1].i]);
 //            }
 //        }
 //        if (!tmp2[p2].left) {

From 41d0c8c5369bddfc136044d6a54ae5d3a9b2605e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 7 Jun 2025 15:35:35 +0800
Subject: [PATCH 0936/1712] modify code

---
 src/class171/Code05_Cute1.java     | 20 ++++++++++++--------
 src/class171/Code05_Cute2.java     | 20 ++++++++++++--------
 src/class171/Code06_Treasure1.java | 20 ++++++++++++--------
 src/class171/Code06_Treasure2.java | 18 +++++++++++-------
 4 files changed, 47 insertions(+), 31 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index a7f244961..6de375ca3 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -135,7 +135,7 @@ public static void clear(int i) {
 		}
 	}
 
-	public static void merge(int l, int m, int r) {
+	public static void merge2(int l, int m, int r) {
 		for (int i = l; i <= r; i++) {
 			tmp2[i] = tmp1[i];
 		}
@@ -166,22 +166,26 @@ public static void cdq2(int l, int r) {
 		}
 		int mid = (l + r) / 2;
 		cdq2(l, mid);
-		merge(l, mid, r);
+		merge2(l, mid, r);
 		cdq2(mid + 1, r);
 	}
 
+	public static void merge1(int l, int m, int r) {
+		for (int i = l; i <= r; i++) {
+			tmp1[i] = arr[i];
+			tmp1[i].left = i <= m;
+		}
+		Arrays.sort(tmp1, l, r + 1, cmp2);
+		cdq2(l, r);
+	}
+
 	public static void cdq1(int l, int r) {
 		if (l == r) {
 			return;
 		}
 		int mid = (l + r) / 2;
 		cdq1(l, mid);
-		for (int i = l; i <= r; i++) {
-			tmp1[i] = arr[i];
-			tmp1[i].left = i <= mid;
-		}
-		Arrays.sort(tmp1, l, r + 1, cmp2);
-		cdq2(l, r);
+		merge1(l, mid, r);
 		cdq1(mid + 1, r);
 	}
 
diff --git a/src/class171/Code05_Cute2.java b/src/class171/Code05_Cute2.java
index 1e65b770c..805ed1d22 100644
--- a/src/class171/Code05_Cute2.java
+++ b/src/class171/Code05_Cute2.java
@@ -83,7 +83,7 @@
 //    }
 //}
 //
-//void merge(int l, int m, int r) {
+//void merge2(int l, int m, int r) {
 //    for (int i = l; i <= r; i++) {
 //        tmp2[i] = tmp1[i];
 //    }
@@ -112,20 +112,24 @@
 //    if (l == r) return;
 //    int mid = (l + r) / 2;
 //    cdq2(l, mid);
-//    merge(l, mid, r);
+//    merge2(l, mid, r);
 //    cdq2(mid + 1, r);
 //}
 //
-//void cdq1(int l, int r) {
-//    if (l == r) return;
-//    int mid = (l + r) / 2;
-//    cdq1(l, mid);
+//void merge1(int l, int m, int r) {
 //    for (int i = l; i <= r; i++) {
 //        tmp1[i] = arr[i];
-//        tmp1[i].left = i <= mid;
-//    }
+//        tmp1[i].left = i <= m;
+//    } 
 //    sort(tmp1 + l, tmp1 + r + 1, Cmp2);
 //    cdq2(l, r);
+//}
+//
+//void cdq1(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq1(l, mid);
+//    merge1(l, mid, r);
 //    cdq1(mid + 1, r);
 //}
 //
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index b3a3a9c6a..306ab1ab2 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -144,7 +144,7 @@ public static void clear(int i) {
 		}
 	}
 
-	public static void merge(int l, int mid, int r) {
+	public static void merge2(int l, int mid, int r) {
 		for (int i = l; i <= r; i++) {
 			tmp2[i] = tmp1[i];
 		}
@@ -182,22 +182,26 @@ public static void cdq2(int l, int r) {
 		}
 		int mid = (l + r) / 2;
 		cdq2(l, mid);
-		merge(l, mid, r);
+		merge2(l, mid, r);
 		cdq2(mid + 1, r);
 	}
 
+	public static void merge1(int l, int m, int r) {
+		for (int i = l; i <= r; i++) {
+			tmp1[i] = arr[i];
+			tmp1[i].left = (i <= m);
+		}
+		Arrays.sort(tmp1, l, r + 1, cmp2);
+		cdq2(l, r);
+	}
+
 	public static void cdq1(int l, int r) {
 		if (l == r) {
 			return;
 		}
 		int mid = (l + r) / 2;
 		cdq1(l, mid);
-		for (int i = l; i <= r; i++) {
-			tmp1[i] = arr[i];
-			tmp1[i].left = (i <= mid);
-		}
-		Arrays.sort(tmp1, l, r + 1, cmp2);
-		cdq2(l, r);
+		merge1(l, mid, r);
 		cdq1(mid + 1, r);
 	}
 
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index c39740ccc..0e62a0fea 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -99,7 +99,7 @@
 //    }
 //}
 //
-//void merge(int l, int m, int r) {
+//void merge2(int l, int m, int r) {
 //    for (int i = l; i <= r; i++) {
 //        tmp2[i] = tmp1[i];
 //    }
@@ -135,20 +135,24 @@
 //    if (l == r) return;
 //    int mid = (l + r) / 2;
 //    cdq2(l, mid);
-//    merge(l, mid, r);
+//    merge2(l, mid, r);
 //    cdq2(mid + 1, r);
 //}
 //
-//void cdq1(int l, int r) {
-//    if (l == r) return;
-//    int mid = (l + r) / 2;
-//    cdq1(l, mid);
+//void merge1(int l, int m, int r) {
 //    for (int i = l; i <= r; i++) {
 //        tmp1[i] = arr[i];
-//        tmp1[i].left = (i <= mid);
+//        tmp1[i].left = (i <= m);
 //    }
 //    sort(tmp1 + l, tmp1 + r + 1, Cmp2);
 //    cdq2(l, r);
+//}
+//
+//void cdq1(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq1(l, mid);
+//    merge1(l, mid, r);
 //    cdq1(mid + 1, r);
 //}
 //

From c64b9510cd16538b5c5b0c54b9080c6243bcbf96 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 7 Jun 2025 15:51:25 +0800
Subject: [PATCH 0937/1712] modify code

---
 src/class171/Code05_Cute1.java     | 24 ++++++++++++------------
 src/class171/Code05_Cute2.java     | 18 +++++++-----------
 src/class171/Code06_Treasure1.java | 20 ++++++++------------
 src/class171/Code06_Treasure2.java | 18 +++++++-----------
 4 files changed, 34 insertions(+), 46 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index 6de375ca3..c477bca37 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -135,7 +135,7 @@ public static void clear(int i) {
 		}
 	}
 
-	public static void merge2(int l, int m, int r) {
+	public static void merge(int l, int m, int r) {
 		for (int i = l; i <= r; i++) {
 			tmp2[i] = tmp1[i];
 		}
@@ -160,32 +160,32 @@ public static void merge2(int l, int m, int r) {
 		}
 	}
 
+	// tmp1[l..r]中所有对象根据b属性值稳定排序了
+	// 有些对象的dp值已经计算，left = true
+	// 有些对象的dp值还没计算，left = false
+	// 计算过的对象，去更新，还没计算出的对象dp值
 	public static void cdq2(int l, int r) {
 		if (l == r) {
 			return;
 		}
 		int mid = (l + r) / 2;
 		cdq2(l, mid);
-		merge2(l, mid, r);
+		merge(l, mid, r);
 		cdq2(mid + 1, r);
 	}
 
-	public static void merge1(int l, int m, int r) {
-		for (int i = l; i <= r; i++) {
-			tmp1[i] = arr[i];
-			tmp1[i].left = i <= m;
-		}
-		Arrays.sort(tmp1, l, r + 1, cmp2);
-		cdq2(l, r);
-	}
-
 	public static void cdq1(int l, int r) {
 		if (l == r) {
 			return;
 		}
 		int mid = (l + r) / 2;
 		cdq1(l, mid);
-		merge1(l, mid, r);
+		for (int i = l; i <= r; i++) {
+			tmp1[i] = arr[i];
+			tmp1[i].left = i <= mid;
+		}
+		Arrays.sort(tmp1, l, r + 1, cmp2);
+		cdq2(l, r);
 		cdq1(mid + 1, r);
 	}
 
diff --git a/src/class171/Code05_Cute2.java b/src/class171/Code05_Cute2.java
index 805ed1d22..1d724d843 100644
--- a/src/class171/Code05_Cute2.java
+++ b/src/class171/Code05_Cute2.java
@@ -83,7 +83,7 @@
 //    }
 //}
 //
-//void merge2(int l, int m, int r) {
+//void merge(int l, int m, int r) {
 //    for (int i = l; i <= r; i++) {
 //        tmp2[i] = tmp1[i];
 //    }
@@ -112,24 +112,20 @@
 //    if (l == r) return;
 //    int mid = (l + r) / 2;
 //    cdq2(l, mid);
-//    merge2(l, mid, r);
+//    merge(l, mid, r);
 //    cdq2(mid + 1, r);
 //}
 //
-//void merge1(int l, int m, int r) {
+//void cdq1(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq1(l, mid);
 //    for (int i = l; i <= r; i++) {
 //        tmp1[i] = arr[i];
-//        tmp1[i].left = i <= m;
+//        tmp1[i].left = i <= mid;
 //    } 
 //    sort(tmp1 + l, tmp1 + r + 1, Cmp2);
 //    cdq2(l, r);
-//}
-//
-//void cdq1(int l, int r) {
-//    if (l == r) return;
-//    int mid = (l + r) / 2;
-//    cdq1(l, mid);
-//    merge1(l, mid, r);
 //    cdq1(mid + 1, r);
 //}
 //
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index 306ab1ab2..5968be915 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -144,7 +144,7 @@ public static void clear(int i) {
 		}
 	}
 
-	public static void merge2(int l, int mid, int r) {
+	public static void merge(int l, int mid, int r) {
 		for (int i = l; i <= r; i++) {
 			tmp2[i] = tmp1[i];
 		}
@@ -182,26 +182,22 @@ public static void cdq2(int l, int r) {
 		}
 		int mid = (l + r) / 2;
 		cdq2(l, mid);
-		merge2(l, mid, r);
+		merge(l, mid, r);
 		cdq2(mid + 1, r);
 	}
 
-	public static void merge1(int l, int m, int r) {
-		for (int i = l; i <= r; i++) {
-			tmp1[i] = arr[i];
-			tmp1[i].left = (i <= m);
-		}
-		Arrays.sort(tmp1, l, r + 1, cmp2);
-		cdq2(l, r);
-	}
-
 	public static void cdq1(int l, int r) {
 		if (l == r) {
 			return;
 		}
 		int mid = (l + r) / 2;
 		cdq1(l, mid);
-		merge1(l, mid, r);
+		for (int i = l; i <= r; i++) {
+			tmp1[i] = arr[i];
+			tmp1[i].left = i <= mid;
+		}
+		Arrays.sort(tmp1, l, r + 1, cmp2);
+		cdq2(l, r);
 		cdq1(mid + 1, r);
 	}
 
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index 0e62a0fea..c2c8335c2 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -99,7 +99,7 @@
 //    }
 //}
 //
-//void merge2(int l, int m, int r) {
+//void merge(int l, int m, int r) {
 //    for (int i = l; i <= r; i++) {
 //        tmp2[i] = tmp1[i];
 //    }
@@ -135,24 +135,20 @@
 //    if (l == r) return;
 //    int mid = (l + r) / 2;
 //    cdq2(l, mid);
-//    merge2(l, mid, r);
+//    merge(l, mid, r);
 //    cdq2(mid + 1, r);
 //}
 //
-//void merge1(int l, int m, int r) {
+//void cdq1(int l, int r) {
+//    if (l == r) return;
+//    int mid = (l + r) / 2;
+//    cdq1(l, mid);
 //    for (int i = l; i <= r; i++) {
 //        tmp1[i] = arr[i];
-//        tmp1[i].left = (i <= m);
+//        tmp1[i].left = i <= mid;
 //    }
 //    sort(tmp1 + l, tmp1 + r + 1, Cmp2);
 //    cdq2(l, r);
-//}
-//
-//void cdq1(int l, int r) {
-//    if (l == r) return;
-//    int mid = (l + r) / 2;
-//    cdq1(l, mid);
-//    merge1(l, mid, r);
 //    cdq1(mid + 1, r);
 //}
 //

From dc3a900be66fc5d18d2d1841f73a2d4f57a115bf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 7 Jun 2025 21:00:10 +0800
Subject: [PATCH 0938/1712] modify code

---
 src/class171/Code05_Cute1.java     | 4 ++--
 src/class171/Code06_Treasure1.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index c477bca37..5334aee96 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -57,7 +57,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 需要排序的稳定性
+	// 需要稳定排序
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
@@ -74,7 +74,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 需要排序的稳定性
+	// 需要稳定排序
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index 5968be915..c157adff6 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -49,7 +49,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 需要排序的稳定性
+	// 需要稳定排序
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
@@ -66,7 +66,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 需要排序的稳定性
+	// 需要稳定排序
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {

From 5331885e002de18e10cb2454a722460f513491ec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 8 Jun 2025 15:04:04 +0800
Subject: [PATCH 0939/1712] modify code

---
 src/class171/Code05_Cute1.java     | 26 +++++++-------------------
 src/class171/Code05_Cute2.java     |  8 ++------
 src/class171/Code06_Treasure1.java | 20 ++++----------------
 src/class171/Code06_Treasure2.java |  8 ++------
 4 files changed, 15 insertions(+), 47 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index 5334aee96..39747a188 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -57,37 +57,25 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 需要稳定排序
+	// 根据属性b进行稳定排序
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.b != y.b) {
 				return x.b - y.b;
 			}
-			if (x.c != y.c) {
-				return x.c - y.c;
-			}
-			if (x.d != y.d) {
-				return x.d - y.d;
-			}
-			return x.a - y.a;
+			return x.i - y.i;
 		}
 	}
 
-	// 需要稳定排序
+	// 根据属性c进行稳定排序
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.c != y.c) {
 				return x.c - y.c;
 			}
-			if (x.d != y.d) {
-				return x.d - y.d;
-			}
-			if (x.a != y.a) {
-				return x.a - y.a;
-			}
-			return x.b - y.b;
+			return x.i - y.i;
 		}
 	}
 
@@ -161,9 +149,9 @@ public static void merge(int l, int m, int r) {
 	}
 
 	// tmp1[l..r]中所有对象根据b属性值稳定排序了
-	// 有些对象的dp值已经计算，left = true
-	// 有些对象的dp值还没计算，left = false
-	// 计算过的对象，去更新，还没计算出的对象dp值
+	// dp值已经计算过的对象，left = true
+	// dp值还没计算过的对象，left = false
+	// 计算过的对象，去更新，还没还没计算过对象的dp值
 	public static void cdq2(int l, int r) {
 		if (l == r) {
 			return;
diff --git a/src/class171/Code05_Cute2.java b/src/class171/Code05_Cute2.java
index 1d724d843..21cc5e3c4 100644
--- a/src/class171/Code05_Cute2.java
+++ b/src/class171/Code05_Cute2.java
@@ -32,16 +32,12 @@
 //
 //bool Cmp2(Node x, Node y) {
 //    if (x.b != y.b) return x.b < y.b;
-//    if (x.c != y.c) return x.c < y.c;
-//    if (x.d != y.d) return x.d < y.d;
-//    return x.a < y.a;
+//    return x.i < y.i;
 //}
 //
 //bool Cmp3(Node x, Node y) {
 //    if (x.c != y.c) return x.c < y.c;
-//    if (x.d != y.d) return x.d < y.d;
-//    if (x.a != y.a) return x.a < y.a;
-//    return x.b < y.b;
+//    return x.i < y.i;
 //}
 //
 //const int MAXN = 50001;
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index c157adff6..ab4d6615d 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -49,37 +49,25 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 需要稳定排序
+	// 根据属性b进行稳定排序
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.b != y.b) {
 				return x.b - y.b;
 			}
-			if (x.c != y.c) {
-				return x.c - y.c;
-			}
-			if (x.d != y.d) {
-				return x.d - y.d;
-			}
-			return x.a - y.a;
+			return x.i - y.i;
 		}
 	}
 
-	// 需要稳定排序
+	// 根据属性c进行稳定排序
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
 			if (x.c != y.c) {
 				return x.c - y.c;
 			}
-			if (x.d != y.d) {
-				return x.d - y.d;
-			}
-			if (x.a != y.a) {
-				return x.a - y.a;
-			}
-			return x.b - y.b;
+			return x.i - y.i;
 		}
 	}
 
diff --git a/src/class171/Code06_Treasure2.java b/src/class171/Code06_Treasure2.java
index c2c8335c2..a586e54b8 100644
--- a/src/class171/Code06_Treasure2.java
+++ b/src/class171/Code06_Treasure2.java
@@ -30,16 +30,12 @@
 //
 //bool Cmp2(Node x, Node y) {
 //    if (x.b != y.b) return x.b < y.b;
-//    if (x.c != y.c) return x.c < y.c;
-//    if (x.d != y.d) return x.d < y.d;
-//    return x.a < y.a;
+//    return x.i < y.i;
 //}
 //
 //bool Cmp3(Node x, Node y) {
 //    if (x.c != y.c) return x.c < y.c;
-//    if (x.d != y.d) return x.d < y.d;
-//    if (x.a != y.a) return x.a < y.a;
-//    return x.b < y.b;
+//    return x.i < y.i;
 //}
 //
 //const int MAXN = 80001;

From a9a4c31de5a709b88f08a9081f1ea7c751353ef9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 8 Jun 2025 15:15:22 +0800
Subject: [PATCH 0940/1712] modify code

---
 src/class171/Code05_Cute1.java     | 4 ++--
 src/class171/Code06_Treasure1.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index 39747a188..5559690ad 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -57,7 +57,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 根据属性b进行稳定排序
+	// 根据属性c进行排序，b一样的对象，保持原始次序
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
@@ -68,7 +68,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 根据属性c进行稳定排序
+	// 根据属性c进行排序，c一样的对象，保持原始次序
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
diff --git a/src/class171/Code06_Treasure1.java b/src/class171/Code06_Treasure1.java
index ab4d6615d..db7b9c61f 100644
--- a/src/class171/Code06_Treasure1.java
+++ b/src/class171/Code06_Treasure1.java
@@ -49,7 +49,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 根据属性b进行稳定排序
+	// 根据属性b进行排序，b一样的对象，保持原始次序
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
@@ -60,7 +60,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 根据属性c进行稳定排序
+	// 根据属性c进行排序，c一样的对象，保持原始次序
 	public static class Cmp3 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {

From a6e420fe3b0d0cfc183191003e179f202684eb76 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 8 Jun 2025 16:27:25 +0800
Subject: [PATCH 0941/1712] modify code

---
 src/class171/Code01_MooFest1.java | 10 +++++-----
 src/class171/Code01_MooFest2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class171/Code01_MooFest1.java b/src/class171/Code01_MooFest1.java
index 0705956d0..0a41b927d 100644
--- a/src/class171/Code01_MooFest1.java
+++ b/src/class171/Code01_MooFest1.java
@@ -30,17 +30,17 @@ public static void clone(int[] a, int[] b) {
 
 	public static long merge(int l, int m, int r) {
 		int p1, p2;
-		long sum1 = 0, sum2 = 0, ans = 0;
+		long rsum = 0, lsum = 0, ans = 0;
 		for (p1 = l; p1 <= m; p1++) {
-			sum1 += arr[p1][1];
+			rsum += arr[p1][1];
 		}
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][1] < arr[p2][1]) {
 				p1++;
-				sum1 -= arr[p1][1];
-				sum2 += arr[p1][1];
+				rsum -= arr[p1][1];
+				lsum += arr[p1][1];
 			}
-			ans += (1L * (p1 - l + 1) * arr[p2][1] - sum2 + sum1 - 1L * (m - p1) * arr[p2][1]) * arr[p2][0];
+			ans += (1L * (p1 - l + 1) * arr[p2][1] - lsum + rsum - 1L * (m - p1) * arr[p2][1]) * arr[p2][0];
 		}
 		p1 = l;
 		p2 = m + 1;
diff --git a/src/class171/Code01_MooFest2.java b/src/class171/Code01_MooFest2.java
index f101326c0..e32af0716 100644
--- a/src/class171/Code01_MooFest2.java
+++ b/src/class171/Code01_MooFest2.java
@@ -28,17 +28,17 @@
 //
 //long long merge(int l, int m, int r) {
 //    int p1, p2;
-//    long long sum1 = 0, sum2 = 0, ans = 0;
+//    long long rsum = 0, lsum = 0, ans = 0;
 //    for (p1 = l; p1 <= m; p1++) {
-//        sum1 += arr[p1].x;
+//        rsum += arr[p1].x;
 //    }
 //    for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 //        while (p1 + 1 <= m && arr[p1 + 1].x < arr[p2].x) {
 //            p1++;
-//            sum1 -= arr[p1].x;
-//            sum2 += arr[p1].x;
+//            rsum -= arr[p1].x;
+//            lsum += arr[p1].x;
 //        }
-//        ans += (1LL * (p1 - l + 1) * arr[p2].x - sum2 + sum1 - 1LL * (m - p1) * arr[p2].x) * arr[p2].v;
+//        ans += (1LL * (p1 - l + 1) * arr[p2].x - lsum + rsum - 1LL * (m - p1) * arr[p2].x) * arr[p2].v;
 //    }
 //    p1 = l;
 //    p2 = m + 1;

From d3713c4a5c96745115a1c8949253f86f47463439 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 8 Jun 2025 18:17:03 +0800
Subject: [PATCH 0942/1712] modify code

---
 src/class171/Code02_AiRobots1.java | 2 +-
 src/class171/Code02_AiRobots2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class171/Code02_AiRobots1.java b/src/class171/Code02_AiRobots1.java
index ed44087e0..3309d66d7 100644
--- a/src/class171/Code02_AiRobots1.java
+++ b/src/class171/Code02_AiRobots1.java
@@ -1,7 +1,7 @@
 package class171;
 
 // 机器人聊天对，java版
-// 一共有n个机器人，每个机器人给定，位置x、视野y、智商q
+// 一共有n个机器人，给定一个整数k，每个机器人给定，位置x、视野y、智商q
 // 第i个机器人可以看见的范围是[xi − yi, xi + yi]
 // 如果两个机器人相互之间可以看见，并且智商差距不大于k，那么它们会开始聊天
 // 打印有多少对机器人可以聊天
diff --git a/src/class171/Code02_AiRobots2.java b/src/class171/Code02_AiRobots2.java
index fdf28ca16..dd7f45f1a 100644
--- a/src/class171/Code02_AiRobots2.java
+++ b/src/class171/Code02_AiRobots2.java
@@ -1,7 +1,7 @@
 package class171;
 
 // 机器人聊天对，C++版
-// 一共有n个机器人，每个机器人给定，位置x、视野y、智商q
+// 一共有n个机器人，给定一个整数k，每个机器人给定，位置x、视野y、智商q
 // 第i个机器人可以看见的范围是[xi − yi, xi + yi]
 // 如果两个机器人相互之间可以看见，并且智商差距不大于k，那么它们会开始聊天
 // 打印有多少对机器人可以聊天

From 7f488624af18a5fe3472f159fba056a575f460d4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 8 Jun 2025 18:40:56 +0800
Subject: [PATCH 0943/1712] modify code

---
 src/class171/Code02_AiRobots1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class171/Code02_AiRobots1.java b/src/class171/Code02_AiRobots1.java
index 3309d66d7..dc6c1f18d 100644
--- a/src/class171/Code02_AiRobots1.java
+++ b/src/class171/Code02_AiRobots1.java
@@ -23,7 +23,7 @@ public class Code02_AiRobots1 {
 	public static int MAXN = 100001;
 	public static int n, k, s;
 
-	// 位置x、视野y、智商q、左边界l、右边界r
+	// 位置x、视野y、智商q、能看到的最左位置l、能看到的最右位置r
 	public static int[][] arr = new int[MAXN][5];
 	// 所有x坐标组成的数组
 	public static int[] x = new int[MAXN];

From dadcf3b303a6da5b27266ddc32755723db8a821c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 8 Jun 2025 20:13:28 +0800
Subject: [PATCH 0944/1712] modify code

---
 src/class171/Code03_Sequence1.java | 5 -----
 1 file changed, 5 deletions(-)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index 8ddf9073f..e134f70a7 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -82,11 +82,6 @@ public static void cdq(int l, int r) {
 			return;
 		}
 		int mid = (l + r) / 2;
-		// 为什么顺序是左、merge、右，而不是经典顺序，左、右、merge？
-		// 因为右侧dp的计算依赖左侧dp的结果
-		// 需要先处理左侧范围，得到部分状态转移的可能性
-		// 然后把左侧dp结果推送到右侧，右侧先获得这些结果
-		// 在此基础上，最后处理右侧范围，才能把右侧dp计算正确
 		cdq(l, mid);
 		merge(l, mid, r);
 		cdq(mid + 1, r);

From c5461f4db6bafc6e317b1d9dd78bbf3c57706740 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 8 Jun 2025 22:41:46 +0800
Subject: [PATCH 0945/1712] modify code

---
 src/class171/Code03_Sequence1.java    | 9 +++++++++
 src/class171/Code04_Interceptor1.java | 3 +++
 2 files changed, 12 insertions(+)

diff --git a/src/class171/Code03_Sequence1.java b/src/class171/Code03_Sequence1.java
index e134f70a7..4ee27515e 100644
--- a/src/class171/Code03_Sequence1.java
+++ b/src/class171/Code03_Sequence1.java
@@ -25,6 +25,7 @@ public class Code03_Sequence1 {
 
 	// 位置i、数值v、最小值lv、最大值rv
 	public static int[][] arr = new int[MAXN][4];
+	// 树状数组维护前缀最大值
 	public static int[] tree = new int[MAXN];
 	public static int[] dp = new int[MAXN];
 
@@ -56,22 +57,30 @@ public static void clear(int i) {
 	}
 
 	public static void merge(int l, int m, int r) {
+		// 辅助数组arr拷贝l..r所有的对象
+		// 接下来的排序都发生在arr中，不影响原始的次序
 		for (int i = l; i <= r; i++) {
 			arr[i][0] = i;
 			arr[i][1] = v[i];
 			arr[i][2] = lv[i];
 			arr[i][3] = rv[i];
 		}
+		// 左侧根据v排序
 		Arrays.sort(arr, l, m + 1, (a, b) -> a[1] - b[1]);
+		// 右侧根据lv排序
 		Arrays.sort(arr, m + 1, r + 1, (a, b) -> a[2] - b[2]);
 		int p1, p2;
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
+			// 左侧对象.v <= 右侧对象.lv 窗口扩充
 			while (p1 + 1 <= m && arr[p1 + 1][1] <= arr[p2][2]) {
 				p1++;
+				// 树状数组中，下标是rv，加入的值是左侧对象的dp值
 				more(arr[p1][3], dp[arr[p1][0]]);
 			}
+			// 右侧对象更新dp值，查出1..v范围上最大的dp值 + 1
 			dp[arr[p2][0]] = Math.max(dp[arr[p2][0]], query(arr[p2][1]) + 1);
 		}
+		// 清空树状数组
 		for (int i = l; i <= p1; i++) {
 			clear(arr[i][3]);
 		}
diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
index 60955ea10..a0dcc28cc 100644
--- a/src/class171/Code04_Interceptor1.java
+++ b/src/class171/Code04_Interceptor1.java
@@ -28,12 +28,15 @@ public class Code04_Interceptor1 {
 	// 位置i、高度h、速度v
 	public static int[][] arr = new int[MAXN][3];
 
+	// 树状数组维护前缀最大值、最大值出现的次数
 	public static int[] treeVal = new int[MAXN];
 	public static double[] treeCnt = new double[MAXN];
 
+	// i位置结尾的情况下，最长不上升子序列的长度 及其 子序列个数
 	public static int[] len1 = new int[MAXN];
 	public static double[] cnt1 = new double[MAXN];
 
+	// i位置开头的情况下，最长不上升子序列的长度 及其 子序列个数
 	public static int[] len2 = new int[MAXN];
 	public static double[] cnt2 = new double[MAXN];
 

From 894dea001441be04c0f446f17a4c8b8d10f6ebe6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Jun 2025 16:43:27 +0800
Subject: [PATCH 0946/1712] modify code

---
 src/class171/Code04_Interceptor1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class171/Code04_Interceptor1.java b/src/class171/Code04_Interceptor1.java
index a0dcc28cc..22a4ba8a6 100644
--- a/src/class171/Code04_Interceptor1.java
+++ b/src/class171/Code04_Interceptor1.java
@@ -90,6 +90,7 @@ public static void merge1(int l, int m, int r) {
 		Arrays.sort(arr, l, m + 1, (a, b) -> b[1] - a[1]);
 		Arrays.sort(arr, m + 1, r + 1, (a, b) -> b[1] - a[1]);
 		int p1, p2;
+		// 为了防止出现0下标，(s - v + 1)是树状数组的下标
 		for (p1 = l - 1, p2 = m + 1; p2 <= r; p2++) {
 			while (p1 + 1 <= m && arr[p1 + 1][1] >= arr[p2][1]) {
 				p1++;
@@ -108,6 +109,7 @@ public static void merge1(int l, int m, int r) {
 		}
 	}
 
+	// 最长不上升子序列的长度 及其 个数
 	public static void cdq1(int l, int r) {
 		if (l == r) {
 			return;
@@ -145,6 +147,7 @@ public static void merge2(int l, int m, int r) {
 		}
 	}
 
+	// 最长不下降子序列的长度 及其 个数
 	public static void cdq2(int l, int r) {
 		if (l == r) {
 			return;

From dc828378ee3ebfee13a3841eafc3381ebced281d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Jun 2025 19:13:50 +0800
Subject: [PATCH 0947/1712] modify code

---
 src/class171/Code05_Cute1.java | 15 ++++++++++-----
 1 file changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/class171/Code05_Cute1.java b/src/class171/Code05_Cute1.java
index 5559690ad..bbc6b82e7 100644
--- a/src/class171/Code05_Cute1.java
+++ b/src/class171/Code05_Cute1.java
@@ -27,7 +27,7 @@ public static class Node {
 		int a, b, c, d;
 		int i;
 		long v;
-		boolean left;
+		boolean left; // 是否是原左组的对象
 
 		public Node(int a_, int b_, int c_, int d_, long v_) {
 			a = a_;
@@ -57,7 +57,7 @@ public int compare(Node x, Node y) {
 		}
 	}
 
-	// 根据属性c进行排序，b一样的对象，保持原始次序
+	// 根据属性b进行排序，b一样的对象，保持原始次序
 	public static class Cmp2 implements Comparator<Node> {
 		@Override
 		public int compare(Node x, Node y) {
@@ -88,12 +88,19 @@ public int compare(Node x, Node y) {
 	public static int n, s;
 
 	public static Node[] arr = new Node[MAXN];
+
 	public static int[] sortd = new int[MAXN];
 
+	// 根据b重排时，准备的辅助数组，不改变原始次序
 	public static Node[] tmp1 = new Node[MAXN];
+
+	// 根据c重排时，准备的辅助数组，不改变原始次序
 	public static Node[] tmp2 = new Node[MAXN];
 
+	// 树状数组，维护前缀最大值
 	public static long[] tree = new long[MAXN];
+
+	// dp[i]表示i号怪兽最后杀死的情况下，最大的收益
 	public static long[] dp = new long[MAXN];
 
 	public static int lowbit(int i) {
@@ -149,9 +156,7 @@ public static void merge(int l, int m, int r) {
 	}
 
 	// tmp1[l..r]中所有对象根据b属性值稳定排序了
-	// dp值已经计算过的对象，left = true
-	// dp值还没计算过的对象，left = false
-	// 计算过的对象，去更新，还没还没计算过对象的dp值
+	// 让每个原左组的对象影响到后面每个原右组对象(更新dp)
 	public static void cdq2(int l, int r) {
 		if (l == r) {
 			return;

From 489ddd9d2f479fe0b04d7f07372e9bf54ac249ff Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 9 Jun 2025 19:42:20 +0800
Subject: [PATCH 0948/1712] modify code

---
 ...Q\345\210\206\346\262\273-\344\270\213.pptx" | Bin 0 -> 50426 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243171\343\200\220\346\214\272\351\232\276\343\200\221CDQ\345\210\206\346\262\273-\344\270\213.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243171\343\200\220\346\214\272\351\232\276\343\200\221CDQ\345\210\206\346\262\273-\344\270\213.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243171\343\200\220\346\214\272\351\232\276\343\200\221CDQ\345\210\206\346\262\273-\344\270\213.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..2418474b4b6b46a1b7c4c9fe0c81af608534c8de
GIT binary patch
literal 50426
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
EKM^dxbpQYW

literal 0
HcmV?d00001


From 1f6de205ca9a10ea5e1182b7dfd5ddd724fc34c5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 11 Jun 2025 20:41:43 +0800
Subject: [PATCH 0949/1712] modify code

---
 src/class157/Code03_RangePersistentClassic1.java | 2 +-
 src/class157/Code03_RangePersistentClassic2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class157/Code03_RangePersistentClassic1.java b/src/class157/Code03_RangePersistentClassic1.java
index 6fe9f1dfe..507235fc1 100644
--- a/src/class157/Code03_RangePersistentClassic1.java
+++ b/src/class157/Code03_RangePersistentClassic1.java
@@ -10,7 +10,7 @@
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP11470
-// 测试链接 : https://www.spoj.com/problems/TTM/
+// 测试链接 : https://www.spoj.com/problems/TTM
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是通过不了
 // 因为这道题根据C++的运行时间，制定通过标准，根本没考虑java的用户
diff --git a/src/class157/Code03_RangePersistentClassic2.java b/src/class157/Code03_RangePersistentClassic2.java
index 3ae4ab33d..fd08cae91 100644
--- a/src/class157/Code03_RangePersistentClassic2.java
+++ b/src/class157/Code03_RangePersistentClassic2.java
@@ -10,7 +10,7 @@
 // 1 <= n、m <= 10^5
 // -10^9 <= arr[i] <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP11470
-// 测试链接 : https://www.spoj.com/problems/TTM/
+// 测试链接 : https://www.spoj.com/problems/TTM
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 

From afc0cb16c446540e25cf9dfbb9a3fef532b0e898 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Jun 2025 18:00:20 +0800
Subject: [PATCH 0950/1712] modify code

---
 src/class172/Code01_GiveAway1.java | 158 +++++++++++++++++++++++++++++
 src/class172/Code01_GiveAway2.java | 111 ++++++++++++++++++++
 2 files changed, 269 insertions(+)
 create mode 100644 src/class172/Code01_GiveAway1.java
 create mode 100644 src/class172/Code01_GiveAway2.java

diff --git a/src/class172/Code01_GiveAway1.java b/src/class172/Code01_GiveAway1.java
new file mode 100644
index 000000000..c0e109428
--- /dev/null
+++ b/src/class172/Code01_GiveAway1.java
@@ -0,0 +1,158 @@
+package class172;
+
+// 区间内>=C的个数，java版
+// 测试链接 : https://www.luogu.com.cn/problem/SP18185
+// 测试链接 : https://www.spoj.com/problems/GIVEAWAY
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_GiveAway1 {
+
+	public static int MAXN = 500001;
+	public static int MAXB = 1001;
+	public static int n, m;
+	public static int blen, bnum;
+	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+	public static int[] sortv = new int[MAXN];
+
+	public static void build() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1, l = 1, r = blen; i <= bnum; i++, l += blen, r += blen) {
+			r = Math.min(r, n);
+			for (int j = l; j <= r; j++) {
+				bi[j] = i;
+			}
+			bl[i] = l;
+			br[i] = r;
+		}
+		for (int i = 1; i <= n; i++) {
+			sortv[i] = arr[i];
+		}
+		for (int i = 1; i <= bnum; i++) {
+			Arrays.sort(sortv, bl[i], br[i] + 1);
+		}
+	}
+
+	public static int num(int bid, int v) {
+		int l = bl[bid], r = br[bid], m, ans = 0;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (sortv[m] >= v) {
+				ans += r - m + 1;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static int query(int l, int r, int v) {
+		int ans = 0;
+		if (bi[l] == bi[r]) {
+			for (int i = l; i <= r; i++) {
+				if (arr[i] >= v) {
+					ans++;
+				}
+			}
+		} else {
+			for (int i = l; i <= br[bi[l]]; i++) {
+				if (arr[i] >= v) {
+					ans++;
+				}
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				if (arr[i] >= v) {
+					ans++;
+				}
+			}
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				ans += num(i, v);
+			}
+		}
+		return ans;
+	}
+
+	public static void update(int i, int v) {
+		int l = bl[bi[i]];
+		int r = br[bi[i]];
+		arr[i] = v;
+		for (int j = l; j <= r; j++) {
+			sortv[j] = arr[j];
+		}
+		Arrays.sort(sortv, l, r + 1);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		build();
+		m = in.nextInt();
+		for (int i = 1, op, a, b, c; i <= m; i++) {
+			op = in.nextInt();
+			a = in.nextInt();
+			b = in.nextInt();
+			if (op == 0) {
+				c = in.nextInt();
+				out.println(query(a, b, c));
+			} else {
+				update(a, b);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class172/Code01_GiveAway2.java b/src/class172/Code01_GiveAway2.java
new file mode 100644
index 000000000..e7686555f
--- /dev/null
+++ b/src/class172/Code01_GiveAway2.java
@@ -0,0 +1,111 @@
+package class172;
+
+// 区间内>=C的个数，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/SP18185
+// 测试链接 : https://www.spoj.com/problems/GIVEAWAY
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//const int MAXB = 1001;
+//int n, m;
+//int blen, bnum;
+//int arr[MAXN];
+//int bi[MAXN];
+//int bl[MAXB], br[MAXB];
+//int sortv[MAXN];
+//
+//void build() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1, l = 1, r = blen; i <= bnum; i++, l += blen, r += blen) {
+//        r = min(r, n);
+//        for (int j = l; j <= r; j++) {
+//            bi[j] = i;
+//        }
+//        bl[i] = l;
+//        br[i] = r;
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        sortv[i] = arr[i];
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        sort(sortv + bl[i], sortv + br[i] + 1);
+//    }
+//}
+//
+//int num(int bid, int v) {
+//    int l = bl[bid], r = br[bid], m, ans = 0;
+//    while (l <= r) {
+//        m = (l + r) >> 1;
+//        if (sortv[m] >= v) {
+//            ans += r - m + 1;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int query(int l, int r, int v) {
+//    int ans = 0;
+//    if (bi[l] == bi[r]) {
+//        for (int i = l; i <= r; i++) {
+//            if (arr[i] >= v) {
+//                ans++;
+//            }
+//        }
+//    } else {
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            if (arr[i] >= v) {
+//                ans++;
+//            }
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            if (arr[i] >= v) {
+//                ans++;
+//            }
+//        }
+//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+//            ans += num(i, v);
+//        }
+//    }
+//    return ans;
+//}
+//
+//void update(int i, int v) {
+//    int l = bl[bi[i]];
+//    int r = br[bi[i]];
+//    arr[i] = v;
+//    for (int j = l; j <= r; j++) {
+//        sortv[j] = arr[j];
+//    }
+//    sort(sortv + l, sortv + r + 1);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    build();
+//    cin >> m;
+//    int op, a, b, c;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op >> a >> b;
+//        if (op == 0) {
+//            cin >> c;
+//            cout << query(a, b, c) << '\n';
+//        } else {
+//            update(a, b);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 1a6188821dd40c7af7e38d91ccacbce1b0ca6b98 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Jun 2025 18:01:47 +0800
Subject: [PATCH 0951/1712] modify code

---
 src/class172/Code01_GiveAway1.java | 2 +-
 src/class172/Code01_GiveAway2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class172/Code01_GiveAway1.java b/src/class172/Code01_GiveAway1.java
index c0e109428..4f0dbe3e0 100644
--- a/src/class172/Code01_GiveAway1.java
+++ b/src/class172/Code01_GiveAway1.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 区间内>=C的个数，java版
+// 区间内>=的个数，java版
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class172/Code01_GiveAway2.java b/src/class172/Code01_GiveAway2.java
index e7686555f..cc4ca0052 100644
--- a/src/class172/Code01_GiveAway2.java
+++ b/src/class172/Code01_GiveAway2.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 区间内>=C的个数，C++版
+// 区间内>=的个数，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From feef84556f6e756d82471b9ec48f318828c2d93c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Jun 2025 18:03:21 +0800
Subject: [PATCH 0952/1712] modify code

---
 src/class172/Code01_GiveAway1.java | 2 +-
 src/class172/Code01_GiveAway2.java | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class172/Code01_GiveAway1.java b/src/class172/Code01_GiveAway1.java
index 4f0dbe3e0..3f9163677 100644
--- a/src/class172/Code01_GiveAway1.java
+++ b/src/class172/Code01_GiveAway1.java
@@ -45,7 +45,7 @@ public static void build() {
 	public static int num(int bid, int v) {
 		int l = bl[bid], r = br[bid], m, ans = 0;
 		while (l <= r) {
-			m = (l + r) / 2;
+			m = (l + r) >> 1;
 			if (sortv[m] >= v) {
 				ans += r - m + 1;
 				r = m - 1;
diff --git a/src/class172/Code01_GiveAway2.java b/src/class172/Code01_GiveAway2.java
index cc4ca0052..e27d8e746 100644
--- a/src/class172/Code01_GiveAway2.java
+++ b/src/class172/Code01_GiveAway2.java
@@ -16,7 +16,8 @@
 //int blen, bnum;
 //int arr[MAXN];
 //int bi[MAXN];
-//int bl[MAXB], br[MAXB];
+//int bl[MAXB];
+//int br[MAXB];
 //int sortv[MAXN];
 //
 //void build() {

From 2074a56a930d594e1b5660c45cfbeb581f7a846a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 12 Jun 2025 21:57:44 +0800
Subject: [PATCH 0953/1712] modify code

---
 src/class172/Code01_GiveAway1.java |  26 ++--
 src/class172/Code01_GiveAway2.java |  26 ++--
 src/class172/Code02_Magic1.java    | 197 +++++++++++++++++++++++++++++
 src/class172/Code02_Magic2.java    | 123 ++++++++++++++++++
 4 files changed, 346 insertions(+), 26 deletions(-)
 create mode 100644 src/class172/Code02_Magic1.java
 create mode 100644 src/class172/Code02_Magic2.java

diff --git a/src/class172/Code01_GiveAway1.java b/src/class172/Code01_GiveAway1.java
index 3f9163677..1e3a36673 100644
--- a/src/class172/Code01_GiveAway1.java
+++ b/src/class172/Code01_GiveAway1.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 区间内>=的个数，java版
+// 单点修改区间查询，java版
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -16,23 +16,23 @@ public class Code01_GiveAway1 {
 	public static int MAXN = 500001;
 	public static int MAXB = 1001;
 	public static int n, m;
-	public static int blen, bnum;
 	public static int[] arr = new int[MAXN];
+	public static int[] sortv = new int[MAXN];
+
+	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
-	public static int[] sortv = new int[MAXN];
 
 	public static void build() {
 		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
-		for (int i = 1, l = 1, r = blen; i <= bnum; i++, l += blen, r += blen) {
-			r = Math.min(r, n);
-			for (int j = l; j <= r; j++) {
-				bi[j] = i;
-			}
-			bl[i] = l;
-			br[i] = r;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
 		}
 		for (int i = 1; i <= n; i++) {
 			sortv[i] = arr[i];
@@ -42,8 +42,8 @@ public static void build() {
 		}
 	}
 
-	public static int num(int bid, int v) {
-		int l = bl[bid], r = br[bid], m, ans = 0;
+	public static int num(int l, int r, int v) {
+		int m, ans = 0;
 		while (l <= r) {
 			m = (l + r) >> 1;
 			if (sortv[m] >= v) {
@@ -76,7 +76,7 @@ public static int query(int l, int r, int v) {
 				}
 			}
 			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-				ans += num(i, v);
+				ans += num(bl[i], br[i], v);
 			}
 		}
 		return ans;
diff --git a/src/class172/Code01_GiveAway2.java b/src/class172/Code01_GiveAway2.java
index e27d8e746..014eb7cbc 100644
--- a/src/class172/Code01_GiveAway2.java
+++ b/src/class172/Code01_GiveAway2.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 区间内>=的个数，C++版
+// 单点修改区间查询，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -13,23 +13,23 @@
 //const int MAXN = 500001;
 //const int MAXB = 1001;
 //int n, m;
-//int blen, bnum;
 //int arr[MAXN];
+//int sortv[MAXN];
+//
+//int blen, bnum;
 //int bi[MAXN];
 //int bl[MAXB];
 //int br[MAXB];
-//int sortv[MAXN];
 //
 //void build() {
 //    blen = (int)sqrt(n);
 //    bnum = (n + blen - 1) / blen;
-//    for (int i = 1, l = 1, r = blen; i <= bnum; i++, l += blen, r += blen) {
-//        r = min(r, n);
-//        for (int j = l; j <= r; j++) {
-//            bi[j] = i;
-//        }
-//        bl[i] = l;
-//        br[i] = r;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
 //    }
 //    for (int i = 1; i <= n; i++) {
 //        sortv[i] = arr[i];
@@ -39,8 +39,8 @@
 //    }
 //}
 //
-//int num(int bid, int v) {
-//    int l = bl[bid], r = br[bid], m, ans = 0;
+//int num(int l, int r, int v) {
+//    int m, ans = 0;
 //    while (l <= r) {
 //        m = (l + r) >> 1;
 //        if (sortv[m] >= v) {
@@ -73,7 +73,7 @@
 //            }
 //        }
 //        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-//            ans += num(i, v);
+//            ans += num(bl[i], br[i], v);
 //        }
 //    }
 //    return ans;
diff --git a/src/class172/Code02_Magic1.java b/src/class172/Code02_Magic1.java
new file mode 100644
index 000000000..42236e5d4
--- /dev/null
+++ b/src/class172/Code02_Magic1.java
@@ -0,0 +1,197 @@
+package class172;
+
+// 范围修改区间查询，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2801
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_Magic1 {
+
+	public static int MAXN = 1000001;
+	public static int MAXB = 1001;
+	public static int n, q;
+	public static int[] arr = new int[MAXN];
+	public static int[] sortv = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+	public static int[] lazy = new int[MAXB];
+
+	public static void build() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		for (int i = 1; i <= n; i++) {
+			sortv[i] = arr[i];
+		}
+		for (int i = 1; i <= bnum; i++) {
+			Arrays.sort(sortv, bl[i], br[i] + 1);
+		}
+	}
+
+	public static int num(int l, int r, int v) {
+		v -= lazy[bi[l]];
+		int m, ans = 0;
+		while (l <= r) {
+			m = (l + r) >> 1;
+			if (sortv[m] >= v) {
+				ans += r - m + 1;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static int innerQuery(int l, int r, int v) {
+		v -= lazy[bi[l]];
+		int ans = 0;
+		for (int i = l; i <= r; i++) {
+			if (arr[i] >= v) {
+				ans++;
+			}
+		}
+		return ans;
+	}
+
+	public static int query(int l, int r, int v) {
+		int ans = 0;
+		if (bi[l] == bi[r]) {
+			ans = innerQuery(l, r, v);
+		} else {
+			ans += innerQuery(l, br[bi[l]], v);
+			ans += innerQuery(bl[bi[r]], r, v);
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				ans += num(bl[i], br[i], v);
+			}
+		}
+		return ans;
+	}
+
+	public static void innerAdd(int l, int r, int v) {
+		for (int i = l; i <= r; i++) {
+			arr[i] += v;
+		}
+		for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
+			sortv[i] = arr[i];
+		}
+		Arrays.sort(sortv, bl[bi[l]], br[bi[l]] + 1);
+	}
+
+	public static void add(int l, int r, int v) {
+		if (bi[l] == bi[r]) {
+			innerAdd(l, r, v);
+		} else {
+			innerAdd(l, br[bi[l]], v);
+			innerAdd(bl[bi[r]], r, v);
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				lazy[i] += v;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		build();
+		char op;
+		int l, r, v;
+		for (int i = 1; i <= q; i++) {
+			op = in.nextChar();
+			l = in.nextInt();
+			r = in.nextInt();
+			v = in.nextInt();
+			if (op == 'A') {
+				out.println(query(l, r, v));
+			} else {
+				add(l, r, v);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class172/Code02_Magic2.java b/src/class172/Code02_Magic2.java
new file mode 100644
index 000000000..12470d0eb
--- /dev/null
+++ b/src/class172/Code02_Magic2.java
@@ -0,0 +1,123 @@
+package class172;
+
+// 范围修改区间查询，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2801
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//const int MAXB = 1001;
+//int n, q;
+//int arr[MAXN];
+//int sortv[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//int lazy[MAXB];
+//
+//void build() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        sortv[i] = arr[i];
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        sort(sortv + bl[i], sortv + br[i] + 1);
+//    }
+//}
+//
+//int num(int l, int r, int v) {
+//    v -= lazy[bi[l]];
+//    int m, ans = 0;
+//    while (l <= r) {
+//        m = (l + r) >> 1;
+//        if (sortv[m] >= v) {
+//            ans += r - m + 1;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int innerQuery(int l, int r, int v) {
+//    v -= lazy[bi[l]];
+//    int ans = 0;
+//    for (int i = l; i <= r; i++) {
+//        if (arr[i] >= v) {
+//            ans++;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int query(int l, int r, int v) {
+//    int ans = 0;
+//    if (bi[l] == bi[r]) {
+//        ans = innerQuery(l, r, v);
+//    } else {
+//        ans += innerQuery(l, br[bi[l]], v);
+//        ans += innerQuery(bl[bi[r]], r, v);
+//        for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
+//            ans += num(bl[b], br[b], v);
+//        }
+//    }
+//    return ans;
+//}
+//
+//void innerAdd(int l, int r, int v) {
+//    for (int i = l; i <= r; i++) {
+//        arr[i] += v;
+//    }
+//    for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
+//        sortv[i] = arr[i];
+//    }
+//    sort(sortv + bl[bi[l]], sortv + br[bi[l]] + 1);
+//}
+//
+//void add(int l, int r, int v) {
+//    if (bi[l] == bi[r]) {
+//        innerAdd(l, r, v);
+//    } else {
+//        innerAdd(l, br[bi[l]], v);
+//        innerAdd(bl[bi[r]], r, v);
+//        for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
+//            lazy[b] += v;
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> q;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    build();
+//    char op;
+//    int l, r, v;
+//    for (int i = 0; i < q; i++) {
+//        cin >> op >> l >> r >> v;
+//        if (op == 'A') {
+//            cout << query(l, r, v) << '\n';
+//        } else {
+//            add(l, r, v);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From a0db7198ccb906e1b899b323d22a165afa9927e9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 13 Jun 2025 16:27:21 +0800
Subject: [PATCH 0954/1712] modify code

---
 src/class172/Code01_GiveAway1.java | 2 +-
 src/class172/Code01_GiveAway2.java | 2 +-
 src/class172/Code02_Magic1.java    | 2 +-
 src/class172/Code02_Magic2.java    | 2 +-
 src/class172/Code03_Violet1.java   | 9 +++++++++
 5 files changed, 13 insertions(+), 4 deletions(-)
 create mode 100644 src/class172/Code03_Violet1.java

diff --git a/src/class172/Code01_GiveAway1.java b/src/class172/Code01_GiveAway1.java
index 1e3a36673..fd43ed62f 100644
--- a/src/class172/Code01_GiveAway1.java
+++ b/src/class172/Code01_GiveAway1.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 单点修改区间查询，java版
+// Give Away，java版
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class172/Code01_GiveAway2.java b/src/class172/Code01_GiveAway2.java
index 014eb7cbc..3176ecb73 100644
--- a/src/class172/Code01_GiveAway2.java
+++ b/src/class172/Code01_GiveAway2.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 单点修改区间查询，C++版
+// Give Away，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class172/Code02_Magic1.java b/src/class172/Code02_Magic1.java
index 42236e5d4..371842c32 100644
--- a/src/class172/Code02_Magic1.java
+++ b/src/class172/Code02_Magic1.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 范围修改区间查询，java版
+// 教主的魔法，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2801
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class172/Code02_Magic2.java b/src/class172/Code02_Magic2.java
index 12470d0eb..6f424af96 100644
--- a/src/class172/Code02_Magic2.java
+++ b/src/class172/Code02_Magic2.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 范围修改区间查询，C++版
+// 教主的魔法，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P2801
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class172/Code03_Violet1.java b/src/class172/Code03_Violet1.java
new file mode 100644
index 000000000..50a88f0e7
--- /dev/null
+++ b/src/class172/Code03_Violet1.java
@@ -0,0 +1,9 @@
+package class172;
+
+// 蒲公英，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4168
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code03_Violet1 {
+
+}

From 5c0c9a5108fd5d26a868c2d5cffca50031291b7b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 13 Jun 2025 21:11:15 +0800
Subject: [PATCH 0955/1712] modify code

---
 src/class172/Code03_Violet1.java | 203 +++++++++++++++++++++++++++++++
 src/class172/Code03_Violet2.java | 159 ++++++++++++++++++++++++
 2 files changed, 362 insertions(+)
 create mode 100644 src/class172/Code03_Violet2.java

diff --git a/src/class172/Code03_Violet1.java b/src/class172/Code03_Violet1.java
index 50a88f0e7..d462a132f 100644
--- a/src/class172/Code03_Violet1.java
+++ b/src/class172/Code03_Violet1.java
@@ -4,6 +4,209 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4168
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code03_Violet1 {
 
+	public static int MAXN = 40001;
+	public static int MAXB = 201;
+	public static int n, m, s;
+	public static int[] arr = new int[MAXN];
+	public static int[] sortv = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	// freq[i][j]表示前i块中j出现的次数
+	public static int[][] freq = new int[MAXB][MAXN];
+
+	// mode[i][j]表示从i块到j块中的众数
+	public static int[][] mode = new int[MAXB][MAXB];
+
+	// 数字词频统计
+	public static int[] numCnt = new int[MAXN];
+
+	public static int lower(int num) {
+		int l = 1, r = s, m, ans = 0;
+		while (l <= r) {
+			m = (l + r) >> 1;
+			if (sortv[m] >= num) {
+				ans = m;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static int getCnt(int l, int r, int v) {
+		return freq[r][v] - freq[l - 1][v];
+	}
+
+	public static void prepare() {
+		// 离散化
+		for (int i = 1; i <= n; i++) {
+			sortv[i] = arr[i];
+		}
+		Arrays.sort(sortv, 1, n + 1);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sortv[s] != sortv[i]) {
+				sortv[++s] = sortv[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = lower(arr[i]);
+		}
+		// 建块
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		// 填好freq
+		for (int i = 1; i <= bnum; i++) {
+			for (int j = bl[i]; j <= br[i]; j++) {
+				freq[i][arr[j]]++;
+			}
+			for (int j = 1; j <= s; j++) {
+				freq[i][j] += freq[i - 1][j];
+			}
+		}
+		// 填好mode
+		for (int i = 1; i <= bnum; i++) {
+			for (int j = i; j <= bnum; j++) {
+				int most = mode[i][j - 1];
+				for (int k = bl[j]; k <= br[j]; k++) {
+					int cur = arr[k];
+					int curCnt = getCnt(i, j, cur);
+					int mostCnt = getCnt(i, j, most);
+					if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
+						most = cur;
+					}
+				}
+				mode[i][j] = most;
+			}
+		}
+	}
+
+	public static int query(int l, int r) {
+		int most = 0;
+		if (bi[l] == bi[r]) {
+			for (int i = l; i <= r; i++) {
+				numCnt[arr[i]]++;
+			}
+			for (int i = l; i <= r; i++) {
+				if (numCnt[arr[i]] > numCnt[most] || (numCnt[arr[i]] == numCnt[most] && arr[i] < most)) {
+					most = arr[i];
+				}
+			}
+			for (int i = l; i <= r; i++) {
+				numCnt[arr[i]] = 0;
+			}
+		} else {
+			for (int i = l; i <= br[bi[l]]; i++) {
+				numCnt[arr[i]]++;
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				numCnt[arr[i]]++;
+			}
+			most = mode[bi[l] + 1][bi[r] - 1];
+			for (int i = l; i <= br[bi[l]]; i++) {
+				int cur = arr[i];
+				int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
+				int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
+				if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
+					most = cur;
+				}
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				int cur = arr[i];
+				int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
+				int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
+				if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
+					most = cur;
+				}
+			}
+			for (int i = l; i <= br[bi[l]]; i++) {
+				numCnt[arr[i]] = 0;
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				numCnt[arr[i]] = 0;
+			}
+		}
+		return sortv[most];
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, a, b, l, r, lastAns = 0; i <= m; i++) {
+			a = (in.nextInt() + lastAns - 1) % n + 1;
+			b = (in.nextInt() + lastAns - 1) % n + 1;
+			l = Math.min(a, b);
+			r = Math.max(a, b);
+			lastAns = query(l, r);
+			out.println(lastAns);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class172/Code03_Violet2.java b/src/class172/Code03_Violet2.java
new file mode 100644
index 000000000..0fc7bcfc2
--- /dev/null
+++ b/src/class172/Code03_Violet2.java
@@ -0,0 +1,159 @@
+package class172;
+
+// 蒲公英，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4168
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 40001;
+//const int MAXB = 201;
+//int n, m, s;
+//int arr[MAXN];
+//int sortv[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//int freq[MAXB][MAXN];
+//int mode[MAXB][MAXB];
+//int numCnt[MAXN];
+//
+//int lower(int num) {
+//    int l = 1, r = s, m, ans = 0;
+//    while (l <= r) {
+//        m = (l + r) >> 1;
+//        if (sortv[m] >= num) {
+//            ans = m;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int getCnt(int l, int r, int v) {
+//    return freq[r][v] - freq[l - 1][v];
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sortv[i] = arr[i];
+//    }
+//    sort(sortv + 1, sortv + n + 1);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sortv[s] != sortv[i]) {
+//            sortv[++s] = sortv[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = lower(arr[i]);
+//    }
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        for (int j = bl[i]; j <= br[i]; j++) {
+//            freq[i][arr[j]]++;
+//        }
+//        for (int j = 1; j <= s; j++) {
+//            freq[i][j] += freq[i - 1][j];
+//        }
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        for (int j = i; j <= bnum; j++) {
+//            int most = mode[i][j - 1];
+//            for (int k = bl[j]; k <= br[j]; k++) {
+//                int cur = arr[k];
+//                int curCnt = getCnt(i, j, cur);
+//                int mostCnt = getCnt(i, j, most);
+//                if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
+//                    most = cur;
+//                }
+//            }
+//            mode[i][j] = most;
+//        }
+//    }
+//}
+//
+//int query(int l, int r) {
+//    int most = 0;
+//    if (bi[l] == bi[r]) {
+//        for (int i = l; i <= r; i++) {
+//            numCnt[arr[i]]++;
+//        }
+//        for (int i = l; i <= r; i++) {
+//            if (numCnt[arr[i]] > numCnt[most] || (numCnt[arr[i]] == numCnt[most] && arr[i] < most)) {
+//                most = arr[i];
+//            }
+//        }
+//        for (int i = l; i <= r; i++) {
+//            numCnt[arr[i]] = 0;
+//        }
+//    } else {
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            numCnt[arr[i]]++;
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            numCnt[arr[i]]++;
+//        }
+//        most = mode[bi[l] + 1][bi[r] - 1];
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            int cur = arr[i];
+//            int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
+//            int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
+//            if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
+//                most = cur;
+//            }
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            int cur = arr[i];
+//            int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
+//            int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
+//            if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
+//                most = cur;
+//            }
+//        }
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            numCnt[arr[i]] = 0;
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            numCnt[arr[i]] = 0;
+//        }
+//    }
+//    return sortv[most];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    int lastAns = 0, a, b, l, r;
+//    for (int i = 0; i < m; i++) {
+//        cin >> a >> b;
+//        a = (a + lastAns - 1) % n + 1;
+//        b = (b + lastAns - 1) % n + 1;
+//        l = min(a, b);
+//        r = max(a, b);
+//        lastAns = query(l, r);
+//        cout << lastAns << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 87ff4b67d3b665532bff66c1f573fd0f094f27c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 13 Jun 2025 21:12:06 +0800
Subject: [PATCH 0956/1712] modify code

---
 src/class172/Code03_Violet1.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/class172/Code03_Violet1.java b/src/class172/Code03_Violet1.java
index d462a132f..2a3981de4 100644
--- a/src/class172/Code03_Violet1.java
+++ b/src/class172/Code03_Violet1.java
@@ -25,10 +25,8 @@ public class Code03_Violet1 {
 
 	// freq[i][j]表示前i块中j出现的次数
 	public static int[][] freq = new int[MAXB][MAXN];
-
 	// mode[i][j]表示从i块到j块中的众数
 	public static int[][] mode = new int[MAXB][MAXB];
-
 	// 数字词频统计
 	public static int[] numCnt = new int[MAXN];
 

From 0a7f694f677b9475c5cf524cc1a42b7e10661aa3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Jun 2025 12:46:59 +0800
Subject: [PATCH 0957/1712] modify code

---
 src/class172/Code03_Violet1.java  |  20 ++--
 src/class172/Code03_Violet2.java  |  18 +--
 src/class172/Code04_ModeCnt1.java | 186 ++++++++++++++++++++++++++++++
 src/class172/Code04_ModeCnt2.java | 142 +++++++++++++++++++++++
 4 files changed, 347 insertions(+), 19 deletions(-)
 create mode 100644 src/class172/Code04_ModeCnt1.java
 create mode 100644 src/class172/Code04_ModeCnt2.java

diff --git a/src/class172/Code03_Violet1.java b/src/class172/Code03_Violet1.java
index 2a3981de4..84cc7f213 100644
--- a/src/class172/Code03_Violet1.java
+++ b/src/class172/Code03_Violet1.java
@@ -49,6 +49,16 @@ public static int getCnt(int l, int r, int v) {
 	}
 
 	public static void prepare() {
+		// 建块
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
 		// 离散化
 		for (int i = 1; i <= n; i++) {
 			sortv[i] = arr[i];
@@ -63,16 +73,6 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = lower(arr[i]);
 		}
-		// 建块
-		blen = (int) Math.sqrt(n);
-		bnum = (n + blen - 1) / blen;
-		for (int i = 1; i <= n; i++) {
-			bi[i] = (i - 1) / blen + 1;
-		}
-		for (int i = 1; i <= bnum; i++) {
-			bl[i] = (i - 1) * blen + 1;
-			br[i] = Math.min(i * blen, n);
-		}
 		// 填好freq
 		for (int i = 1; i <= bnum; i++) {
 			for (int j = bl[i]; j <= br[i]; j++) {
diff --git a/src/class172/Code03_Violet2.java b/src/class172/Code03_Violet2.java
index 0fc7bcfc2..a9e054d1c 100644
--- a/src/class172/Code03_Violet2.java
+++ b/src/class172/Code03_Violet2.java
@@ -43,6 +43,15 @@
 //}
 //
 //void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
 //    for (int i = 1; i <= n; i++) {
 //        sortv[i] = arr[i];
 //    }
@@ -56,15 +65,6 @@
 //    for (int i = 1; i <= n; i++) {
 //        arr[i] = lower(arr[i]);
 //    }
-//    blen = (int)sqrt(n);
-//    bnum = (n + blen - 1) / blen;
-//    for (int i = 1; i <= n; i++) {
-//        bi[i] = (i - 1) / blen + 1;
-//    }
-//    for (int i = 1; i <= bnum; i++) {
-//        bl[i] = (i - 1) * blen + 1;
-//        br[i] = min(i * blen, n);
-//    }
 //    for (int i = 1; i <= bnum; i++) {
 //        for (int j = bl[i]; j <= br[i]; j++) {
 //            freq[i][arr[j]]++;
diff --git a/src/class172/Code04_ModeCnt1.java b/src/class172/Code04_ModeCnt1.java
new file mode 100644
index 000000000..c5c7480d7
--- /dev/null
+++ b/src/class172/Code04_ModeCnt1.java
@@ -0,0 +1,186 @@
+package class172;
+
+// 空间少求区间众数的次数，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5048
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是内存占用过大，无法通过测试用例
+// 因为这道题只考虑C++能通过的空间标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code04_ModeCnt2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code04_ModeCnt1 {
+
+	public static int MAXN = 500001;
+	public static int MAXB = 801;
+	public static int n, m, s;
+	public static int[] arr = new int[MAXN];
+	public static int[] sortv = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	// 值、下标
+	public static int[][] bucket = new int[MAXN][2];
+	// bucketIdx[i] = j，代表数组的i位置元素在bucket中的j位置
+	public static int[] bucketIdx = new int[MAXN];
+
+	// modeCnt[i][j]表示从i块到j块中众数的出现次数
+	public static int[][] modeCnt = new int[MAXB][MAXB];
+	// 数字词频统计
+	public static int[] numCnt = new int[MAXN];
+
+	public static int lower(int num) {
+		int l = 1, r = s, m, ans = 0;
+		while (l <= r) {
+			m = (l + r) >> 1;
+			if (sortv[m] >= num) {
+				ans = m;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		for (int i = 1; i <= n; i++) {
+			sortv[i] = arr[i];
+		}
+		Arrays.sort(sortv, 1, n + 1);
+		s = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sortv[s] != sortv[i]) {
+				sortv[++s] = sortv[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = lower(arr[i]);
+		}
+		for (int i = 1; i <= n; i++) {
+			bucket[i][0] = arr[i];
+			bucket[i][1] = i;
+		}
+		Arrays.sort(bucket, 1, n + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
+		for (int i = 1; i <= n; i++) {
+			bucketIdx[bucket[i][1]] = i;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			for (int j = i; j <= bnum; j++) {
+				int cnt = modeCnt[i][j - 1];
+				for (int k = bl[j]; k <= br[j]; k++) {
+					cnt = Math.max(cnt, ++numCnt[arr[k]]);
+				}
+				modeCnt[i][j] = cnt;
+			}
+			for (int j = 1; j <= n; j++) {
+				numCnt[j] = 0;
+			}
+		}
+	}
+
+	public static int query(int l, int r) {
+		int ans = 0;
+		if (bi[l] == bi[r]) {
+			for (int i = l; i <= r; i++) {
+				ans = Math.max(ans, ++numCnt[arr[i]]);
+			}
+			for (int i = l; i <= r; i++) {
+				numCnt[arr[i]] = 0;
+			}
+		} else {
+			ans = modeCnt[bi[l] + 1][bi[r] - 1];
+			for (int i = l, idx; i <= br[bi[l]]; i++) {
+				idx = bucketIdx[i];
+				while (idx + ans <= n && bucket[idx + ans][0] == arr[i] && bucket[idx + ans][1] <= r) {
+					ans++;
+				}
+			}
+			for (int i = bl[bi[r]], idx; i <= r; i++) {
+				idx = bucketIdx[i];
+				while (idx - ans >= 1 && bucket[idx - ans][0] == arr[i] && bucket[idx - ans][1] >= l) {
+					ans++;
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, l, r, lastAns = 0; i <= m; i++) {
+			l = in.nextInt();
+			r = in.nextInt();
+			l ^= lastAns;
+			r ^= lastAns;
+			lastAns = query(l, r);
+			out.println(lastAns);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class172/Code04_ModeCnt2.java b/src/class172/Code04_ModeCnt2.java
new file mode 100644
index 000000000..454891105
--- /dev/null
+++ b/src/class172/Code04_ModeCnt2.java
@@ -0,0 +1,142 @@
+package class172;
+
+// 空间少求区间众数的次数，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5048
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int v, i;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    if (a.v != b.v) {
+//        return a.v < b.v;
+//    }
+//    return a.i < b.i;
+//}
+//
+//const int MAXN = 500001;
+//const int MAXB = 801;
+//int n, m, s;
+//int arr[MAXN];
+//int sortv[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//Node bucket[MAXN];
+//int bucketIdx[MAXN];
+//
+//int modeCnt[MAXB][MAXB];
+//int numCnt[MAXN];
+//
+//int lower(int x) {
+//    int l = 1, r = s, m, ans = 0;
+//    while (l <= r) {
+//        m = (l + r) >> 1;
+//        if (sortv[m] >= x) {
+//            ans = m;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        sortv[i] = arr[i];
+//    }
+//    sort(sortv + 1, sortv + n + 1);
+//    s = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sortv[s] != sortv[i]) {
+//            sortv[++s] = sortv[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = lower(arr[i]);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        bucket[i].v = arr[i];
+//        bucket[i].i = i;
+//    }
+//    sort(bucket + 1, bucket + n + 1, NodeCmp);
+//    for (int i = 1; i <= n; i++) {
+//        bucketIdx[bucket[i].i] = i;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        for (int j = i; j <= bnum; j++) {
+//            int cnt = modeCnt[i][j - 1];
+//            for (int k = bl[j]; k <= br[j]; k++) {
+//                cnt = max(cnt, ++numCnt[arr[k]]);
+//            }
+//            modeCnt[i][j] = cnt;
+//        }
+//        for (int j = 1; j <= n; j++) {
+//            numCnt[j] = 0;
+//        }
+//    }
+//}
+//
+//int query(int l, int r) {
+//    int ans = 0;
+//    if (bi[l] == bi[r]) {
+//        for (int i = l; i <= r; i++) {
+//            ans = max(ans, ++numCnt[arr[i]]);
+//        }
+//        for (int i = l; i <= r; i++) {
+//            numCnt[arr[i]] = 0;
+//        }
+//    } else {
+//        ans = modeCnt[bi[l] + 1][bi[r] - 1];
+//        for (int i = l, idx; i <= br[bi[l]]; i++) {
+//            idx = bucketIdx[i];
+//            while (idx + ans <= n && bucket[idx + ans].v == arr[i] && bucket[idx + ans].i <= r) {
+//                ans++;
+//            }
+//        }
+//        for (int i = bl[bi[r]], idx; i <= r; i++) {
+//            idx = bucketIdx[i];
+//            while (idx - ans >= 1 && bucket[idx - ans].v == arr[i] && bucket[idx - ans].i >= l) {
+//                ans++;
+//            }
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, l, r, lastAns = 0; i <= m; i++) {
+//        cin >> l >> r;
+//        l ^= lastAns;
+//        r ^= lastAns;
+//        lastAns = query(l, r);
+//        cout << lastAns << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 6d378303a3f6590fcdf02e6756351c3edc3a63e2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Jun 2025 15:35:58 +0800
Subject: [PATCH 0958/1712] modify code

---
 src/class172/Code04_ModeCnt1.java |  38 +------
 src/class172/Code04_ModeCnt2.java |  32 +-----
 src/class172/Code05_Poem1.java    | 164 ++++++++++++++++++++++++++++++
 src/class172/Code05_Poem2.java    | 114 +++++++++++++++++++++
 4 files changed, 284 insertions(+), 64 deletions(-)
 create mode 100644 src/class172/Code05_Poem1.java
 create mode 100644 src/class172/Code05_Poem2.java

diff --git a/src/class172/Code04_ModeCnt1.java b/src/class172/Code04_ModeCnt1.java
index c5c7480d7..c59890259 100644
--- a/src/class172/Code04_ModeCnt1.java
+++ b/src/class172/Code04_ModeCnt1.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 空间少求区间众数的次数，java版
+// 空间少求众数的次数，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5048
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是内存占用过大，无法通过测试用例
@@ -18,9 +18,8 @@ public class Code04_ModeCnt1 {
 
 	public static int MAXN = 500001;
 	public static int MAXB = 801;
-	public static int n, m, s;
+	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	public static int[] sortv = new int[MAXN];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
@@ -37,20 +36,6 @@ public class Code04_ModeCnt1 {
 	// 数字词频统计
 	public static int[] numCnt = new int[MAXN];
 
-	public static int lower(int num) {
-		int l = 1, r = s, m, ans = 0;
-		while (l <= r) {
-			m = (l + r) >> 1;
-			if (sortv[m] >= num) {
-				ans = m;
-				r = m - 1;
-			} else {
-				l = m + 1;
-			}
-		}
-		return ans;
-	}
-
 	public static void prepare() {
 		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
@@ -61,19 +46,6 @@ public static void prepare() {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, n);
 		}
-		for (int i = 1; i <= n; i++) {
-			sortv[i] = arr[i];
-		}
-		Arrays.sort(sortv, 1, n + 1);
-		s = 1;
-		for (int i = 2; i <= n; i++) {
-			if (sortv[s] != sortv[i]) {
-				sortv[++s] = sortv[i];
-			}
-		}
-		for (int i = 1; i <= n; i++) {
-			arr[i] = lower(arr[i]);
-		}
 		for (int i = 1; i <= n; i++) {
 			bucket[i][0] = arr[i];
 			bucket[i][1] = i;
@@ -133,10 +105,8 @@ public static void main(String[] args) throws IOException {
 		}
 		prepare();
 		for (int i = 1, l, r, lastAns = 0; i <= m; i++) {
-			l = in.nextInt();
-			r = in.nextInt();
-			l ^= lastAns;
-			r ^= lastAns;
+			l = in.nextInt() ^ lastAns;
+			r = in.nextInt() ^ lastAns;
 			lastAns = query(l, r);
 			out.println(lastAns);
 		}
diff --git a/src/class172/Code04_ModeCnt2.java b/src/class172/Code04_ModeCnt2.java
index 454891105..9805408f8 100644
--- a/src/class172/Code04_ModeCnt2.java
+++ b/src/class172/Code04_ModeCnt2.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 空间少求区间众数的次数，C++版
+// 空间少求众数的次数，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P5048
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -22,9 +22,8 @@
 //
 //const int MAXN = 500001;
 //const int MAXB = 801;
-//int n, m, s;
+//int n, m;
 //int arr[MAXN];
-//int sortv[MAXN];
 //
 //int blen, bnum;
 //int bi[MAXN];
@@ -37,20 +36,6 @@
 //int modeCnt[MAXB][MAXB];
 //int numCnt[MAXN];
 //
-//int lower(int x) {
-//    int l = 1, r = s, m, ans = 0;
-//    while (l <= r) {
-//        m = (l + r) >> 1;
-//        if (sortv[m] >= x) {
-//            ans = m;
-//            r = m - 1;
-//        } else {
-//            l = m + 1;
-//        }
-//    }
-//    return ans;
-//}
-//
 //void prepare() {
 //    blen = (int)sqrt(n);
 //    bnum = (n + blen - 1) / blen;
@@ -62,19 +47,6 @@
 //        br[i] = min(i * blen, n);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        sortv[i] = arr[i];
-//    }
-//    sort(sortv + 1, sortv + n + 1);
-//    s = 1;
-//    for (int i = 2; i <= n; i++) {
-//        if (sortv[s] != sortv[i]) {
-//            sortv[++s] = sortv[i];
-//        }
-//    }
-//    for (int i = 1; i <= n; i++) {
-//        arr[i] = lower(arr[i]);
-//    }
-//    for (int i = 1; i <= n; i++) {
 //        bucket[i].v = arr[i];
 //        bucket[i].i = i;
 //    }
diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
new file mode 100644
index 000000000..a2f8eb92b
--- /dev/null
+++ b/src/class172/Code05_Poem1.java
@@ -0,0 +1,164 @@
+package class172;
+
+// 作诗，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4135
+// 提交交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code05_Poem1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 401;
+	public static int n, c, m;
+	public static int[] arr = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	// freq[i][j]表示前i块中j出现的次数
+	public static int[][] freq = new int[MAXB][MAXN];
+	// even[i][j]表示从第i块到第j块出现正偶数次的数有几个
+	public static int[][] even = new int[MAXB][MAXB];
+	// 数字词频统计
+	public static int[] numCnt = new int[MAXN];
+
+	// 返回从l块到r块中，数字v的次数
+	public static int getCnt(int l, int r, int v) {
+		return freq[r][v] - freq[l - 1][v];
+	}
+
+	// 加1之前的词频是pre，返回加1之后，正偶数次的数的个数变化量
+	public static int change(int pre) {
+		return pre != 0 ? ((pre & 1) == 0 ? -1 : 1) : 0;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		for (int i = 1; i <= bnum; i++) {
+			for (int j = bl[i]; j <= br[i]; j++) {
+				freq[i][arr[j]]++;
+			}
+			for (int j = 1; j <= c; j++) {
+				freq[i][j] += freq[i - 1][j];
+			}
+		}
+		for (int i = 1; i <= bnum; i++) {
+			for (int j = i; j <= bnum; j++) {
+				even[i][j] = even[i][j - 1];
+				for (int k = bl[j]; k <= br[j]; k++) {
+					even[i][j] += change(numCnt[arr[k]]);
+					numCnt[arr[k]]++;
+				}
+			}
+			for (int j = 1; j <= c; j++) {
+				numCnt[j] = 0;
+			}
+		}
+	}
+
+	public static int query(int l, int r) {
+		int ans = 0;
+		if (bi[l] == bi[r]) {
+			for (int i = l; i <= r; i++) {
+				ans += change(numCnt[arr[i]]);
+				numCnt[arr[i]]++;
+			}
+			for (int i = l; i <= r; i++) {
+				numCnt[arr[i]] = 0;
+			}
+		} else {
+			ans = even[bi[l] + 1][bi[r] - 1];
+			for (int i = l; i <= br[bi[l]]; i++) {
+				ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+				numCnt[arr[i]]++;
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+				numCnt[arr[i]]++;
+			}
+			for (int i = l; i <= br[bi[l]]; i++) {
+				numCnt[arr[i]] = 0;
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				numCnt[arr[i]] = 0;
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		c = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, a, b, l, r, lastAns = 0; i <= m; i++) {
+			a = (in.nextInt() + lastAns) % n + 1;
+			b = (in.nextInt() + lastAns) % n + 1;
+			l = Math.min(a, b);
+			r = Math.max(a, b);
+			lastAns = query(l, r);
+			out.println(lastAns);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
new file mode 100644
index 000000000..a1fed9023
--- /dev/null
+++ b/src/class172/Code05_Poem2.java
@@ -0,0 +1,114 @@
+package class172;
+
+// 作诗，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4135
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXB = 401;
+//int n, c, m;
+//int arr[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//int freq[MAXB][MAXN];
+//int even[MAXB][MAXB];
+//int numCnt[MAXN];
+//
+//int getCnt(int l, int r, int v) {
+//    return freq[r][v] - freq[l - 1][v];
+//}
+//
+//int change(int pre) {
+//    return pre ? ((pre & 1) ? 1 : -1) : 0;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        for (int j = bl[i]; j <= br[i]; j++) {
+//            freq[i][arr[j]]++;
+//        }
+//        for (int j = 1; j <= c; j++) {
+//            freq[i][j] += freq[i - 1][j];
+//        }
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        for (int j = i; j <= bnum; j++) {
+//            even[i][j] = even[i][j - 1];
+//            for (int k = bl[j]; k <= br[j]; k++) {
+//                even[i][j] += change(numCnt[arr[k]]);
+//                numCnt[arr[k]]++;
+//            }
+//        }
+//        for (int j = 1; j <= c; j++) {
+//            numCnt[j] = 0;
+//        }
+//    }
+//}
+//
+//int query(int l, int r) {
+//    int ans = 0;
+//    if (bi[l] == bi[r]) {
+//        for (int i = l; i <= r; i++) {
+//            ans += change(numCnt[arr[i]]);
+//            numCnt[arr[i]]++;
+//        }
+//        for (int i = l; i <= r; i++) {
+//            numCnt[arr[i]] = 0;
+//        }
+//    } else {
+//        ans = even[bi[l] + 1][bi[r] - 1];
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+//            numCnt[arr[i]]++;
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+//            numCnt[arr[i]]++;
+//        }
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            numCnt[arr[i]] = 0;
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            numCnt[arr[i]] = 0;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> c >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, a, b, l, r, lastAns = 0; i <= m; i++) {
+//        cin >> a >> b;
+//        a = (a + lastAns) % n + 1;
+//        b = (b + lastAns) % n + 1;
+//        l = min(a, b);
+//        r = max(a, b);
+//        lastAns = query(l, r);
+//        cout << lastAns << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From f2ca6ed577659f9f22160288a00e3764b5f77933 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Jun 2025 15:38:47 +0800
Subject: [PATCH 0959/1712] modify code

---
 src/class172/Code05_Poem1.java | 10 +++++-----
 src/class172/Code05_Poem2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index a2f8eb92b..8c12af1fc 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -34,7 +34,7 @@ public static int getCnt(int l, int r, int v) {
 	}
 
 	// 加1之前的词频是pre，返回加1之后，正偶数次的数的个数变化量
-	public static int change(int pre) {
+	public static int delta(int pre) {
 		return pre != 0 ? ((pre & 1) == 0 ? -1 : 1) : 0;
 	}
 
@@ -60,7 +60,7 @@ public static void prepare() {
 			for (int j = i; j <= bnum; j++) {
 				even[i][j] = even[i][j - 1];
 				for (int k = bl[j]; k <= br[j]; k++) {
-					even[i][j] += change(numCnt[arr[k]]);
+					even[i][j] += delta(numCnt[arr[k]]);
 					numCnt[arr[k]]++;
 				}
 			}
@@ -74,7 +74,7 @@ public static int query(int l, int r) {
 		int ans = 0;
 		if (bi[l] == bi[r]) {
 			for (int i = l; i <= r; i++) {
-				ans += change(numCnt[arr[i]]);
+				ans += delta(numCnt[arr[i]]);
 				numCnt[arr[i]]++;
 			}
 			for (int i = l; i <= r; i++) {
@@ -83,11 +83,11 @@ public static int query(int l, int r) {
 		} else {
 			ans = even[bi[l] + 1][bi[r] - 1];
 			for (int i = l; i <= br[bi[l]]; i++) {
-				ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+				ans += delta(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
 				numCnt[arr[i]]++;
 			}
 			for (int i = bl[bi[r]]; i <= r; i++) {
-				ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+				ans += delta(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
 				numCnt[arr[i]]++;
 			}
 			for (int i = l; i <= br[bi[l]]; i++) {
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index a1fed9023..c7bccb28b 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -27,7 +27,7 @@
 //    return freq[r][v] - freq[l - 1][v];
 //}
 //
-//int change(int pre) {
+//int delta(int pre) {
 //    return pre ? ((pre & 1) ? 1 : -1) : 0;
 //}
 //
@@ -53,7 +53,7 @@
 //        for (int j = i; j <= bnum; j++) {
 //            even[i][j] = even[i][j - 1];
 //            for (int k = bl[j]; k <= br[j]; k++) {
-//                even[i][j] += change(numCnt[arr[k]]);
+//                even[i][j] += delta(numCnt[arr[k]]);
 //                numCnt[arr[k]]++;
 //            }
 //        }
@@ -67,7 +67,7 @@
 //    int ans = 0;
 //    if (bi[l] == bi[r]) {
 //        for (int i = l; i <= r; i++) {
-//            ans += change(numCnt[arr[i]]);
+//            ans += delta(numCnt[arr[i]]);
 //            numCnt[arr[i]]++;
 //        }
 //        for (int i = l; i <= r; i++) {
@@ -76,11 +76,11 @@
 //    } else {
 //        ans = even[bi[l] + 1][bi[r] - 1];
 //        for (int i = l; i <= br[bi[l]]; i++) {
-//            ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+//            ans += delta(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
 //            numCnt[arr[i]]++;
 //        }
 //        for (int i = bl[bi[r]]; i <= r; i++) {
-//            ans += change(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
+//            ans += delta(getCnt(bi[l] + 1, bi[r] - 1, arr[i]) + numCnt[arr[i]]);
 //            numCnt[arr[i]]++;
 //        }
 //        for (int i = l; i <= br[bi[l]]; i++) {

From 22759c3bd54cfed790dcdefeb3e36b31322343e3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Jun 2025 20:49:01 +0800
Subject: [PATCH 0960/1712] modify code

---
 src/class152/Code03_TextEditor1.java | 176 ++++++++++++++++++---------
 src/class172/Code06_TextEditor1.java |  95 +++++++++++++++
 2 files changed, 213 insertions(+), 58 deletions(-)
 create mode 100644 src/class172/Code06_TextEditor1.java

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index 929823b3c..24b8a0cbd 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -16,9 +16,8 @@
 // C++版本是Code03_TextEditor2文件，可以通过所有测试用例
 // 在真正笔试、比赛时，一定是兼顾各种语言的，该实现是一定正确的
 
-import java.io.BufferedReader;
 import java.io.IOException;
-import java.io.InputStreamReader;
+import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
@@ -90,75 +89,136 @@ public static void inorder(int i) {
 	// 以下风格只是其中一种，无所谓了，逻辑是对的
 	// 想通过这个题看C++版本吧，完全一样的逻辑
 	public static void main(String[] args) throws IOException {
-		BufferedReader in = new BufferedReader(new InputStreamReader(System.in));
+		FastReader in = new FastReader();
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		int n = Integer.valueOf(in.readLine());
+		int n = in.nextInt();
 		int pos = 0;
-		String str;
 		String op;
 		int x;
 		for (int i = 1; i <= n; i++) {
-			str = in.readLine();
-			if (str.equals("Prev")) {
+			op = in.nextString();
+			if (op.equals("Prev")) {
 				pos--;
-			} else if (str.equals("Next")) {
+			} else if (op.equals("Next")) {
 				pos++;
+			} else if (op.equals("Move")) {
+				pos = in.nextInt();
+			} else if (op.equals("Delete")) {
+				x = in.nextInt();
+				split(0, 0, head, pos + x);
+				int r = left[0];
+				int lm = right[0];
+				left[0] = right[0] = 0;
+				split(0, 0, lm, pos);
+				int l = right[0];
+				left[0] = right[0] = 0;
+				head = merge(l, r);
+			} else if (op.equals("Insert")) {
+				x = in.nextInt();
+				split(0, 0, head, pos);
+				int l = right[0];
+				int r = left[0];
+				left[0] = right[0] = 0;
+				for (int j = 1; j <= x; j++) {
+					key[++cnt] = in.nextChar();
+					size[cnt] = 1;
+					priority[cnt] = Math.random();
+					l = merge(l, cnt);
+				}
+				head = merge(l, r);
 			} else {
-				String[] input = str.split(" ");
-				op = input[0];
-				x = Integer.valueOf(input[1]);
-				if (op.equals("Move")) {
-					pos = x;
-				} else if (op.equals("Insert")) {
-					split(0, 0, head, pos);
-					int l = right[0];
-					int r = left[0];
-					left[0] = right[0] = 0;
-					int add = 0;
-					while (add < x) {
-						char[] insert = in.readLine().toCharArray();
-						for (int j = 0; j < insert.length; j++) {
-							if (insert[j] >= 32 && insert[j] <= 126) {
-								key[++cnt] = insert[j];
-								size[cnt] = 1;
-								priority[cnt] = Math.random();
-								l = merge(l, cnt);
-								add++;
-							}
-						}
-					}
-					head = merge(l, r);
-				} else if (op.equals("Delete")) {
-					split(0, 0, head, pos + x);
-					int r = left[0];
-					int lm = right[0];
-					left[0] = right[0] = 0;
-					split(0, 0, lm, pos);
-					int l = right[0];
-					left[0] = right[0] = 0;
-					head = merge(l, r);
-				} else {
-					split(0, 0, head, pos + x);
-					int r = left[0];
-					int lm = right[0];
-					left[0] = right[0] = 0;
-					split(0, 0, lm, pos);
-					int l = right[0];
-					int m = left[0];
-					left[0] = right[0] = 0;
-					ansi = 0;
-					inorder(m);
-					head = merge(merge(l, m), r);
-					for (int j = 1; j <= ansi; j++) {
-						out.print((char) ans[j]);
-					}
-					out.println();
+				x = in.nextInt();
+				split(0, 0, head, pos + x);
+				int r = left[0];
+				int lm = right[0];
+				left[0] = right[0] = 0;
+				split(0, 0, lm, pos);
+				int l = right[0];
+				int m = left[0];
+				left[0] = right[0] = 0;
+				ansi = 0;
+				inorder(m);
+				head = merge(merge(l, m), r);
+				for (int j = 1; j <= ansi; j++) {
+					out.print((char) ans[j]);
 				}
+				out.println();
 			}
 		}
 		out.flush();
 		out.close();
-		in.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c < 32 || c > 126);
+			return (char) c;
+		}
+
+		public String nextString() throws IOException {
+			byte b = readByte();
+			while (isWhitespace(b)) {
+				b = readByte();
+			}
+			StringBuilder sb = new StringBuilder(1000);
+			while (!isWhitespace(b) && b != -1) {
+				sb.append((char) b);
+				b = readByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
 	}
 
 }
diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
new file mode 100644
index 000000000..980fcfcdd
--- /dev/null
+++ b/src/class172/Code06_TextEditor1.java
@@ -0,0 +1,95 @@
+package class172;
+
+// 文本编辑器，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4008
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code06_TextEditor1 {
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		// 读取下一个ASCII码在闭区间[32, 126]内的字符
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c < 32 || c > 126);
+			return (char) c;
+		}
+
+		public String nextString() throws IOException {
+			byte b = readByte();
+			while (isWhitespace(b)) {
+				b = readByte();
+			}
+			StringBuilder sb = new StringBuilder(1000);
+			while (!isWhitespace(b) && b != -1) {
+				sb.append((char) b);
+				b = readByte();
+			}
+			return sb.toString();
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}

From e081a152291d88136f711b6235ee4c9df3cde8d9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Jun 2025 21:02:12 +0800
Subject: [PATCH 0961/1712] modify code

---
 src/class152/Code03_TextEditor1.java |  13 +-
 src/class152/Code03_TextEditor3.java | 337 +++++++++++++++++++++++++++
 2 files changed, 342 insertions(+), 8 deletions(-)
 create mode 100644 src/class152/Code03_TextEditor3.java

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index 24b8a0cbd..ee89c34f8 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -10,11 +10,11 @@
 // Next       : 光标后移一个字符，操作保证光标不会到非法位置
 // Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
-// 如下实现是正确的，但java的版本无法通过所有测试用例
-// 这是洛谷平台没有照顾各种语言的实现所导致的
-// java的实现空间就是无法达标，C++的实现完全一样的逻辑，就是可以达标
-// C++版本是Code03_TextEditor2文件，可以通过所有测试用例
-// 在真正笔试、比赛时，一定是兼顾各种语言的，该实现是一定正确的
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是内存占用过大，无法通过测试用例
+// 因为这道题只考虑C++能通过的空间标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code03_TextEditor2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -85,9 +85,6 @@ public static void inorder(int i) {
 		}
 	}
 
-	// 我做了很多个版本的IO尝试，空间都无法达标
-	// 以下风格只是其中一种，无所谓了，逻辑是对的
-	// 想通过这个题看C++版本吧，完全一样的逻辑
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader();
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
diff --git a/src/class152/Code03_TextEditor3.java b/src/class152/Code03_TextEditor3.java
new file mode 100644
index 000000000..30a6f4e21
--- /dev/null
+++ b/src/class152/Code03_TextEditor3.java
@@ -0,0 +1,337 @@
+package class152;
+
+// 文本编辑器，能通过的java版本
+// 一开始文本为空，光标在文本开头，也就是1位置，请实现如下6种操作
+// Move k     : 将光标移动到第k个字符之后，操作保证光标不会到非法位置
+// Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
+// Delete n   : 删除光标后的n个字符，光标位置不变，操作保证有足够字符
+// Get n      : 输出光标后的n个字符，光标位置不变，操作保证有足够字符
+// Prev       : 光标前移一个字符，操作保证光标不会到非法位置
+// Next       : 光标后移一个字符，操作保证光标不会到非法位置
+// Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
+// 测试链接 : https://www.luogu.com.cn/problem/P4008
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 一个能通过的版本，连数组都自己去扩容，IO彻底重写，看看就好
+
+import java.util.Arrays;
+
+public class Code03_TextEditor3 {
+
+	static java.io.InputStream is = System.in;
+	static byte[] inbuf = new byte[1024];
+	static char[] str = new char[16];
+	static int lenbuf, ptrbuf, b;
+	static FastWriter out = new FastWriter();
+
+	static byte[] key;
+	static int[] lc, rc, sz;
+	static double[] priority;
+	static int head, no;
+
+	static int create(byte k) {
+		if (++no == key.length) {
+			key = Arrays.copyOf(key, no << 1);
+			lc = Arrays.copyOf(lc, no << 1);
+			rc = Arrays.copyOf(rc, no << 1);
+			sz = Arrays.copyOf(sz, no << 1);
+			priority = Arrays.copyOf(priority, no << 1);
+		}
+		key[no] = k;
+		sz[no] = 1;
+		priority[no] = Math.random();
+		return no;
+	}
+
+	static void up(int i) {
+		sz[i] = sz[lc[i]] + sz[rc[i]] + 1;
+	}
+
+	static void split(int l, int r, int i, int rk) {
+		if (i == 0) {
+			rc[l] = lc[r] = 0;
+			return;
+		}
+		if (sz[lc[i]] + 1 <= rk) {
+			rc[l] = i;
+			split(i, r, rc[i], rk - sz[lc[i]] - 1);
+		} else {
+			lc[r] = i;
+			split(l, i, lc[i], rk);
+		}
+		up(i);
+	}
+
+	static int merge(int l, int r) {
+		if (l == 0 || r == 0) {
+			return l + r;
+		}
+		if (priority[l] >= priority[r]) {
+			rc[l] = merge(rc[l], r);
+			up(l);
+			return l;
+		} else {
+			lc[r] = merge(l, lc[r]);
+			up(r);
+			return r;
+		}
+	}
+
+	static void inorder(int i) {
+		if (i == 0) {
+			return;
+		}
+		inorder(lc[i]);
+		out.write(key[i]);
+		inorder(rc[i]);
+	}
+
+	public static void main(String[] args) {
+		key = new byte[1];
+		lc = new int[1];
+		rc = new int[1];
+		sz = new int[1];
+		priority = new double[1];
+		int i = 0, n, l, r, lx, mx, rx;
+		byte c;
+		int op = nextInt();
+		while (op-- > 0) {
+			switch (next()) {
+			case 'M':
+				i = nextInt();
+				break;
+			case 'I':
+				split(0, 0, head, i);
+				l = rc[0];
+				r = lc[0];
+				n = nextInt();
+				while (n > 0) {
+					c = readByte();
+					if (c < 32) {
+						continue;
+					}
+					l = merge(l, create(c));
+					n--;
+				}
+				head = merge(l, r);
+				break;
+			case 'D':
+				n = nextInt();
+				l = i + 1;
+				r = i + n;
+				split(0, 0, head, i);
+				lx = rc[0];
+				mx = lc[0];
+				split(0, 0, mx, n);
+				mx = rc[0];
+				rx = lc[0];
+				head = merge(lx, rx);
+				break;
+			case 'G':
+				n = nextInt();
+				l = i + 1;
+				r = i + n;
+				split(0, 0, head, i);
+				lx = rc[0];
+				mx = lc[0];
+				split(0, 0, mx, n);
+				mx = rc[0];
+				rx = lc[0];
+				inorder(mx);
+				out.writeln();
+				head = merge(merge(lx, mx), rx);
+				break;
+			case 'P':
+				i--;
+				break;
+			default:
+				i++;
+				break;
+			}
+		}
+		out.flush();
+	}
+
+	static byte readByte() {
+		if (ptrbuf == lenbuf) {
+			ptrbuf = 0;
+			try {
+				lenbuf = is.read(inbuf);
+			} catch (Exception e) {
+			}
+			if (lenbuf <= 0)
+				return -1;
+		}
+		return inbuf[ptrbuf++];
+	}
+
+	static char next() {
+		while ((b = readByte()) < 33)
+			;
+		int i = 0;
+		while (b > 32) {
+			str[i++] = (char) b;
+			b = readByte();
+		}
+		return str[0];
+	}
+
+	static int nextInt() {
+		while ((b = readByte()) < 33)
+			;
+		int num = b - '0';
+		while ((b = readByte()) > 32)
+			num = num * 10 + (b - '0');
+		return num;
+	}
+
+	static class FastWriter {
+		java.io.OutputStream out = System.out;
+		int tr = 0, BUF_SIZE = 8192;
+		byte[] buf = new byte[BUF_SIZE];
+
+		int countDigits(int v) {
+			return v >= 100000 ? v >= 10000000 ? v >= 100000000 ? v >= 1000000000 ? 10 : 9 : 8 : v >= 1000000 ? 7 : 6
+					: v >= 1000 ? v >= 10000 ? 5 : 4 : v >= 100 ? 3 : v >= 10 ? 2 : 1;
+		}
+
+		int countDigits(long v) {
+			return v >= 10000000000L ? 10 + countDigits((int) (v / 10000000000L))
+					: v >= 1000000000 ? 10 : countDigits((int) v);
+		}
+
+		FastWriter write(byte b) {
+			buf[tr++] = b;
+			if (tr == BUF_SIZE)
+				innerflush();
+			return this;
+		}
+
+		FastWriter write(char c) {
+			return write((byte) c);
+		}
+
+		FastWriter write(int x) {
+			if (x == Integer.MIN_VALUE) {
+				return write((long) x);
+			}
+			if (tr + 12 >= BUF_SIZE)
+				innerflush();
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = tr + d - 1; i >= tr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			tr += d;
+			return this;
+		}
+
+		FastWriter write(long x) {
+			if (x == Long.MIN_VALUE) {
+				return write("" + x);
+			}
+			if (tr + 21 >= BUF_SIZE)
+				innerflush();
+			if (x < 0) {
+				write((byte) '-');
+				x = -x;
+			}
+			int d = countDigits(x);
+			for (int i = tr + d - 1; i >= tr; i--) {
+				buf[i] = (byte) ('0' + x % 10);
+				x /= 10;
+			}
+			tr += d;
+			return this;
+		}
+
+		FastWriter write(double x, int precision) {
+			if (x < 0) {
+				write('-');
+				x = -x;
+			}
+			x += Math.pow(10, -precision) / 2;
+			write((long) x).write(".");
+			x -= (long) x;
+			for (int i = 0; i < precision; i++) {
+				x *= 10;
+				write((char) ('0' + (int) x));
+				x -= (int) x;
+			}
+			return this;
+		}
+
+		FastWriter write(String s) {
+			for (int i = 0; i < s.length(); i++) {
+				buf[tr++] = (byte) s.charAt(i);
+				if (tr == BUF_SIZE)
+					innerflush();
+			}
+			return this;
+		}
+
+		void print(char c) {
+			write(c);
+		}
+
+		void print(String s) {
+			write(s);
+		}
+
+		void print(int x) {
+			write(x);
+		}
+
+		void print(long x) {
+			write(x);
+		}
+
+		void print(double x, int precision) {
+			write(x, precision);
+		}
+
+		void writeln() {
+			write((byte) '\n');
+		}
+
+		void println(char c) {
+			write(c).writeln();
+		}
+
+		void println(int x) {
+			write(x).writeln();
+		}
+
+		void println(long x) {
+			write(x).writeln();
+		}
+
+		void println(double x, int precision) {
+			write(x, precision).writeln();
+		}
+
+		void println(String s) {
+			write(s).writeln();
+		}
+
+		private void innerflush() {
+			try {
+				out.write(buf, 0, tr);
+				tr = 0;
+			} catch (Exception e) {
+			}
+		}
+
+		void flush() {
+			innerflush();
+			try {
+				out.flush();
+			} catch (Exception e) {
+			}
+		}
+	}
+
+}
\ No newline at end of file

From 948ac4c60038ae21d8679f390246a6cdeb976b18 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 14 Jun 2025 21:03:06 +0800
Subject: [PATCH 0962/1712] modify code

---
 src/class152/Code03_TextEditor3.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class152/Code03_TextEditor3.java b/src/class152/Code03_TextEditor3.java
index 30a6f4e21..3bc940299 100644
--- a/src/class152/Code03_TextEditor3.java
+++ b/src/class152/Code03_TextEditor3.java
@@ -11,7 +11,7 @@
 // Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-// 一个能通过的版本，连数组都自己去扩容，IO彻底重写，看看就好
+// 一个能通过的版本，连数组都自己写扩容逻辑，IO彻底重写，看看就好
 
 import java.util.Arrays;
 

From 9af463df079237b26124c92ec9e2f1f17b8d8400 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 13:41:58 +0800
Subject: [PATCH 0963/1712] modify code

---
 src/class148/Code01_AVL2.java                  | 16 ++++++++--------
 src/class148/FollowUp2.java                    | 16 ++++++++--------
 src/class150/Code02_ScapeGoat2.java            | 18 +++++++++---------
 src/class150/FollowUp2.java                    | 18 +++++++++---------
 src/class151/Code02_Treap2.java                | 16 ++++++++--------
 src/class151/FollowUp2.java                    | 16 ++++++++--------
 src/class152/Code01_FHQTreapWithCount2.java    | 14 +++++++-------
 src/class152/Code02_FHQTreapWithoutCount2.java | 14 +++++++-------
 src/class152/Code03_TextEditor2.java           | 10 +++++-----
 src/class152/Code04_LiteraryTree2.java         | 10 +++++-----
 src/class152/Code05_PersistentFHQTreap2.java   | 16 ++++++++--------
 .../Code06_PersistentLiteraryTree2.java        | 12 ++++++------
 src/class152/FollowUp2.java                    | 14 +++++++-------
 src/class153/Code01_Splay2.java                | 14 +++++++-------
 src/class153/Code02_FrustratedCashier2.java    | 18 +++++++++---------
 src/class153/Code03_LiteraryTree2.java         | 12 ++++++------
 src/class153/Code04_Bookcase2.java             | 14 +++++++-------
 src/class153/Code05_MaintainSequence2.java     | 14 +++++++-------
 src/class153/FollowUp2.java                    | 14 +++++++-------
 src/class157/Code02_PointPersistent2.java      | 12 ++++++------
 src/class158/Code04_CountOnTree2.java          | 12 ++++++------
 src/class159/Code03_PathDfnXor2.java           |  8 ++++----
 src/class159/Code04_Yummy2.java                |  8 ++++----
 src/class160/Code07_NetworkManagement2.java    | 12 ++++++------
 24 files changed, 164 insertions(+), 164 deletions(-)

diff --git a/src/class148/Code01_AVL2.java b/src/class148/Code01_AVL2.java
index 4202633de..4a953d651 100644
--- a/src/class148/Code01_AVL2.java
+++ b/src/class148/Code01_AVL2.java
@@ -30,10 +30,10 @@
 //int ls[MAXN];
 //int rs[MAXN];
 //int key_count[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + key_count[i];
 //    height[i] = max(height[ls[i]], height[rs[i]]) + 1;
 //}
 //
@@ -79,7 +79,7 @@
 //int add(int i, int num) {
 //    if (i == 0) {
 //        key[++cnt] = num;
-//        key_count[cnt] = size[cnt] = height[cnt] = 1;
+//        key_count[cnt] = siz[cnt] = height[cnt] = 1;
 //        return cnt;
 //    }
 //    if (key[i] == num) {
@@ -104,7 +104,7 @@
 //    if (key[i] >= num) {
 //        return getRank(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + getRank(rs[i], num);
+//        return siz[ls[i]] + key_count[i] + getRank(rs[i], num);
 //    }
 //}
 //
@@ -160,10 +160,10 @@
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    } else if (siz[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - siz[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
@@ -208,7 +208,7 @@
 //    memset(ls + 1, 0, cnt * sizeof(int));
 //    memset(rs + 1, 0, cnt * sizeof(int));
 //    memset(key_count + 1, 0, cnt * sizeof(int));
-//    memset(size + 1, 0, cnt * sizeof(int));
+//    memset(siz + 1, 0, cnt * sizeof(int));
 //    cnt = 0;
 //    head = 0;
 //}
diff --git a/src/class148/FollowUp2.java b/src/class148/FollowUp2.java
index eb9844f80..192218118 100644
--- a/src/class148/FollowUp2.java
+++ b/src/class148/FollowUp2.java
@@ -23,10 +23,10 @@
 //int ls[MAXN];
 //int rs[MAXN];
 //int key_count[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + key_count[i];
 //    height[i] = max(height[ls[i]], height[rs[i]]) + 1;
 //}
 //
@@ -72,7 +72,7 @@
 //int add(int i, int num) {
 //    if (i == 0) {
 //        key[++cnt] = num;
-//        key_count[cnt] = size[cnt] = height[cnt] = 1;
+//        key_count[cnt] = siz[cnt] = height[cnt] = 1;
 //        return cnt;
 //    }
 //    if (key[i] == num) {
@@ -97,7 +97,7 @@
 //    if (key[i] >= num) {
 //        return getRank(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + getRank(rs[i], num);
+//        return siz[ls[i]] + key_count[i] + getRank(rs[i], num);
 //    }
 //}
 //
@@ -153,10 +153,10 @@
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    } else if (siz[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - siz[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
@@ -201,7 +201,7 @@
 //    memset(ls + 1, 0, cnt * sizeof(int));
 //    memset(rs + 1, 0, cnt * sizeof(int));
 //    memset(key_count + 1, 0, cnt * sizeof(int));
-//    memset(size + 1, 0, cnt * sizeof(int));
+//    memset(siz + 1, 0, cnt * sizeof(int));
 //    cnt = 0;
 //    head = 0;
 //}
diff --git a/src/class150/Code02_ScapeGoat2.java b/src/class150/Code02_ScapeGoat2.java
index 16bfe5f75..6cd87753c 100644
--- a/src/class150/Code02_ScapeGoat2.java
+++ b/src/class150/Code02_ScapeGoat2.java
@@ -31,7 +31,7 @@
 //int key_count[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //int diff[MAXN];
 //int collect[MAXN];
 //int ci;
@@ -42,12 +42,12 @@
 //int init(int num) {
 //    key[++cnt] = num;
 //    ls[cnt] = rs[cnt] = 0;
-//    key_count[cnt] = size[cnt] = diff[cnt] = 1;
+//    key_count[cnt] = siz[cnt] = diff[cnt] = 1;
 //    return cnt;
 //}
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + key_count[i];
 //    diff[i] = diff[ls[i]] + diff[rs[i]] + (key_count[i] > 0 ? 1 : 0);
 //}
 //
@@ -132,7 +132,7 @@
 //    if (key[i] >= num) {
 //        return small(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//        return siz[ls[i]] + key_count[i] + small(rs[i], num);
 //    }
 //}
 //
@@ -141,10 +141,10 @@
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    } else if (siz[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - siz[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
@@ -164,7 +164,7 @@
 //
 //int post(int num) {
 //    int kth = getRank(num + 1);
-//    if (kth == size[head] + 1) {
+//    if (kth == siz[head] + 1) {
 //        return INT_MAX;
 //    } else {
 //        return index(kth);
@@ -200,7 +200,7 @@
 //    memset(key_count, 0, sizeof(key_count));
 //    memset(ls, 0, sizeof(ls));
 //    memset(rs, 0, sizeof(rs));
-//    memset(size, 0, sizeof(size));
+//    memset(siz, 0, sizeof(siz));
 //    memset(diff, 0, sizeof(diff));
 //    cnt = 0;
 //    head = 0;
diff --git a/src/class150/FollowUp2.java b/src/class150/FollowUp2.java
index 8fe8f4e6f..e3acc4376 100644
--- a/src/class150/FollowUp2.java
+++ b/src/class150/FollowUp2.java
@@ -24,7 +24,7 @@
 //int key_count[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //int diff[MAXN];
 //int collect[MAXN];
 //int ci;
@@ -35,12 +35,12 @@
 //int init(int num) {
 //    key[++cnt] = num;
 //    ls[cnt] = rs[cnt] = 0;
-//    key_count[cnt] = size[cnt] = diff[cnt] = 1;
+//    key_count[cnt] = siz[cnt] = diff[cnt] = 1;
 //    return cnt;
 //}
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + key_count[i];
 //    diff[i] = diff[ls[i]] + diff[rs[i]] + (key_count[i] > 0 ? 1 : 0);
 //}
 //
@@ -125,7 +125,7 @@
 //    if (key[i] >= num) {
 //        return small(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//        return siz[ls[i]] + key_count[i] + small(rs[i], num);
 //    }
 //}
 //
@@ -134,10 +134,10 @@
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    } else if (siz[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - siz[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
@@ -157,7 +157,7 @@
 //
 //int post(int num) {
 //    int kth = getRank(num + 1);
-//    if (kth == size[head] + 1) {
+//    if (kth == siz[head] + 1) {
 //        return INT_MAX;
 //    } else {
 //        return index(kth);
@@ -193,7 +193,7 @@
 //    memset(key_count, 0, sizeof(key_count));
 //    memset(ls, 0, sizeof(ls));
 //    memset(rs, 0, sizeof(rs));
-//    memset(size, 0, sizeof(size));
+//    memset(siz, 0, sizeof(siz));
 //    memset(diff, 0, sizeof(diff));
 //    cnt = 0;
 //    head = 0;
diff --git a/src/class151/Code02_Treap2.java b/src/class151/Code02_Treap2.java
index ef8b276da..00a4449bf 100644
--- a/src/class151/Code02_Treap2.java
+++ b/src/class151/Code02_Treap2.java
@@ -30,11 +30,11 @@
 //int key_count[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //double priority[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + key_count[i];
 //}
 //
 //int leftRotate(int i) {
@@ -58,7 +58,7 @@
 //int add(int i, int num) {
 //    if (i == 0) {
 //        key[++cnt] = num;
-//        key_count[cnt] = size[cnt] = 1;
+//        key_count[cnt] = siz[cnt] = 1;
 //        priority[cnt] = static_cast<double>(rand()) / RAND_MAX;
 //        return cnt;
 //    }
@@ -90,7 +90,7 @@
 //    if (key[i] >= num) {
 //        return small(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//        return siz[ls[i]] + key_count[i] + small(rs[i], num);
 //    }
 //}
 //
@@ -99,10 +99,10 @@
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    } else if (siz[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - siz[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
@@ -182,7 +182,7 @@
 //    fill(key_count + 1, key_count + cnt + 1, 0);
 //    fill(ls + 1, ls + cnt + 1, 0);
 //    fill(rs + 1, rs + cnt + 1, 0);
-//    fill(size + 1, size + cnt + 1, 0);
+//    fill(siz + 1, siz + cnt + 1, 0);
 //    fill(priority + 1, priority + cnt + 1, 0);
 //    cnt = 0;
 //    head = 0;
diff --git a/src/class151/FollowUp2.java b/src/class151/FollowUp2.java
index 6c8793e42..da9078481 100644
--- a/src/class151/FollowUp2.java
+++ b/src/class151/FollowUp2.java
@@ -23,11 +23,11 @@
 //int key_count[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //double priority[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + key_count[i];
 //}
 //
 //int leftRotate(int i) {
@@ -51,7 +51,7 @@
 //int add(int i, int num) {
 //    if (i == 0) {
 //        key[++cnt] = num;
-//        key_count[cnt] = size[cnt] = 1;
+//        key_count[cnt] = siz[cnt] = 1;
 //        priority[cnt] = static_cast<double>(rand()) / RAND_MAX;
 //        return cnt;
 //    }
@@ -83,7 +83,7 @@
 //    if (key[i] >= num) {
 //        return small(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//        return siz[ls[i]] + key_count[i] + small(rs[i], num);
 //    }
 //}
 //
@@ -92,10 +92,10 @@
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    } else if (siz[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - siz[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
@@ -175,7 +175,7 @@
 //    fill(key_count + 1, key_count + cnt + 1, 0);
 //    fill(ls + 1, ls + cnt + 1, 0);
 //    fill(rs + 1, rs + cnt + 1, 0);
-//    fill(size + 1, size + cnt + 1, 0);
+//    fill(siz + 1, siz + cnt + 1, 0);
 //    fill(priority + 1, priority + cnt + 1, 0);
 //    cnt = 0;
 //    head = 0;
diff --git a/src/class152/Code01_FHQTreapWithCount2.java b/src/class152/Code01_FHQTreapWithCount2.java
index dc5804004..f1e908a20 100644
--- a/src/class152/Code01_FHQTreapWithCount2.java
+++ b/src/class152/Code01_FHQTreapWithCount2.java
@@ -29,11 +29,11 @@
 //int key_count[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //double priority[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + key_count[i];
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + key_count[i];
 //}
 //
 //void split(int l, int r, int i, int num) {
@@ -96,7 +96,7 @@
 //    } else {
 //        split(0, 0, head, num);
 //        key[++cnt] = num;
-//        key_count[cnt] = size[cnt] = 1;
+//        key_count[cnt] = siz[cnt] = 1;
 //        priority[cnt] = (double)rand() / RAND_MAX;
 //        head = merge(merge(rs[0], cnt), ls[0]);
 //    }
@@ -125,7 +125,7 @@
 //    if (key[i] >= num) {
 //        return small(ls[i], num);
 //    } else {
-//        return size[ls[i]] + key_count[i] + small(rs[i], num);
+//        return siz[ls[i]] + key_count[i] + small(rs[i], num);
 //    }
 //}
 //
@@ -134,10 +134,10 @@
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + key_count[i] < x) {
-//        return index(rs[i], x - size[ls[i]] - key_count[i]);
+//    } else if (siz[ls[i]] + key_count[i] < x) {
+//        return index(rs[i], x - siz[ls[i]] - key_count[i]);
 //    }
 //    return key[i];
 //}
diff --git a/src/class152/Code02_FHQTreapWithoutCount2.java b/src/class152/Code02_FHQTreapWithoutCount2.java
index 9655a7fd3..b74f202c0 100644
--- a/src/class152/Code02_FHQTreapWithoutCount2.java
+++ b/src/class152/Code02_FHQTreapWithoutCount2.java
@@ -28,11 +28,11 @@
 //int key[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //double priority[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //void split(int l, int r, int i, int num) {
@@ -68,7 +68,7 @@
 //void add(int num) {
 //    split(0, 0, head, num);
 //    key[++cnt] = num;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    priority[cnt] = (double)rand() / RAND_MAX;
 //    head = merge(merge(rs[0], cnt), ls[0]);
 //}
@@ -85,16 +85,16 @@
 //
 //int getRank(int num) {
 //    split(0, 0, head, num - 1);
-//    int ans = size[rs[0]] + 1;
+//    int ans = siz[rs[0]] + 1;
 //    head = merge(rs[0], ls[0]);
 //    return ans;
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + 1 < x) {
-//        return index(rs[i], x - size[ls[i]] - 1);
+//    } else if (siz[ls[i]] + 1 < x) {
+//        return index(rs[i], x - siz[ls[i]] - 1);
 //    } else {
 //        return key[i];
 //    }
diff --git a/src/class152/Code03_TextEditor2.java b/src/class152/Code03_TextEditor2.java
index cb3bd74ef..b3e6f98aa 100644
--- a/src/class152/Code03_TextEditor2.java
+++ b/src/class152/Code03_TextEditor2.java
@@ -27,22 +27,22 @@
 //char key[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //double priority[MAXN];
 //char ans[MAXN];
 //int ansi;
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //void split(int l, int r, int i, int rank) {
 //    if (i == 0) {
 //        rs[l] = ls[r] = 0;
 //    } else {
-//        if (size[ls[i]] + 1 <= rank) {
+//        if (siz[ls[i]] + 1 <= rank) {
 //            rs[l] = i;
-//            split(i, r, rs[i], rank - size[ls[i]] - 1);
+//            split(i, r, rs[i], rank - siz[ls[i]] - 1);
 //        } else {
 //            ls[r] = i;
 //            split(l, i, ls[i], rank);
@@ -99,7 +99,7 @@
 //                    ch = getchar();
 //                }
 //                key[++cnt] = ch;
-//                size[cnt] = 1;
+//                siz[cnt] = 1;
 //                priority[cnt] = (double)rand() / RAND_MAX;
 //                l = merge(l, cnt);
 //            }
diff --git a/src/class152/Code04_LiteraryTree2.java b/src/class152/Code04_LiteraryTree2.java
index ce492e41e..2903de582 100644
--- a/src/class152/Code04_LiteraryTree2.java
+++ b/src/class152/Code04_LiteraryTree2.java
@@ -25,14 +25,14 @@
 //int key[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //double priority[MAXN];
 //bool rev[MAXN];
 //int ans[MAXN];
 //int ansi;
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //void down(int i) {
@@ -49,9 +49,9 @@
 //        rs[l] = ls[r] = 0;
 //    } else {
 //        down(i);
-//        if (size[ls[i]] + 1 <= rank) {
+//        if (siz[ls[i]] + 1 <= rank) {
 //            rs[l] = i;
-//            split(i, r, rs[i], rank - size[ls[i]] - 1);
+//            split(i, r, rs[i], rank - siz[ls[i]] - 1);
 //        } else {
 //            ls[r] = i;
 //            split(l, i, ls[i], rank);
@@ -94,7 +94,7 @@
 //    cin >> n >> k;
 //    for (int i = 1; i <= n; i++) {
 //        key[++cnt] = i;
-//        size[cnt] = 1;
+//        siz[cnt] = 1;
 //        priority[cnt] = (double)rand() / RAND_MAX;
 //        head = merge(head, cnt);
 //    }
diff --git a/src/class152/Code05_PersistentFHQTreap2.java b/src/class152/Code05_PersistentFHQTreap2.java
index 6ae238d6f..c0be77e6c 100644
--- a/src/class152/Code05_PersistentFHQTreap2.java
+++ b/src/class152/Code05_PersistentFHQTreap2.java
@@ -33,7 +33,7 @@
 //int key[MAXM];
 //int ls[MAXM];
 //int rs[MAXM];
-//int size[MAXM];
+//int siz[MAXM];
 //double priority[MAXM];
 //
 //int copy(int i) {
@@ -41,13 +41,13 @@
 //    key[cnt] = key[i];
 //    ls[cnt] = ls[i];
 //    rs[cnt] = rs[i];
-//    size[cnt] = size[i];
+//    siz[cnt] = siz[i];
 //    priority[cnt] = priority[i];
 //    return cnt;
 //}
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //void split(int l, int r, int i, int num) {
@@ -90,7 +90,7 @@
 //    ls[0] = rs[0] = 0;
 //    ++cnt;
 //    key[cnt] = num;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    priority[cnt] = (double)rand() / RAND_MAX;
 //    head[v] = merge(merge(l, cnt), r);
 //}
@@ -113,15 +113,15 @@
 //    if (key[i] >= num) {
 //        return small(ls[i], num);
 //    } else {
-//        return size[ls[i]] + 1 + small(rs[i], num);
+//        return siz[ls[i]] + 1 + small(rs[i], num);
 //    }
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + 1 < x) {
-//        return index(rs[i], x - size[ls[i]] - 1);
+//    } else if (siz[ls[i]] + 1 < x) {
+//        return index(rs[i], x - siz[ls[i]] - 1);
 //    } else {
 //        return key[i];
 //    }
diff --git a/src/class152/Code06_PersistentLiteraryTree2.java b/src/class152/Code06_PersistentLiteraryTree2.java
index 80a34595f..0793043fb 100644
--- a/src/class152/Code06_PersistentLiteraryTree2.java
+++ b/src/class152/Code06_PersistentLiteraryTree2.java
@@ -28,7 +28,7 @@
 //int key[MAXM];
 //int ls[MAXM];
 //int rs[MAXM];
-//int size[MAXM];
+//int siz[MAXM];
 //bool rev[MAXM];
 //long long sum[MAXM];
 //double priority[MAXM];
@@ -37,7 +37,7 @@
 //    key[++cnt] = key[i];
 //    ls[cnt] = ls[i];
 //    rs[cnt] = rs[i];
-//    size[cnt] = size[i];
+//    siz[cnt] = siz[i];
 //    rev[cnt] = rev[i];
 //    sum[cnt] = sum[i];
 //    priority[cnt] = priority[i];
@@ -45,7 +45,7 @@
 //}
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //    sum[i] = sum[ls[i]] + sum[rs[i]] + key[i];
 //}
 //
@@ -70,9 +70,9 @@
 //    } else {
 //        i = copy(i);
 //        down(i);
-//        if (size[ls[i]] + 1 <= rank) {
+//        if (siz[ls[i]] + 1 <= rank) {
 //            rs[l] = i;
-//            split(i, r, rs[i], rank - size[ls[i]] - 1);
+//            split(i, r, rs[i], rank - siz[ls[i]] - 1);
 //        } else {
 //            ls[r] = i;
 //            split(l, i, ls[i], rank);
@@ -123,7 +123,7 @@
 //            r = ls[0];
 //            ls[0] = rs[0] = 0;
 //            key[++cnt] = y;
-//            size[cnt] = 1;
+//            siz[cnt] = 1;
 //            sum[cnt] = y;
 //            priority[cnt] = (double)rand() / RAND_MAX;
 //            head[i] = merge(merge(l, cnt), r);
diff --git a/src/class152/FollowUp2.java b/src/class152/FollowUp2.java
index 1ac7e8b72..758bc8f5e 100644
--- a/src/class152/FollowUp2.java
+++ b/src/class152/FollowUp2.java
@@ -21,11 +21,11 @@
 //int key[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //double priority[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //void split(int l, int r, int i, int num) {
@@ -61,7 +61,7 @@
 //void add(int num) {
 //    split(0, 0, head, num);
 //    key[++cnt] = num;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    priority[cnt] = (double)rand() / RAND_MAX;
 //    head = merge(merge(rs[0], cnt), ls[0]);
 //}
@@ -78,16 +78,16 @@
 //
 //int getRank(int num) {
 //    split(0, 0, head, num - 1);
-//    int ans = size[rs[0]] + 1;
+//    int ans = siz[rs[0]] + 1;
 //    head = merge(rs[0], ls[0]);
 //    return ans;
 //}
 //
 //int index(int i, int x) {
-//    if (size[ls[i]] >= x) {
+//    if (siz[ls[i]] >= x) {
 //        return index(ls[i], x);
-//    } else if (size[ls[i]] + 1 < x) {
-//        return index(rs[i], x - size[ls[i]] - 1);
+//    } else if (siz[ls[i]] + 1 < x) {
+//        return index(rs[i], x - siz[ls[i]] - 1);
 //    } else {
 //        return key[i];
 //    }
diff --git a/src/class153/Code01_Splay2.java b/src/class153/Code01_Splay2.java
index b00ee7ba7..c8a18e59a 100644
--- a/src/class153/Code01_Splay2.java
+++ b/src/class153/Code01_Splay2.java
@@ -29,10 +29,10 @@
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //int lr(int i) {
@@ -89,12 +89,12 @@
 //int find(int rank) {
 //    int i = head;
 //    while (i != 0) {
-//        if (size[ls[i]] + 1 == rank) {
+//        if (siz[ls[i]] + 1 == rank) {
 //            return i;
-//        } else if (size[ls[i]] >= rank) {
+//        } else if (siz[ls[i]] >= rank) {
 //            i = ls[i];
 //        } else {
-//            rank -= size[ls[i]] + 1;
+//            rank -= siz[ls[i]] + 1;
 //            i = rs[i];
 //        }
 //    }
@@ -103,7 +103,7 @@
 //
 //void add(int num) {
 //    key[++cnt] = num;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    if (head == 0) {
 //        head = cnt;
 //    } else {
@@ -136,7 +136,7 @@
 //        if (key[i] >= num) {
 //            i = ls[i];
 //        } else {
-//            ans += size[ls[i]] + 1;
+//            ans += siz[ls[i]] + 1;
 //            i = rs[i];
 //        }
 //    }
diff --git a/src/class153/Code02_FrustratedCashier2.java b/src/class153/Code02_FrustratedCashier2.java
index 00850dfc5..4324c0dc7 100644
--- a/src/class153/Code02_FrustratedCashier2.java
+++ b/src/class153/Code02_FrustratedCashier2.java
@@ -24,13 +24,13 @@
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //int limit;
 //int change = 0;
 //int enter = 0;
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //int lr(int i) {
@@ -86,7 +86,7 @@
 //
 //void add(int num) {
 //    key[++cnt] = num;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    if (head == 0) {
 //        head = cnt;
 //    } else {
@@ -115,10 +115,10 @@
 //    int i = head, last = head;
 //    while (i != 0) {
 //        last = i;
-//        if (size[ls[i]] >= x) {
+//        if (siz[ls[i]] >= x) {
 //            i = ls[i];
-//        } else if (size[ls[i]] + 1 < x) {
-//            x -= size[ls[i]] + 1;
+//        } else if (siz[ls[i]] + 1 < x) {
+//            x -= siz[ls[i]] + 1;
 //            i = rs[i];
 //        } else {
 //            i = 0;
@@ -167,13 +167,13 @@
 //            change -= x;
 //            departure();
 //        } else if (op == 'F') {
-//            if (x > size[head]) {
+//            if (x > siz[head]) {
 //                cout << -1 << endl;
 //            } else {
-//                cout << index(size[head] - x + 1) + change << endl;
+//                cout << index(siz[head] - x + 1) + change << endl;
 //            }
 //        }
 //    }
-//    cout << enter - size[head] << endl;
+//    cout << enter - siz[head] << endl;
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class153/Code03_LiteraryTree2.java b/src/class153/Code03_LiteraryTree2.java
index e1fc072c0..6732ac8e4 100644
--- a/src/class153/Code03_LiteraryTree2.java
+++ b/src/class153/Code03_LiteraryTree2.java
@@ -21,7 +21,7 @@
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //bool rev[MAXN];
 //int sta[MAXN];
 //int si;
@@ -29,7 +29,7 @@
 //int ai;
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //int lr(int i) {
@@ -98,12 +98,12 @@
 //    int i = head;
 //    while (i != 0) {
 //        down(i);
-//        if (size[ls[i]] + 1 == rank) {
+//        if (siz[ls[i]] + 1 == rank) {
 //            return i;
-//        } else if (size[ls[i]] >= rank) {
+//        } else if (siz[ls[i]] >= rank) {
 //            i = ls[i];
 //        } else {
-//            rank -= size[ls[i]] + 1;
+//            rank -= siz[ls[i]] + 1;
 //            i = rs[i];
 //        }
 //    }
@@ -112,7 +112,7 @@
 //
 //void add(int x) {
 //    num[++cnt] = x;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    fa[cnt] = head;
 //    rs[head] = cnt;
 //    splay(cnt, 0);
diff --git a/src/class153/Code04_Bookcase2.java b/src/class153/Code04_Bookcase2.java
index d9a81bb32..820e1a07e 100644
--- a/src/class153/Code04_Bookcase2.java
+++ b/src/class153/Code04_Bookcase2.java
@@ -25,11 +25,11 @@
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //int pos[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //int lr(int i) {
@@ -86,12 +86,12 @@
 //int find(int rank) {
 //    int i = head;
 //    while (i != 0) {
-//        if (size[ls[i]] + 1 == rank) {
+//        if (siz[ls[i]] + 1 == rank) {
 //            return i;
-//        } else if (size[ls[i]] >= rank) {
+//        } else if (siz[ls[i]] >= rank) {
 //            i = ls[i];
 //        } else {
-//            rank -= size[ls[i]] + 1;
+//            rank -= siz[ls[i]] + 1;
 //            i = rs[i];
 //        }
 //    }
@@ -101,7 +101,7 @@
 //void add(int s) {
 //    num[++cnt] = s;
 //    pos[s] = cnt;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    fa[cnt] = head;
 //    rs[head] = cnt;
 //    splay(cnt, 0);
@@ -110,7 +110,7 @@
 //int ask(int s) {
 //    int i = pos[s];
 //    splay(i, 0);
-//    return size[ls[i]];
+//    return siz[ls[i]];
 //}
 //
 //int query(int s) {
diff --git a/src/class153/Code05_MaintainSequence2.java b/src/class153/Code05_MaintainSequence2.java
index 8c4255941..5ae0341d5 100644
--- a/src/class153/Code05_MaintainSequence2.java
+++ b/src/class153/Code05_MaintainSequence2.java
@@ -27,7 +27,7 @@
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //int space[MAXN], si;
 //int sum[MAXN];
 //int all[MAXN];
@@ -39,7 +39,7 @@
 //
 //void up(int i) {
 //    int l = ls[i], r = rs[i];
-//    size[i] = size[l] + size[r] + 1;
+//    siz[i] = siz[l] + siz[r] + 1;
 //    sum[i] = sum[l] + sum[r] + num[i];
 //    all[i] = max(max(all[l], all[r]), suf[l] + num[i] + pre[r]);
 //    pre[i] = max(pre[l], sum[l] + num[i] + pre[r]);
@@ -100,7 +100,7 @@
 //        update[i] = true;
 //        change[i] = val;
 //        num[i] = val;
-//        sum[i] = size[i] * val;
+//        sum[i] = siz[i] * val;
 //        all[i] = max(sum[i], val);
 //        pre[i] = max(sum[i], 0);
 //        suf[i] = max(sum[i], 0);
@@ -130,7 +130,7 @@
 //
 //int init(int val) {
 //    int i = space[si--];
-//    size[i] = 1;
+//    siz[i] = 1;
 //    num[i] = sum[i] = all[i] = val;
 //    pre[i] = suf[i] = max(val, 0);
 //    fa[i] = ls[i] = rs[i] = 0;
@@ -157,12 +157,12 @@
 //    int i = head;
 //    while (i != 0) {
 //        down(i);
-//        if (size[ls[i]] + 1 == rank) {
+//        if (siz[ls[i]] + 1 == rank) {
 //            return i;
-//        } else if (size[ls[i]] >= rank) {
+//        } else if (siz[ls[i]] >= rank) {
 //            i = ls[i];
 //        } else {
-//            rank -= size[ls[i]] + 1;
+//            rank -= siz[ls[i]] + 1;
 //            i = rs[i];
 //        }
 //    }
diff --git a/src/class153/FollowUp2.java b/src/class153/FollowUp2.java
index 13f127ab1..aeabae2b5 100644
--- a/src/class153/FollowUp2.java
+++ b/src/class153/FollowUp2.java
@@ -22,10 +22,10 @@
 //int fa[MAXN];
 //int ls[MAXN];
 //int rs[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //
 //void up(int i) {
-//    size[i] = size[ls[i]] + size[rs[i]] + 1;
+//    siz[i] = siz[ls[i]] + siz[rs[i]] + 1;
 //}
 //
 //int lr(int i) {
@@ -82,12 +82,12 @@
 //int find(int rank) {
 //    int i = head;
 //    while (i != 0) {
-//        if (size[ls[i]] + 1 == rank) {
+//        if (siz[ls[i]] + 1 == rank) {
 //            return i;
-//        } else if (size[ls[i]] >= rank) {
+//        } else if (siz[ls[i]] >= rank) {
 //            i = ls[i];
 //        } else {
-//            rank -= size[ls[i]] + 1;
+//            rank -= siz[ls[i]] + 1;
 //            i = rs[i];
 //        }
 //    }
@@ -96,7 +96,7 @@
 //
 //void add(int num) {
 //    key[++cnt] = num;
-//    size[cnt] = 1;
+//    siz[cnt] = 1;
 //    if (head == 0) {
 //        head = cnt;
 //    } else {
@@ -129,7 +129,7 @@
 //        if (key[i] >= num) {
 //            i = ls[i];
 //        } else {
-//            ans += size[ls[i]] + 1;
+//            ans += siz[ls[i]] + 1;
 //            i = rs[i];
 //        }
 //    }
diff --git a/src/class157/Code02_PointPersistent2.java b/src/class157/Code02_PointPersistent2.java
index 31e5b9ca5..ca417a518 100644
--- a/src/class157/Code02_PointPersistent2.java
+++ b/src/class157/Code02_PointPersistent2.java
@@ -21,7 +21,7 @@
 //int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
-//int size[MAXT];
+//int siz[MAXT];
 //int cnt;
 //
 //int kth(int num) {
@@ -40,7 +40,7 @@
 //
 //int build(int l, int r) {
 //    int rt = ++cnt;
-//    size[rt] = 0;
+//    siz[rt] = 0;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        ls[rt] = build(l, mid);
@@ -53,7 +53,7 @@
 //    int rt = ++cnt;
 //    ls[rt] = ls[i];
 //    rs[rt] = rs[i];
-//    size[rt] = size[i] + 1;
+//    siz[rt] = siz[i] + 1;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
@@ -69,12 +69,12 @@
 //    if (l == r) {
 //        return l;
 //    }
-//    int lsize = size[ls[v]] - size[ls[u]];
+//    int lsiz = siz[ls[v]] - siz[ls[u]];
 //    int mid = (l + r) / 2;
-//    if (lsize >= jobk) {
+//    if (lsiz >= jobk) {
 //        return query(jobk, l, mid, ls[u], ls[v]);
 //    } else {
-//        return query(jobk - lsize, mid + 1, r, rs[u], rs[v]);
+//        return query(jobk - lsiz, mid + 1, r, rs[u], rs[v]);
 //    }
 //}
 //
diff --git a/src/class158/Code04_CountOnTree2.java b/src/class158/Code04_CountOnTree2.java
index af273f7ed..02682b396 100644
--- a/src/class158/Code04_CountOnTree2.java
+++ b/src/class158/Code04_CountOnTree2.java
@@ -33,7 +33,7 @@
 //int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
-//int size[MAXT];
+//int siz[MAXT];
 //int cntt = 0;
 //
 //int deep[MAXN];
@@ -56,7 +56,7 @@
 //
 //int build(int l, int r) {
 //    int rt = ++cntt;
-//    size[rt] = 0;
+//    siz[rt] = 0;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        ls[rt] = build(l, mid);
@@ -89,7 +89,7 @@
 //    int rt = ++cntt;
 //    ls[rt] = ls[i];
 //    rs[rt] = rs[i];
-//    size[rt] = size[i] + 1;
+//    siz[rt] = siz[i] + 1;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
@@ -105,12 +105,12 @@
 //    if (l == r) {
 //        return l;
 //    }
-//    int lsize = size[ls[u]] + size[ls[v]] - size[ls[lca]] - size[ls[lcafa]];
+//    int lsiz = siz[ls[u]] + siz[ls[v]] - siz[ls[lca]] - siz[ls[lcafa]];
 //    int mid = (l + r) / 2;
-//    if (lsize >= jobk) {
+//    if (lsiz >= jobk) {
 //        return query(jobk, l, mid, ls[u], ls[v], ls[lca], ls[lcafa]);
 //    } else {
-//        return query(jobk - lsize, mid + 1, r, rs[u], rs[v], rs[lca], rs[lcafa]);
+//        return query(jobk - lsiz, mid + 1, r, rs[u], rs[v], rs[lca], rs[lcafa]);
 //    }
 //}
 //
diff --git a/src/class159/Code03_PathDfnXor2.java b/src/class159/Code03_PathDfnXor2.java
index e899a01a8..408cf9be3 100644
--- a/src/class159/Code03_PathDfnXor2.java
+++ b/src/class159/Code03_PathDfnXor2.java
@@ -28,7 +28,7 @@
 //int cntg = 0;
 //
 //int deep[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //int stjump[MAXN][MAXH];
 //int dfn[MAXN];
 //int cntd = 0;
@@ -81,7 +81,7 @@
 //
 //void dfs1(int u, int fa) {
 //    deep[u] = deep[fa] + 1;
-//    size[u] = 1;
+//    siz[u] = 1;
 //    stjump[u][0] = fa;
 //    dfn[u] = ++cntd;
 //    for (int p = 1; p < MAXH; p++) {
@@ -91,7 +91,7 @@
 //        v = to[ei];
 //        if (v != fa) {
 //            dfs1(v, u);
-//            size[u] += size[v];
+//            siz[u] += siz[v];
 //        }
 //    }
 //}
@@ -144,7 +144,7 @@
 //    for (int i = 1, op, x, y, z; i <= m; i++) {
 //        cin >> op >> x >> y;
 //        if (op == 1) {
-//            cout << query(y, root1[dfn[x] - 1], root1[dfn[x] + size[x] - 1]) << '\n';
+//            cout << query(y, root1[dfn[x] - 1], root1[dfn[x] + siz[x] - 1]) << '\n';
 //        } else {
 //            cin >> z;
 //            int lcafa = stjump[lca(x, y)][0];
diff --git a/src/class159/Code04_Yummy2.java b/src/class159/Code04_Yummy2.java
index 18a567473..c63f538c1 100644
--- a/src/class159/Code04_Yummy2.java
+++ b/src/class159/Code04_Yummy2.java
@@ -22,12 +22,12 @@
 //int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
-//int size[MAXT];
+//int siz[MAXT];
 //int cnt;
 //
 //int build(int l, int r) {
 //    int rt = ++cnt;
-//    size[rt] = 0;
+//    siz[rt] = 0;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        ls[rt] = build(l, mid);
@@ -40,7 +40,7 @@
 //    int rt = ++cnt;
 //    ls[rt] = ls[i];
 //    rs[rt] = rs[i];
-//    size[rt] = size[i] + 1;
+//    siz[rt] = siz[i] + 1;
 //    if (l < r) {
 //        int mid = (l + r) / 2;
 //        if (jobi <= mid) {
@@ -57,7 +57,7 @@
 //        return 0;
 //    }
 //    if (jobl <= l && r <= jobr) {
-//        return size[v] - size[u];
+//        return siz[v] - siz[u];
 //    }
 //    int mid = (l + r) / 2;
 //    int ans = 0;
diff --git a/src/class160/Code07_NetworkManagement2.java b/src/class160/Code07_NetworkManagement2.java
index b29cb49dd..95f26f8dd 100644
--- a/src/class160/Code07_NetworkManagement2.java
+++ b/src/class160/Code07_NetworkManagement2.java
@@ -37,7 +37,7 @@
 //int cntt;
 //
 //int deep[MAXN];
-//int size[MAXN];
+//int siz[MAXN];
 //int dfn[MAXN];
 //int stjump[MAXN][MAXH];
 //int cntd;
@@ -69,7 +69,7 @@
 //
 //void dfs(int u, int fa) {
 //    deep[u] = deep[fa] + 1;
-//    size[u] = 1;
+//    siz[u] = 1;
 //    dfn[u] = ++cntd;
 //    stjump[u][0] = fa;
 //    for (int p = 1; p < MAXH; p++) {
@@ -79,7 +79,7 @@
 //        if (to[e] != fa) dfs(to[e], u);
 //    }
 //    for (int e = head[u]; e; e = nxt[e]) {
-//        if (to[e] != fa) size[u] += size[to[e]];
+//        if (to[e] != fa) siz[u] += siz[to[e]];
 //    }
 //}
 //
@@ -153,10 +153,10 @@
 //
 //void update(int i, int v) {
 //    add(dfn[i], arr[i], -1);
-//    add(dfn[i] + size[i], arr[i], 1);
+//    add(dfn[i] + siz[i], arr[i], 1);
 //    arr[i] = kth(v);
 //    add(dfn[i], arr[i], 1);
-//    add(dfn[i] + size[i], arr[i], -1);
+//    add(dfn[i] + siz[i], arr[i], -1);
 //}
 //
 //int query(int x, int y, int k) {
@@ -192,7 +192,7 @@
 //    dfs(1, 0);
 //    for (int i = 1; i <= n; i++) {
 //        add(dfn[i], arr[i], 1);
-//        add(dfn[i] + size[i], arr[i], -1);
+//        add(dfn[i] + siz[i], arr[i], -1);
 //    }
 //}
 //

From f9560a41a3d88dc209d6304db8ff354a374a5368 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 17:57:21 +0800
Subject: [PATCH 0964/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 187 ++++++++++++++++++++++++---
 src/class172/Code06_TextEditor2.java | 172 ++++++++++++++++++++++++
 2 files changed, 342 insertions(+), 17 deletions(-)
 create mode 100644 src/class172/Code06_TextEditor2.java

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 980fcfcdd..ef25c9ef3 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -4,17 +4,172 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.BufferedOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
-import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
 public class Code06_TextEditor1 {
 
-	public static void main(String[] args) throws IOException {
-		FastReader in = new FastReader();
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+	public static int MAXN = 3000001;
+	public static int BLEN = 4001;
+	public static int BNUM = (MAXN / BLEN) << 1;
+
+	public static char[][] blocks = new char[BNUM][BLEN];
+	public static int[] nxt = new int[BNUM];
+	public static int[] siz = new int[BNUM];
+	public static int[] pool = new int[BNUM];
+	public static int psiz = 0;
+
+	public static char[] str = new char[MAXN];
+
+	public static void prepare() {
+		for (int i = 1; i < BNUM; i++) {
+			pool[i] = i;
+		}
+		psiz = BNUM - 1;
+		siz[0] = 0;
+		nxt[0] = -1;
+	}
+
+	public static int assign() {
+		return pool[psiz--];
+	}
+
+	public static void recycle(int i) {
+		pool[++psiz] = i;
+	}
+
+	public static int bi, pi;
+
+	public static void find(int pos) {
+		int cur = 0;
+		while (cur != -1 && pos > siz[cur]) {
+			pos -= siz[cur];
+			cur = nxt[cur];
+		}
+		bi = cur;
+		pi = pos;
+	}
+
+	public static void flush(int cur, int next, int endLen, char[] src, int srcPos) {
+		nxt[next] = nxt[cur];
+		nxt[cur] = next;
+		siz[next] = endLen;
+		System.arraycopy(src, srcPos, blocks[next], 0, endLen);
+	}
+
+	public static void merge(int cur, int next) {
+		System.arraycopy(blocks[next], 0, blocks[cur], siz[cur], siz[next]);
+		siz[cur] += siz[next];
+		nxt[cur] = nxt[next];
+		recycle(next);
+	}
+
+	public static void split(int cur, int pos) {
+		if (cur == -1 || pos == siz[cur]) {
+			return;
+		}
+		int next = assign();
+		flush(cur, next, siz[cur] - pos, blocks[cur], pos);
+		siz[cur] = pos;
+	}
 
+	public static void maintain() {
+		for (int cur = 0, next; cur != -1; cur = nxt[cur]) {
+			next = nxt[cur];
+			while (next != -1 && siz[cur] + siz[next] <= BLEN) {
+				merge(cur, next);
+				next = nxt[cur];
+			}
+		}
+	}
+
+	public static void insert(int pos, int len) {
+		find(pos);
+		split(bi, pi);
+		int cur = bi, newb, done = 0;
+		while (done + BLEN <= len) {
+			newb = assign();
+			flush(cur, newb, BLEN, str, done);
+			done += BLEN;
+			cur = newb;
+		}
+		if (len > done) {
+			newb = assign();
+			flush(cur, newb, len - done, str, done);
+		}
+		maintain();
+	}
+
+	public static void erase(int pos, int len) {
+		find(pos);
+		split(bi, pi);
+		int cur = bi, next = nxt[cur];
+		while (next != -1 && len > siz[next]) {
+			len -= siz[next];
+			recycle(next);
+			next = nxt[next];
+		}
+		if (next != -1) {
+			split(next, len);
+			recycle(next);
+			nxt[cur] = nxt[next];
+		} else {
+			nxt[cur] = -1;
+		}
+		maintain();
+	}
+
+	public static void get(int pos, int len) {
+		find(pos);
+		int cur = bi;
+		pos = pi;
+		int got = (len < siz[cur] - pos) ? len : (siz[cur] - pos);
+		System.arraycopy(blocks[cur], pos, str, 0, got);
+		cur = nxt[cur];
+		while (cur != -1 && got + siz[cur] <= len) {
+			System.arraycopy(blocks[cur], 0, str, got, siz[cur]);
+			got += siz[cur];
+			cur = nxt[cur];
+		}
+		if (cur != -1 && got < len) {
+			System.arraycopy(blocks[cur], 0, str, got, len - got);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new BufferedOutputStream(System.out));
+		int n = in.nextInt();
+		int pos = 0;
+		int len;
+		String op;
+		prepare();
+		for (int i = 1; i <= n; i++) {
+			op = in.nextString();
+			if (op.equals("Prev")) {
+				pos--;
+			} else if (op.equals("Next")) {
+				pos++;
+			} else if (op.equals("Move")) {
+				pos = in.nextInt();
+			} else if (op.equals("Insert")) {
+				len = in.nextInt();
+				for (int j = 0; j < len; j++) {
+					str[j] = in.nextChar();
+				}
+				insert(pos, len);
+			} else if (op.equals("Delete")) {
+				len = in.nextInt();
+				erase(pos, len);
+			} else {
+				len = in.nextInt();
+				get(pos, len);
+				out.write(str, 0, len);
+				out.write('\n');
+			}
+		}
 		out.flush();
 		out.close();
 	}
@@ -26,7 +181,7 @@ static class FastReader {
 		private final byte[] buffer;
 		private int ptr, len;
 
-		public FastReader() {
+		FastReader() {
 			in = System.in;
 			buffer = new byte[BUFFER_SIZE];
 			ptr = len = 0;
@@ -46,8 +201,8 @@ private byte readByte() throws IOException {
 			return buffer[ptr++];
 		}
 
-		// 读取下一个ASCII码在闭区间[32, 126]内的字符
-		public char nextChar() throws IOException {
+		// 读取下一个ASCII码范围在[32,126]的字符
+		char nextChar() throws IOException {
 			byte c;
 			do {
 				c = readByte();
@@ -57,12 +212,11 @@ public char nextChar() throws IOException {
 			return (char) c;
 		}
 
-		public String nextString() throws IOException {
+		String nextString() throws IOException {
 			byte b = readByte();
-			while (isWhitespace(b)) {
+			while (isWhitespace(b))
 				b = readByte();
-			}
-			StringBuilder sb = new StringBuilder(1000);
+			StringBuilder sb = new StringBuilder(16);
 			while (!isWhitespace(b) && b != -1) {
 				sb.append((char) b);
 				b = readByte();
@@ -70,21 +224,20 @@ public String nextString() throws IOException {
 			return sb.toString();
 		}
 
-		public int nextInt() throws IOException {
-			int num = 0;
+		int nextInt() throws IOException {
+			int num = 0, sign = 1;
 			byte b = readByte();
 			while (isWhitespace(b))
 				b = readByte();
-			boolean minus = false;
 			if (b == '-') {
-				minus = true;
+				sign = -1;
 				b = readByte();
 			}
 			while (!isWhitespace(b) && b != -1) {
 				num = num * 10 + (b - '0');
 				b = readByte();
 			}
-			return minus ? -num : num;
+			return sign * num;
 		}
 
 		private boolean isWhitespace(byte b) {
@@ -92,4 +245,4 @@ private boolean isWhitespace(byte b) {
 		}
 	}
 
-}
+}
\ No newline at end of file
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
new file mode 100644
index 000000000..690de8071
--- /dev/null
+++ b/src/class172/Code06_TextEditor2.java
@@ -0,0 +1,172 @@
+package class172;
+
+// 文本编辑器，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4008
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 3000001;
+//const int BLEN = 4001;
+//const int BNUM = (MAXN / BLEN) << 1;
+//
+//char blocks[BNUM][BLEN];
+//int nxt[BNUM];
+//int siz[BNUM];
+//int pool[BNUM];
+//int psiz = 0;
+//
+//char str[MAXN];
+//
+//void prepare() {
+//    for (int i = 1; i < BNUM; i++) pool[i] = i;
+//    psiz = BNUM - 1;
+//    siz[0] = 0;
+//    nxt[0] = -1;
+//}
+//
+//int assign() {
+//    return pool[psiz--];
+//}
+//
+//void recycle(int i) {
+//    pool[++psiz] = i;
+//}
+//
+//int bi, pi;
+//
+//void find(int pos) {
+//    int cur = 0;
+//    while (cur != -1 && pos > siz[cur]) {
+//        pos -= siz[cur];
+//        cur = nxt[cur];
+//    }
+//    bi = cur;
+//    pi = pos;
+//}
+//
+//void flush(int cur, int nextb, int endLen, char* src, int srcPos) {
+//    nxt[nextb] = nxt[cur];
+//    nxt[cur] = nextb;
+//    siz[nextb] = endLen;
+//    memcpy(blocks[nextb], src + srcPos, endLen);
+//}
+//
+//void merge(int cur, int nextb) {
+//    memcpy(blocks[cur] + siz[cur], blocks[nextb], siz[nextb]);
+//    siz[cur] += siz[nextb];
+//    nxt[cur] = nxt[nextb];
+//    recycle(nextb);
+//}
+//
+//void split(int cur, int pos) {
+//    if (cur == -1 || pos == siz[cur]) return;
+//    int nextb = assign();
+//    flush(cur, nextb, siz[cur] - pos, blocks[cur], pos);
+//    siz[cur] = pos;
+//}
+//
+//void maintain() {
+//    for (int cur = 0, nextb; cur != -1; cur = nxt[cur]) {
+//        nextb = nxt[cur];
+//        while (nextb != -1 && siz[cur] + siz[nextb] <= BLEN) {
+//            merge(cur, nextb);
+//            nextb = nxt[cur];
+//        }
+//    }
+//}
+//
+//void insert(int pos, int len) {
+//    find(pos);
+//    split(bi, pi);
+//    int cur = bi, newb, done = 0;
+//    while (done + BLEN <= len) {
+//        newb = assign();
+//        flush(cur, newb, BLEN, str, done);
+//        done += BLEN;
+//        cur = newb;
+//    }
+//    if (len > done) {
+//        newb = assign();
+//        flush(cur, newb, len - done, str, done);
+//    }
+//    maintain();
+//}
+//
+//void erase(int pos, int len) {
+//    find(pos);
+//    split(bi, pi);
+//    int cur = bi;
+//    int nextb = nxt[cur];
+//    while (nextb != -1 && len > siz[nextb]) {
+//        len -= siz[nextb];
+//        recycle(nextb);
+//        nextb = nxt[nextb];
+//    }
+//    if (nextb != -1) {
+//        split(nextb, len);
+//        recycle(nextb);
+//        nxt[cur] = nxt[nextb];
+//    } else {
+//        nxt[cur] = -1;
+//    }
+//    maintain();
+//}
+//
+//void get(int pos, int len) {
+//    find(pos);
+//    int cur = bi;
+//    pos = pi;
+//    int got = (len < siz[cur] - pos) ? len : (siz[cur] - pos);
+//    memcpy(str, blocks[cur] + pos, got);
+//    cur = nxt[cur];
+//    while (cur != -1 && got + siz[cur] <= len) {
+//        memcpy(str + got, blocks[cur], siz[cur]);
+//        got += siz[cur];
+//        cur = nxt[cur];
+//    }
+//    if (cur != -1 && got < len) {
+//        memcpy(str + got, blocks[cur], len - got);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int n;
+//    cin >> n;
+//    int pos = 0, len;
+//    char op[10];
+//    prepare();
+//    for (int i = 1; i <= n; i++) {
+//        cin >> op;
+//        if (op[0] == 'P') {
+//            pos--;
+//        } else if (op[0] == 'N') {
+//            pos++;
+//        } else if (op[0] == 'M') {
+//            cin >> pos;
+//        } else if (op[0] == 'I') {
+//            cin >> len;
+//            for (int j = 0; j < len; ) {
+//                char ch = cin.get();
+//                if (32 <= ch && ch <= 126) {
+//                    str[j++] = ch;
+//                }
+//            }
+//            insert(pos, len);
+//        } else if (op[0] == 'D') {
+//            cin >> len;
+//            erase(pos, len);
+//        } else {
+//            cin >> len;
+//            get(pos, len);
+//            cout.write(str, len);
+//            cout.put('\n');
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 04b5d9b8e60c819849d0e09484d4fe09a478bc10 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 18:08:41 +0800
Subject: [PATCH 0965/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 6 +++---
 src/class172/Code06_TextEditor2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index ef25c9ef3..6f8d12270 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -52,11 +52,11 @@ public static void find(int pos) {
 		pi = pos;
 	}
 
-	public static void flush(int cur, int next, int endLen, char[] src, int srcPos) {
+	public static void flush(int cur, int next, int tailLen, char[] src, int srcPos) {
 		nxt[next] = nxt[cur];
 		nxt[cur] = next;
-		siz[next] = endLen;
-		System.arraycopy(src, srcPos, blocks[next], 0, endLen);
+		siz[next] = tailLen;
+		System.arraycopy(src, srcPos, blocks[next], 0, tailLen);
 	}
 
 	public static void merge(int cur, int next) {
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 690de8071..1c38802ee 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -48,11 +48,11 @@
 //    pi = pos;
 //}
 //
-//void flush(int cur, int nextb, int endLen, char* src, int srcPos) {
+//void flush(int cur, int nextb, int tailLen, char* src, int srcPos) {
 //    nxt[nextb] = nxt[cur];
 //    nxt[cur] = nextb;
-//    siz[nextb] = endLen;
-//    memcpy(blocks[nextb], src + srcPos, endLen);
+//    siz[nextb] = tailLen;
+//    memcpy(blocks[nextb], src + srcPos, tailLen);
 //}
 //
 //void merge(int cur, int nextb) {

From d0dee603fd285a988d2fd10944f762d9604cbea2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 18:12:00 +0800
Subject: [PATCH 0966/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 2 +-
 src/class172/Code06_TextEditor2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 6f8d12270..5409f4610 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 文本编辑器，java版
+// 文本编辑器，块状链表实现，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 1c38802ee..65a6fa8f6 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -1,6 +1,6 @@
 package class172;
 
-// 文本编辑器，C++版
+// 文本编辑器，块状链表实现，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 22c6b5284f8ebf0d0bce31cfcac0ce379017478c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 18:21:36 +0800
Subject: [PATCH 0967/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 102 +++++++++++++--------------
 src/class172/Code06_TextEditor2.java |  78 ++++++++++----------
 2 files changed, 90 insertions(+), 90 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 5409f4610..533730acf 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -43,44 +43,44 @@ public static void recycle(int i) {
 	public static int bi, pi;
 
 	public static void find(int pos) {
-		int cur = 0;
-		while (cur != -1 && pos > siz[cur]) {
-			pos -= siz[cur];
-			cur = nxt[cur];
+		int curb = 0;
+		while (curb != -1 && pos > siz[curb]) {
+			pos -= siz[curb];
+			curb = nxt[curb];
 		}
-		bi = cur;
+		bi = curb;
 		pi = pos;
 	}
 
-	public static void flush(int cur, int next, int tailLen, char[] src, int srcPos) {
-		nxt[next] = nxt[cur];
-		nxt[cur] = next;
-		siz[next] = tailLen;
-		System.arraycopy(src, srcPos, blocks[next], 0, tailLen);
+	public static void flush(int curb, int nextb, int tailLen, char[] src, int srcPos) {
+		nxt[nextb] = nxt[curb];
+		nxt[curb] = nextb;
+		siz[nextb] = tailLen;
+		System.arraycopy(src, srcPos, blocks[nextb], 0, tailLen);
 	}
 
-	public static void merge(int cur, int next) {
-		System.arraycopy(blocks[next], 0, blocks[cur], siz[cur], siz[next]);
-		siz[cur] += siz[next];
-		nxt[cur] = nxt[next];
-		recycle(next);
+	public static void merge(int curb, int nextb) {
+		System.arraycopy(blocks[nextb], 0, blocks[curb], siz[curb], siz[nextb]);
+		siz[curb] += siz[nextb];
+		nxt[curb] = nxt[nextb];
+		recycle(nextb);
 	}
 
-	public static void split(int cur, int pos) {
-		if (cur == -1 || pos == siz[cur]) {
+	public static void split(int curb, int pos) {
+		if (curb == -1 || pos == siz[curb]) {
 			return;
 		}
-		int next = assign();
-		flush(cur, next, siz[cur] - pos, blocks[cur], pos);
-		siz[cur] = pos;
+		int nextb = assign();
+		flush(curb, nextb, siz[curb] - pos, blocks[curb], pos);
+		siz[curb] = pos;
 	}
 
 	public static void maintain() {
-		for (int cur = 0, next; cur != -1; cur = nxt[cur]) {
-			next = nxt[cur];
-			while (next != -1 && siz[cur] + siz[next] <= BLEN) {
-				merge(cur, next);
-				next = nxt[cur];
+		for (int curb = 0, nextb; curb != -1; curb = nxt[curb]) {
+			nextb = nxt[curb];
+			while (nextb != -1 && siz[curb] + siz[nextb] <= BLEN) {
+				merge(curb, nextb);
+				nextb = nxt[curb];
 			}
 		}
 	}
@@ -88,16 +88,16 @@ public static void maintain() {
 	public static void insert(int pos, int len) {
 		find(pos);
 		split(bi, pi);
-		int cur = bi, newb, done = 0;
+		int curb = bi, newb, done = 0;
 		while (done + BLEN <= len) {
 			newb = assign();
-			flush(cur, newb, BLEN, str, done);
+			flush(curb, newb, BLEN, str, done);
 			done += BLEN;
-			cur = newb;
+			curb = newb;
 		}
 		if (len > done) {
 			newb = assign();
-			flush(cur, newb, len - done, str, done);
+			flush(curb, newb, len - done, str, done);
 		}
 		maintain();
 	}
@@ -105,36 +105,36 @@ public static void insert(int pos, int len) {
 	public static void erase(int pos, int len) {
 		find(pos);
 		split(bi, pi);
-		int cur = bi, next = nxt[cur];
-		while (next != -1 && len > siz[next]) {
-			len -= siz[next];
-			recycle(next);
-			next = nxt[next];
-		}
-		if (next != -1) {
-			split(next, len);
-			recycle(next);
-			nxt[cur] = nxt[next];
+		int curb = bi, nextb = nxt[curb];
+		while (nextb != -1 && len > siz[nextb]) {
+			len -= siz[nextb];
+			recycle(nextb);
+			nextb = nxt[nextb];
+		}
+		if (nextb != -1) {
+			split(nextb, len);
+			recycle(nextb);
+			nxt[curb] = nxt[nextb];
 		} else {
-			nxt[cur] = -1;
+			nxt[curb] = -1;
 		}
 		maintain();
 	}
 
 	public static void get(int pos, int len) {
 		find(pos);
-		int cur = bi;
+		int curb = bi;
 		pos = pi;
-		int got = (len < siz[cur] - pos) ? len : (siz[cur] - pos);
-		System.arraycopy(blocks[cur], pos, str, 0, got);
-		cur = nxt[cur];
-		while (cur != -1 && got + siz[cur] <= len) {
-			System.arraycopy(blocks[cur], 0, str, got, siz[cur]);
-			got += siz[cur];
-			cur = nxt[cur];
-		}
-		if (cur != -1 && got < len) {
-			System.arraycopy(blocks[cur], 0, str, got, len - got);
+		int got = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
+		System.arraycopy(blocks[curb], pos, str, 0, got);
+		curb = nxt[curb];
+		while (curb != -1 && got + siz[curb] <= len) {
+			System.arraycopy(blocks[curb], 0, str, got, siz[curb]);
+			got += siz[curb];
+			curb = nxt[curb];
+		}
+		if (curb != -1 && got < len) {
+			System.arraycopy(blocks[curb], 0, str, got, len - got);
 		}
 	}
 
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 65a6fa8f6..7767401da 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -39,42 +39,42 @@
 //int bi, pi;
 //
 //void find(int pos) {
-//    int cur = 0;
-//    while (cur != -1 && pos > siz[cur]) {
-//        pos -= siz[cur];
-//        cur = nxt[cur];
+//    int curb = 0;
+//    while (curb != -1 && pos > siz[curb]) {
+//        pos -= siz[curb];
+//        curb = nxt[curb];
 //    }
-//    bi = cur;
+//    bi = curb;
 //    pi = pos;
 //}
 //
-//void flush(int cur, int nextb, int tailLen, char* src, int srcPos) {
-//    nxt[nextb] = nxt[cur];
-//    nxt[cur] = nextb;
+//void flush(int curb, int nextb, int tailLen, char* src, int srcPos) {
+//    nxt[nextb] = nxt[curb];
+//    nxt[curb] = nextb;
 //    siz[nextb] = tailLen;
 //    memcpy(blocks[nextb], src + srcPos, tailLen);
 //}
 //
-//void merge(int cur, int nextb) {
-//    memcpy(blocks[cur] + siz[cur], blocks[nextb], siz[nextb]);
-//    siz[cur] += siz[nextb];
-//    nxt[cur] = nxt[nextb];
+//void merge(int curb, int nextb) {
+//    memcpy(blocks[curb] + siz[curb], blocks[nextb], siz[nextb]);
+//    siz[curb] += siz[nextb];
+//    nxt[curb] = nxt[nextb];
 //    recycle(nextb);
 //}
 //
-//void split(int cur, int pos) {
-//    if (cur == -1 || pos == siz[cur]) return;
+//void split(int curb, int pos) {
+//    if (curb == -1 || pos == siz[curb]) return;
 //    int nextb = assign();
-//    flush(cur, nextb, siz[cur] - pos, blocks[cur], pos);
-//    siz[cur] = pos;
+//    flush(curb, nextb, siz[curb] - pos, blocks[curb], pos);
+//    siz[curb] = pos;
 //}
 //
 //void maintain() {
-//    for (int cur = 0, nextb; cur != -1; cur = nxt[cur]) {
-//        nextb = nxt[cur];
-//        while (nextb != -1 && siz[cur] + siz[nextb] <= BLEN) {
-//            merge(cur, nextb);
-//            nextb = nxt[cur];
+//    for (int curb = 0, nextb; curb != -1; curb = nxt[curb]) {
+//        nextb = nxt[curb];
+//        while (nextb != -1 && siz[curb] + siz[nextb] <= BLEN) {
+//            merge(curb, nextb);
+//            nextb = nxt[curb];
 //        }
 //    }
 //}
@@ -82,16 +82,16 @@
 //void insert(int pos, int len) {
 //    find(pos);
 //    split(bi, pi);
-//    int cur = bi, newb, done = 0;
+//    int curb = bi, newb, done = 0;
 //    while (done + BLEN <= len) {
 //        newb = assign();
-//        flush(cur, newb, BLEN, str, done);
+//        flush(curb, newb, BLEN, str, done);
 //        done += BLEN;
-//        cur = newb;
+//        curb = newb;
 //    }
 //    if (len > done) {
 //        newb = assign();
-//        flush(cur, newb, len - done, str, done);
+//        flush(curb, newb, len - done, str, done);
 //    }
 //    maintain();
 //}
@@ -99,8 +99,8 @@
 //void erase(int pos, int len) {
 //    find(pos);
 //    split(bi, pi);
-//    int cur = bi;
-//    int nextb = nxt[cur];
+//    int curb = bi;
+//    int nextb = nxt[curb];
 //    while (nextb != -1 && len > siz[nextb]) {
 //        len -= siz[nextb];
 //        recycle(nextb);
@@ -109,27 +109,27 @@
 //    if (nextb != -1) {
 //        split(nextb, len);
 //        recycle(nextb);
-//        nxt[cur] = nxt[nextb];
+//        nxt[curb] = nxt[nextb];
 //    } else {
-//        nxt[cur] = -1;
+//        nxt[curb] = -1;
 //    }
 //    maintain();
 //}
 //
 //void get(int pos, int len) {
 //    find(pos);
-//    int cur = bi;
+//    int curb = bi;
 //    pos = pi;
-//    int got = (len < siz[cur] - pos) ? len : (siz[cur] - pos);
-//    memcpy(str, blocks[cur] + pos, got);
-//    cur = nxt[cur];
-//    while (cur != -1 && got + siz[cur] <= len) {
-//        memcpy(str + got, blocks[cur], siz[cur]);
-//        got += siz[cur];
-//        cur = nxt[cur];
+//    int got = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
+//    memcpy(str, blocks[curb] + pos, got);
+//    curb = nxt[curb];
+//    while (curb != -1 && got + siz[curb] <= len) {
+//        memcpy(str + got, blocks[curb], siz[curb]);
+//        got += siz[curb];
+//        curb = nxt[curb];
 //    }
-//    if (cur != -1 && got < len) {
-//        memcpy(str + got, blocks[cur], len - got);
+//    if (curb != -1 && got < len) {
+//        memcpy(str + got, blocks[curb], len - got);
 //    }
 //}
 //

From dd0e0b0467a0bf73528a2750bcd7edd7f6798795 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 18:26:35 +0800
Subject: [PATCH 0968/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 6 +++---
 src/class172/Code06_TextEditor2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 533730acf..4dbd87df8 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -52,11 +52,11 @@ public static void find(int pos) {
 		pi = pos;
 	}
 
-	public static void flush(int curb, int nextb, int tailLen, char[] src, int srcPos) {
+	public static void flush(int curb, int nextb, int nextLen, char[] src, int srcPos) {
 		nxt[nextb] = nxt[curb];
 		nxt[curb] = nextb;
-		siz[nextb] = tailLen;
-		System.arraycopy(src, srcPos, blocks[nextb], 0, tailLen);
+		siz[nextb] = nextLen;
+		System.arraycopy(src, srcPos, blocks[nextb], 0, nextLen);
 	}
 
 	public static void merge(int curb, int nextb) {
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 7767401da..ef4649ecf 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -48,11 +48,11 @@
 //    pi = pos;
 //}
 //
-//void flush(int curb, int nextb, int tailLen, char* src, int srcPos) {
+//void flush(int curb, int nextb, int nextLen, char* src, int srcPos) {
 //    nxt[nextb] = nxt[curb];
 //    nxt[curb] = nextb;
-//    siz[nextb] = tailLen;
-//    memcpy(blocks[nextb], src + srcPos, tailLen);
+//    siz[nextb] = nextLen;
+//    memcpy(blocks[nextb], src + srcPos, nextLen);
 //}
 //
 //void merge(int curb, int nextb) {

From 1b5c9bdca61fe9b96b416529091a370209745122 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 18:29:40 +0800
Subject: [PATCH 0969/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 8 ++++----
 src/class172/Code06_TextEditor2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 4dbd87df8..7b19d30f0 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -52,7 +52,7 @@ public static void find(int pos) {
 		pi = pos;
 	}
 
-	public static void flush(int curb, int nextb, int nextLen, char[] src, int srcPos) {
+	public static void link(int curb, int nextb, int nextLen, char[] src, int srcPos) {
 		nxt[nextb] = nxt[curb];
 		nxt[curb] = nextb;
 		siz[nextb] = nextLen;
@@ -71,7 +71,7 @@ public static void split(int curb, int pos) {
 			return;
 		}
 		int nextb = assign();
-		flush(curb, nextb, siz[curb] - pos, blocks[curb], pos);
+		link(curb, nextb, siz[curb] - pos, blocks[curb], pos);
 		siz[curb] = pos;
 	}
 
@@ -91,13 +91,13 @@ public static void insert(int pos, int len) {
 		int curb = bi, newb, done = 0;
 		while (done + BLEN <= len) {
 			newb = assign();
-			flush(curb, newb, BLEN, str, done);
+			link(curb, newb, BLEN, str, done);
 			done += BLEN;
 			curb = newb;
 		}
 		if (len > done) {
 			newb = assign();
-			flush(curb, newb, len - done, str, done);
+			link(curb, newb, len - done, str, done);
 		}
 		maintain();
 	}
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index ef4649ecf..9c1a94023 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -48,7 +48,7 @@
 //    pi = pos;
 //}
 //
-//void flush(int curb, int nextb, int nextLen, char* src, int srcPos) {
+//void link(int curb, int nextb, int nextLen, char* src, int srcPos) {
 //    nxt[nextb] = nxt[curb];
 //    nxt[curb] = nextb;
 //    siz[nextb] = nextLen;
@@ -65,7 +65,7 @@
 //void split(int curb, int pos) {
 //    if (curb == -1 || pos == siz[curb]) return;
 //    int nextb = assign();
-//    flush(curb, nextb, siz[curb] - pos, blocks[curb], pos);
+//    link(curb, nextb, siz[curb] - pos, blocks[curb], pos);
 //    siz[curb] = pos;
 //}
 //
@@ -85,13 +85,13 @@
 //    int curb = bi, newb, done = 0;
 //    while (done + BLEN <= len) {
 //        newb = assign();
-//        flush(curb, newb, BLEN, str, done);
+//        link(curb, newb, BLEN, str, done);
 //        done += BLEN;
 //        curb = newb;
 //    }
 //    if (len > done) {
 //        newb = assign();
-//        flush(curb, newb, len - done, str, done);
+//        link(curb, newb, len - done, str, done);
 //    }
 //    maintain();
 //}

From 5e7a8660cbd4a5b3e3e4639dac6d10e3247d04ae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 18:33:29 +0800
Subject: [PATCH 0970/1712] modify code

---
 src/class152/Code03_TextEditor1.java | 1 +
 src/class152/Code03_TextEditor3.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index ee89c34f8..0b6930314 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -15,6 +15,7 @@
 // 因为这道题只考虑C++能通过的空间标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code03_TextEditor2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
+// 讲解172，讲解块状链表时，本题又讲了一遍，可以通过所有测试用例，更有学习意义
 
 import java.io.IOException;
 import java.io.InputStream;
diff --git a/src/class152/Code03_TextEditor3.java b/src/class152/Code03_TextEditor3.java
index 3bc940299..f141ffe99 100644
--- a/src/class152/Code03_TextEditor3.java
+++ b/src/class152/Code03_TextEditor3.java
@@ -12,6 +12,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 // 一个能通过的版本，连数组都自己写扩容逻辑，IO彻底重写，看看就好
+// 讲解172，讲解块状链表时，本题又讲了一遍，可以通过所有测试用例，更有学习意义
 
 import java.util.Arrays;
 

From 6d1574f8be19e3aaf9e55669aa56b9ba3278575d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 15 Jun 2025 20:49:54 +0800
Subject: [PATCH 0971/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 2 +-
 src/class172/Code06_TextEditor2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 7b19d30f0..724b65320 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -12,7 +12,7 @@
 public class Code06_TextEditor1 {
 
 	public static int MAXN = 3000001;
-	public static int BLEN = 4001;
+	public static int BLEN = 3001;
 	public static int BNUM = (MAXN / BLEN) << 1;
 
 	public static char[][] blocks = new char[BNUM][BLEN];
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 9c1a94023..ccaa291ee 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -10,7 +10,7 @@
 //using namespace std;
 //
 //const int MAXN = 3000001;
-//const int BLEN = 4001;
+//const int BLEN = 3001;
 //const int BNUM = (MAXN / BLEN) << 1;
 //
 //char blocks[BNUM][BLEN];

From d76c36afd389667db2366f9f85a4261398b6e853 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 16 Jun 2025 11:48:21 +0800
Subject: [PATCH 0972/1712] modify code

---
 src/class172/Code01_GiveAway1.java |  6 +++---
 src/class172/Code01_GiveAway2.java |  6 +++---
 src/class172/Code02_Magic1.java    |  8 ++++----
 src/class172/Code02_Magic2.java    | 10 +++++-----
 4 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/class172/Code01_GiveAway1.java b/src/class172/Code01_GiveAway1.java
index fd43ed62f..be03ee2da 100644
--- a/src/class172/Code01_GiveAway1.java
+++ b/src/class172/Code01_GiveAway1.java
@@ -42,8 +42,8 @@ public static void build() {
 		}
 	}
 
-	public static int num(int l, int r, int v) {
-		int m, ans = 0;
+	public static int getCnt(int i, int v) {
+		int l = bl[i], r = br[i], m, ans = 0;
 		while (l <= r) {
 			m = (l + r) >> 1;
 			if (sortv[m] >= v) {
@@ -76,7 +76,7 @@ public static int query(int l, int r, int v) {
 				}
 			}
 			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-				ans += num(bl[i], br[i], v);
+				ans += getCnt(i, v);
 			}
 		}
 		return ans;
diff --git a/src/class172/Code01_GiveAway2.java b/src/class172/Code01_GiveAway2.java
index 3176ecb73..bd5ac53f3 100644
--- a/src/class172/Code01_GiveAway2.java
+++ b/src/class172/Code01_GiveAway2.java
@@ -39,8 +39,8 @@
 //    }
 //}
 //
-//int num(int l, int r, int v) {
-//    int m, ans = 0;
+//int getCnt(int i, int v) {
+//    int l = bl[i], r = br[i], m, ans = 0;
 //    while (l <= r) {
 //        m = (l + r) >> 1;
 //        if (sortv[m] >= v) {
@@ -73,7 +73,7 @@
 //            }
 //        }
 //        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-//            ans += num(bl[i], br[i], v);
+//            ans += getCnt(i, v);
 //        }
 //    }
 //    return ans;
diff --git a/src/class172/Code02_Magic1.java b/src/class172/Code02_Magic1.java
index 371842c32..313badcd1 100644
--- a/src/class172/Code02_Magic1.java
+++ b/src/class172/Code02_Magic1.java
@@ -42,9 +42,9 @@ public static void build() {
 		}
 	}
 
-	public static int num(int l, int r, int v) {
-		v -= lazy[bi[l]];
-		int m, ans = 0;
+	public static int getCnt(int i, int v) {
+		v -= lazy[i];
+		int l = bl[i], r = br[i], m, ans = 0;
 		while (l <= r) {
 			m = (l + r) >> 1;
 			if (sortv[m] >= v) {
@@ -76,7 +76,7 @@ public static int query(int l, int r, int v) {
 			ans += innerQuery(l, br[bi[l]], v);
 			ans += innerQuery(bl[bi[r]], r, v);
 			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-				ans += num(bl[i], br[i], v);
+				ans += getCnt(i, v);
 			}
 		}
 		return ans;
diff --git a/src/class172/Code02_Magic2.java b/src/class172/Code02_Magic2.java
index 6f424af96..9a4c109ce 100644
--- a/src/class172/Code02_Magic2.java
+++ b/src/class172/Code02_Magic2.java
@@ -39,9 +39,9 @@
 //    }
 //}
 //
-//int num(int l, int r, int v) {
-//    v -= lazy[bi[l]];
-//    int m, ans = 0;
+//int getCnt(int i, int v) {
+//    v -= lazy[i];
+//    int l = bl[i], r = br[i], m, ans = 0;
 //    while (l <= r) {
 //        m = (l + r) >> 1;
 //        if (sortv[m] >= v) {
@@ -72,8 +72,8 @@
 //    } else {
 //        ans += innerQuery(l, br[bi[l]], v);
 //        ans += innerQuery(bl[bi[r]], r, v);
-//        for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
-//            ans += num(bl[b], br[b], v);
+//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+//            ans += getCnt(i, v);
 //        }
 //    }
 //    return ans;

From b595f6051e7c008fa83c50da0b02d0cbbdf56349 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 16 Jun 2025 13:42:07 +0800
Subject: [PATCH 0973/1712] modify code

---
 src/class152/Code03_TextEditor1.java |  2 +-
 src/class152/Code03_TextEditor3.java |  2 +-
 src/class172/Code01_GiveAway1.java   |  6 ++++++
 src/class172/Code01_GiveAway2.java   |  6 ++++++
 src/class172/Code02_Magic1.java      | 12 +++++++++---
 src/class172/Code02_Magic2.java      | 12 +++++++++---
 src/class172/Code03_Violet1.java     |  6 ++++++
 src/class172/Code03_Violet2.java     |  8 +++++++-
 src/class172/Code04_ModeCnt1.java    |  4 ++++
 src/class172/Code04_ModeCnt2.java    |  4 ++++
 src/class172/Code05_Poem1.java       |  4 ++++
 src/class172/Code05_Poem2.java       |  4 ++++
 src/class172/Code06_TextEditor1.java |  8 ++++++++
 src/class172/Code06_TextEditor2.java |  8 ++++++++
 14 files changed, 77 insertions(+), 9 deletions(-)

diff --git a/src/class152/Code03_TextEditor1.java b/src/class152/Code03_TextEditor1.java
index 0b6930314..66b98c531 100644
--- a/src/class152/Code03_TextEditor1.java
+++ b/src/class152/Code03_TextEditor1.java
@@ -15,7 +15,7 @@
 // 因为这道题只考虑C++能通过的空间标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code03_TextEditor2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
-// 讲解172，讲解块状链表时，本题又讲了一遍，可以通过所有测试用例，更有学习意义
+// 讲解172，讲解块状链表时，本题又讲了一遍，分块的方法，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
diff --git a/src/class152/Code03_TextEditor3.java b/src/class152/Code03_TextEditor3.java
index f141ffe99..253f73287 100644
--- a/src/class152/Code03_TextEditor3.java
+++ b/src/class152/Code03_TextEditor3.java
@@ -12,7 +12,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 // 一个能通过的版本，连数组都自己写扩容逻辑，IO彻底重写，看看就好
-// 讲解172，讲解块状链表时，本题又讲了一遍，可以通过所有测试用例，更有学习意义
+// 讲解172，讲解块状链表时，本题又讲了一遍，分块的方法，可以通过所有测试用例，更有学习意义
 
 import java.util.Arrays;
 
diff --git a/src/class172/Code01_GiveAway1.java b/src/class172/Code01_GiveAway1.java
index be03ee2da..b60c84881 100644
--- a/src/class172/Code01_GiveAway1.java
+++ b/src/class172/Code01_GiveAway1.java
@@ -1,6 +1,12 @@
 package class172;
 
 // Give Away，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作是如下两种类型中的一种
+// 操作 0 a b c : 打印arr[a..b]范围上>=c的数字个数
+// 操作 1 a b   : 把arr[a]的值改成b
+// 1 <= n <= 5 * 10^5
+// 1 <= m <= 10^5
+// 1 <= 数组中的值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class172/Code01_GiveAway2.java b/src/class172/Code01_GiveAway2.java
index bd5ac53f3..2f2c19dd1 100644
--- a/src/class172/Code01_GiveAway2.java
+++ b/src/class172/Code01_GiveAway2.java
@@ -1,6 +1,12 @@
 package class172;
 
 // Give Away，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作是如下两种类型中的一种
+// 操作 0 a b c : 打印arr[a..b]范围上>=c的数字个数
+// 操作 1 a b   : 把arr[a]的值改成b
+// 1 <= n <= 5 * 10^5
+// 1 <= m <= 10^5
+// 1 <= 数组中的值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP18185
 // 测试链接 : https://www.spoj.com/problems/GIVEAWAY
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class172/Code02_Magic1.java b/src/class172/Code02_Magic1.java
index 313badcd1..f4751f781 100644
--- a/src/class172/Code02_Magic1.java
+++ b/src/class172/Code02_Magic1.java
@@ -1,6 +1,12 @@
 package class172;
 
 // 教主的魔法，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作是如下两种类型中的一种
+// 操作 A l r v : 打印arr[l..r]范围上>=v的数字个数
+// 操作 M l r v : 把arr[l..r]范围上每个值都加上v
+// 1 <= n <= 10^6
+// 1 <= m <= 3000
+// 1 <= 数组中的值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2801
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,7 +20,7 @@ public class Code02_Magic1 {
 
 	public static int MAXN = 1000001;
 	public static int MAXB = 1001;
-	public static int n, q;
+	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	public static int[] sortv = new int[MAXN];
 
@@ -108,14 +114,14 @@ public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader();
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
-		q = in.nextInt();
+		m = in.nextInt();
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
 		build();
 		char op;
 		int l, r, v;
-		for (int i = 1; i <= q; i++) {
+		for (int i = 1; i <= m; i++) {
 			op = in.nextChar();
 			l = in.nextInt();
 			r = in.nextInt();
diff --git a/src/class172/Code02_Magic2.java b/src/class172/Code02_Magic2.java
index 9a4c109ce..3d61366d8 100644
--- a/src/class172/Code02_Magic2.java
+++ b/src/class172/Code02_Magic2.java
@@ -1,6 +1,12 @@
 package class172;
 
 // 教主的魔法，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作是如下两种类型中的一种
+// 操作 A l r v : 打印arr[l..r]范围上>=v的数字个数
+// 操作 M l r v : 把arr[l..r]范围上每个值都加上v
+// 1 <= n <= 10^6
+// 1 <= m <= 3000
+// 1 <= 数组中的值 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P2801
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -11,7 +17,7 @@
 //
 //const int MAXN = 1000001;
 //const int MAXB = 1001;
-//int n, q;
+//int n, m;
 //int arr[MAXN];
 //int sortv[MAXN];
 //
@@ -104,14 +110,14 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> q;
+//    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
 //    build();
 //    char op;
 //    int l, r, v;
-//    for (int i = 0; i < q; i++) {
+//    for (int i = 1; i <= m; i++) {
 //        cin >> op >> l >> r >> v;
 //        if (op == 'A') {
 //            cout << query(l, r, v) << '\n';
diff --git a/src/class172/Code03_Violet1.java b/src/class172/Code03_Violet1.java
index 84cc7f213..359684a99 100644
--- a/src/class172/Code03_Violet1.java
+++ b/src/class172/Code03_Violet1.java
@@ -1,6 +1,12 @@
 package class172;
 
 // 蒲公英，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上的众数，如果有多个众数，打印值最小的
+// 1 <= n <= 4 * 10^4
+// 1 <= m <= 5 * 10^4
+// 1 <= 数组中的值 <= 10^9
+// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4168
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class172/Code03_Violet2.java b/src/class172/Code03_Violet2.java
index a9e054d1c..68d1cdcdf 100644
--- a/src/class172/Code03_Violet2.java
+++ b/src/class172/Code03_Violet2.java
@@ -1,6 +1,12 @@
 package class172;
 
 // 蒲公英，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上的众数，如果有多个众数，打印值最小的
+// 1 <= n <= 4 * 10^4
+// 1 <= m <= 5 * 10^4
+// 1 <= 数组中的值 <= 10^9
+// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4168
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -146,7 +152,7 @@
 //    }
 //    prepare();
 //    int lastAns = 0, a, b, l, r;
-//    for (int i = 0; i < m; i++) {
+//    for (int i = 1; i <= m; i++) {
 //        cin >> a >> b;
 //        a = (a + lastAns - 1) % n + 1;
 //        b = (b + lastAns - 1) % n + 1;
diff --git a/src/class172/Code04_ModeCnt1.java b/src/class172/Code04_ModeCnt1.java
index c59890259..a429f02b6 100644
--- a/src/class172/Code04_ModeCnt1.java
+++ b/src/class172/Code04_ModeCnt1.java
@@ -1,6 +1,10 @@
 package class172;
 
 // 空间少求众数的次数，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上，众数到底出现了几次
+// 1 <= 所有数值 <= 5 * 10^5
+// 内存空间只有64MB，题目要求强制在线，强制在线的方式，可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5048
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是内存占用过大，无法通过测试用例
diff --git a/src/class172/Code04_ModeCnt2.java b/src/class172/Code04_ModeCnt2.java
index 9805408f8..455dc6759 100644
--- a/src/class172/Code04_ModeCnt2.java
+++ b/src/class172/Code04_ModeCnt2.java
@@ -1,6 +1,10 @@
 package class172;
 
 // 空间少求众数的次数，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上，众数到底出现了几次
+// 1 <= 所有数值 <= 5 * 10^5
+// 内存空间只有64MB，题目要求强制在线，强制在线的方式，可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5048
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index 8c12af1fc..c4e6116f0 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -1,6 +1,10 @@
 package class172;
 
 // 作诗，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
+// 1 <= 所有数值 <= 10^5
+// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135
 // 提交交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index c7bccb28b..3e4fd0948 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -1,6 +1,10 @@
 package class172;
 
 // 作诗，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
+// 1 <= 所有数值 <= 10^5
+// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 724b65320..1c0de7246 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -1,6 +1,14 @@
 package class172;
 
 // 文本编辑器，块状链表实现，java版
+// 一开始文本为空，光标在文本开头，也就是1位置，请实现如下6种操作
+// Move k     : 将光标移动到第k个字符之后，操作保证光标不会到非法位置
+// Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
+// Delete n   : 删除光标后的n个字符，光标位置不变，操作保证有足够字符
+// Get n      : 输出光标后的n个字符，光标位置不变，操作保证有足够字符
+// Prev       : 光标前移一个字符，操作保证光标不会到非法位置
+// Next       : 光标后移一个字符，操作保证光标不会到非法位置
+// Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index ccaa291ee..e622bd50d 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -1,6 +1,14 @@
 package class172;
 
 // 文本编辑器，块状链表实现，C++版
+// 一开始文本为空，光标在文本开头，也就是1位置，请实现如下6种操作
+// Move k     : 将光标移动到第k个字符之后，操作保证光标不会到非法位置
+// Insert n s : 在光标处插入长度为n的字符串s，光标位置不变
+// Delete n   : 删除光标后的n个字符，光标位置不变，操作保证有足够字符
+// Get n      : 输出光标后的n个字符，光标位置不变，操作保证有足够字符
+// Prev       : 光标前移一个字符，操作保证光标不会到非法位置
+// Next       : 光标后移一个字符，操作保证光标不会到非法位置
+// Insert操作时，字符串s中ASCII码在[32,126]范围上的字符一定有n个，其他字符请过滤掉
 // 测试链接 : https://www.luogu.com.cn/problem/P4008
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 5cdc8f9c3bb4b40d71810571a6a706f9d11647d5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 16 Jun 2025 14:58:08 +0800
Subject: [PATCH 0974/1712] modify code

---
 src/class172/Code03_Violet1.java  | 2 +-
 src/class172/Code03_Violet2.java  | 2 +-
 src/class172/Code04_ModeCnt1.java | 2 +-
 src/class172/Code04_ModeCnt2.java | 2 +-
 src/class172/Code05_Poem1.java    | 2 +-
 src/class172/Code05_Poem2.java    | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class172/Code03_Violet1.java b/src/class172/Code03_Violet1.java
index 359684a99..fea0f50f3 100644
--- a/src/class172/Code03_Violet1.java
+++ b/src/class172/Code03_Violet1.java
@@ -6,7 +6,7 @@
 // 1 <= n <= 4 * 10^4
 // 1 <= m <= 5 * 10^4
 // 1 <= 数组中的值 <= 10^9
-// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4168
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class172/Code03_Violet2.java b/src/class172/Code03_Violet2.java
index 68d1cdcdf..f3bb0b42a 100644
--- a/src/class172/Code03_Violet2.java
+++ b/src/class172/Code03_Violet2.java
@@ -6,7 +6,7 @@
 // 1 <= n <= 4 * 10^4
 // 1 <= m <= 5 * 10^4
 // 1 <= 数组中的值 <= 10^9
-// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4168
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class172/Code04_ModeCnt1.java b/src/class172/Code04_ModeCnt1.java
index a429f02b6..a1bd1e875 100644
--- a/src/class172/Code04_ModeCnt1.java
+++ b/src/class172/Code04_ModeCnt1.java
@@ -4,7 +4,7 @@
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
 // 操作 l r : 打印arr[l..r]范围上，众数到底出现了几次
 // 1 <= 所有数值 <= 5 * 10^5
-// 内存空间只有64MB，题目要求强制在线，强制在线的方式，可以打开测试链接查看
+// 内存空间只有64MB，题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5048
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是内存占用过大，无法通过测试用例
diff --git a/src/class172/Code04_ModeCnt2.java b/src/class172/Code04_ModeCnt2.java
index 455dc6759..79bdb24da 100644
--- a/src/class172/Code04_ModeCnt2.java
+++ b/src/class172/Code04_ModeCnt2.java
@@ -4,7 +4,7 @@
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
 // 操作 l r : 打印arr[l..r]范围上，众数到底出现了几次
 // 1 <= 所有数值 <= 5 * 10^5
-// 内存空间只有64MB，题目要求强制在线，强制在线的方式，可以打开测试链接查看
+// 内存空间只有64MB，题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5048
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index c4e6116f0..04e37aaeb 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -4,7 +4,7 @@
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
 // 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
 // 1 <= 所有数值 <= 10^5
-// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135
 // 提交交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index 3e4fd0948..d81faeb5b 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -4,7 +4,7 @@
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
 // 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
 // 1 <= 所有数值 <= 10^5
-// 题目要求强制在线，强制在线的方式，可以打开测试链接查看
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From b29e3f2653dca397ea5c6cf0d449df09469e8001 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 16 Jun 2025 17:09:15 +0800
Subject: [PATCH 0975/1712] modify code

---
 src/class172/Code02_Magic1.java | 1 +
 src/class172/Code02_Magic2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class172/Code02_Magic1.java b/src/class172/Code02_Magic1.java
index f4751f781..11ba3e514 100644
--- a/src/class172/Code02_Magic1.java
+++ b/src/class172/Code02_Magic1.java
@@ -28,6 +28,7 @@ public class Code02_Magic1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
+
 	public static int[] lazy = new int[MAXB];
 
 	public static void build() {
diff --git a/src/class172/Code02_Magic2.java b/src/class172/Code02_Magic2.java
index 3d61366d8..8105fa6ad 100644
--- a/src/class172/Code02_Magic2.java
+++ b/src/class172/Code02_Magic2.java
@@ -25,6 +25,7 @@
 //int bi[MAXN];
 //int bl[MAXB];
 //int br[MAXB];
+//
 //int lazy[MAXB];
 //
 //void build() {

From 609932daad52d3ece0071a419997ad3c5404c865 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 16 Jun 2025 21:42:54 +0800
Subject: [PATCH 0976/1712] modify code

---
 src/class172/Code03_Violet1.java | 14 +++++++++-----
 src/class172/Code03_Violet2.java |  8 +++++---
 2 files changed, 14 insertions(+), 8 deletions(-)

diff --git a/src/class172/Code03_Violet1.java b/src/class172/Code03_Violet1.java
index fea0f50f3..4ac62d389 100644
--- a/src/class172/Code03_Violet1.java
+++ b/src/class172/Code03_Violet1.java
@@ -22,6 +22,8 @@ public class Code03_Violet1 {
 	public static int MAXB = 201;
 	public static int n, m, s;
 	public static int[] arr = new int[MAXN];
+
+	// 数字做离散化
 	public static int[] sortv = new int[MAXN];
 
 	public static int blen, bnum;
@@ -31,9 +33,9 @@ public class Code03_Violet1 {
 
 	// freq[i][j]表示前i块中j出现的次数
 	public static int[][] freq = new int[MAXB][MAXN];
-	// mode[i][j]表示从i块到j块中的众数
+	// mode[i][j]表示从i块到j块中的众数(最小)
 	public static int[][] mode = new int[MAXB][MAXB];
-	// 数字词频统计
+	// 数字的词频统计
 	public static int[] numCnt = new int[MAXN];
 
 	public static int lower(int num) {
@@ -92,12 +94,13 @@ public static void prepare() {
 		for (int i = 1; i <= bnum; i++) {
 			for (int j = i; j <= bnum; j++) {
 				int most = mode[i][j - 1];
+				int mostCnt = getCnt(i, j, most);
 				for (int k = bl[j]; k <= br[j]; k++) {
 					int cur = arr[k];
 					int curCnt = getCnt(i, j, cur);
-					int mostCnt = getCnt(i, j, most);
 					if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
 						most = cur;
+						mostCnt = curCnt;
 					}
 				}
 				mode[i][j] = most;
@@ -127,20 +130,21 @@ public static int query(int l, int r) {
 				numCnt[arr[i]]++;
 			}
 			most = mode[bi[l] + 1][bi[r] - 1];
+			int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
 			for (int i = l; i <= br[bi[l]]; i++) {
 				int cur = arr[i];
 				int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
-				int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
 				if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
 					most = cur;
+					mostCnt = curCnt;
 				}
 			}
 			for (int i = bl[bi[r]]; i <= r; i++) {
 				int cur = arr[i];
 				int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
-				int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
 				if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
 					most = cur;
+					mostCnt = curCnt;
 				}
 			}
 			for (int i = l; i <= br[bi[l]]; i++) {
diff --git a/src/class172/Code03_Violet2.java b/src/class172/Code03_Violet2.java
index f3bb0b42a..26b5d4d92 100644
--- a/src/class172/Code03_Violet2.java
+++ b/src/class172/Code03_Violet2.java
@@ -82,12 +82,13 @@
 //    for (int i = 1; i <= bnum; i++) {
 //        for (int j = i; j <= bnum; j++) {
 //            int most = mode[i][j - 1];
+//            int mostCnt = getCnt(i, j, most);
 //            for (int k = bl[j]; k <= br[j]; k++) {
 //                int cur = arr[k];
 //                int curCnt = getCnt(i, j, cur);
-//                int mostCnt = getCnt(i, j, most);
 //                if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
 //                    most = cur;
+//                    mostCnt = curCnt;
 //                }
 //            }
 //            mode[i][j] = most;
@@ -117,20 +118,21 @@
 //            numCnt[arr[i]]++;
 //        }
 //        most = mode[bi[l] + 1][bi[r] - 1];
+//        int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
 //        for (int i = l; i <= br[bi[l]]; i++) {
 //            int cur = arr[i];
 //            int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
-//            int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
 //            if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
 //                most = cur;
+//                mostCnt = curCnt;
 //            }
 //        }
 //        for (int i = bl[bi[r]]; i <= r; i++) {
 //            int cur = arr[i];
 //            int curCnt = getCnt(bi[l] + 1, bi[r] - 1, cur) + numCnt[cur];
-//            int mostCnt = getCnt(bi[l] + 1, bi[r] - 1, most) + numCnt[most];
 //            if (curCnt > mostCnt || (curCnt == mostCnt && cur < most)) {
 //                most = cur;
+//                mostCnt = curCnt;
 //            }
 //        }
 //        for (int i = l; i <= br[bi[l]]; i++) {

From 665a3ff1ec1b136d885994b5419df2c9f9b93d2d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 16 Jun 2025 21:47:33 +0800
Subject: [PATCH 0977/1712] modify code

---
 src/class172/Code04_ModeCnt1.java | 23 +++++++++++------------
 src/class172/Code04_ModeCnt2.java | 20 ++++++++++----------
 2 files changed, 21 insertions(+), 22 deletions(-)

diff --git a/src/class172/Code04_ModeCnt1.java b/src/class172/Code04_ModeCnt1.java
index a1bd1e875..f3557fa69 100644
--- a/src/class172/Code04_ModeCnt1.java
+++ b/src/class172/Code04_ModeCnt1.java
@@ -31,10 +31,9 @@ public class Code04_ModeCnt1 {
 	public static int[] br = new int[MAXB];
 
 	// 值、下标
-	public static int[][] bucket = new int[MAXN][2];
-	// bucketIdx[i] = j，代表数组的i位置元素在bucket中的j位置
-	public static int[] bucketIdx = new int[MAXN];
-
+	public static int[][] sortList = new int[MAXN][2];
+	// listIdx[i] = j，代表数组的i位置元素在sortList中的j位置
+	public static int[] listIdx = new int[MAXN];
 	// modeCnt[i][j]表示从i块到j块中众数的出现次数
 	public static int[][] modeCnt = new int[MAXB][MAXB];
 	// 数字词频统计
@@ -51,12 +50,12 @@ public static void prepare() {
 			br[i] = Math.min(i * blen, n);
 		}
 		for (int i = 1; i <= n; i++) {
-			bucket[i][0] = arr[i];
-			bucket[i][1] = i;
+			sortList[i][0] = arr[i];
+			sortList[i][1] = i;
 		}
-		Arrays.sort(bucket, 1, n + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
+		Arrays.sort(sortList, 1, n + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
 		for (int i = 1; i <= n; i++) {
-			bucketIdx[bucket[i][1]] = i;
+			listIdx[sortList[i][1]] = i;
 		}
 		for (int i = 1; i <= bnum; i++) {
 			for (int j = i; j <= bnum; j++) {
@@ -84,14 +83,14 @@ public static int query(int l, int r) {
 		} else {
 			ans = modeCnt[bi[l] + 1][bi[r] - 1];
 			for (int i = l, idx; i <= br[bi[l]]; i++) {
-				idx = bucketIdx[i];
-				while (idx + ans <= n && bucket[idx + ans][0] == arr[i] && bucket[idx + ans][1] <= r) {
+				idx = listIdx[i];
+				while (idx + ans <= n && sortList[idx + ans][0] == arr[i] && sortList[idx + ans][1] <= r) {
 					ans++;
 				}
 			}
 			for (int i = bl[bi[r]], idx; i <= r; i++) {
-				idx = bucketIdx[i];
-				while (idx - ans >= 1 && bucket[idx - ans][0] == arr[i] && bucket[idx - ans][1] >= l) {
+				idx = listIdx[i];
+				while (idx - ans >= 1 && sortList[idx - ans][0] == arr[i] && sortList[idx - ans][1] >= l) {
 					ans++;
 				}
 			}
diff --git a/src/class172/Code04_ModeCnt2.java b/src/class172/Code04_ModeCnt2.java
index 79bdb24da..097990812 100644
--- a/src/class172/Code04_ModeCnt2.java
+++ b/src/class172/Code04_ModeCnt2.java
@@ -34,8 +34,8 @@
 //int bl[MAXB];
 //int br[MAXB];
 //
-//Node bucket[MAXN];
-//int bucketIdx[MAXN];
+//Node sortList[MAXN];
+//int listIdx[MAXN];
 //
 //int modeCnt[MAXB][MAXB];
 //int numCnt[MAXN];
@@ -51,12 +51,12 @@
 //        br[i] = min(i * blen, n);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        bucket[i].v = arr[i];
-//        bucket[i].i = i;
+//        sortList[i].v = arr[i];
+//        sortList[i].i = i;
 //    }
-//    sort(bucket + 1, bucket + n + 1, NodeCmp);
+//    sort(sortList + 1, sortList + n + 1, NodeCmp);
 //    for (int i = 1; i <= n; i++) {
-//        bucketIdx[bucket[i].i] = i;
+//        listIdx[sortList[i].i] = i;
 //    }
 //    for (int i = 1; i <= bnum; i++) {
 //        for (int j = i; j <= bnum; j++) {
@@ -84,14 +84,14 @@
 //    } else {
 //        ans = modeCnt[bi[l] + 1][bi[r] - 1];
 //        for (int i = l, idx; i <= br[bi[l]]; i++) {
-//            idx = bucketIdx[i];
-//            while (idx + ans <= n && bucket[idx + ans].v == arr[i] && bucket[idx + ans].i <= r) {
+//            idx = listIdx[i];
+//            while (idx + ans <= n && sortList[idx + ans].v == arr[i] && sortList[idx + ans].i <= r) {
 //                ans++;
 //            }
 //        }
 //        for (int i = bl[bi[r]], idx; i <= r; i++) {
-//            idx = bucketIdx[i];
-//            while (idx - ans >= 1 && bucket[idx - ans].v == arr[i] && bucket[idx - ans].i >= l) {
+//            idx = listIdx[i];
+//            while (idx - ans >= 1 && sortList[idx - ans].v == arr[i] && sortList[idx - ans].i >= l) {
 //                ans++;
 //            }
 //        }

From 10520dc229c41426f9e4c42d4690a4194e14d33a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 16 Jun 2025 21:54:47 +0800
Subject: [PATCH 0978/1712] modify code

---
 src/class172/Code04_ModeCnt1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class172/Code04_ModeCnt1.java b/src/class172/Code04_ModeCnt1.java
index f3557fa69..75b50a94a 100644
--- a/src/class172/Code04_ModeCnt1.java
+++ b/src/class172/Code04_ModeCnt1.java
@@ -30,9 +30,9 @@ public class Code04_ModeCnt1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
-	// 值、下标
+	// (值、下标)，用来收集同一种数的下标列表
 	public static int[][] sortList = new int[MAXN][2];
-	// listIdx[i] = j，代表数组的i位置元素在sortList中的j位置
+	// listIdx[i] = j，表示arr[i]这个元素在sortList里的j位置
 	public static int[] listIdx = new int[MAXN];
 	// modeCnt[i][j]表示从i块到j块中众数的出现次数
 	public static int[][] modeCnt = new int[MAXB][MAXB];

From 3824c1f08c54c16998e3b22689864f7ff06bee8b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 11:13:49 +0800
Subject: [PATCH 0979/1712] modify code

---
 src/class172/Code05_Poem1.java | 10 ++++++++--
 src/class172/Code05_Poem2.java |  8 +++++++-
 2 files changed, 15 insertions(+), 3 deletions(-)

diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index 04e37aaeb..a2a59e7d8 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -37,9 +37,15 @@ public static int getCnt(int l, int r, int v) {
 		return freq[r][v] - freq[l - 1][v];
 	}
 
-	// 加1之前的词频是pre，返回加1之后，正偶数次的数的个数变化量
+	// 加1之前的词频是pre，如果词频+1，返回 出现正偶数次的数的个数 变化量
 	public static int delta(int pre) {
-		return pre != 0 ? ((pre & 1) == 0 ? -1 : 1) : 0;
+		if (pre == 0) {
+			return 0;
+		}
+		if ((pre & 1) == 0) {
+			return -1;
+		}
+		return 1;
 	}
 
 	public static void prepare() {
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index d81faeb5b..334432be0 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -32,7 +32,13 @@
 //}
 //
 //int delta(int pre) {
-//    return pre ? ((pre & 1) ? 1 : -1) : 0;
+//    if (pre == 0) {
+//        return 0;
+//    }
+//    if ((pre & 1) == 0) {
+//        return -1;
+//    }
+//    return 1;
 //}
 //
 //void prepare() {

From 9cb769112282ec70600112ad6dfa33b97f49e94d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 11:18:19 +0800
Subject: [PATCH 0980/1712] modify code

---
 src/class172/Code05_Poem1.java | 6 +++---
 src/class172/Code05_Poem2.java | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index a2a59e7d8..3386e48dd 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -2,7 +2,7 @@
 
 // 作诗，java版
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
-// 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
+// 操作 l r : 打印arr[l..r]范围上，有多少数的出现次数是正偶数
 // 1 <= 所有数值 <= 10^5
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135
@@ -27,7 +27,7 @@ public class Code05_Poem1 {
 
 	// freq[i][j]表示前i块中j出现的次数
 	public static int[][] freq = new int[MAXB][MAXN];
-	// even[i][j]表示从第i块到第j块出现正偶数次的数有几个
+	// even[i][j]表示从第i块到第j块，有多少数的出现次数是正偶数
 	public static int[][] even = new int[MAXB][MAXB];
 	// 数字词频统计
 	public static int[] numCnt = new int[MAXN];
@@ -37,7 +37,7 @@ public static int getCnt(int l, int r, int v) {
 		return freq[r][v] - freq[l - 1][v];
 	}
 
-	// 加1之前的词频是pre，如果词频+1，返回 出现正偶数次的数的个数 变化量
+	// 加1之前的词频是pre，如果词频+1，返回 出现正偶数次的数字个数 的变化量
 	public static int delta(int pre) {
 		if (pre == 0) {
 			return 0;
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index 334432be0..0ca905a6b 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -2,7 +2,7 @@
 
 // 作诗，C++版
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
-// 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
+// 操作 l r : 打印arr[l..r]范围上，有多少数的出现次数是正偶数
 // 1 <= 所有数值 <= 10^5
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135

From 48bcdbc76e6284bf5800c38136acaa5e3a1d99e5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 11:23:56 +0800
Subject: [PATCH 0981/1712] modify code

---
 src/class172/Code05_Poem1.java | 14 +++++++-------
 src/class172/Code05_Poem2.java |  8 ++++----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index 3386e48dd..f9b575a58 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -2,7 +2,7 @@
 
 // 作诗，java版
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
-// 操作 l r : 打印arr[l..r]范围上，有多少数的出现次数是正偶数
+// 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
 // 1 <= 所有数值 <= 10^5
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135
@@ -27,22 +27,22 @@ public class Code05_Poem1 {
 
 	// freq[i][j]表示前i块中j出现的次数
 	public static int[][] freq = new int[MAXB][MAXN];
-	// even[i][j]表示从第i块到第j块，有多少数的出现次数是正偶数
+	// even[i][j]表示从第i块到第j块，有多少个数出现正偶数次
 	public static int[][] even = new int[MAXB][MAXB];
 	// 数字词频统计
 	public static int[] numCnt = new int[MAXN];
 
-	// 返回从l块到r块中，数字v的次数
+	// 返回从l块到r块，数字v的次数
 	public static int getCnt(int l, int r, int v) {
 		return freq[r][v] - freq[l - 1][v];
 	}
 
-	// 加1之前的词频是pre，如果词频+1，返回 出现正偶数次的数字个数 的变化量
-	public static int delta(int pre) {
-		if (pre == 0) {
+	// 之前某种数的词频是preCnt，如果词频加1，返回 出现正偶数次的数字个数 的变化量
+	public static int delta(int preCnt) {
+		if (preCnt == 0) {
 			return 0;
 		}
-		if ((pre & 1) == 0) {
+		if ((preCnt & 1) == 0) {
 			return -1;
 		}
 		return 1;
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index 0ca905a6b..70ba3fa0b 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -2,7 +2,7 @@
 
 // 作诗，C++版
 // 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
-// 操作 l r : 打印arr[l..r]范围上，有多少数的出现次数是正偶数
+// 操作 l r : 打印arr[l..r]范围上，有多少个数出现正偶数次
 // 1 <= 所有数值 <= 10^5
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P4135
@@ -31,11 +31,11 @@
 //    return freq[r][v] - freq[l - 1][v];
 //}
 //
-//int delta(int pre) {
-//    if (pre == 0) {
+//int delta(int preCnt) {
+//    if (preCnt == 0) {
 //        return 0;
 //    }
-//    if ((pre & 1) == 0) {
+//    if ((preCnt & 1) == 0) {
 //        return -1;
 //    }
 //    return 1;

From 768797cfc632ab7cf3160cca4b465ff3b1348f26 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 11:25:25 +0800
Subject: [PATCH 0982/1712] modify code

---
 src/class172/Code05_Poem1.java | 8 ++++----
 src/class172/Code05_Poem2.java | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index f9b575a58..d71daf428 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -37,12 +37,12 @@ public static int getCnt(int l, int r, int v) {
 		return freq[r][v] - freq[l - 1][v];
 	}
 
-	// 之前某种数的词频是preCnt，如果词频加1，返回 出现正偶数次的数字个数 的变化量
-	public static int delta(int preCnt) {
-		if (preCnt == 0) {
+	// 某种数的当前词频是curCnt，如果词频加1，返回 出现正偶数次的数字个数 的变化量
+	public static int delta(int curCnt) {
+		if (curCnt == 0) {
 			return 0;
 		}
-		if ((preCnt & 1) == 0) {
+		if ((curCnt & 1) == 0) {
 			return -1;
 		}
 		return 1;
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index 70ba3fa0b..f8dcd1c58 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -31,11 +31,11 @@
 //    return freq[r][v] - freq[l - 1][v];
 //}
 //
-//int delta(int preCnt) {
-//    if (preCnt == 0) {
+//int delta(int curCnt) {
+//    if (curCnt == 0) {
 //        return 0;
 //    }
-//    if ((preCnt & 1) == 0) {
+//    if ((curCnt & 1) == 0) {
 //        return -1;
 //    }
 //    return 1;

From a7cc366daf15df49618cc8d236d06ea7b45b5dbc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 11:26:29 +0800
Subject: [PATCH 0983/1712] modify code

---
 src/class172/Code05_Poem1.java | 8 ++++----
 src/class172/Code05_Poem2.java | 6 +++---
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index d71daf428..c0b6038e5 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -37,12 +37,12 @@ public static int getCnt(int l, int r, int v) {
 		return freq[r][v] - freq[l - 1][v];
 	}
 
-	// 某种数的当前词频是curCnt，如果词频加1，返回 出现正偶数次的数字个数 的变化量
-	public static int delta(int curCnt) {
-		if (curCnt == 0) {
+	// 某种数的当前词频是cnt，如果词频加1，返回 出现正偶数次的数字个数 的变化量
+	public static int delta(int cnt) {
+		if (cnt == 0) {
 			return 0;
 		}
-		if ((curCnt & 1) == 0) {
+		if ((cnt & 1) == 0) {
 			return -1;
 		}
 		return 1;
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index f8dcd1c58..e265e63c3 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -31,11 +31,11 @@
 //    return freq[r][v] - freq[l - 1][v];
 //}
 //
-//int delta(int curCnt) {
-//    if (curCnt == 0) {
+//int delta(int cnt) {
+//    if (cnt == 0) {
 //        return 0;
 //    }
-//    if ((curCnt & 1) == 0) {
+//    if ((cnt & 1) == 0) {
 //        return -1;
 //    }
 //    return 1;

From cfc64403854b0c821a9debb2bd7a72c0e37c7537 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 12:07:26 +0800
Subject: [PATCH 0984/1712] modify code

---
 src/class172/Code05_Poem1.java | 9 +++++----
 src/class172/Code05_Poem2.java | 6 +++---
 2 files changed, 8 insertions(+), 7 deletions(-)

diff --git a/src/class172/Code05_Poem1.java b/src/class172/Code05_Poem1.java
index c0b6038e5..0e7a9bef5 100644
--- a/src/class172/Code05_Poem1.java
+++ b/src/class172/Code05_Poem1.java
@@ -37,12 +37,13 @@ public static int getCnt(int l, int r, int v) {
 		return freq[r][v] - freq[l - 1][v];
 	}
 
-	// 某种数的当前词频是cnt，如果词频加1，返回 出现正偶数次的数字个数 的变化量
-	public static int delta(int cnt) {
-		if (cnt == 0) {
+	// 某种数的之前词频是pre，现在如果词频加1
+	// 返回 出现正偶数次的数字个数 的变化量
+	public static int delta(int pre) {
+		if (pre == 0) {
 			return 0;
 		}
-		if ((cnt & 1) == 0) {
+		if ((pre & 1) == 0) {
 			return -1;
 		}
 		return 1;
diff --git a/src/class172/Code05_Poem2.java b/src/class172/Code05_Poem2.java
index e265e63c3..334432be0 100644
--- a/src/class172/Code05_Poem2.java
+++ b/src/class172/Code05_Poem2.java
@@ -31,11 +31,11 @@
 //    return freq[r][v] - freq[l - 1][v];
 //}
 //
-//int delta(int cnt) {
-//    if (cnt == 0) {
+//int delta(int pre) {
+//    if (pre == 0) {
 //        return 0;
 //    }
-//    if ((cnt & 1) == 0) {
+//    if ((pre & 1) == 0) {
 //        return -1;
 //    }
 //    return 1;

From 24a44b1f63e984fe45113950be65e7b049def2e3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 13:18:51 +0800
Subject: [PATCH 0985/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 65 +++++++++++++++++++---------
 src/class172/Code06_TextEditor2.java | 40 +++++++++--------
 2 files changed, 65 insertions(+), 40 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 1c0de7246..833aec5d9 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -20,34 +20,49 @@
 public class Code06_TextEditor1 {
 
 	public static int MAXN = 3000001;
+	// 每块的最大容量，近似等于 2 * 根号n
 	public static int BLEN = 3001;
+	// 块的最大数量
 	public static int BNUM = (MAXN / BLEN) << 1;
-
+	// 所有空间
 	public static char[][] blocks = new char[BNUM][BLEN];
+	// nxt[i]表示编号为i的块，下一块的编号
 	public static int[] nxt = new int[BNUM];
+	// siz[i]表示编号为i的块，写入了多少长度的内容
 	public static int[] siz = new int[BNUM];
+	// 编号分配池，其实是一个栈，分配编号从栈顶弹出，回收编号从栈顶压入
 	public static int[] pool = new int[BNUM];
-	public static int psiz = 0;
+	// 分配池的栈顶
+	public static int top = 0;
 
+	// 插入字符串时，先读入进str，然后写入到块
+	// 获取字符串时，先从块里取出内容保留在str，然后打印str
 	public static char[] str = new char[MAXN];
 
+	// 准备好分配池，从栈顶到栈底，依次是1、2、... BNUM - 1
+	// 准备好头块的配置
 	public static void prepare() {
-		for (int i = 1; i < BNUM; i++) {
-			pool[i] = i;
+		for (int i = 1, id = BNUM - 1; i < BNUM; i++, id--) {
+			pool[i] = id;
 		}
-		psiz = BNUM - 1;
+		top = BNUM - 1;
 		siz[0] = 0;
 		nxt[0] = -1;
 	}
 
+	// 分配编号
 	public static int assign() {
-		return pool[psiz--];
+		return pool[top--];
 	}
 
-	public static void recycle(int i) {
-		pool[++psiz] = i;
+	// 回收编号
+	public static void recycle(int id) {
+		pool[++top] = id;
 	}
 
+	// 寻找整个文章中的pos位置
+	// 找到所在块的编号 和 块内位置
+	// 块编号设置给bi，块内位置设置给pi
 	public static int bi, pi;
 
 	public static void find(int pos) {
@@ -60,13 +75,16 @@ public static void find(int pos) {
 		pi = pos;
 	}
 
-	public static void link(int curb, int nextb, int nextLen, char[] src, int srcPos) {
+	// 链表中让curb块和nextb块，连在一起，然后让nextb块从0位置开始，写入如下的内容
+	// 从src[pos]开始，拿取长度为len的字符串
+	public static void linkAndWrite(int curb, int nextb, char[] src, int pos, int len) {
 		nxt[nextb] = nxt[curb];
 		nxt[curb] = nextb;
-		siz[nextb] = nextLen;
-		System.arraycopy(src, srcPos, blocks[nextb], 0, nextLen);
+		System.arraycopy(src, pos, blocks[nextb], 0, len);
+		siz[nextb] = len;
 	}
 
+	// curb块里，在内容的后面，追加nextb块的内容，然后nextb块从链表中删掉
 	public static void merge(int curb, int nextb) {
 		System.arraycopy(blocks[nextb], 0, blocks[curb], siz[curb], siz[nextb]);
 		siz[curb] += siz[nextb];
@@ -74,15 +92,17 @@ public static void merge(int curb, int nextb) {
 		recycle(nextb);
 	}
 
+	// curb块的pos位置往后的内容，写入到新分裂出的块里
 	public static void split(int curb, int pos) {
 		if (curb == -1 || pos == siz[curb]) {
 			return;
 		}
 		int nextb = assign();
-		link(curb, nextb, siz[curb] - pos, blocks[curb], pos);
+		linkAndWrite(curb, nextb, blocks[curb], pos, siz[curb] - pos);
 		siz[curb] = pos;
 	}
 
+	// 从头到尾遍历所有的块，任意相邻两块的大小累加和 <= BLEN，合并这两块
 	public static void maintain() {
 		for (int curb = 0, nextb; curb != -1; curb = nxt[curb]) {
 			nextb = nxt[curb];
@@ -93,23 +113,25 @@ public static void maintain() {
 		}
 	}
 
+	// 插入的字符串在str中，长度为len，从整个文章的pos位置插入
 	public static void insert(int pos, int len) {
 		find(pos);
 		split(bi, pi);
 		int curb = bi, newb, done = 0;
 		while (done + BLEN <= len) {
 			newb = assign();
-			link(curb, newb, BLEN, str, done);
+			linkAndWrite(curb, newb, str, done, BLEN);
 			done += BLEN;
 			curb = newb;
 		}
 		if (len > done) {
 			newb = assign();
-			link(curb, newb, len - done, str, done);
+			linkAndWrite(curb, newb, str, done, len - done);
 		}
 		maintain();
 	}
 
+	// 从整个文章的pos位置，往后len的长度，这些内容删掉
 	public static void erase(int pos, int len) {
 		find(pos);
 		split(bi, pi);
@@ -129,20 +151,21 @@ public static void erase(int pos, int len) {
 		maintain();
 	}
 
+	// 从整个文章的pos位置，往后len的长度，这些内容找到，写入进str
 	public static void get(int pos, int len) {
 		find(pos);
 		int curb = bi;
 		pos = pi;
-		int got = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
-		System.arraycopy(blocks[curb], pos, str, 0, got);
+		int done = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
+		System.arraycopy(blocks[curb], pos, str, 0, done);
 		curb = nxt[curb];
-		while (curb != -1 && got + siz[curb] <= len) {
-			System.arraycopy(blocks[curb], 0, str, got, siz[curb]);
-			got += siz[curb];
+		while (curb != -1 && done + siz[curb] <= len) {
+			System.arraycopy(blocks[curb], 0, str, done, siz[curb]);
+			done += siz[curb];
 			curb = nxt[curb];
 		}
-		if (curb != -1 && got < len) {
-			System.arraycopy(blocks[curb], 0, str, got, len - got);
+		if (curb != -1 && done < len) {
+			System.arraycopy(blocks[curb], 0, str, done, len - done);
 		}
 	}
 
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index e622bd50d..3bb7898a8 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -25,23 +25,25 @@
 //int nxt[BNUM];
 //int siz[BNUM];
 //int pool[BNUM];
-//int psiz = 0;
+//int top = 0;
 //
 //char str[MAXN];
 //
 //void prepare() {
-//    for (int i = 1; i < BNUM; i++) pool[i] = i;
-//    psiz = BNUM - 1;
+//    for (int i = 1, id = BNUM - 1; i < BNUM; i++, id--) {
+//        pool[i] = id;
+//    }
+//    top = BNUM - 1;
 //    siz[0] = 0;
 //    nxt[0] = -1;
 //}
 //
 //int assign() {
-//    return pool[psiz--];
+//    return pool[top--];
 //}
 //
-//void recycle(int i) {
-//    pool[++psiz] = i;
+//void recycle(int id) {
+//    pool[++top] = id;
 //}
 //
 //int bi, pi;
@@ -56,11 +58,11 @@
 //    pi = pos;
 //}
 //
-//void link(int curb, int nextb, int nextLen, char* src, int srcPos) {
+//void linkAndWrite(int curb, int nextb, char* src, int pos, int len) {
 //    nxt[nextb] = nxt[curb];
 //    nxt[curb] = nextb;
-//    siz[nextb] = nextLen;
-//    memcpy(blocks[nextb], src + srcPos, nextLen);
+//    memcpy(blocks[nextb], src + pos, len);
+//    siz[nextb] = len;
 //}
 //
 //void merge(int curb, int nextb) {
@@ -73,7 +75,7 @@
 //void split(int curb, int pos) {
 //    if (curb == -1 || pos == siz[curb]) return;
 //    int nextb = assign();
-//    link(curb, nextb, siz[curb] - pos, blocks[curb], pos);
+//    linkAndWrite(curb, nextb, blocks[curb], pos, siz[curb] - pos);
 //    siz[curb] = pos;
 //}
 //
@@ -93,13 +95,13 @@
 //    int curb = bi, newb, done = 0;
 //    while (done + BLEN <= len) {
 //        newb = assign();
-//        link(curb, newb, BLEN, str, done);
+//        linkAndWrite(curb, newb, str, done, BLEN);
 //        done += BLEN;
 //        curb = newb;
 //    }
 //    if (len > done) {
 //        newb = assign();
-//        link(curb, newb, len - done, str, done);
+//        linkAndWrite(curb, newb, str, done, len - done);
 //    }
 //    maintain();
 //}
@@ -128,16 +130,16 @@
 //    find(pos);
 //    int curb = bi;
 //    pos = pi;
-//    int got = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
-//    memcpy(str, blocks[curb] + pos, got);
+//    int done = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
+//    memcpy(str, blocks[curb] + pos, done);
 //    curb = nxt[curb];
-//    while (curb != -1 && got + siz[curb] <= len) {
-//        memcpy(str + got, blocks[curb], siz[curb]);
-//        got += siz[curb];
+//    while (curb != -1 && done + siz[curb] <= len) {
+//        memcpy(str + done, blocks[curb], siz[curb]);
+//        done += siz[curb];
 //        curb = nxt[curb];
 //    }
-//    if (curb != -1 && got < len) {
-//        memcpy(str + got, blocks[curb], len - got);
+//    if (curb != -1 && done < len) {
+//        memcpy(str + done, blocks[curb], len - done);
 //    }
 //}
 //

From b829f0a49c5ebb5228c1c277b7f0f225410b2780 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 13:21:26 +0800
Subject: [PATCH 0986/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 5 ++++-
 src/class172/Code06_TextEditor2.java | 1 +
 2 files changed, 5 insertions(+), 1 deletion(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 833aec5d9..245d6a04d 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -19,17 +19,20 @@
 
 public class Code06_TextEditor1 {
 
+	// 整个文章能到达的最大长度
 	public static int MAXN = 3000001;
-	// 每块的最大容量，近似等于 2 * 根号n
+	// 每块的最大容量，近似等于 2 * 根号n，每块内容的大小不会超过该容量
 	public static int BLEN = 3001;
 	// 块的最大数量
 	public static int BNUM = (MAXN / BLEN) << 1;
+
 	// 所有空间
 	public static char[][] blocks = new char[BNUM][BLEN];
 	// nxt[i]表示编号为i的块，下一块的编号
 	public static int[] nxt = new int[BNUM];
 	// siz[i]表示编号为i的块，写入了多少长度的内容
 	public static int[] siz = new int[BNUM];
+
 	// 编号分配池，其实是一个栈，分配编号从栈顶弹出，回收编号从栈顶压入
 	public static int[] pool = new int[BNUM];
 	// 分配池的栈顶
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 3bb7898a8..503b4ccbe 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -24,6 +24,7 @@
 //char blocks[BNUM][BLEN];
 //int nxt[BNUM];
 //int siz[BNUM];
+//
 //int pool[BNUM];
 //int top = 0;
 //

From 6b65ef8d0c1be327038fa62616e6889ae2ae36ca Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 13:22:27 +0800
Subject: [PATCH 0987/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 245d6a04d..14f485e68 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -23,7 +23,7 @@ public class Code06_TextEditor1 {
 	public static int MAXN = 3000001;
 	// 每块的最大容量，近似等于 2 * 根号n，每块内容的大小不会超过该容量
 	public static int BLEN = 3001;
-	// 块的最大数量
+	// 块的数量上限
 	public static int BNUM = (MAXN / BLEN) << 1;
 
 	// 所有空间

From 33ea9b88509b067ad2df5f6699e321d0ec16fe14 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 13:24:48 +0800
Subject: [PATCH 0988/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 4 ++--
 src/class172/Code06_TextEditor2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 14f485e68..da4576813 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -26,13 +26,13 @@ public class Code06_TextEditor1 {
 	// 块的数量上限
 	public static int BNUM = (MAXN / BLEN) << 1;
 
-	// 所有空间
-	public static char[][] blocks = new char[BNUM][BLEN];
 	// nxt[i]表示编号为i的块，下一块的编号
 	public static int[] nxt = new int[BNUM];
 	// siz[i]表示编号为i的块，写入了多少长度的内容
 	public static int[] siz = new int[BNUM];
 
+	// 所有空间，编号为i的块，内容就写入到blocks[i]
+	public static char[][] blocks = new char[BNUM][BLEN];
 	// 编号分配池，其实是一个栈，分配编号从栈顶弹出，回收编号从栈顶压入
 	public static int[] pool = new int[BNUM];
 	// 分配池的栈顶
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 503b4ccbe..414306960 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -21,10 +21,10 @@
 //const int BLEN = 3001;
 //const int BNUM = (MAXN / BLEN) << 1;
 //
-//char blocks[BNUM][BLEN];
 //int nxt[BNUM];
 //int siz[BNUM];
 //
+//char blocks[BNUM][BLEN];
 //int pool[BNUM];
 //int top = 0;
 //

From ef664d1b6da7d5261766610d36238dbd3cb4a78d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 13:25:42 +0800
Subject: [PATCH 0989/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 10 +++++-----
 src/class172/Code06_TextEditor2.java |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index da4576813..ffc7960c7 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -26,11 +26,6 @@ public class Code06_TextEditor1 {
 	// 块的数量上限
 	public static int BNUM = (MAXN / BLEN) << 1;
 
-	// nxt[i]表示编号为i的块，下一块的编号
-	public static int[] nxt = new int[BNUM];
-	// siz[i]表示编号为i的块，写入了多少长度的内容
-	public static int[] siz = new int[BNUM];
-
 	// 所有空间，编号为i的块，内容就写入到blocks[i]
 	public static char[][] blocks = new char[BNUM][BLEN];
 	// 编号分配池，其实是一个栈，分配编号从栈顶弹出，回收编号从栈顶压入
@@ -38,6 +33,11 @@ public class Code06_TextEditor1 {
 	// 分配池的栈顶
 	public static int top = 0;
 
+	// nxt[i]表示编号为i的块，下一块的编号
+	public static int[] nxt = new int[BNUM];
+	// siz[i]表示编号为i的块，写入了多少长度的内容
+	public static int[] siz = new int[BNUM];
+
 	// 插入字符串时，先读入进str，然后写入到块
 	// 获取字符串时，先从块里取出内容保留在str，然后打印str
 	public static char[] str = new char[MAXN];
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 414306960..5da39ee59 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -21,13 +21,13 @@
 //const int BLEN = 3001;
 //const int BNUM = (MAXN / BLEN) << 1;
 //
-//int nxt[BNUM];
-//int siz[BNUM];
-//
 //char blocks[BNUM][BLEN];
 //int pool[BNUM];
 //int top = 0;
 //
+//int nxt[BNUM];
+//int siz[BNUM];
+//
 //char str[MAXN];
 //
 //void prepare() {

From 9c490293e7de2887966d1234af7c631e8a41c341 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 13:26:40 +0800
Subject: [PATCH 0990/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index ffc7960c7..002f470ed 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -26,7 +26,7 @@ public class Code06_TextEditor1 {
 	// 块的数量上限
 	public static int BNUM = (MAXN / BLEN) << 1;
 
-	// 所有空间，编号为i的块，内容就写入到blocks[i]
+	// 写入内容的空间，编号为i的块，内容写入到blocks[i]
 	public static char[][] blocks = new char[BNUM][BLEN];
 	// 编号分配池，其实是一个栈，分配编号从栈顶弹出，回收编号从栈顶压入
 	public static int[] pool = new int[BNUM];

From 4d4988eb9ec13c198d8d48d52edbae88c495e85d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 13:54:22 +0800
Subject: [PATCH 0991/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 002f470ed..59abd6684 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -21,7 +21,7 @@ public class Code06_TextEditor1 {
 
 	// 整个文章能到达的最大长度
 	public static int MAXN = 3000001;
-	// 每块的最大容量，近似等于 2 * 根号n，每块内容的大小不会超过该容量
+	// 块内容量，近似等于 2 * 根号n，每块内容大小不会超过容量
 	public static int BLEN = 3001;
 	// 块的数量上限
 	public static int BNUM = (MAXN / BLEN) << 1;
@@ -105,7 +105,7 @@ public static void split(int curb, int pos) {
 		siz[curb] = pos;
 	}
 
-	// 从头到尾遍历所有的块，任意相邻两块的大小累加和 <= BLEN，合并这两块
+	// 从头到尾遍历所有的块，任意相邻两块的内容大小累加和 <= 块内容量，就合并两块
 	public static void maintain() {
 		for (int curb = 0, nextb; curb != -1; curb = nxt[curb]) {
 			nextb = nxt[curb];

From 16c60cb3c79f57af7820e4e72cfd17ebfa4409ec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 14:02:12 +0800
Subject: [PATCH 0992/1712] modify code

---
 src/class172/Code06_TextEditor1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 59abd6684..338d4a479 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -105,7 +105,7 @@ public static void split(int curb, int pos) {
 		siz[curb] = pos;
 	}
 
-	// 从头到尾遍历所有的块，任意相邻两块的内容大小累加和 <= 块内容量，就合并两块
+	// 从头到尾遍历所有的块，检查任意相邻两块，内容大小的累加和 <= 块内容量，就合并
 	public static void maintain() {
 		for (int curb = 0, nextb; curb != -1; curb = nxt[curb]) {
 			nextb = nxt[curb];

From 32b026f1394ce58b65adf603ace94d8e79076af7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 17 Jun 2025 15:25:00 +0800
Subject: [PATCH 0993/1712] modify code

---
 ...\347\212\266\351\223\276\350\241\250.pptx" | Bin 0 -> 54183 bytes
 src/class172/Code06_TextEditor1.java          |  18 +++++++++---------
 src/class172/Code06_TextEditor2.java          |  14 +++++++-------
 3 files changed, 16 insertions(+), 16 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243172\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2301-\345\235\227\347\212\266\346\225\260\347\273\204\343\200\201\345\235\227\347\212\266\351\223\276\350\241\250.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243172\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2301-\345\235\227\347\212\266\346\225\260\347\273\204\343\200\201\345\235\227\347\212\266\351\223\276\350\241\250.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243172\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2301-\345\235\227\347\212\266\346\225\260\347\273\204\343\200\201\345\235\227\347\212\266\351\223\276\350\241\250.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..8fc03065a10e9d01e2f2896e6b416b64a69abc1a
GIT binary patch
literal 54183
zcmdp;WmKh0vZitO!rk57-K}uf!rfh~pm5z-;qLD4?(XjHP&f>Iy6>7kJ@-t{toyH7
zi=AKQ{*}oWPei;Kfr1Pu7%C7D5EKxK*R)nefF;Mu=S&a;2nZGk6-eLF#M+60{%@ba
zKuDio{Q0LGFlq_P1Sj_J1e5C{9)~IoeQm4^vz!3%^{-|_#9kFvlX-q%`#ysZh-9AB
z(!!ngv!PX)Hw6*Eyl-qcUuQu1gj>L>;m*fPM_{l>*TCTHtVLsz*7VCWF6^gb0!K)H
zG^(xzvvNr)zl^h%1XfJCpA+bIi_N8?FH2S`(>T9IjE}~5E^p?y$jI0^@InM1bgh~>
ztLaebpFCKSbb)7?Ryq@r1pr_M*m66J5g!2$&#`wtr5PDLXC>+HJuYN}-s49X0+9!i
z1X!kG=+tbyjh#R3e?zVBz$*OdSip!D&{{sXjspw?g#39d#&$*uj&}A=3`Ta2CiLz$
z*8kn%*hI-$1qvdGUcSR5w>H=kf@$6-Dx-r)8B~g_P8+5p7Vu#C`I6WCl8F*)_nh-s
zJJa%2Hr~~(Txn4x<GPD;aH{0r$SkE`L+Hm63Fe=%y8E7kxx;*k>xSuB9}<Y*??6=A
zJP|m$Ul^?>6Xg(;bzNZgLwT0>2ibHSI(%mjHLkdey1YAOuey#~cc37Rren|40^Mu1
z@bpb*Ks(n^<hW3N{K;LF(~~0X;^^qAZwGUf7!N79$TjGnH~$b7&k*ss`Nhv)q<`ML
zp}qZI?LB>B9Hxg632e(NlX!2Vz!Qn;tr>L^zvKa6z2d(NKdg1Kii7M86y3{6FpJRY
z7XtsyF)*E1r5@EkC89S!uJKqYV}A<coK4Ap2mvqzDx0p8ERw4-L-WX`+B~qP5$1b<
zyPGqlRcJ{1cIRIf<>I4M#gYZA97I6b`K|W4vxw;JDd}RC#`x=fKhB?b1Hx(0zz+%p
zRDcKcxffI*dwXXFdq)!|6I*9PXA3*qzuM7xvd!03Mx?>bOJz|H9-#~Zt!d(=pkI9o
zV#|>Bx`pHRX+y4<SI2Iy0CKXTDydVNQYEk79~X{pPh>W8wYP;ow4wvU+l*OOd0cG5
z8Feb08j_a<E-U4gUcBFr%Tm<Rpn6CFTjoMYUzAyE8<o_Q2a(-nU`XXh!x*P(02q=z
z0J}6ciB2L-A-qi&qe4Nh+Ew@W*hl73N7;_VCi<-_ITZP#3K8pDY3JpVXk#4LYc;9<
z&P1@C2ALmi_VEQnOblYl!^%47HbJ)RG2Kq7%m<7XLW=@1F@b*in@~@dgCmP9s}DV-
zvH_g3HsN3A5h!EN$0pMndo-y+IqMcFq*h4nehTjRv=)<vL5k&3`|8U>+!)g$YG18Y
z^JATCNJg(`Uqrju6+s%U6P#>oAO?A|F7#&ON8g(lQM_?sM>#%y+orHb2w-*AJ%SSG
zt;ZzQD^r`e@UHiDz|QAs48;iIsbm{gklW|;0LVPa4!^<`xA*_h2H)Xe!THhEG%G%_
z;9tp(yxukc)dn{0a@z7~X8-37**v}G@ZL{Xk$PGi8Qt$^LAp1Pl=BS@AvQq!V&hfv
z#Zj`$H9aFpXnF<~e8iIb&9>SVwU-W3H52M#1C36r$_&gNU6rcp_ZTCWnP~%h9cN=S
z=0=T8bXd~`qBNX1@;nthn2XXJ?ZQ8%(vaJ`plq4ogbkcMK@k?cr85MO^6Bcqc^Cy5
zRCh~TV}e_T!f({S49~3x9x&{+WF~l;?W@XLaNw+)O5N74%)xeO3hCR-_6l7z$I_B$
zxWdm{YB!!aue%%wC)?*qoTw6rfXVO&iX!8H9S>4Ez>^tCzg~SPq4+3Qc4mV)mc*G3
zAHrOaV^Y8CRDGegDM!AOCM-g(awjvGhT3Vyq+AT-M@cp^UI(Nskx*-+Ytz2<Y6L0n
zv<Aub9!xLYd9erdTDxv${%z{81n0@#+iTq*KnI@&F=5n=_1j+jvMc%7!g7n%9v^X{
zD42yGuJE$(IeD$iVv83g%>mKu1|dxf^VcB}=ppj9tS9GeuRS&MIB4wm+YtK#zO*>E
zt%%${UL-8eXsAQc-s86W%*fggyVKWMf<N0J5!A|>+$Ty?p@D!1{$YcE_cZ@%iGS&N
z+85TPdl^w7uU`1XhTG)?8f@cSM34+IejIuGFJ;vCvr|d2udk+NPt-*OU=Sre9q#Q7
zLdRFIXX@hM3YCaorS%z#f^7Yy#L?T|b9u0@B}~0HzK5fmEfAfTs|0ZhDovZydT5L<
z$q9-oR=DdLpU@kMvZ#$mJJ-CPpw5y)HBnjN8}giDSxV%JU1cWkzL@Lv^9+CMpxV+y
z4Mu3{a0EXmE25wpGwF^RhH;jsS2S-y_QZ>A62--N#3Z6e4wBR*hM7)pyg+C{p8>!*
zMX<OGPoI_l#PG4~uF)WZNNx@+YM|PVrGmdf{Pr^-4AaO&{?KUR2V3&(4UZ_iQxXI{
zYtglNnZ3gI8uST$>pL|8sxS>tVNy)uC|)Wh6=W|ZSw*oODJBuLVhXV!>VgbZCl#jK
zJdLcdvAA!c)CV2>TGI>x2=CPkaSVU{>qu*KWsiQczV#o@?!O56hsXOXJf_FWg?|D+
z=<+=b&?-k=BWZCe#_P58224~yJ~bSe{CIuqrT{zI0=aDTs||6oZPvz)Q5EAWF4KKU
zab$_NqkF{hTxsRxn`3T6Z_cO<`6NG@_TKJy>QFLUn@VA-=J^!eD}&~Nv$!#F(kihG
z=NX9__3rLG^#O15DyCwyjE&)4PVqyxqX|L~M5w1@+a4m*42vhcl}WyLr5_*E!;E7{
zt7ZC(NO(lM8kWIVq+{z)*-VI$LM;dW>c{TF@d*(#B87eg1{&V~;{E!b9pQUFPb1@>
zPQ%s0#O?on8q?jjJ&bS=TRdMC_vL4Epykkh_L5KFHb92_kRhITFoqo2oy0k};K{-x
zIsCXA-N3uxRO2uRjrW{gh%6@b;2v~79zPs(c(X)!nWuMagqjVddCSOiYKP9>o6x!j
zo|2No0!%=Ba~8|=t~PUxW9D3uo3*BE`8AeyXm-O2H{HwgL?cX%7-;A$Rw^B$iB2bw
zYXYHoK=Gzd_G(9l7X<EbKFR=*Ylea?eGYAAxEu*%!?GA7IE%B*LF)-^^icXQ@5I7=
z`R?BWAi(D-p#Q^SjqGe}KE0-pi?g|%qtjo$7*le8iv+;8e7-8yG+Ky>hLuC@jO61J
z=2?6>GVYOm<?0YRm&WMdzj7ytUcSI*Jm3&Ho8ri!mX5`#takD>@7wp*vF@uFZ^&M#
z>J$%m-uYD+b*RPGGk|GHrKt@X1`9V(SSA62HY*iyCb=F5o~x6%ul2)G&-<CRFxuy`
zjw`F<$Mtn&43?^_*K$i&9QuLzcQ}fJ`FA$x_w;yS9-<O0AEqr<A|nFW$SdT6P10=Y
zO%~%+KHxuF#aSXgF$^RSP=_245YazQz{%Re*hJ3I$=SrwiQ%6nOn-G4=V`09tDH!J
zn=fcT^e`$!LtB=LlsS)E=wkE~%mn-sEwrIrG{aoe(ZQeTUaANd7?z31Rveuaci7OE
zQaq|8da?8-V^Dkd`bXsk%GmZ*wf01C_}py552To6Zu_U+cP-b#&y&n1_2L7<#y4W6
z6>Pst=)n(7>A@%>;1)_JvXac-=HzkZjl*Uj14nyrk8wW1ahZ%=>u@+T0}fnwCkb}-
z#||xo_0fi@bDN7;w&Rh3>&p`@G>_Lt2KUq)wS?G5UMi?fg4Li=lDNP8xGJ}<Vcix}
z9qYf%8%n`--V{U_Dlc__SWlB(lJ)(HaepY``}+r6$&dV6hml{NTj9sxy9+5**?ejO
z4Nkv%mRX$YYIAQ(Mrh=V<8SV*^yH<JVZb}|{r1$j1G*c_(~O<XN7qz@jSlAIrR{wk
z_0419*qt(l?aVXlu~r0UB43^JqHF^b=0=PQ<q`=ls^k(oHx18^K+@E*YgAqKZ8-*K
z$CCvM6;7$qB5bwE$LXrM7}#spS0P3&9W6prQC<UYsuJ^BG*okj_-}}5#EdS@Aq#aq
zUEI_OC*eUGZAl$-JK`T&`bFNLnr&zG0(}U6zU!3^XYD1p%Y}~tdZrFoksIdX?oG%n
zm2HUUX&d=R0VG4J{AR@wx``lrO9=vUziI8LL7I=K%iX!_I`zO}Il_MUGT?$21;^q%
zh?6Xywqr-H#fA@J_;|m=-%J2Kb(_hLpxAeS_#MqNk%VI_)J0ZENQjFA+LJ-Ex%p3E
zM1Y^QRhOsN^$_;_Cv1&r3a;Qu#x@S-rx4aOT+7V`u73B{-4nJug*;44qu#1$+!ABN
z1u{|x%ipK=-$*5U=hUha&y^Lo*3hfC_>z(D1Szr&<v%M-i$G9orq%z7&u|HM=L;#3
zYN3h}fAyX6fp591qCZYyJ{6Jo^Zs~|Y8qWxjmc)_V!vPNb=cYoE{bj^bdEJE`j{`y
ztia6eL79r@S=#i_vL462XyD@Q>GmoK_)vjd+rO%N?0<ose^F)6f0fFH^<ufIDL)yV
zdUq1zWZV?3ag&^DfqHnk|F#c`=i|N<t}PI#fpAiEPlDTW;fGO&=)jQcV16iuQ2HB~
z$sm?j6TONdy+lhTA1=s&`l457*eYlbX#D6kOqOEmLnxxX059tm%)(J62BGG~&C#~C
z_&hyrqUa)^rAy0J)tF)Jz`9`Q89Nx`@DaE3L=1zZbJ30IqF>Q{Bi!hNw`-R(B1e7m
zj84p79|4!^!RhSmckG01Z3^RiRQ!VT_aOE!j1QsklC@Sb1+ZUFc#CiI5J&-}RW1<W
z;#1gPts2-n79O<%>LIM;ve>>a1ZsWh;U1WI#U?j+GU=@w*qDQ%n@0u*c9yaYOK|5=
zu072t*pMT}-Cjau0)rrsg!kjQwe`4MhOix7xU3SR(_S+?t+x(9(C#$Bab4O;w3#!+
zsk7ciSgkTyy{wAVY8X0aj9MKi>TTk4EHXOk`8|~#RSmmp6wD35V2y}>g4tfh=SgWz
ze!E%+BY#7ka9ZO_;Coh)OUtjUhhFTNFwc;qrYanZl`bSYzJNh1SJ4<Ay;Q_is8qAo
zxsd|P(!(&{iUXAyA9KK14Mm31;NK2ftIbjn{I>M4uK-hEz4zkdo1A%T^`udWRP|6q
zvA<_Td;-m~p^fbdap+tjCpJG;?x|%{7<I4%+)D1!@&o$Wa(C`#Z&VGp7s2A?3V#8Y
z42HQpsp<SoKsB|Ss+dxiqt3T*oldz}Nzg&0HJF$RCPPm-nO9M%y=c&qpxv?!L0e+T
zfb3_%L`n2~p8y4P{DXGl!!Pp%j~itWvhh@pdu3szdFXk$1!)hF<&-d1q6M#(967lQ
zt={+}zA?C<w<fDDrY%lwEo}SO;O=9R2zXA2GzeTjNCaO@+&u|O);&x|Y{#ppw5))%
zrEnvWD563lilx{u{IXGp{n=JSOna<*fjo{m2#&;Osqi&K5^-P7he8R+CB7NC4h7-L
z$+wXdZVJg`ikb#n4^8jgjUF`0oP%~Ny^ZW;%yv(m)A-wF&(Bgxh?ai1*V%93M_1T@
z#~ijkj|_e-)1`%OM0vzq5$O0Z*^Ewqp**`VK^UZP_z}W8_W-8>QD&6MXsdq?|F@?M
zL21z{;8A~<Gf?Tx1b8+Btg0w)-)5f|mcKoDw1u`aGN-zME=+$FaKQa(dTZOo{k(1N
zzdL2U0k1L0$zzkAm>3{TOC_*pYC_!P^TPhDEG2UBvCsOhzZ1x94^THdMyIS6>O5+f
z4j7j*aylyi`*@Wu-8(Mj<a8DJkJ0BJqs>1?-G7X7e~h(!u+{`0T<4w5u38@<=V!|T
ze|D}mUcu>@pP>ag3=k0Qf9G8Po*n$Fi~Y;&pnqY~Du5BS>)PuBX4ofmvSA_0lEFw}
z$->!BaOx1TAe8i2<KqP!CRf<wjL{vV`xmbOMJImL=Ik%;?Arjge4ykoFgcslZs+_*
z&Q5-`9gT8?OU@Id#z)^@J}8rz`eFQmPnuNv51bYZ=Mm)m7UikVA&nKvwG{#`!PGLd
zI?XRwIa*_~@^Vyb#lW#?l`QWj4K}OU0~p%+<gDA>G%6uxObBxoy$Uc?b~KGNL!4iW
z1|!Y{uzYc`y=T?Epkc?>pTB*f(smkQmTuUNFQ-~gRBp&N<|?$78Fo#pNdusz)!>n>
zI*q_cLr_uJe4X*X*G>hnZy>}F0WF{aC4(5)0LL%^EnovBgBqLzzd{Jn`974)BmVi+
zl?n>VNFacKMAZJb6yj`dVq?Pa$LC*1F*<)lF+P{-P@cMVEj+FYg_5b5x`gN0Qs_Q9
zQz$0I*_3orhrjR1ioHk&ZBv}J&p7>iM~Tchd2z!;y6raCP5YV#A_}?EQzvj%SsCGP
zDf3U8pC0yi?&rMS?oQ~qQK2WQh^FHSa+;H&6mhlC5lxtO>~27mH8BopMTAY4SHdt`
zV%v@T9BsV5nNa4N&S#v@@<;Eo_EC5=4Kt#dP{4g5%`4!Qg0;m)HF39XnGm={{@TkR
zMP22ga_T8vWjUlOB)KG31X)!s<-A|ymsYM$0L4;)oSfQS{LE6G+o%Rg_$@^H=<Cl?
zpy`CxQh~-ZyAU4eIsMs8h%CnV0IZRQbEC%Cb>M_y!_A4kyDbrd&Erj+EsBZZxzxKW
zz3>MKYX|1rHT(^`>uxCDotHvB@2MRM68B9$S5J3%X-Vly@iL>;NEd9$w7BTptNt8N
zJ4Ll%K@%@(*C{FyeW!*PPQF1v?HrODc$6aLHUU%f05N>*HI`i!N-zS`3NX}DF3{=s
zG1`0q{qJf8^YwrR&4y892kD`oO(c&IR{0+CGv-9FF5-<g<Ry~EHGq}ga;zDPfc+gA
zYCt#`no>$GS((TDeF~1)1R390xsMeGKuNJ&M=Wm!4mb3xhYGrvtFEm}%XBl_CCrTq
z<O|F#g0Ji^WsryX1F+qh9}@YRcvd4~-w5k<IlnZb+FT(a<5IOI;myt7{7~LoO6QVR
z2$Trp*>ze=e&uat3%FF;@rbZSjIf4R|C0Td=D@;X_8sS!ct}_?mJ9|_oF>uBuConx
zNZJ0aAms?~g<d$KI4_P_g3-%r*~S+|MtXUquOn(LB^wA9rJXpBBM6f$K&Qo8?#hP(
zb3LA%^_)=-lnwE9nwsja%vvw623E4Q^PbnRJU$;%;SFeee$l&E0ZfBTsc*kvUN|eG
zINiMaY?01R3t&i5M0})X3Ta8t7d}1M=rRX3fkjC3lcyHBrg9U2`zud?vhG_Mp0Q=;
zYsV^6Lu3C^!yEGeg19vvudSt3lW6%wZrTL=gx1qZX}k|H0V+ox?e@>Hgitb^iko1>
zv-6|Ys+nc(3!%;B66zG17*+n?Fk^54)A^fPFND_9tax@k73h*Xt^MhB0F@Ti3T7J=
zM)6&TSx7k9H%Ud=^n`x>8yfQFIf_c9g4n$?-!h%;eFyc0lmU2U&s#r^5W`tQKc$KS
zgA$6ORKxYLlGN<fGZFbZVkMsRvfl*cArm8{Ioa{*wmbs`2FKjU<J^={9KtK5H`Dte
z^*$b_LnOEi`FPBI6VAcR4i#UhBKKI6gj3STW3FWCTAGq%BwJz1BOr=dx~d_FsZ<d(
z@kA$%yj=53zdVV?&D=YR^ok2Lr=l4aTQtEzBD$#&Tz8PGHKDfUD2!*=o;%RucdOQy
zM(%Czm#Y>qT%_i4&$1>@a`kglO_dY?>bja)m!zXDe{v>9TWOfFDi>Q5N2<q_yfSEb
z{#0H6DL;&2AvmdeusSDK!LFIIuRofo0xlux87<Jza5CMw{q*~O9#-|v;H|z|v41{>
zK!6WB(>~s|COvov|01^57;*5j#>Zcc57fm`)8RRVv)@;gTo-#1cXKmo0Ab2q(#Y(&
zhIOMu&N|m2lNgPOI;yD)d20w$Vl9yb-yV#Uc>uX`KLimMI4Z)S&yEWPNW!1Q2p3u_
zO4gsGE0!rrRx1kk?`vG<T+HB6KoSF-%r;!ipnrd&IdP_796JTeKICMdIci|G_c*_*
zDnn%#lxE>DSpiDO82`)~4F!(^QUm0R{6_Jvl;LalQ|{f`lww9_Q|HxTeC@Z!PH29X
zn9i3!RnUMlH7R5@w<v^Uo(coMj(rSI3Krp0f@FJcK?R<CCqXKKjQU*Q{L=!E1fdEd
z?o)!uy<DK)+6ByfZ|h6vUF%E5r5v9f48x_svTD=&XiM0}B_!|l{+j^vb4o~T<Gm`l
zI7#JUX;{pqF9CsGU+_9?&Px|^$OWhbVGAPe_alCLuzy|vjuLbx;Jon?dnnE7V0%@~
zd`|L<()0Nj4FxCkhtTY&=3ayNFS)a<p@*G|^FMOuzfb<s>&&a`{w;U*y`%zb=XtL8
zjo=nLvknKJ=__i7%p&7PQ6p|9Jzt_jUz$DZ{!NMp0OXU8uuqT+E+F27q}j1<j+qyE
zd>HDhFCaK6Dlyl$vn)0+4x8%%R*T<OPj)G*1=2dbCdqR~DyP2N=7U2Klbc&&DAk1S
zhLm-&p_s)Rf_UMKSdnfgZgO);xET~z;BLB*6pE8o<M8^yWZ1Hs1Tk1NlrzN+Kn<b+
zw#q4`$+fJ`s1`5>LB`DQVr1@}bbpNJu>EMe`kve}#);-kGRdsPfxfcj4?bzL76Tbn
z*g$LY(?$mM?t%pc<(91K_8B&O=SO_K7H{yF@hEj8R0(j)j6yx-QkYR0Y0XRDGJvjW
zp?!m{N%deQt9wblcDjfQA`ko!|Fr>a+PHJO{uz>e!Pin`9d~YC(aN2ne2ms~-BN80
z?#Q&C0dz(F1*q^rp?`#vL-26u@EZ;62%V_oDT<VLULj-R+T@X5tU!&*N13^BXTcLN
z$eWAhN3|F(u}y%()I+!D_dahL(sGQn1zC3Sw1u$Q2N^iX;Q$@T?CeXAVNN;XkHL^9
zJ#4QEoL>r}Lh%E~h}VK&27bN<TG&t-S~{gkX_x1&C&Y-?t4`~M4p4~k2~f)QqkL0*
zlkS^C7_3ebKEAhe|1e!|o$gQ*rr*!*(b`bW2(yZOOqei`a&)Jw`?Wg`Q=Wu0)<+Pn
ztL~*4OEwx$sL?Q#S1*Fr*Q44QWTtNv#8F;>D&DAi>bkhPzc|0aw8KWG5q@>Yu(h<(
z#=Rwq<Py!OhtoV5bR1sc%{mPofA}yWC6ot&%{j|tYjj#i_RR3}r159VQ9a3MTXW%@
z<t({g0c|d0q_gJpE~l)rT@|&6a)Kc$xx!GTYGQ~nlD#_yL3x9oXEsd1?;%9*IHO4~
zJpe($PUj()`E42D0@}v*NDI+pX6L(aY~mdNZ+Njd+DG6@$&K+oLyFHjdR<-S?W4KX
z9OD8l1N}`1WJ-Q}bUU*4iU+-$FnkWSmt&InNFy+SwvBMXX4hsGiU)hw5IZ!J)GlM-
zQIpQ2S$9;T#WA>{%X=0yS}g<U>MJ-{AxKXquspA3&u?Q*HIu0FQ=9f6qwRPR@E|Th
zc;DmqS16AJ*Gt}_0C-upu!~00l*t}VcdoEQjBZMoUi<jIY3q2>Zfjg$*&NP}*I9n%
zfEc8$173WcLY!z^7XITY)mN5p96aOI3r-6<3`}hKSo8AW5sspw#iO;!LYdr8OrF79
zx%v16(Y=`lf(--BHrd`Bl_O^l7lHx^n}?Sj|3V2b1Jv(jpBf|iXCm;YB;da&@lQ#>
zKe6I3lYq$RKkgs{FMYzQ+~O7jLRinm0`c1<ef(prXAN#eP{cMjaJ8?t9L&r*3|HQ5
zFm8H&MY!Q&Yk>+;v@^>)HAN?_BR^MI+BJpf&|0t)#R42cd()ganG*LR)JRW2TW*rQ
z>xh$BEYSnKp(3sI7a`FX;f~m4nJEz*6yRg7zg!VCWRjCypY6})j0#X|XhrmtN@5vx
zhZQk7WjUAI$->j2b+shg9JtP7{5dcO`8YOV1OoyxM*jD_Wd19yab82$c9$K=cT*Y3
z^C*=>@xyUZvro!RkuVk0#S=&?ha@{^2vE1UoFn*kHsGEVPYH0|w_=?}E_ebNPJD<n
z&T$)ydjH-VG;c1KU*gW<a20w;xU$z)l(HIndpbU-c;e0J^Pm@@s;dLw>6n2+io}i!
zRkoxXs3^SwFz3iOWx+?#H5-fembbaUN_F^CsI_(+_S2K7?mD|aq4Mg}m!|1mdH0*=
zYEu9fL`CXK$^uW?Lkr!%0I2ParbURV4}-u0OfCbruDak$9f#5MPvX*QCqy!FuKe5S
z;e05L`lfLpivfO5vhf9u2y<7ygJrx{)TZ2DvuU5&=oLgTw`{3(mG3|ecO+P8nhzEP
zLvf^vE!a-KDvkBaYOT$Ck}Ile9MWw#w0@r$vk_|8=J((HEyuh;OU9y}^^^SzB$%_=
zyY8$62ll>=S;y)4=qd1O+p9&_$~nQ-1>aniWdKj!uH92wxraPV1(F4fih4u|U9Z>O
zm}<Q4jaUNDmYEUWeP3i`>jx*>m`|VsDw&>)Rp1*fOgm)q)h=m-Pi1b15n`bx(wdR<
zfH3u2sAG_<(T-$_)!<#+ef~_jh21w$WnB$Vmi_+pYMm}L6s3=~qR_Z)#vwu7-{cV}
za2$?)#?>6(rr-s%Ejr3t%<3n`1k3MqHs|M*P<~e?1h+f6AvgJi;#0+MVpukCFvO}}
zw+j>PIvWLY>oD6O7m=QL=d+rz3@1;ezbW4Lc3?>8KB1fi4-4JfCmK{%>R|>KUwTxk
z^3Lp$1)Dfd4@@0yG%T`RP@+0N!D7<H2JF280ZKYRz9^^>EG;axUm92X8e97u&-N-|
z#y4m@jd4S+LO0I{4#^L~=0wxf3`@zJKcK}{!TqkC^D7>qa9B{oH)0qNa#VQYj2z$j
zMoj?ekZ4@VW7QhU&1lt{`lk6p_mfb3FJD)&w7|b-g<SF=i1r|6bS^q#gDxvMe2rC5
zs#YhLt(XWc<LRDzrS{j1iCw9x)oSXwI7aEyVrt|nd!_p<Jx;m-#(4vT5ZGkg2`Jl}
zTY6BtJUp203|slMi^#{*=_Q6DweL0Ai0ln*Z*+wsW<<@9A6fBxriqz|J0Z{N9VB!Y
zZ|&;uRMYKC4X^-OgI>f<-f)9KVq9b3(%SXS4faTT2@>pr*k_C90}IhfPq$x{=+8Kn
zh&-$y59`ED_cvhvezb&~=t#bZ_InE`_u8Xv6)<5HYSzFnJxr}IxShakj}Uine0!>i
zUJrthGMr)9Eq-~|PpoM{7`c0|w3sG(m{BvN8BsH=zr?o(S>*xY0_k)tl2V{+_*@cA
ztxjdD86Gw#mQTqcr}g_oXWNf!uFy^uwsLOdTPgr?Rke(D^?<^RdGHV6{H+AOE4%1Z
zX&_B;SjgCKK6>g;cCC0mFU@;*>z#i_(EmS-{{Yc{AdI_r+wdViVLXoT?_tdHS1=w|
z|CCI`k$fiAX&<KwhuXs9vAL@D$SJp$g!6s7!gP{Fo02Z*U8EGV^y3gmlbjjyD9P%K
zu-LXR92r<@oepTtI4?IY?ZMeY!U2HLU43^1LDF0gsSApU%u&REIS;?513a8?>dx<8
zS~6LzA(*|P%96ta6*M&<hLrS_BBJNzRD%j7RGn^42#q5s6>D9$LG(dn4%j~Ls6H)v
zNmwlfnvuw{3s4eh@gv%b@v?ObOUh+TQGv`xbuT(SlP*#==;g>q5(2-vO$LgytUO{B
z*EGzHa%ms+c7xVfSRM8zfOE1|zbZ)fVZfyLwJ|bONQU0;<mZrSt8ft_(X^XT(SZ4W
z|MdoQ0G@!VqdEfx-LMCBjJ)i<XWf0UcC=x8fE(Y;)wN>3W}1uaR1Uyu+AQ8|6ye+`
z=UT7>hd(2aY7zB%bH2x3k&0RFFVh|mYsFtKdn}h&u|c$tMwl-ua}wx*4nUubx236~
zGXVxGV<aOC$c%L_HDmOHB^(w~G|~wNz4|iuJRTN=p=KJzT$u*zT^Jdh=n&nG^hR{u
zu85MCA;tsMrl6ZP`}p{sK+NKo#+L71aP?*SPO#Bu^cq45;mPR0Il|g&568hFtTnCH
z_eh3axo0bV+n%UX+z6w5&x8EMY)@iaa-D}Ibf-`Ki*H*k_saB2px!*7V)TI4O4d$A
zn0~KA7y^X_(aU0N?3~wLdj~(8!TMNR#U#qVd5HoH*hX$}?6^=G8(u+>sq|-_`vjF~
zO{_q4V;9Z<yp3;+`^H0EB)~Wi1K!FZ1wsg=1JxqN7+f{f$wb$k^1$9YW@t3`>R2R?
zD@-6RzUZakhObEoN98-ukB+yOds<6Y)P#u+*|g420gT_OgX+Vtkmfo_FAa_$mqvD%
zGDI(=;!D(+yYdsaFy;+T+_p5J6#H8cmlngeWp)n$qFUSlb?AqQC!q%WB<WI@v>D(x
zN=qS%a-FS7epOAmMq_IUhJGT?B7z-Nb&^E-d$6OmiA<zpPtz2xVY@95SUZr)kEy3K
zms}`rR6_=sgxehTXyP*k(RRvL#_QlpeDS&NkQc)|p_C3!%<Avk8NP>zg*#&H07T<m
zd3efJxeJ~m0U;tzbs}DMqUYqEWHd5<y4yxJy<$guc_u}<(3uk&if$+A;6sVrSi1Y{
zqyZt!4D@LGUjus9RuaENdof=4UZgzqOZ|NDx;tmLt+C~DPlcFUVIWBu!XPY|(-3A@
z(*~x4oqv%oesBgG6jOddtB~*=U8~Tvw{bFDDte?Cx?m@_UUDX4sqJ$HH4@`NHi;J@
zmR>ilKVMc(B^GZCVbMyNIGMtLF6jCe&jWOjs;O$4+3FV{qVM^1@GqkG|36~?z{`Ii
zVo{2VEEGTWf%Z@N|4(=8{}uWFA^iV+!unT;omU%mTxCaHKcr#Qai$2!D>5T7BW@mc
z9;jx^e+EW^PEOlV1<J{H=ANxQ4&Ik>1O}iaP?ql-$GQ`NZ1F)p=-~D|?3d!173HkN
zD~<g)qJ~34OCFQCW`y<CZ$FL<P+w%wD=9X7qFWv<7xPCll{OVJEKm7nUGu~7TSZ<D
z$c9bcL0^xGz?M#&guxEnpdn{pT0F7&)iafQ^Kv{^d+eu%Z)k-ghgBU@P9<%k#eR><
zo?i@%9nGJF;%6&;RbwtC8SgFLJ1Q$f!tt9ruFcTg3KULpDbMgBYyzYeHil|%m**Sp
zJe6d43+(7lJ!P|YTaeMPQX+{E=ayQ&3F@0@(=*n1V}zoWcZed5Trp1QNx53FmSuEX
zX(Dz)b73VG$Xc6uk3IYi=qvPVHXh*EHn-X92V-3-xIuRNOTTU81?|X5|5;NC+Jo7*
z+MOhp>85ocH+GkjlRf^VxW4j?_yjJo4thundi>>eor|=q0O1D}F)tAO?=aucwT;O1
zEr%0qb{t^4*3adXVe=z>WXL3J8DUw+t+y7WT&%3i3*fKe3c6b(Zra0jdS}(sWRt6l
z*I7;|Mm|{WUiE&rkW4XYPgb7l^7_bxul{(GSbi=vk!iH@a@g0oF<5x0-I}DE-dX@^
zBI1wAP@ni(hStArkF-z_`jYF;9P!l#T_R2qH7L@L{LPq^pKZF4hp5jN4Pt~HQ|!y5
zbL*G&^fI2fIOY4@FtLiVv?Fc17o|P>@<&5?4w@SI?8II7Efp_+N!0@gag))poG?a8
znWJ~?^z{&~^}6bXxoVrG>vPZ44*hd`zP7lW2As2Z9MXmgI|9j`!YOM-Gu>z&%MR=5
z1zG*enLL-`fGlk-#h?rDx2ws{Nyd@~)4N^oV=KRM5?EIO<zW((ZfG`Q1h}t2eMunC
zNg#j^P@SWo?&EZq#(k?MCweB3J2roAFEbww{H3lBcZ!F~YkQ`z2g7o9b?)nzay_KS
zkrKTgcDxspki)6h_N*;WJe-sP0H~>;P8}U@Yef5X*~b~Cx2U3*5v#q9Q;kQmee6W;
zJ4}$g6e#7Eh7y~>j1@4dC&_w1{$(D5PmCgA;w-NqX(f8u*gL0hY%u@bbHBv@G$8!L
zQvU;K705mVn($d4fAx8F_U~xL_E)rOSCz5-EGJ$+L<M_5c#E~^55X0ckCWqvNW=Hf
zK9Z#LBcl?tRU|At?)C%#;*D`4r#W?<NfdKEzFxuy=iY{=uqY_nz)+!Za-NF_g2!qS
zWqf&jx^BVf4SyPLPQglC--)E9vxhP?<^0}UZy6Lr#I?VaCN1{Ut1&Uf=oJ5+WrWq&
zK{hShuv0(?7Xzfh-3LyuVi7!B9T1-evl?SQQsrVPr$;$kU2L=zUobEYc1I-js!!IO
z<RS3`avBF)4~Z^PXH}WlV{~eMfC=uo9IjQ7^?O55*WS%O0*=i6h$hY%Wa3jkWfS7W
zdP5A_sDIbm_6&f@QVt5|zKH6cMseM|UP%V8=CU*&LJXY}2UYYuoE@Gmt4h$XE3=g>
zW8P}~Z9N&-1w?n%`W5X7vz(4lF6JzU)Q>Yp=H@G8jp74v-Gky~3G&0jg!|Hylt}|{
zV_gm$FVyqt{oz8E1h95t&F|lh{BOGZHs_hR*xUm#Adc4P`PBf1`n{0`#<}gO4)j@c
zaSJ26qP;E#lp?C?sX>QNN*R^QK*JUEdl@bdn0dm>7gIh7*MM=GiN{vq-c9aYH<jbE
zxSDW81VN(F8_r(Q9#!3<(J;eg2&)5~viJL~LV&kSS4V@DeJk&#>qYk8mH^I;2FZB<
zGFRuFyC2f$HkosgR?d6@2q?Z~lRM;2Wv?}O%WN&8Sh-QIW?;Q{zPlGfF4)q#w{GqZ
z6GzS*m2l|lM0uLMQJ(bAO09(NDso3v><&A7-h<kvHv^gmtR}a*cXHO9g~nf@^NpSn
zN`tB0_Y4*2ge9M_7V|EYaEk|eP<>I{zPv6q7w^H&OQRb;+Da5EPS6%&fpM0iml5i_
z7P`EgrewZC{7)_ZkGK6l(BhYV!k2-5rhq2!|K8%+|H|V3mI8k2aXy=sgm+VgoGluO
z#%}3iXU-VlHKB^F1cEXur16b_J36uNzH$O(`ZGjiPctsHQZaNVkY1t_aAp&@@Pn5E
z)>vXzInH#CORx-}h{ze?IR}VFmxuj>dIvsDo)3CataP^5@?~%!uoV*SXQ~53v6rW9
z#BirFM9{(QN|ZtHyd{vG3htm8nD@DalHNg97xlkSxPIr*o~EsZc=tnbM1B#YWJfBm
zuq@`WyW!f%BgS6iJar<fUJL?DRXqd?zQ(ZCNT<mbv!HkC)<VQ%-y(urVH}eORGT&6
z&m=5)53C@u1<&>D{?v3Cw=%`3%%XitLk}^6a1CEkaQseABON+@#51<{V6FyDl2(ui
zD;ARQ_#6jt;!>XIUiU0e&}~x2mdMz&t+Vts+5`I_I6zDfkyuq?dVzh)K3@VQKR;`<
zTO3-*YSSD;EcI~l6X&S(<;*>IgM5?-UMWl2>X4;?Zt*^-qlZeVOdKGto191?tW6Io
zANR@3drMH&4$r4_1$y6IdU5%QmUa2vZYmn64CeG$8mHS-n$bdw!uPOW06`{mkTT+j
zF%s*t#2YI%`81VYFDo8|P<U?@LE$nLraNf@duE8i5RB2+*fn=oyh^)z3l$zTj5u48
znota$QVS<A(xYgd=yvy*AQ6L|>i}+F4Sc>Pg<^K6+T6ZjD{L(lEVaf8Z#IT4I)`sU
zBj9=yz$3KSOL^(QnWJkkS_idjS!@OV(gp%H8H3nglw4Z`?F(0n@m!NipLV~Ua_ppU
z^@Z9$e??lV@kl0w!VvZn{o+DGU_!E<l*@<Te3M+NOs@&MdxmXwOn8xX&*RB2H1j57
zCO1W=`6cXv>*+LFK!11^X10dxc-4tDYR4L>@2fqkWh&{Lo!HEmo~N&i=Eu*3%t!~x
z%y_iO@tyr9m)lqn(=zbS3~V8trdPrxVvr>^lqh5X4e2r%5YF#q@ZzZ}DumQ>!w5jE
zQ&;pcD8DzT{AHp8ZxW_4pl(5IN!x-{r%XkSqP8jmPVWQj51Xk^+fH+)X_hb%a<lS{
z7!YPCrR0w>A$l2yXPUN+FcBdF$_RW`E4bix-=8X$FL2%Dtj7EAM?z|BCoR+X#4glT
z+x$F1>Gizd*f0*X-C`LfgKZw(lITIQ;Cr?{ro_<gW)F5}rPs=rP)tLU;z17Vs<?T=
zz1uNAkR8d!a@f~5YmB)=DX!%h()Av^dI_VvG*e_fH5W4BcA_-_1st7TFJnL`2+e##
zP9Kb&&*M|4S-B@Hi4RsuBu=x}b97QX8XP5%X!a$Hi}iRPt)1|bcnkSUNMvH?<nM27
z6=bBNlG{W&WrcMUeq3$XFCQ}Mm+${$zW%|M|3JRVyZmH4{EVo|KkKXiT|~w4SA4Bk
zU3FYxMEa~sGQX4G!x>;?N)}AHBf==iBgh(ZJS#RS2H0n%zk88A2}}M$7?;(*s^K?l
zH*;y@?_8>ZVO1#sEK=P~@<N%*xvMQqQoa6m=ab&*f1PdqRZQL5&(ks8#c0XaOGR6U
z&Ju`9McI220jrhj#gznSb*s*wE4zcC9I8rr)rQHWvrx4=s{F`1DI;9Txy-0_+7Ob5
zwost08ZUf5-$ykcm^TvdaArhT9o=ATi|&JbCUH4Z1(2+8ub6}~)BWkoUhw16#pWnI
zi)v0AN~K%>qH0E^B9isP<(sO`0$J^FGZ%VI1+#*Ysk@bQ8FP}_j-rxfZcB6QH#)VM
z?90>yFp~r62HKDo96Y#sQj9E)yF>oIS{wT0c5EhtRAHmk^fxhfiAL-gcB$W*O1!w;
zfSp@p))NAMJ-)dT%TzB0Gv=e?0w8=D-D#mT6QFk8tMUYX^E!3KJ0~|d1%vuE%JF4s
zM{?(22|nO<TS2_cAOd#>*2we;bKD^1%W-26KkjQj21_ythj_4!Y<u1>O2;@OSXDwW
z`P1Mw_#BPWjZ^qLElRpy)l3>{hbWxbY8>QXZ1p&DOjgD6@3bzdPj(7!c#yHiJFy?*
zcwopRVI+hwe_a(S?hO_QNibG^Jtt2z`d0A!ryBe`S@%|kEoD=#X0u_smN#}((X74Y
zpgeGnUKlLo_alWSdx41q_k+9Br|)jGLOfbB=(Zzo&We`<o$kz-yqXDE;14*zMfU|X
zXJ~bMEu*&vA!Kf!MU+>$k4OscUd_2(D(*xWupkZH%|{vK2R546OgKY#J`RRKadO-S
zV^h;jDIRG;lfuoBbtB0~N9|efbIjvqcls%%diptA<adVmPB?IbObT=m@i{&9%sa6a
zTY1+lRBjN$g9jobo9SAesSGikVb?`u6+^95xl5fhGnJD%wir}k^ja7Os~!><zhR9N
zc4^j@N#FQ%x&&Qb{2!fE|Nk1&ANKPf$Pfs)%6PO-4e1%`-!p{suNcy<w(6Mr$&g8P
zMo%{|cJ?jk;Xe7eW7!n<uoqzFkS<hR>d%G34?QXWNSs1B&s)$kwN?o)SB&yWdiFd=
zOIqV$bGSBT49;H#v^2*eaQt+YkVH+K0$jVwnkJ3rqYER`_$u;>a4`9gsKUwUzX&}>
zI14-(%zhB&C+z^6g78_ADs^X{$`cBaftPo>M+%JIGWV;~>VA<`1tqrs86TyFPL_m+
z?FWyIp<#)6>O)I<(@Jzao&zeB@c|bUUu*!_KVdb=6FYLuMdodU7qQ`r`o01rfqr%k
z3V;b0Rla==6LXM~`4)fJLTjO9f*>aPLMNkYc$lH4-AeMLWMECIwF#AR^|K1W?OvGE
z#8eSS0%$dI0ghc>&0nBNz?nG3)=_9o`__S-X)3*z?W?)7dv02tVu6>9)*3;zT)3M=
znV}od8J?vETQ^_f7g4;-JZhG+CFipuEH4QgQ){D;OUx7whL%2U#6m&Gj>NFop9X=Y
z3;3=GReo)}8L)Oo@&mTLGfn|RLy#U=o{C$|wlYh%625y9kag4Xu*J5FBvHuU2<=P!
zr*ogxN(Sm!suhRX$$Obsu}2epSE+L>$W(J0&>CQE3C^P;_0t~!rZEZq7~@pv9RWXe
zk@e`sj_?zSH7n;*OAUW4`h1`UFj$c~?}A3!C_gO9u;POEnlry@hUUZ)1YQV~#3;8H
zGDEy`UO9g$eHXsNDBak}Dp9MTnaoQdbg&Z02beww)qD%OCDS6~PTID&*3gDbxtfCl
z6o#vCv6aX+rs$8>+A;Ndn3WnEttOwlsh{pyG=GnDA2gq}eZGt4u2OZ1JtiF3eM6R;
zi(E6hbqseMzdO`D!E-%cPbqUwYR{LrSD4e2XuVs6f6DB*)Io$2d9dP4o_tOAV}m+K
z$`#ssekX(@uNA_KGBx_(P6O+n=cqC&P!?w6cyx5!_8sanMOmIx-2vTssNa`78%ohe
z<Cv{rT2D1s_+CUiE_-46WJN(~7Oi2gw!+kglLN4-0W<3o(&Vcgxx0P$TzU)T5_m%R
zpJs)BSlfRfar7;r2Gc)@gYf@Q)yDN##QEP<ZBQLN&yB{p(#SlkIf5ye2@gPZq7pq}
z#4<Bs>z_3mwUDcE@p+^&7IW5V>p39=Wkg(?_8rN{#U5{_U!@g{=wY<_r?_f~x>TiW
zb6O&|Gfx}ipgOqx?o-Cal6A8|*QK(M5`N`k9w^l`n}o6sf`zh-*yk@a#D5{3kJ;41
zl5iVAp`u%CC`1<$1K0kermaydjKQLXqzMp-93?}V&`8Yi>!_@{P{Rlp)?^@SP>1;Q
zUXbn}9eM8&aV&;-UuCMCSBA=h&be9<9k<m*1RpahdrgGU(enWqI@BYlh^seL)mITs
z^lL_GU7l3(cNpZKtxf%^L1SeGR#DZ7CC_+f(Ao~U-nx~Xl*~rez(S?E=JRC`#$czA
zk2VxJPrjp}zSQ&v1R|<zkZ*R!Ty05&HsrIu?BjOg&a<!4$Tp>`UD(zonrst%d0)h?
z^pLt*V#xR%XMqSGU|SZ)qEYYT_I2mrLG~nR-Gr5DcH$YAPqgv6urC+}0=AoevsU4x
zMBz=;c{4Cpu)yN2+G6o^U~vBS*)X4Iin(MY6NF{j<4jPP%zc&~60cWg(hFUn7-!}&
zACL4*Va@TNGA2eOV+S>TUqRdL<RuW7OHDKd-LN(~b8{`HhmR&T`Ypl?SQpPoLp<-G
zewk!?trO9i=TjMwyLx{hZPq)QD7Y|^O7ZZ;d@I5Ie&a*-?FceESC}Fglpog`BEZXo
z%~6+|yA14_=9V2zwE%&V#MHf2JXN%x*%5Sn1*jx2Ukiy=Hy>rLXzsqmk8U!10K|?*
zmkN7bzFdF(3@~}xJ|D7JX9**J{;tT?U@^h8FN$=h&8o+7<3CO!wxT-gS23HsK3^Q<
zPouMovZnHwY3C=9t0d>ZU(4<{Jo@ex))RX6<y5%1-yQ`_pc0;>C6{+@bZdnnFk&_C
zT6}m6chir`xGf_>KziU>*z8$p>5(thAWd#hd|JlvOPYI51r?1FlViqj%B-;liDl$B
zFn=%VE*`Y451g$&p6y4&w0N<g?)xa~xxzuJ#qXB!sFruL`yA_FhypJSB^Fc8ouae*
zJ^GJHarPeDa;6QJUvunReu>65LcKOlv%)cS_K>ik0i+#jeercl?fA<Ic$l(jo*?^d
zEqh~sv71^H{JQYRp4St@+Al)+c`@7aeo?H8mh1M5MeEnX*^&ly!4OKCkbjM*Ci=1d
zTf4Wl^`yQJ<o}d>e^~v0Ao+OTa*w<|$>;r95<&dW?K=O>eH|0yU!m_@UB>aVp!ZV(
zr@Sz^q6k$IlNWOYXg=m*dmsP>WDUbyV}0J&<tZi1j&&c91|U+67%hlq%*^1FfVVB4
zJqSv#UkaR=!($Vx_Ae8M(Dwi#1$pRI4~kt4z8xx}dpCJM=#8nS>*w-qS{h)=j!zR)
z)}uQ?q0vK&o&1398Pn?~6I=04h-OSW8aB>hi|Dlnp(@dsy4k1l)<Z=jSI4!ZGF+jE
z%@bcyDIJk6qEF={ON|jtW{u)gL3!&WOCGP0`H^!chOK2djK**Weo!|)<zd7uYN#Ew
z0b2ugM-No8_mxA^f|x^G%ek$JUZ5syrC-L0_OofhpUBc3CpTg#XDtZj0f2;4eGra{
zQ=N$5w^~M4<d`&f3$kQe$9N<~@Bfh_;7XKo2_to07z^qe-o?x5<@M7w@{G017x|&I
zsST%V=VlfN+m*v#f}_5~+ks(!tVVtkaOh<(hpiOABmVyWv?!Ei0^F{Blb+x=Wg#H8
z-11?tG;m>efTXAkM&1Y-fKoiKW+A@_P|jWjs~QE0E>-G97jxjm3fA-H4)3Lv%UDH|
zsI@>1Do2!Jmy4tHIe<ukExyC(p{nX8jsaV}6?dA`p*hdS>r>5NNhv$?wu@EEz6NH}
zalA$UM(2Z8KZDa=85*9-U1O?9TDjh>Ld)?r5mxbSh<BW5S=<1J^82Dj0K|MaA#6E}
z{y39?R2V`@La=L<?}K6MlWS)Hf7^aU6C*|cWdR|mHdroa=o^;Ubl=+0yrG`e!9<nd
zQrfOvo^414BS@pMOc(rcDV@!^c;R*xH+<pmJ5<6mQFraO-ty(^tmR{O>|nd7%*pE}
zH(o4fZ}j}*)Lk=Y-ebJ4ka*F6;@Jn&r)Ju(UZaD(iDnLo?V7&gqk}o&(eEOkUWy%N
zd_DANR3zH8dqt5~5tqeZYMC7q@&G#Uu|9CGKJZQ*Y>5NA>U7~f*DTeAZ?&Mp5yZCf
z?)#8>y_G2~6YU4oTeH{<>yXVP`bUcZk2=GBna>Y~i4I1(mV_6+)Uw25=5}m3b%MBQ
zTG?4e_H<ea%|zP4<3nrabiFqygpmlcv(GZf6xbJjf@jSxP4!V6(hKau*p_U={lvg@
z4&J)pUwJ4@s>{VisRi=shG2fgN>?NB!of`9&?Jd~wb!n_@sf(G#SU%$h}fjd_kU?^
z|K}u<?!PnV|FiJ+52OAMBpVXsOmhAw*;YQ4{(noh|4XZa;@?^o-acCufZv=chXG_b
zE@3OnsIYmV)$)jf%5`KasG0!RGgR0!i{A!bfX~|7{5;E3uwx0|JR&wbRy)o;xXt#>
z+MZ>_Vn;oB-H$ORJS~)rgMHHz-;Q=%(u<c{j>|q#v|}{>t8!N$#S-X@mgI$RKVpcn
zOf=FRgk&BY4giMmBF#d@eQpM!XrHna@;6R~b!>*O-M9DL6n8)3=yLNbA|$m8;5SNW
zF-oe*<*Ug_RSgDmUUa@qx<K=rMk1dDZzdaZ#p+zw^OK~_qo;g!Dr}anPeBS5R&2CJ
zjXbVXl(8nrWF5Fspf3kAo0;C=CjO)ipQB;|U8CLPO!{TcQ`uLZHz&D&k&7x*9i#T<
z*%%|Ap_Pg@CUzgJ1+Pj-lO=H_N3t{QOPA~cieo0=LS%<<5ITmtZWXK&mzPeqEEi2b
z{C+eoK8~nxSQw<buY-tZH;0sReYd4EjYpT33V45*?34(CI5>KXxP<>8QM^Uh#Ct=_
z(q*(zO@k|aQnQ#q2e4#YVOrW3okpBQM-aH@4wZ7g=;1~NJQ~J>_~E`}sLw_ROhp5(
zgpjU8CG!Q8CU8k)b*0XkccC|QsdS6ksTXKeUyO$eAagC;fxUD95xpDQs{E+Z4ENbt
zY8z-B&`7;EBNgI$1u;8nef<zokU9BpR*LlCOg~VJh3aa1`{(3%d$VuyOBr)d#Z^nC
z>lLj!D;h>$R{2W$tn`#<3Y_0CIO|GW{Rx%bkVLm4TY`(k(l=Ez7D<2Tp%|h<Zde(h
z)X4_5%MSQrcEFJLCQ2=h_7M!cAE_!pYf~!<B#=r1)P=}uRHk~{8P0k$p4`7BpEz;G
zZD8}+)YC*9QS%s-^CL%ReF5rL2JZdr2+#*s@M6v>D0wYw=##Tyx<^}RvxLfubQiZ^
zlDTmSCyT#nnE+$ZHwPG?K88Nj3bWt`IqbYua4WxRQhOae8y#7-fG*>eaR->8lR`Rv
zpjRe71i2W4T=hnp4Sj5+L&|Gl;LqoOab4XV^ZZ^Wmr|yS?jfCiN~bL}!AEA4eGI8$
zH}THRr%#=PzX$$I?`vi555H+QY|amBw%t#d;fIMZpofV7aA(CK9kxgRnKVop#qjPL
zJw`}MW-lTTMQ^!kuHv%7?)=$K(my`oXxu=Sxk_c&@+4ia3Y?3QM9m?yvZgBEP6XvE
zk-yd4Zi>qQ{kM8o<t5N#TfMzK87~c728%<x_y0?9_y5SiKg|C>kb!&4Hf$%K45a$}
ze}Dg$fq&V4aIU`kS&sELDb4<o{?>O^bV9>5&UGMhe&h`(1WZmI8U$QWQ@W7lJ?1wX
z!2!cC2&ouXwh>ocn<nBO3UBKgA1A8YX2&XEWXXVDT5D4Fu#X*Hr;wHAbT#?uaQsEe
zx`W5(Hc?J2LHB=g_m0t(aND+a#kNtgZQHJ(qKa+XPQ|uu+qP}nb}GrY-gEb9ZST|0
zd-rYM{dLd3wdU`&#u&ZNKAxHP-KqcxuQ4SrRb67VD2a3q7==WRqMvnRoRVCkkF>jy
zDe8&<xs+zPNjN;Gj*Z*LJA!`_;HzP<SV2}9;RNnOOOB|ZlA?IAILojM)%r55dC-vF
zbyD_D<{|jwew8y6$Z(>uB$HE;Y6WKDgzT(nVcQSiOeAQ`BZ76d3km6W`Ojta2N~I^
zB#Y2y^)(fgQ!$&1^jtp&OI2WiweMn5mv4FQSPmv>8epW8vX99?SbE8nx6k%gEJ@-l
zVO%wLh8C@7pg099MqEyS&R#6cDq6TwM>c55{9bHm!Rsv=q$f5l_wjYQkylnu-;m&x
zo564-Bc)%CT-)=q8taW&=iDqCdnPSorskSkW?2Us$2U3JhT9XUhl&Nd237_`K8}n@
zpy4EyaTcuL3v)_Iz%&_o<Xv|L(P}sNt*`^JWzeRHQ(y>TJuZ9_B$>cN1R{%taR*W~
zAU`w#ki12|#M7k-HB1p^)kEpXmED_^B$P>Q6+TqLQ%@mc<9$!y>0fpS-*$wKe?hgz
zwL@EYC~=0V`o9!zb=6Jn1kD%+-{UlB1EtpDfHqauSDc|qClac)$rRQKChiG+v~eLI
zIb=MmQU0<-z`3eQUmQ-aTug)cWnk4e|K&Tdbm;*i>AHIp!gjvIR}y?0ki?sI2A5C_
zp{QtEn)yq$==IXA(cQ{hI#;h+{?I^k53VZW9Gic`=S?mXy=06#_7gLbOJRq!s+jeR
zTpRiKQ!;X7{tVO~l|1c>AZyDnl1RS%=9zG(vd$AS?-Y{E8SfDHZ{P}<Bi5r)&s4$H
z;+4-t;*=M|)h%nf>O~`JJK#8~9Mm{-v%yjQg?k(sE3pQ?DmwiJy%zHy-~mxMoyZ(g
zIoyaRys|mh@4eK1`JnC~exLK8WKH*FJ$Aq!emy&8z~AXZbiP1`v0$S<&iFUJnsbmV
zsVz@}-*!L0VynM)ECg<@EZU>(0t4O^A+8JIKONxdFLm>}0@Rg_f+IzRmuASi3*7v$
zkUPZIFOJ(2v**;+bVdn&yGbp+|G>?f{%G}K44s<pkko(w1YOI1C5h^E+v$$(r)Yaw
z-cSWkSn#-vth0a%NL_@tPHPL(A$0DXWku%Q%{(V93hqbe5+I-uZ=_IGT8r))hR=xD
z(wj0ZEnfPVpu|L#wl&74SkF*3dRw01zB2ioXV3n>A142&ZVsFzxg{wA3aKF=*7|P?
z>EEsn9I9y8%rl^RAFHZ)Yah2vHs%SRgF}Xn7xW?6q7;YL7#MJO`o3J_9@jbLW8>^a
zCJ*qjXWx5uWh7TWDdy0!H>pel&)<I|-a05NNuLDvdHrJ?x2K9huYJ~vHt69jUn#sZ
zyTYllGsekFK5&GVJds5`i8GTpCUK-|&Q`!+2@zXBFi#K?YUmUI;d77bqnzY4Rjs@w
zwbjBGvg^+|vZT`3WWe%~V7g`tqsMivL^;|m3ze{l88~~>%uqKKSy$$G+!`kwh=da&
z5I_j$GUMsDiAStax(Q+Yot>H@5)a0@Y`iE*+ZCwcfLb9ZSn{U5G(pMK-}of_%2CCK
zE#qCG-pk@aYCC1>aQ|s2r|o3#sVW6FtT*C8Zqt{?b~{3tZ97@)jsIuh6AY}!@lN-^
z_{&yq2gZ@hT*sSZA6vC{b`9A+@PVm<j&k-!sD06{+Kl2Qs3K{dObzg*xoYm*LWcl&
z4!^L4GEB<N<WLsj5-LS?LQ~aL_nHR9)$Yz$8#d&e6MUej&W;T&a}Q+jBH=UTAhG6_
zA1=As4`Q)=68N|rhyZXFcz=i+(p?&ux{BYVV|_Goa~?Z2t!zu3hf+lRYP$UnzdJLm
zwl$X1qsX*WoJU44lgl_<$65aX3Ex)L!el6@AwTJ}L*)nd4d7ZViDO@HmW(fz*5NIk
z1-J#(SRcasyMUcu&0m*Ti(N4h5SK^W;cV_V<)f}7mI-pckNFKpoo7vzCDt{baB8Z^
zBoN2WAER)F19J@X#@5qF7E3y2OJIL<)nl-<<tkJVP<r!G#Ny{EN;8|3=?&UpXo`CL
z<39oIEpWcn%g8M(_KJgeVzk|A`imV`Tceg%qW72mxGw)sT)Ma7xNRjq54J-TXdZ-!
z-|8$LuJ&fQN<KN_ef<=&{ySeJJXlaVp=~=S2Gq;8R(L3Zo;=ame6nZ__&ZK_Yah%G
zU(iN(m`s-1eM%SSAF)HK<F;7ZKjO;AS4m*{Y~#po?c<8-jZnKJ_eokmLv5%*B(O^^
zksL=i4dmX~y94A>5M+GToLR@JI9tv{)}GNiPcxxFSu1KAuf2z=PD?w(RJg4h%G!gE
zo3v`N!xB4sLeSQ!fvS&t@Hx!^Kl?wxe{bvkA5MP%Q*-z&ZA@QVfE)%0Acyg93)bHT
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

literal 0
HcmV?d00001

diff --git a/src/class172/Code06_TextEditor1.java b/src/class172/Code06_TextEditor1.java
index 338d4a479..4b6980e86 100644
--- a/src/class172/Code06_TextEditor1.java
+++ b/src/class172/Code06_TextEditor1.java
@@ -26,8 +26,8 @@ public class Code06_TextEditor1 {
 	// 块的数量上限
 	public static int BNUM = (MAXN / BLEN) << 1;
 
-	// 写入内容的空间，编号为i的块，内容写入到blocks[i]
-	public static char[][] blocks = new char[BNUM][BLEN];
+	// 写入内容的空间，编号为i的块，内容写入到space[i]
+	public static char[][] space = new char[BNUM][BLEN];
 	// 编号分配池，其实是一个栈，分配编号从栈顶弹出，回收编号从栈顶压入
 	public static int[] pool = new int[BNUM];
 	// 分配池的栈顶
@@ -83,13 +83,13 @@ public static void find(int pos) {
 	public static void linkAndWrite(int curb, int nextb, char[] src, int pos, int len) {
 		nxt[nextb] = nxt[curb];
 		nxt[curb] = nextb;
-		System.arraycopy(src, pos, blocks[nextb], 0, len);
+		System.arraycopy(src, pos, space[nextb], 0, len);
 		siz[nextb] = len;
 	}
 
 	// curb块里，在内容的后面，追加nextb块的内容，然后nextb块从链表中删掉
 	public static void merge(int curb, int nextb) {
-		System.arraycopy(blocks[nextb], 0, blocks[curb], siz[curb], siz[nextb]);
+		System.arraycopy(space[nextb], 0, space[curb], siz[curb], siz[nextb]);
 		siz[curb] += siz[nextb];
 		nxt[curb] = nxt[nextb];
 		recycle(nextb);
@@ -101,11 +101,11 @@ public static void split(int curb, int pos) {
 			return;
 		}
 		int nextb = assign();
-		linkAndWrite(curb, nextb, blocks[curb], pos, siz[curb] - pos);
+		linkAndWrite(curb, nextb, space[curb], pos, siz[curb] - pos);
 		siz[curb] = pos;
 	}
 
-	// 从头到尾遍历所有的块，检查任意相邻两块，内容大小的累加和 <= 块内容量，就合并
+	// 从头到尾遍历所有的块，检查任意相邻块，内容大小的累加和 <= 块内容量，就合并
 	public static void maintain() {
 		for (int curb = 0, nextb; curb != -1; curb = nxt[curb]) {
 			nextb = nxt[curb];
@@ -160,15 +160,15 @@ public static void get(int pos, int len) {
 		int curb = bi;
 		pos = pi;
 		int done = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
-		System.arraycopy(blocks[curb], pos, str, 0, done);
+		System.arraycopy(space[curb], pos, str, 0, done);
 		curb = nxt[curb];
 		while (curb != -1 && done + siz[curb] <= len) {
-			System.arraycopy(blocks[curb], 0, str, done, siz[curb]);
+			System.arraycopy(space[curb], 0, str, done, siz[curb]);
 			done += siz[curb];
 			curb = nxt[curb];
 		}
 		if (curb != -1 && done < len) {
-			System.arraycopy(blocks[curb], 0, str, done, len - done);
+			System.arraycopy(space[curb], 0, str, done, len - done);
 		}
 	}
 
diff --git a/src/class172/Code06_TextEditor2.java b/src/class172/Code06_TextEditor2.java
index 5da39ee59..e2e037b7f 100644
--- a/src/class172/Code06_TextEditor2.java
+++ b/src/class172/Code06_TextEditor2.java
@@ -21,7 +21,7 @@
 //const int BLEN = 3001;
 //const int BNUM = (MAXN / BLEN) << 1;
 //
-//char blocks[BNUM][BLEN];
+//char space[BNUM][BLEN];
 //int pool[BNUM];
 //int top = 0;
 //
@@ -62,12 +62,12 @@
 //void linkAndWrite(int curb, int nextb, char* src, int pos, int len) {
 //    nxt[nextb] = nxt[curb];
 //    nxt[curb] = nextb;
-//    memcpy(blocks[nextb], src + pos, len);
+//    memcpy(space[nextb], src + pos, len);
 //    siz[nextb] = len;
 //}
 //
 //void merge(int curb, int nextb) {
-//    memcpy(blocks[curb] + siz[curb], blocks[nextb], siz[nextb]);
+//    memcpy(space[curb] + siz[curb], space[nextb], siz[nextb]);
 //    siz[curb] += siz[nextb];
 //    nxt[curb] = nxt[nextb];
 //    recycle(nextb);
@@ -76,7 +76,7 @@
 //void split(int curb, int pos) {
 //    if (curb == -1 || pos == siz[curb]) return;
 //    int nextb = assign();
-//    linkAndWrite(curb, nextb, blocks[curb], pos, siz[curb] - pos);
+//    linkAndWrite(curb, nextb, space[curb], pos, siz[curb] - pos);
 //    siz[curb] = pos;
 //}
 //
@@ -132,15 +132,15 @@
 //    int curb = bi;
 //    pos = pi;
 //    int done = (len < siz[curb] - pos) ? len : (siz[curb] - pos);
-//    memcpy(str, blocks[curb] + pos, done);
+//    memcpy(str, space[curb] + pos, done);
 //    curb = nxt[curb];
 //    while (curb != -1 && done + siz[curb] <= len) {
-//        memcpy(str + done, blocks[curb], siz[curb]);
+//        memcpy(str + done, space[curb], siz[curb]);
 //        done += siz[curb];
 //        curb = nxt[curb];
 //    }
 //    if (curb != -1 && done < len) {
-//        memcpy(str + done, blocks[curb], len - done);
+//        memcpy(str + done, space[curb], len - done);
 //    }
 //}
 //

From 8e70af26f7d2447e173418402ba3482701a7f392 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 18 Jun 2025 19:34:33 +0800
Subject: [PATCH 0994/1712] modify code

---
 src/class173/Code01_Sequence1.java | 215 +++++++++++++++++++++++++++++
 src/class173/Code01_Sequence2.java | 166 ++++++++++++++++++++++
 2 files changed, 381 insertions(+)
 create mode 100644 src/class173/Code01_Sequence1.java
 create mode 100644 src/class173/Code01_Sequence2.java

diff --git a/src/class173/Code01_Sequence1.java b/src/class173/Code01_Sequence1.java
new file mode 100644
index 000000000..bb7dfc358
--- /dev/null
+++ b/src/class173/Code01_Sequence1.java
@@ -0,0 +1,215 @@
+package class173;
+
+// 序列，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3863
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_Sequence1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 501;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+
+	// op == 1，代表修改事件，位置x、时间t、修改效果v、空缺
+	// op == 2，代表查询事件，位置x、时间t、查询标准v、问题编号q
+	public static int[][] event = new int[MAXN << 2][5];
+	public static int cnte = 0;
+	public static int cntq = 0;
+
+	public static long[] tim = new long[MAXN];
+	public static long[] sort = new long[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+	public static long[] lazy = new long[MAXB];
+
+	public static int[] ans = new int[MAXN];
+
+	public static void addChange(int x, int t, int v) {
+		event[++cnte][0] = 1;
+		event[cnte][1] = x;
+		event[cnte][2] = t;
+		event[cnte][3] = v;
+	}
+
+	public static void addQuery(int x, int t, int v) {
+		event[++cnte][0] = 2;
+		event[cnte][1] = x;
+		event[cnte][2] = t;
+		event[cnte][3] = v;
+		event[cnte][4] = ++cntq;
+	}
+
+	public static void innerAdd(int l, int r, long v) {
+		for (int i = l; i <= r; i++) {
+			tim[i] += v;
+		}
+		for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
+			sort[i] = tim[i];
+		}
+		Arrays.sort(sort, bl[bi[l]], br[bi[l]] + 1);
+	}
+
+	public static void add(int l, int r, long v) {
+		if (l > r) {
+			return;
+		}
+		if (bi[l] == bi[r]) {
+			innerAdd(l, r, v);
+		} else {
+			innerAdd(l, br[bi[l]], v);
+			innerAdd(bl[bi[r]], r, v);
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				lazy[i] += v;
+			}
+		}
+	}
+
+	public static int innerQuery(int l, int r, long v) {
+		v -= lazy[bi[l]];
+		int ans = 0;
+		for (int i = l; i <= r; i++) {
+			if (tim[i] >= v) {
+				ans++;
+			}
+		}
+		return ans;
+	}
+
+	public static int getCnt(int i, long v) {
+		v -= lazy[i];
+		int l = bl[i], r = br[i], m, pos = br[i] + 1;
+		while (l <= r) {
+			m = (l + r) >> 1;
+			if (sort[m] >= v) {
+				pos = m;
+				r = m - 1;
+			} else {
+				l = m + 1;
+			}
+		}
+		return br[i] - pos + 1;
+	}
+
+	public static int query(int l, int r, long v) {
+		if (l > r) {
+			return 0;
+		}
+		int ans = 0;
+		if (bi[l] == bi[r]) {
+			ans += innerQuery(l, r, v);
+		} else {
+			ans += innerQuery(l, br[bi[l]], v);
+			ans += innerQuery(bl[bi[r]], r, v);
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				ans += getCnt(i, v);
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(m);
+		bnum = (m + blen - 1) / blen;
+		for (int i = 1; i <= m; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, m);
+		}
+		Arrays.sort(event, 1, cnte + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] - b[2]);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		m++; // 时间轴重新定义，1是初始时刻、2、3 ... m+1
+		for (int t = 2, op, l, r, v, x; t <= m; t++) {
+			op = in.nextInt();
+			if (op == 1) {
+				l = in.nextInt();
+				r = in.nextInt();
+				v = in.nextInt();
+				addChange(l, t, v);
+				addChange(r + 1, t, -v);
+			} else {
+				x = in.nextInt();
+				v = in.nextInt();
+				addQuery(x, t, v);
+			}
+		}
+		prepare();
+		for (int i = 1, op, x, t, v, q; i <= cnte; i++) {
+			op = event[i][0];
+			x = event[i][1];
+			t = event[i][2];
+			v = event[i][3];
+			q = event[i][4];
+			if (op == 1) {
+				add(t, m, v);
+			} else {
+				ans[q] = query(1, t - 1, v - arr[x]);
+			}
+		}
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class173/Code01_Sequence2.java b/src/class173/Code01_Sequence2.java
new file mode 100644
index 000000000..cd88f2bd1
--- /dev/null
+++ b/src/class173/Code01_Sequence2.java
@@ -0,0 +1,166 @@
+package class173;
+
+// 序列，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3863
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Event {
+//    int op, x, t, v, q;
+//};
+//
+//bool EventCmp(Event a, Event b) {
+//    return a.x != b.x ? a.x < b.x : a.t < b.t;
+//}
+//
+//const int MAXN = 100001;
+//const int MAXB = 501;
+//int n, m;
+//int arr[MAXN];
+//
+//Event event[MAXN << 2];
+//int cnte, cntq;
+//
+//long long tim[MAXN];
+//long long sortv[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//long long lazy[MAXB];
+//
+//int ans[MAXN];
+//
+//void addChange(int x, int t, int v) {
+//    event[++cnte].op = 1;
+//    event[cnte].x = x;
+//    event[cnte].t = t;
+//    event[cnte].v = v;
+//}
+//
+//void addQuery(int x, int t, int v) {
+//    event[++cnte].op = 2;
+//    event[cnte].x = x;
+//    event[cnte].t = t;
+//    event[cnte].v = v;
+//    event[cnte].q = ++cntq;
+//}
+//
+//void innerAdd(int l, int r, long long v) {
+//    for (int i = l; i <= r; i++) {
+//        tim[i] += v;
+//    }
+//    for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
+//        sortv[i] = tim[i];
+//    }
+//    sort(sortv + bl[bi[l]], sortv + br[bi[l]] + 1);
+//}
+//
+//void add(int l, int r, long long v) {
+//    if (l > r) {
+//        return;
+//    }
+//    if (bi[l] == bi[r]) {
+//        innerAdd(l, r, v);
+//    } else {
+//        innerAdd(l, br[bi[l]], v);
+//        innerAdd(bl[bi[r]], r, v);
+//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+//            lazy[i] += v;
+//        }
+//    }
+//}
+//
+//int innerQuery(int l, int r, long long v) {
+//    v -= lazy[bi[l]];
+//    int ans = 0;
+//    for (int i = l; i <= r; i++) {
+//        if (tim[i] >= v) {
+//            ans++;
+//        }
+//    }
+//    return ans;
+//}
+//
+//int getCnt(int i, long long v) {
+//    v -= lazy[i];
+//    int l = bl[i], r = br[i], m, pos = br[i] + 1;
+//    while (l <= r) {
+//        m = (l + r) >> 1;
+//        if (sortv[m] >= v) {
+//            pos = m;
+//            r = m - 1;
+//        } else {
+//            l = m + 1;
+//        }
+//    }
+//    return br[i] - pos + 1;
+//}
+//
+//int query(int l, int r, long long v) {
+//    if (l > r) {
+//        return 0;
+//    }
+//    int ans = 0;
+//    if (bi[l] == bi[r]) {
+//    	ans = innerQuery(l, r, v);
+//    } else {
+//    	ans += innerQuery(l, br[bi[l]], v);
+//    	ans += innerQuery(bl[bi[r]], r, v);
+//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+//            ans += getCnt(i, v);
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(m);
+//    bnum = (m + blen - 1) / blen;
+//    for (int i = 1; i <= m; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, m);
+//    }
+//    sort(event + 1, event + cnte + 1, EventCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    m++;
+//    for (int t = 2, op, l, r, v, x; t <= m; t++) {
+//        cin >> op;
+//        if (op == 1) {
+//            cin >> l >> r >> v;
+//            addChange(l, t, v);
+//            addChange(r + 1, t, -v);
+//        } else {
+//            cin >> x >> v;
+//            addQuery(x, t, v);
+//        }
+//    }
+//    prepare();
+//    for (int i = 1; i <= cnte; i++) {
+//        if (event[i].op == 1) {
+//            add(event[i].t, m, event[i].v);
+//        } else {
+//            ans[event[i].q] = query(1, event[i].t - 1, 1LL * event[i].v - arr[event[i].x]);
+//        }
+//    }
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 12d2ec1a1ca8c33a884f0009e2166e183e7e5683 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Jun 2025 16:17:14 +0800
Subject: [PATCH 0995/1712] modify code

---
 src/class173/{Code01_Sequence1.java => Code02_Sequence1.java} | 2 +-
 src/class173/{Code01_Sequence2.java => Code02_Sequence2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class173/{Code01_Sequence1.java => Code02_Sequence1.java} (99%)
 rename src/class173/{Code01_Sequence2.java => Code02_Sequence2.java} (100%)

diff --git a/src/class173/Code01_Sequence1.java b/src/class173/Code02_Sequence1.java
similarity index 99%
rename from src/class173/Code01_Sequence1.java
rename to src/class173/Code02_Sequence1.java
index bb7dfc358..f7c04ff29 100644
--- a/src/class173/Code01_Sequence1.java
+++ b/src/class173/Code02_Sequence1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code01_Sequence1 {
+public class Code02_Sequence1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 501;
diff --git a/src/class173/Code01_Sequence2.java b/src/class173/Code02_Sequence2.java
similarity index 100%
rename from src/class173/Code01_Sequence2.java
rename to src/class173/Code02_Sequence2.java

From 06197e514e958f9d1577cbc83238840665b5eb82 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Jun 2025 16:17:40 +0800
Subject: [PATCH 0996/1712] modify code

---
 src/class173/{Code02_Sequence1.java => Code01_Sequence1.java} | 2 +-
 src/class173/{Code02_Sequence2.java => Code01_Sequence2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class173/{Code02_Sequence1.java => Code01_Sequence1.java} (99%)
 rename src/class173/{Code02_Sequence2.java => Code01_Sequence2.java} (100%)

diff --git a/src/class173/Code02_Sequence1.java b/src/class173/Code01_Sequence1.java
similarity index 99%
rename from src/class173/Code02_Sequence1.java
rename to src/class173/Code01_Sequence1.java
index f7c04ff29..bb7dfc358 100644
--- a/src/class173/Code02_Sequence1.java
+++ b/src/class173/Code01_Sequence1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_Sequence1 {
+public class Code01_Sequence1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 501;
diff --git a/src/class173/Code02_Sequence2.java b/src/class173/Code01_Sequence2.java
similarity index 100%
rename from src/class173/Code02_Sequence2.java
rename to src/class173/Code01_Sequence2.java

From b5452b47a36a85c0b7d987669c2cac191ab3720b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 19 Jun 2025 18:22:38 +0800
Subject: [PATCH 0997/1712] modify code

---
 src/class173/Code02_Poker1.java | 240 ++++++++++++++++++++++++++++++++
 src/class173/Code02_Poker2.java | 190 +++++++++++++++++++++++++
 2 files changed, 430 insertions(+)
 create mode 100644 src/class173/Code02_Poker1.java
 create mode 100644 src/class173/Code02_Poker2.java

diff --git a/src/class173/Code02_Poker1.java b/src/class173/Code02_Poker1.java
new file mode 100644
index 000000000..381d4eeac
--- /dev/null
+++ b/src/class173/Code02_Poker1.java
@@ -0,0 +1,240 @@
+package class173;
+
+// 由乃打扑克，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5356
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_Poker1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 1001;
+	public static int INF = Integer.MAX_VALUE;
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+	public static int[] sort = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+	public static int[] lazy = new int[MAXB];
+
+	public static void innerAdd(int l, int r, int v) {
+		for (int i = l; i <= r; i++) {
+			arr[i] += v;
+		}
+		for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
+			sort[i] = arr[i];
+		}
+		Arrays.sort(sort, bl[bi[l]], br[bi[l]] + 1);
+	}
+
+	public static void add(int l, int r, int v) {
+		if (bi[l] == bi[r]) {
+			innerAdd(l, r, v);
+		} else {
+			innerAdd(l, br[bi[l]], v);
+			innerAdd(bl[bi[r]], r, v);
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				lazy[i] += v;
+			}
+		}
+	}
+
+	public static int getMin(int l, int r) {
+		int lb = bi[l], rb = bi[r], ans = INF;
+		if (lb == rb) {
+			for (int i = l; i <= r; i++) {
+				ans = Math.min(ans, arr[i] + lazy[lb]);
+			}
+		} else {
+			for (int i = l; i <= br[lb]; i++) {
+				ans = Math.min(ans, arr[i] + lazy[lb]);
+			}
+			for (int i = bl[rb]; i <= r; i++) {
+				ans = Math.min(ans, arr[i] + lazy[rb]);
+			}
+			for (int i = lb + 1; i <= rb - 1; i++) {
+				ans = Math.min(ans, sort[bl[i]] + lazy[i]);
+			}
+		}
+		return ans;
+	}
+
+	public static int getMax(int l, int r) {
+		int lb = bi[l], rb = bi[r], ans = -INF;
+		if (lb == rb) {
+			for (int i = l; i <= r; i++) {
+				ans = Math.max(ans, arr[i] + lazy[lb]);
+			}
+		} else {
+			for (int i = l; i <= br[lb]; i++) {
+				ans = Math.max(ans, arr[i] + lazy[lb]);
+			}
+			for (int i = bl[rb]; i <= r; i++) {
+				ans = Math.max(ans, arr[i] + lazy[rb]);
+			}
+			for (int i = lb + 1; i <= rb - 1; i++) {
+				ans = Math.max(ans, sort[br[i]] + lazy[i]);
+			}
+		}
+		return ans;
+	}
+
+	public static int getCnt(int i, int v) {
+		v -= lazy[i];
+		int l = bl[i], r = br[i];
+		if (sort[l] > v) {
+			return 0;
+		}
+		if (sort[r] <= v) {
+			return r - l + 1;
+		}
+		int m, find = l;
+		while (l <= r) {
+			m = (l + r) / 2;
+			if (sort[m] <= v) {
+				find = m;
+				l = m + 1;
+			} else {
+				r = m - 1;
+			}
+		}
+		return find - bl[i] + 1;
+	}
+
+	public static int num(int l, int r, int v) {
+		int lb = bi[l], rb = bi[r], ans = 0;
+		if (lb == rb) {
+			for (int i = l; i <= r; i++) {
+				if (arr[i] + lazy[lb] <= v) {
+					ans++;
+				}
+			}
+		} else {
+			for (int i = l; i <= br[lb]; i++) {
+				if (arr[i] + lazy[lb] <= v) {
+					ans++;
+				}
+			}
+			for (int i = bl[rb]; i <= r; i++) {
+				if (arr[i] + lazy[rb] <= v) {
+					ans++;
+				}
+			}
+			for (int i = lb + 1; i <= rb - 1; i++) {
+				ans += getCnt(i, v);
+			}
+		}
+		return ans;
+	}
+
+	public static int query(int l, int r, int v) {
+		if (v < 1 || v > r - l + 1) {
+			return -1;
+		}
+		int minv = getMin(l, r);
+		int maxv = getMax(l, r);
+		int midv;
+		int ans = -1;
+		while (minv <= maxv) {
+			midv = minv + (maxv - minv) / 2;
+			if (num(l, r, midv) >= v) {
+				ans = midv;
+				maxv = midv - 1;
+			} else {
+				minv = midv + 1;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		for (int i = 1; i <= n; i++) {
+			sort[i] = arr[i];
+		}
+		for (int i = 1; i <= bnum; i++) {
+			Arrays.sort(sort, bl[i], br[i] + 1);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, op, l, r, v; i <= m; i++) {
+			op = in.nextInt();
+			l = in.nextInt();
+			r = in.nextInt();
+			v = in.nextInt();
+			if (op == 1) {
+				out.println(query(l, r, v));
+			} else {
+				add(l, r, v);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class173/Code02_Poker2.java b/src/class173/Code02_Poker2.java
new file mode 100644
index 000000000..3cc0466c9
--- /dev/null
+++ b/src/class173/Code02_Poker2.java
@@ -0,0 +1,190 @@
+package class173;
+
+// 由乃打扑克，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5356
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXB = 1001;
+//const int INF = 2147483647;
+//
+//int n, m;
+//int arr[MAXN];
+//int sortv[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//int lazy[MAXB];
+//
+//void innerAdd(int l, int r, int v) {
+//    for (int i = l; i <= r; i++) {
+//        arr[i] += v;
+//    }
+//    for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
+//        sortv[i] = arr[i];
+//    }
+//    sort(sortv + bl[bi[l]], sortv + br[bi[l]] + 1);
+//}
+//
+//void add(int l, int r, int v) {
+//    if (bi[l] == bi[r]) {
+//        innerAdd(l, r, v);
+//    } else {
+//        innerAdd(l, br[bi[l]], v);
+//        innerAdd(bl[bi[r]], r, v);
+//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+//            lazy[i] += v;
+//        }
+//    }
+//}
+//
+//int getMin(int l, int r) {
+//    int lb = bi[l], rb = bi[r], ans = INF;
+//    if (lb == rb) {
+//        for (int i = l; i <= r; i++) {
+//            ans = min(ans, arr[i] + lazy[lb]);
+//        }
+//    } else {
+//        for (int i = l; i <= br[lb]; i++) {
+//            ans = min(ans, arr[i] + lazy[lb]);
+//        }
+//        for (int i = bl[rb]; i <= r; i++) {
+//            ans = min(ans, arr[i] + lazy[rb]);
+//        }
+//        for (int i = lb + 1; i <= rb - 1; i++) {
+//            ans = min(ans, sortv[bl[i]] + lazy[i]);
+//        }
+//    }
+//    return ans;
+//}
+//
+//int getMax(int l, int r) {
+//    int lb = bi[l], rb = bi[r], ans = -INF;
+//    if (lb == rb) {
+//        for (int i = l; i <= r; i++) {
+//            ans = max(ans, arr[i] + lazy[lb]);
+//        }
+//    } else {
+//        for (int i = l; i <= br[lb]; i++) {
+//            ans = max(ans, arr[i] + lazy[lb]);
+//        }
+//        for (int i = bl[rb]; i <= r; i++) {
+//            ans = max(ans, arr[i] + lazy[rb]);
+//        }
+//        for (int i = lb + 1; i <= rb - 1; i++) {
+//            ans = max(ans, sortv[br[i]] + lazy[i]);
+//        }
+//    }
+//    return ans;
+//}
+//
+//int getCnt(int i, int v) {
+//    v -= lazy[i];
+//    int l = bl[i], r = br[i];
+//    if (sortv[l] > v) {
+//        return 0;
+//    }
+//    if (sortv[r] <= v) {
+//        return r - l + 1;
+//    }
+//    int find = l;
+//    while (l <= r) {
+//        int m = (l + r) >> 1;
+//        if (sortv[m] <= v) {
+//            find = m;
+//            l = m + 1;
+//        } else {
+//            r = m - 1;
+//        }
+//    }
+//    return find - bl[i] + 1;
+//}
+//
+//int num(int l, int r, int v) {
+//    int lb = bi[l], rb = bi[r], ans = 0;
+//    if (lb == rb) {
+//        for (int i = l; i <= r; i++) {
+//            if (arr[i] + lazy[lb] <= v) {
+//                ans++;
+//            }
+//        }
+//    } else {
+//        for (int i = l; i <= br[lb]; i++) {
+//            if (arr[i] + lazy[lb] <= v) {
+//                ans++;
+//            }
+//        }
+//        for (int i = bl[rb]; i <= r; i++) {
+//            if (arr[i] + lazy[rb] <= v) {
+//                ans++;
+//            }
+//        }
+//        for (int i = lb + 1; i <= rb - 1; i++) {
+//            ans += getCnt(i, v);
+//        }
+//    }
+//    return ans;
+//}
+//
+//int query(int l, int r, int v) {
+//    if (v < 1 || v > r - l + 1) {
+//        return -1;
+//    }
+//    int minv = getMin(l, r);
+//    int maxv = getMax(l, r);
+//    int ans = -1;
+//    while (minv <= maxv) {
+//        int midv = minv + (maxv - minv) / 2;
+//        if (num(l, r, midv) >= v) {
+//            ans = midv;
+//            maxv = midv - 1;
+//        } else {
+//            minv = midv + 1;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(m);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        sortv[i] = arr[i];
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        sort(sortv + bl[i], sortv + br[i] + 1);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, op, l, r, v; i <= m; i++) {
+//        cin >> op >> l >> r >> v;
+//        if (op == 1) {
+//            cout << query(l, r, v) << '\n';
+//        } else {
+//            add(l, r, v);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From dc4d057ad7920704a72da99153086f420fbaca98 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Jun 2025 14:10:38 +0800
Subject: [PATCH 0998/1712] modify code

---
 src/class173/Code03_Inversion1.java | 209 ++++++++++++++++++++++++++++
 src/class173/Code03_Inversion2.java | 176 +++++++++++++++++++++++
 2 files changed, 385 insertions(+)
 create mode 100644 src/class173/Code03_Inversion1.java
 create mode 100644 src/class173/Code03_Inversion2.java

diff --git a/src/class173/Code03_Inversion1.java b/src/class173/Code03_Inversion1.java
new file mode 100644
index 000000000..3049a2fc2
--- /dev/null
+++ b/src/class173/Code03_Inversion1.java
@@ -0,0 +1,209 @@
+package class173;
+
+// 区间逆序对，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5046
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是无法通过所有测试用例
+// 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
+// 甚至C++也需要考虑优化常数，想通过用C++实现，正式比赛不卡常
+// 本节课Code03_Inversion2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code03_Inversion1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 701;
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+	public static int[][] sortv = new int[MAXN][2];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	public static int[] tree = new int[MAXN];
+	public static int[] pre = new int[MAXN];
+	public static int[] nxt = new int[MAXN];
+	public static int[][] cnt = new int[MAXB][MAXN];
+	public static long[][] dp = new long[MAXB][MAXB];
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static int calc(int i, int j, int li, int ri, int lj, int rj) {
+		int ans = 0;
+		for (int p1 = bl[i], p2 = bl[j] - 1, tmp = 0; p1 <= br[i]; p1++) {
+			if (li <= sortv[p1][1] && sortv[p1][1] <= ri) {
+				while (p2 + 1 <= br[j] && sortv[p1][0] > sortv[p2 + 1][0]) {
+					p2++;
+					if (lj <= sortv[p2][1] && sortv[p2][1] <= rj) {
+						tmp++;
+					}
+				}
+				ans += tmp;
+			}
+		}
+		return ans;
+	}
+
+	public static long query(int l, int r) {
+		long ans = 0;
+		int lb = bi[l];
+		int rb = bi[r];
+		if (lb == rb) {
+			if (l == bl[lb]) {
+				ans = pre[r];
+			} else {
+				ans = pre[r] - pre[l - 1] - calc(lb, lb, 1, l - 1, l, r);
+			}
+		} else {
+			for (int i = l; i <= br[lb]; i++) {
+				ans += cnt[rb - 1][arr[i]] - cnt[lb][arr[i]];
+			}
+			for (int i = bl[rb]; i <= r; i++) {
+				ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
+			}
+			ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, rb, l, br[lb], bl[rb], r);
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		// 注意调整块长
+		blen = (int) (Math.sqrt(n) / 2);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		for (int i = 1; i <= n; i++) {
+			sortv[i][0] = arr[i];
+			sortv[i][1] = i;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			Arrays.sort(sortv, bl[i], br[i] + 1, (a, b) -> a[0] != b[0] ? a[0] - b[0] : a[1] - b[1]);
+		}
+		for (int i = 1; i <= bnum; i++) {
+			for (int j = bl[i]; j <= br[i]; j++) {
+				cnt[i][arr[j]]++;
+				if (j != bl[i]) {
+					pre[j] = pre[j - 1] + sum(n) - sum(arr[j]);
+				}
+				add(arr[j], 1);
+			}
+			for (int j = bl[i]; j <= br[i]; j++) {
+				add(arr[j], -1);
+			}
+			for (int j = br[i]; j >= bl[i]; j--) {
+				if (j != br[i]) {
+					nxt[j] = nxt[j + 1] + sum(arr[j]);
+				}
+				add(arr[j], 1);
+			}
+			for (int j = bl[i]; j <= br[i]; j++) {
+				add(arr[j], -1);
+			}
+			int tmp = 0;
+			for (int j = 1; j <= n; j++) {
+				tmp += cnt[i][j];
+				cnt[i][j] = tmp + cnt[i - 1][j];
+			}
+			dp[i][i] = pre[br[i]];
+		}
+		for (int len = 2; len <= bnum; len++) {
+			for (int l = 1, r = l + len - 1; r <= bnum; l++, r++) {
+				dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, r, bl[l], br[l], bl[r], br[r]);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		long lastAns = 0;
+		for (int i = 1, l, r; i <= m; i++) {
+			l = in.nextInt();
+			r = in.nextInt();
+			l = (int) (lastAns ^ l);
+			r = (int) (lastAns ^ r);
+			lastAns = query(l, r);
+			out.println(lastAns);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class173/Code03_Inversion2.java b/src/class173/Code03_Inversion2.java
new file mode 100644
index 000000000..de1612223
--- /dev/null
+++ b/src/class173/Code03_Inversion2.java
@@ -0,0 +1,176 @@
+package class173;
+
+// 区间逆序对，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5046
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+// 注意本题需要优化常数，虽然程度不深，正式比赛不卡常
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//char buf[1 << 20], *p1 = buf, *p2 = buf, obuf[1 << 20], *o = obuf;
+//
+//inline char gc() {
+//    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;
+//}
+//
+//inline int read() {
+//    int s = 0;
+//    char c = gc();
+//    while (!isdigit(c)) c = gc();
+//    while (isdigit(c)) {
+//        s = s * 10 + c - '0';
+//        c = gc();
+//    }
+//    return s;
+//}
+//
+//struct Node {
+//    int v, i;
+//};
+//
+//bool NodeCmp(Node &a, Node &b) {
+//    return a.v != b.v ? a.v < b.v : a.i < b.i;
+//}
+//
+//const int MAXN = 100001;
+//const int MAXB = 701;
+//int n, m;
+//int arr[MAXN];
+//Node sortv[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//int tree[MAXN];
+//int pre[MAXN];
+//int nxt[MAXN];
+//int cnt[MAXB][MAXN];
+//long long dp[MAXB][MAXB];
+//
+//inline int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//inline void add(int i, int v) {
+//    while (i <= n) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//inline int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//inline int calc(int i, int j, int li, int ri, int lj, int rj) {
+//    int ans = 0;
+//    for (int p1 = bl[i], p2 = bl[j] - 1, tmp = 0; p1 <= br[i]; p1++) {
+//        if (li <= sortv[p1].i && sortv[p1].i <= ri) {
+//            while (p2 + 1 <= br[j] && sortv[p1].v > sortv[p2 + 1].v) {
+//                p2++;
+//                if (lj <= sortv[p2].i && sortv[p2].i <= rj) {
+//                    tmp++;
+//                }
+//            }
+//            ans += tmp;
+//        }
+//    }
+//    return ans;
+//}
+//
+//long long query(int l, int r) {
+//    long long ans = 0;
+//    int lb = bi[l], rb = bi[r];
+//    if (lb == rb) {
+//        if (l == bl[lb]) {
+//            ans = pre[r];
+//        } else {
+//            ans = pre[r] - pre[l - 1] - calc(lb, lb, 1, l - 1, l, r);
+//        }
+//    } else {
+//        for (int i = l; i <= br[lb]; i++) {
+//            ans += cnt[rb - 1][arr[i]] - cnt[lb][arr[i]];
+//        }
+//        for (int i = bl[rb]; i <= r; i++) {
+//            ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
+//        }
+//        ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, rb, l, br[lb], bl[rb], r);
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = (int)(sqrt(n) / 2);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) bi[i] = (i - 1) / blen + 1;
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        sortv[i].v = arr[i];
+//        sortv[i].i = i;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        sort(sortv + bl[i], sortv + br[i] + 1, NodeCmp);
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        for (int j = bl[i]; j <= br[i]; j++) {
+//            cnt[i][arr[j]]++;
+//            if (j != bl[i]) {
+//                pre[j] = pre[j - 1] + sum(n) - sum(arr[j]);
+//            }
+//            add(arr[j], 1);
+//        }
+//        for (int j = bl[i]; j <= br[i]; j++) {
+//            add(arr[j], -1);
+//        }
+//        for (int j = br[i]; j >= bl[i]; j--) {
+//            if (j != br[i]) {
+//                nxt[j] = nxt[j + 1] + sum(arr[j]);
+//            }
+//            add(arr[j], 1);
+//        }
+//        for (int j = bl[i]; j <= br[i]; j++) {
+//            add(arr[j], -1);
+//        }
+//        int tmp = 0;
+//        for (int j = 1; j <= n; j++) {
+//            tmp += cnt[i][j];
+//            cnt[i][j] = tmp + cnt[i - 1][j];
+//        }
+//        dp[i][i] = pre[br[i]];
+//    }
+//    for (int len = 2; len <= bnum; len++) {
+//        for (int l = 1, r = l + len - 1; r <= bnum; l++, r++) {
+//            dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, r, bl[l], br[l], bl[r], br[r]);
+//        }
+//    }
+//}
+//
+//int main() {
+//    n = read();
+//    m = read();
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = read();
+//    }
+//    prepare();
+//    long long lastAns = 0;
+//    for (int i = 1, l, r; i <= m; i++) {
+//        l = read() ^ lastAns;
+//        r = read() ^ lastAns;
+//        lastAns = query(l, r);
+//        printf("%lld\n", lastAns);
+//    }
+//    return 0;
+//}
\ No newline at end of file

From d0b7a34ec7992011333611beec12e0398c71b906 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 20 Jun 2025 14:13:59 +0800
Subject: [PATCH 0999/1712] modify code

---
 src/class173/Code03_Inversion1.java | 7 ++++---
 src/class173/Code03_Inversion2.java | 2 +-
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code03_Inversion1.java b/src/class173/Code03_Inversion1.java
index 3049a2fc2..590b500de 100644
--- a/src/class173/Code03_Inversion1.java
+++ b/src/class173/Code03_Inversion1.java
@@ -3,11 +3,12 @@
 // 区间逆序对，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5046
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是无法通过所有测试用例
+// java实现的逻辑一定是正确的，但是无法通过测试
 // 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
-// 甚至C++也需要考虑优化常数，想通过用C++实现，正式比赛不卡常
-// 本节课Code03_Inversion2文件就是C++的实现
+// 想通过用C++实现，本节课Code03_Inversion2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
+// 本题对C++来说，卡常的程度较浅，现在正式比赛是不卡常的
+
 
 import java.io.IOException;
 import java.io.InputStream;
diff --git a/src/class173/Code03_Inversion2.java b/src/class173/Code03_Inversion2.java
index de1612223..9260b6088 100644
--- a/src/class173/Code03_Inversion2.java
+++ b/src/class173/Code03_Inversion2.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P5046
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
-// 注意本题需要优化常数，虽然程度不深，正式比赛不卡常
+// 本题对C++来说，卡常的程度较浅，现在正式比赛是不卡常的
 
 //#include <bits/stdc++.h>
 //

From e0078d5357f588b31af3c9f749c99d0ec2682a06 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 10:23:21 +0800
Subject: [PATCH 1000/1712] modify code

---
 src/class173/Code03_Inversion1.java   | 20 +++++++++-----------
 src/class173/Code03_Inversion2.java   | 19 ++++++++++---------
 src/class173/Code04_FutureDiary1.java |  9 +++++++++
 3 files changed, 28 insertions(+), 20 deletions(-)
 create mode 100644 src/class173/Code04_FutureDiary1.java

diff --git a/src/class173/Code03_Inversion1.java b/src/class173/Code03_Inversion1.java
index 590b500de..eeff59197 100644
--- a/src/class173/Code03_Inversion1.java
+++ b/src/class173/Code03_Inversion1.java
@@ -7,8 +7,6 @@
 // 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code03_Inversion2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
-// 本题对C++来说，卡常的程度较浅，现在正式比赛是不卡常的
-
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -56,13 +54,13 @@ public static int sum(int i) {
 		return ret;
 	}
 
-	public static int calc(int i, int j, int li, int ri, int lj, int rj) {
+	public static int calc(int x, int xl, int xr, int y, int yl, int yr) {
 		int ans = 0;
-		for (int p1 = bl[i], p2 = bl[j] - 1, tmp = 0; p1 <= br[i]; p1++) {
-			if (li <= sortv[p1][1] && sortv[p1][1] <= ri) {
-				while (p2 + 1 <= br[j] && sortv[p1][0] > sortv[p2 + 1][0]) {
+		for (int p1 = bl[x], p2 = bl[y] - 1, tmp = 0; p1 <= br[x]; p1++) {
+			if (xl <= sortv[p1][1] && sortv[p1][1] <= xr) {
+				while (p2 + 1 <= br[y] && sortv[p1][0] > sortv[p2 + 1][0]) {
 					p2++;
-					if (lj <= sortv[p2][1] && sortv[p2][1] <= rj) {
+					if (yl <= sortv[p2][1] && sortv[p2][1] <= yr) {
 						tmp++;
 					}
 				}
@@ -80,7 +78,7 @@ public static long query(int l, int r) {
 			if (l == bl[lb]) {
 				ans = pre[r];
 			} else {
-				ans = pre[r] - pre[l - 1] - calc(lb, lb, 1, l - 1, l, r);
+				ans = pre[r] - pre[l - 1] - calc(lb, 1, l - 1, lb, l, r);
 			}
 		} else {
 			for (int i = l; i <= br[lb]; i++) {
@@ -89,13 +87,13 @@ public static long query(int l, int r) {
 			for (int i = bl[rb]; i <= r; i++) {
 				ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
 			}
-			ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, rb, l, br[lb], bl[rb], r);
+			ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
 		}
 		return ans;
 	}
 
+	// 注意调整块长
 	public static void prepare() {
-		// 注意调整块长
 		blen = (int) (Math.sqrt(n) / 2);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
@@ -141,7 +139,7 @@ public static void prepare() {
 		}
 		for (int len = 2; len <= bnum; len++) {
 			for (int l = 1, r = l + len - 1; r <= bnum; l++, r++) {
-				dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, r, bl[l], br[l], bl[r], br[r]);
+				dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
 			}
 		}
 	}
diff --git a/src/class173/Code03_Inversion2.java b/src/class173/Code03_Inversion2.java
index 9260b6088..6085084c5 100644
--- a/src/class173/Code03_Inversion2.java
+++ b/src/class173/Code03_Inversion2.java
@@ -4,7 +4,8 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P5046
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
-// 本题对C++来说，卡常的程度较浅，现在正式比赛是不卡常的
+// 这道题比较卡常，C++实现也需要优化常数，比如重写读入函数
+// 正式比赛不卡常！
 
 //#include <bits/stdc++.h>
 //
@@ -72,13 +73,13 @@
 //    return ret;
 //}
 //
-//inline int calc(int i, int j, int li, int ri, int lj, int rj) {
+//inline int calc(int x, int xl, int xr, int y, int yl, int yr) {
 //    int ans = 0;
-//    for (int p1 = bl[i], p2 = bl[j] - 1, tmp = 0; p1 <= br[i]; p1++) {
-//        if (li <= sortv[p1].i && sortv[p1].i <= ri) {
-//            while (p2 + 1 <= br[j] && sortv[p1].v > sortv[p2 + 1].v) {
+//    for (int p1 = bl[x], p2 = bl[y] - 1, tmp = 0; p1 <= br[x]; p1++) {
+//        if (xl <= sortv[p1].i && sortv[p1].i <= xr) {
+//            while (p2 + 1 <= br[y] && sortv[p1].v > sortv[p2 + 1].v) {
 //                p2++;
-//                if (lj <= sortv[p2].i && sortv[p2].i <= rj) {
+//                if (yl <= sortv[p2].i && sortv[p2].i <= yr) {
 //                    tmp++;
 //                }
 //            }
@@ -95,7 +96,7 @@
 //        if (l == bl[lb]) {
 //            ans = pre[r];
 //        } else {
-//            ans = pre[r] - pre[l - 1] - calc(lb, lb, 1, l - 1, l, r);
+//            ans = pre[r] - pre[l - 1] - calc(lb, 1, l - 1, lb, l, r);
 //        }
 //    } else {
 //        for (int i = l; i <= br[lb]; i++) {
@@ -104,7 +105,7 @@
 //        for (int i = bl[rb]; i <= r; i++) {
 //            ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
 //        }
-//        ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, rb, l, br[lb], bl[rb], r);
+//        ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
 //    }
 //    return ans;
 //}
@@ -153,7 +154,7 @@
 //    }
 //    for (int len = 2; len <= bnum; len++) {
 //        for (int l = 1, r = l + len - 1; r <= bnum; l++, r++) {
-//            dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, r, bl[l], br[l], bl[r], br[r]);
+//            dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
 //        }
 //    }
 //}
diff --git a/src/class173/Code04_FutureDiary1.java b/src/class173/Code04_FutureDiary1.java
new file mode 100644
index 000000000..6d314a6a3
--- /dev/null
+++ b/src/class173/Code04_FutureDiary1.java
@@ -0,0 +1,9 @@
+package class173;
+
+// 未来日记，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4119
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code04_FutureDiary1 {
+
+}

From cf0814cf2e2c958acd648d58683f2175eb59123f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 10:31:57 +0800
Subject: [PATCH 1001/1712] modify code

---
 src/class173/Code01_Sequence1.java  |  8 ++++----
 src/class173/Code02_Poker1.java     | 20 ++++++++++----------
 src/class173/Code03_Inversion1.java |  6 +++---
 src/class173/Code03_Inversion2.java |  8 ++++----
 4 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/class173/Code01_Sequence1.java b/src/class173/Code01_Sequence1.java
index bb7dfc358..efb7bcf36 100644
--- a/src/class173/Code01_Sequence1.java
+++ b/src/class173/Code01_Sequence1.java
@@ -24,7 +24,7 @@ public class Code01_Sequence1 {
 	public static int cntq = 0;
 
 	public static long[] tim = new long[MAXN];
-	public static long[] sort = new long[MAXN];
+	public static long[] sortv = new long[MAXN];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
@@ -54,9 +54,9 @@ public static void innerAdd(int l, int r, long v) {
 			tim[i] += v;
 		}
 		for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
-			sort[i] = tim[i];
+			sortv[i] = tim[i];
 		}
-		Arrays.sort(sort, bl[bi[l]], br[bi[l]] + 1);
+		Arrays.sort(sortv, bl[bi[l]], br[bi[l]] + 1);
 	}
 
 	public static void add(int l, int r, long v) {
@@ -90,7 +90,7 @@ public static int getCnt(int i, long v) {
 		int l = bl[i], r = br[i], m, pos = br[i] + 1;
 		while (l <= r) {
 			m = (l + r) >> 1;
-			if (sort[m] >= v) {
+			if (sortv[m] >= v) {
 				pos = m;
 				r = m - 1;
 			} else {
diff --git a/src/class173/Code02_Poker1.java b/src/class173/Code02_Poker1.java
index 381d4eeac..481c23d55 100644
--- a/src/class173/Code02_Poker1.java
+++ b/src/class173/Code02_Poker1.java
@@ -18,7 +18,7 @@ public class Code02_Poker1 {
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
-	public static int[] sort = new int[MAXN];
+	public static int[] sortv = new int[MAXN];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
@@ -31,9 +31,9 @@ public static void innerAdd(int l, int r, int v) {
 			arr[i] += v;
 		}
 		for (int i = bl[bi[l]]; i <= br[bi[l]]; i++) {
-			sort[i] = arr[i];
+			sortv[i] = arr[i];
 		}
-		Arrays.sort(sort, bl[bi[l]], br[bi[l]] + 1);
+		Arrays.sort(sortv, bl[bi[l]], br[bi[l]] + 1);
 	}
 
 	public static void add(int l, int r, int v) {
@@ -62,7 +62,7 @@ public static int getMin(int l, int r) {
 				ans = Math.min(ans, arr[i] + lazy[rb]);
 			}
 			for (int i = lb + 1; i <= rb - 1; i++) {
-				ans = Math.min(ans, sort[bl[i]] + lazy[i]);
+				ans = Math.min(ans, sortv[bl[i]] + lazy[i]);
 			}
 		}
 		return ans;
@@ -82,7 +82,7 @@ public static int getMax(int l, int r) {
 				ans = Math.max(ans, arr[i] + lazy[rb]);
 			}
 			for (int i = lb + 1; i <= rb - 1; i++) {
-				ans = Math.max(ans, sort[br[i]] + lazy[i]);
+				ans = Math.max(ans, sortv[br[i]] + lazy[i]);
 			}
 		}
 		return ans;
@@ -91,16 +91,16 @@ public static int getMax(int l, int r) {
 	public static int getCnt(int i, int v) {
 		v -= lazy[i];
 		int l = bl[i], r = br[i];
-		if (sort[l] > v) {
+		if (sortv[l] > v) {
 			return 0;
 		}
-		if (sort[r] <= v) {
+		if (sortv[r] <= v) {
 			return r - l + 1;
 		}
 		int m, find = l;
 		while (l <= r) {
 			m = (l + r) / 2;
-			if (sort[m] <= v) {
+			if (sortv[m] <= v) {
 				find = m;
 				l = m + 1;
 			} else {
@@ -167,10 +167,10 @@ public static void prepare() {
 			br[i] = Math.min(i * blen, n);
 		}
 		for (int i = 1; i <= n; i++) {
-			sort[i] = arr[i];
+			sortv[i] = arr[i];
 		}
 		for (int i = 1; i <= bnum; i++) {
-			Arrays.sort(sort, bl[i], br[i] + 1);
+			Arrays.sort(sortv, bl[i], br[i] + 1);
 		}
 	}
 
diff --git a/src/class173/Code03_Inversion1.java b/src/class173/Code03_Inversion1.java
index eeff59197..7972793a1 100644
--- a/src/class173/Code03_Inversion1.java
+++ b/src/class173/Code03_Inversion1.java
@@ -30,7 +30,7 @@ public class Code03_Inversion1 {
 
 	public static int[] tree = new int[MAXN];
 	public static int[] pre = new int[MAXN];
-	public static int[] nxt = new int[MAXN];
+	public static int[] suf = new int[MAXN];
 	public static int[][] cnt = new int[MAXB][MAXN];
 	public static long[][] dp = new long[MAXB][MAXB];
 
@@ -87,7 +87,7 @@ public static long query(int l, int r) {
 			for (int i = bl[rb]; i <= r; i++) {
 				ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
 			}
-			ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
+			ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
 		}
 		return ans;
 	}
@@ -123,7 +123,7 @@ public static void prepare() {
 			}
 			for (int j = br[i]; j >= bl[i]; j--) {
 				if (j != br[i]) {
-					nxt[j] = nxt[j + 1] + sum(arr[j]);
+					suf[j] = suf[j + 1] + sum(arr[j]);
 				}
 				add(arr[j], 1);
 			}
diff --git a/src/class173/Code03_Inversion2.java b/src/class173/Code03_Inversion2.java
index 6085084c5..9920e4477 100644
--- a/src/class173/Code03_Inversion2.java
+++ b/src/class173/Code03_Inversion2.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P5046
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
-// 这道题比较卡常，C++实现也需要优化常数，比如重写读入函数
+// 这道题比较卡常，C++实现也需要优化常数，比如快读
 // 正式比赛不卡常！
 
 //#include <bits/stdc++.h>
@@ -49,7 +49,7 @@
 //
 //int tree[MAXN];
 //int pre[MAXN];
-//int nxt[MAXN];
+//int suf[MAXN];
 //int cnt[MAXB][MAXN];
 //long long dp[MAXB][MAXB];
 //
@@ -105,7 +105,7 @@
 //        for (int i = bl[rb]; i <= r; i++) {
 //            ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
 //        }
-//        ans += dp[lb + 1][rb - 1] + nxt[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
+//        ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
 //    }
 //    return ans;
 //}
@@ -138,7 +138,7 @@
 //        }
 //        for (int j = br[i]; j >= bl[i]; j--) {
 //            if (j != br[i]) {
-//                nxt[j] = nxt[j + 1] + sum(arr[j]);
+//                suf[j] = suf[j + 1] + sum(arr[j]);
 //            }
 //            add(arr[j], 1);
 //        }

From 226700a0055af34a8c2cbdc0edd93bb53125bb7e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 12:31:57 +0800
Subject: [PATCH 1002/1712] modify code

---
 src/class173/Code03_Inversion2.java | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/class173/Code03_Inversion2.java b/src/class173/Code03_Inversion2.java
index 9920e4477..67de915d9 100644
--- a/src/class173/Code03_Inversion2.java
+++ b/src/class173/Code03_Inversion2.java
@@ -11,19 +11,21 @@
 //
 //using namespace std;
 //
-//char buf[1 << 20], *p1 = buf, *p2 = buf, obuf[1 << 20], *o = obuf;
+//char buf[1000000], *p1 = buf, *p2 = buf;
 //
-//inline char gc() {
-//    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1 << 21, stdin), p1 == p2) ? EOF : *p1++;
+//inline char getChar() {
+//    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;
 //}
 //
 //inline int read() {
 //    int s = 0;
-//    char c = gc();
-//    while (!isdigit(c)) c = gc();
+//    char c = getChar();
+//    while (!isdigit(c)) {
+//        c = getChar();
+//    }
 //    while (isdigit(c)) {
 //        s = s * 10 + c - '0';
-//        c = gc();
+//        c = getChar();
 //    }
 //    return s;
 //}

From 0c651a58cfaa367722bd40aaa735b18250dd137c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 14:13:36 +0800
Subject: [PATCH 1003/1712] modify code

---
 ...\347\212\266\351\223\276\350\241\250.pptx" | Bin 54183 -> 54184 bytes
 src/class173/Code04_FutureDiary1.java         |   9 ---------
 2 files changed, 9 deletions(-)
 delete mode 100644 src/class173/Code04_FutureDiary1.java

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243172\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2301-\345\235\227\347\212\266\346\225\260\347\273\204\343\200\201\345\235\227\347\212\266\351\223\276\350\241\250.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243172\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2301-\345\235\227\347\212\266\346\225\260\347\273\204\343\200\201\345\235\227\347\212\266\351\223\276\350\241\250.pptx"
index 8fc03065a10e9d01e2f2896e6b416b64a69abc1a..158b950809c1bebcefda8132bba40e5418d5ddda 100644
GIT binary patch
delta 2962
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
L5eQ0qvHtWw5(GE{

delta 2944
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

diff --git a/src/class173/Code04_FutureDiary1.java b/src/class173/Code04_FutureDiary1.java
deleted file mode 100644
index 6d314a6a3..000000000
--- a/src/class173/Code04_FutureDiary1.java
+++ /dev/null
@@ -1,9 +0,0 @@
-package class173;
-
-// 未来日记，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P4119
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code04_FutureDiary1 {
-
-}

From f315b6efaa97d6c48359232ea1550dfc62d96f1a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 17:54:45 +0800
Subject: [PATCH 1004/1712] modify code

---
 src/class173/Code04_Magnet1.java | 176 +++++++++++++++++++++++++++++++
 src/class173/Code04_Magnet2.java | 118 +++++++++++++++++++++
 2 files changed, 294 insertions(+)
 create mode 100644 src/class173/Code04_Magnet1.java
 create mode 100644 src/class173/Code04_Magnet2.java

diff --git a/src/class173/Code04_Magnet1.java b/src/class173/Code04_Magnet1.java
new file mode 100644
index 000000000..ff11f2be0
--- /dev/null
+++ b/src/class173/Code04_Magnet1.java
@@ -0,0 +1,176 @@
+package class173;
+
+// 磁力块，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P10590
+// java实现的逻辑一定是正确的，但是无法通过测试
+// 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code04_Magnet2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code04_Magnet1 {
+
+	public static class Node {
+		int x, y, m, p;
+		long range;
+		long dist;
+
+		public Node(int x_, int y_, int m_, int p_, int range_) {
+			x = x_;
+			y = y_;
+			m = m_;
+			p = p_;
+			range = range_;
+		}
+	}
+
+	public static long pow2(long x) {
+		return x * x;
+	}
+
+	public static long dist(Node a, Node b) {
+		return pow2(a.x - b.x) + pow2(a.y - b.y);
+	}
+
+	public static int MAXN = 300001;
+	public static int MAXB = 1001;
+	public static int n;
+
+	public static Node[] arr = new Node[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+	public static int[] maxm = new int[MAXB];
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] que = new int[MAXN];
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		Arrays.sort(arr, 1, n + 1, (a, b) -> a.m - b.m);
+		for (int i = 1; i <= bnum; i++) {
+			maxm[i] = arr[br[i]].m;
+			Arrays.sort(arr, bl[i], br[i] + 1, (a, b) -> a.dist <= b.dist ? -1 : 1);
+		}
+	}
+
+	public static int bfs() {
+		int ans = 0;
+		vis[0] = true;
+		int l = 1, r = 1;
+		que[r++] = 0;
+		while (l < r) {
+			int cur = que[l++];
+			int block = bnum + 1;
+			for (int i = 1; i <= bnum; i++) {
+				if (maxm[i] > arr[cur].p) {
+					block = i;
+					break;
+				}
+			}
+			for (int i = 1; i < block; i++) {
+				while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
+					if (!vis[bl[i]]) {
+						ans++;
+						que[r++] = bl[i];
+						vis[bl[i]] = true;
+					}
+					bl[i]++;
+				}
+			}
+			if (block <= bnum) {
+				for (int i = bl[block]; i <= br[block]; i++) {
+					if (arr[i].m <= arr[cur].p && dist(arr[0], arr[i]) <= arr[cur].range && !vis[i]) {
+						ans++;
+						que[r++] = i;
+						vis[i] = true;
+					}
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		int x = in.nextInt();
+		int y = in.nextInt();
+		int m = 0;
+		int p = in.nextInt();
+		int range = in.nextInt();
+		arr[0] = new Node(x, y, 0, p, range);
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			x = in.nextInt();
+			y = in.nextInt();
+			m = in.nextInt();
+			p = in.nextInt();
+			range = in.nextInt();
+			arr[i] = new Node(x, y, m, p, range);
+		}
+		for (int i = 0; i <= n; i++) {
+			arr[i].range = pow2(arr[i].range);
+			arr[i].dist = dist(arr[0], arr[i]);
+		}
+		prepare();
+		out.println(bfs());
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class173/Code04_Magnet2.java b/src/class173/Code04_Magnet2.java
new file mode 100644
index 000000000..183378ed4
--- /dev/null
+++ b/src/class173/Code04_Magnet2.java
@@ -0,0 +1,118 @@
+package class173;
+
+// 磁力块，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P10590
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int x, y, m, p;
+//    long long range, dist;
+//};
+//
+//bool cmp1(Node a, Node b) {
+//    return a.m < b.m;
+//}
+//
+//bool cmp2(Node a, Node b) {
+//    return a.dist < b.dist;
+//}
+//
+//const int MAXN = 300001;
+//const int MAXB = 1001;
+//int n;
+//Node arr[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//int maxm[MAXB];
+//
+//bool vis[MAXN];
+//int que[MAXN];
+//
+//inline long long pow2(long long x) {
+//    return x * x;
+//}
+//
+//inline long long dist(Node a, Node b) {
+//    return pow2(1L * a.x - b.x) + pow2(1L * a.y - b.y);
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    sort(arr + 1, arr + n + 1, cmp1);
+//    for (int i = 1; i <= bnum; i++) {
+//        maxm[i] = arr[br[i]].m;
+//        sort(arr + bl[i], arr + br[i] + 1, cmp2);
+//    }
+//}
+//
+//int bfs() {
+//    int ans = 0;
+//    vis[0] = true;
+//    int l = 1, r = 1;
+//    que[r++] = 0;
+//    while (l < r) {
+//        int cur = que[l++];
+//        int block = bnum + 1;
+//        for (int i = 1; i <= bnum; i++) {
+//            if (maxm[i] > arr[cur].p) {
+//                block = i;
+//                break;
+//            }
+//        }
+//        for (int i = 1; i < block; i++) {
+//            while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
+//                if (!vis[bl[i]]) {
+//                    ans++;
+//                    que[r++] = bl[i];
+//                    vis[bl[i]] = true;
+//                }
+//                bl[i]++;
+//            }
+//        }
+//        if (block <= bnum) {
+//            for (int i = bl[block]; i <= br[block]; i++) {
+//                if (arr[i].m <= arr[cur].p && dist(arr[0], arr[i]) <= arr[cur].range && !vis[i]) {
+//                    ans++;
+//                    que[r++] = i;
+//                    vis[i] = true;
+//                }
+//            }
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    int x, y, m, p, range;
+//    cin >> x >> y >> p >> range >> n;
+//    arr[0] = {x, y, 0, p, range, 0};
+//    for (int i = 1; i <= n; i++) {
+//        cin >> x >> y >> m >> p >> range;
+//        arr[i] = {x, y, m, p, range, 0};
+//    }
+//    for (int i = 0; i <= n; i++) {
+//        arr[i].range = pow2(arr[i].range);
+//        arr[i].dist = dist(arr[0], arr[i]);
+//    }
+//    prepare();
+//    cout << bfs();
+//    return 0;
+//}
\ No newline at end of file

From 635195122165b5f1b41f4d0d4195545a2f42c2aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 18:14:37 +0800
Subject: [PATCH 1005/1712] modify code

---
 src/class173/Code04_Magnet1.java | 36 +++++++++++++------------------
 src/class173/Code04_Magnet2.java | 37 ++++++++++++++------------------
 2 files changed, 31 insertions(+), 42 deletions(-)

diff --git a/src/class173/Code04_Magnet1.java b/src/class173/Code04_Magnet1.java
index ff11f2be0..973434922 100644
--- a/src/class173/Code04_Magnet1.java
+++ b/src/class173/Code04_Magnet1.java
@@ -40,7 +40,6 @@ public static long dist(Node a, Node b) {
 	public static int MAXN = 300001;
 	public static int MAXB = 1001;
 	public static int n;
-
 	public static Node[] arr = new Node[MAXN];
 
 	public static int blen, bnum;
@@ -76,29 +75,24 @@ public static int bfs() {
 		que[r++] = 0;
 		while (l < r) {
 			int cur = que[l++];
-			int block = bnum + 1;
 			for (int i = 1; i <= bnum; i++) {
 				if (maxm[i] > arr[cur].p) {
-					block = i;
-					break;
-				}
-			}
-			for (int i = 1; i < block; i++) {
-				while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
-					if (!vis[bl[i]]) {
-						ans++;
-						que[r++] = bl[i];
-						vis[bl[i]] = true;
+					for (int j = bl[i]; j <= br[i]; j++) {
+						if (arr[j].dist <= arr[cur].range && arr[j].m <= arr[cur].p && !vis[j]) {
+							vis[j] = true;
+							que[r++] = j;
+							ans++;
+						}
 					}
-					bl[i]++;
-				}
-			}
-			if (block <= bnum) {
-				for (int i = bl[block]; i <= br[block]; i++) {
-					if (arr[i].m <= arr[cur].p && dist(arr[0], arr[i]) <= arr[cur].range && !vis[i]) {
-						ans++;
-						que[r++] = i;
-						vis[i] = true;
+					break;
+				} else {
+					while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
+						if (!vis[bl[i]]) {
+							vis[bl[i]] = true;
+							que[r++] = bl[i];
+							ans++;
+						}
+						bl[i]++;
 					}
 				}
 			}
diff --git a/src/class173/Code04_Magnet2.java b/src/class173/Code04_Magnet2.java
index 183378ed4..15f4ca532 100644
--- a/src/class173/Code04_Magnet2.java
+++ b/src/class173/Code04_Magnet2.java
@@ -68,29 +68,24 @@
 //    que[r++] = 0;
 //    while (l < r) {
 //        int cur = que[l++];
-//        int block = bnum + 1;
 //        for (int i = 1; i <= bnum; i++) {
 //            if (maxm[i] > arr[cur].p) {
-//                block = i;
-//                break;
-//            }
-//        }
-//        for (int i = 1; i < block; i++) {
-//            while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
-//                if (!vis[bl[i]]) {
-//                    ans++;
-//                    que[r++] = bl[i];
-//                    vis[bl[i]] = true;
+//                for (int j = bl[i]; j <= br[i]; j++) {
+//                    if (arr[j].dist <= arr[cur].range && arr[j].m <= arr[cur].p && !vis[j]) {
+//                        vis[j] = true;
+//                        que[r++] = j;
+//                        ans++;
+//                    }
 //                }
-//                bl[i]++;
-//            }
-//        }
-//        if (block <= bnum) {
-//            for (int i = bl[block]; i <= br[block]; i++) {
-//                if (arr[i].m <= arr[cur].p && dist(arr[0], arr[i]) <= arr[cur].range && !vis[i]) {
-//                    ans++;
-//                    que[r++] = i;
-//                    vis[i] = true;
+//                break;
+//            } else {
+//                while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
+//                    if (!vis[bl[i]]) {
+//                        vis[bl[i]] = true;
+//                        que[r++] = bl[i];
+//                        ans++;
+//                    }
+//                    bl[i]++;
 //                }
 //            }
 //        }
@@ -113,6 +108,6 @@
 //        arr[i].dist = dist(arr[0], arr[i]);
 //    }
 //    prepare();
-//    cout << bfs();
+//    cout << bfs() << '\n';
 //    return 0;
 //}
\ No newline at end of file

From 67db4be3abf271e565e8cc2f7f2f538c5afb3cd1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 18:19:42 +0800
Subject: [PATCH 1006/1712] modify code

---
 src/class173/Code04_Magnet1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class173/Code04_Magnet1.java b/src/class173/Code04_Magnet1.java
index 973434922..e12990bef 100644
--- a/src/class173/Code04_Magnet1.java
+++ b/src/class173/Code04_Magnet1.java
@@ -2,6 +2,7 @@
 
 // 磁力块，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
+// 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是无法通过测试
 // 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code04_Magnet2文件就是C++的实现

From 91462ab0fe6dc13bad763dcd99c654daba609cf1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 19:16:33 +0800
Subject: [PATCH 1007/1712] modify code

---
 src/class173/Code04_Magnet1.java | 36 +++++++++++++++++++++-----------
 src/class173/Code04_Magnet2.java | 24 +++++++++------------
 2 files changed, 34 insertions(+), 26 deletions(-)

diff --git a/src/class173/Code04_Magnet1.java b/src/class173/Code04_Magnet1.java
index e12990bef..93de5a3ba 100644
--- a/src/class173/Code04_Magnet1.java
+++ b/src/class173/Code04_Magnet1.java
@@ -2,7 +2,6 @@
 
 // 磁力块，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
-// 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是无法通过测试
 // 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code04_Magnet2文件就是C++的实现
@@ -13,6 +12,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 import java.util.Arrays;
+import java.util.Comparator;
 
 public class Code04_Magnet1 {
 
@@ -30,16 +30,25 @@ public Node(int x_, int y_, int m_, int p_, int range_) {
 		}
 	}
 
-	public static long pow2(long x) {
-		return x * x;
+	public static class Cmp1 implements Comparator<Node> {
+		@Override
+		public int compare(Node a, Node b) {
+			return a.m - b.m;
+		}
 	}
 
-	public static long dist(Node a, Node b) {
-		return pow2(a.x - b.x) + pow2(a.y - b.y);
+	public static class Cmp2 implements Comparator<Node> {
+		@Override
+		public int compare(Node a, Node b) {
+			return a.dist <= b.dist ? -1 : 1;
+		}
 	}
 
-	public static int MAXN = 300001;
-	public static int MAXB = 1001;
+	public static Cmp1 cmp1 = new Cmp1();
+	public static Cmp2 cmp2 = new Cmp2();
+
+	public static int MAXN = 250001;
+	public static int MAXB = 501;
 	public static int n;
 	public static Node[] arr = new Node[MAXN];
 
@@ -62,10 +71,10 @@ public static void prepare() {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, n);
 		}
-		Arrays.sort(arr, 1, n + 1, (a, b) -> a.m - b.m);
+		Arrays.sort(arr, 1, n + 1, cmp1);
 		for (int i = 1; i <= bnum; i++) {
 			maxm[i] = arr[br[i]].m;
-			Arrays.sort(arr, bl[i], br[i] + 1, (a, b) -> a.dist <= b.dist ? -1 : 1);
+			Arrays.sort(arr, bl[i], br[i] + 1, cmp2);
 		}
 	}
 
@@ -87,7 +96,7 @@ public static int bfs() {
 					}
 					break;
 				} else {
-					while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
+					while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
 						if (!vis[bl[i]]) {
 							vis[bl[i]] = true;
 							que[r++] = bl[i];
@@ -119,9 +128,12 @@ public static void main(String[] args) throws IOException {
 			range = in.nextInt();
 			arr[i] = new Node(x, y, m, p, range);
 		}
+		long xd, yd;
 		for (int i = 0; i <= n; i++) {
-			arr[i].range = pow2(arr[i].range);
-			arr[i].dist = dist(arr[0], arr[i]);
+			arr[i].range = arr[i].range * arr[i].range;
+			xd = arr[0].x - arr[i].x;
+			yd = arr[0].y - arr[i].y;
+			arr[i].dist = xd * xd + yd * yd;
 		}
 		prepare();
 		out.println(bfs());
diff --git a/src/class173/Code04_Magnet2.java b/src/class173/Code04_Magnet2.java
index 15f4ca532..79314355a 100644
--- a/src/class173/Code04_Magnet2.java
+++ b/src/class173/Code04_Magnet2.java
@@ -11,7 +11,8 @@
 //
 //struct Node {
 //    int x, y, m, p;
-//    long long range, dist;
+//    long long range;
+//    long long dist;
 //};
 //
 //bool cmp1(Node a, Node b) {
@@ -22,8 +23,8 @@
 //    return a.dist < b.dist;
 //}
 //
-//const int MAXN = 300001;
-//const int MAXB = 1001;
+//const int MAXN = 250001;
+//const int MAXB = 501;
 //int n;
 //Node arr[MAXN];
 //
@@ -36,14 +37,6 @@
 //bool vis[MAXN];
 //int que[MAXN];
 //
-//inline long long pow2(long long x) {
-//    return x * x;
-//}
-//
-//inline long long dist(Node a, Node b) {
-//    return pow2(1L * a.x - b.x) + pow2(1L * a.y - b.y);
-//}
-//
 //void prepare() {
 //    blen = (int)sqrt(n);
 //    bnum = (n + blen - 1) / blen;
@@ -79,7 +72,7 @@
 //                }
 //                break;
 //            } else {
-//                while (bl[i] <= br[i] && dist(arr[0], arr[bl[i]]) <= arr[cur].range) {
+//                while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
 //                    if (!vis[bl[i]]) {
 //                        vis[bl[i]] = true;
 //                        que[r++] = bl[i];
@@ -103,9 +96,12 @@
 //        cin >> x >> y >> m >> p >> range;
 //        arr[i] = {x, y, m, p, range, 0};
 //    }
+//    long long xd, yd;
 //    for (int i = 0; i <= n; i++) {
-//        arr[i].range = pow2(arr[i].range);
-//        arr[i].dist = dist(arr[0], arr[i]);
+//        arr[i].range = arr[i].range * arr[i].range;
+//        xd = arr[0].x - arr[i].x;
+//        yd = arr[0].y - arr[i].y;
+//        arr[i].dist = xd * xd + yd * yd;
 //    }
 //    prepare();
 //    cout << bfs() << '\n';

From ab070af6b48a059df05419176b3fa4bce5c3d040 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 19:19:30 +0800
Subject: [PATCH 1008/1712] modify code

---
 src/class173/Code04_Magnet1.java | 4 ++--
 src/class173/Code04_Magnet2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code04_Magnet1.java b/src/class173/Code04_Magnet1.java
index 93de5a3ba..54ce758cb 100644
--- a/src/class173/Code04_Magnet1.java
+++ b/src/class173/Code04_Magnet1.java
@@ -47,8 +47,8 @@ public int compare(Node a, Node b) {
 	public static Cmp1 cmp1 = new Cmp1();
 	public static Cmp2 cmp2 = new Cmp2();
 
-	public static int MAXN = 250001;
-	public static int MAXB = 501;
+	public static int MAXN = 300001;
+	public static int MAXB = 601;
 	public static int n;
 	public static Node[] arr = new Node[MAXN];
 
diff --git a/src/class173/Code04_Magnet2.java b/src/class173/Code04_Magnet2.java
index 79314355a..99604c0ea 100644
--- a/src/class173/Code04_Magnet2.java
+++ b/src/class173/Code04_Magnet2.java
@@ -23,8 +23,8 @@
 //    return a.dist < b.dist;
 //}
 //
-//const int MAXN = 250001;
-//const int MAXB = 501;
+//const int MAXN = 300001;
+//const int MAXB = 601;
 //int n;
 //Node arr[MAXN];
 //

From 66a8124c6b4e005a5c63ae7b0b55ed11cdb576ae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 19:24:33 +0800
Subject: [PATCH 1009/1712] modify code

---
 src/class173/Code01_Sequence2.java |  2 +-
 src/class173/Code04_Magnet1.java   | 15 +++++++--------
 src/class173/Code04_Magnet2.java   | 19 +++++++++----------
 3 files changed, 17 insertions(+), 19 deletions(-)

diff --git a/src/class173/Code01_Sequence2.java b/src/class173/Code01_Sequence2.java
index cd88f2bd1..006c649d2 100644
--- a/src/class173/Code01_Sequence2.java
+++ b/src/class173/Code01_Sequence2.java
@@ -13,7 +13,7 @@
 //    int op, x, t, v, q;
 //};
 //
-//bool EventCmp(Event a, Event b) {
+//bool EventCmp(Event &a, Event &b) {
 //    return a.x != b.x ? a.x < b.x : a.t < b.t;
 //}
 //
diff --git a/src/class173/Code04_Magnet1.java b/src/class173/Code04_Magnet1.java
index 54ce758cb..7dc61a940 100644
--- a/src/class173/Code04_Magnet1.java
+++ b/src/class173/Code04_Magnet1.java
@@ -95,15 +95,14 @@ public static int bfs() {
 						}
 					}
 					break;
-				} else {
-					while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
-						if (!vis[bl[i]]) {
-							vis[bl[i]] = true;
-							que[r++] = bl[i];
-							ans++;
-						}
-						bl[i]++;
+				}
+				while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
+					if (!vis[bl[i]]) {
+						vis[bl[i]] = true;
+						que[r++] = bl[i];
+						ans++;
 					}
+					bl[i]++;
 				}
 			}
 		}
diff --git a/src/class173/Code04_Magnet2.java b/src/class173/Code04_Magnet2.java
index 99604c0ea..38148ac8a 100644
--- a/src/class173/Code04_Magnet2.java
+++ b/src/class173/Code04_Magnet2.java
@@ -15,11 +15,11 @@
 //    long long dist;
 //};
 //
-//bool cmp1(Node a, Node b) {
+//bool cmp1(Node &a, Node &b) {
 //    return a.m < b.m;
 //}
 //
-//bool cmp2(Node a, Node b) {
+//bool cmp2(Node &a, Node &b) {
 //    return a.dist < b.dist;
 //}
 //
@@ -71,15 +71,14 @@
 //                    }
 //                }
 //                break;
-//            } else {
-//                while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
-//                    if (!vis[bl[i]]) {
-//                        vis[bl[i]] = true;
-//                        que[r++] = bl[i];
-//                        ans++;
-//                    }
-//                    bl[i]++;
+//            }
+//            while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
+//                if (!vis[bl[i]]) {
+//                    vis[bl[i]] = true;
+//                    que[r++] = bl[i];
+//                    ans++;
 //                }
+//                bl[i]++;
 //            }
 //        }
 //    }

From f6017735f14dd45a3f5d39f656d295543385be97 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 21 Jun 2025 22:54:08 +0800
Subject: [PATCH 1010/1712] modify code

---
 src/class173/Code03_Magnet1.java              | 205 ++++++++++++++++++
 ...ode04_Magnet2.java => Code03_Magnet2.java} |  24 +-
 ...Inversion1.java => Code04_Inversion1.java} |   4 +-
 ...Inversion2.java => Code04_Inversion2.java} |   2 +-
 src/class173/Code04_Magnet1.java              | 182 ----------------
 5 files changed, 221 insertions(+), 196 deletions(-)
 create mode 100644 src/class173/Code03_Magnet1.java
 rename src/class173/{Code04_Magnet2.java => Code03_Magnet2.java} (78%)
 rename src/class173/{Code03_Inversion1.java => Code04_Inversion1.java} (98%)
 rename src/class173/{Code03_Inversion2.java => Code04_Inversion2.java} (99%)
 delete mode 100644 src/class173/Code04_Magnet1.java

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
new file mode 100644
index 000000000..782f0edf7
--- /dev/null
+++ b/src/class173/Code03_Magnet1.java
@@ -0,0 +1,205 @@
+package class173;
+
+// 磁力块，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P10590
+// 测试链接 : https://codeforces.com/problemset/problem/198/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 为了这道题能用java通过，我没有把数据封装到一起，组成一个磁块对象
+// 自己手撸了双指针快排优化常数时间，其实并不需要这么做，因为正式比赛不卡常
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_Magnet1 {
+
+	public static int MAXN = 300001;
+	public static int MAXB = 601;
+	public static int n;
+	public static int[] x = new int[MAXN];
+	public static int[] y = new int[MAXN];
+	public static int[] m = new int[MAXN];
+	public static int[] p = new int[MAXN];
+	public static long[] range = new long[MAXN];
+	public static long[] dist = new long[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+	public static int[] maxm = new int[MAXB];
+
+	public static int[] que = new int[MAXN];
+	public static boolean[] vis = new boolean[MAXN];
+
+	// 下标为i的磁块和下标为j的磁块交换
+	public static void swap(int i, int j) {
+		int tmp1;
+		tmp1 = x[i]; x[i] = x[j]; x[j] = tmp1;
+		tmp1 = y[i]; y[i] = y[j]; y[j] = tmp1;
+		tmp1 = m[i]; m[i] = m[j]; m[j] = tmp1;
+		tmp1 = p[i]; p[i] = p[j]; p[j] = tmp1;
+		long tmp2;
+		tmp2 = range[i]; range[i] = range[j]; range[j] = tmp2;
+		tmp2 = dist[i]; dist[i] = dist[j]; dist[j] = tmp2;
+	}
+
+	// 所有磁块根据m值排序，手写双指针快排
+	public static void sortByM(int l, int r) {
+		if (l >= r) {
+			return;
+		}
+		int i = l, j = r, pivot = m[(l + r) >>> 1];
+		while (i <= j) {
+			while (m[i] < pivot) {
+				i++;
+			}
+			while (m[j] > pivot) {
+				j--;
+			}
+			if (i <= j) {
+				swap(i++, j--);
+			}
+		}
+		sortByM(l, j);
+		sortByM(i, r);
+	}
+
+	// 所有磁块根据dist值排序，手写双指针快排
+	public static void sortByDist(int l, int r) {
+		if (l >= r) {
+			return;
+		}
+		int i = l, j = r;
+		long pivot = dist[(l + r) >>> 1];
+		while (i <= j) {
+			while (dist[i] < pivot) {
+				i++;
+			}
+			while (dist[j] > pivot) {
+				j--;
+			}
+			if (i <= j) {
+				swap(i++, j--);
+			}
+		}
+		sortByDist(l, j);
+		sortByDist(i, r);
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		sortByM(1, n);
+		for (int i = 1; i <= bnum; i++) {
+			maxm[i] = m[br[i]];
+			sortByDist(bl[i], br[i]);
+		}
+	}
+
+	public static int bfs() {
+		int ans = 0;
+		vis[0] = true;
+		int l = 1, r = 1;
+		que[r++] = 0;
+		while (l < r) {
+			int cur = que[l++];
+			for (int b = 1; b <= bnum; b++) {
+				if (maxm[b] > p[cur]) {
+					for (int j = bl[b]; j <= br[b]; j++) {
+						if (dist[j] <= range[cur] && m[j] <= p[cur] && !vis[j]) {
+							vis[j] = true;
+							que[r++] = j;
+							ans++;
+						}
+					}
+					break;
+				}
+				while (bl[b] <= br[b] && dist[bl[b]] <= range[cur]) {
+					int i = bl[b];
+					if (!vis[i]) {
+						vis[i] = true;
+						que[r++] = i;
+						ans++;
+					}
+					bl[b]++;
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		x[0] = in.nextInt();
+		y[0] = in.nextInt();
+		p[0] = in.nextInt();
+		range[0] = in.nextInt();
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			x[i] = in.nextInt();
+			y[i] = in.nextInt();
+			m[i] = in.nextInt();
+			p[i] = in.nextInt();
+			range[i] = in.nextInt();
+		}
+		for (int i = 0; i <= n; i++) {
+			range[i] *= range[i];
+			long dx = x[0] - x[i];
+			long dy = y[0] - y[i];
+			dist[i] = dx * dx + dy * dy;
+		}
+		prepare();
+		out.println(bfs());
+		out.flush();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buf = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buf);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buf[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class173/Code04_Magnet2.java b/src/class173/Code03_Magnet2.java
similarity index 78%
rename from src/class173/Code04_Magnet2.java
rename to src/class173/Code03_Magnet2.java
index 38148ac8a..922ff1ebb 100644
--- a/src/class173/Code04_Magnet2.java
+++ b/src/class173/Code03_Magnet2.java
@@ -2,6 +2,7 @@
 
 // 磁力块，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
+// 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
@@ -61,24 +62,25 @@
 //    que[r++] = 0;
 //    while (l < r) {
 //        int cur = que[l++];
-//        for (int i = 1; i <= bnum; i++) {
-//            if (maxm[i] > arr[cur].p) {
-//                for (int j = bl[i]; j <= br[i]; j++) {
-//                    if (arr[j].dist <= arr[cur].range && arr[j].m <= arr[cur].p && !vis[j]) {
-//                        vis[j] = true;
-//                        que[r++] = j;
+//        for (int b = 1; b <= bnum; b++) {
+//            if (maxm[b] > arr[cur].p) {
+//                for (int i = bl[b]; i <= br[b]; i++) {
+//                    if (arr[i].dist <= arr[cur].range && arr[i].m <= arr[cur].p && !vis[i]) {
+//                        vis[i] = true;
+//                        que[r++] = i;
 //                        ans++;
 //                    }
 //                }
 //                break;
 //            }
-//            while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
-//                if (!vis[bl[i]]) {
-//                    vis[bl[i]] = true;
-//                    que[r++] = bl[i];
+//            while (bl[b] <= br[b] && arr[bl[b]].dist <= arr[cur].range) {
+//                int i = bl[b];
+//                if (!vis[i]) {
+//                    vis[i] = true;
+//                    que[r++] = i;
 //                    ans++;
 //                }
-//                bl[i]++;
+//                bl[b]++;
 //            }
 //        }
 //    }
diff --git a/src/class173/Code03_Inversion1.java b/src/class173/Code04_Inversion1.java
similarity index 98%
rename from src/class173/Code03_Inversion1.java
rename to src/class173/Code04_Inversion1.java
index 7972793a1..b50a47af2 100644
--- a/src/class173/Code03_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -5,7 +5,7 @@
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是无法通过测试
 // 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code03_Inversion2文件就是C++的实现
+// 想通过用C++实现，本节课Code04_Inversion2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_Inversion1 {
+public class Code04_Inversion1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 701;
diff --git a/src/class173/Code03_Inversion2.java b/src/class173/Code04_Inversion2.java
similarity index 99%
rename from src/class173/Code03_Inversion2.java
rename to src/class173/Code04_Inversion2.java
index 67de915d9..a6fe80adf 100644
--- a/src/class173/Code03_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -5,7 +5,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 // 这道题比较卡常，C++实现也需要优化常数，比如快读
-// 正式比赛不卡常！
+// 正式比赛不卡常
 
 //#include <bits/stdc++.h>
 //
diff --git a/src/class173/Code04_Magnet1.java b/src/class173/Code04_Magnet1.java
deleted file mode 100644
index 7dc61a940..000000000
--- a/src/class173/Code04_Magnet1.java
+++ /dev/null
@@ -1,182 +0,0 @@
-package class173;
-
-// 磁力块，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P10590
-// java实现的逻辑一定是正确的，但是无法通过测试
-// 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
-// 想通过用C++实现，本节课Code04_Magnet2文件就是C++的实现
-// 两个版本的逻辑完全一样，C++版本可以通过所有测试
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.util.Arrays;
-import java.util.Comparator;
-
-public class Code04_Magnet1 {
-
-	public static class Node {
-		int x, y, m, p;
-		long range;
-		long dist;
-
-		public Node(int x_, int y_, int m_, int p_, int range_) {
-			x = x_;
-			y = y_;
-			m = m_;
-			p = p_;
-			range = range_;
-		}
-	}
-
-	public static class Cmp1 implements Comparator<Node> {
-		@Override
-		public int compare(Node a, Node b) {
-			return a.m - b.m;
-		}
-	}
-
-	public static class Cmp2 implements Comparator<Node> {
-		@Override
-		public int compare(Node a, Node b) {
-			return a.dist <= b.dist ? -1 : 1;
-		}
-	}
-
-	public static Cmp1 cmp1 = new Cmp1();
-	public static Cmp2 cmp2 = new Cmp2();
-
-	public static int MAXN = 300001;
-	public static int MAXB = 601;
-	public static int n;
-	public static Node[] arr = new Node[MAXN];
-
-	public static int blen, bnum;
-	public static int[] bi = new int[MAXN];
-	public static int[] bl = new int[MAXB];
-	public static int[] br = new int[MAXB];
-	public static int[] maxm = new int[MAXB];
-
-	public static boolean[] vis = new boolean[MAXN];
-	public static int[] que = new int[MAXN];
-
-	public static void prepare() {
-		blen = (int) Math.sqrt(n);
-		bnum = (n + blen - 1) / blen;
-		for (int i = 1; i <= n; i++) {
-			bi[i] = (i - 1) / blen + 1;
-		}
-		for (int i = 1; i <= bnum; i++) {
-			bl[i] = (i - 1) * blen + 1;
-			br[i] = Math.min(i * blen, n);
-		}
-		Arrays.sort(arr, 1, n + 1, cmp1);
-		for (int i = 1; i <= bnum; i++) {
-			maxm[i] = arr[br[i]].m;
-			Arrays.sort(arr, bl[i], br[i] + 1, cmp2);
-		}
-	}
-
-	public static int bfs() {
-		int ans = 0;
-		vis[0] = true;
-		int l = 1, r = 1;
-		que[r++] = 0;
-		while (l < r) {
-			int cur = que[l++];
-			for (int i = 1; i <= bnum; i++) {
-				if (maxm[i] > arr[cur].p) {
-					for (int j = bl[i]; j <= br[i]; j++) {
-						if (arr[j].dist <= arr[cur].range && arr[j].m <= arr[cur].p && !vis[j]) {
-							vis[j] = true;
-							que[r++] = j;
-							ans++;
-						}
-					}
-					break;
-				}
-				while (bl[i] <= br[i] && arr[bl[i]].dist <= arr[cur].range) {
-					if (!vis[bl[i]]) {
-						vis[bl[i]] = true;
-						que[r++] = bl[i];
-						ans++;
-					}
-					bl[i]++;
-				}
-			}
-		}
-		return ans;
-	}
-
-	public static void main(String[] args) throws IOException {
-		FastReader in = new FastReader(System.in);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		int x = in.nextInt();
-		int y = in.nextInt();
-		int m = 0;
-		int p = in.nextInt();
-		int range = in.nextInt();
-		arr[0] = new Node(x, y, 0, p, range);
-		n = in.nextInt();
-		for (int i = 1; i <= n; i++) {
-			x = in.nextInt();
-			y = in.nextInt();
-			m = in.nextInt();
-			p = in.nextInt();
-			range = in.nextInt();
-			arr[i] = new Node(x, y, m, p, range);
-		}
-		long xd, yd;
-		for (int i = 0; i <= n; i++) {
-			arr[i].range = arr[i].range * arr[i].range;
-			xd = arr[0].x - arr[i].x;
-			yd = arr[0].y - arr[i].y;
-			arr[i].dist = xd * xd + yd * yd;
-		}
-		prepare();
-		out.println(bfs());
-		out.flush();
-		out.close();
-	}
-
-	// 读写工具类
-	static class FastReader {
-		private final byte[] buffer = new byte[1 << 20];
-		private int ptr = 0, len = 0;
-		private final InputStream in;
-
-		FastReader(InputStream in) {
-			this.in = in;
-		}
-
-		private int readByte() throws IOException {
-			if (ptr >= len) {
-				len = in.read(buffer);
-				ptr = 0;
-				if (len <= 0)
-					return -1;
-			}
-			return buffer[ptr++];
-		}
-
-		int nextInt() throws IOException {
-			int c;
-			do {
-				c = readByte();
-			} while (c <= ' ' && c != -1);
-			boolean neg = false;
-			if (c == '-') {
-				neg = true;
-				c = readByte();
-			}
-			int val = 0;
-			while (c > ' ' && c != -1) {
-				val = val * 10 + (c - '0');
-				c = readByte();
-			}
-			return neg ? -val : val;
-		}
-	}
-
-}

From 68deca3f8b630745e8132432655ac201efa67939 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 14:28:07 +0800
Subject: [PATCH 1011/1712] modify code

---
 src/class173/Code05_TreeBlock1.java | 334 ++++++++++++++++++++++++++++
 src/class173/Code05_TreeBlock2.java | 165 ++++++++++++++
 2 files changed, 499 insertions(+)
 create mode 100644 src/class173/Code05_TreeBlock1.java
 create mode 100644 src/class173/Code05_TreeBlock2.java

diff --git a/src/class173/Code05_TreeBlock1.java b/src/class173/Code05_TreeBlock1.java
new file mode 100644
index 000000000..ff3763e35
--- /dev/null
+++ b/src/class173/Code05_TreeBlock1.java
@@ -0,0 +1,334 @@
+package class173;
+
+// 树上分块模版题，重链剖分后序列分块，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3603
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code05_TreeBlock1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 1001;
+	public static int MAXV = 30001;
+	public static int MAXS = (MAXV + 31) / 32;
+	public static int n, m, f, k;
+	public static int[] arr = new int[MAXN];
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	// 重链剖分
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[] val = new int[MAXN];
+	public static int cntd = 0;
+
+	// 分块
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+	public static int[][] bitSet = new int[MAXB][MAXS];
+
+	public static int[] tmp = new int[MAXS];
+	public static int[] ans = new int[MAXS];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		dfn[u] = ++cntd;
+		val[cntd] = arr[u];
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				dfn[first] = ++cntd;
+				val[cntd] = arr[first];
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static void setOne(int[] cur, int v) {
+		cur[v / 32] |= 1 << (v % 32);
+	}
+
+	public static void clear(int[] cur) {
+		for (int i = 0; i < MAXS; i++) {
+			cur[i] = 0;
+		}
+	}
+
+	public static void or(int[] a, int[] b) {
+		for (int i = 0; i < MAXS; i++) {
+			a[i] |= b[i];
+		}
+	}
+
+	public static int getOnes(int[] cur) {
+		int ans = 0;
+		for (int x : cur) {
+			ans += Integer.bitCount(x);
+		}
+		return ans;
+	}
+
+	public static int firstMiss(int[] cur) {
+		for (int i = 0, inv; i < MAXS; i++) {
+			inv = ~cur[i];
+			if (inv != 0) {
+				return i * 32 + Integer.numberOfTrailingZeros(inv);
+			}
+		}
+		return -1;
+	}
+
+	public static void query(int l, int r) {
+		clear(tmp);
+		if (bi[l] == bi[r]) {
+			for (int i = l; i <= r; i++) {
+				setOne(tmp, val[i]);
+			}
+		} else {
+			for (int i = l; i <= br[bi[l]]; i++) {
+				setOne(tmp, val[i]);
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				setOne(tmp, val[i]);
+			}
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				or(tmp, bitSet[i]);
+			}
+		}
+	}
+
+	public static void updateAns(int x, int y) {
+		while (top[x] != top[y]) {
+			if (dep[top[x]] < dep[top[y]]) {
+				int tmp = x;
+				x = y;
+				y = tmp;
+			}
+			query(dfn[top[x]], dfn[x]);
+			or(ans, tmp);
+			x = fa[top[x]];
+		}
+		query(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]));
+		or(ans, tmp);
+	}
+
+	public static void prepare() {
+		dfs3();
+		dfs4();
+		// 调整块长
+		blen = (int) Math.sqrt(n * 20);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+			for (int j = bl[i]; j <= br[i]; j++) {
+				setOne(bitSet[i], val[j]);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		f = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		prepare();
+		for (int i = 1, last = 0; i <= m; i++) {
+			clear(ans);
+			k = in.nextInt();
+			for (int j = 1, x, y; j <= k; j++) {
+				x = in.nextInt();
+				y = in.nextInt();
+				if (f > 0) {
+					x = x ^ last;
+					y = y ^ last;
+				}
+				updateAns(x, y);
+			}
+			int ans1 = getOnes(ans);
+			int ans2 = firstMiss(ans);
+			out.println(ans1 + " " + ans2);
+			last = ans1 + ans2;
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class173/Code05_TreeBlock2.java b/src/class173/Code05_TreeBlock2.java
new file mode 100644
index 000000000..a515710af
--- /dev/null
+++ b/src/class173/Code05_TreeBlock2.java
@@ -0,0 +1,165 @@
+package class173;
+
+// 树上分块模版题，重链剖分后序列分块，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3603
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXB = 1001;
+//const int MAXV = 30001;
+//int n, m, f, k;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//int dfn[MAXN];
+//int val[MAXN];
+//int cntd;
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//bitset<MAXV> bitSet[MAXB];
+//
+//bitset<MAXV> tmp;
+//bitset<MAXV> ans;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (!son[u] || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    dfn[u] = ++cntd;
+//    val[cntd] = arr[u];
+//    if (!son[u]) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//void query(int l, int r) {
+//    tmp.reset();
+//    if (bi[l] == bi[r]) {
+//        for (int i = l; i <= r; i++) {
+//        	tmp[val[i]] = 1;
+//        }
+//    } else {
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//        	tmp[val[i]] = 1;
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//        	tmp[val[i]] = 1;
+//        }
+//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+//        	tmp |= bitSet[i];
+//        }
+//    }
+//}
+//
+//void updateAns(int x, int y) {
+//    while (top[x] != top[y]) {
+//        if (dep[top[x]] < dep[top[y]]) {
+//            swap(x, y);
+//        }
+//        query(dfn[top[x]], dfn[x]);
+//        ans |= tmp;
+//        x = fa[top[x]];
+//    }
+//    query(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]));
+//    ans |= tmp;
+//}
+//
+//void prepare() {
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    blen = (int)sqrt(n * 20);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//        for (int j = bl[i]; j <= br[i]; j++) {
+//            bitSet[i][val[j]] = 1;
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> f;
+//    for (int i = 1; i <= n; ++i) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    prepare();
+//    int last = 0;
+//    for (int i = 1; i <= m; i++) {
+//        ans.reset(); 
+//        cin >> k;
+//        for (int j = 1, x, y; j <= k; j++) {
+//            cin >> x >> y;
+//            if (f) {
+//                x ^= last;
+//                y ^= last;
+//            }
+//            updateAns(x, y);
+//        }
+//        int ans1 = ans.count();
+//        ans.flip();
+//		int ans2 = ans._Find_first();
+//        cout << ans1 << ' ' << ans2 << '\n';
+//        last = ans1 + ans2;
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 2e6211c98ba549c3b7ce3877dd10a72d7b037eb5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 14:31:13 +0800
Subject: [PATCH 1012/1712] modify code

---
 src/class173/Code05_TreeBlock2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code05_TreeBlock2.java b/src/class173/Code05_TreeBlock2.java
index a515710af..55bf04a86 100644
--- a/src/class173/Code05_TreeBlock2.java
+++ b/src/class173/Code05_TreeBlock2.java
@@ -157,7 +157,7 @@
 //        }
 //        int ans1 = ans.count();
 //        ans.flip();
-//		int ans2 = ans._Find_first();
+//        int ans2 = ans._Find_first();
 //        cout << ans1 << ' ' << ans2 << '\n';
 //        last = ans1 + ans2;
 //    }

From 1405e3fa1e26c1690af8cc92339c5daeaedde418 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 14:34:34 +0800
Subject: [PATCH 1013/1712] modify code

---
 src/class173/{Code05_TreeBlock1.java => Code05_TreeHld1.java} | 2 +-
 src/class173/{Code05_TreeBlock2.java => Code05_TreeHld2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class173/{Code05_TreeBlock1.java => Code05_TreeHld1.java} (99%)
 rename src/class173/{Code05_TreeBlock2.java => Code05_TreeHld2.java} (100%)

diff --git a/src/class173/Code05_TreeBlock1.java b/src/class173/Code05_TreeHld1.java
similarity index 99%
rename from src/class173/Code05_TreeBlock1.java
rename to src/class173/Code05_TreeHld1.java
index ff3763e35..03fa44a0e 100644
--- a/src/class173/Code05_TreeBlock1.java
+++ b/src/class173/Code05_TreeHld1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_TreeBlock1 {
+public class Code05_TreeHld1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 1001;
diff --git a/src/class173/Code05_TreeBlock2.java b/src/class173/Code05_TreeHld2.java
similarity index 100%
rename from src/class173/Code05_TreeBlock2.java
rename to src/class173/Code05_TreeHld2.java

From 43b07ea653bca05246c678dcc9be99c79f4c0e39 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 14:35:58 +0800
Subject: [PATCH 1014/1712] modify code

---
 src/class173/Code05_TreeHld1.java | 2 +-
 src/class173/Code05_TreeHld2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code05_TreeHld1.java b/src/class173/Code05_TreeHld1.java
index 03fa44a0e..4ac986098 100644
--- a/src/class173/Code05_TreeHld1.java
+++ b/src/class173/Code05_TreeHld1.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链剖分后序列分块，java版
+// 树上分块模版题，重链序列分块，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class173/Code05_TreeHld2.java b/src/class173/Code05_TreeHld2.java
index 55bf04a86..9bf9dfb31 100644
--- a/src/class173/Code05_TreeHld2.java
+++ b/src/class173/Code05_TreeHld2.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链剖分后序列分块，C++版
+// 树上分块模版题，重链序列分块，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 2d00be49ec404bf9b9213171b308d3772f668462 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 14:38:43 +0800
Subject: [PATCH 1015/1712] modify code

---
 .../{Code05_TreeHld1.java => Code05_TreeBlockHld1.java}  | 2 +-
 .../{Code05_TreeHld2.java => Code05_TreeBlockHld2.java}  | 0
 src/class173/Code06_TreeBlockRandom1.java                | 9 +++++++++
 3 files changed, 10 insertions(+), 1 deletion(-)
 rename src/class173/{Code05_TreeHld1.java => Code05_TreeBlockHld1.java} (99%)
 rename src/class173/{Code05_TreeHld2.java => Code05_TreeBlockHld2.java} (100%)
 create mode 100644 src/class173/Code06_TreeBlockRandom1.java

diff --git a/src/class173/Code05_TreeHld1.java b/src/class173/Code05_TreeBlockHld1.java
similarity index 99%
rename from src/class173/Code05_TreeHld1.java
rename to src/class173/Code05_TreeBlockHld1.java
index 4ac986098..9b1ccc95e 100644
--- a/src/class173/Code05_TreeHld1.java
+++ b/src/class173/Code05_TreeBlockHld1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_TreeHld1 {
+public class Code05_TreeBlockHld1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 1001;
diff --git a/src/class173/Code05_TreeHld2.java b/src/class173/Code05_TreeBlockHld2.java
similarity index 100%
rename from src/class173/Code05_TreeHld2.java
rename to src/class173/Code05_TreeBlockHld2.java
diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
new file mode 100644
index 000000000..6b494531d
--- /dev/null
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -0,0 +1,9 @@
+package class173;
+
+// 树上分块模版题，随机撒点分块，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3603
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code06_TreeBlockRandom1 {
+
+}

From 42d94b02af7f6d16026cbd1d3241c2a939b908e4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 15:20:08 +0800
Subject: [PATCH 1016/1712] modify code

---
 ...\347\240\201\350\257\246\350\247\243.pptx" | Bin 59044 -> 58992 bytes
 ...\345\210\253\344\277\256\346\224\271.pptx" | Bin 47568 -> 47513 bytes
 ...\347\232\204\344\277\241\346\201\257.pptx" | Bin 43916 -> 43864 bytes
 ...\347\232\204\351\227\256\351\242\230.pptx" | Bin 45764 -> 45715 bytes
 ...\345\217\262\346\234\200\345\200\274.pptx" | Bin 50239 -> 50187 bytes
 ...\347\232\204\351\242\230\347\233\256.pptx" | Bin 44912 -> 44863 bytes
 ...4\347\276\216\346\264\227\347\211\214.pdf" | Bin 152273 -> 150620 bytes
 ...344\272\214\345\210\206-\344\270\213.pptx" | Bin 48349 -> 48399 bytes
 8 files changed, 0 insertions(+), 0 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243110\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2301-\347\272\277\346\256\265\346\240\221\345\216\237\347\220\206\345\222\214\344\273\243\347\240\201\350\257\246\350\247\243.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243110\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2301-\347\272\277\346\256\265\346\240\221\345\216\237\347\220\206\345\222\214\344\273\243\347\240\201\350\257\246\350\247\243.pptx"
index 04729721e8aa5521d30a53bde27e632b01d03c39..cd37be837a512508a5574c85b44f5175cc9a2060 100644
GIT binary patch
delta 3604
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
Y1BMfd@KA2duUHT<p~8E=l{LkG0J&ox4*&oF

delta 3714
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

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243111\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2302-\347\272\277\346\256\265\346\240\221\347\232\204\347\246\273\346\225\243\345\214\226\343\200\201\344\272\214\345\210\206\346\220\234\347\264\242\343\200\201\347\211\271\345\210\253\344\277\256\346\224\271.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243111\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2302-\347\272\277\346\256\265\346\240\221\347\232\204\347\246\273\346\225\243\345\214\226\343\200\201\344\272\214\345\210\206\346\220\234\347\264\242\343\200\201\347\211\271\345\210\253\344\277\256\346\224\271.pptx"
index 02eab704315f73b17238ce6bb1d34ad1af7e48ca..4e90dd0d8f8cdfa34d71f2a0079cc7ff1d72021e 100644
GIT binary patch
delta 3272
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

delta 3065
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
Hm@DwV#xp;7

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243112\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2303-\347\272\277\346\256\265\346\240\221\347\273\264\346\212\244\346\233\264\345\244\232\347\261\273\345\236\213\347\232\204\344\277\241\346\201\257.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243112\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2303-\347\272\277\346\256\265\346\240\221\347\273\264\346\212\244\346\233\264\345\244\232\347\261\273\345\236\213\347\232\204\344\277\241\346\201\257.pptx"
index bc3c30c4c9adc525ee86bf47cb1465cfaaafbeda..11cbba761b962e6a61928116495aaac8910536b3 100644
GIT binary patch
delta 3155
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
TufpF=R{_sT6#-ewX61hY?Mq<M

delta 3097
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

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243113\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2304-\347\272\277\346\256\265\346\240\221\350\247\243\345\206\263\345\214\272\351\227\264\345\220\210\345\271\266\347\232\204\351\227\256\351\242\230.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243113\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2304-\347\272\277\346\256\265\346\240\221\350\247\243\345\206\263\345\214\272\351\227\264\345\220\210\345\271\266\347\232\204\351\227\256\351\242\230.pptx"
index fbd5176424392536a1df9d1f46b59d83f3e0ba4b..c62cbd7fa0c76642a751c2774a4e9f66f4638b5b 100644
GIT binary patch
delta 3090
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
WPeXx^q3e%!KnhI`-jK!o4F3W)oOzD`

delta 3224
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
L$G1RQJ-ELCUp=p=

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243114\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2305-\345\274\200\347\202\271\347\272\277\346\256\265\346\240\221\343\200\201\345\214\272\351\227\264\346\234\200\345\200\274\345\222\214\345\216\206\345\217\262\346\234\200\345\200\274.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243114\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2305-\345\274\200\347\202\271\347\272\277\346\256\265\346\240\221\343\200\201\345\214\272\351\227\264\346\234\200\345\200\274\345\222\214\345\216\206\345\217\262\346\234\200\345\200\274.pptx"
index da196ecd665694de5b651034f834e914455fc656..f1619596b9379db297460baf84525248edfeb581 100644
GIT binary patch
delta 3509
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
SJbxFJfr7nCY~pphng0b~WX)^<

delta 3289
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
WxyTYXd;C}G2S)1TIBZL|GXDY6Al1D9

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243115\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2306-\347\272\277\346\256\265\346\240\221\344\270\216\346\211\253\346\217\217\347\272\277\347\273\223\345\220\210\347\232\204\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243115\343\200\220\346\211\251\345\261\225\343\200\221\347\272\277\346\256\265\346\240\221\344\270\223\351\242\2306-\347\272\277\346\256\265\346\240\221\344\270\216\346\211\253\346\217\217\347\272\277\347\273\223\345\220\210\347\232\204\351\242\230\347\233\256.pptx"
index 839a3ce20bc640a21a2d2bea7efcbfa7f044664a..1d904370b48787c163425463f36c911d5929ea7c 100644
GIT binary patch
delta 3254
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
Dfn=D+

delta 3347
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
P>r?@Ft7PFs{9f%p752Ie

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243146\343\200\220\346\211\251\345\261\225\343\200\221\345\272\267\346\211\230\345\261\225\345\274\200\343\200\201\347\272\246\347\221\237\345\244\253\347\216\257\343\200\201\345\256\214\347\276\216\346\264\227\347\211\214.pdf" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243146\343\200\220\346\211\251\345\261\225\343\200\221\345\272\267\346\211\230\345\261\225\345\274\200\343\200\201\347\272\246\347\221\237\345\244\253\347\216\257\343\200\201\345\256\214\347\276\216\346\264\227\347\211\214.pdf"
index c2b78d93b257e931d73ab2f8bc591abddf1cb8e7..c74235a7db51cdd6970912b6b56cbcde20ccfbc2 100644
GIT binary patch
delta 58905
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

delta 61028
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

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243169\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\213.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243169\343\200\220\346\214\272\351\232\276\343\200\221\346\225\264\344\275\223\344\272\214\345\210\206-\344\270\213.pptx"
index 9b01581dc1d378f2330b68b63b00b9022c063423..c0eb0cf562a015da005395dfe00495f2c76402b7 100644
GIT binary patch
delta 3215
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
MS*I?{DCQ;p4~-|t(*OVf

delta 3264
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


From 076669b0a36e1bf0aa8a3b38b4830c68692cfb08 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 15:26:58 +0800
Subject: [PATCH 1017/1712] modify code

---
 src/class146/Code02_InverseCantorExpansion.java | 2 ++
 src/class169/Code01_Juice1.java                 | 2 ++
 2 files changed, 4 insertions(+)

diff --git a/src/class146/Code02_InverseCantorExpansion.java b/src/class146/Code02_InverseCantorExpansion.java
index ccbfb3419..b801cbec7 100644
--- a/src/class146/Code02_InverseCantorExpansion.java
+++ b/src/class146/Code02_InverseCantorExpansion.java
@@ -23,6 +23,8 @@ public class Code02_InverseCantorExpansion {
 	public static long[] arr = new long[MAXN];
 
 	// 线段树
+	// 这种使用线段树的方式叫线段树二分
+	// 讲解169的题目1，也涉及线段树二分
 	public static int[] sum = new int[MAXN << 2];
 
 	public static int n;
diff --git a/src/class169/Code01_Juice1.java b/src/class169/Code01_Juice1.java
index 0d6cf24fa..94d92c8de 100644
--- a/src/class169/Code01_Juice1.java
+++ b/src/class169/Code01_Juice1.java
@@ -29,6 +29,8 @@ public class Code01_Juice1 {
 	// 小朋友至少的果汁量
 	public static long[] least = new long[MAXN];
 
+	// 这种使用线段树的方式叫线段树二分
+	// 讲解146的题目2，也涉及线段树二分
 	// 果汁单价作为下标的线段树
 	// maxp为最大的果汁单价
 	public static int maxp = 0;

From 95e27ea384b507eb2e943eac0931ae96c0ec31bd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 15:40:42 +0800
Subject: [PATCH 1018/1712] modify code

---
 src/class173/Code06_TreeBlockRandom1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index 6b494531d..af715fa23 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，随机撒点分块，java版
+// 树上分块模版题，随机分块，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 524150a1a272c1abf19605813843a003bc3f462f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 15:59:18 +0800
Subject: [PATCH 1019/1712] modify code

---
 src/class173/Code06_TreeBlockRandom1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index af715fa23..6b494531d 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，随机分块，java版
+// 树上分块模版题，随机撒点分块，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From fa11cbe6931629aec868568bd6fc82d4b1d49e4b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 21:28:45 +0800
Subject: [PATCH 1020/1712] modify code

---
 src/class173/Code05_TreeBlockHld1.java    | 118 ++++----
 src/class173/Code05_TreeBlockHld2.java    |   6 +-
 src/class173/Code06_TreeBlockRandom1.java | 349 +++++++++++++++++++++-
 src/class173/Code06_TreeBlockRandom2.java | 175 +++++++++++
 4 files changed, 592 insertions(+), 56 deletions(-)
 create mode 100644 src/class173/Code06_TreeBlockRandom2.java

diff --git a/src/class173/Code05_TreeBlockHld1.java b/src/class173/Code05_TreeBlockHld1.java
index 9b1ccc95e..15c42f67b 100644
--- a/src/class173/Code05_TreeBlockHld1.java
+++ b/src/class173/Code05_TreeBlockHld1.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链序列分块，java版
+// 树上分块模版题，重链剖分 + 序列分块，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,9 +12,8 @@
 public class Code05_TreeBlockHld1 {
 
 	public static int MAXN = 100001;
-	public static int MAXB = 1001;
+	public static int MAXB = 301;
 	public static int MAXV = 30001;
-	public static int MAXS = (MAXV + 31) / 32;
 	public static int n, m, f, k;
 	public static int[] arr = new int[MAXN];
 
@@ -39,10 +38,58 @@ public class Code05_TreeBlockHld1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
-	public static int[][] bitSet = new int[MAXB][MAXS];
+	public static BitSet[] bitSet = new BitSet[MAXB];
 
-	public static int[] tmp = new int[MAXS];
-	public static int[] ans = new int[MAXS];
+	// 答案
+	public static BitSet tmp = new BitSet();
+	public static BitSet ans = new BitSet();
+
+	static class BitSet {
+
+		int len;
+
+		public int[] set;
+
+		public BitSet() {
+			len = (MAXV + 31) / 32;
+			set = new int[len];
+		}
+
+		public void clear() {
+			for (int i = 0; i < len; i++) {
+				set[i] = 0;
+			}
+		}
+
+		public void setOne(int v) {
+			set[v / 32] |= 1 << (v % 32);
+		}
+
+		public void or(BitSet obj) {
+			for (int i = 0; i < len; i++) {
+				set[i] |= obj.set[i];
+			}
+		}
+
+		public int getOnes() {
+			int ans = 0;
+			for (int x : set) {
+				ans += Integer.bitCount(x);
+			}
+			return ans;
+		}
+
+		public int mex() {
+			for (int i = 0, inv; i < len; i++) {
+				inv = ~set[i];
+				if (inv != 0) {
+					return i * 32 + Integer.numberOfTrailingZeros(inv);
+				}
+			}
+			return -1;
+		}
+
+	}
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
@@ -169,55 +216,21 @@ public static void dfs4() {
 		}
 	}
 
-	public static void setOne(int[] cur, int v) {
-		cur[v / 32] |= 1 << (v % 32);
-	}
-
-	public static void clear(int[] cur) {
-		for (int i = 0; i < MAXS; i++) {
-			cur[i] = 0;
-		}
-	}
-
-	public static void or(int[] a, int[] b) {
-		for (int i = 0; i < MAXS; i++) {
-			a[i] |= b[i];
-		}
-	}
-
-	public static int getOnes(int[] cur) {
-		int ans = 0;
-		for (int x : cur) {
-			ans += Integer.bitCount(x);
-		}
-		return ans;
-	}
-
-	public static int firstMiss(int[] cur) {
-		for (int i = 0, inv; i < MAXS; i++) {
-			inv = ~cur[i];
-			if (inv != 0) {
-				return i * 32 + Integer.numberOfTrailingZeros(inv);
-			}
-		}
-		return -1;
-	}
-
 	public static void query(int l, int r) {
-		clear(tmp);
+		tmp.clear();
 		if (bi[l] == bi[r]) {
 			for (int i = l; i <= r; i++) {
-				setOne(tmp, val[i]);
+				tmp.setOne(val[i]);
 			}
 		} else {
 			for (int i = l; i <= br[bi[l]]; i++) {
-				setOne(tmp, val[i]);
+				tmp.setOne(val[i]);
 			}
 			for (int i = bl[bi[r]]; i <= r; i++) {
-				setOne(tmp, val[i]);
+				tmp.setOne(val[i]);
 			}
 			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-				or(tmp, bitSet[i]);
+				tmp.or(bitSet[i]);
 			}
 		}
 	}
@@ -230,18 +243,18 @@ public static void updateAns(int x, int y) {
 				y = tmp;
 			}
 			query(dfn[top[x]], dfn[x]);
-			or(ans, tmp);
+			ans.or(tmp);
 			x = fa[top[x]];
 		}
 		query(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]));
-		or(ans, tmp);
+		ans.or(tmp);
 	}
 
 	public static void prepare() {
 		dfs3();
 		dfs4();
 		// 调整块长
-		blen = (int) Math.sqrt(n * 20);
+		blen = (int) Math.sqrt(20.0 * n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
@@ -249,8 +262,9 @@ public static void prepare() {
 		for (int i = 1; i <= bnum; i++) {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, n);
+			bitSet[i] = new BitSet();
 			for (int j = bl[i]; j <= br[i]; j++) {
-				setOne(bitSet[i], val[j]);
+				bitSet[i].setOne(val[j]);
 			}
 		}
 	}
@@ -272,7 +286,7 @@ public static void main(String[] args) throws IOException {
 		}
 		prepare();
 		for (int i = 1, last = 0; i <= m; i++) {
-			clear(ans);
+			ans.clear();
 			k = in.nextInt();
 			for (int j = 1, x, y; j <= k; j++) {
 				x = in.nextInt();
@@ -283,8 +297,8 @@ public static void main(String[] args) throws IOException {
 				}
 				updateAns(x, y);
 			}
-			int ans1 = getOnes(ans);
-			int ans2 = firstMiss(ans);
+			int ans1 = ans.getOnes();
+			int ans2 = ans.mex();
 			out.println(ans1 + " " + ans2);
 			last = ans1 + ans2;
 		}
diff --git a/src/class173/Code05_TreeBlockHld2.java b/src/class173/Code05_TreeBlockHld2.java
index 9bf9dfb31..490ea2f81 100644
--- a/src/class173/Code05_TreeBlockHld2.java
+++ b/src/class173/Code05_TreeBlockHld2.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链序列分块，C++版
+// 树上分块模版题，重链剖分 + 序列分块，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -10,7 +10,7 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
-//const int MAXB = 1001;
+//const int MAXB = 301;
 //const int MAXV = 30001;
 //int n, m, f, k;
 //int arr[MAXN];
@@ -116,7 +116,7 @@
 //void prepare() {
 //    dfs1(1, 0);
 //    dfs2(1, 1);
-//    blen = (int)sqrt(n * 20);
+//    blen = (int)sqrt(20.0 * n);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index 6b494531d..10c82ae59 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -1,9 +1,356 @@
 package class173;
 
-// 树上分块模版题，随机撒点分块，java版
+// 树上分块模版题，重链剖分 + 随机撒点，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
 public class Code06_TreeBlockRandom1 {
 
+	public static int MAXN = 100001;
+	public static int MAXB = 301;
+	public static int MAXV = 30001;
+	public static int n, m, f, k;
+	public static int[] arr = new int[MAXN];
+
+	// 链式前向星
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	// 重链剖分
+	public static int[] fa = new int[MAXN];
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] son = new int[MAXN];
+	public static int[] top = new int[MAXN];
+
+	// 随机撒点
+	public static int bnum;
+	public static int[] tag = new int[MAXN];
+	public static int[] spe = new int[MAXN];
+	public static int[] up = new int[MAXN];
+	public static boolean[] vis = new boolean[MAXN];
+	public static BitSet[][] bitSet = new BitSet[MAXB][MAXB];
+
+	public static BitSet tmp = new BitSet();
+	public static BitSet ans = new BitSet();
+
+	static class BitSet {
+
+		int len;
+
+		public int[] set;
+
+		public BitSet() {
+			len = (MAXV + 31) / 32;
+			set = new int[len];
+		}
+
+		public void clear() {
+			for (int i = 0; i < len; i++) {
+				set[i] = 0;
+			}
+		}
+
+		public void setOne(int v) {
+			set[v / 32] |= 1 << (v % 32);
+		}
+
+		public void or(BitSet obj) {
+			for (int i = 0; i < len; i++) {
+				set[i] |= obj.set[i];
+			}
+		}
+
+		public int getOnes() {
+			int ans = 0;
+			for (int x : set) {
+				ans += Integer.bitCount(x);
+			}
+			return ans;
+		}
+
+		public int mex() {
+			for (int i = 0, inv; i < len; i++) {
+				inv = ~set[i];
+				if (inv != 0) {
+					return i * 32 + Integer.numberOfTrailingZeros(inv);
+				}
+			}
+			return -1;
+		}
+
+	}
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs1(int u, int f) {
+		fa[u] = f;
+		dep[u] = dep[f] + 1;
+		siz[u] = 1;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				siz[u] += siz[v];
+				if (son[u] == 0 || siz[son[u]] < siz[v]) {
+					son[u] = v;
+				}
+			}
+		}
+	}
+
+	public static void dfs2(int u, int t) {
+		top[u] = t;
+		if (son[u] == 0) {
+			return;
+		}
+		dfs2(son[u], t);
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa[u] && v != son[u]) {
+				dfs2(v, v);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] fse = new int[MAXN][3];
+
+	public static int stacksize, first, second, edge;
+
+	public static void push(int fir, int sec, int edg) {
+		fse[stacksize][0] = fir;
+		fse[stacksize][1] = sec;
+		fse[stacksize][2] = edg;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		first = fse[stacksize][0];
+		second = fse[stacksize][1];
+		edge = fse[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs3() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				fa[first] = second;
+				dep[first] = dep[second] + 1;
+				siz[first] = 1;
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != second) {
+					push(to[edge], first, -1);
+				}
+			} else {
+				for (int e = head[first], v; e > 0; e = next[e]) {
+					v = to[e];
+					if (v != second) {
+						siz[first] += siz[v];
+						if (son[first] == 0 || siz[son[first]] < siz[v]) {
+							son[first] = v;
+						}
+					}
+				}
+			}
+		}
+	}
+
+	// dfs2的迭代版
+	public static void dfs4() {
+		stacksize = 0;
+		push(1, 1, -1);
+		while (stacksize > 0) {
+			pop();
+			if (edge == -1) {
+				top[first] = second;
+				if (son[first] == 0) {
+					continue;
+				}
+				push(first, second, -2);
+				push(son[first], second, -1);
+				continue;
+			} else if (edge == -2) {
+				edge = head[first];
+			} else {
+				edge = next[edge];
+			}
+			if (edge != 0) {
+				push(first, second, edge);
+				if (to[edge] != fa[first] && to[edge] != son[first]) {
+					push(to[edge], to[edge], -1);
+				}
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		while (top[a] != top[b]) {
+			if (dep[top[a]] <= dep[top[b]]) {
+				b = fa[top[b]];
+			} else {
+				a = fa[top[a]];
+			}
+		}
+		return dep[a] <= dep[b] ? a : b;
+	}
+
+	public static void query(int x, int xylca) {
+		while (spe[x] == 0 && x != xylca) {
+			ans.setOne(arr[x]);
+			x = fa[x];
+		}
+		int backup = x;
+		while (up[x] > 0 && dep[up[x]] > dep[xylca]) {
+			x = up[x];
+		}
+		ans.or(bitSet[spe[backup]][spe[x]]);
+		while (x != xylca) {
+			ans.setOne(arr[x]);
+			x = fa[x];
+		}
+	}
+
+	public static void updateAns(int x, int y) {
+		int xylca = lca(x, y);
+		ans.setOne(arr[xylca]);
+		query(x, xylca);
+		query(y, xylca);
+	}
+
+	public static void prepare() {
+		dfs3();
+		dfs4();
+		int blen = (int) Math.sqrt(20.0 * n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1, pick; i <= bnum; i++) {
+			do {
+				pick = (int) (Math.random() * n) + 1;
+			} while (vis[pick]);
+			vis[pick] = true;
+			tag[i] = pick;
+			spe[pick] = i;
+		}
+		for (int i = 0; i <= bnum; i++) {
+			for (int j = 0; j <= bnum; j++) {
+				bitSet[i][j] = new BitSet();
+			}
+		}
+		for (int i = 1, cur; i <= bnum; i++) {
+			cur = tag[i];
+			tmp.clear();
+			do {
+				tmp.setOne(arr[cur]);
+				if (cur != tag[i] && spe[cur] > 0) {
+					bitSet[i][spe[cur]].or(tmp);
+					if (up[tag[i]] == 0) {
+						up[tag[i]] = cur;
+					}
+				}
+				cur = fa[cur];
+			} while (cur != 0);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		f = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		prepare();
+		for (int i = 1, last = 0; i <= m; i++) {
+			ans.clear();
+			k = in.nextInt();
+			for (int j = 1, x, y; j <= k; j++) {
+				x = in.nextInt();
+				y = in.nextInt();
+				if (f > 0) {
+					x = x ^ last;
+					y = y ^ last;
+				}
+				updateAns(x, y);
+			}
+			int ans1 = ans.getOnes();
+			int ans2 = ans.mex();
+			out.println(ans1 + " " + ans2);
+			last = ans1 + ans2;
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
new file mode 100644
index 000000000..f8df20c15
--- /dev/null
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -0,0 +1,175 @@
+package class173;
+
+// 树上分块模版题，重链剖分 + 随机撒点，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3603
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXB = 301;
+//const int MAXV = 30001;
+//int n, m, f, k;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int fa[MAXN];
+//int dep[MAXN];
+//int siz[MAXN];
+//int son[MAXN];
+//int top[MAXN];
+//
+//int bnum;
+//int tag[MAXN];
+//int spe[MAXN];
+//int up[MAXN];
+//bool vis[MAXN];
+//bitset<MAXV> bitSet[MAXB][MAXB];
+//
+//bitset<MAXV> tmp;
+//bitset<MAXV> ans;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs1(int u, int f) {
+//    fa[u] = f;
+//    dep[u] = dep[f] + 1;
+//    siz[u] = 1;
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs1(v, u);
+//        }
+//    }
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            siz[u] += siz[v];
+//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
+//                son[u] = v;
+//            }
+//        }
+//    }
+//}
+//
+//void dfs2(int u, int t) {
+//    top[u] = t;
+//    if (!son[u]) {
+//        return;
+//    }
+//    dfs2(son[u], t);
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa[u] && v != son[u]) {
+//            dfs2(v, v);
+//        }
+//    }
+//}
+//
+//int lca(int a, int b) {
+//    while (top[a] != top[b]) {
+//        if (dep[top[a]] <= dep[top[b]]) {
+//            b = fa[top[b]];
+//        } else {
+//            a = fa[top[a]];
+//        }
+//    }
+//    return dep[a] <= dep[b] ? a : b;
+//}
+//
+//void query(int x, int xylca) {
+//    while (spe[x] == 0 && x != xylca) {
+//    	ans[arr[x]] = 1;
+//        x = fa[x];
+//    }
+//    int backup = x;
+//    while (up[x] && dep[up[x]] > dep[xylca]) {
+//        x = up[x];
+//    }
+//    ans |= bitSet[spe[backup]][spe[x]];
+//    while (x != xylca) {
+//    	ans[arr[x]] = 1;
+//        x = fa[x];
+//    }
+//}
+//
+//void updateAns(int x, int y) {
+//    int xylca = lca(x, y);
+//    ans[arr[xylca]] = 1;
+//    query(x, xylca);
+//    query(y, xylca);
+//}
+//
+//void prepare() {
+//    dfs1(1, 0);
+//    dfs2(1, 1);
+//    int blen = (int)sqrt(20.0 * n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1, pick; i <= bnum; i++) {
+//        do {
+//            pick = rand() % n + 1;
+//        } while (vis[pick]);
+//        vis[pick] = true;
+//        tag[i] = pick;
+//        spe[pick] = i;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        int cur = tag[i];
+//        tmp.reset();
+//        do {
+//            tmp[arr[cur]] = 1;
+//            if (cur != tag[i] && spe[cur] > 0) {
+//                bitSet[i][spe[cur]] |= tmp;
+//                if (up[tag[i]] == 0) {
+//                    up[tag[i]] = cur;
+//                }
+//            }
+//            cur = fa[cur];
+//        } while (cur != 0);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    srand(time(0));
+//    cin >> n >> m >> f;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    prepare();
+//    for (int i = 1, last = 0; i <= m; i++) {
+//        ans.reset();
+//        cin >> k;
+//        for (int j = 1, x, y; j <= k; j++) {
+//            cin >> x >> y;
+//            if (f) {
+//                x ^= last;
+//                y ^= last;
+//            }
+//            updateAns(x, y);
+//        }
+//        int ans1 = ans.count();
+//        ans.flip();
+//        int ans2 = ans._Find_first();
+//        cout << ans1 << ' ' << ans2 << '\n';
+//        last = ans1 + ans2;
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 83ef40caf4763a8bd06df43b1e41e549c46744de Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 21:33:24 +0800
Subject: [PATCH 1021/1712] modify code

---
 src/class173/Code07_TreeBlockWithModify1.java | 10 ++++++++++
 1 file changed, 10 insertions(+)
 create mode 100644 src/class173/Code07_TreeBlockWithModify1.java

diff --git a/src/class173/Code07_TreeBlockWithModify1.java b/src/class173/Code07_TreeBlockWithModify1.java
new file mode 100644
index 000000000..1c9aa41c7
--- /dev/null
+++ b/src/class173/Code07_TreeBlockWithModify1.java
@@ -0,0 +1,10 @@
+package class173;
+
+// 带修改的树上分块，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1491H
+// 测试链接 : https://codeforces.com/problemset/problem/1491/H
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code07_TreeBlockWithModify1 {
+
+}

From 0258f7173dfe5e872273a58a4f90c2b956f6fade Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 21:51:06 +0800
Subject: [PATCH 1022/1712] modify code

---
 src/class173/Code07_Royal1.java               |  9 +++++++++
 src/class173/Code07_TreeBlockWithModify1.java | 10 ----------
 2 files changed, 9 insertions(+), 10 deletions(-)
 create mode 100644 src/class173/Code07_Royal1.java
 delete mode 100644 src/class173/Code07_TreeBlockWithModify1.java

diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
new file mode 100644
index 000000000..d8d4c74f0
--- /dev/null
+++ b/src/class173/Code07_Royal1.java
@@ -0,0 +1,9 @@
+package class173;
+
+// 王室联邦，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2325
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code07_Royal1 {
+
+}
diff --git a/src/class173/Code07_TreeBlockWithModify1.java b/src/class173/Code07_TreeBlockWithModify1.java
deleted file mode 100644
index 1c9aa41c7..000000000
--- a/src/class173/Code07_TreeBlockWithModify1.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package class173;
-
-// 带修改的树上分块，java版
-// 测试链接 : https://www.luogu.com.cn/problem/CF1491H
-// 测试链接 : https://codeforces.com/problemset/problem/1491/H
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code07_TreeBlockWithModify1 {
-
-}

From f37237330206d75b251899d46c87f95c8ac09ba5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 23 Jun 2025 21:53:19 +0800
Subject: [PATCH 1023/1712] modify code

---
 src/class173/Code06_TreeBlockRandom1.java | 2 +-
 src/class173/Code06_TreeBlockRandom2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index 10c82ae59..b4c33ec6a 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -32,10 +32,10 @@ public class Code06_TreeBlockRandom1 {
 
 	// 随机撒点
 	public static int bnum;
+	public static boolean[] vis = new boolean[MAXN];
 	public static int[] tag = new int[MAXN];
 	public static int[] spe = new int[MAXN];
 	public static int[] up = new int[MAXN];
-	public static boolean[] vis = new boolean[MAXN];
 	public static BitSet[][] bitSet = new BitSet[MAXB][MAXB];
 
 	public static BitSet tmp = new BitSet();
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index f8df20c15..dc6962ed1 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -27,10 +27,10 @@
 //int top[MAXN];
 //
 //int bnum;
+//bool vis[MAXN];
 //int tag[MAXN];
 //int spe[MAXN];
 //int up[MAXN];
-//bool vis[MAXN];
 //bitset<MAXV> bitSet[MAXB][MAXB];
 //
 //bitset<MAXV> tmp;

From 892ea1c8e311653c72673f7a253dd1ae91f8700a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Jun 2025 13:03:00 +0800
Subject: [PATCH 1024/1712] modify code

---
 src/class173/Code07_Royal1.java | 112 ++++++++++++++++++++++++++++++++
 src/class173/Code07_Royal2.java |  75 +++++++++++++++++++++
 2 files changed, 187 insertions(+)
 create mode 100644 src/class173/Code07_Royal2.java

diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index d8d4c74f0..ed7e7ae56 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -4,6 +4,118 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P2325
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
 public class Code07_Royal1 {
 
+	public static int MAXN = 1001;
+	public static int n, b;
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] root = new int[MAXN];
+	public static int[] belong = new int[MAXN];
+	public static int[] stack = new int[MAXN];
+	public static int siz;
+	public static int cntb;
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs(int u, int f) {
+		int tmp = siz;
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != f) {
+				dfs(v, u);
+				if (siz - tmp >= b) {
+					root[++cntb] = u;
+					while (siz > tmp) {
+						belong[stack[siz--]] = cntb;
+					}
+				}
+			}
+		}
+		stack[++siz] = u;
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		b = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs(1, 0);
+		if (cntb == 0) {
+			root[++cntb] = 1;
+		}
+		while (siz > 0) {
+			belong[stack[siz--]] = cntb;
+		}
+		out.println(cntb);
+		for (int i = 1; i <= n; i++) {
+			out.print(belong[i] + " ");
+		}
+		out.println();
+		for (int i = 1; i <= cntb; i++) {
+			out.print(root[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
new file mode 100644
index 000000000..6028d2e1d
--- /dev/null
+++ b/src/class173/Code07_Royal2.java
@@ -0,0 +1,75 @@
+package class173;
+
+// 王室联邦，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2325
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1001;
+//int n, b;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int root[MAXN];
+//int belong[MAXN];
+//int sta[MAXN];
+//int siz;
+//int cntb;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int f) {
+//    int tmp = siz;
+//    for (int e = head[u], v; e; e = nxt[e]) {
+//        v = to[e];
+//        if (v != f) {
+//            dfs(v, u);
+//            if (siz - tmp >= b) {
+//                root[++cntb] = u;
+//                while (siz > tmp) {
+//                    belong[sta[siz--]] = cntb;
+//                }
+//            }
+//        }
+//    }
+//    sta[++siz] = u;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> b;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs(1, 0);
+//    if (cntb == 0) {
+//        root[++cntb] = 1;
+//    }
+//    while (siz > 0) {
+//        belong[sta[siz--]] = cntb;
+//    }
+//    cout << cntb << '\n';
+//    for (int i = 1; i <= n; i++) {
+//        cout << belong[i] << ' ';
+//    }
+//    cout << '\n';
+//    for (int i = 1; i <= cntb; i++) {
+//        cout << root[i] << ' ';
+//    }
+//    cout << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 183df604c74d1866af62049ca3941bad98b4904a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Jun 2025 14:45:45 +0800
Subject: [PATCH 1025/1712] modify code

---
 src/class173/Code03_Magnet1.java           |  2 +-
 src/class173/Code08_RangeFatherMinus1.java | 10 ++++++++++
 2 files changed, 11 insertions(+), 1 deletion(-)
 create mode 100644 src/class173/Code08_RangeFatherMinus1.java

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index 782f0edf7..cdeb09f55 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -5,7 +5,7 @@
 // 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 // 为了这道题能用java通过，我没有把数据封装到一起，组成一个磁块对象
-// 自己手撸了双指针快排优化常数时间，其实并不需要这么做，因为正式比赛不卡常
+// 手写了双指针快排优化常数时间，一般不需要这么做，正式比赛不卡常
 
 import java.io.IOException;
 import java.io.InputStream;
diff --git a/src/class173/Code08_RangeFatherMinus1.java b/src/class173/Code08_RangeFatherMinus1.java
new file mode 100644
index 000000000..72d53d55e
--- /dev/null
+++ b/src/class173/Code08_RangeFatherMinus1.java
@@ -0,0 +1,10 @@
+package class173;
+
+// 区间父变小，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1491H
+// 测试链接 : http://codeforces.com/problemset/problem/1491/H
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code08_RangeFatherMinus1 {
+
+}

From 63947bf06739b1515f5d764b7864c24678f68be7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Jun 2025 15:35:38 +0800
Subject: [PATCH 1026/1712] modify code

---
 src/class173/Code06_TreeBlockRandom1.java  |  9 +++++----
 src/class173/Code06_TreeBlockRandom2.java  | 13 +++++++------
 src/class173/Code08_RangeFatherMinus1.java | 10 ----------
 3 files changed, 12 insertions(+), 20 deletions(-)
 delete mode 100644 src/class173/Code08_RangeFatherMinus1.java

diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index b4c33ec6a..fbe307c70 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -262,18 +262,19 @@ public static void prepare() {
 			}
 		}
 		for (int i = 1, cur; i <= bnum; i++) {
-			cur = tag[i];
 			tmp.clear();
-			do {
+			tmp.setOne(arr[tag[i]]);
+			cur = fa[tag[i]];
+			while (cur != 0) {
 				tmp.setOne(arr[cur]);
-				if (cur != tag[i] && spe[cur] > 0) {
+				if (spe[cur] > 0) {
 					bitSet[i][spe[cur]].or(tmp);
 					if (up[tag[i]] == 0) {
 						up[tag[i]] = cur;
 					}
 				}
 				cur = fa[cur];
-			} while (cur != 0);
+			}
 		}
 	}
 
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index dc6962ed1..81c659e87 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -124,20 +124,21 @@
 //        tag[i] = pick;
 //        spe[pick] = i;
 //    }
-//    for (int i = 1; i <= bnum; i++) {
-//        int cur = tag[i];
+//    for (int i = 1, cur; i <= bnum; i++) {
 //        tmp.reset();
-//        do {
+//        tmp[arr[tag[i]]] = 1;
+//        cur = fa[tag[i]];
+//        while (cur != 0) {
 //            tmp[arr[cur]] = 1;
-//            if (cur != tag[i] && spe[cur] > 0) {
+//            if (spe[cur] > 0) {
 //                bitSet[i][spe[cur]] |= tmp;
 //                if (up[tag[i]] == 0) {
 //                    up[tag[i]] = cur;
 //                }
 //            }
 //            cur = fa[cur];
-//        } while (cur != 0);
-//    }
+//        }
+//    }	
 //}
 //
 //int main() {
diff --git a/src/class173/Code08_RangeFatherMinus1.java b/src/class173/Code08_RangeFatherMinus1.java
deleted file mode 100644
index 72d53d55e..000000000
--- a/src/class173/Code08_RangeFatherMinus1.java
+++ /dev/null
@@ -1,10 +0,0 @@
-package class173;
-
-// 区间父变小，java版
-// 测试链接 : https://www.luogu.com.cn/problem/CF1491H
-// 测试链接 : http://codeforces.com/problemset/problem/1491/H
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-public class Code08_RangeFatherMinus1 {
-
-}

From 5405523fa58a2bc24f0f879a575edf289b423ceb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 24 Jun 2025 18:38:27 +0800
Subject: [PATCH 1027/1712] modify code

---
 src/class173/Code08_RangeFatherMinus1.java | 172 +++++++++++++++++++++
 src/class173/Code08_RangeFatherMinus2.java | 125 +++++++++++++++
 2 files changed, 297 insertions(+)
 create mode 100644 src/class173/Code08_RangeFatherMinus1.java
 create mode 100644 src/class173/Code08_RangeFatherMinus2.java

diff --git a/src/class173/Code08_RangeFatherMinus1.java b/src/class173/Code08_RangeFatherMinus1.java
new file mode 100644
index 000000000..ceed9de21
--- /dev/null
+++ b/src/class173/Code08_RangeFatherMinus1.java
@@ -0,0 +1,172 @@
+package class173;
+
+// 区间父变小，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1491H
+// 测试链接 : https://codeforces.com/problemset/problem/1491/H
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code08_RangeFatherMinus1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 501;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	public static int[] lazy = new int[MAXB];
+	public static int[] outer = new int[MAXN];
+	public static int[] cnt = new int[MAXB];
+
+	public static void innerUpdate(int b) {
+		for (int i = bl[b]; i <= br[b]; i++) {
+			arr[i] = Math.max(1, arr[i] - lazy[b]);
+		}
+		lazy[b] = 0;
+		for (int i = bl[b]; i <= br[b]; i++) {
+			if (arr[i] < bl[b]) {
+				outer[i] = arr[i];
+			} else {
+				outer[i] = outer[arr[i]];
+			}
+		}
+	}
+
+	public static void update(int l, int r, int v) {
+		if (bi[l] == bi[r]) {
+			for (int i = l; i <= r; i++) {
+				arr[i] = Math.max(1, arr[i] - v);
+			}
+			innerUpdate(bi[l]);
+		} else {
+			for (int i = l; i <= br[bi[l]]; i++) {
+				arr[i] = Math.max(1, arr[i] - v);
+			}
+			innerUpdate(bi[l]);
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				arr[i] = Math.max(1, arr[i] - v);
+			}
+			innerUpdate(bi[r]);
+			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+				lazy[i] = Math.min(n, lazy[i] + v);
+				if (++cnt[i] <= blen) {
+					innerUpdate(i);
+				}
+			}
+		}
+	}
+
+	public static int jumpFa(int i) {
+		return Math.max(1, arr[i] - lazy[bi[i]]);
+	}
+
+	public static int jumpOut(int i) {
+		return Math.max(1, outer[i] - lazy[bi[i]]);
+	}
+
+	public static int lca(int x, int y) {
+		while (bi[x] != bi[y] || jumpOut(x) != jumpOut(y)) {
+			if (bi[x] == bi[y]) {
+				x = jumpOut(x);
+				y = jumpOut(y);
+			} else {
+				if (bi[x] < bi[y]) {
+					int tmp = x; x = y; y = tmp;
+				}
+				x = jumpOut(x);
+			}
+		}
+		while (x != y) {
+			if (x < y) {
+				int tmp = x; x = y; y = tmp;
+			}
+			x = jumpFa(x);
+		}
+		return x;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+			innerUpdate(i);
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 2; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			op = in.nextInt();
+			x = in.nextInt();
+			y = in.nextInt();
+			if (op == 1) {
+				z = in.nextInt();
+				update(x, y, z);
+			} else {
+				out.println(lca(x, y));
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class173/Code08_RangeFatherMinus2.java b/src/class173/Code08_RangeFatherMinus2.java
new file mode 100644
index 000000000..ad04273aa
--- /dev/null
+++ b/src/class173/Code08_RangeFatherMinus2.java
@@ -0,0 +1,125 @@
+package class173;
+
+// 区间父变小，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1491H
+// 测试链接 : https://codeforces.com/problemset/problem/1491/H
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXB = 501;
+//int n, m;
+//int arr[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//int lazy[MAXB];
+//int outer[MAXN];
+//int cnt[MAXB];
+//
+//void innerUpdate(int b) {
+//    for (int i = bl[b]; i <= br[b]; i++) {
+//        arr[i] = max(1, arr[i] - lazy[b]);
+//    }
+//    lazy[b] = 0;
+//    for (int i = bl[b]; i <= br[b]; i++) {
+//        if (arr[i] < bl[b]) {
+//            outer[i] = arr[i];
+//        } else {
+//            outer[i] = outer[arr[i]];
+//        }
+//    }
+//}
+//
+//void update(int l, int r, int v) {
+//    if (bi[l] == bi[r]) {
+//        for (int i = l; i <= r; i++) {
+//            arr[i] = max(1, arr[i] - v);
+//        }
+//        innerUpdate(bi[l]);
+//    } else {
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            arr[i] = max(1, arr[i] - v);
+//        }
+//        innerUpdate(bi[l]);
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            arr[i] = max(1, arr[i] - v);
+//        }
+//        innerUpdate(bi[r]);
+//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
+//            lazy[i] = min(n, lazy[i] + v);
+//            if (++cnt[i] <= blen) {
+//                innerUpdate(i);
+//            }
+//        }
+//    }
+//}
+//
+//int jumpFa(int i) {
+//    return max(1, arr[i] - lazy[bi[i]]);
+//}
+//
+//int jumpOut(int i) { 
+//    return max(1, outer[i] - lazy[bi[i]]);
+//}
+//
+//int lca(int x, int y) {
+//    while (bi[x] != bi[y] || jumpOut(x) != jumpOut(y)) {
+//        if (bi[x] == bi[y]) {
+//            x = jumpOut(x);
+//            y = jumpOut(y);
+//        } else {
+//            if (bi[x] < bi[y]) {
+//                swap(x, y);
+//            }
+//            x = jumpOut(x);
+//        }
+//    }
+//    while (x != y) {
+//        if (x < y) {
+//            swap(x, y);
+//        }
+//        x = jumpFa(x);
+//    }
+//    return x;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//        innerUpdate(i);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 2; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 1) {
+//            cin >> z;
+//            update(x, y, z);
+//        } else {
+//            cout << lca(x, y) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 71e6f98ab6f6dbca3611d94b77f8caa83e08c386 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Jun 2025 20:08:48 +0800
Subject: [PATCH 1028/1712] modify code

---
 src/class173/Code01_Sequence1.java         |  6 ++++
 src/class173/Code01_Sequence2.java         |  6 ++++
 src/class173/Code02_Poker1.java            |  5 ++++
 src/class173/Code02_Poker2.java            |  5 ++++
 src/class173/Code03_Magnet1.java           | 34 ++++++++++++++++++----
 src/class173/Code03_Magnet2.java           | 10 +++++++
 src/class173/Code04_Inversion1.java        |  4 +++
 src/class173/Code04_Inversion2.java        |  4 +++
 src/class173/Code05_TreeBlockHld1.java     |  7 +++++
 src/class173/Code05_TreeBlockHld2.java     |  7 +++++
 src/class173/Code06_TreeBlockRandom1.java  |  7 +++++
 src/class173/Code06_TreeBlockRandom2.java  |  7 +++++
 src/class173/Code07_Royal1.java            |  9 ++++++
 src/class173/Code07_Royal2.java            |  9 ++++++
 src/class173/Code08_RangeFatherMinus1.java | 13 +++++++--
 src/class173/Code08_RangeFatherMinus2.java |  5 ++++
 16 files changed, 130 insertions(+), 8 deletions(-)

diff --git a/src/class173/Code01_Sequence1.java b/src/class173/Code01_Sequence1.java
index efb7bcf36..1ace32076 100644
--- a/src/class173/Code01_Sequence1.java
+++ b/src/class173/Code01_Sequence1.java
@@ -1,6 +1,12 @@
 package class173;
 
 // 序列，java版
+// 给定一个长度为n的数组arr，初始时刻认为是第0秒
+// 接下来发生m条操作，第i条操作发生在第i秒，操作类型如下
+// 操作 1 l r v : arr[l..r]范围上每个数加v，v可能是负数
+// 操作 2 x v   : 不包括当前这一秒，查询过去多少秒内，arr[x] >= v
+// 2 <= n、m <= 10^5
+// -10^9 <= 数组中的值 <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3863
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class173/Code01_Sequence2.java b/src/class173/Code01_Sequence2.java
index 006c649d2..f01340edb 100644
--- a/src/class173/Code01_Sequence2.java
+++ b/src/class173/Code01_Sequence2.java
@@ -1,6 +1,12 @@
 package class173;
 
 // 序列，C++版
+// 给定一个长度为n的数组arr，初始时刻认为是第0秒
+// 接下来发生m条操作，第i条操作发生在第i秒，操作类型如下
+// 操作 1 l r v : arr[l..r]范围上每个数加v，v可能是负数
+// 操作 2 x v   : 不包括当前这一秒，查询过去多少秒内，arr[x] >= v
+// 2 <= n、m <= 10^5
+// -10^9 <= 数组中的值 <= +10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3863
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class173/Code02_Poker1.java b/src/class173/Code02_Poker1.java
index 481c23d55..b9f96a845 100644
--- a/src/class173/Code02_Poker1.java
+++ b/src/class173/Code02_Poker1.java
@@ -1,6 +1,11 @@
 package class173;
 
 // 由乃打扑克，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，操作类型如下
+// 操作 1 l r v : 查询arr[l..r]范围上，第v小的数
+// 操作 2 l r v : arr[l..r]范围上每个数加v，v可能是负数
+// 1 <= n、m <= 10^5
+// -2 * 10^4 <= 数组中的值 <= +2 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P5356
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class173/Code02_Poker2.java b/src/class173/Code02_Poker2.java
index 3cc0466c9..a2e381ee7 100644
--- a/src/class173/Code02_Poker2.java
+++ b/src/class173/Code02_Poker2.java
@@ -1,6 +1,11 @@
 package class173;
 
 // 由乃打扑克，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，操作类型如下
+// 操作 1 l r v : 查询arr[l..r]范围上，第v小的数
+// 操作 2 l r v : arr[l..r]范围上每个数加v，v可能是负数
+// 1 <= n、m <= 10^5
+// -2 * 10^4 <= 数组中的值 <= +2 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P5356
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index cdeb09f55..c2ece0584 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -1,6 +1,16 @@
 package class173;
 
 // 磁力块，java版
+// 每个磁块有五个属性值，x、y、m、p、range
+// 表示磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
+// 磁块A可以把磁块B吸到磁块A的位置，需要满足如下的条件
+// A与B的距离不大于A的吸引半径，并且B的质量不大于A的磁力
+// 你有一个初始磁块，给定初始磁块属性值，你永远在初始磁块的位置
+// 接下来给定n个磁块各自的属性值，你可以用初始磁块，吸过来其中的磁块
+// 吸过来的磁块可以被你随意使用，返回你最多能吸过来多少磁块
+// 1 <= n <= 3 * 10^5
+// -10^9 <= x、y <= +10^9
+// 1 <= m、p、range <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
 // 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -36,13 +46,25 @@ public class Code03_Magnet1 {
 	// 下标为i的磁块和下标为j的磁块交换
 	public static void swap(int i, int j) {
 		int tmp1;
-		tmp1 = x[i]; x[i] = x[j]; x[j] = tmp1;
-		tmp1 = y[i]; y[i] = y[j]; y[j] = tmp1;
-		tmp1 = m[i]; m[i] = m[j]; m[j] = tmp1;
-		tmp1 = p[i]; p[i] = p[j]; p[j] = tmp1;
+		tmp1 = x[i];
+		x[i] = x[j];
+		x[j] = tmp1;
+		tmp1 = y[i];
+		y[i] = y[j];
+		y[j] = tmp1;
+		tmp1 = m[i];
+		m[i] = m[j];
+		m[j] = tmp1;
+		tmp1 = p[i];
+		p[i] = p[j];
+		p[j] = tmp1;
 		long tmp2;
-		tmp2 = range[i]; range[i] = range[j]; range[j] = tmp2;
-		tmp2 = dist[i]; dist[i] = dist[j]; dist[j] = tmp2;
+		tmp2 = range[i];
+		range[i] = range[j];
+		range[j] = tmp2;
+		tmp2 = dist[i];
+		dist[i] = dist[j];
+		dist[j] = tmp2;
 	}
 
 	// 所有磁块根据m值排序，手写双指针快排
diff --git a/src/class173/Code03_Magnet2.java b/src/class173/Code03_Magnet2.java
index 922ff1ebb..2cc692a9d 100644
--- a/src/class173/Code03_Magnet2.java
+++ b/src/class173/Code03_Magnet2.java
@@ -1,6 +1,16 @@
 package class173;
 
 // 磁力块，C++版
+// 每个磁块有五个属性值，x、y、m、p、range
+// 表示磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
+// 磁块A可以把磁块B吸到磁块A的位置，需要满足如下的条件
+// A与B的距离不大于A的吸引半径，并且B的质量不大于A的磁力
+// 你有一个初始磁块，给定初始磁块属性值，你永远在初始磁块的位置
+// 接下来给定n个磁块各自的属性值，你可以用初始磁块，吸过来其中的磁块
+// 吸过来的磁块可以被你随意使用，返回你最多能吸过来多少磁块
+// 1 <= n <= 3 * 10^5
+// -10^9 <= x、y <= +10^9
+// 1 <= m、p、range <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
 // 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index b50a47af2..a8c1c8531 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -1,6 +1,10 @@
 package class173;
 
 // 区间逆序对，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上的逆序对数量
+// 1 <= n、m <= 10^5
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5046
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是无法通过测试
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index a6fe80adf..824f4ae6a 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -1,6 +1,10 @@
 package class173;
 
 // 区间逆序对，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 操作 l r : 打印arr[l..r]范围上的逆序对数量
+// 1 <= n、m <= 10^5
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P5046
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class173/Code05_TreeBlockHld1.java b/src/class173/Code05_TreeBlockHld1.java
index 15c42f67b..cbe247e3d 100644
--- a/src/class173/Code05_TreeBlockHld1.java
+++ b/src/class173/Code05_TreeBlockHld1.java
@@ -1,6 +1,13 @@
 package class173;
 
 // 树上分块模版题，重链剖分 + 序列分块，java版
+// 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
+// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
+// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
+// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 1 <= n、m <= 10^5    点权 <= 30000
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class173/Code05_TreeBlockHld2.java b/src/class173/Code05_TreeBlockHld2.java
index 490ea2f81..60576d590 100644
--- a/src/class173/Code05_TreeBlockHld2.java
+++ b/src/class173/Code05_TreeBlockHld2.java
@@ -1,6 +1,13 @@
 package class173;
 
 // 树上分块模版题，重链剖分 + 序列分块，C++版
+// 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
+// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
+// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
+// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 1 <= n、m <= 10^5    点权 <= 30000
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index fbe307c70..ce05a56c8 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -1,6 +1,13 @@
 package class173;
 
 // 树上分块模版题，重链剖分 + 随机撒点，java版
+// 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
+// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
+// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
+// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 1 <= n、m <= 10^5    点权 <= 30000
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index 81c659e87..39bf30da9 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -1,6 +1,13 @@
 package class173;
 
 // 树上分块模版题，重链剖分 + 随机撒点，C++版
+// 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
+// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
+// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
+// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 1 <= n、m <= 10^5    点权 <= 30000
+// 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index ed7e7ae56..992cbbf91 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -1,6 +1,15 @@
 package class173;
 
 // 王室联邦，java版
+// 一共有n个城市，编号1~n，给定n-1条边，所有城市连成一棵树
+// 给定数值b，希望你把树划分成若干个联通区，也叫省，划分要求如下
+// 每个省至少要有b个城市，最多有3 * b个城市，每个省必须有一个省会
+// 省会可在省内也可在省外，一个城市可以是多个省的省会
+// 一个省里，任何城市到达省会的路径上，除了省会之外，其他的城市必须都在省内
+// 根据要求完成一种有效划分即可，先打印你划分了多少个省，假设数量为k
+// 然后打印n个数字，范围[1, k]，表示每个城市被划分给了哪个省
+// 最后打印k个数字，表示每个省会的城市编号
+// 1 <= n、b <= 10^3
 // 测试链接 : https://www.luogu.com.cn/problem/P2325
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
index 6028d2e1d..c3dbe210d 100644
--- a/src/class173/Code07_Royal2.java
+++ b/src/class173/Code07_Royal2.java
@@ -1,6 +1,15 @@
 package class173;
 
 // 王室联邦，C++版
+// 一共有n个城市，编号1~n，给定n-1条边，所有城市连成一棵树
+// 给定数值b，希望你把树划分成若干个联通区，也叫省，划分要求如下
+// 每个省至少要有b个城市，最多有3 * b个城市，每个省必须有一个省会
+// 省会可在省内也可在省外，一个城市可以是多个省的省会
+// 一个省里，任何城市到达省会的路径上，除了省会之外，其他的城市必须都在省内
+// 根据要求完成一种有效划分即可，先打印你划分了多少个省，假设数量为k
+// 然后打印n个数字，范围[1, k]，表示每个城市被划分给了哪个省
+// 最后打印k个数字，表示每个省会的城市编号
+// 1 <= n、b <= 10^3
 // 测试链接 : https://www.luogu.com.cn/problem/P2325
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class173/Code08_RangeFatherMinus1.java b/src/class173/Code08_RangeFatherMinus1.java
index ceed9de21..580c3e348 100644
--- a/src/class173/Code08_RangeFatherMinus1.java
+++ b/src/class173/Code08_RangeFatherMinus1.java
@@ -1,6 +1,11 @@
 package class173;
 
 // 区间父变小，java版
+// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，2 <= i <= n
+// 接下来有m条操作，每种操作是如下两种类型中的一种
+// 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
+// 操作 x y   : 查询点x和点y的最低公共祖先
+// 2 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1491H
 // 测试链接 : https://codeforces.com/problemset/problem/1491/H
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -79,14 +84,18 @@ public static int lca(int x, int y) {
 				y = jumpOut(y);
 			} else {
 				if (bi[x] < bi[y]) {
-					int tmp = x; x = y; y = tmp;
+					int tmp = x;
+					x = y;
+					y = tmp;
 				}
 				x = jumpOut(x);
 			}
 		}
 		while (x != y) {
 			if (x < y) {
-				int tmp = x; x = y; y = tmp;
+				int tmp = x;
+				x = y;
+				y = tmp;
 			}
 			x = jumpFa(x);
 		}
diff --git a/src/class173/Code08_RangeFatherMinus2.java b/src/class173/Code08_RangeFatherMinus2.java
index ad04273aa..08b6f0a1d 100644
--- a/src/class173/Code08_RangeFatherMinus2.java
+++ b/src/class173/Code08_RangeFatherMinus2.java
@@ -1,6 +1,11 @@
 package class173;
 
 // 区间父变小，C++版
+// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，2 <= i <= n
+// 接下来有m条操作，每种操作是如下两种类型中的一种
+// 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
+// 操作 x y   : 查询点x和点y的最低公共祖先
+// 2 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1491H
 // 测试链接 : https://codeforces.com/problemset/problem/1491/H
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From cb3ee6608648da2fe3b70410257cdf29320d60cd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Jun 2025 20:10:27 +0800
Subject: [PATCH 1029/1712] modify code

---
 src/class173/Code08_RangeFatherMinus1.java | 2 +-
 src/class173/Code08_RangeFatherMinus2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code08_RangeFatherMinus1.java b/src/class173/Code08_RangeFatherMinus1.java
index 580c3e348..6a9ef3778 100644
--- a/src/class173/Code08_RangeFatherMinus1.java
+++ b/src/class173/Code08_RangeFatherMinus1.java
@@ -1,7 +1,7 @@
 package class173;
 
 // 区间父变小，java版
-// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，2 <= i <= n
+// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，给定arr[2..n]
 // 接下来有m条操作，每种操作是如下两种类型中的一种
 // 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
 // 操作 x y   : 查询点x和点y的最低公共祖先
diff --git a/src/class173/Code08_RangeFatherMinus2.java b/src/class173/Code08_RangeFatherMinus2.java
index 08b6f0a1d..6f85ac6b1 100644
--- a/src/class173/Code08_RangeFatherMinus2.java
+++ b/src/class173/Code08_RangeFatherMinus2.java
@@ -1,7 +1,7 @@
 package class173;
 
 // 区间父变小，C++版
-// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，2 <= i <= n
+// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，给定arr[2..n]
 // 接下来有m条操作，每种操作是如下两种类型中的一种
 // 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
 // 操作 x y   : 查询点x和点y的最低公共祖先

From 1525cd278b8a0fd8e9f6ea055684589b3b238527 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Jun 2025 20:12:52 +0800
Subject: [PATCH 1030/1712] modify code

---
 src/class173/Code07_Royal1.java | 2 +-
 src/class173/Code07_Royal2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index 992cbbf91..9554a8f75 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -5,7 +5,7 @@
 // 给定数值b，希望你把树划分成若干个联通区，也叫省，划分要求如下
 // 每个省至少要有b个城市，最多有3 * b个城市，每个省必须有一个省会
 // 省会可在省内也可在省外，一个城市可以是多个省的省会
-// 一个省里，任何城市到达省会的路径上，除了省会之外，其他的城市必须都在省内
+// 一个省里，任何城市到达省会的路径上，除了省会之外的其他城市，必须都在省内
 // 根据要求完成一种有效划分即可，先打印你划分了多少个省，假设数量为k
 // 然后打印n个数字，范围[1, k]，表示每个城市被划分给了哪个省
 // 最后打印k个数字，表示每个省会的城市编号
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
index c3dbe210d..47e0fa9f8 100644
--- a/src/class173/Code07_Royal2.java
+++ b/src/class173/Code07_Royal2.java
@@ -5,7 +5,7 @@
 // 给定数值b，希望你把树划分成若干个联通区，也叫省，划分要求如下
 // 每个省至少要有b个城市，最多有3 * b个城市，每个省必须有一个省会
 // 省会可在省内也可在省外，一个城市可以是多个省的省会
-// 一个省里，任何城市到达省会的路径上，除了省会之外，其他的城市必须都在省内
+// 一个省里，任何城市到达省会的路径上，除了省会之外的其他城市，必须都在省内
 // 根据要求完成一种有效划分即可，先打印你划分了多少个省，假设数量为k
 // 然后打印n个数字，范围[1, k]，表示每个城市被划分给了哪个省
 // 最后打印k个数字，表示每个省会的城市编号

From 1257702edf377ab89220fc20469a72fcc620ac22 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Jun 2025 20:16:54 +0800
Subject: [PATCH 1031/1712] modify code

---
 src/class173/Code05_TreeBlockHld1.java    | 6 +++---
 src/class173/Code05_TreeBlockHld2.java    | 6 +++---
 src/class173/Code06_TreeBlockRandom1.java | 6 +++---
 src/class173/Code06_TreeBlockRandom2.java | 6 +++---
 4 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class173/Code05_TreeBlockHld1.java b/src/class173/Code05_TreeBlockHld1.java
index cbe247e3d..5068e3357 100644
--- a/src/class173/Code05_TreeBlockHld1.java
+++ b/src/class173/Code05_TreeBlockHld1.java
@@ -2,10 +2,10 @@
 
 // 树上分块模版题，重链剖分 + 序列分块，java版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
-// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
-// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 接下来有m条操作，每条操作都要打印两个答案，描述如下
+// 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
-// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
 // 1 <= n、m <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
diff --git a/src/class173/Code05_TreeBlockHld2.java b/src/class173/Code05_TreeBlockHld2.java
index 60576d590..e26bf2c2b 100644
--- a/src/class173/Code05_TreeBlockHld2.java
+++ b/src/class173/Code05_TreeBlockHld2.java
@@ -2,10 +2,10 @@
 
 // 树上分块模版题，重链剖分 + 序列分块，C++版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
-// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
-// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 接下来有m条操作，每条操作都要打印两个答案，描述如下
+// 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
-// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
 // 1 <= n、m <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index ce05a56c8..0a58275c9 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -2,10 +2,10 @@
 
 // 树上分块模版题，重链剖分 + 随机撒点，java版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
-// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
-// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 接下来有m条操作，每条操作都要打印两个答案，描述如下
+// 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
-// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
 // 1 <= n、m <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index 39bf30da9..9c6606b1a 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -2,10 +2,10 @@
 
 // 树上分块模版题，重链剖分 + 随机撒点，C++版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
-// 接下来由m条操作，每条操作都要打印两个答案，操作类型如下
-// 操作 k x1 y1 x2 y2 ..(一共k个点对) 
+// 接下来有m条操作，每条操作都要打印两个答案，描述如下
+// 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
-// 先打印k条路径总共有多少个不同的点权，再打印其中没有出现的最小非负整数(mex)
+// 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
 // 1 <= n、m <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603

From 7ba34feaff806dbb0526537ee9000533220f50df Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Jun 2025 20:50:18 +0800
Subject: [PATCH 1032/1712] modify code

---
 src/class173/Code05_TreeBlockHld1.java    |   2 +-
 src/class173/Code05_TreeBlockHld2.java    |   2 +-
 src/class173/Code06_TreeBlockRandom1.java | 167 ++++++++--------------
 src/class173/Code06_TreeBlockRandom2.java |  75 ++++------
 4 files changed, 91 insertions(+), 155 deletions(-)

diff --git a/src/class173/Code05_TreeBlockHld1.java b/src/class173/Code05_TreeBlockHld1.java
index 5068e3357..3460b05ae 100644
--- a/src/class173/Code05_TreeBlockHld1.java
+++ b/src/class173/Code05_TreeBlockHld1.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链剖分 + 序列分块，java版
+// 树上分块模版题，重链序列分块，java版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
 // 接下来有m条操作，每条操作都要打印两个答案，描述如下
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
diff --git a/src/class173/Code05_TreeBlockHld2.java b/src/class173/Code05_TreeBlockHld2.java
index e26bf2c2b..66f1790f3 100644
--- a/src/class173/Code05_TreeBlockHld2.java
+++ b/src/class173/Code05_TreeBlockHld2.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链剖分 + 序列分块，C++版
+// 树上分块模版题，重链序列分块，C++版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
 // 接下来有m条操作，每条操作都要打印两个答案，描述如下
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index 0a58275c9..d49c23c16 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链剖分 + 随机撒点，java版
+// 树上分块模版题，随机撒点分块，java版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
 // 接下来有m条操作，每条操作都要打印两个答案，描述如下
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
@@ -21,6 +21,7 @@ public class Code06_TreeBlockRandom1 {
 	public static int MAXN = 100001;
 	public static int MAXB = 301;
 	public static int MAXV = 30001;
+	public static int LIMIT = 17;
 	public static int n, m, f, k;
 	public static int[] arr = new int[MAXN];
 
@@ -30,12 +31,9 @@ public class Code06_TreeBlockRandom1 {
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
-	// 重链剖分
-	public static int[] fa = new int[MAXN];
+	// 树上倍增
 	public static int[] dep = new int[MAXN];
-	public static int[] siz = new int[MAXN];
-	public static int[] son = new int[MAXN];
-	public static int[] top = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][LIMIT];
 
 	// 随机撒点
 	public static int bnum;
@@ -101,136 +99,90 @@ public static void addEdge(int u, int v) {
 		head[u] = cntg;
 	}
 
-	public static void dfs1(int u, int f) {
-		fa[u] = f;
-		dep[u] = dep[f] + 1;
-		siz[u] = 1;
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				dfs1(v, u);
-			}
-		}
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != f) {
-				siz[u] += siz[v];
-				if (son[u] == 0 || siz[son[u]] < siz[v]) {
-					son[u] = v;
-				}
-			}
-		}
-	}
-
-	public static void dfs2(int u, int t) {
-		top[u] = t;
-		if (son[u] == 0) {
-			return;
+	// 树上倍增递归版
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < LIMIT; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 		}
-		dfs2(son[u], t);
-		for (int e = head[u], v; e > 0; e = next[e]) {
-			v = to[e];
-			if (v != fa[u] && v != son[u]) {
-				dfs2(v, v);
+		for (int e = head[u]; e != 0; e = next[e]) {
+			if (to[e] != fa) {
+				dfs1(to[e], u);
 			}
 		}
 	}
 
-	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
-	public static int[][] fse = new int[MAXN][3];
+	// 树上倍增迭代版
+	public static int[][] ufe = new int[MAXN][3];
 
-	public static int stacksize, first, second, edge;
+	public static int stackSize, cur, fath, edge;
 
-	public static void push(int fir, int sec, int edg) {
-		fse[stacksize][0] = fir;
-		fse[stacksize][1] = sec;
-		fse[stacksize][2] = edg;
-		stacksize++;
+	public static void push(int u, int f, int e) {
+		ufe[stackSize][0] = u;
+		ufe[stackSize][1] = f;
+		ufe[stackSize][2] = e;
+		stackSize++;
 	}
 
 	public static void pop() {
-		--stacksize;
-		first = fse[stacksize][0];
-		second = fse[stacksize][1];
-		edge = fse[stacksize][2];
+		--stackSize;
+		cur = ufe[stackSize][0];
+		fath = ufe[stackSize][1];
+		edge = ufe[stackSize][2];
 	}
 
-	// dfs1的迭代版
-	public static void dfs3() {
-		stacksize = 0;
+	public static void dfs2() {
+		stackSize = 0;
 		push(1, 0, -1);
-		while (stacksize > 0) {
-			pop();
-			if (edge == -1) {
-				fa[first] = second;
-				dep[first] = dep[second] + 1;
-				siz[first] = 1;
-				edge = head[first];
-			} else {
-				edge = next[edge];
-			}
-			if (edge != 0) {
-				push(first, second, edge);
-				if (to[edge] != second) {
-					push(to[edge], first, -1);
-				}
-			} else {
-				for (int e = head[first], v; e > 0; e = next[e]) {
-					v = to[e];
-					if (v != second) {
-						siz[first] += siz[v];
-						if (son[first] == 0 || siz[son[first]] < siz[v]) {
-							son[first] = v;
-						}
-					}
-				}
-			}
-		}
-	}
-
-	// dfs2的迭代版
-	public static void dfs4() {
-		stacksize = 0;
-		push(1, 1, -1);
-		while (stacksize > 0) {
+		while (stackSize > 0) {
 			pop();
 			if (edge == -1) {
-				top[first] = second;
-				if (son[first] == 0) {
-					continue;
+				dep[cur] = dep[fath] + 1;
+				stjump[cur][0] = fath;
+				for (int p = 1; p < LIMIT; p++) {
+					stjump[cur][p] = stjump[stjump[cur][p - 1]][p - 1];
 				}
-				push(first, second, -2);
-				push(son[first], second, -1);
-				continue;
-			} else if (edge == -2) {
-				edge = head[first];
+				edge = head[cur];
 			} else {
 				edge = next[edge];
 			}
 			if (edge != 0) {
-				push(first, second, edge);
-				if (to[edge] != fa[first] && to[edge] != son[first]) {
-					push(to[edge], to[edge], -1);
+				push(cur, fath, edge);
+				if (to[edge] != fath) {
+					push(to[edge], cur, -1);
 				}
 			}
 		}
 	}
 
 	public static int lca(int a, int b) {
-		while (top[a] != top[b]) {
-			if (dep[top[a]] <= dep[top[b]]) {
-				b = fa[top[b]];
-			} else {
-				a = fa[top[a]];
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = LIMIT - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = LIMIT - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
 			}
 		}
-		return dep[a] <= dep[b] ? a : b;
+		return stjump[a][0];
 	}
 
 	public static void query(int x, int xylca) {
 		while (spe[x] == 0 && x != xylca) {
 			ans.setOne(arr[x]);
-			x = fa[x];
+			x = stjump[x][0];
 		}
 		int backup = x;
 		while (up[x] > 0 && dep[up[x]] > dep[xylca]) {
@@ -239,7 +191,7 @@ public static void query(int x, int xylca) {
 		ans.or(bitSet[spe[backup]][spe[x]]);
 		while (x != xylca) {
 			ans.setOne(arr[x]);
-			x = fa[x];
+			x = stjump[x][0];
 		}
 	}
 
@@ -251,8 +203,7 @@ public static void updateAns(int x, int y) {
 	}
 
 	public static void prepare() {
-		dfs3();
-		dfs4();
+		dfs2();
 		int blen = (int) Math.sqrt(20.0 * n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1, pick; i <= bnum; i++) {
@@ -271,7 +222,7 @@ public static void prepare() {
 		for (int i = 1, cur; i <= bnum; i++) {
 			tmp.clear();
 			tmp.setOne(arr[tag[i]]);
-			cur = fa[tag[i]];
+			cur = stjump[tag[i]][0];
 			while (cur != 0) {
 				tmp.setOne(arr[cur]);
 				if (spe[cur] > 0) {
@@ -280,7 +231,7 @@ public static void prepare() {
 						up[tag[i]] = cur;
 					}
 				}
-				cur = fa[cur];
+				cur = stjump[cur][0];
 			}
 		}
 	}
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index 9c6606b1a..e1e4e7161 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，重链剖分 + 随机撒点，C++版
+// 树上分块模版题，随机撒点分块，C++版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
 // 接下来有m条操作，每条操作都要打印两个答案，描述如下
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
@@ -19,6 +19,7 @@
 //const int MAXN = 100001;
 //const int MAXB = 301;
 //const int MAXV = 30001;
+//const int LIMIT = 17;
 //int n, m, f, k;
 //int arr[MAXN];
 //
@@ -27,11 +28,8 @@
 //int to[MAXN << 1];
 //int cntg;
 //
-//int fa[MAXN];
 //int dep[MAXN];
-//int siz[MAXN];
-//int son[MAXN];
-//int top[MAXN];
+//int stjump[MAXN][LIMIT];
 //
 //int bnum;
 //bool vis[MAXN];
@@ -49,56 +47,44 @@
 //    head[u] = cntg;
 //}
 //
-//void dfs1(int u, int f) {
-//    fa[u] = f;
-//    dep[u] = dep[f] + 1;
-//    siz[u] = 1;
-//    for (int e = head[u], v; e; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            dfs1(v, u);
-//        }
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < LIMIT; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 //    }
-//    for (int e = head[u], v; e; e = nxt[e]) {
-//        v = to[e];
-//        if (v != f) {
-//            siz[u] += siz[v];
-//            if (son[u] == 0 || siz[son[u]] < siz[v]) {
-//                son[u] = v;
-//            }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        if (to[e] != fa) {
+//            dfs(to[e], u);
 //        }
 //    }
 //}
 //
-//void dfs2(int u, int t) {
-//    top[u] = t;
-//    if (!son[u]) {
-//        return;
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
 //    }
-//    dfs2(son[u], t);
-//    for (int e = head[u], v; e; e = nxt[e]) {
-//        v = to[e];
-//        if (v != fa[u] && v != son[u]) {
-//            dfs2(v, v);
+//    for (int p = LIMIT - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
 //        }
 //    }
-//}
-//
-//int lca(int a, int b) {
-//    while (top[a] != top[b]) {
-//        if (dep[top[a]] <= dep[top[b]]) {
-//            b = fa[top[b]];
-//        } else {
-//            a = fa[top[a]];
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = LIMIT - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
 //        }
 //    }
-//    return dep[a] <= dep[b] ? a : b;
+//    return stjump[a][0];
 //}
 //
 //void query(int x, int xylca) {
 //    while (spe[x] == 0 && x != xylca) {
 //    	ans[arr[x]] = 1;
-//        x = fa[x];
+//        x = stjump[x][0];
 //    }
 //    int backup = x;
 //    while (up[x] && dep[up[x]] > dep[xylca]) {
@@ -107,7 +93,7 @@
 //    ans |= bitSet[spe[backup]][spe[x]];
 //    while (x != xylca) {
 //    	ans[arr[x]] = 1;
-//        x = fa[x];
+//        x = stjump[x][0];
 //    }
 //}
 //
@@ -119,8 +105,7 @@
 //}
 //
 //void prepare() {
-//    dfs1(1, 0);
-//    dfs2(1, 1);
+//    dfs(1, 0);
 //    int blen = (int)sqrt(20.0 * n);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1, pick; i <= bnum; i++) {
@@ -134,7 +119,7 @@
 //    for (int i = 1, cur; i <= bnum; i++) {
 //        tmp.reset();
 //        tmp[arr[tag[i]]] = 1;
-//        cur = fa[tag[i]];
+//        cur = stjump[tag[i]][0];
 //        while (cur != 0) {
 //            tmp[arr[cur]] = 1;
 //            if (spe[cur] > 0) {
@@ -143,7 +128,7 @@
 //                    up[tag[i]] = cur;
 //                }
 //            }
-//            cur = fa[cur];
+//            cur = stjump[cur][0];
 //        }
 //    }	
 //}

From 0d82a145185ccd794ee6c53f99307617ec6b1e64 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 25 Jun 2025 21:05:21 +0800
Subject: [PATCH 1033/1712] modify code

---
 src/class173/Code06_TreeBlockRandom1.java | 30 +++++++++++------------
 src/class173/Code06_TreeBlockRandom2.java | 30 +++++++++++------------
 2 files changed, 30 insertions(+), 30 deletions(-)

diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index d49c23c16..3cd48254e 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -38,9 +38,9 @@ public class Code06_TreeBlockRandom1 {
 	// 随机撒点
 	public static int bnum;
 	public static boolean[] vis = new boolean[MAXN];
-	public static int[] tag = new int[MAXN];
-	public static int[] spe = new int[MAXN];
-	public static int[] up = new int[MAXN];
+	public static int[] capital = new int[MAXN];
+	public static int[] belong = new int[MAXN];
+	public static int[] top = new int[MAXN];
 	public static BitSet[][] bitSet = new BitSet[MAXB][MAXB];
 
 	public static BitSet tmp = new BitSet();
@@ -180,15 +180,15 @@ public static int lca(int a, int b) {
 	}
 
 	public static void query(int x, int xylca) {
-		while (spe[x] == 0 && x != xylca) {
+		while (belong[x] == 0 && x != xylca) {
 			ans.setOne(arr[x]);
 			x = stjump[x][0];
 		}
 		int backup = x;
-		while (up[x] > 0 && dep[up[x]] > dep[xylca]) {
-			x = up[x];
+		while (top[x] > 0 && dep[top[x]] > dep[xylca]) {
+			x = top[x];
 		}
-		ans.or(bitSet[spe[backup]][spe[x]]);
+		ans.or(bitSet[belong[backup]][belong[x]]);
 		while (x != xylca) {
 			ans.setOne(arr[x]);
 			x = stjump[x][0];
@@ -211,8 +211,8 @@ public static void prepare() {
 				pick = (int) (Math.random() * n) + 1;
 			} while (vis[pick]);
 			vis[pick] = true;
-			tag[i] = pick;
-			spe[pick] = i;
+			capital[i] = pick;
+			belong[pick] = i;
 		}
 		for (int i = 0; i <= bnum; i++) {
 			for (int j = 0; j <= bnum; j++) {
@@ -221,14 +221,14 @@ public static void prepare() {
 		}
 		for (int i = 1, cur; i <= bnum; i++) {
 			tmp.clear();
-			tmp.setOne(arr[tag[i]]);
-			cur = stjump[tag[i]][0];
+			tmp.setOne(arr[capital[i]]);
+			cur = stjump[capital[i]][0];
 			while (cur != 0) {
 				tmp.setOne(arr[cur]);
-				if (spe[cur] > 0) {
-					bitSet[i][spe[cur]].or(tmp);
-					if (up[tag[i]] == 0) {
-						up[tag[i]] = cur;
+				if (belong[cur] > 0) {
+					bitSet[i][belong[cur]].or(tmp);
+					if (top[capital[i]] == 0) {
+						top[capital[i]] = cur;
 					}
 				}
 				cur = stjump[cur][0];
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index e1e4e7161..26b61f3ef 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -33,9 +33,9 @@
 //
 //int bnum;
 //bool vis[MAXN];
-//int tag[MAXN];
-//int spe[MAXN];
-//int up[MAXN];
+//int capital[MAXN];
+//int belong[MAXN];
+//int top[MAXN];
 //bitset<MAXV> bitSet[MAXB][MAXB];
 //
 //bitset<MAXV> tmp;
@@ -82,15 +82,15 @@
 //}
 //
 //void query(int x, int xylca) {
-//    while (spe[x] == 0 && x != xylca) {
+//    while (belong[x] == 0 && x != xylca) {
 //    	ans[arr[x]] = 1;
 //        x = stjump[x][0];
 //    }
 //    int backup = x;
-//    while (up[x] && dep[up[x]] > dep[xylca]) {
-//        x = up[x];
+//    while (top[x] && dep[top[x]] > dep[xylca]) {
+//        x = top[x];
 //    }
-//    ans |= bitSet[spe[backup]][spe[x]];
+//    ans |= bitSet[belong[backup]][belong[x]];
 //    while (x != xylca) {
 //    	ans[arr[x]] = 1;
 //        x = stjump[x][0];
@@ -113,19 +113,19 @@
 //            pick = rand() % n + 1;
 //        } while (vis[pick]);
 //        vis[pick] = true;
-//        tag[i] = pick;
-//        spe[pick] = i;
+//        capital[i] = pick;
+//        belong[pick] = i;
 //    }
 //    for (int i = 1, cur; i <= bnum; i++) {
 //        tmp.reset();
-//        tmp[arr[tag[i]]] = 1;
-//        cur = stjump[tag[i]][0];
+//        tmp[arr[capital[i]]] = 1;
+//        cur = stjump[capital[i]][0];
 //        while (cur != 0) {
 //            tmp[arr[cur]] = 1;
-//            if (spe[cur] > 0) {
-//                bitSet[i][spe[cur]] |= tmp;
-//                if (up[tag[i]] == 0) {
-//                    up[tag[i]] = cur;
+//            if (belong[cur] > 0) {
+//                bitSet[i][belong[cur]] |= tmp;
+//                if (top[capital[i]] == 0) {
+//                    top[capital[i]] = cur;
 //                }
 //            }
 //            cur = stjump[cur][0];

From 66571cd8436b94e3157b935d36c3a904f77e5a36 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 28 Jun 2025 09:19:35 +0800
Subject: [PATCH 1034/1712] modify code

---
 src/class173/Code06_TreeBlockRandom1.java | 47 ++++++++++++++---------
 src/class173/Code06_TreeBlockRandom2.java | 35 +++++++++--------
 2 files changed, 46 insertions(+), 36 deletions(-)

diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index 3cd48254e..5ad75b0d8 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -35,12 +35,21 @@ public class Code06_TreeBlockRandom1 {
 	public static int[] dep = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][LIMIT];
 
-	// 随机撒点
+	// 随机撒点，预处理过程需要
+	// bnum表示块的数量，也表示会有几个点被选为代表点
 	public static int bnum;
+	// vis[i]表示i号点是否已经选为某个块的代表点
 	public static boolean[] vis = new boolean[MAXN];
-	public static int[] capital = new int[MAXN];
-	public static int[] belong = new int[MAXN];
-	public static int[] top = new int[MAXN];
+	// capital[i]表示第i块的代表节点
+	public static int[] capital = new int[MAXB];
+
+	// 随机撒点，预处理之后生成的信息
+	// repBlock[i] = j，表示i号节点是第j块的代表
+	// repBlock[i] = 0，表示i号节点不是任何块的代表
+	public static int[] repBlock = new int[MAXN];
+	// up[i] = j，表示i号节点是某块的代表，它往上跳到最近的代表点是j
+	public static int[] up = new int[MAXN];
+	// bitSet[i][j]，表示第i块代表点往上走到第j块的代表点，沿途所有点权组成的位图
 	public static BitSet[][] bitSet = new BitSet[MAXB][MAXB];
 
 	public static BitSet tmp = new BitSet();
@@ -180,15 +189,15 @@ public static int lca(int a, int b) {
 	}
 
 	public static void query(int x, int xylca) {
-		while (belong[x] == 0 && x != xylca) {
+		while (repBlock[x] == 0 && x != xylca) {
 			ans.setOne(arr[x]);
 			x = stjump[x][0];
 		}
-		int backup = x;
-		while (top[x] > 0 && dep[top[x]] > dep[xylca]) {
-			x = top[x];
+		int from = x;
+		while (up[x] > 0 && dep[up[x]] > dep[xylca]) {
+			x = up[x];
 		}
-		ans.or(bitSet[belong[backup]][belong[x]]);
+		ans.or(bitSet[repBlock[from]][repBlock[x]]);
 		while (x != xylca) {
 			ans.setOne(arr[x]);
 			x = stjump[x][0];
@@ -206,29 +215,29 @@ public static void prepare() {
 		dfs2();
 		int blen = (int) Math.sqrt(20.0 * n);
 		bnum = (n + blen - 1) / blen;
-		for (int i = 1, pick; i <= bnum; i++) {
+		for (int b = 1, pick; b <= bnum; b++) {
 			do {
 				pick = (int) (Math.random() * n) + 1;
 			} while (vis[pick]);
 			vis[pick] = true;
-			capital[i] = pick;
-			belong[pick] = i;
+			capital[b] = pick;
+			repBlock[pick] = b;
 		}
 		for (int i = 0; i <= bnum; i++) {
 			for (int j = 0; j <= bnum; j++) {
 				bitSet[i][j] = new BitSet();
 			}
 		}
-		for (int i = 1, cur; i <= bnum; i++) {
+		for (int b = 1, cur; b <= bnum; b++) {
 			tmp.clear();
-			tmp.setOne(arr[capital[i]]);
-			cur = stjump[capital[i]][0];
+			tmp.setOne(arr[capital[b]]);
+			cur = stjump[capital[b]][0];
 			while (cur != 0) {
 				tmp.setOne(arr[cur]);
-				if (belong[cur] > 0) {
-					bitSet[i][belong[cur]].or(tmp);
-					if (top[capital[i]] == 0) {
-						top[capital[i]] = cur;
+				if (repBlock[cur] > 0) {
+					bitSet[b][repBlock[cur]].or(tmp);
+					if (up[capital[b]] == 0) {
+						up[capital[b]] = cur;
 					}
 				}
 				cur = stjump[cur][0];
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index 26b61f3ef..a4129b606 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -34,8 +34,9 @@
 //int bnum;
 //bool vis[MAXN];
 //int capital[MAXN];
-//int belong[MAXN];
-//int top[MAXN];
+//
+//int repBlock[MAXN];
+//int up[MAXN];
 //bitset<MAXV> bitSet[MAXB][MAXB];
 //
 //bitset<MAXV> tmp;
@@ -82,15 +83,15 @@
 //}
 //
 //void query(int x, int xylca) {
-//    while (belong[x] == 0 && x != xylca) {
+//    while (repBlock[x] == 0 && x != xylca) {
 //    	ans[arr[x]] = 1;
 //        x = stjump[x][0];
 //    }
-//    int backup = x;
-//    while (top[x] && dep[top[x]] > dep[xylca]) {
-//        x = top[x];
+//    int from = x;
+//    while (up[x] && dep[up[x]] > dep[xylca]) {
+//        x = up[x];
 //    }
-//    ans |= bitSet[belong[backup]][belong[x]];
+//    ans |= bitSet[repBlock[from]][repBlock[x]];
 //    while (x != xylca) {
 //    	ans[arr[x]] = 1;
 //        x = stjump[x][0];
@@ -108,24 +109,24 @@
 //    dfs(1, 0);
 //    int blen = (int)sqrt(20.0 * n);
 //    bnum = (n + blen - 1) / blen;
-//    for (int i = 1, pick; i <= bnum; i++) {
+//    for (int b = 1, pick; b <= bnum; b++) {
 //        do {
 //            pick = rand() % n + 1;
 //        } while (vis[pick]);
 //        vis[pick] = true;
-//        capital[i] = pick;
-//        belong[pick] = i;
+//        capital[b] = pick;
+//        repBlock[pick] = b;
 //    }
-//    for (int i = 1, cur; i <= bnum; i++) {
+//    for (int b = 1, cur; b <= bnum; b++) {
 //        tmp.reset();
-//        tmp[arr[capital[i]]] = 1;
-//        cur = stjump[capital[i]][0];
+//        tmp[arr[capital[b]]] = 1;
+//        cur = stjump[capital[b]][0];
 //        while (cur != 0) {
 //            tmp[arr[cur]] = 1;
-//            if (belong[cur] > 0) {
-//                bitSet[i][belong[cur]] |= tmp;
-//                if (top[capital[i]] == 0) {
-//                    top[capital[i]] = cur;
+//            if (repBlock[cur] > 0) {
+//                bitSet[b][repBlock[cur]] |= tmp;
+//                if (up[capital[b]] == 0) {
+//                    up[capital[b]] = cur;
 //                }
 //            }
 //            cur = stjump[cur][0];

From b948ac5d8f70b3ca00cfecbc4b7222ff51d31fd0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 28 Jun 2025 09:37:31 +0800
Subject: [PATCH 1035/1712] modify code

---
 src/class173/Code05_TreeBlockHld1.java | 2 +-
 src/class173/Code05_TreeBlockHld2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code05_TreeBlockHld1.java b/src/class173/Code05_TreeBlockHld1.java
index 3460b05ae..e6f7080a4 100644
--- a/src/class173/Code05_TreeBlockHld1.java
+++ b/src/class173/Code05_TreeBlockHld1.java
@@ -6,7 +6,7 @@
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
 // 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
-// 1 <= n、m <= 10^5    点权 <= 30000
+// 1 <= n、点对总数 <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class173/Code05_TreeBlockHld2.java b/src/class173/Code05_TreeBlockHld2.java
index 66f1790f3..03d539faf 100644
--- a/src/class173/Code05_TreeBlockHld2.java
+++ b/src/class173/Code05_TreeBlockHld2.java
@@ -6,7 +6,7 @@
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
 // 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
-// 1 <= n、m <= 10^5    点权 <= 30000
+// 1 <= n、点对总数 <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From bf03507b6a5f9e08a49784d1ead5385a058f8613 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 28 Jun 2025 11:13:22 +0800
Subject: [PATCH 1036/1712] modify code

---
 src/class173/Code03_Magnet1.java | 24 ++++++------------------
 src/class173/Code07_Royal1.java  |  8 ++++----
 src/class173/Code07_Royal2.java  |  8 ++++----
 3 files changed, 14 insertions(+), 26 deletions(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index c2ece0584..2f586d221 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -46,25 +46,13 @@ public class Code03_Magnet1 {
 	// 下标为i的磁块和下标为j的磁块交换
 	public static void swap(int i, int j) {
 		int tmp1;
-		tmp1 = x[i];
-		x[i] = x[j];
-		x[j] = tmp1;
-		tmp1 = y[i];
-		y[i] = y[j];
-		y[j] = tmp1;
-		tmp1 = m[i];
-		m[i] = m[j];
-		m[j] = tmp1;
-		tmp1 = p[i];
-		p[i] = p[j];
-		p[j] = tmp1;
+		tmp1 = x[i]; x[i] = x[j]; x[j] = tmp1;
+		tmp1 = y[i]; y[i] = y[j]; y[j] = tmp1;
+		tmp1 = m[i]; m[i] = m[j]; m[j] = tmp1;
+		tmp1 = p[i]; p[i] = p[j]; p[j] = tmp1;
 		long tmp2;
-		tmp2 = range[i];
-		range[i] = range[j];
-		range[j] = tmp2;
-		tmp2 = dist[i];
-		dist[i] = dist[j];
-		dist[j] = tmp2;
+		tmp2 = range[i]; range[i] = range[j]; range[j] = tmp2;
+		tmp2 = dist[i]; dist[i] = dist[j]; dist[j] = tmp2;
 	}
 
 	// 所有磁块根据m值排序，手写双指针快排
diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index 9554a8f75..601d6ae09 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -28,7 +28,7 @@ public class Code07_Royal1 {
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg;
 
-	public static int[] root = new int[MAXN];
+	public static int[] capital = new int[MAXN];
 	public static int[] belong = new int[MAXN];
 	public static int[] stack = new int[MAXN];
 	public static int siz;
@@ -47,7 +47,7 @@ public static void dfs(int u, int f) {
 			if (v != f) {
 				dfs(v, u);
 				if (siz - tmp >= b) {
-					root[++cntb] = u;
+					capital[++cntb] = u;
 					while (siz > tmp) {
 						belong[stack[siz--]] = cntb;
 					}
@@ -70,7 +70,7 @@ public static void main(String[] args) throws IOException {
 		}
 		dfs(1, 0);
 		if (cntb == 0) {
-			root[++cntb] = 1;
+			capital[++cntb] = 1;
 		}
 		while (siz > 0) {
 			belong[stack[siz--]] = cntb;
@@ -81,7 +81,7 @@ public static void main(String[] args) throws IOException {
 		}
 		out.println();
 		for (int i = 1; i <= cntb; i++) {
-			out.print(root[i] + " ");
+			out.print(capital[i] + " ");
 		}
 		out.println();
 		out.flush();
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
index 47e0fa9f8..9e67bbd8e 100644
--- a/src/class173/Code07_Royal2.java
+++ b/src/class173/Code07_Royal2.java
@@ -26,7 +26,7 @@
 //int to[MAXN << 1];
 //int cntg;
 //
-//int root[MAXN];
+//int capital[MAXN];
 //int belong[MAXN];
 //int sta[MAXN];
 //int siz;
@@ -45,7 +45,7 @@
 //        if (v != f) {
 //            dfs(v, u);
 //            if (siz - tmp >= b) {
-//                root[++cntb] = u;
+//                capital[++cntb] = u;
 //                while (siz > tmp) {
 //                    belong[sta[siz--]] = cntb;
 //                }
@@ -66,7 +66,7 @@
 //    }
 //    dfs(1, 0);
 //    if (cntb == 0) {
-//        root[++cntb] = 1;
+//        capital[++cntb] = 1;
 //    }
 //    while (siz > 0) {
 //        belong[sta[siz--]] = cntb;
@@ -77,7 +77,7 @@
 //    }
 //    cout << '\n';
 //    for (int i = 1; i <= cntb; i++) {
-//        cout << root[i] << ' ';
+//        cout << capital[i] << ' ';
 //    }
 //    cout << '\n';
 //    return 0;

From 089b28a162d1d6811b88a2d0bee93d0c386dfe98 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 28 Jun 2025 13:53:05 +0800
Subject: [PATCH 1037/1712] modify code

---
 src/class173/Code05_TreeBlockHld2.java    |  9 ++++--
 src/class173/Code06_TreeBlockRandom1.java | 33 +++++++++------------
 src/class173/Code06_TreeBlockRandom2.java | 35 ++++++++++++-----------
 3 files changed, 39 insertions(+), 38 deletions(-)

diff --git a/src/class173/Code05_TreeBlockHld2.java b/src/class173/Code05_TreeBlockHld2.java
index 03d539faf..7e69b18de 100644
--- a/src/class173/Code05_TreeBlockHld2.java
+++ b/src/class173/Code05_TreeBlockHld2.java
@@ -163,8 +163,13 @@
 //            updateAns(x, y);
 //        }
 //        int ans1 = ans.count();
-//        ans.flip();
-//        int ans2 = ans._Find_first();
+//        int ans2 = MAXV;
+//        for (int i = 0; i < MAXV; i++) {
+//            if (ans[i] == 0) {
+//                ans2 = i;
+//                break;
+//            }
+//        }
 //        cout << ans1 << ' ' << ans2 << '\n';
 //        last = ans1 + ans2;
 //    }
diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_TreeBlockRandom1.java
index 5ad75b0d8..7a964b13c 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_TreeBlockRandom1.java
@@ -6,7 +6,7 @@
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
 // 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
-// 1 <= n、m <= 10^5    点权 <= 30000
+// 1 <= n、点对总数 <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -31,7 +31,7 @@ public class Code06_TreeBlockRandom1 {
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
-	// 树上倍增
+	// 树上倍增求LCA
 	public static int[] dep = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][LIMIT];
 
@@ -49,10 +49,10 @@ public class Code06_TreeBlockRandom1 {
 	public static int[] repBlock = new int[MAXN];
 	// up[i] = j，表示i号节点是某块的代表，它往上跳到最近的代表点是j
 	public static int[] up = new int[MAXN];
-	// bitSet[i][j]，表示第i块代表点往上走到第j块的代表点，沿途所有点权组成的位图
-	public static BitSet[][] bitSet = new BitSet[MAXB][MAXB];
+	// downSet[i]，表示第i块的代表点往上走到最近的代表点
+	// 但是路径不包括上方最近的代表点，沿途所有点权组成的位图
+	public static BitSet[] downSet = new BitSet[MAXB];
 
-	public static BitSet tmp = new BitSet();
 	public static BitSet ans = new BitSet();
 
 	static class BitSet {
@@ -193,11 +193,10 @@ public static void query(int x, int xylca) {
 			ans.setOne(arr[x]);
 			x = stjump[x][0];
 		}
-		int from = x;
 		while (up[x] > 0 && dep[up[x]] > dep[xylca]) {
+			ans.or(downSet[repBlock[x]]);
 			x = up[x];
 		}
-		ans.or(bitSet[repBlock[from]][repBlock[x]]);
 		while (x != xylca) {
 			ans.setOne(arr[x]);
 			x = stjump[x][0];
@@ -223,24 +222,20 @@ public static void prepare() {
 			capital[b] = pick;
 			repBlock[pick] = b;
 		}
-		for (int i = 0; i <= bnum; i++) {
-			for (int j = 0; j <= bnum; j++) {
-				bitSet[i][j] = new BitSet();
-			}
+		for (int b = 0; b <= bnum; b++) {
+			downSet[b] = new BitSet();
 		}
 		for (int b = 1, cur; b <= bnum; b++) {
-			tmp.clear();
-			tmp.setOne(arr[capital[b]]);
+			downSet[b].setOne(arr[capital[b]]);
 			cur = stjump[capital[b]][0];
 			while (cur != 0) {
-				tmp.setOne(arr[cur]);
 				if (repBlock[cur] > 0) {
-					bitSet[b][repBlock[cur]].or(tmp);
-					if (up[capital[b]] == 0) {
-						up[capital[b]] = cur;
-					}
+					up[capital[b]] = cur;
+					break;
+				} else {
+					downSet[b].setOne(arr[cur]);
+					cur = stjump[cur][0];
 				}
-				cur = stjump[cur][0];
 			}
 		}
 	}
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_TreeBlockRandom2.java
index a4129b606..0de6c9fe7 100644
--- a/src/class173/Code06_TreeBlockRandom2.java
+++ b/src/class173/Code06_TreeBlockRandom2.java
@@ -6,7 +6,7 @@
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
 // 每个点对(x, y)，在树上都有从x到y的路径，那么k个点对就有k条路径
 // 先打印k条路径上不同点权的数量，再打印点权集合中没有出现的最小非负数(mex)
-// 1 <= n、m <= 10^5    点权 <= 30000
+// 1 <= n、点对总数 <= 10^5    点权 <= 30000
 // 题目要求强制在线，具体规则可以打开测试链接查看
 // 测试链接 : https://www.luogu.com.cn/problem/P3603
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -37,9 +37,8 @@
 //
 //int repBlock[MAXN];
 //int up[MAXN];
-//bitset<MAXV> bitSet[MAXB][MAXB];
+//bitset<MAXV> downSet[MAXB];
 //
-//bitset<MAXV> tmp;
 //bitset<MAXV> ans;
 //
 //void addEdge(int u, int v) {
@@ -84,16 +83,15 @@
 //
 //void query(int x, int xylca) {
 //    while (repBlock[x] == 0 && x != xylca) {
-//    	ans[arr[x]] = 1;
+//        ans[arr[x]] = 1;
 //        x = stjump[x][0];
 //    }
-//    int from = x;
 //    while (up[x] && dep[up[x]] > dep[xylca]) {
+//        ans |= downSet[repBlock[x]];
 //        x = up[x];
 //    }
-//    ans |= bitSet[repBlock[from]][repBlock[x]];
 //    while (x != xylca) {
-//    	ans[arr[x]] = 1;
+//        ans[arr[x]] = 1;
 //        x = stjump[x][0];
 //    }
 //}
@@ -118,18 +116,16 @@
 //        repBlock[pick] = b;
 //    }
 //    for (int b = 1, cur; b <= bnum; b++) {
-//        tmp.reset();
-//        tmp[arr[capital[b]]] = 1;
+//        downSet[b][arr[capital[b]]] = 1;
 //        cur = stjump[capital[b]][0];
 //        while (cur != 0) {
-//            tmp[arr[cur]] = 1;
 //            if (repBlock[cur] > 0) {
-//                bitSet[b][repBlock[cur]] |= tmp;
-//                if (up[capital[b]] == 0) {
-//                    up[capital[b]] = cur;
-//                }
+//                up[capital[b]] = cur;
+//                break;
+//            } else {
+//                downSet[b][arr[cur]] = 1;
+//                cur = stjump[cur][0];
 //            }
-//            cur = stjump[cur][0];
 //        }
 //    }	
 //}
@@ -160,8 +156,13 @@
 //            updateAns(x, y);
 //        }
 //        int ans1 = ans.count();
-//        ans.flip();
-//        int ans2 = ans._Find_first();
+//        int ans2 = MAXV;
+//        for (int i = 0; i < MAXV; i++) {
+//            if (ans[i] == 0) {
+//                ans2 = i;
+//                break;
+//            }
+//        }
 //        cout << ans1 << ' ' << ans2 << '\n';
 //        last = ans1 + ans2;
 //    }

From 6c3258ec4ddbfbe2cc2b3477b8fbe877f9eab572 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 28 Jun 2025 15:11:38 +0800
Subject: [PATCH 1038/1712] modify code

---
 src/class173/Code03_Magnet1.java | 7 ++-----
 src/class173/Code03_Magnet2.java | 7 ++-----
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index 2f586d221..6cbbf3249 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -1,16 +1,13 @@
 package class173;
 
 // 磁力块，java版
-// 每个磁块有五个属性值，x、y、m、p、range
-// 表示磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
+// 磁块有五个属性值，x、y、m、p、range，磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
 // 磁块A可以把磁块B吸到磁块A的位置，需要满足如下的条件
 // A与B的距离不大于A的吸引半径，并且B的质量不大于A的磁力
 // 你有一个初始磁块，给定初始磁块属性值，你永远在初始磁块的位置
 // 接下来给定n个磁块各自的属性值，你可以用初始磁块，吸过来其中的磁块
 // 吸过来的磁块可以被你随意使用，返回你最多能吸过来多少磁块
-// 1 <= n <= 3 * 10^5
-// -10^9 <= x、y <= +10^9
-// 1 <= m、p、range <= 10^9
+// 1 <= n <= 3 * 10^5    -10^9 <= x、y <= +10^9    1 <= m、p、range <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
 // 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class173/Code03_Magnet2.java b/src/class173/Code03_Magnet2.java
index 2cc692a9d..4e4d3fbcc 100644
--- a/src/class173/Code03_Magnet2.java
+++ b/src/class173/Code03_Magnet2.java
@@ -1,16 +1,13 @@
 package class173;
 
 // 磁力块，C++版
-// 每个磁块有五个属性值，x、y、m、p、range
-// 表示磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
+// 磁块有五个属性值，x、y、m、p、range，磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
 // 磁块A可以把磁块B吸到磁块A的位置，需要满足如下的条件
 // A与B的距离不大于A的吸引半径，并且B的质量不大于A的磁力
 // 你有一个初始磁块，给定初始磁块属性值，你永远在初始磁块的位置
 // 接下来给定n个磁块各自的属性值，你可以用初始磁块，吸过来其中的磁块
 // 吸过来的磁块可以被你随意使用，返回你最多能吸过来多少磁块
-// 1 <= n <= 3 * 10^5
-// -10^9 <= x、y <= +10^9
-// 1 <= m、p、range <= 10^9
+// 1 <= n <= 3 * 10^5    -10^9 <= x、y <= +10^9    1 <= m、p、range <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
 // 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 80da7821d9a7b60d9227c764b07d4488f94e8730 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 28 Jun 2025 15:30:34 +0800
Subject: [PATCH 1039/1712] modify code

---
 src/class173/{Code05_TreeBlockHld1.java => Code05_HLD1.java}    | 2 +-
 src/class173/{Code05_TreeBlockHld2.java => Code05_HLD2.java}    | 0
 .../{Code06_TreeBlockRandom1.java => Code06_Random1.java}       | 2 +-
 .../{Code06_TreeBlockRandom2.java => Code06_Random2.java}       | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class173/{Code05_TreeBlockHld1.java => Code05_HLD1.java} (99%)
 rename src/class173/{Code05_TreeBlockHld2.java => Code05_HLD2.java} (100%)
 rename src/class173/{Code06_TreeBlockRandom1.java => Code06_Random1.java} (99%)
 rename src/class173/{Code06_TreeBlockRandom2.java => Code06_Random2.java} (100%)

diff --git a/src/class173/Code05_TreeBlockHld1.java b/src/class173/Code05_HLD1.java
similarity index 99%
rename from src/class173/Code05_TreeBlockHld1.java
rename to src/class173/Code05_HLD1.java
index e6f7080a4..b711002ed 100644
--- a/src/class173/Code05_TreeBlockHld1.java
+++ b/src/class173/Code05_HLD1.java
@@ -16,7 +16,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_TreeBlockHld1 {
+public class Code05_HLD1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 301;
diff --git a/src/class173/Code05_TreeBlockHld2.java b/src/class173/Code05_HLD2.java
similarity index 100%
rename from src/class173/Code05_TreeBlockHld2.java
rename to src/class173/Code05_HLD2.java
diff --git a/src/class173/Code06_TreeBlockRandom1.java b/src/class173/Code06_Random1.java
similarity index 99%
rename from src/class173/Code06_TreeBlockRandom1.java
rename to src/class173/Code06_Random1.java
index 7a964b13c..8baeccd26 100644
--- a/src/class173/Code06_TreeBlockRandom1.java
+++ b/src/class173/Code06_Random1.java
@@ -16,7 +16,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code06_TreeBlockRandom1 {
+public class Code06_Random1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 301;
diff --git a/src/class173/Code06_TreeBlockRandom2.java b/src/class173/Code06_Random2.java
similarity index 100%
rename from src/class173/Code06_TreeBlockRandom2.java
rename to src/class173/Code06_Random2.java

From 118193dddcdde0888de76f2a7b3f561dc4be1120 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 28 Jun 2025 16:06:01 +0800
Subject: [PATCH 1040/1712] modify code

---
 src/class173/Code06_Random1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 8baeccd26..88ffb00e7 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -49,8 +49,8 @@ public class Code06_Random1 {
 	public static int[] repBlock = new int[MAXN];
 	// up[i] = j，表示i号节点是某块的代表，它往上跳到最近的代表点是j
 	public static int[] up = new int[MAXN];
-	// downSet[i]，表示第i块的代表点往上走到最近的代表点
-	// 但是路径不包括上方最近的代表点，沿途所有点权组成的位图
+	// downSet[i]，表示下方第i块的代表点往上走到最近的代表点
+	// 路径不包括上方代表点，沿途所有点权组成的位图
 	public static BitSet[] downSet = new BitSet[MAXB];
 
 	public static BitSet ans = new BitSet();

From 1633d6c092a20482e4691a2382cc7180bbf878b1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 13:56:31 +0800
Subject: [PATCH 1041/1712] modify code

---
 src/class173/Code01_Sequence1.java  | 7 +++++--
 src/class173/Code04_Inversion1.java | 2 +-
 src/class173/Code04_Inversion2.java | 1 +
 3 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/class173/Code01_Sequence1.java b/src/class173/Code01_Sequence1.java
index 1ace32076..3b2578b55 100644
--- a/src/class173/Code01_Sequence1.java
+++ b/src/class173/Code01_Sequence1.java
@@ -23,15 +23,18 @@ public class Code01_Sequence1 {
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 
-	// op == 1，代表修改事件，位置x、时间t、修改效果v、空缺
-	// op == 2，代表查询事件，位置x、时间t、查询标准v、问题编号q
+	// op == 1，代表修改事件，位置x、时刻t、修改效果v、空缺
+	// op == 2，代表查询事件，位置x、时刻t、查询标准v、问题编号q
 	public static int[][] event = new int[MAXN << 2][5];
 	public static int cnte = 0;
 	public static int cntq = 0;
 
+	// 时间块内的值
 	public static long[] tim = new long[MAXN];
+	// 每块的值排序
 	public static long[] sortv = new long[MAXN];
 
+	// 时间分块
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index a8c1c8531..b978413b9 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -23,7 +23,6 @@ public class Code04_Inversion1 {
 	public static int MAXN = 100001;
 	public static int MAXB = 701;
 	public static int n, m;
-
 	public static int[] arr = new int[MAXN];
 	public static int[][] sortv = new int[MAXN][2];
 
@@ -33,6 +32,7 @@ public class Code04_Inversion1 {
 	public static int[] br = new int[MAXB];
 
 	public static int[] tree = new int[MAXN];
+
 	public static int[] pre = new int[MAXN];
 	public static int[] suf = new int[MAXN];
 	public static int[][] cnt = new int[MAXB][MAXN];
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index 824f4ae6a..5d4c7b8a7 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -54,6 +54,7 @@
 //int br[MAXB];
 //
 //int tree[MAXN];
+//
 //int pre[MAXN];
 //int suf[MAXN];
 //int cnt[MAXB][MAXN];

From 2bae720aab0d133b0145a92da8121396dba9bad7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 14:58:49 +0800
Subject: [PATCH 1042/1712] modify code

---
 src/class173/Code03_Magnet1.java | 4 ++--
 src/class173/Code03_Magnet2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index 6cbbf3249..3aa7e3d39 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -4,8 +4,8 @@
 // 磁块有五个属性值，x、y、m、p、range，磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
 // 磁块A可以把磁块B吸到磁块A的位置，需要满足如下的条件
 // A与B的距离不大于A的吸引半径，并且B的质量不大于A的磁力
-// 你有一个初始磁块，给定初始磁块属性值，你永远在初始磁块的位置
-// 接下来给定n个磁块各自的属性值，你可以用初始磁块，吸过来其中的磁块
+// 你有一个初始磁块，给定初始磁块的4个属性值(不给质量，因为没用)，你永远在初始磁块的位置
+// 接下来给定n个磁块各自的5个属性值，你可以用初始磁块，吸过来其中的磁块
 // 吸过来的磁块可以被你随意使用，返回你最多能吸过来多少磁块
 // 1 <= n <= 3 * 10^5    -10^9 <= x、y <= +10^9    1 <= m、p、range <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
diff --git a/src/class173/Code03_Magnet2.java b/src/class173/Code03_Magnet2.java
index 4e4d3fbcc..26cb94ba9 100644
--- a/src/class173/Code03_Magnet2.java
+++ b/src/class173/Code03_Magnet2.java
@@ -4,8 +4,8 @@
 // 磁块有五个属性值，x、y、m、p、range，磁块在(x, y)位置、质量为m、磁力为p、吸引半径range
 // 磁块A可以把磁块B吸到磁块A的位置，需要满足如下的条件
 // A与B的距离不大于A的吸引半径，并且B的质量不大于A的磁力
-// 你有一个初始磁块，给定初始磁块属性值，你永远在初始磁块的位置
-// 接下来给定n个磁块各自的属性值，你可以用初始磁块，吸过来其中的磁块
+// 你有一个初始磁块，给定初始磁块的4个属性值(不给质量，因为没用)，你永远在初始磁块的位置
+// 接下来给定n个磁块各自的5个属性值，你可以用初始磁块，吸过来其中的磁块
 // 吸过来的磁块可以被你随意使用，返回你最多能吸过来多少磁块
 // 1 <= n <= 3 * 10^5    -10^9 <= x、y <= +10^9    1 <= m、p、range <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P10590

From 260e0a42ab4c81d512bc2cfe17b8a4f555f7dc2c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 16:07:29 +0800
Subject: [PATCH 1043/1712] modify code

---
 src/class173/Code04_Inversion1.java | 4 ++--
 src/class173/Code04_Inversion2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index b978413b9..5c3fe492d 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -141,8 +141,8 @@ public static void prepare() {
 			}
 			dp[i][i] = pre[br[i]];
 		}
-		for (int len = 2; len <= bnum; len++) {
-			for (int l = 1, r = l + len - 1; r <= bnum; l++, r++) {
+		for (int l = bnum; l >= 1; l--) {
+			for (int r = l + 1; r <= bnum; r++) {
 				dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
 			}
 		}
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index 5d4c7b8a7..be90c2894 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -159,8 +159,8 @@
 //        }
 //        dp[i][i] = pre[br[i]];
 //    }
-//    for (int len = 2; len <= bnum; len++) {
-//        for (int l = 1, r = l + len - 1; r <= bnum; l++, r++) {
+//    for (int l = bnum; l >= 1; l--) {
+//        for (int r = l + 1; r <= bnum; r++) {
 //            dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
 //        }
 //    }

From ee79b825825c20b3617ffe619f1d05b63f586129 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 16:14:25 +0800
Subject: [PATCH 1044/1712] modify code

---
 src/class173/Code06_Random1.java | 28 ++++++++++++++--------------
 1 file changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 88ffb00e7..da316fe52 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -82,7 +82,7 @@ public void or(BitSet obj) {
 			}
 		}
 
-		public int getOnes() {
+		public int count() {
 			int ans = 0;
 			for (int x : set) {
 				ans += Integer.bitCount(x);
@@ -122,29 +122,29 @@ public static void dfs1(int u, int fa) {
 		}
 	}
 
-	// 树上倍增迭代版
+	// 树上倍增迭代版，讲解118进行了详细讲述
 	public static int[][] ufe = new int[MAXN][3];
 
-	public static int stackSize, cur, fath, edge;
+	public static int stacksize, cur, fath, edge;
 
 	public static void push(int u, int f, int e) {
-		ufe[stackSize][0] = u;
-		ufe[stackSize][1] = f;
-		ufe[stackSize][2] = e;
-		stackSize++;
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
 	}
 
 	public static void pop() {
-		--stackSize;
-		cur = ufe[stackSize][0];
-		fath = ufe[stackSize][1];
-		edge = ufe[stackSize][2];
+		--stacksize;
+		cur = ufe[stacksize][0];
+		fath = ufe[stacksize][1];
+		edge = ufe[stacksize][2];
 	}
 
 	public static void dfs2() {
-		stackSize = 0;
+		stacksize = 0;
 		push(1, 0, -1);
-		while (stackSize > 0) {
+		while (stacksize > 0) {
 			pop();
 			if (edge == -1) {
 				dep[cur] = dep[fath] + 1;
@@ -268,7 +268,7 @@ public static void main(String[] args) throws IOException {
 				}
 				updateAns(x, y);
 			}
-			int ans1 = ans.getOnes();
+			int ans1 = ans.count();
 			int ans2 = ans.mex();
 			out.println(ans1 + " " + ans2);
 			last = ans1 + ans2;

From 9e414cc81f9032c19379dd8fc92e929913bb2f43 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 16:17:51 +0800
Subject: [PATCH 1045/1712] modify code

---
 src/class173/Code06_Random1.java | 12 ++++++------
 src/class173/Code06_Random2.java | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index da316fe52..303ac360a 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -21,7 +21,7 @@ public class Code06_Random1 {
 	public static int MAXN = 100001;
 	public static int MAXB = 301;
 	public static int MAXV = 30001;
-	public static int LIMIT = 17;
+	public static int MAXP = 17;
 	public static int n, m, f, k;
 	public static int[] arr = new int[MAXN];
 
@@ -33,7 +33,7 @@ public class Code06_Random1 {
 
 	// 树上倍增求LCA
 	public static int[] dep = new int[MAXN];
-	public static int[][] stjump = new int[MAXN][LIMIT];
+	public static int[][] stjump = new int[MAXN][MAXP];
 
 	// 随机撒点，预处理过程需要
 	// bnum表示块的数量，也表示会有几个点被选为代表点
@@ -112,7 +112,7 @@ public static void addEdge(int u, int v) {
 	public static void dfs1(int u, int fa) {
 		dep[u] = dep[fa] + 1;
 		stjump[u][0] = fa;
-		for (int p = 1; p < LIMIT; p++) {
+		for (int p = 1; p < MAXP; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 		}
 		for (int e = head[u]; e != 0; e = next[e]) {
@@ -149,7 +149,7 @@ public static void dfs2() {
 			if (edge == -1) {
 				dep[cur] = dep[fath] + 1;
 				stjump[cur][0] = fath;
-				for (int p = 1; p < LIMIT; p++) {
+				for (int p = 1; p < MAXP; p++) {
 					stjump[cur][p] = stjump[stjump[cur][p - 1]][p - 1];
 				}
 				edge = head[cur];
@@ -171,7 +171,7 @@ public static int lca(int a, int b) {
 			a = b;
 			b = tmp;
 		}
-		for (int p = LIMIT - 1; p >= 0; p--) {
+		for (int p = MAXP - 1; p >= 0; p--) {
 			if (dep[stjump[a][p]] >= dep[b]) {
 				a = stjump[a][p];
 			}
@@ -179,7 +179,7 @@ public static int lca(int a, int b) {
 		if (a == b) {
 			return a;
 		}
-		for (int p = LIMIT - 1; p >= 0; p--) {
+		for (int p = MAXP - 1; p >= 0; p--) {
 			if (stjump[a][p] != stjump[b][p]) {
 				a = stjump[a][p];
 				b = stjump[b][p];
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index 0de6c9fe7..27f41235e 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -19,7 +19,7 @@
 //const int MAXN = 100001;
 //const int MAXB = 301;
 //const int MAXV = 30001;
-//const int LIMIT = 17;
+//const int MAXP = 17;
 //int n, m, f, k;
 //int arr[MAXN];
 //
@@ -29,7 +29,7 @@
 //int cntg;
 //
 //int dep[MAXN];
-//int stjump[MAXN][LIMIT];
+//int stjump[MAXN][MAXP];
 //
 //int bnum;
 //bool vis[MAXN];
@@ -50,7 +50,7 @@
 //void dfs(int u, int fa) {
 //    dep[u] = dep[fa] + 1;
 //    stjump[u][0] = fa;
-//    for (int p = 1; p < LIMIT; p++) {
+//    for (int p = 1; p < MAXP; p++) {
 //        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
 //    }
 //    for (int e = head[u]; e; e = nxt[e]) {
@@ -64,7 +64,7 @@
 //    if (dep[a] < dep[b]) {
 //        swap(a, b);
 //    }
-//    for (int p = LIMIT - 1; p >= 0; p--) {
+//    for (int p = MAXP - 1; p >= 0; p--) {
 //        if (dep[stjump[a][p]] >= dep[b]) {
 //            a = stjump[a][p];
 //        }
@@ -72,7 +72,7 @@
 //    if (a == b) {
 //        return a;
 //    }
-//    for (int p = LIMIT - 1; p >= 0; p--) {
+//    for (int p = MAXP - 1; p >= 0; p--) {
 //        if (stjump[a][p] != stjump[b][p]) {
 //            a = stjump[a][p];
 //            b = stjump[b][p];

From dcc11d77174d26b69dc0a9185e2e026c283ef8af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 16:24:37 +0800
Subject: [PATCH 1046/1712] modify code

---
 src/class173/Code06_Random1.java | 8 +++-----
 1 file changed, 3 insertions(+), 5 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 303ac360a..4b8b6927a 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -82,7 +82,7 @@ public void or(BitSet obj) {
 			}
 		}
 
-		public int count() {
+		public int countOnes() {
 			int ans = 0;
 			for (int x : set) {
 				ans += Integer.bitCount(x);
@@ -222,10 +222,8 @@ public static void prepare() {
 			capital[b] = pick;
 			repBlock[pick] = b;
 		}
-		for (int b = 0; b <= bnum; b++) {
-			downSet[b] = new BitSet();
-		}
 		for (int b = 1, cur; b <= bnum; b++) {
+			downSet[b] = new BitSet();
 			downSet[b].setOne(arr[capital[b]]);
 			cur = stjump[capital[b]][0];
 			while (cur != 0) {
@@ -268,7 +266,7 @@ public static void main(String[] args) throws IOException {
 				}
 				updateAns(x, y);
 			}
-			int ans1 = ans.count();
+			int ans1 = ans.countOnes();
 			int ans2 = ans.mex();
 			out.println(ans1 + " " + ans2);
 			last = ans1 + ans2;

From 416dec670aaaa579777eaf374786f4ec43d7d552 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 16:42:29 +0800
Subject: [PATCH 1047/1712] modify code

---
 src/class173/Code06_Random1.java | 19 +++++++++----------
 1 file changed, 9 insertions(+), 10 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 4b8b6927a..d2f217115 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -35,22 +35,21 @@ public class Code06_Random1 {
 	public static int[] dep = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
 
-	// 随机撒点，预处理过程需要
-	// bnum表示块的数量，也表示会有几个点被选为代表点
+	// 随机撒点，预处理阶段需要的信息
+	// bnum表示关键点数量
 	public static int bnum;
-	// vis[i]表示i号点是否已经选为某个块的代表点
+	// vis[i]表示i号节点是否已经是关键点
 	public static boolean[] vis = new boolean[MAXN];
-	// capital[i]表示第i块的代表节点
+	// capital[i]表示第i个关键点的节点编号
 	public static int[] capital = new int[MAXB];
 
-	// 随机撒点，预处理之后生成的信息
-	// repBlock[i] = j，表示i号节点是第j块的代表
-	// repBlock[i] = 0，表示i号节点不是任何块的代表
+	// 随机撒点，预处理阶段生成的信息
+	// repBlock[i] = j 表示i号节点是第j个关键点
+	// repBlock[i] = 0 表示i号节点是非关键点
 	public static int[] repBlock = new int[MAXN];
-	// up[i] = j，表示i号节点是某块的代表，它往上跳到最近的代表点是j
+	// up[i] = j，表示i号节点是关键点，它往上跳到最近的关键点是j号节点
 	public static int[] up = new int[MAXN];
-	// downSet[i]，表示下方第i块的代表点往上走到最近的代表点
-	// 路径不包括上方代表点，沿途所有点权组成的位图
+	// downSet[i]的含义，路径是[第i个的关键点 .. 最近的上方关键点)，沿途所有节点值组成的位图
 	public static BitSet[] downSet = new BitSet[MAXB];
 
 	public static BitSet ans = new BitSet();

From bc3c10eff8bb4dce83dd3889eb41948f42fdc25f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 16:43:10 +0800
Subject: [PATCH 1048/1712] modify code

---
 src/class173/Code06_Random1.java | 2 +-
 src/class173/Code06_Random2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index d2f217115..502e5d3bc 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，随机撒点分块，java版
+// 树上分块模版题，随机撒点，java版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
 // 接下来有m条操作，每条操作都要打印两个答案，描述如下
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index 27f41235e..ff4abb621 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -1,6 +1,6 @@
 package class173;
 
-// 树上分块模版题，随机撒点分块，C++版
+// 树上分块模版题，随机撒点，C++版
 // 一共有n个节点，每个节点有点权，给定n-1条边，所有节点连成一棵树
 // 接下来有m条操作，每条操作都要打印两个答案，描述如下
 // 操作 k x1 y1 x2 y2 .. (一共k个点对) 

From f9f287707edaf6a72b8c88582e816f8444851a3e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 17:03:54 +0800
Subject: [PATCH 1049/1712] modify code

---
 src/class173/Code01_Sequence1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code01_Sequence1.java b/src/class173/Code01_Sequence1.java
index 3b2578b55..162abc669 100644
--- a/src/class173/Code01_Sequence1.java
+++ b/src/class173/Code01_Sequence1.java
@@ -23,8 +23,8 @@ public class Code01_Sequence1 {
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 
-	// op == 1，代表修改事件，位置x、时刻t、修改效果v、空缺
-	// op == 2，代表查询事件，位置x、时刻t、查询标准v、问题编号q
+	// op == 1 表示修改事件、位置x、时刻t、修改效果v、空缺
+	// op == 2 表示查询事件、位置x、时刻t、查询标准v、问题编号q
 	public static int[][] event = new int[MAXN << 2][5];
 	public static int cnte = 0;
 	public static int cntq = 0;

From 3273575ae7b83e5d254b2ec02ef132f42da1c6aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 29 Jun 2025 17:21:18 +0800
Subject: [PATCH 1050/1712] modify code

---
 src/class173/Code06_Random1.java | 39 ++++++++++++++++----------------
 src/class173/Code06_Random2.java | 30 ++++++++++++------------
 2 files changed, 34 insertions(+), 35 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 502e5d3bc..b86e8d8b5 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -36,20 +36,19 @@ public class Code06_Random1 {
 	public static int[][] stjump = new int[MAXN][MAXP];
 
 	// 随机撒点，预处理阶段需要的信息
-	// bnum表示关键点数量
-	public static int bnum;
+	// markNum表示关键点数量
+	public static int markNum;
 	// vis[i]表示i号节点是否已经是关键点
 	public static boolean[] vis = new boolean[MAXN];
-	// capital[i]表示第i个关键点的节点编号
-	public static int[] capital = new int[MAXB];
+	// markNode[k] = i 表示第k个关键点是编号为i的节点
+	public static int[] markNode = new int[MAXB];
 
 	// 随机撒点，预处理阶段生成的信息
-	// repBlock[i] = j 表示i号节点是第j个关键点
-	// repBlock[i] = 0 表示i号节点是非关键点
-	public static int[] repBlock = new int[MAXN];
+	// kthMark[i] = k 表示i号节点是第k个关键点，kthMark[i] = 0 表示i号节点是非关键点
+	public static int[] kthMark = new int[MAXN];
 	// up[i] = j，表示i号节点是关键点，它往上跳到最近的关键点是j号节点
 	public static int[] up = new int[MAXN];
-	// downSet[i]的含义，路径是[第i个的关键点 .. 最近的上方关键点)，沿途所有节点值组成的位图
+	// downSet[k]的含义，路径是[第k个的关键点 .. 最近的上方关键点)，沿途所有节点值组成的位图
 	public static BitSet[] downSet = new BitSet[MAXB];
 
 	public static BitSet ans = new BitSet();
@@ -188,12 +187,12 @@ public static int lca(int a, int b) {
 	}
 
 	public static void query(int x, int xylca) {
-		while (repBlock[x] == 0 && x != xylca) {
+		while (kthMark[x] == 0 && x != xylca) {
 			ans.setOne(arr[x]);
 			x = stjump[x][0];
 		}
 		while (up[x] > 0 && dep[up[x]] > dep[xylca]) {
-			ans.or(downSet[repBlock[x]]);
+			ans.or(downSet[kthMark[x]]);
 			x = up[x];
 		}
 		while (x != xylca) {
@@ -211,23 +210,23 @@ public static void updateAns(int x, int y) {
 
 	public static void prepare() {
 		dfs2();
-		int blen = (int) Math.sqrt(20.0 * n);
-		bnum = (n + blen - 1) / blen;
-		for (int b = 1, pick; b <= bnum; b++) {
+		int len = (int) Math.sqrt(20.0 * n);
+		markNum = (n + len - 1) / len;
+		for (int b = 1, pick; b <= markNum; b++) {
 			do {
 				pick = (int) (Math.random() * n) + 1;
 			} while (vis[pick]);
 			vis[pick] = true;
-			capital[b] = pick;
-			repBlock[pick] = b;
+			markNode[b] = pick;
+			kthMark[pick] = b;
 		}
-		for (int b = 1, cur; b <= bnum; b++) {
+		for (int b = 1, cur; b <= markNum; b++) {
 			downSet[b] = new BitSet();
-			downSet[b].setOne(arr[capital[b]]);
-			cur = stjump[capital[b]][0];
+			downSet[b].setOne(arr[markNode[b]]);
+			cur = stjump[markNode[b]][0];
 			while (cur != 0) {
-				if (repBlock[cur] > 0) {
-					up[capital[b]] = cur;
+				if (kthMark[cur] > 0) {
+					up[markNode[b]] = cur;
 					break;
 				} else {
 					downSet[b].setOne(arr[cur]);
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index ff4abb621..dc7bfc7ab 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -31,11 +31,11 @@
 //int dep[MAXN];
 //int stjump[MAXN][MAXP];
 //
-//int bnum;
+//int markNum;
 //bool vis[MAXN];
-//int capital[MAXN];
+//int markNode[MAXN];
 //
-//int repBlock[MAXN];
+//int kthMark[MAXN];
 //int up[MAXN];
 //bitset<MAXV> downSet[MAXB];
 //
@@ -82,12 +82,12 @@
 //}
 //
 //void query(int x, int xylca) {
-//    while (repBlock[x] == 0 && x != xylca) {
+//    while (kthMark[x] == 0 && x != xylca) {
 //        ans[arr[x]] = 1;
 //        x = stjump[x][0];
 //    }
 //    while (up[x] && dep[up[x]] > dep[xylca]) {
-//        ans |= downSet[repBlock[x]];
+//        ans |= downSet[kthMark[x]];
 //        x = up[x];
 //    }
 //    while (x != xylca) {
@@ -105,22 +105,22 @@
 //
 //void prepare() {
 //    dfs(1, 0);
-//    int blen = (int)sqrt(20.0 * n);
-//    bnum = (n + blen - 1) / blen;
-//    for (int b = 1, pick; b <= bnum; b++) {
+//    int len = (int)sqrt(20.0 * n);
+//    markNum = (n + len - 1) / len;
+//    for (int b = 1, pick; b <= markNum; b++) {
 //        do {
 //            pick = rand() % n + 1;
 //        } while (vis[pick]);
 //        vis[pick] = true;
-//        capital[b] = pick;
-//        repBlock[pick] = b;
+//        markNode[b] = pick;
+//        kthMark[pick] = b;
 //    }
-//    for (int b = 1, cur; b <= bnum; b++) {
-//        downSet[b][arr[capital[b]]] = 1;
-//        cur = stjump[capital[b]][0];
+//    for (int b = 1, cur; b <= markNum; b++) {
+//        downSet[b][arr[markNode[b]]] = 1;
+//        cur = stjump[markNode[b]][0];
 //        while (cur != 0) {
-//            if (repBlock[cur] > 0) {
-//                up[capital[b]] = cur;
+//            if (kthMark[cur] > 0) {
+//                up[markNode[b]] = cur;
 //                break;
 //            } else {
 //                downSet[b][arr[cur]] = 1;

From 81de19638d79b2bd2c457df8b8b909a82b28ac38 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 13:23:46 +0800
Subject: [PATCH 1051/1712] modify code

---
 src/class173/Code05_HLD1.java    | 3 +--
 src/class173/Code05_HLD2.java    | 2 +-
 src/class173/Code06_Random1.java | 4 ++--
 src/class173/Code06_Random2.java | 4 ++--
 4 files changed, 6 insertions(+), 7 deletions(-)

diff --git a/src/class173/Code05_HLD1.java b/src/class173/Code05_HLD1.java
index b711002ed..609baef80 100644
--- a/src/class173/Code05_HLD1.java
+++ b/src/class173/Code05_HLD1.java
@@ -19,7 +19,7 @@
 public class Code05_HLD1 {
 
 	public static int MAXN = 100001;
-	public static int MAXB = 301;
+	public static int MAXB = 401;
 	public static int MAXV = 30001;
 	public static int n, m, f, k;
 	public static int[] arr = new int[MAXN];
@@ -260,7 +260,6 @@ public static void updateAns(int x, int y) {
 	public static void prepare() {
 		dfs3();
 		dfs4();
-		// 调整块长
 		blen = (int) Math.sqrt(20.0 * n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
diff --git a/src/class173/Code05_HLD2.java b/src/class173/Code05_HLD2.java
index 7e69b18de..63b13a67e 100644
--- a/src/class173/Code05_HLD2.java
+++ b/src/class173/Code05_HLD2.java
@@ -17,7 +17,7 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
-//const int MAXB = 301;
+//const int MAXB = 401;
 //const int MAXV = 30001;
 //int n, m, f, k;
 //int arr[MAXN];
diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index b86e8d8b5..594b682c7 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -19,7 +19,7 @@
 public class Code06_Random1 {
 
 	public static int MAXN = 100001;
-	public static int MAXB = 301;
+	public static int MAXB = 401;
 	public static int MAXV = 30001;
 	public static int MAXP = 17;
 	public static int n, m, f, k;
@@ -210,7 +210,7 @@ public static void updateAns(int x, int y) {
 
 	public static void prepare() {
 		dfs2();
-		int len = (int) Math.sqrt(20.0 * n);
+		int len = (int) Math.sqrt(10.0 * n);
 		markNum = (n + len - 1) / len;
 		for (int b = 1, pick; b <= markNum; b++) {
 			do {
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index dc7bfc7ab..1fc36616a 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -17,7 +17,7 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
-//const int MAXB = 301;
+//const int MAXB = 401;
 //const int MAXV = 30001;
 //const int MAXP = 17;
 //int n, m, f, k;
@@ -105,7 +105,7 @@
 //
 //void prepare() {
 //    dfs(1, 0);
-//    int len = (int)sqrt(20.0 * n);
+//    int len = (int)sqrt(10.0 * n);
 //    markNum = (n + len - 1) / len;
 //    for (int b = 1, pick; b <= markNum; b++) {
 //        do {

From e003b8905bc4fc316f9fc2a7f4f6c191f5deee91 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 13:31:13 +0800
Subject: [PATCH 1052/1712] modify code

---
 src/class173/Code05_HLD1.java | 13 ++++---------
 src/class173/Code05_HLD2.java | 12 ++++--------
 2 files changed, 8 insertions(+), 17 deletions(-)

diff --git a/src/class173/Code05_HLD1.java b/src/class173/Code05_HLD1.java
index 609baef80..1a427d88d 100644
--- a/src/class173/Code05_HLD1.java
+++ b/src/class173/Code05_HLD1.java
@@ -47,8 +47,6 @@ public class Code05_HLD1 {
 	public static int[] br = new int[MAXB];
 	public static BitSet[] bitSet = new BitSet[MAXB];
 
-	// 答案
-	public static BitSet tmp = new BitSet();
 	public static BitSet ans = new BitSet();
 
 	static class BitSet {
@@ -224,20 +222,19 @@ public static void dfs4() {
 	}
 
 	public static void query(int l, int r) {
-		tmp.clear();
 		if (bi[l] == bi[r]) {
 			for (int i = l; i <= r; i++) {
-				tmp.setOne(val[i]);
+				ans.setOne(val[i]);
 			}
 		} else {
 			for (int i = l; i <= br[bi[l]]; i++) {
-				tmp.setOne(val[i]);
+				ans.setOne(val[i]);
 			}
 			for (int i = bl[bi[r]]; i <= r; i++) {
-				tmp.setOne(val[i]);
+				ans.setOne(val[i]);
 			}
 			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-				tmp.or(bitSet[i]);
+				ans.or(bitSet[i]);
 			}
 		}
 	}
@@ -250,11 +247,9 @@ public static void updateAns(int x, int y) {
 				y = tmp;
 			}
 			query(dfn[top[x]], dfn[x]);
-			ans.or(tmp);
 			x = fa[top[x]];
 		}
 		query(Math.min(dfn[x], dfn[y]), Math.max(dfn[x], dfn[y]));
-		ans.or(tmp);
 	}
 
 	public static void prepare() {
diff --git a/src/class173/Code05_HLD2.java b/src/class173/Code05_HLD2.java
index 63b13a67e..da227684c 100644
--- a/src/class173/Code05_HLD2.java
+++ b/src/class173/Code05_HLD2.java
@@ -42,7 +42,6 @@
 //int br[MAXB];
 //bitset<MAXV> bitSet[MAXB];
 //
-//bitset<MAXV> tmp;
 //bitset<MAXV> ans;
 //
 //void addEdge(int u, int v) {
@@ -89,20 +88,19 @@
 //}
 //
 //void query(int l, int r) {
-//    tmp.reset();
 //    if (bi[l] == bi[r]) {
 //        for (int i = l; i <= r; i++) {
-//        	tmp[val[i]] = 1;
+//        	ans[val[i]] = 1;
 //        }
 //    } else {
 //        for (int i = l; i <= br[bi[l]]; i++) {
-//        	tmp[val[i]] = 1;
+//        	ans[val[i]] = 1;
 //        }
 //        for (int i = bl[bi[r]]; i <= r; i++) {
-//        	tmp[val[i]] = 1;
+//        	ans[val[i]] = 1;
 //        }
 //        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-//        	tmp |= bitSet[i];
+//        	ans |= bitSet[i];
 //        }
 //    }
 //}
@@ -113,11 +111,9 @@
 //            swap(x, y);
 //        }
 //        query(dfn[top[x]], dfn[x]);
-//        ans |= tmp;
 //        x = fa[top[x]];
 //    }
 //    query(min(dfn[x], dfn[y]), max(dfn[x], dfn[y]));
-//    ans |= tmp;
 //}
 //
 //void prepare() {

From c02a85de99e41e9035cdceaabd81c4ed40725bd5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 13:34:20 +0800
Subject: [PATCH 1053/1712] modify code

---
 src/class173/Code05_HLD2.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code05_HLD2.java b/src/class173/Code05_HLD2.java
index da227684c..9aa4aedce 100644
--- a/src/class173/Code05_HLD2.java
+++ b/src/class173/Code05_HLD2.java
@@ -90,17 +90,17 @@
 //void query(int l, int r) {
 //    if (bi[l] == bi[r]) {
 //        for (int i = l; i <= r; i++) {
-//        	ans[val[i]] = 1;
+//            ans[val[i]] = 1;
 //        }
 //    } else {
 //        for (int i = l; i <= br[bi[l]]; i++) {
-//        	ans[val[i]] = 1;
+//            ans[val[i]] = 1;
 //        }
 //        for (int i = bl[bi[r]]; i <= r; i++) {
-//        	ans[val[i]] = 1;
+//            ans[val[i]] = 1;
 //        }
 //        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-//        	ans |= bitSet[i];
+//            ans |= bitSet[i];
 //        }
 //    }
 //}

From 05ba96004315e33587fe75e0c445610c695b1c6e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 17:17:53 +0800
Subject: [PATCH 1054/1712] modify code

---
 src/class173/{Code02_Poker1.java => Code01_Poker1.java}       | 2 +-
 src/class173/{Code02_Poker2.java => Code01_Poker2.java}       | 0
 src/class173/{Code01_Sequence1.java => Code02_Sequence1.java} | 2 +-
 src/class173/{Code01_Sequence2.java => Code02_Sequence2.java} | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class173/{Code02_Poker1.java => Code01_Poker1.java} (99%)
 rename src/class173/{Code02_Poker2.java => Code01_Poker2.java} (100%)
 rename src/class173/{Code01_Sequence1.java => Code02_Sequence1.java} (99%)
 rename src/class173/{Code01_Sequence2.java => Code02_Sequence2.java} (100%)

diff --git a/src/class173/Code02_Poker1.java b/src/class173/Code01_Poker1.java
similarity index 99%
rename from src/class173/Code02_Poker1.java
rename to src/class173/Code01_Poker1.java
index b9f96a845..db04a25df 100644
--- a/src/class173/Code02_Poker1.java
+++ b/src/class173/Code01_Poker1.java
@@ -15,7 +15,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_Poker1 {
+public class Code01_Poker1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 1001;
diff --git a/src/class173/Code02_Poker2.java b/src/class173/Code01_Poker2.java
similarity index 100%
rename from src/class173/Code02_Poker2.java
rename to src/class173/Code01_Poker2.java
diff --git a/src/class173/Code01_Sequence1.java b/src/class173/Code02_Sequence1.java
similarity index 99%
rename from src/class173/Code01_Sequence1.java
rename to src/class173/Code02_Sequence1.java
index 162abc669..f1fb2f6d2 100644
--- a/src/class173/Code01_Sequence1.java
+++ b/src/class173/Code02_Sequence1.java
@@ -16,7 +16,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code01_Sequence1 {
+public class Code02_Sequence1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 501;
diff --git a/src/class173/Code01_Sequence2.java b/src/class173/Code02_Sequence2.java
similarity index 100%
rename from src/class173/Code01_Sequence2.java
rename to src/class173/Code02_Sequence2.java

From 3ec6f41e20dea1e7d20c1829af4bea2603255305 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 17:52:58 +0800
Subject: [PATCH 1055/1712] modify code

---
 src/class173/Code01_Poker1.java | 7 +++----
 src/class173/Code01_Poker2.java | 7 +++----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/class173/Code01_Poker1.java b/src/class173/Code01_Poker1.java
index db04a25df..f37453906 100644
--- a/src/class173/Code01_Poker1.java
+++ b/src/class173/Code01_Poker1.java
@@ -19,7 +19,6 @@ public class Code01_Poker1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 1001;
-	public static int INF = Integer.MAX_VALUE;
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
@@ -54,7 +53,7 @@ public static void add(int l, int r, int v) {
 	}
 
 	public static int getMin(int l, int r) {
-		int lb = bi[l], rb = bi[r], ans = INF;
+		int lb = bi[l], rb = bi[r], ans = 10000000;
 		if (lb == rb) {
 			for (int i = l; i <= r; i++) {
 				ans = Math.min(ans, arr[i] + lazy[lb]);
@@ -74,7 +73,7 @@ public static int getMin(int l, int r) {
 	}
 
 	public static int getMax(int l, int r) {
-		int lb = bi[l], rb = bi[r], ans = -INF;
+		int lb = bi[l], rb = bi[r], ans = -10000000;
 		if (lb == rb) {
 			for (int i = l; i <= r; i++) {
 				ans = Math.max(ans, arr[i] + lazy[lb]);
@@ -162,7 +161,7 @@ public static int query(int l, int r, int v) {
 	}
 
 	public static void prepare() {
-		blen = (int) Math.sqrt(n);
+		blen = (int) Math.sqrt(n / 2);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
diff --git a/src/class173/Code01_Poker2.java b/src/class173/Code01_Poker2.java
index a2e381ee7..36c4f4755 100644
--- a/src/class173/Code01_Poker2.java
+++ b/src/class173/Code01_Poker2.java
@@ -16,7 +16,6 @@
 //
 //const int MAXN = 100001;
 //const int MAXB = 1001;
-//const int INF = 2147483647;
 //
 //int n, m;
 //int arr[MAXN];
@@ -51,7 +50,7 @@
 //}
 //
 //int getMin(int l, int r) {
-//    int lb = bi[l], rb = bi[r], ans = INF;
+//    int lb = bi[l], rb = bi[r], ans = 10000000;
 //    if (lb == rb) {
 //        for (int i = l; i <= r; i++) {
 //            ans = min(ans, arr[i] + lazy[lb]);
@@ -71,7 +70,7 @@
 //}
 //
 //int getMax(int l, int r) {
-//    int lb = bi[l], rb = bi[r], ans = -INF;
+//    int lb = bi[l], rb = bi[r], ans = -10000000;
 //    if (lb == rb) {
 //        for (int i = l; i <= r; i++) {
 //            ans = max(ans, arr[i] + lazy[lb]);
@@ -158,7 +157,7 @@
 //}
 //
 //void prepare() {
-//    blen = (int)sqrt(m);
+//    blen = (int)sqrt(n / 2);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;

From 41568774b9a88ecc370b792b94543c9ea7d33701 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 18:15:16 +0800
Subject: [PATCH 1056/1712] modify code

---
 src/class173/Code04_Inversion1.java | 2 +-
 src/class173/Code04_Inversion2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index 5c3fe492d..c6e37799c 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -98,7 +98,7 @@ public static long query(int l, int r) {
 
 	// 注意调整块长
 	public static void prepare() {
-		blen = (int) (Math.sqrt(n) / 2);
+		blen = (int) Math.sqrt(n / 4);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index be90c2894..bf0c58041 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -118,7 +118,7 @@
 //}
 //
 //void prepare() {
-//    blen = (int)(sqrt(n) / 2);
+//    blen = (int)sqrt(n / 4);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) bi[i] = (i - 1) / blen + 1;
 //    for (int i = 1; i <= bnum; i++) {

From 53737b5466e7c14664425a128884f4c4fdecec65 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 19:03:27 +0800
Subject: [PATCH 1057/1712] modify code

---
 src/class173/Code05_HLD1.java    | 2 +-
 src/class173/Code05_HLD2.java    | 2 +-
 src/class173/Code06_Random1.java | 2 +-
 src/class173/Code06_Random2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code05_HLD1.java b/src/class173/Code05_HLD1.java
index 1a427d88d..88fce56b9 100644
--- a/src/class173/Code05_HLD1.java
+++ b/src/class173/Code05_HLD1.java
@@ -255,7 +255,7 @@ public static void updateAns(int x, int y) {
 	public static void prepare() {
 		dfs3();
 		dfs4();
-		blen = (int) Math.sqrt(20.0 * n);
+		blen = (int) Math.sqrt(n * 20);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
diff --git a/src/class173/Code05_HLD2.java b/src/class173/Code05_HLD2.java
index 9aa4aedce..3870ff4c9 100644
--- a/src/class173/Code05_HLD2.java
+++ b/src/class173/Code05_HLD2.java
@@ -119,7 +119,7 @@
 //void prepare() {
 //    dfs1(1, 0);
 //    dfs2(1, 1);
-//    blen = (int)sqrt(20.0 * n);
+//    blen = (int)sqrt(n * 20);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 594b682c7..623172587 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -210,7 +210,7 @@ public static void updateAns(int x, int y) {
 
 	public static void prepare() {
 		dfs2();
-		int len = (int) Math.sqrt(10.0 * n);
+		int len = (int) Math.sqrt(n * 10);
 		markNum = (n + len - 1) / len;
 		for (int b = 1, pick; b <= markNum; b++) {
 			do {
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index 1fc36616a..580c1b655 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -105,7 +105,7 @@
 //
 //void prepare() {
 //    dfs(1, 0);
-//    int len = (int)sqrt(10.0 * n);
+//    int len = (int)sqrt(n * 10);
 //    markNum = (n + len - 1) / len;
 //    for (int b = 1, pick; b <= markNum; b++) {
 //        do {

From 5fb494b460b79d0778fdf2b223ccb6cc6068199e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 19:21:48 +0800
Subject: [PATCH 1058/1712] modify code

---
 .../{Code08_RangeFatherMinus1.java => Code08_FatherMinus1.java} | 2 +-
 .../{Code08_RangeFatherMinus2.java => Code08_FatherMinus2.java} | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class173/{Code08_RangeFatherMinus1.java => Code08_FatherMinus1.java} (99%)
 rename src/class173/{Code08_RangeFatherMinus2.java => Code08_FatherMinus2.java} (100%)

diff --git a/src/class173/Code08_RangeFatherMinus1.java b/src/class173/Code08_FatherMinus1.java
similarity index 99%
rename from src/class173/Code08_RangeFatherMinus1.java
rename to src/class173/Code08_FatherMinus1.java
index 6a9ef3778..55b88f287 100644
--- a/src/class173/Code08_RangeFatherMinus1.java
+++ b/src/class173/Code08_FatherMinus1.java
@@ -15,7 +15,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code08_RangeFatherMinus1 {
+public class Code08_FatherMinus1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 501;
diff --git a/src/class173/Code08_RangeFatherMinus2.java b/src/class173/Code08_FatherMinus2.java
similarity index 100%
rename from src/class173/Code08_RangeFatherMinus2.java
rename to src/class173/Code08_FatherMinus2.java

From 2f93f66e59fd62b0236c28a1fa04cf27a7e13c0a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 30 Jun 2025 19:51:06 +0800
Subject: [PATCH 1059/1712] modify code

---
 src/class173/Code06_Random1.java | 4 +---
 src/class173/Code06_Random2.java | 1 -
 2 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 623172587..718bcae72 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -35,15 +35,13 @@ public class Code06_Random1 {
 	public static int[] dep = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
 
-	// 随机撒点，预处理阶段需要的信息
+	// 随机撒点
 	// markNum表示关键点数量
 	public static int markNum;
 	// vis[i]表示i号节点是否已经是关键点
 	public static boolean[] vis = new boolean[MAXN];
 	// markNode[k] = i 表示第k个关键点是编号为i的节点
 	public static int[] markNode = new int[MAXB];
-
-	// 随机撒点，预处理阶段生成的信息
 	// kthMark[i] = k 表示i号节点是第k个关键点，kthMark[i] = 0 表示i号节点是非关键点
 	public static int[] kthMark = new int[MAXN];
 	// up[i] = j，表示i号节点是关键点，它往上跳到最近的关键点是j号节点
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index 580c1b655..86b4dca17 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -34,7 +34,6 @@
 //int markNum;
 //bool vis[MAXN];
 //int markNode[MAXN];
-//
 //int kthMark[MAXN];
 //int up[MAXN];
 //bitset<MAXV> downSet[MAXB];

From 4ba0435f894e27451175af04d8e11797c827aef1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 13:36:00 +0800
Subject: [PATCH 1060/1712] modify code

---
 src/class173/Code01_Poker1.java | 15 +++++++++------
 src/class173/Code01_Poker2.java | 12 ++++++------
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/class173/Code01_Poker1.java b/src/class173/Code01_Poker1.java
index f37453906..cc60e469e 100644
--- a/src/class173/Code01_Poker1.java
+++ b/src/class173/Code01_Poker1.java
@@ -92,7 +92,8 @@ public static int getMax(int l, int r) {
 		return ans;
 	}
 
-	public static int getCnt(int i, int v) {
+	// 返回第i块内<= v的数字个数
+	public static int blockCnt(int i, int v) {
 		v -= lazy[i];
 		int l = bl[i], r = br[i];
 		if (sortv[l] > v) {
@@ -114,7 +115,8 @@ public static int getCnt(int i, int v) {
 		return find - bl[i] + 1;
 	}
 
-	public static int num(int l, int r, int v) {
+	// 返回[l..r]范围上<= v的数字个数
+	public static int getCnt(int l, int r, int v) {
 		int lb = bi[l], rb = bi[r], ans = 0;
 		if (lb == rb) {
 			for (int i = l; i <= r; i++) {
@@ -134,14 +136,14 @@ public static int num(int l, int r, int v) {
 				}
 			}
 			for (int i = lb + 1; i <= rb - 1; i++) {
-				ans += getCnt(i, v);
+				ans += blockCnt(i, v);
 			}
 		}
 		return ans;
 	}
 
-	public static int query(int l, int r, int v) {
-		if (v < 1 || v > r - l + 1) {
+	public static int query(int l, int r, int k) {
+		if (k < 1 || k > r - l + 1) {
 			return -1;
 		}
 		int minv = getMin(l, r);
@@ -150,7 +152,7 @@ public static int query(int l, int r, int v) {
 		int ans = -1;
 		while (minv <= maxv) {
 			midv = minv + (maxv - minv) / 2;
-			if (num(l, r, midv) >= v) {
+			if (getCnt(l, r, midv) >= k) {
 				ans = midv;
 				maxv = midv - 1;
 			} else {
@@ -160,6 +162,7 @@ public static int query(int l, int r, int v) {
 		return ans;
 	}
 
+	// 注意调整块长
 	public static void prepare() {
 		blen = (int) Math.sqrt(n / 2);
 		bnum = (n + blen - 1) / blen;
diff --git a/src/class173/Code01_Poker2.java b/src/class173/Code01_Poker2.java
index 36c4f4755..44b7984a3 100644
--- a/src/class173/Code01_Poker2.java
+++ b/src/class173/Code01_Poker2.java
@@ -89,7 +89,7 @@
 //    return ans;
 //}
 //
-//int getCnt(int i, int v) {
+//int blockCnt(int i, int v) {
 //    v -= lazy[i];
 //    int l = bl[i], r = br[i];
 //    if (sortv[l] > v) {
@@ -111,7 +111,7 @@
 //    return find - bl[i] + 1;
 //}
 //
-//int num(int l, int r, int v) {
+//int getCnt(int l, int r, int v) {
 //    int lb = bi[l], rb = bi[r], ans = 0;
 //    if (lb == rb) {
 //        for (int i = l; i <= r; i++) {
@@ -131,14 +131,14 @@
 //            }
 //        }
 //        for (int i = lb + 1; i <= rb - 1; i++) {
-//            ans += getCnt(i, v);
+//            ans += blockCnt(i, v);
 //        }
 //    }
 //    return ans;
 //}
 //
-//int query(int l, int r, int v) {
-//    if (v < 1 || v > r - l + 1) {
+//int query(int l, int r, int k) {
+//    if (k < 1 || k > r - l + 1) {
 //        return -1;
 //    }
 //    int minv = getMin(l, r);
@@ -146,7 +146,7 @@
 //    int ans = -1;
 //    while (minv <= maxv) {
 //        int midv = minv + (maxv - minv) / 2;
-//        if (num(l, r, midv) >= v) {
+//        if (getCnt(l, r, midv) >= k) {
 //            ans = midv;
 //            maxv = midv - 1;
 //        } else {

From aa7bd4236cf8415aed4b63ec2c69a6e136f44fb3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 15:42:26 +0800
Subject: [PATCH 1061/1712] modify code

---
 src/class173/Code01_Poker1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code01_Poker1.java b/src/class173/Code01_Poker1.java
index cc60e469e..3930eb93b 100644
--- a/src/class173/Code01_Poker1.java
+++ b/src/class173/Code01_Poker1.java
@@ -115,7 +115,7 @@ public static int blockCnt(int i, int v) {
 		return find - bl[i] + 1;
 	}
 
-	// 返回[l..r]范围上<= v的数字个数
+	// 返回arr[l..r]范围上<= v的数字个数
 	public static int getCnt(int l, int r, int v) {
 		int lb = bi[l], rb = bi[r], ans = 0;
 		if (lb == rb) {

From c4361fb7cf773f8b496ad8cc7dc87ded733a58fc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 17:23:52 +0800
Subject: [PATCH 1062/1712] modify code

---
 src/class173/Code02_Sequence1.java | 6 ++++--
 1 file changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code02_Sequence1.java b/src/class173/Code02_Sequence1.java
index f1fb2f6d2..a9aa70e18 100644
--- a/src/class173/Code02_Sequence1.java
+++ b/src/class173/Code02_Sequence1.java
@@ -29,9 +29,9 @@ public class Code02_Sequence1 {
 	public static int cnte = 0;
 	public static int cntq = 0;
 
-	// 时间块内的值
+	// tim[i] = v，表示在i号时间点，所有数字都增加v
 	public static long[] tim = new long[MAXN];
-	// 每块的值排序
+	// 时间块内的所有值要排序，方便查询 >= v的数字个数
 	public static long[] sortv = new long[MAXN];
 
 	// 时间分块
@@ -41,6 +41,7 @@ public class Code02_Sequence1 {
 	public static int[] br = new int[MAXB];
 	public static long[] lazy = new long[MAXB];
 
+	// 每个查询的答案
 	public static int[] ans = new int[MAXN];
 
 	public static void addChange(int x, int t, int v) {
@@ -94,6 +95,7 @@ public static int innerQuery(int l, int r, long v) {
 		return ans;
 	}
 
+	// 第i块内>= v的数字个数
 	public static int getCnt(int i, long v) {
 		v -= lazy[i];
 		int l = bl[i], r = br[i], m, pos = br[i] + 1;

From 715a392c5860a07ac4c4bec180d17747faec705c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 17:53:58 +0800
Subject: [PATCH 1063/1712] modify code

---
 src/class173/Code02_Sequence1.java | 31 +++++++++++++++---------------
 src/class173/Code02_Sequence2.java | 30 ++++++++++++++---------------
 2 files changed, 31 insertions(+), 30 deletions(-)

diff --git a/src/class173/Code02_Sequence1.java b/src/class173/Code02_Sequence1.java
index a9aa70e18..38faa801d 100644
--- a/src/class173/Code02_Sequence1.java
+++ b/src/class173/Code02_Sequence1.java
@@ -44,21 +44,6 @@ public class Code02_Sequence1 {
 	// 每个查询的答案
 	public static int[] ans = new int[MAXN];
 
-	public static void addChange(int x, int t, int v) {
-		event[++cnte][0] = 1;
-		event[cnte][1] = x;
-		event[cnte][2] = t;
-		event[cnte][3] = v;
-	}
-
-	public static void addQuery(int x, int t, int v) {
-		event[++cnte][0] = 2;
-		event[cnte][1] = x;
-		event[cnte][2] = t;
-		event[cnte][3] = v;
-		event[cnte][4] = ++cntq;
-	}
-
 	public static void innerAdd(int l, int r, long v) {
 		for (int i = l; i <= r; i++) {
 			tim[i] += v;
@@ -128,6 +113,21 @@ public static int query(int l, int r, long v) {
 		return ans;
 	}
 
+	public static void addChange(int x, int t, int v) {
+		event[++cnte][0] = 1;
+		event[cnte][1] = x;
+		event[cnte][2] = t;
+		event[cnte][3] = v;
+	}
+
+	public static void addQuery(int x, int t, int v) {
+		event[++cnte][0] = 2;
+		event[cnte][1] = x;
+		event[cnte][2] = t;
+		event[cnte][3] = v;
+		event[cnte][4] = ++cntq;
+	}
+
 	public static void prepare() {
 		blen = (int) Math.sqrt(m);
 		bnum = (m + blen - 1) / blen;
@@ -138,6 +138,7 @@ public static void prepare() {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, m);
 		}
+		// 所有事件根据位置x排序，位置一样的事件，修改事件先执行，查询事件后执行
 		Arrays.sort(event, 1, cnte + 1, (a, b) -> a[1] != b[1] ? a[1] - b[1] : a[2] - b[2]);
 	}
 
diff --git a/src/class173/Code02_Sequence2.java b/src/class173/Code02_Sequence2.java
index f01340edb..ea2ab6689 100644
--- a/src/class173/Code02_Sequence2.java
+++ b/src/class173/Code02_Sequence2.java
@@ -42,21 +42,6 @@
 //
 //int ans[MAXN];
 //
-//void addChange(int x, int t, int v) {
-//    event[++cnte].op = 1;
-//    event[cnte].x = x;
-//    event[cnte].t = t;
-//    event[cnte].v = v;
-//}
-//
-//void addQuery(int x, int t, int v) {
-//    event[++cnte].op = 2;
-//    event[cnte].x = x;
-//    event[cnte].t = t;
-//    event[cnte].v = v;
-//    event[cnte].q = ++cntq;
-//}
-//
 //void innerAdd(int l, int r, long long v) {
 //    for (int i = l; i <= r; i++) {
 //        tim[i] += v;
@@ -125,6 +110,21 @@
 //    return ans;
 //}
 //
+//void addChange(int x, int t, int v) {
+//    event[++cnte].op = 1;
+//    event[cnte].x = x;
+//    event[cnte].t = t;
+//    event[cnte].v = v;
+//}
+//
+//void addQuery(int x, int t, int v) {
+//    event[++cnte].op = 2;
+//    event[cnte].x = x;
+//    event[cnte].t = t;
+//    event[cnte].v = v;
+//    event[cnte].q = ++cntq;
+//}
+//
 //void prepare() {
 //    blen = (int)sqrt(m);
 //    bnum = (m + blen - 1) / blen;

From 5c13e376872fc3f361fdd14c8aa765992586bb4e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 18:05:22 +0800
Subject: [PATCH 1064/1712] modify code

---
 src/class173/Code03_Magnet1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index 3aa7e3d39..189d3c975 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -137,7 +137,7 @@ public static int bfs() {
 						que[r++] = i;
 						ans++;
 					}
-					bl[b]++;
+					bl[b]++; // 重要剪枝逻辑
 				}
 			}
 		}

From 59e6d0e7c256233e0db51d1ea09b31b9a7afde7c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 18:30:18 +0800
Subject: [PATCH 1065/1712] modify code

---
 src/class173/Code03_Magnet1.java | 23 ++++++++++++-----------
 src/class173/Code03_Magnet2.java | 21 +++++++++++----------
 2 files changed, 23 insertions(+), 21 deletions(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index 189d3c975..e76854128 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -11,7 +11,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
 // 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-// 为了这道题能用java通过，我没有把数据封装到一起，组成一个磁块对象
+// 为了这道题能用java通过，不把数据封装到一起组成一个磁块对象
 // 手写了双指针快排优化常数时间，一般不需要这么做，正式比赛不卡常
 
 import java.io.IOException;
@@ -120,7 +120,17 @@ public static int bfs() {
 		while (l < r) {
 			int cur = que[l++];
 			for (int b = 1; b <= bnum; b++) {
-				if (maxm[b] > p[cur]) {
+				if (maxm[b] <= p[cur]) {
+					while (bl[b] <= br[b] && dist[bl[b]] <= range[cur]) {
+						int i = bl[b];
+						if (!vis[i]) {
+							vis[i] = true;
+							que[r++] = i;
+							ans++;
+						}
+						bl[b]++; // 重要剪枝逻辑
+					}
+				} else {
 					for (int j = bl[b]; j <= br[b]; j++) {
 						if (dist[j] <= range[cur] && m[j] <= p[cur] && !vis[j]) {
 							vis[j] = true;
@@ -130,15 +140,6 @@ public static int bfs() {
 					}
 					break;
 				}
-				while (bl[b] <= br[b] && dist[bl[b]] <= range[cur]) {
-					int i = bl[b];
-					if (!vis[i]) {
-						vis[i] = true;
-						que[r++] = i;
-						ans++;
-					}
-					bl[b]++; // 重要剪枝逻辑
-				}
 			}
 		}
 		return ans;
diff --git a/src/class173/Code03_Magnet2.java b/src/class173/Code03_Magnet2.java
index 26cb94ba9..5ae4d94fb 100644
--- a/src/class173/Code03_Magnet2.java
+++ b/src/class173/Code03_Magnet2.java
@@ -70,7 +70,17 @@
 //    while (l < r) {
 //        int cur = que[l++];
 //        for (int b = 1; b <= bnum; b++) {
-//            if (maxm[b] > arr[cur].p) {
+//            if (maxm[b] <= arr[cur].p) {
+//                while (bl[b] <= br[b] && arr[bl[b]].dist <= arr[cur].range) {
+//                    int i = bl[b];
+//                    if (!vis[i]) {
+//                        vis[i] = true;
+//                        que[r++] = i;
+//                        ans++;
+//                    }
+//                    bl[b]++;
+//                }
+//            } else {
 //                for (int i = bl[b]; i <= br[b]; i++) {
 //                    if (arr[i].dist <= arr[cur].range && arr[i].m <= arr[cur].p && !vis[i]) {
 //                        vis[i] = true;
@@ -80,15 +90,6 @@
 //                }
 //                break;
 //            }
-//            while (bl[b] <= br[b] && arr[bl[b]].dist <= arr[cur].range) {
-//                int i = bl[b];
-//                if (!vis[i]) {
-//                    vis[i] = true;
-//                    que[r++] = i;
-//                    ans++;
-//                }
-//                bl[b]++;
-//            }
 //        }
 //    }
 //    return ans;

From 7b9d51c6ea8aa5bfa53d5be3326b03ce86a1e750 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 18:32:57 +0800
Subject: [PATCH 1066/1712] modify code

---
 src/class173/Code03_Magnet1.java | 34 ++++++++++++++++----------------
 src/class173/Code03_Magnet2.java | 34 ++++++++++++++++----------------
 2 files changed, 34 insertions(+), 34 deletions(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index e76854128..c7984292e 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -95,23 +95,6 @@ public static void sortByDist(int l, int r) {
 		sortByDist(i, r);
 	}
 
-	public static void prepare() {
-		blen = (int) Math.sqrt(n);
-		bnum = (n + blen - 1) / blen;
-		for (int i = 1; i <= n; i++) {
-			bi[i] = (i - 1) / blen + 1;
-		}
-		for (int i = 1; i <= bnum; i++) {
-			bl[i] = (i - 1) * blen + 1;
-			br[i] = Math.min(i * blen, n);
-		}
-		sortByM(1, n);
-		for (int i = 1; i <= bnum; i++) {
-			maxm[i] = m[br[i]];
-			sortByDist(bl[i], br[i]);
-		}
-	}
-
 	public static int bfs() {
 		int ans = 0;
 		vis[0] = true;
@@ -145,6 +128,23 @@ public static int bfs() {
 		return ans;
 	}
 
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		sortByM(1, n);
+		for (int i = 1; i <= bnum; i++) {
+			maxm[i] = m[br[i]];
+			sortByDist(bl[i], br[i]);
+		}
+	}
+
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
diff --git a/src/class173/Code03_Magnet2.java b/src/class173/Code03_Magnet2.java
index 5ae4d94fb..7e14a8bab 100644
--- a/src/class173/Code03_Magnet2.java
+++ b/src/class173/Code03_Magnet2.java
@@ -45,23 +45,6 @@
 //bool vis[MAXN];
 //int que[MAXN];
 //
-//void prepare() {
-//    blen = (int)sqrt(n);
-//    bnum = (n + blen - 1) / blen;
-//    for (int i = 1; i <= n; i++) {
-//        bi[i] = (i - 1) / blen + 1;
-//    }
-//    for (int i = 1; i <= bnum; i++) {
-//        bl[i] = (i - 1) * blen + 1;
-//        br[i] = min(i * blen, n);
-//    }
-//    sort(arr + 1, arr + n + 1, cmp1);
-//    for (int i = 1; i <= bnum; i++) {
-//        maxm[i] = arr[br[i]].m;
-//        sort(arr + bl[i], arr + br[i] + 1, cmp2);
-//    }
-//}
-//
 //int bfs() {
 //    int ans = 0;
 //    vis[0] = true;
@@ -95,6 +78,23 @@
 //    return ans;
 //}
 //
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    sort(arr + 1, arr + n + 1, cmp1);
+//    for (int i = 1; i <= bnum; i++) {
+//        maxm[i] = arr[br[i]].m;
+//        sort(arr + bl[i], arr + br[i] + 1, cmp2);
+//    }
+//}
+//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);

From ac8a593ac2e971402cf41ddee3124b9956a199cf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 18:34:09 +0800
Subject: [PATCH 1067/1712] modify code

---
 src/class173/Code03_Magnet2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code03_Magnet2.java b/src/class173/Code03_Magnet2.java
index 7e14a8bab..623bf0deb 100644
--- a/src/class173/Code03_Magnet2.java
+++ b/src/class173/Code03_Magnet2.java
@@ -42,8 +42,8 @@
 //int br[MAXB];
 //int maxm[MAXB];
 //
-//bool vis[MAXN];
 //int que[MAXN];
+//bool vis[MAXN];
 //
 //int bfs() {
 //    int ans = 0;

From ae36473d2538536d3d77f862f224c56cfc2d390d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 18:35:26 +0800
Subject: [PATCH 1068/1712] modify code

---
 src/class173/Code03_Magnet1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index c7984292e..990fee72d 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -57,7 +57,8 @@ public static void sortByM(int l, int r) {
 		if (l >= r) {
 			return;
 		}
-		int i = l, j = r, pivot = m[(l + r) >>> 1];
+		int i = l, j = r;
+		int pivot = m[(l + r) >>> 1];
 		while (i <= j) {
 			while (m[i] < pivot) {
 				i++;

From 102d7a5933ae1e345b09f37084678f264c41cc51 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 18:38:02 +0800
Subject: [PATCH 1069/1712] modify code

---
 src/class173/Code03_Magnet1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index 990fee72d..a371117e4 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -11,7 +11,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P10590
 // 测试链接 : https://codeforces.com/problemset/problem/198/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-// 为了这道题能用java通过，不把数据封装到一起组成一个磁块对象
+// 为了java的实现能通过，不把数据封装成一个磁块对象，然后去排序
 // 手写了双指针快排优化常数时间，一般不需要这么做，正式比赛不卡常
 
 import java.io.IOException;

From 54dff74f2b21752b54308424729dcb69352a1df7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 21:07:26 +0800
Subject: [PATCH 1070/1712] modify code

---
 src/class173/Code04_Inversion1.java | 16 ++++++++++++----
 src/class173/Code04_Inversion2.java |  8 ++++----
 2 files changed, 16 insertions(+), 8 deletions(-)

diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index c6e37799c..64cffaa31 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -31,11 +31,16 @@ public class Code04_Inversion1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
+	// 树状数组
 	public static int[] tree = new int[MAXN];
 
+	// pre[i] : 从所在块最左位置到i位置，有多少逆序对
 	public static int[] pre = new int[MAXN];
+	// suf[i] : 从i位置到所在块最右位置，有多少逆序对
 	public static int[] suf = new int[MAXN];
+	// cnt[i][j] : 前i块里<=j的数字个数
 	public static int[][] cnt = new int[MAXB][MAXN];
+	// dp[i][j] : 从第i块到第j块有多少逆序对
 	public static long[][] dp = new long[MAXB][MAXB];
 
 	public static int lowbit(int i) {
@@ -58,17 +63,20 @@ public static int sum(int i) {
 		return ret;
 	}
 
+	// 更靠左的第x块，从xl到xr范围上，选第一个数
+	// 更靠左的第y块，从yl到yr范围上，选第二个数
+	// 这两个数一定要构成逆序对，返回这样的逆序对数量
 	public static int calc(int x, int xl, int xr, int y, int yl, int yr) {
 		int ans = 0;
-		for (int p1 = bl[x], p2 = bl[y] - 1, tmp = 0; p1 <= br[x]; p1++) {
+		for (int p1 = bl[x], p2 = bl[y] - 1, cnt = 0; p1 <= br[x]; p1++) {
 			if (xl <= sortv[p1][1] && sortv[p1][1] <= xr) {
 				while (p2 + 1 <= br[y] && sortv[p1][0] > sortv[p2 + 1][0]) {
 					p2++;
 					if (yl <= sortv[p2][1] && sortv[p2][1] <= yr) {
-						tmp++;
+						cnt++;
 					}
 				}
-				ans += tmp;
+				ans += cnt;
 			}
 		}
 		return ans;
@@ -139,9 +147,9 @@ public static void prepare() {
 				tmp += cnt[i][j];
 				cnt[i][j] = tmp + cnt[i - 1][j];
 			}
-			dp[i][i] = pre[br[i]];
 		}
 		for (int l = bnum; l >= 1; l--) {
+			dp[l][l] = pre[br[l]];
 			for (int r = l + 1; r <= bnum; r++) {
 				dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
 			}
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index bf0c58041..f9f0776f2 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -82,15 +82,15 @@
 //
 //inline int calc(int x, int xl, int xr, int y, int yl, int yr) {
 //    int ans = 0;
-//    for (int p1 = bl[x], p2 = bl[y] - 1, tmp = 0; p1 <= br[x]; p1++) {
+//    for (int p1 = bl[x], p2 = bl[y] - 1, cnt = 0; p1 <= br[x]; p1++) {
 //        if (xl <= sortv[p1].i && sortv[p1].i <= xr) {
 //            while (p2 + 1 <= br[y] && sortv[p1].v > sortv[p2 + 1].v) {
 //                p2++;
 //                if (yl <= sortv[p2].i && sortv[p2].i <= yr) {
-//                    tmp++;
+//                    cnt++;
 //                }
 //            }
-//            ans += tmp;
+//            ans += cnt;
 //        }
 //    }
 //    return ans;
@@ -157,9 +157,9 @@
 //            tmp += cnt[i][j];
 //            cnt[i][j] = tmp + cnt[i - 1][j];
 //        }
-//        dp[i][i] = pre[br[i]];
 //    }
 //    for (int l = bnum; l >= 1; l--) {
+//        dp[l][l] = pre[br[l]];
 //        for (int r = l + 1; r <= bnum; r++) {
 //            dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
 //        }

From 5b4749f5cbda40107d60407b31ba29d247dd0ddc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 21:28:55 +0800
Subject: [PATCH 1071/1712] modify code

---
 src/class173/Code04_Inversion1.java | 12 ++++++------
 src/class173/Code04_Inversion2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index 64cffaa31..7e9b90375 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -1,7 +1,7 @@
 package class173;
 
 // 区间逆序对，java版
-// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 给定一个长度为n的排列，接下来有m条操作，每条操作格式如下
 // 操作 l r : 打印arr[l..r]范围上的逆序对数量
 // 1 <= n、m <= 10^5
 // 题目要求强制在线，具体规则可以打开测试链接查看
@@ -66,7 +66,7 @@ public static int sum(int i) {
 	// 更靠左的第x块，从xl到xr范围上，选第一个数
 	// 更靠左的第y块，从yl到yr范围上，选第二个数
 	// 这两个数一定要构成逆序对，返回这样的逆序对数量
-	public static int calc(int x, int xl, int xr, int y, int yl, int yr) {
+	public static int f(int x, int xl, int xr, int y, int yl, int yr) {
 		int ans = 0;
 		for (int p1 = bl[x], p2 = bl[y] - 1, cnt = 0; p1 <= br[x]; p1++) {
 			if (xl <= sortv[p1][1] && sortv[p1][1] <= xr) {
@@ -90,16 +90,16 @@ public static long query(int l, int r) {
 			if (l == bl[lb]) {
 				ans = pre[r];
 			} else {
-				ans = pre[r] - pre[l - 1] - calc(lb, 1, l - 1, lb, l, r);
+				ans = pre[r] - pre[l - 1] - f(lb, 1, l - 1, lb, l, r);
 			}
 		} else {
 			for (int i = l; i <= br[lb]; i++) {
 				ans += cnt[rb - 1][arr[i]] - cnt[lb][arr[i]];
 			}
 			for (int i = bl[rb]; i <= r; i++) {
-				ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
+				ans += br[rb - 1] - bl[lb + 1] + 1 - (cnt[rb - 1][arr[i]] - cnt[lb][arr[i]]);
 			}
-			ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
+			ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + f(lb, l, br[lb], rb, bl[rb], r);
 		}
 		return ans;
 	}
@@ -151,7 +151,7 @@ public static void prepare() {
 		for (int l = bnum; l >= 1; l--) {
 			dp[l][l] = pre[br[l]];
 			for (int r = l + 1; r <= bnum; r++) {
-				dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
+				dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + f(l, bl[l], br[l], r, bl[r], br[r]);
 			}
 		}
 	}
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index f9f0776f2..f6a5ff166 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -1,7 +1,7 @@
 package class173;
 
 // 区间逆序对，C++版
-// 给定一个长度为n的数组arr，接下来有m条操作，每条操作格式如下
+// 给定一个长度为n的排列，接下来有m条操作，每条操作格式如下
 // 操作 l r : 打印arr[l..r]范围上的逆序对数量
 // 1 <= n、m <= 10^5
 // 题目要求强制在线，具体规则可以打开测试链接查看
@@ -80,7 +80,7 @@
 //    return ret;
 //}
 //
-//inline int calc(int x, int xl, int xr, int y, int yl, int yr) {
+//inline int f(int x, int xl, int xr, int y, int yl, int yr) {
 //    int ans = 0;
 //    for (int p1 = bl[x], p2 = bl[y] - 1, cnt = 0; p1 <= br[x]; p1++) {
 //        if (xl <= sortv[p1].i && sortv[p1].i <= xr) {
@@ -103,16 +103,16 @@
 //        if (l == bl[lb]) {
 //            ans = pre[r];
 //        } else {
-//            ans = pre[r] - pre[l - 1] - calc(lb, 1, l - 1, lb, l, r);
+//            ans = pre[r] - pre[l - 1] - f(lb, 1, l - 1, lb, l, r);
 //        }
 //    } else {
 //        for (int i = l; i <= br[lb]; i++) {
 //            ans += cnt[rb - 1][arr[i]] - cnt[lb][arr[i]];
 //        }
 //        for (int i = bl[rb]; i <= r; i++) {
-//            ans += br[rb - 1] - bl[lb + 1] + 1 - cnt[rb - 1][arr[i]] + cnt[lb][arr[i]];
+//            ans += br[rb - 1] - bl[lb + 1] + 1 - (cnt[rb - 1][arr[i]] - cnt[lb][arr[i]]);
 //        }
-//        ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + calc(lb, l, br[lb], rb, bl[rb], r);
+//        ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + f(lb, l, br[lb], rb, bl[rb], r);
 //    }
 //    return ans;
 //}
@@ -161,7 +161,7 @@
 //    for (int l = bnum; l >= 1; l--) {
 //        dp[l][l] = pre[br[l]];
 //        for (int r = l + 1; r <= bnum; r++) {
-//            dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + calc(l, bl[l], br[l], r, bl[r], br[r]);
+//            dp[l][r] = dp[l + 1][r] + dp[l][r - 1] - dp[l + 1][r - 1] + f(l, bl[l], br[l], r, bl[r], br[r]);
 //        }
 //    }
 //}

From 7000e81ab6f02e4c86b45bdca4678431508fc8a3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 21:43:13 +0800
Subject: [PATCH 1072/1712] modify code

---
 src/class173/Code04_Inversion1.java | 12 ++++++++++--
 src/class173/Code04_Inversion2.java |  2 +-
 2 files changed, 11 insertions(+), 3 deletions(-)

diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index 7e9b90375..a6d4511e4 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -65,7 +65,7 @@ public static int sum(int i) {
 
 	// 更靠左的第x块，从xl到xr范围上，选第一个数
 	// 更靠左的第y块，从yl到yr范围上，选第二个数
-	// 这两个数一定要构成逆序对，返回这样的逆序对数量
+	// 返回逆序对数量
 	public static int f(int x, int xl, int xr, int y, int yl, int yr) {
 		int ans = 0;
 		for (int p1 = bl[x], p2 = bl[y] - 1, cnt = 0; p1 <= br[x]; p1++) {
@@ -90,15 +90,23 @@ public static long query(int l, int r) {
 			if (l == bl[lb]) {
 				ans = pre[r];
 			} else {
-				ans = pre[r] - pre[l - 1] - f(lb, 1, l - 1, lb, l, r);
+				ans = pre[r] - pre[l - 1] - f(lb, bl[lb], l - 1, lb, l, r);
 			}
 		} else {
+			// 左散块中的arr[i]，作为第一个数
+			// 中间整块中的某个数字，作为第二个数
+			// 计算这样的逆序对数量
+			// 注意因为题目给定的是排列！所以如下这么写没问题
 			for (int i = l; i <= br[lb]; i++) {
 				ans += cnt[rb - 1][arr[i]] - cnt[lb][arr[i]];
 			}
+			// 中间整块中的某个数字，作为第一个数
+			// 右散块中的arr[i]，作为第二个数
+			// 计算这样的逆序对数量
 			for (int i = bl[rb]; i <= r; i++) {
 				ans += br[rb - 1] - bl[lb + 1] + 1 - (cnt[rb - 1][arr[i]] - cnt[lb][arr[i]]);
 			}
+			// 中间整块的逆序对 + 左散块[l..]的逆序对 + 右散块[..r]的逆序对 + 左散块 结合 右散块 的逆序对
 			ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + f(lb, l, br[lb], rb, bl[rb], r);
 		}
 		return ans;
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index f6a5ff166..ece8fdc40 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -103,7 +103,7 @@
 //        if (l == bl[lb]) {
 //            ans = pre[r];
 //        } else {
-//            ans = pre[r] - pre[l - 1] - f(lb, 1, l - 1, lb, l, r);
+//            ans = pre[r] - pre[l - 1] - f(lb, bl[lb], l - 1, lb, l, r);
 //        }
 //    } else {
 //        for (int i = l; i <= br[lb]; i++) {

From e8a21a9ddb22f6e18a89d532ba6ec72a0ace5317 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 1 Jul 2025 23:43:28 +0800
Subject: [PATCH 1073/1712] modify code

---
 src/class173/Code04_Inversion1.java | 12 ++++++++----
 src/class173/Code04_Inversion2.java |  3 ++-
 2 files changed, 10 insertions(+), 5 deletions(-)

diff --git a/src/class173/Code04_Inversion1.java b/src/class173/Code04_Inversion1.java
index a6d4511e4..70774f398 100644
--- a/src/class173/Code04_Inversion1.java
+++ b/src/class173/Code04_Inversion1.java
@@ -24,6 +24,7 @@ public class Code04_Inversion1 {
 	public static int MAXB = 701;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
+	// (数值、位置)
 	public static int[][] sortv = new int[MAXN][2];
 
 	public static int blen, bnum;
@@ -31,7 +32,7 @@ public class Code04_Inversion1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
-	// 树状数组
+	// 树状数组，为了快速生成pre数组和suf数组
 	public static int[] tree = new int[MAXN];
 
 	// pre[i] : 从所在块最左位置到i位置，有多少逆序对
@@ -64,7 +65,8 @@ public static int sum(int i) {
 	}
 
 	// 更靠左的第x块，从xl到xr范围上，选第一个数
-	// 更靠左的第y块，从yl到yr范围上，选第二个数
+	// 更靠右的第y块，从yl到yr范围上，选第二个数
+	// x和y可以相等，但是xl..xr需要在yl..yr的左侧
 	// 返回逆序对数量
 	public static int f(int x, int xl, int xr, int y, int yl, int yr) {
 		int ans = 0;
@@ -93,6 +95,8 @@ public static long query(int l, int r) {
 				ans = pre[r] - pre[l - 1] - f(lb, bl[lb], l - 1, lb, l, r);
 			}
 		} else {
+			// 左散块[l..]内部逆序对 + 右散块[..r]内部逆序对 + 左散块 结合 右散块 的逆序对
+			ans = suf[l] + pre[r] + f(lb, l, br[lb], rb, bl[rb], r);
 			// 左散块中的arr[i]，作为第一个数
 			// 中间整块中的某个数字，作为第二个数
 			// 计算这样的逆序对数量
@@ -106,8 +110,8 @@ public static long query(int l, int r) {
 			for (int i = bl[rb]; i <= r; i++) {
 				ans += br[rb - 1] - bl[lb + 1] + 1 - (cnt[rb - 1][arr[i]] - cnt[lb][arr[i]]);
 			}
-			// 中间整块的逆序对 + 左散块[l..]的逆序对 + 右散块[..r]的逆序对 + 左散块 结合 右散块 的逆序对
-			ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + f(lb, l, br[lb], rb, bl[rb], r);
+			// 中间整块的逆序对
+			ans += dp[lb + 1][rb - 1];
 		}
 		return ans;
 	}
diff --git a/src/class173/Code04_Inversion2.java b/src/class173/Code04_Inversion2.java
index ece8fdc40..a259b839a 100644
--- a/src/class173/Code04_Inversion2.java
+++ b/src/class173/Code04_Inversion2.java
@@ -106,13 +106,14 @@
 //            ans = pre[r] - pre[l - 1] - f(lb, bl[lb], l - 1, lb, l, r);
 //        }
 //    } else {
+//        ans = suf[l] + pre[r] + f(lb, l, br[lb], rb, bl[rb], r);
 //        for (int i = l; i <= br[lb]; i++) {
 //            ans += cnt[rb - 1][arr[i]] - cnt[lb][arr[i]];
 //        }
 //        for (int i = bl[rb]; i <= r; i++) {
 //            ans += br[rb - 1] - bl[lb + 1] + 1 - (cnt[rb - 1][arr[i]] - cnt[lb][arr[i]]);
 //        }
-//        ans += dp[lb + 1][rb - 1] + suf[l] + pre[r] + f(lb, l, br[lb], rb, bl[rb], r);
+//        ans += dp[lb + 1][rb - 1];
 //    }
 //    return ans;
 //}

From 19be945c8f5511d6cde5b817f0d04bd165770098 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 10:02:13 +0800
Subject: [PATCH 1074/1712] modify code

---
 src/class173/Code07_Royal1.java | 4 ++--
 src/class173/Code07_Royal2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index 601d6ae09..1dcf80273 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -46,9 +46,9 @@ public static void dfs(int u, int f) {
 			v = to[e];
 			if (v != f) {
 				dfs(v, u);
-				if (siz - tmp >= b) {
+				if (siz >= tmp + b) {
 					capital[++cntb] = u;
-					while (siz > tmp) {
+					while (siz != tmp) {
 						belong[stack[siz--]] = cntb;
 					}
 				}
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
index 9e67bbd8e..11ac39804 100644
--- a/src/class173/Code07_Royal2.java
+++ b/src/class173/Code07_Royal2.java
@@ -44,9 +44,9 @@
 //        v = to[e];
 //        if (v != f) {
 //            dfs(v, u);
-//            if (siz - tmp >= b) {
+//            if (siz >= tmp + b) {
 //                capital[++cntb] = u;
-//                while (siz > tmp) {
+//                while (siz != tmp) {
 //                    belong[sta[siz--]] = cntb;
 //                }
 //            }

From 000791207af204f05332818b55f9c5ce4f9a3322 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 10:37:30 +0800
Subject: [PATCH 1075/1712] modify code

---
 src/class173/Code08_FatherMinus1.java | 20 +++++++++++---------
 src/class173/Code08_FatherMinus2.java | 18 +++++++++---------
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/src/class173/Code08_FatherMinus1.java b/src/class173/Code08_FatherMinus1.java
index 55b88f287..194b27d71 100644
--- a/src/class173/Code08_FatherMinus1.java
+++ b/src/class173/Code08_FatherMinus1.java
@@ -2,7 +2,7 @@
 
 // 区间父变小，java版
 // 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，给定arr[2..n]
-// 接下来有m条操作，每种操作是如下两种类型中的一种
+// 对于每个i > 1，都有arr[i] < i，下来有m条操作，操作类型如下
 // 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
 // 操作 x y   : 查询点x和点y的最低公共祖先
 // 2 <= n、m <= 10^5
@@ -60,10 +60,12 @@ public static void update(int l, int r, int v) {
 				arr[i] = Math.max(1, arr[i] - v);
 			}
 			innerUpdate(bi[r]);
-			for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-				lazy[i] = Math.min(n, lazy[i] + v);
-				if (++cnt[i] <= blen) {
-					innerUpdate(i);
+			for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
+				// 减少的幅度最多到n，不会更大
+				// 这样还可以让lazy保持int类型并且不溢出
+				lazy[b] = Math.min(n, lazy[b] + v);
+				if (++cnt[b] <= blen) {
+					innerUpdate(b);
 				}
 			}
 		}
@@ -79,16 +81,16 @@ public static int jumpOut(int i) {
 
 	public static int lca(int x, int y) {
 		while (bi[x] != bi[y] || jumpOut(x) != jumpOut(y)) {
-			if (bi[x] == bi[y]) {
-				x = jumpOut(x);
-				y = jumpOut(y);
-			} else {
+			if (bi[x] != bi[y]) {
 				if (bi[x] < bi[y]) {
 					int tmp = x;
 					x = y;
 					y = tmp;
 				}
 				x = jumpOut(x);
+			} else {
+				x = jumpOut(x);
+				y = jumpOut(y);
 			}
 		}
 		while (x != y) {
diff --git a/src/class173/Code08_FatherMinus2.java b/src/class173/Code08_FatherMinus2.java
index 6f85ac6b1..9dcc69c0b 100644
--- a/src/class173/Code08_FatherMinus2.java
+++ b/src/class173/Code08_FatherMinus2.java
@@ -2,7 +2,7 @@
 
 // 区间父变小，C++版
 // 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，给定arr[2..n]
-// 接下来有m条操作，每种操作是如下两种类型中的一种
+// 对于每个i > 1，都有arr[i] < i，下来有m条操作，操作类型如下
 // 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
 // 操作 x y   : 查询点x和点y的最低公共祖先
 // 2 <= n、m <= 10^5
@@ -58,10 +58,10 @@
 //            arr[i] = max(1, arr[i] - v);
 //        }
 //        innerUpdate(bi[r]);
-//        for (int i = bi[l] + 1; i <= bi[r] - 1; i++) {
-//            lazy[i] = min(n, lazy[i] + v);
-//            if (++cnt[i] <= blen) {
-//                innerUpdate(i);
+//        for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
+//            lazy[b] = min(n, lazy[b] + v);
+//            if (++cnt[b] <= blen) {
+//                innerUpdate(b);
 //            }
 //        }
 //    }
@@ -77,14 +77,14 @@
 //
 //int lca(int x, int y) {
 //    while (bi[x] != bi[y] || jumpOut(x) != jumpOut(y)) {
-//        if (bi[x] == bi[y]) {
-//            x = jumpOut(x);
-//            y = jumpOut(y);
-//        } else {
+//        if (bi[x] != bi[y]) {
 //            if (bi[x] < bi[y]) {
 //                swap(x, y);
 //            }
 //            x = jumpOut(x);
+//        } else {
+//            x = jumpOut(x);
+//            y = jumpOut(y);
 //        }
 //    }
 //    while (x != y) {

From e4784ae58fbda3e8f103c3e376395a0a499be9d8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 10:56:04 +0800
Subject: [PATCH 1076/1712] modify code

---
 src/class173/Code08_FatherMinus1.java | 29 +++++++++++++--------------
 src/class173/Code08_FatherMinus2.java | 29 +++++++++++++--------------
 2 files changed, 28 insertions(+), 30 deletions(-)

diff --git a/src/class173/Code08_FatherMinus1.java b/src/class173/Code08_FatherMinus1.java
index 194b27d71..473b05881 100644
--- a/src/class173/Code08_FatherMinus1.java
+++ b/src/class173/Code08_FatherMinus1.java
@@ -1,9 +1,9 @@
 package class173;
 
 // 区间父变小，java版
-// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，给定arr[2..n]
-// 对于每个i > 1，都有arr[i] < i，下来有m条操作，操作类型如下
-// 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
+// 一棵大小为n树，节点1是树头，给定fa[2..n]表示父亲节点编号
+// 对于每个i > 1，都有fa[i] < i，下来有m条操作，操作类型如下
+// 操作 x y z : [x..y]范围上任何一点i，fa[i] = max(1, fa[i] - z)
 // 操作 x y   : 查询点x和点y的最低公共祖先
 // 2 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1491H
@@ -20,27 +20,26 @@ public class Code08_FatherMinus1 {
 	public static int MAXN = 100001;
 	public static int MAXB = 501;
 	public static int n, m;
-	public static int[] arr = new int[MAXN];
+	public static int[] fa = new int[MAXN];
+	public static int[] outer = new int[MAXN];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
-
 	public static int[] lazy = new int[MAXB];
-	public static int[] outer = new int[MAXN];
 	public static int[] cnt = new int[MAXB];
 
 	public static void innerUpdate(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
-			arr[i] = Math.max(1, arr[i] - lazy[b]);
+			fa[i] = Math.max(1, fa[i] - lazy[b]);
 		}
 		lazy[b] = 0;
 		for (int i = bl[b]; i <= br[b]; i++) {
-			if (arr[i] < bl[b]) {
-				outer[i] = arr[i];
+			if (fa[i] < bl[b]) {
+				outer[i] = fa[i];
 			} else {
-				outer[i] = outer[arr[i]];
+				outer[i] = outer[fa[i]];
 			}
 		}
 	}
@@ -48,16 +47,16 @@ public static void innerUpdate(int b) {
 	public static void update(int l, int r, int v) {
 		if (bi[l] == bi[r]) {
 			for (int i = l; i <= r; i++) {
-				arr[i] = Math.max(1, arr[i] - v);
+				fa[i] = Math.max(1, fa[i] - v);
 			}
 			innerUpdate(bi[l]);
 		} else {
 			for (int i = l; i <= br[bi[l]]; i++) {
-				arr[i] = Math.max(1, arr[i] - v);
+				fa[i] = Math.max(1, fa[i] - v);
 			}
 			innerUpdate(bi[l]);
 			for (int i = bl[bi[r]]; i <= r; i++) {
-				arr[i] = Math.max(1, arr[i] - v);
+				fa[i] = Math.max(1, fa[i] - v);
 			}
 			innerUpdate(bi[r]);
 			for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
@@ -72,7 +71,7 @@ public static void update(int l, int r, int v) {
 	}
 
 	public static int jumpFa(int i) {
-		return Math.max(1, arr[i] - lazy[bi[i]]);
+		return Math.max(1, fa[i] - lazy[bi[i]]);
 	}
 
 	public static int jumpOut(int i) {
@@ -123,7 +122,7 @@ public static void main(String[] args) throws IOException {
 		n = in.nextInt();
 		m = in.nextInt();
 		for (int i = 2; i <= n; i++) {
-			arr[i] = in.nextInt();
+			fa[i] = in.nextInt();
 		}
 		prepare();
 		for (int i = 1, op, x, y, z; i <= m; i++) {
diff --git a/src/class173/Code08_FatherMinus2.java b/src/class173/Code08_FatherMinus2.java
index 9dcc69c0b..aa82db387 100644
--- a/src/class173/Code08_FatherMinus2.java
+++ b/src/class173/Code08_FatherMinus2.java
@@ -1,9 +1,9 @@
 package class173;
 
 // 区间父变小，C++版
-// 一棵大小为n树，节点1是树头，节点i的父节点 = arr[i]，给定arr[2..n]
-// 对于每个i > 1，都有arr[i] < i，下来有m条操作，操作类型如下
-// 操作 x y z : [x..y]范围上任何一点i，arr[i] = max(1, arr[i] - z)
+// 一棵大小为n树，节点1是树头，给定fa[2..n]表示父亲节点编号
+// 对于每个i > 1，都有fa[i] < i，下来有m条操作，操作类型如下
+// 操作 x y z : [x..y]范围上任何一点i，fa[i] = max(1, fa[i] - z)
 // 操作 x y   : 查询点x和点y的最低公共祖先
 // 2 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1491H
@@ -18,27 +18,26 @@
 //const int MAXN = 100001;
 //const int MAXB = 501;
 //int n, m;
-//int arr[MAXN];
+//int fa[MAXN];
+//int outer[MAXN];
 //
 //int blen, bnum;
 //int bi[MAXN];
 //int bl[MAXB];
 //int br[MAXB];
-//
 //int lazy[MAXB];
-//int outer[MAXN];
 //int cnt[MAXB];
 //
 //void innerUpdate(int b) {
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        arr[i] = max(1, arr[i] - lazy[b]);
+//        fa[i] = max(1, fa[i] - lazy[b]);
 //    }
 //    lazy[b] = 0;
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        if (arr[i] < bl[b]) {
-//            outer[i] = arr[i];
+//        if (fa[i] < bl[b]) {
+//            outer[i] = fa[i];
 //        } else {
-//            outer[i] = outer[arr[i]];
+//            outer[i] = outer[fa[i]];
 //        }
 //    }
 //}
@@ -46,16 +45,16 @@
 //void update(int l, int r, int v) {
 //    if (bi[l] == bi[r]) {
 //        for (int i = l; i <= r; i++) {
-//            arr[i] = max(1, arr[i] - v);
+//            fa[i] = max(1, fa[i] - v);
 //        }
 //        innerUpdate(bi[l]);
 //    } else {
 //        for (int i = l; i <= br[bi[l]]; i++) {
-//            arr[i] = max(1, arr[i] - v);
+//            fa[i] = max(1, fa[i] - v);
 //        }
 //        innerUpdate(bi[l]);
 //        for (int i = bl[bi[r]]; i <= r; i++) {
-//            arr[i] = max(1, arr[i] - v);
+//            fa[i] = max(1, fa[i] - v);
 //        }
 //        innerUpdate(bi[r]);
 //        for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
@@ -68,7 +67,7 @@
 //}
 //
 //int jumpFa(int i) {
-//    return max(1, arr[i] - lazy[bi[i]]);
+//    return max(1, fa[i] - lazy[bi[i]]);
 //}
 //
 //int jumpOut(int i) { 
@@ -114,7 +113,7 @@
 //    cin.tie(nullptr);
 //    cin >> n >> m;
 //    for (int i = 2; i <= n; i++) {
-//        cin >> arr[i];
+//        cin >> fa[i];
 //    }
 //    prepare();
 //    for (int i = 1, op, x, y, z; i <= m; i++) {

From 53ea1f78a6dd9151fa83b3fbc1ef467e03dc45aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 10:59:46 +0800
Subject: [PATCH 1077/1712] modify code

---
 src/class173/Code07_Royal1.java | 3 ++-
 src/class173/Code07_Royal2.java | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index 1dcf80273..0e9bad3e0 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -30,9 +30,10 @@ public class Code07_Royal1 {
 
 	public static int[] capital = new int[MAXN];
 	public static int[] belong = new int[MAXN];
+	public static int cntb;
+
 	public static int[] stack = new int[MAXN];
 	public static int siz;
-	public static int cntb;
 
 	public static void addEdge(int u, int v) {
 		next[++cntg] = head[u];
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
index 11ac39804..f9fffc55e 100644
--- a/src/class173/Code07_Royal2.java
+++ b/src/class173/Code07_Royal2.java
@@ -28,9 +28,10 @@
 //
 //int capital[MAXN];
 //int belong[MAXN];
+//int cntb;
+//
 //int sta[MAXN];
 //int siz;
-//int cntb;
 //
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];

From 67214cee5343b6874eecff3ab58505cbb90809eb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 11:11:41 +0800
Subject: [PATCH 1078/1712] modify code

---
 src/class173/Code08_FatherMinus1.java | 8 ++++----
 src/class173/Code08_FatherMinus2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class173/Code08_FatherMinus1.java b/src/class173/Code08_FatherMinus1.java
index 473b05881..b47133916 100644
--- a/src/class173/Code08_FatherMinus1.java
+++ b/src/class173/Code08_FatherMinus1.java
@@ -21,7 +21,7 @@ public class Code08_FatherMinus1 {
 	public static int MAXB = 501;
 	public static int n, m;
 	public static int[] fa = new int[MAXN];
-	public static int[] outer = new int[MAXN];
+	public static int[] out = new int[MAXN];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
@@ -37,9 +37,9 @@ public static void innerUpdate(int b) {
 		lazy[b] = 0;
 		for (int i = bl[b]; i <= br[b]; i++) {
 			if (fa[i] < bl[b]) {
-				outer[i] = fa[i];
+				out[i] = fa[i];
 			} else {
-				outer[i] = outer[fa[i]];
+				out[i] = out[fa[i]];
 			}
 		}
 	}
@@ -75,7 +75,7 @@ public static int jumpFa(int i) {
 	}
 
 	public static int jumpOut(int i) {
-		return Math.max(1, outer[i] - lazy[bi[i]]);
+		return Math.max(1, out[i] - lazy[bi[i]]);
 	}
 
 	public static int lca(int x, int y) {
diff --git a/src/class173/Code08_FatherMinus2.java b/src/class173/Code08_FatherMinus2.java
index aa82db387..990e5040a 100644
--- a/src/class173/Code08_FatherMinus2.java
+++ b/src/class173/Code08_FatherMinus2.java
@@ -19,7 +19,7 @@
 //const int MAXB = 501;
 //int n, m;
 //int fa[MAXN];
-//int outer[MAXN];
+//int out[MAXN];
 //
 //int blen, bnum;
 //int bi[MAXN];
@@ -35,9 +35,9 @@
 //    lazy[b] = 0;
 //    for (int i = bl[b]; i <= br[b]; i++) {
 //        if (fa[i] < bl[b]) {
-//            outer[i] = fa[i];
+//            out[i] = fa[i];
 //        } else {
-//            outer[i] = outer[fa[i]];
+//            out[i] = out[fa[i]];
 //        }
 //    }
 //}
@@ -71,7 +71,7 @@
 //}
 //
 //int jumpOut(int i) { 
-//    return max(1, outer[i] - lazy[bi[i]]);
+//    return max(1, out[i] - lazy[bi[i]]);
 //}
 //
 //int lca(int x, int y) {

From 1353fb6e303e3691842cba2bd5e80db06c92ce04 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 11:20:02 +0800
Subject: [PATCH 1079/1712] modify code

---
 src/class173/Code06_Random1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 718bcae72..f7e565ab9 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -31,7 +31,7 @@ public class Code06_Random1 {
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
-	// 树上倍增求LCA
+	// 树上倍增，就只是为了快速求出LCA
 	public static int[] dep = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
 

From 7ba0cd17d378134766d259c95f3d73291e4a614b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 11:26:10 +0800
Subject: [PATCH 1080/1712] modify code

---
 src/class173/Code05_HLD1.java    | 8 ++++----
 src/class173/Code05_HLD2.java    | 9 ++++-----
 src/class173/Code06_Random1.java | 8 ++++----
 src/class173/Code06_Random2.java | 8 ++++----
 4 files changed, 16 insertions(+), 17 deletions(-)

diff --git a/src/class173/Code05_HLD1.java b/src/class173/Code05_HLD1.java
index 88fce56b9..f3b9c409c 100644
--- a/src/class173/Code05_HLD1.java
+++ b/src/class173/Code05_HLD1.java
@@ -286,22 +286,22 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		prepare();
-		for (int i = 1, last = 0; i <= m; i++) {
+		for (int i = 1, lastAns = 0; i <= m; i++) {
 			ans.clear();
 			k = in.nextInt();
 			for (int j = 1, x, y; j <= k; j++) {
 				x = in.nextInt();
 				y = in.nextInt();
 				if (f > 0) {
-					x = x ^ last;
-					y = y ^ last;
+					x = x ^ lastAns;
+					y = y ^ lastAns;
 				}
 				updateAns(x, y);
 			}
 			int ans1 = ans.getOnes();
 			int ans2 = ans.mex();
 			out.println(ans1 + " " + ans2);
-			last = ans1 + ans2;
+			lastAns = ans1 + ans2;
 		}
 		out.flush();
 		out.close();
diff --git a/src/class173/Code05_HLD2.java b/src/class173/Code05_HLD2.java
index 3870ff4c9..36d2a4e83 100644
--- a/src/class173/Code05_HLD2.java
+++ b/src/class173/Code05_HLD2.java
@@ -146,15 +146,14 @@
 //        addEdge(v, u);
 //    }
 //    prepare();
-//    int last = 0;
-//    for (int i = 1; i <= m; i++) {
+//    for (int i = 1, lastAns = 0; i <= m; i++) {
 //        ans.reset(); 
 //        cin >> k;
 //        for (int j = 1, x, y; j <= k; j++) {
 //            cin >> x >> y;
 //            if (f) {
-//                x ^= last;
-//                y ^= last;
+//                x ^= lastAns;
+//                y ^= lastAns;
 //            }
 //            updateAns(x, y);
 //        }
@@ -167,7 +166,7 @@
 //            }
 //        }
 //        cout << ans1 << ' ' << ans2 << '\n';
-//        last = ans1 + ans2;
+//        lastAns = ans1 + ans2;
 //    }
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index f7e565ab9..68dc2624a 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -250,22 +250,22 @@ public static void main(String[] args) throws IOException {
 			addEdge(v, u);
 		}
 		prepare();
-		for (int i = 1, last = 0; i <= m; i++) {
+		for (int i = 1, lastAns = 0; i <= m; i++) {
 			ans.clear();
 			k = in.nextInt();
 			for (int j = 1, x, y; j <= k; j++) {
 				x = in.nextInt();
 				y = in.nextInt();
 				if (f > 0) {
-					x = x ^ last;
-					y = y ^ last;
+					x = x ^ lastAns;
+					y = y ^ lastAns;
 				}
 				updateAns(x, y);
 			}
 			int ans1 = ans.countOnes();
 			int ans2 = ans.mex();
 			out.println(ans1 + " " + ans2);
-			last = ans1 + ans2;
+			lastAns = ans1 + ans2;
 		}
 		out.flush();
 		out.close();
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index 86b4dca17..81260650d 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -143,14 +143,14 @@
 //        addEdge(v, u);
 //    }
 //    prepare();
-//    for (int i = 1, last = 0; i <= m; i++) {
+//    for (int i = 1, lastAns = 0; i <= m; i++) {
 //        ans.reset();
 //        cin >> k;
 //        for (int j = 1, x, y; j <= k; j++) {
 //            cin >> x >> y;
 //            if (f) {
-//                x ^= last;
-//                y ^= last;
+//                x ^= lastAns;
+//                y ^= lastAns;
 //            }
 //            updateAns(x, y);
 //        }
@@ -163,7 +163,7 @@
 //            }
 //        }
 //        cout << ans1 << ' ' << ans2 << '\n';
-//        last = ans1 + ans2;
+//        lastAns = ans1 + ans2;
 //    }
 //    return 0;
 //}
\ No newline at end of file

From c5e7f1f359bb5f9d7dbb4eb9741690465e99b63e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 14:11:58 +0800
Subject: [PATCH 1081/1712] modify code

---
 src/class173/Code08_FatherMinus1.java | 9 +++++++--
 src/class173/Code08_FatherMinus2.java | 5 +++--
 2 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code08_FatherMinus1.java b/src/class173/Code08_FatherMinus1.java
index b47133916..019baa24c 100644
--- a/src/class173/Code08_FatherMinus1.java
+++ b/src/class173/Code08_FatherMinus1.java
@@ -20,15 +20,20 @@ public class Code08_FatherMinus1 {
 	public static int MAXN = 100001;
 	public static int MAXB = 501;
 	public static int n, m;
+
+	// 节点的父亲节点
 	public static int[] fa = new int[MAXN];
+	// 节点如果从所在块出去，会去往的最近节点
 	public static int[] out = new int[MAXN];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
+	// 块内所有节点的父亲编号减少的幅度
 	public static int[] lazy = new int[MAXB];
-	public static int[] cnt = new int[MAXB];
+	// 块内所有节点的父亲编号被统一削减的次数
+	public static int[] minusCnt = new int[MAXB];
 
 	public static void innerUpdate(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
@@ -63,7 +68,7 @@ public static void update(int l, int r, int v) {
 				// 减少的幅度最多到n，不会更大
 				// 这样还可以让lazy保持int类型并且不溢出
 				lazy[b] = Math.min(n, lazy[b] + v);
-				if (++cnt[b] <= blen) {
+				if (++minusCnt[b] <= blen) {
 					innerUpdate(b);
 				}
 			}
diff --git a/src/class173/Code08_FatherMinus2.java b/src/class173/Code08_FatherMinus2.java
index 990e5040a..447e60682 100644
--- a/src/class173/Code08_FatherMinus2.java
+++ b/src/class173/Code08_FatherMinus2.java
@@ -18,6 +18,7 @@
 //const int MAXN = 100001;
 //const int MAXB = 501;
 //int n, m;
+//
 //int fa[MAXN];
 //int out[MAXN];
 //
@@ -26,7 +27,7 @@
 //int bl[MAXB];
 //int br[MAXB];
 //int lazy[MAXB];
-//int cnt[MAXB];
+//int minusCnt[MAXB];
 //
 //void innerUpdate(int b) {
 //    for (int i = bl[b]; i <= br[b]; i++) {
@@ -59,7 +60,7 @@
 //        innerUpdate(bi[r]);
 //        for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
 //            lazy[b] = min(n, lazy[b] + v);
-//            if (++cnt[b] <= blen) {
+//            if (++minusCnt[b] <= blen) {
 //                innerUpdate(b);
 //            }
 //        }

From 320079da4db387fec5073aabb64f50adf1f7e4ef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 14:12:59 +0800
Subject: [PATCH 1082/1712] modify code

---
 src/class173/Code08_FatherMinus1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code08_FatherMinus1.java b/src/class173/Code08_FatherMinus1.java
index 019baa24c..70e1e94e7 100644
--- a/src/class173/Code08_FatherMinus1.java
+++ b/src/class173/Code08_FatherMinus1.java
@@ -30,9 +30,9 @@ public class Code08_FatherMinus1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
-	// 块内所有节点的父亲编号减少的幅度
+	// 块内所有节点的父亲编号，统一减少的幅度
 	public static int[] lazy = new int[MAXB];
-	// 块内所有节点的父亲编号被统一削减的次数
+	// 块内所有节点的父亲编号，统一削减的次数
 	public static int[] minusCnt = new int[MAXB];
 
 	public static void innerUpdate(int b) {

From b296394145de51411c65909943ef4b76d475f119 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 15:58:53 +0800
Subject: [PATCH 1083/1712] modify code

---
 src/class173/Code06_Random1.java | 2 +-
 src/class173/Code06_Random2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class173/Code06_Random1.java b/src/class173/Code06_Random1.java
index 68dc2624a..0f1ca9d83 100644
--- a/src/class173/Code06_Random1.java
+++ b/src/class173/Code06_Random1.java
@@ -201,9 +201,9 @@ public static void query(int x, int xylca) {
 
 	public static void updateAns(int x, int y) {
 		int xylca = lca(x, y);
-		ans.setOne(arr[xylca]);
 		query(x, xylca);
 		query(y, xylca);
+		ans.setOne(arr[xylca]);
 	}
 
 	public static void prepare() {
diff --git a/src/class173/Code06_Random2.java b/src/class173/Code06_Random2.java
index 81260650d..b478ea93f 100644
--- a/src/class173/Code06_Random2.java
+++ b/src/class173/Code06_Random2.java
@@ -97,9 +97,9 @@
 //
 //void updateAns(int x, int y) {
 //    int xylca = lca(x, y);
-//    ans[arr[xylca]] = 1;
 //    query(x, xylca);
 //    query(y, xylca);
+//    ans[arr[xylca]] = 1;
 //}
 //
 //void prepare() {

From fe27487d18bd9bdf30ad1927e926e579bf347b1a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 17:05:26 +0800
Subject: [PATCH 1084/1712] modify code

---
 src/class173/Code07_Royal1.java | 4 ++--
 src/class173/Code07_Royal2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index 0e9bad3e0..3c9114548 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -2,11 +2,11 @@
 
 // 王室联邦，java版
 // 一共有n个城市，编号1~n，给定n-1条边，所有城市连成一棵树
-// 给定数值b，希望你把树划分成若干个联通区，也叫省，划分要求如下
+// 给定数值b，请把树划分成若干个省，划分要求如下
 // 每个省至少要有b个城市，最多有3 * b个城市，每个省必须有一个省会
 // 省会可在省内也可在省外，一个城市可以是多个省的省会
 // 一个省里，任何城市到达省会的路径上，除了省会之外的其他城市，必须都在省内
-// 根据要求完成一种有效划分即可，先打印你划分了多少个省，假设数量为k
+// 根据要求完成一种有效划分即可，先打印划分了多少个省，假设数量为k
 // 然后打印n个数字，范围[1, k]，表示每个城市被划分给了哪个省
 // 最后打印k个数字，表示每个省会的城市编号
 // 1 <= n、b <= 10^3
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
index f9fffc55e..6c7f3a0ec 100644
--- a/src/class173/Code07_Royal2.java
+++ b/src/class173/Code07_Royal2.java
@@ -2,11 +2,11 @@
 
 // 王室联邦，C++版
 // 一共有n个城市，编号1~n，给定n-1条边，所有城市连成一棵树
-// 给定数值b，希望你把树划分成若干个联通区，也叫省，划分要求如下
+// 给定数值b，请把树划分成若干个省，划分要求如下
 // 每个省至少要有b个城市，最多有3 * b个城市，每个省必须有一个省会
 // 省会可在省内也可在省外，一个城市可以是多个省的省会
 // 一个省里，任何城市到达省会的路径上，除了省会之外的其他城市，必须都在省内
-// 根据要求完成一种有效划分即可，先打印你划分了多少个省，假设数量为k
+// 根据要求完成一种有效划分即可，先打印划分了多少个省，假设数量为k
 // 然后打印n个数字，范围[1, k]，表示每个城市被划分给了哪个省
 // 最后打印k个数字，表示每个省会的城市编号
 // 1 <= n、b <= 10^3

From bb09f7350535e8dff88e5c2f90d8fdf1ab6b57b2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 17:49:05 +0800
Subject: [PATCH 1085/1712] modify code

---
 src/class173/Code07_Royal1.java | 6 +++---
 src/class173/Code07_Royal2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class173/Code07_Royal1.java b/src/class173/Code07_Royal1.java
index 3c9114548..983f69508 100644
--- a/src/class173/Code07_Royal1.java
+++ b/src/class173/Code07_Royal1.java
@@ -42,14 +42,14 @@ public static void addEdge(int u, int v) {
 	}
 
 	public static void dfs(int u, int f) {
-		int tmp = siz;
+		int x = siz;
 		for (int e = head[u], v; e > 0; e = next[e]) {
 			v = to[e];
 			if (v != f) {
 				dfs(v, u);
-				if (siz >= tmp + b) {
+				if (siz - x >= b) {
 					capital[++cntb] = u;
-					while (siz != tmp) {
+					while (siz != x) {
 						belong[stack[siz--]] = cntb;
 					}
 				}
diff --git a/src/class173/Code07_Royal2.java b/src/class173/Code07_Royal2.java
index 6c7f3a0ec..acbd7c90c 100644
--- a/src/class173/Code07_Royal2.java
+++ b/src/class173/Code07_Royal2.java
@@ -40,14 +40,14 @@
 //}
 //
 //void dfs(int u, int f) {
-//    int tmp = siz;
+//    int x = siz;
 //    for (int e = head[u], v; e; e = nxt[e]) {
 //        v = to[e];
 //        if (v != f) {
 //            dfs(v, u);
-//            if (siz >= tmp + b) {
+//            if (siz - x >= b) {
 //                capital[++cntb] = u;
-//                while (siz != tmp) {
+//                while (siz != x) {
 //                    belong[sta[siz--]] = cntb;
 //                }
 //            }

From 93477e7cf5d36307f01410b68b1dcee335e7d970 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 20:12:52 +0800
Subject: [PATCH 1086/1712] modify code

---
 src/class173/Code08_FatherMinus1.java | 4 ++--
 src/class173/Code08_FatherMinus2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class173/Code08_FatherMinus1.java b/src/class173/Code08_FatherMinus1.java
index 70e1e94e7..3a24e3a05 100644
--- a/src/class173/Code08_FatherMinus1.java
+++ b/src/class173/Code08_FatherMinus1.java
@@ -3,8 +3,8 @@
 // 区间父变小，java版
 // 一棵大小为n树，节点1是树头，给定fa[2..n]表示父亲节点编号
 // 对于每个i > 1，都有fa[i] < i，下来有m条操作，操作类型如下
-// 操作 x y z : [x..y]范围上任何一点i，fa[i] = max(1, fa[i] - z)
-// 操作 x y   : 查询点x和点y的最低公共祖先
+// 操作 1 x y z : [x..y]范围上任何一点i，fa[i] = max(1, fa[i] - z)
+// 操作 2 x y   : 查询点x和点y的最低公共祖先
 // 2 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1491H
 // 测试链接 : https://codeforces.com/problemset/problem/1491/H
diff --git a/src/class173/Code08_FatherMinus2.java b/src/class173/Code08_FatherMinus2.java
index 447e60682..78332d6a6 100644
--- a/src/class173/Code08_FatherMinus2.java
+++ b/src/class173/Code08_FatherMinus2.java
@@ -3,8 +3,8 @@
 // 区间父变小，C++版
 // 一棵大小为n树，节点1是树头，给定fa[2..n]表示父亲节点编号
 // 对于每个i > 1，都有fa[i] < i，下来有m条操作，操作类型如下
-// 操作 x y z : [x..y]范围上任何一点i，fa[i] = max(1, fa[i] - z)
-// 操作 x y   : 查询点x和点y的最低公共祖先
+// 操作 1 x y z : [x..y]范围上任何一点i，fa[i] = max(1, fa[i] - z)
+// 操作 2 x y   : 查询点x和点y的最低公共祖先
 // 2 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1491H
 // 测试链接 : https://codeforces.com/problemset/problem/1491/H

From 23beb9e7f7b4137518fbf7c4e04e1aaf81aeecb1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 2 Jul 2025 22:12:47 +0800
Subject: [PATCH 1087/1712] modify code

---
 ...21\344\270\212\345\210\206\345\235\227.pptx" | Bin 0 -> 60290 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243173\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2302-\345\210\206\345\235\227\347\232\204\345\207\240\351\201\223\345\245\275\351\242\230\343\200\201\346\240\221\344\270\212\345\210\206\345\235\227.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243173\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2302-\345\210\206\345\235\227\347\232\204\345\207\240\351\201\223\345\245\275\351\242\230\343\200\201\346\240\221\344\270\212\345\210\206\345\235\227.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243173\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2302-\345\210\206\345\235\227\347\232\204\345\207\240\351\201\223\345\245\275\351\242\230\343\200\201\346\240\221\344\270\212\345\210\206\345\235\227.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..066f41b0fe6106917711f3cce00a374f602a5fc6
GIT binary patch
literal 60290
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
S5ReeyTZ0M&R5khY=>GxfB70T<

literal 0
HcmV?d00001


From 0a9a74b80a03b2b4ee38864e59f8570ed441d856 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 5 Jul 2025 17:16:03 +0800
Subject: [PATCH 1088/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 257 ++++++++++++++++++++++++++
 src/class174/Code01_FutureDiary2.java | 225 ++++++++++++++++++++++
 2 files changed, 482 insertions(+)
 create mode 100644 src/class174/Code01_FutureDiary1.java
 create mode 100644 src/class174/Code01_FutureDiary2.java

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
new file mode 100644
index 000000000..60960bccc
--- /dev/null
+++ b/src/class174/Code01_FutureDiary1.java
@@ -0,0 +1,257 @@
+package class174;
+
+// 未来日记，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4119
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是无法通过测试
+// 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code01_FutureDiary2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_FutureDiary1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 318;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] tmp = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	public static int[][] valRoot = new int[MAXB][MAXN];
+	public static int[][] rootVal = new int[MAXB][MAXN];
+	public static int[] idxRoot = new int[MAXN];
+
+	public static int[][] sum1 = new int[MAXB][MAXB];
+	public static int[][] sum2 = new int[MAXB][MAXN];
+	public static int[] cnt1 = new int[MAXB];
+	public static int[] cnt2 = new int[MAXN];
+
+	public static void build(int b) {
+		for (int i = 1; i <= blen; i++) {
+			valRoot[b][rootVal[b][i]] = 0;
+		}
+		for (int i = bl[b], cnt = 0; i <= br[b]; i++) {
+			if (valRoot[b][arr[i]] == 0) {
+				cnt++;
+				valRoot[b][arr[i]] = cnt;
+				rootVal[b][cnt] = arr[i];
+			}
+			idxRoot[i] = valRoot[b][arr[i]];
+		}
+	}
+
+	public static void down(int b) {
+		for (int i = bl[b]; i <= br[b]; i++) {
+			arr[i] = rootVal[b][idxRoot[i]];
+		}
+	}
+
+	public static void xToy(int b, int x, int y) {
+		valRoot[b][y] = valRoot[b][x];
+		rootVal[b][valRoot[b][x]] = y;
+		valRoot[b][x] = 0;
+	}
+
+	public static void innerUpdate(int l, int r, int x, int y) {
+		down(bi[l]);
+		for (int i = l; i <= r; i++) {
+			if (arr[i] == x) {
+				sum1[bi[i]][bi[x]]--;
+				sum1[bi[i]][bi[y]]++;
+				sum2[bi[i]][x]--;
+				sum2[bi[i]][y]++;
+				arr[i] = y;
+			}
+		}
+		build(bi[l]);
+	}
+
+	public static void update(int l, int r, int x, int y) {
+		if (x == y || (sum2[bi[r]][x] - sum2[bi[l] - 1][x] == 0)) {
+			return;
+		}
+		for (int b = bi[n]; b >= bi[l]; b--) {
+			sum1[b][bi[x]] -= sum1[b - 1][bi[x]];
+			sum1[b][bi[y]] -= sum1[b - 1][bi[y]];
+			sum2[b][x] -= sum2[b - 1][x];
+			sum2[b][y] -= sum2[b - 1][y];
+		}
+		if (bi[l] == bi[r]) {
+			innerUpdate(l, r, x, y);
+		} else {
+			innerUpdate(l, br[bi[l]], x, y);
+			innerUpdate(bl[bi[r]], r, x, y);
+			for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
+				if (sum2[b][x] != 0) {
+					if (sum2[b][y] != 0) {
+						innerUpdate(bl[b], br[b], x, y);
+					} else {
+						sum1[b][bi[y]] += sum2[b][x];
+						sum1[b][bi[x]] -= sum2[b][x];
+						sum2[b][y] += sum2[b][x];
+						sum2[b][x] = 0;
+						xToy(b, x, y);
+					}
+				}
+			}
+		}
+		for (int b = bi[l]; b <= bi[n]; b++) {
+			sum1[b][bi[x]] += sum1[b - 1][bi[x]];
+			sum1[b][bi[y]] += sum1[b - 1][bi[y]];
+			sum2[b][x] += sum2[b - 1][x];
+			sum2[b][y] += sum2[b - 1][y];
+		}
+	}
+
+	public static int query(int l, int r, int k) {
+		int ans = 0;
+		if (bi[l] == bi[r]) {
+			down(bi[l]);
+			for (int i = l; i <= r; i++) {
+				tmp[i] = arr[i];
+			}
+			Arrays.sort(tmp, l, r + 1);
+			ans = tmp[l + k - 1];
+		} else {
+			down(bi[l]);
+			down(bi[r]);
+			for (int i = l; i <= br[bi[l]]; i++) {
+				cnt1[bi[arr[i]]]++;
+				cnt2[arr[i]]++;
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				cnt1[bi[arr[i]]]++;
+				cnt2[arr[i]]++;
+			}
+			int sumCnt = 0;
+			int vblock = 0;
+			for (int b = 1; b <= bi[MAXN - 1]; b++) {
+				int blockCnt = cnt1[b] + sum1[bi[r] - 1][b] - sum1[bi[l]][b];
+				if (sumCnt + blockCnt < k) {
+					sumCnt += blockCnt;
+				} else {
+					vblock = b;
+					break;
+				}
+			}
+			for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
+				int valCnt = cnt2[v] + sum2[bi[r] - 1][v] - sum2[bi[l]][v];
+				if (sumCnt + valCnt >= k) {
+					ans = v;
+					break;
+				} else {
+					sumCnt += valCnt;
+				}
+			}
+			for (int i = l; i <= br[bi[l]]; i++) {
+				cnt1[bi[arr[i]]]--;
+				cnt2[arr[i]]--;
+			}
+			for (int i = bl[bi[r]]; i <= r; i++) {
+				cnt1[bi[arr[i]]]--;
+				cnt2[arr[i]]--;
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i < MAXN; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+			build(i);
+		}
+		for (int i = 1; i <= bnum; i++) {
+			for (int j = 1; j < MAXB; j++) {
+				sum1[i][j] = sum1[i - 1][j];
+			}
+			for (int j = 1; j < MAXN; j++) {
+				sum2[i][j] = sum2[i - 1][j];
+			}
+			for (int j = bl[i]; j <= br[i]; j++) {
+				sum1[i][bi[arr[j]]]++;
+				sum2[i][arr[j]]++;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, op, l, r, x, y, k; i <= m; i++) {
+			op = in.nextInt();
+			l = in.nextInt();
+			r = in.nextInt();
+			if (op == 1) {
+				x = in.nextInt();
+				y = in.nextInt();
+				update(l, r, x, y);
+			} else {
+				k = in.nextInt();
+				out.println(query(l, r, k));
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+}
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
new file mode 100644
index 000000000..beb28b9de
--- /dev/null
+++ b/src/class174/Code01_FutureDiary2.java
@@ -0,0 +1,225 @@
+package class174;
+
+// 未来日记，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4119
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//char buf[1000000], *p1 = buf, *p2 = buf;
+//
+//inline char getChar() {
+//    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;
+//}
+//
+//inline int read() {
+//    int s = 0;
+//    char c = getChar();
+//    while (!isdigit(c)) {
+//        c = getChar();
+//    }
+//    while (isdigit(c)) {
+//        s = s * 10 + c - '0';
+//        c = getChar();
+//    }
+//    return s;
+//}
+//
+//const int MAXN = 100001;
+//const int MAXB = 318;
+//int n, m;
+//int arr[MAXN];
+//int tmp[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//int valRoot[MAXB][MAXN];
+//int rootVal[MAXB][MAXN];
+//int idxRoot[MAXN];
+//
+//int sum1[MAXB][MAXB];
+//int sum2[MAXB][MAXN];
+//int cnt1[MAXB];
+//int cnt2[MAXN];
+//
+//void build(int b) {
+//    for (int i = 1; i <= blen; i++) {
+//        valRoot[b][rootVal[b][i]] = 0;
+//    }
+//    int cnt = 0;
+//    for (int i = bl[b]; i <= br[b]; i++) {
+//        if (valRoot[b][arr[i]] == 0) {
+//            cnt++;
+//            valRoot[b][arr[i]] = cnt;
+//            rootVal[b][cnt] = arr[i];
+//        }
+//        idxRoot[i] = valRoot[b][arr[i]];
+//    }
+//}
+//
+//void down(int b) {
+//    for (int i = bl[b]; i <= br[b]; i++) {
+//        arr[i] = rootVal[b][idxRoot[i]];
+//    }
+//}
+//
+//void xToy(int b, int x, int y) {
+//    valRoot[b][y] = valRoot[b][x];
+//    rootVal[b][valRoot[b][x]] = y;
+//    valRoot[b][x] = 0;
+//}
+//
+//void innerUpdate(int l, int r, int x, int y) {
+//    down(bi[l]);
+//    for (int i = l; i <= r; i++) {
+//        if (arr[i] == x) {
+//            sum1[bi[i]][bi[x]]--;
+//            sum1[bi[i]][bi[y]]++;
+//            sum2[bi[i]][x]--;
+//            sum2[bi[i]][y]++;
+//            arr[i] = y;
+//        }
+//    }
+//    build(bi[l]);
+//}
+//
+//void update(int l, int r, int x, int y) {
+//    if (x == y || (sum2[bi[r]][x] - sum2[bi[l] - 1][x] == 0)) {
+//        return;
+//    }
+//    for (int b = bi[n]; b >= bi[l]; b--) {
+//        sum1[b][bi[x]] -= sum1[b - 1][bi[x]];
+//        sum1[b][bi[y]] -= sum1[b - 1][bi[y]];
+//        sum2[b][x] -= sum2[b - 1][x];
+//        sum2[b][y] -= sum2[b - 1][y];
+//    }
+//    if (bi[l] == bi[r]) {
+//        innerUpdate(l, r, x, y);
+//    } else {
+//        innerUpdate(l, br[bi[l]], x, y);
+//        innerUpdate(bl[bi[r]], r, x, y);
+//        for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
+//            if (sum2[b][x] != 0) {
+//                if (sum2[b][y] != 0) {
+//                    innerUpdate(bl[b], br[b], x, y);
+//                } else {
+//                    sum1[b][bi[y]] += sum2[b][x];
+//                    sum1[b][bi[x]] -= sum2[b][x];
+//                    sum2[b][y] += sum2[b][x];
+//                    sum2[b][x] = 0;
+//                    xToy(b, x, y);
+//                }
+//            }
+//        }
+//    }
+//    for (int b = bi[l]; b <= bi[n]; b++) {
+//        sum1[b][bi[x]] += sum1[b - 1][bi[x]];
+//        sum1[b][bi[y]] += sum1[b - 1][bi[y]];
+//        sum2[b][x] += sum2[b - 1][x];
+//        sum2[b][y] += sum2[b - 1][y];
+//    }
+//}
+//
+//int query(int l, int r, int k) {
+//    int ans = 0;
+//    if (bi[l] == bi[r]) {
+//        down(bi[l]);
+//        for (int i = l; i <= r; i++) {
+//            tmp[i] = arr[i];
+//        }
+//        sort(tmp + l, tmp + r + 1);
+//        ans = tmp[l + k - 1];
+//    } else {
+//        down(bi[l]);
+//        down(bi[r]);
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            cnt1[bi[arr[i]]]++;
+//            cnt2[arr[i]]++;
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            cnt1[bi[arr[i]]]++;
+//            cnt2[arr[i]]++;
+//        }
+//        int sumCnt = 0, vblock = 0;
+//        for (int b = 1; b <= bi[MAXN - 1]; b++) {
+//            int blockCnt = cnt1[b] + sum1[bi[r] - 1][b] - sum1[bi[l]][b];
+//            if (sumCnt + blockCnt < k) {
+//                sumCnt += blockCnt;
+//            } else {
+//                vblock = b;
+//                break;
+//            }
+//        }
+//        for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
+//            int valCnt = cnt2[v] + sum2[bi[r] - 1][v] - sum2[bi[l]][v];
+//            if (sumCnt + valCnt >= k) {
+//                ans = v;
+//                break;
+//            }
+//            sumCnt += valCnt;
+//        }
+//        for (int i = l; i <= br[bi[l]]; i++) {
+//            cnt1[bi[arr[i]]]--;
+//            cnt2[arr[i]]--;
+//        }
+//        for (int i = bl[bi[r]]; i <= r; i++) {
+//            cnt1[bi[arr[i]]]--;
+//            cnt2[arr[i]]--;
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i < MAXN; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//        build(i);
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        for (int j = 1; j < MAXB; j++) {
+//            sum1[i][j] = sum1[i - 1][j];
+//        }
+//        for (int j = 1; j < MAXN; j++) {
+//            sum2[i][j] = sum2[i - 1][j];
+//        }
+//        for (int j = bl[i]; j <= br[i]; j++) {
+//            sum1[i][bi[arr[j]]]++;
+//            sum2[i][arr[j]]++;
+//        }
+//    }
+//}
+//
+//int main() {
+//    n = read();
+//    m = read();
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = read();
+//    }
+//    prepare();
+//    for (int i = 1, op, l, r, x, y, k; i <= m; i++) {
+//        op = read();
+//        l = read();
+//        r = read();
+//        if (op == 1) {
+//            x = read();
+//            y = read();
+//            update(l, r, x, y);
+//        } else {
+//            k = read();
+//            printf("%d\n", query(l, r, k));
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From ca02e726c15136667c60b8de66efcd7f477e6a1b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 5 Jul 2025 17:22:55 +0800
Subject: [PATCH 1089/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 6 ++----
 src/class174/Code01_FutureDiary2.java | 6 ++----
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 60960bccc..fd9c9a6e9 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -154,12 +154,10 @@ public static int query(int l, int r, int k) {
 				}
 			}
 			for (int i = l; i <= br[bi[l]]; i++) {
-				cnt1[bi[arr[i]]]--;
-				cnt2[arr[i]]--;
+				cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
 			}
 			for (int i = bl[bi[r]]; i <= r; i++) {
-				cnt1[bi[arr[i]]]--;
-				cnt2[arr[i]]--;
+				cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
 			}
 		}
 		return ans;
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index beb28b9de..c27ea3f3f 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -165,12 +165,10 @@
 //            sumCnt += valCnt;
 //        }
 //        for (int i = l; i <= br[bi[l]]; i++) {
-//            cnt1[bi[arr[i]]]--;
-//            cnt2[arr[i]]--;
+//            cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
 //        }
 //        for (int i = bl[bi[r]]; i <= r; i++) {
-//            cnt1[bi[arr[i]]]--;
-//            cnt2[arr[i]]--;
+//            cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
 //        }
 //    }
 //    return ans;

From abeca9bd961ca00ba5d962af47727ed50c2febee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 6 Jul 2025 21:49:09 +0800
Subject: [PATCH 1090/1712] modify code

---
 src/class174/Code01_FutureDiary1.java   |   5 +-
 src/class174/Code01_FutureDiary2.java   |   2 +-
 src/class174/Code02_ColorfulWorld1.java | 215 ++++++++++++++++++++++++
 src/class174/Code02_ColorfulWorld2.java | 162 ++++++++++++++++++
 4 files changed, 381 insertions(+), 3 deletions(-)
 create mode 100644 src/class174/Code02_ColorfulWorld1.java
 create mode 100644 src/class174/Code02_ColorfulWorld2.java

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index fd9c9a6e9..ad7f05459 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -3,7 +3,7 @@
 // 未来日记，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4119
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是无法通过测试
+// java实现的逻辑一定是正确的，但是运行超时
 // 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
 // 想通过用C++实现，本节课Code01_FutureDiary2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
@@ -27,9 +27,9 @@ public class Code01_FutureDiary1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
+	public static int[] idxRoot = new int[MAXN];
 	public static int[][] valRoot = new int[MAXB][MAXN];
 	public static int[][] rootVal = new int[MAXB][MAXN];
-	public static int[] idxRoot = new int[MAXN];
 
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];
@@ -252,4 +252,5 @@ int nextInt() throws IOException {
 			return neg ? -val : val;
 		}
 	}
+
 }
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index c27ea3f3f..88fd4a1fc 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -39,9 +39,9 @@
 //int bl[MAXB];
 //int br[MAXB];
 //
+//int idxRoot[MAXN];
 //int valRoot[MAXB][MAXN];
 //int rootVal[MAXB][MAXN];
-//int idxRoot[MAXN];
 //
 //int sum1[MAXB][MAXB];
 //int sum2[MAXB][MAXN];
diff --git a/src/class174/Code02_ColorfulWorld1.java b/src/class174/Code02_ColorfulWorld1.java
new file mode 100644
index 000000000..62e8f4384
--- /dev/null
+++ b/src/class174/Code02_ColorfulWorld1.java
@@ -0,0 +1,215 @@
+package class174;
+
+// 五彩斑斓的世界，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4117
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是内存占用过大
+// 因为这道题只考虑C++能通过的空间标准，根本没考虑java的用户
+// 想通过用C++实现，本节课Code02_ColorfulWorld2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_ColorfulWorld1 {
+
+	public static int MAXN = 1000001;
+	public static int n, m;
+	public static int blen, bnum;
+	public static int maxv, lazy;
+	public static int[] arr = new int[MAXN];
+
+	public static int[] op = new int[MAXN];
+	public static int[] ql = new int[MAXN];
+	public static int[] qr = new int[MAXN];
+	public static int[] qx = new int[MAXN];
+
+	public static int[] fa = new int[MAXN];
+	public static int[] sum = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static int find(int x) {
+		if (x != fa[x]) {
+			fa[x] = find(fa[x]);
+		}
+		return fa[x];
+	}
+
+	public static void union(int x, int y) {
+		fa[find(x)] = find(y);
+	}
+
+	public static void down(int l, int r) {
+		for (int i = l; i <= r; i++) {
+			arr[i] = find(arr[i]);
+		}
+	}
+
+	public static void update(int qi, int l, int r) {
+		int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
+		if (jobx > maxv - lazy || jobl > r || jobr < l) {
+			return;
+		}
+		if (jobl <= l && r <= jobr) {
+			if ((jobx << 1) <= maxv - lazy) {
+				for (int v = lazy + 1; v <= lazy + jobx; v++) {
+					sum[v + jobx] += sum[v];
+					sum[v] = 0;
+					union(v, v + jobx);
+				}
+				lazy += jobx;
+			} else {
+				for (int v = maxv; v > lazy + jobx; v--) {
+					sum[v - jobx] += sum[v];
+					sum[v] = 0;
+					union(v, v - jobx);
+				}
+				for (int v = maxv; v >= 0; v--) {
+					if (sum[v] != 0) {
+						maxv = v;
+						break;
+					}
+				}
+			}
+		} else {
+			down(l, r);
+			for (int i = Math.max(l, jobl); i <= Math.min(r, jobr); i++) {
+				if (arr[i] - lazy > jobx) {
+					sum[arr[i]]--;
+					arr[i] -= jobx;
+					sum[arr[i]]++;
+				}
+			}
+			for (int v = maxv; v >= 0; v--) {
+				if (sum[v] != 0) {
+					maxv = v;
+					break;
+				}
+			}
+		}
+	}
+
+	public static void query(int qi, int l, int r) {
+		int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
+		if (jobx == 0) {
+			return;
+		}
+		if (jobx > maxv - lazy || jobl > r || jobr < l) {
+			return;
+		}
+		if (jobl <= l && r <= jobr) {
+			ans[qi] += sum[jobx + lazy];
+		} else {
+			down(l, r);
+			for (int i = Math.max(l, jobl); i <= Math.min(r, jobr); i++) {
+				if (arr[i] - lazy == jobx) {
+					ans[qi]++;
+				}
+			}
+		}
+	}
+
+	public static void compute(int l, int r) {
+		Arrays.fill(sum, 0);
+		maxv = lazy = 0;
+		for (int i = l; i <= r; i++) {
+			maxv = Math.max(maxv, arr[i]);
+			sum[arr[i]]++;
+		}
+		for (int v = 0; v <= maxv; v++) {
+			fa[v] = v;
+		}
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 1) {
+				update(i, l, r);
+			} else {
+				query(i, l, r);
+			}
+		}
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n * 3.0);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			sum[i] = sum[i - 1] + (arr[i] == 0 ? 1 : 0);
+		}
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 2 && qx[i] == 0) {
+				ans[i] = sum[qr[i]] - sum[ql[i] - 1];
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			op[i] = in.nextInt();
+			ql[i] = in.nextInt();
+			qr[i] = in.nextInt();
+			qx[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, l, r; i <= bnum; i++) {
+			l = (i - 1) * blen + 1;
+			r = Math.min(i * blen, n);
+			compute(l, r);
+		}
+		for (int i = 1; i <= m; i++) {
+			if (op[i] == 2) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class174/Code02_ColorfulWorld2.java b/src/class174/Code02_ColorfulWorld2.java
new file mode 100644
index 000000000..661af14e2
--- /dev/null
+++ b/src/class174/Code02_ColorfulWorld2.java
@@ -0,0 +1,162 @@
+package class174;
+
+// 五彩斑斓的世界，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4117
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//int n, m;
+//int blen, bnum;
+//int maxv, lazy;
+//int arr[MAXN];
+//
+//int op[MAXN];
+//int ql[MAXN];
+//int qr[MAXN];
+//int qx[MAXN];
+//
+//int fa[MAXN];
+//int sum[MAXN];
+//int ans[MAXN];
+//
+//int find(int x) {
+//    if (x != fa[x]) {
+//        fa[x] = find(fa[x]);
+//    }
+//    return fa[x];
+//}
+//
+//void Union(int x, int y) {
+//    fa[find(x)] = find(y);
+//}
+//
+//void down(int l, int r) {
+//    for (int i = l; i <= r; i++) {
+//        arr[i] = find(arr[i]);
+//    }
+//}
+//
+//void update(int qi, int l, int r) {
+//    int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
+//    if (jobx > maxv - lazy || jobl > r || jobr < l) {
+//        return;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        if ((jobx << 1) <= maxv - lazy) {
+//            for (int v = lazy + 1; v <= lazy + jobx; v++) {
+//                sum[v + jobx] += sum[v];
+//                sum[v] = 0;
+//                Union(v, v + jobx);
+//            }
+//            lazy += jobx;
+//        } else {
+//            for (int v = maxv; v > lazy + jobx; v--) {
+//                sum[v - jobx] += sum[v];
+//                sum[v] = 0;
+//                Union(v, v - jobx);
+//            }
+//            for (int v = maxv; v >= 0; v--) {
+//                if (sum[v] != 0) {
+//                    maxv = v;
+//                    break;
+//                }
+//            }
+//        }
+//    } else {
+//        down(l, r);
+//        for (int i = max(l, jobl); i <= min(r, jobr); i++) {
+//            if (arr[i] - lazy > jobx) {
+//                sum[arr[i]]--;
+//                arr[i] -= jobx;
+//                sum[arr[i]]++;
+//            }
+//        }
+//        for (int v = maxv; v >= 0; v--) {
+//            if (sum[v] != 0) {
+//                maxv = v;
+//                break;
+//            }
+//        }
+//    }
+//}
+//
+//void query(int qi, int l, int r) {
+//    int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
+//    if (jobx == 0) {
+//        return;
+//    }
+//    if (jobx > maxv - lazy || jobl > r || jobr < l) {
+//        return;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        ans[qi] += sum[jobx + lazy];
+//    } else {
+//        down(l, r);
+//        for (int i = max(l, jobl); i <= min(r, jobr); i++) {
+//            if (arr[i] - lazy == jobx) {
+//                ans[qi]++;
+//            }
+//        }
+//    }
+//}
+//
+//void compute(int l, int r) {
+//    fill(sum, sum + MAXN, 0);
+//    maxv = lazy = 0;
+//    for (int i = l; i <= r; i++) {
+//        maxv = max(maxv, arr[i]);
+//        sum[arr[i]]++;
+//    }
+//    for (int v = 0; v <= maxv; v++) {
+//        fa[v] = v;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 1) {
+//            update(i, l, r);
+//        } else {
+//            query(i, l, r);
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n * 3.0);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        sum[i] = sum[i - 1] + (arr[i] == 0 ? 1 : 0);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 2 && qx[i] == 0) {
+//            ans[i] = sum[qr[i]] - sum[ql[i] - 1];
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op[i] >> ql[i] >> qr[i] >> qx[i];
+//    }
+//    prepare();
+//    for (int i = 1, l, r; i <= bnum; i++) {
+//        l = (i - 1) * blen + 1;
+//        r = min(i * blen, n);
+//        compute(l, r);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        if (op[i] == 2) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 1abeed757a8e5749b20eda148d714c27c8ad0f3b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 8 Jul 2025 17:24:54 +0800
Subject: [PATCH 1091/1712] modify code

---
 src/class174/Code01_FutureDiary1.java   |   4 +-
 src/class174/Code02_ColorfulWorld1.java |   4 +-
 src/class174/Code03_MagicGirl1.java     | 273 ++++++++++++++++++++++++
 src/class174/Code03_MagicGirl2.java     | 221 +++++++++++++++++++
 4 files changed, 496 insertions(+), 6 deletions(-)
 create mode 100644 src/class174/Code03_MagicGirl1.java
 create mode 100644 src/class174/Code03_MagicGirl2.java

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index ad7f05459..01d957b1b 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -2,9 +2,7 @@
 
 // 未来日记，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4119
-// 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是运行超时
-// 因为这道题只考虑C++能通过的时间标准，根本没考虑java的用户
+// 提交以下的code，提交时请把类名改成"Main"，本题卡常，java实现无法通过
 // 想通过用C++实现，本节课Code01_FutureDiary2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
diff --git a/src/class174/Code02_ColorfulWorld1.java b/src/class174/Code02_ColorfulWorld1.java
index 62e8f4384..3b87236ec 100644
--- a/src/class174/Code02_ColorfulWorld1.java
+++ b/src/class174/Code02_ColorfulWorld1.java
@@ -2,9 +2,7 @@
 
 // 五彩斑斓的世界，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4117
-// 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是内存占用过大
-// 因为这道题只考虑C++能通过的空间标准，根本没考虑java的用户
+// 提交以下的code，提交时请把类名改成"Main"，本题卡常，java实现无法通过
 // 想通过用C++实现，本节课Code02_ColorfulWorld2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
new file mode 100644
index 000000000..1c40178ed
--- /dev/null
+++ b/src/class174/Code03_MagicGirl1.java
@@ -0,0 +1,273 @@
+package class174;
+
+// 魔法少女网站，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P6578
+// 提交以下的code，提交时请把类名改成"Main"，本题卡常，java实现无法通过
+// 想通过用C++实现，本节课Code03_MagicGirl2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code03_MagicGirl1 {
+
+	static class Node {
+		int v, i;
+
+		Node(int v_, int i_) {
+			v = v_;
+			i = i_;
+		}
+	}
+
+	static class Answer {
+		int pre, suf, len;
+		long res;
+
+		Answer(int p, int s, int l, long r) {
+			pre = p;
+			suf = s;
+			len = l;
+			res = r;
+		}
+
+		void merge(Answer right) {
+			res += right.res + 1L * suf * right.pre;
+			if (pre == len)
+				pre += right.pre;
+			if (right.suf == right.len) {
+				suf += right.suf;
+			} else {
+				suf = right.suf;
+			}
+			len += right.len;
+		}
+
+	}
+
+	public static int MAXN = 300005;
+	public static int MAXB = 601;
+	public static int BLEN = 512;
+	public static int OFFSET = 0x1ff;
+	public static int POWER = 9;
+	public static int n, m;
+
+	public static int[] arr = new int[MAXN];
+	public static Node[] sortv = new Node[MAXN];
+
+	public static int[] op = new int[MAXN];
+	public static int[] x = new int[MAXN];
+	public static int[] y = new int[MAXN];
+	public static int[] z = new int[MAXN];
+
+	public static int[] head1 = new int[MAXB];
+	public static int[] head2 = new int[MAXB];
+	public static int[] toq = new int[MAXN << 1];
+	public static int[] nexte = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] sortq = new int[MAXN];
+	public static int cntq;
+
+	public static int[] lst = new int[MAXN];
+	public static int[] nxt = new int[MAXN];
+
+	public static Answer tmp = new Answer(0, 0, 0, 0);
+	public static Answer[] ans = new Answer[MAXN];
+
+	public static void swap(Node[] a, int i, int j) {
+		Node t = a[i];
+		a[i] = a[j];
+		a[j] = t;
+	}
+
+	public static void swap(int[] a, int i, int j) {
+		int t = a[i];
+		a[i] = a[j];
+		a[j] = t;
+	}
+
+	public static void addEdge(int[] head, int u, int v) {
+		nexte[++cntg] = head[u];
+		toq[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void calc(int l, int r) {
+		for (int md = 0; md < BLEN; ++md) {
+			for (int e = head1[md]; e != 0; e = nexte[e]) {
+				addEdge(head2, z[toq[e]] >> POWER, toq[e]);
+			}
+			head1[md] = 0;
+		}
+		for (int tm = n / BLEN; tm >= 0; --tm) {
+			for (int e = head2[tm]; e != 0; e = nexte[e]) {
+				sortq[++cntq] = toq[e];
+			}
+			head2[tm] = 0;
+		}
+		for (int left = 1, right = cntq; left < right; ++left, --right) {
+			swap(sortq, left, right);
+		}
+		for (int i = l; i <= r; ++i) {
+			lst[i] = i - 1;
+			nxt[i] = i + 1;
+		}
+		tmp.pre = tmp.suf = 0;
+		tmp.len = r - l + 1;
+		tmp.res = 0;
+		int k = 1;
+		for (int i = l; i <= r; ++i) {
+			int idx = sortv[i].i;
+			while (k <= cntq && z[sortq[k]] < arr[idx]) {
+				ans[sortq[k++]].merge(tmp);
+			}
+			if (lst[idx] == l - 1) {
+				tmp.pre += nxt[idx] - idx;
+			}
+			if (nxt[idx] == r + 1) {
+				tmp.suf += idx - lst[idx];
+			}
+			tmp.res += 1L * (idx - lst[idx]) * (nxt[idx] - idx);
+			lst[nxt[idx]] = lst[idx];
+			nxt[lst[idx]] = nxt[idx];
+		}
+		while (k <= cntq) {
+			ans[sortq[k++]].merge(tmp);
+		}
+		cntg = cntq = 0;
+	}
+
+	public static void update(int qi, int l, int r) {
+		int jobi = x[qi], jobv = y[qi];
+		if (l <= jobi && jobi <= r) {
+			calc(l, r);
+			arr[jobi] = jobv;
+			int pos = 0;
+			for (int i = l; i <= r; ++i) {
+				if (sortv[i].i == jobi) {
+					sortv[i].v = jobv;
+					pos = i;
+					break;
+				}
+			}
+			for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; ++i) {
+				swap(sortv, i, i + 1);
+			}
+			for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; --i) {
+				swap(sortv, i - 1, i);
+			}
+		}
+	}
+
+	public static void query(int qi, int l, int r) {
+		int jobl = x[qi], jobr = y[qi], jobv = z[qi];
+		if (jobl <= l && r <= jobr) {
+			addEdge(head1, jobv & OFFSET, qi);
+		} else {
+			for (int i = Math.max(jobl, l); i <= Math.min(jobr, r); ++i) {
+				if (arr[i] <= jobv) {
+					tmp.pre = tmp.suf = tmp.len = 1;
+					tmp.res = 1;
+				} else {
+					tmp.pre = tmp.suf = 0;
+					tmp.len = 1;
+					tmp.res = 0;
+				}
+				ans[qi].merge(tmp);
+			}
+		}
+	}
+
+	public static void compute(int l, int r) {
+		for (int i = l; i <= r; ++i) {
+			sortv[i] = new Node(arr[i], i);
+		}
+		Arrays.sort(sortv, l, r + 1, (a, b) -> a.v - b.v);
+		for (int qi = 1; qi <= m; ++qi) {
+			if (op[qi] == 1) {
+				update(qi, l, r);
+			} else {
+				query(qi, l, r);
+			}
+		}
+		calc(l, r);
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; ++i) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; ++i) {
+			op[i] = in.nextInt();
+			x[i] = in.nextInt();
+			y[i] = in.nextInt();
+			if (op[i] == 2) {
+				z[i] = in.nextInt();
+			}
+		}
+		for (int i = 1; i <= m; ++i) {
+			ans[i] = new Answer(0, 0, 0, 0);
+		}
+		int BNUM = (n + BLEN - 1) / BLEN;
+		for (int b = 1, l, r; b <= BNUM; ++b) {
+			l = (b - 1) * BLEN + 1;
+			r = Math.min(b * BLEN, n);
+			compute(l, r);
+		}
+		for (int i = 1; i <= m; ++i) {
+			if (op[i] == 2) {
+				out.println(ans[i].res);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code03_MagicGirl2.java
new file mode 100644
index 000000000..5ec71e7d3
--- /dev/null
+++ b/src/class174/Code03_MagicGirl2.java
@@ -0,0 +1,221 @@
+package class174;
+
+// 魔法少女网站，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P6578
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//char buf[1000000], *p1 = buf, *p2 = buf;
+//
+//inline char gc() {
+//    if (p1 == p2) {
+//        p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
+//        if (p1 == p2) {
+//            return EOF;
+//        }
+//    }
+//    return *p1++;
+//}
+//
+//inline int read() {
+//    int x = 0;
+//    char c = gc();
+//    while (!isdigit(c)) {
+//        c = gc();
+//    }
+//    while (isdigit(c)) {
+//        x = x * 10 + c - '0';
+//        c = gc();
+//    }
+//    return x;
+//}
+//
+//struct Node {
+//    int v;
+//    int i;
+//};
+//
+//inline bool nodeCmp(const Node &a, const Node &b) {
+//    return a.v < b.v;
+//}
+//
+//struct Answer {
+//    int pre, suf, len;
+//    long long res;
+//    inline void merge(const Answer &right) {
+//        res += right.res + 1LL * suf * right.pre;
+//        if (pre == len) {
+//            pre += right.pre;
+//        }
+//        if (right.suf == right.len) {
+//            suf += right.suf;
+//        } else {
+//            suf = right.suf;
+//        }
+//        len += right.len;
+//    }
+//};
+//
+//const int MAXN = 300005;
+//const int MAXB = 601;
+//const int BLEN = 512;
+//const int OFFSET = 0x1ff;
+//const int POWER = 9;
+//int n, m;
+//
+//int arr[MAXN];
+//Node sortv[MAXN];
+//
+//int op[MAXN];
+//int x[MAXN];
+//int y[MAXN];
+//int z[MAXN];
+//
+//int head1[MAXB];
+//int head2[MAXB];
+//int toq[MAXN << 1];
+//int nexte[MAXN << 1];
+//int cntg;
+//
+//int sortq[MAXN];
+//int cntq;
+//
+//int lst[MAXN];
+//int nxt[MAXN];
+//
+//Answer tmp;
+//Answer ans[MAXN];
+//
+//inline void addEdge(int *head, int u, int v) {
+//    nexte[++cntg] = head[u];
+//    toq[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void calc(int l, int r) {
+//    for (int md = 0; md < BLEN; ++md) {
+//        for (int e = head1[md]; e; e = nexte[e]) {
+//            addEdge(head2, z[toq[e]] >> POWER, toq[e]);
+//        }
+//        head1[md] = 0;
+//    }
+//    for (int tm = n / BLEN; tm >= 0; --tm) {
+//        for (int e = head2[tm]; e; e = nexte[e]) {
+//            sortq[++cntq] = toq[e];
+//        }
+//        head2[tm] = 0;
+//    }
+//    for (int left = 1, right = cntq; left < right; ++left, --right) {
+//        swap(sortq[left], sortq[right]);
+//    }
+//    for (int i = l; i <= r; ++i) {
+//        lst[i] = i - 1;
+//        nxt[i] = i + 1;
+//    }
+//    tmp = { 0, 0, r - l + 1, 0 };
+//    int k = 1;
+//    for (int i = l, idx; i <= r; ++i) {
+//        idx = sortv[i].i;
+//        for(; k <= cntq && z[sortq[k]] < arr[idx]; ++k) {
+//        	ans[sortq[k]].merge(tmp);
+//        }
+//        if (lst[idx] == l - 1) {
+//            tmp.pre += nxt[idx] - idx;
+//        }
+//        if (nxt[idx] == r + 1) {
+//            tmp.suf += idx - lst[idx];
+//        }
+//        tmp.res += 1LL * (idx - lst[idx]) * (nxt[idx] - idx);
+//        lst[nxt[idx]] = lst[idx];
+//        nxt[lst[idx]] = nxt[idx];
+//    }
+//    for(; k <= cntq; ++k) {
+//    	ans[sortq[k]].merge(tmp);
+//    }
+//    cntg = cntq = 0;
+//}
+//
+//inline void update(int qi, int l, int r) {
+//    int jobi = x[qi], jobv = y[qi];
+//    if (l <= jobi && jobi <= r) {
+//        calc(l, r);
+//        arr[jobi] = jobv;
+//        int pos = 0;
+//        for (int i = l; i <= r; ++i) {
+//            if (sortv[i].i == jobi) {
+//                sortv[i].v = jobv;
+//                pos = i;
+//                break;
+//            }
+//        }
+//        for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; ++i) {
+//            swap(sortv[i], sortv[i + 1]);
+//        }
+//        for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; --i) {
+//            swap(sortv[i - 1], sortv[i]);
+//        }
+//    }
+//}
+//
+//inline void query(int qi, int l, int r) {
+//    int jobl = x[qi], jobr = y[qi], jobv = z[qi];
+//    if (jobl <= l && r <= jobr) {
+//        addEdge(head1, jobv & OFFSET, qi);
+//    } else {
+//    	for (int i = max(jobl, l); i <= min(jobr, r); ++i) {
+//            if (arr[i] <= jobv) {
+//                tmp = { 1, 1, 1, 1 };
+//            }else {
+//            	tmp = { 0, 0, 1, 0 };
+//            }
+//    		ans[qi].merge(tmp);
+//        }
+//    }
+//}
+//
+//void compute(int l, int r) {
+//    for (int i = l; i <= r; ++i) {
+//        sortv[i] = { arr[i], i };
+//    }
+//    sort(sortv + l, sortv + r + 1, nodeCmp);
+//    for (int qi = 1; qi <= m; ++qi) {
+//        if (op[qi] == 1) {
+//            update(qi, l, r);
+//        } else {
+//            query(qi, l, r);
+//        }
+//    }
+//    calc(l, r);
+//}
+//
+//int main() {
+//    n = read();
+//    m = read();
+//    for (int i = 1; i <= n; ++i) {
+//        arr[i] = read();
+//    }
+//    for (int i = 1; i <= m; ++i) {
+//        op[i] = read();
+//        x[i] = read();
+//        y[i] = read();
+//        if (op[i] == 2) {
+//            z[i] = read();
+//        }
+//    }
+//    int BNUM = (n + BLEN - 1) / BLEN;
+//    for (int i = 1, l, r; i <= BNUM; ++i) {
+//        l = (i - 1) * BLEN + 1;
+//        r = min(i * BLEN, n);
+//        compute(l, r);
+//    }
+//    for (int i = 1; i <= m; ++i) {
+//        if (op[i] == 2) {
+//            printf("%lld\n", ans[i].res);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From afe361a6fa0a7030ed376cedd5d9186c511f5e24 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 8 Jul 2025 22:06:22 +0800
Subject: [PATCH 1092/1712] modify code

---
 src/class174/Code03_MagicGirl1.java | 101 ++++++++++++----------------
 src/class174/Code03_MagicGirl2.java |  91 +++++++++++--------------
 2 files changed, 83 insertions(+), 109 deletions(-)

diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index 1c40178ed..cfaa85e18 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -16,7 +16,6 @@ public class Code03_MagicGirl1 {
 
 	static class Node {
 		int v, i;
-
 		Node(int v_, int i_) {
 			v = v_;
 			i = i_;
@@ -26,14 +25,12 @@ static class Node {
 	static class Answer {
 		int pre, suf, len;
 		long res;
-
 		Answer(int p, int s, int l, long r) {
 			pre = p;
 			suf = s;
 			len = l;
 			res = r;
 		}
-
 		void merge(Answer right) {
 			res += right.res + 1L * suf * right.pre;
 			if (pre == len)
@@ -45,14 +42,13 @@ void merge(Answer right) {
 			}
 			len += right.len;
 		}
-
 	}
 
 	public static int MAXN = 300005;
 	public static int MAXB = 601;
-	public static int BLEN = 512;
-	public static int OFFSET = 0x1ff;
-	public static int POWER = 9;
+	public static int POW2 = 9;
+	public static int BLEN = 1 << POW2;
+	public static int OFFSET = BLEN - 1;
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
@@ -61,16 +57,12 @@ void merge(Answer right) {
 	public static int[] op = new int[MAXN];
 	public static int[] x = new int[MAXN];
 	public static int[] y = new int[MAXN];
-	public static int[] z = new int[MAXN];
-
-	public static int[] head1 = new int[MAXB];
-	public static int[] head2 = new int[MAXB];
-	public static int[] toq = new int[MAXN << 1];
-	public static int[] nexte = new int[MAXN << 1];
-	public static int cntg;
+	public static int[] v = new int[MAXN];
 
-	public static int[] sortq = new int[MAXN];
-	public static int cntq;
+	public static int[] arrq = new int[MAXN];
+	public static int[] cntv = new int[MAXB];
+	public static int[] help = new int[MAXN];
+	public static int siz;
 
 	public static int[] lst = new int[MAXN];
 	public static int[] nxt = new int[MAXN];
@@ -90,29 +82,22 @@ public static void swap(int[] a, int i, int j) {
 		a[j] = t;
 	}
 
-	public static void addEdge(int[] head, int u, int v) {
-		nexte[++cntg] = head[u];
-		toq[cntg] = v;
-		head[u] = cntg;
+	public static void radixSort() {
+		Arrays.fill(cntv, 0);
+		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] & OFFSET]++;
+		for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
+		for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] & OFFSET]--] = arrq[i];
+		for (int i = 1; i <= siz; i++) arrq[i] = help[i];
+		Arrays.fill(cntv, 0);
+		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW2]++;
+		for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
+		for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW2]--] = arrq[i];
+		for (int i = 1; i <= siz; i++) arrq[i] = help[i];
 	}
 
 	public static void calc(int l, int r) {
-		for (int md = 0; md < BLEN; ++md) {
-			for (int e = head1[md]; e != 0; e = nexte[e]) {
-				addEdge(head2, z[toq[e]] >> POWER, toq[e]);
-			}
-			head1[md] = 0;
-		}
-		for (int tm = n / BLEN; tm >= 0; --tm) {
-			for (int e = head2[tm]; e != 0; e = nexte[e]) {
-				sortq[++cntq] = toq[e];
-			}
-			head2[tm] = 0;
-		}
-		for (int left = 1, right = cntq; left < right; ++left, --right) {
-			swap(sortq, left, right);
-		}
-		for (int i = l; i <= r; ++i) {
+		radixSort();
+		for (int i = l; i <= r; i++) {
 			lst[i] = i - 1;
 			nxt[i] = i + 1;
 		}
@@ -120,10 +105,10 @@ public static void calc(int l, int r) {
 		tmp.len = r - l + 1;
 		tmp.res = 0;
 		int k = 1;
-		for (int i = l; i <= r; ++i) {
+		for (int i = l; i <= r; i++) {
 			int idx = sortv[i].i;
-			while (k <= cntq && z[sortq[k]] < arr[idx]) {
-				ans[sortq[k++]].merge(tmp);
+			for (; k <= siz && v[arrq[k]] < arr[idx]; k++) {
+				ans[arrq[k]].merge(tmp);
 			}
 			if (lst[idx] == l - 1) {
 				tmp.pre += nxt[idx] - idx;
@@ -135,10 +120,10 @@ public static void calc(int l, int r) {
 			lst[nxt[idx]] = lst[idx];
 			nxt[lst[idx]] = nxt[idx];
 		}
-		while (k <= cntq) {
-			ans[sortq[k++]].merge(tmp);
+		for (; k <= siz; k++) {
+			ans[arrq[k]].merge(tmp);
 		}
-		cntg = cntq = 0;
+		siz = 0;
 	}
 
 	public static void update(int qi, int l, int r) {
@@ -147,28 +132,28 @@ public static void update(int qi, int l, int r) {
 			calc(l, r);
 			arr[jobi] = jobv;
 			int pos = 0;
-			for (int i = l; i <= r; ++i) {
+			for (int i = l; i <= r; i++) {
 				if (sortv[i].i == jobi) {
 					sortv[i].v = jobv;
 					pos = i;
 					break;
 				}
 			}
-			for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; ++i) {
+			for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; i++) {
 				swap(sortv, i, i + 1);
 			}
-			for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; --i) {
+			for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; i--) {
 				swap(sortv, i - 1, i);
 			}
 		}
 	}
 
 	public static void query(int qi, int l, int r) {
-		int jobl = x[qi], jobr = y[qi], jobv = z[qi];
+		int jobl = x[qi], jobr = y[qi], jobv = v[qi];
 		if (jobl <= l && r <= jobr) {
-			addEdge(head1, jobv & OFFSET, qi);
+			arrq[++siz] = qi;
 		} else {
-			for (int i = Math.max(jobl, l); i <= Math.min(jobr, r); ++i) {
+			for (int i = Math.max(jobl, l); i <= Math.min(jobr, r); i++) {
 				if (arr[i] <= jobv) {
 					tmp.pre = tmp.suf = tmp.len = 1;
 					tmp.res = 1;
@@ -183,11 +168,11 @@ public static void query(int qi, int l, int r) {
 	}
 
 	public static void compute(int l, int r) {
-		for (int i = l; i <= r; ++i) {
+		for (int i = l; i <= r; i++) {
 			sortv[i] = new Node(arr[i], i);
 		}
 		Arrays.sort(sortv, l, r + 1, (a, b) -> a.v - b.v);
-		for (int qi = 1; qi <= m; ++qi) {
+		for (int qi = 1; qi <= m; qi++) {
 			if (op[qi] == 1) {
 				update(qi, l, r);
 			} else {
@@ -202,27 +187,27 @@ public static void main(String[] args) throws Exception {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		m = in.nextInt();
-		for (int i = 1; i <= n; ++i) {
+		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
-		for (int i = 1; i <= m; ++i) {
+		for (int i = 1; i <= m; i++) {
 			op[i] = in.nextInt();
 			x[i] = in.nextInt();
 			y[i] = in.nextInt();
 			if (op[i] == 2) {
-				z[i] = in.nextInt();
+				v[i] = in.nextInt();
 			}
 		}
-		for (int i = 1; i <= m; ++i) {
+		for (int i = 1; i <= m; i++) {
 			ans[i] = new Answer(0, 0, 0, 0);
 		}
 		int BNUM = (n + BLEN - 1) / BLEN;
-		for (int b = 1, l, r; b <= BNUM; ++b) {
-			l = (b - 1) * BLEN + 1;
-			r = Math.min(b * BLEN, n);
+		for (int i = 1, l, r; i <= BNUM; i++) {
+			l = (i - 1) * BLEN + 1;
+			r = Math.min(i * BLEN, n);
 			compute(l, r);
 		}
-		for (int i = 1; i <= m; ++i) {
+		for (int i = 1; i <= m; i++) {
 			if (op[i] == 2) {
 				out.println(ans[i].res);
 			}
diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code03_MagicGirl2.java
index 5ec71e7d3..f0e5338f4 100644
--- a/src/class174/Code03_MagicGirl2.java
+++ b/src/class174/Code03_MagicGirl2.java
@@ -62,9 +62,9 @@
 //
 //const int MAXN = 300005;
 //const int MAXB = 601;
-//const int BLEN = 512;
-//const int OFFSET = 0x1ff;
-//const int POWER = 9;
+//const int POW2 = 9;
+//const int BLEN = 1 << POW2;
+//const int OFFSET = BLEN - 1;
 //int n, m;
 //
 //int arr[MAXN];
@@ -73,16 +73,12 @@
 //int op[MAXN];
 //int x[MAXN];
 //int y[MAXN];
-//int z[MAXN];
+//int v[MAXN];
 //
-//int head1[MAXB];
-//int head2[MAXB];
-//int toq[MAXN << 1];
-//int nexte[MAXN << 1];
-//int cntg;
-//
-//int sortq[MAXN];
-//int cntq;
+//int arrq[MAXN];
+//int cntv[MAXB];
+//int help[MAXN];
+//int siz;
 //
 //int lst[MAXN];
 //int nxt[MAXN];
@@ -90,38 +86,31 @@
 //Answer tmp;
 //Answer ans[MAXN];
 //
-//inline void addEdge(int *head, int u, int v) {
-//    nexte[++cntg] = head[u];
-//    toq[cntg] = v;
-//    head[u] = cntg;
+//inline void radixSort() {
+//    fill(cntv, cntv + MAXB, 0);
+//    for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] & OFFSET]++;
+//    for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
+//    for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] & OFFSET]--] = arrq[i];
+//    for (int i = 1; i <= siz; i++) arrq[i] = help[i];
+//    fill(cntv, cntv + MAXB, 0);
+//    for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW2]++;
+//    for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
+//    for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW2]--] = arrq[i];
+//    for (int i = 1; i <= siz; i++) arrq[i] = help[i];
 //}
 //
 //void calc(int l, int r) {
-//    for (int md = 0; md < BLEN; ++md) {
-//        for (int e = head1[md]; e; e = nexte[e]) {
-//            addEdge(head2, z[toq[e]] >> POWER, toq[e]);
-//        }
-//        head1[md] = 0;
-//    }
-//    for (int tm = n / BLEN; tm >= 0; --tm) {
-//        for (int e = head2[tm]; e; e = nexte[e]) {
-//            sortq[++cntq] = toq[e];
-//        }
-//        head2[tm] = 0;
-//    }
-//    for (int left = 1, right = cntq; left < right; ++left, --right) {
-//        swap(sortq[left], sortq[right]);
-//    }
-//    for (int i = l; i <= r; ++i) {
+//	radixSort();
+//    for (int i = l; i <= r; i++) {
 //        lst[i] = i - 1;
 //        nxt[i] = i + 1;
 //    }
 //    tmp = { 0, 0, r - l + 1, 0 };
 //    int k = 1;
-//    for (int i = l, idx; i <= r; ++i) {
+//    for (int i = l, idx; i <= r; i++) {
 //        idx = sortv[i].i;
-//        for(; k <= cntq && z[sortq[k]] < arr[idx]; ++k) {
-//        	ans[sortq[k]].merge(tmp);
+//        for(; k <= siz && v[arrq[k]] < arr[idx]; k++) {
+//        	ans[arrq[k]].merge(tmp);
 //        }
 //        if (lst[idx] == l - 1) {
 //            tmp.pre += nxt[idx] - idx;
@@ -133,10 +122,10 @@
 //        lst[nxt[idx]] = lst[idx];
 //        nxt[lst[idx]] = nxt[idx];
 //    }
-//    for(; k <= cntq; ++k) {
-//    	ans[sortq[k]].merge(tmp);
+//    for(; k <= siz; k++) {
+//    	ans[arrq[k]].merge(tmp);
 //    }
-//    cntg = cntq = 0;
+//    siz = 0;
 //}
 //
 //inline void update(int qi, int l, int r) {
@@ -145,28 +134,28 @@
 //        calc(l, r);
 //        arr[jobi] = jobv;
 //        int pos = 0;
-//        for (int i = l; i <= r; ++i) {
+//        for (int i = l; i <= r; i++) {
 //            if (sortv[i].i == jobi) {
 //                sortv[i].v = jobv;
 //                pos = i;
 //                break;
 //            }
 //        }
-//        for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; ++i) {
+//        for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; i++) {
 //            swap(sortv[i], sortv[i + 1]);
 //        }
-//        for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; --i) {
+//        for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; i--) {
 //            swap(sortv[i - 1], sortv[i]);
 //        }
 //    }
 //}
 //
 //inline void query(int qi, int l, int r) {
-//    int jobl = x[qi], jobr = y[qi], jobv = z[qi];
+//    int jobl = x[qi], jobr = y[qi], jobv = v[qi];
 //    if (jobl <= l && r <= jobr) {
-//        addEdge(head1, jobv & OFFSET, qi);
+//        arrq[++siz] = qi;
 //    } else {
-//    	for (int i = max(jobl, l); i <= min(jobr, r); ++i) {
+//    	for (int i = max(jobl, l); i <= min(jobr, r); i++) {
 //            if (arr[i] <= jobv) {
 //                tmp = { 1, 1, 1, 1 };
 //            }else {
@@ -178,11 +167,11 @@
 //}
 //
 //void compute(int l, int r) {
-//    for (int i = l; i <= r; ++i) {
+//    for (int i = l; i <= r; i++) {
 //        sortv[i] = { arr[i], i };
 //    }
 //    sort(sortv + l, sortv + r + 1, nodeCmp);
-//    for (int qi = 1; qi <= m; ++qi) {
+//    for (int qi = 1; qi <= m; qi++) {
 //        if (op[qi] == 1) {
 //            update(qi, l, r);
 //        } else {
@@ -195,24 +184,24 @@
 //int main() {
 //    n = read();
 //    m = read();
-//    for (int i = 1; i <= n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        arr[i] = read();
 //    }
-//    for (int i = 1; i <= m; ++i) {
+//    for (int i = 1; i <= m; i++) {
 //        op[i] = read();
 //        x[i] = read();
 //        y[i] = read();
 //        if (op[i] == 2) {
-//            z[i] = read();
+//        	v[i] = read();
 //        }
 //    }
 //    int BNUM = (n + BLEN - 1) / BLEN;
-//    for (int i = 1, l, r; i <= BNUM; ++i) {
+//    for (int i = 1, l, r; i <= BNUM; i++) {
 //        l = (i - 1) * BLEN + 1;
 //        r = min(i * BLEN, n);
 //        compute(l, r);
 //    }
-//    for (int i = 1; i <= m; ++i) {
+//    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 2) {
 //            printf("%lld\n", ans[i].res);
 //        }

From 54a81f3712209744578658030a448c260b5d9a71 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 8 Jul 2025 22:41:09 +0800
Subject: [PATCH 1093/1712] modify code

---
 src/class174/Code03_MagicGirl2.java | 12 ++++++------
 1 file changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code03_MagicGirl2.java
index f0e5338f4..53465aee5 100644
--- a/src/class174/Code03_MagicGirl2.java
+++ b/src/class174/Code03_MagicGirl2.java
@@ -100,7 +100,7 @@
 //}
 //
 //void calc(int l, int r) {
-//	radixSort();
+//    radixSort();
 //    for (int i = l; i <= r; i++) {
 //        lst[i] = i - 1;
 //        nxt[i] = i + 1;
@@ -155,13 +155,13 @@
 //    if (jobl <= l && r <= jobr) {
 //        arrq[++siz] = qi;
 //    } else {
-//    	for (int i = max(jobl, l); i <= min(jobr, r); i++) {
+//        for (int i = max(jobl, l); i <= min(jobr, r); i++) {
 //            if (arr[i] <= jobv) {
 //                tmp = { 1, 1, 1, 1 };
-//            }else {
-//            	tmp = { 0, 0, 1, 0 };
+//            } else {
+//                tmp = { 0, 0, 1, 0 };
 //            }
-//    		ans[qi].merge(tmp);
+//            ans[qi].merge(tmp);
 //        }
 //    }
 //}
@@ -192,7 +192,7 @@
 //        x[i] = read();
 //        y[i] = read();
 //        if (op[i] == 2) {
-//        	v[i] = read();
+//            v[i] = read();
 //        }
 //    }
 //    int BNUM = (n + BLEN - 1) / BLEN;

From be75e0126af0393dd6488a1aabba2283bb0cd68e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 8 Jul 2025 22:57:18 +0800
Subject: [PATCH 1094/1712] modify code

---
 src/class174/Code03_MagicGirl1.java | 21 ++++----------
 src/class174/Code03_MagicGirl2.java | 44 ++++++-----------------------
 2 files changed, 14 insertions(+), 51 deletions(-)

diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index cfaa85e18..d021863e9 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -70,18 +70,6 @@ void merge(Answer right) {
 	public static Answer tmp = new Answer(0, 0, 0, 0);
 	public static Answer[] ans = new Answer[MAXN];
 
-	public static void swap(Node[] a, int i, int j) {
-		Node t = a[i];
-		a[i] = a[j];
-		a[j] = t;
-	}
-
-	public static void swap(int[] a, int i, int j) {
-		int t = a[i];
-		a[i] = a[j];
-		a[j] = t;
-	}
-
 	public static void radixSort() {
 		Arrays.fill(cntv, 0);
 		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] & OFFSET]++;
@@ -139,11 +127,12 @@ public static void update(int qi, int l, int r) {
 					break;
 				}
 			}
+			Node tmp;
 			for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; i++) {
-				swap(sortv, i, i + 1);
+				tmp = sortv[i]; sortv[i] = sortv[i + 1]; sortv[i + 1] = tmp;
 			}
 			for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; i--) {
-				swap(sortv, i - 1, i);
+				tmp = sortv[i - 1]; sortv[i - 1] = sortv[i]; sortv[i] = tmp;
 			}
 		}
 	}
@@ -201,8 +190,8 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= m; i++) {
 			ans[i] = new Answer(0, 0, 0, 0);
 		}
-		int BNUM = (n + BLEN - 1) / BLEN;
-		for (int i = 1, l, r; i <= BNUM; i++) {
+		int bnum = (n + BLEN - 1) / BLEN;
+		for (int i = 1, l, r; i <= bnum; i++) {
 			l = (i - 1) * BLEN + 1;
 			r = Math.min(i * BLEN, n);
 			compute(l, r);
diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code03_MagicGirl2.java
index 53465aee5..66fad9987 100644
--- a/src/class174/Code03_MagicGirl2.java
+++ b/src/class174/Code03_MagicGirl2.java
@@ -9,31 +9,6 @@
 //
 //using namespace std;
 //
-//char buf[1000000], *p1 = buf, *p2 = buf;
-//
-//inline char gc() {
-//    if (p1 == p2) {
-//        p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin);
-//        if (p1 == p2) {
-//            return EOF;
-//        }
-//    }
-//    return *p1++;
-//}
-//
-//inline int read() {
-//    int x = 0;
-//    char c = gc();
-//    while (!isdigit(c)) {
-//        c = gc();
-//    }
-//    while (isdigit(c)) {
-//        x = x * 10 + c - '0';
-//        c = gc();
-//    }
-//    return x;
-//}
-//
 //struct Node {
 //    int v;
 //    int i;
@@ -182,28 +157,27 @@
 //}
 //
 //int main() {
-//    n = read();
-//    m = read();
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
-//        arr[i] = read();
+//        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        op[i] = read();
-//        x[i] = read();
-//        y[i] = read();
+//        cin >> op[i] >> x[i] >> y[i];
 //        if (op[i] == 2) {
-//            v[i] = read();
+//            cin >> v[i];
 //        }
 //    }
-//    int BNUM = (n + BLEN - 1) / BLEN;
-//    for (int i = 1, l, r; i <= BNUM; i++) {
+//    int bnum = (n + BLEN - 1) / BLEN;
+//    for (int i = 1, l, r; i <= bnum; i++) {
 //        l = (i - 1) * BLEN + 1;
 //        r = min(i * BLEN, n);
 //        compute(l, r);
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 2) {
-//            printf("%lld\n", ans[i].res);
+//            cout << ans[i].res << '\n';
 //        }
 //    }
 //    return 0;

From f4947f06e226d7a883446b85a49d5f727461becf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 8 Jul 2025 23:45:27 +0800
Subject: [PATCH 1095/1712] modify code

---
 src/class174/Code03_MagicGirl1.java | 35 +++++++++++-----------------
 src/class174/Code03_MagicGirl2.java | 36 +++++++++++------------------
 2 files changed, 26 insertions(+), 45 deletions(-)

diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index d021863e9..d4fc8fa72 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -14,14 +14,6 @@
 
 public class Code03_MagicGirl1 {
 
-	static class Node {
-		int v, i;
-		Node(int v_, int i_) {
-			v = v_;
-			i = i_;
-		}
-	}
-
 	static class Answer {
 		int pre, suf, len;
 		long res;
@@ -52,7 +44,7 @@ void merge(Answer right) {
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
-	public static Node[] sortv = new Node[MAXN];
+	public static Integer[] pos = new Integer[MAXN];
 
 	public static int[] op = new int[MAXN];
 	public static int[] x = new int[MAXN];
@@ -93,8 +85,8 @@ public static void calc(int l, int r) {
 		tmp.len = r - l + 1;
 		tmp.res = 0;
 		int k = 1;
-		for (int i = l; i <= r; i++) {
-			int idx = sortv[i].i;
+		for (int i = l, idx; i <= r; i++) {
+			idx = pos[i];
 			for (; k <= siz && v[arrq[k]] < arr[idx]; k++) {
 				ans[arrq[k]].merge(tmp);
 			}
@@ -119,20 +111,19 @@ public static void update(int qi, int l, int r) {
 		if (l <= jobi && jobi <= r) {
 			calc(l, r);
 			arr[jobi] = jobv;
-			int pos = 0;
+			int find = 0;
 			for (int i = l; i <= r; i++) {
-				if (sortv[i].i == jobi) {
-					sortv[i].v = jobv;
-					pos = i;
+				if (pos[i] == jobi) {
+					find = i;
 					break;
 				}
 			}
-			Node tmp;
-			for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; i++) {
-				tmp = sortv[i]; sortv[i] = sortv[i + 1]; sortv[i + 1] = tmp;
+			int tmp;
+			for (int i = find; i < r && arr[pos[i]] > arr[pos[i + 1]]; i++) {
+				tmp = pos[i]; pos[i] = pos[i + 1]; pos[i + 1] = tmp;
 			}
-			for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; i--) {
-				tmp = sortv[i - 1]; sortv[i - 1] = sortv[i]; sortv[i] = tmp;
+			for (int i = find; i > l && arr[pos[i - 1]] > arr[pos[i]]; i--) {
+				tmp = pos[i - 1]; pos[i - 1] = pos[i]; pos[i] = tmp;
 			}
 		}
 	}
@@ -158,9 +149,9 @@ public static void query(int qi, int l, int r) {
 
 	public static void compute(int l, int r) {
 		for (int i = l; i <= r; i++) {
-			sortv[i] = new Node(arr[i], i);
+			pos[i] = i;
 		}
-		Arrays.sort(sortv, l, r + 1, (a, b) -> a.v - b.v);
+		Arrays.sort(pos, l, r + 1, (a, b) -> arr[a] - arr[b]);
 		for (int qi = 1; qi <= m; qi++) {
 			if (op[qi] == 1) {
 				update(qi, l, r);
diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code03_MagicGirl2.java
index 66fad9987..a762654df 100644
--- a/src/class174/Code03_MagicGirl2.java
+++ b/src/class174/Code03_MagicGirl2.java
@@ -9,15 +9,6 @@
 //
 //using namespace std;
 //
-//struct Node {
-//    int v;
-//    int i;
-//};
-//
-//inline bool nodeCmp(const Node &a, const Node &b) {
-//    return a.v < b.v;
-//}
-//
 //struct Answer {
 //    int pre, suf, len;
 //    long long res;
@@ -43,7 +34,7 @@
 //int n, m;
 //
 //int arr[MAXN];
-//Node sortv[MAXN];
+//int pos[MAXN];
 //
 //int op[MAXN];
 //int x[MAXN];
@@ -83,9 +74,9 @@
 //    tmp = { 0, 0, r - l + 1, 0 };
 //    int k = 1;
 //    for (int i = l, idx; i <= r; i++) {
-//        idx = sortv[i].i;
+//        idx = pos[i];
 //        for(; k <= siz && v[arrq[k]] < arr[idx]; k++) {
-//        	ans[arrq[k]].merge(tmp);
+//            ans[arrq[k]].merge(tmp);
 //        }
 //        if (lst[idx] == l - 1) {
 //            tmp.pre += nxt[idx] - idx;
@@ -98,7 +89,7 @@
 //        nxt[lst[idx]] = nxt[idx];
 //    }
 //    for(; k <= siz; k++) {
-//    	ans[arrq[k]].merge(tmp);
+//        ans[arrq[k]].merge(tmp);
 //    }
 //    siz = 0;
 //}
@@ -108,19 +99,18 @@
 //    if (l <= jobi && jobi <= r) {
 //        calc(l, r);
 //        arr[jobi] = jobv;
-//        int pos = 0;
+//        int find = 0;
 //        for (int i = l; i <= r; i++) {
-//            if (sortv[i].i == jobi) {
-//                sortv[i].v = jobv;
-//                pos = i;
+//            if (pos[i] == jobi) {
+//                find = i;
 //                break;
 //            }
 //        }
-//        for (int i = pos; i < r && sortv[i].v > sortv[i + 1].v; i++) {
-//            swap(sortv[i], sortv[i + 1]);
+//        for (int i = find; i < r && arr[pos[i]] > arr[pos[i + 1]]; i++) {
+//            swap(pos[i], pos[i + 1]);
 //        }
-//        for (int i = pos; i > l && sortv[i - 1].v > sortv[i].v; i--) {
-//            swap(sortv[i - 1], sortv[i]);
+//        for (int i = find; i > l && arr[pos[i - 1]] > arr[pos[i]]; i--) {
+//            swap(pos[i - 1], pos[i]);
 //        }
 //    }
 //}
@@ -143,9 +133,9 @@
 //
 //void compute(int l, int r) {
 //    for (int i = l; i <= r; i++) {
-//        sortv[i] = { arr[i], i };
+//        pos[i] = i;
 //    }
-//    sort(sortv + l, sortv + r + 1, nodeCmp);
+//    sort(pos + l, pos + r + 1, [&](int a, int b) {return arr[a] < arr[b];});
 //    for (int qi = 1; qi <= m; qi++) {
 //        if (op[qi] == 1) {
 //            update(qi, l, r);

From fd50bbfa272e216d8e955080eefb63e3c86180de Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 9 Jul 2025 13:57:02 +0800
Subject: [PATCH 1096/1712] modify code

---
 src/class173/Code03_Magnet1.java    | 36 ++++++++---------------------
 src/class174/Code03_MagicGirl1.java | 25 ++++++++++++++++++--
 src/class174/Code03_MagicGirl2.java |  1 +
 3 files changed, 34 insertions(+), 28 deletions(-)

diff --git a/src/class173/Code03_Magnet1.java b/src/class173/Code03_Magnet1.java
index a371117e4..ebb4c8d33 100644
--- a/src/class173/Code03_Magnet1.java
+++ b/src/class173/Code03_Magnet1.java
@@ -54,21 +54,13 @@ public static void swap(int i, int j) {
 
 	// 所有磁块根据m值排序，手写双指针快排
 	public static void sortByM(int l, int r) {
-		if (l >= r) {
-			return;
-		}
+		if (l >= r) return;
 		int i = l, j = r;
-		int pivot = m[(l + r) >>> 1];
+		int pivot = m[(l + r) >> 1];
 		while (i <= j) {
-			while (m[i] < pivot) {
-				i++;
-			}
-			while (m[j] > pivot) {
-				j--;
-			}
-			if (i <= j) {
-				swap(i++, j--);
-			}
+			while (m[i] < pivot) i++;
+			while (m[j] > pivot) j--;
+			if (i <= j) swap(i++, j--);
 		}
 		sortByM(l, j);
 		sortByM(i, r);
@@ -76,21 +68,13 @@ public static void sortByM(int l, int r) {
 
 	// 所有磁块根据dist值排序，手写双指针快排
 	public static void sortByDist(int l, int r) {
-		if (l >= r) {
-			return;
-		}
+		if (l >= r) return;
 		int i = l, j = r;
-		long pivot = dist[(l + r) >>> 1];
+		long pivot = dist[(l + r) >> 1];
 		while (i <= j) {
-			while (dist[i] < pivot) {
-				i++;
-			}
-			while (dist[j] > pivot) {
-				j--;
-			}
-			if (i <= j) {
-				swap(i++, j--);
-			}
+			while (dist[i] < pivot) i++;
+			while (dist[j] > pivot) j--;
+			if (i <= j) swap(i++, j--);
 		}
 		sortByDist(l, j);
 		sortByDist(i, r);
diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index d4fc8fa72..29b597cb5 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -17,12 +17,14 @@ public class Code03_MagicGirl1 {
 	static class Answer {
 		int pre, suf, len;
 		long res;
+
 		Answer(int p, int s, int l, long r) {
 			pre = p;
 			suf = s;
 			len = l;
 			res = r;
 		}
+
 		void merge(Answer right) {
 			res += right.res + 1L * suf * right.pre;
 			if (pre == len)
@@ -44,7 +46,7 @@ void merge(Answer right) {
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
-	public static Integer[] pos = new Integer[MAXN];
+	public static int[] pos = new int[MAXN];
 
 	public static int[] op = new int[MAXN];
 	public static int[] x = new int[MAXN];
@@ -61,7 +63,26 @@ void merge(Answer right) {
 
 	public static Answer tmp = new Answer(0, 0, 0, 0);
 	public static Answer[] ans = new Answer[MAXN];
+	
+	// 根据arr[pos[i]]的值，对pos[l..r]进行双指针快排
+	public static void quickSort(int l, int r) {
+		if (l >= r) {
+			return;
+		}
+		int i = l, j = r, pivot = arr[pos[(l + r) >> 1]], tmp;
+		while (i <= j) {
+			while (arr[pos[i]] < pivot) i++;
+			while (arr[pos[j]] > pivot) j--;
+			if (i <= j) {
+				tmp = pos[i]; pos[i] = pos[j]; pos[j] = tmp;
+				i++; j--;
+			}
+		}
+		quickSort(l, j);
+		quickSort(i, r);
+	}
 
+	// 根据查询任务的jobv，对查询任务的编号进行基数排序
 	public static void radixSort() {
 		Arrays.fill(cntv, 0);
 		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] & OFFSET]++;
@@ -151,7 +172,7 @@ public static void compute(int l, int r) {
 		for (int i = l; i <= r; i++) {
 			pos[i] = i;
 		}
-		Arrays.sort(pos, l, r + 1, (a, b) -> arr[a] - arr[b]);
+		quickSort(l, r);
 		for (int qi = 1; qi <= m; qi++) {
 			if (op[qi] == 1) {
 				update(qi, l, r);
diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code03_MagicGirl2.java
index a762654df..274888b7f 100644
--- a/src/class174/Code03_MagicGirl2.java
+++ b/src/class174/Code03_MagicGirl2.java
@@ -12,6 +12,7 @@
 //struct Answer {
 //    int pre, suf, len;
 //    long long res;
+//
 //    inline void merge(const Answer &right) {
 //        res += right.res + 1LL * suf * right.pre;
 //        if (pre == len) {

From c55f7cc0f52bdb34dc1b084f0995aee7344bd047 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 9 Jul 2025 14:13:46 +0800
Subject: [PATCH 1097/1712] modify code

---
 src/class174/Code01_FutureDiary1.java   | 3 ++-
 src/class174/Code02_ColorfulWorld1.java | 3 ++-
 src/class174/Code03_MagicGirl1.java     | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 01d957b1b..875d50289 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -2,7 +2,8 @@
 
 // 未来日记，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4119
-// 提交以下的code，提交时请把类名改成"Main"，本题卡常，java实现无法通过
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
 // 想通过用C++实现，本节课Code01_FutureDiary2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
diff --git a/src/class174/Code02_ColorfulWorld1.java b/src/class174/Code02_ColorfulWorld1.java
index 3b87236ec..171b8d5d6 100644
--- a/src/class174/Code02_ColorfulWorld1.java
+++ b/src/class174/Code02_ColorfulWorld1.java
@@ -2,7 +2,8 @@
 
 // 五彩斑斓的世界，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4117
-// 提交以下的code，提交时请把类名改成"Main"，本题卡常，java实现无法通过
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
 // 想通过用C++实现，本节课Code02_ColorfulWorld2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index 29b597cb5..48970bca5 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -2,7 +2,8 @@
 
 // 魔法少女网站，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P6578
-// 提交以下的code，提交时请把类名改成"Main"，本题卡常，java实现无法通过
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
 // 想通过用C++实现，本节课Code03_MagicGirl2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 

From c423adb76169ca84bb149836e0f01f9723689370 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 9 Jul 2025 14:17:55 +0800
Subject: [PATCH 1098/1712] modify code

---
 src/class174/Code03_MagicGirl1.java | 24 ++++++++++++------------
 1 file changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index 48970bca5..bfffef54e 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -59,8 +59,8 @@ void merge(Answer right) {
 	public static int[] help = new int[MAXN];
 	public static int siz;
 
-	public static int[] lst = new int[MAXN];
-	public static int[] nxt = new int[MAXN];
+	public static int[] last = new int[MAXN];
+	public static int[] next = new int[MAXN];
 
 	public static Answer tmp = new Answer(0, 0, 0, 0);
 	public static Answer[] ans = new Answer[MAXN];
@@ -83,7 +83,7 @@ public static void quickSort(int l, int r) {
 		quickSort(i, r);
 	}
 
-	// 根据查询任务的jobv，对查询任务的编号进行基数排序
+	// 根据查询任务的v值，对查询任务的编号进行基数排序
 	public static void radixSort() {
 		Arrays.fill(cntv, 0);
 		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] & OFFSET]++;
@@ -100,8 +100,8 @@ public static void radixSort() {
 	public static void calc(int l, int r) {
 		radixSort();
 		for (int i = l; i <= r; i++) {
-			lst[i] = i - 1;
-			nxt[i] = i + 1;
+			last[i] = i - 1;
+			next[i] = i + 1;
 		}
 		tmp.pre = tmp.suf = 0;
 		tmp.len = r - l + 1;
@@ -112,15 +112,15 @@ public static void calc(int l, int r) {
 			for (; k <= siz && v[arrq[k]] < arr[idx]; k++) {
 				ans[arrq[k]].merge(tmp);
 			}
-			if (lst[idx] == l - 1) {
-				tmp.pre += nxt[idx] - idx;
+			if (last[idx] == l - 1) {
+				tmp.pre += next[idx] - idx;
 			}
-			if (nxt[idx] == r + 1) {
-				tmp.suf += idx - lst[idx];
+			if (next[idx] == r + 1) {
+				tmp.suf += idx - last[idx];
 			}
-			tmp.res += 1L * (idx - lst[idx]) * (nxt[idx] - idx);
-			lst[nxt[idx]] = lst[idx];
-			nxt[lst[idx]] = nxt[idx];
+			tmp.res += 1L * (idx - last[idx]) * (next[idx] - idx);
+			last[next[idx]] = last[idx];
+			next[last[idx]] = next[idx];
 		}
 		for (; k <= siz; k++) {
 			ans[arrq[k]].merge(tmp);

From 7bf83b8e895447329a10868dd601f47d75dc957e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 9 Jul 2025 14:23:49 +0800
Subject: [PATCH 1099/1712] modify code

---
 src/class174/Code03_MagicGirl1.java | 11 +++--------
 1 file changed, 3 insertions(+), 8 deletions(-)

diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index bfffef54e..cf9a17549 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -103,9 +103,7 @@ public static void calc(int l, int r) {
 			last[i] = i - 1;
 			next[i] = i + 1;
 		}
-		tmp.pre = tmp.suf = 0;
-		tmp.len = r - l + 1;
-		tmp.res = 0;
+		tmp.pre = 0; tmp.suf = 0; tmp.len = r - l + 1; tmp.res = 0;
 		int k = 1;
 		for (int i = l, idx; i <= r; i++) {
 			idx = pos[i];
@@ -157,12 +155,9 @@ public static void query(int qi, int l, int r) {
 		} else {
 			for (int i = Math.max(jobl, l); i <= Math.min(jobr, r); i++) {
 				if (arr[i] <= jobv) {
-					tmp.pre = tmp.suf = tmp.len = 1;
-					tmp.res = 1;
+					tmp.pre = 1; tmp.suf = 1; tmp.len = 1; tmp.res = 1;
 				} else {
-					tmp.pre = tmp.suf = 0;
-					tmp.len = 1;
-					tmp.res = 0;
+					tmp.pre = 0; tmp.suf = 0; tmp.len = 1; tmp.res = 0;
 				}
 				ans[qi].merge(tmp);
 			}

From 1c339fdcc5efda45a00728860e763a748111687e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 9 Jul 2025 18:08:51 +0800
Subject: [PATCH 1100/1712] modify code

---
 src/class174/Code04_Lcm1.java | 239 ++++++++++++++++++++++++++++++++++
 src/class174/Code04_Lcm2.java | 150 +++++++++++++++++++++
 2 files changed, 389 insertions(+)
 create mode 100644 src/class174/Code04_Lcm1.java
 create mode 100644 src/class174/Code04_Lcm2.java

diff --git a/src/class174/Code04_Lcm1.java b/src/class174/Code04_Lcm1.java
new file mode 100644
index 000000000..237836674
--- /dev/null
+++ b/src/class174/Code04_Lcm1.java
@@ -0,0 +1,239 @@
+package class174;
+
+// 最小公倍数，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3247
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code04_Lcm1 {
+
+	static class Param {
+		int u, v, a, b, qid;
+
+		public Param(int u_, int v_, int a_, int b_) {
+			u = u_;
+			v = v_;
+			a = a_;
+			b = b_;
+		}
+	}
+
+	static class CmpA implements Comparator<Param> {
+		@Override
+		public int compare(Param o1, Param o2) {
+			return o1.a - o2.a;
+		}
+	}
+
+	static class CmpB implements Comparator<Param> {
+		@Override
+		public int compare(Param o1, Param o2) {
+			return o1.b - o2.b;
+		}
+	}
+
+	public static CmpA cmpa = new CmpA();
+	public static CmpB cmpb = new CmpB();
+
+	public static int MAXN = 50001;
+	public static int MAXM = 100001;
+	public static int MAXQ = 50001;
+	public static int n, m, q;
+	public static int blen, bnum;
+
+	public static Param[] edge = new Param[MAXM];
+	public static Param[] ques = new Param[MAXQ];
+
+	public static int[] arr = new int[MAXQ];
+	public static int cntq = 0;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxa = new int[MAXN];
+	public static int[] maxb = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][5];
+	public static int opsize = 0;
+
+	public static boolean[] ans = new boolean[MAXQ];
+
+	public static void build() {
+		for (int i = 1; i <= n; i++) {
+			fa[i] = i;
+			siz[i] = 1;
+			maxa[i] = -1;
+			maxb[i] = -1;
+		}
+	}
+
+	public static int find(int x) {
+		while (x != fa[x]) {
+			x = fa[x];
+		}
+		return x;
+	}
+
+	public static void union(int x, int y, int a, int b) {
+		int fx = find(x);
+		int fy = find(y);
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+		rollback[opsize][2] = siz[fx];
+		rollback[opsize][3] = maxa[fx];
+		rollback[opsize][4] = maxb[fx];
+		if (fx != fy) {
+			fa[fy] = fx;
+			siz[fx] += siz[fy];
+		}
+		maxa[fx] = Math.max(Math.max(maxa[fx], maxa[fy]), a);
+		maxb[fx] = Math.max(Math.max(maxb[fx], maxb[fy]), b);
+	}
+
+	public static void undo() {
+		for (int fx, fy; opsize > 0; opsize--) {
+			fx = rollback[opsize][0];
+			fy = rollback[opsize][1];
+			fa[fy] = fy;
+			siz[fx] = rollback[opsize][2];
+			maxa[fx] = rollback[opsize][3];
+			maxb[fx] = rollback[opsize][4];
+		}
+	}
+
+	public static boolean query(int x, int y, int a, int b) {
+		int fx = find(x);
+		int fy = find(y);
+		return fx == fy && maxa[fx] == a && maxb[fx] == b;
+	}
+
+	public static void compute(int l, int r) {
+		build();
+		cntq = 0;
+		for (int i = 1; i <= q; i++) {
+			// 保证每条询问只落入其中的一块
+			if (edge[l].a <= ques[i].a && (r + 1 > m || ques[i].a < edge[r + 1].a)) {
+				arr[++cntq] = i;
+			}
+		}
+		if (cntq > 0) {
+			Arrays.sort(edge, 1, l, cmpb);
+			int pos = 1;
+			for (int i = 1; i <= cntq; i++) {
+				for (; pos < l && edge[pos].b <= ques[arr[i]].b; pos++) {
+					union(edge[pos].u, edge[pos].v, edge[pos].a, edge[pos].b);
+				}
+				opsize = 0;
+				for (int j = l; j <= r; j++) {
+					if (edge[j].a <= ques[arr[i]].a && edge[j].b <= ques[arr[i]].b) {
+						union(edge[j].u, edge[j].v, edge[j].a, edge[j].b);
+					}
+				}
+				ans[ques[arr[i]].qid] = query(ques[arr[i]].u, ques[arr[i]].v, ques[arr[i]].a, ques[arr[i]].b);
+				undo();
+			}
+		}
+	}
+
+	public static int log2(int n) {
+		int ans = 0;
+		while ((1 << ans) <= (n >> 1)) {
+			ans++;
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = Math.max(1, (int) Math.sqrt(m * log2(n)));
+		bnum = (m + blen - 1) / blen;
+		Arrays.sort(edge, 1, m + 1, cmpa);
+		Arrays.sort(ques, 1, q + 1, cmpb);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, u, v, a, b; i <= m; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			a = in.nextInt();
+			b = in.nextInt();
+			edge[i] = new Param(u, v, a, b);
+		}
+		q = in.nextInt();
+		for (int i = 1, u, v, a, b; i <= q; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			a = in.nextInt();
+			b = in.nextInt();
+			ques[i] = new Param(u, v, a, b);
+			ques[i].qid = i;
+		}
+		prepare();
+		for (int i = 1, l, r; i <= bnum; i++) {
+			l = (i - 1) * blen + 1;
+			r = Math.min(i * blen, m);
+			compute(l, r);
+		}
+		for (int i = 1; i <= q; i++) {
+			if (ans[i]) {
+				out.println("Yes");
+			} else {
+				out.println("No");
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class174/Code04_Lcm2.java b/src/class174/Code04_Lcm2.java
new file mode 100644
index 000000000..369954352
--- /dev/null
+++ b/src/class174/Code04_Lcm2.java
@@ -0,0 +1,150 @@
+package class174;
+
+// 最小公倍数，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3247
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Param {
+//    int u, v, a, b, qid;
+//};
+//
+//bool cmpa(Param &x, Param &y) {
+//    return x.a < y.a;
+//}
+//
+//bool cmpb(Param &x, Param &y) {
+//    return x.b < y.b;
+//}
+//
+//const int MAXN = 50001;
+//const int MAXM = 100001;
+//const int MAXQ = 50001;
+//int n, m, q;
+//int blen, bnum;
+//
+//Param edge[MAXM];
+//Param ques[MAXQ];
+//
+//int arr[MAXQ];
+//int cntq;
+//
+//int fa[MAXN];
+//int siz[MAXN];
+//int maxa[MAXN];
+//int maxb[MAXN];
+//
+//int rollback[MAXN][5];
+//int opsize;
+//bool ans[MAXQ];
+//
+//void build() {
+//    for (int i = 1; i <= n; i++) {
+//        fa[i] = i;
+//        siz[i] = 1;
+//        maxa[i] = -1;
+//        maxb[i] = -1;
+//    }
+//}
+//
+//int find(int x) {
+//    while (x != fa[x]) {
+//        x = fa[x];
+//    }
+//    return x;
+//}
+//
+//void Union(int x, int y, int a, int b) {
+//    int fx = find(x), fy = find(y);
+//    if (siz[fx] < siz[fy]) swap(fx, fy);
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
+//    rollback[opsize][2] = siz[fx];
+//    rollback[opsize][3] = maxa[fx];
+//    rollback[opsize][4] = maxb[fx];
+//    if (fx != fy) {
+//        fa[fy] = fx;
+//        siz[fx] += siz[fy];
+//    }
+//    maxa[fx] = max({maxa[fx], maxa[fy], a});
+//    maxb[fx] = max({maxb[fx], maxb[fy], b});
+//}
+//
+//void undo() {
+//    for (int fx, fy; opsize > 0; opsize--) {
+//        fx = rollback[opsize][0];
+//        fy = rollback[opsize][1];
+//        fa[fy] = fy;
+//        siz[fx] = rollback[opsize][2];
+//        maxa[fx] = rollback[opsize][3];
+//        maxb[fx] = rollback[opsize][4];
+//    }
+//}
+//
+//bool query(int x, int y, int a, int b) {
+//    int fx = find(x), fy = find(y);
+//    return fx == fy && maxa[fx] == a && maxb[fx] == b;
+//}
+//
+//void compute(int l, int r) {
+//    build();
+//    cntq = 0;
+//    for (int i = 1; i <= q; i++) {
+//        if (edge[l].a <= ques[i].a && (r + 1 > m || ques[i].a < edge[r + 1].a)) {
+//            arr[++cntq] = i;
+//        }
+//    }
+//    if (cntq > 0) {
+//        sort(edge + 1, edge + l, cmpb);
+//        int pos = 1;
+//        for (int i = 1; i <= cntq; i++) {
+//            while (pos < l && edge[pos].b <= ques[arr[i]].b) {
+//                Union(edge[pos].u, edge[pos].v, edge[pos].a, edge[pos].b);
+//                pos++;
+//            }
+//            opsize = 0;
+//            for (int j = l; j <= r; j++) {
+//                if (edge[j].a <= ques[arr[i]].a && edge[j].b <= ques[arr[i]].b) {
+//                    Union(edge[j].u, edge[j].v, edge[j].a, edge[j].b);
+//                }
+//            }
+//            ans[ques[arr[i]].qid] = query(ques[arr[i]].u, ques[arr[i]].v, ques[arr[i]].a, ques[arr[i]].b);
+//            undo();
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    blen = max(1, (int)sqrt(m * log2(n)));
+//    bnum = (m + blen - 1) / blen;
+//    sort(edge + 1, edge + m + 1, cmpa);
+//    sort(ques + 1, ques + q + 1, cmpb);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, u, v, a, b; i <= m; i++) {
+//        cin >> edge[i].u >> edge[i].v >> edge[i].a >> edge[i].b;
+//    }
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> ques[i].u >> ques[i].v >> ques[i].a >> ques[i].b;
+//        ques[i].qid = i;
+//    }
+//    prepare();
+//    for (int i = 1, l, r; i <= bnum; i++) {
+//        l = (i - 1) * blen + 1;
+//        r = min(i * blen, m);
+//        compute(l, r);
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        cout << (ans[i] ? "Yes" : "No") << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From bd05e9aeff818a9f3f816e461fb3b1fe87ef5b13 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 9 Jul 2025 18:14:54 +0800
Subject: [PATCH 1101/1712] modify code

---
 src/class174/Code04_Lcm2.java    | 13 ++++++++-----
 src/class174/Code05_Bridge1.java |  8 ++++++++
 2 files changed, 16 insertions(+), 5 deletions(-)
 create mode 100644 src/class174/Code05_Bridge1.java

diff --git a/src/class174/Code04_Lcm2.java b/src/class174/Code04_Lcm2.java
index 369954352..b03c20be0 100644
--- a/src/class174/Code04_Lcm2.java
+++ b/src/class174/Code04_Lcm2.java
@@ -59,8 +59,11 @@
 //}
 //
 //void Union(int x, int y, int a, int b) {
-//    int fx = find(x), fy = find(y);
-//    if (siz[fx] < siz[fy]) swap(fx, fy);
+//    int fx = find(x);
+//    int fy = find(y);
+//    if (siz[fx] < siz[fy]) {
+//        swap(fx, fy);
+//    }
 //    rollback[++opsize][0] = fx;
 //    rollback[opsize][1] = fy;
 //    rollback[opsize][2] = siz[fx];
@@ -86,7 +89,8 @@
 //}
 //
 //bool query(int x, int y, int a, int b) {
-//    int fx = find(x), fy = find(y);
+//    int fx = find(x);
+//    int fy = find(y);
 //    return fx == fy && maxa[fx] == a && maxb[fx] == b;
 //}
 //
@@ -102,9 +106,8 @@
 //        sort(edge + 1, edge + l, cmpb);
 //        int pos = 1;
 //        for (int i = 1; i <= cntq; i++) {
-//            while (pos < l && edge[pos].b <= ques[arr[i]].b) {
+//            for (; pos < l && edge[pos].b <= ques[arr[i]].b; pos++) {
 //                Union(edge[pos].u, edge[pos].v, edge[pos].a, edge[pos].b);
-//                pos++;
 //            }
 //            opsize = 0;
 //            for (int j = l; j <= r; j++) {
diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
new file mode 100644
index 000000000..1e3f212a9
--- /dev/null
+++ b/src/class174/Code05_Bridge1.java
@@ -0,0 +1,8 @@
+package class174;
+
+// 桥梁，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5443
+
+public class Code05_Bridge1 {
+
+}

From b79b2df4c81c64361ba4748f34fde8be184bd0d7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 9 Jul 2025 21:21:06 +0800
Subject: [PATCH 1102/1712] modify code

---
 src/class174/Code04_Lcm1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class174/Code04_Lcm1.java b/src/class174/Code04_Lcm1.java
index 237836674..5b5bdfece 100644
--- a/src/class174/Code04_Lcm1.java
+++ b/src/class174/Code04_Lcm1.java
@@ -126,6 +126,9 @@ public static void compute(int l, int r) {
 			}
 		}
 		if (cntq > 0) {
+			// 可以使用额外的数组，每块内部根据b进行排序
+			// 每次把新块归并进来，保证 1..l-1 范围根据b有序
+			// 可以省掉一个log的复杂度，本题不做这个优化也能通过，索性算了
 			Arrays.sort(edge, 1, l, cmpb);
 			int pos = 1;
 			for (int i = 1; i <= cntq; i++) {

From 9a984f1529581061548c8832587e24233ac56163 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 16:00:29 +0800
Subject: [PATCH 1103/1712] modify code

---
 src/class174/Code05_Bridge1.java | 246 +++++++++++++++++++++++++++++++
 src/class174/Code05_Bridge2.java | 179 ++++++++++++++++++++++
 2 files changed, 425 insertions(+)
 create mode 100644 src/class174/Code05_Bridge2.java

diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
index 1e3f212a9..f56ce5d94 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code05_Bridge1.java
@@ -2,7 +2,253 @@
 
 // 桥梁，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5443
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
 
 public class Code05_Bridge1 {
 
+	public static int MAXN = 100001;
+	public static int n, m, q;
+	public static int blen, bnum;
+	public static int[] u = new int[MAXN];
+	public static int[] v = new int[MAXN];
+	public static int[] w = new int[MAXN];
+
+	public static int[] op = new int[MAXN];
+	public static int[] a = new int[MAXN];
+	public static int[] b = new int[MAXN];
+
+	public static int[] eid = new int[MAXN];
+	public static int[] change = new int[MAXN];
+	public static int[] unchange = new int[MAXN];
+
+	public static int[] qid = new int[MAXN];
+	public static int[] update = new int[MAXN];
+	public static int[] query = new int[MAXN];
+
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXN][2];
+	public static int opsize = 0;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] curw = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	// 编号组成的数组idx，根据v[编号]的值进行从大到小排序，手写双指针快排
+	public static void sort(int[] idx, int[] v, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r, pivot = v[idx[(l + r) >> 1]], tmp;
+		while (i <= j) {
+			while (v[idx[i]] > pivot) i++;
+			while (v[idx[j]] < pivot) j--;
+			if (i <= j) {
+				tmp = idx[i]; idx[i] = idx[j]; idx[j] = tmp;
+				i++; j--;
+			}
+		}
+		sort(idx, v, l, j);
+		sort(idx, v, i, r);
+	}
+
+	public static void build() {
+		for (int i = 1; i <= n; i++) {
+			fa[i] = i;
+			siz[i] = 1;
+		}
+	}
+
+	public static int find(int x) {
+		while (x != fa[x]) {
+			x = fa[x];
+		}
+		return x;
+	}
+
+	public static void union(int x, int y) {
+		int fx = find(x);
+		int fy = find(y);
+		if (fx == fy) {
+			return;
+		}
+		if (siz[fx] < siz[fy]) {
+			int tmp = fx;
+			fx = fy;
+			fy = tmp;
+		}
+		fa[fy] = fx;
+		siz[fx] += siz[fy];
+		rollback[++opsize][0] = fx;
+		rollback[opsize][1] = fy;
+	}
+
+	public static void undo() {
+		for (int fx, fy; opsize > 0; opsize--) {
+			fx = rollback[opsize][0];
+			fy = rollback[opsize][1];
+			fa[fy] = fy;
+			siz[fx] -= siz[fy];
+		}
+	}
+
+	public static void merge(int l1, int r1, int l2, int r2) {
+		int i = 0;
+		while (l1 <= r1 && l2 <= r2) {
+			eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+		}
+		while (l1 <= r1) {
+			eid[++i] = change[l1++];
+		}
+		while (l2 <= r2) {
+			eid[++i] = unchange[l2++];
+		}
+	}
+
+	public static void compute(int l, int r) {
+		build();
+		Arrays.fill(vis, false);
+		int cntu = 0, cntq = 0;
+		for (int i = l; i <= r; i++) {
+			if (op[qid[i]] == 1) {
+				vis[a[qid[i]]] = true;
+				update[++cntu] = qid[i];
+			} else {
+				query[++cntq] = qid[i];
+			}
+		}
+		sort(query, b, 1, cntq);
+		int k = 1;
+		for (int i = 1; i <= cntq; i++) {
+			for (; k <= m && w[eid[k]] >= b[query[i]]; k++) {
+				if (!vis[eid[k]]) {
+					union(u[eid[k]], v[eid[k]]);
+				}
+			}
+			opsize = 0;
+			for (int j = 1; j <= cntu; j++) {
+				curw[a[update[j]]] = w[a[update[j]]];
+			}
+			for (int j = 1; j <= cntu; j++) {
+				if (update[j] < query[i]) {
+					curw[a[update[j]]] = b[update[j]];
+				}
+			}
+			for (int j = 1; j <= cntu; j++) {
+				if (curw[a[update[j]]] >= b[query[i]]) {
+					union(u[a[update[j]]], v[a[update[j]]]);
+				}
+			}
+			ans[query[i]] = siz[find(a[query[i]])];
+			undo();
+		}
+		for (int i = 1; i <= cntu; i++) {
+			w[a[update[i]]] = b[update[i]];
+		}
+		int siz1 = 0, siz2 = 0;
+		for (int i = 1; i <= m; i++) {
+			if (vis[eid[i]]) {
+				change[++siz1] = eid[i];
+			} else {
+				unchange[++siz2] = eid[i];
+			}
+		}
+		sort(change, w, 1, siz1);
+		merge(1, siz1, 1, siz2);
+	}
+
+	public static int log2(int n) {
+		int ans = 0;
+		while ((1 << ans) <= (n >> 1)) {
+			ans++;
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = Math.max(1, (int) Math.sqrt(q * log2(n)));
+		bnum = (q + blen - 1) / blen;
+		for (int i = 1; i <= m; i++) {
+			eid[i] = i;
+		}
+		for (int i = 1; i <= q; i++) {
+			qid[i] = i;
+		}
+		sort(eid, w, 1, m);
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= m; i++) {
+			u[i] = in.nextInt();
+			v[i] = in.nextInt();
+			w[i] = in.nextInt();
+		}
+		q = in.nextInt();
+		for (int i = 1; i <= q; i++) {
+			op[i] = in.nextInt();
+			a[i] = in.nextInt();
+			b[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, l, r; i <= bnum; i++) {
+			l = (i - 1) * blen + 1;
+			r = Math.min(i * blen, q);
+			compute(l, r);
+		}
+		for (int i = 1; i <= q; i++) {
+			if (ans[i] > 0) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code05_Bridge2.java
new file mode 100644
index 000000000..0442c2842
--- /dev/null
+++ b/src/class174/Code05_Bridge2.java
@@ -0,0 +1,179 @@
+package class174;
+
+// 桥梁，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5443
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, m, q;
+//int blen, bnum;
+//int u[MAXN];
+//int v[MAXN];
+//int w[MAXN];
+//
+//int op[MAXN];
+//int a[MAXN];
+//int b[MAXN];
+//
+//int eid[MAXN];
+//int change[MAXN];
+//int unchange[MAXN];
+//
+//int qid[MAXN];
+//int update[MAXN];
+//int query[MAXN];
+//
+//int fa[MAXN];
+//int siz[MAXN];
+//int rollback[MAXN][2];
+//int opsize = 0;
+//
+//bool vis[MAXN];
+//int curw[MAXN];
+//int ans[MAXN];
+//
+//void build() {
+//    for (int i = 1; i <= n; i++) {
+//        fa[i] = i;
+//        siz[i] = 1;
+//    }
+//}
+//
+//int find(int x) {
+//    while (x != fa[x]) {
+//        x = fa[x];
+//    }
+//    return x;
+//}
+//
+//void Union(int x, int y) {
+//    int fx = find(x), fy = find(y);
+//    if (fx == fy) {
+//        return;
+//    }
+//    if (siz[fx] < siz[fy]) {
+//        swap(fx, fy);
+//    }
+//    fa[fy] = fx;
+//    siz[fx] += siz[fy];
+//    rollback[++opsize][0] = fx;
+//    rollback[opsize][1] = fy;
+//}
+//
+//void undo() {
+//    for (int fx, fy; opsize > 0; opsize--) {
+//        fx = rollback[opsize][0];
+//        fy = rollback[opsize][1];
+//        fa[fy] = fy;
+//        siz[fx] -= siz[fy];
+//    }
+//}
+//
+//void merge(int l1, int r1, int l2, int r2) {
+//    int i = 0;
+//    while (l1 <= r1 && l2 <= r2) {
+//        eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+//    }
+//    while (l1 <= r1) {
+//        eid[++i] = change[l1++];
+//    }
+//    while (l2 <= r2) {
+//        eid[++i] = unchange[l2++];
+//    }
+//}
+//
+//void compute(int l, int r) {
+//    build();
+//    fill(vis + 1, vis + m + 1, false);
+//    int cntu = 0, cntq = 0;
+//    for (int i = l; i <= r; i++) {
+//        if (op[qid[i]] == 1) {
+//            vis[a[qid[i]]] = true;
+//            update[++cntu] = qid[i];
+//        } else {
+//            query[++cntq] = qid[i];
+//        }
+//    }
+//    sort(query + 1, query + cntq + 1, [&](int x, int y) { return b[x] > b[y]; });
+//    int k = 1;
+//    for (int i = 1; i <= cntq; i++) {
+//        for (; k <= m && w[eid[k]] >= b[query[i]]; k++) {
+//            if (!vis[eid[k]]) {
+//                Union(u[eid[k]], v[eid[k]]);
+//            }
+//        }
+//        opsize = 0;
+//        for (int j = 1; j <= cntu; j++) {
+//            curw[a[update[j]]] = w[a[update[j]]];
+//        }
+//        for (int j = 1; j <= cntu; j++) {
+//            if (update[j] < query[i]) {
+//                curw[a[update[j]]] = b[update[j]];
+//            }
+//        }
+//        for (int j = 1; j <= cntu; j++) {
+//            if (curw[a[update[j]]] >= b[query[i]]) {
+//                Union(u[a[update[j]]], v[a[update[j]]]);
+//            }
+//        }
+//        ans[query[i]] = siz[find(a[query[i]])];
+//        undo();
+//    }
+//    for (int i = 1; i <= cntu; i++) {
+//        w[a[update[i]]] = b[update[i]];
+//    }
+//    int siz1 = 0, siz2 = 0;
+//    for (int i = 1; i <= m; i++) {
+//        if (vis[eid[i]]) {
+//            change[++siz1] = eid[i];
+//        } else {
+//            unchange[++siz2] = eid[i];
+//        }
+//    }
+//    if (siz1 > 0) {
+//        std::sort(change + 1, change + siz1 + 1, [&](int x, int y) { return w[x] > w[y]; });
+//    }
+//    merge(1, siz1, 1, siz2);
+//}
+//
+//void prepare() {
+//    blen = max(1, (int)sqrt(q * log2(n)));
+//    bnum = (q + blen - 1) / blen;
+//    for (int i = 1; i <= m; i++) {
+//        eid[i] = i;
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        qid[i] = i;
+//    }
+//    std::sort(eid + 1, eid + m + 1, [&](int x, int y) { return w[x] > w[y]; });
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> u[i] >> v[i] >> w[i];
+//    }
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> op[i] >> a[i] >> b[i];
+//    }
+//    prepare();
+//    for (int i = 1, l, r; i <= bnum; i++) {
+//        l = (i - 1) * blen + 1;
+//        r = min(i * blen, q);
+//        compute(l, r);
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        if (ans[i]) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From f22a30ab1a3b4e5a79e912f391baa8e45f3173bd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 16:12:59 +0800
Subject: [PATCH 1104/1712] modify code

---
 src/class174/Code05_Bridge1.java | 32 ++++++++++++++++++--------------
 src/class174/Code05_Bridge2.java | 26 +++++++++++++-------------
 2 files changed, 31 insertions(+), 27 deletions(-)

diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
index f56ce5d94..be363ad57 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code05_Bridge1.java
@@ -3,6 +3,7 @@
 // 桥梁，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5443
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 为了java版本能通过，不定义任何类，关于排序一律手写
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -40,7 +41,7 @@ public class Code05_Bridge1 {
 	public static int[] curw = new int[MAXN];
 	public static int[] ans = new int[MAXN];
 
-	// 编号组成的数组idx，根据v[编号]的值进行从大到小排序，手写双指针快排
+	// idx[l..r]由序号组成，v[序号]的值越大，序号越靠前，手写双指针快排
 	public static void sort(int[] idx, int[] v, int l, int r) {
 		if (l >= r) return;
 		int i = l, j = r, pivot = v[idx[(l + r) >> 1]], tmp;
@@ -56,6 +57,22 @@ public static void sort(int[] idx, int[] v, int l, int r) {
 		sort(idx, v, i, r);
 	}
 
+	// change[l1..r1]都是边的序号，已经有序了，w[序号]的值越大，序号越靠前
+	// unchange[l2..r2]都是边的序号，已经有序了，w[序号]的值越大，序号越靠前
+	// 把两个数组中的序号，根据w[序号]的值，归并到eid中
+	public static void merge(int l1, int r1, int l2, int r2) {
+		int i = 0;
+		while (l1 <= r1 && l2 <= r2) {
+			eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+		}
+		while (l1 <= r1) {
+			eid[++i] = change[l1++];
+		}
+		while (l2 <= r2) {
+			eid[++i] = unchange[l2++];
+		}
+	}
+
 	public static void build() {
 		for (int i = 1; i <= n; i++) {
 			fa[i] = i;
@@ -96,19 +113,6 @@ public static void undo() {
 		}
 	}
 
-	public static void merge(int l1, int r1, int l2, int r2) {
-		int i = 0;
-		while (l1 <= r1 && l2 <= r2) {
-			eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
-		}
-		while (l1 <= r1) {
-			eid[++i] = change[l1++];
-		}
-		while (l2 <= r2) {
-			eid[++i] = unchange[l2++];
-		}
-	}
-
 	public static void compute(int l, int r) {
 		build();
 		Arrays.fill(vis, false);
diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code05_Bridge2.java
index 0442c2842..43469f375 100644
--- a/src/class174/Code05_Bridge2.java
+++ b/src/class174/Code05_Bridge2.java
@@ -37,6 +37,19 @@
 //int curw[MAXN];
 //int ans[MAXN];
 //
+//void merge(int l1, int r1, int l2, int r2) {
+//    int i = 0;
+//    while (l1 <= r1 && l2 <= r2) {
+//        eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+//    }
+//    while (l1 <= r1) {
+//        eid[++i] = change[l1++];
+//    }
+//    while (l2 <= r2) {
+//        eid[++i] = unchange[l2++];
+//    }
+//}
+//
 //void build() {
 //    for (int i = 1; i <= n; i++) {
 //        fa[i] = i;
@@ -74,19 +87,6 @@
 //    }
 //}
 //
-//void merge(int l1, int r1, int l2, int r2) {
-//    int i = 0;
-//    while (l1 <= r1 && l2 <= r2) {
-//        eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
-//    }
-//    while (l1 <= r1) {
-//        eid[++i] = change[l1++];
-//    }
-//    while (l2 <= r2) {
-//        eid[++i] = unchange[l2++];
-//    }
-//}
-//
 //void compute(int l, int r) {
 //    build();
 //    fill(vis + 1, vis + m + 1, false);

From 6b5f24119f8d16e80e8057baffafcd883bdb5252 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 16:16:36 +0800
Subject: [PATCH 1105/1712] modify code

---
 src/class174/Code05_Bridge2.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code05_Bridge2.java
index 43469f375..cb2918fbb 100644
--- a/src/class174/Code05_Bridge2.java
+++ b/src/class174/Code05_Bridge2.java
@@ -135,9 +135,7 @@
 //            unchange[++siz2] = eid[i];
 //        }
 //    }
-//    if (siz1 > 0) {
-//        std::sort(change + 1, change + siz1 + 1, [&](int x, int y) { return w[x] > w[y]; });
-//    }
+//    sort(change + 1, change + siz1 + 1, [&](int x, int y) { return w[x] > w[y]; });
 //    merge(1, siz1, 1, siz2);
 //}
 //
@@ -150,7 +148,7 @@
 //    for (int i = 1; i <= q; i++) {
 //        qid[i] = i;
 //    }
-//    std::sort(eid + 1, eid + m + 1, [&](int x, int y) { return w[x] > w[y]; });
+//    sort(eid + 1, eid + m + 1, [&](int x, int y) { return w[x] > w[y]; });
 //}
 //
 //int main() {

From e6a19fd33e0d25545a80c97c4d9458b030689f8c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 17:25:46 +0800
Subject: [PATCH 1106/1712] modify code

---
 src/class174/Code03_MagicGirl1.java | 71 ++++++++++++-----------------
 src/class174/Code03_MagicGirl2.java | 56 +++++++++++------------
 2 files changed, 54 insertions(+), 73 deletions(-)

diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code03_MagicGirl1.java
index cf9a17549..93080a509 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code03_MagicGirl1.java
@@ -15,30 +15,6 @@
 
 public class Code03_MagicGirl1 {
 
-	static class Answer {
-		int pre, suf, len;
-		long res;
-
-		Answer(int p, int s, int l, long r) {
-			pre = p;
-			suf = s;
-			len = l;
-			res = r;
-		}
-
-		void merge(Answer right) {
-			res += right.res + 1L * suf * right.pre;
-			if (pre == len)
-				pre += right.pre;
-			if (right.suf == right.len) {
-				suf += right.suf;
-			} else {
-				suf = right.suf;
-			}
-			len += right.len;
-		}
-	}
-
 	public static int MAXN = 300005;
 	public static int MAXB = 601;
 	public static int POW2 = 9;
@@ -62,14 +38,27 @@ void merge(Answer right) {
 	public static int[] last = new int[MAXN];
 	public static int[] next = new int[MAXN];
 
-	public static Answer tmp = new Answer(0, 0, 0, 0);
-	public static Answer[] ans = new Answer[MAXN];
-	
+	public static int[] pre = new int[MAXN];
+	public static int[] suf = new int[MAXN];
+	public static int[] len = new int[MAXN];
+	public static long[] ans = new long[MAXN];
+
+	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
+		ans[i] += rans + 1L * suf[i] * rpre;
+		if (pre[i] == len[i]) {
+			pre[i] += rpre;
+		}
+		if (rsuf == rlen) {
+			suf[i] += rsuf;
+		} else {
+			suf[i] = rsuf;
+		}
+		len[i] += rlen;
+	}
+
 	// 根据arr[pos[i]]的值，对pos[l..r]进行双指针快排
 	public static void quickSort(int l, int r) {
-		if (l >= r) {
-			return;
-		}
+		if (l >= r) return;
 		int i = l, j = r, pivot = arr[pos[(l + r) >> 1]], tmp;
 		while (i <= j) {
 			while (arr[pos[i]] < pivot) i++;
@@ -103,25 +92,25 @@ public static void calc(int l, int r) {
 			last[i] = i - 1;
 			next[i] = i + 1;
 		}
-		tmp.pre = 0; tmp.suf = 0; tmp.len = r - l + 1; tmp.res = 0;
+		int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
 		int k = 1;
 		for (int i = l, idx; i <= r; i++) {
 			idx = pos[i];
 			for (; k <= siz && v[arrq[k]] < arr[idx]; k++) {
-				ans[arrq[k]].merge(tmp);
+				mergeAns(arrq[k], rpre, rsuf, rlen, rans);
 			}
 			if (last[idx] == l - 1) {
-				tmp.pre += next[idx] - idx;
+				rpre += next[idx] - idx;
 			}
 			if (next[idx] == r + 1) {
-				tmp.suf += idx - last[idx];
+				rsuf += idx - last[idx];
 			}
-			tmp.res += 1L * (idx - last[idx]) * (next[idx] - idx);
+			rans += 1L * (idx - last[idx]) * (next[idx] - idx);
 			last[next[idx]] = last[idx];
 			next[last[idx]] = next[idx];
 		}
 		for (; k <= siz; k++) {
-			ans[arrq[k]].merge(tmp);
+			mergeAns(arrq[k], rpre, rsuf, rlen, rans);
 		}
 		siz = 0;
 	}
@@ -155,11 +144,10 @@ public static void query(int qi, int l, int r) {
 		} else {
 			for (int i = Math.max(jobl, l); i <= Math.min(jobr, r); i++) {
 				if (arr[i] <= jobv) {
-					tmp.pre = 1; tmp.suf = 1; tmp.len = 1; tmp.res = 1;
+					mergeAns(qi, 1, 1, 1, 1);
 				} else {
-					tmp.pre = 0; tmp.suf = 0; tmp.len = 1; tmp.res = 0;
+					mergeAns(qi, 0, 0, 1, 0);
 				}
-				ans[qi].merge(tmp);
 			}
 		}
 	}
@@ -195,9 +183,6 @@ public static void main(String[] args) throws Exception {
 				v[i] = in.nextInt();
 			}
 		}
-		for (int i = 1; i <= m; i++) {
-			ans[i] = new Answer(0, 0, 0, 0);
-		}
 		int bnum = (n + BLEN - 1) / BLEN;
 		for (int i = 1, l, r; i <= bnum; i++) {
 			l = (i - 1) * BLEN + 1;
@@ -206,7 +191,7 @@ public static void main(String[] args) throws Exception {
 		}
 		for (int i = 1; i <= m; i++) {
 			if (op[i] == 2) {
-				out.println(ans[i].res);
+				out.println(ans[i]);
 			}
 		}
 		out.flush();
diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code03_MagicGirl2.java
index 274888b7f..296669533 100644
--- a/src/class174/Code03_MagicGirl2.java
+++ b/src/class174/Code03_MagicGirl2.java
@@ -9,24 +9,6 @@
 //
 //using namespace std;
 //
-//struct Answer {
-//    int pre, suf, len;
-//    long long res;
-//
-//    inline void merge(const Answer &right) {
-//        res += right.res + 1LL * suf * right.pre;
-//        if (pre == len) {
-//            pre += right.pre;
-//        }
-//        if (right.suf == right.len) {
-//            suf += right.suf;
-//        } else {
-//            suf = right.suf;
-//        }
-//        len += right.len;
-//    }
-//};
-//
 //const int MAXN = 300005;
 //const int MAXB = 601;
 //const int POW2 = 9;
@@ -50,8 +32,23 @@
 //int lst[MAXN];
 //int nxt[MAXN];
 //
-//Answer tmp;
-//Answer ans[MAXN];
+//int pre[MAXN];
+//int suf[MAXN];
+//int len[MAXN];
+//long long ans[MAXN];
+//
+//inline void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
+//    ans[i] += rans + 1LL * suf[i] * rpre;
+//    if (pre[i] == len[i]) {
+//        pre[i] += rpre;
+//    }
+//    if (rsuf == rlen) {
+//        suf[i] += rsuf;
+//    } else {
+//        suf[i] = rsuf;
+//    }
+//    len[i] += rlen;
+//}
 //
 //inline void radixSort() {
 //    fill(cntv, cntv + MAXB, 0);
@@ -72,25 +69,25 @@
 //        lst[i] = i - 1;
 //        nxt[i] = i + 1;
 //    }
-//    tmp = { 0, 0, r - l + 1, 0 };
+//    int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
 //    int k = 1;
 //    for (int i = l, idx; i <= r; i++) {
 //        idx = pos[i];
 //        for(; k <= siz && v[arrq[k]] < arr[idx]; k++) {
-//            ans[arrq[k]].merge(tmp);
+//            mergeAns(arrq[k], rpre, rsuf, rlen, rans);
 //        }
 //        if (lst[idx] == l - 1) {
-//            tmp.pre += nxt[idx] - idx;
+//            rpre += nxt[idx] - idx;
 //        }
 //        if (nxt[idx] == r + 1) {
-//            tmp.suf += idx - lst[idx];
+//            rsuf += idx - lst[idx];
 //        }
-//        tmp.res += 1LL * (idx - lst[idx]) * (nxt[idx] - idx);
+//        rans += 1LL * (idx - lst[idx]) * (nxt[idx] - idx);
 //        lst[nxt[idx]] = lst[idx];
 //        nxt[lst[idx]] = nxt[idx];
 //    }
 //    for(; k <= siz; k++) {
-//        ans[arrq[k]].merge(tmp);
+//        mergeAns(arrq[k], rpre, rsuf, rlen, rans);
 //    }
 //    siz = 0;
 //}
@@ -123,11 +120,10 @@
 //    } else {
 //        for (int i = max(jobl, l); i <= min(jobr, r); i++) {
 //            if (arr[i] <= jobv) {
-//                tmp = { 1, 1, 1, 1 };
+//                mergeAns(qi, 1, 1, 1, 1);
 //            } else {
-//                tmp = { 0, 0, 1, 0 };
+//                mergeAns(qi, 0, 0, 1, 0);
 //            }
-//            ans[qi].merge(tmp);
 //        }
 //    }
 //}
@@ -168,7 +164,7 @@
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 2) {
-//            cout << ans[i].res << '\n';
+//            cout << ans[i] << '\n';
 //        }
 //    }
 //    return 0;

From b6cca0519e3138965058ae47ab53f364fa9820f9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 18:23:29 +0800
Subject: [PATCH 1107/1712] modify code

---
 src/class174/Code04_Lcm1.java    | 117 +++++++++++++++----------------
 src/class174/Code04_Lcm2.java    |  80 +++++++++++----------
 src/class174/Code05_Bridge1.java |   1 -
 3 files changed, 100 insertions(+), 98 deletions(-)

diff --git a/src/class174/Code04_Lcm1.java b/src/class174/Code04_Lcm1.java
index 5b5bdfece..11d723d02 100644
--- a/src/class174/Code04_Lcm1.java
+++ b/src/class174/Code04_Lcm1.java
@@ -8,49 +8,30 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.util.Arrays;
-import java.util.Comparator;
 
 public class Code04_Lcm1 {
 
-	static class Param {
-		int u, v, a, b, qid;
-
-		public Param(int u_, int v_, int a_, int b_) {
-			u = u_;
-			v = v_;
-			a = a_;
-			b = b_;
-		}
-	}
-
-	static class CmpA implements Comparator<Param> {
-		@Override
-		public int compare(Param o1, Param o2) {
-			return o1.a - o2.a;
-		}
-	}
-
-	static class CmpB implements Comparator<Param> {
-		@Override
-		public int compare(Param o1, Param o2) {
-			return o1.b - o2.b;
-		}
-	}
-
-	public static CmpA cmpa = new CmpA();
-	public static CmpB cmpb = new CmpB();
-
 	public static int MAXN = 50001;
 	public static int MAXM = 100001;
 	public static int MAXQ = 50001;
 	public static int n, m, q;
 	public static int blen, bnum;
 
-	public static Param[] edge = new Param[MAXM];
-	public static Param[] ques = new Param[MAXQ];
+	public static int[] eu = new int[MAXM];
+	public static int[] ev = new int[MAXM];
+	public static int[] ea = new int[MAXM];
+	public static int[] eb = new int[MAXM];
 
-	public static int[] arr = new int[MAXQ];
+	public static int[] qu = new int[MAXQ];
+	public static int[] qv = new int[MAXQ];
+	public static int[] qa = new int[MAXQ];
+	public static int[] qb = new int[MAXQ];
+	public static int[] qid = new int[MAXQ];
+
+	public static int[] arre = new int[MAXM];
+	public static int[] arrq = new int[MAXQ];
+
+	public static int[] cur = new int[MAXQ];
 	public static int cntq = 0;
 
 	public static int[] fa = new int[MAXN];
@@ -62,6 +43,21 @@ public int compare(Param o1, Param o2) {
 
 	public static boolean[] ans = new boolean[MAXQ];
 
+	public static void sort(int[] idx, int[] v, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r, pivot = v[idx[(l + r) >> 1]], tmp;
+		while (i <= j) {
+			while (v[idx[i]] < pivot) i++;
+			while (v[idx[j]] > pivot) j--;
+			if (i <= j) {
+				tmp = idx[i]; idx[i] = idx[j]; idx[j] = tmp;
+				i++; j--;
+			}
+		}
+		sort(idx, v, l, j);
+		sort(idx, v, i, r);
+	}
+
 	public static void build() {
 		for (int i = 1; i <= n; i++) {
 			fa[i] = i;
@@ -82,9 +78,7 @@ public static void union(int x, int y, int a, int b) {
 		int fx = find(x);
 		int fy = find(y);
 		if (siz[fx] < siz[fy]) {
-			int tmp = fx;
-			fx = fy;
-			fy = tmp;
+			int tmp = fx; fx = fy; fy = tmp;
 		}
 		rollback[++opsize][0] = fx;
 		rollback[opsize][1] = fy;
@@ -121,27 +115,28 @@ public static void compute(int l, int r) {
 		cntq = 0;
 		for (int i = 1; i <= q; i++) {
 			// 保证每条询问只落入其中的一块
-			if (edge[l].a <= ques[i].a && (r + 1 > m || ques[i].a < edge[r + 1].a)) {
-				arr[++cntq] = i;
+			if (ea[arre[l]] <= qa[arrq[i]] && (r + 1 > m || qa[arrq[i]] < ea[arre[r + 1]])) {
+				cur[++cntq] = arrq[i];
 			}
 		}
 		if (cntq > 0) {
 			// 可以使用额外的数组，每块内部根据b进行排序
 			// 每次把新块归并进来，保证 1..l-1 范围根据b有序
 			// 可以省掉一个log的复杂度，本题不做这个优化也能通过，索性算了
-			Arrays.sort(edge, 1, l, cmpb);
+			sort(arre, eb, 1, l - 1);
 			int pos = 1;
 			for (int i = 1; i <= cntq; i++) {
-				for (; pos < l && edge[pos].b <= ques[arr[i]].b; pos++) {
-					union(edge[pos].u, edge[pos].v, edge[pos].a, edge[pos].b);
+				for (int edge = arre[pos]; pos < l && eb[edge] <= qb[cur[i]]; pos++, edge = arre[pos]) {
+					union(eu[edge], ev[edge], ea[edge], eb[edge]);
 				}
 				opsize = 0;
 				for (int j = l; j <= r; j++) {
-					if (edge[j].a <= ques[arr[i]].a && edge[j].b <= ques[arr[i]].b) {
-						union(edge[j].u, edge[j].v, edge[j].a, edge[j].b);
+					int edge = arre[j];
+					if (ea[edge] <= qa[cur[i]] && eb[edge] <= qb[cur[i]]) {
+						union(eu[edge], ev[edge], ea[edge], eb[edge]);
 					}
 				}
-				ans[ques[arr[i]].qid] = query(ques[arr[i]].u, ques[arr[i]].v, ques[arr[i]].a, ques[arr[i]].b);
+				ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
 				undo();
 			}
 		}
@@ -158,8 +153,14 @@ public static int log2(int n) {
 	public static void prepare() {
 		blen = Math.max(1, (int) Math.sqrt(m * log2(n)));
 		bnum = (m + blen - 1) / blen;
-		Arrays.sort(edge, 1, m + 1, cmpa);
-		Arrays.sort(ques, 1, q + 1, cmpb);
+		for (int i = 1; i <= m; i++) {
+			arre[i] = i;
+		}
+		for (int i = 1; i <= q; i++) {
+			arrq[i] = i;
+		}
+		sort(arre, ea, 1, m);
+		sort(arrq, qb, 1, q);
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -167,21 +168,19 @@ public static void main(String[] args) throws IOException {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		m = in.nextInt();
-		for (int i = 1, u, v, a, b; i <= m; i++) {
-			u = in.nextInt();
-			v = in.nextInt();
-			a = in.nextInt();
-			b = in.nextInt();
-			edge[i] = new Param(u, v, a, b);
+		for (int i = 1; i <= m; i++) {
+			eu[i] = in.nextInt();
+			ev[i] = in.nextInt();
+			ea[i] = in.nextInt();
+			eb[i] = in.nextInt();
 		}
 		q = in.nextInt();
-		for (int i = 1, u, v, a, b; i <= q; i++) {
-			u = in.nextInt();
-			v = in.nextInt();
-			a = in.nextInt();
-			b = in.nextInt();
-			ques[i] = new Param(u, v, a, b);
-			ques[i].qid = i;
+		for (int i = 1; i <= q; i++) {
+			qu[i] = in.nextInt();
+			qv[i] = in.nextInt();
+			qa[i] = in.nextInt();
+			qb[i] = in.nextInt();
+			qid[i] = i;
 		}
 		prepare();
 		for (int i = 1, l, r; i <= bnum; i++) {
diff --git a/src/class174/Code04_Lcm2.java b/src/class174/Code04_Lcm2.java
index b03c20be0..184a86699 100644
--- a/src/class174/Code04_Lcm2.java
+++ b/src/class174/Code04_Lcm2.java
@@ -9,37 +9,36 @@
 //
 //using namespace std;
 //
-//struct Param {
-//    int u, v, a, b, qid;
-//};
-//
-//bool cmpa(Param &x, Param &y) {
-//    return x.a < y.a;
-//}
-//
-//bool cmpb(Param &x, Param &y) {
-//    return x.b < y.b;
-//}
-//
 //const int MAXN = 50001;
 //const int MAXM = 100001;
 //const int MAXQ = 50001;
 //int n, m, q;
 //int blen, bnum;
 //
-//Param edge[MAXM];
-//Param ques[MAXQ];
+//int eu[MAXM];
+//int ev[MAXM];
+//int ea[MAXM];
+//int eb[MAXM];
+//
+//int qu[MAXQ];
+//int qv[MAXQ];
+//int qa[MAXQ];
+//int qb[MAXQ];
+//int qid[MAXQ];
 //
-//int arr[MAXQ];
-//int cntq;
+//int arre[MAXM];
+//int arrq[MAXQ];
+//
+//int cur[MAXQ];
+//int cntq = 0;
 //
 //int fa[MAXN];
 //int siz[MAXN];
 //int maxa[MAXN];
 //int maxb[MAXN];
-//
 //int rollback[MAXN][5];
-//int opsize;
+//int opsize = 0;
+//
 //bool ans[MAXQ];
 //
 //void build() {
@@ -59,8 +58,7 @@
 //}
 //
 //void Union(int x, int y, int a, int b) {
-//    int fx = find(x);
-//    int fy = find(y);
+//    int fx = find(x), fy = find(y);
 //    if (siz[fx] < siz[fy]) {
 //        swap(fx, fy);
 //    }
@@ -73,8 +71,8 @@
 //        fa[fy] = fx;
 //        siz[fx] += siz[fy];
 //    }
-//    maxa[fx] = max({maxa[fx], maxa[fy], a});
-//    maxb[fx] = max({maxb[fx], maxb[fy], b});
+//    maxa[fx] = max(max(maxa[fx], maxa[fy]), a);
+//    maxb[fx] = max(max(maxb[fx], maxb[fy]), b);
 //}
 //
 //void undo() {
@@ -89,8 +87,7 @@
 //}
 //
 //bool query(int x, int y, int a, int b) {
-//    int fx = find(x);
-//    int fy = find(y);
+//    int fx = find(x), fy = find(y);
 //    return fx == fy && maxa[fx] == a && maxb[fx] == b;
 //}
 //
@@ -98,24 +95,25 @@
 //    build();
 //    cntq = 0;
 //    for (int i = 1; i <= q; i++) {
-//        if (edge[l].a <= ques[i].a && (r + 1 > m || ques[i].a < edge[r + 1].a)) {
-//            arr[++cntq] = i;
+//        if (ea[arre[l]] <= qa[arrq[i]] && (r + 1 > m || qa[arrq[i]] < ea[arre[r + 1]])) {
+//            cur[++cntq] = arrq[i];
 //        }
 //    }
 //    if (cntq > 0) {
-//        sort(edge + 1, edge + l, cmpb);
+//        sort(arre + 1, arre + l, [&](int x, int y) { return eb[x] < eb[y]; });
 //        int pos = 1;
 //        for (int i = 1; i <= cntq; i++) {
-//            for (; pos < l && edge[pos].b <= ques[arr[i]].b; pos++) {
-//                Union(edge[pos].u, edge[pos].v, edge[pos].a, edge[pos].b);
+//            for (int edge = arre[pos]; pos < l && eb[edge] <= qb[cur[i]]; pos++, edge = arre[pos]) {
+//                Union(eu[edge], ev[edge], ea[edge], eb[edge]);
 //            }
 //            opsize = 0;
 //            for (int j = l; j <= r; j++) {
-//                if (edge[j].a <= ques[arr[i]].a && edge[j].b <= ques[arr[i]].b) {
-//                    Union(edge[j].u, edge[j].v, edge[j].a, edge[j].b);
+//                int edge = arre[j];
+//                if (ea[edge] <= qa[cur[i]] && eb[edge] <= qb[cur[i]]) {
+//            	    Union(eu[edge], ev[edge], ea[edge], eb[edge]);
 //                }
 //            }
-//            ans[ques[arr[i]].qid] = query(ques[arr[i]].u, ques[arr[i]].v, ques[arr[i]].a, ques[arr[i]].b);
+//            ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
 //            undo();
 //        }
 //    }
@@ -124,21 +122,27 @@
 //void prepare() {
 //    blen = max(1, (int)sqrt(m * log2(n)));
 //    bnum = (m + blen - 1) / blen;
-//    sort(edge + 1, edge + m + 1, cmpa);
-//    sort(ques + 1, ques + q + 1, cmpb);
+//    for (int i = 1; i <= m; i++) {
+//        arre[i] = i;
+//    }
+//    for (int i = 1; i <= q; i++) {
+//        arrq[i] = i;
+//    }
+//    sort(arre + 1, arre + m + 1, [&](int x, int y) { return ea[x] < ea[y]; });
+//    sort(arrq + 1, arrq + q + 1, [&](int x, int y) { return qb[x] < qb[y]; });
 //}
 //
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m;
-//    for (int i = 1, u, v, a, b; i <= m; i++) {
-//        cin >> edge[i].u >> edge[i].v >> edge[i].a >> edge[i].b;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> eu[i] >> ev[i] >> ea[i] >> eb[i];
 //    }
 //    cin >> q;
 //    for (int i = 1; i <= q; i++) {
-//        cin >> ques[i].u >> ques[i].v >> ques[i].a >> ques[i].b;
-//        ques[i].qid = i;
+//        cin >> qu[i] >> qv[i] >> qa[i] >> qb[i];
+//        qid[i] = i;
 //    }
 //    prepare();
 //    for (int i = 1, l, r; i <= bnum; i++) {
diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
index be363ad57..454f7ee0d 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code05_Bridge1.java
@@ -3,7 +3,6 @@
 // 桥梁，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5443
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-// 为了java版本能通过，不定义任何类，关于排序一律手写
 
 import java.io.IOException;
 import java.io.InputStream;

From 352c1d8cc49c4d9e11203d5ee5751b6a713d8f0a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 18:28:36 +0800
Subject: [PATCH 1108/1712] modify code

---
 src/class174/Code05_Bridge1.java | 36 ++++++++++++++++----------------
 src/class174/Code05_Bridge2.java | 36 ++++++++++++++++----------------
 2 files changed, 36 insertions(+), 36 deletions(-)

diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
index 454f7ee0d..bb6bc1608 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code05_Bridge1.java
@@ -23,11 +23,11 @@ public class Code05_Bridge1 {
 	public static int[] a = new int[MAXN];
 	public static int[] b = new int[MAXN];
 
-	public static int[] eid = new int[MAXN];
+	public static int[] arre = new int[MAXN];
 	public static int[] change = new int[MAXN];
 	public static int[] unchange = new int[MAXN];
 
-	public static int[] qid = new int[MAXN];
+	public static int[] arrq = new int[MAXN];
 	public static int[] update = new int[MAXN];
 	public static int[] query = new int[MAXN];
 
@@ -62,13 +62,13 @@ public static void sort(int[] idx, int[] v, int l, int r) {
 	public static void merge(int l1, int r1, int l2, int r2) {
 		int i = 0;
 		while (l1 <= r1 && l2 <= r2) {
-			eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+			arre[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
 		}
 		while (l1 <= r1) {
-			eid[++i] = change[l1++];
+			arre[++i] = change[l1++];
 		}
 		while (l2 <= r2) {
-			eid[++i] = unchange[l2++];
+			arre[++i] = unchange[l2++];
 		}
 	}
 
@@ -117,19 +117,19 @@ public static void compute(int l, int r) {
 		Arrays.fill(vis, false);
 		int cntu = 0, cntq = 0;
 		for (int i = l; i <= r; i++) {
-			if (op[qid[i]] == 1) {
-				vis[a[qid[i]]] = true;
-				update[++cntu] = qid[i];
+			if (op[arrq[i]] == 1) {
+				vis[a[arrq[i]]] = true;
+				update[++cntu] = arrq[i];
 			} else {
-				query[++cntq] = qid[i];
+				query[++cntq] = arrq[i];
 			}
 		}
 		sort(query, b, 1, cntq);
 		int k = 1;
 		for (int i = 1; i <= cntq; i++) {
-			for (; k <= m && w[eid[k]] >= b[query[i]]; k++) {
-				if (!vis[eid[k]]) {
-					union(u[eid[k]], v[eid[k]]);
+			for (; k <= m && w[arre[k]] >= b[query[i]]; k++) {
+				if (!vis[arre[k]]) {
+					union(u[arre[k]], v[arre[k]]);
 				}
 			}
 			opsize = 0;
@@ -154,10 +154,10 @@ public static void compute(int l, int r) {
 		}
 		int siz1 = 0, siz2 = 0;
 		for (int i = 1; i <= m; i++) {
-			if (vis[eid[i]]) {
-				change[++siz1] = eid[i];
+			if (vis[arre[i]]) {
+				change[++siz1] = arre[i];
 			} else {
-				unchange[++siz2] = eid[i];
+				unchange[++siz2] = arre[i];
 			}
 		}
 		sort(change, w, 1, siz1);
@@ -176,12 +176,12 @@ public static void prepare() {
 		blen = Math.max(1, (int) Math.sqrt(q * log2(n)));
 		bnum = (q + blen - 1) / blen;
 		for (int i = 1; i <= m; i++) {
-			eid[i] = i;
+			arre[i] = i;
 		}
 		for (int i = 1; i <= q; i++) {
-			qid[i] = i;
+			arrq[i] = i;
 		}
-		sort(eid, w, 1, m);
+		sort(arre, w, 1, m);
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code05_Bridge2.java
index cb2918fbb..5f2992289 100644
--- a/src/class174/Code05_Bridge2.java
+++ b/src/class174/Code05_Bridge2.java
@@ -20,11 +20,11 @@
 //int a[MAXN];
 //int b[MAXN];
 //
-//int eid[MAXN];
+//int arre[MAXN];
 //int change[MAXN];
 //int unchange[MAXN];
 //
-//int qid[MAXN];
+//int arrq[MAXN];
 //int update[MAXN];
 //int query[MAXN];
 //
@@ -40,13 +40,13 @@
 //void merge(int l1, int r1, int l2, int r2) {
 //    int i = 0;
 //    while (l1 <= r1 && l2 <= r2) {
-//        eid[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+//        arre[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
 //    }
 //    while (l1 <= r1) {
-//        eid[++i] = change[l1++];
+//        arre[++i] = change[l1++];
 //    }
 //    while (l2 <= r2) {
-//        eid[++i] = unchange[l2++];
+//        arre[++i] = unchange[l2++];
 //    }
 //}
 //
@@ -92,19 +92,19 @@
 //    fill(vis + 1, vis + m + 1, false);
 //    int cntu = 0, cntq = 0;
 //    for (int i = l; i <= r; i++) {
-//        if (op[qid[i]] == 1) {
-//            vis[a[qid[i]]] = true;
-//            update[++cntu] = qid[i];
+//        if (op[arrq[i]] == 1) {
+//            vis[a[arrq[i]]] = true;
+//            update[++cntu] = arrq[i];
 //        } else {
-//            query[++cntq] = qid[i];
+//            query[++cntq] = arrq[i];
 //        }
 //    }
 //    sort(query + 1, query + cntq + 1, [&](int x, int y) { return b[x] > b[y]; });
 //    int k = 1;
 //    for (int i = 1; i <= cntq; i++) {
-//        for (; k <= m && w[eid[k]] >= b[query[i]]; k++) {
-//            if (!vis[eid[k]]) {
-//                Union(u[eid[k]], v[eid[k]]);
+//        for (; k <= m && w[arre[k]] >= b[query[i]]; k++) {
+//            if (!vis[arre[k]]) {
+//                Union(u[arre[k]], v[arre[k]]);
 //            }
 //        }
 //        opsize = 0;
@@ -129,10 +129,10 @@
 //    }
 //    int siz1 = 0, siz2 = 0;
 //    for (int i = 1; i <= m; i++) {
-//        if (vis[eid[i]]) {
-//            change[++siz1] = eid[i];
+//        if (vis[arre[i]]) {
+//            change[++siz1] = arre[i];
 //        } else {
-//            unchange[++siz2] = eid[i];
+//            unchange[++siz2] = arre[i];
 //        }
 //    }
 //    sort(change + 1, change + siz1 + 1, [&](int x, int y) { return w[x] > w[y]; });
@@ -143,12 +143,12 @@
 //    blen = max(1, (int)sqrt(q * log2(n)));
 //    bnum = (q + blen - 1) / blen;
 //    for (int i = 1; i <= m; i++) {
-//        eid[i] = i;
+//        arre[i] = i;
 //    }
 //    for (int i = 1; i <= q; i++) {
-//        qid[i] = i;
+//        arrq[i] = i;
 //    }
-//    sort(eid + 1, eid + m + 1, [&](int x, int y) { return w[x] > w[y]; });
+//    sort(arre + 1, arre + m + 1, [&](int x, int y) { return w[x] > w[y]; });
 //}
 //
 //int main() {

From a65fd909a33368de47a651701326d08d8cc82be5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 19:17:34 +0800
Subject: [PATCH 1109/1712] modify code

---
 src/class039/Code01_BasicCalculatorIII.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class039/Code01_BasicCalculatorIII.java b/src/class039/Code01_BasicCalculatorIII.java
index 958c21d3b..2774c4f32 100644
--- a/src/class039/Code01_BasicCalculatorIII.java
+++ b/src/class039/Code01_BasicCalculatorIII.java
@@ -3,7 +3,10 @@
 import java.util.ArrayList;
 
 // 含有嵌套的表达式求值
+// 力扣上本题为会员题，所以额外提供了牛客网的测试链接
+// 如果在牛客网上提交，请将函数名从改calculate为solve
 // 测试链接 : https://leetcode.cn/problems/basic-calculator-iii/
+// 测试链接 : https://www.nowcoder.com/practice/c215ba61c8b1443b996351df929dc4d4
 public class Code01_BasicCalculatorIII {
 
 	public static int calculate(String str) {

From d1a068e333c60fa814c5c12d8c184a26256cd36f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 10 Jul 2025 19:22:49 +0800
Subject: [PATCH 1110/1712] modify code

---
 src/class039/Code01_BasicCalculatorIII.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class039/Code01_BasicCalculatorIII.java b/src/class039/Code01_BasicCalculatorIII.java
index 2774c4f32..81714ed36 100644
--- a/src/class039/Code01_BasicCalculatorIII.java
+++ b/src/class039/Code01_BasicCalculatorIII.java
@@ -4,7 +4,7 @@
 
 // 含有嵌套的表达式求值
 // 力扣上本题为会员题，所以额外提供了牛客网的测试链接
-// 如果在牛客网上提交，请将函数名从改calculate为solve
+// 如果在牛客网上提交，请将函数名从calculate改为solve
 // 测试链接 : https://leetcode.cn/problems/basic-calculator-iii/
 // 测试链接 : https://www.nowcoder.com/practice/c215ba61c8b1443b996351df929dc4d4
 public class Code01_BasicCalculatorIII {

From fcefda6ca30ccda591cab21c0b6d2087f6496458 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 11:33:01 +0800
Subject: [PATCH 1111/1712] modify code

---
 src/class174/Code01_FutureDiary1.java         | 24 +++++++++----------
 src/class174/Code01_FutureDiary2.java         | 24 +++++++++----------
 ...MagicGirl1.java => Code02_MagicGirl1.java} |  4 ++--
 ...MagicGirl2.java => Code02_MagicGirl2.java} |  0
 ...World1.java => Code03_ColorfulWorld1.java} |  4 ++--
 ...World2.java => Code03_ColorfulWorld2.java} |  0
 6 files changed, 28 insertions(+), 28 deletions(-)
 rename src/class174/{Code03_MagicGirl1.java => Code02_MagicGirl1.java} (98%)
 rename src/class174/{Code03_MagicGirl2.java => Code02_MagicGirl2.java} (100%)
 rename src/class174/{Code02_ColorfulWorld1.java => Code03_ColorfulWorld1.java} (97%)
 rename src/class174/{Code02_ColorfulWorld2.java => Code03_ColorfulWorld2.java} (100%)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 875d50289..4df774bfc 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -26,9 +26,9 @@ public class Code01_FutureDiary1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
-	public static int[] idxRoot = new int[MAXN];
-	public static int[][] valRoot = new int[MAXB][MAXN];
-	public static int[][] rootVal = new int[MAXB][MAXN];
+	public static int[] idxPos = new int[MAXN];
+	public static int[][] valPos = new int[MAXB][MAXN];
+	public static int[][] posVal = new int[MAXB][MAXN];
 
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];
@@ -37,28 +37,28 @@ public class Code01_FutureDiary1 {
 
 	public static void build(int b) {
 		for (int i = 1; i <= blen; i++) {
-			valRoot[b][rootVal[b][i]] = 0;
+			valPos[b][posVal[b][i]] = 0;
 		}
 		for (int i = bl[b], cnt = 0; i <= br[b]; i++) {
-			if (valRoot[b][arr[i]] == 0) {
+			if (valPos[b][arr[i]] == 0) {
 				cnt++;
-				valRoot[b][arr[i]] = cnt;
-				rootVal[b][cnt] = arr[i];
+				valPos[b][arr[i]] = cnt;
+				posVal[b][cnt] = arr[i];
 			}
-			idxRoot[i] = valRoot[b][arr[i]];
+			idxPos[i] = valPos[b][arr[i]];
 		}
 	}
 
 	public static void down(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
-			arr[i] = rootVal[b][idxRoot[i]];
+			arr[i] = posVal[b][idxPos[i]];
 		}
 	}
 
 	public static void xToy(int b, int x, int y) {
-		valRoot[b][y] = valRoot[b][x];
-		rootVal[b][valRoot[b][x]] = y;
-		valRoot[b][x] = 0;
+		valPos[b][y] = valPos[b][x];
+		posVal[b][valPos[b][x]] = y;
+		valPos[b][x] = 0;
 	}
 
 	public static void innerUpdate(int l, int r, int x, int y) {
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 88fd4a1fc..d7e5298c3 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -39,9 +39,9 @@
 //int bl[MAXB];
 //int br[MAXB];
 //
-//int idxRoot[MAXN];
-//int valRoot[MAXB][MAXN];
-//int rootVal[MAXB][MAXN];
+//int idxPos[MAXN];
+//int valPos[MAXB][MAXN];
+//int posVal[MAXB][MAXN];
 //
 //int sum1[MAXB][MAXB];
 //int sum2[MAXB][MAXN];
@@ -50,29 +50,29 @@
 //
 //void build(int b) {
 //    for (int i = 1; i <= blen; i++) {
-//        valRoot[b][rootVal[b][i]] = 0;
+//        valPos[b][posVal[b][i]] = 0;
 //    }
 //    int cnt = 0;
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        if (valRoot[b][arr[i]] == 0) {
+//        if (valPos[b][arr[i]] == 0) {
 //            cnt++;
-//            valRoot[b][arr[i]] = cnt;
-//            rootVal[b][cnt] = arr[i];
+//            valPos[b][arr[i]] = cnt;
+//            posVal[b][cnt] = arr[i];
 //        }
-//        idxRoot[i] = valRoot[b][arr[i]];
+//        idxPos[i] = valPos[b][arr[i]];
 //    }
 //}
 //
 //void down(int b) {
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        arr[i] = rootVal[b][idxRoot[i]];
+//        arr[i] = posVal[b][idxPos[i]];
 //    }
 //}
 //
 //void xToy(int b, int x, int y) {
-//    valRoot[b][y] = valRoot[b][x];
-//    rootVal[b][valRoot[b][x]] = y;
-//    valRoot[b][x] = 0;
+//    valPos[b][y] = valPos[b][x];
+//    posVal[b][valPos[b][x]] = y;
+//    valPos[b][x] = 0;
 //}
 //
 //void innerUpdate(int l, int r, int x, int y) {
diff --git a/src/class174/Code03_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
similarity index 98%
rename from src/class174/Code03_MagicGirl1.java
rename to src/class174/Code02_MagicGirl1.java
index 93080a509..e102a8c25 100644
--- a/src/class174/Code03_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P6578
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code03_MagicGirl2文件就是C++的实现
+// 想通过用C++实现，本节课Code02_MagicGirl2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_MagicGirl1 {
+public class Code02_MagicGirl1 {
 
 	public static int MAXN = 300005;
 	public static int MAXB = 601;
diff --git a/src/class174/Code03_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
similarity index 100%
rename from src/class174/Code03_MagicGirl2.java
rename to src/class174/Code02_MagicGirl2.java
diff --git a/src/class174/Code02_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
similarity index 97%
rename from src/class174/Code02_ColorfulWorld1.java
rename to src/class174/Code03_ColorfulWorld1.java
index 171b8d5d6..ee0d73576 100644
--- a/src/class174/Code02_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P4117
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code02_ColorfulWorld2文件就是C++的实现
+// 想通过用C++实现，本节课Code03_ColorfulWorld2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -13,7 +13,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_ColorfulWorld1 {
+public class Code03_ColorfulWorld1 {
 
 	public static int MAXN = 1000001;
 	public static int n, m;
diff --git a/src/class174/Code02_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
similarity index 100%
rename from src/class174/Code02_ColorfulWorld2.java
rename to src/class174/Code03_ColorfulWorld2.java

From d1f90265a6da85f0cf8af6d1648da57054f315ec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 11:46:19 +0800
Subject: [PATCH 1112/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 24 ++++++++++++------------
 src/class174/Code01_FutureDiary2.java | 24 ++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 4df774bfc..3e319ff49 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -26,9 +26,9 @@ public class Code01_FutureDiary1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
-	public static int[] idxPos = new int[MAXN];
-	public static int[][] valPos = new int[MAXB][MAXN];
-	public static int[][] posVal = new int[MAXB][MAXN];
+	public static int[] idxrt = new int[MAXN];
+	public static int[][] valrt = new int[MAXB][MAXN];
+	public static int[][] rtval = new int[MAXB][MAXN];
 
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];
@@ -37,28 +37,28 @@ public class Code01_FutureDiary1 {
 
 	public static void build(int b) {
 		for (int i = 1; i <= blen; i++) {
-			valPos[b][posVal[b][i]] = 0;
+			valrt[b][rtval[b][i]] = 0;
 		}
 		for (int i = bl[b], cnt = 0; i <= br[b]; i++) {
-			if (valPos[b][arr[i]] == 0) {
+			if (valrt[b][arr[i]] == 0) {
 				cnt++;
-				valPos[b][arr[i]] = cnt;
-				posVal[b][cnt] = arr[i];
+				valrt[b][arr[i]] = cnt;
+				rtval[b][cnt] = arr[i];
 			}
-			idxPos[i] = valPos[b][arr[i]];
+			idxrt[i] = valrt[b][arr[i]];
 		}
 	}
 
 	public static void down(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
-			arr[i] = posVal[b][idxPos[i]];
+			arr[i] = rtval[b][idxrt[i]];
 		}
 	}
 
 	public static void xToy(int b, int x, int y) {
-		valPos[b][y] = valPos[b][x];
-		posVal[b][valPos[b][x]] = y;
-		valPos[b][x] = 0;
+		valrt[b][y] = valrt[b][x];
+		rtval[b][valrt[b][x]] = y;
+		valrt[b][x] = 0;
 	}
 
 	public static void innerUpdate(int l, int r, int x, int y) {
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index d7e5298c3..26f2ee084 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -39,9 +39,9 @@
 //int bl[MAXB];
 //int br[MAXB];
 //
-//int idxPos[MAXN];
-//int valPos[MAXB][MAXN];
-//int posVal[MAXB][MAXN];
+//int idxrt[MAXN];
+//int valrt[MAXB][MAXN];
+//int rtval[MAXB][MAXN];
 //
 //int sum1[MAXB][MAXB];
 //int sum2[MAXB][MAXN];
@@ -50,29 +50,29 @@
 //
 //void build(int b) {
 //    for (int i = 1; i <= blen; i++) {
-//        valPos[b][posVal[b][i]] = 0;
+//        valrt[b][rtval[b][i]] = 0;
 //    }
 //    int cnt = 0;
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        if (valPos[b][arr[i]] == 0) {
+//        if (valrt[b][arr[i]] == 0) {
 //            cnt++;
-//            valPos[b][arr[i]] = cnt;
-//            posVal[b][cnt] = arr[i];
+//            valrt[b][arr[i]] = cnt;
+//            rtval[b][cnt] = arr[i];
 //        }
-//        idxPos[i] = valPos[b][arr[i]];
+//        idxrt[i] = valrt[b][arr[i]];
 //    }
 //}
 //
 //void down(int b) {
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        arr[i] = posVal[b][idxPos[i]];
+//        arr[i] = rtval[b][idxrt[i]];
 //    }
 //}
 //
 //void xToy(int b, int x, int y) {
-//    valPos[b][y] = valPos[b][x];
-//    posVal[b][valPos[b][x]] = y;
-//    valPos[b][x] = 0;
+//    valrt[b][y] = valrt[b][x];
+//    rtval[b][valrt[b][x]] = y;
+//    valrt[b][x] = 0;
 //}
 //
 //void innerUpdate(int l, int r, int x, int y) {

From 641eb71370c6ff066db9f70acb0221a6391102aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 12:53:56 +0800
Subject: [PATCH 1113/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 +-
 src/class174/Code01_FutureDiary2.java | 2 +-
 src/class174/Code02_MagicGirl1.java   | 2 +-
 src/class174/Code02_MagicGirl2.java   | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 3e319ff49..cde5746aa 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -16,7 +16,7 @@
 public class Code01_FutureDiary1 {
 
 	public static int MAXN = 100001;
-	public static int MAXB = 318;
+	public static int MAXB = 401;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	public static int[] tmp = new int[MAXN];
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 26f2ee084..c0868c583 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -29,7 +29,7 @@
 //}
 //
 //const int MAXN = 100001;
-//const int MAXB = 318;
+//const int MAXB = 401;
 //int n, m;
 //int arr[MAXN];
 //int tmp[MAXN];
diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index e102a8c25..57b682594 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -15,7 +15,7 @@
 
 public class Code02_MagicGirl1 {
 
-	public static int MAXN = 300005;
+	public static int MAXN = 300002;
 	public static int MAXB = 601;
 	public static int POW2 = 9;
 	public static int BLEN = 1 << POW2;
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 296669533..acc42f522 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -9,7 +9,7 @@
 //
 //using namespace std;
 //
-//const int MAXN = 300005;
+//const int MAXN = 300002;
 //const int MAXB = 601;
 //const int POW2 = 9;
 //const int BLEN = 1 << POW2;

From 2476d07818c23cbffc22dae48b846a021b1b2cf3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 13:22:30 +0800
Subject: [PATCH 1114/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 22 ++++++++------
 src/class174/Code03_ColorfulWorld2.java | 22 ++++++++------
 src/class174/Code05_Bridge1.java        | 40 ++++++++++++++-----------
 src/class174/Code05_Bridge2.java        | 40 ++++++++++++++-----------
 4 files changed, 70 insertions(+), 54 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index ee0d73576..ce33ef9db 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -16,19 +16,23 @@
 public class Code03_ColorfulWorld1 {
 
 	public static int MAXN = 1000001;
+	public static int MAXM = 500001;
+	public static int MAXV = 100002;
 	public static int n, m;
 	public static int blen, bnum;
 	public static int maxv, lazy;
+
 	public static int[] arr = new int[MAXN];
+	public static int[] op = new int[MAXM];
+	public static int[] ql = new int[MAXM];
+	public static int[] qr = new int[MAXM];
+	public static int[] qx = new int[MAXM];
 
-	public static int[] op = new int[MAXN];
-	public static int[] ql = new int[MAXN];
-	public static int[] qr = new int[MAXN];
-	public static int[] qx = new int[MAXN];
+	public static int[] pre0 = new int[MAXN];
+	public static int[] fa = new int[MAXV];
+	public static int[] sum = new int[MAXV];
 
-	public static int[] fa = new int[MAXN];
-	public static int[] sum = new int[MAXN];
-	public static int[] ans = new int[MAXN];
+	public static int[] ans = new int[MAXM];
 
 	public static int find(int x) {
 		if (x != fa[x]) {
@@ -134,11 +138,11 @@ public static void prepare() {
 		blen = (int) Math.sqrt(n * 3.0);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
-			sum[i] = sum[i - 1] + (arr[i] == 0 ? 1 : 0);
+			pre0[i] = pre0[i - 1] + (arr[i] == 0 ? 1 : 0);
 		}
 		for (int i = 1; i <= m; i++) {
 			if (op[i] == 2 && qx[i] == 0) {
-				ans[i] = sum[qr[i]] - sum[ql[i] - 1];
+				ans[i] = pre0[qr[i]] - pre0[ql[i] - 1];
 			}
 		}
 	}
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 661af14e2..7969df021 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -10,19 +10,23 @@
 //using namespace std;
 //
 //const int MAXN = 1000001;
+//const int MAXM = 500001;
+//const int MAXV = 100002;
 //int n, m;
 //int blen, bnum;
 //int maxv, lazy;
+//
 //int arr[MAXN];
+//int op[MAXM];
+//int ql[MAXM];
+//int qr[MAXM];
+//int qx[MAXM];
 //
-//int op[MAXN];
-//int ql[MAXN];
-//int qr[MAXN];
-//int qx[MAXN];
+//int pre0[MAXN];
+//int fa[MAXV];
+//int sum[MAXV];
 //
-//int fa[MAXN];
-//int sum[MAXN];
-//int ans[MAXN];
+//int ans[MAXM];
 //
 //int find(int x) {
 //    if (x != fa[x]) {
@@ -128,11 +132,11 @@
 //    blen = (int)sqrt(n * 3.0);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
-//        sum[i] = sum[i - 1] + (arr[i] == 0 ? 1 : 0);
+//        pre0[i] = pre0[i - 1] + (arr[i] == 0 ? 1 : 0);
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 2 && qx[i] == 0) {
-//            ans[i] = sum[qr[i]] - sum[ql[i] - 1];
+//            ans[i] = pre0[qr[i]] - pre0[ql[i] - 1];
 //        }
 //    }
 //}
diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
index bb6bc1608..65dc09489 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code05_Bridge1.java
@@ -12,33 +12,37 @@
 
 public class Code05_Bridge1 {
 
-	public static int MAXN = 100001;
+	public static int MAXN = 50001;
+	public static int MAXM = 100001;
+	public static int MAXQ = 100001;
 	public static int n, m, q;
 	public static int blen, bnum;
-	public static int[] u = new int[MAXN];
-	public static int[] v = new int[MAXN];
-	public static int[] w = new int[MAXN];
 
-	public static int[] op = new int[MAXN];
-	public static int[] a = new int[MAXN];
-	public static int[] b = new int[MAXN];
+	public static int[] u = new int[MAXM];
+	public static int[] v = new int[MAXM];
+	public static int[] w = new int[MAXM];
 
-	public static int[] arre = new int[MAXN];
-	public static int[] change = new int[MAXN];
-	public static int[] unchange = new int[MAXN];
-
-	public static int[] arrq = new int[MAXN];
-	public static int[] update = new int[MAXN];
-	public static int[] query = new int[MAXN];
+	public static int[] op = new int[MAXQ];
+	public static int[] a = new int[MAXQ];
+	public static int[] b = new int[MAXQ];
 
 	public static int[] fa = new int[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[][] rollback = new int[MAXN][2];
+	public static int[][] rollback = new int[MAXM][2];
 	public static int opsize = 0;
 
-	public static boolean[] vis = new boolean[MAXN];
-	public static int[] curw = new int[MAXN];
-	public static int[] ans = new int[MAXN];
+	public static int[] arre = new int[MAXM];
+	public static int[] change = new int[MAXM];
+	public static int[] unchange = new int[MAXM];
+
+	public static int[] arrq = new int[MAXQ];
+	public static int[] update = new int[MAXQ];
+	public static int[] query = new int[MAXQ];
+
+	public static boolean[] vis = new boolean[MAXM];
+	public static int[] curw = new int[MAXM];
+
+	public static int[] ans = new int[MAXQ];
 
 	// idx[l..r]由序号组成，v[序号]的值越大，序号越靠前，手写双指针快排
 	public static void sort(int[] idx, int[] v, int l, int r) {
diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code05_Bridge2.java
index 5f2992289..dd0cb82a5 100644
--- a/src/class174/Code05_Bridge2.java
+++ b/src/class174/Code05_Bridge2.java
@@ -9,33 +9,37 @@
 //
 //using namespace std;
 //
-//const int MAXN = 100001;
+//const int MAXN = 50001;
+//const int MAXM = 100001;
+//const int MAXQ = 100001;
 //int n, m, q;
 //int blen, bnum;
-//int u[MAXN];
-//int v[MAXN];
-//int w[MAXN];
 //
-//int op[MAXN];
-//int a[MAXN];
-//int b[MAXN];
+//int u[MAXM];
+//int v[MAXM];
+//int w[MAXM];
 //
-//int arre[MAXN];
-//int change[MAXN];
-//int unchange[MAXN];
-//
-//int arrq[MAXN];
-//int update[MAXN];
-//int query[MAXN];
+//int op[MAXQ];
+//int a[MAXQ];
+//int b[MAXQ];
 //
 //int fa[MAXN];
 //int siz[MAXN];
-//int rollback[MAXN][2];
+//int rollback[MAXM][2];
 //int opsize = 0;
 //
-//bool vis[MAXN];
-//int curw[MAXN];
-//int ans[MAXN];
+//int arre[MAXM];
+//int change[MAXM];
+//int unchange[MAXM];
+//
+//int arrq[MAXQ];
+//int update[MAXQ];
+//int query[MAXQ];
+//
+//bool vis[MAXM];
+//int curw[MAXM];
+//
+//int ans[MAXQ];
 //
 //void merge(int l1, int r1, int l2, int r2) {
 //    int i = 0;

From 281a8e866780050dc75a05c7feb450c55cb3492c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 14:24:59 +0800
Subject: [PATCH 1115/1712] modify code

---
 src/class174/Code01_FutureDiary1.java   |  4 ++++
 src/class174/Code01_FutureDiary2.java   |  4 ++++
 src/class174/Code02_MagicGirl1.java     | 13 ++++++++++---
 src/class174/Code02_MagicGirl2.java     | 13 ++++++++++---
 src/class174/Code03_ColorfulWorld1.java |  6 ++++++
 src/class174/Code03_ColorfulWorld2.java |  6 ++++++
 src/class174/Code04_Lcm1.java           |  7 +++++++
 src/class174/Code04_Lcm2.java           |  7 +++++++
 src/class174/Code05_Bridge1.java        |  8 ++++++++
 src/class174/Code05_Bridge2.java        |  8 ++++++++
 10 files changed, 70 insertions(+), 6 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index cde5746aa..f10d4cc72 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -1,6 +1,10 @@
 package class174;
 
 // 未来日记，java版
+// 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
+// 操作 1 l r x y : arr[l..r]范围上，所有值x变成值y
+// 操作 2 l r k   : arr[l..r]范围上，查询第k小的值
+// 1 <= n、m、arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4119
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index c0868c583..8f4e292b1 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -1,6 +1,10 @@
 package class174;
 
 // 未来日记，C++版
+// 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
+// 操作 1 l r x y : arr[l..r]范围上，所有值x变成值y
+// 操作 2 l r k   : arr[l..r]范围上，查询第k小的值
+// 1 <= n、m、arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4119
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 57b682594..531c6fd12 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -1,6 +1,11 @@
 package class174;
 
 // 魔法少女网站，java版
+// 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
+// 操作 1 x v   : arr[x]的值变成v
+// 操作 2 x y v : arr[x..y]范围上，查询有多少连续子数组的最大值 <= v
+// 1 <= n、m <= 3 * 10^5
+// 1 <= arr[i] <= n
 // 测试链接 : https://www.luogu.com.cn/problem/P6578
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
@@ -116,7 +121,7 @@ public static void calc(int l, int r) {
 	}
 
 	public static void update(int qi, int l, int r) {
-		int jobi = x[qi], jobv = y[qi];
+		int jobi = x[qi], jobv = v[qi];
 		if (l <= jobi && jobi <= r) {
 			calc(l, r);
 			arr[jobi] = jobv;
@@ -178,8 +183,10 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= m; i++) {
 			op[i] = in.nextInt();
 			x[i] = in.nextInt();
-			y[i] = in.nextInt();
-			if (op[i] == 2) {
+			if (op[i] == 1) {
+				v[i] = in.nextInt();
+			} else {
+				y[i] = in.nextInt();
 				v[i] = in.nextInt();
 			}
 		}
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index acc42f522..3c4ab05e6 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -1,6 +1,11 @@
 package class174;
 
 // 魔法少女网站，C++版
+// 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
+// 操作 1 x v   : arr[x]的值变成v
+// 操作 2 x y v : arr[x..y]范围上，查询有多少连续子数组的最大值 <= v
+// 1 <= n、m <= 3 * 10^5
+// 1 <= arr[i] <= n
 // 测试链接 : https://www.luogu.com.cn/problem/P6578
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -93,7 +98,7 @@
 //}
 //
 //inline void update(int qi, int l, int r) {
-//    int jobi = x[qi], jobv = y[qi];
+//    int jobi = x[qi], jobv = v[qi];
 //    if (l <= jobi && jobi <= r) {
 //        calc(l, r);
 //        arr[jobi] = jobv;
@@ -151,9 +156,11 @@
 //        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> op[i] >> x[i] >> y[i];
-//        if (op[i] == 2) {
+//        cin >> op[i] >> x[i];
+//        if (op[i] == 1) {
 //            cin >> v[i];
+//        } else {
+//            cin >> y[i] >> v[i];
 //        }
 //    }
 //    int bnum = (n + BLEN - 1) / BLEN;
diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index ce33ef9db..23d03e647 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -1,6 +1,12 @@
 package class174;
 
 // 五彩斑斓的世界，java版
+// 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
+// 操作 1 l r x : arr[l..r]范围上，所有大于x的数减去x
+// 操作 2 l r x : arr[l..l]范围上，查询x出现的次数
+// 1 <= n <= 10^6
+// 1 <= m <= 5 * 10^5
+// 0 <= arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4117
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 7969df021..d08eb4d41 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -1,6 +1,12 @@
 package class174;
 
 // 五彩斑斓的世界，C++版
+// 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
+// 操作 1 l r x : arr[l..r]范围上，所有大于x的数减去x
+// 操作 2 l r x : arr[l..l]范围上，查询x出现的次数
+// 1 <= n <= 10^6
+// 1 <= m <= 5 * 10^5
+// 0 <= arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4117
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class174/Code04_Lcm1.java b/src/class174/Code04_Lcm1.java
index 11d723d02..91a1bfc97 100644
--- a/src/class174/Code04_Lcm1.java
+++ b/src/class174/Code04_Lcm1.java
@@ -1,6 +1,13 @@
 package class174;
 
 // 最小公倍数，java版
+// 有n个点组成的无向图，依次给出m条无向边，每条边都有边权，并且边权很特殊
+// u v a b : u到v的边，边权 = 2的a次方 * 3的b次方
+// 接下来有q条查询，每条查询的格式如下
+// u v a b : 从u出发可以随意选择边到达v，打印是否存在一条路径，满足如下条件
+//           路径上所有边权的最小公倍数 = 2的a次方 * 3的b次方
+// 1 <= n、q <= 5 * 10^4
+// 1 <= m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3247
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class174/Code04_Lcm2.java b/src/class174/Code04_Lcm2.java
index 184a86699..7143c8ee6 100644
--- a/src/class174/Code04_Lcm2.java
+++ b/src/class174/Code04_Lcm2.java
@@ -1,6 +1,13 @@
 package class174;
 
 // 最小公倍数，C++版
+// 有n个点组成的无向图，依次给出m条无向边，每条边都有边权，并且边权很特殊
+// u v a b : u到v的边，边权 = 2的a次方 * 3的b次方
+// 接下来有q条查询，每条查询的格式如下
+// u v a b : 从u出发可以随意选择边到达v，打印是否存在一条路径，满足如下条件
+//           路径上所有边权的最小公倍数 = 2的a次方 * 3的b次方
+// 1 <= n、q <= 5 * 10^4
+// 1 <= m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3247
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
index 65dc09489..94d029831 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code05_Bridge1.java
@@ -1,6 +1,14 @@
 package class174;
 
 // 桥梁，java版
+// 有n个点组成的无向图，依次给出m条无向边
+// u v w : u到v的边，边权为w，边权同时代表限重
+// 如果开车从边上经过，车的重量 <= 边的限重，车才能走过这条边
+// 接下来有q条操作，每条操作的格式如下
+// 操作 1 a b : 编号为a的边，边权变成b
+// 操作 2 a b : 编号为a的点是出发点，车重为b，查询车能到达几个不同的点
+// 1 <= n <= 5 * 10^4    0 <= m <= 10^5
+// 1 <= q <= 10^5        1 <= 其他数据 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5443
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code05_Bridge2.java
index dd0cb82a5..f0cf9c79e 100644
--- a/src/class174/Code05_Bridge2.java
+++ b/src/class174/Code05_Bridge2.java
@@ -1,6 +1,14 @@
 package class174;
 
 // 桥梁，C++版
+// 有n个点组成的无向图，依次给出m条无向边
+// u v w : u到v的边，边权为w，边权同时代表限重
+// 如果开车从边上经过，车的重量 <= 边的限重，车才能走过这条边
+// 接下来有q条操作，每条操作的格式如下
+// 操作 1 a b : 编号为a的边，边权变成b
+// 操作 2 a b : 编号为a的点是出发点，车重为b，查询车能到达几个不同的点
+// 1 <= n <= 5 * 10^4    0 <= m <= 10^5
+// 1 <= q <= 10^5        1 <= 其他数据 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5443
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From c3170149f9b47df5e9c199062e29ff1a905ab0e0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 15:09:26 +0800
Subject: [PATCH 1116/1712] modify code

---
 src/class091/Code05_MinimalBatteryPower.java | 13 ++++++++++++-
 1 file changed, 12 insertions(+), 1 deletion(-)

diff --git a/src/class091/Code05_MinimalBatteryPower.java b/src/class091/Code05_MinimalBatteryPower.java
index e515061ee..36518dc1b 100644
--- a/src/class091/Code05_MinimalBatteryPower.java
+++ b/src/class091/Code05_MinimalBatteryPower.java
@@ -5,9 +5,20 @@
 // 执行所有任务的最少初始电量
 // 每一个任务有两个参数，需要耗费的电量、至少多少电量才能开始这个任务
 // 返回手机至少需要多少的初始电量，才能执行完所有的任务
-// 来自真实大厂笔试，没有在线测试，对数器验证
+// 测试链接 : https://leetcode.cn/problems/minimum-initial-energy-to-finish-tasks/
 public class Code05_MinimalBatteryPower {
 
+	// 同学找到了本题的在线测试，把如下minimumEffort方法提交，可以直接通过
+	// 测试链接 : https://leetcode.cn/problems/minimum-initial-energy-to-finish-tasks/
+	public static int minimumEffort(int[][] tasks) {
+		Arrays.sort(tasks, (a, b) -> (b[0] - b[1]) - (a[0] - a[1]));
+		int ans = 0;
+		for (int[] job : tasks) {
+			ans = Math.max(ans + job[0], job[1]);
+		}
+		return ans;
+	}
+
 	// 暴力递归
 	// 为了验证
 	// 时间复杂度O(n!)

From 0bc2fff73cb73693f59d255af591d5eb92c5de8e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 15:35:31 +0800
Subject: [PATCH 1117/1712] modify code

---
 src/class094/Code05_CuttingTree.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/class094/Code05_CuttingTree.java b/src/class094/Code05_CuttingTree.java
index 78d245e6a..ddb7b1abf 100644
--- a/src/class094/Code05_CuttingTree.java
+++ b/src/class094/Code05_CuttingTree.java
@@ -6,9 +6,8 @@
 // 你每天最多能砍1棵树，砍下这棵树的收益为：
 // 这棵树的初始重量 + 这棵树增长到这一天的总增重
 // 从第1天开始，你一共有m天可以砍树，返回m天内你获得的最大收益
-// 测试链接 : https://pintia.cn/problem-sets/91827364500/exam/problems/91827367873
-// 请同学们务必参考如下代码中关于输入、输出的处理
-// 这是输入输出处理效率很高的写法
+// 测试链接 : https://pintia.cn/problem-sets/91827364500/exam/problems/type/7?problemSetProblemId=91827367873
+// 如果测试链接失效，去往 ZOJ Problem Set 网站上找第3211题，本题的名字叫 "Dream City"
 // 提交以下的code，提交时请把类名改成"Main"，可以直接通过
 
 import java.io.BufferedReader;

From c89bb021734ea807d8f3ab838b781b71393a0e9d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 15:41:19 +0800
Subject: [PATCH 1118/1712] modify code

---
 src/class094/Code05_CuttingTree.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class094/Code05_CuttingTree.java b/src/class094/Code05_CuttingTree.java
index ddb7b1abf..c3919e043 100644
--- a/src/class094/Code05_CuttingTree.java
+++ b/src/class094/Code05_CuttingTree.java
@@ -7,7 +7,7 @@
 // 这棵树的初始重量 + 这棵树增长到这一天的总增重
 // 从第1天开始，你一共有m天可以砍树，返回m天内你获得的最大收益
 // 测试链接 : https://pintia.cn/problem-sets/91827364500/exam/problems/type/7?problemSetProblemId=91827367873
-// 如果测试链接失效，去往 ZOJ Problem Set 网站上找第3211题，本题的名字叫 "Dream City"
+// 如果测试链接失效，搜索 "ZOJ Problem Set" 所在网站，找第3211题 "Dream City"
 // 提交以下的code，提交时请把类名改成"Main"，可以直接通过
 
 import java.io.BufferedReader;

From 6be2ed914645e6557c5e5a6cdc26399819f6d2ef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 11 Jul 2025 15:52:13 +0800
Subject: [PATCH 1119/1712] modify code

---
 src/class063/Code02_SnacksWaysBuyTickets.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class063/Code02_SnacksWaysBuyTickets.java b/src/class063/Code02_SnacksWaysBuyTickets.java
index 2907fedfa..81c60e58f 100644
--- a/src/class063/Code02_SnacksWaysBuyTickets.java
+++ b/src/class063/Code02_SnacksWaysBuyTickets.java
@@ -73,7 +73,7 @@ public static long compute() {
 		return ans;
 	}
 
-	// arr[i....e]结束，e再往右不展开了！
+	// arr[i..e-1]范围上展开，到达e就停止
 	// 返回值 : ans数组填到了什么位置！
 	public static int f(int i, int e, long s, long w, long[] ans, int j) {
 		if (s > w) {

From dc69590aa234bc75d553d36ff65c6bc9fb12eaee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 11:22:15 +0800
Subject: [PATCH 1120/1712] modify code

---
 src/class174/Code05_Bridge1.java | 41 ++++++++++++++++++--------------
 src/class174/Code05_Bridge2.java | 35 ++++++++++++++++-----------
 2 files changed, 44 insertions(+), 32 deletions(-)

diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code05_Bridge1.java
index 94d029831..23b170736 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code05_Bridge1.java
@@ -5,8 +5,8 @@
 // u v w : u到v的边，边权为w，边权同时代表限重
 // 如果开车从边上经过，车的重量 <= 边的限重，车才能走过这条边
 // 接下来有q条操作，每条操作的格式如下
-// 操作 1 a b : 编号为a的边，边权变成b
-// 操作 2 a b : 编号为a的点是出发点，车重为b，查询车能到达几个不同的点
+// 操作 1 eid tow : 编号为eid的边，边权变成tow
+// 操作 2 nid car : 编号为nid的点出发，车重为car，查询能到达几个不同的点
 // 1 <= n <= 5 * 10^4    0 <= m <= 10^5
 // 1 <= q <= 10^5        1 <= 其他数据 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5443
@@ -31,8 +31,10 @@ public class Code05_Bridge1 {
 	public static int[] w = new int[MAXM];
 
 	public static int[] op = new int[MAXQ];
-	public static int[] a = new int[MAXQ];
-	public static int[] b = new int[MAXQ];
+	public static int[] eid = new int[MAXQ];
+	public static int[] tow = new int[MAXQ];
+	public static int[] nid = new int[MAXQ];
+	public static int[] car = new int[MAXQ];
 
 	public static int[] fa = new int[MAXN];
 	public static int[] siz = new int[MAXN];
@@ -105,9 +107,7 @@ public static void union(int x, int y) {
 			return;
 		}
 		if (siz[fx] < siz[fy]) {
-			int tmp = fx;
-			fx = fy;
-			fy = tmp;
+			int tmp = fx; fx = fy; fy = tmp;
 		}
 		fa[fy] = fx;
 		siz[fx] += siz[fy];
@@ -130,39 +130,39 @@ public static void compute(int l, int r) {
 		int cntu = 0, cntq = 0;
 		for (int i = l; i <= r; i++) {
 			if (op[arrq[i]] == 1) {
-				vis[a[arrq[i]]] = true;
+				vis[eid[arrq[i]]] = true;
 				update[++cntu] = arrq[i];
 			} else {
 				query[++cntq] = arrq[i];
 			}
 		}
-		sort(query, b, 1, cntq);
+		sort(query, car, 1, cntq);
 		int k = 1;
 		for (int i = 1; i <= cntq; i++) {
-			for (; k <= m && w[arre[k]] >= b[query[i]]; k++) {
+			for (; k <= m && w[arre[k]] >= car[query[i]]; k++) {
 				if (!vis[arre[k]]) {
 					union(u[arre[k]], v[arre[k]]);
 				}
 			}
 			opsize = 0;
 			for (int j = 1; j <= cntu; j++) {
-				curw[a[update[j]]] = w[a[update[j]]];
+				curw[eid[update[j]]] = w[eid[update[j]]];
 			}
 			for (int j = 1; j <= cntu; j++) {
 				if (update[j] < query[i]) {
-					curw[a[update[j]]] = b[update[j]];
+					curw[eid[update[j]]] = tow[update[j]];
 				}
 			}
 			for (int j = 1; j <= cntu; j++) {
-				if (curw[a[update[j]]] >= b[query[i]]) {
-					union(u[a[update[j]]], v[a[update[j]]]);
+				if (curw[eid[update[j]]] >= car[query[i]]) {
+					union(u[eid[update[j]]], v[eid[update[j]]]);
 				}
 			}
-			ans[query[i]] = siz[find(a[query[i]])];
+			ans[query[i]] = siz[find(nid[query[i]])];
 			undo();
 		}
 		for (int i = 1; i <= cntu; i++) {
-			w[a[update[i]]] = b[update[i]];
+			w[eid[update[i]]] = tow[update[i]];
 		}
 		int siz1 = 0, siz2 = 0;
 		for (int i = 1; i <= m; i++) {
@@ -209,8 +209,13 @@ public static void main(String[] args) throws IOException {
 		q = in.nextInt();
 		for (int i = 1; i <= q; i++) {
 			op[i] = in.nextInt();
-			a[i] = in.nextInt();
-			b[i] = in.nextInt();
+			if (op[i] == 1) {
+				eid[i] = in.nextInt();
+				tow[i] = in.nextInt();
+			} else {
+				nid[i] = in.nextInt();
+				car[i] = in.nextInt();
+			}
 		}
 		prepare();
 		for (int i = 1, l, r; i <= bnum; i++) {
diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code05_Bridge2.java
index f0cf9c79e..e964f3a74 100644
--- a/src/class174/Code05_Bridge2.java
+++ b/src/class174/Code05_Bridge2.java
@@ -5,8 +5,8 @@
 // u v w : u到v的边，边权为w，边权同时代表限重
 // 如果开车从边上经过，车的重量 <= 边的限重，车才能走过这条边
 // 接下来有q条操作，每条操作的格式如下
-// 操作 1 a b : 编号为a的边，边权变成b
-// 操作 2 a b : 编号为a的点是出发点，车重为b，查询车能到达几个不同的点
+// 操作 1 eid tow : 编号为eid的边，边权变成tow
+// 操作 2 nid car : 编号为nid的点出发，车重为car，查询能到达几个不同的点
 // 1 <= n <= 5 * 10^4    0 <= m <= 10^5
 // 1 <= q <= 10^5        1 <= 其他数据 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5443
@@ -28,8 +28,10 @@
 //int w[MAXM];
 //
 //int op[MAXQ];
-//int a[MAXQ];
-//int b[MAXQ];
+//int eid[MAXQ];
+//int tow[MAXQ];
+//int nid[MAXQ];
+//int car[MAXQ];
 //
 //int fa[MAXN];
 //int siz[MAXN];
@@ -105,39 +107,39 @@
 //    int cntu = 0, cntq = 0;
 //    for (int i = l; i <= r; i++) {
 //        if (op[arrq[i]] == 1) {
-//            vis[a[arrq[i]]] = true;
+//            vis[eid[arrq[i]]] = true;
 //            update[++cntu] = arrq[i];
 //        } else {
 //            query[++cntq] = arrq[i];
 //        }
 //    }
-//    sort(query + 1, query + cntq + 1, [&](int x, int y) { return b[x] > b[y]; });
+//    sort(query + 1, query + cntq + 1, [&](int x, int y) { return car[x] > car[y]; });
 //    int k = 1;
 //    for (int i = 1; i <= cntq; i++) {
-//        for (; k <= m && w[arre[k]] >= b[query[i]]; k++) {
+//        for (; k <= m && w[arre[k]] >= car[query[i]]; k++) {
 //            if (!vis[arre[k]]) {
 //                Union(u[arre[k]], v[arre[k]]);
 //            }
 //        }
 //        opsize = 0;
 //        for (int j = 1; j <= cntu; j++) {
-//            curw[a[update[j]]] = w[a[update[j]]];
+//            curw[eid[update[j]]] = w[eid[update[j]]];
 //        }
 //        for (int j = 1; j <= cntu; j++) {
 //            if (update[j] < query[i]) {
-//                curw[a[update[j]]] = b[update[j]];
+//                curw[eid[update[j]]] = tow[update[j]];
 //            }
 //        }
 //        for (int j = 1; j <= cntu; j++) {
-//            if (curw[a[update[j]]] >= b[query[i]]) {
-//                Union(u[a[update[j]]], v[a[update[j]]]);
+//            if (curw[eid[update[j]]] >= car[query[i]]) {
+//                Union(u[eid[update[j]]], v[eid[update[j]]]);
 //            }
 //        }
-//        ans[query[i]] = siz[find(a[query[i]])];
+//        ans[query[i]] = siz[find(nid[query[i]])];
 //        undo();
 //    }
 //    for (int i = 1; i <= cntu; i++) {
-//        w[a[update[i]]] = b[update[i]];
+//        w[eid[update[i]]] = tow[update[i]];
 //    }
 //    int siz1 = 0, siz2 = 0;
 //    for (int i = 1; i <= m; i++) {
@@ -172,7 +174,12 @@
 //    }
 //    cin >> q;
 //    for (int i = 1; i <= q; i++) {
-//        cin >> op[i] >> a[i] >> b[i];
+//        cin >> op[i];
+//        if (op[i] == 1) {
+//            cin >> eid[i] >> tow[i];
+//        } else {
+//            cin >> nid[i] >> car[i];
+//        }
 //    }
 //    prepare();
 //    for (int i = 1, l, r; i <= bnum; i++) {

From 20031d1640f53e9f4ab0bfae26d6dcac6d475f92 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 11:35:10 +0800
Subject: [PATCH 1121/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 2 +-
 src/class174/Code03_ColorfulWorld2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 23d03e647..fc7a6eae6 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -6,7 +6,7 @@
 // 操作 2 l r x : arr[l..l]范围上，查询x出现的次数
 // 1 <= n <= 10^6
 // 1 <= m <= 5 * 10^5
-// 0 <= arr[i] <= 10^5
+// 0 <= arr[i]、x <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4117
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index d08eb4d41..3d3789c59 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -6,7 +6,7 @@
 // 操作 2 l r x : arr[l..l]范围上，查询x出现的次数
 // 1 <= n <= 10^6
 // 1 <= m <= 5 * 10^5
-// 0 <= arr[i] <= 10^5
+// 0 <= arr[i]、x <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4117
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 6454f4a61698ede7a1c0ad24069f817a206bd7fd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 12:20:56 +0800
Subject: [PATCH 1122/1712] modify code

---
 src/class174/{Code05_Bridge1.java => Code04_Bridge1.java} | 2 +-
 src/class174/{Code05_Bridge2.java => Code04_Bridge2.java} | 0
 src/class174/{Code04_Lcm1.java => Code05_Lcm1.java}       | 2 +-
 src/class174/{Code04_Lcm2.java => Code05_Lcm2.java}       | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class174/{Code05_Bridge1.java => Code04_Bridge1.java} (99%)
 rename src/class174/{Code05_Bridge2.java => Code04_Bridge2.java} (100%)
 rename src/class174/{Code04_Lcm1.java => Code05_Lcm1.java} (99%)
 rename src/class174/{Code04_Lcm2.java => Code05_Lcm2.java} (100%)

diff --git a/src/class174/Code05_Bridge1.java b/src/class174/Code04_Bridge1.java
similarity index 99%
rename from src/class174/Code05_Bridge1.java
rename to src/class174/Code04_Bridge1.java
index 23b170736..fffe7bbdd 100644
--- a/src/class174/Code05_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -18,7 +18,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_Bridge1 {
+public class Code04_Bridge1 {
 
 	public static int MAXN = 50001;
 	public static int MAXM = 100001;
diff --git a/src/class174/Code05_Bridge2.java b/src/class174/Code04_Bridge2.java
similarity index 100%
rename from src/class174/Code05_Bridge2.java
rename to src/class174/Code04_Bridge2.java
diff --git a/src/class174/Code04_Lcm1.java b/src/class174/Code05_Lcm1.java
similarity index 99%
rename from src/class174/Code04_Lcm1.java
rename to src/class174/Code05_Lcm1.java
index 91a1bfc97..6cd909d2b 100644
--- a/src/class174/Code04_Lcm1.java
+++ b/src/class174/Code05_Lcm1.java
@@ -16,7 +16,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_Lcm1 {
+public class Code05_Lcm1 {
 
 	public static int MAXN = 50001;
 	public static int MAXM = 100001;
diff --git a/src/class174/Code04_Lcm2.java b/src/class174/Code05_Lcm2.java
similarity index 100%
rename from src/class174/Code04_Lcm2.java
rename to src/class174/Code05_Lcm2.java

From eac92550b07e667231872066de5b517698fb169d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 12:36:16 +0800
Subject: [PATCH 1123/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 18 +++++++++---------
 src/class174/Code02_MagicGirl2.java | 16 ++++++++--------
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 531c6fd12..fb67d2dd5 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -20,11 +20,10 @@
 
 public class Code02_MagicGirl1 {
 
-	public static int MAXN = 300002;
+	public static int MAXN = 300002; // 双向链表需要n+1下标
 	public static int MAXB = 601;
-	public static int POW2 = 9;
-	public static int BLEN = 1 << POW2;
-	public static int OFFSET = BLEN - 1;
+	public static int POW = 9; // 块长为(2的POW次方)，/ 块长时，>> POW即可
+	public static int OFFSET = (1 << POW) - 1; // % 块长时, & OFFSET即可
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
@@ -85,9 +84,9 @@ public static void radixSort() {
 		for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] & OFFSET]--] = arrq[i];
 		for (int i = 1; i <= siz; i++) arrq[i] = help[i];
 		Arrays.fill(cntv, 0);
-		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW2]++;
+		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW]++;
 		for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
-		for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW2]--] = arrq[i];
+		for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW]--] = arrq[i];
 		for (int i = 1; i <= siz; i++) arrq[i] = help[i];
 	}
 
@@ -190,10 +189,11 @@ public static void main(String[] args) throws Exception {
 				v[i] = in.nextInt();
 			}
 		}
-		int bnum = (n + BLEN - 1) / BLEN;
+		int blen = 1 << POW;
+		int bnum = (n + blen - 1) / blen;
 		for (int i = 1, l, r; i <= bnum; i++) {
-			l = (i - 1) * BLEN + 1;
-			r = Math.min(i * BLEN, n);
+			l = (i - 1) * blen + 1;
+			r = Math.min(i * blen, n);
 			compute(l, r);
 		}
 		for (int i = 1; i <= m; i++) {
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 3c4ab05e6..4cdad00cc 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -16,9 +16,8 @@
 //
 //const int MAXN = 300002;
 //const int MAXB = 601;
-//const int POW2 = 9;
-//const int BLEN = 1 << POW2;
-//const int OFFSET = BLEN - 1;
+//const int POW = 9;
+//const int OFFSET = (1 << POW) - 1;
 //int n, m;
 //
 //int arr[MAXN];
@@ -62,9 +61,9 @@
 //    for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] & OFFSET]--] = arrq[i];
 //    for (int i = 1; i <= siz; i++) arrq[i] = help[i];
 //    fill(cntv, cntv + MAXB, 0);
-//    for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW2]++;
+//    for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW]++;
 //    for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
-//    for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW2]--] = arrq[i];
+//    for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW]--] = arrq[i];
 //    for (int i = 1; i <= siz; i++) arrq[i] = help[i];
 //}
 //
@@ -163,10 +162,11 @@
 //            cin >> y[i] >> v[i];
 //        }
 //    }
-//    int bnum = (n + BLEN - 1) / BLEN;
+//    int blen = 1 << POW;
+//    int bnum = (n + blen - 1) / blen;
 //    for (int i = 1, l, r; i <= bnum; i++) {
-//        l = (i - 1) * BLEN + 1;
-//        r = min(i * BLEN, n);
+//        l = (i - 1) * blen + 1;
+//        r = min(i * blen, n);
 //        compute(l, r);
 //    }
 //    for (int i = 1; i <= m; i++) {

From 81a11d48f9a8911b7781f63cf63133924fed9ed5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 12:43:58 +0800
Subject: [PATCH 1124/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 +-
 src/class174/Code01_FutureDiary2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index f10d4cc72..5d4f6e600 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -23,7 +23,6 @@ public class Code01_FutureDiary1 {
 	public static int MAXB = 401;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	public static int[] tmp = new int[MAXN];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
@@ -34,6 +33,7 @@ public class Code01_FutureDiary1 {
 	public static int[][] valrt = new int[MAXB][MAXN];
 	public static int[][] rtval = new int[MAXB][MAXN];
 
+	public static int[] tmp = new int[MAXN];
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];
 	public static int[] cnt1 = new int[MAXB];
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 8f4e292b1..573dda9c5 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -36,7 +36,6 @@
 //const int MAXB = 401;
 //int n, m;
 //int arr[MAXN];
-//int tmp[MAXN];
 //
 //int blen, bnum;
 //int bi[MAXN];
@@ -47,6 +46,7 @@
 //int valrt[MAXB][MAXN];
 //int rtval[MAXB][MAXN];
 //
+//int tmp[MAXN];
 //int sum1[MAXB][MAXB];
 //int sum2[MAXB][MAXN];
 //int cnt1[MAXB];

From 87f3c8e98d2db26710d64c26737a5f1028a6dca4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 13:02:33 +0800
Subject: [PATCH 1125/1712] modify code

---
 src/class085/FollowUpWindy.java | 111 ++++++++++++++++++++++++++++++++
 1 file changed, 111 insertions(+)
 create mode 100644 src/class085/FollowUpWindy.java

diff --git a/src/class085/FollowUpWindy.java b/src/class085/FollowUpWindy.java
new file mode 100644
index 000000000..b34c73bc7
--- /dev/null
+++ b/src/class085/FollowUpWindy.java
@@ -0,0 +1,111 @@
+package class085;
+
+// windy数，加强版
+// 课上没有讲这个文件，这是windy数的加强版测试
+// 需要改成long类型，除此之外和课上讲的完全一样
+// 测试链接 : https://www.luogu.com.cn/problem/P13085
+// 提交以下的code，提交时请把类名改成"Main"，可以直接通过
+
+import java.io.BufferedReader;
+import java.io.IOException;
+import java.io.InputStreamReader;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.io.StreamTokenizer;
+
+public class FollowUpWindy {
+
+	public static int MAXLEN = 21;
+
+	public static long[][][] dp = new long[MAXLEN][11][2];
+
+	public static void build(int len) {
+		for (int i = 0; i <= len; i++) {
+			for (int j = 0; j <= 10; j++) {
+				dp[i][j][0] = -1;
+				dp[i][j][1] = -1;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
+		StreamTokenizer in = new StreamTokenizer(br);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		while (in.nextToken() != StreamTokenizer.TT_EOF) {
+			long a = (long) in.nval;
+			in.nextToken();
+			long b = (long) in.nval;
+			out.println(compute(a, b));
+		}
+		out.flush();
+		out.close();
+		br.close();
+	}
+
+	public static long compute(long a, long b) {
+		return cnt(b) - cnt(a - 1);
+	}
+
+	public static long cnt(long num) {
+		if (num == 0) {
+			return 1;
+		}
+		int len = 1;
+		long offset = 1;
+		long tmp = num / 10;
+		while (tmp > 0) {
+			len++;
+			offset *= 10;
+			tmp /= 10;
+		}
+		build(len);
+		return f(num, offset, len, 10, 0);
+	}
+
+	public static long f(long num, long offset, int len, int pre, int free) {
+		if (len == 0) {
+			return 1;
+		}
+		if (dp[len][pre][free] != -1) {
+			return dp[len][pre][free];
+		}
+		int cur = (int) (num / offset % 10);
+		long ans = 0;
+		if (free == 0) {
+			if (pre == 10) {
+				ans += f(num, offset / 10, len - 1, 10, 1);
+				for (int i = 1; i < cur; i++) {
+					ans += f(num, offset / 10, len - 1, i, 1);
+				}
+				ans += f(num, offset / 10, len - 1, cur, 0);
+			} else {
+				for (int i = 0; i <= 9; i++) {
+					if (i <= pre - 2 || i >= pre + 2) {
+						if (i < cur) {
+							ans += f(num, offset / 10, len - 1, i, 1);
+						} else if (i == cur) {
+							ans += f(num, offset / 10, len - 1, cur, 0);
+						}
+					}
+				}
+			}
+		} else {
+			if (pre == 10) {
+				ans += f(num, offset / 10, len - 1, 10, 1);
+				for (int i = 1; i <= 9; i++) {
+					ans += f(num, offset / 10, len - 1, i, 1);
+				}
+			} else {
+				for (int i = 0; i <= 9; i++) {
+					if (i <= pre - 2 || i >= pre + 2) {
+						ans += f(num, offset / 10, len - 1, i, 1);
+					}
+				}
+			}
+		}
+		dp[len][pre][free] = ans;
+		return ans;
+	}
+
+}

From 16efa12f29f41b38cfc6a46d283667874dfaf1f8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 13:41:00 +0800
Subject: [PATCH 1126/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 4 ++--
 src/class174/Code01_FutureDiary2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 5d4f6e600..f93fcce45 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -59,7 +59,7 @@ public static void down(int b) {
 		}
 	}
 
-	public static void xToy(int b, int x, int y) {
+	public static void xtoy(int b, int x, int y) {
 		valrt[b][y] = valrt[b][x];
 		rtval[b][valrt[b][x]] = y;
 		valrt[b][x] = 0;
@@ -103,7 +103,7 @@ public static void update(int l, int r, int x, int y) {
 						sum1[b][bi[x]] -= sum2[b][x];
 						sum2[b][y] += sum2[b][x];
 						sum2[b][x] = 0;
-						xToy(b, x, y);
+						xtoy(b, x, y);
 					}
 				}
 			}
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 573dda9c5..6f6be3e08 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -73,7 +73,7 @@
 //    }
 //}
 //
-//void xToy(int b, int x, int y) {
+//void xtoy(int b, int x, int y) {
 //    valrt[b][y] = valrt[b][x];
 //    rtval[b][valrt[b][x]] = y;
 //    valrt[b][x] = 0;
@@ -117,7 +117,7 @@
 //                    sum1[b][bi[x]] -= sum2[b][x];
 //                    sum2[b][y] += sum2[b][x];
 //                    sum2[b][x] = 0;
-//                    xToy(b, x, y);
+//                    xtoy(b, x, y);
 //                }
 //            }
 //        }

From e786957c39e58764a6411a1538e5f20e5ddd4fe5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 14:09:48 +0800
Subject: [PATCH 1127/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 42 +++++++++++++++++++++++----
 src/class174/Code01_FutureDiary2.java | 12 ++++----
 2 files changed, 42 insertions(+), 12 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index f93fcce45..448bf409c 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -29,16 +29,25 @@ public class Code01_FutureDiary1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
+	// idxrt[i]表示下标i，在归属的块中，对应的根编号
+	// valrt[b][v]表示序列块b中的数值v，对应的根编号
+	// rtval[b][i]表示序列块b中的根编号i，对应的数值
 	public static int[] idxrt = new int[MAXN];
 	public static int[][] valrt = new int[MAXB][MAXN];
 	public static int[][] rtval = new int[MAXB][MAXN];
 
+	// tmp用于临时排序找第k小的值
+	// sum1[b][i]表示序列块b中，来自值域块i的数字有几个
+	// sum2[b][v]表示序列块b中，数字v有几个
+	// cnt1[i]表示遍历过程中，统计值域块i的数字有几个
+	// cnt2[v]表示遍历过程中，统计数字v有几个
 	public static int[] tmp = new int[MAXN];
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];
 	public static int[] cnt1 = new int[MAXB];
 	public static int[] cnt2 = new int[MAXN];
 
+	// 序列第b块中，根据arr中的值建立起，idxrt、valrt[b]、rtval[b]
 	public static void build(int b) {
 		for (int i = 1; i <= blen; i++) {
 			valrt[b][rtval[b][i]] = 0;
@@ -53,18 +62,14 @@ public static void build(int b) {
 		}
 	}
 
+	// 序列第b块中，有些位置的值已经改了，让改动写入arr
 	public static void down(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
 			arr[i] = rtval[b][idxrt[i]];
 		}
 	}
 
-	public static void xtoy(int b, int x, int y) {
-		valrt[b][y] = valrt[b][x];
-		rtval[b][valrt[b][x]] = y;
-		valrt[b][x] = 0;
-	}
-
+	// 序列[l..r]范围上，目前既有x又有y，把所有x改成y
 	public static void innerUpdate(int l, int r, int x, int y) {
 		down(bi[l]);
 		for (int i = l; i <= r; i++) {
@@ -79,10 +84,18 @@ public static void innerUpdate(int l, int r, int x, int y) {
 		build(bi[l]);
 	}
 
+	// 序列第b块中，目前没有y这个数值，把块中所有的x改成y
+	public static void xtoy(int b, int x, int y) {
+		valrt[b][y] = valrt[b][x];
+		rtval[b][valrt[b][x]] = y;
+		valrt[b][x] = 0;
+	}
+
 	public static void update(int l, int r, int x, int y) {
 		if (x == y || (sum2[bi[r]][x] - sum2[bi[l] - 1][x] == 0)) {
 			return;
 		}
+		// 前缀统计变成当前块统计
 		for (int b = bi[n]; b >= bi[l]; b--) {
 			sum1[b][bi[x]] -= sum1[b - 1][bi[x]];
 			sum1[b][bi[y]] -= sum1[b - 1][bi[y]];
@@ -97,6 +110,8 @@ public static void update(int l, int r, int x, int y) {
 			for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
 				if (sum2[b][x] != 0) {
 					if (sum2[b][y] != 0) {
+						// 可以证明
+						// 整块发生innerUpdate的次数 <= 根号n
 						innerUpdate(bl[b], br[b], x, y);
 					} else {
 						sum1[b][bi[y]] += sum2[b][x];
@@ -108,6 +123,7 @@ public static void update(int l, int r, int x, int y) {
 				}
 			}
 		}
+		// 当前块统计变回前缀统计
 		for (int b = bi[l]; b <= bi[n]; b++) {
 			sum1[b][bi[x]] += sum1[b - 1][bi[x]];
 			sum1[b][bi[y]] += sum1[b - 1][bi[y]];
@@ -128,16 +144,19 @@ public static int query(int l, int r, int k) {
 		} else {
 			down(bi[l]);
 			down(bi[r]);
+			// 左散块中，每种值的词频统计
 			for (int i = l; i <= br[bi[l]]; i++) {
 				cnt1[bi[arr[i]]]++;
 				cnt2[arr[i]]++;
 			}
+			// 右散块中，每种值的词频统计
 			for (int i = bl[bi[r]]; i <= r; i++) {
 				cnt1[bi[arr[i]]]++;
 				cnt2[arr[i]]++;
 			}
 			int sumCnt = 0;
 			int vblock = 0;
+			// 先定位第k小的数，来自值域的哪个块，vblock
 			for (int b = 1; b <= bi[MAXN - 1]; b++) {
 				int blockCnt = cnt1[b] + sum1[bi[r] - 1][b] - sum1[bi[l]][b];
 				if (sumCnt + blockCnt < k) {
@@ -147,6 +166,7 @@ public static int query(int l, int r, int k) {
 					break;
 				}
 			}
+			// 再定位第k小的数，来自值域第vblock块中，具体什么数字
 			for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
 				int valCnt = cnt2[v] + sum2[bi[r] - 1][v] - sum2[bi[l]][v];
 				if (sumCnt + valCnt >= k) {
@@ -156,9 +176,11 @@ public static int query(int l, int r, int k) {
 					sumCnt += valCnt;
 				}
 			}
+			// 左散块的词频统计清空
 			for (int i = l; i <= br[bi[l]]; i++) {
 				cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
 			}
+			// 右散块的词频统计清空
 			for (int i = bl[bi[r]]; i <= r; i++) {
 				cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
 			}
@@ -169,14 +191,22 @@ public static int query(int l, int r, int k) {
 	public static void prepare() {
 		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
+		// i一定要枚举[1, MAXN)
+		// 因为不仅序列要分块，值域也要分块
+		// bi[i]可以查询下标i来自哪个序列块
+		// bi[v]也可查询数字v来自哪个值域块
 		for (int i = 1; i < MAXN; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
+		// bl[i]表示下标第i块的左边界
+		// br[i]表示下标第i块的右边界
+		// bl、br 仅用于序列分块
 		for (int i = 1; i <= bnum; i++) {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, n);
 			build(i);
 		}
+		// 初始建立sum1、sum2，都表示前缀信息
 		for (int i = 1; i <= bnum; i++) {
 			for (int j = 1; j < MAXB; j++) {
 				sum1[i][j] = sum1[i - 1][j];
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 6f6be3e08..f0d7d3056 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -73,12 +73,6 @@
 //    }
 //}
 //
-//void xtoy(int b, int x, int y) {
-//    valrt[b][y] = valrt[b][x];
-//    rtval[b][valrt[b][x]] = y;
-//    valrt[b][x] = 0;
-//}
-//
 //void innerUpdate(int l, int r, int x, int y) {
 //    down(bi[l]);
 //    for (int i = l; i <= r; i++) {
@@ -93,6 +87,12 @@
 //    build(bi[l]);
 //}
 //
+//void xtoy(int b, int x, int y) {
+//    valrt[b][y] = valrt[b][x];
+//    rtval[b][valrt[b][x]] = y;
+//    valrt[b][x] = 0;
+//}
+//
 //void update(int l, int r, int x, int y) {
 //    if (x == y || (sum2[bi[r]][x] - sum2[bi[l] - 1][x] == 0)) {
 //        return;

From 4accfb8734fc165786f74485046031d66666f546 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 14:26:03 +0800
Subject: [PATCH 1128/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 448bf409c..c8bbbbb6d 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -32,15 +32,16 @@ public class Code01_FutureDiary1 {
 	// idxrt[i]表示下标i，在归属的块中，对应的根编号
 	// valrt[b][v]表示序列块b中的数值v，对应的根编号
 	// rtval[b][i]表示序列块b中的根编号i，对应的数值
+	// 绝不会向上跳跃多次才能找到根编号，很像并查集，其实不是
 	public static int[] idxrt = new int[MAXN];
 	public static int[][] valrt = new int[MAXB][MAXN];
 	public static int[][] rtval = new int[MAXB][MAXN];
 
 	// tmp用于临时排序找第k小的值
-	// sum1[b][i]表示序列块b中，来自值域块i的数字有几个
-	// sum2[b][v]表示序列块b中，数字v有几个
-	// cnt1[i]表示遍历过程中，统计值域块i的数字有几个
-	// cnt2[v]表示遍历过程中，统计数字v有几个
+	// sum1[b][i]表示前b个序列块中，来自值域块i的数字有几个
+	// sum2[b][v]表示前b个序列块中，数字v有几个
+	// cnt1[i]表示遍历散块，统计值域块i的数字有几个
+	// cnt2[v]表示遍历散块，统计数字v有几个
 	public static int[] tmp = new int[MAXN];
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];

From 5a4ede3bd191fb6c23cf71c22517c514b0ab1440 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 14:28:21 +0800
Subject: [PATCH 1129/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index c8bbbbb6d..f0c53e4c0 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -112,7 +112,7 @@ public static void update(int l, int r, int x, int y) {
 				if (sum2[b][x] != 0) {
 					if (sum2[b][y] != 0) {
 						// 可以证明
-						// 整块发生innerUpdate的次数 <= 根号n
+						// 整块发生innerUpdate的次数 <= 块长
 						innerUpdate(bl[b], br[b], x, y);
 					} else {
 						sum1[b][bi[y]] += sum2[b][x];

From 3043dfbdc227308ae880e572cb8193a7c0f7b8b5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 14:37:00 +0800
Subject: [PATCH 1130/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index f0c53e4c0..8dc852b80 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -111,8 +111,7 @@ public static void update(int l, int r, int x, int y) {
 			for (int b = bi[l] + 1; b <= bi[r] - 1; b++) {
 				if (sum2[b][x] != 0) {
 					if (sum2[b][y] != 0) {
-						// 可以证明
-						// 整块发生innerUpdate的次数 <= 块长
+						// 整块更新时，调用innerUpdate的次数 <= 块长
 						innerUpdate(bl[b], br[b], x, y);
 					} else {
 						sum1[b][bi[y]] += sum2[b][x];

From c31998ca2b2ed0ac505948130a7cdb2c4c3de866 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 15:09:44 +0800
Subject: [PATCH 1131/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 8dc852b80..7151686b4 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -93,6 +93,7 @@ public static void xtoy(int b, int x, int y) {
 	}
 
 	public static void update(int l, int r, int x, int y) {
+		// 必要的剪枝
 		if (x == y || (sum2[bi[r]][x] - sum2[bi[l] - 1][x] == 0)) {
 			return;
 		}

From b2bc59b44537a2a0718c6e0db520e3c421f9299a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 16:01:45 +0800
Subject: [PATCH 1132/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 95 +++++++++++++--------------
 src/class174/Code01_FutureDiary2.java | 83 ++++++++++++-----------
 2 files changed, 89 insertions(+), 89 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 7151686b4..d0828a44b 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -15,7 +15,6 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.util.Arrays;
 
 public class Code01_FutureDiary1 {
 
@@ -37,19 +36,17 @@ public class Code01_FutureDiary1 {
 	public static int[][] valrt = new int[MAXB][MAXN];
 	public static int[][] rtval = new int[MAXB][MAXN];
 
-	// tmp用于临时排序找第k小的值
 	// sum1[b][i]表示前b个序列块中，来自值域块i的数字有几个
 	// sum2[b][v]表示前b个序列块中，数字v有几个
 	// cnt1[i]表示遍历散块，统计值域块i的数字有几个
 	// cnt2[v]表示遍历散块，统计数字v有几个
-	public static int[] tmp = new int[MAXN];
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];
 	public static int[] cnt1 = new int[MAXB];
 	public static int[] cnt2 = new int[MAXN];
 
 	// 序列第b块中，根据arr中的值建立起，idxrt、valrt[b]、rtval[b]
-	public static void build(int b) {
+	public static void buildSet(int b) {
 		for (int i = 1; i <= blen; i++) {
 			valrt[b][rtval[b][i]] = 0;
 		}
@@ -82,7 +79,7 @@ public static void innerUpdate(int l, int r, int x, int y) {
 				arr[i] = y;
 			}
 		}
-		build(bi[l]);
+		buildSet(bi[l]);
 	}
 
 	// 序列第b块中，目前没有y这个数值，把块中所有的x改成y
@@ -133,59 +130,57 @@ public static void update(int l, int r, int x, int y) {
 		}
 	}
 
+	public static void buildCnt(int l, int r) {
+		for (int i = l; i <= r; i++) {
+			cnt1[bi[arr[i]]]++;
+			cnt2[arr[i]]++;
+		}
+	}
+
+	public static void clearCnt(int l, int r) {
+		for (int i = l; i <= r; i++) {
+			cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
+		}
+	}
+
 	public static int query(int l, int r, int k) {
 		int ans = 0;
-		if (bi[l] == bi[r]) {
+		boolean inner = bi[l] == bi[r];
+		if (inner) {
 			down(bi[l]);
-			for (int i = l; i <= r; i++) {
-				tmp[i] = arr[i];
-			}
-			Arrays.sort(tmp, l, r + 1);
-			ans = tmp[l + k - 1];
+			buildCnt(l, r);
 		} else {
 			down(bi[l]);
 			down(bi[r]);
-			// 左散块中，每种值的词频统计
-			for (int i = l; i <= br[bi[l]]; i++) {
-				cnt1[bi[arr[i]]]++;
-				cnt2[arr[i]]++;
-			}
-			// 右散块中，每种值的词频统计
-			for (int i = bl[bi[r]]; i <= r; i++) {
-				cnt1[bi[arr[i]]]++;
-				cnt2[arr[i]]++;
-			}
-			int sumCnt = 0;
-			int vblock = 0;
-			// 先定位第k小的数，来自值域的哪个块，vblock
-			for (int b = 1; b <= bi[MAXN - 1]; b++) {
-				int blockCnt = cnt1[b] + sum1[bi[r] - 1][b] - sum1[bi[l]][b];
-				if (sumCnt + blockCnt < k) {
-					sumCnt += blockCnt;
-				} else {
-					vblock = b;
-					break;
-				}
-			}
-			// 再定位第k小的数，来自值域第vblock块中，具体什么数字
-			for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
-				int valCnt = cnt2[v] + sum2[bi[r] - 1][v] - sum2[bi[l]][v];
-				if (sumCnt + valCnt >= k) {
-					ans = v;
-					break;
-				} else {
-					sumCnt += valCnt;
-				}
-			}
-			// 左散块的词频统计清空
-			for (int i = l; i <= br[bi[l]]; i++) {
-				cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
+			buildCnt(l, br[bi[l]]);
+			buildCnt(bl[bi[r]], r);
+		}
+		int sumCnt = 0;
+		int vblock = 0;
+		for (int b = 1; b <= bi[MAXN - 1]; b++) {
+			int blockCnt = cnt1[b] + (inner ? 0 : sum1[bi[r] - 1][b] - sum1[bi[l]][b]);
+			if (sumCnt + blockCnt < k) {
+				sumCnt += blockCnt;
+			} else {
+				vblock = b;
+				break;
 			}
-			// 右散块的词频统计清空
-			for (int i = bl[bi[r]]; i <= r; i++) {
-				cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
+		}
+		for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
+			int valCnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);
+			if (sumCnt + valCnt >= k) {
+				ans = v;
+				break;
+			} else {
+				sumCnt += valCnt;
 			}
 		}
+		if (inner) {
+			clearCnt(l, r);
+		} else {
+			clearCnt(l, br[bi[l]]);
+			clearCnt(bl[bi[r]], r);
+		}
 		return ans;
 	}
 
@@ -205,7 +200,7 @@ public static void prepare() {
 		for (int i = 1; i <= bnum; i++) {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, n);
-			build(i);
+			buildSet(i);
 		}
 		// 初始建立sum1、sum2，都表示前缀信息
 		for (int i = 1; i <= bnum; i++) {
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index f0d7d3056..8cbd94506 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -46,13 +46,12 @@
 //int valrt[MAXB][MAXN];
 //int rtval[MAXB][MAXN];
 //
-//int tmp[MAXN];
 //int sum1[MAXB][MAXB];
 //int sum2[MAXB][MAXN];
 //int cnt1[MAXB];
 //int cnt2[MAXN];
 //
-//void build(int b) {
+//void buildSet(int b) {
 //    for (int i = 1; i <= blen; i++) {
 //        valrt[b][rtval[b][i]] = 0;
 //    }
@@ -84,7 +83,7 @@
 //            arr[i] = y;
 //        }
 //    }
-//    build(bi[l]);
+//    buildSet(bi[l]);
 //}
 //
 //void xtoy(int b, int x, int y) {
@@ -130,50 +129,56 @@
 //    }
 //}
 //
+//void buildCnt(int l, int r) {
+//    for (int i = l; i <= r; i++) {
+//        cnt1[bi[arr[i]]]++;
+//        cnt2[arr[i]]++;
+//    }
+//}
+//
+//void clearCnt(int l, int r) {
+//    for (int i = l; i <= r; i++) {
+//        cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
+//    }
+//}
+//
 //int query(int l, int r, int k) {
 //    int ans = 0;
-//    if (bi[l] == bi[r]) {
+//    bool inner = bi[l] == bi[r];
+//    if (inner) {
 //        down(bi[l]);
-//        for (int i = l; i <= r; i++) {
-//            tmp[i] = arr[i];
-//        }
-//        sort(tmp + l, tmp + r + 1);
-//        ans = tmp[l + k - 1];
+//        buildCnt(l, r);
 //    } else {
 //        down(bi[l]);
 //        down(bi[r]);
-//        for (int i = l; i <= br[bi[l]]; i++) {
-//            cnt1[bi[arr[i]]]++;
-//            cnt2[arr[i]]++;
-//        }
-//        for (int i = bl[bi[r]]; i <= r; i++) {
-//            cnt1[bi[arr[i]]]++;
-//            cnt2[arr[i]]++;
-//        }
-//        int sumCnt = 0, vblock = 0;
-//        for (int b = 1; b <= bi[MAXN - 1]; b++) {
-//            int blockCnt = cnt1[b] + sum1[bi[r] - 1][b] - sum1[bi[l]][b];
-//            if (sumCnt + blockCnt < k) {
-//                sumCnt += blockCnt;
-//            } else {
-//                vblock = b;
-//                break;
-//            }
+//        buildCnt(l, br[bi[l]]);
+//        buildCnt(bl[bi[r]], r);
+//    }
+//    int sumCnt = 0;
+//    int vblock = 0;
+//    for (int b = 1; b <= bi[MAXN - 1]; b++) {
+//        int blockCnt = cnt1[b] + (inner ? 0 : sum1[bi[r] - 1][b] - sum1[bi[l]][b]);
+//        if (sumCnt + blockCnt < k) {
+//            sumCnt += blockCnt;
+//        } else {
+//            vblock = b;
+//            break;
 //        }
-//        for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
-//            int valCnt = cnt2[v] + sum2[bi[r] - 1][v] - sum2[bi[l]][v];
-//            if (sumCnt + valCnt >= k) {
-//                ans = v;
-//                break;
-//            }
+//    }
+//    for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
+//        int valCnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);
+//        if (sumCnt + valCnt >= k) {
+//            ans = v;
+//            break;
+//        } else {
 //            sumCnt += valCnt;
 //        }
-//        for (int i = l; i <= br[bi[l]]; i++) {
-//            cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
-//        }
-//        for (int i = bl[bi[r]]; i <= r; i++) {
-//            cnt1[bi[arr[i]]] = cnt2[arr[i]] = 0;
-//        }
+//    }
+//    if (inner) {
+//        clearCnt(l, r);
+//    } else {
+//        clearCnt(l, br[bi[l]]);
+//        clearCnt(bl[bi[r]], r);
 //    }
 //    return ans;
 //}
@@ -187,7 +192,7 @@
 //    for (int i = 1; i <= bnum; i++) {
 //        bl[i] = (i - 1) * blen + 1;
 //        br[i] = min(i * blen, n);
-//        build(i);
+//        buildSet(i);
 //    }
 //    for (int i = 1; i <= bnum; i++) {
 //        for (int j = 1; j < MAXB; j++) {

From 640e6100626b387bda58c04790d916d341e21da5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 16:09:01 +0800
Subject: [PATCH 1133/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 16 +++++++++-------
 src/class174/Code01_FutureDiary2.java | 14 +++++++-------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index d0828a44b..8416a3428 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -157,22 +157,24 @@ public static int query(int l, int r, int k) {
 		}
 		int sumCnt = 0;
 		int vblock = 0;
+		// 定位第k小的数字，来自哪个值域块
 		for (int b = 1; b <= bi[MAXN - 1]; b++) {
-			int blockCnt = cnt1[b] + (inner ? 0 : sum1[bi[r] - 1][b] - sum1[bi[l]][b]);
-			if (sumCnt + blockCnt < k) {
-				sumCnt += blockCnt;
-			} else {
+			int cnt = cnt1[b] + (inner ? 0 : sum1[bi[r] - 1][b] - sum1[bi[l]][b]);
+			if (sumCnt + cnt >= k) {
 				vblock = b;
 				break;
+			} else {
+				sumCnt += cnt;
 			}
 		}
+		// 定位第k小的数字，来自值域块的哪个数字
 		for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
-			int valCnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);
-			if (sumCnt + valCnt >= k) {
+			int cnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);
+			if (sumCnt + cnt >= k) {
 				ans = v;
 				break;
 			} else {
-				sumCnt += valCnt;
+				sumCnt += cnt;
 			}
 		}
 		if (inner) {
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 8cbd94506..1234a1f3c 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -157,21 +157,21 @@
 //    int sumCnt = 0;
 //    int vblock = 0;
 //    for (int b = 1; b <= bi[MAXN - 1]; b++) {
-//        int blockCnt = cnt1[b] + (inner ? 0 : sum1[bi[r] - 1][b] - sum1[bi[l]][b]);
-//        if (sumCnt + blockCnt < k) {
-//            sumCnt += blockCnt;
-//        } else {
+//        int cnt = cnt1[b] + (inner ? 0 : sum1[bi[r] - 1][b] - sum1[bi[l]][b]);
+//        if (sumCnt + cnt >= k) {
 //            vblock = b;
 //            break;
+//        } else {
+//            sumCnt += cnt;
 //        }
 //    }
 //    for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
-//        int valCnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);
-//        if (sumCnt + valCnt >= k) {
+//        int cnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);
+//        if (sumCnt + cnt >= k) {
 //            ans = v;
 //            break;
 //        } else {
-//            sumCnt += valCnt;
+//            sumCnt += cnt;
 //        }
 //    }
 //    if (inner) {

From 49f95c330d295f57ae96d2f2acad8595a54a3608 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 16:15:10 +0800
Subject: [PATCH 1134/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 14 +++++++-------
 src/class174/Code01_FutureDiary2.java | 14 +++++++-------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 8416a3428..738c37658 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -46,7 +46,7 @@ public class Code01_FutureDiary1 {
 	public static int[] cnt2 = new int[MAXN];
 
 	// 序列第b块中，根据arr中的值建立起，idxrt、valrt[b]、rtval[b]
-	public static void buildSet(int b) {
+	public static void build(int b) {
 		for (int i = 1; i <= blen; i++) {
 			valrt[b][rtval[b][i]] = 0;
 		}
@@ -79,7 +79,7 @@ public static void innerUpdate(int l, int r, int x, int y) {
 				arr[i] = y;
 			}
 		}
-		buildSet(bi[l]);
+		build(bi[l]);
 	}
 
 	// 序列第b块中，目前没有y这个数值，把块中所有的x改成y
@@ -130,7 +130,7 @@ public static void update(int l, int r, int x, int y) {
 		}
 	}
 
-	public static void buildCnt(int l, int r) {
+	public static void addCnt(int l, int r) {
 		for (int i = l; i <= r; i++) {
 			cnt1[bi[arr[i]]]++;
 			cnt2[arr[i]]++;
@@ -148,12 +148,12 @@ public static int query(int l, int r, int k) {
 		boolean inner = bi[l] == bi[r];
 		if (inner) {
 			down(bi[l]);
-			buildCnt(l, r);
+			addCnt(l, r);
 		} else {
 			down(bi[l]);
 			down(bi[r]);
-			buildCnt(l, br[bi[l]]);
-			buildCnt(bl[bi[r]], r);
+			addCnt(l, br[bi[l]]);
+			addCnt(bl[bi[r]], r);
 		}
 		int sumCnt = 0;
 		int vblock = 0;
@@ -202,7 +202,7 @@ public static void prepare() {
 		for (int i = 1; i <= bnum; i++) {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, n);
-			buildSet(i);
+			build(i);
 		}
 		// 初始建立sum1、sum2，都表示前缀信息
 		for (int i = 1; i <= bnum; i++) {
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 1234a1f3c..481717f68 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -51,7 +51,7 @@
 //int cnt1[MAXB];
 //int cnt2[MAXN];
 //
-//void buildSet(int b) {
+//void build(int b) {
 //    for (int i = 1; i <= blen; i++) {
 //        valrt[b][rtval[b][i]] = 0;
 //    }
@@ -83,7 +83,7 @@
 //            arr[i] = y;
 //        }
 //    }
-//    buildSet(bi[l]);
+//    build(bi[l]);
 //}
 //
 //void xtoy(int b, int x, int y) {
@@ -129,7 +129,7 @@
 //    }
 //}
 //
-//void buildCnt(int l, int r) {
+//void addCnt(int l, int r) {
 //    for (int i = l; i <= r; i++) {
 //        cnt1[bi[arr[i]]]++;
 //        cnt2[arr[i]]++;
@@ -147,12 +147,12 @@
 //    bool inner = bi[l] == bi[r];
 //    if (inner) {
 //        down(bi[l]);
-//        buildCnt(l, r);
+//        addCnt(l, r);
 //    } else {
 //        down(bi[l]);
 //        down(bi[r]);
-//        buildCnt(l, br[bi[l]]);
-//        buildCnt(bl[bi[r]], r);
+//        addCnt(l, br[bi[l]]);
+//        addCnt(bl[bi[r]], r);
 //    }
 //    int sumCnt = 0;
 //    int vblock = 0;
@@ -192,7 +192,7 @@
 //    for (int i = 1; i <= bnum; i++) {
 //        bl[i] = (i - 1) * blen + 1;
 //        br[i] = min(i * blen, n);
-//        buildSet(i);
+//        build(i);
 //    }
 //    for (int i = 1; i <= bnum; i++) {
 //        for (int j = 1; j < MAXB; j++) {

From 14d41098a438a1c40112d8c97a8ae0aead47a839 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 16:19:11 +0800
Subject: [PATCH 1135/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 738c37658..7318d3fb3 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -146,6 +146,7 @@ public static void clearCnt(int l, int r) {
 	public static int query(int l, int r, int k) {
 		int ans = 0;
 		boolean inner = bi[l] == bi[r];
+		// 建立散块的词频统计
 		if (inner) {
 			down(bi[l]);
 			addCnt(l, r);
@@ -159,6 +160,7 @@ public static int query(int l, int r, int k) {
 		int vblock = 0;
 		// 定位第k小的数字，来自哪个值域块
 		for (int b = 1; b <= bi[MAXN - 1]; b++) {
+			// 如果不存在中间的整块，词频 = 散块词频，否则 词频 = 散块词频 + 整块词频
 			int cnt = cnt1[b] + (inner ? 0 : sum1[bi[r] - 1][b] - sum1[bi[l]][b]);
 			if (sumCnt + cnt >= k) {
 				vblock = b;
@@ -169,6 +171,7 @@ public static int query(int l, int r, int k) {
 		}
 		// 定位第k小的数字，来自值域块的哪个数字
 		for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
+			// 如果不存在中间的整块，词频 = 散块词频，否则 词频 = 散块词频 + 整块词频
 			int cnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);
 			if (sumCnt + cnt >= k) {
 				ans = v;
@@ -177,6 +180,7 @@ public static int query(int l, int r, int k) {
 				sumCnt += cnt;
 			}
 		}
+		// 清空散块的词频统计
 		if (inner) {
 			clearCnt(l, r);
 		} else {

From 9477605e108a03764461b6a964028c1331026c88 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 16:20:18 +0800
Subject: [PATCH 1136/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 7318d3fb3..1ba7410bc 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -169,7 +169,7 @@ public static int query(int l, int r, int k) {
 				sumCnt += cnt;
 			}
 		}
-		// 定位第k小的数字，来自值域块的哪个数字
+		// 定位第k小的数字，来自值域块的具体数字
 		for (int v = (vblock - 1) * blen + 1; v <= vblock * blen; v++) {
 			// 如果不存在中间的整块，词频 = 散块词频，否则 词频 = 散块词频 + 整块词频
 			int cnt = cnt2[v] + (inner ? 0 : sum2[bi[r] - 1][v] - sum2[bi[l]][v]);

From d5d21315c2132e1eea9e180e8be62acff7f25db8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 17:27:13 +0800
Subject: [PATCH 1137/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 1ba7410bc..59e724de7 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -31,7 +31,8 @@ public class Code01_FutureDiary1 {
 	// idxrt[i]表示下标i，在归属的块中，对应的根编号
 	// valrt[b][v]表示序列块b中的数值v，对应的根编号
 	// rtval[b][i]表示序列块b中的根编号i，对应的数值
-	// 绝不会向上跳跃多次才能找到根编号，很像并查集，其实不是
+	// 块中有x无y时，x要改成y，这三个信息才体现作用
+	// 绝不会向上跳跃多次才能找到根编号，不是并查集
 	public static int[] idxrt = new int[MAXN];
 	public static int[][] valrt = new int[MAXB][MAXN];
 	public static int[][] rtval = new int[MAXB][MAXN];

From de074b793eec32ccf007815f11573d9f0b84931a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 17:29:36 +0800
Subject: [PATCH 1138/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 10 +++++-----
 src/class174/Code01_FutureDiary2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 59e724de7..26baea823 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -62,7 +62,7 @@ public static void build(int b) {
 	}
 
 	// 序列第b块中，有些位置的值已经改了，让改动写入arr
-	public static void down(int b) {
+	public static void writeArray(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
 			arr[i] = rtval[b][idxrt[i]];
 		}
@@ -70,7 +70,7 @@ public static void down(int b) {
 
 	// 序列[l..r]范围上，目前既有x又有y，把所有x改成y
 	public static void innerUpdate(int l, int r, int x, int y) {
-		down(bi[l]);
+		writeArray(bi[l]);
 		for (int i = l; i <= r; i++) {
 			if (arr[i] == x) {
 				sum1[bi[i]][bi[x]]--;
@@ -149,11 +149,11 @@ public static int query(int l, int r, int k) {
 		boolean inner = bi[l] == bi[r];
 		// 建立散块的词频统计
 		if (inner) {
-			down(bi[l]);
+			writeArray(bi[l]);
 			addCnt(l, r);
 		} else {
-			down(bi[l]);
-			down(bi[r]);
+			writeArray(bi[l]);
+			writeArray(bi[r]);
 			addCnt(l, br[bi[l]]);
 			addCnt(bl[bi[r]], r);
 		}
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 481717f68..982d11c03 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -66,14 +66,14 @@
 //    }
 //}
 //
-//void down(int b) {
+//void writeArray(int b) {
 //    for (int i = bl[b]; i <= br[b]; i++) {
 //        arr[i] = rtval[b][idxrt[i]];
 //    }
 //}
 //
 //void innerUpdate(int l, int r, int x, int y) {
-//    down(bi[l]);
+//    writeArray(bi[l]);
 //    for (int i = l; i <= r; i++) {
 //        if (arr[i] == x) {
 //            sum1[bi[i]][bi[x]]--;
@@ -146,11 +146,11 @@
 //    int ans = 0;
 //    bool inner = bi[l] == bi[r];
 //    if (inner) {
-//        down(bi[l]);
+//        writeArray(bi[l]);
 //        addCnt(l, r);
 //    } else {
-//        down(bi[l]);
-//        down(bi[r]);
+//        writeArray(bi[l]);
+//        writeArray(bi[r]);
 //        addCnt(l, br[bi[l]]);
 //        addCnt(bl[bi[r]], r);
 //    }

From 775dc59455828ecd2d2d84e3f0e493e1949effc2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 17:30:45 +0800
Subject: [PATCH 1139/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 26baea823..618c05426 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -83,7 +83,7 @@ public static void innerUpdate(int l, int r, int x, int y) {
 		build(bi[l]);
 	}
 
-	// 序列第b块中，目前没有y这个数值，把块中所有的x改成y
+	// 序列第b块中，有x无y，把块中所有的x改成y
 	public static void xtoy(int b, int x, int y) {
 		valrt[b][y] = valrt[b][x];
 		rtval[b][valrt[b][x]] = y;

From 83ee1c73437d82095f4a69d5f290cb491860e4ed Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 17:31:37 +0800
Subject: [PATCH 1140/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 618c05426..973e0fc18 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -31,8 +31,6 @@ public class Code01_FutureDiary1 {
 	// idxrt[i]表示下标i，在归属的块中，对应的根编号
 	// valrt[b][v]表示序列块b中的数值v，对应的根编号
 	// rtval[b][i]表示序列块b中的根编号i，对应的数值
-	// 块中有x无y时，x要改成y，这三个信息才体现作用
-	// 绝不会向上跳跃多次才能找到根编号，不是并查集
 	public static int[] idxrt = new int[MAXN];
 	public static int[][] valrt = new int[MAXB][MAXN];
 	public static int[][] rtval = new int[MAXB][MAXN];

From 6d72c247ea1fa4e954272f347ffff6609af7f062 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 17:36:14 +0800
Subject: [PATCH 1141/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 973e0fc18..dd96a5b58 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -35,10 +35,10 @@ public class Code01_FutureDiary1 {
 	public static int[][] valrt = new int[MAXB][MAXN];
 	public static int[][] rtval = new int[MAXB][MAXN];
 
-	// sum1[b][i]表示前b个序列块中，来自值域块i的数字有几个
-	// sum2[b][v]表示前b个序列块中，数字v有几个
-	// cnt1[i]表示遍历散块，统计值域块i的数字有几个
-	// cnt2[v]表示遍历散块，统计数字v有几个
+	// sum1[k][b]表示前k个序列块中，第b块个值域块的数字有几个
+	// sum2[k][v]表示前k个序列块中，数字v有几个
+	// cnt1[b]表示遍历散块之后，第b块个值域块的数字有几个
+	// cnt2[v]表示遍历散块之后，数字v有几个
 	public static int[][] sum1 = new int[MAXB][MAXB];
 	public static int[][] sum2 = new int[MAXB][MAXN];
 	public static int[] cnt1 = new int[MAXB];

From b14e148d369ba89a430682693fe6d0bf5e2369ef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 17:37:56 +0800
Subject: [PATCH 1142/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index dd96a5b58..9a867cc47 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -66,7 +66,7 @@ public static void writeArray(int b) {
 		}
 	}
 
-	// 序列[l..r]范围上，目前既有x又有y，把所有x改成y
+	// 序列[l..r]范围上，有x有y，把所有x改成y
 	public static void innerUpdate(int l, int r, int x, int y) {
 		writeArray(bi[l]);
 		for (int i = l; i <= r; i++) {
@@ -81,7 +81,7 @@ public static void innerUpdate(int l, int r, int x, int y) {
 		build(bi[l]);
 	}
 
-	// 序列第b块中，有x无y，把块中所有的x改成y
+	// 序列第b块中，有x无y，把所有x改成y
 	public static void xtoy(int b, int x, int y) {
 		valrt[b][y] = valrt[b][x];
 		rtval[b][valrt[b][x]] = y;

From 62c3043951b46609431a7da873252bf969307527 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 18:13:15 +0800
Subject: [PATCH 1143/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 +-
 src/class174/Code01_FutureDiary2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 9a867cc47..8966008b3 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -190,7 +190,7 @@ public static int query(int l, int r, int k) {
 	}
 
 	public static void prepare() {
-		blen = (int) Math.sqrt(n);
+		blen = 300;
 		bnum = (n + blen - 1) / blen;
 		// i一定要枚举[1, MAXN)
 		// 因为不仅序列要分块，值域也要分块
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 982d11c03..0eae7997b 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -184,7 +184,7 @@
 //}
 //
 //void prepare() {
-//    blen = (int)sqrt(n);
+//    blen = 300;
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i < MAXN; i++) {
 //        bi[i] = (i - 1) / blen + 1;

From 6ad7cf7d38b0156f4d791cdcbbdae064d2193afe Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 19:52:35 +0800
Subject: [PATCH 1144/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 32 +++++++++++++--------------
 src/class174/Code01_FutureDiary2.java | 24 ++++++++++----------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 8966008b3..e9ac65fdb 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -28,12 +28,12 @@ public class Code01_FutureDiary1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
-	// idxrt[i]表示下标i，在归属的块中，对应的根编号
-	// valrt[b][v]表示序列块b中的数值v，对应的根编号
-	// rtval[b][i]表示序列块b中的根编号i，对应的数值
-	public static int[] idxrt = new int[MAXN];
-	public static int[][] valrt = new int[MAXB][MAXN];
-	public static int[][] rtval = new int[MAXB][MAXN];
+	// idxset[i]表示下标i，在归属的块中，所属集合的编号
+	// valset[b][v]表示序列块b中的数值v，所属集合的编号
+	// setval[b][s]表示序列块b中的集合s，对应的数值
+	public static int[] idxset = new int[MAXN];
+	public static int[][] valset = new int[MAXB][MAXN];
+	public static int[][] setval = new int[MAXB][MAXN];
 
 	// sum1[k][b]表示前k个序列块中，第b块个值域块的数字有几个
 	// sum2[k][v]表示前k个序列块中，数字v有几个
@@ -44,25 +44,25 @@ public class Code01_FutureDiary1 {
 	public static int[] cnt1 = new int[MAXB];
 	public static int[] cnt2 = new int[MAXN];
 
-	// 序列第b块中，根据arr中的值建立起，idxrt、valrt[b]、rtval[b]
+	// 序列第b块中，根据arr中的值建立起，idxset、valset[b]、setval[b]
 	public static void build(int b) {
 		for (int i = 1; i <= blen; i++) {
-			valrt[b][rtval[b][i]] = 0;
+			valset[b][setval[b][i]] = 0;
 		}
 		for (int i = bl[b], cnt = 0; i <= br[b]; i++) {
-			if (valrt[b][arr[i]] == 0) {
+			if (valset[b][arr[i]] == 0) {
 				cnt++;
-				valrt[b][arr[i]] = cnt;
-				rtval[b][cnt] = arr[i];
+				valset[b][arr[i]] = cnt;
+				setval[b][cnt] = arr[i];
 			}
-			idxrt[i] = valrt[b][arr[i]];
+			idxset[i] = valset[b][arr[i]];
 		}
 	}
 
 	// 序列第b块中，有些位置的值已经改了，让改动写入arr
 	public static void writeArray(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
-			arr[i] = rtval[b][idxrt[i]];
+			arr[i] = setval[b][idxset[i]];
 		}
 	}
 
@@ -83,9 +83,9 @@ public static void innerUpdate(int l, int r, int x, int y) {
 
 	// 序列第b块中，有x无y，把所有x改成y
 	public static void xtoy(int b, int x, int y) {
-		valrt[b][y] = valrt[b][x];
-		rtval[b][valrt[b][x]] = y;
-		valrt[b][x] = 0;
+		valset[b][y] = valset[b][x];
+		setval[b][valset[b][x]] = y;
+		valset[b][x] = 0;
 	}
 
 	public static void update(int l, int r, int x, int y) {
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index 0eae7997b..e899da892 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -42,9 +42,9 @@
 //int bl[MAXB];
 //int br[MAXB];
 //
-//int idxrt[MAXN];
-//int valrt[MAXB][MAXN];
-//int rtval[MAXB][MAXN];
+//int idxset[MAXN];
+//int valset[MAXB][MAXN];
+//int setval[MAXB][MAXN];
 //
 //int sum1[MAXB][MAXB];
 //int sum2[MAXB][MAXN];
@@ -53,22 +53,22 @@
 //
 //void build(int b) {
 //    for (int i = 1; i <= blen; i++) {
-//        valrt[b][rtval[b][i]] = 0;
+//        valset[b][setval[b][i]] = 0;
 //    }
 //    int cnt = 0;
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        if (valrt[b][arr[i]] == 0) {
+//        if (valset[b][arr[i]] == 0) {
 //            cnt++;
-//            valrt[b][arr[i]] = cnt;
-//            rtval[b][cnt] = arr[i];
+//            valset[b][arr[i]] = cnt;
+//            setval[b][cnt] = arr[i];
 //        }
-//        idxrt[i] = valrt[b][arr[i]];
+//        idxset[i] = valset[b][arr[i]];
 //    }
 //}
 //
 //void writeArray(int b) {
 //    for (int i = bl[b]; i <= br[b]; i++) {
-//        arr[i] = rtval[b][idxrt[i]];
+//        arr[i] = setval[b][idxset[i]];
 //    }
 //}
 //
@@ -87,9 +87,9 @@
 //}
 //
 //void xtoy(int b, int x, int y) {
-//    valrt[b][y] = valrt[b][x];
-//    rtval[b][valrt[b][x]] = y;
-//    valrt[b][x] = 0;
+//    valset[b][y] = valset[b][x];
+//    setval[b][valset[b][x]] = y;
+//    valset[b][x] = 0;
 //}
 //
 //void update(int l, int r, int x, int y) {

From 76169825cb9cb561542e94b49b3c006525704999 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 20:13:07 +0800
Subject: [PATCH 1145/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 40 +++++++++++++--------------
 src/class174/Code01_FutureDiary2.java | 33 +++++++++++-----------
 2 files changed, 36 insertions(+), 37 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index e9ac65fdb..d61a1c12b 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -28,8 +28,8 @@ public class Code01_FutureDiary1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
-	// idxset[i]表示下标i，在归属的块中，所属集合的编号
-	// valset[b][v]表示序列块b中的数值v，所属集合的编号
+	// idxset[i]表示下标i，在归属的块中，来自哪个集合
+	// valset[b][v]表示序列块b中的数值v，来自哪个集合
 	// setval[b][s]表示序列块b中的集合s，对应的数值
 	public static int[] idxset = new int[MAXN];
 	public static int[][] valset = new int[MAXB][MAXN];
@@ -49,18 +49,25 @@ public static void build(int b) {
 		for (int i = 1; i <= blen; i++) {
 			valset[b][setval[b][i]] = 0;
 		}
-		for (int i = bl[b], cnt = 0; i <= br[b]; i++) {
+		for (int i = bl[b], s = 0; i <= br[b]; i++) {
 			if (valset[b][arr[i]] == 0) {
-				cnt++;
-				valset[b][arr[i]] = cnt;
-				setval[b][cnt] = arr[i];
+				s++;
+				valset[b][arr[i]] = s;
+				setval[b][s] = arr[i];
 			}
 			idxset[i] = valset[b][arr[i]];
 		}
 	}
 
-	// 序列第b块中，有些位置的值已经改了，让改动写入arr
-	public static void writeArray(int b) {
+	// 命中了整块修改有x无y的情况，序列第b块中，把所有x改成y
+	public static void lazy(int b, int x, int y) {
+		valset[b][y] = valset[b][x];
+		setval[b][valset[b][x]] = y;
+		valset[b][x] = 0;
+	}
+
+	// 之前的整块修改有x无y的情况，导致序列第b块中，有些值改动了，把改动写入arr
+	public static void down(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
 			arr[i] = setval[b][idxset[i]];
 		}
@@ -68,7 +75,7 @@ public static void writeArray(int b) {
 
 	// 序列[l..r]范围上，有x有y，把所有x改成y
 	public static void innerUpdate(int l, int r, int x, int y) {
-		writeArray(bi[l]);
+		down(bi[l]);
 		for (int i = l; i <= r; i++) {
 			if (arr[i] == x) {
 				sum1[bi[i]][bi[x]]--;
@@ -81,13 +88,6 @@ public static void innerUpdate(int l, int r, int x, int y) {
 		build(bi[l]);
 	}
 
-	// 序列第b块中，有x无y，把所有x改成y
-	public static void xtoy(int b, int x, int y) {
-		valset[b][y] = valset[b][x];
-		setval[b][valset[b][x]] = y;
-		valset[b][x] = 0;
-	}
-
 	public static void update(int l, int r, int x, int y) {
 		// 必要的剪枝
 		if (x == y || (sum2[bi[r]][x] - sum2[bi[l] - 1][x] == 0)) {
@@ -115,7 +115,7 @@ public static void update(int l, int r, int x, int y) {
 						sum1[b][bi[x]] -= sum2[b][x];
 						sum2[b][y] += sum2[b][x];
 						sum2[b][x] = 0;
-						xtoy(b, x, y);
+						lazy(b, x, y);
 					}
 				}
 			}
@@ -147,11 +147,11 @@ public static int query(int l, int r, int k) {
 		boolean inner = bi[l] == bi[r];
 		// 建立散块的词频统计
 		if (inner) {
-			writeArray(bi[l]);
+			down(bi[l]);
 			addCnt(l, r);
 		} else {
-			writeArray(bi[l]);
-			writeArray(bi[r]);
+			down(bi[l]);
+			down(bi[r]);
 			addCnt(l, br[bi[l]]);
 			addCnt(bl[bi[r]], r);
 		}
diff --git a/src/class174/Code01_FutureDiary2.java b/src/class174/Code01_FutureDiary2.java
index e899da892..ca6b37748 100644
--- a/src/class174/Code01_FutureDiary2.java
+++ b/src/class174/Code01_FutureDiary2.java
@@ -55,25 +55,30 @@
 //    for (int i = 1; i <= blen; i++) {
 //        valset[b][setval[b][i]] = 0;
 //    }
-//    int cnt = 0;
-//    for (int i = bl[b]; i <= br[b]; i++) {
+//    for (int i = bl[b], s = 0; i <= br[b]; i++) {
 //        if (valset[b][arr[i]] == 0) {
-//            cnt++;
-//            valset[b][arr[i]] = cnt;
-//            setval[b][cnt] = arr[i];
+//            s++;
+//            valset[b][arr[i]] = s;
+//            setval[b][s] = arr[i];
 //        }
 //        idxset[i] = valset[b][arr[i]];
 //    }
 //}
 //
-//void writeArray(int b) {
+//void lazy(int b, int x, int y) {
+//    valset[b][y] = valset[b][x];
+//    setval[b][valset[b][x]] = y;
+//    valset[b][x] = 0;
+//}
+//
+//void down(int b) {
 //    for (int i = bl[b]; i <= br[b]; i++) {
 //        arr[i] = setval[b][idxset[i]];
 //    }
 //}
 //
 //void innerUpdate(int l, int r, int x, int y) {
-//    writeArray(bi[l]);
+//    down(bi[l]);
 //    for (int i = l; i <= r; i++) {
 //        if (arr[i] == x) {
 //            sum1[bi[i]][bi[x]]--;
@@ -86,12 +91,6 @@
 //    build(bi[l]);
 //}
 //
-//void xtoy(int b, int x, int y) {
-//    valset[b][y] = valset[b][x];
-//    setval[b][valset[b][x]] = y;
-//    valset[b][x] = 0;
-//}
-//
 //void update(int l, int r, int x, int y) {
 //    if (x == y || (sum2[bi[r]][x] - sum2[bi[l] - 1][x] == 0)) {
 //        return;
@@ -116,7 +115,7 @@
 //                    sum1[b][bi[x]] -= sum2[b][x];
 //                    sum2[b][y] += sum2[b][x];
 //                    sum2[b][x] = 0;
-//                    xtoy(b, x, y);
+//                    lazy(b, x, y);
 //                }
 //            }
 //        }
@@ -146,11 +145,11 @@
 //    int ans = 0;
 //    bool inner = bi[l] == bi[r];
 //    if (inner) {
-//        writeArray(bi[l]);
+//        down(bi[l]);
 //        addCnt(l, r);
 //    } else {
-//        writeArray(bi[l]);
-//        writeArray(bi[r]);
+//        down(bi[l]);
+//        down(bi[r]);
 //        addCnt(l, br[bi[l]]);
 //        addCnt(bl[bi[r]], r);
 //    }

From aa550f0a5257fcf4f87a23dbe8188b5b6f9711f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 20:15:20 +0800
Subject: [PATCH 1146/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index d61a1c12b..60d3b9809 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -59,14 +59,14 @@ public static void build(int b) {
 		}
 	}
 
-	// 命中了整块修改有x无y的情况，序列第b块中，把所有x改成y
+	// 命中了整块修改有x无y的情况，序列第b块中所有x改成y
 	public static void lazy(int b, int x, int y) {
 		valset[b][y] = valset[b][x];
 		setval[b][valset[b][x]] = y;
 		valset[b][x] = 0;
 	}
 
-	// 之前的整块修改有x无y的情况，导致序列第b块中，有些值改动了，把改动写入arr
+	// 之前的整块修改有x无y的情况，导致序列第b块中有些值改动了，把改动写入arr
 	public static void down(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
 			arr[i] = setval[b][idxset[i]];

From ab43e731353088c862981b6522ff652af65ba0a8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 20:25:57 +0800
Subject: [PATCH 1147/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 9 ++++++++-
 1 file changed, 8 insertions(+), 1 deletion(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 60d3b9809..c7d0fef24 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -44,11 +44,18 @@ public class Code01_FutureDiary1 {
 	public static int[] cnt1 = new int[MAXB];
 	public static int[] cnt2 = new int[MAXN];
 
-	// 序列第b块中，根据arr中的值建立起，idxset、valset[b]、setval[b]
+	// 序列第b块中，根据当前arr中的值，重建集合
 	public static void build(int b) {
+		// 根据arr中的值重建集合，需要放弃之前的信息
+		// 可是数值范围很大，不能枚举数值去清空 valset
+		// 注意到，一个块里集合的数量 <= 块长
+		// 所以根据 setval[b][s]，得到每个集合之前的对应值v
+		// 然后 valset[b][v] = 0，让块内之前的每个值，不再挂靠任何集合
+		// 这样可以避免数值的枚举，做到快速清空 valset
 		for (int i = 1; i <= blen; i++) {
 			valset[b][setval[b][i]] = 0;
 		}
+		// 重建集合的过程
 		for (int i = bl[b], s = 0; i <= br[b]; i++) {
 			if (valset[b][arr[i]] == 0) {
 				s++;

From dd5472f2d7640c0c8e4c19a6c160d858a2ecebba Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 20:27:57 +0800
Subject: [PATCH 1148/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index c7d0fef24..7246152d7 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -66,14 +66,14 @@ public static void build(int b) {
 		}
 	}
 
-	// 命中了整块修改有x无y的情况，序列第b块中所有x改成y
+	// 命中了整块修改，有x无y的情况，序列第b块中所有x改成y
 	public static void lazy(int b, int x, int y) {
 		valset[b][y] = valset[b][x];
 		setval[b][valset[b][x]] = y;
 		valset[b][x] = 0;
 	}
 
-	// 之前的整块修改有x无y的情况，导致序列第b块中有些值改动了，把改动写入arr
+	// 之前命中了整块修改，有x无y的情况，导致序列第b块中有些值改动了，把改动写入arr
 	public static void down(int b) {
 		for (int i = bl[b]; i <= br[b]; i++) {
 			arr[i] = setval[b][idxset[i]];

From a70bbec6a0a5d11bbe21b6df35eb22f7f2740357 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 20:31:10 +0800
Subject: [PATCH 1149/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 7246152d7..7ada9fc25 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -49,7 +49,7 @@ public static void build(int b) {
 		// 根据arr中的值重建集合，需要放弃之前的信息
 		// 可是数值范围很大，不能枚举数值去清空 valset
 		// 注意到，一个块里集合的数量 <= 块长
-		// 所以根据 setval[b][s]，得到每个集合之前的对应值v
+		// 所以根据 setval[b][s]，可以得到每个集合之前的对应值v
 		// 然后 valset[b][v] = 0，让块内之前的每个值，不再挂靠任何集合
 		// 这样可以避免数值的枚举，做到快速清空 valset
 		for (int i = 1; i <= blen; i++) {

From 68c16d814e6a581357338fc78825b738325300e7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 20:35:03 +0800
Subject: [PATCH 1150/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 7ada9fc25..1d4d3bfad 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -23,6 +23,10 @@ public class Code01_FutureDiary1 {
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 
+	// bi[i]可以查询下标i来自哪个序列块
+	// bi[v]也可查询数字v来自哪个值域块
+	// bl[i]表示下标第i块的左边界
+	// br[i]表示下标第i块的右边界
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
@@ -201,13 +205,9 @@ public static void prepare() {
 		bnum = (n + blen - 1) / blen;
 		// i一定要枚举[1, MAXN)
 		// 因为不仅序列要分块，值域也要分块
-		// bi[i]可以查询下标i来自哪个序列块
-		// bi[v]也可查询数字v来自哪个值域块
 		for (int i = 1; i < MAXN; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		// bl[i]表示下标第i块的左边界
-		// br[i]表示下标第i块的右边界
 		// bl、br 仅用于序列分块
 		for (int i = 1; i <= bnum; i++) {
 			bl[i] = (i - 1) * blen + 1;

From 85cd121f0fb6691144935f227a12828edcdad9e7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 12 Jul 2025 22:20:41 +0800
Subject: [PATCH 1151/1712] modify code

---
 src/class174/Code01_FutureDiary1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class174/Code01_FutureDiary1.java b/src/class174/Code01_FutureDiary1.java
index 1d4d3bfad..18ee82619 100644
--- a/src/class174/Code01_FutureDiary1.java
+++ b/src/class174/Code01_FutureDiary1.java
@@ -23,6 +23,8 @@ public class Code01_FutureDiary1 {
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 
+	// blen既表示序列块长，也表示值域块长
+	// bnum只表示序列块的数量
 	// bi[i]可以查询下标i来自哪个序列块
 	// bi[v]也可查询数字v来自哪个值域块
 	// bl[i]表示下标第i块的左边界

From e93e23ee8c114961530f453b62d8797ff4836a11 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 13 Jul 2025 11:51:26 +0800
Subject: [PATCH 1152/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 77 +++++++++++++----------------
 src/class174/Code02_MagicGirl2.java | 52 +++++++++----------
 2 files changed, 60 insertions(+), 69 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index fb67d2dd5..6f6f135e0 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -27,17 +27,18 @@ public class Code02_MagicGirl1 {
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
-	public static int[] pos = new int[MAXN];
-
 	public static int[] op = new int[MAXN];
 	public static int[] x = new int[MAXN];
 	public static int[] y = new int[MAXN];
 	public static int[] v = new int[MAXN];
 
-	public static int[] arrq = new int[MAXN];
+	public static int[] pos = new int[MAXN];
+	public static int[] que = new int[MAXN];
+	public static int cntp;
+	public static int cntq;
+
 	public static int[] cntv = new int[MAXB];
 	public static int[] help = new int[MAXN];
-	public static int siz;
 
 	public static int[] last = new int[MAXN];
 	public static int[] next = new int[MAXN];
@@ -60,48 +61,31 @@ public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 		len[i] += rlen;
 	}
 
-	// 根据arr[pos[i]]的值，对pos[l..r]进行双指针快排
-	public static void quickSort(int l, int r) {
-		if (l >= r) return;
-		int i = l, j = r, pivot = arr[pos[(l + r) >> 1]], tmp;
-		while (i <= j) {
-			while (arr[pos[i]] < pivot) i++;
-			while (arr[pos[j]] > pivot) j--;
-			if (i <= j) {
-				tmp = pos[i]; pos[i] = pos[j]; pos[j] = tmp;
-				i++; j--;
-			}
-		}
-		quickSort(l, j);
-		quickSort(i, r);
-	}
-
-	// 根据查询任务的v值，对查询任务的编号进行基数排序
-	public static void radixSort() {
+	public static void radix(int[] idx, int[] val, int siz) {
 		Arrays.fill(cntv, 0);
-		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] & OFFSET]++;
+		for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;
 		for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
-		for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] & OFFSET]--] = arrq[i];
-		for (int i = 1; i <= siz; i++) arrq[i] = help[i];
+		for (int i = siz; i >= 1; i--) help[cntv[val[idx[i]] & OFFSET]--] = idx[i];
+		for (int i = 1; i <= siz; i++) idx[i] = help[i];
 		Arrays.fill(cntv, 0);
-		for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW]++;
+		for (int i = 1; i <= siz; i++) cntv[val[idx[i]] >> POW]++;
 		for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
-		for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW]--] = arrq[i];
-		for (int i = 1; i <= siz; i++) arrq[i] = help[i];
+		for (int i = siz; i >= 1; i--) help[cntv[val[idx[i]] >> POW]--] = idx[i];
+		for (int i = 1; i <= siz; i++) idx[i] = help[i];
 	}
 
 	public static void calc(int l, int r) {
-		radixSort();
+		radix(que, v, cntq);
 		for (int i = l; i <= r; i++) {
 			last[i] = i - 1;
 			next[i] = i + 1;
 		}
 		int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
 		int k = 1;
-		for (int i = l, idx; i <= r; i++) {
-			idx = pos[i];
-			for (; k <= siz && v[arrq[k]] < arr[idx]; k++) {
-				mergeAns(arrq[k], rpre, rsuf, rlen, rans);
+		for (int i = 1; i <= cntp; i++) {
+			int idx = pos[i];
+			for (; k <= cntq && v[que[k]] < arr[idx]; k++) {
+				mergeAns(que[k], rpre, rsuf, rlen, rans);
 			}
 			if (last[idx] == l - 1) {
 				rpre += next[idx] - idx;
@@ -113,10 +97,10 @@ public static void calc(int l, int r) {
 			last[next[idx]] = last[idx];
 			next[last[idx]] = next[idx];
 		}
-		for (; k <= siz; k++) {
-			mergeAns(arrq[k], rpre, rsuf, rlen, rans);
+		for (; k <= cntq; k++) {
+			mergeAns(que[k], rpre, rsuf, rlen, rans);
 		}
-		siz = 0;
+		cntq = 0;
 	}
 
 	public static void update(int qi, int l, int r) {
@@ -125,18 +109,22 @@ public static void update(int qi, int l, int r) {
 			calc(l, r);
 			arr[jobi] = jobv;
 			int find = 0;
-			for (int i = l; i <= r; i++) {
+			for (int i = 1; i <= cntp; i++) {
 				if (pos[i] == jobi) {
 					find = i;
 					break;
 				}
 			}
 			int tmp;
-			for (int i = find; i < r && arr[pos[i]] > arr[pos[i + 1]]; i++) {
-				tmp = pos[i]; pos[i] = pos[i + 1]; pos[i + 1] = tmp;
+			for (int i = find; i < cntp && arr[pos[i]] > arr[pos[i + 1]]; i++) {
+				tmp = pos[i];
+				pos[i] = pos[i + 1];
+				pos[i + 1] = tmp;
 			}
-			for (int i = find; i > l && arr[pos[i - 1]] > arr[pos[i]]; i--) {
-				tmp = pos[i - 1]; pos[i - 1] = pos[i]; pos[i] = tmp;
+			for (int i = find; i > 1 && arr[pos[i - 1]] > arr[pos[i]]; i--) {
+				tmp = pos[i - 1];
+				pos[i - 1] = pos[i];
+				pos[i] = tmp;
 			}
 		}
 	}
@@ -144,7 +132,7 @@ public static void update(int qi, int l, int r) {
 	public static void query(int qi, int l, int r) {
 		int jobl = x[qi], jobr = y[qi], jobv = v[qi];
 		if (jobl <= l && r <= jobr) {
-			arrq[++siz] = qi;
+			que[++cntq] = qi;
 		} else {
 			for (int i = Math.max(jobl, l); i <= Math.min(jobr, r); i++) {
 				if (arr[i] <= jobv) {
@@ -157,10 +145,11 @@ public static void query(int qi, int l, int r) {
 	}
 
 	public static void compute(int l, int r) {
+		cntp = 0;
 		for (int i = l; i <= r; i++) {
-			pos[i] = i;
+			pos[++cntp] = i;
 		}
-		quickSort(l, r);
+		radix(pos, arr, cntp);
 		for (int qi = 1; qi <= m; qi++) {
 			if (op[qi] == 1) {
 				update(qi, l, r);
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 4cdad00cc..c3d11119c 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -21,17 +21,18 @@
 //int n, m;
 //
 //int arr[MAXN];
-//int pos[MAXN];
-//
 //int op[MAXN];
 //int x[MAXN];
 //int y[MAXN];
 //int v[MAXN];
 //
-//int arrq[MAXN];
+//int pos[MAXN];
+//int que[MAXN];
+//int cntp;
+//int cntq;
+//
 //int cntv[MAXB];
 //int help[MAXN];
-//int siz;
 //
 //int lst[MAXN];
 //int nxt[MAXN];
@@ -54,31 +55,31 @@
 //    len[i] += rlen;
 //}
 //
-//inline void radixSort() {
+//inline void radix(int* idx, int* val, int siz) {
 //    fill(cntv, cntv + MAXB, 0);
-//    for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] & OFFSET]++;
+//    for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;
 //    for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
-//    for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] & OFFSET]--] = arrq[i];
-//    for (int i = 1; i <= siz; i++) arrq[i] = help[i];
+//    for (int i = siz; i >= 1; i--) help[cntv[val[idx[i]] & OFFSET]--] = idx[i];
+//    for (int i = 1; i <= siz; i++) idx[i] = help[i];
 //    fill(cntv, cntv + MAXB, 0);
-//    for (int i = 1; i <= siz; i++) cntv[v[arrq[i]] >> POW]++;
+//    for (int i = 1; i <= siz; i++) cntv[val[idx[i]] >> POW]++;
 //    for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
-//    for (int i = siz; i >= 1; i--) help[cntv[v[arrq[i]] >> POW]--] = arrq[i];
-//    for (int i = 1; i <= siz; i++) arrq[i] = help[i];
+//    for (int i = siz; i >= 1; i--) help[cntv[val[idx[i]] >> POW]--] = idx[i];
+//    for (int i = 1; i <= siz; i++) idx[i] = help[i];
 //}
 //
 //void calc(int l, int r) {
-//    radixSort();
+//    radix(que, v, cntq);
 //    for (int i = l; i <= r; i++) {
 //        lst[i] = i - 1;
 //        nxt[i] = i + 1;
 //    }
 //    int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
 //    int k = 1;
-//    for (int i = l, idx; i <= r; i++) {
-//        idx = pos[i];
-//        for(; k <= siz && v[arrq[k]] < arr[idx]; k++) {
-//            mergeAns(arrq[k], rpre, rsuf, rlen, rans);
+//    for (int i = 1; i <= cntp; i++) {
+//        int idx = pos[i];
+//        for(; k <= cntq && v[que[k]] < arr[idx]; k++) {
+//            mergeAns(que[k], rpre, rsuf, rlen, rans);
 //        }
 //        if (lst[idx] == l - 1) {
 //            rpre += nxt[idx] - idx;
@@ -90,10 +91,10 @@
 //        lst[nxt[idx]] = lst[idx];
 //        nxt[lst[idx]] = nxt[idx];
 //    }
-//    for(; k <= siz; k++) {
-//        mergeAns(arrq[k], rpre, rsuf, rlen, rans);
+//    for(; k <= cntq; k++) {
+//        mergeAns(que[k], rpre, rsuf, rlen, rans);
 //    }
-//    siz = 0;
+//    cntq = 0;
 //}
 //
 //inline void update(int qi, int l, int r) {
@@ -102,16 +103,16 @@
 //        calc(l, r);
 //        arr[jobi] = jobv;
 //        int find = 0;
-//        for (int i = l; i <= r; i++) {
+//        for (int i = 1; i <= cntp; i++) {
 //            if (pos[i] == jobi) {
 //                find = i;
 //                break;
 //            }
 //        }
-//        for (int i = find; i < r && arr[pos[i]] > arr[pos[i + 1]]; i++) {
+//        for (int i = find; i < cntp && arr[pos[i]] > arr[pos[i + 1]]; i++) {
 //            swap(pos[i], pos[i + 1]);
 //        }
-//        for (int i = find; i > l && arr[pos[i - 1]] > arr[pos[i]]; i--) {
+//        for (int i = find; i > 1 && arr[pos[i - 1]] > arr[pos[i]]; i--) {
 //            swap(pos[i - 1], pos[i]);
 //        }
 //    }
@@ -120,7 +121,7 @@
 //inline void query(int qi, int l, int r) {
 //    int jobl = x[qi], jobr = y[qi], jobv = v[qi];
 //    if (jobl <= l && r <= jobr) {
-//        arrq[++siz] = qi;
+//        que[++cntq] = qi;
 //    } else {
 //        for (int i = max(jobl, l); i <= min(jobr, r); i++) {
 //            if (arr[i] <= jobv) {
@@ -133,10 +134,11 @@
 //}
 //
 //void compute(int l, int r) {
+//    cntp = 0;
 //    for (int i = l; i <= r; i++) {
-//        pos[i] = i;
+//        pos[++cntp] = i;
 //    }
-//    sort(pos + l, pos + r + 1, [&](int a, int b) {return arr[a] < arr[b];});
+//    radix(pos, arr, cntp);
 //    for (int qi = 1; qi <= m; qi++) {
 //        if (op[qi] == 1) {
 //            update(qi, l, r);

From a21f318908b763b93e2ba7c8329529f74f24b617 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 14:29:13 +0800
Subject: [PATCH 1153/1712] modify code

---
 src/class174/Code04_Bridge1.java | 36 ++++++++++++++++----------------
 src/class174/Code04_Bridge2.java | 36 ++++++++++++++++----------------
 src/class174/Code05_Lcm1.java    | 27 ++++++++++++------------
 src/class174/Code05_Lcm2.java    | 27 ++++++++++++------------
 4 files changed, 62 insertions(+), 64 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index fffe7bbdd..872846f23 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -41,11 +41,11 @@ public class Code04_Bridge1 {
 	public static int[][] rollback = new int[MAXM][2];
 	public static int opsize = 0;
 
-	public static int[] arre = new int[MAXM];
+	public static int[] edge = new int[MAXM];
 	public static int[] change = new int[MAXM];
 	public static int[] unchange = new int[MAXM];
 
-	public static int[] arrq = new int[MAXQ];
+	public static int[] operate = new int[MAXQ];
 	public static int[] update = new int[MAXQ];
 	public static int[] query = new int[MAXQ];
 
@@ -76,13 +76,13 @@ public static void sort(int[] idx, int[] v, int l, int r) {
 	public static void merge(int l1, int r1, int l2, int r2) {
 		int i = 0;
 		while (l1 <= r1 && l2 <= r2) {
-			arre[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+			edge[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
 		}
 		while (l1 <= r1) {
-			arre[++i] = change[l1++];
+			edge[++i] = change[l1++];
 		}
 		while (l2 <= r2) {
-			arre[++i] = unchange[l2++];
+			edge[++i] = unchange[l2++];
 		}
 	}
 
@@ -129,19 +129,19 @@ public static void compute(int l, int r) {
 		Arrays.fill(vis, false);
 		int cntu = 0, cntq = 0;
 		for (int i = l; i <= r; i++) {
-			if (op[arrq[i]] == 1) {
-				vis[eid[arrq[i]]] = true;
-				update[++cntu] = arrq[i];
+			if (op[operate[i]] == 1) {
+				vis[eid[operate[i]]] = true;
+				update[++cntu] = operate[i];
 			} else {
-				query[++cntq] = arrq[i];
+				query[++cntq] = operate[i];
 			}
 		}
 		sort(query, car, 1, cntq);
 		int k = 1;
 		for (int i = 1; i <= cntq; i++) {
-			for (; k <= m && w[arre[k]] >= car[query[i]]; k++) {
-				if (!vis[arre[k]]) {
-					union(u[arre[k]], v[arre[k]]);
+			for (; k <= m && w[edge[k]] >= car[query[i]]; k++) {
+				if (!vis[edge[k]]) {
+					union(u[edge[k]], v[edge[k]]);
 				}
 			}
 			opsize = 0;
@@ -166,10 +166,10 @@ public static void compute(int l, int r) {
 		}
 		int siz1 = 0, siz2 = 0;
 		for (int i = 1; i <= m; i++) {
-			if (vis[arre[i]]) {
-				change[++siz1] = arre[i];
+			if (vis[edge[i]]) {
+				change[++siz1] = edge[i];
 			} else {
-				unchange[++siz2] = arre[i];
+				unchange[++siz2] = edge[i];
 			}
 		}
 		sort(change, w, 1, siz1);
@@ -188,12 +188,12 @@ public static void prepare() {
 		blen = Math.max(1, (int) Math.sqrt(q * log2(n)));
 		bnum = (q + blen - 1) / blen;
 		for (int i = 1; i <= m; i++) {
-			arre[i] = i;
+			edge[i] = i;
 		}
 		for (int i = 1; i <= q; i++) {
-			arrq[i] = i;
+			operate[i] = i;
 		}
-		sort(arre, w, 1, m);
+		sort(edge, w, 1, m);
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index e964f3a74..b6b03dd8f 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -38,11 +38,11 @@
 //int rollback[MAXM][2];
 //int opsize = 0;
 //
-//int arre[MAXM];
+//int edge[MAXM];
 //int change[MAXM];
 //int unchange[MAXM];
 //
-//int arrq[MAXQ];
+//int operate[MAXQ];
 //int update[MAXQ];
 //int query[MAXQ];
 //
@@ -54,13 +54,13 @@
 //void merge(int l1, int r1, int l2, int r2) {
 //    int i = 0;
 //    while (l1 <= r1 && l2 <= r2) {
-//        arre[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
+//        edge[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
 //    }
 //    while (l1 <= r1) {
-//        arre[++i] = change[l1++];
+//        edge[++i] = change[l1++];
 //    }
 //    while (l2 <= r2) {
-//        arre[++i] = unchange[l2++];
+//        edge[++i] = unchange[l2++];
 //    }
 //}
 //
@@ -106,19 +106,19 @@
 //    fill(vis + 1, vis + m + 1, false);
 //    int cntu = 0, cntq = 0;
 //    for (int i = l; i <= r; i++) {
-//        if (op[arrq[i]] == 1) {
-//            vis[eid[arrq[i]]] = true;
-//            update[++cntu] = arrq[i];
+//        if (op[operate[i]] == 1) {
+//            vis[eid[operate[i]]] = true;
+//            update[++cntu] = operate[i];
 //        } else {
-//            query[++cntq] = arrq[i];
+//            query[++cntq] = operate[i];
 //        }
 //    }
 //    sort(query + 1, query + cntq + 1, [&](int x, int y) { return car[x] > car[y]; });
 //    int k = 1;
 //    for (int i = 1; i <= cntq; i++) {
-//        for (; k <= m && w[arre[k]] >= car[query[i]]; k++) {
-//            if (!vis[arre[k]]) {
-//                Union(u[arre[k]], v[arre[k]]);
+//        for (; k <= m && w[edge[k]] >= car[query[i]]; k++) {
+//            if (!vis[edge[k]]) {
+//                Union(u[edge[k]], v[edge[k]]);
 //            }
 //        }
 //        opsize = 0;
@@ -143,10 +143,10 @@
 //    }
 //    int siz1 = 0, siz2 = 0;
 //    for (int i = 1; i <= m; i++) {
-//        if (vis[arre[i]]) {
-//            change[++siz1] = arre[i];
+//        if (vis[edge[i]]) {
+//            change[++siz1] = edge[i];
 //        } else {
-//            unchange[++siz2] = arre[i];
+//            unchange[++siz2] = edge[i];
 //        }
 //    }
 //    sort(change + 1, change + siz1 + 1, [&](int x, int y) { return w[x] > w[y]; });
@@ -157,12 +157,12 @@
 //    blen = max(1, (int)sqrt(q * log2(n)));
 //    bnum = (q + blen - 1) / blen;
 //    for (int i = 1; i <= m; i++) {
-//        arre[i] = i;
+//        edge[i] = i;
 //    }
 //    for (int i = 1; i <= q; i++) {
-//        arrq[i] = i;
+//        operate[i] = i;
 //    }
-//    sort(arre + 1, arre + m + 1, [&](int x, int y) { return w[x] > w[y]; });
+//    sort(edge + 1, edge + m + 1, [&](int x, int y) { return w[x] > w[y]; });
 //}
 //
 //int main() {
diff --git a/src/class174/Code05_Lcm1.java b/src/class174/Code05_Lcm1.java
index 6cd909d2b..50a725271 100644
--- a/src/class174/Code05_Lcm1.java
+++ b/src/class174/Code05_Lcm1.java
@@ -35,8 +35,8 @@ public class Code05_Lcm1 {
 	public static int[] qb = new int[MAXQ];
 	public static int[] qid = new int[MAXQ];
 
-	public static int[] arre = new int[MAXM];
-	public static int[] arrq = new int[MAXQ];
+	public static int[] edge = new int[MAXM];
+	public static int[] ques = new int[MAXQ];
 
 	public static int[] cur = new int[MAXQ];
 	public static int cntq = 0;
@@ -122,25 +122,24 @@ public static void compute(int l, int r) {
 		cntq = 0;
 		for (int i = 1; i <= q; i++) {
 			// 保证每条询问只落入其中的一块
-			if (ea[arre[l]] <= qa[arrq[i]] && (r + 1 > m || qa[arrq[i]] < ea[arre[r + 1]])) {
-				cur[++cntq] = arrq[i];
+			if (ea[edge[l]] <= qa[ques[i]] && (r + 1 > m || qa[ques[i]] < ea[edge[r + 1]])) {
+				cur[++cntq] = ques[i];
 			}
 		}
 		if (cntq > 0) {
 			// 可以使用额外的数组，每块内部根据b进行排序
 			// 每次把新块归并进来，保证 1..l-1 范围根据b有序
 			// 可以省掉一个log的复杂度，本题不做这个优化也能通过，索性算了
-			sort(arre, eb, 1, l - 1);
+			sort(edge, eb, 1, l - 1);
 			int pos = 1;
 			for (int i = 1; i <= cntq; i++) {
-				for (int edge = arre[pos]; pos < l && eb[edge] <= qb[cur[i]]; pos++, edge = arre[pos]) {
-					union(eu[edge], ev[edge], ea[edge], eb[edge]);
+				for (; pos < l && eb[edge[pos]] <= qb[cur[i]]; pos++) {
+					union(eu[edge[pos]], ev[edge[pos]], ea[edge[pos]], eb[edge[pos]]);
 				}
 				opsize = 0;
 				for (int j = l; j <= r; j++) {
-					int edge = arre[j];
-					if (ea[edge] <= qa[cur[i]] && eb[edge] <= qb[cur[i]]) {
-						union(eu[edge], ev[edge], ea[edge], eb[edge]);
+					if (ea[edge[j]] <= qa[cur[i]] && eb[edge[j]] <= qb[cur[i]]) {
+						union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
 					}
 				}
 				ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
@@ -161,13 +160,13 @@ public static void prepare() {
 		blen = Math.max(1, (int) Math.sqrt(m * log2(n)));
 		bnum = (m + blen - 1) / blen;
 		for (int i = 1; i <= m; i++) {
-			arre[i] = i;
+			edge[i] = i;
 		}
 		for (int i = 1; i <= q; i++) {
-			arrq[i] = i;
+			ques[i] = i;
 		}
-		sort(arre, ea, 1, m);
-		sort(arrq, qb, 1, q);
+		sort(edge, ea, 1, m);
+		sort(ques, qb, 1, q);
 	}
 
 	public static void main(String[] args) throws IOException {
diff --git a/src/class174/Code05_Lcm2.java b/src/class174/Code05_Lcm2.java
index 7143c8ee6..80b7aee91 100644
--- a/src/class174/Code05_Lcm2.java
+++ b/src/class174/Code05_Lcm2.java
@@ -33,8 +33,8 @@
 //int qb[MAXQ];
 //int qid[MAXQ];
 //
-//int arre[MAXM];
-//int arrq[MAXQ];
+//int edge[MAXM];
+//int ques[MAXQ];
 //
 //int cur[MAXQ];
 //int cntq = 0;
@@ -102,22 +102,21 @@
 //    build();
 //    cntq = 0;
 //    for (int i = 1; i <= q; i++) {
-//        if (ea[arre[l]] <= qa[arrq[i]] && (r + 1 > m || qa[arrq[i]] < ea[arre[r + 1]])) {
-//            cur[++cntq] = arrq[i];
+//        if (ea[edge[l]] <= qa[ques[i]] && (r + 1 > m || qa[ques[i]] < ea[edge[r + 1]])) {
+//            cur[++cntq] = ques[i];
 //        }
 //    }
 //    if (cntq > 0) {
-//        sort(arre + 1, arre + l, [&](int x, int y) { return eb[x] < eb[y]; });
+//        sort(edge + 1, edge + l, [&](int x, int y) { return eb[x] < eb[y]; });
 //        int pos = 1;
 //        for (int i = 1; i <= cntq; i++) {
-//            for (int edge = arre[pos]; pos < l && eb[edge] <= qb[cur[i]]; pos++, edge = arre[pos]) {
-//                Union(eu[edge], ev[edge], ea[edge], eb[edge]);
+//            for (; pos < l && eb[edge[pos]] <= qb[cur[i]]; pos++) {
+//                Union(eu[edge[pos]], ev[edge[pos]], ea[edge[pos]], eb[edge[pos]]);
 //            }
 //            opsize = 0;
 //            for (int j = l; j <= r; j++) {
-//                int edge = arre[j];
-//                if (ea[edge] <= qa[cur[i]] && eb[edge] <= qb[cur[i]]) {
-//            	    Union(eu[edge], ev[edge], ea[edge], eb[edge]);
+//                if (ea[edge[j]] <= qa[cur[i]] && eb[edge[j]] <= qb[cur[i]]) {
+//            	      Union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
 //                }
 //            }
 //            ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
@@ -130,13 +129,13 @@
 //    blen = max(1, (int)sqrt(m * log2(n)));
 //    bnum = (m + blen - 1) / blen;
 //    for (int i = 1; i <= m; i++) {
-//        arre[i] = i;
+//        edge[i] = i;
 //    }
 //    for (int i = 1; i <= q; i++) {
-//        arrq[i] = i;
+//        ques[i] = i;
 //    }
-//    sort(arre + 1, arre + m + 1, [&](int x, int y) { return ea[x] < ea[y]; });
-//    sort(arrq + 1, arrq + q + 1, [&](int x, int y) { return qb[x] < qb[y]; });
+//    sort(edge + 1, edge + m + 1, [&](int x, int y) { return ea[x] < ea[y]; });
+//    sort(ques + 1, ques + q + 1, [&](int x, int y) { return qb[x] < qb[y]; });
 //}
 //
 //int main() {

From c7b291fba96fb72fc66f40996ed6860941c542fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 17:31:45 +0800
Subject: [PATCH 1154/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 33 +++++++++++++++++------------
 src/class174/Code02_MagicGirl2.java | 26 +++++++++++------------
 2 files changed, 33 insertions(+), 26 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 6f6f135e0..873459c2f 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -48,19 +48,10 @@ public class Code02_MagicGirl1 {
 	public static int[] len = new int[MAXN];
 	public static long[] ans = new long[MAXN];
 
-	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
-		ans[i] += rans + 1L * suf[i] * rpre;
-		if (pre[i] == len[i]) {
-			pre[i] += rpre;
-		}
-		if (rsuf == rlen) {
-			suf[i] += rsuf;
-		} else {
-			suf[i] = rsuf;
-		}
-		len[i] += rlen;
-	}
-
+	// idx[1..siz]都是下标，下标之间根据val[下标]进行从小到大的基数排序
+	// 每个val[下标]的数值，只有两位
+	// 高位 : val[下标] >> POW
+	// 低位 : val[下标] & OFFSET
 	public static void radix(int[] idx, int[] val, int siz) {
 		Arrays.fill(cntv, 0);
 		for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;
@@ -74,6 +65,22 @@ public static void radix(int[] idx, int[] val, int siz) {
 		for (int i = 1; i <= siz; i++) idx[i] = help[i];
 	}
 
+	// 左侧形成的区域，pre[i]、suf[i]、len[i]、ans[i]
+	// 右侧形成的区域，rpre、rsuf、rlen、rans
+	// 左侧与右侧合并，修改好pre[i]、suf[i]、len[i]、ans[i]
+	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
+		ans[i] += rans + 1L * suf[i] * rpre;
+		if (pre[i] == len[i]) {
+			pre[i] += rpre;
+		}
+		if (rsuf == rlen) {
+			suf[i] += rsuf;
+		} else {
+			suf[i] = rsuf;
+		}
+		len[i] += rlen;
+	}
+
 	public static void calc(int l, int r) {
 		radix(que, v, cntq);
 		for (int i = l; i <= r; i++) {
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index c3d11119c..9106e53a1 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -42,19 +42,6 @@
 //int len[MAXN];
 //long long ans[MAXN];
 //
-//inline void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
-//    ans[i] += rans + 1LL * suf[i] * rpre;
-//    if (pre[i] == len[i]) {
-//        pre[i] += rpre;
-//    }
-//    if (rsuf == rlen) {
-//        suf[i] += rsuf;
-//    } else {
-//        suf[i] = rsuf;
-//    }
-//    len[i] += rlen;
-//}
-//
 //inline void radix(int* idx, int* val, int siz) {
 //    fill(cntv, cntv + MAXB, 0);
 //    for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;
@@ -68,6 +55,19 @@
 //    for (int i = 1; i <= siz; i++) idx[i] = help[i];
 //}
 //
+//inline void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
+//    ans[i] += rans + 1LL * suf[i] * rpre;
+//    if (pre[i] == len[i]) {
+//        pre[i] += rpre;
+//    }
+//    if (rsuf == rlen) {
+//        suf[i] += rsuf;
+//    } else {
+//        suf[i] = rsuf;
+//    }
+//    len[i] += rlen;
+//}
+//
 //void calc(int l, int r) {
 //    radix(que, v, cntq);
 //    for (int i = l; i <= r; i++) {

From 28c004d11847335b0fcd28e619016165624d36e5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 18:02:27 +0800
Subject: [PATCH 1155/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 37 ++++++++++++++++-------------
 1 file changed, 20 insertions(+), 17 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 873459c2f..7432f3467 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -21,8 +21,8 @@
 public class Code02_MagicGirl1 {
 
 	public static int MAXN = 300002; // 双向链表需要n+1下标
-	public static int MAXB = 601;
-	public static int POW = 9; // 块长为(2的POW次方)，/ 块长时，>> POW即可
+	public static int MAXB = 601; // 块的最大数量
+	public static int POW = 9; // 块长为 2的POW次方，/ 块长时，>> POW即可
 	public static int OFFSET = (1 << POW) - 1; // % 块长时, & OFFSET即可
 	public static int n, m;
 
@@ -32,26 +32,27 @@ public class Code02_MagicGirl1 {
 	public static int[] y = new int[MAXN];
 	public static int[] v = new int[MAXN];
 
-	public static int[] pos = new int[MAXN];
-	public static int[] que = new int[MAXN];
-	public static int cntp;
-	public static int cntq;
+	public static int[] pos = new int[MAXN]; // 当前序列块的下标放入pos
+	public static int[] que = new int[MAXN]; // 如果查询包含当前序列块，查询下标放入que
+	public static int cntp; // cntp是pos中的下标个数
+	public static int cntq; // cntq是que中的下标个数
 
+	// 基数排序
 	public static int[] cntv = new int[MAXB];
 	public static int[] help = new int[MAXN];
 
+	// 双指针
 	public static int[] last = new int[MAXN];
 	public static int[] next = new int[MAXN];
 
-	public static int[] pre = new int[MAXN];
-	public static int[] suf = new int[MAXN];
-	public static int[] len = new int[MAXN];
-	public static long[] ans = new long[MAXN];
+	// 每个查询的答案信息
+	public static int[] pre = new int[MAXN]; // 达标前缀长度
+	public static int[] suf = new int[MAXN]; // 达标后缀长度
+	public static int[] len = new int[MAXN]; // 总长度
+	public static long[] ans = new long[MAXN]; // 达标子数组数量
 
-	// idx[1..siz]都是下标，下标之间根据val[下标]进行从小到大的基数排序
-	// 每个val[下标]的数值，只有两位
-	// 高位 : val[下标] >> POW
-	// 低位 : val[下标] & OFFSET
+	// idx[1..siz]放着所有下标，下标之间根据val[下标]进行从小到大的基数排序
+	// 每个val[下标]只有两位，高位数值(val[下标] >> POW)，低位数值(val[下标] & OFFSET)
 	public static void radix(int[] idx, int[] val, int siz) {
 		Arrays.fill(cntv, 0);
 		for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;
@@ -65,9 +66,9 @@ public static void radix(int[] idx, int[] val, int siz) {
 		for (int i = 1; i <= siz; i++) idx[i] = help[i];
 	}
 
-	// 左侧形成的区域，pre[i]、suf[i]、len[i]、ans[i]
-	// 右侧形成的区域，rpre、rsuf、rlen、rans
-	// 左侧与右侧合并，修改好pre[i]、suf[i]、len[i]、ans[i]
+	// 之前的答案信息 pre[i]、suf[i]、len[i]、ans[i]
+	// 当前的答案信息 rpre、rsuf、rlen、rans
+	// 之前信息吸收当前信息
 	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 		ans[i] += rans + 1L * suf[i] * rpre;
 		if (pre[i] == len[i]) {
@@ -81,6 +82,8 @@ public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 		len[i] += rlen;
 	}
 
+	// que[1..cntq]放着所有查询的编号，每条查询都包含arr[l..r]
+	// 根据arr[l..r]的数字状况，更新每个查询的答案信息
 	public static void calc(int l, int r) {
 		radix(que, v, cntq);
 		for (int i = l; i <= r; i++) {

From 3f7a8e587bd83266d58f869a2d6ec932eda4554a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 18:06:45 +0800
Subject: [PATCH 1156/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 7432f3467..522ed6088 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -21,7 +21,7 @@
 public class Code02_MagicGirl1 {
 
 	public static int MAXN = 300002; // 双向链表需要n+1下标
-	public static int MAXB = 601; // 块的最大数量
+	public static int MAXB = 601; // 块的数量上限
 	public static int POW = 9; // 块长为 2的POW次方，/ 块长时，>> POW即可
 	public static int OFFSET = (1 << POW) - 1; // % 块长时, & OFFSET即可
 	public static int n, m;
@@ -32,10 +32,12 @@ public class Code02_MagicGirl1 {
 	public static int[] y = new int[MAXN];
 	public static int[] v = new int[MAXN];
 
-	public static int[] pos = new int[MAXN]; // 当前序列块的下标放入pos
-	public static int[] que = new int[MAXN]; // 如果查询包含当前序列块，查询下标放入que
-	public static int cntp; // cntp是pos中的下标个数
-	public static int cntq; // cntq是que中的下标个数
+	// pos[1..cntp]存放数组下标
+	// que[1..cntq]存放查询下标
+	public static int[] pos = new int[MAXN];
+	public static int[] que = new int[MAXN];
+	public static int cntp;
+	public static int cntq;
 
 	// 基数排序
 	public static int[] cntv = new int[MAXB];
@@ -68,7 +70,7 @@ public static void radix(int[] idx, int[] val, int siz) {
 
 	// 之前的答案信息 pre[i]、suf[i]、len[i]、ans[i]
 	// 当前的答案信息 rpre、rsuf、rlen、rans
-	// 之前信息吸收当前信息
+	// 之前答案合并当前答案
 	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 		ans[i] += rans + 1L * suf[i] * rpre;
 		if (pre[i] == len[i]) {

From 9cd52ca9fa32652a0b1d68f40606578774ad44dd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 18:09:45 +0800
Subject: [PATCH 1157/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 522ed6088..2d5ebf9c9 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -20,10 +20,10 @@
 
 public class Code02_MagicGirl1 {
 
-	public static int MAXN = 300002; // 双向链表需要n+1下标
-	public static int MAXB = 601; // 块的数量上限
-	public static int POW = 9; // 块长为 2的POW次方，/ 块长时，>> POW即可
-	public static int OFFSET = (1 << POW) - 1; // % 块长时, & OFFSET即可
+	public static int MAXN = 300002;
+	public static int MAXB = 601;
+	public static int POW = 9;
+	public static int OFFSET = (1 << POW) - 1;
 	public static int n, m;
 
 	public static int[] arr = new int[MAXN];
@@ -54,7 +54,7 @@ public class Code02_MagicGirl1 {
 	public static long[] ans = new long[MAXN]; // 达标子数组数量
 
 	// idx[1..siz]放着所有下标，下标之间根据val[下标]进行从小到大的基数排序
-	// 每个val[下标]只有两位，高位数值(val[下标] >> POW)，低位数值(val[下标] & OFFSET)
+	// val[下标]只有两位，高位 = val[下标] >> POW，低位 = val[下标] & OFFSET
 	public static void radix(int[] idx, int[] val, int siz) {
 		Arrays.fill(cntv, 0);
 		for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;

From c90e41cdaf1b18471cecd48a4560a33f5efb2a04 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 18:13:41 +0800
Subject: [PATCH 1158/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 2d5ebf9c9..862e66495 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -53,8 +53,9 @@ public class Code02_MagicGirl1 {
 	public static int[] len = new int[MAXN]; // 总长度
 	public static long[] ans = new long[MAXN]; // 达标子数组数量
 
-	// idx[1..siz]放着所有下标，下标之间根据val[下标]进行从小到大的基数排序
-	// val[下标]只有两位，高位 = val[下标] >> POW，低位 = val[下标] & OFFSET
+	// idx[1..siz]存放着编号，编号之间根据val[编号]，进行从小到大的基数排序
+	// val[编号]的高位 = val[编号] >> POW
+	// val[编号]的低位 = val[编号] & OFFSET
 	public static void radix(int[] idx, int[] val, int siz) {
 		Arrays.fill(cntv, 0);
 		for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;

From 306bd00132afc03be93c3b9d0acbcf3042dde97e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 18:15:26 +0800
Subject: [PATCH 1159/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 862e66495..389d64ca9 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -53,6 +53,7 @@ public class Code02_MagicGirl1 {
 	public static int[] len = new int[MAXN]; // 总长度
 	public static long[] ans = new long[MAXN]; // 达标子数组数量
 
+	// 讲解028 - 基数排序，不会的话看一下
 	// idx[1..siz]存放着编号，编号之间根据val[编号]，进行从小到大的基数排序
 	// val[编号]的高位 = val[编号] >> POW
 	// val[编号]的低位 = val[编号] & OFFSET

From 8c9deade23749378b7c4fbf6fc9808e3903f5a5b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 18:17:47 +0800
Subject: [PATCH 1160/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 389d64ca9..3ebe9506c 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -54,7 +54,7 @@ public class Code02_MagicGirl1 {
 	public static long[] ans = new long[MAXN]; // 达标子数组数量
 
 	// 讲解028 - 基数排序，不会的话看一下
-	// idx[1..siz]存放着编号，编号之间根据val[编号]，进行从小到大的基数排序
+	// idx[1..siz]存放着编号，编号根据val[编号]的值排序，值只有两位
 	// val[编号]的高位 = val[编号] >> POW
 	// val[编号]的低位 = val[编号] & OFFSET
 	public static void radix(int[] idx, int[] val, int siz) {

From 4631d25fdb58abb28ca3b7a1399c5769e625cf15 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 20:23:36 +0800
Subject: [PATCH 1161/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 3ebe9506c..350addfd5 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -53,8 +53,8 @@ public class Code02_MagicGirl1 {
 	public static int[] len = new int[MAXN]; // 总长度
 	public static long[] ans = new long[MAXN]; // 达标子数组数量
 
-	// 讲解028 - 基数排序，不会的话看一下
-	// idx[1..siz]存放着编号，编号根据val[编号]的值排序，值只有两位
+	// 讲解028 - 基数排序，不会的话去看课
+	// idx[1..siz]中的编号排序，根据val[编号]的值排序
 	// val[编号]的高位 = val[编号] >> POW
 	// val[编号]的低位 = val[编号] & OFFSET
 	public static void radix(int[] idx, int[] val, int siz) {

From 7092d3956f8ccc94e9e9ecb365fdc638173815a0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 20:40:18 +0800
Subject: [PATCH 1162/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 350addfd5..38e0920d9 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -48,8 +48,8 @@ public class Code02_MagicGirl1 {
 	public static int[] next = new int[MAXN];
 
 	// 每个查询的答案信息
-	public static int[] pre = new int[MAXN]; // 达标前缀长度
-	public static int[] suf = new int[MAXN]; // 达标后缀长度
+	public static int[] pre = new int[MAXN]; // <=v的前缀长度
+	public static int[] suf = new int[MAXN]; // <=v的后缀长度
 	public static int[] len = new int[MAXN]; // 总长度
 	public static long[] ans = new long[MAXN]; // 达标子数组数量
 
@@ -70,9 +70,9 @@ public static void radix(int[] idx, int[] val, int siz) {
 		for (int i = 1; i <= siz; i++) idx[i] = help[i];
 	}
 
-	// 之前的答案信息 pre[i]、suf[i]、len[i]、ans[i]
-	// 当前的答案信息 rpre、rsuf、rlen、rans
-	// 之前答案合并当前答案
+	// 左侧的答案信息 pre[i]、suf[i]、len[i]、ans[i]
+	// 右侧的答案信息 rpre、rsuf、rlen、rans
+	// 左侧答案合并右侧答案
 	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 		ans[i] += rans + 1L * suf[i] * rpre;
 		if (pre[i] == len[i]) {

From a512c293b0a02ab824d99b335fce9b8af6490f7d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 20:53:46 +0800
Subject: [PATCH 1163/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 21 ++++-----------------
 src/class174/Code02_MagicGirl2.java | 16 ++++------------
 2 files changed, 8 insertions(+), 29 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 38e0920d9..15dc12e84 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -122,24 +122,11 @@ public static void update(int qi, int l, int r) {
 		if (l <= jobi && jobi <= r) {
 			calc(l, r);
 			arr[jobi] = jobv;
-			int find = 0;
-			for (int i = 1; i <= cntp; i++) {
-				if (pos[i] == jobi) {
-					find = i;
-					break;
-				}
-			}
-			int tmp;
-			for (int i = find; i < cntp && arr[pos[i]] > arr[pos[i + 1]]; i++) {
-				tmp = pos[i];
-				pos[i] = pos[i + 1];
-				pos[i + 1] = tmp;
-			}
-			for (int i = find; i > 1 && arr[pos[i - 1]] > arr[pos[i]]; i--) {
-				tmp = pos[i - 1];
-				pos[i - 1] = pos[i];
-				pos[i] = tmp;
+			cntp = 0;
+			for (int i = l; i <= r; i++) {
+				pos[++cntp] = i;
 			}
+			radix(pos, arr, cntp);
 		}
 	}
 
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 9106e53a1..1f96735f6 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -102,19 +102,11 @@
 //    if (l <= jobi && jobi <= r) {
 //        calc(l, r);
 //        arr[jobi] = jobv;
-//        int find = 0;
-//        for (int i = 1; i <= cntp; i++) {
-//            if (pos[i] == jobi) {
-//                find = i;
-//                break;
-//            }
-//        }
-//        for (int i = find; i < cntp && arr[pos[i]] > arr[pos[i + 1]]; i++) {
-//            swap(pos[i], pos[i + 1]);
-//        }
-//        for (int i = find; i > 1 && arr[pos[i - 1]] > arr[pos[i]]; i--) {
-//            swap(pos[i - 1], pos[i]);
+//        cntp = 0;
+//        for (int i = l; i <= r; i++) {
+//            pos[++cntp] = i;
 //        }
+//        radix(pos, arr, cntp);
 //    }
 //}
 //

From dd40a04475d92a22aee3b096b6ecf5ecbf8f7160 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 21:30:17 +0800
Subject: [PATCH 1164/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 12 +++---------
 src/class174/Code02_MagicGirl2.java | 12 +++---------
 2 files changed, 6 insertions(+), 18 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 15dc12e84..fc9abe9a8 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -51,7 +51,7 @@ public class Code02_MagicGirl1 {
 	public static int[] pre = new int[MAXN]; // <=v的前缀长度
 	public static int[] suf = new int[MAXN]; // <=v的后缀长度
 	public static int[] len = new int[MAXN]; // 总长度
-	public static long[] ans = new long[MAXN]; // 达标子数组数量
+	public static long[] ans = new long[MAXN]; // 达标子数组个数
 
 	// 讲解028 - 基数排序，不会的话去看课
 	// idx[1..siz]中的编号排序，根据val[编号]的值排序
@@ -75,14 +75,8 @@ public static void radix(int[] idx, int[] val, int siz) {
 	// 左侧答案合并右侧答案
 	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 		ans[i] += rans + 1L * suf[i] * rpre;
-		if (pre[i] == len[i]) {
-			pre[i] += rpre;
-		}
-		if (rsuf == rlen) {
-			suf[i] += rsuf;
-		} else {
-			suf[i] = rsuf;
-		}
+		pre[i] = pre[i] != len[i] ? pre[i] : len[i] + rpre;
+		suf[i] = rsuf != rlen ? rsuf : rlen + suf[i];
 		len[i] += rlen;
 	}
 
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 1f96735f6..6796e0390 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -56,15 +56,9 @@
 //}
 //
 //inline void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
-//    ans[i] += rans + 1LL * suf[i] * rpre;
-//    if (pre[i] == len[i]) {
-//        pre[i] += rpre;
-//    }
-//    if (rsuf == rlen) {
-//        suf[i] += rsuf;
-//    } else {
-//        suf[i] = rsuf;
-//    }
+//    ans[i] += rans + 1L * suf[i] * rpre;
+//    pre[i] = pre[i] != len[i] ? pre[i] : len[i] + rpre;
+//    suf[i] = rsuf != rlen ? rsuf : rlen + suf[i];
 //    len[i] += rlen;
 //}
 //

From 9cfb849795be29cfc0263366b01bd6af7b4de2fe Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 22:41:42 +0800
Subject: [PATCH 1165/1712] modifycode

---
 src/class174/Code02_MagicGirl1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index fc9abe9a8..86d4f2e09 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -43,7 +43,7 @@ public class Code02_MagicGirl1 {
 	public static int[] cntv = new int[MAXB];
 	public static int[] help = new int[MAXN];
 
-	// 双指针
+	// 双链表
 	public static int[] last = new int[MAXN];
 	public static int[] next = new int[MAXN];
 

From aed9b9b769a866e585af4c99feaaf779327c902d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 23:01:35 +0800
Subject: [PATCH 1166/1712] modifycode

---
 src/class174/Code02_MagicGirl1.java | 55 ++++++++++-------------------
 src/class174/Code02_MagicGirl2.java | 55 ++++++++++-------------------
 2 files changed, 38 insertions(+), 72 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 86d4f2e09..0b4fb56fd 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -83,11 +83,14 @@ public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 	// que[1..cntq]放着所有查询的编号，每条查询都包含arr[l..r]
 	// 根据arr[l..r]的数字状况，更新每个查询的答案信息
 	public static void calc(int l, int r) {
-		radix(que, v, cntq);
+		cntp = 0;
 		for (int i = l; i <= r; i++) {
+			pos[++cntp] = i;
 			last[i] = i - 1;
 			next[i] = i + 1;
 		}
+		radix(pos, arr, cntq);
+		radix(que, v, cntq);
 		int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
 		int k = 1;
 		for (int i = 1; i <= cntp; i++) {
@@ -111,45 +114,25 @@ public static void calc(int l, int r) {
 		cntq = 0;
 	}
 
-	public static void update(int qi, int l, int r) {
-		int jobi = x[qi], jobv = v[qi];
-		if (l <= jobi && jobi <= r) {
-			calc(l, r);
-			arr[jobi] = jobv;
-			cntp = 0;
-			for (int i = l; i <= r; i++) {
-				pos[++cntp] = i;
-			}
-			radix(pos, arr, cntp);
-		}
-	}
-
-	public static void query(int qi, int l, int r) {
-		int jobl = x[qi], jobr = y[qi], jobv = v[qi];
-		if (jobl <= l && r <= jobr) {
-			que[++cntq] = qi;
-		} else {
-			for (int i = Math.max(jobl, l); i <= Math.min(jobr, r); i++) {
-				if (arr[i] <= jobv) {
-					mergeAns(qi, 1, 1, 1, 1);
-				} else {
-					mergeAns(qi, 0, 0, 1, 0);
-				}
-			}
-		}
-	}
-
 	public static void compute(int l, int r) {
-		cntp = 0;
-		for (int i = l; i <= r; i++) {
-			pos[++cntp] = i;
-		}
-		radix(pos, arr, cntp);
 		for (int qi = 1; qi <= m; qi++) {
 			if (op[qi] == 1) {
-				update(qi, l, r);
+				if (l <= x[qi] && x[qi] <= r) {
+					calc(l, r);
+					arr[x[qi]] = v[qi];
+				}
 			} else {
-				query(qi, l, r);
+				if (x[qi] <= l && r <= y[qi]) {
+					que[++cntq] = qi;
+				} else {
+					for (int i = Math.max(x[qi], l); i <= Math.min(y[qi], r); i++) {
+						if (arr[i] <= v[qi]) {
+							mergeAns(qi, 1, 1, 1, 1);
+						} else {
+							mergeAns(qi, 0, 0, 1, 0);
+						}
+					}
+				}
 			}
 		}
 		calc(l, r);
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 6796e0390..3d893eb10 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -63,11 +63,14 @@
 //}
 //
 //void calc(int l, int r) {
-//    radix(que, v, cntq);
+//    cntp = 0;
 //    for (int i = l; i <= r; i++) {
+//        pos[++cntp] = i;
 //        lst[i] = i - 1;
 //        nxt[i] = i + 1;
 //    }
+//    radix(pos, arr, cntp);
+//    radix(que, v, cntq);
 //    int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
 //    int k = 1;
 //    for (int i = 1; i <= cntp; i++) {
@@ -91,45 +94,25 @@
 //    cntq = 0;
 //}
 //
-//inline void update(int qi, int l, int r) {
-//    int jobi = x[qi], jobv = v[qi];
-//    if (l <= jobi && jobi <= r) {
-//        calc(l, r);
-//        arr[jobi] = jobv;
-//        cntp = 0;
-//        for (int i = l; i <= r; i++) {
-//            pos[++cntp] = i;
-//        }
-//        radix(pos, arr, cntp);
-//    }
-//}
-//
-//inline void query(int qi, int l, int r) {
-//    int jobl = x[qi], jobr = y[qi], jobv = v[qi];
-//    if (jobl <= l && r <= jobr) {
-//        que[++cntq] = qi;
-//    } else {
-//        for (int i = max(jobl, l); i <= min(jobr, r); i++) {
-//            if (arr[i] <= jobv) {
-//                mergeAns(qi, 1, 1, 1, 1);
-//            } else {
-//                mergeAns(qi, 0, 0, 1, 0);
-//            }
-//        }
-//    }
-//}
-//
 //void compute(int l, int r) {
-//    cntp = 0;
-//    for (int i = l; i <= r; i++) {
-//        pos[++cntp] = i;
-//    }
-//    radix(pos, arr, cntp);
 //    for (int qi = 1; qi <= m; qi++) {
 //        if (op[qi] == 1) {
-//            update(qi, l, r);
+//            if (l <= x[qi] && x[qi] <= r) {
+//                calc(l, r);
+//                arr[x[qi]] = v[qi];
+//            }
 //        } else {
-//            query(qi, l, r);
+//            if (x[qi] <= l && r <= y[qi]) {
+//                que[++cntq] = qi;
+//            } else {
+//                for (int i = max(x[qi], l); i <= min(y[qi], r); i++) {
+//                    if (arr[i] <= v[qi]) {
+//                        mergeAns(qi, 1, 1, 1, 1);
+//                    } else {
+//                        mergeAns(qi, 0, 0, 1, 0);
+//                    }
+//                }
+//            }
 //        }
 //    }
 //    calc(l, r);

From a633578687e5485291c0eb60496e789d7d079f88 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 14 Jul 2025 23:05:27 +0800
Subject: [PATCH 1167/1712] modifycode

---
 src/class174/Code02_MagicGirl1.java | 3 +--
 src/class174/Code02_MagicGirl2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 0b4fb56fd..84e5e9173 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -83,7 +83,6 @@ public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
 	// que[1..cntq]放着所有查询的编号，每条查询都包含arr[l..r]
 	// 根据arr[l..r]的数字状况，更新每个查询的答案信息
 	public static void calc(int l, int r) {
-		cntp = 0;
 		for (int i = l; i <= r; i++) {
 			pos[++cntp] = i;
 			last[i] = i - 1;
@@ -111,7 +110,7 @@ public static void calc(int l, int r) {
 		for (; k <= cntq; k++) {
 			mergeAns(que[k], rpre, rsuf, rlen, rans);
 		}
-		cntq = 0;
+		cntp = cntq = 0;
 	}
 
 	public static void compute(int l, int r) {
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 3d893eb10..edaea47f5 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -63,7 +63,6 @@
 //}
 //
 //void calc(int l, int r) {
-//    cntp = 0;
 //    for (int i = l; i <= r; i++) {
 //        pos[++cntp] = i;
 //        lst[i] = i - 1;
@@ -91,7 +90,7 @@
 //    for(; k <= cntq; k++) {
 //        mergeAns(que[k], rpre, rsuf, rlen, rans);
 //    }
-//    cntq = 0;
+//    cntp = cntq = 0;
 //}
 //
 //void compute(int l, int r) {

From ca2ed72d3f41db844c70ffa6f445679e1f2d3bf2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 12:29:20 +0800
Subject: [PATCH 1168/1712] modifycode

---
 src/class174/Code02_MagicGirl1.java | 70 ++++++++++++++---------------
 src/class174/Code02_MagicGirl2.java | 43 +++++++++---------
 2 files changed, 54 insertions(+), 59 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 84e5e9173..fa6cbef6e 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -32,8 +32,8 @@ public class Code02_MagicGirl1 {
 	public static int[] y = new int[MAXN];
 	public static int[] v = new int[MAXN];
 
-	// pos[1..cntp]存放数组下标
-	// que[1..cntq]存放查询下标
+	// pos[1..cntp]是当前序列块的下标
+	// que[1..cntq]是整包清算的查询编号
 	public static int[] pos = new int[MAXN];
 	public static int[] que = new int[MAXN];
 	public static int cntp;
@@ -47,14 +47,14 @@ public class Code02_MagicGirl1 {
 	public static int[] last = new int[MAXN];
 	public static int[] next = new int[MAXN];
 
-	// 每个查询的答案信息
-	public static int[] pre = new int[MAXN]; // <=v的前缀长度
-	public static int[] suf = new int[MAXN]; // <=v的后缀长度
-	public static int[] len = new int[MAXN]; // 总长度
-	public static long[] ans = new long[MAXN]; // 达标子数组个数
+	// 每条查询的答案信息
+	public static int[] pre = new int[MAXN];
+	public static int[] suf = new int[MAXN];
+	public static int[] len = new int[MAXN];
+	public static long[] ans = new long[MAXN];
 
 	// 讲解028 - 基数排序，不会的话去看课
-	// idx[1..siz]中的编号排序，根据val[编号]的值排序
+	// idx[1..siz]都是编号，编号根据val[编号]的值排序
 	// val[编号]的高位 = val[编号] >> POW
 	// val[编号]的低位 = val[编号] & OFFSET
 	public static void radix(int[] idx, int[] val, int siz) {
@@ -70,17 +70,18 @@ public static void radix(int[] idx, int[] val, int siz) {
 		for (int i = 1; i <= siz; i++) idx[i] = help[i];
 	}
 
-	// 左侧的答案信息 pre[i]、suf[i]、len[i]、ans[i]
-	// 右侧的答案信息 rpre、rsuf、rlen、rans
-	// 左侧答案合并右侧答案
-	public static void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
-		ans[i] += rans + 1L * suf[i] * rpre;
-		pre[i] = pre[i] != len[i] ? pre[i] : len[i] + rpre;
-		suf[i] = rsuf != rlen ? rsuf : rlen + suf[i];
-		len[i] += rlen;
+	// 之前的答案信息 pre[i]、suf[i]、len[i]、ans[i]
+	// 当前的答案信息 curPre、curSuf、curLen、curAns
+	// 之前的答案合并当前的答案
+	public static void mergeAns(int i, int curPre, int curSuf, int curLen, int curAns) {
+		ans[i] += 1L * suf[i] * curPre + curAns;
+		pre[i] = pre[i] + (pre[i] == len[i] ? curPre : 0);
+		suf[i] = curSuf + (curSuf == curLen ? suf[i] : 0);
+		len[i] += curLen;
 	}
 
-	// que[1..cntq]放着所有查询的编号，每条查询都包含arr[l..r]
+	// 整包结算
+	// que[1..cntq]是查询编号，每条查询整包arr[l..r]
 	// 根据arr[l..r]的数字状况，更新每个查询的答案信息
 	public static void calc(int l, int r) {
 		for (int i = l; i <= r; i++) {
@@ -88,27 +89,24 @@ public static void calc(int l, int r) {
 			last[i] = i - 1;
 			next[i] = i + 1;
 		}
-		radix(pos, arr, cntq);
+		radix(pos, arr, cntp);
 		radix(que, v, cntq);
-		int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
-		int k = 1;
-		for (int i = 1; i <= cntp; i++) {
-			int idx = pos[i];
-			for (; k <= cntq && v[que[k]] < arr[idx]; k++) {
-				mergeAns(que[k], rpre, rsuf, rlen, rans);
-			}
-			if (last[idx] == l - 1) {
-				rpre += next[idx] - idx;
-			}
-			if (next[idx] == r + 1) {
-				rsuf += idx - last[idx];
+		int curPre = 0, curSuf = 0, curLen = r - l + 1, curAns = 0;
+		for (int i = 1, j = 1, idx; i <= cntq; i++) {
+			while (j <= cntp && arr[pos[j]] <= v[que[i]]) {
+				idx = pos[j];
+				if (last[idx] == l - 1) {
+					curPre += next[idx] - idx;
+				}
+				if (next[idx] == r + 1) {
+					curSuf += idx - last[idx];
+				}
+				curAns += 1L * (idx - last[idx]) * (next[idx] - idx);
+				last[next[idx]] = last[idx];
+				next[last[idx]] = next[idx];
+				j++;
 			}
-			rans += 1L * (idx - last[idx]) * (next[idx] - idx);
-			last[next[idx]] = last[idx];
-			next[last[idx]] = next[idx];
-		}
-		for (; k <= cntq; k++) {
-			mergeAns(que[k], rpre, rsuf, rlen, rans);
+			mergeAns(que[i], curPre, curSuf, curLen, curAns);
 		}
 		cntp = cntq = 0;
 	}
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index edaea47f5..c8f27294e 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -55,11 +55,11 @@
 //    for (int i = 1; i <= siz; i++) idx[i] = help[i];
 //}
 //
-//inline void mergeAns(int i, int rpre, int rsuf, int rlen, int rans) {
-//    ans[i] += rans + 1L * suf[i] * rpre;
-//    pre[i] = pre[i] != len[i] ? pre[i] : len[i] + rpre;
-//    suf[i] = rsuf != rlen ? rsuf : rlen + suf[i];
-//    len[i] += rlen;
+//inline void mergeAns(int i, int curPre, int curSuf, int curLen, int curAns) {
+//    ans[i] += 1L * suf[i] * curPre + curAns;
+//    pre[i] = pre[i] + (pre[i] == len[i] ? curPre : 0);
+//    suf[i] = curSuf + (curSuf == curLen ? suf[i] : 0);
+//    len[i] += curLen;
 //}
 //
 //void calc(int l, int r) {
@@ -70,25 +70,22 @@
 //    }
 //    radix(pos, arr, cntp);
 //    radix(que, v, cntq);
-//    int rpre = 0, rsuf = 0, rlen = r - l + 1, rans = 0;
-//    int k = 1;
-//    for (int i = 1; i <= cntp; i++) {
-//        int idx = pos[i];
-//        for(; k <= cntq && v[que[k]] < arr[idx]; k++) {
-//            mergeAns(que[k], rpre, rsuf, rlen, rans);
-//        }
-//        if (lst[idx] == l - 1) {
-//            rpre += nxt[idx] - idx;
-//        }
-//        if (nxt[idx] == r + 1) {
-//            rsuf += idx - lst[idx];
+//    int curPre = 0, curSuf = 0, curLen = r - l + 1, curAns = 0;
+//    for (int i = 1, j = 1, idx; i <= cntq; i++) {
+//        while (j <= cntp && arr[pos[j]] <= v[que[i]]) {
+//            idx = pos[j];
+//            if (lst[idx] == l - 1) {
+//                curPre += nxt[idx] - idx;
+//            }
+//            if (nxt[idx] == r + 1) {
+//                curSuf += idx - lst[idx];
+//            }
+//            curAns += 1L * (idx - lst[idx]) * (nxt[idx] - idx);
+//            lst[nxt[idx]] = lst[idx];
+//            nxt[lst[idx]] = nxt[idx];
+//            j++;
 //        }
-//        rans += 1LL * (idx - lst[idx]) * (nxt[idx] - idx);
-//        lst[nxt[idx]] = lst[idx];
-//        nxt[lst[idx]] = nxt[idx];
-//    }
-//    for(; k <= cntq; k++) {
-//        mergeAns(que[k], rpre, rsuf, rlen, rans);
+//        mergeAns(que[i], curPre, curSuf, curLen, curAns);
 //    }
 //    cntp = cntq = 0;
 //}

From 23954c3147cefb33a06d51665045d87f89cc16ce Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 12:32:22 +0800
Subject: [PATCH 1169/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index fa6cbef6e..2161f1ee4 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -81,8 +81,8 @@ public static void mergeAns(int i, int curPre, int curSuf, int curLen, int curAn
 	}
 
 	// 整包结算
-	// que[1..cntq]是查询编号，每条查询整包arr[l..r]
-	// 根据arr[l..r]的数字状况，更新每个查询的答案信息
+	// que[1..cntq]是查询编号，每条查询整包[l..r]
+	// 根据序列块的数字状况，更新每个查询的答案信息
 	public static void calc(int l, int r) {
 		for (int i = l; i <= r; i++) {
 			pos[++cntp] = i;

From 87fb6487c1c0246e765bc8c8407b482884c5e1cd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 13:20:12 +0800
Subject: [PATCH 1170/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 2161f1ee4..37301d598 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -33,7 +33,7 @@ public class Code02_MagicGirl1 {
 	public static int[] v = new int[MAXN];
 
 	// pos[1..cntp]是当前序列块的下标
-	// que[1..cntq]是整包清算的查询编号
+	// que[1..cntq]是整包结算的查询编号
 	public static int[] pos = new int[MAXN];
 	public static int[] que = new int[MAXN];
 	public static int cntp;

From 77e4c6780bfc424b198deccaed52530fda5e8df7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 13:26:25 +0800
Subject: [PATCH 1171/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 14 +++++++-------
 src/class174/Code02_MagicGirl2.java |  8 ++++----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index 37301d598..c68789f69 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -70,10 +70,10 @@ public static void radix(int[] idx, int[] val, int siz) {
 		for (int i = 1; i <= siz; i++) idx[i] = help[i];
 	}
 
-	// 之前的答案信息 pre[i]、suf[i]、len[i]、ans[i]
-	// 当前的答案信息 curPre、curSuf、curLen、curAns
-	// 之前的答案合并当前的答案
-	public static void mergeAns(int i, int curPre, int curSuf, int curLen, int curAns) {
+	// 查询的答案信息 pre[i]、suf[i]、len[i]、ans[i]
+	// 当前块答案信息 curPre、curSuf、curLen、curAns
+	// 查询的答案信息 合并 当前块答案信息
+	public static void merge(int i, int curPre, int curSuf, int curLen, int curAns) {
 		ans[i] += 1L * suf[i] * curPre + curAns;
 		pre[i] = pre[i] + (pre[i] == len[i] ? curPre : 0);
 		suf[i] = curSuf + (curSuf == curLen ? suf[i] : 0);
@@ -106,7 +106,7 @@ public static void calc(int l, int r) {
 				next[last[idx]] = next[idx];
 				j++;
 			}
-			mergeAns(que[i], curPre, curSuf, curLen, curAns);
+			merge(que[i], curPre, curSuf, curLen, curAns);
 		}
 		cntp = cntq = 0;
 	}
@@ -124,9 +124,9 @@ public static void compute(int l, int r) {
 				} else {
 					for (int i = Math.max(x[qi], l); i <= Math.min(y[qi], r); i++) {
 						if (arr[i] <= v[qi]) {
-							mergeAns(qi, 1, 1, 1, 1);
+							merge(qi, 1, 1, 1, 1);
 						} else {
-							mergeAns(qi, 0, 0, 1, 0);
+							merge(qi, 0, 0, 1, 0);
 						}
 					}
 				}
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index c8f27294e..40d1f8aa5 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -55,7 +55,7 @@
 //    for (int i = 1; i <= siz; i++) idx[i] = help[i];
 //}
 //
-//inline void mergeAns(int i, int curPre, int curSuf, int curLen, int curAns) {
+//inline void merge(int i, int curPre, int curSuf, int curLen, int curAns) {
 //    ans[i] += 1L * suf[i] * curPre + curAns;
 //    pre[i] = pre[i] + (pre[i] == len[i] ? curPre : 0);
 //    suf[i] = curSuf + (curSuf == curLen ? suf[i] : 0);
@@ -85,7 +85,7 @@
 //            nxt[lst[idx]] = nxt[idx];
 //            j++;
 //        }
-//        mergeAns(que[i], curPre, curSuf, curLen, curAns);
+//        merge(que[i], curPre, curSuf, curLen, curAns);
 //    }
 //    cntp = cntq = 0;
 //}
@@ -103,9 +103,9 @@
 //            } else {
 //                for (int i = max(x[qi], l); i <= min(y[qi], r); i++) {
 //                    if (arr[i] <= v[qi]) {
-//                        mergeAns(qi, 1, 1, 1, 1);
+//                        merge(qi, 1, 1, 1, 1);
 //                    } else {
-//                        mergeAns(qi, 0, 0, 1, 0);
+//                        merge(qi, 0, 0, 1, 0);
 //                    }
 //                }
 //            }

From 90f6c1852e87fdfa7ad8a38d2a6c9c9bd047c03c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 15:18:37 +0800
Subject: [PATCH 1172/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 14 +++++++-------
 src/class174/Code02_MagicGirl2.java | 10 +++++-----
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index c68789f69..a9cf5b3fd 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -33,9 +33,9 @@ public class Code02_MagicGirl1 {
 	public static int[] v = new int[MAXN];
 
 	// pos[1..cntp]是当前序列块的下标
-	// que[1..cntq]是整包结算的查询编号
+	// qid[1..cntq]是整包结算的查询编号
 	public static int[] pos = new int[MAXN];
-	public static int[] que = new int[MAXN];
+	public static int[] qid = new int[MAXN];
 	public static int cntp;
 	public static int cntq;
 
@@ -81,7 +81,7 @@ public static void merge(int i, int curPre, int curSuf, int curLen, int curAns)
 	}
 
 	// 整包结算
-	// que[1..cntq]是查询编号，每条查询整包[l..r]
+	// qid[1..cntq]是查询编号，每条查询整包[l..r]
 	// 根据序列块的数字状况，更新每个查询的答案信息
 	public static void calc(int l, int r) {
 		for (int i = l; i <= r; i++) {
@@ -90,10 +90,10 @@ public static void calc(int l, int r) {
 			next[i] = i + 1;
 		}
 		radix(pos, arr, cntp);
-		radix(que, v, cntq);
+		radix(qid, v, cntq);
 		int curPre = 0, curSuf = 0, curLen = r - l + 1, curAns = 0;
 		for (int i = 1, j = 1, idx; i <= cntq; i++) {
-			while (j <= cntp && arr[pos[j]] <= v[que[i]]) {
+			while (j <= cntp && arr[pos[j]] <= v[qid[i]]) {
 				idx = pos[j];
 				if (last[idx] == l - 1) {
 					curPre += next[idx] - idx;
@@ -106,7 +106,7 @@ public static void calc(int l, int r) {
 				next[last[idx]] = next[idx];
 				j++;
 			}
-			merge(que[i], curPre, curSuf, curLen, curAns);
+			merge(qid[i], curPre, curSuf, curLen, curAns);
 		}
 		cntp = cntq = 0;
 	}
@@ -120,7 +120,7 @@ public static void compute(int l, int r) {
 				}
 			} else {
 				if (x[qi] <= l && r <= y[qi]) {
-					que[++cntq] = qi;
+					qid[++cntq] = qi;
 				} else {
 					for (int i = Math.max(x[qi], l); i <= Math.min(y[qi], r); i++) {
 						if (arr[i] <= v[qi]) {
diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 40d1f8aa5..e59cb767f 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -27,7 +27,7 @@
 //int v[MAXN];
 //
 //int pos[MAXN];
-//int que[MAXN];
+//int qid[MAXN];
 //int cntp;
 //int cntq;
 //
@@ -69,10 +69,10 @@
 //        nxt[i] = i + 1;
 //    }
 //    radix(pos, arr, cntp);
-//    radix(que, v, cntq);
+//    radix(qid, v, cntq);
 //    int curPre = 0, curSuf = 0, curLen = r - l + 1, curAns = 0;
 //    for (int i = 1, j = 1, idx; i <= cntq; i++) {
-//        while (j <= cntp && arr[pos[j]] <= v[que[i]]) {
+//        while (j <= cntp && arr[pos[j]] <= v[qid[i]]) {
 //            idx = pos[j];
 //            if (lst[idx] == l - 1) {
 //                curPre += nxt[idx] - idx;
@@ -85,7 +85,7 @@
 //            nxt[lst[idx]] = nxt[idx];
 //            j++;
 //        }
-//        merge(que[i], curPre, curSuf, curLen, curAns);
+//        merge(qid[i], curPre, curSuf, curLen, curAns);
 //    }
 //    cntp = cntq = 0;
 //}
@@ -99,7 +99,7 @@
 //            }
 //        } else {
 //            if (x[qi] <= l && r <= y[qi]) {
-//                que[++cntq] = qi;
+//                qid[++cntq] = qi;
 //            } else {
 //                for (int i = max(x[qi], l); i <= min(y[qi], r); i++) {
 //                    if (arr[i] <= v[qi]) {

From 1d0a1ea6f5e6a557058285795e4c30de921da331 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 17:41:24 +0800
Subject: [PATCH 1173/1712] modify code

---
 src/class174/Code02_MagicGirl1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class174/Code02_MagicGirl1.java b/src/class174/Code02_MagicGirl1.java
index a9cf5b3fd..6fc1bdbdd 100644
--- a/src/class174/Code02_MagicGirl1.java
+++ b/src/class174/Code02_MagicGirl1.java
@@ -111,6 +111,7 @@ public static void calc(int l, int r) {
 		cntp = cntq = 0;
 	}
 
+	// 序列块[l..r]，处理一遍所有的操作(单改 + 查询)
 	public static void compute(int l, int r) {
 		for (int qi = 1; qi <= m; qi++) {
 			if (op[qi] == 1) {

From e38954a1fc79603f472e5384adf2b37f64bf6613 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 19:38:15 +0800
Subject: [PATCH 1174/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 7 ++-----
 src/class174/Code03_ColorfulWorld2.java | 7 ++-----
 2 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index fc7a6eae6..68c161852 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -59,7 +59,7 @@ public static void down(int l, int r) {
 
 	public static void update(int qi, int l, int r) {
 		int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
-		if (jobx > maxv - lazy || jobl > r || jobr < l) {
+		if (jobx >= maxv - lazy || jobl > r || jobr < l) {
 			return;
 		}
 		if (jobl <= l && r <= jobr) {
@@ -103,10 +103,7 @@ public static void update(int qi, int l, int r) {
 
 	public static void query(int qi, int l, int r) {
 		int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
-		if (jobx == 0) {
-			return;
-		}
-		if (jobx > maxv - lazy || jobl > r || jobr < l) {
+		if (jobx == 0 || jobx > maxv - lazy || jobl > r || jobr < l) {
 			return;
 		}
 		if (jobl <= l && r <= jobr) {
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 3d3789c59..02765aea7 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -53,7 +53,7 @@
 //
 //void update(int qi, int l, int r) {
 //    int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
-//    if (jobx > maxv - lazy || jobl > r || jobr < l) {
+//    if (jobx >= maxv - lazy || jobl > r || jobr < l) {
 //        return;
 //    }
 //    if (jobl <= l && r <= jobr) {
@@ -97,10 +97,7 @@
 //
 //void query(int qi, int l, int r) {
 //    int jobl = ql[qi], jobr = qr[qi], jobx = qx[qi];
-//    if (jobx == 0) {
-//        return;
-//    }
-//    if (jobx > maxv - lazy || jobl > r || jobr < l) {
+//    if (jobx == 0 || jobx > maxv - lazy || jobl > r || jobr < l) {
 //        return;
 //    }
 //    if (jobl <= l && r <= jobr) {

From e48be5a415b462733ffae43d6bc13319a696e63e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 19:45:25 +0800
Subject: [PATCH 1175/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 24 ++++++++++++------------
 src/class174/Code03_ColorfulWorld2.java | 24 ++++++++++++------------
 2 files changed, 24 insertions(+), 24 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 68c161852..09e962330 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -36,7 +36,7 @@ public class Code03_ColorfulWorld1 {
 
 	public static int[] pre0 = new int[MAXN];
 	public static int[] fa = new int[MAXV];
-	public static int[] sum = new int[MAXV];
+	public static int[] cntv = new int[MAXV];
 
 	public static int[] ans = new int[MAXM];
 
@@ -65,19 +65,19 @@ public static void update(int qi, int l, int r) {
 		if (jobl <= l && r <= jobr) {
 			if ((jobx << 1) <= maxv - lazy) {
 				for (int v = lazy + 1; v <= lazy + jobx; v++) {
-					sum[v + jobx] += sum[v];
-					sum[v] = 0;
+					cntv[v + jobx] += cntv[v];
+					cntv[v] = 0;
 					union(v, v + jobx);
 				}
 				lazy += jobx;
 			} else {
 				for (int v = maxv; v > lazy + jobx; v--) {
-					sum[v - jobx] += sum[v];
-					sum[v] = 0;
+					cntv[v - jobx] += cntv[v];
+					cntv[v] = 0;
 					union(v, v - jobx);
 				}
 				for (int v = maxv; v >= 0; v--) {
-					if (sum[v] != 0) {
+					if (cntv[v] != 0) {
 						maxv = v;
 						break;
 					}
@@ -87,13 +87,13 @@ public static void update(int qi, int l, int r) {
 			down(l, r);
 			for (int i = Math.max(l, jobl); i <= Math.min(r, jobr); i++) {
 				if (arr[i] - lazy > jobx) {
-					sum[arr[i]]--;
+					cntv[arr[i]]--;
 					arr[i] -= jobx;
-					sum[arr[i]]++;
+					cntv[arr[i]]++;
 				}
 			}
 			for (int v = maxv; v >= 0; v--) {
-				if (sum[v] != 0) {
+				if (cntv[v] != 0) {
 					maxv = v;
 					break;
 				}
@@ -107,7 +107,7 @@ public static void query(int qi, int l, int r) {
 			return;
 		}
 		if (jobl <= l && r <= jobr) {
-			ans[qi] += sum[jobx + lazy];
+			ans[qi] += cntv[jobx + lazy];
 		} else {
 			down(l, r);
 			for (int i = Math.max(l, jobl); i <= Math.min(r, jobr); i++) {
@@ -119,11 +119,11 @@ public static void query(int qi, int l, int r) {
 	}
 
 	public static void compute(int l, int r) {
-		Arrays.fill(sum, 0);
+		Arrays.fill(cntv, 0);
 		maxv = lazy = 0;
 		for (int i = l; i <= r; i++) {
 			maxv = Math.max(maxv, arr[i]);
-			sum[arr[i]]++;
+			cntv[arr[i]]++;
 		}
 		for (int v = 0; v <= maxv; v++) {
 			fa[v] = v;
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 02765aea7..5cae34136 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -30,7 +30,7 @@
 //
 //int pre0[MAXN];
 //int fa[MAXV];
-//int sum[MAXV];
+//int cntv[MAXV];
 //
 //int ans[MAXM];
 //
@@ -59,19 +59,19 @@
 //    if (jobl <= l && r <= jobr) {
 //        if ((jobx << 1) <= maxv - lazy) {
 //            for (int v = lazy + 1; v <= lazy + jobx; v++) {
-//                sum[v + jobx] += sum[v];
-//                sum[v] = 0;
+//                cntv[v + jobx] += cntv[v];
+//                cntv[v] = 0;
 //                Union(v, v + jobx);
 //            }
 //            lazy += jobx;
 //        } else {
 //            for (int v = maxv; v > lazy + jobx; v--) {
-//                sum[v - jobx] += sum[v];
-//                sum[v] = 0;
+//                cntv[v - jobx] += cntv[v];
+//                cntv[v] = 0;
 //                Union(v, v - jobx);
 //            }
 //            for (int v = maxv; v >= 0; v--) {
-//                if (sum[v] != 0) {
+//                if (cntv[v] != 0) {
 //                    maxv = v;
 //                    break;
 //                }
@@ -81,13 +81,13 @@
 //        down(l, r);
 //        for (int i = max(l, jobl); i <= min(r, jobr); i++) {
 //            if (arr[i] - lazy > jobx) {
-//                sum[arr[i]]--;
+//                cntv[arr[i]]--;
 //                arr[i] -= jobx;
-//                sum[arr[i]]++;
+//                cntv[arr[i]]++;
 //            }
 //        }
 //        for (int v = maxv; v >= 0; v--) {
-//            if (sum[v] != 0) {
+//            if (cntv[v] != 0) {
 //                maxv = v;
 //                break;
 //            }
@@ -101,7 +101,7 @@
 //        return;
 //    }
 //    if (jobl <= l && r <= jobr) {
-//        ans[qi] += sum[jobx + lazy];
+//        ans[qi] += cntv[jobx + lazy];
 //    } else {
 //        down(l, r);
 //        for (int i = max(l, jobl); i <= min(r, jobr); i++) {
@@ -113,11 +113,11 @@
 //}
 //
 //void compute(int l, int r) {
-//    fill(sum, sum + MAXN, 0);
+//    fill(cntv, cntv + MAXV, 0);
 //    maxv = lazy = 0;
 //    for (int i = l; i <= r; i++) {
 //        maxv = max(maxv, arr[i]);
-//        sum[arr[i]]++;
+//        cntv[arr[i]]++;
 //    }
 //    for (int v = 0; v <= maxv; v++) {
 //        fa[v] = v;

From de036d55df98e29a2c35b93a7ea1d3bec7063c57 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 19:47:58 +0800
Subject: [PATCH 1176/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 2 +-
 src/class174/Code03_ColorfulWorld2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 09e962330..8e89ac698 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -34,8 +34,8 @@ public class Code03_ColorfulWorld1 {
 	public static int[] qr = new int[MAXM];
 	public static int[] qx = new int[MAXM];
 
-	public static int[] pre0 = new int[MAXN];
 	public static int[] fa = new int[MAXV];
+	public static int[] pre0 = new int[MAXN];
 	public static int[] cntv = new int[MAXV];
 
 	public static int[] ans = new int[MAXM];
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 5cae34136..7907295fd 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -28,8 +28,8 @@
 //int qr[MAXM];
 //int qx[MAXM];
 //
-//int pre0[MAXN];
 //int fa[MAXV];
+//int pre0[MAXN];
 //int cntv[MAXV];
 //
 //int ans[MAXM];

From 1a73475ce48dd81f90c3875aa33a8c98aa3252da Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 19:54:49 +0800
Subject: [PATCH 1177/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 8 +++++++-
 src/class174/Code03_ColorfulWorld2.java | 2 +-
 2 files changed, 8 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 8e89ac698..14f5577a9 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -26,7 +26,6 @@ public class Code03_ColorfulWorld1 {
 	public static int MAXV = 100002;
 	public static int n, m;
 	public static int blen, bnum;
-	public static int maxv, lazy;
 
 	public static int[] arr = new int[MAXN];
 	public static int[] op = new int[MAXM];
@@ -34,10 +33,17 @@ public class Code03_ColorfulWorld1 {
 	public static int[] qr = new int[MAXM];
 	public static int[] qx = new int[MAXM];
 
+	// maxv代表一个序列块中的最大值
+	// lazy代表一个序列块中，所有数字需要统计减去多少
+	// fa代表值域并查集
+	// pre0代表数组前缀上0的词频统计
+	// cntv代表一个序列块中每种值的词频统计
+	public static int maxv, lazy;
 	public static int[] fa = new int[MAXV];
 	public static int[] pre0 = new int[MAXN];
 	public static int[] cntv = new int[MAXV];
 
+	// 查询的答案
 	public static int[] ans = new int[MAXM];
 
 	public static int find(int x) {
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 7907295fd..130aab998 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -20,7 +20,6 @@
 //const int MAXV = 100002;
 //int n, m;
 //int blen, bnum;
-//int maxv, lazy;
 //
 //int arr[MAXN];
 //int op[MAXM];
@@ -28,6 +27,7 @@
 //int qr[MAXM];
 //int qx[MAXM];
 //
+//int maxv, lazy;
 //int fa[MAXV];
 //int pre0[MAXN];
 //int cntv[MAXV];

From b6d244f4f59b820c3b2090d142b1936ba32b086e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 20:00:09 +0800
Subject: [PATCH 1178/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 14f5577a9..00ba1a1bc 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -46,6 +46,7 @@ public class Code03_ColorfulWorld1 {
 	// 查询的答案
 	public static int[] ans = new int[MAXM];
 
+	// 查询x值变成了什么
 	public static int find(int x) {
 		if (x != fa[x]) {
 			fa[x] = find(fa[x]);
@@ -53,10 +54,12 @@ public static int find(int x) {
 		return fa[x];
 	}
 
+	// 所有x值变成y值
 	public static void union(int x, int y) {
 		fa[find(x)] = find(y);
 	}
 
+	// 根据值域并查集的修改结果，把修改写入arr[l..r]
 	public static void down(int l, int r) {
 		for (int i = l; i <= r; i++) {
 			arr[i] = find(arr[i]);

From 0f3c89ba5bfa4ccd33015cd784fe7c4c82a2b8b8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 20:01:48 +0800
Subject: [PATCH 1179/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 00ba1a1bc..7b94bdb29 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -59,7 +59,7 @@ public static void union(int x, int y) {
 		fa[find(x)] = find(y);
 	}
 
-	// 根据值域并查集的修改结果，把修改写入arr[l..r]
+	// 修改保留在值域并查集，把真实值写入arr[l..r]
 	public static void down(int l, int r) {
 		for (int i = l; i <= r; i++) {
 			arr[i] = find(arr[i]);

From 94a53a7ab5a9f37037ab99bc7d1307e46c9d98db Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 20:08:06 +0800
Subject: [PATCH 1180/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 2 +-
 src/class174/Code03_ColorfulWorld2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 7b94bdb29..7e03b8b15 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -3,7 +3,7 @@
 // 五彩斑斓的世界，java版
 // 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
 // 操作 1 l r x : arr[l..r]范围上，所有大于x的数减去x
-// 操作 2 l r x : arr[l..l]范围上，查询x出现的次数
+// 操作 2 l r x : arr[l..r]范围上，查询x出现的次数
 // 1 <= n <= 10^6
 // 1 <= m <= 5 * 10^5
 // 0 <= arr[i]、x <= 10^5
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 130aab998..6c0f4d5c7 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -3,7 +3,7 @@
 // 五彩斑斓的世界，C++版
 // 给定一个长度为n的数组arr，一共有m条操作，每条操作类型如下
 // 操作 1 l r x : arr[l..r]范围上，所有大于x的数减去x
-// 操作 2 l r x : arr[l..l]范围上，查询x出现的次数
+// 操作 2 l r x : arr[l..r]范围上，查询x出现的次数
 // 1 <= n <= 10^6
 // 1 <= m <= 5 * 10^5
 // 0 <= arr[i]、x <= 10^5

From 280eb3f26e12777cae3852f97d584a1ffe8f3369 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 21:23:54 +0800
Subject: [PATCH 1181/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 7e03b8b15..8ee1cdcc2 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -59,7 +59,7 @@ public static void union(int x, int y) {
 		fa[find(x)] = find(y);
 	}
 
-	// 修改保留在值域并查集，把真实值写入arr[l..r]
+	// 修改保留在值域并查集，把修改写入arr[l..r]
 	public static void down(int l, int r) {
 		for (int i = l; i <= r; i++) {
 			arr[i] = find(arr[i]);

From 503a4c91658ef3235746602cb14bc423bbf622c3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 21:28:48 +0800
Subject: [PATCH 1182/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 2 +-
 src/class174/Code03_ColorfulWorld2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 8ee1cdcc2..0a3d34229 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -80,7 +80,7 @@ public static void update(int qi, int l, int r) {
 				}
 				lazy += jobx;
 			} else {
-				for (int v = maxv; v > lazy + jobx; v--) {
+				for (int v = lazy + jobx + 1; v <= maxv; v++) {
 					cntv[v - jobx] += cntv[v];
 					cntv[v] = 0;
 					union(v, v - jobx);
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index 6c0f4d5c7..b1ead2e55 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -65,7 +65,7 @@
 //            }
 //            lazy += jobx;
 //        } else {
-//            for (int v = maxv; v > lazy + jobx; v--) {
+//            for (int v = lazy + jobx + 1; v <= maxv; v++) {
 //                cntv[v - jobx] += cntv[v];
 //                cntv[v] = 0;
 //                Union(v, v - jobx);

From 139aea758cdfc92b20317834aae1437217ca928a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 15 Jul 2025 22:14:59 +0800
Subject: [PATCH 1183/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 8 ++++----
 src/class174/Code03_ColorfulWorld2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index 0a3d34229..dc9dfb990 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -55,8 +55,8 @@ public static int find(int x) {
 	}
 
 	// 所有x值变成y值
-	public static void union(int x, int y) {
-		fa[find(x)] = find(y);
+	public static void change(int x, int y) {
+		fa[x] = y;
 	}
 
 	// 修改保留在值域并查集，把修改写入arr[l..r]
@@ -76,14 +76,14 @@ public static void update(int qi, int l, int r) {
 				for (int v = lazy + 1; v <= lazy + jobx; v++) {
 					cntv[v + jobx] += cntv[v];
 					cntv[v] = 0;
-					union(v, v + jobx);
+					change(v, v + jobx);
 				}
 				lazy += jobx;
 			} else {
 				for (int v = lazy + jobx + 1; v <= maxv; v++) {
 					cntv[v - jobx] += cntv[v];
 					cntv[v] = 0;
-					union(v, v - jobx);
+					change(v, v - jobx);
 				}
 				for (int v = maxv; v >= 0; v--) {
 					if (cntv[v] != 0) {
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index b1ead2e55..befc8e922 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -41,8 +41,8 @@
 //    return fa[x];
 //}
 //
-//void Union(int x, int y) {
-//    fa[find(x)] = find(y);
+//void change(int x, int y) {
+//    fa[x] = y;
 //}
 //
 //void down(int l, int r) {
@@ -61,14 +61,14 @@
 //            for (int v = lazy + 1; v <= lazy + jobx; v++) {
 //                cntv[v + jobx] += cntv[v];
 //                cntv[v] = 0;
-//                Union(v, v + jobx);
+//                change(v, v + jobx);
 //            }
 //            lazy += jobx;
 //        } else {
 //            for (int v = lazy + jobx + 1; v <= maxv; v++) {
 //                cntv[v - jobx] += cntv[v];
 //                cntv[v] = 0;
-//                Union(v, v - jobx);
+//                change(v, v - jobx);
 //            }
 //            for (int v = maxv; v >= 0; v--) {
 //                if (cntv[v] != 0) {

From fd96ab2acc8cbce4ed82e76d83bbba1fc2a89516 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 12:32:09 +0800
Subject: [PATCH 1184/1712] modify code

---
 src/class174/Code04_Bridge1.java | 26 +++++++++++++-------------
 src/class174/Code04_Bridge2.java | 26 +++++++++++++-------------
 src/class174/Code05_Lcm1.java    | 18 ++++++++----------
 src/class174/Code05_Lcm2.java    | 14 +++++++-------
 4 files changed, 41 insertions(+), 43 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 872846f23..00d8069f8 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -137,25 +137,25 @@ public static void compute(int l, int r) {
 			}
 		}
 		sort(query, car, 1, cntq);
-		int k = 1;
-		for (int i = 1; i <= cntq; i++) {
-			for (; k <= m && w[edge[k]] >= car[query[i]]; k++) {
-				if (!vis[edge[k]]) {
-					union(u[edge[k]], v[edge[k]]);
+		for (int i = 1, j = 1; i <= cntq; i++) {
+			while (j <= m && w[edge[j]] >= car[query[i]]) {
+				if (!vis[edge[j]]) {
+					union(u[edge[j]], v[edge[j]]);
 				}
+				j++;
 			}
 			opsize = 0;
-			for (int j = 1; j <= cntu; j++) {
-				curw[eid[update[j]]] = w[eid[update[j]]];
+			for (int k = 1; k <= cntu; k++) {
+				curw[eid[update[k]]] = w[eid[update[k]]];
 			}
-			for (int j = 1; j <= cntu; j++) {
-				if (update[j] < query[i]) {
-					curw[eid[update[j]]] = tow[update[j]];
+			for (int k = 1; k <= cntu; k++) {
+				if (update[k] < query[i]) {
+					curw[eid[update[k]]] = tow[update[k]];
 				}
 			}
-			for (int j = 1; j <= cntu; j++) {
-				if (curw[eid[update[j]]] >= car[query[i]]) {
-					union(u[eid[update[j]]], v[eid[update[j]]]);
+			for (int k = 1; k <= cntu; k++) {
+				if (curw[eid[update[k]]] >= car[query[i]]) {
+					union(u[eid[update[k]]], v[eid[update[k]]]);
 				}
 			}
 			ans[query[i]] = siz[find(nid[query[i]])];
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index b6b03dd8f..ed4ae15c9 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -114,25 +114,25 @@
 //        }
 //    }
 //    sort(query + 1, query + cntq + 1, [&](int x, int y) { return car[x] > car[y]; });
-//    int k = 1;
-//    for (int i = 1; i <= cntq; i++) {
-//        for (; k <= m && w[edge[k]] >= car[query[i]]; k++) {
-//            if (!vis[edge[k]]) {
-//                Union(u[edge[k]], v[edge[k]]);
+//    for (int i = 1, j = 1; i <= cntq; i++) {
+//        while (j <= m && w[edge[j]] >= car[query[i]]) {
+//            if (!vis[edge[j]]) {
+//                Union(u[edge[j]], v[edge[j]]);
 //            }
+//            j++;
 //        }
 //        opsize = 0;
-//        for (int j = 1; j <= cntu; j++) {
-//            curw[eid[update[j]]] = w[eid[update[j]]];
+//        for (int k = 1; k <= cntu; k++) {
+//            curw[eid[update[k]]] = w[eid[update[k]]];
 //        }
-//        for (int j = 1; j <= cntu; j++) {
-//            if (update[j] < query[i]) {
-//                curw[eid[update[j]]] = tow[update[j]];
+//        for (int k = 1; k <= cntu; k++) {
+//            if (update[k] < query[i]) {
+//                curw[eid[update[k]]] = tow[update[k]];
 //            }
 //        }
-//        for (int j = 1; j <= cntu; j++) {
-//            if (curw[eid[update[j]]] >= car[query[i]]) {
-//                Union(u[eid[update[j]]], v[eid[update[j]]]);
+//        for (int k = 1; k <= cntu; k++) {
+//            if (curw[eid[update[k]]] >= car[query[i]]) {
+//                Union(u[eid[update[k]]], v[eid[update[k]]]);
 //            }
 //        }
 //        ans[query[i]] = siz[find(nid[query[i]])];
diff --git a/src/class174/Code05_Lcm1.java b/src/class174/Code05_Lcm1.java
index 50a725271..65c62021d 100644
--- a/src/class174/Code05_Lcm1.java
+++ b/src/class174/Code05_Lcm1.java
@@ -127,19 +127,17 @@ public static void compute(int l, int r) {
 			}
 		}
 		if (cntq > 0) {
-			// 可以使用额外的数组，每块内部根据b进行排序
-			// 每次把新块归并进来，保证 1..l-1 范围根据b有序
-			// 可以省掉一个log的复杂度，本题不做这个优化也能通过，索性算了
+			// 本题直接排序能通过，就不写归并了
 			sort(edge, eb, 1, l - 1);
-			int pos = 1;
-			for (int i = 1; i <= cntq; i++) {
-				for (; pos < l && eb[edge[pos]] <= qb[cur[i]]; pos++) {
-					union(eu[edge[pos]], ev[edge[pos]], ea[edge[pos]], eb[edge[pos]]);
+			for (int i = 1, j = 1; i <= cntq; i++) {
+				while (j < l && eb[edge[j]] <= qb[cur[i]]) {
+					union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
+					j++;
 				}
 				opsize = 0;
-				for (int j = l; j <= r; j++) {
-					if (ea[edge[j]] <= qa[cur[i]] && eb[edge[j]] <= qb[cur[i]]) {
-						union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
+				for (int k = l; k <= r; k++) {
+					if (ea[edge[k]] <= qa[cur[i]] && eb[edge[k]] <= qb[cur[i]]) {
+						union(eu[edge[k]], ev[edge[k]], ea[edge[k]], eb[edge[k]]);
 					}
 				}
 				ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
diff --git a/src/class174/Code05_Lcm2.java b/src/class174/Code05_Lcm2.java
index 80b7aee91..38c9692c6 100644
--- a/src/class174/Code05_Lcm2.java
+++ b/src/class174/Code05_Lcm2.java
@@ -108,15 +108,15 @@
 //    }
 //    if (cntq > 0) {
 //        sort(edge + 1, edge + l, [&](int x, int y) { return eb[x] < eb[y]; });
-//        int pos = 1;
-//        for (int i = 1; i <= cntq; i++) {
-//            for (; pos < l && eb[edge[pos]] <= qb[cur[i]]; pos++) {
-//                Union(eu[edge[pos]], ev[edge[pos]], ea[edge[pos]], eb[edge[pos]]);
+//        for (int i = 1, j = 1; i <= cntq; i++) {
+//            while (j < l && eb[edge[j]] <= qb[cur[i]]) {
+//                Union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
+//                j++;
 //            }
 //            opsize = 0;
-//            for (int j = l; j <= r; j++) {
-//                if (ea[edge[j]] <= qa[cur[i]] && eb[edge[j]] <= qb[cur[i]]) {
-//            	      Union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
+//            for (int k = l; k <= r; k++) {
+//                if (ea[edge[k]] <= qa[cur[i]] && eb[edge[k]] <= qb[cur[i]]) {
+//            	      Union(eu[edge[k]], ev[edge[k]], ea[edge[k]], eb[edge[k]]);
 //                }
 //            }
 //            ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);

From a47e05facac1098a2572cd4b5f9df2aaa72ba49f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 13:19:06 +0800
Subject: [PATCH 1185/1712] modify code

---
 src/class174/Code04_Bridge1.java | 13 ++++++-------
 src/class174/Code04_Bridge2.java | 13 ++++++-------
 2 files changed, 12 insertions(+), 14 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 00d8069f8..d11c9cf8a 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -36,21 +36,20 @@ public class Code04_Bridge1 {
 	public static int[] nid = new int[MAXQ];
 	public static int[] car = new int[MAXQ];
 
-	public static int[] fa = new int[MAXN];
-	public static int[] siz = new int[MAXN];
-	public static int[][] rollback = new int[MAXM][2];
-	public static int opsize = 0;
-
 	public static int[] edge = new int[MAXM];
 	public static int[] change = new int[MAXM];
 	public static int[] unchange = new int[MAXM];
+	public static boolean[] vis = new boolean[MAXM];
+	public static int[] curw = new int[MAXM];
 
 	public static int[] operate = new int[MAXQ];
 	public static int[] update = new int[MAXQ];
 	public static int[] query = new int[MAXQ];
 
-	public static boolean[] vis = new boolean[MAXM];
-	public static int[] curw = new int[MAXM];
+	public static int[] fa = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[][] rollback = new int[MAXM][2];
+	public static int opsize = 0;
 
 	public static int[] ans = new int[MAXQ];
 
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index ed4ae15c9..f4a2b4c5e 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -33,21 +33,20 @@
 //int nid[MAXQ];
 //int car[MAXQ];
 //
-//int fa[MAXN];
-//int siz[MAXN];
-//int rollback[MAXM][2];
-//int opsize = 0;
-//
 //int edge[MAXM];
 //int change[MAXM];
 //int unchange[MAXM];
+//bool vis[MAXM];
+//int curw[MAXM];
 //
 //int operate[MAXQ];
 //int update[MAXQ];
 //int query[MAXQ];
 //
-//bool vis[MAXM];
-//int curw[MAXM];
+//int fa[MAXN];
+//int siz[MAXN];
+//int rollback[MAXM][2];
+//int opsize = 0;
 //
 //int ans[MAXQ];
 //

From 7bc7d4add02e516d53291f694e387089e161a344 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 13:30:45 +0800
Subject: [PATCH 1186/1712] modify code

---
 src/class174/Code04_Bridge1.java | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index d11c9cf8a..90a5ebcae 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -53,25 +53,25 @@ public class Code04_Bridge1 {
 
 	public static int[] ans = new int[MAXQ];
 
-	// idx[l..r]由序号组成，v[序号]的值越大，序号越靠前，手写双指针快排
-	public static void sort(int[] idx, int[] v, int l, int r) {
+	// idx[l..r]都是编号，编号根据val[编号]的值从大到小排序，手写双指针快排
+	public static void sort(int[] idx, int[] val, int l, int r) {
 		if (l >= r) return;
-		int i = l, j = r, pivot = v[idx[(l + r) >> 1]], tmp;
+		int i = l, j = r, pivot = val[idx[(l + r) >> 1]], tmp;
 		while (i <= j) {
-			while (v[idx[i]] > pivot) i++;
-			while (v[idx[j]] < pivot) j--;
+			while (val[idx[i]] > pivot) i++;
+			while (val[idx[j]] < pivot) j--;
 			if (i <= j) {
 				tmp = idx[i]; idx[i] = idx[j]; idx[j] = tmp;
 				i++; j--;
 			}
 		}
-		sort(idx, v, l, j);
-		sort(idx, v, i, r);
+		sort(idx, val, l, j);
+		sort(idx, val, i, r);
 	}
 
-	// change[l1..r1]都是边的序号，已经有序了，w[序号]的值越大，序号越靠前
-	// unchange[l2..r2]都是边的序号，已经有序了，w[序号]的值越大，序号越靠前
-	// 把两个数组中的序号，根据w[序号]的值，归并到eid中
+	// change[l1..r1]和unchange[l2..r2]都是边的序号
+	// 各自的数组中，序号是有序的，w[序号]的值越大，序号越靠前
+	// 归并两个数组的序号
 	public static void merge(int l1, int r1, int l2, int r2) {
 		int i = 0;
 		while (l1 <= r1 && l2 <= r2) {

From a5910ec20e03502244e8c59cc429238d61f714cc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 13:59:37 +0800
Subject: [PATCH 1187/1712] modify code

---
 src/class174/Code04_Bridge1.java | 22 +++++---------
 src/class174/Code04_Bridge2.java |  8 ++---
 src/class174/Code05_Lcm1.java    | 52 ++++++++++++--------------------
 src/class174/Code05_Lcm2.java    | 30 ++++++++----------
 4 files changed, 40 insertions(+), 72 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 90a5ebcae..149c7e5c0 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -175,23 +175,13 @@ public static void compute(int l, int r) {
 		merge(1, siz1, 1, siz2);
 	}
 
-	public static int log2(int n) {
-		int ans = 0;
-		while ((1 << ans) <= (n >> 1)) {
-			ans++;
-		}
-		return ans;
-	}
-
 	public static void prepare() {
-		blen = Math.max(1, (int) Math.sqrt(q * log2(n)));
-		bnum = (q + blen - 1) / blen;
-		for (int i = 1; i <= m; i++) {
-			edge[i] = i;
-		}
-		for (int i = 1; i <= q; i++) {
-			operate[i] = i;
+		int log2n = 0;
+		while ((1 << log2n) <= (n >> 1)) {
+			log2n++;
 		}
+		blen = Math.max(1, (int) Math.sqrt(q * log2n));
+		bnum = (q + blen - 1) / blen;
 		sort(edge, w, 1, m);
 	}
 
@@ -204,6 +194,7 @@ public static void main(String[] args) throws IOException {
 			u[i] = in.nextInt();
 			v[i] = in.nextInt();
 			w[i] = in.nextInt();
+			edge[i] = i;
 		}
 		q = in.nextInt();
 		for (int i = 1; i <= q; i++) {
@@ -215,6 +206,7 @@ public static void main(String[] args) throws IOException {
 				nid[i] = in.nextInt();
 				car[i] = in.nextInt();
 			}
+			operate[i] = i;
 		}
 		prepare();
 		for (int i = 1, l, r; i <= bnum; i++) {
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index f4a2b4c5e..1613e76b5 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -155,12 +155,6 @@
 //void prepare() {
 //    blen = max(1, (int)sqrt(q * log2(n)));
 //    bnum = (q + blen - 1) / blen;
-//    for (int i = 1; i <= m; i++) {
-//        edge[i] = i;
-//    }
-//    for (int i = 1; i <= q; i++) {
-//        operate[i] = i;
-//    }
 //    sort(edge + 1, edge + m + 1, [&](int x, int y) { return w[x] > w[y]; });
 //}
 //
@@ -170,6 +164,7 @@
 //    cin >> n >> m;
 //    for (int i = 1; i <= m; i++) {
 //        cin >> u[i] >> v[i] >> w[i];
+//        edge[i] = i;
 //    }
 //    cin >> q;
 //    for (int i = 1; i <= q; i++) {
@@ -179,6 +174,7 @@
 //        } else {
 //            cin >> nid[i] >> car[i];
 //        }
+//        operate[i] = i;
 //    }
 //    prepare();
 //    for (int i = 1, l, r; i <= bnum; i++) {
diff --git a/src/class174/Code05_Lcm1.java b/src/class174/Code05_Lcm1.java
index 65c62021d..afe4b8317 100644
--- a/src/class174/Code05_Lcm1.java
+++ b/src/class174/Code05_Lcm1.java
@@ -33,13 +33,12 @@ public class Code05_Lcm1 {
 	public static int[] qv = new int[MAXQ];
 	public static int[] qa = new int[MAXQ];
 	public static int[] qb = new int[MAXQ];
-	public static int[] qid = new int[MAXQ];
 
 	public static int[] edge = new int[MAXM];
-	public static int[] ques = new int[MAXQ];
+	public static int[] query = new int[MAXQ];
 
 	public static int[] cur = new int[MAXQ];
-	public static int cntq = 0;
+	public static int cursiz = 0;
 
 	public static int[] fa = new int[MAXN];
 	public static int[] siz = new int[MAXN];
@@ -111,7 +110,7 @@ public static void undo() {
 		}
 	}
 
-	public static boolean query(int x, int y, int a, int b) {
+	public static boolean check(int x, int y, int a, int b) {
 		int fx = find(x);
 		int fy = find(y);
 		return fx == fy && maxa[fx] == a && maxb[fx] == b;
@@ -119,17 +118,17 @@ public static boolean query(int x, int y, int a, int b) {
 
 	public static void compute(int l, int r) {
 		build();
-		cntq = 0;
+		cursiz = 0;
 		for (int i = 1; i <= q; i++) {
-			// 保证每条询问只落入其中的一块
-			if (ea[edge[l]] <= qa[ques[i]] && (r + 1 > m || qa[ques[i]] < ea[edge[r + 1]])) {
-				cur[++cntq] = ques[i];
+			// 保证每条查询只在一个边的序列块中处理
+			if (ea[edge[l]] <= qa[query[i]] && (r + 1 > m || qa[query[i]] < ea[edge[r + 1]])) {
+				cur[++cursiz] = query[i];
 			}
 		}
-		if (cntq > 0) {
+		if (cursiz > 0) {
 			// 本题直接排序能通过，就不写归并了
 			sort(edge, eb, 1, l - 1);
-			for (int i = 1, j = 1; i <= cntq; i++) {
+			for (int i = 1, j = 1; i <= cursiz; i++) {
 				while (j < l && eb[edge[j]] <= qb[cur[i]]) {
 					union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
 					j++;
@@ -140,31 +139,21 @@ public static void compute(int l, int r) {
 						union(eu[edge[k]], ev[edge[k]], ea[edge[k]], eb[edge[k]]);
 					}
 				}
-				ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
+				ans[cur[i]] = check(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
 				undo();
 			}
 		}
 	}
 
-	public static int log2(int n) {
-		int ans = 0;
-		while ((1 << ans) <= (n >> 1)) {
-			ans++;
-		}
-		return ans;
-	}
-
 	public static void prepare() {
-		blen = Math.max(1, (int) Math.sqrt(m * log2(n)));
-		bnum = (m + blen - 1) / blen;
-		for (int i = 1; i <= m; i++) {
-			edge[i] = i;
-		}
-		for (int i = 1; i <= q; i++) {
-			ques[i] = i;
+		int log2n = 0;
+		while ((1 << log2n) <= (n >> 1)) {
+			log2n++;
 		}
+		blen = Math.max(1, (int) Math.sqrt(m * log2n));
+		bnum = (m + blen - 1) / blen;
 		sort(edge, ea, 1, m);
-		sort(ques, qb, 1, q);
+		sort(query, qb, 1, q);
 	}
 
 	public static void main(String[] args) throws IOException {
@@ -177,6 +166,7 @@ public static void main(String[] args) throws IOException {
 			ev[i] = in.nextInt();
 			ea[i] = in.nextInt();
 			eb[i] = in.nextInt();
+			edge[i] = i;
 		}
 		q = in.nextInt();
 		for (int i = 1; i <= q; i++) {
@@ -184,7 +174,7 @@ public static void main(String[] args) throws IOException {
 			qv[i] = in.nextInt();
 			qa[i] = in.nextInt();
 			qb[i] = in.nextInt();
-			qid[i] = i;
+			query[i] = i;
 		}
 		prepare();
 		for (int i = 1, l, r; i <= bnum; i++) {
@@ -193,11 +183,7 @@ public static void main(String[] args) throws IOException {
 			compute(l, r);
 		}
 		for (int i = 1; i <= q; i++) {
-			if (ans[i]) {
-				out.println("Yes");
-			} else {
-				out.println("No");
-			}
+			out.println(ans[i] ? "Yes" : "No");
 		}
 		out.flush();
 		out.close();
diff --git a/src/class174/Code05_Lcm2.java b/src/class174/Code05_Lcm2.java
index 38c9692c6..57faf78d4 100644
--- a/src/class174/Code05_Lcm2.java
+++ b/src/class174/Code05_Lcm2.java
@@ -31,13 +31,12 @@
 //int qv[MAXQ];
 //int qa[MAXQ];
 //int qb[MAXQ];
-//int qid[MAXQ];
 //
 //int edge[MAXM];
-//int ques[MAXQ];
+//int query[MAXQ];
 //
 //int cur[MAXQ];
-//int cntq = 0;
+//int cursiz;
 //
 //int fa[MAXN];
 //int siz[MAXN];
@@ -93,22 +92,22 @@
 //    }
 //}
 //
-//bool query(int x, int y, int a, int b) {
+//bool check(int x, int y, int a, int b) {
 //    int fx = find(x), fy = find(y);
 //    return fx == fy && maxa[fx] == a && maxb[fx] == b;
 //}
 //
 //void compute(int l, int r) {
 //    build();
-//    cntq = 0;
+//    cursiz = 0;
 //    for (int i = 1; i <= q; i++) {
-//        if (ea[edge[l]] <= qa[ques[i]] && (r + 1 > m || qa[ques[i]] < ea[edge[r + 1]])) {
-//            cur[++cntq] = ques[i];
+//        if (ea[edge[l]] <= qa[query[i]] && (r + 1 > m || qa[query[i]] < ea[edge[r + 1]])) {
+//            cur[++cursiz] = query[i];
 //        }
 //    }
-//    if (cntq > 0) {
+//    if (cursiz > 0) {
 //        sort(edge + 1, edge + l, [&](int x, int y) { return eb[x] < eb[y]; });
-//        for (int i = 1, j = 1; i <= cntq; i++) {
+//        for (int i = 1, j = 1; i <= cursiz; i++) {
 //            while (j < l && eb[edge[j]] <= qb[cur[i]]) {
 //                Union(eu[edge[j]], ev[edge[j]], ea[edge[j]], eb[edge[j]]);
 //                j++;
@@ -119,7 +118,7 @@
 //            	      Union(eu[edge[k]], ev[edge[k]], ea[edge[k]], eb[edge[k]]);
 //                }
 //            }
-//            ans[qid[cur[i]]] = query(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
+//            ans[cur[i]] = check(qu[cur[i]], qv[cur[i]], qa[cur[i]], qb[cur[i]]);
 //            undo();
 //        }
 //    }
@@ -128,14 +127,8 @@
 //void prepare() {
 //    blen = max(1, (int)sqrt(m * log2(n)));
 //    bnum = (m + blen - 1) / blen;
-//    for (int i = 1; i <= m; i++) {
-//        edge[i] = i;
-//    }
-//    for (int i = 1; i <= q; i++) {
-//        ques[i] = i;
-//    }
 //    sort(edge + 1, edge + m + 1, [&](int x, int y) { return ea[x] < ea[y]; });
-//    sort(ques + 1, ques + q + 1, [&](int x, int y) { return qb[x] < qb[y]; });
+//    sort(query + 1, query + q + 1, [&](int x, int y) { return qb[x] < qb[y]; });
 //}
 //
 //int main() {
@@ -144,11 +137,12 @@
 //    cin >> n >> m;
 //    for (int i = 1; i <= m; i++) {
 //        cin >> eu[i] >> ev[i] >> ea[i] >> eb[i];
+//        edge[i] = i;
 //    }
 //    cin >> q;
 //    for (int i = 1; i <= q; i++) {
 //        cin >> qu[i] >> qv[i] >> qa[i] >> qb[i];
-//        qid[i] = i;
+//        query[i] = i;
 //    }
 //    prepare();
 //    for (int i = 1, l, r; i <= bnum; i++) {

From 047674b0cf9b7cf5ae8d9cecd6630aea51bc8f1a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 15:02:06 +0800
Subject: [PATCH 1188/1712] modify code

---
 src/class174/Code03_ColorfulWorld1.java | 2 +-
 src/class174/Code03_ColorfulWorld2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code03_ColorfulWorld1.java b/src/class174/Code03_ColorfulWorld1.java
index dc9dfb990..5be4c84f3 100644
--- a/src/class174/Code03_ColorfulWorld1.java
+++ b/src/class174/Code03_ColorfulWorld1.java
@@ -147,7 +147,7 @@ public static void compute(int l, int r) {
 	}
 
 	public static void prepare() {
-		blen = (int) Math.sqrt(n * 3.0);
+		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			pre0[i] = pre0[i - 1] + (arr[i] == 0 ? 1 : 0);
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index befc8e922..f6e0adb06 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -132,7 +132,7 @@
 //}
 //
 //void prepare() {
-//    blen = (int)sqrt(n * 3.0);
+//    blen = (int)sqrt(n);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
 //        pre0[i] = pre0[i - 1] + (arr[i] == 0 ? 1 : 0);

From 7689795c3a22a5287abcf77e34277004fd6cf8f0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 17:58:56 +0800
Subject: [PATCH 1189/1712] modify code

---
 src/class174/Code04_Bridge1.java | 88 ++++++++++++++++++--------------
 src/class174/Code04_Bridge2.java | 65 ++++++++++++-----------
 2 files changed, 81 insertions(+), 72 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 149c7e5c0..609ca2cfa 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -37,9 +37,7 @@ public class Code04_Bridge1 {
 	public static int[] car = new int[MAXQ];
 
 	public static int[] edge = new int[MAXM];
-	public static int[] change = new int[MAXM];
-	public static int[] unchange = new int[MAXM];
-	public static boolean[] vis = new boolean[MAXM];
+	public static boolean[] change = new boolean[MAXM];
 	public static int[] curw = new int[MAXM];
 
 	public static int[] operate = new int[MAXQ];
@@ -51,6 +49,9 @@ public class Code04_Bridge1 {
 	public static int[][] rollback = new int[MAXM][2];
 	public static int opsize = 0;
 
+	public static int[] arr1 = new int[MAXM];
+	public static int[] arr2 = new int[MAXM];
+
 	public static int[] ans = new int[MAXQ];
 
 	// idx[l..r]都是编号，编号根据val[编号]的值从大到小排序，手写双指针快排
@@ -69,22 +70,6 @@ public static void sort(int[] idx, int[] val, int l, int r) {
 		sort(idx, val, i, r);
 	}
 
-	// change[l1..r1]和unchange[l2..r2]都是边的序号
-	// 各自的数组中，序号是有序的，w[序号]的值越大，序号越靠前
-	// 归并两个数组的序号
-	public static void merge(int l1, int r1, int l2, int r2) {
-		int i = 0;
-		while (l1 <= r1 && l2 <= r2) {
-			edge[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
-		}
-		while (l1 <= r1) {
-			edge[++i] = change[l1++];
-		}
-		while (l2 <= r2) {
-			edge[++i] = unchange[l2++];
-		}
-	}
-
 	public static void build() {
 		for (int i = 1; i <= n; i++) {
 			fa[i] = i;
@@ -123,56 +108,81 @@ public static void undo() {
 		}
 	}
 
+	public static void merge() {
+		int siz1 = 0, siz2 = 0;
+		for (int i = 1; i <= m; i++) {
+			if (change[edge[i]]) {
+				arr1[++siz1] = edge[i];
+			} else {
+				arr2[++siz2] = edge[i];
+			}
+		}
+		sort(arr1, w, 1, siz1);
+		int i = 0, p1 = 1, p2 = 1;
+		while (p1 <= siz1 && p2 <= siz2) {
+			edge[++i] = w[arr1[p1]] >= w[arr2[p2]] ? arr1[p1++] : arr2[p2++];
+		}
+		while (p1 <= siz1) {
+			edge[++i] = arr1[p1++];
+		}
+		while (p2 <= siz2) {
+			edge[++i] = arr2[p2++];
+		}
+	}
+
+	// 当前操作序号[l..r]，之前的所有修改操作都已生效
+	// 所有边的序号edge[1..m]，按照边权从大到小排序
+	// 处理当前操作块的所有操作
 	public static void compute(int l, int r) {
-		build();
-		Arrays.fill(vis, false);
+		build(); // 重建并查集，目前没有任何联通性
+		Arrays.fill(change, false); // 清空边的修改标记
 		int cntu = 0, cntq = 0;
 		for (int i = l; i <= r; i++) {
-			if (op[operate[i]] == 1) {
-				vis[eid[operate[i]]] = true;
+			if (op[operate[i]] == 1) { // 修改类型的操作
+				change[eid[operate[i]]] = true;
 				update[++cntu] = operate[i];
-			} else {
+			} else { // 查询类型的操作
 				query[++cntq] = operate[i];
 			}
 		}
+		// 查询操作的所有序号，根据车重从大到小排序
+		// 然后依次处理所有查询
 		sort(query, car, 1, cntq);
 		for (int i = 1, j = 1; i <= cntq; i++) {
+			// 边权 >= 当前车重 的边全部连上，注意这是不回退的
 			while (j <= m && w[edge[j]] >= car[query[i]]) {
-				if (!vis[edge[j]]) {
+				if (!change[edge[j]]) {
 					union(u[edge[j]], v[edge[j]]);
 				}
 				j++;
 			}
+			// 注意需要用可撤销并查集，撤销会改值的边
 			opsize = 0;
+			// 会改值的边，边权先继承改之前的值
 			for (int k = 1; k <= cntu; k++) {
 				curw[eid[update[k]]] = w[eid[update[k]]];
 			}
-			for (int k = 1; k <= cntu; k++) {
-				if (update[k] < query[i]) {
-					curw[eid[update[k]]] = tow[update[k]];
-				}
+			// 修改操作的时序 < 当前查询操作的时序，那么相关边的边权改成最新值
+			for (int k = 1; k <= cntu && update[k] < query[i]; k++) {
+				curw[eid[update[k]]] = tow[update[k]];
 			}
+			// 会改值的边，其中 边权 >= 当前车重 的边全部连上
 			for (int k = 1; k <= cntu; k++) {
 				if (curw[eid[update[k]]] >= car[query[i]]) {
 					union(u[eid[update[k]]], v[eid[update[k]]]);
 				}
 			}
+			// 并查集修改完毕，查询答案
 			ans[query[i]] = siz[find(nid[query[i]])];
+			// 并查集的撤销
 			undo();
 		}
+		// 所有会改值的边，边权修改，因为即将去下个操作块
 		for (int i = 1; i <= cntu; i++) {
 			w[eid[update[i]]] = tow[update[i]];
 		}
-		int siz1 = 0, siz2 = 0;
-		for (int i = 1; i <= m; i++) {
-			if (vis[edge[i]]) {
-				change[++siz1] = edge[i];
-			} else {
-				unchange[++siz2] = edge[i];
-			}
-		}
-		sort(change, w, 1, siz1);
-		merge(1, siz1, 1, siz2);
+		// 没改值的边和改了值的边，根据边权从大到小合并
+		merge();
 	}
 
 	public static void prepare() {
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index 1613e76b5..2e0d68ef8 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -34,9 +34,7 @@
 //int car[MAXQ];
 //
 //int edge[MAXM];
-//int change[MAXM];
-//int unchange[MAXM];
-//bool vis[MAXM];
+//bool change[MAXM];
 //int curw[MAXM];
 //
 //int operate[MAXQ];
@@ -48,20 +46,10 @@
 //int rollback[MAXM][2];
 //int opsize = 0;
 //
-//int ans[MAXQ];
+//int arr1[MAXM];
+//int arr2[MAXM];
 //
-//void merge(int l1, int r1, int l2, int r2) {
-//    int i = 0;
-//    while (l1 <= r1 && l2 <= r2) {
-//        edge[++i] = w[change[l1]] >= w[unchange[l2]] ? change[l1++] : unchange[l2++];
-//    }
-//    while (l1 <= r1) {
-//        edge[++i] = change[l1++];
-//    }
-//    while (l2 <= r2) {
-//        edge[++i] = unchange[l2++];
-//    }
-//}
+//int ans[MAXQ];
 //
 //void build() {
 //    for (int i = 1; i <= n; i++) {
@@ -100,13 +88,35 @@
 //    }
 //}
 //
+//void merge() {
+//    int siz1 = 0, siz2 = 0;
+//    for (int i = 1; i <= m; i++) {
+//        if (change[edge[i]]) {
+//            arr1[++siz1] = edge[i];
+//        } else {
+//            arr2[++siz2] = edge[i];
+//        }
+//    }
+//    sort(arr1 + 1, arr1 + siz1 + 1, [&](int x, int y) { return w[x] > w[y]; });
+//    int i = 0, p1 = 1, p2 = 1;
+//    while (p1 <= siz1 && p2 <= siz2) {
+//        edge[++i] = w[arr1[p1]] >= w[arr2[p2]] ? arr1[p1++] : arr2[p2++];
+//    }
+//    while (p1 <= siz1) {
+//        edge[++i] = arr1[p1++];
+//    }
+//    while (p2 <= siz2) {
+//        edge[++i] = arr2[p2++];
+//    }
+//}
+//
 //void compute(int l, int r) {
 //    build();
-//    fill(vis + 1, vis + m + 1, false);
+//    fill(change + 1, change + m + 1, false);
 //    int cntu = 0, cntq = 0;
 //    for (int i = l; i <= r; i++) {
 //        if (op[operate[i]] == 1) {
-//            vis[eid[operate[i]]] = true;
+//            change[eid[operate[i]]] = true;
 //            update[++cntu] = operate[i];
 //        } else {
 //            query[++cntq] = operate[i];
@@ -115,7 +125,7 @@
 //    sort(query + 1, query + cntq + 1, [&](int x, int y) { return car[x] > car[y]; });
 //    for (int i = 1, j = 1; i <= cntq; i++) {
 //        while (j <= m && w[edge[j]] >= car[query[i]]) {
-//            if (!vis[edge[j]]) {
+//            if (!change[edge[j]]) {
 //                Union(u[edge[j]], v[edge[j]]);
 //            }
 //            j++;
@@ -124,10 +134,8 @@
 //        for (int k = 1; k <= cntu; k++) {
 //            curw[eid[update[k]]] = w[eid[update[k]]];
 //        }
-//        for (int k = 1; k <= cntu; k++) {
-//            if (update[k] < query[i]) {
-//                curw[eid[update[k]]] = tow[update[k]];
-//            }
+//        for (int k = 1; k <= cntu && update[k] < query[i]; k++) {
+//            curw[eid[update[k]]] = tow[update[k]];
 //        }
 //        for (int k = 1; k <= cntu; k++) {
 //            if (curw[eid[update[k]]] >= car[query[i]]) {
@@ -140,16 +148,7 @@
 //    for (int i = 1; i <= cntu; i++) {
 //        w[eid[update[i]]] = tow[update[i]];
 //    }
-//    int siz1 = 0, siz2 = 0;
-//    for (int i = 1; i <= m; i++) {
-//        if (vis[edge[i]]) {
-//            change[++siz1] = edge[i];
-//        } else {
-//            unchange[++siz2] = edge[i];
-//        }
-//    }
-//    sort(change + 1, change + siz1 + 1, [&](int x, int y) { return w[x] > w[y]; });
-//    merge(1, siz1, 1, siz2);
+//    merge();
 //}
 //
 //void prepare() {

From 7e979613a61484b9fa0f0eb2de1f8c4fe89323b7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 18:54:16 +0800
Subject: [PATCH 1190/1712] modify code

---
 src/class174/Code04_Bridge1.java | 11 ++++++++++-
 src/class174/Code04_Bridge2.java |  2 +-
 2 files changed, 11 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 609ca2cfa..9f3228c43 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -36,22 +36,31 @@ public class Code04_Bridge1 {
 	public static int[] nid = new int[MAXQ];
 	public static int[] car = new int[MAXQ];
 
+	// edge里是所有边的序号
+	// change表示边的分类
+	// curw表示边最新的权值
 	public static int[] edge = new int[MAXM];
 	public static boolean[] change = new boolean[MAXM];
 	public static int[] curw = new int[MAXM];
 
+	// edge里是所有操作的编号
+	// query里是当前操作块里查询操作的编号
+	// update里是当前操作块里修改操作的编号
 	public static int[] operate = new int[MAXQ];
-	public static int[] update = new int[MAXQ];
 	public static int[] query = new int[MAXQ];
+	public static int[] update = new int[MAXQ];
 
+	// 可撤销并查集
 	public static int[] fa = new int[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[][] rollback = new int[MAXM][2];
 	public static int opsize = 0;
 
+	// 归并的辅助数组
 	public static int[] arr1 = new int[MAXM];
 	public static int[] arr2 = new int[MAXM];
 
+	// 所有查询的答案
 	public static int[] ans = new int[MAXQ];
 
 	// idx[l..r]都是编号，编号根据val[编号]的值从大到小排序，手写双指针快排
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index 2e0d68ef8..132f218c2 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -38,8 +38,8 @@
 //int curw[MAXM];
 //
 //int operate[MAXQ];
-//int update[MAXQ];
 //int query[MAXQ];
+//int update[MAXQ];
 //
 //int fa[MAXN];
 //int siz[MAXN];

From 27fb792edc2c6e8b03c38e3857b0b060958b381b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 18:56:10 +0800
Subject: [PATCH 1191/1712] modify code

---
 src/class174/Code04_Bridge1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 9f3228c43..57c291aaa 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -36,7 +36,7 @@ public class Code04_Bridge1 {
 	public static int[] nid = new int[MAXQ];
 	public static int[] car = new int[MAXQ];
 
-	// edge里是所有边的序号
+	// edge里是所有边的编号
 	// change表示边的分类
 	// curw表示边最新的权值
 	public static int[] edge = new int[MAXM];
@@ -139,8 +139,8 @@ public static void merge() {
 		}
 	}
 
-	// 当前操作序号[l..r]，之前的所有修改操作都已生效
-	// 所有边的序号edge[1..m]，按照边权从大到小排序
+	// 当前操作编号[l..r]，之前的所有修改操作都已生效
+	// 所有边的编号edge[1..m]，按照边权从大到小排序
 	// 处理当前操作块的所有操作
 	public static void compute(int l, int r) {
 		build(); // 重建并查集，目前没有任何联通性
@@ -154,7 +154,7 @@ public static void compute(int l, int r) {
 				query[++cntq] = operate[i];
 			}
 		}
-		// 查询操作的所有序号，根据车重从大到小排序
+		// 查询操作的所有编号，根据车重从大到小排序
 		// 然后依次处理所有查询
 		sort(query, car, 1, cntq);
 		for (int i = 1, j = 1; i <= cntq; i++) {

From ba48f97e6eb8d34df5b5fbc7cc74027659849f6f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 18:57:29 +0800
Subject: [PATCH 1192/1712] modify code

---
 src/class174/Code04_Bridge1.java | 10 ++++++----
 1 file changed, 6 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 57c291aaa..cf3dab677 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -143,14 +143,16 @@ public static void merge() {
 	// 所有边的编号edge[1..m]，按照边权从大到小排序
 	// 处理当前操作块的所有操作
 	public static void compute(int l, int r) {
-		build(); // 重建并查集，目前没有任何联通性
-		Arrays.fill(change, false); // 清空边的修改标记
+		// 重建并查集，目前没有任何联通性
+		// 清空边的修改标记
+		build(); 
+		Arrays.fill(change, false);
 		int cntu = 0, cntq = 0;
 		for (int i = l; i <= r; i++) {
-			if (op[operate[i]] == 1) { // 修改类型的操作
+			if (op[operate[i]] == 1) {
 				change[eid[operate[i]]] = true;
 				update[++cntu] = operate[i];
-			} else { // 查询类型的操作
+			} else {
 				query[++cntq] = operate[i];
 			}
 		}

From 5fa7c9af6d8fab31b5f2f13af0cf0d4fb54f124c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 18:58:37 +0800
Subject: [PATCH 1193/1712] modify code

---
 src/class174/Code04_Bridge1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index cf3dab677..8f75525d6 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -36,16 +36,16 @@ public class Code04_Bridge1 {
 	public static int[] nid = new int[MAXQ];
 	public static int[] car = new int[MAXQ];
 
-	// edge里是所有边的编号
+	// edge是所有边的编号
 	// change表示边的分类
 	// curw表示边最新的权值
 	public static int[] edge = new int[MAXM];
 	public static boolean[] change = new boolean[MAXM];
 	public static int[] curw = new int[MAXM];
 
-	// edge里是所有操作的编号
-	// query里是当前操作块里查询操作的编号
-	// update里是当前操作块里修改操作的编号
+	// edge是所有操作的编号
+	// query是当前操作块查询操作的编号
+	// update是当前操作块修改操作的编号
 	public static int[] operate = new int[MAXQ];
 	public static int[] query = new int[MAXQ];
 	public static int[] update = new int[MAXQ];

From 5fe8f9c56b886710329ded0e51a2b8222737d122 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 20:50:19 +0800
Subject: [PATCH 1194/1712] modify code

---
 src/class174/Code04_Bridge1.java | 4 ++--
 src/class174/Code04_Bridge2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index 8f75525d6..ac300ff22 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -43,7 +43,7 @@ public class Code04_Bridge1 {
 	public static boolean[] change = new boolean[MAXM];
 	public static int[] curw = new int[MAXM];
 
-	// edge是所有操作的编号
+	// operate是所有操作的编号
 	// query是当前操作块查询操作的编号
 	// update是当前操作块修改操作的编号
 	public static int[] operate = new int[MAXQ];
@@ -236,7 +236,7 @@ public static void main(String[] args) throws IOException {
 			compute(l, r);
 		}
 		for (int i = 1; i <= q; i++) {
-			if (ans[i] > 0) {
+			if (op[i] == 2) {
 				out.println(ans[i]);
 			}
 		}
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index 132f218c2..fe5644d84 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -182,7 +182,7 @@
 //        compute(l, r);
 //    }
 //    for (int i = 1; i <= q; i++) {
-//        if (ans[i]) {
+//        if (op[i] == 2) {
 //            cout << ans[i] << '\n';
 //        }
 //    }

From 176ad1d02d24881298810fe3f10719bbb700e861 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 22:31:48 +0800
Subject: [PATCH 1195/1712] modify code

---
 src/class174/Code04_Bridge1.java | 2 +-
 src/class174/Code05_Lcm1.java    | 4 +++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class174/Code04_Bridge1.java b/src/class174/Code04_Bridge1.java
index ac300ff22..492dc72c5 100644
--- a/src/class174/Code04_Bridge1.java
+++ b/src/class174/Code04_Bridge1.java
@@ -143,7 +143,7 @@ public static void merge() {
 	// 所有边的编号edge[1..m]，按照边权从大到小排序
 	// 处理当前操作块的所有操作
 	public static void compute(int l, int r) {
-		// 重建并查集，目前没有任何联通性
+		// 重建并查集，目前没有任何连通性
 		// 清空边的修改标记
 		build(); 
 		Arrays.fill(change, false);
diff --git a/src/class174/Code05_Lcm1.java b/src/class174/Code05_Lcm1.java
index afe4b8317..5d969c958 100644
--- a/src/class174/Code05_Lcm1.java
+++ b/src/class174/Code05_Lcm1.java
@@ -117,10 +117,12 @@ public static boolean check(int x, int y, int a, int b) {
 	}
 
 	public static void compute(int l, int r) {
+		// 重建并查集，目前没有任何连通性
 		build();
+		// 重要剪枝
+		// 保证每条查询只在一个边的序列块中处理
 		cursiz = 0;
 		for (int i = 1; i <= q; i++) {
-			// 保证每条查询只在一个边的序列块中处理
 			if (ea[edge[l]] <= qa[query[i]] && (r + 1 > m || qa[query[i]] < ea[edge[r + 1]])) {
 				cur[++cursiz] = query[i];
 			}

From ea7b882bb48299e0f45c51602cb6901574f9a9a0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 23:03:54 +0800
Subject: [PATCH 1196/1712] modify code

---
 src/class174/Code05_Lcm1.java | 4 ++--
 src/class174/Code05_Lcm2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class174/Code05_Lcm1.java b/src/class174/Code05_Lcm1.java
index 5d969c958..abdc20fc9 100644
--- a/src/class174/Code05_Lcm1.java
+++ b/src/class174/Code05_Lcm1.java
@@ -117,8 +117,6 @@ public static boolean check(int x, int y, int a, int b) {
 	}
 
 	public static void compute(int l, int r) {
-		// 重建并查集，目前没有任何连通性
-		build();
 		// 重要剪枝
 		// 保证每条查询只在一个边的序列块中处理
 		cursiz = 0;
@@ -128,6 +126,8 @@ public static void compute(int l, int r) {
 			}
 		}
 		if (cursiz > 0) {
+			// 重建并查集，目前没有任何连通性
+			build();
 			// 本题直接排序能通过，就不写归并了
 			sort(edge, eb, 1, l - 1);
 			for (int i = 1, j = 1; i <= cursiz; i++) {
diff --git a/src/class174/Code05_Lcm2.java b/src/class174/Code05_Lcm2.java
index 57faf78d4..6036c1d61 100644
--- a/src/class174/Code05_Lcm2.java
+++ b/src/class174/Code05_Lcm2.java
@@ -98,7 +98,6 @@
 //}
 //
 //void compute(int l, int r) {
-//    build();
 //    cursiz = 0;
 //    for (int i = 1; i <= q; i++) {
 //        if (ea[edge[l]] <= qa[query[i]] && (r + 1 > m || qa[query[i]] < ea[edge[r + 1]])) {
@@ -106,6 +105,7 @@
 //        }
 //    }
 //    if (cursiz > 0) {
+//        build();
 //        sort(edge + 1, edge + l, [&](int x, int y) { return eb[x] < eb[y]; });
 //        for (int i = 1, j = 1; i <= cursiz; i++) {
 //            while (j < l && eb[edge[j]] <= qb[cur[i]]) {

From 20cb3c9732d5f1012621baae38973b027978f39a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 16 Jul 2025 23:52:55 +0800
Subject: [PATCH 1197/1712] modify code

---
 ...10\345\271\266\346\237\245\351\233\206.pptx" | Bin 0 -> 47558 bytes
 src/class174/Code05_Lcm1.java                   |  12 ++++++------
 2 files changed, 6 insertions(+), 6 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243174\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2303-\345\217\214\345\261\202\345\210\206\345\235\227\343\200\201\345\210\206\345\235\227\347\273\223\345\220\210\345\271\266\346\237\245\351\233\206.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243174\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2303-\345\217\214\345\261\202\345\210\206\345\235\227\343\200\201\345\210\206\345\235\227\347\273\223\345\220\210\345\271\266\346\237\245\351\233\206.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243174\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2303-\345\217\214\345\261\202\345\210\206\345\235\227\343\200\201\345\210\206\345\235\227\347\273\223\345\220\210\345\271\266\346\237\245\351\233\206.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..16e2b92f6c12f5491b05e579b534bb6775150634
GIT binary patch
literal 47558
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
XHoMrN$8Z!%ANp885A|LpOKblFFukhT

literal 0
HcmV?d00001

diff --git a/src/class174/Code05_Lcm1.java b/src/class174/Code05_Lcm1.java
index abdc20fc9..b4393cb10 100644
--- a/src/class174/Code05_Lcm1.java
+++ b/src/class174/Code05_Lcm1.java
@@ -49,19 +49,19 @@ public class Code05_Lcm1 {
 
 	public static boolean[] ans = new boolean[MAXQ];
 
-	public static void sort(int[] idx, int[] v, int l, int r) {
+	public static void sort(int[] idx, int[] val, int l, int r) {
 		if (l >= r) return;
-		int i = l, j = r, pivot = v[idx[(l + r) >> 1]], tmp;
+		int i = l, j = r, pivot = val[idx[(l + r) >> 1]], tmp;
 		while (i <= j) {
-			while (v[idx[i]] < pivot) i++;
-			while (v[idx[j]] > pivot) j--;
+			while (val[idx[i]] < pivot) i++;
+			while (val[idx[j]] > pivot) j--;
 			if (i <= j) {
 				tmp = idx[i]; idx[i] = idx[j]; idx[j] = tmp;
 				i++; j--;
 			}
 		}
-		sort(idx, v, l, j);
-		sort(idx, v, i, r);
+		sort(idx, val, l, j);
+		sort(idx, val, i, r);
 	}
 
 	public static void build() {

From 192def1801e77154f4b4fc52685c0d7ae77dfa1f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Jul 2025 19:44:19 +0800
Subject: [PATCH 1198/1712] modify code

---
 src/class174/Code02_MagicGirl2.java     | 70 ++++++++++++++++++++-----
 src/class174/Code03_ColorfulWorld2.java |  2 +-
 src/class174/Code04_Bridge2.java        |  2 +-
 3 files changed, 60 insertions(+), 14 deletions(-)

diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index e59cb767f..242b3062d 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -14,6 +14,50 @@
 //
 //using namespace std;
 //
+//namespace fastio {
+//    static const int SZ = 1 << 20;
+//    char ibuf[SZ], *is = ibuf, *ie = ibuf;
+//    inline int gc() {
+//        if (is == ie) {
+//            size_t len = fread(ibuf, 1, SZ, stdin);
+//            if (len == 0) return -1;
+//            is = ibuf;
+//            ie = ibuf + len;
+//        }
+//        return *is++;
+//    }
+//    template <typename T>
+//    inline bool readInt(T& x) {
+//        int c = gc(); if (c == -1) return false;
+//        bool neg = false;
+//        while (c != '-' && (c < '0' || c > '9')) { c = gc(); if (c == -1) return false; }
+//        if (c == '-') { neg = true; c = gc(); }
+//        x = 0;
+//        while (c >= '0' && c <= '9') { x = x * 10 + (c & 15); c = gc(); }
+//        if (neg) x = -x;
+//        return true;
+//    }
+//    char obuf[SZ]; char* op = obuf;
+//    inline void flush() {
+//        fwrite(obuf, 1, op - obuf, stdout);
+//        op = obuf;
+//    }
+//    template <typename T>
+//    inline void writeInt(T x, char end = '\n') {
+//        if (op > obuf + SZ - 64) flush();
+//        if (x == 0) { *op++ = '0'; *op++ = end; return; }
+//        if (x < 0) { *op++ = '-'; x = -x; }
+//        char s[24]; int n = 0;
+//        while (x) { s[n++] = char('0' + x % 10); x /= 10; }
+//        while (n) *op++ = s[--n];
+//        *op++ = end;
+//    }
+//}
+//
+//using fastio::readInt;
+//using fastio::writeInt;
+//using fastio::flush;
+//
 //const int MAXN = 300002;
 //const int MAXB = 601;
 //const int POW = 9;
@@ -43,16 +87,16 @@
 //long long ans[MAXN];
 //
 //inline void radix(int* idx, int* val, int siz) {
-//    fill(cntv, cntv + MAXB, 0);
+//    memset(cntv, 0, sizeof(int) * MAXB);
 //    for (int i = 1; i <= siz; i++) cntv[val[idx[i]] & OFFSET]++;
 //    for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
 //    for (int i = siz; i >= 1; i--) help[cntv[val[idx[i]] & OFFSET]--] = idx[i];
-//    for (int i = 1; i <= siz; i++) idx[i] = help[i];
-//    fill(cntv, cntv + MAXB, 0);
+//    memcpy(idx + 1, help + 1, siz * sizeof(int));
+//    memset(cntv, 0, sizeof(int) * MAXB);
 //    for (int i = 1; i <= siz; i++) cntv[val[idx[i]] >> POW]++;
 //    for (int i = 1; i < MAXB; i++) cntv[i] += cntv[i - 1];
 //    for (int i = siz; i >= 1; i--) help[cntv[val[idx[i]] >> POW]--] = idx[i];
-//    for (int i = 1; i <= siz; i++) idx[i] = help[i];
+//    memcpy(idx + 1, help + 1, siz * sizeof(int));
 //}
 //
 //inline void merge(int i, int curPre, int curSuf, int curLen, int curAns) {
@@ -115,18 +159,19 @@
 //}
 //
 //int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n >> m;
+//    readInt(n);
+//    readInt(m);
 //    for (int i = 1; i <= n; i++) {
-//        cin >> arr[i];
+//        readInt(arr[i]);
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> op[i] >> x[i];
+//        readInt(op[i]);
+//        readInt(x[i]);
 //        if (op[i] == 1) {
-//            cin >> v[i];
+//            readInt(v[i]);
 //        } else {
-//            cin >> y[i] >> v[i];
+//            readInt(y[i]);
+//            readInt(v[i]);
 //        }
 //    }
 //    int blen = 1 << POW;
@@ -138,8 +183,9 @@
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        if (op[i] == 2) {
-//            cout << ans[i] << '\n';
+//            writeInt(ans[i]);
 //        }
 //    }
+//    flush();
 //    return 0;
 //}
\ No newline at end of file
diff --git a/src/class174/Code03_ColorfulWorld2.java b/src/class174/Code03_ColorfulWorld2.java
index f6e0adb06..247c5da1a 100644
--- a/src/class174/Code03_ColorfulWorld2.java
+++ b/src/class174/Code03_ColorfulWorld2.java
@@ -113,7 +113,7 @@
 //}
 //
 //void compute(int l, int r) {
-//    fill(cntv, cntv + MAXV, 0);
+//    memset(cntv, 0, sizeof(int) * MAXV);
 //    maxv = lazy = 0;
 //    for (int i = l; i <= r; i++) {
 //        maxv = max(maxv, arr[i]);
diff --git a/src/class174/Code04_Bridge2.java b/src/class174/Code04_Bridge2.java
index fe5644d84..0a76f3c34 100644
--- a/src/class174/Code04_Bridge2.java
+++ b/src/class174/Code04_Bridge2.java
@@ -112,7 +112,7 @@
 //
 //void compute(int l, int r) {
 //    build();
-//    fill(change + 1, change + m + 1, false);
+//    memset(change + 1, 0, m * sizeof(bool));
 //    int cntu = 0, cntq = 0;
 //    for (int i = l; i <= r; i++) {
 //        if (op[operate[i]] == 1) {

From 10d30251b71ba74e9531e5c232c51e0d9e8c8335 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Jul 2025 20:10:19 +0800
Subject: [PATCH 1199/1712] modify code

---
 src/class119/Code01_EmergencyAssembly2.java | 11 ++++-------
 src/class151/Code02_Treap2.java             | 18 +++++++-----------
 src/class151/FollowUp2.java                 | 18 +++++++-----------
 3 files changed, 18 insertions(+), 29 deletions(-)

diff --git a/src/class119/Code01_EmergencyAssembly2.java b/src/class119/Code01_EmergencyAssembly2.java
index e8eef367d..0588f622d 100644
--- a/src/class119/Code01_EmergencyAssembly2.java
+++ b/src/class119/Code01_EmergencyAssembly2.java
@@ -12,10 +12,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <algorithm>
-//#include <cmath>
-//#include <cstdio>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //
@@ -43,12 +40,12 @@
 //void build(int n) {
 //    power = log2(n);
 //    cnt = 1;
-//    fill(head, head + n + 1, 0);
+//    memset(head + 1, 0, n * sizeof(int));
 //}
 //
 //void addEdge(int u, int v) {
-//	edgeNext[cnt] = head[u];
-//	edgeTo[cnt] = v;
+//    edgeNext[cnt] = head[u];
+//    edgeTo[cnt] = v;
 //    head[u] = cnt++;
 //}
 //
diff --git a/src/class151/Code02_Treap2.java b/src/class151/Code02_Treap2.java
index 00a4449bf..d2e7e1be1 100644
--- a/src/class151/Code02_Treap2.java
+++ b/src/class151/Code02_Treap2.java
@@ -14,11 +14,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <algorithm>
-//#include <cstring>
-//#include <random>
-//#include <climits>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //
@@ -178,12 +174,12 @@
 //}
 //
 //void clear() {
-//    fill(key + 1, key + cnt + 1, 0);
-//    fill(key_count + 1, key_count + cnt + 1, 0);
-//    fill(ls + 1, ls + cnt + 1, 0);
-//    fill(rs + 1, rs + cnt + 1, 0);
-//    fill(siz + 1, siz + cnt + 1, 0);
-//    fill(priority + 1, priority + cnt + 1, 0);
+//    memset(key + 1, 0, cnt * sizeof(int));
+//    memset(key_count + 1, 0, cnt * sizeof(int));
+//    memset(ls + 1, 0, cnt * sizeof(int));
+//    memset(rs + 1, 0, cnt * sizeof(int));
+//    memset(siz + 1, 0, cnt * sizeof(int));
+//    memset(priority + 1, 0, cnt * sizeof(int));
 //    cnt = 0;
 //    head = 0;
 //}
diff --git a/src/class151/FollowUp2.java b/src/class151/FollowUp2.java
index da9078481..34e8e6336 100644
--- a/src/class151/FollowUp2.java
+++ b/src/class151/FollowUp2.java
@@ -7,11 +7,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <algorithm>
-//#include <cstring>
-//#include <random>
-//#include <climits>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //
@@ -171,12 +167,12 @@
 //}
 //
 //void clear() {
-//    fill(key + 1, key + cnt + 1, 0);
-//    fill(key_count + 1, key_count + cnt + 1, 0);
-//    fill(ls + 1, ls + cnt + 1, 0);
-//    fill(rs + 1, rs + cnt + 1, 0);
-//    fill(siz + 1, siz + cnt + 1, 0);
-//    fill(priority + 1, priority + cnt + 1, 0);
+//    memset(key + 1, 0, cnt * sizeof(int));
+//    memset(key_count + 1, 0, cnt * sizeof(int));
+//    memset(ls + 1, 0, cnt * sizeof(int));
+//    memset(rs + 1, 0, cnt * sizeof(int));
+//    memset(siz + 1, 0, cnt * sizeof(int));
+//    memset(priority + 1, 0, cnt * sizeof(int));
 //    cnt = 0;
 //    head = 0;
 //}

From 880a9b975b3e1177398d94a7b987eff3d73abf25 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 17 Jul 2025 20:50:17 +0800
Subject: [PATCH 1200/1712] modify code

---
 src/class174/Code02_MagicGirl2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class174/Code02_MagicGirl2.java b/src/class174/Code02_MagicGirl2.java
index 242b3062d..ea7ed0586 100644
--- a/src/class174/Code02_MagicGirl2.java
+++ b/src/class174/Code02_MagicGirl2.java
@@ -44,7 +44,7 @@
 //    }
 //    template <typename T>
 //    inline void writeInt(T x, char end = '\n') {
-//        if (op > obuf + SZ - 64) flush();
+//        if (op > obuf + SZ - 256) flush();
 //        if (x == 0) { *op++ = '0'; *op++ = end; return; }
 //        if (x < 0) { *op++ = '-'; x = -x; }
 //        char s[24]; int n = 0;

From 2e4771cba7be771465e695797836d09263ce81ae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Jul 2025 00:57:23 +0800
Subject: [PATCH 1201/1712] modify code

---
 src/class164/Code02_Training1.java | 24 ++++++++++++++++++++----
 src/class164/Code02_Training2.java | 18 ++++++++++++++----
 2 files changed, 34 insertions(+), 8 deletions(-)

diff --git a/src/class164/Code02_Training1.java b/src/class164/Code02_Training1.java
index bbb1eea0b..691e5ac7a 100644
--- a/src/class164/Code02_Training1.java
+++ b/src/class164/Code02_Training1.java
@@ -2,10 +2,11 @@
 
 // youyou的军训，java版
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
-// 一共有q条操作，每条操作都是如下的三种类型中的一种
-// 操作 1 x   : 限制变量limit，把limit的值改成x
+// 一开始limit = 0，接下来有q条操作，每条操作都是如下的三种类型中的一种
+// 操作 1 x   : 所有修改操作生效，然后limit变成x，图中那些边权小于limit的边断开
 // 操作 2 x   : 点x不能走过任何边权小于limit的边，打印此时x所在的连通区域大小
-// 操作 3 x y : 第x条边的边权修改为y，题目保证修改之后，第x条边的边权排名不变
+// 操作 3 x y : 第x条边的边权修改为y，但不是立刻生效，而是下次limit改变时生效
+// 题目保证边权不管怎么修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9638
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -44,6 +45,14 @@ public class Code02_Training1 {
 	// 树上dfs，Kruskal重构树的节点，倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
 
+	// 边权的修改操作先不生效，等到下次limit被设置时生效
+	// 修改了哪些边
+	public static int[] pendEdge = new int[MAXM];
+	// 修改成了什么边权
+	public static int[] pendVal = new int[MAXM];
+	// 修改操作的个数
+	public static int cntp = 0;
+
 	// 并查集的find方法，需要改成迭代版不然会爆栈，C++实现不需要
 	public static int find(int i) {
 		int size = 0;
@@ -181,6 +190,11 @@ public static void main(String[] args) {
 		for (int i = 1; i <= q; i++) {
 			op = io.nextInt();
 			if (op == 1) {
+				// 从上次limit改变开始，积攒的修改操作统一生效
+				for (int k = 1; k <= cntp; k++) {
+					nodeKey[edgeToTree[pendEdge[k]]] = pendVal[k];
+				}
+				cntp = 0;
 				limit = io.nextInt();
 			} else if (op == 2) {
 				x = io.nextInt();
@@ -188,8 +202,10 @@ public static void main(String[] args) {
 			} else {
 				x = io.nextInt();
 				y = io.nextInt();
+				// 修改操作先收集起来，等到limit改变时，统一生效
 				if (edgeToTree[x] != 0) {
-					nodeKey[edgeToTree[x]] = y;
+					pendEdge[++cntp] = x;
+					pendVal[cntp] = y;
 				}
 			}
 		}
diff --git a/src/class164/Code02_Training2.java b/src/class164/Code02_Training2.java
index 2211ff9f3..ab6b865ec 100644
--- a/src/class164/Code02_Training2.java
+++ b/src/class164/Code02_Training2.java
@@ -2,10 +2,11 @@
 
 // youyou的军训，C++版
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
-// 一共有q条操作，每条操作都是如下的三种类型中的一种
-// 操作 1 x   : 限制变量limit，把limit的值改成x
+// 一开始limit = 0，接下来有q条操作，每条操作都是如下的三种类型中的一种
+// 操作 1 x   : 所有修改操作生效，然后limit变成x，图中那些边权小于limit的边断开
 // 操作 2 x   : 点x不能走过任何边权小于limit的边，打印此时x所在的连通区域大小
-// 操作 3 x y : 第x条边的边权修改为y，题目保证修改之后，第x条边的边权排名不变
+// 操作 3 x y : 第x条边的边权修改为y，但不是立刻生效，而是下次limit改变时生效
+// 题目保证边权不管怎么修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9638
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -42,6 +43,10 @@
 //int leafsiz[MAXK];
 //int stjump[MAXK][MAXH];
 //
+//int pendEdge[MAXM];
+//int pendVal[MAXM];
+//int cntp;
+//
 //int find(int i) {
 //    if (i != father[i]) {
 //        father[i] = find(father[i]);
@@ -120,6 +125,10 @@
 //    for (int i = 1; i <= q; i++) {
 //        cin >> op;
 //        if (op == 1) {
+//            for (int k = 1; k <= cntp; k++) {
+//                nodeKey[edgeToTree[pendEdge[k]]] = pendVal[k];
+//            }
+//            cntp = 0;
 //            cin >> limit;
 //        } else if (op == 2) {
 //            cin >> x;
@@ -127,7 +136,8 @@
 //        } else {
 //            cin >> x >> y;
 //            if (edgeToTree[x] != 0) {
-//                nodeKey[edgeToTree[x]] = y;
+//                pendEdge[++cntp] = x;
+//                pendVal[cntp] = y;
 //            }
 //        }
 //    }

From e951e9a362e8d236216e935405cd150c7ddc461f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Jul 2025 01:01:09 +0800
Subject: [PATCH 1202/1712] modify code

---
 ...\345\205\263\351\242\230\347\233\256.pptx" | Bin 54142 -> 54193 bytes
 src/class164/Code02_Training1.java            |   2 +-
 src/class164/Code02_Training2.java            |   2 +-
 3 files changed, 2 insertions(+), 2 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
index 5bb5c6ddf8e296952cf831e9e94f92b06db290b1..14593bfa8fadfa1502ea91dbde223eaa59613494 100644
GIT binary patch
delta 3349
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
Bgg5{I

delta 3302
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

diff --git a/src/class164/Code02_Training1.java b/src/class164/Code02_Training1.java
index 691e5ac7a..2ae39f93f 100644
--- a/src/class164/Code02_Training1.java
+++ b/src/class164/Code02_Training1.java
@@ -4,7 +4,7 @@
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
 // 一开始limit = 0，接下来有q条操作，每条操作都是如下的三种类型中的一种
 // 操作 1 x   : 所有修改操作生效，然后limit变成x，图中那些边权小于limit的边断开
-// 操作 2 x   : 点x不能走过任何边权小于limit的边，打印此时x所在的连通区域大小
+// 操作 2 x   : 查询点x所在连通区域大小
 // 操作 3 x y : 第x条边的边权修改为y，但不是立刻生效，而是下次limit改变时生效
 // 题目保证边权不管怎么修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5
diff --git a/src/class164/Code02_Training2.java b/src/class164/Code02_Training2.java
index ab6b865ec..86c8851b6 100644
--- a/src/class164/Code02_Training2.java
+++ b/src/class164/Code02_Training2.java
@@ -4,7 +4,7 @@
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
 // 一开始limit = 0，接下来有q条操作，每条操作都是如下的三种类型中的一种
 // 操作 1 x   : 所有修改操作生效，然后limit变成x，图中那些边权小于limit的边断开
-// 操作 2 x   : 点x不能走过任何边权小于limit的边，打印此时x所在的连通区域大小
+// 操作 2 x   : 查询点x所在连通区域大小
 // 操作 3 x y : 第x条边的边权修改为y，但不是立刻生效，而是下次limit改变时生效
 // 题目保证边权不管怎么修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5

From 2dfc27eacbc2a426dab687c38790aa6f3bf65a7b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Jul 2025 12:39:57 +0800
Subject: [PATCH 1203/1712] modify code

---
 ...\345\205\263\351\242\230\347\233\256.pptx" | Bin 54193 -> 54188 bytes
 src/class164/Code02_Training1.java            |  30 +++++++++---------
 src/class164/Code02_Training2.java            |  19 +++++------
 3 files changed, 25 insertions(+), 24 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
index 14593bfa8fadfa1502ea91dbde223eaa59613494..aa7ea88121f57100c76dbe0a956865cfc69d0d01 100644
GIT binary patch
delta 3209
zcmZvec|6oxAIE2gu_yaFJ!Ffz*>?)p64FgVmKL()id3jbhK2{(CO=t<Yae24xt3Cl
zonh<>nX-)Rbd$AoAHP#~JomZJ{PX>t_xXIj=X=iU%<Fr~^BIWw3>=mx85sEx2m}ja
z)3uy~ABoy@g(Q(*;2@6b+6@)UsQV0XyvdXX&sK1;aDezPRz^7HNU?#T47(#UJdNY=
z1LG~;D@^eCvWOJpZiM9ZRU!E%HfURi4C4f`P&zh~8ibLU^f@{TX{IahAI^r?2MHYH
zfl^W71L`kip$w3OiZ$I#)BxzdrY7C^Q3s$_U3ah-d3_d8q^7|#U2@(SNR&+|K!P-9
z1rm;v8$g0ISA)7b=v8r9>VoxPtY?XaBCUJiJ=oji($%W=AR(KBA{|jW*`T`@zyX}N
z=nwV)Cs=g?$_{61u(X&PBa(H~^^?Q2np4uj1U``p6L%wUm@!`2Xn5m_H+SIG6nx1r
z-W|$9l7T}o+79gdp^$~vLICOtt)rvgBZfHP%z-Yhl~0)vh#FDIDN_Ji=|Mw}MEIci
zOm^(o-sHn0(JS(tY@y<VRuVkHB==WU=N5}AT-vVL$Z?sYo@*klJbo6>Wa0{Etd#KQ
zN%)#fuD$i!wqT&U`<q*&-hxcF$~cLY^WAC3W}d93kECh^XS>dxKVux{o;rsgJ`$!m
zWKE25|InWmEr~l8)f-jk(zcYCb43%cmY$e~<(yWkI;*=P8!&`Vzu0MeYPQp%9j|14
zCay<3fWuEnTY>fG7!6kn$JSKenO4UUBB3Dvr#z<u8FzDhVW-fd->1h*jH8P=9u*Jg
zLqxP+KxVCaYOLC;p*;36FY{V^`CPSZ1vU;RO<ZLuL+;BSe=<QUF86(gvr*;Xj9S`f
zh}{Z4t77URW`R>CUTGgFKY=eyNU+z%Ejr(2>02(1HjErlwvLb!_0;B@+~K?wa|P!S
zigmdoFH3%EB_K>=Rrk&FW0}mh2oC5cBq`>XndA)>(t2*=Z9e7en65UkZ&oGql&0J`
zFc#Iq5K(7@o=G5zS#$?(lm-^DujLgjW5;mYU)44~SloL)|Lx=3hMd~9={3TXk!Zxp
zL&ZFyd2@OJqXC@B-j;<<s@cvL_Mr>#!F5!Dd=<rPsb+}|Mt?1y=&<mQ&M{I-!h-07
zjcLh@1&3M;x!UDKwKiisg)wruhNd>xBY*E~DaCXdF>re(PCYRSA}2=CWOe6a$XGdQ
zLsJd0==bx3#*;xNl(_bsruPIxRyh%V#=;945#Hf^7)N0%#dC@N*H4IJ>+YRm6~ZD1
zWBSb)Z>%%=A9W)gg)XN);wP=9xse}C8y>9BF}(4vZz3@^?pTl$n@W5@8`=Bf+s|zg
zxNhNP9nW5_3n`wif!=I)5UOHfvtO_%HEzbjFJGp%2j)iC8{ZpCU_V<*-hnK6^X%+6
z+Abf!opNmuhzOp*U5*VyXqdbc*q9mV6_>uDZD#tgDQogA(g79CW_mKBPBgML@7o>K
z5#ELP2gkV2n124e!EV*_v>`a_QX~hbl;oj$W-1e{XHY1?TlD4>OAK=&lfTvsw#`k&
zMofz$^6aLEFpqJPS8Bt@`{QP(g7+6|?hxnniR`SX<JU?v*U27tjnyB$4EMOqs+6!M
zSf*C6C8R=GnJgmCIH{RrbvLh#m~INjZF$G#T}?GO_2yUfv<b6cGoE)efA?RI-#sFO
zJ&uxtkaEJ5JiS&itdXrrf*IKyD<^zfN-9fIPTGX*swsfx^t0c3XeS)i+TyBjWP4Cq
zCa8wH(M_$(?I`d5BhO0IlQrT>yaWd=3>rQ+X&@H89X>7f&GDY~IVAJ)?Dl@Hf&JGq
z0*{~6=32qBn2a1I>1|!EsT#Ax_MyXNW~N`^I)qo=`B&K9v#o!&HnSky<cJNJrP}+?
z2#VazUG}!lM3dLjGsf2P9Q<FWXCQ^LS{zdmNJ3Mwm#WMygR?Gy6zVqrpxXM1Sd2m_
zt)cns?Rf{m>yy}G?d7_E-OjKud>oOR^nnre$CyL0_EIqs8T6iO(}(i<){4^N!fAJV
z{*ceMmugFoEKeN~r-nnDJ(<`Eqmt$u=O3(=#506d?)a~)C&iC0F~6JS)3>jGG1uL5
zW>9qD?i$tK$Fpt_UB1t#gSos)g*i2o_RF=}N9e{CvWnBKsiDr+Z&Gb`J@*Jx3Yr3q
zKk?(8?v=eBzC)vm-o{?MnSW7zeSNIMCdu}NX7vPyDXlZacV}xgA;TVr^&(4D+fwBj
ze#8Izs#bLE5`p?O-Bzf+hI2T<>yNS1yb@hJb9EIRVK3~ekKgnBawImk^LW+J$o95j
zg6?fW;chASUmKlJ%)GTm?$6nTptAR)L>r%K+j^(Cm(QOpfBngxNpAVtbcxQYi=dy#
zcqu_tG@7}3-N^ul&|@_J*o0-G`BPr1W?m&rbLO?b<4mWJUYn~loH**s9hy_NwXV0|
zT>V=UE;1c=bNHDbaU?h84aO@=nc6_B#K=;nm4?jYtE^R2yxbk$qW+}T#4ldQ3{S?y
z#;(nykDL>Cd~&gc=It6gU)Zo;+GV1-UL*hEfZ0L$dse=qYa0wZ(zVztm2>4p*}|wC
zYxzr-9o#zJD`uwL!wbq+-Nrmmn;8Ge;-DZ@?5-pb7sfDt|6I_6r{fgJVcECDzQo2y
z-$7a@O!VCN6p1<_6MfzdvU$~#%nb3HR#)ysyqk`dOc(j1xQMULzczbzHq9$T!3yFC
z+^3@dq+O0hN6?cOnP;k@ejt{XHf}p#&~~s&jUe&1e>U7|LA(9mG?xP5cGuMGj3lE!
zJsXj{@jK}Me!NtK#H)jbU4yS-+6VWzo-QlW%<j`>8X^%6R6I`J52lM!d_XJ3WPF!f
zXI=v1O2YT?Qobj>rv~-2LD40ha9_161+BJ1s!9W-xlr8+H`R*6udtwv7u9RPotRdC
z3=WbcT{t+C^x=?0Itho5BrvDY0K&C~pJDi{;S?N@jdpNwYy^h%MgZ|G7>K0_WHM=@
zlk)FmWsf*C15HXZUBl1<h(XH_0+P@FHNrqPtzaH%r8~ZTC%SEPlHUe2(|g3S9gw*8
zU*KBblQGbCJJ^d>2c6_~07Ba%mSjNU$v-squvxp4?jUr6`RP4!rV9{!7pUcZ7pPu~
z0*>Y`#Q^r-=)pjv6h-)xqnl2yb_0^WN4|b1@;yH^7T{*kUq2AJM_nAgD=crbKYiG}
zE2BsRLVP#w{e0q~@?IfGvsVCK%(54Q%!j;trNsVr!~WrNhRS*sV8g_&;W6~>hv6`5
z4C((b!wwnrDS)IkHF_Z;yHB$%5d?yNua4a>Lnyva3Y2TTDeepBq5WgwTmmSUN??N?
zG;@H2%&3$h>D`1#%>O1FgT(u#ejF#tv;;VV`UQY1{7r6F*sd#T*Cp_`GEP9{{nD^&
yxF3V!tpYC20YTtWDy&_ML?aNyTL=X2-&_`u(SQW(@)*D%g`w~P8K#taSn(f=V8G=7

delta 3129
zcmZ9Oc{r5o8^>qHHcfLZ*_o_Ea%{<-ZB)WY){Y?|yGZtvZO9TL@)9|t6p=lg<YXIb
zb{RS6pcEn^D%(MEypPlPUBCCA?|Xml?|nbd^Iq?D-A`#DLuDZY)|AM=$b~>4&<K8X
zC6*hB;zvW`$SqhzP`$fSy@<Nb0IMG}1<qEpqp?7R4lu%+hsS_W@}MmXoQ^&e0OAc!
zH)c4#B!Fk!RY*=(391)*1*0_KC^|C410*c*3mugn1?al;LwH?KXd?%Zg8U5X2kL9b
zK$|DJ;eKMrE%%F6_lnij=*6E;0Mw!B3eF*?iv}B1BP`M_7fu6<qJAH+AdL<H3zoPJ
zEJ!0|NaGx^u$yXvwP2)U$^^w*4!~O=S>@B6hkG!PHVNzuW1~RFzILF&nTvto3~+;G
z2Y|X9Ey1$FE{w<n{OGSX)5;EaMANtgs`Xt@fsdHv^^gfZxPsqzcr|(dZW!-|Qcz?+
z29gcwf$?U@;D0VDXf<*eM!ivuboBd;VOF@i6E;V-oEd@W5`>ykd7!d*L2{@M=Na~$
z`{#VWHd*-vM~t-)B-vwZjAB|@YAFM2388^LhsVmK@9Lh^8?Ps#MSn-WN{gxS{D_YY
z%lz1%(zMB~Q5WiV!ol6rG}h+KZJ*$vprDy&$Ez!*j&wioI4jk8{;W7RJ4-C0kgw{l
zRdSg0RbMY>5h1l>0SmPmzdw~Bv((4sq?<>fI?ktk@cturHciXjCK2ha&N+7|PP%)U
zgwN28EB`_u#D9IBFMzDj(J&$(&$MuvPCv>U*iJP@n=2iNz86Gz>SdoD$mPLf?!|sG
zblu!=r%;;U)XXcEFrnHuTbyJ();mEMd8KtgTSbJxrK!AdouqMO#G1fQRxntQOyZ%%
z6?0Cq8%I+HtKMI>buutB=*m)yE=^KSbYK3!nHO(SZ5byzXC%%3u7Nov*)7LCid+^t
zE^pN3$2#}^poagnCF0vdy@+di7TsA8zuBVcbjyZNz28It+m&(Q$R&Yv>-O|{M-!zP
z!Ih)ZqnY@!K<~!w&z|20$$nGYR>6*Cl}gj&S(i&+z4nRl&}#h4dc;%EB;U6-j3&cr
zJ-P-}SiQU2j(VV|?<D<adSnX5<3n9wWhjF<bF8}>N1^16yopqHjU+Qu<F-=-^zo@^
z)GN+OQFMNOtXG)+vA|ng=E(d`HQiZSo12PjsrEsu?lns>6_=l5{K>e+0R2b#u2a}@
zcZ}>gcd=vICGR`(zw~An>1y&Npivp+{QN{orm?g$F1=?B1hT|ab<Q=Zu&gv8E_KY|
zQ75*p*WOZymyN!37jmX9Q#=f+<_Mw<j|eqyX%4@v+>@=Zz*wY^UUb`?w_SM=9o^3_
zq)|M?PRcTJ_LIfbvXPaR>SpV3%8Mt8x5l83YLc7J#**f3o#!PS^$8^j&F%)+(|KAs
zXPx_bqJt(H!jfwdzli0v*I)b7%D|AKf5`lwCndjzL~_~ZiJ4nORm6!`I%x11Vowcm
z_=?D2zC;Dspjjybh6g=FH5Do7``-kd=Tmhc2|S7CeaEp`HYswlyZQKXPf)S8U-q!X
z#!E$fqRfb5tRrHFXcckB+IN)H%52X&$r$$9j_@Yq%VMH)Cllvj+aU+S9l1;Xr&bkQ
z)86t_q}{nO%*PbMQqG%<-_|oras4ej`>>gE@_EyUFzb_8^#`HZtd-#l$Hs2mXJb!4
zpd&@fV%d4Dy%A|f<~PB+TQYN2{;Dapg6$SL*nLV$Ac}AH%rr}4_f@>4<TqVs?iMF%
zM>69DllBY!N>}yoC_QSZ_YH8V%XPk~SRiOG{6w`iZE4L!Ug7B?HRf3KP84;8GImf)
z-YA4|e1|<LkrYF&a>}ytxZ=G=c+hoi+G>9E!uRH+iB}Qs#^lBAjV;PWd%KFa;qT>S
zRqbzwgokoSnO<2S&tG{H?76&1!%@-cn;*Fy928%-f11h26e&`#n^@e&PG+;P*$!_}
zN1lJ}&AIoH!DJ!W(`tRacq@R1rip*bb%Z^hSA{a_6&}d&ZtFUg>_2{OBR5&Aqz3UO
zbZikabYL>g86_J}&4o=BhObYQT8!nVOPg*gaBlHCQ#v!$ZxQ`g?@H^=<GhA_K2;TT
zls(=2<Pllx8~DP`CbxP*ZoK52e8ycOLqS>B5~YEA=ELI6({3r1*BZ%goRU>3LA;{`
z;ZIMKXV#oLC0(d*!apZTpn|Uq*xC9wkuj!gj`P=L8K01?5H%gkA6(>zHb*k9?e3u@
z(n3SNP-H`o)%}~=yvfotty)qJgP5Vnz+Xktdc2d}!NGh);f4N-o$A)!SM1lQWqqnO
zf6fmxxdmq<&nn9GaU~%Y<t9i)$|`OK=6}EO^?at$^FYUNHCAwurb*)E%|!Y}j_1@3
zvE+pOQ&COs`!rVeTZKa`1Dg(G;!djum(p;pQfbjw308?NN4A{477|gJs;?Z%5%u7z
z!1~(8)v$pnjy5@cb+2rJ^RnhLk5yF6Vud^~o<cD*2eXVG1=}Uw?&BNjS8o;+WV<b%
z@{`*=^CG3k+<jrUDS^x`(a%!V%a3a4WXH!%?u=97$mfp4SbxsT9%^h@@{m_I`PuuX
z1nE2$_aH3xq2A)_qv0Y#*w%?mkDn)4wKzB$PI#0(4(`09#KpQn-8dPRRP=7O#CDOh
z+%CxTFVV6z@zzztzg23tLY)(AUpo$Oe&Q{=eA78P^vT7h`tbbA_{Qa$mf(A~&OhZq
zrOTX_5;={hd$1OV{@`)sJ#8l=!etm&mPVP<u{gXM(WXemR2gS9Dg=(-kTKAHo)&9-
zC+9OQZMMPc@7&4CCdB_<U#de>RFFTx6K-YhBCr4Mge!n5vv{kAQ}2Kw>Yb?yrg}k^
z4>KCJNgqg}LQyGV)jIcCLFQbpJ#aoLPyz95p(lOLhLwYXYEc13Z?$mEUNh@wJ@A07
zmS`Y@v0l)m3Qy*@O<J%BQ8i(?K-Goi9+e2oJQd`mn}K*V>%p+B`7A8onyq0u-vSD<
zS^!LK#X$_MpcA3>KLTtYe?&OQstx3!HhRVO9?@*4lfri3ncgR+9e~{GpnEp<i0TVE
zdH4c&-t7}&Cm;!(Ch%SrdU4QdCpe2z7oFsG0rGaA5W4|M?52Cx_K0#1ojm9Po_9Y8
z30~l4FWAdyFF3POANVvueFQj1py8n5J_Y!drJqh*`vJ+?C+mCU=m6alKcE2q75Z%m
zY9CO6`+Oh3p#oB%FEl>r_)8v`5MSburI7neJRID5i9@+&f^^$n`t@%5KD4oy79PZ*
z*zbe1&V3AIKZu2kya#a%2Du2xA(w~Ml!!!WBYxbup(ncqMFpT>W)Lj5J%~e2K!P-|
z-0lHUXUjo4tQ-S{c7lE>G#t_xDy2yX!~ZcVD=~Fu_YOabL?A?Wb^qamKGPI{=U8#w
uLOc@!Q5u9maPAv+-^?JLAu-^IrM(^1Kp_y-Jpb<zf+B|`nRA-p!hZqi#`#<T

diff --git a/src/class164/Code02_Training1.java b/src/class164/Code02_Training1.java
index 2ae39f93f..9a1c8febc 100644
--- a/src/class164/Code02_Training1.java
+++ b/src/class164/Code02_Training1.java
@@ -2,11 +2,11 @@
 
 // youyou的军训，java版
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
-// 一开始limit = 0，接下来有q条操作，每条操作都是如下的三种类型中的一种
-// 操作 1 x   : 所有修改操作生效，然后limit变成x，图中那些边权小于limit的边断开
-// 操作 2 x   : 查询点x所在连通区域大小
-// 操作 3 x y : 第x条边的边权修改为y，但不是立刻生效，而是下次limit改变时生效
-// 题目保证边权不管怎么修改，所有边权都不相等，并且每条边的边权排名不发生变化
+// 一开始limit = 0，接下来有q条操作，每种操作的格式如下
+// 操作 1 x   : 所有修改操作生效，然后limit设置成x
+// 操作 2 x   : 从点x出发，只能走过 边权 < limit 的边，查询最多到达几个点
+// 操作 3 x y : 第x条边的边权修改为y，不是立刻生效，等到下次操作1发生时生效
+// 题目保证边权不管如何修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9638
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -28,6 +28,14 @@ public class Code02_Training1 {
 	// 边的编号对应重构树上的点的编号
 	public static int[] edgeToTree = new int[MAXM];
 
+	// 边权的修改操作先不生效，等到下次操作1发生时生效
+	// 修改了哪些边
+	public static int[] pendEdge = new int[MAXM];
+	// 修改成了什么边权
+	public static int[] pendVal = new int[MAXM];
+	// 修改操作的个数
+	public static int cntp = 0;
+
 	// 并查集
 	public static int[] father = new int[MAXK];
 	public static int[] stack = new int[MAXK];
@@ -45,14 +53,6 @@ public class Code02_Training1 {
 	// 树上dfs，Kruskal重构树的节点，倍增表
 	public static int[][] stjump = new int[MAXK][MAXH];
 
-	// 边权的修改操作先不生效，等到下次limit被设置时生效
-	// 修改了哪些边
-	public static int[] pendEdge = new int[MAXM];
-	// 修改成了什么边权
-	public static int[] pendVal = new int[MAXM];
-	// 修改操作的个数
-	public static int cntp = 0;
-
 	// 并查集的find方法，需要改成迭代版不然会爆栈，C++实现不需要
 	public static int find(int i) {
 		int size = 0;
@@ -190,7 +190,7 @@ public static void main(String[] args) {
 		for (int i = 1; i <= q; i++) {
 			op = io.nextInt();
 			if (op == 1) {
-				// 从上次limit改变开始，积攒的修改操作统一生效
+				// 收集的修改操作生效
 				for (int k = 1; k <= cntp; k++) {
 					nodeKey[edgeToTree[pendEdge[k]]] = pendVal[k];
 				}
@@ -202,7 +202,7 @@ public static void main(String[] args) {
 			} else {
 				x = io.nextInt();
 				y = io.nextInt();
-				// 修改操作先收集起来，等到limit改变时，统一生效
+				// 收集修改操作
 				if (edgeToTree[x] != 0) {
 					pendEdge[++cntp] = x;
 					pendVal[cntp] = y;
diff --git a/src/class164/Code02_Training2.java b/src/class164/Code02_Training2.java
index 86c8851b6..7e8636dc9 100644
--- a/src/class164/Code02_Training2.java
+++ b/src/class164/Code02_Training2.java
@@ -2,11 +2,11 @@
 
 // youyou的军训，C++版
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
-// 一开始limit = 0，接下来有q条操作，每条操作都是如下的三种类型中的一种
-// 操作 1 x   : 所有修改操作生效，然后limit变成x，图中那些边权小于limit的边断开
-// 操作 2 x   : 查询点x所在连通区域大小
-// 操作 3 x y : 第x条边的边权修改为y，但不是立刻生效，而是下次limit改变时生效
-// 题目保证边权不管怎么修改，所有边权都不相等，并且每条边的边权排名不发生变化
+// 一开始limit = 0，接下来有q条操作，每种操作的格式如下
+// 操作 1 x   : 所有修改操作生效，然后limit设置成x
+// 操作 2 x   : 从点x出发，只能走过 边权 < limit 的边，查询最多到达几个点
+// 操作 3 x y : 第x条边的边权修改为y，不是立刻生效，等到下次操作1发生时生效
+// 题目保证边权不管如何修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P9638
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -28,9 +28,14 @@
 //const int MAXM = 400001;
 //const int MAXH = 20;
 //int n, m, q;
+//
 //Edge edge[MAXM];
 //int edgeToTree[MAXM];
 //
+//int pendEdge[MAXM];
+//int pendVal[MAXM];
+//int cntp;
+//
 //int father[MAXK];
 //
 //int head[MAXK];
@@ -43,10 +48,6 @@
 //int leafsiz[MAXK];
 //int stjump[MAXK][MAXH];
 //
-//int pendEdge[MAXM];
-//int pendVal[MAXM];
-//int cntp;
-//
 //int find(int i) {
 //    if (i != father[i]) {
 //        father[i] = find(father[i]);

From 9e1d9c93603ed756db910a11e59526beeca3423e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 18 Jul 2025 13:05:06 +0800
Subject: [PATCH 1204/1712] modify code

---
 ...\345\205\263\351\242\230\347\233\256.pptx" | Bin 54188 -> 54204 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
index aa7ea88121f57100c76dbe0a956865cfc69d0d01..656af71ca9d046493096e90d84196503c661afeb 100644
GIT binary patch
delta 3126
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

delta 3109
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
Z@M%;Ng+NsD{=Y{6A`VJ2q&C2X{{?t$sWSio


From 592dce0eb1915b6ec3842fab1906c02df4227d86 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 24 Jul 2025 23:09:15 +0800
Subject: [PATCH 1205/1712] modify code

---
 src/class143/Code04_MomoEquation1.java | 17 +++++++++++------
 1 file changed, 11 insertions(+), 6 deletions(-)

diff --git a/src/class143/Code04_MomoEquation1.java b/src/class143/Code04_MomoEquation1.java
index 56189443b..f58d77d22 100644
--- a/src/class143/Code04_MomoEquation1.java
+++ b/src/class143/Code04_MomoEquation1.java
@@ -112,14 +112,19 @@ public static void main(String[] args) throws IOException {
 		l = (long) in.nval - 1;
 		in.nextToken();
 		r = (long) in.nval;
-		in.nextToken();
-		x = (int) in.nval;
-		prepare();
-		for (int i = 2, vi; i <= n; i++) {
+		x = 0;
+		for (int i = 1, vi; i <= n; i++) {
 			in.nextToken();
 			vi = (int) in.nval;
-			for (int j = 0; j < x; j++) {
-				addEdge(j, (j + vi) % x, vi);
+			if (vi != 0) {
+				if (x == 0) {
+					x = vi;
+					prepare();
+				} else {
+					for (int j = 0; j < x; j++) {
+						addEdge(j, (j + vi) % x, vi);
+					}
+				}
 			}
 		}
 		out.println(compute());

From cc1563b43b6318f54a70b58f13dab4cca33750f0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 30 Jul 2025 17:18:34 +0800
Subject: [PATCH 1206/1712] modify code

---
 src/class175/Code01_HashCollision1.java | 137 ++++++++++++++++++++++++
 src/class175/Code01_HashCollision2.java |  65 +++++++++++
 2 files changed, 202 insertions(+)
 create mode 100644 src/class175/Code01_HashCollision1.java
 create mode 100644 src/class175/Code01_HashCollision2.java

diff --git a/src/class175/Code01_HashCollision1.java b/src/class175/Code01_HashCollision1.java
new file mode 100644
index 000000000..9f2c905fa
--- /dev/null
+++ b/src/class175/Code01_HashCollision1.java
@@ -0,0 +1,137 @@
+package class175;
+
+// 哈希冲突，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3396
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code01_HashCollision1 {
+
+	public static int MAXN = 150001;
+	public static int MAXB = 401;
+	public static int n, m, blen;
+	public static int[] arr = new int[MAXN];
+	public static long[][] dp = new long[MAXB][MAXB];
+
+	public static long query(int x, int y) {
+		if (x <= blen) {
+			return dp[x][y];
+		}
+		long ans = 0;
+		for (int i = y; i <= n; i += x) {
+			ans += arr[i];
+		}
+		return ans;
+	}
+
+	public static void update(int x, int y) {
+		int delta = y - arr[x];
+		arr[x] = y;
+		for (int mod = 1; mod <= blen; mod++) {
+			dp[mod][x % mod] += delta;
+		}
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		for (int mod = 1; mod <= blen; mod++) {
+			for (int i = 1; i <= n; i++) {
+				dp[mod][i % mod] += arr[i];
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		char op;
+		int x, y;
+		for (int i = 1; i <= m; i++) {
+			op = in.nextChar();
+			x = in.nextInt();
+			y = in.nextInt();
+			if (op == 'A') {
+				out.println(query(x, y));
+			} else {
+				update(x, y);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class175/Code01_HashCollision2.java b/src/class175/Code01_HashCollision2.java
new file mode 100644
index 000000000..3999efe2b
--- /dev/null
+++ b/src/class175/Code01_HashCollision2.java
@@ -0,0 +1,65 @@
+package class175;
+
+// 哈希冲突，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3396
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 150001;
+//const int MAXB = 401;
+//int n, m, blen;
+//int arr[MAXN];
+//long long dp[MAXB][MAXB];
+//
+//long long query(int x, int y) {
+//    if (x <= blen) {
+//        return dp[x][y];
+//    }
+//    long long ans = 0;
+//    for (int i = y; i <= n; i += x) {
+//        ans += arr[i];
+//    }
+//    return ans;
+//}
+//
+//void update(int x, int y) {
+//    int delta = y - arr[x];
+//    arr[x] = y;
+//    for (int mod = 1; mod <= blen; mod++) {
+//        dp[mod][x % mod] += delta;
+//    }
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    for (int mod = 1; mod <= blen; mod++) {
+//        for (int i = 1; i <= n; i++) {
+//            dp[mod][i % mod] += arr[i];
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    char op;
+//    int x, y;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 'A') {
+//            cout << query(x, y) << '\n';
+//        } else {
+//            update(x, y);
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From c222b2cd0370cd2b463187e8372b5bcf91b6524e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 30 Jul 2025 21:05:41 +0800
Subject: [PATCH 1207/1712] modify code

---
 src/class175/Code02_SumOfProgression1.java | 114 +++++++++++++++++++++
 src/class175/Code02_SumOfProgression2.java |  67 ++++++++++++
 2 files changed, 181 insertions(+)
 create mode 100644 src/class175/Code02_SumOfProgression1.java
 create mode 100644 src/class175/Code02_SumOfProgression2.java

diff --git a/src/class175/Code02_SumOfProgression1.java b/src/class175/Code02_SumOfProgression1.java
new file mode 100644
index 000000000..e9b5a94f6
--- /dev/null
+++ b/src/class175/Code02_SumOfProgression1.java
@@ -0,0 +1,114 @@
+package class175;
+
+// 等差数列求和，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1921F
+// 测试链接 : https://codeforces.com/problemset/problem/1921/F
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code02_SumOfProgression1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 401;
+	public static int MAXS = MAXN + MAXB;
+	public static int t, n, q, blen;
+	public static int[] arr = new int[MAXN];
+	public static long[][] f = new long[MAXS][MAXB];
+	public static long[][] g = new long[MAXS][MAXB];
+
+	public static long query(int s, int d, int k) {
+		if (d <= blen) {
+			return g[s][d] - g[s + d * k][d] - f[s + d * k][d] * k;
+		}
+		long ans = 0;
+		for (int i = 1; i <= k; i++) {
+			ans += 1L * arr[s + (i - 1) * d] * i;
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		for (int s = 1; s <= n + blen; s++) {
+			for (int d = 1; d < MAXB; d++) {
+				f[s][d] = g[s][d] = 0;
+			}
+		}
+		for (int s = n; s >= 1; s--) {
+			for (int d = 1; d <= blen; d++) {
+				f[s][d] = f[s + d][d] + arr[s];
+			}
+		}
+		for (int s = n; s >= 1; s--) {
+			for (int d = 1; d <= blen; d++) {
+				g[s][d] = g[s + d][d] + f[s][d];
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		t = in.nextInt();
+		for (int c = 1; c <= t; c++) {
+			n = in.nextInt();
+			q = in.nextInt();
+			for (int i = 1; i <= n; i++) {
+				arr[i] = in.nextInt();
+			}
+			prepare();
+			for (int i = 1, s, d, k; i <= q; i++) {
+				s = in.nextInt();
+				d = in.nextInt();
+				k = in.nextInt();
+				out.println(query(s, d, k));
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class175/Code02_SumOfProgression2.java b/src/class175/Code02_SumOfProgression2.java
new file mode 100644
index 000000000..38f2faf34
--- /dev/null
+++ b/src/class175/Code02_SumOfProgression2.java
@@ -0,0 +1,67 @@
+package class175;
+
+// 等差数列求和，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1921F
+// 测试链接 : https://codeforces.com/problemset/problem/1921/F
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXB = 401;
+//const int MAXS = MAXN + MAXB;
+//int t, n, q, blen;
+//int arr[MAXN];
+//long long f[MAXS][MAXB];
+//long long g[MAXS][MAXB];
+//
+//long long query(int s, int d, int k) {
+//    if (d <= blen) {
+//        return g[s][d] - g[s + d * k][d] - f[s + d * k][d] * k;
+//    }
+//    long long ans = 0;
+//    for (int i = 1; i <= k; i++) {
+//        ans += 1LL * i * arr[s + (i - 1) * d];
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    for (int s = 1; s <= n + blen; s++) {
+//        for (int d = 1; d < MAXB; d++) {
+//            f[s][d] = g[s][d] = 0;
+//        }
+//    }
+//    for (int s = n; s >= 1; s--) {
+//        for (int d = 1; d <= blen; d++) {
+//            f[s][d] = f[s + d][d] + arr[s];
+//        }
+//    }
+//    for (int s = n; s >= 1; s--) {
+//        for (int d = 1; d <= blen; d++) {
+//            g[s][d] = g[s + d][d] + f[s][d];
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> t;
+//    for (int c = 1; c <= t; c++) {
+//        cin >> n >> q;
+//        for (int i = 1; i <= n; ++i) {
+//            cin >> arr[i];
+//        }
+//        prepare();
+//        for (int i = 1, s, d, k; i <= q; i++) {
+//            cin >> s >> d >> k;
+//            cout << query(s, d, k) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From a0a72393409fe6a29b9f30efdeeeec95f1654b60 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 31 Jul 2025 15:21:14 +0800
Subject: [PATCH 1208/1712] modify code

---
 src/class175/Code02_ArrayQueries1.java        | 99 +++++++++++++++++++
 src/class175/Code02_ArrayQueries2.java        | 54 ++++++++++
 ...on1.java => Code03_SumOfProgression1.java} | 30 +++---
 ...on2.java => Code03_SumOfProgression2.java} | 30 +++---
 4 files changed, 181 insertions(+), 32 deletions(-)
 create mode 100644 src/class175/Code02_ArrayQueries1.java
 create mode 100644 src/class175/Code02_ArrayQueries2.java
 rename src/class175/{Code02_SumOfProgression1.java => Code03_SumOfProgression1.java} (81%)
 rename src/class175/{Code02_SumOfProgression2.java => Code03_SumOfProgression2.java} (70%)

diff --git a/src/class175/Code02_ArrayQueries1.java b/src/class175/Code02_ArrayQueries1.java
new file mode 100644
index 000000000..8036e2e21
--- /dev/null
+++ b/src/class175/Code02_ArrayQueries1.java
@@ -0,0 +1,99 @@
+package class175;
+
+// 数组查询，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF797E
+// 测试链接 : https://codeforces.com/problemset/problem/797/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code02_ArrayQueries1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 401;
+	public static int n, q, blen;
+	public static int[] arr = new int[MAXN];
+	public static int[][] dp = new int[MAXN][MAXB];
+
+	public static int query(int p, int k) {
+		if (k <= blen) {
+			return dp[p][k];
+		}
+		int ans = 0;
+		while (p <= n) {
+			ans++;
+			p += arr[p] + k;
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		for (int p = n; p >= 1; p--) {
+			for (int k = 1; k <= blen; k++) {
+				dp[p][k] = 1 + (p + arr[p] + k > n ? 0 : dp[p + arr[p] + k][k]);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		q = in.nextInt();
+		for (int i = 1, p, k; i <= q; i++) {
+			p = in.nextInt();
+			k = in.nextInt();
+			out.println(query(p, k));
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class175/Code02_ArrayQueries2.java b/src/class175/Code02_ArrayQueries2.java
new file mode 100644
index 000000000..e3b6b2ec7
--- /dev/null
+++ b/src/class175/Code02_ArrayQueries2.java
@@ -0,0 +1,54 @@
+package class175;
+
+// 数组查询，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF797E
+// 测试链接 : https://codeforces.com/problemset/problem/797/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXB = 401;
+//int n, q, blen;
+//int arr[MAXN];
+//int dp[MAXN][MAXB];
+//
+//int query(int p, int k) {
+//    if (k <= blen) {
+//        return dp[p][k];
+//    }
+//    int ans = 0;
+//    while (p <= n) {
+//        ans++;
+//        p += arr[p] + k;
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    for (int p = n; p >= 1; p--) {
+//        for (int k = 1; k <= blen; k++) {
+//            dp[p][k] = 1 + (p + arr[p] + k > n ? 0 : dp[p + arr[p] + k][k]);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    cin >> q;
+//    for (int i = 1, p, k; i <= q; i++) {
+//        cin >> p >> k;
+//        cout << query(p, k) << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class175/Code02_SumOfProgression1.java b/src/class175/Code03_SumOfProgression1.java
similarity index 81%
rename from src/class175/Code02_SumOfProgression1.java
rename to src/class175/Code03_SumOfProgression1.java
index e9b5a94f6..4092a4399 100644
--- a/src/class175/Code02_SumOfProgression1.java
+++ b/src/class175/Code03_SumOfProgression1.java
@@ -10,42 +10,40 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_SumOfProgression1 {
+public class Code03_SumOfProgression1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 401;
-	public static int MAXS = MAXN + MAXB;
 	public static int t, n, q, blen;
 	public static int[] arr = new int[MAXN];
-	public static long[][] f = new long[MAXS][MAXB];
-	public static long[][] g = new long[MAXS][MAXB];
+	public static long[][] f = new long[MAXN][MAXB];
+	public static long[][] g = new long[MAXN][MAXB];
 
 	public static long query(int s, int d, int k) {
-		if (d <= blen) {
-			return g[s][d] - g[s + d * k][d] - f[s + d * k][d] * k;
-		}
 		long ans = 0;
-		for (int i = 1; i <= k; i++) {
-			ans += 1L * arr[s + (i - 1) * d] * i;
+		if (d <= blen) {
+			ans = g[s][d];
+			if (s + d * k <= n) {
+				ans = ans - g[s + d * k][d] - f[s + d * k][d] * k;
+			}
+		} else {
+			for (int i = 1; i <= k; i++) {
+				ans += 1L * arr[s + (i - 1) * d] * i;
+			}
 		}
 		return ans;
 	}
 
 	public static void prepare() {
 		blen = (int) Math.sqrt(n);
-		for (int s = 1; s <= n + blen; s++) {
-			for (int d = 1; d < MAXB; d++) {
-				f[s][d] = g[s][d] = 0;
-			}
-		}
 		for (int s = n; s >= 1; s--) {
 			for (int d = 1; d <= blen; d++) {
-				f[s][d] = f[s + d][d] + arr[s];
+				f[s][d] = arr[s] + (s + d > n ? 0 : f[s + d][d]);
 			}
 		}
 		for (int s = n; s >= 1; s--) {
 			for (int d = 1; d <= blen; d++) {
-				g[s][d] = g[s + d][d] + f[s][d];
+				g[s][d] = f[s][d] + (s + d > n ? 0 : g[s + d][d]);
 			}
 		}
 	}
diff --git a/src/class175/Code02_SumOfProgression2.java b/src/class175/Code03_SumOfProgression2.java
similarity index 70%
rename from src/class175/Code02_SumOfProgression2.java
rename to src/class175/Code03_SumOfProgression2.java
index 38f2faf34..20f7464a0 100644
--- a/src/class175/Code02_SumOfProgression2.java
+++ b/src/class175/Code03_SumOfProgression2.java
@@ -12,38 +12,36 @@
 //
 //const int MAXN = 100001;
 //const int MAXB = 401;
-//const int MAXS = MAXN + MAXB;
 //int t, n, q, blen;
 //int arr[MAXN];
-//long long f[MAXS][MAXB];
-//long long g[MAXS][MAXB];
+//long long f[MAXN][MAXB];
+//long long g[MAXN][MAXB];
 //
 //long long query(int s, int d, int k) {
-//    if (d <= blen) {
-//        return g[s][d] - g[s + d * k][d] - f[s + d * k][d] * k;
-//    }
 //    long long ans = 0;
-//    for (int i = 1; i <= k; i++) {
-//        ans += 1LL * i * arr[s + (i - 1) * d];
+//    if (d <= blen) {
+//        ans = g[s][d];
+//        if (s + d * k <= n) {
+//            ans -= g[s + d * k][d] + f[s + d * k][d] * k;
+//        }
+//    } else {
+//        for (int i = 1; i <= k; i++) {
+//            ans += 1LL * arr[s + (i - 1) * d] * i;
+//        }
 //    }
 //    return ans;
 //}
 //
 //void prepare() {
 //    blen = (int)sqrt(n);
-//    for (int s = 1; s <= n + blen; s++) {
-//        for (int d = 1; d < MAXB; d++) {
-//            f[s][d] = g[s][d] = 0;
-//        }
-//    }
 //    for (int s = n; s >= 1; s--) {
 //        for (int d = 1; d <= blen; d++) {
-//            f[s][d] = f[s + d][d] + arr[s];
+//            f[s][d] = arr[s] + (s + d > n ? 0 : f[s + d][d]);
 //        }
 //    }
 //    for (int s = n; s >= 1; s--) {
 //        for (int d = 1; d <= blen; d++) {
-//            g[s][d] = g[s + d][d] + f[s][d];
+//            g[s][d] = f[s][d] + (s + d > n ? 0 : g[s + d][d]);
 //        }
 //    }
 //}
@@ -54,7 +52,7 @@
 //    cin >> t;
 //    for (int c = 1; c <= t; c++) {
 //        cin >> n >> q;
-//        for (int i = 1; i <= n; ++i) {
+//        for (int i = 1; i <= n; i++) {
 //            cin >> arr[i];
 //        }
 //        prepare();

From 38091a52a3667326b42506cba164147b0aab1a94 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 31 Jul 2025 21:04:16 +0800
Subject: [PATCH 1209/1712] modify code

---
 src/class175/Code04_Initialization1.java | 162 +++++++++++++++++++++++
 src/class175/Code04_Initialization2.java | 112 ++++++++++++++++
 2 files changed, 274 insertions(+)
 create mode 100644 src/class175/Code04_Initialization1.java
 create mode 100644 src/class175/Code04_Initialization2.java

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
new file mode 100644
index 000000000..2a5f26267
--- /dev/null
+++ b/src/class175/Code04_Initialization1.java
@@ -0,0 +1,162 @@
+package class175;
+
+// 初始化，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5309
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code04_Initialization2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code04_Initialization1 {
+
+	public static int MAXN = 200001;
+	public static int MAXB = 2001;
+	public static int MOD = 1000000007;
+	public static int n, m;
+
+	public static long[] arr = new long[MAXN];
+	public static long[] sum = new long[MAXN];
+	public static long[][] pre = new long[MAXB][MAXB];
+	public static long[][] suf = new long[MAXB][MAXB];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	public static void add(int x, int y, int z) {
+		if (x >= blen) {
+			for (int i = y; i <= n; i += x) {
+				arr[i] += z;
+				sum[bi[i]] += z;
+			}
+		} else {
+			for (int i = y; i <= x; i++) {
+				pre[x][i] += z;
+			}
+			for (int i = 1; i <= y; i++) {
+				suf[x][i] += z;
+			}
+		}
+	}
+
+	public static long querySum(int l, int r) {
+		int lb = bi[l], rb = bi[r];
+		long ans = 0;
+		if (lb == rb) {
+			for (int i = l; i <= r; i++) {
+				ans += arr[i];
+			}
+		} else {
+			for (int i = l; i <= br[lb]; i++) {
+				ans += arr[i];
+			}
+			for (int i = bl[rb]; i <= r; i++) {
+				ans += arr[i];
+			}
+			for (int b = lb + 1; b <= rb - 1; b++) {
+				ans += sum[b];
+			}
+		}
+		return ans;
+	}
+
+	public static long query(int l, int r) {
+		long ans = querySum(l, r);
+		for (int x = 1, lb, rb, num; x < blen; x++) {
+			lb = (l - 1) / x + 1;
+			rb = (r - 1) / x + 1;
+			num = rb - lb - 1;
+			if (lb == rb) {
+				ans = ans - pre[x][(l - 1) % x] + pre[x][(r - 1) % x + 1];
+			} else {
+				ans = ans + pre[x][x] * num + pre[x][(r - 1) % x + 1] + suf[x][(l - 1) % x + 1];
+			}
+		}
+		return ans;
+	}
+
+	public static void prepare() {
+		blen = 128;
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int b = 1; b <= bnum; b++) {
+			bl[b] = (b - 1) * blen + 1;
+			br[b] = Math.min(b * blen, n);
+			for (int i = bl[b]; i <= br[b]; i++) {
+				sum[b] += arr[i];
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			op = in.nextInt();
+			x = in.nextInt();
+			y = in.nextInt();
+			if (op == 1) {
+				z = in.nextInt();
+				add(x, y, z);
+			} else {
+				out.println((query(x, y) % MOD + MOD) % MOD);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
new file mode 100644
index 000000000..0eefea368
--- /dev/null
+++ b/src/class175/Code04_Initialization2.java
@@ -0,0 +1,112 @@
+package class175;
+
+// 初始化，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5309
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXB = 2001;
+//const int MOD  = 1000000007;
+//int n, m;
+//
+//long long arr[MAXN];
+//long long sum[MAXN];
+//long long pre[MAXB][MAXB];
+//long long suf[MAXB][MAXB];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//void add(int x, int y, long long z) {
+//    if (x >= blen) {
+//        for (int i = y; i <= n; i += x) {
+//            arr[i] += z;
+//            sum[bi[i]] += z;
+//        }
+//    } else {
+//        for (int i = y; i <= x; i++) {
+//            pre[x][i] += z;
+//        }
+//        for (int i = 1; i <= y; i++) {
+//            suf[x][i] += z;
+//        }
+//    }
+//}
+//
+//long long querySum(int l, int r) {
+//    int lb = bi[l], rb = bi[r];
+//    long long ans = 0;
+//    if (lb == rb) {
+//        for (int i = l; i <= r; i++) {
+//            ans += arr[i];
+//        }
+//    } else {
+//        for (int i = l; i <= br[lb]; i++) {
+//            ans += arr[i];
+//        }
+//        for (int i = bl[rb]; i <= r; i++) {
+//            ans += arr[i];
+//        }
+//        for (int b = lb + 1; b <= rb - 1; b++) {
+//            ans += sum[b];
+//        }
+//    }
+//    return ans;
+//}
+//
+//long long query(int l, int r) {
+//    long long ans = querySum(l, r);
+//    for (int x = 1, lb, rb, num; x < blen; x++) {
+//        lb = (l - 1) / x + 1;
+//        rb = (r - 1) / x + 1;
+//        num = rb - lb - 1;
+//        if (lb == rb) {
+//            ans = ans - pre[x][(l - 1) % x] + pre[x][(r - 1) % x + 1];
+//        } else {
+//            ans = ans + pre[x][x] * num + pre[x][(r - 1) % x + 1] + suf[x][(l - 1) % x + 1];
+//        }
+//    }
+//    return ans;
+//}
+//
+//void prepare() {
+//    blen = 128;
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int b = 1; b <= bnum; b++) {
+//        bl[b] = (b - 1) * blen + 1;
+//        br[b] = min(b * blen, n);
+//        for (int i = bl[b]; i <= br[b]; i++) {
+//            sum[b] += arr[i];
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 1) {
+//            cin >> z;
+//            add(x, y, z);
+//        } else {
+//            cout << ((query(x, y) % MOD + MOD) % MOD) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 0cbca3816ba94b81ffaccf6040186f72b086fbef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 31 Jul 2025 21:12:39 +0800
Subject: [PATCH 1210/1712] modify code

---
 src/class175/Code04_Initialization1.java | 16 ++++++++--------
 src/class175/Code04_Initialization2.java | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index 2a5f26267..785d522f6 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -30,18 +30,18 @@ public class Code04_Initialization1 {
 	public static int[] br = new int[MAXB];
 
 	public static void add(int x, int y, int z) {
-		if (x >= blen) {
-			for (int i = y; i <= n; i += x) {
-				arr[i] += z;
-				sum[bi[i]] += z;
-			}
-		} else {
+		if (x <= blen) {
 			for (int i = y; i <= x; i++) {
 				pre[x][i] += z;
 			}
 			for (int i = 1; i <= y; i++) {
 				suf[x][i] += z;
 			}
+		} else {
+			for (int i = y; i <= n; i += x) {
+				arr[i] += z;
+				sum[bi[i]] += z;
+			}
 		}
 	}
 
@@ -68,7 +68,7 @@ public static long querySum(int l, int r) {
 
 	public static long query(int l, int r) {
 		long ans = querySum(l, r);
-		for (int x = 1, lb, rb, num; x < blen; x++) {
+		for (int x = 1, lb, rb, num; x <= blen; x++) {
 			lb = (l - 1) / x + 1;
 			rb = (r - 1) / x + 1;
 			num = rb - lb - 1;
@@ -82,7 +82,7 @@ public static long query(int l, int r) {
 	}
 
 	public static void prepare() {
-		blen = 128;
+		blen = 150;
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 0eefea368..1a2539436 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -25,18 +25,18 @@
 //int br[MAXB];
 //
 //void add(int x, int y, long long z) {
-//    if (x >= blen) {
-//        for (int i = y; i <= n; i += x) {
-//            arr[i] += z;
-//            sum[bi[i]] += z;
-//        }
-//    } else {
+//    if (x <= blen) {
 //        for (int i = y; i <= x; i++) {
 //            pre[x][i] += z;
 //        }
 //        for (int i = 1; i <= y; i++) {
 //            suf[x][i] += z;
 //        }
+//    } else {
+//        for (int i = y; i <= n; i += x) {
+//            arr[i] += z;
+//            sum[bi[i]] += z;
+//        }
 //    }
 //}
 //
@@ -63,7 +63,7 @@
 //
 //long long query(int l, int r) {
 //    long long ans = querySum(l, r);
-//    for (int x = 1, lb, rb, num; x < blen; x++) {
+//    for (int x = 1, lb, rb, num; x <= blen; x++) {
 //        lb = (l - 1) / x + 1;
 //        rb = (r - 1) / x + 1;
 //        num = rb - lb - 1;
@@ -77,7 +77,7 @@
 //}
 //
 //void prepare() {
-//    blen = 128;
+//    blen = 150;
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;

From e01fbd0b9dc5fbc91e0bbd074d2b5f254527f8c2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 31 Jul 2025 21:16:38 +0800
Subject: [PATCH 1211/1712] modify code

---
 src/class175/Code04_Initialization1.java | 4 ++--
 src/class175/Code04_Initialization2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index 785d522f6..83eed97cd 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -78,7 +78,7 @@ public static long query(int l, int r) {
 				ans = ans + pre[x][x] * num + pre[x][(r - 1) % x + 1] + suf[x][(l - 1) % x + 1];
 			}
 		}
-		return ans;
+		return (ans % MOD + MOD) % MOD;
 	}
 
 	public static void prepare() {
@@ -113,7 +113,7 @@ public static void main(String[] args) throws Exception {
 				z = in.nextInt();
 				add(x, y, z);
 			} else {
-				out.println((query(x, y) % MOD + MOD) % MOD);
+				out.println(query(x, y));
 			}
 		}
 		out.flush();
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 1a2539436..ef05a63cf 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -73,7 +73,7 @@
 //            ans = ans + pre[x][x] * num + pre[x][(r - 1) % x + 1] + suf[x][(l - 1) % x + 1];
 //        }
 //    }
-//    return ans;
+//    return (ans % MOD + MOD) % MOD;
 //}
 //
 //void prepare() {
@@ -105,7 +105,7 @@
 //            cin >> z;
 //            add(x, y, z);
 //        } else {
-//            cout << ((query(x, y) % MOD + MOD) % MOD) << '\n';
+//            cout << query(x, y) << '\n';
 //        }
 //    }
 //    return 0;

From a72f94d1607121d8ba8ecf00d12703bcfc0e669b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 31 Jul 2025 21:48:11 +0800
Subject: [PATCH 1212/1712] modify code

---
 src/class175/Code04_Initialization1.java | 4 ++--
 src/class175/Code04_Initialization2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index 83eed97cd..69fcbc3b7 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -73,9 +73,9 @@ public static long query(int l, int r) {
 			rb = (r - 1) / x + 1;
 			num = rb - lb - 1;
 			if (lb == rb) {
-				ans = ans - pre[x][(l - 1) % x] + pre[x][(r - 1) % x + 1];
+				ans = ans + pre[x][(r - 1) % x + 1] - pre[x][(l - 1) % x];
 			} else {
-				ans = ans + pre[x][x] * num + pre[x][(r - 1) % x + 1] + suf[x][(l - 1) % x + 1];
+				ans = ans + suf[x][(l - 1) % x + 1] + pre[x][x] * num + pre[x][(r - 1) % x + 1];
 			}
 		}
 		return (ans % MOD + MOD) % MOD;
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index ef05a63cf..c98151d8d 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -68,9 +68,9 @@
 //        rb = (r - 1) / x + 1;
 //        num = rb - lb - 1;
 //        if (lb == rb) {
-//            ans = ans - pre[x][(l - 1) % x] + pre[x][(r - 1) % x + 1];
+//            ans = ans + pre[x][(r - 1) % x + 1] - pre[x][(l - 1) % x];
 //        } else {
-//            ans = ans + pre[x][x] * num + pre[x][(r - 1) % x + 1] + suf[x][(l - 1) % x + 1];
+//            ans = ans + suf[x][(l - 1) % x + 1] + pre[x][x] * num + pre[x][(r - 1) % x + 1];
 //        }
 //    }
 //    return (ans % MOD + MOD) % MOD;

From 2862218c889187aea244b8886e9ac6d3e9916dc9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 1 Aug 2025 20:44:23 +0800
Subject: [PATCH 1213/1712] modify code

---
 src/class175/Code05_Skyscraper1.java | 157 +++++++++++++++++++++++++++
 src/class175/Code05_Skyscraper2.java | 102 +++++++++++++++++
 2 files changed, 259 insertions(+)
 create mode 100644 src/class175/Code05_Skyscraper1.java
 create mode 100644 src/class175/Code05_Skyscraper2.java

diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
new file mode 100644
index 000000000..84c89396f
--- /dev/null
+++ b/src/class175/Code05_Skyscraper1.java
@@ -0,0 +1,157 @@
+package class175;
+
+// 雅加达的摩天楼，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3645
+// 测试链接 : https://uoj.ac/problem/111
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.ArrayDeque;
+import java.util.BitSet;
+
+public class Code05_Skyscraper1 {
+
+	static class Node {
+		int idx, jump, step;
+
+		Node(int i, int j, int s) {
+			idx = i;
+			jump = j;
+			step = s;
+		}
+
+	}
+
+	public static int MAXN = 30001;
+	public static int n, m;
+
+	// 每个位置拥有的doge列表
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN];
+	public static int[] to = new int[MAXN];
+	public static int cnt;
+
+	// bfs需要
+	public static ArrayDeque<Node> que = new ArrayDeque<>();
+	public static BitSet[] set = new BitSet[MAXN];
+	public static boolean[] vis = new boolean[MAXN];
+
+	public static void add(int idx, int jump) {
+		next[++cnt] = head[idx];
+		to[cnt] = jump;
+		head[idx] = cnt;
+	}
+
+	public static void extend(int idx, int jump, int step) {
+		if (!set[idx].get(jump)) {
+			set[idx].set(jump);
+			que.addLast(new Node(idx, jump, step));
+		}
+		if (!vis[idx]) {
+			vis[idx] = true;
+			for (int e = head[idx], nextJump; e > 0; e = next[e]) {
+				nextJump = to[e];
+				if (!set[idx].get(nextJump)) {
+					set[idx].set(nextJump);
+					que.addLast(new Node(idx, nextJump, step));
+				}
+			}
+		}
+	}
+
+	public static int bfs(int s, int t) {
+		if (s == t) {
+			return 0;
+		}
+		for (int idx = 0; idx < MAXN; idx++) {
+			set[idx] = new BitSet();
+		}
+		vis[s] = true;
+		for (int e = head[s], jump; e > 0; e = next[e]) {
+			jump = to[e];
+			if (!set[s].get(jump)) {
+				set[s].set(jump);
+				que.addLast(new Node(s, jump, 0));
+			}
+		}
+		while (!que.isEmpty()) {
+			Node cur = que.pollFirst();
+			int idx = cur.idx;
+			int jump = cur.jump;
+			int step = cur.step;
+			if (idx - jump == t || idx + jump == t) {
+				return step + 1;
+			}
+			if (idx - jump >= 0) {
+				extend(idx - jump, jump, step + 1);
+			}
+			if (idx + jump < n) {
+				extend(idx + jump, jump, step + 1);
+			}
+		}
+		return -1;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		n = in.nextInt();
+		m = in.nextInt();
+		int s = in.nextInt();
+		int sjump = in.nextInt();
+		int t = in.nextInt();
+		int tjump = in.nextInt();
+		add(s, sjump);
+		add(t, tjump);
+		for (int i = 2, idx, jump; i < m; i++) {
+			idx = in.nextInt();
+			jump = in.nextInt();
+			add(idx, jump);
+		}
+		out.println(bfs(s, t));
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class175/Code05_Skyscraper2.java b/src/class175/Code05_Skyscraper2.java
new file mode 100644
index 000000000..b858d0646
--- /dev/null
+++ b/src/class175/Code05_Skyscraper2.java
@@ -0,0 +1,102 @@
+package class175;
+
+// 雅加达的摩天楼，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3645
+// 测试链接 : https://uoj.ac/problem/111
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int idx, jump, step;
+//};
+//
+//const int MAXN = 30001;
+//int n, m;
+//
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cnt;
+//
+//deque<Node> que;
+//bitset<MAXN> bs[MAXN];
+//bool vis[MAXN];
+//
+//void add(int idx, int jump) {
+//    nxt[++cnt] = head[idx];
+//    to[cnt] = jump;
+//    head[idx] = cnt;
+//}
+//
+//void extend(int idx, int jump, int step) {
+//    if (!bs[idx].test(jump)) {
+//        bs[idx].set(jump);
+//        que.push_back({idx, jump, step});
+//    }
+//    if (!vis[idx]) {
+//        vis[idx] = true;
+//        for (int e = head[idx], nextJump; e; e = nxt[e]) {
+//            nextJump = to[e];
+//            if (!bs[idx].test(nextJump)) {
+//                bs[idx].set(nextJump);
+//                que.push_back({idx, nextJump, step});
+//            }
+//        }
+//    }
+//}
+//
+//int bfs(int s, int t) {
+//    if (s == t) {
+//        return 0;
+//    }
+//    for (int i = 0; i < n; i++) {
+//        bs[i].reset();
+//        vis[i] = false;
+//    }
+//    que.clear();
+//    vis[s] = true;
+//    for (int e = head[s], jump; e; e = nxt[e]) {
+//        jump = to[e];
+//        if (!bs[s].test(jump)) {
+//            bs[s].set(jump);
+//            que.push_back({s, jump, 0});
+//        }
+//    }
+//    while (!que.empty()) {
+//        Node cur = que.front();
+//        que.pop_front();
+//        int idx = cur.idx;
+//        int jump = cur.jump;
+//        int step = cur.step;
+//        if (idx - jump == t || idx + jump == t) {
+//            return step + 1;
+//        }
+//        if (idx - jump >= 0) {
+//            extend(idx - jump, jump, step + 1);
+//        }
+//        if (idx + jump < n) {
+//            extend(idx + jump, jump, step + 1);
+//        }
+//    }
+//    return -1;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    int s, sjump, t, tjump;
+//    cin >> s >> sjump >> t >> tjump;
+//    add(s, sjump);
+//    add(t, tjump);
+//    for (int i = 2, idx, jump; i < m; i++) {
+//        cin >> idx >> jump;
+//        add(idx, jump);
+//    }
+//    cout << bfs(s, t) << '\n';
+//    return 0;
+//}
\ No newline at end of file

From f2f82995335784309b422203cc7a8f0c15f5f9cd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 1 Aug 2025 23:07:35 +0800
Subject: [PATCH 1214/1712] modify code

---
 src/class175/Code05_Skyscraper1.java | 44 ++++++++++++----------------
 src/class175/Code05_Skyscraper2.java | 41 +++++++++++---------------
 2 files changed, 36 insertions(+), 49 deletions(-)

diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
index 84c89396f..3d41b9755 100644
--- a/src/class175/Code05_Skyscraper1.java
+++ b/src/class175/Code05_Skyscraper1.java
@@ -33,10 +33,9 @@ static class Node {
 	public static int[] to = new int[MAXN];
 	public static int cnt;
 
-	// bfs需要
+	// bfs过程
 	public static ArrayDeque<Node> que = new ArrayDeque<>();
-	public static BitSet[] set = new BitSet[MAXN];
-	public static boolean[] vis = new boolean[MAXN];
+	public static BitSet[] vis = new BitSet[MAXN];
 
 	public static void add(int idx, int jump) {
 		next[++cnt] = head[idx];
@@ -44,38 +43,33 @@ public static void add(int idx, int jump) {
 		head[idx] = cnt;
 	}
 
+	public static void trigger(int idx, int step) {
+		for (int e = head[idx], nextJump; e > 0; e = next[e]) {
+			nextJump = to[e];
+			if (!vis[idx].get(nextJump)) {
+				vis[idx].set(nextJump);
+				que.addLast(new Node(idx, nextJump, step));
+			}
+		}
+		head[idx] = 0;
+	}
+
 	public static void extend(int idx, int jump, int step) {
-		if (!set[idx].get(jump)) {
-			set[idx].set(jump);
+		trigger(idx, step);
+		if (!vis[idx].get(jump)) {
+			vis[idx].set(jump);
 			que.addLast(new Node(idx, jump, step));
 		}
-		if (!vis[idx]) {
-			vis[idx] = true;
-			for (int e = head[idx], nextJump; e > 0; e = next[e]) {
-				nextJump = to[e];
-				if (!set[idx].get(nextJump)) {
-					set[idx].set(nextJump);
-					que.addLast(new Node(idx, nextJump, step));
-				}
-			}
-		}
 	}
 
 	public static int bfs(int s, int t) {
 		if (s == t) {
 			return 0;
 		}
-		for (int idx = 0; idx < MAXN; idx++) {
-			set[idx] = new BitSet();
-		}
-		vis[s] = true;
-		for (int e = head[s], jump; e > 0; e = next[e]) {
-			jump = to[e];
-			if (!set[s].get(jump)) {
-				set[s].set(jump);
-				que.addLast(new Node(s, jump, 0));
-			}
+		for (int i = 0; i < MAXN; i++) {
+			vis[i] = new BitSet();
 		}
+		trigger(s, 0);
 		while (!que.isEmpty()) {
 			Node cur = que.pollFirst();
 			int idx = cur.idx;
diff --git a/src/class175/Code05_Skyscraper2.java b/src/class175/Code05_Skyscraper2.java
index b858d0646..f050a6fa4 100644
--- a/src/class175/Code05_Skyscraper2.java
+++ b/src/class175/Code05_Skyscraper2.java
@@ -23,8 +23,7 @@
 //int cnt;
 //
 //deque<Node> que;
-//bitset<MAXN> bs[MAXN];
-//bool vis[MAXN];
+//bitset<MAXN> vis[MAXN];
 //
 //void add(int idx, int jump) {
 //    nxt[++cnt] = head[idx];
@@ -32,21 +31,23 @@
 //    head[idx] = cnt;
 //}
 //
+//void trigger(int idx, int step) {
+//    for (int e = head[idx], nextJump; e; e = nxt[e]) {
+//        nextJump = to[e];
+//        if (!vis[idx].test(nextJump)) {
+//            vis[idx].set(nextJump);
+//            que.push_back({idx, nextJump, step});
+//        }
+//    }
+//    head[idx] = 0;
+//}
+//
 //void extend(int idx, int jump, int step) {
-//    if (!bs[idx].test(jump)) {
-//        bs[idx].set(jump);
+//    trigger(idx, step);
+//    if (!vis[idx].test(jump)) {
+//        vis[idx].set(jump);
 //        que.push_back({idx, jump, step});
 //    }
-//    if (!vis[idx]) {
-//        vis[idx] = true;
-//        for (int e = head[idx], nextJump; e; e = nxt[e]) {
-//            nextJump = to[e];
-//            if (!bs[idx].test(nextJump)) {
-//                bs[idx].set(nextJump);
-//                que.push_back({idx, nextJump, step});
-//            }
-//        }
-//    }
 //}
 //
 //int bfs(int s, int t) {
@@ -54,18 +55,10 @@
 //        return 0;
 //    }
 //    for (int i = 0; i < n; i++) {
-//        bs[i].reset();
-//        vis[i] = false;
+//        vis[i].reset();
 //    }
 //    que.clear();
-//    vis[s] = true;
-//    for (int e = head[s], jump; e; e = nxt[e]) {
-//        jump = to[e];
-//        if (!bs[s].test(jump)) {
-//            bs[s].set(jump);
-//            que.push_back({s, jump, 0});
-//        }
-//    }
+//    trigger(s, 0);
 //    while (!que.empty()) {
 //        Node cur = que.front();
 //        que.pop_front();

From 143c90d9891ebab2512411882233446bc5674876 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 2 Aug 2025 17:17:21 +0800
Subject: [PATCH 1215/1712] modify code

---
 src/class175/Code06_GivenTree1.java | 170 ++++++++++++++++++++++++++++
 src/class175/Code06_GivenTree2.java | 121 ++++++++++++++++++++
 2 files changed, 291 insertions(+)
 create mode 100644 src/class175/Code06_GivenTree1.java
 create mode 100644 src/class175/Code06_GivenTree2.java

diff --git a/src/class175/Code06_GivenTree1.java b/src/class175/Code06_GivenTree1.java
new file mode 100644
index 000000000..abcc818db
--- /dev/null
+++ b/src/class175/Code06_GivenTree1.java
@@ -0,0 +1,170 @@
+package class175;
+
+// 给你一棵树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1039D
+// 测试链接 : https://codeforces.com/problemset/problem/1039/D
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code06_GivenTree1 {
+
+	public static int MAXN = 200001;
+	public static int n, blen;
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg = 0;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] seg = new int[MAXN];
+	public static int cntd = 0;
+
+	public static int[] len = new int[MAXN];
+	public static int[] max1 = new int[MAXN];
+	public static int[] max2 = new int[MAXN];
+
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs(int u, int f) {
+		fa[u] = f;
+		seg[++cntd] = u;
+		for (int e = head[u]; e > 0; e = next[e]) {
+			if (to[e] != f) {
+				dfs(to[e], u);
+			}
+		}
+	}
+
+	public static int getCnt(int limit) {
+		int pathCnt = 0;
+		for (int dfn = n, cur, father; dfn >= 1; dfn--) {
+			cur = seg[dfn];
+			father = fa[cur];
+			if (max1[cur] + max2[cur] + 1 >= limit) {
+				pathCnt++;
+				len[cur] = 0;
+			} else {
+				len[cur] = max1[cur] + 1;
+			}
+			if (len[cur] > max1[father]) {
+				max2[father] = max1[father];
+				max1[father] = len[cur];
+			} else if (len[cur] > max2[father]) {
+				max2[father] = len[cur];
+			}
+			max1[cur] = max2[cur] = 0;
+		}
+		return pathCnt;
+	}
+
+	public static int findLimit(int l, int r, int pathCnt) {
+		int limit = 1;
+		while (l <= r) {
+			int mid = (l + r) >> 1;
+			if (getCnt(mid) <= pathCnt) {
+				limit = mid;
+				r = mid - 1;
+			} else {
+				l = mid + 1;
+			}
+		}
+		return limit;
+	}
+
+	public static void compute() {
+		for (int k = 1; k <= blen; k++) {
+			ans[k] = getCnt(k);
+		}
+		int l = 1, r = n;
+		for (int pathCnt = 0; pathCnt * blen <= n; pathCnt++) {
+			int limit = findLimit(l, r, pathCnt);
+			if (getCnt(limit) == pathCnt) {
+				ans[limit] = pathCnt;
+				r = limit;
+			}
+		}
+	}
+
+	public static void prepare() {
+		dfs(1, 0);
+		int log2n = 0;
+		while ((1 << log2n) <= (n >> 1)) {
+			log2n++;
+		}
+		blen = Math.max(1, (int) Math.sqrt(n * log2n));
+		Arrays.fill(ans, 1, n + 1, -1);
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		n = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= n; i++) {
+			if (ans[i] == -1) {
+				ans[i] = ans[i - 1];
+			}
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class175/Code06_GivenTree2.java b/src/class175/Code06_GivenTree2.java
new file mode 100644
index 000000000..5d28dd73e
--- /dev/null
+++ b/src/class175/Code06_GivenTree2.java
@@ -0,0 +1,121 @@
+package class175;
+
+// 给你一棵树，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1039D
+// 测试链接 : https://codeforces.com/problemset/problem/1039/D
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//int n, blen;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg = 0;
+//
+//int fa[MAXN];
+//int seg[MAXN];
+//int cntd = 0;
+//
+//int len[MAXN];
+//int max1[MAXN];
+//int max2[MAXN];
+//
+//int ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//	nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int f) {
+//    fa[u] = f;
+//    seg[++cntd] = u;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//    	if (to[e] != f) {
+//    	    dfs(to[e], u);
+//    	}
+//    }
+//}
+//
+//int getCnt(int limit) {
+//    int pathCnt = 0;
+//    for (int dfn = n, cur, father; dfn >= 1; dfn--) {
+//        cur = seg[dfn];
+//        father = fa[cur];
+//        if (max1[cur] + max2[cur] + 1 >= limit) {
+//            pathCnt++;
+//            len[cur] = 0;
+//        } else {
+//            len[cur] = max1[cur] + 1;
+//        }
+//        if (len[cur] > max1[father]) {
+//        	max2[father] = max1[father];
+//            max1[father] = len[cur];
+//        } else if (len[cur] > max2[father]) {
+//        	max2[father] = len[cur];
+//        }
+//        max1[cur] = max2[cur] = 0;
+//    }
+//    return pathCnt;
+//}
+//
+//int findLimit(int l, int r, int pathCnt) {
+//    int limit = 1;
+//    while (l <= r) {
+//        int mid = (l + r) >> 1;
+//        if (getCnt(mid) <= pathCnt) {
+//            limit = mid;
+//            r = mid - 1;
+//        } else {
+//            l = mid + 1;
+//        }
+//    }
+//    return limit;
+//}
+//
+//void compute() {
+//    for (int k = 1; k <= blen; k++) {
+//        ans[k] = getCnt(k);
+//    }
+//    int l = 1, r = n;
+//    for (int pathCnt = 0; pathCnt * blen <= n; pathCnt++) {
+//        int limit = findLimit(l, r, pathCnt);
+//        if (getCnt(limit) == pathCnt) {
+//            ans[limit] = pathCnt;
+//            r = limit;
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    dfs(1, 0);
+//    blen = max(1, (int)sqrt(n * log2(n)));
+//    fill(ans + 1, ans + n + 1, -1);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= n; i++) {
+//        if (ans[i] == -1) {
+//            ans[i] = ans[i - 1];
+//        }
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 9cb6b0d5ae1dce1490e91b304170d500c181d4fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 2 Aug 2025 19:20:19 +0800
Subject: [PATCH 1216/1712] modify code

---
 src/class175/Code06_TillCollapse1.java        | 123 ++++++++++++++++++
 src/class175/Code06_TillCollapse2.java        |  79 +++++++++++
 ...GivenTree1.java => Code07_GivenTree1.java} |  15 ++-
 ...GivenTree2.java => Code07_GivenTree2.java} |  13 +-
 4 files changed, 219 insertions(+), 11 deletions(-)
 create mode 100644 src/class175/Code06_TillCollapse1.java
 create mode 100644 src/class175/Code06_TillCollapse2.java
 rename src/class175/{Code06_GivenTree1.java => Code07_GivenTree1.java} (95%)
 rename src/class175/{Code06_GivenTree2.java => Code07_GivenTree2.java} (93%)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
new file mode 100644
index 000000000..e1028ba2e
--- /dev/null
+++ b/src/class175/Code06_TillCollapse1.java
@@ -0,0 +1,123 @@
+package class175;
+
+// 直到倒下，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF786C
+// 测试链接 : https://codeforces.com/problemset/problem/786/C
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.InputStream;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.io.IOException;
+
+public class Code06_TillCollapse1 {
+
+	public static int MAXN = 100001;
+	public static int n, blen = 1000;
+	public static int[] arr = new int[MAXN];
+	public static int[] num = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	private static int query(int x) {
+		Arrays.fill(num, 0);
+		int cnt = 0, lst = 1, tot = 0;
+		for (int i = 1; i <= n; i++) {
+			if (num[arr[i]] == 0) {
+				cnt++;
+				num[arr[i]] = 1;
+			}
+			if (cnt > x) {
+				tot++;
+				for (int j = lst; j <= i; j++) {
+					num[arr[j]] = 0;
+				}
+				lst = i;
+				num[arr[i]] = 1;
+				cnt = 1;
+			}
+		}
+		if (cnt > 0) {
+			tot++;
+		}
+		return tot;
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= blen; i++) {
+			ans[i] = query(i);
+		}
+		for (int i = blen + 1; i <= n; i++) {
+			int tmp = query(i);
+			int l = i, r = n, find = i;
+			while (l <= r) {
+				int mid = (l + r) >> 1;
+				if (query(mid) >= tmp) {
+					find = mid;
+					l = mid + 1;
+				} else {
+					r = mid - 1;
+				}
+			}
+			for (int j = i; j <= find; j++) {
+				ans[j] = tmp;
+			}
+			i = find;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(System.out);
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		compute();
+		for (int i = 1; i <= n; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
new file mode 100644
index 000000000..aa5b0da17
--- /dev/null
+++ b/src/class175/Code06_TillCollapse2.java
@@ -0,0 +1,79 @@
+package class175;
+
+// 直到倒下，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF786C
+// 测试链接 : https://codeforces.com/problemset/problem/786/C
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//int n, blen = 1000;
+//int arr[MAXN];
+//int num[MAXN];
+//int ans[MAXN];
+//
+//int query(int x) {
+//    memset(num, 0, sizeof(num));
+//    int cnt = 0, lst = 1, tot = 0;
+//    for (int i = 1; i <= n; i++) {
+//        if (num[arr[i]] == 0) {
+//            cnt++;
+//            num[arr[i]] = 1;
+//        }
+//        if (cnt > x) {
+//            tot++;
+//            for (int j = lst; j <= i; j++) {
+//                num[arr[j]] = 0;
+//            }
+//            lst = i;
+//            num[arr[i]] = 1;
+//            cnt = 1;
+//        }
+//    }
+//    if (cnt > 0) {
+//        tot++;
+//    }
+//    return tot;
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= blen; i++) {
+//        ans[i] = query(i);
+//    }
+//    for (int i = blen + 1; i <= n; i++) {
+//        int tmp = query(i);
+//        int l = i, r = n, find = i;
+//        while (l <= r) {
+//            int mid = (l + r) >> 1;
+//            if (query(mid) >= tmp) {
+//                find = mid;
+//                l = mid + 1;
+//            } else {
+//                r = mid - 1;
+//            }
+//        }
+//        for (int j = i; j <= find; j++) {
+//            ans[j] = tmp;
+//        }
+//        i = find;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    compute();
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << ' ';
+//    }
+//    cout << '\n';
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class175/Code06_GivenTree1.java b/src/class175/Code07_GivenTree1.java
similarity index 95%
rename from src/class175/Code06_GivenTree1.java
rename to src/class175/Code07_GivenTree1.java
index abcc818db..2ee5b7bdb 100644
--- a/src/class175/Code06_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code06_GivenTree1 {
+public class Code07_GivenTree1 {
 
 	public static int MAXN = 200001;
 	public static int n, blen;
@@ -69,14 +69,17 @@ public static int getCnt(int limit) {
 	}
 
 	public static int findLimit(int l, int r, int pathCnt) {
-		int limit = 1;
+		int limit = -1;
 		while (l <= r) {
 			int mid = (l + r) >> 1;
-			if (getCnt(mid) <= pathCnt) {
-				limit = mid;
+			int cnt = getCnt(mid);
+			if (cnt < pathCnt) {
 				r = mid - 1;
-			} else {
+			} else if (cnt > pathCnt) {
 				l = mid + 1;
+			} else {
+				limit = mid;
+				r = mid - 1;
 			}
 		}
 		return limit;
@@ -89,7 +92,7 @@ public static void compute() {
 		int l = 1, r = n;
 		for (int pathCnt = 0; pathCnt * blen <= n; pathCnt++) {
 			int limit = findLimit(l, r, pathCnt);
-			if (getCnt(limit) == pathCnt) {
+			if (limit != -1) {
 				ans[limit] = pathCnt;
 				r = limit;
 			}
diff --git a/src/class175/Code06_GivenTree2.java b/src/class175/Code07_GivenTree2.java
similarity index 93%
rename from src/class175/Code06_GivenTree2.java
rename to src/class175/Code07_GivenTree2.java
index 5d28dd73e..45c92b8cf 100644
--- a/src/class175/Code06_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -67,14 +67,17 @@
 //}
 //
 //int findLimit(int l, int r, int pathCnt) {
-//    int limit = 1;
+//    int limit = -1;
 //    while (l <= r) {
 //        int mid = (l + r) >> 1;
-//        if (getCnt(mid) <= pathCnt) {
-//            limit = mid;
+//        int cnt = getCnt(mid);
+//        if (cnt < pathCnt) {
 //            r = mid - 1;
-//        } else {
+//        } else if (cnt > pathCnt) {
 //            l = mid + 1;
+//        } else {
+//            limit = mid;
+//            r = mid - 1;
 //        }
 //    }
 //    return limit;
@@ -87,7 +90,7 @@
 //    int l = 1, r = n;
 //    for (int pathCnt = 0; pathCnt * blen <= n; pathCnt++) {
 //        int limit = findLimit(l, r, pathCnt);
-//        if (getCnt(limit) == pathCnt) {
+//        if (limit != -1) {
 //            ans[limit] = pathCnt;
 //            r = limit;
 //        }

From c2cf63b50b666ef1ced0aa1b01f464b82b17a8be Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 3 Aug 2025 10:01:58 +0800
Subject: [PATCH 1217/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 17 ++++++++---------
 src/class175/Code07_GivenTree2.java | 17 ++++++++---------
 2 files changed, 16 insertions(+), 18 deletions(-)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index 2ee5b7bdb..bf28c1e39 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -69,7 +69,7 @@ public static int getCnt(int limit) {
 	}
 
 	public static int findLimit(int l, int r, int pathCnt) {
-		int limit = -1;
+		int find = -1;
 		while (l <= r) {
 			int mid = (l + r) >> 1;
 			int cnt = getCnt(mid);
@@ -78,23 +78,22 @@ public static int findLimit(int l, int r, int pathCnt) {
 			} else if (cnt > pathCnt) {
 				l = mid + 1;
 			} else {
-				limit = mid;
+				find = mid;
 				r = mid - 1;
 			}
 		}
-		return limit;
+		return find;
 	}
 
 	public static void compute() {
 		for (int k = 1; k <= blen; k++) {
 			ans[k] = getCnt(k);
 		}
-		int l = 1, r = n;
-		for (int pathCnt = 0; pathCnt * blen <= n; pathCnt++) {
-			int limit = findLimit(l, r, pathCnt);
-			if (limit != -1) {
-				ans[limit] = pathCnt;
-				r = limit;
+		for (int pathCnt = 0, limit = n; pathCnt * blen <= n; pathCnt++) {
+			int find = findLimit(1, limit, pathCnt);
+			if (find != -1) {
+				ans[find] = pathCnt;
+				limit = find;
 			}
 		}
 	}
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index 45c92b8cf..9bcf3f245 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -67,7 +67,7 @@
 //}
 //
 //int findLimit(int l, int r, int pathCnt) {
-//    int limit = -1;
+//    int find = -1;
 //    while (l <= r) {
 //        int mid = (l + r) >> 1;
 //        int cnt = getCnt(mid);
@@ -76,23 +76,22 @@
 //        } else if (cnt > pathCnt) {
 //            l = mid + 1;
 //        } else {
-//            limit = mid;
+//            find = mid;
 //            r = mid - 1;
 //        }
 //    }
-//    return limit;
+//    return find;
 //}
 //
 //void compute() {
 //    for (int k = 1; k <= blen; k++) {
 //        ans[k] = getCnt(k);
 //    }
-//    int l = 1, r = n;
-//    for (int pathCnt = 0; pathCnt * blen <= n; pathCnt++) {
-//        int limit = findLimit(l, r, pathCnt);
-//        if (limit != -1) {
-//            ans[limit] = pathCnt;
-//            r = limit;
+//    for (int pathCnt = 0, limit = n; pathCnt * blen <= n; pathCnt++) {
+//        int find = findLimit(1, limit, pathCnt);
+//        if (find != -1) {
+//            ans[find] = pathCnt;
+//            limit = find;
 //        }
 //    }
 //}

From 22d13ac1763e21cbcac062a21c0fdf714edda599 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 3 Aug 2025 15:54:58 +0800
Subject: [PATCH 1218/1712] modify code

---
 src/class175/Code06_TillCollapse1.java | 15 ++++++++-------
 src/class175/Code06_TillCollapse2.java | 15 ++++++++-------
 2 files changed, 16 insertions(+), 14 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index e1028ba2e..cb39af0ba 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -43,25 +43,23 @@ private static int query(int x) {
 	}
 
 	public static void compute() {
+		Arrays.fill(ans, 1, n + 1, -1);
 		for (int i = 1; i <= blen; i++) {
 			ans[i] = query(i);
 		}
-		for (int i = blen + 1; i <= n; i++) {
-			int tmp = query(i);
+		for (int i = blen + 1; i <= n;) {
+			ans[i] = query(i);
 			int l = i, r = n, find = i;
 			while (l <= r) {
 				int mid = (l + r) >> 1;
-				if (query(mid) >= tmp) {
+				if (query(mid) >= ans[i]) {
 					find = mid;
 					l = mid + 1;
 				} else {
 					r = mid - 1;
 				}
 			}
-			for (int j = i; j <= find; j++) {
-				ans[j] = tmp;
-			}
-			i = find;
+			i = find + 1;
 		}
 	}
 
@@ -74,6 +72,9 @@ public static void main(String[] args) throws Exception {
 		}
 		compute();
 		for (int i = 1; i <= n; i++) {
+			if (ans[i] == -1) {
+				ans[i] = ans[i - 1];
+			}
 			out.print(ans[i] + " ");
 		}
 		out.println();
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index aa5b0da17..f6a48cfd4 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -41,25 +41,23 @@
 //}
 //
 //void compute() {
+//    fill(ans + 1, ans + n + 1, -1);
 //    for (int i = 1; i <= blen; i++) {
 //        ans[i] = query(i);
 //    }
-//    for (int i = blen + 1; i <= n; i++) {
-//        int tmp = query(i);
+//    for (int i = blen + 1; i <= n;) {
+//        ans[i] = query(i);
 //        int l = i, r = n, find = i;
 //        while (l <= r) {
 //            int mid = (l + r) >> 1;
-//            if (query(mid) >= tmp) {
+//            if (query(mid) >= ans[i]) {
 //                find = mid;
 //                l = mid + 1;
 //            } else {
 //                r = mid - 1;
 //            }
 //        }
-//        for (int j = i; j <= find; j++) {
-//            ans[j] = tmp;
-//        }
-//        i = find;
+//        i = find + 1;
 //    }
 //}
 //
@@ -72,6 +70,9 @@
 //    }
 //    compute();
 //    for (int i = 1; i <= n; i++) {
+//        if (ans[i] == -1) {
+//            ans[i] = ans[i - 1];
+//        }
 //        cout << ans[i] << ' ';
 //    }
 //    cout << '\n';

From 3ed692c5d3f1083090f655d6bcc871719fd52253 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 3 Aug 2025 16:09:28 +0800
Subject: [PATCH 1219/1712] modify code

---
 src/class175/Code06_TillCollapse1.java | 13 +++++++++++--
 src/class175/Code06_TillCollapse2.java |  9 +++++++--
 2 files changed, 18 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index cb39af0ba..06eabbedf 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -13,7 +13,7 @@
 public class Code06_TillCollapse1 {
 
 	public static int MAXN = 100001;
-	public static int n, blen = 1000;
+	public static int n, blen;
 	public static int[] arr = new int[MAXN];
 	public static int[] num = new int[MAXN];
 	public static int[] ans = new int[MAXN];
@@ -43,7 +43,6 @@ private static int query(int x) {
 	}
 
 	public static void compute() {
-		Arrays.fill(ans, 1, n + 1, -1);
 		for (int i = 1; i <= blen; i++) {
 			ans[i] = query(i);
 		}
@@ -63,6 +62,15 @@ public static void compute() {
 		}
 	}
 
+	public static void prepare() {
+		int log2n = 0;
+		while ((1 << log2n) <= (n >> 1)) {
+			log2n++;
+		}
+		blen = Math.max(1, (int) Math.sqrt(n * log2n));
+		Arrays.fill(ans, 1, n + 1, -1);
+	}
+
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(System.out);
@@ -70,6 +78,7 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
+		prepare();
 		compute();
 		for (int i = 1; i <= n; i++) {
 			if (ans[i] == -1) {
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index f6a48cfd4..8e47a514a 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -11,7 +11,7 @@
 //using namespace std;
 //
 //const int MAXN = 100001;
-//int n, blen = 1000;
+//int n, blen;
 //int arr[MAXN];
 //int num[MAXN];
 //int ans[MAXN];
@@ -41,7 +41,6 @@
 //}
 //
 //void compute() {
-//    fill(ans + 1, ans + n + 1, -1);
 //    for (int i = 1; i <= blen; i++) {
 //        ans[i] = query(i);
 //    }
@@ -61,6 +60,11 @@
 //    }
 //}
 //
+//void prepare() {
+//    blen = max(1, (int)sqrt(n * log2(n)));
+//    fill(ans + 1, ans + n + 1, -1);
+//}
+//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
@@ -68,6 +72,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
+//    prepare();
 //    compute();
 //    for (int i = 1; i <= n; i++) {
 //        if (ans[i] == -1) {

From 73bbf063d5e49dbe9a46b442fb527b9e2db20e6e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 3 Aug 2025 18:54:57 +0800
Subject: [PATCH 1220/1712] modify code

---
 src/class175/Code01_HashCollision1.java    | 4 ++++
 src/class175/Code01_HashCollision2.java    | 4 ++++
 src/class175/Code02_ArrayQueries1.java     | 3 +++
 src/class175/Code02_ArrayQueries2.java     | 3 +++
 src/class175/Code03_SumOfProgression1.java | 6 ++++++
 src/class175/Code03_SumOfProgression2.java | 6 ++++++
 src/class175/Code04_Initialization1.java   | 4 ++++
 src/class175/Code04_Initialization2.java   | 4 ++++
 src/class175/Code05_Skyscraper1.java       | 7 ++++++-
 src/class175/Code05_Skyscraper2.java       | 5 +++++
 src/class175/Code06_TillCollapse1.java     | 4 ++++
 src/class175/Code06_TillCollapse2.java     | 4 ++++
 src/class175/Code07_GivenTree1.java        | 5 +++++
 src/class175/Code07_GivenTree2.java        | 5 +++++
 14 files changed, 63 insertions(+), 1 deletion(-)

diff --git a/src/class175/Code01_HashCollision1.java b/src/class175/Code01_HashCollision1.java
index 9f2c905fa..5d1f37810 100644
--- a/src/class175/Code01_HashCollision1.java
+++ b/src/class175/Code01_HashCollision1.java
@@ -1,6 +1,10 @@
 package class175;
 
 // 哈希冲突，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，操作格式如下
+// 操作 A x y : 下标 % x == y，符合要求的下标，把对应的值累加起来，打印结果
+// 操作 C x y : arr[x]的值改成y
+// 1 <= n、m <= 1.5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3396
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class175/Code01_HashCollision2.java b/src/class175/Code01_HashCollision2.java
index 3999efe2b..efd052a58 100644
--- a/src/class175/Code01_HashCollision2.java
+++ b/src/class175/Code01_HashCollision2.java
@@ -1,6 +1,10 @@
 package class175;
 
 // 哈希冲突，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，操作格式如下
+// 操作 A x y : 下标 % x == y，符合要求的下标，把对应的值累加起来，打印结果
+// 操作 C x y : arr[x]的值改成y
+// 1 <= n、m <= 1.5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3396
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class175/Code02_ArrayQueries1.java b/src/class175/Code02_ArrayQueries1.java
index 8036e2e21..959cab0a4 100644
--- a/src/class175/Code02_ArrayQueries1.java
+++ b/src/class175/Code02_ArrayQueries1.java
@@ -1,6 +1,9 @@
 package class175;
 
 // 数组查询，java版
+// 给定一个长度为n的数组arr，接下来有q条查询，查询格式如下
+// 查询 p k : p 不断变成 p + arr[p] + k，直到 p > n 停止，打印操作次数
+// 1 <= n、q <= 10 ^ 5
 // 测试链接 : https://www.luogu.com.cn/problem/CF797E
 // 测试链接 : https://codeforces.com/problemset/problem/797/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class175/Code02_ArrayQueries2.java b/src/class175/Code02_ArrayQueries2.java
index e3b6b2ec7..df092d986 100644
--- a/src/class175/Code02_ArrayQueries2.java
+++ b/src/class175/Code02_ArrayQueries2.java
@@ -1,6 +1,9 @@
 package class175;
 
 // 数组查询，C++版
+// 给定一个长度为n的数组arr，接下来有q条查询，查询格式如下
+// 查询 p k : p 不断变成 p + arr[p] + k，直到 p > n 停止，打印操作次数
+// 1 <= n、q <= 10 ^ 5
 // 测试链接 : https://www.luogu.com.cn/problem/CF797E
 // 测试链接 : https://codeforces.com/problemset/problem/797/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class175/Code03_SumOfProgression1.java b/src/class175/Code03_SumOfProgression1.java
index 4092a4399..c4f1679de 100644
--- a/src/class175/Code03_SumOfProgression1.java
+++ b/src/class175/Code03_SumOfProgression1.java
@@ -1,6 +1,12 @@
 package class175;
 
 // 等差数列求和，java版
+// 一共有t组测试，每组测试遵循同样的设定
+// 给定一个长度为n的数组arr，接下来有q条查询，查询格式如下
+// 查询 s d k : arr[s]作为第1项、arr[s + 1d]作为第2项、arr[s + 2d]作为第3项...
+//             每项的值 * 项的编号，一共k项都累加起来，打印累加和
+// 1 <= n <= 10^5
+// 1 <= q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1921F
 // 测试链接 : https://codeforces.com/problemset/problem/1921/F
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class175/Code03_SumOfProgression2.java b/src/class175/Code03_SumOfProgression2.java
index 20f7464a0..4d4a21935 100644
--- a/src/class175/Code03_SumOfProgression2.java
+++ b/src/class175/Code03_SumOfProgression2.java
@@ -1,6 +1,12 @@
 package class175;
 
 // 等差数列求和，C++版
+// 一共有t组测试，每组测试遵循同样的设定
+// 给定一个长度为n的数组arr，接下来有q条查询，查询格式如下
+// 查询 s d k : arr[s]作为第1项、arr[s + 1d]作为第2项、arr[s + 2d]作为第3项...
+//             每项的值 * 项的编号，一共k项都累加起来，打印累加和
+// 1 <= n <= 10^5
+// 1 <= q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1921F
 // 测试链接 : https://codeforces.com/problemset/problem/1921/F
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index 69fcbc3b7..87d5241b0 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -1,6 +1,10 @@
 package class175;
 
 // 初始化，java版
+// 给定一个长度为n的数组arr，接下来有m条操作，操作格式如下
+// 操作 1 x y z : 从arr[y]开始，下标每次+x，所有相应位置的数都+z，题目保证 y <= x
+// 操作 2 x y   : 打印arr[x..y]的累加和，答案对1000000007取余
+// 1 <= n、m <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5309
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index c98151d8d..8f9d5632a 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -1,6 +1,10 @@
 package class175;
 
 // 初始化，C++版
+// 给定一个长度为n的数组arr，接下来有m条操作，操作格式如下
+// 操作 1 x y z : 从arr[y]开始，下标每次+x，所有相应位置的数都+z，题目保证 y <= x
+// 操作 2 x y   : 打印arr[x..y]的累加和，答案对1000000007取余
+// 1 <= n、m <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5309
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
index 3d41b9755..790221ba0 100644
--- a/src/class175/Code05_Skyscraper1.java
+++ b/src/class175/Code05_Skyscraper1.java
@@ -1,6 +1,11 @@
 package class175;
 
 // 雅加达的摩天楼，java版
+// 有n个大楼，编号0~n-1，有m个狗子，编号0~m-1
+// 每只狗子有两个参数，idx表示狗子的初始大楼，jump表示狗子的跳跃能力
+// 狗子在i位置，可以来到 i - jump 或 i + jump，向左向右自由跳跃，但不能越界
+// 0号狗子有消息希望传给1号狗子，所有狗子都可帮忙，返回至少传几次，无法送达打印-1
+// 1 <= n、m <= 30000
 // 测试链接 : https://www.luogu.com.cn/problem/P3645
 // 测试链接 : https://uoj.ac/problem/111
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -27,7 +32,7 @@ static class Node {
 	public static int MAXN = 30001;
 	public static int n, m;
 
-	// 每个位置拥有的doge列表
+	// 每个位置拥有的狗子列表
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
 	public static int[] to = new int[MAXN];
diff --git a/src/class175/Code05_Skyscraper2.java b/src/class175/Code05_Skyscraper2.java
index f050a6fa4..d84ecf2c6 100644
--- a/src/class175/Code05_Skyscraper2.java
+++ b/src/class175/Code05_Skyscraper2.java
@@ -1,6 +1,11 @@
 package class175;
 
 // 雅加达的摩天楼，C++版
+// 有n个大楼，编号0~n-1，有m个狗子，编号0~m-1
+// 每只狗子有两个参数，idx表示狗子的初始大楼，jump表示狗子的跳跃能力
+// 狗子在i位置，可以来到 i - jump 或 i + jump，向左向右自由跳跃，但不能越界
+// 0号狗子有消息希望传给1号狗子，所有狗子都可帮忙，返回至少传几次，无法送达打印-1
+// 1 <= n、m <= 30000
 // 测试链接 : https://www.luogu.com.cn/problem/P3645
 // 测试链接 : https://uoj.ac/problem/111
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index 06eabbedf..52954b9f8 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -1,6 +1,10 @@
 package class175;
 
 // 直到倒下，java版
+// 给定一个长度为n的数组arr，考虑如下问题的解
+// 希望知道arr最少划分成几段，可以做到每段内，不同数值的个数 <= k
+// 打印k = 1, 2, 3..n时，所有的答案
+// 1 <= arr[i] <= n <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF786C
 // 测试链接 : https://codeforces.com/problemset/problem/786/C
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index 8e47a514a..793cc0752 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -1,6 +1,10 @@
 package class175;
 
 // 直到倒下，C++版
+// 给定一个长度为n的数组arr，考虑如下问题的解
+// 希望知道arr最少划分成几段，可以做到每段内，不同数值的个数 <= k
+// 打印k = 1, 2, 3..n时，所有的答案
+// 1 <= arr[i] <= n <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF786C
 // 测试链接 : https://codeforces.com/problemset/problem/786/C
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index bf28c1e39..de57cb283 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -1,6 +1,11 @@
 package class175;
 
 // 给你一棵树，java版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树
+// 树的路径是指，从节点x到节点y，沿途节点只经过一次，k路径是指，路径上节点数正好为k
+// 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
+// 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
+// 打印k = 1, 2, 3..n时，所有的答案
 // 测试链接 : https://www.luogu.com.cn/problem/CF1039D
 // 测试链接 : https://codeforces.com/problemset/problem/1039/D
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index 9bcf3f245..69724e903 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -1,6 +1,11 @@
 package class175;
 
 // 给你一棵树，C++版
+// 一共有n个节点，给定n-1条边，所有节点连成一棵树
+// 树的路径是指，从节点x到节点y，沿途节点只经过一次，k路径是指，路径上节点数正好为k
+// 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
+// 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
+// 打印k = 1, 2, 3..n时，所有的答案
 // 测试链接 : https://www.luogu.com.cn/problem/CF1039D
 // 测试链接 : https://codeforces.com/problemset/problem/1039/D
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From c1944d9cc07d0564c5f0ea18f234fadd1e42d0fb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 4 Aug 2025 17:43:25 +0800
Subject: [PATCH 1221/1712] modify code

---
 src/class175/Code06_TillCollapse1.java | 66 +++++++++++++++-----------
 src/class175/Code06_TillCollapse2.java | 66 +++++++++++++++-----------
 src/class175/Code07_GivenTree1.java    | 24 +++++-----
 src/class175/Code07_GivenTree2.java    | 24 +++++-----
 4 files changed, 98 insertions(+), 82 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index 52954b9f8..e1747de37 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -19,31 +19,49 @@ public class Code06_TillCollapse1 {
 	public static int MAXN = 100001;
 	public static int n, blen;
 	public static int[] arr = new int[MAXN];
-	public static int[] num = new int[MAXN];
+	public static boolean[] vis = new boolean[MAXN];
 	public static int[] ans = new int[MAXN];
 
-	private static int query(int x) {
-		Arrays.fill(num, 0);
-		int cnt = 0, lst = 1, tot = 0;
+	public static int query(int limit) {
+		int num = 0, cnt = 0, start = 1;
 		for (int i = 1; i <= n; i++) {
-			if (num[arr[i]] == 0) {
-				cnt++;
-				num[arr[i]] = 1;
-			}
-			if (cnt > x) {
-				tot++;
-				for (int j = lst; j <= i; j++) {
-					num[arr[j]] = 0;
+			if (!vis[arr[i]]) {
+				num++;
+				if (num > limit) {
+					cnt++;
+					for (int j = start; j < i; j++) {
+						vis[arr[j]] = false;
+					}
+					start = i;
+					num = 1;
 				}
-				lst = i;
-				num[arr[i]] = 1;
-				cnt = 1;
+				vis[arr[i]] = true;
+			}
+		}
+		if (num > 0) {
+			cnt++;
+			for (int j = start; j <= n; j++) {
+				vis[arr[j]] = false;
 			}
 		}
-		if (cnt > 0) {
-			tot++;
+		return cnt;
+	}
+
+	public static int jump(int l, int r, int curAns) {
+		int find = l;
+		while (l <= r) {
+			int mid = (l + r) >> 1;
+			int check = query(mid);
+			if (check < curAns) {
+				r = mid - 1;
+			} else if (check > curAns) {
+				l = mid + 1;
+			} else {
+				find = mid;
+				l = mid + 1;
+			}
 		}
-		return tot;
+		return find;
 	}
 
 	public static void compute() {
@@ -52,17 +70,7 @@ public static void compute() {
 		}
 		for (int i = blen + 1; i <= n;) {
 			ans[i] = query(i);
-			int l = i, r = n, find = i;
-			while (l <= r) {
-				int mid = (l + r) >> 1;
-				if (query(mid) >= ans[i]) {
-					find = mid;
-					l = mid + 1;
-				} else {
-					r = mid - 1;
-				}
-			}
-			i = find + 1;
+			i = jump(i, n, ans[i]) + 1;
 		}
 	}
 
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index 793cc0752..bf4600222 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -17,31 +17,49 @@
 //const int MAXN = 100001;
 //int n, blen;
 //int arr[MAXN];
-//int num[MAXN];
+//bool vis[MAXN];
 //int ans[MAXN];
 //
-//int query(int x) {
-//    memset(num, 0, sizeof(num));
-//    int cnt = 0, lst = 1, tot = 0;
+//int query(int limit) {
+//    int num = 0, cnt = 0, start = 1;
 //    for (int i = 1; i <= n; i++) {
-//        if (num[arr[i]] == 0) {
-//            cnt++;
-//            num[arr[i]] = 1;
-//        }
-//        if (cnt > x) {
-//            tot++;
-//            for (int j = lst; j <= i; j++) {
-//                num[arr[j]] = 0;
+//        if (!vis[arr[i]]) {
+//            num++;
+//            if (num > limit) {
+//                cnt++;
+//                for (int j = start; j < i; j++) {
+//                    vis[arr[j]] = false;
+//                }
+//                start = i;
+//                num = 1;
 //            }
-//            lst = i;
-//            num[arr[i]] = 1;
-//            cnt = 1;
+//            vis[arr[i]] = true;
+//        }
+//    }
+//    if (num > 0) {
+//        cnt++;
+//        for (int j = start; j <= n; j++) {
+//            vis[arr[j]] = false;
 //        }
 //    }
-//    if (cnt > 0) {
-//        tot++;
+//    return cnt;
+//}
+//
+//int jump(int l, int r, int curAns) {
+//    int find = l;
+//    while (l <= r) {
+//        int mid = (l + r) >> 1;
+//        int check = query(mid);
+//        if (check < curAns) {
+//            r = mid - 1;
+//        } else if (check > curAns) {
+//            l = mid + 1;
+//        } else {
+//            find = mid;
+//            l = mid + 1;
+//        }
 //    }
-//    return tot;
+//    return find;
 //}
 //
 //void compute() {
@@ -50,17 +68,7 @@
 //    }
 //    for (int i = blen + 1; i <= n;) {
 //        ans[i] = query(i);
-//        int l = i, r = n, find = i;
-//        while (l <= r) {
-//            int mid = (l + r) >> 1;
-//            if (query(mid) >= ans[i]) {
-//                find = mid;
-//                l = mid + 1;
-//            } else {
-//                r = mid - 1;
-//            }
-//        }
-//        i = find + 1;
+//        i = jump(i, n, ans[i]) + 1;
 //    }
 //}
 //
diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index de57cb283..57d578233 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -51,7 +51,7 @@ public static void dfs(int u, int f) {
 		}
 	}
 
-	public static int getCnt(int limit) {
+	public static int dp(int limit) {
 		int pathCnt = 0;
 		for (int dfn = n, cur, father; dfn >= 1; dfn--) {
 			cur = seg[dfn];
@@ -73,32 +73,32 @@ public static int getCnt(int limit) {
 		return pathCnt;
 	}
 
-	public static int findLimit(int l, int r, int pathCnt) {
-		int find = -1;
+	public static int find(int l, int r, int pathCnt) {
+		int limit = -1;
 		while (l <= r) {
 			int mid = (l + r) >> 1;
-			int cnt = getCnt(mid);
+			int cnt = dp(mid);
 			if (cnt < pathCnt) {
 				r = mid - 1;
 			} else if (cnt > pathCnt) {
 				l = mid + 1;
 			} else {
-				find = mid;
+				limit = mid;
 				r = mid - 1;
 			}
 		}
-		return find;
+		return limit;
 	}
 
 	public static void compute() {
 		for (int k = 1; k <= blen; k++) {
-			ans[k] = getCnt(k);
+			ans[k] = dp(k);
 		}
-		for (int pathCnt = 0, limit = n; pathCnt * blen <= n; pathCnt++) {
-			int find = findLimit(1, limit, pathCnt);
-			if (find != -1) {
-				ans[find] = pathCnt;
-				limit = find;
+		for (int pathCnt = 0, r = n; pathCnt * blen <= n; pathCnt++) {
+			int limit = find(1, r, pathCnt);
+			if (limit != -1) {
+				ans[limit] = pathCnt;
+				r = limit;
 			}
 		}
 	}
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index 69724e903..d5b4b5f25 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -49,7 +49,7 @@
 //    }
 //}
 //
-//int getCnt(int limit) {
+//int dp(int limit) {
 //    int pathCnt = 0;
 //    for (int dfn = n, cur, father; dfn >= 1; dfn--) {
 //        cur = seg[dfn];
@@ -71,32 +71,32 @@
 //    return pathCnt;
 //}
 //
-//int findLimit(int l, int r, int pathCnt) {
-//    int find = -1;
+//int find(int l, int r, int pathCnt) {
+//    int limit = -1;
 //    while (l <= r) {
 //        int mid = (l + r) >> 1;
-//        int cnt = getCnt(mid);
+//        int cnt = dp(mid);
 //        if (cnt < pathCnt) {
 //            r = mid - 1;
 //        } else if (cnt > pathCnt) {
 //            l = mid + 1;
 //        } else {
-//            find = mid;
+//            limit = mid;
 //            r = mid - 1;
 //        }
 //    }
-//    return find;
+//    return limit;
 //}
 //
 //void compute() {
 //    for (int k = 1; k <= blen; k++) {
-//        ans[k] = getCnt(k);
+//        ans[k] = dp(k);
 //    }
-//    for (int pathCnt = 0, limit = n; pathCnt * blen <= n; pathCnt++) {
-//        int find = findLimit(1, limit, pathCnt);
-//        if (find != -1) {
-//            ans[find] = pathCnt;
-//            limit = find;
+//    for (int pathCnt = 0, r = n; pathCnt * blen <= n; pathCnt++) {
+//        int limit = find(1, r, pathCnt);
+//        if (limit != -1) {
+//            ans[limit] = pathCnt;
+//            r = limit;
 //        }
 //    }
 //}

From 2a9d49661c5eb89dc944260e9a0c3af5e9b85c8b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 4 Aug 2025 19:32:55 +0800
Subject: [PATCH 1222/1712] modify code

---
 src/class175/Code06_TillCollapse1.java | 3 +--
 src/class175/Code06_TillCollapse2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index e1747de37..180eaff7e 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -68,9 +68,8 @@ public static void compute() {
 		for (int i = 1; i <= blen; i++) {
 			ans[i] = query(i);
 		}
-		for (int i = blen + 1; i <= n;) {
+		for (int i = blen + 1; i <= n; i = jump(i, n, ans[i]) + 1) {
 			ans[i] = query(i);
-			i = jump(i, n, ans[i]) + 1;
 		}
 	}
 
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index bf4600222..ab43e3fb3 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -66,9 +66,8 @@
 //    for (int i = 1; i <= blen; i++) {
 //        ans[i] = query(i);
 //    }
-//    for (int i = blen + 1; i <= n;) {
+//    for (int i = blen + 1; i <= n; i = jump(i, n, ans[i]) + 1) {
 //        ans[i] = query(i);
-//        i = jump(i, n, ans[i]) + 1;
 //    }
 //}
 //

From c8b78ab7ee6b6137395278cf3beb83e05eeb96ae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Aug 2025 13:48:40 +0800
Subject: [PATCH 1223/1712] modify code

---
 src/class175/Code02_ArrayQueries1.java   | 1 +
 src/class175/Code02_ArrayQueries2.java   | 1 +
 src/class175/Code04_Initialization1.java | 8 ++++++--
 src/class175/Code04_Initialization2.java | 4 ++--
 4 files changed, 10 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code02_ArrayQueries1.java b/src/class175/Code02_ArrayQueries1.java
index 959cab0a4..29653cd8d 100644
--- a/src/class175/Code02_ArrayQueries1.java
+++ b/src/class175/Code02_ArrayQueries1.java
@@ -4,6 +4,7 @@
 // 给定一个长度为n的数组arr，接下来有q条查询，查询格式如下
 // 查询 p k : p 不断变成 p + arr[p] + k，直到 p > n 停止，打印操作次数
 // 1 <= n、q <= 10 ^ 5
+// 1 <= arr[i] <= n
 // 测试链接 : https://www.luogu.com.cn/problem/CF797E
 // 测试链接 : https://codeforces.com/problemset/problem/797/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class175/Code02_ArrayQueries2.java b/src/class175/Code02_ArrayQueries2.java
index df092d986..8dbacb952 100644
--- a/src/class175/Code02_ArrayQueries2.java
+++ b/src/class175/Code02_ArrayQueries2.java
@@ -4,6 +4,7 @@
 // 给定一个长度为n的数组arr，接下来有q条查询，查询格式如下
 // 查询 p k : p 不断变成 p + arr[p] + k，直到 p > n 停止，打印操作次数
 // 1 <= n、q <= 10 ^ 5
+// 1 <= arr[i] <= n
 // 测试链接 : https://www.luogu.com.cn/problem/CF797E
 // 测试链接 : https://codeforces.com/problemset/problem/797/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index 87d5241b0..be3defe0d 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -82,11 +82,15 @@ public static long query(int l, int r) {
 				ans = ans + suf[x][(l - 1) % x + 1] + pre[x][x] * num + pre[x][(r - 1) % x + 1];
 			}
 		}
-		return (ans % MOD + MOD) % MOD;
+		return ans % MOD;
 	}
 
 	public static void prepare() {
-		blen = 150;
+		int log2n = 0;
+		while ((1 << log2n) <= (n >> 1)) {
+			log2n++;
+		}
+		blen = Math.max(1, (int) Math.sqrt(n / log2n));
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 8f9d5632a..664e7735a 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -77,11 +77,11 @@
 //            ans = ans + suf[x][(l - 1) % x + 1] + pre[x][x] * num + pre[x][(r - 1) % x + 1];
 //        }
 //    }
-//    return (ans % MOD + MOD) % MOD;
+//    return ans % MOD;
 //}
 //
 //void prepare() {
-//    blen = 150;
+//    blen = max(1, (int)sqrt(n / log2(n)));
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;

From 1cf5d009f85a4f4e79af25f72f8f58db86306b4c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Aug 2025 13:55:26 +0800
Subject: [PATCH 1224/1712] modify code

---
 src/class175/Code06_TillCollapse1.java | 2 +-
 src/class175/Code06_TillCollapse2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index 180eaff7e..7bf96fb30 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -1,6 +1,6 @@
 package class175;
 
-// 直到倒下，java版
+// 最少划分，java版
 // 给定一个长度为n的数组arr，考虑如下问题的解
 // 希望知道arr最少划分成几段，可以做到每段内，不同数值的个数 <= k
 // 打印k = 1, 2, 3..n时，所有的答案
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index ab43e3fb3..fdeb29dd5 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -1,6 +1,6 @@
 package class175;
 
-// 直到倒下，C++版
+// 最少划分，C++版
 // 给定一个长度为n的数组arr，考虑如下问题的解
 // 希望知道arr最少划分成几段，可以做到每段内，不同数值的个数 <= k
 // 打印k = 1, 2, 3..n时，所有的答案

From a162d915c7d1e5119afae3cdfb9d00aff2ce6b01 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Aug 2025 14:15:29 +0800
Subject: [PATCH 1225/1712] modify code

---
 src/class175/Code05_Skyscraper1.java | 2 +-
 src/class175/Code05_Skyscraper2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
index 790221ba0..0637531c9 100644
--- a/src/class175/Code05_Skyscraper1.java
+++ b/src/class175/Code05_Skyscraper1.java
@@ -4,7 +4,7 @@
 // 有n个大楼，编号0~n-1，有m个狗子，编号0~m-1
 // 每只狗子有两个参数，idx表示狗子的初始大楼，jump表示狗子的跳跃能力
 // 狗子在i位置，可以来到 i - jump 或 i + jump，向左向右自由跳跃，但不能越界
-// 0号狗子有消息希望传给1号狗子，所有狗子都可帮忙，返回至少传几次，无法送达打印-1
+// 0号狗子有消息希望传给1号狗子，所有狗子都可帮忙，返回至少传送几次，无法送达打印-1
 // 1 <= n、m <= 30000
 // 测试链接 : https://www.luogu.com.cn/problem/P3645
 // 测试链接 : https://uoj.ac/problem/111
diff --git a/src/class175/Code05_Skyscraper2.java b/src/class175/Code05_Skyscraper2.java
index d84ecf2c6..b7ff56e78 100644
--- a/src/class175/Code05_Skyscraper2.java
+++ b/src/class175/Code05_Skyscraper2.java
@@ -4,7 +4,7 @@
 // 有n个大楼，编号0~n-1，有m个狗子，编号0~m-1
 // 每只狗子有两个参数，idx表示狗子的初始大楼，jump表示狗子的跳跃能力
 // 狗子在i位置，可以来到 i - jump 或 i + jump，向左向右自由跳跃，但不能越界
-// 0号狗子有消息希望传给1号狗子，所有狗子都可帮忙，返回至少传几次，无法送达打印-1
+// 0号狗子有消息希望传给1号狗子，所有狗子都可帮忙，返回至少传送几次，无法送达打印-1
 // 1 <= n、m <= 30000
 // 测试链接 : https://www.luogu.com.cn/problem/P3645
 // 测试链接 : https://uoj.ac/problem/111

From e7364004c5b2d0baa6cdab05ccbeaca7a5f193c8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Aug 2025 15:33:33 +0800
Subject: [PATCH 1226/1712] modify code

---
 src/class175/Code01_HashCollision1.java | 4 ++--
 src/class175/Code01_HashCollision2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code01_HashCollision1.java b/src/class175/Code01_HashCollision1.java
index 5d1f37810..19801e067 100644
--- a/src/class175/Code01_HashCollision1.java
+++ b/src/class175/Code01_HashCollision1.java
@@ -42,9 +42,9 @@ public static void update(int x, int y) {
 
 	public static void prepare() {
 		blen = (int) Math.sqrt(n);
-		for (int mod = 1; mod <= blen; mod++) {
+		for (int x = 1; x <= blen; x++) {
 			for (int i = 1; i <= n; i++) {
-				dp[mod][i % mod] += arr[i];
+				dp[x][i % x] += arr[i];
 			}
 		}
 	}
diff --git a/src/class175/Code01_HashCollision2.java b/src/class175/Code01_HashCollision2.java
index efd052a58..ecd70a378 100644
--- a/src/class175/Code01_HashCollision2.java
+++ b/src/class175/Code01_HashCollision2.java
@@ -40,9 +40,9 @@
 //
 //void prepare() {
 //    blen = (int)sqrt(n);
-//    for (int mod = 1; mod <= blen; mod++) {
+//    for (int x = 1; x <= blen; x++) {
 //        for (int i = 1; i <= n; i++) {
-//            dp[mod][i % mod] += arr[i];
+//            dp[x][i % x] += arr[i];
 //        }
 //    }
 //}

From 50962fac33a8a4c882545d635d7584fc0fa963ed Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 5 Aug 2025 15:35:43 +0800
Subject: [PATCH 1227/1712] modify code

---
 src/class175/Code01_HashCollision1.java | 10 +++++-----
 src/class175/Code01_HashCollision2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class175/Code01_HashCollision1.java b/src/class175/Code01_HashCollision1.java
index 19801e067..722069de0 100644
--- a/src/class175/Code01_HashCollision1.java
+++ b/src/class175/Code01_HashCollision1.java
@@ -32,11 +32,11 @@ public static long query(int x, int y) {
 		return ans;
 	}
 
-	public static void update(int x, int y) {
-		int delta = y - arr[x];
-		arr[x] = y;
-		for (int mod = 1; mod <= blen; mod++) {
-			dp[mod][x % mod] += delta;
+	public static void update(int i, int v) {
+		int delta = v - arr[i];
+		arr[i] = v;
+		for (int x = 1; x <= blen; x++) {
+			dp[x][i % x] += delta;
 		}
 	}
 
diff --git a/src/class175/Code01_HashCollision2.java b/src/class175/Code01_HashCollision2.java
index ecd70a378..dd62d12e4 100644
--- a/src/class175/Code01_HashCollision2.java
+++ b/src/class175/Code01_HashCollision2.java
@@ -30,11 +30,11 @@
 //    return ans;
 //}
 //
-//void update(int x, int y) {
-//    int delta = y - arr[x];
-//    arr[x] = y;
-//    for (int mod = 1; mod <= blen; mod++) {
-//        dp[mod][x % mod] += delta;
+//void update(int i, int v) {
+//    int delta = v - arr[i];
+//    arr[i] = v;
+//    for (int x = 1; x <= blen; x++) {
+//        dp[x][i % x] += delta;
 //    }
 //}
 //

From bd3a807cef6cf0dbe3c9aa33a92d230211c037aa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 12:31:16 +0800
Subject: [PATCH 1228/1712] modify code

---
 src/class175/Code06_TillCollapse1.java |  4 +--
 src/class175/Code06_TillCollapse2.java |  4 +--
 src/class175/Code07_GivenTree1.java    | 37 +++++++++----------
 src/class175/Code07_GivenTree2.java    | 49 ++++++++++++--------------
 4 files changed, 42 insertions(+), 52 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index 7bf96fb30..350c80381 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -61,14 +61,14 @@ public static int jump(int l, int r, int curAns) {
 				l = mid + 1;
 			}
 		}
-		return find;
+		return find + 1;
 	}
 
 	public static void compute() {
 		for (int i = 1; i <= blen; i++) {
 			ans[i] = query(i);
 		}
-		for (int i = blen + 1; i <= n; i = jump(i, n, ans[i]) + 1) {
+		for (int i = blen + 1; i <= n; i = jump(i, n, ans[i])) {
 			ans[i] = query(i);
 		}
 	}
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index fdeb29dd5..049a75fd3 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -59,14 +59,14 @@
 //            l = mid + 1;
 //        }
 //    }
-//    return find;
+//    return find + 1;
 //}
 //
 //void compute() {
 //    for (int i = 1; i <= blen; i++) {
 //        ans[i] = query(i);
 //    }
-//    for (int i = blen + 1; i <= n; i = jump(i, n, ans[i]) + 1) {
+//    for (int i = blen + 1; i <= n; i = jump(i, n, ans[i])) {
 //        ans[i] = query(i);
 //    }
 //}
diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index 57d578233..4e3c795e1 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -19,7 +19,6 @@ public class Code07_GivenTree1 {
 
 	public static int MAXN = 200001;
 	public static int n, blen;
-
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN << 1];
 	public static int[] to = new int[MAXN << 1];
@@ -51,13 +50,13 @@ public static void dfs(int u, int f) {
 		}
 	}
 
-	public static int dp(int limit) {
-		int pathCnt = 0;
+	public static int query(int limit) {
+		int cnt = 0;
 		for (int dfn = n, cur, father; dfn >= 1; dfn--) {
 			cur = seg[dfn];
 			father = fa[cur];
 			if (max1[cur] + max2[cur] + 1 >= limit) {
-				pathCnt++;
+				cnt++;
 				len[cur] = 0;
 			} else {
 				len[cur] = max1[cur] + 1;
@@ -70,36 +69,32 @@ public static int dp(int limit) {
 			}
 			max1[cur] = max2[cur] = 0;
 		}
-		return pathCnt;
+		return cnt;
 	}
 
-	public static int find(int l, int r, int pathCnt) {
-		int limit = -1;
+	public static int jump(int l, int r, int curAns) {
+		int find = l;
 		while (l <= r) {
 			int mid = (l + r) >> 1;
-			int cnt = dp(mid);
-			if (cnt < pathCnt) {
+			int check = query(mid);
+			if (check < curAns) {
 				r = mid - 1;
-			} else if (cnt > pathCnt) {
+			} else if (check > curAns) {
 				l = mid + 1;
 			} else {
-				limit = mid;
-				r = mid - 1;
+				find = mid;
+				l = mid + 1;
 			}
 		}
-		return limit;
+		return find + 1;
 	}
 
 	public static void compute() {
-		for (int k = 1; k <= blen; k++) {
-			ans[k] = dp(k);
+		for (int i = 1; i <= blen; i++) {
+			ans[i] = query(i);
 		}
-		for (int pathCnt = 0, r = n; pathCnt * blen <= n; pathCnt++) {
-			int limit = find(1, r, pathCnt);
-			if (limit != -1) {
-				ans[limit] = pathCnt;
-				r = limit;
-			}
+		for (int i = blen + 1; i <= n; i = jump(i, n, ans[i])) {
+			ans[i] = query(i);
 		}
 	}
 
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index d5b4b5f25..5ef60252a 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -17,7 +17,6 @@
 //
 //const int MAXN = 200001;
 //int n, blen;
-//
 //int head[MAXN];
 //int nxt[MAXN << 1];
 //int to[MAXN << 1];
@@ -34,7 +33,7 @@
 //int ans[MAXN];
 //
 //void addEdge(int u, int v) {
-//	nxt[++cntg] = head[u];
+//    nxt[++cntg] = head[u];
 //    to[cntg] = v;
 //    head[u] = cntg;
 //}
@@ -43,61 +42,57 @@
 //    fa[u] = f;
 //    seg[++cntd] = u;
 //    for (int e = head[u]; e; e = nxt[e]) {
-//    	if (to[e] != f) {
-//    	    dfs(to[e], u);
-//    	}
+//        if (to[e] != f) {
+//            dfs(to[e], u);
+//        }
 //    }
 //}
 //
-//int dp(int limit) {
-//    int pathCnt = 0;
+//int query(int limit) {
+//    int cnt = 0;
 //    for (int dfn = n, cur, father; dfn >= 1; dfn--) {
 //        cur = seg[dfn];
 //        father = fa[cur];
 //        if (max1[cur] + max2[cur] + 1 >= limit) {
-//            pathCnt++;
+//            cnt++;
 //            len[cur] = 0;
 //        } else {
 //            len[cur] = max1[cur] + 1;
 //        }
 //        if (len[cur] > max1[father]) {
-//        	max2[father] = max1[father];
+//            max2[father] = max1[father];
 //            max1[father] = len[cur];
 //        } else if (len[cur] > max2[father]) {
-//        	max2[father] = len[cur];
+//            max2[father] = len[cur];
 //        }
 //        max1[cur] = max2[cur] = 0;
 //    }
-//    return pathCnt;
+//    return cnt;
 //}
 //
-//int find(int l, int r, int pathCnt) {
-//    int limit = -1;
+//int jump(int l, int r, int curAns) {
+//    int find = l;
 //    while (l <= r) {
 //        int mid = (l + r) >> 1;
-//        int cnt = dp(mid);
-//        if (cnt < pathCnt) {
+//        int check = query(mid);
+//        if (check < curAns) {
 //            r = mid - 1;
-//        } else if (cnt > pathCnt) {
+//        } else if (check > curAns) {
 //            l = mid + 1;
 //        } else {
-//            limit = mid;
-//            r = mid - 1;
+//            find = mid;
+//            l = mid + 1;
 //        }
 //    }
-//    return limit;
+//    return find + 1;
 //}
 //
 //void compute() {
-//    for (int k = 1; k <= blen; k++) {
-//        ans[k] = dp(k);
+//    for (int i = 1; i <= blen; i++) {
+//        ans[i] = query(i);
 //    }
-//    for (int pathCnt = 0, r = n; pathCnt * blen <= n; pathCnt++) {
-//        int limit = find(1, r, pathCnt);
-//        if (limit != -1) {
-//            ans[limit] = pathCnt;
-//            r = limit;
-//        }
+//    for (int i = blen + 1; i <= n; i = jump(i, n, ans[i])) {
+//        ans[i] = query(i);
 //    }
 //}
 //

From 6054e9456a2b6f4d2a4131915cdfb0f72654081a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 12:43:19 +0800
Subject: [PATCH 1229/1712] modify code

---
 ...eNumber.java => Code05_DoubleNumber1.java} |  3 ++-
 src/class030/Code05_DoubleNumber2.java        | 25 +++++++++++++++++++
 2 files changed, 27 insertions(+), 1 deletion(-)
 rename src/class030/{Code05_DoubleNumber.java => Code05_DoubleNumber1.java} (86%)
 create mode 100644 src/class030/Code05_DoubleNumber2.java

diff --git a/src/class030/Code05_DoubleNumber.java b/src/class030/Code05_DoubleNumber1.java
similarity index 86%
rename from src/class030/Code05_DoubleNumber.java
rename to src/class030/Code05_DoubleNumber1.java
index 757ecd56b..079654751 100644
--- a/src/class030/Code05_DoubleNumber.java
+++ b/src/class030/Code05_DoubleNumber1.java
@@ -3,7 +3,8 @@
 // 数组中有2种数出现了奇数次，其他的数都出现了偶数次
 // 返回这2种出现了奇数次的数
 // 测试链接 : https://leetcode.cn/problems/single-number-iii/
-public class Code05_DoubleNumber {
+// C++版本的实现，就是本节课Code05_DoubleNumber2文件
+public class Code05_DoubleNumber1 {
 
 	public static int[] singleNumber(int[] nums) {
 		int eor1 = 0;
diff --git a/src/class030/Code05_DoubleNumber2.java b/src/class030/Code05_DoubleNumber2.java
new file mode 100644
index 000000000..f447b5d78
--- /dev/null
+++ b/src/class030/Code05_DoubleNumber2.java
@@ -0,0 +1,25 @@
+package class030;
+
+// 数组中有2种数出现了奇数次，其他的数都出现了偶数次
+// 返回这2种出现了奇数次的数
+// 测试链接 : https://leetcode.cn/problems/single-number-iii/
+// 如下代码是C++版，直接提交可以通过，注意看代码中的注释
+
+//class Solution {
+//public:
+//    vector<int> singleNumber(vector<int>& nums) {
+//        int eor1 = 0;
+//        for (int x : nums) {
+//            eor1 ^= x;
+//        }
+//        // 为什么这么写？自己去查！语言问题自己搞定
+//        uint32_t rightOne = (uint32_t)eor1 & (-(uint32_t)eor1);
+//        int a = 0;
+//        for (int x : nums) {
+//            if (((uint32_t)x & rightOne) == 0) {
+//                a ^= x;
+//            }
+//        }
+//        return {a, eor1 ^ a};
+//    }
+//};
\ No newline at end of file

From 67f3837a409a340650ac4bc254d71157ba5cf1c2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 12:47:38 +0800
Subject: [PATCH 1230/1712] modify code

---
 src/class030/Code05_DoubleNumber1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class030/Code05_DoubleNumber1.java b/src/class030/Code05_DoubleNumber1.java
index 079654751..4d9bda306 100644
--- a/src/class030/Code05_DoubleNumber1.java
+++ b/src/class030/Code05_DoubleNumber1.java
@@ -3,7 +3,7 @@
 // 数组中有2种数出现了奇数次，其他的数都出现了偶数次
 // 返回这2种出现了奇数次的数
 // 测试链接 : https://leetcode.cn/problems/single-number-iii/
-// C++版本的实现，就是本节课Code05_DoubleNumber2文件
+// 这是java版本的实现，本节课Code05_DoubleNumber2文件是C++版本的实现
 public class Code05_DoubleNumber1 {
 
 	public static int[] singleNumber(int[] nums) {

From 2426255cb690f7aca5a512aa150d5c4f157b7a6c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 12:52:31 +0800
Subject: [PATCH 1231/1712] modify code

---
 src/class030/Code05_DoubleNumber2.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class030/Code05_DoubleNumber2.java b/src/class030/Code05_DoubleNumber2.java
index f447b5d78..cc8008c8d 100644
--- a/src/class030/Code05_DoubleNumber2.java
+++ b/src/class030/Code05_DoubleNumber2.java
@@ -13,10 +13,10 @@
 //            eor1 ^= x;
 //        }
 //        // 为什么这么写？自己去查！语言问题自己搞定
-//        uint32_t rightOne = (uint32_t)eor1 & (-(uint32_t)eor1);
+//        unsigned int rightOne = (unsigned int)eor1 & (-(unsigned int)eor1);
 //        int a = 0;
 //        for (int x : nums) {
-//            if (((uint32_t)x & rightOne) == 0) {
+//            if (((unsigned int)x & rightOne) == 0) {
 //                a ^= x;
 //            }
 //        }

From fccd0197c9dbb3046caccb5960da6410f6bac680 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 13:33:48 +0800
Subject: [PATCH 1232/1712] modify code

---
 src/class175/Code03_SumOfProgression1.java | 20 ++++++++++----------
 src/class175/Code03_SumOfProgression2.java | 20 ++++++++++----------
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/src/class175/Code03_SumOfProgression1.java b/src/class175/Code03_SumOfProgression1.java
index c4f1679de..16ce54faa 100644
--- a/src/class175/Code03_SumOfProgression1.java
+++ b/src/class175/Code03_SumOfProgression1.java
@@ -22,15 +22,15 @@ public class Code03_SumOfProgression1 {
 	public static int MAXB = 401;
 	public static int t, n, q, blen;
 	public static int[] arr = new int[MAXN];
-	public static long[][] f = new long[MAXN][MAXB];
-	public static long[][] g = new long[MAXN][MAXB];
+	public static long[][] f = new long[MAXB][MAXN];
+	public static long[][] g = new long[MAXB][MAXN];
 
 	public static long query(int s, int d, int k) {
 		long ans = 0;
 		if (d <= blen) {
-			ans = g[s][d];
+			ans = g[d][s];
 			if (s + d * k <= n) {
-				ans = ans - g[s + d * k][d] - f[s + d * k][d] * k;
+				ans = ans - g[d][s + d * k] - f[d][s + d * k] * k;
 			}
 		} else {
 			for (int i = 1; i <= k; i++) {
@@ -42,14 +42,14 @@ public static long query(int s, int d, int k) {
 
 	public static void prepare() {
 		blen = (int) Math.sqrt(n);
-		for (int s = n; s >= 1; s--) {
-			for (int d = 1; d <= blen; d++) {
-				f[s][d] = arr[s] + (s + d > n ? 0 : f[s + d][d]);
+		for (int d = 1; d <= blen; d++) {
+			for (int s = n; s >= 1; s--) {
+				f[d][s] = arr[s] + (s + d > n ? 0 : f[d][s + d]);
 			}
 		}
-		for (int s = n; s >= 1; s--) {
-			for (int d = 1; d <= blen; d++) {
-				g[s][d] = f[s][d] + (s + d > n ? 0 : g[s + d][d]);
+		for (int d = 1; d <= blen; d++) {
+			for (int s = n; s >= 1; s--) {
+				g[d][s] = f[d][s] + (s + d > n ? 0 : g[d][s + d]);
 			}
 		}
 	}
diff --git a/src/class175/Code03_SumOfProgression2.java b/src/class175/Code03_SumOfProgression2.java
index 4d4a21935..f5a6ec378 100644
--- a/src/class175/Code03_SumOfProgression2.java
+++ b/src/class175/Code03_SumOfProgression2.java
@@ -20,15 +20,15 @@
 //const int MAXB = 401;
 //int t, n, q, blen;
 //int arr[MAXN];
-//long long f[MAXN][MAXB];
-//long long g[MAXN][MAXB];
+//long long f[MAXB][MAXN];
+//long long g[MAXB][MAXN];
 //
 //long long query(int s, int d, int k) {
 //    long long ans = 0;
 //    if (d <= blen) {
-//        ans = g[s][d];
+//        ans = g[d][s];
 //        if (s + d * k <= n) {
-//            ans -= g[s + d * k][d] + f[s + d * k][d] * k;
+//            ans -= g[d][s + d * k] + f[d][s + d * k] * k;
 //        }
 //    } else {
 //        for (int i = 1; i <= k; i++) {
@@ -40,14 +40,14 @@
 //
 //void prepare() {
 //    blen = (int)sqrt(n);
-//    for (int s = n; s >= 1; s--) {
-//        for (int d = 1; d <= blen; d++) {
-//            f[s][d] = arr[s] + (s + d > n ? 0 : f[s + d][d]);
+//    for (int d = 1; d <= blen; d++) {
+//        for (int s = n; s >= 1; s--) {
+//            f[d][s] = arr[s] + (s + d > n ? 0 : f[d][s + d]);
 //        }
 //    }
-//    for (int s = n; s >= 1; s--) {
-//        for (int d = 1; d <= blen; d++) {
-//            g[s][d] = f[s][d] + (s + d > n ? 0 : g[s + d][d]);
+//    for (int d = 1; d <= blen; d++) {
+//        for (int s = n; s >= 1; s--) {
+//            g[d][s] = f[d][s] + (s + d > n ? 0 : g[d][s + d]);
 //        }
 //    }
 //}

From caa976ecbfed8f0f3a230bf3e5863a3aab695fff Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 14:27:31 +0800
Subject: [PATCH 1233/1712] modify code

---
 src/class175/Code04_Initialization1.java | 4 ++--
 src/class175/Code04_Initialization2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index be3defe0d..d86b9f374 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -19,7 +19,7 @@
 public class Code04_Initialization1 {
 
 	public static int MAXN = 200001;
-	public static int MAXB = 2001;
+	public static int MAXB = 501;
 	public static int MOD = 1000000007;
 	public static int n, m;
 
@@ -90,7 +90,7 @@ public static void prepare() {
 		while ((1 << log2n) <= (n >> 1)) {
 			log2n++;
 		}
-		blen = Math.max(1, (int) Math.sqrt(n / log2n));
+		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 664e7735a..0befce448 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -14,7 +14,7 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//const int MAXB = 2001;
+//const int MAXB = 501;
 //const int MOD  = 1000000007;
 //int n, m;
 //
@@ -81,7 +81,7 @@
 //}
 //
 //void prepare() {
-//    blen = max(1, (int)sqrt(n / log2(n)));
+//    blen = (int)sqrt(n);
 //    bnum = (n + blen - 1) / blen;
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;

From c8bc4eef3028497674423764498ccab953f06172 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 14:28:43 +0800
Subject: [PATCH 1234/1712] modify code

---
 src/class175/Code04_Initialization1.java | 4 ----
 1 file changed, 4 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index d86b9f374..ffafb2e23 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -86,10 +86,6 @@ public static long query(int l, int r) {
 	}
 
 	public static void prepare() {
-		int log2n = 0;
-		while ((1 << log2n) <= (n >> 1)) {
-			log2n++;
-		}
 		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {

From 67fff86b7414c7d43ca07ccc2b24845ec5de0e29 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 15:21:49 +0800
Subject: [PATCH 1235/1712] modify code

---
 src/class175/Code03_SumOfProgression1.java | 8 ++++----
 src/class175/Code03_SumOfProgression2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class175/Code03_SumOfProgression1.java b/src/class175/Code03_SumOfProgression1.java
index 16ce54faa..f55984bc5 100644
--- a/src/class175/Code03_SumOfProgression1.java
+++ b/src/class175/Code03_SumOfProgression1.java
@@ -43,13 +43,13 @@ public static long query(int s, int d, int k) {
 	public static void prepare() {
 		blen = (int) Math.sqrt(n);
 		for (int d = 1; d <= blen; d++) {
-			for (int s = n; s >= 1; s--) {
-				f[d][s] = arr[s] + (s + d > n ? 0 : f[d][s + d]);
+			for (int i = n; i >= 1; i--) {
+				f[d][i] = arr[i] + (i + d > n ? 0 : f[d][i + d]);
 			}
 		}
 		for (int d = 1; d <= blen; d++) {
-			for (int s = n; s >= 1; s--) {
-				g[d][s] = f[d][s] + (s + d > n ? 0 : g[d][s + d]);
+			for (int i = n; i >= 1; i--) {
+				g[d][i] = f[d][i] + (i + d > n ? 0 : g[d][i + d]);
 			}
 		}
 	}
diff --git a/src/class175/Code03_SumOfProgression2.java b/src/class175/Code03_SumOfProgression2.java
index f5a6ec378..f4a3b74f8 100644
--- a/src/class175/Code03_SumOfProgression2.java
+++ b/src/class175/Code03_SumOfProgression2.java
@@ -41,13 +41,13 @@
 //void prepare() {
 //    blen = (int)sqrt(n);
 //    for (int d = 1; d <= blen; d++) {
-//        for (int s = n; s >= 1; s--) {
-//            f[d][s] = arr[s] + (s + d > n ? 0 : f[d][s + d]);
+//        for (int i = n; i >= 1; i--) {
+//            f[d][i] = arr[i] + (i + d > n ? 0 : f[d][i + d]);
 //        }
 //    }
 //    for (int d = 1; d <= blen; d++) {
-//        for (int s = n; s >= 1; s--) {
-//            g[d][s] = f[d][s] + (s + d > n ? 0 : g[d][s + d]);
+//        for (int i = n; i >= 1; i--) {
+//            g[d][i] = f[d][i] + (i + d > n ? 0 : g[d][i + d]);
 //        }
 //    }
 //}

From bfad0b04c14e981b4e65f5e0e330dee90783c927 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 15:54:47 +0800
Subject: [PATCH 1236/1712] modify code

---
 src/class175/Code04_Initialization1.java | 2 +-
 src/class175/Code04_Initialization2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index ffafb2e23..dda4f664b 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -24,7 +24,7 @@ public class Code04_Initialization1 {
 	public static int n, m;
 
 	public static long[] arr = new long[MAXN];
-	public static long[] sum = new long[MAXN];
+	public static long[] sum = new long[MAXB];
 	public static long[][] pre = new long[MAXB][MAXB];
 	public static long[][] suf = new long[MAXB][MAXB];
 
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 0befce448..d146c2310 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -19,7 +19,7 @@
 //int n, m;
 //
 //long long arr[MAXN];
-//long long sum[MAXN];
+//long long sum[MAXB];
 //long long pre[MAXB][MAXB];
 //long long suf[MAXB][MAXB];
 //

From 714933cdefddfcd76fedd57780f3b404ff09188c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 15:57:10 +0800
Subject: [PATCH 1237/1712] modify code

---
 src/class175/Code04_Initialization1.java | 4 ++--
 src/class175/Code04_Initialization2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index dda4f664b..0f6c73e40 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -23,10 +23,10 @@ public class Code04_Initialization1 {
 	public static int MOD = 1000000007;
 	public static int n, m;
 
-	public static long[] arr = new long[MAXN];
-	public static long[] sum = new long[MAXB];
 	public static long[][] pre = new long[MAXB][MAXB];
 	public static long[][] suf = new long[MAXB][MAXB];
+	public static long[] arr = new long[MAXN];
+	public static long[] sum = new long[MAXB];
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index d146c2310..10ade8894 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -18,10 +18,10 @@
 //const int MOD  = 1000000007;
 //int n, m;
 //
-//long long arr[MAXN];
-//long long sum[MAXB];
 //long long pre[MAXB][MAXB];
 //long long suf[MAXB][MAXB];
+//long long arr[MAXN];
+//long long sum[MAXB];
 //
 //int blen, bnum;
 //int bi[MAXN];

From fa0e93b776145df72547ea08ff57ae210bd39303 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 16:47:02 +0800
Subject: [PATCH 1238/1712] modify code

---
 src/class175/Code04_Initialization1.java | 2 +-
 src/class175/Code04_Initialization2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index 0f6c73e40..59454c28a 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -38,7 +38,7 @@ public static void add(int x, int y, int z) {
 			for (int i = y; i <= x; i++) {
 				pre[x][i] += z;
 			}
-			for (int i = 1; i <= y; i++) {
+			for (int i = y; i >= 1; i--) {
 				suf[x][i] += z;
 			}
 		} else {
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 10ade8894..033c9f3f9 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -33,7 +33,7 @@
 //        for (int i = y; i <= x; i++) {
 //            pre[x][i] += z;
 //        }
-//        for (int i = 1; i <= y; i++) {
+//        for (int i = y; i >= 1; i--) {
 //            suf[x][i] += z;
 //        }
 //    } else {

From cce01b65082fc77e465bdd9e51461bdc6f6c2c6e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 17:59:54 +0800
Subject: [PATCH 1239/1712] modify code

---
 src/class175/Code04_Initialization1.java | 10 +++++-----
 src/class175/Code04_Initialization2.java |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class175/Code04_Initialization1.java b/src/class175/Code04_Initialization1.java
index 59454c28a..677b0f564 100644
--- a/src/class175/Code04_Initialization1.java
+++ b/src/class175/Code04_Initialization1.java
@@ -72,11 +72,11 @@ public static long querySum(int l, int r) {
 
 	public static long query(int l, int r) {
 		long ans = querySum(l, r);
-		for (int x = 1, lb, rb, num; x <= blen; x++) {
-			lb = (l - 1) / x + 1;
-			rb = (r - 1) / x + 1;
-			num = rb - lb - 1;
-			if (lb == rb) {
+		for (int x = 1, lth, rth, num; x <= blen; x++) {
+			lth = (l - 1) / x + 1;
+			rth = (r - 1) / x + 1;
+			num = rth - lth - 1;
+			if (lth == rth) {
 				ans = ans + pre[x][(r - 1) % x + 1] - pre[x][(l - 1) % x];
 			} else {
 				ans = ans + suf[x][(l - 1) % x + 1] + pre[x][x] * num + pre[x][(r - 1) % x + 1];
diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 033c9f3f9..7e3dc9f45 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -68,10 +68,10 @@
 //long long query(int l, int r) {
 //    long long ans = querySum(l, r);
 //    for (int x = 1, lb, rb, num; x <= blen; x++) {
-//        lb = (l - 1) / x + 1;
-//        rb = (r - 1) / x + 1;
-//        num = rb - lb - 1;
-//        if (lb == rb) {
+//        lth = (l - 1) / x + 1;
+//        rth = (r - 1) / x + 1;
+//        num = rth - lth - 1;
+//        if (lth == rth) {
 //            ans = ans + pre[x][(r - 1) % x + 1] - pre[x][(l - 1) % x];
 //        } else {
 //            ans = ans + suf[x][(l - 1) % x + 1] + pre[x][x] * num + pre[x][(r - 1) % x + 1];

From 1184806eec3e69c1b15bd1348e156d652708c9a5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 18:07:27 +0800
Subject: [PATCH 1240/1712] modify code

---
 src/class175/Code04_Initialization2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class175/Code04_Initialization2.java b/src/class175/Code04_Initialization2.java
index 7e3dc9f45..f7f7e80fd 100644
--- a/src/class175/Code04_Initialization2.java
+++ b/src/class175/Code04_Initialization2.java
@@ -67,7 +67,7 @@
 //
 //long long query(int l, int r) {
 //    long long ans = querySum(l, r);
-//    for (int x = 1, lb, rb, num; x <= blen; x++) {
+//    for (int x = 1, lth, rth, num; x <= blen; x++) {
 //        lth = (l - 1) / x + 1;
 //        rth = (r - 1) / x + 1;
 //        num = rth - lth - 1;

From 7c0b30b8685fd62b7f3dadcdf02fcc30028a5d70 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 18:39:18 +0800
Subject: [PATCH 1241/1712] modify code

---
 src/class175/Code05_Skyscraper1.java | 1 -
 src/class175/Code05_Skyscraper2.java | 1 -
 2 files changed, 2 deletions(-)

diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
index 0637531c9..3c26112c5 100644
--- a/src/class175/Code05_Skyscraper1.java
+++ b/src/class175/Code05_Skyscraper1.java
@@ -31,7 +31,6 @@ static class Node {
 
 	public static int MAXN = 30001;
 	public static int n, m;
-
 	// 每个位置拥有的狗子列表
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
diff --git a/src/class175/Code05_Skyscraper2.java b/src/class175/Code05_Skyscraper2.java
index b7ff56e78..c4200f861 100644
--- a/src/class175/Code05_Skyscraper2.java
+++ b/src/class175/Code05_Skyscraper2.java
@@ -21,7 +21,6 @@
 //
 //const int MAXN = 30001;
 //int n, m;
-//
 //int head[MAXN];
 //int nxt[MAXN];
 //int to[MAXN];

From 5045eab81ba3f864f7e4ad66cf3e484a0b8b178d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 19:08:43 +0800
Subject: [PATCH 1242/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 4 +++-
 src/class175/Code07_GivenTree2.java | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index 4e3c795e1..fe997e124 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -67,7 +67,9 @@ public static int query(int limit) {
 			} else if (len[cur] > max2[father]) {
 				max2[father] = len[cur];
 			}
-			max1[cur] = max2[cur] = 0;
+		}
+		for (int i = 1; i <= n; i++) {
+			len[i] = max1[i] = max2[i] = 0;
 		}
 		return cnt;
 	}
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index 5ef60252a..0049027ba 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -65,7 +65,9 @@
 //        } else if (len[cur] > max2[father]) {
 //            max2[father] = len[cur];
 //        }
-//        max1[cur] = max2[cur] = 0;
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        len[i] = max1[i] = max2[i] = 0;
 //    }
 //    return cnt;
 //}

From c3bb6cf60e703091ec0534484f759831355134c2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 19:41:46 +0800
Subject: [PATCH 1243/1712] modify code

---
 src/class175/Code05_Skyscraper1.java | 24 ++++++++++++------------
 src/class175/Code05_Skyscraper2.java | 20 ++++++++++----------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
index 3c26112c5..7f923cfc9 100644
--- a/src/class175/Code05_Skyscraper1.java
+++ b/src/class175/Code05_Skyscraper1.java
@@ -19,12 +19,12 @@
 public class Code05_Skyscraper1 {
 
 	static class Node {
-		int idx, jump, step;
+		int idx, jump, time;
 
-		Node(int i, int j, int s) {
+		Node(int i, int j, int t) {
 			idx = i;
 			jump = j;
-			step = s;
+			time = t;
 		}
 
 	}
@@ -47,22 +47,22 @@ public static void add(int idx, int jump) {
 		head[idx] = cnt;
 	}
 
-	public static void trigger(int idx, int step) {
+	public static void trigger(int idx, int time) {
 		for (int e = head[idx], nextJump; e > 0; e = next[e]) {
 			nextJump = to[e];
 			if (!vis[idx].get(nextJump)) {
 				vis[idx].set(nextJump);
-				que.addLast(new Node(idx, nextJump, step));
+				que.addLast(new Node(idx, nextJump, time));
 			}
 		}
 		head[idx] = 0;
 	}
 
-	public static void extend(int idx, int jump, int step) {
-		trigger(idx, step);
+	public static void extend(int idx, int jump, int time) {
+		trigger(idx, time);
 		if (!vis[idx].get(jump)) {
 			vis[idx].set(jump);
-			que.addLast(new Node(idx, jump, step));
+			que.addLast(new Node(idx, jump, time));
 		}
 	}
 
@@ -78,15 +78,15 @@ public static int bfs(int s, int t) {
 			Node cur = que.pollFirst();
 			int idx = cur.idx;
 			int jump = cur.jump;
-			int step = cur.step;
+			int time = cur.time;
 			if (idx - jump == t || idx + jump == t) {
-				return step + 1;
+				return time + 1;
 			}
 			if (idx - jump >= 0) {
-				extend(idx - jump, jump, step + 1);
+				extend(idx - jump, jump, time + 1);
 			}
 			if (idx + jump < n) {
-				extend(idx + jump, jump, step + 1);
+				extend(idx + jump, jump, time + 1);
 			}
 		}
 		return -1;
diff --git a/src/class175/Code05_Skyscraper2.java b/src/class175/Code05_Skyscraper2.java
index c4200f861..638d65afb 100644
--- a/src/class175/Code05_Skyscraper2.java
+++ b/src/class175/Code05_Skyscraper2.java
@@ -16,7 +16,7 @@
 //using namespace std;
 //
 //struct Node {
-//    int idx, jump, step;
+//    int idx, jump, time;
 //};
 //
 //const int MAXN = 30001;
@@ -35,22 +35,22 @@
 //    head[idx] = cnt;
 //}
 //
-//void trigger(int idx, int step) {
+//void trigger(int idx, int time) {
 //    for (int e = head[idx], nextJump; e; e = nxt[e]) {
 //        nextJump = to[e];
 //        if (!vis[idx].test(nextJump)) {
 //            vis[idx].set(nextJump);
-//            que.push_back({idx, nextJump, step});
+//            que.push_back({idx, nextJump, time});
 //        }
 //    }
 //    head[idx] = 0;
 //}
 //
-//void extend(int idx, int jump, int step) {
-//    trigger(idx, step);
+//void extend(int idx, int jump, int time) {
+//    trigger(idx, time);
 //    if (!vis[idx].test(jump)) {
 //        vis[idx].set(jump);
-//        que.push_back({idx, jump, step});
+//        que.push_back({idx, jump, time});
 //    }
 //}
 //
@@ -68,15 +68,15 @@
 //        que.pop_front();
 //        int idx = cur.idx;
 //        int jump = cur.jump;
-//        int step = cur.step;
+//        int time = cur.time;
 //        if (idx - jump == t || idx + jump == t) {
-//            return step + 1;
+//            return time + 1;
 //        }
 //        if (idx - jump >= 0) {
-//            extend(idx - jump, jump, step + 1);
+//            extend(idx - jump, jump, time + 1);
 //        }
 //        if (idx + jump < n) {
-//            extend(idx + jump, jump, step + 1);
+//            extend(idx + jump, jump, time + 1);
 //        }
 //    }
 //    return -1;

From 75a1a1c7327058f3c7ec8c890baf594f472442b9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 20:06:54 +0800
Subject: [PATCH 1244/1712] modify code

---
 src/class175/Code05_Skyscraper1.java | 10 +++++-----
 src/class175/Code05_Skyscraper2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
index 7f923cfc9..a86a9519e 100644
--- a/src/class175/Code05_Skyscraper1.java
+++ b/src/class175/Code05_Skyscraper1.java
@@ -48,11 +48,11 @@ public static void add(int idx, int jump) {
 	}
 
 	public static void trigger(int idx, int time) {
-		for (int e = head[idx], nextJump; e > 0; e = next[e]) {
-			nextJump = to[e];
-			if (!vis[idx].get(nextJump)) {
-				vis[idx].set(nextJump);
-				que.addLast(new Node(idx, nextJump, time));
+		for (int e = head[idx], jump; e > 0; e = next[e]) {
+			jump = to[e];
+			if (!vis[idx].get(jump)) {
+				vis[idx].set(jump);
+				que.addLast(new Node(idx, jump, time));
 			}
 		}
 		head[idx] = 0;
diff --git a/src/class175/Code05_Skyscraper2.java b/src/class175/Code05_Skyscraper2.java
index 638d65afb..b3a27e22e 100644
--- a/src/class175/Code05_Skyscraper2.java
+++ b/src/class175/Code05_Skyscraper2.java
@@ -36,11 +36,11 @@
 //}
 //
 //void trigger(int idx, int time) {
-//    for (int e = head[idx], nextJump; e; e = nxt[e]) {
-//        nextJump = to[e];
-//        if (!vis[idx].test(nextJump)) {
-//            vis[idx].set(nextJump);
-//            que.push_back({idx, nextJump, time});
+//    for (int e = head[idx], jump; e; e = nxt[e]) {
+//        jump = to[e];
+//        if (!vis[idx].test(jump)) {
+//            vis[idx].set(jump);
+//            que.push_back({idx, jump, time});
 //        }
 //    }
 //    head[idx] = 0;

From d1309bda3c4a06f5c9443a3cecefca1c2b3812d7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 6 Aug 2025 20:43:46 +0800
Subject: [PATCH 1245/1712] modify code

---
 src/class175/Code05_Skyscraper1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class175/Code05_Skyscraper1.java b/src/class175/Code05_Skyscraper1.java
index a86a9519e..ecbcad1da 100644
--- a/src/class175/Code05_Skyscraper1.java
+++ b/src/class175/Code05_Skyscraper1.java
@@ -31,7 +31,7 @@ static class Node {
 
 	public static int MAXN = 30001;
 	public static int n, m;
-	// 每个位置拥有的狗子列表
+	// 每个大楼拥有的狗子列表
 	public static int[] head = new int[MAXN];
 	public static int[] next = new int[MAXN];
 	public static int[] to = new int[MAXN];
@@ -39,6 +39,7 @@ static class Node {
 
 	// bfs过程
 	public static ArrayDeque<Node> que = new ArrayDeque<>();
+	// vis[idx]是个位图，可以表示vis[idx][jump]是否出现过
 	public static BitSet[] vis = new BitSet[MAXN];
 
 	public static void add(int idx, int jump) {

From c7b497efdba598b0f573b01fe2e2c6257822dd29 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 13:29:49 +0800
Subject: [PATCH 1246/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 2 +-
 src/class175/Code07_GivenTree2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index fe997e124..311d40c70 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -2,7 +2,7 @@
 
 // 给你一棵树，java版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 树的路径是指，从节点x到节点y，沿途节点只经过一次，k路径是指，路径上节点数正好为k
+// 树的路径是指，从节点x到节点y的简单路径，k路径是指，路径上节点数正好为k
 // 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
 // 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
 // 打印k = 1, 2, 3..n时，所有的答案
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index 0049027ba..49ead5990 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -2,7 +2,7 @@
 
 // 给你一棵树，C++版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 树的路径是指，从节点x到节点y，沿途节点只经过一次，k路径是指，路径上节点数正好为k
+// 树的路径是指，从节点x到节点y的简单路径，k路径是指，路径上节点数正好为k
 // 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
 // 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
 // 打印k = 1, 2, 3..n时，所有的答案

From 90182eabb32153e55f81721041e8f03941c6c653 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 13:41:06 +0800
Subject: [PATCH 1247/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index 311d40c70..17f091ff0 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -24,10 +24,15 @@ public class Code07_GivenTree1 {
 	public static int[] to = new int[MAXN << 1];
 	public static int cntg = 0;
 
+	// fa[i]表示，i节点的父节点编号
+	// seg[d]表示，dfn序号为d的节点，在图上的编号是什么
 	public static int[] fa = new int[MAXN];
 	public static int[] seg = new int[MAXN];
 	public static int cntd = 0;
 
+	// len[i]表示，当前i号节点只能往下走，没分配成路径的最长链的长度
+	// max1[i]表示，最大值 { len[a], len[b], len[c] ... }，其中a、b、c..是i的子节点
+	// max2[i]表示，次大值 { len[a], len[b], len[c] ... }，其中a、b、c..是i的子节点
 	public static int[] len = new int[MAXN];
 	public static int[] max1 = new int[MAXN];
 	public static int[] max2 = new int[MAXN];

From 67ce8d5c3a800b033eb05525d34010541d28833f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 13:43:06 +0800
Subject: [PATCH 1248/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index 17f091ff0..cdd01bbee 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -2,7 +2,7 @@
 
 // 给你一棵树，java版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 树的路径是指，从节点x到节点y的简单路径，k路径是指，路径上节点数正好为k
+// 树的路径是指，从端点x到端点y的简单路径，k路径是指，路径上节点数正好为k
 // 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
 // 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
 // 打印k = 1, 2, 3..n时，所有的答案

From 7d33ffe509216d8d01e953787653bcad21b659fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 13:43:37 +0800
Subject: [PATCH 1249/1712] modify code

---
 src/class175/Code07_GivenTree2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index 49ead5990..ade3e13d7 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -2,7 +2,7 @@
 
 // 给你一棵树，C++版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 树的路径是指，从节点x到节点y的简单路径，k路径是指，路径上节点数正好为k
+// 树的路径是指，从端点x到端点y的简单路径，k路径是指，路径上节点数正好为k
 // 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
 // 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
 // 打印k = 1, 2, 3..n时，所有的答案

From 6c132ae2aec803fdc3082a91ac256c3987baf163 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 14:23:18 +0800
Subject: [PATCH 1250/1712] modify code

---
 src/class175/Code06_TillCollapse1.java | 2 +-
 src/class175/Code06_TillCollapse2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index 350c80381..4ed19f510 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -2,7 +2,7 @@
 
 // 最少划分，java版
 // 给定一个长度为n的数组arr，考虑如下问题的解
-// 希望知道arr最少划分成几段，可以做到每段内，不同数值的个数 <= k
+// 数组arr划分成若干段子数组，保证每段不同数字的种类 <= k，返回至少划分成几段
 // 打印k = 1, 2, 3..n时，所有的答案
 // 1 <= arr[i] <= n <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF786C
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index 049a75fd3..67a626ce5 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -2,7 +2,7 @@
 
 // 最少划分，C++版
 // 给定一个长度为n的数组arr，考虑如下问题的解
-// 希望知道arr最少划分成几段，可以做到每段内，不同数值的个数 <= k
+// 数组arr划分成若干段子数组，保证每段不同数字的种类 <= k，返回至少划分成几段
 // 打印k = 1, 2, 3..n时，所有的答案
 // 1 <= arr[i] <= n <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF786C

From 6c0ca39a7375a444d55b3e0a361d0ed3d4b23776 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 14:40:51 +0800
Subject: [PATCH 1251/1712] modify code

---
 src/class175/Code06_TillCollapse1.java | 10 +++++-----
 src/class175/Code06_TillCollapse2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class175/Code06_TillCollapse1.java b/src/class175/Code06_TillCollapse1.java
index 4ed19f510..938c885e5 100644
--- a/src/class175/Code06_TillCollapse1.java
+++ b/src/class175/Code06_TillCollapse1.java
@@ -23,22 +23,22 @@ public class Code06_TillCollapse1 {
 	public static int[] ans = new int[MAXN];
 
 	public static int query(int limit) {
-		int num = 0, cnt = 0, start = 1;
+		int kind = 0, cnt = 0, start = 1;
 		for (int i = 1; i <= n; i++) {
 			if (!vis[arr[i]]) {
-				num++;
-				if (num > limit) {
+				kind++;
+				if (kind > limit) {
 					cnt++;
 					for (int j = start; j < i; j++) {
 						vis[arr[j]] = false;
 					}
 					start = i;
-					num = 1;
+					kind = 1;
 				}
 				vis[arr[i]] = true;
 			}
 		}
-		if (num > 0) {
+		if (kind > 0) {
 			cnt++;
 			for (int j = start; j <= n; j++) {
 				vis[arr[j]] = false;
diff --git a/src/class175/Code06_TillCollapse2.java b/src/class175/Code06_TillCollapse2.java
index 67a626ce5..cc1b86e4b 100644
--- a/src/class175/Code06_TillCollapse2.java
+++ b/src/class175/Code06_TillCollapse2.java
@@ -21,22 +21,22 @@
 //int ans[MAXN];
 //
 //int query(int limit) {
-//    int num = 0, cnt = 0, start = 1;
+//    int kind = 0, cnt = 0, start = 1;
 //    for (int i = 1; i <= n; i++) {
 //        if (!vis[arr[i]]) {
-//            num++;
-//            if (num > limit) {
+//            kind++;
+//            if (kind > limit) {
 //                cnt++;
 //                for (int j = start; j < i; j++) {
 //                    vis[arr[j]] = false;
 //                }
 //                start = i;
-//                num = 1;
+//                kind = 1;
 //            }
 //            vis[arr[i]] = true;
 //        }
 //    }
-//    if (num > 0) {
+//    if (kind > 0) {
 //        cnt++;
 //        for (int j = start; j <= n; j++) {
 //            vis[arr[j]] = false;

From 10be0c6bd8d1bc2b928d696452685515c56745bf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 15:51:51 +0800
Subject: [PATCH 1252/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 7 +++----
 src/class175/Code07_GivenTree2.java | 7 +++----
 2 files changed, 6 insertions(+), 8 deletions(-)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index cdd01bbee..e783de56e 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -2,10 +2,9 @@
 
 // 给你一棵树，java版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 树的路径是指，从端点x到端点y的简单路径，k路径是指，路径上节点数正好为k
-// 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
-// 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
-// 打印k = 1, 2, 3..n时，所有的答案
+// 树的路径是指，从端点x到端点y的简单路径，k路径是指，路径的节点数正好为k
+// 整棵树希望分解成尽量多的k路径，k路径的节点不能复用，所有k路径不要求包含所有点
+// 打印k = 1, 2, 3..n时，k路径有最多有几条
 // 测试链接 : https://www.luogu.com.cn/problem/CF1039D
 // 测试链接 : https://codeforces.com/problemset/problem/1039/D
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index ade3e13d7..c6b55cca0 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -2,10 +2,9 @@
 
 // 给你一棵树，C++版
 // 一共有n个节点，给定n-1条边，所有节点连成一棵树
-// 树的路径是指，从端点x到端点y的简单路径，k路径是指，路径上节点数正好为k
-// 那么整棵树可以分解出若干条路径，路径之间不能重叠，所有路径也不要求覆盖所有点
-// 希望分解方案中，k路径的数量尽可能多，返回这个尽可能多的数量作为答案
-// 打印k = 1, 2, 3..n时，所有的答案
+// 树的路径是指，从端点x到端点y的简单路径，k路径是指，路径的节点数正好为k
+// 整棵树希望分解成尽量多的k路径，k路径的节点不能复用，所有k路径不要求包含所有点
+// 打印k = 1, 2, 3..n时，k路径有最多有几条
 // 测试链接 : https://www.luogu.com.cn/problem/CF1039D
 // 测试链接 : https://codeforces.com/problemset/problem/1039/D
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 3d2c99e873718084852369895673e3cea20c45d2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 16:01:29 +0800
Subject: [PATCH 1253/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 6 +++---
 src/class175/Code07_GivenTree2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index e783de56e..8481942b2 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -54,12 +54,12 @@ public static void dfs(int u, int f) {
 		}
 	}
 
-	public static int query(int limit) {
+	public static int query(int k) {
 		int cnt = 0;
 		for (int dfn = n, cur, father; dfn >= 1; dfn--) {
 			cur = seg[dfn];
 			father = fa[cur];
-			if (max1[cur] + max2[cur] + 1 >= limit) {
+			if (max1[cur] + max2[cur] + 1 >= k) {
 				cnt++;
 				len[cur] = 0;
 			} else {
@@ -105,7 +105,6 @@ public static void compute() {
 	}
 
 	public static void prepare() {
-		dfs(1, 0);
 		int log2n = 0;
 		while ((1 << log2n) <= (n >> 1)) {
 			log2n++;
@@ -124,6 +123,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(u, v);
 			addEdge(v, u);
 		}
+		dfs(1, 0);
 		prepare();
 		compute();
 		for (int i = 1; i <= n; i++) {
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index c6b55cca0..4ac155bf1 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -47,12 +47,12 @@
 //    }
 //}
 //
-//int query(int limit) {
+//int query(int k) {
 //    int cnt = 0;
 //    for (int dfn = n, cur, father; dfn >= 1; dfn--) {
 //        cur = seg[dfn];
 //        father = fa[cur];
-//        if (max1[cur] + max2[cur] + 1 >= limit) {
+//        if (max1[cur] + max2[cur] + 1 >= k) {
 //            cnt++;
 //            len[cur] = 0;
 //        } else {
@@ -98,7 +98,6 @@
 //}
 //
 //void prepare() {
-//    dfs(1, 0);
 //    blen = max(1, (int)sqrt(n * log2(n)));
 //    fill(ans + 1, ans + n + 1, -1);
 //}
@@ -112,6 +111,7 @@
 //        addEdge(u, v);
 //        addEdge(v, u);
 //    }
+//    dfs(1, 0);
 //    prepare();
 //    compute();
 //    for (int i = 1; i <= n; i++) {

From 21326292a8020dab6a60be2e0d383149c36a0126 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 16:07:31 +0800
Subject: [PATCH 1254/1712] modify code

---
 src/class175/Code07_GivenTree1.java | 10 +++++-----
 src/class175/Code07_GivenTree2.java |  8 ++++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/src/class175/Code07_GivenTree1.java b/src/class175/Code07_GivenTree1.java
index 8481942b2..c8b69c415 100644
--- a/src/class175/Code07_GivenTree1.java
+++ b/src/class175/Code07_GivenTree1.java
@@ -24,9 +24,9 @@ public class Code07_GivenTree1 {
 	public static int cntg = 0;
 
 	// fa[i]表示，i节点的父节点编号
-	// seg[d]表示，dfn序号为d的节点，在图上的编号是什么
+	// dfnOrder是根据dfn序，依次收集上来的节点编号
 	public static int[] fa = new int[MAXN];
-	public static int[] seg = new int[MAXN];
+	public static int[] dfnOrder = new int[MAXN];
 	public static int cntd = 0;
 
 	// len[i]表示，当前i号节点只能往下走，没分配成路径的最长链的长度
@@ -46,7 +46,7 @@ public static void addEdge(int u, int v) {
 
 	public static void dfs(int u, int f) {
 		fa[u] = f;
-		seg[++cntd] = u;
+		dfnOrder[++cntd] = u;
 		for (int e = head[u]; e > 0; e = next[e]) {
 			if (to[e] != f) {
 				dfs(to[e], u);
@@ -56,8 +56,8 @@ public static void dfs(int u, int f) {
 
 	public static int query(int k) {
 		int cnt = 0;
-		for (int dfn = n, cur, father; dfn >= 1; dfn--) {
-			cur = seg[dfn];
+		for (int i = n, cur, father; i >= 1; i--) {
+			cur = dfnOrder[i];
 			father = fa[cur];
 			if (max1[cur] + max2[cur] + 1 >= k) {
 				cnt++;
diff --git a/src/class175/Code07_GivenTree2.java b/src/class175/Code07_GivenTree2.java
index 4ac155bf1..7fc6acecd 100644
--- a/src/class175/Code07_GivenTree2.java
+++ b/src/class175/Code07_GivenTree2.java
@@ -22,7 +22,7 @@
 //int cntg = 0;
 //
 //int fa[MAXN];
-//int seg[MAXN];
+//int dfnOrder[MAXN];
 //int cntd = 0;
 //
 //int len[MAXN];
@@ -39,7 +39,7 @@
 //
 //void dfs(int u, int f) {
 //    fa[u] = f;
-//    seg[++cntd] = u;
+//    dfnOrder[++cntd] = u;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        if (to[e] != f) {
 //            dfs(to[e], u);
@@ -49,8 +49,8 @@
 //
 //int query(int k) {
 //    int cnt = 0;
-//    for (int dfn = n, cur, father; dfn >= 1; dfn--) {
-//        cur = seg[dfn];
+//    for (int i = n, cur, father; i >= 1; i--) {
+//        cur = dfnOrder[i];
 //        father = fa[cur];
 //        if (max1[cur] + max2[cur] + 1 >= k) {
 //            cnt++;

From 3cdba910b92bdcbf30a9e1b785becaab0161c3f3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 7 Aug 2025 17:04:20 +0800
Subject: [PATCH 1255/1712] modify code

---
 ...71\345\217\267\345\210\206\346\262\273.pptx" | Bin 0 -> 52612 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243175\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2304-\346\240\271\345\217\267\345\210\206\346\262\273.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243175\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2304-\346\240\271\345\217\267\345\210\206\346\262\273.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243175\343\200\220\346\214\272\351\232\276\343\200\221\345\210\206\345\235\227\344\270\223\351\242\2304-\346\240\271\345\217\267\345\210\206\346\262\273.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..ef506834435332aac705106e78fc455beffe719a
GIT binary patch
literal 52612
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
Apa1{>

literal 0
HcmV?d00001


From 994f427912bf2e0a95b798639b68f09ba786e26b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Aug 2025 17:24:55 +0800
Subject: [PATCH 1256/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java | 164 ++++++++++++++++++++++++++
 src/class176/Code01_MoAlgorithm2.java | 106 +++++++++++++++++
 2 files changed, 270 insertions(+)
 create mode 100644 src/class176/Code01_MoAlgorithm1.java
 create mode 100644 src/class176/Code01_MoAlgorithm2.java

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
new file mode 100644
index 000000000..60bea028d
--- /dev/null
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -0,0 +1,164 @@
+package class176;
+
+// 普通莫队模版题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/SP3267
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code01_MoAlgorithm1 {
+
+	// 莫队经典排序
+	public static class QueryCmp1 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	// 莫队优化常数的排序
+	public static class QueryCmp2 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			}
+			return b[1] - a[1];
+		}
+
+	}
+
+	public static QueryCmp1 cmp1 = new QueryCmp1();
+	public static QueryCmp2 cmp2 = new QueryCmp2();
+
+	public static int MAXN = 30001;
+	public static int MAXV = 1000001;
+	public static int MAXQ = 200001;
+	public static int n, q;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXQ][3];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cnt = new int[MAXV];
+	public static int kind = 0;
+
+	public static int[] ans = new int[MAXQ];
+
+	public static void del(int idx) {
+		if (--cnt[arr[idx]] == 0) {
+			kind--;
+		}
+	}
+
+	public static void add(int idx) {
+		if (++cnt[arr[idx]] == 1) {
+			kind++;
+		}
+	}
+
+	public static void prepare() {
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		// Arrays.sort(query, 1, q + 1, cmp1);
+		Arrays.sort(query, 1, q + 1, cmp2);
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= q; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			while (winl < jobl) {
+				del(winl++);
+			}
+			while (winl > jobl) {
+				add(--winl);
+			}
+			while (winr < jobr) {
+				add(++winr);
+			}
+			while (winr > jobr) {
+				del(winr--);
+			}
+			ans[query[i][2]] = kind;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		q = in.nextInt();
+		for (int i = 1; i <= q; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= q; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
new file mode 100644
index 000000000..fa31ab4e9
--- /dev/null
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -0,0 +1,106 @@
+package class176;
+
+// 普通莫队模版题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/SP3267
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 30001;
+//const int MAXV = 1000001;
+//const int MAXQ = 200001;
+//int n, q;
+//int arr[MAXN];
+//Query query[MAXQ];
+//
+//int bi[MAXN];
+//int cnt[MAXV];
+//int kind = 0;
+//
+//int ans[MAXQ];
+//
+//bool QueryCmp1(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    return a.r < b.r;
+//}
+//
+//bool QueryCmp2(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    }
+//    return a.r > b.r;
+//}
+//
+//void del(int idx) {
+//    if (--cnt[arr[idx]] == 0) {
+//        kind--;
+//    }
+//}
+//
+//void add(int idx) {
+//    if (++cnt[arr[idx]] == 1) {
+//        kind++;
+//    }
+//}
+//
+//void prepare() {
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + q + 1, QueryCmp2);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= q; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
+//        while (winl > jobl) {
+//            add(--winl);
+//        }
+//        while (winr < jobr) {
+//            add(++winr);
+//        }
+//        while (winr > jobr) {
+//            del(winr--);
+//        }
+//        ans[query[i].id] = kind;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> query[i].l;
+//        cin >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= q; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From c22cb7b414f0afae08264cc5bc49087de4532395 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 12 Aug 2025 19:11:13 +0800
Subject: [PATCH 1257/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java |   3 +-
 src/class176/Code01_MoAlgorithm2.java |   1 -
 src/class176/Code02_QueryFromB1.java  | 160 ++++++++++++++++++++++++++
 src/class176/Code02_QueryFromB2.java  | 100 ++++++++++++++++
 4 files changed, 261 insertions(+), 3 deletions(-)
 create mode 100644 src/class176/Code02_QueryFromB1.java
 create mode 100644 src/class176/Code02_QueryFromB2.java

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index 60bea028d..1954f09ce 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -26,7 +26,7 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	// 莫队优化常数的排序
+	// 莫队奇偶排序
 	public static class QueryCmp2 implements Comparator<int[]> {
 
 		@Override
@@ -55,7 +55,6 @@ public int compare(int[] a, int[] b) {
 	public static int[] bi = new int[MAXN];
 	public static int[] cnt = new int[MAXV];
 	public static int kind = 0;
-
 	public static int[] ans = new int[MAXQ];
 
 	public static void del(int idx) {
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index fa31ab4e9..ae602430b 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -23,7 +23,6 @@
 //int bi[MAXN];
 //int cnt[MAXV];
 //int kind = 0;
-//
 //int ans[MAXQ];
 //
 //bool QueryCmp1(Query &a, Query &b) {
diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
new file mode 100644
index 000000000..9b0db1917
--- /dev/null
+++ b/src/class176/Code02_QueryFromB1.java
@@ -0,0 +1,160 @@
+package class176;
+
+// 小B的询问，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2709
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code02_QueryFromB1 {
+
+	// 莫队经典排序
+	public static class QueryCmp1 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	// 莫队奇偶排序
+	public static class QueryCmp2 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			}
+			return b[1] - a[1];
+		}
+
+	}
+
+	public static QueryCmp1 cmp1 = new QueryCmp1();
+	public static QueryCmp2 cmp2 = new QueryCmp2();
+
+	public static int MAXN = 50001;
+	public static int n, m, k;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cnt = new int[MAXN];
+	public static long sum = 0;
+	public static long[] ans = new long[MAXN];
+
+	public static void del(int idx) {
+		sum -= 2 * cnt[arr[idx]] - 1;
+		cnt[arr[idx]]--;
+	}
+
+	public static void add(int idx) {
+		sum += 2 * cnt[arr[idx]] + 1;
+		cnt[arr[idx]]++;
+	}
+
+	public static void prepare() {
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		// Arrays.sort(query, 1, m + 1, cmp1);
+		Arrays.sort(query, 1, m + 1, cmp2);
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			while (winl < jobl) {
+				del(winl++);
+			}
+			while (winl > jobl) {
+				add(--winl);
+			}
+			while (winr < jobr) {
+				add(++winr);
+			}
+			while (winr > jobr) {
+				del(winr--);
+			}
+			ans[query[i][2]] = sum;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class176/Code02_QueryFromB2.java b/src/class176/Code02_QueryFromB2.java
new file mode 100644
index 000000000..e048b35b9
--- /dev/null
+++ b/src/class176/Code02_QueryFromB2.java
@@ -0,0 +1,100 @@
+package class176;
+
+// 小B的询问，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2709
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 50001;
+//int n, m, k;
+//int arr[MAXN];
+//Query query[MAXN];
+//
+//int bi[MAXN];
+//int cnt[MAXN];
+//long long sum = 0;
+//long long ans[MAXN];
+//
+//bool QueryCmp1(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    return a.r < b.r;
+//}
+//
+//bool QueryCmp2(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    }
+//    return a.r > b.r;
+//}
+//
+//void del(int idx) {
+//    sum -= 2 * cnt[arr[idx]] - 1;
+//    cnt[arr[idx]]--;
+//}
+//
+//void add(int idx) {
+//    sum += 2 * cnt[arr[idx]] + 1;
+//    cnt[arr[idx]]++;
+//}
+//
+//void prepare() {
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp2);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
+//        while (winl > jobl) {
+//            add(--winl);
+//        }
+//        while (winr < jobr) {
+//            add(++winr);
+//        }
+//        while (winr > jobr) {
+//            del(winr--);
+//        }
+//        ans[query[i].id] = sum;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l;
+//        cin >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From ee6e6adb8e7a6f3d2c0933f0fcefac411c78ee8c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Aug 2025 10:49:08 +0800
Subject: [PATCH 1258/1712] modify code

---
 src/class176/Code03_SockFromZ1.java | 179 ++++++++++++++++++++++++++++
 src/class176/Code03_SockFromZ2.java | 117 ++++++++++++++++++
 2 files changed, 296 insertions(+)
 create mode 100644 src/class176/Code03_SockFromZ1.java
 create mode 100644 src/class176/Code03_SockFromZ2.java

diff --git a/src/class176/Code03_SockFromZ1.java b/src/class176/Code03_SockFromZ1.java
new file mode 100644
index 000000000..09e678a6c
--- /dev/null
+++ b/src/class176/Code03_SockFromZ1.java
@@ -0,0 +1,179 @@
+package class176;
+
+// 小Z的袜子，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1494
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code03_SockFromZ2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code03_SockFromZ1 {
+
+	// 莫队经典排序
+	public static class QueryCmp1 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	// 莫队奇偶排序
+	public static class QueryCmp2 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			}
+			return b[1] - a[1];
+		}
+
+	}
+
+	public static QueryCmp1 cmp1 = new QueryCmp1();
+	public static QueryCmp2 cmp2 = new QueryCmp2();
+
+	public static int MAXN = 50001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cnt = new int[MAXN];
+	public static long sum = 0;
+	public static long[] ans1 = new long[MAXN];
+	public static long[] ans2 = new long[MAXN];
+
+	public static long gcd(long a, long b) {
+		return b == 0 ? a : gcd(b, a % b);
+	}
+
+	public static void del(int idx) {
+		sum -= cnt[arr[idx]] * cnt[arr[idx]];
+		cnt[arr[idx]]--;
+		sum += cnt[arr[idx]] * cnt[arr[idx]];
+	}
+
+	public static void add(int idx) {
+		sum -= cnt[arr[idx]] * cnt[arr[idx]];
+		cnt[arr[idx]]++;
+		sum += cnt[arr[idx]] * cnt[arr[idx]];
+	}
+
+	public static void prepare() {
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		// Arrays.sort(query, 1, m + 1, cmp1);
+		Arrays.sort(query, 1, m + 1, cmp2);
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			while (winl < jobl) {
+				del(winl++);
+			}
+			while (winl > jobl) {
+				add(--winl);
+			}
+			while (winr < jobr) {
+				add(++winr);
+			}
+			while (winr > jobr) {
+				del(winr--);
+			}
+			if (jobl == jobr) {
+				ans1[id] = 0;
+				ans2[id] = 1;
+			} else {
+				ans1[id] = sum - (jobr - jobl + 1);
+				ans2[id] = 1L * (jobr - jobl + 1) * (jobr - jobl);
+				long g = gcd(ans1[id], ans2[id]);
+				ans1[id] /= g;
+				ans2[id] /= g;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans1[i] + "/" + ans2[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class176/Code03_SockFromZ2.java b/src/class176/Code03_SockFromZ2.java
new file mode 100644
index 000000000..8a92a19e6
--- /dev/null
+++ b/src/class176/Code03_SockFromZ2.java
@@ -0,0 +1,117 @@
+package class176;
+
+// 小Z的袜子，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1494
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 50001;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//
+//int bi[MAXN];
+//int cnt[MAXN];
+//long long sum = 0;
+//long long ans1[MAXN];
+//long long ans2[MAXN];
+//
+//bool QueryCmp1(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    return a.r < b.r;
+//}
+//
+//bool QueryCmp2(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    }
+//    return a.r > b.r;
+//}
+//
+//long long gcd(long long a, long long b) {
+//    return b == 0 ? a : gcd(b, a % b);
+//}
+//
+//void del(int idx) {
+//    sum -= cnt[arr[idx]] * cnt[arr[idx]];
+//    cnt[arr[idx]]--;
+//    sum += cnt[arr[idx]] * cnt[arr[idx]];
+//}
+//
+//void add(int idx) {
+//    sum -= cnt[arr[idx]] * cnt[arr[idx]];
+//    cnt[arr[idx]]++;
+//    sum += cnt[arr[idx]] * cnt[arr[idx]];
+//}
+//
+//void prepare() {
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp2);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
+//        while (winl > jobl) {
+//            add(--winl);
+//        }
+//        while (winr < jobr) {
+//            add(++winr);
+//        }
+//        while (winr > jobr) {
+//            del(winr--);
+//        }
+//        if (jobl == jobr) {
+//            ans1[id] = 0;
+//            ans2[id] = 1;
+//        } else {
+//            ans1[id] = sum - (jobr - jobl + 1);
+//            ans2[id] = 1LL * (jobr - jobl + 1) * (jobr - jobl);
+//            long long g = gcd(ans1[id], ans2[id]);
+//            ans1[id] /= g;
+//            ans2[id] /= g;
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l;
+//        cin >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans1[i] << '/' << ans2[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 336f780a7ab066ce3dd025a6b439187cb1fb3327 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Aug 2025 12:02:35 +0800
Subject: [PATCH 1259/1712] modify code

---
 src/class176/Code03_SockFromZ2.java    |   2 +-
 src/class176/Code04_BloodyString1.java | 196 +++++++++++++++++++++++++
 src/class176/Code04_BloodyString2.java | 137 +++++++++++++++++
 3 files changed, 334 insertions(+), 1 deletion(-)
 create mode 100644 src/class176/Code04_BloodyString1.java
 create mode 100644 src/class176/Code04_BloodyString2.java

diff --git a/src/class176/Code03_SockFromZ2.java b/src/class176/Code03_SockFromZ2.java
index 8a92a19e6..582f746fd 100644
--- a/src/class176/Code03_SockFromZ2.java
+++ b/src/class176/Code03_SockFromZ2.java
@@ -1,6 +1,6 @@
 package class176;
 
-// 小Z的袜子，java版
+// 小Z的袜子，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P1494
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
new file mode 100644
index 000000000..40a26d17a
--- /dev/null
+++ b/src/class176/Code04_BloodyString1.java
@@ -0,0 +1,196 @@
+package class176;
+
+// 大爷的字符串题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3709
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code04_BloodyString1 {
+
+	// 莫队经典排序
+	public static class QueryCmp1 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	// 莫队奇偶排序
+	public static class QueryCmp2 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			}
+			return b[1] - a[1];
+		}
+
+	}
+
+	public static QueryCmp1 cmp1 = new QueryCmp1();
+	public static QueryCmp2 cmp2 = new QueryCmp2();
+
+	public static int MAXN = 200001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cnt1 = new int[MAXN];
+	public static int[] cnt2 = new int[MAXN];
+	public static int maxCnt = 0;
+	public static int[] ans = new int[MAXN];
+
+	public static int kth(int len, int num) {
+		int left = 1, right = len, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static void del(int idx) {
+		int num = arr[idx];
+		if (cnt1[num] == maxCnt && cnt2[cnt1[num]] == 1) {
+			maxCnt--;
+		}
+		cnt2[cnt1[num]]--;
+		cnt2[--cnt1[num]]++;
+	}
+
+	public static void add(int idx) {
+		int num = arr[idx];
+		cnt2[cnt1[num]]--;
+		cnt2[++cnt1[num]]++;
+		maxCnt = Math.max(maxCnt, cnt1[num]);
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		int len = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(len, arr[i]);
+		}
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		// Arrays.sort(query, 1, m + 1, cmp1);
+		Arrays.sort(query, 1, m + 1, cmp2);
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			// 为了滑动窗口时，不让词频变成负数
+			// 先执行关于加的，再执行关于减的
+			while (winl > jobl) {
+				add(--winl);
+			}
+			while (winr < jobr) {
+				add(++winr);
+			}
+			while (winl < jobl) {
+				del(winl++);
+			}
+			while (winr > jobr) {
+				del(winr--);
+			}
+			ans[query[i][2]] = maxCnt;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(-ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class176/Code04_BloodyString2.java b/src/class176/Code04_BloodyString2.java
new file mode 100644
index 000000000..c62789be8
--- /dev/null
+++ b/src/class176/Code04_BloodyString2.java
@@ -0,0 +1,137 @@
+package class176;
+
+// 大爷的字符串题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3709
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 200001;
+//int n, m;
+//int arr[MAXN];
+//int sorted[MAXN];
+//Query query[MAXN];
+//
+//int bi[MAXN];
+//int cnt1[MAXN];
+//int cnt2[MAXN];
+//int maxCnt = 0;
+//int ans[MAXN];
+//
+//bool QueryCmp1(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    return a.r < b.r;
+//}
+//
+//bool QueryCmp2(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    }
+//    return a.r > b.r;
+//}
+//
+//int kth(int len, int num) {
+//    int left = 1, right = len, mid, ret = 0;
+//    while (left <= right) {
+//        mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//        	ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//void del(int idx) {
+//    int num = arr[idx];
+//    if (cnt1[num] == maxCnt && cnt2[cnt1[num]] == 1) {
+//        maxCnt--;
+//    }
+//    cnt2[cnt1[num]]--;
+//    cnt2[--cnt1[num]]++;
+//}
+//
+//void add(int idx) {
+//    int num = arr[idx];
+//    cnt2[cnt1[num]]--;
+//    cnt2[++cnt1[num]]++;
+//    if (cnt1[num] > maxCnt) {
+//        maxCnt = cnt1[num];
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    int len = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[len] != sorted[i]) {
+//            sorted[++len] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(len, arr[i]);
+//    }
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp2);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        while (winl > jobl) {
+//            add(--winl);
+//        }
+//        while (winr < jobr) {
+//            add(++winr);
+//        }
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
+//        while (winr > jobr) {
+//            del(winr--);
+//        }
+//        ans[query[i].id] = maxCnt;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l;
+//        cin >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << -ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 5d1f81f48de2fda22499e57dab4cf8d3eb624755 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 13 Aug 2025 12:04:30 +0800
Subject: [PATCH 1260/1712] modify code

---
 src/class176/Code04_BloodyString1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index 40a26d17a..9a672f342 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -115,7 +115,7 @@ public static void compute() {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
 			// 为了滑动窗口时，不让词频变成负数
-			// 先执行关于加的，再执行关于减的
+			// 先执行加词频的操作，再执行减词频的操作
 			while (winl > jobl) {
 				add(--winl);
 			}

From cc277146a067d2095ab9b8e25d65f78128db4261 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 14 Aug 2025 14:56:37 +0800
Subject: [PATCH 1261/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java |   6 +-
 src/class176/Code01_MoAlgorithm2.java |   6 +-
 src/class176/Code02_QueryFromB1.java  |   6 +-
 src/class176/Code02_QueryFromB2.java  |   6 +-
 src/class176/Code03_SockFromZ1.java   |   6 +-
 src/class176/Code03_SockFromZ2.java   |   6 +-
 src/class176/Code05_XorSequence1.java | 187 ++++++++++++++++++++++++++
 7 files changed, 205 insertions(+), 18 deletions(-)
 create mode 100644 src/class176/Code05_XorSequence1.java

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index 1954f09ce..898f997f3 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -83,15 +83,15 @@ public static void compute() {
 		for (int i = 1; i <= q; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
-			while (winl < jobl) {
-				del(winl++);
-			}
 			while (winl > jobl) {
 				add(--winl);
 			}
 			while (winr < jobr) {
 				add(++winr);
 			}
+			while (winl < jobl) {
+				del(winl++);
+			}
 			while (winr > jobr) {
 				del(winr--);
 			}
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index ae602430b..994a89dc1 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -67,15 +67,15 @@
 //    for (int i = 1; i <= q; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
-//        while (winl < jobl) {
-//            del(winl++);
-//        }
 //        while (winl > jobl) {
 //            add(--winl);
 //        }
 //        while (winr < jobr) {
 //            add(++winr);
 //        }
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
 //        while (winr > jobr) {
 //            del(winr--);
 //        }
diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
index 9b0db1917..27ffb096f 100644
--- a/src/class176/Code02_QueryFromB1.java
+++ b/src/class176/Code02_QueryFromB1.java
@@ -79,15 +79,15 @@ public static void compute() {
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
-			while (winl < jobl) {
-				del(winl++);
-			}
 			while (winl > jobl) {
 				add(--winl);
 			}
 			while (winr < jobr) {
 				add(++winr);
 			}
+			while (winl < jobl) {
+				del(winl++);
+			}
 			while (winr > jobr) {
 				del(winr--);
 			}
diff --git a/src/class176/Code02_QueryFromB2.java b/src/class176/Code02_QueryFromB2.java
index e048b35b9..6f4d2aeda 100644
--- a/src/class176/Code02_QueryFromB2.java
+++ b/src/class176/Code02_QueryFromB2.java
@@ -63,15 +63,15 @@
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
-//        while (winl < jobl) {
-//            del(winl++);
-//        }
 //        while (winl > jobl) {
 //            add(--winl);
 //        }
 //        while (winr < jobr) {
 //            add(++winr);
 //        }
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
 //        while (winr > jobr) {
 //            del(winr--);
 //        }
diff --git a/src/class176/Code03_SockFromZ1.java b/src/class176/Code03_SockFromZ1.java
index 09e678a6c..ecb502855 100644
--- a/src/class176/Code03_SockFromZ1.java
+++ b/src/class176/Code03_SockFromZ1.java
@@ -90,15 +90,15 @@ public static void compute() {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
 			int id = query[i][2];
-			while (winl < jobl) {
-				del(winl++);
-			}
 			while (winl > jobl) {
 				add(--winl);
 			}
 			while (winr < jobr) {
 				add(++winr);
 			}
+			while (winl < jobl) {
+				del(winl++);
+			}
 			while (winr > jobr) {
 				del(winr--);
 			}
diff --git a/src/class176/Code03_SockFromZ2.java b/src/class176/Code03_SockFromZ2.java
index 582f746fd..5d890c155 100644
--- a/src/class176/Code03_SockFromZ2.java
+++ b/src/class176/Code03_SockFromZ2.java
@@ -71,15 +71,15 @@
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
 //        int id = query[i].id;
-//        while (winl < jobl) {
-//            del(winl++);
-//        }
 //        while (winl > jobl) {
 //            add(--winl);
 //        }
 //        while (winr < jobr) {
 //            add(++winr);
 //        }
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
 //        while (winr > jobr) {
 //            del(winr--);
 //        }
diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
new file mode 100644
index 000000000..c4abbe435
--- /dev/null
+++ b/src/class176/Code05_XorSequence1.java
@@ -0,0 +1,187 @@
+package class176;
+
+// 异或序列，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4462
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code05_XorSequence1 {
+
+	// 莫队经典排序
+	public static class QueryCmp1 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	// 莫队奇偶排序
+	public static class QueryCmp2 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return a[0] - b[0];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			}
+			return b[1] - a[1];
+		}
+
+	}
+
+	public static QueryCmp1 cmp1 = new QueryCmp1();
+	public static QueryCmp2 cmp2 = new QueryCmp2();
+
+	public static int MAXN = 100001;
+	public static int MAXK = 1 << 20;
+	public static int n, m, k;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] pre = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	public static long[] cnt = new long[MAXK];
+	public static long[] ans = new long[MAXN];
+	public static long cur;
+
+	public static void del(int idx) {
+		int xor = pre[idx];
+		if (k != 0) {
+			cur -= cnt[xor] * cnt[xor ^ k];
+		} else {
+			cur -= (cnt[xor] * (cnt[xor] - 1)) >> 1;
+		}
+		cnt[xor]--;
+		if (k != 0) {
+			cur += cnt[xor] * cnt[xor ^ k];
+		} else {
+			cur += (cnt[xor] * (cnt[xor] - 1)) >> 1;
+		}
+	}
+
+	public static void add(int idx) {
+		int xor = pre[idx];
+		if (k != 0) {
+			cur -= cnt[xor] * cnt[xor ^ k];
+		} else {
+			cur -= (cnt[xor] * (cnt[xor] - 1)) >> 1;
+		}
+		cnt[xor]++;
+		if (k != 0) {
+			cur += cnt[xor] * cnt[xor ^ k];
+		} else {
+			cur += (cnt[xor] * (cnt[xor] - 1)) >> 1;
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			pre[i] = pre[i - 1] ^ arr[i];
+		}
+		int blen = Math.max(1, (int) Math.sqrt(n));
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		// Arrays.sort(query, 1, m + 1, cmp1);
+		Arrays.sort(query, 1, m + 1, cmp2);
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			// 左边界要-1
+			int jobl = query[i][0] - 1;
+			int jobr = query[i][1];
+			while (winl > jobl) {
+				add(--winl);
+			}
+			while (winr < jobr) {
+				add(++winr);
+			}
+			while (winl < jobl) {
+				del(winl++);
+			}
+			while (winr > jobr) {
+				del(winr--);
+			}
+			ans[query[i][2]] = cur;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 03f8bea9c0c0d38bd9e99f0c2ca6650aa1d9c997 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 14 Aug 2025 15:11:33 +0800
Subject: [PATCH 1262/1712] modify code

---
 src/class176/Code05_XorSequence1.java |  26 +++---
 src/class176/Code05_XorSequence2.java | 126 ++++++++++++++++++++++++++
 2 files changed, 139 insertions(+), 13 deletions(-)
 create mode 100644 src/class176/Code05_XorSequence2.java

diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index c4abbe435..a880b6991 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -59,32 +59,32 @@ public int compare(int[] a, int[] b) {
 	public static long cur;
 
 	public static void del(int idx) {
-		int xor = pre[idx];
+		int x = pre[idx];
 		if (k != 0) {
-			cur -= cnt[xor] * cnt[xor ^ k];
+			cur -= cnt[x] * cnt[x ^ k];
 		} else {
-			cur -= (cnt[xor] * (cnt[xor] - 1)) >> 1;
+			cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
-		cnt[xor]--;
+		cnt[x]--;
 		if (k != 0) {
-			cur += cnt[xor] * cnt[xor ^ k];
+			cur += cnt[x] * cnt[x ^ k];
 		} else {
-			cur += (cnt[xor] * (cnt[xor] - 1)) >> 1;
+			cur += (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
 	}
 
 	public static void add(int idx) {
-		int xor = pre[idx];
+		int x = pre[idx];
 		if (k != 0) {
-			cur -= cnt[xor] * cnt[xor ^ k];
+			cur -= cnt[x] * cnt[x ^ k];
 		} else {
-			cur -= (cnt[xor] * (cnt[xor] - 1)) >> 1;
+			cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
-		cnt[xor]++;
+		cnt[x]++;
 		if (k != 0) {
-			cur += cnt[xor] * cnt[xor ^ k];
+			cur += cnt[x] * cnt[x ^ k];
 		} else {
-			cur += (cnt[xor] * (cnt[xor] - 1)) >> 1;
+			cur += (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
 	}
 
@@ -92,7 +92,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			pre[i] = pre[i - 1] ^ arr[i];
 		}
-		int blen = Math.max(1, (int) Math.sqrt(n));
+		int blen = (int) Math.sqrt(n);
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
diff --git a/src/class176/Code05_XorSequence2.java b/src/class176/Code05_XorSequence2.java
new file mode 100644
index 000000000..bffd02b3f
--- /dev/null
+++ b/src/class176/Code05_XorSequence2.java
@@ -0,0 +1,126 @@
+package class176;
+
+// 异或序列，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4462
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXK = 1 << 20;
+//int n, m, k;
+//int arr[MAXN];
+//Query query[MAXN];
+//
+//int pre[MAXN];
+//int bi[MAXN];
+//
+//long long cnt[MAXK];
+//long long ans[MAXN];
+//long long cur;
+//
+//bool QueryCmp1(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    return a.r < b.r;
+//}
+//
+//bool QueryCmp2(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return a.l < b.l;
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    }
+//    return a.r > b.r;
+//}
+//
+//void del(int idx) {
+//    int x = pre[idx];
+//    if (k != 0) {
+//        cur -= cnt[x] * cnt[x ^ k];
+//    } else {
+//        cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
+//    }
+//    cnt[x]--;
+//    if (k != 0) {
+//        cur += cnt[x] * cnt[x ^ k];
+//    } else {
+//        cur += (cnt[x] * (cnt[x] - 1)) >> 1;
+//    }
+//}
+//
+//void add(int idx) {
+//    int x = pre[idx];
+//    if (k != 0) {
+//        cur -= cnt[x] * cnt[x ^ k];
+//    } else {
+//        cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
+//    }
+//    cnt[x]++;
+//    if (k != 0) {
+//        cur += cnt[x] * cnt[x ^ k];
+//    } else {
+//        cur += (cnt[x] * (cnt[x] - 1)) >> 1;
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        pre[i] = pre[i - 1] ^ arr[i];
+//    }
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp2);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l - 1;
+//        int jobr = query[i].r;
+//        while (winl > jobl) {
+//            add(--winl);
+//        }
+//        while (winr < jobr) {
+//            add(++winr);
+//        }
+//        while (winl < jobl) {
+//            del(winl++);
+//        }
+//        while (winr > jobr) {
+//            del(winr--);
+//        }
+//        ans[query[i].id] = cur;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l;
+//        cin >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 2791e44f07927c5a5296f99989d1dc5d98ef3d56 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 10:13:29 +0800
Subject: [PATCH 1263/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index 898f997f3..00e560209 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -19,7 +19,7 @@ public static class QueryCmp1 implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
+				return bi[a[0]] - bi[b[0]];
 			}
 			return a[1] - b[1];
 		}
@@ -32,7 +32,7 @@ public static class QueryCmp2 implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
+				return bi[a[0]] - bi[b[0]];
 			}
 			if ((bi[a[0]] & 1) == 1) {
 				return a[1] - b[1];
@@ -42,8 +42,8 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static QueryCmp1 cmp1 = new QueryCmp1();
-	public static QueryCmp2 cmp2 = new QueryCmp2();
+	public static QueryCmp1 mo1 = new QueryCmp1();
+	public static QueryCmp2 mo2 = new QueryCmp2();
 
 	public static int MAXN = 30001;
 	public static int MAXV = 1000001;
@@ -75,7 +75,7 @@ public static void prepare() {
 			bi[i] = (i - 1) / blen + 1;
 		}
 		// Arrays.sort(query, 1, q + 1, cmp1);
-		Arrays.sort(query, 1, q + 1, cmp2);
+		Arrays.sort(query, 1, q + 1, mo2);
 	}
 
 	public static void compute() {

From a2731cf727009c04a4dd3670f80b4b3bd308b8fd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 10:27:08 +0800
Subject: [PATCH 1264/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java |  8 +++-----
 src/class176/Code01_MoAlgorithm2.java |  5 +++--
 src/class176/Code02_QueryFromB1.java  | 27 +++------------------------
 src/class176/Code02_QueryFromB2.java  | 16 +++-------------
 4 files changed, 12 insertions(+), 44 deletions(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index 00e560209..ae59f75db 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -2,6 +2,7 @@
 
 // 普通莫队模版题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/SP3267
+// 测试链接 : https://www.spoj.com/problems/DQUERY/
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
@@ -42,9 +43,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static QueryCmp1 mo1 = new QueryCmp1();
-	public static QueryCmp2 mo2 = new QueryCmp2();
-
 	public static int MAXN = 30001;
 	public static int MAXV = 1000001;
 	public static int MAXQ = 200001;
@@ -74,8 +72,8 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		// Arrays.sort(query, 1, q + 1, cmp1);
-		Arrays.sort(query, 1, q + 1, mo2);
+		Arrays.sort(query, 1, q + 1, new QueryCmp1());
+		// Arrays.sort(query, 1, q + 1, new QueryCmp2());
 	}
 
 	public static void compute() {
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index 994a89dc1..9dcc3177d 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -2,6 +2,7 @@
 
 // 普通莫队模版题，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/SP3267
+// 测试链接 : https://www.spoj.com/problems/DQUERY/
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
@@ -27,14 +28,14 @@
 //
 //bool QueryCmp1(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
+//        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
 //bool QueryCmp2(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
+//        return bi[a.l] < bi[b.l];
 //    }
 //    if ((bi[a.l] & 1) == 1) {
 //        return a.r < b.r;
diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
index 27ffb096f..f655ad890 100644
--- a/src/class176/Code02_QueryFromB1.java
+++ b/src/class176/Code02_QueryFromB1.java
@@ -13,38 +13,18 @@
 
 public class Code02_QueryFromB1 {
 
-	// 莫队经典排序
-	public static class QueryCmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
+				return bi[a[0]] - bi[b[0]];
 			}
 			return a[1] - b[1];
 		}
 
 	}
 
-	// 莫队奇偶排序
-	public static class QueryCmp2 implements Comparator<int[]> {
-
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
-			}
-			if ((bi[a[0]] & 1) == 1) {
-				return a[1] - b[1];
-			}
-			return b[1] - a[1];
-		}
-
-	}
-
-	public static QueryCmp1 cmp1 = new QueryCmp1();
-	public static QueryCmp2 cmp2 = new QueryCmp2();
-
 	public static int MAXN = 50001;
 	public static int n, m, k;
 	public static int[] arr = new int[MAXN];
@@ -70,8 +50,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		// Arrays.sort(query, 1, m + 1, cmp1);
-		Arrays.sort(query, 1, m + 1, cmp2);
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
 	public static void compute() {
diff --git a/src/class176/Code02_QueryFromB2.java b/src/class176/Code02_QueryFromB2.java
index 6f4d2aeda..7d951a49a 100644
--- a/src/class176/Code02_QueryFromB2.java
+++ b/src/class176/Code02_QueryFromB2.java
@@ -23,23 +23,13 @@
 //long long sum = 0;
 //long long ans[MAXN];
 //
-//bool QueryCmp1(Query &a, Query &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
+//        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
-//bool QueryCmp2(Query &a, Query &b) {
-//    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
-//    }
-//    if ((bi[a.l] & 1) == 1) {
-//        return a.r < b.r;
-//    }
-//    return a.r > b.r;
-//}
-//
 //void del(int idx) {
 //    sum -= 2 * cnt[arr[idx]] - 1;
 //    cnt[arr[idx]]--;
@@ -55,7 +45,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query + 1, query + m + 1, QueryCmp2);
+//    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //
 //void compute() {

From c1260072e7726122c4224acc772e34994bc567e4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 10:36:43 +0800
Subject: [PATCH 1265/1712] modify code

---
 src/class176/Code03_SockFromZ1.java    | 27 +++---------------------
 src/class176/Code03_SockFromZ2.java    | 16 +++-----------
 src/class176/Code04_BloodyString1.java | 29 +++-----------------------
 src/class176/Code04_BloodyString2.java | 16 +++-----------
 src/class176/Code05_XorSequence1.java  | 27 +++---------------------
 src/class176/Code05_XorSequence2.java  | 16 +++-----------
 6 files changed, 18 insertions(+), 113 deletions(-)

diff --git a/src/class176/Code03_SockFromZ1.java b/src/class176/Code03_SockFromZ1.java
index ecb502855..679c76831 100644
--- a/src/class176/Code03_SockFromZ1.java
+++ b/src/class176/Code03_SockFromZ1.java
@@ -16,38 +16,18 @@
 
 public class Code03_SockFromZ1 {
 
-	// 莫队经典排序
-	public static class QueryCmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
+				return bi[a[0]] - bi[b[0]];
 			}
 			return a[1] - b[1];
 		}
 
 	}
 
-	// 莫队奇偶排序
-	public static class QueryCmp2 implements Comparator<int[]> {
-
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
-			}
-			if ((bi[a[0]] & 1) == 1) {
-				return a[1] - b[1];
-			}
-			return b[1] - a[1];
-		}
-
-	}
-
-	public static QueryCmp1 cmp1 = new QueryCmp1();
-	public static QueryCmp2 cmp2 = new QueryCmp2();
-
 	public static int MAXN = 50001;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
@@ -80,8 +60,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		// Arrays.sort(query, 1, m + 1, cmp1);
-		Arrays.sort(query, 1, m + 1, cmp2);
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
 	public static void compute() {
diff --git a/src/class176/Code03_SockFromZ2.java b/src/class176/Code03_SockFromZ2.java
index 5d890c155..42439abc1 100644
--- a/src/class176/Code03_SockFromZ2.java
+++ b/src/class176/Code03_SockFromZ2.java
@@ -24,23 +24,13 @@
 //long long ans1[MAXN];
 //long long ans2[MAXN];
 //
-//bool QueryCmp1(Query &a, Query &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
+//        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
-//bool QueryCmp2(Query &a, Query &b) {
-//    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
-//    }
-//    if ((bi[a.l] & 1) == 1) {
-//        return a.r < b.r;
-//    }
-//    return a.r > b.r;
-//}
-//
 //long long gcd(long long a, long long b) {
 //    return b == 0 ? a : gcd(b, a % b);
 //}
@@ -62,7 +52,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query + 1, query + m + 1, QueryCmp2);
+//    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //
 //void compute() {
diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index 9a672f342..2e8a6edfc 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -13,38 +13,18 @@
 
 public class Code04_BloodyString1 {
 
-	// 莫队经典排序
-	public static class QueryCmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
+				return bi[a[0]] - bi[b[0]];
 			}
 			return a[1] - b[1];
 		}
 
 	}
 
-	// 莫队奇偶排序
-	public static class QueryCmp2 implements Comparator<int[]> {
-
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
-			}
-			if ((bi[a[0]] & 1) == 1) {
-				return a[1] - b[1];
-			}
-			return b[1] - a[1];
-		}
-
-	}
-
-	public static QueryCmp1 cmp1 = new QueryCmp1();
-	public static QueryCmp2 cmp2 = new QueryCmp2();
-
 	public static int MAXN = 200001;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
@@ -105,8 +85,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		// Arrays.sort(query, 1, m + 1, cmp1);
-		Arrays.sort(query, 1, m + 1, cmp2);
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
 	public static void compute() {
@@ -114,8 +93,6 @@ public static void compute() {
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
-			// 为了滑动窗口时，不让词频变成负数
-			// 先执行加词频的操作，再执行减词频的操作
 			while (winl > jobl) {
 				add(--winl);
 			}
diff --git a/src/class176/Code04_BloodyString2.java b/src/class176/Code04_BloodyString2.java
index c62789be8..785bd6a5c 100644
--- a/src/class176/Code04_BloodyString2.java
+++ b/src/class176/Code04_BloodyString2.java
@@ -25,23 +25,13 @@
 //int maxCnt = 0;
 //int ans[MAXN];
 //
-//bool QueryCmp1(Query &a, Query &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
+//        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
-//bool QueryCmp2(Query &a, Query &b) {
-//    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
-//    }
-//    if ((bi[a.l] & 1) == 1) {
-//        return a.r < b.r;
-//    }
-//    return a.r > b.r;
-//}
-//
 //int kth(int len, int num) {
 //    int left = 1, right = len, mid, ret = 0;
 //    while (left <= right) {
@@ -92,7 +82,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query + 1, query + m + 1, QueryCmp2);
+//    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //
 //void compute() {
diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index a880b6991..c832fb0b7 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -13,38 +13,18 @@
 
 public class Code05_XorSequence1 {
 
-	// 莫队经典排序
-	public static class QueryCmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
+				return bi[a[0]] - bi[b[0]];
 			}
 			return a[1] - b[1];
 		}
 
 	}
 
-	// 莫队奇偶排序
-	public static class QueryCmp2 implements Comparator<int[]> {
-
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return a[0] - b[0];
-			}
-			if ((bi[a[0]] & 1) == 1) {
-				return a[1] - b[1];
-			}
-			return b[1] - a[1];
-		}
-
-	}
-
-	public static QueryCmp1 cmp1 = new QueryCmp1();
-	public static QueryCmp2 cmp2 = new QueryCmp2();
-
 	public static int MAXN = 100001;
 	public static int MAXK = 1 << 20;
 	public static int n, m, k;
@@ -96,8 +76,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		// Arrays.sort(query, 1, m + 1, cmp1);
-		Arrays.sort(query, 1, m + 1, cmp2);
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
 	public static void compute() {
diff --git a/src/class176/Code05_XorSequence2.java b/src/class176/Code05_XorSequence2.java
index bffd02b3f..e929be4f9 100644
--- a/src/class176/Code05_XorSequence2.java
+++ b/src/class176/Code05_XorSequence2.java
@@ -26,23 +26,13 @@
 //long long ans[MAXN];
 //long long cur;
 //
-//bool QueryCmp1(Query &a, Query &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
+//        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
-//bool QueryCmp2(Query &a, Query &b) {
-//    if (bi[a.l] != bi[b.l]) {
-//        return a.l < b.l;
-//    }
-//    if ((bi[a.l] & 1) == 1) {
-//        return a.r < b.r;
-//    }
-//    return a.r > b.r;
-//}
-//
 //void del(int idx) {
 //    int x = pre[idx];
 //    if (k != 0) {
@@ -81,7 +71,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query + 1, query + m + 1, QueryCmp2);
+//    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //
 //void compute() {

From 152326aaf600687691d5ccd011ca309d42f646d3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 10:42:18 +0800
Subject: [PATCH 1266/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index ae59f75db..c7e8adcda 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -27,7 +27,7 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	// 莫队奇偶排序
+	// 莫队奇偶排序，玄学优化
 	public static class QueryCmp2 implements Comparator<int[]> {
 
 		@Override
@@ -72,8 +72,8 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		Arrays.sort(query, 1, q + 1, new QueryCmp1());
-		// Arrays.sort(query, 1, q + 1, new QueryCmp2());
+		// Arrays.sort(query, 1, q + 1, new QueryCmp1());
+		Arrays.sort(query, 1, q + 1, new QueryCmp2());
 	}
 
 	public static void compute() {

From 6120cc87f0c47c60b08b78f4dd23d4b5c8a59de1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 14:09:55 +0800
Subject: [PATCH 1267/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java    |  16 +-
 src/class176/Code01_MoAlgorithm2.java    |  16 +-
 src/class176/Code02_QueryFromB1.java     |  20 +--
 src/class176/Code02_QueryFromB2.java     |  20 +--
 src/class176/Code03_SockFromZ1.java      |  24 +--
 src/class176/Code03_SockFromZ2.java      |  24 +--
 src/class176/Code04_BloodyString1.java   |  14 +-
 src/class176/Code04_BloodyString2.java   |  14 +-
 src/class176/Code05_XorSequence1.java    |  14 +-
 src/class176/Code05_XorSequence2.java    |  14 +-
 src/class176/Code06_CountingColors1.java | 206 +++++++++++++++++++++++
 11 files changed, 290 insertions(+), 92 deletions(-)
 create mode 100644 src/class176/Code06_CountingColors1.java

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index c7e8adcda..f3398b433 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -55,14 +55,14 @@ public int compare(int[] a, int[] b) {
 	public static int kind = 0;
 	public static int[] ans = new int[MAXQ];
 
-	public static void del(int idx) {
-		if (--cnt[arr[idx]] == 0) {
+	public static void del(int num) {
+		if (--cnt[num] == 0) {
 			kind--;
 		}
 	}
 
-	public static void add(int idx) {
-		if (++cnt[arr[idx]] == 1) {
+	public static void add(int num) {
+		if (++cnt[num] == 1) {
 			kind++;
 		}
 	}
@@ -82,16 +82,16 @@ public static void compute() {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
 			while (winl > jobl) {
-				add(--winl);
+				add(arr[--winl]);
 			}
 			while (winr < jobr) {
-				add(++winr);
+				add(arr[++winr]);
 			}
 			while (winl < jobl) {
-				del(winl++);
+				del(arr[winl++]);
 			}
 			while (winr > jobr) {
-				del(winr--);
+				del(arr[winr--]);
 			}
 			ans[query[i][2]] = kind;
 		}
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index 9dcc3177d..16209b02c 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -43,14 +43,14 @@
 //    return a.r > b.r;
 //}
 //
-//void del(int idx) {
-//    if (--cnt[arr[idx]] == 0) {
+//void del(int num) {
+//    if (--cnt[num] == 0) {
 //        kind--;
 //    }
 //}
 //
-//void add(int idx) {
-//    if (++cnt[arr[idx]] == 1) {
+//void add(int num) {
+//    if (++cnt[num] == 1) {
 //        kind++;
 //    }
 //}
@@ -69,16 +69,16 @@
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
 //        while (winl > jobl) {
-//            add(--winl);
+//            add(arr[--winl]);
 //        }
 //        while (winr < jobr) {
-//            add(++winr);
+//            add(arr[++winr]);
 //        }
 //        while (winl < jobl) {
-//            del(winl++);
+//            del(arr[winl++]);
 //        }
 //        while (winr > jobr) {
-//            del(winr--);
+//            del(arr[winr--]);
 //        }
 //        ans[query[i].id] = kind;
 //    }
diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
index f655ad890..2c1e0b753 100644
--- a/src/class176/Code02_QueryFromB1.java
+++ b/src/class176/Code02_QueryFromB1.java
@@ -35,14 +35,14 @@ public int compare(int[] a, int[] b) {
 	public static long sum = 0;
 	public static long[] ans = new long[MAXN];
 
-	public static void del(int idx) {
-		sum -= 2 * cnt[arr[idx]] - 1;
-		cnt[arr[idx]]--;
+	public static void del(int num) {
+		sum -= 2 * cnt[num] - 1;
+		cnt[num]--;
 	}
 
-	public static void add(int idx) {
-		sum += 2 * cnt[arr[idx]] + 1;
-		cnt[arr[idx]]++;
+	public static void add(int num) {
+		sum += 2 * cnt[num] + 1;
+		cnt[num]++;
 	}
 
 	public static void prepare() {
@@ -59,16 +59,16 @@ public static void compute() {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
 			while (winl > jobl) {
-				add(--winl);
+				add(arr[--winl]);
 			}
 			while (winr < jobr) {
-				add(++winr);
+				add(arr[++winr]);
 			}
 			while (winl < jobl) {
-				del(winl++);
+				del(arr[winl++]);
 			}
 			while (winr > jobr) {
-				del(winr--);
+				del(arr[winr--]);
 			}
 			ans[query[i][2]] = sum;
 		}
diff --git a/src/class176/Code02_QueryFromB2.java b/src/class176/Code02_QueryFromB2.java
index 7d951a49a..876b10460 100644
--- a/src/class176/Code02_QueryFromB2.java
+++ b/src/class176/Code02_QueryFromB2.java
@@ -30,14 +30,14 @@
 //    return a.r < b.r;
 //}
 //
-//void del(int idx) {
-//    sum -= 2 * cnt[arr[idx]] - 1;
-//    cnt[arr[idx]]--;
+//void del(int num) {
+//    sum -= 2 * cnt[num] - 1;
+//    cnt[num]--;
 //}
 //
-//void add(int idx) {
-//    sum += 2 * cnt[arr[idx]] + 1;
-//    cnt[arr[idx]]++;
+//void add(int num) {
+//    sum += 2 * cnt[num] + 1;
+//    cnt[num]++;
 //}
 //
 //void prepare() {
@@ -54,16 +54,16 @@
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
 //        while (winl > jobl) {
-//            add(--winl);
+//            add(arr[--winl]);
 //        }
 //        while (winr < jobr) {
-//            add(++winr);
+//            add(arr[++winr]);
 //        }
 //        while (winl < jobl) {
-//            del(winl++);
+//            del(arr[winl++]);
 //        }
 //        while (winr > jobr) {
-//            del(winr--);
+//            del(arr[winr--]);
 //        }
 //        ans[query[i].id] = sum;
 //    }
diff --git a/src/class176/Code03_SockFromZ1.java b/src/class176/Code03_SockFromZ1.java
index 679c76831..897fb599a 100644
--- a/src/class176/Code03_SockFromZ1.java
+++ b/src/class176/Code03_SockFromZ1.java
@@ -43,16 +43,16 @@ public static long gcd(long a, long b) {
 		return b == 0 ? a : gcd(b, a % b);
 	}
 
-	public static void del(int idx) {
-		sum -= cnt[arr[idx]] * cnt[arr[idx]];
-		cnt[arr[idx]]--;
-		sum += cnt[arr[idx]] * cnt[arr[idx]];
+	public static void del(int num) {
+		sum -= cnt[num] * cnt[num];
+		cnt[num]--;
+		sum += cnt[num] * cnt[num];
 	}
 
-	public static void add(int idx) {
-		sum -= cnt[arr[idx]] * cnt[arr[idx]];
-		cnt[arr[idx]]++;
-		sum += cnt[arr[idx]] * cnt[arr[idx]];
+	public static void add(int num) {
+		sum -= cnt[num] * cnt[num];
+		cnt[num]++;
+		sum += cnt[num] * cnt[num];
 	}
 
 	public static void prepare() {
@@ -70,16 +70,16 @@ public static void compute() {
 			int jobr = query[i][1];
 			int id = query[i][2];
 			while (winl > jobl) {
-				add(--winl);
+				add(arr[--winl]);
 			}
 			while (winr < jobr) {
-				add(++winr);
+				add(arr[++winr]);
 			}
 			while (winl < jobl) {
-				del(winl++);
+				del(arr[winl++]);
 			}
 			while (winr > jobr) {
-				del(winr--);
+				del(arr[winr--]);
 			}
 			if (jobl == jobr) {
 				ans1[id] = 0;
diff --git a/src/class176/Code03_SockFromZ2.java b/src/class176/Code03_SockFromZ2.java
index 42439abc1..b4fddadb8 100644
--- a/src/class176/Code03_SockFromZ2.java
+++ b/src/class176/Code03_SockFromZ2.java
@@ -35,16 +35,16 @@
 //    return b == 0 ? a : gcd(b, a % b);
 //}
 //
-//void del(int idx) {
-//    sum -= cnt[arr[idx]] * cnt[arr[idx]];
-//    cnt[arr[idx]]--;
-//    sum += cnt[arr[idx]] * cnt[arr[idx]];
+//void del(int num) {
+//    sum -= cnt[num] * cnt[num];
+//    cnt[num]--;
+//    sum += cnt[num] * cnt[num];
 //}
 //
-//void add(int idx) {
-//    sum -= cnt[arr[idx]] * cnt[arr[idx]];
-//    cnt[arr[idx]]++;
-//    sum += cnt[arr[idx]] * cnt[arr[idx]];
+//void add(int num) {
+//    sum -= cnt[num] * cnt[num];
+//    cnt[num]++;
+//    sum += cnt[num] * cnt[num];
 //}
 //
 //void prepare() {
@@ -62,16 +62,16 @@
 //        int jobr = query[i].r;
 //        int id = query[i].id;
 //        while (winl > jobl) {
-//            add(--winl);
+//            add(arr[--winl]);
 //        }
 //        while (winr < jobr) {
-//            add(++winr);
+//            add(arr[++winr]);
 //        }
 //        while (winl < jobl) {
-//            del(winl++);
+//            del(arr[winl++]);
 //        }
 //        while (winr > jobr) {
-//            del(winr--);
+//            del(arr[winr--]);
 //        }
 //        if (jobl == jobr) {
 //            ans1[id] = 0;
diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index 2e8a6edfc..ed5b0f270 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -51,8 +51,7 @@ public static int kth(int len, int num) {
 		return ret;
 	}
 
-	public static void del(int idx) {
-		int num = arr[idx];
+	public static void del(int num) {
 		if (cnt1[num] == maxCnt && cnt2[cnt1[num]] == 1) {
 			maxCnt--;
 		}
@@ -60,8 +59,7 @@ public static void del(int idx) {
 		cnt2[--cnt1[num]]++;
 	}
 
-	public static void add(int idx) {
-		int num = arr[idx];
+	public static void add(int num) {
 		cnt2[cnt1[num]]--;
 		cnt2[++cnt1[num]]++;
 		maxCnt = Math.max(maxCnt, cnt1[num]);
@@ -94,16 +92,16 @@ public static void compute() {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
 			while (winl > jobl) {
-				add(--winl);
+				add(arr[--winl]);
 			}
 			while (winr < jobr) {
-				add(++winr);
+				add(arr[++winr]);
 			}
 			while (winl < jobl) {
-				del(winl++);
+				del(arr[winl++]);
 			}
 			while (winr > jobr) {
-				del(winr--);
+				del(arr[winr--]);
 			}
 			ans[query[i][2]] = maxCnt;
 		}
diff --git a/src/class176/Code04_BloodyString2.java b/src/class176/Code04_BloodyString2.java
index 785bd6a5c..5e9bc1b84 100644
--- a/src/class176/Code04_BloodyString2.java
+++ b/src/class176/Code04_BloodyString2.java
@@ -46,8 +46,7 @@
 //    return ret;
 //}
 //
-//void del(int idx) {
-//    int num = arr[idx];
+//void del(int num) {
 //    if (cnt1[num] == maxCnt && cnt2[cnt1[num]] == 1) {
 //        maxCnt--;
 //    }
@@ -55,8 +54,7 @@
 //    cnt2[--cnt1[num]]++;
 //}
 //
-//void add(int idx) {
-//    int num = arr[idx];
+//void add(int num) {
 //    cnt2[cnt1[num]]--;
 //    cnt2[++cnt1[num]]++;
 //    if (cnt1[num] > maxCnt) {
@@ -91,16 +89,16 @@
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
 //        while (winl > jobl) {
-//            add(--winl);
+//            add(arr[--winl]);
 //        }
 //        while (winr < jobr) {
-//            add(++winr);
+//            add(arr[++winr]);
 //        }
 //        while (winl < jobl) {
-//            del(winl++);
+//            del(arr[winl++]);
 //        }
 //        while (winr > jobr) {
-//            del(winr--);
+//            del(arr[winr--]);
 //        }
 //        ans[query[i].id] = maxCnt;
 //    }
diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index c832fb0b7..b4db3064f 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -38,8 +38,7 @@ public int compare(int[] a, int[] b) {
 	public static long[] ans = new long[MAXN];
 	public static long cur;
 
-	public static void del(int idx) {
-		int x = pre[idx];
+	public static void del(int x) {
 		if (k != 0) {
 			cur -= cnt[x] * cnt[x ^ k];
 		} else {
@@ -53,8 +52,7 @@ public static void del(int idx) {
 		}
 	}
 
-	public static void add(int idx) {
-		int x = pre[idx];
+	public static void add(int x) {
 		if (k != 0) {
 			cur -= cnt[x] * cnt[x ^ k];
 		} else {
@@ -86,16 +84,16 @@ public static void compute() {
 			int jobl = query[i][0] - 1;
 			int jobr = query[i][1];
 			while (winl > jobl) {
-				add(--winl);
+				add(pre[--winl]);
 			}
 			while (winr < jobr) {
-				add(++winr);
+				add(pre[++winr]);
 			}
 			while (winl < jobl) {
-				del(winl++);
+				del(pre[winl++]);
 			}
 			while (winr > jobr) {
-				del(winr--);
+				del(pre[winr--]);
 			}
 			ans[query[i][2]] = cur;
 		}
diff --git a/src/class176/Code05_XorSequence2.java b/src/class176/Code05_XorSequence2.java
index e929be4f9..b4e4990c5 100644
--- a/src/class176/Code05_XorSequence2.java
+++ b/src/class176/Code05_XorSequence2.java
@@ -33,8 +33,7 @@
 //    return a.r < b.r;
 //}
 //
-//void del(int idx) {
-//    int x = pre[idx];
+//void del(int x) {
 //    if (k != 0) {
 //        cur -= cnt[x] * cnt[x ^ k];
 //    } else {
@@ -48,8 +47,7 @@
 //    }
 //}
 //
-//void add(int idx) {
-//    int x = pre[idx];
+//void add(int x) {
 //    if (k != 0) {
 //        cur -= cnt[x] * cnt[x ^ k];
 //    } else {
@@ -80,16 +78,16 @@
 //        int jobl = query[i].l - 1;
 //        int jobr = query[i].r;
 //        while (winl > jobl) {
-//            add(--winl);
+//            add(pre[--winl]);
 //        }
 //        while (winr < jobr) {
-//            add(++winr);
+//            add(pre[++winr]);
 //        }
 //        while (winl < jobl) {
-//            del(winl++);
+//            del(pre[winl++]);
 //        }
 //        while (winr > jobr) {
-//            del(winr--);
+//            del(pre[winr--]);
 //        }
 //        ans[query[i].id] = cur;
 //    }
diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
new file mode 100644
index 000000000..fb55bd982
--- /dev/null
+++ b/src/class176/Code06_CountingColors1.java
@@ -0,0 +1,206 @@
+package class176;
+
+// 数颜色，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1903
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code06_CountingColors1 {
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if (bi[a[1]] != bi[b[1]]) {
+				return bi[a[1]] - bi[b[1]];
+			}
+			return a[2] - b[2];
+		}
+
+	}
+
+	public static int MAXN = 200001;
+	public static int MAXV = 1000001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	public static int[][] query = new int[MAXN][4];
+	public static int[][] update = new int[MAXN][2];
+	public static int cntq;
+	public static int cntu;
+
+	public static int[] cnt = new int[MAXV];
+	public static int[] ans = new int[MAXN];
+	public static int kind;
+
+	public static void del(int num) {
+		if (--cnt[num] == 0) {
+			kind--;
+		}
+	}
+
+	public static void add(int num) {
+		if (++cnt[num] == 1) {
+			kind++;
+		}
+	}
+
+	public static void updateTime(int jobl, int jobr, int t) {
+		int pos = update[t][0];
+		int val = update[t][1];
+		if (jobl <= pos && pos <= jobr) {
+			del(arr[pos]);
+			add(val);
+		}
+		int tmp = arr[pos];
+		arr[pos] = val;
+		update[t][1] = tmp;
+	}
+
+	public static void prepare() {
+		int blen = Math.max(1, (int) Math.pow(n, 0.666));
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0, wint = 0;
+		for (int i = 1; i <= cntq; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int jobt = query[i][2];
+			int id = query[i][3];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			while (wint < jobt) {
+				updateTime(jobl, jobr, ++wint);
+			}
+			while (wint > jobt) {
+				updateTime(jobl, jobr, wint--);
+			}
+			ans[id] = kind;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		char op;
+		int x, y;
+		for (int i = 1; i <= m; i++) {
+			op = in.nextChar();
+			x = in.nextInt();
+			y = in.nextInt();
+			if (op == 'Q') {
+				cntq++;
+				query[cntq][0] = x;
+				query[cntq][1] = y;
+				query[cntq][2] = cntu;
+				query[cntq][3] = cntq;
+			} else {
+				cntu++;
+				update[cntu][0] = x;
+				update[cntu][1] = y;
+			}
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}

From ce79edb8682bcc7e3e4cd6fbb519a7a0d3fba727 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 14:14:19 +0800
Subject: [PATCH 1268/1712] modify code

---
 src/class176/Code06_CountingColors1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index fb55bd982..f8b52ff2b 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -55,16 +55,16 @@ public static void add(int num) {
 		}
 	}
 
-	public static void updateTime(int jobl, int jobr, int t) {
-		int pos = update[t][0];
-		int val = update[t][1];
+	public static void updateTime(int jobl, int jobr, int tim) {
+		int pos = update[tim][0];
+		int val = update[tim][1];
 		if (jobl <= pos && pos <= jobr) {
 			del(arr[pos]);
 			add(val);
 		}
 		int tmp = arr[pos];
 		arr[pos] = val;
-		update[t][1] = tmp;
+		update[tim][1] = tmp;
 	}
 
 	public static void prepare() {

From 290487c287296afc67170fb0dc6352b7cb1f9b2e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 17:42:49 +0800
Subject: [PATCH 1269/1712] modify code

---
 src/class176/Code06_CountingColors1.java |   5 +-
 src/class176/Code06_CountingColors2.java | 134 +++++++++++++++++++++++
 2 files changed, 136 insertions(+), 3 deletions(-)
 create mode 100644 src/class176/Code06_CountingColors2.java

diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index f8b52ff2b..83ab59f14 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -36,8 +36,7 @@ public int compare(int[] a, int[] b) {
 
 	public static int[][] query = new int[MAXN][4];
 	public static int[][] update = new int[MAXN][2];
-	public static int cntq;
-	public static int cntu;
+	public static int cntq, cntu;
 
 	public static int[] cnt = new int[MAXV];
 	public static int[] ans = new int[MAXN];
@@ -68,7 +67,7 @@ public static void updateTime(int jobl, int jobr, int tim) {
 	}
 
 	public static void prepare() {
-		int blen = Math.max(1, (int) Math.pow(n, 0.666));
+		int blen = Math.max(1, (int) Math.pow(n, 2.0 / 3));
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_CountingColors2.java
new file mode 100644
index 000000000..51d8afe5a
--- /dev/null
+++ b/src/class176/Code06_CountingColors2.java
@@ -0,0 +1,134 @@
+package class176;
+
+// 数颜色，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P1903
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, t, id;
+//};
+//
+//struct Update {
+//    int i, v;
+//};
+//
+//const int MAXN = 200001;
+//const int MAXV = 1000001;
+//int n, m;
+//int arr[MAXN];
+//int bi[MAXN];
+//
+//Query query[MAXN];
+//Update update[MAXN];
+//int cntq, cntu;
+//
+//int cnt[MAXV];
+//int ans[MAXN];
+//int kind;
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.r] != bi[b.r]) {
+//        return bi[a.r] < bi[b.r];
+//    }
+//    return a.t < b.t;
+//}
+//
+//void del(int num) {
+//    if (--cnt[num] == 0) {
+//        kind--;
+//    }
+//}
+//
+//void add(int num) {
+//    if (++cnt[num] == 1) {
+//        kind++;
+//    }
+//}
+//
+//void updateTime(int jobl, int jobr, int tim) {
+//    int pos = update[tim].i;
+//    int val = update[tim].v;
+//    if (jobl <= pos && pos <= jobr) {
+//        del(arr[pos]);
+//        add(val);
+//    }
+//    int tmp = arr[pos];
+//    arr[pos] = val;
+//    update[tim].v = tmp;
+//}
+//
+//void prepare() {
+//    int blen = max(1, (int)pow(n, 2.0 / 3));
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0, wint = 0;
+//    for (int i = 1; i <= cntq; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int jobt = query[i].t;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        while (wint < jobt) {
+//            updateTime(jobl, jobr, ++wint);
+//        }
+//        while (wint > jobt) {
+//            updateTime(jobl, jobr, wint--);
+//        }
+//        ans[id] = kind;
+//     }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    char op;
+//    int x, y;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 'Q') {
+//            cntq++;
+//            query[cntq].l = x;
+//            query[cntq].r = y;
+//            query[cntq].t = cntu;
+//            query[cntq].id = cntq;
+//        } else {
+//            cntu++;
+//            update[cntu].i = x;
+//            update[cntu].v = y;
+//        }
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 123348e6c6fcd2d03bd58b53beb517ba2e9df329 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 18:56:02 +0800
Subject: [PATCH 1270/1712] modify code

---
 src/class176/Code06_CountingColors1.java | 6 +++---
 src/class176/Code06_CountingColors2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index 83ab59f14..1a6ea41b4 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -54,7 +54,7 @@ public static void add(int num) {
 		}
 	}
 
-	public static void updateTime(int jobl, int jobr, int tim) {
+	public static void moveTime(int jobl, int jobr, int tim) {
 		int pos = update[tim][0];
 		int val = update[tim][1];
 		if (jobl <= pos && pos <= jobr) {
@@ -94,10 +94,10 @@ public static void compute() {
 				del(arr[winr--]);
 			}
 			while (wint < jobt) {
-				updateTime(jobl, jobr, ++wint);
+				moveTime(jobl, jobr, ++wint);
 			}
 			while (wint > jobt) {
-				updateTime(jobl, jobr, wint--);
+				moveTime(jobl, jobr, wint--);
 			}
 			ans[id] = kind;
 		}
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_CountingColors2.java
index 51d8afe5a..41ccd6397 100644
--- a/src/class176/Code06_CountingColors2.java
+++ b/src/class176/Code06_CountingColors2.java
@@ -53,7 +53,7 @@
 //    }
 //}
 //
-//void updateTime(int jobl, int jobr, int tim) {
+//void moveTime(int jobl, int jobr, int tim) {
 //    int pos = update[tim].i;
 //    int val = update[tim].v;
 //    if (jobl <= pos && pos <= jobr) {
@@ -93,10 +93,10 @@
 //            del(arr[winr--]);
 //        }
 //        while (wint < jobt) {
-//            updateTime(jobl, jobr, ++wint);
+//            moveTime(jobl, jobr, ++wint);
 //        }
 //        while (wint > jobt) {
-//            updateTime(jobl, jobr, wint--);
+//            moveTime(jobl, jobr, wint--);
 //        }
 //        ans[id] = kind;
 //     }

From f50d6e93f57448ed8bbc9520c6b188d1203bd16b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 15 Aug 2025 20:06:51 +0800
Subject: [PATCH 1271/1712] modify code

---
 src/class176/Code07_MachineLearning1.java | 239 ++++++++++++++++++++++
 src/class176/Code07_MachineLearning2.java | 170 +++++++++++++++
 2 files changed, 409 insertions(+)
 create mode 100644 src/class176/Code07_MachineLearning1.java
 create mode 100644 src/class176/Code07_MachineLearning2.java

diff --git a/src/class176/Code07_MachineLearning1.java b/src/class176/Code07_MachineLearning1.java
new file mode 100644
index 000000000..98daf9398
--- /dev/null
+++ b/src/class176/Code07_MachineLearning1.java
@@ -0,0 +1,239 @@
+package class176;
+
+// 机器学习，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF940F
+// 测试链接 : https://codeforces.com/problemset/problem/940/F
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code07_MachineLearning1 {
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if (bi[a[1]] != bi[b[1]]) {
+				return bi[a[1]] - bi[b[1]];
+			}
+			return a[2] - b[2];
+		}
+	}
+
+	public static int MAXN = 100001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] sorted = new int[MAXN << 1];
+
+	public static int[] bi = new int[MAXN];
+	public static int[][] query = new int[MAXN][4];
+	public static int[][] update = new int[MAXN][2];
+	public static int cntq, cntu;
+
+	public static int[] cnt1 = new int[MAXN << 1];
+	public static int[] cnt2 = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static int kth(int len, int num) {
+		int left = 1, right = len, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static void add(int num) {
+		--cnt2[cnt1[num]];
+		++cnt2[++cnt1[num]];
+	}
+
+	public static void del(int num) {
+		--cnt2[cnt1[num]];
+		++cnt2[--cnt1[num]];
+	}
+
+	public static void moveTime(int jobl, int jobr, int tim) {
+		int pos = update[tim][0];
+		int val = update[tim][1];
+		if (jobl <= pos && pos <= jobr) {
+			del(arr[pos]);
+			add(val);
+		}
+		int tmp = arr[pos];
+		arr[pos] = val;
+		update[tim][1] = tmp;
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0, wint = 0;
+		for (int i = 1; i <= cntq; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int jobt = query[i][2];
+			int id = query[i][3];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			while (wint < jobt) {
+				moveTime(jobl, jobr, ++wint);
+			}
+			while (wint > jobt) {
+				moveTime(jobl, jobr, wint--);
+			}
+			int ret = 1;
+			while (ret <= n && cnt2[ret] > 0) {
+				ret++;
+			}
+			ans[id] = ret;
+		}
+	}
+
+	public static void prepare() {
+		int len = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[++len] = arr[i];
+		}
+		for (int i = 1; i <= cntu; i++) {
+			sorted[++len] = update[i][1];
+		}
+		Arrays.sort(sorted, 1, len + 1);
+		int tmp = 1;
+		for (int i = 2; i <= len; i++) {
+			if (sorted[tmp] != sorted[i]) {
+				sorted[++tmp] = sorted[i];
+			}
+		}
+		len = tmp;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(len, arr[i]);
+		}
+		for (int i = 1; i <= cntu; i++) {
+			update[i][1] = kth(len, update[i][1]);
+		}
+		int blen = Math.max(1, (int) Math.pow(n, 2.0 / 3));
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1, op, x, y; i <= m; i++) {
+			op = in.nextInt();
+			x = in.nextInt();
+			y = in.nextInt();
+			if (op == 1) {
+				cntq++;
+				query[cntq][0] = x;
+				query[cntq][1] = y;
+				query[cntq][2] = cntu;
+				query[cntq][3] = cntq;
+			} else {
+				cntu++;
+				update[cntu][0] = x;
+				update[cntu][1] = y;
+			}
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class176/Code07_MachineLearning2.java b/src/class176/Code07_MachineLearning2.java
new file mode 100644
index 000000000..2fa851b91
--- /dev/null
+++ b/src/class176/Code07_MachineLearning2.java
@@ -0,0 +1,170 @@
+package class176;
+
+// 机器学习，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF940F
+// 测试链接 : https://codeforces.com/problemset/problem/940/F
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, t, id;
+//};
+//
+//struct Update {
+//    int i, v;
+//};
+//
+//const int MAXN = 100001;
+//int n, m;
+//int arr[MAXN];
+//int sorted[MAXN << 1];
+//
+//int bi[MAXN];
+//Query query[MAXN];
+//Update update[MAXN];
+//int cntq, cntu;
+//
+//int cnt1[MAXN << 1];
+//int cnt2[MAXN];
+//int ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.r] != bi[b.r]) {
+//        return bi[a.r] < bi[b.r];
+//    }
+//    return a.t < b.t;
+//}
+//
+//int kth(int len, int num) {
+//    int left = 1, right = len, mid, ret = 0;
+//    while (left <= right) {
+//        mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//void add(int num) {
+//    --cnt2[cnt1[num]];
+//    ++cnt2[++cnt1[num]];
+//}
+//
+//void del(int num) {
+//    --cnt2[cnt1[num]];
+//    ++cnt2[--cnt1[num]];
+//}
+//
+//void moveTime(int jobl, int jobr, int tim) {
+//    int pos = update[tim].i;
+//    int val = update[tim].v;
+//    if (jobl <= pos && pos <= jobr) {
+//        del(arr[pos]);
+//        add(val);
+//    }
+//    int tmp = arr[pos];
+//    arr[pos] = val;
+//    update[tim].v = tmp;
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0, wint = 0;
+//    for (int i = 1; i <= cntq; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int jobt = query[i].t;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        while (wint < jobt) {
+//            moveTime(jobl, jobr, ++wint);
+//        }
+//        while (wint > jobt) {
+//            moveTime(jobl, jobr,  wint--);
+//        }
+//        int ret = 1;
+//        while (ret <= n && cnt2[ret] > 0) {
+//            ret++;
+//        }
+//        ans[id] = ret;
+//    }
+//}
+//
+//void prepare() {
+//    int len = 0;
+//    for (int i = 1; i <= n; i++) {
+//        sorted[++len] = arr[i];
+//    }
+//    for (int i = 1; i <= cntu; i++) {
+//        sorted[++len] = update[i].v;
+//    }
+//    sort(sorted + 1, sorted + len + 1);
+//    int tmp = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (sorted[tmp] != sorted[i]) {
+//            sorted[++tmp] = sorted[i];
+//        }
+//    }
+//    len = tmp;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(len, arr[i]);
+//    }
+//    for (int i = 1; i <= cntu; i++) {
+//        update[i].v = kth(len, update[i].v);
+//    }
+//    int blen = max(1, (int)pow(n, 2.0 / 3));
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, op, x, y; i <= m; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 1) {
+//            ++cntq;
+//            query[cntq].l = x;
+//            query[cntq].r = y;
+//            query[cntq].t = cntu;
+//            query[cntq].id = cntq;
+//        } else {
+//            ++cntu;
+//            update[cntu].i = x;
+//            update[cntu].v = y;
+//        }
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From c5c9bee8fe85773510e7404578dc892bd44f106b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 16 Aug 2025 11:03:29 +0800
Subject: [PATCH 1272/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java    |  7 ++++---
 src/class176/Code01_MoAlgorithm2.java    |  3 ++-
 src/class176/Code06_CountingColors1.java | 26 ++++++++++++++++++++++--
 src/class176/Code06_CountingColors2.java | 18 ++++++++++++++--
 4 files changed, 46 insertions(+), 8 deletions(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index f3398b433..cb1bc4058 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -14,7 +14,7 @@
 
 public class Code01_MoAlgorithm1 {
 
-	// 莫队经典排序
+	// 普通莫队经典排序
 	public static class QueryCmp1 implements Comparator<int[]> {
 
 		@Override
@@ -27,7 +27,7 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	// 莫队奇偶排序，玄学优化
+	// 普通莫队奇偶排序
 	public static class QueryCmp2 implements Comparator<int[]> {
 
 		@Override
@@ -37,8 +37,9 @@ public int compare(int[] a, int[] b) {
 			}
 			if ((bi[a[0]] & 1) == 1) {
 				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
 			}
-			return b[1] - a[1];
 		}
 
 	}
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index 16209b02c..c257997cb 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -39,8 +39,9 @@
 //    }
 //    if ((bi[a.l] & 1) == 1) {
 //        return a.r < b.r;
+//    } else {
+//        return a.r > b.r;
 //    }
-//    return a.r > b.r;
 //}
 //
 //void del(int num) {
diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index 1a6ea41b4..5de71f76a 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -13,7 +13,8 @@
 
 public class Code06_CountingColors1 {
 
-	public static class QueryCmp implements Comparator<int[]> {
+	// 带修莫队经典排序
+	public static class QueryCmp1 implements Comparator<int[]> {
 
 		@Override
 		public int compare(int[] a, int[] b) {
@@ -28,6 +29,26 @@ public int compare(int[] a, int[] b) {
 
 	}
 
+	// 带修莫队奇偶排序
+	public static class QueryCmp2 implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if (bi[a[1]] != bi[b[1]]) {
+				if ((bi[a[0]] & 1) == 1) {
+					return bi[a[1]] - bi[b[1]];
+				} else {
+					return bi[b[1]] - bi[a[1]];
+				}
+			}
+			return a[2] - b[2];
+		}
+
+	}
+
 	public static int MAXN = 200001;
 	public static int MAXV = 1000001;
 	public static int n, m;
@@ -71,7 +92,8 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+		// Arrays.sort(query, 1, cntq + 1, new QueryCmp1());
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp2());
 	}
 
 	public static void compute() {
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_CountingColors2.java
index 41ccd6397..a65035f08 100644
--- a/src/class176/Code06_CountingColors2.java
+++ b/src/class176/Code06_CountingColors2.java
@@ -31,7 +31,7 @@
 //int ans[MAXN];
 //int kind;
 //
-//bool QueryCmp(Query &a, Query &b) {
+//bool QueryCmp1(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
@@ -41,6 +41,20 @@
 //    return a.t < b.t;
 //}
 //
+//bool QueryCmp2(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.r] != bi[b.r]) {
+//        if ((bi[a.l] & 1) == 1) {
+//            return bi[a.r] < bi[b.r];
+//        } else {
+//            return bi[a.r] > bi[b.r];
+//        }
+//    }
+//    return a.t < b.t;
+//}
+//
 //void del(int num) {
 //    if (--cnt[num] == 0) {
 //        kind--;
@@ -70,7 +84,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query + 1, query + cntq + 1, QueryCmp);
+//    sort(query + 1, query + cntq + 1, QueryCmp2);
 //}
 //
 //void compute() {

From dde2baa1a17df64293631da240c66a8de41c537b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 16 Aug 2025 14:12:38 +0800
Subject: [PATCH 1273/1712] modify code

---
 src/class176/Code06_CountingColors1.java    |  16 +-
 src/class176/Code06_CountingColors2.java    |  22 +-
 src/class176/Code07_MachineLearning1.java   |  16 +-
 src/class176/Code07_MachineLearning2.java   |  26 +--
 src/class176/Code08_MinimumDifference1.java | 225 ++++++++++++++++++++
 src/class176/Code08_MinimumDifference2.java | 178 ++++++++++++++++
 6 files changed, 447 insertions(+), 36 deletions(-)
 create mode 100644 src/class176/Code08_MinimumDifference1.java
 create mode 100644 src/class176/Code08_MinimumDifference2.java

diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index 5de71f76a..895f0020b 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -134,21 +134,23 @@ public static void main(String[] args) throws Exception {
 			arr[i] = in.nextInt();
 		}
 		char op;
-		int x, y;
+		int l, r, pos, val;
 		for (int i = 1; i <= m; i++) {
 			op = in.nextChar();
-			x = in.nextInt();
-			y = in.nextInt();
 			if (op == 'Q') {
+				l = in.nextInt();
+				r = in.nextInt();
 				cntq++;
-				query[cntq][0] = x;
-				query[cntq][1] = y;
+				query[cntq][0] = l;
+				query[cntq][1] = r;
 				query[cntq][2] = cntu;
 				query[cntq][3] = cntq;
 			} else {
+				pos = in.nextInt();
+				val = in.nextInt();
 				cntu++;
-				update[cntu][0] = x;
-				update[cntu][1] = y;
+				update[cntu][0] = pos;
+				update[cntu][1] = val;
 			}
 		}
 		prepare();
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_CountingColors2.java
index a65035f08..ac8eae32b 100644
--- a/src/class176/Code06_CountingColors2.java
+++ b/src/class176/Code06_CountingColors2.java
@@ -14,7 +14,7 @@
 //};
 //
 //struct Update {
-//    int i, v;
+//    int pos, val;
 //};
 //
 //const int MAXN = 200001;
@@ -68,15 +68,15 @@
 //}
 //
 //void moveTime(int jobl, int jobr, int tim) {
-//    int pos = update[tim].i;
-//    int val = update[tim].v;
+//    int pos = update[tim].pos;
+//    int val = update[tim].val;
 //    if (jobl <= pos && pos <= jobr) {
 //        del(arr[pos]);
 //        add(val);
 //    }
 //    int tmp = arr[pos];
 //    arr[pos] = val;
-//    update[tim].v = tmp;
+//    update[tim].val = tmp;
 //}
 //
 //void prepare() {
@@ -124,19 +124,21 @@
 //        cin >> arr[i];
 //    }
 //    char op;
-//    int x, y;
+//    int l, r, pos, val;
 //    for (int i = 1; i <= m; i++) {
-//        cin >> op >> x >> y;
+//        cin >> op;
 //        if (op == 'Q') {
+//            cin >> l >> r;
 //            cntq++;
-//            query[cntq].l = x;
-//            query[cntq].r = y;
+//            query[cntq].l = l;
+//            query[cntq].r = r;
 //            query[cntq].t = cntu;
 //            query[cntq].id = cntq;
 //        } else {
+//            cin >> pos >> val;
 //            cntu++;
-//            update[cntu].i = x;
-//            update[cntu].v = y;
+//            update[cntu].pos = pos;
+//            update[cntu].val = val;
 //        }
 //    }
 //    prepare();
diff --git a/src/class176/Code07_MachineLearning1.java b/src/class176/Code07_MachineLearning1.java
index 98daf9398..3a050766e 100644
--- a/src/class176/Code07_MachineLearning1.java
+++ b/src/class176/Code07_MachineLearning1.java
@@ -147,20 +147,22 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
-		for (int i = 1, op, x, y; i <= m; i++) {
+		for (int i = 1, op, l, r, pos, val; i <= m; i++) {
 			op = in.nextInt();
-			x = in.nextInt();
-			y = in.nextInt();
 			if (op == 1) {
+				l = in.nextInt();
+				r = in.nextInt();
 				cntq++;
-				query[cntq][0] = x;
-				query[cntq][1] = y;
+				query[cntq][0] = l;
+				query[cntq][1] = r;
 				query[cntq][2] = cntu;
 				query[cntq][3] = cntq;
 			} else {
+				pos = in.nextInt();
+				val = in.nextInt();
 				cntu++;
-				update[cntu][0] = x;
-				update[cntu][1] = y;
+				update[cntu][0] = pos;
+				update[cntu][1] = val;
 			}
 		}
 		prepare();
diff --git a/src/class176/Code07_MachineLearning2.java b/src/class176/Code07_MachineLearning2.java
index 2fa851b91..1ffc67816 100644
--- a/src/class176/Code07_MachineLearning2.java
+++ b/src/class176/Code07_MachineLearning2.java
@@ -15,7 +15,7 @@
 //};
 //
 //struct Update {
-//    int i, v;
+//    int pos, val;
 //};
 //
 //const int MAXN = 100001;
@@ -67,15 +67,15 @@
 //}
 //
 //void moveTime(int jobl, int jobr, int tim) {
-//    int pos = update[tim].i;
-//    int val = update[tim].v;
+//    int pos = update[tim].pos;
+//    int val = update[tim].val;
 //    if (jobl <= pos && pos <= jobr) {
 //        del(arr[pos]);
 //        add(val);
 //    }
 //    int tmp = arr[pos];
 //    arr[pos] = val;
-//    update[tim].v = tmp;
+//    update[tim].val = tmp;
 //}
 //
 //void compute() {
@@ -117,7 +117,7 @@
 //        sorted[++len] = arr[i];
 //    }
 //    for (int i = 1; i <= cntu; i++) {
-//        sorted[++len] = update[i].v;
+//        sorted[++len] = update[i].val;
 //    }
 //    sort(sorted + 1, sorted + len + 1);
 //    int tmp = 1;
@@ -131,7 +131,7 @@
 //        arr[i] = kth(len, arr[i]);
 //    }
 //    for (int i = 1; i <= cntu; i++) {
-//        update[i].v = kth(len, update[i].v);
+//        update[i].val = kth(len, update[i].val);
 //    }
 //    int blen = max(1, (int)pow(n, 2.0 / 3));
 //    for (int i = 1; i <= n; i++) {
@@ -147,18 +147,20 @@
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
-//    for (int i = 1, op, x, y; i <= m; i++) {
-//        cin >> op >> x >> y;
+//    for (int i = 1, op, l, r, pos, val; i <= m; i++) {
+//        cin >> op;
 //        if (op == 1) {
+//            cin >> l >> r;
 //            ++cntq;
-//            query[cntq].l = x;
-//            query[cntq].r = y;
+//            query[cntq].l = l;
+//            query[cntq].r = r;
 //            query[cntq].t = cntu;
 //            query[cntq].id = cntq;
 //        } else {
+//            cin >> pos >> val;
 //            ++cntu;
-//            update[cntu].i = x;
-//            update[cntu].v = y;
+//            update[cntu].pos = pos;
+//            update[cntu].val = val;
 //        }
 //    }
 //    prepare();
diff --git a/src/class176/Code08_MinimumDifference1.java b/src/class176/Code08_MinimumDifference1.java
new file mode 100644
index 000000000..befeaa9b2
--- /dev/null
+++ b/src/class176/Code08_MinimumDifference1.java
@@ -0,0 +1,225 @@
+package class176;
+
+// 最小化极差，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1476G
+// 测试链接 : https://codeforces.com/problemset/problem/1476/G
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code08_MinimumDifference1 {
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if (bi[a[1]] != bi[b[1]]) {
+				return bi[a[1]] - bi[b[1]];
+			}
+			return a[3] - b[3];
+		}
+	}
+
+	public static int MAXN = 100001;
+	public static int MAXB = 3001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	// query : l, r, k, t, id
+	// update : pos, val
+	public static int[][] query = new int[MAXN][5];
+	public static int[][] update = new int[MAXN][2];
+	public static int cntq, cntu;
+
+	public static int[] cnt1 = new int[MAXN];
+	public static int[] cnt2 = new int[MAXN];
+	public static int[] sum = new int[MAXB];
+	public static int[] cntFreq = new int[MAXN];
+	public static int[] freqVal = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static void del(int num) {
+		cnt2[cnt1[num]]--;
+		sum[bi[cnt1[num]]]--;
+		cnt1[num]--;
+		cnt2[cnt1[num]]++;
+		sum[bi[cnt1[num]]]++;
+	}
+
+	public static void add(int num) {
+		cnt2[cnt1[num]]--;
+		sum[bi[cnt1[num]]]--;
+		cnt1[num]++;
+		cnt2[cnt1[num]]++;
+		sum[bi[cnt1[num]]]++;
+	}
+
+	public static void moveTime(int jobl, int jobr, int tim) {
+		int pos = update[tim][0];
+		int val = update[tim][1];
+		if (jobl <= pos && pos <= jobr) {
+			del(arr[pos]);
+			add(val);
+		}
+		int tmp = arr[pos];
+		arr[pos] = val;
+		update[tim][1] = tmp;
+	}
+
+	public static int getAns(int k) {
+		int size = 0;
+		for (int b = 1; b <= bi[n]; b++) {
+			if (sum[b] != 0) {
+				for (int f = bl[b]; f <= br[b]; f++) {
+					if (cnt2[f] > 0) {
+						cntFreq[++size] = cnt2[f];
+						freqVal[size] = f;
+					}
+				}
+			}
+		}
+		int minDiff = Integer.MAX_VALUE;
+		int cntSum = 0;
+		for (int l = 1, r = 0; l <= size; l++) {
+			while (cntSum < k && r < size) {
+				r++;
+				cntSum += cntFreq[r];
+			}
+			if (cntSum >= k) {
+				minDiff = Math.min(minDiff, freqVal[r] - freqVal[l]);
+			}
+			cntSum -= cntFreq[l];
+		}
+		return minDiff == Integer.MAX_VALUE ? -1 : minDiff;
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0, wint = 0;
+		for (int i = 1; i <= cntq; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int jobk = query[i][2];
+			int jobt = query[i][3];
+			int id = query[i][4];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			while (wint < jobt) {
+				moveTime(jobl, jobr, ++wint);
+			}
+			while (wint > jobt) {
+				moveTime(jobl, jobr, wint--);
+			}
+			ans[id] = getAns(jobk);
+		}
+	}
+
+	public static void prepare() {
+		int blen = Math.max(1, (int) Math.pow(n, 2.0 / 3));
+		int bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, n);
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1, op, l, r, k, pos, val; i <= m; i++) {
+			op = in.nextInt();
+			if (op == 1) {
+				l = in.nextInt();
+				r = in.nextInt();
+				k = in.nextInt();
+				cntq++;
+				query[cntq][0] = l;
+				query[cntq][1] = r;
+				query[cntq][2] = k;
+				query[cntq][3] = cntu;
+				query[cntq][4] = cntq;
+			} else {
+				pos = in.nextInt();
+				val = in.nextInt();
+				cntu++;
+				update[cntu][0] = pos;
+				update[cntu][1] = val;
+			}
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class176/Code08_MinimumDifference2.java b/src/class176/Code08_MinimumDifference2.java
new file mode 100644
index 000000000..9ed9f00f8
--- /dev/null
+++ b/src/class176/Code08_MinimumDifference2.java
@@ -0,0 +1,178 @@
+package class176;
+
+// 最小化极差，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1476G
+// 测试链接 : https://codeforces.com/problemset/problem/1476/G
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, k, t, id;
+//};
+//
+//struct Update {
+//    int pos, val;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXB = 3001;
+//int n, m;
+//int arr[MAXN];
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//Query query[MAXN];
+//Update update[MAXN];
+//int cntq, cntu;
+//
+//int cnt1[MAXN];
+//int cnt2[MAXN];
+//int sum[MAXB];
+//int cntFreq[MAXN];
+//int freqVal[MAXN];
+//int ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.r] != bi[b.r]) {
+//        return bi[a.r] < bi[b.r];
+//    }
+//    return a.t < b.t;
+//}
+//
+//void del(int num) {
+//    cnt2[cnt1[num]]--;
+//    sum[bi[cnt1[num]]]--;
+//    cnt1[num]--;
+//    cnt2[cnt1[num]]++;
+//    sum[bi[cnt1[num]]]++;
+//}
+//
+//void add(int num) {
+//    cnt2[cnt1[num]]--;
+//    sum[bi[cnt1[num]]]--;
+//    cnt1[num]++;
+//    cnt2[cnt1[num]]++;
+//    sum[bi[cnt1[num]]]++;
+//}
+//
+//void moveTime(int jobl, int jobr, int tim) {
+//    int pos = update[tim].pos;
+//    int val = update[tim].val;
+//    if (jobl <= pos && pos <= jobr) {
+//    	del(arr[pos]);
+//    	add(val);
+//    }
+//    int tmp = arr[pos];
+//    arr[pos] = val;
+//    update[tim].val = tmp;
+//}
+//
+//int getAns(int k) {
+//    int size = 0;
+//    for (int b = 1; b <= bi[n]; b++) {
+//        if (sum[b] != 0) {
+//            for (int f = bl[b]; f <= br[b]; f++) {
+//                if (cnt2[f] > 0) {
+//                    cntFreq[++size] = cnt2[f];
+//                    freqVal[size] = f;
+//                }
+//            }
+//        }
+//    }
+//    int minDiff = INT_MAX;
+//    int cntSum = 0;
+//    for (int l = 1, r = 0; l <= size; l++) {
+//        while (cntSum < k && r < size) {
+//            r++;
+//            cntSum += cntFreq[r];
+//        }
+//        if (cntSum >= k) {
+//            minDiff = min(minDiff, freqVal[r] - freqVal[l]);
+//        }
+//        cntSum -= cntFreq[l];
+//    }
+//    return minDiff == INT_MAX ? -1 : minDiff;
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0, wint = 0;
+//    for (int i = 1; i <= cntq; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int jobk = query[i].k;
+//        int jobt = query[i].t;
+//        int id   = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        while (wint < jobt) {
+//            moveTime(jobl, jobr, ++wint);
+//        }
+//        while (wint > jobt) {
+//            moveTime(jobl, jobr, wint--);
+//        }
+//        ans[id] = getAns(jobk);
+//    }
+//}
+//
+//void prepare() {
+//    int blen = max(1, (int)pow(n, 2.0 / 3.0));
+//    int bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, n);
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, op, l, r, k, pos, val; i <= m; i++) {
+//        cin >> op;
+//        if (op == 1) {
+//            cin >> l >> r >> k;
+//            ++cntq;
+//            query[cntq].l = l;
+//            query[cntq].r = r;
+//            query[cntq].k = k;
+//            query[cntq].t = cntu;
+//            query[cntq].id = cntq;
+//        } else {
+//            cin >> pos >> val;
+//            ++cntu;
+//            update[cntu].pos = pos;
+//            update[cntu].val = val;
+//        }
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From d822b2a6a35548f91620dcebfc37c9126e2d96c2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 16 Aug 2025 14:13:46 +0800
Subject: [PATCH 1274/1712] modify code

---
 src/class176/Code08_MinimumDifference2.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class176/Code08_MinimumDifference2.java b/src/class176/Code08_MinimumDifference2.java
index 9ed9f00f8..8df446db4 100644
--- a/src/class176/Code08_MinimumDifference2.java
+++ b/src/class176/Code08_MinimumDifference2.java
@@ -67,8 +67,8 @@
 //    int pos = update[tim].pos;
 //    int val = update[tim].val;
 //    if (jobl <= pos && pos <= jobr) {
-//    	del(arr[pos]);
-//    	add(val);
+//        del(arr[pos]);
+//        add(val);
 //    }
 //    int tmp = arr[pos];
 //    arr[pos] = val;

From ab7e3f37c5f2f07b36e68d6457e189c50e5ec4c8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 16 Aug 2025 14:15:08 +0800
Subject: [PATCH 1275/1712] modify code

---
 src/class176/Code07_MachineLearning2.java   | 4 ++--
 src/class176/Code08_MinimumDifference2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class176/Code07_MachineLearning2.java b/src/class176/Code07_MachineLearning2.java
index 1ffc67816..956ad7d0b 100644
--- a/src/class176/Code07_MachineLearning2.java
+++ b/src/class176/Code07_MachineLearning2.java
@@ -151,14 +151,14 @@
 //        cin >> op;
 //        if (op == 1) {
 //            cin >> l >> r;
-//            ++cntq;
+//            cntq++;
 //            query[cntq].l = l;
 //            query[cntq].r = r;
 //            query[cntq].t = cntu;
 //            query[cntq].id = cntq;
 //        } else {
 //            cin >> pos >> val;
-//            ++cntu;
+//            cntu++;
 //            update[cntu].pos = pos;
 //            update[cntu].val = val;
 //        }
diff --git a/src/class176/Code08_MinimumDifference2.java b/src/class176/Code08_MinimumDifference2.java
index 8df446db4..49de4b7eb 100644
--- a/src/class176/Code08_MinimumDifference2.java
+++ b/src/class176/Code08_MinimumDifference2.java
@@ -156,7 +156,7 @@
 //        cin >> op;
 //        if (op == 1) {
 //            cin >> l >> r >> k;
-//            ++cntq;
+//            cntq++;
 //            query[cntq].l = l;
 //            query[cntq].r = r;
 //            query[cntq].k = k;
@@ -164,7 +164,7 @@
 //            query[cntq].id = cntq;
 //        } else {
 //            cin >> pos >> val;
-//            ++cntu;
+//            cntu++;
 //            update[cntu].pos = pos;
 //            update[cntu].val = val;
 //        }

From 3f67b922bb0d892e7bda8a1b24ac3edcdc373577 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 16 Aug 2025 15:44:50 +0800
Subject: [PATCH 1276/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java       | 5 +++++
 src/class176/Code01_MoAlgorithm2.java       | 5 +++++
 src/class176/Code02_QueryFromB1.java        | 4 ++++
 src/class176/Code02_QueryFromB2.java        | 4 ++++
 src/class176/Code03_SockFromZ1.java         | 4 ++++
 src/class176/Code03_SockFromZ2.java         | 4 ++++
 src/class176/Code04_BloodyString1.java      | 4 ++++
 src/class176/Code04_BloodyString2.java      | 4 ++++
 src/class176/Code05_XorSequence1.java       | 3 +++
 src/class176/Code05_XorSequence2.java       | 3 +++
 src/class176/Code06_CountingColors1.java    | 5 +++++
 src/class176/Code06_CountingColors2.java    | 5 +++++
 src/class176/Code07_MachineLearning1.java   | 6 ++++++
 src/class176/Code07_MachineLearning2.java   | 6 ++++++
 src/class176/Code08_MinimumDifference1.java | 7 +++++++
 src/class176/Code08_MinimumDifference2.java | 7 +++++++
 16 files changed, 76 insertions(+)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index cb1bc4058..556220cd1 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -1,6 +1,11 @@
 package class176;
 
 // 普通莫队模版题，java版
+// 给定一个长度为n的数组arr，一共有q条查询，格式如下
+// 查询 l r : 打印arr[l..r]范围上有几种不同的数字
+// 1 <= n <= 3 * 10^4
+// 1 <= arr[i] <= 10^6
+// 1 <= q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/SP3267
 // 测试链接 : https://www.spoj.com/problems/DQUERY/
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index c257997cb..affc321fd 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -1,6 +1,11 @@
 package class176;
 
 // 普通莫队模版题，C++版
+// 给定一个长度为n的数组arr，一共有q条查询，格式如下
+// 查询 l r : 打印arr[l..r]范围上有几种不同的数字
+// 1 <= n <= 3 * 10^4
+// 1 <= arr[i] <= 10^6
+// 1 <= q <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/SP3267
 // 测试链接 : https://www.spoj.com/problems/DQUERY/
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
index 2c1e0b753..519a40065 100644
--- a/src/class176/Code02_QueryFromB1.java
+++ b/src/class176/Code02_QueryFromB1.java
@@ -1,6 +1,10 @@
 package class176;
 
 // 小B的询问，java版
+// 给定一个长度为n的数组arr，所有数字在[1..k]范围上
+// 定义f(i) = i这种数的出现次数的平方，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，打印 f(1) + f(2) + .. + f(k) 的值
+// 1 <= n、m、k <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P2709
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class176/Code02_QueryFromB2.java b/src/class176/Code02_QueryFromB2.java
index 876b10460..5d3cb08d6 100644
--- a/src/class176/Code02_QueryFromB2.java
+++ b/src/class176/Code02_QueryFromB2.java
@@ -1,6 +1,10 @@
 package class176;
 
 // 小B的询问，C++版
+// 给定一个长度为n的数组arr，所有数字在[1..k]范围上
+// 定义f(i) = i这种数的出现次数的平方，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，打印 f(1) + f(2) + .. + f(k) 的值
+// 1 <= n、m、k <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P2709
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class176/Code03_SockFromZ1.java b/src/class176/Code03_SockFromZ1.java
index 897fb599a..c26f66b01 100644
--- a/src/class176/Code03_SockFromZ1.java
+++ b/src/class176/Code03_SockFromZ1.java
@@ -1,6 +1,10 @@
 package class176;
 
 // 小Z的袜子，java版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，如果随机选两个数，打印数字相同的概率
+//            打印的结果用分数的形式表达，并且约分到最简的形式
+// 1 <= n、m、arr[i] <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P1494
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class176/Code03_SockFromZ2.java b/src/class176/Code03_SockFromZ2.java
index b4fddadb8..7a7c9832b 100644
--- a/src/class176/Code03_SockFromZ2.java
+++ b/src/class176/Code03_SockFromZ2.java
@@ -1,6 +1,10 @@
 package class176;
 
 // 小Z的袜子，C++版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，如果随机选两个数，打印数字相同的概率
+//            打印的结果用分数的形式表达，并且约分到最简的形式
+// 1 <= n、m、arr[i] <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P1494
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index ed5b0f270..bb450bd1e 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -1,6 +1,10 @@
 package class176;
 
 // 大爷的字符串题，java版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，众数出现了几次，打印其相反数
+// 1 <= n、m <= 2 * 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3709
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class176/Code04_BloodyString2.java b/src/class176/Code04_BloodyString2.java
index 5e9bc1b84..a323ee170 100644
--- a/src/class176/Code04_BloodyString2.java
+++ b/src/class176/Code04_BloodyString2.java
@@ -1,6 +1,10 @@
 package class176;
 
 // 大爷的字符串题，C++版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，众数出现了几次，打印其相反数
+// 1 <= n、m <= 2 * 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3709
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index b4db3064f..7b37c1a99 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -1,6 +1,9 @@
 package class176;
 
 // 异或序列，java版
+// 给定一个长度为n的数组arr，给定一个数字k，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，有多少子数组的异或和为k，打印其数量
+// 0 <= n、m、k、arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4462
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class176/Code05_XorSequence2.java b/src/class176/Code05_XorSequence2.java
index b4e4990c5..62f4e2b50 100644
--- a/src/class176/Code05_XorSequence2.java
+++ b/src/class176/Code05_XorSequence2.java
@@ -1,6 +1,9 @@
 package class176;
 
 // 异或序列，C++版
+// 给定一个长度为n的数组arr，给定一个数字k，一共有m条查询，格式如下
+// 查询 l r : arr[l..r]范围上，有多少子数组的异或和为k，打印其数量
+// 0 <= n、m、k、arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4462
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index 895f0020b..addd6c3c4 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -1,6 +1,11 @@
 package class176;
 
 // 数颜色，java版
+// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
+// 操作 Q l r     : 打印arr[l..r]范围上有几种不同的数
+// 操作 R pos val : 把arr[pos]的值设置成val
+// 1 <= n、m <= 2 * 10^5
+// 1 <= arr[i]、val <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P1903
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_CountingColors2.java
index ac8eae32b..547eaa0ac 100644
--- a/src/class176/Code06_CountingColors2.java
+++ b/src/class176/Code06_CountingColors2.java
@@ -1,6 +1,11 @@
 package class176;
 
 // 数颜色，C++版
+// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
+// 操作 Q l r     : 打印arr[l..r]范围上有几种不同的数
+// 操作 R pos val : 把arr[pos]的值设置成val
+// 1 <= n、m <= 2 * 10^5
+// 1 <= arr[i]、val <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P1903
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class176/Code07_MachineLearning1.java b/src/class176/Code07_MachineLearning1.java
index 3a050766e..a52ff438b 100644
--- a/src/class176/Code07_MachineLearning1.java
+++ b/src/class176/Code07_MachineLearning1.java
@@ -1,6 +1,12 @@
 package class176;
 
 // 机器学习，java版
+// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
+// 操作 1 l r     : arr[l..r]范围上，每种数字出现的次数，假设构成一个集合
+//                  打印这个集合中，没出现的最小非负整数，就是打印次数的mex
+// 操作 2 pos val : 把arr[pos]的值设置成val
+// 1 <= n、m <= 10^5
+// 1 <= arr[i]、val <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF940F
 // 测试链接 : https://codeforces.com/problemset/problem/940/F
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class176/Code07_MachineLearning2.java b/src/class176/Code07_MachineLearning2.java
index 956ad7d0b..ed2750fd1 100644
--- a/src/class176/Code07_MachineLearning2.java
+++ b/src/class176/Code07_MachineLearning2.java
@@ -1,6 +1,12 @@
 package class176;
 
 // 机器学习，C++版
+// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
+// 操作 1 l r     : arr[l..r]范围上，每种数字出现的次数，假设构成一个集合
+//                  打印这个集合中，没出现的最小非负整数，就是打印次数的mex
+// 操作 2 pos val : 把arr[pos]的值设置成val
+// 1 <= n、m <= 10^5
+// 1 <= arr[i]、val <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/CF940F
 // 测试链接 : https://codeforces.com/problemset/problem/940/F
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class176/Code08_MinimumDifference1.java b/src/class176/Code08_MinimumDifference1.java
index befeaa9b2..407cd784e 100644
--- a/src/class176/Code08_MinimumDifference1.java
+++ b/src/class176/Code08_MinimumDifference1.java
@@ -1,6 +1,13 @@
 package class176;
 
 // 最小化极差，java版
+// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
+// 操作 1 l r k   : arr[l..r]范围上，选出k个真的出现并且互不相同的数
+//                  这些数假设为a1、a2 .. ak，对应的出现次数假设为cnt1、cnt2 .. cntk
+//                  打印 max{cnt1 .. cntk} - min{cnt1 .. cntk} 的最小值
+//                  如果无法选出k个数，打印-1
+// 操作 2 pos val : 把arr[pos]的值设置成val
+// 1 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1476G
 // 测试链接 : https://codeforces.com/problemset/problem/1476/G
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class176/Code08_MinimumDifference2.java b/src/class176/Code08_MinimumDifference2.java
index 49de4b7eb..ffc3a61a0 100644
--- a/src/class176/Code08_MinimumDifference2.java
+++ b/src/class176/Code08_MinimumDifference2.java
@@ -1,6 +1,13 @@
 package class176;
 
 // 最小化极差，C++版
+// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
+// 操作 1 l r k   : arr[l..r]范围上，选出k个真的出现并且互不相同的数
+//                  这些数假设为a1、a2 .. ak，对应的出现次数假设为cnt1、cnt2 .. cntk
+//                  打印 max{cnt1 .. cntk} - min{cnt1 .. cntk} 的最小值
+//                  如果无法选出k个数，打印-1
+// 操作 2 pos val : 把arr[pos]的值设置成val
+// 1 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1476G
 // 测试链接 : https://codeforces.com/problemset/problem/1476/G
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 2025ebafe623eb8293d2d7477be5f44374c8ee54 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 17 Aug 2025 16:45:29 +0800
Subject: [PATCH 1277/1712] modify code

---
 src/class176/Code06_CountingColors1.java | 26 ++----------------------
 src/class176/Code06_CountingColors2.java | 18 ++--------------
 2 files changed, 4 insertions(+), 40 deletions(-)

diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index addd6c3c4..4ea1da41a 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -18,8 +18,7 @@
 
 public class Code06_CountingColors1 {
 
-	// 带修莫队经典排序
-	public static class QueryCmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
 		public int compare(int[] a, int[] b) {
@@ -34,26 +33,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	// 带修莫队奇偶排序
-	public static class QueryCmp2 implements Comparator<int[]> {
-
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return bi[a[0]] - bi[b[0]];
-			}
-			if (bi[a[1]] != bi[b[1]]) {
-				if ((bi[a[0]] & 1) == 1) {
-					return bi[a[1]] - bi[b[1]];
-				} else {
-					return bi[b[1]] - bi[a[1]];
-				}
-			}
-			return a[2] - b[2];
-		}
-
-	}
-
 	public static int MAXN = 200001;
 	public static int MAXV = 1000001;
 	public static int n, m;
@@ -97,8 +76,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		// Arrays.sort(query, 1, cntq + 1, new QueryCmp1());
-		Arrays.sort(query, 1, cntq + 1, new QueryCmp2());
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
 	}
 
 	public static void compute() {
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_CountingColors2.java
index 547eaa0ac..61803d938 100644
--- a/src/class176/Code06_CountingColors2.java
+++ b/src/class176/Code06_CountingColors2.java
@@ -36,7 +36,7 @@
 //int ans[MAXN];
 //int kind;
 //
-//bool QueryCmp1(Query &a, Query &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
@@ -46,20 +46,6 @@
 //    return a.t < b.t;
 //}
 //
-//bool QueryCmp2(Query &a, Query &b) {
-//    if (bi[a.l] != bi[b.l]) {
-//        return bi[a.l] < bi[b.l];
-//    }
-//    if (bi[a.r] != bi[b.r]) {
-//        if ((bi[a.l] & 1) == 1) {
-//            return bi[a.r] < bi[b.r];
-//        } else {
-//            return bi[a.r] > bi[b.r];
-//        }
-//    }
-//    return a.t < b.t;
-//}
-//
 //void del(int num) {
 //    if (--cnt[num] == 0) {
 //        kind--;
@@ -89,7 +75,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query + 1, query + cntq + 1, QueryCmp2);
+//    sort(query + 1, query + cntq + 1, QueryCmp);
 //}
 //
 //void compute() {

From 3b6310684a0fd122e694e425e6fc0c6ee00230f9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 17 Aug 2025 17:41:13 +0800
Subject: [PATCH 1278/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java    | 2 +-
 src/class176/Code01_MoAlgorithm2.java    | 2 +-
 src/class176/Code06_CountingColors1.java | 2 +-
 src/class176/Code06_CountingColors2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index 556220cd1..b6aa6f456 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -1,6 +1,6 @@
 package class176;
 
-// 普通莫队模版题，java版
+// 普通莫队入门题，java版
 // 给定一个长度为n的数组arr，一共有q条查询，格式如下
 // 查询 l r : 打印arr[l..r]范围上有几种不同的数字
 // 1 <= n <= 3 * 10^4
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index affc321fd..38c07d6ed 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -1,6 +1,6 @@
 package class176;
 
-// 普通莫队模版题，C++版
+// 普通莫队入门题，C++版
 // 给定一个长度为n的数组arr，一共有q条查询，格式如下
 // 查询 l r : 打印arr[l..r]范围上有几种不同的数字
 // 1 <= n <= 3 * 10^4
diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_CountingColors1.java
index 4ea1da41a..be7c45270 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_CountingColors1.java
@@ -1,6 +1,6 @@
 package class176;
 
-// 数颜色，java版
+// 带修莫队入门题，java版
 // 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
 // 操作 Q l r     : 打印arr[l..r]范围上有几种不同的数
 // 操作 R pos val : 把arr[pos]的值设置成val
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_CountingColors2.java
index 61803d938..7b7adcfe4 100644
--- a/src/class176/Code06_CountingColors2.java
+++ b/src/class176/Code06_CountingColors2.java
@@ -1,6 +1,6 @@
 package class176;
 
-// 数颜色，C++版
+// 带修莫队入门题，C++版
 // 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
 // 操作 Q l r     : 打印arr[l..r]范围上有几种不同的数
 // 操作 R pos val : 把arr[pos]的值设置成val

From 3bfa9fe8d0ca7ef2e26ebe66059666dd7fe3fb7e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 18 Aug 2025 10:39:53 +0800
Subject: [PATCH 1279/1712] modify code

---
 .../{Code06_CountingColors1.java => Code06_MoWithModify1.java}  | 2 +-
 .../{Code06_CountingColors2.java => Code06_MoWithModify2.java}  | 0
 2 files changed, 1 insertion(+), 1 deletion(-)
 rename src/class176/{Code06_CountingColors1.java => Code06_MoWithModify1.java} (99%)
 rename src/class176/{Code06_CountingColors2.java => Code06_MoWithModify2.java} (100%)

diff --git a/src/class176/Code06_CountingColors1.java b/src/class176/Code06_MoWithModify1.java
similarity index 99%
rename from src/class176/Code06_CountingColors1.java
rename to src/class176/Code06_MoWithModify1.java
index be7c45270..025504dee 100644
--- a/src/class176/Code06_CountingColors1.java
+++ b/src/class176/Code06_MoWithModify1.java
@@ -16,7 +16,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code06_CountingColors1 {
+public class Code06_MoWithModify1 {
 
 	public static class QueryCmp implements Comparator<int[]> {
 
diff --git a/src/class176/Code06_CountingColors2.java b/src/class176/Code06_MoWithModify2.java
similarity index 100%
rename from src/class176/Code06_CountingColors2.java
rename to src/class176/Code06_MoWithModify2.java

From 7c68f909d9552aa0d71babbfe014884679be9895 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 18 Aug 2025 11:25:09 +0800
Subject: [PATCH 1280/1712] modify code

---
 src/class176/Code02_QueryFromB1.java | 3 ++-
 src/class176/Code02_QueryFromB2.java | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
index 519a40065..d703c9909 100644
--- a/src/class176/Code02_QueryFromB1.java
+++ b/src/class176/Code02_QueryFromB1.java
@@ -2,7 +2,8 @@
 
 // 小B的询问，java版
 // 给定一个长度为n的数组arr，所有数字在[1..k]范围上
-// 定义f(i) = i这种数的出现次数的平方，一共有m条查询，格式如下
+// 定义f(i) = i这种数的出现次数的平方
+// 一共有m条查询，格式如下
 // 查询 l r : arr[l..r]范围上，打印 f(1) + f(2) + .. + f(k) 的值
 // 1 <= n、m、k <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P2709
diff --git a/src/class176/Code02_QueryFromB2.java b/src/class176/Code02_QueryFromB2.java
index 5d3cb08d6..57ba95552 100644
--- a/src/class176/Code02_QueryFromB2.java
+++ b/src/class176/Code02_QueryFromB2.java
@@ -2,7 +2,8 @@
 
 // 小B的询问，C++版
 // 给定一个长度为n的数组arr，所有数字在[1..k]范围上
-// 定义f(i) = i这种数的出现次数的平方，一共有m条查询，格式如下
+// 定义f(i) = i这种数的出现次数的平方
+// 一共有m条查询，格式如下
 // 查询 l r : arr[l..r]范围上，打印 f(1) + f(2) + .. + f(k) 的值
 // 1 <= n、m、k <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P2709

From 44fce2ef88deab4bdf97a3f51b8c9b65e99c2f55 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 18 Aug 2025 11:40:11 +0800
Subject: [PATCH 1281/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java | 2 +-
 src/class176/Code01_MoAlgorithm2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index b6aa6f456..41b7adf28 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -58,8 +58,8 @@ public int compare(int[] a, int[] b) {
 
 	public static int[] bi = new int[MAXN];
 	public static int[] cnt = new int[MAXV];
-	public static int kind = 0;
 	public static int[] ans = new int[MAXQ];
+	public static int kind = 0;
 
 	public static void del(int num) {
 		if (--cnt[num] == 0) {
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index 38c07d6ed..ca245a000 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -28,8 +28,8 @@
 //
 //int bi[MAXN];
 //int cnt[MAXV];
-//int kind = 0;
 //int ans[MAXQ];
+//int kind = 0;
 //
 //bool QueryCmp1(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {

From 41e1890275db017d0c8bef9d4993e74f548793b4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 15:01:43 +0800
Subject: [PATCH 1282/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java | 25 +++++++++++++------------
 src/class176/Code01_MoAlgorithm2.java |  3 ++-
 2 files changed, 15 insertions(+), 13 deletions(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index 41b7adf28..2f7a464fb 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -19,6 +19,19 @@
 
 public class Code01_MoAlgorithm1 {
 
+	public static int MAXN = 30001;
+	public static int MAXV = 1000001;
+	public static int MAXQ = 200001;
+	public static int n, q;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXQ][3]; // jobl, jobr, 问题id
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cnt = new int[MAXV];
+	public static int kind = 0;
+
+	public static int[] ans = new int[MAXQ];
+
 	// 普通莫队经典排序
 	public static class QueryCmp1 implements Comparator<int[]> {
 
@@ -49,18 +62,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static int MAXN = 30001;
-	public static int MAXV = 1000001;
-	public static int MAXQ = 200001;
-	public static int n, q;
-	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXQ][3];
-
-	public static int[] bi = new int[MAXN];
-	public static int[] cnt = new int[MAXV];
-	public static int[] ans = new int[MAXQ];
-	public static int kind = 0;
-
 	public static void del(int num) {
 		if (--cnt[num] == 0) {
 			kind--;
diff --git a/src/class176/Code01_MoAlgorithm2.java b/src/class176/Code01_MoAlgorithm2.java
index ca245a000..137e14ab7 100644
--- a/src/class176/Code01_MoAlgorithm2.java
+++ b/src/class176/Code01_MoAlgorithm2.java
@@ -28,9 +28,10 @@
 //
 //int bi[MAXN];
 //int cnt[MAXV];
-//int ans[MAXQ];
 //int kind = 0;
 //
+//int ans[MAXQ];
+//
 //bool QueryCmp1(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];

From f12d817ceb9e74f6a06f20a1d62d3d72a2ac79c1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 15:02:49 +0800
Subject: [PATCH 1283/1712] modify code

---
 src/class176/Code01_MoAlgorithm1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class176/Code01_MoAlgorithm1.java b/src/class176/Code01_MoAlgorithm1.java
index 2f7a464fb..1c0a4458b 100644
--- a/src/class176/Code01_MoAlgorithm1.java
+++ b/src/class176/Code01_MoAlgorithm1.java
@@ -24,7 +24,8 @@ public class Code01_MoAlgorithm1 {
 	public static int MAXQ = 200001;
 	public static int n, q;
 	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXQ][3]; // jobl, jobr, 问题id
+	// jobl, jobr, 问题id
+	public static int[][] query = new int[MAXQ][3];
 
 	public static int[] bi = new int[MAXN];
 	public static int[] cnt = new int[MAXV];

From d90d6fe9801e503811c175c6dfb4a4da1864e62f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 15:31:13 +0800
Subject: [PATCH 1284/1712] modify code

---
 src/class176/Code02_QueryFromB1.java | 10 ++++++----
 src/class176/Code02_QueryFromB2.java | 10 ++++++----
 2 files changed, 12 insertions(+), 8 deletions(-)

diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
index d703c9909..92e1a508f 100644
--- a/src/class176/Code02_QueryFromB1.java
+++ b/src/class176/Code02_QueryFromB1.java
@@ -37,17 +37,19 @@ public int compare(int[] a, int[] b) {
 
 	public static int[] bi = new int[MAXN];
 	public static int[] cnt = new int[MAXN];
-	public static long sum = 0;
-	public static long[] ans = new long[MAXN];
+	public static int sum = 0;
+	public static int[] ans = new int[MAXN];
 
 	public static void del(int num) {
-		sum -= 2 * cnt[num] - 1;
+		sum -= cnt[num] * cnt[num];
 		cnt[num]--;
+		sum += cnt[num] * cnt[num];
 	}
 
 	public static void add(int num) {
-		sum += 2 * cnt[num] + 1;
+		sum -= cnt[num] * cnt[num];
 		cnt[num]++;
+		sum += cnt[num] * cnt[num];
 	}
 
 	public static void prepare() {
diff --git a/src/class176/Code02_QueryFromB2.java b/src/class176/Code02_QueryFromB2.java
index 57ba95552..a0d86f55a 100644
--- a/src/class176/Code02_QueryFromB2.java
+++ b/src/class176/Code02_QueryFromB2.java
@@ -25,8 +25,8 @@
 //
 //int bi[MAXN];
 //int cnt[MAXN];
-//long long sum = 0;
-//long long ans[MAXN];
+//int sum = 0;
+//int ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
@@ -36,13 +36,15 @@
 //}
 //
 //void del(int num) {
-//    sum -= 2 * cnt[num] - 1;
+//    sum -= cnt[num] * cnt[num];
 //    cnt[num]--;
+//    sum += cnt[num] * cnt[num];
 //}
 //
 //void add(int num) {
-//    sum += 2 * cnt[num] + 1;
+//    sum -= cnt[num] * cnt[num];
 //    cnt[num]++;
+//    sum += cnt[num] * cnt[num];
 //}
 //
 //void prepare() {

From 10e19aadc78ab7323d4e5f4bce6ffe44c463cd55 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 16:50:11 +0800
Subject: [PATCH 1285/1712] modify code

---
 src/class176/Code02_QueryFromB1.java | 22 ++++++++++++----------
 1 file changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/class176/Code02_QueryFromB1.java b/src/class176/Code02_QueryFromB1.java
index 92e1a508f..61d51c4ed 100644
--- a/src/class176/Code02_QueryFromB1.java
+++ b/src/class176/Code02_QueryFromB1.java
@@ -18,6 +18,18 @@
 
 public class Code02_QueryFromB1 {
 
+	public static int MAXN = 50001;
+	public static int n, m, k;
+	public static int[] arr = new int[MAXN];
+	// jobl, jobr, 问题id
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cnt = new int[MAXN];
+	public static int sum = 0;
+
+	public static int[] ans = new int[MAXN];
+
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
@@ -30,16 +42,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static int MAXN = 50001;
-	public static int n, m, k;
-	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXN][3];
-
-	public static int[] bi = new int[MAXN];
-	public static int[] cnt = new int[MAXN];
-	public static int sum = 0;
-	public static int[] ans = new int[MAXN];
-
 	public static void del(int num) {
 		sum -= cnt[num] * cnt[num];
 		cnt[num]--;

From c6968ffe87bc913dcbd0aacb45c4c3e4025a994d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 17:02:00 +0800
Subject: [PATCH 1286/1712] modify code

---
 src/class176/Code03_SockFromZ1.java | 26 +++++++++++++-------------
 src/class176/Code03_SockFromZ2.java |  4 ++--
 2 files changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/class176/Code03_SockFromZ1.java b/src/class176/Code03_SockFromZ1.java
index c26f66b01..32df429be 100644
--- a/src/class176/Code03_SockFromZ1.java
+++ b/src/class176/Code03_SockFromZ1.java
@@ -2,8 +2,8 @@
 
 // 小Z的袜子，java版
 // 给定一个长度为n的数组arr，一共有m条查询，格式如下
-// 查询 l r : arr[l..r]范围上，如果随机选两个数，打印数字相同的概率
-//            打印的结果用分数的形式表达，并且约分到最简的形式
+// 查询 l r : arr[l..r]范围上，随机选不同位置的两个数，打印数值相同的概率
+//            概率用分数的形式表达，并且约分到最简的形式
 // 1 <= n、m、arr[i] <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P1494
 // 提交以下的code，提交时请把类名改成"Main"
@@ -20,6 +20,17 @@
 
 public class Code03_SockFromZ1 {
 
+	public static int MAXN = 50001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cnt = new int[MAXN];
+	public static long sum = 0;
+	public static long[] ans1 = new long[MAXN];
+	public static long[] ans2 = new long[MAXN];
+
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
@@ -32,17 +43,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static int MAXN = 50001;
-	public static int n, m;
-	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXN][3];
-
-	public static int[] bi = new int[MAXN];
-	public static int[] cnt = new int[MAXN];
-	public static long sum = 0;
-	public static long[] ans1 = new long[MAXN];
-	public static long[] ans2 = new long[MAXN];
-
 	public static long gcd(long a, long b) {
 		return b == 0 ? a : gcd(b, a % b);
 	}
diff --git a/src/class176/Code03_SockFromZ2.java b/src/class176/Code03_SockFromZ2.java
index 7a7c9832b..814bbf2da 100644
--- a/src/class176/Code03_SockFromZ2.java
+++ b/src/class176/Code03_SockFromZ2.java
@@ -2,8 +2,8 @@
 
 // 小Z的袜子，C++版
 // 给定一个长度为n的数组arr，一共有m条查询，格式如下
-// 查询 l r : arr[l..r]范围上，如果随机选两个数，打印数字相同的概率
-//            打印的结果用分数的形式表达，并且约分到最简的形式
+// 查询 l r : arr[l..r]范围上，随机选不同位置的两个数，打印数值相同的概率
+//            概率用分数的形式表达，并且约分到最简的形式
 // 1 <= n、m、arr[i] <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P1494
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 6e75ef36668cee834b5d3d50bd724ad441851d22 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 17:23:19 +0800
Subject: [PATCH 1287/1712] modify code

---
 src/class176/Code03_SockFromZ1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class176/Code03_SockFromZ1.java b/src/class176/Code03_SockFromZ1.java
index 32df429be..49c029739 100644
--- a/src/class176/Code03_SockFromZ1.java
+++ b/src/class176/Code03_SockFromZ1.java
@@ -28,7 +28,10 @@ public class Code03_SockFromZ1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] cnt = new int[MAXN];
 	public static long sum = 0;
+
+	// 每个查询的分子的值
 	public static long[] ans1 = new long[MAXN];
+	// 每个查询的分母的值
 	public static long[] ans2 = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {

From 903ebc497fa5675bc1825208d55b4f67d55239fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 17:40:26 +0800
Subject: [PATCH 1288/1712] modify code

---
 src/class176/Code04_BloodyString1.java | 28 +++++++++++++++-----------
 src/class176/Code04_BloodyString2.java |  3 ++-
 2 files changed, 18 insertions(+), 13 deletions(-)

diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index bb450bd1e..bb547c4a4 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -17,6 +17,22 @@
 
 public class Code04_BloodyString1 {
 
+	public static int MAXN = 200001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+	public static int[] bi = new int[MAXN];
+
+	// cnt1[i] = j，表示窗口内，i这种数出现的次数为j
+	// cnt2[i] = j，表示窗口内，出现次数为i的数，一共有j种
+	// maxCnt表示窗口内众数的次数
+	public static int[] cnt1 = new int[MAXN];
+	public static int[] cnt2 = new int[MAXN];
+	public static int maxCnt = 0;
+
+	public static int[] ans = new int[MAXN];
+
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
@@ -29,18 +45,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static int MAXN = 200001;
-	public static int n, m;
-	public static int[] arr = new int[MAXN];
-	public static int[] sorted = new int[MAXN];
-	public static int[][] query = new int[MAXN][3];
-
-	public static int[] bi = new int[MAXN];
-	public static int[] cnt1 = new int[MAXN];
-	public static int[] cnt2 = new int[MAXN];
-	public static int maxCnt = 0;
-	public static int[] ans = new int[MAXN];
-
 	public static int kth(int len, int num) {
 		int left = 1, right = len, mid, ret = 0;
 		while (left <= right) {
diff --git a/src/class176/Code04_BloodyString2.java b/src/class176/Code04_BloodyString2.java
index a323ee170..27b259897 100644
--- a/src/class176/Code04_BloodyString2.java
+++ b/src/class176/Code04_BloodyString2.java
@@ -22,11 +22,12 @@
 //int arr[MAXN];
 //int sorted[MAXN];
 //Query query[MAXN];
-//
 //int bi[MAXN];
+//
 //int cnt1[MAXN];
 //int cnt2[MAXN];
 //int maxCnt = 0;
+//
 //int ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {

From eaaf377449bc6d6452827e1f790debb12a24056e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 17:47:18 +0800
Subject: [PATCH 1289/1712] modify code

---
 src/class176/Code04_BloodyString1.java |  6 ++++--
 src/class176/Code04_BloodyString2.java | 10 +++++-----
 2 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index bb547c4a4..7a347315d 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -64,12 +64,14 @@ public static void del(int num) {
 			maxCnt--;
 		}
 		cnt2[cnt1[num]]--;
-		cnt2[--cnt1[num]]++;
+		cnt1[num]--;
+		cnt2[cnt1[num]]++;
 	}
 
 	public static void add(int num) {
 		cnt2[cnt1[num]]--;
-		cnt2[++cnt1[num]]++;
+		cnt1[num]++;
+		cnt2[cnt1[num]]++;
 		maxCnt = Math.max(maxCnt, cnt1[num]);
 	}
 
diff --git a/src/class176/Code04_BloodyString2.java b/src/class176/Code04_BloodyString2.java
index 27b259897..b76d12013 100644
--- a/src/class176/Code04_BloodyString2.java
+++ b/src/class176/Code04_BloodyString2.java
@@ -56,15 +56,15 @@
 //        maxCnt--;
 //    }
 //    cnt2[cnt1[num]]--;
-//    cnt2[--cnt1[num]]++;
+//    cnt1[num]--;
+//    cnt2[cnt1[num]]++;
 //}
 //
 //void add(int num) {
 //    cnt2[cnt1[num]]--;
-//    cnt2[++cnt1[num]]++;
-//    if (cnt1[num] > maxCnt) {
-//        maxCnt = cnt1[num];
-//    }
+//    cnt1[num]++;
+//    cnt2[cnt1[num]]++;
+//    maxCnt = max(maxCnt, cnt1[num]);
 //}
 //
 //void prepare() {

From 255f7c9b323a909e35fbe68576d814146239274d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 17:49:11 +0800
Subject: [PATCH 1290/1712] modify code

---
 src/class176/Code04_BloodyString1.java | 2 +-
 src/class176/Code04_BloodyString2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index 7a347315d..66d35b4bc 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -2,7 +2,7 @@
 
 // 大爷的字符串题，java版
 // 给定一个长度为n的数组arr，一共有m条查询，格式如下
-// 查询 l r : arr[l..r]范围上，众数出现了几次，打印其相反数
+// 查询 l r : arr[l..r]范围上，众数出现了几次，打印次数的相反数
 // 1 <= n、m <= 2 * 10^5
 // 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3709
diff --git a/src/class176/Code04_BloodyString2.java b/src/class176/Code04_BloodyString2.java
index b76d12013..eed031769 100644
--- a/src/class176/Code04_BloodyString2.java
+++ b/src/class176/Code04_BloodyString2.java
@@ -2,7 +2,7 @@
 
 // 大爷的字符串题，C++版
 // 给定一个长度为n的数组arr，一共有m条查询，格式如下
-// 查询 l r : arr[l..r]范围上，众数出现了几次，打印其相反数
+// 查询 l r : arr[l..r]范围上，众数出现了几次，打印次数的相反数
 // 1 <= n、m <= 2 * 10^5
 // 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3709

From 5b83ac4629f71b33f0e460c8800b6fb29c4e13c3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 17:53:29 +0800
Subject: [PATCH 1291/1712] modify code

---
 src/class176/Code04_BloodyString1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index 66d35b4bc..57b375341 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -24,8 +24,8 @@ public class Code04_BloodyString1 {
 	public static int[][] query = new int[MAXN][3];
 	public static int[] bi = new int[MAXN];
 
-	// cnt1[i] = j，表示窗口内，i这种数出现的次数为j
-	// cnt2[i] = j，表示窗口内，出现次数为i的数，一共有j种
+	// cnt1[i] = j，表示窗口内，数字i出现了j次
+	// cnt2[i] = j，表示窗口内，出现了i次的数，有j种
 	// maxCnt表示窗口内众数的次数
 	public static int[] cnt1 = new int[MAXN];
 	public static int[] cnt2 = new int[MAXN];

From 9c867c7799af80a947fbd163433b3a84c7bf3f23 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 17:54:03 +0800
Subject: [PATCH 1292/1712] modify code

---
 src/class176/Code04_BloodyString1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index 57b375341..77e842ffb 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -26,7 +26,7 @@ public class Code04_BloodyString1 {
 
 	// cnt1[i] = j，表示窗口内，数字i出现了j次
 	// cnt2[i] = j，表示窗口内，出现了i次的数，有j种
-	// maxCnt表示窗口内众数的次数
+	// maxCnt，表示窗口内，众数的次数
 	public static int[] cnt1 = new int[MAXN];
 	public static int[] cnt2 = new int[MAXN];
 	public static int maxCnt = 0;

From c37c86a106564b130858211f83f7d2b19eec5d87 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 18:34:51 +0800
Subject: [PATCH 1293/1712] modify code

---
 src/class176/Code05_XorSequence1.java | 26 +++++++++++++-------------
 src/class176/Code05_XorSequence2.java |  8 ++++----
 2 files changed, 17 insertions(+), 17 deletions(-)

diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index 7b37c1a99..0841238e0 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -16,6 +16,19 @@
 
 public class Code05_XorSequence1 {
 
+	public static int MAXN = 100001;
+	public static int MAXS = 1 << 20;
+	public static int n, m, k;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] pre = new int[MAXN];
+	public static long[] cnt = new long[MAXS];
+	public static long cur;
+
+	public static long[] ans = new long[MAXN];
+
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
@@ -28,19 +41,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static int MAXN = 100001;
-	public static int MAXK = 1 << 20;
-	public static int n, m, k;
-	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXN][3];
-
-	public static int[] pre = new int[MAXN];
-	public static int[] bi = new int[MAXN];
-
-	public static long[] cnt = new long[MAXK];
-	public static long[] ans = new long[MAXN];
-	public static long cur;
-
 	public static void del(int x) {
 		if (k != 0) {
 			cur -= cnt[x] * cnt[x ^ k];
diff --git a/src/class176/Code05_XorSequence2.java b/src/class176/Code05_XorSequence2.java
index 62f4e2b50..841569e86 100644
--- a/src/class176/Code05_XorSequence2.java
+++ b/src/class176/Code05_XorSequence2.java
@@ -17,17 +17,17 @@
 //};
 //
 //const int MAXN = 100001;
-//const int MAXK = 1 << 20;
+//const int MAXS = 1 << 20;
 //int n, m, k;
 //int arr[MAXN];
 //Query query[MAXN];
 //
-//int pre[MAXN];
 //int bi[MAXN];
+//int pre[MAXN];
+//long long cnt[MAXS];
+//long long cur;
 //
-//long long cnt[MAXK];
 //long long ans[MAXN];
-//long long cur;
 //
 //bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {

From c7661c36175336b46ad232b2350e18a75aaa05ec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 18:48:48 +0800
Subject: [PATCH 1294/1712] modify code

---
 src/class176/Code05_XorSequence1.java | 6 ++++--
 src/class176/Code05_XorSequence2.java | 3 +--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index 0841238e0..be0ebcf5e 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -21,12 +21,14 @@ public class Code05_XorSequence1 {
 	public static int n, m, k;
 	public static int[] arr = new int[MAXN];
 	public static int[][] query = new int[MAXN][3];
-
 	public static int[] bi = new int[MAXN];
+
+	// pre[i] == x，表示前i个数字的前缀异或和为x
 	public static int[] pre = new int[MAXN];
+	// cnt[x] = a，表示窗口内，前缀异或和x，一共有a个
 	public static long[] cnt = new long[MAXS];
+	// cur表示窗口内，异或和为k的子数组数量
 	public static long cur;
-
 	public static long[] ans = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
diff --git a/src/class176/Code05_XorSequence2.java b/src/class176/Code05_XorSequence2.java
index 841569e86..aa6c68d7a 100644
--- a/src/class176/Code05_XorSequence2.java
+++ b/src/class176/Code05_XorSequence2.java
@@ -21,12 +21,11 @@
 //int n, m, k;
 //int arr[MAXN];
 //Query query[MAXN];
-//
 //int bi[MAXN];
+//
 //int pre[MAXN];
 //long long cnt[MAXS];
 //long long cur;
-//
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {

From eff2f20b5e447e603435332f858dd55b76c34305 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 20:59:31 +0800
Subject: [PATCH 1295/1712] modify code

---
 src/class176/Code05_XorSequence1.java | 26 ++++++++++++++------------
 src/class176/Code05_XorSequence2.java | 20 ++++++++++----------
 2 files changed, 24 insertions(+), 22 deletions(-)

diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index be0ebcf5e..5c84033b6 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -27,8 +27,8 @@ public class Code05_XorSequence1 {
 	public static int[] pre = new int[MAXN];
 	// cnt[x] = a，表示窗口内，前缀异或和x，一共有a个
 	public static long[] cnt = new long[MAXS];
-	// cur表示窗口内，异或和为k的子数组数量
-	public static long cur;
+	// num表示窗口内，异或和为k的子数组数量
+	public static long num;
 	public static long[] ans = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
@@ -43,31 +43,33 @@ public int compare(int[] a, int[] b) {
 
 	}
 
+	// 前缀异或和x要删除一次
 	public static void del(int x) {
 		if (k != 0) {
-			cur -= cnt[x] * cnt[x ^ k];
+			num -= cnt[x] * cnt[x ^ k];
 		} else {
-			cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
+			num -= (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
 		cnt[x]--;
 		if (k != 0) {
-			cur += cnt[x] * cnt[x ^ k];
+			num += cnt[x] * cnt[x ^ k];
 		} else {
-			cur += (cnt[x] * (cnt[x] - 1)) >> 1;
+			num += (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
 	}
 
+	// 前缀异或和x要增加一次
 	public static void add(int x) {
 		if (k != 0) {
-			cur -= cnt[x] * cnt[x ^ k];
+			num -= cnt[x] * cnt[x ^ k];
 		} else {
-			cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
+			num -= (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
 		cnt[x]++;
 		if (k != 0) {
-			cur += cnt[x] * cnt[x ^ k];
+			num += cnt[x] * cnt[x ^ k];
 		} else {
-			cur += (cnt[x] * (cnt[x] - 1)) >> 1;
+			num += (cnt[x] * (cnt[x] - 1)) >> 1;
 		}
 	}
 
@@ -85,7 +87,7 @@ public static void prepare() {
 	public static void compute() {
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
-			// 左边界要-1
+			// 窗口[l..r]，但是前缀可能性多一种，1..l-1
 			int jobl = query[i][0] - 1;
 			int jobr = query[i][1];
 			while (winl > jobl) {
@@ -100,7 +102,7 @@ public static void compute() {
 			while (winr > jobr) {
 				del(pre[winr--]);
 			}
-			ans[query[i][2]] = cur;
+			ans[query[i][2]] = num;
 		}
 	}
 
diff --git a/src/class176/Code05_XorSequence2.java b/src/class176/Code05_XorSequence2.java
index aa6c68d7a..cbba1cacc 100644
--- a/src/class176/Code05_XorSequence2.java
+++ b/src/class176/Code05_XorSequence2.java
@@ -25,7 +25,7 @@
 //
 //int pre[MAXN];
 //long long cnt[MAXS];
-//long long cur;
+//long long num;
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -37,29 +37,29 @@
 //
 //void del(int x) {
 //    if (k != 0) {
-//        cur -= cnt[x] * cnt[x ^ k];
+//        num -= cnt[x] * cnt[x ^ k];
 //    } else {
-//        cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
+//        num -= (cnt[x] * (cnt[x] - 1)) >> 1;
 //    }
 //    cnt[x]--;
 //    if (k != 0) {
-//        cur += cnt[x] * cnt[x ^ k];
+//        num += cnt[x] * cnt[x ^ k];
 //    } else {
-//        cur += (cnt[x] * (cnt[x] - 1)) >> 1;
+//        num += (cnt[x] * (cnt[x] - 1)) >> 1;
 //    }
 //}
 //
 //void add(int x) {
 //    if (k != 0) {
-//        cur -= cnt[x] * cnt[x ^ k];
+//        num -= cnt[x] * cnt[x ^ k];
 //    } else {
-//        cur -= (cnt[x] * (cnt[x] - 1)) >> 1;
+//        num -= (cnt[x] * (cnt[x] - 1)) >> 1;
 //    }
 //    cnt[x]++;
 //    if (k != 0) {
-//        cur += cnt[x] * cnt[x ^ k];
+//        num += cnt[x] * cnt[x ^ k];
 //    } else {
-//        cur += (cnt[x] * (cnt[x] - 1)) >> 1;
+//        num += (cnt[x] * (cnt[x] - 1)) >> 1;
 //    }
 //}
 //
@@ -91,7 +91,7 @@
 //        while (winr > jobr) {
 //            del(pre[winr--]);
 //        }
-//        ans[query[i].id] = cur;
+//        ans[query[i].id] = num;
 //    }
 //}
 //

From d67b6ff8c0d16f1add8e2499c80c443424f9b4b8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 19 Aug 2025 21:18:17 +0800
Subject: [PATCH 1296/1712] modify code

---
 src/class176/Code05_XorSequence1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class176/Code05_XorSequence1.java b/src/class176/Code05_XorSequence1.java
index 5c84033b6..8f2375ad8 100644
--- a/src/class176/Code05_XorSequence1.java
+++ b/src/class176/Code05_XorSequence1.java
@@ -87,7 +87,8 @@ public static void prepare() {
 	public static void compute() {
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
-			// 窗口[l..r]，但是前缀可能性多一种，1..l-1
+			// 任务范围[jobl, jobr]，但是前缀可能性会多一种
+			// 所以左边界-1
 			int jobl = query[i][0] - 1;
 			int jobr = query[i][1];
 			while (winl > jobl) {

From f7a9391645546a5b97987d396fdb1b969affb74a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Aug 2025 18:38:54 +0800
Subject: [PATCH 1297/1712] modify code

---
 src/class176/Code06_MoWithModify1.java | 49 ++++++++++++++------------
 src/class176/Code06_MoWithModify2.java | 19 +++++-----
 2 files changed, 37 insertions(+), 31 deletions(-)

diff --git a/src/class176/Code06_MoWithModify1.java b/src/class176/Code06_MoWithModify1.java
index 025504dee..b3d681652 100644
--- a/src/class176/Code06_MoWithModify1.java
+++ b/src/class176/Code06_MoWithModify1.java
@@ -18,6 +18,22 @@
 
 public class Code06_MoWithModify1 {
 
+	public static int MAXN = 200001;
+	public static int MAXV = 1000001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	public static int[][] query = new int[MAXN][4];
+	public static int[][] update = new int[MAXN][2];
+	public static int cntq, cntu;
+
+	public static int[] cnt = new int[MAXV];
+	public static int kind;
+
+	public static int[] ans = new int[MAXN];
+
+	// 带修莫队的任务排序
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
@@ -33,20 +49,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static int MAXN = 200001;
-	public static int MAXV = 1000001;
-	public static int n, m;
-	public static int[] arr = new int[MAXN];
-	public static int[] bi = new int[MAXN];
-
-	public static int[][] query = new int[MAXN][4];
-	public static int[][] update = new int[MAXN][2];
-	public static int cntq, cntu;
-
-	public static int[] cnt = new int[MAXV];
-	public static int[] ans = new int[MAXN];
-	public static int kind;
-
 	public static void del(int num) {
 		if (--cnt[num] == 0) {
 			kind--;
@@ -66,19 +68,14 @@ public static void moveTime(int jobl, int jobr, int tim) {
 			del(arr[pos]);
 			add(val);
 		}
+		// 这里比较巧妙
+		// 修改时间点不管前进还是后退
+		// 数据只要在arr和update之间交换即可
 		int tmp = arr[pos];
 		arr[pos] = val;
 		update[tim][1] = tmp;
 	}
 
-	public static void prepare() {
-		int blen = Math.max(1, (int) Math.pow(n, 2.0 / 3));
-		for (int i = 1; i <= n; i++) {
-			bi[i] = (i - 1) / blen + 1;
-		}
-		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
-	}
-
 	public static void compute() {
 		int winl = 1, winr = 0, wint = 0;
 		for (int i = 1; i <= cntq; i++) {
@@ -108,6 +105,14 @@ public static void compute() {
 		}
 	}
 
+	public static void prepare() {
+		int blen = Math.max(1, (int) Math.pow(n, 2.0 / 3));
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+	}
+
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader();
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
diff --git a/src/class176/Code06_MoWithModify2.java b/src/class176/Code06_MoWithModify2.java
index 7b7adcfe4..bf31d940d 100644
--- a/src/class176/Code06_MoWithModify2.java
+++ b/src/class176/Code06_MoWithModify2.java
@@ -33,9 +33,10 @@
 //int cntq, cntu;
 //
 //int cnt[MAXV];
-//int ans[MAXN];
 //int kind;
 //
+//int ans[MAXN];
+//
 //bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
@@ -70,14 +71,6 @@
 //    update[tim].val = tmp;
 //}
 //
-//void prepare() {
-//    int blen = max(1, (int)pow(n, 2.0 / 3));
-//    for (int i = 1; i <= n; i++) {
-//        bi[i] = (i - 1) / blen + 1;
-//    }
-//    sort(query + 1, query + cntq + 1, QueryCmp);
-//}
-//
 //void compute() {
 //    int winl = 1, winr = 0, wint = 0;
 //    for (int i = 1; i <= cntq; i++) {
@@ -107,6 +100,14 @@
 //     }
 //}
 //
+//void prepare() {
+//    int blen = max(1, (int)pow(n, 2.0 / 3));
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//}
+//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);

From 7ade0c46d424333032a0288c6b25fe480c23af57 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Aug 2025 18:40:46 +0800
Subject: [PATCH 1298/1712] modify code

---
 src/class176/Code06_MoWithModify1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class176/Code06_MoWithModify1.java b/src/class176/Code06_MoWithModify1.java
index b3d681652..124d67dd7 100644
--- a/src/class176/Code06_MoWithModify1.java
+++ b/src/class176/Code06_MoWithModify1.java
@@ -69,7 +69,7 @@ public static void moveTime(int jobl, int jobr, int tim) {
 			add(val);
 		}
 		// 这里比较巧妙
-		// 修改时间点不管前进还是后退
+		// 时间窗口不管前进还是后退
 		// 数据只要在arr和update之间交换即可
 		int tmp = arr[pos];
 		arr[pos] = val;

From e4c0badb33619b9f9bf845022430714803abc3f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Aug 2025 18:41:05 +0800
Subject: [PATCH 1299/1712] modify code

---
 src/class176/Code06_MoWithModify1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class176/Code06_MoWithModify1.java b/src/class176/Code06_MoWithModify1.java
index 124d67dd7..b759cf6b9 100644
--- a/src/class176/Code06_MoWithModify1.java
+++ b/src/class176/Code06_MoWithModify1.java
@@ -68,7 +68,6 @@ public static void moveTime(int jobl, int jobr, int tim) {
 			del(arr[pos]);
 			add(val);
 		}
-		// 这里比较巧妙
 		// 时间窗口不管前进还是后退
 		// 数据只要在arr和update之间交换即可
 		int tmp = arr[pos];

From e21812f9f78f241b6000cce82435472f03d629af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 20 Aug 2025 22:43:28 +0800
Subject: [PATCH 1300/1712] modify code

---
 src/class176/Code06_MoWithModify1.java | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/src/class176/Code06_MoWithModify1.java b/src/class176/Code06_MoWithModify1.java
index b759cf6b9..9f6dba6a7 100644
--- a/src/class176/Code06_MoWithModify1.java
+++ b/src/class176/Code06_MoWithModify1.java
@@ -24,7 +24,9 @@ public class Code06_MoWithModify1 {
 	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
 
+	// 每条查询 : jobl、jobr、jobt、id
 	public static int[][] query = new int[MAXN][4];
+	// 每条修改 : pos、val
 	public static int[][] update = new int[MAXN][2];
 	public static int cntq, cntu;
 
@@ -61,6 +63,8 @@ public static void add(int num) {
 		}
 	}
 
+	// jobl..jobr 数组范围
+	// tim : 生效或者撤销的修改时间点
 	public static void moveTime(int jobl, int jobr, int tim) {
 		int pos = update[tim][0];
 		int val = update[tim][1];
@@ -68,8 +72,7 @@ public static void moveTime(int jobl, int jobr, int tim) {
 			del(arr[pos]);
 			add(val);
 		}
-		// 时间窗口不管前进还是后退
-		// 数据只要在arr和update之间交换即可
+		// 不管生效还是撤销，数据只要在arr和update之间交换即可
 		int tmp = arr[pos];
 		arr[pos] = val;
 		update[tim][1] = tmp;

From f84967d0984c1c0e4e22d83d7141ad785ff0f78c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Aug 2025 14:59:33 +0800
Subject: [PATCH 1301/1712] modify code

---
 src/class176/Code07_UniqueNumbers1.java       | 219 +++++++++++++++++
 ...rence2.java => Code07_UniqueNumbers2.java} | 116 +++------
 ...ing1.java => Code08_MachineLearning1.java} |  43 ++--
 ...ing2.java => Code08_MachineLearning2.java} |  15 +-
 src/class176/Code08_MinimumDifference1.java   | 232 ------------------
 5 files changed, 290 insertions(+), 335 deletions(-)
 create mode 100644 src/class176/Code07_UniqueNumbers1.java
 rename src/class176/{Code08_MinimumDifference2.java => Code07_UniqueNumbers2.java} (50%)
 rename src/class176/{Code07_MachineLearning1.java => Code08_MachineLearning1.java} (97%)
 rename src/class176/{Code07_MachineLearning2.java => Code08_MachineLearning2.java} (96%)
 delete mode 100644 src/class176/Code08_MinimumDifference1.java

diff --git a/src/class176/Code07_UniqueNumbers1.java b/src/class176/Code07_UniqueNumbers1.java
new file mode 100644
index 000000000..8d18790f1
--- /dev/null
+++ b/src/class176/Code07_UniqueNumbers1.java
@@ -0,0 +1,219 @@
+package class176;
+
+// 统计出现1次的数，java版
+// 给定一个长度为n的数组arr，下标0~n-1，一共有m条操作，格式如下
+// 操作 1 pos val : 把arr[pos]的值设置成val
+// 操作 2 l r     : 查询arr[l..r]范围上，有多少种数出现了1次
+// 0 <= n、m、arr[i] <= 2 * 10^5 
+// 测试链接 : https://www.luogu.com.cn/problem/SP30906
+// 测试链接 : https://www.spoj.com/problems/ADAUNIQ/
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code07_UniqueNumbers2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code07_UniqueNumbers1 {
+
+	public static int MAXN = 200001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	public static int[][] query = new int[MAXN][4];
+	public static int[][] update = new int[MAXN][2];
+	public static int cntq, cntu;
+
+	public static int[] cnt = new int[MAXN];
+	public static int curAns = 0;
+
+	public static int[] ans = new int[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if (bi[a[1]] != bi[b[1]]) {
+				return bi[a[1]] - bi[b[1]];
+			}
+			return a[2] - b[2];
+		}
+	}
+
+	public static void del(int num) {
+		if (cnt[num] == 1) {
+			curAns--;
+		}
+		if (cnt[num] == 2) {
+			curAns++;
+		}
+		cnt[num]--;
+	}
+
+	public static void add(int num) {
+		if (cnt[num] == 0) {
+			curAns++;
+		}
+		if (cnt[num] == 1) {
+			curAns--;
+		}
+		cnt[num]++;
+	}
+
+	public static void moveTime(int jobl, int jobr, int tim) {
+		int pos = update[tim][0];
+		int val = update[tim][1];
+		if (jobl <= pos && pos <= jobr) {
+			del(arr[pos]);
+			add(val);
+		}
+		int tmp = arr[pos];
+		arr[pos] = val;
+		update[tim][1] = tmp;
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0, wint = 0;
+		for (int i = 1; i <= cntq; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int jobt = query[i][2];
+			int id = query[i][3];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			while (wint < jobt) {
+				moveTime(jobl, jobr, ++wint);
+			}
+			while (wint > jobt) {
+				moveTime(jobl, jobr, wint--);
+			}
+			ans[id] = curAns;
+		}
+	}
+
+	public static void prepare() {
+		int blen = Math.max(1, (int) Math.pow(n, 2.0 / 3));
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1, op, l, r, pos, val; i <= m; i++) {
+			op = in.nextInt();
+			if (op == 1) {
+				pos = in.nextInt();
+				val = in.nextInt();
+				cntu++;
+				update[cntu][0] = pos + 1;
+				update[cntu][1] = val;
+			} else {
+				l = in.nextInt();
+				r = in.nextInt();
+				cntq++;
+				query[cntq][0] = l + 1;
+				query[cntq][1] = r + 1;
+				query[cntq][2] = cntu;
+				query[cntq][3] = cntq;
+			}
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}
diff --git a/src/class176/Code08_MinimumDifference2.java b/src/class176/Code07_UniqueNumbers2.java
similarity index 50%
rename from src/class176/Code08_MinimumDifference2.java
rename to src/class176/Code07_UniqueNumbers2.java
index ffc3a61a0..05cba1d82 100644
--- a/src/class176/Code08_MinimumDifference2.java
+++ b/src/class176/Code07_UniqueNumbers2.java
@@ -1,15 +1,12 @@
 package class176;
 
-// 最小化极差，C++版
-// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
-// 操作 1 l r k   : arr[l..r]范围上，选出k个真的出现并且互不相同的数
-//                  这些数假设为a1、a2 .. ak，对应的出现次数假设为cnt1、cnt2 .. cntk
-//                  打印 max{cnt1 .. cntk} - min{cnt1 .. cntk} 的最小值
-//                  如果无法选出k个数，打印-1
-// 操作 2 pos val : 把arr[pos]的值设置成val
-// 1 <= 所有数据 <= 10^5
-// 测试链接 : https://www.luogu.com.cn/problem/CF1476G
-// 测试链接 : https://codeforces.com/problemset/problem/1476/G
+// 统计出现1次的数，C++版
+// 给定一个长度为n的数组arr，下标0~n-1，一共有m条操作，格式如下
+// 操作 1 pos val : 把arr[pos]的值设置成val
+// 操作 2 l r     : 查询arr[l..r]范围上，有多少种数出现了1次
+// 0 <= n、m、arr[i] <= 2 * 10^5 
+// 测试链接 : https://www.luogu.com.cn/problem/SP30906
+// 测试链接 : https://www.spoj.com/problems/ADAUNIQ/
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
@@ -18,30 +15,25 @@
 //using namespace std;
 //
 //struct Query {
-//    int l, r, k, t, id;
+//    int l, r, t, id;
 //};
 //
 //struct Update {
 //    int pos, val;
 //};
 //
-//const int MAXN = 100001;
-//const int MAXB = 3001;
+//const int MAXN = 200001;
 //int n, m;
 //int arr[MAXN];
 //int bi[MAXN];
-//int bl[MAXB];
-//int br[MAXB];
 //
 //Query query[MAXN];
 //Update update[MAXN];
 //int cntq, cntu;
 //
-//int cnt1[MAXN];
-//int cnt2[MAXN];
-//int sum[MAXB];
-//int cntFreq[MAXN];
-//int freqVal[MAXN];
+//int cnt[MAXN];
+//int curAns;
+//
 //int ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -55,19 +47,23 @@
 //}
 //
 //void del(int num) {
-//    cnt2[cnt1[num]]--;
-//    sum[bi[cnt1[num]]]--;
-//    cnt1[num]--;
-//    cnt2[cnt1[num]]++;
-//    sum[bi[cnt1[num]]]++;
+//    if (cnt[num] == 1) {
+//        curAns--;
+//    }
+//    if (cnt[num] == 2) {
+//        curAns++;
+//    }
+//    cnt[num]--;
 //}
 //
 //void add(int num) {
-//    cnt2[cnt1[num]]--;
-//    sum[bi[cnt1[num]]]--;
-//    cnt1[num]++;
-//    cnt2[cnt1[num]]++;
-//    sum[bi[cnt1[num]]]++;
+//    if (cnt[num] == 0) {
+//        curAns++;
+//    }
+//    if (cnt[num] == 1) {
+//        curAns--;
+//    }
+//    cnt[num]++;
 //}
 //
 //void moveTime(int jobl, int jobr, int tim) {
@@ -82,41 +78,13 @@
 //    update[tim].val = tmp;
 //}
 //
-//int getAns(int k) {
-//    int size = 0;
-//    for (int b = 1; b <= bi[n]; b++) {
-//        if (sum[b] != 0) {
-//            for (int f = bl[b]; f <= br[b]; f++) {
-//                if (cnt2[f] > 0) {
-//                    cntFreq[++size] = cnt2[f];
-//                    freqVal[size] = f;
-//                }
-//            }
-//        }
-//    }
-//    int minDiff = INT_MAX;
-//    int cntSum = 0;
-//    for (int l = 1, r = 0; l <= size; l++) {
-//        while (cntSum < k && r < size) {
-//            r++;
-//            cntSum += cntFreq[r];
-//        }
-//        if (cntSum >= k) {
-//            minDiff = min(minDiff, freqVal[r] - freqVal[l]);
-//        }
-//        cntSum -= cntFreq[l];
-//    }
-//    return minDiff == INT_MAX ? -1 : minDiff;
-//}
-//
 //void compute() {
 //    int winl = 1, winr = 0, wint = 0;
 //    for (int i = 1; i <= cntq; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
-//        int jobk = query[i].k;
 //        int jobt = query[i].t;
-//        int id   = query[i].id;
+//        int id = query[i].id;
 //        while (winl > jobl) {
 //            add(arr[--winl]);
 //        }
@@ -135,20 +103,15 @@
 //        while (wint > jobt) {
 //            moveTime(jobl, jobr, wint--);
 //        }
-//        ans[id] = getAns(jobk);
-//    }
+//        ans[id] = curAns;
+//     }
 //}
 //
 //void prepare() {
-//    int blen = max(1, (int)pow(n, 2.0 / 3.0));
-//    int bnum = (n + blen - 1) / blen;
+//    int blen = max(1, (int)pow(n, 2.0 / 3));
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    for (int i = 1; i <= bnum; i++) {
-//        bl[i] = (i - 1) * blen + 1;
-//        br[i] = min(i * blen, n);
-//    }
 //    sort(query + 1, query + cntq + 1, QueryCmp);
 //}
 //
@@ -159,21 +122,20 @@
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
-//    for (int i = 1, op, l, r, k, pos, val; i <= m; i++) {
+//    for (int i = 1, op, l, r, pos, val; i <= m; i++) {
 //        cin >> op;
 //        if (op == 1) {
-//            cin >> l >> r >> k;
-//            cntq++;
-//            query[cntq].l = l;
-//            query[cntq].r = r;
-//            query[cntq].k = k;
-//            query[cntq].t = cntu;
-//            query[cntq].id = cntq;
-//        } else {
 //            cin >> pos >> val;
 //            cntu++;
-//            update[cntu].pos = pos;
+//            update[cntu].pos = pos + 1;
 //            update[cntu].val = val;
+//        } else {
+//            cin >> l >> r;
+//            cntq++;
+//            query[cntq].l = l + 1;
+//            query[cntq].r = r + 1;
+//            query[cntq].t = cntu;
+//            query[cntq].id = cntq;
 //        }
 //    }
 //    prepare();
diff --git a/src/class176/Code07_MachineLearning1.java b/src/class176/Code08_MachineLearning1.java
similarity index 97%
rename from src/class176/Code07_MachineLearning1.java
rename to src/class176/Code08_MachineLearning1.java
index a52ff438b..f51730060 100644
--- a/src/class176/Code07_MachineLearning1.java
+++ b/src/class176/Code08_MachineLearning1.java
@@ -18,20 +18,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code07_MachineLearning1 {
-
-	public static class QueryCmp implements Comparator<int[]> {
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return bi[a[0]] - bi[b[0]];
-			}
-			if (bi[a[1]] != bi[b[1]]) {
-				return bi[a[1]] - bi[b[1]];
-			}
-			return a[2] - b[2];
-		}
-	}
+public class Code08_MachineLearning1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
@@ -45,8 +32,22 @@ public int compare(int[] a, int[] b) {
 
 	public static int[] cnt1 = new int[MAXN << 1];
 	public static int[] cnt2 = new int[MAXN];
+
 	public static int[] ans = new int[MAXN];
 
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if (bi[a[1]] != bi[b[1]]) {
+				return bi[a[1]] - bi[b[1]];
+			}
+			return a[2] - b[2];
+		}
+	}
+
 	public static int kth(int len, int num) {
 		int left = 1, right = len, mid, ret = 0;
 		while (left <= right) {
@@ -61,14 +62,16 @@ public static int kth(int len, int num) {
 		return ret;
 	}
 
-	public static void add(int num) {
-		--cnt2[cnt1[num]];
-		++cnt2[++cnt1[num]];
+	public static void del(int num) {
+		cnt2[cnt1[num]]--;
+		cnt1[num]--;
+		cnt2[cnt1[num]]++;
 	}
 
-	public static void del(int num) {
-		--cnt2[cnt1[num]];
-		++cnt2[--cnt1[num]];
+	public static void add(int num) {
+		cnt2[cnt1[num]]--;
+		cnt1[num]++;
+		cnt2[cnt1[num]]++;
 	}
 
 	public static void moveTime(int jobl, int jobr, int tim) {
diff --git a/src/class176/Code07_MachineLearning2.java b/src/class176/Code08_MachineLearning2.java
similarity index 96%
rename from src/class176/Code07_MachineLearning2.java
rename to src/class176/Code08_MachineLearning2.java
index ed2750fd1..065b2be6c 100644
--- a/src/class176/Code07_MachineLearning2.java
+++ b/src/class176/Code08_MachineLearning2.java
@@ -36,6 +36,7 @@
 //
 //int cnt1[MAXN << 1];
 //int cnt2[MAXN];
+//
 //int ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -62,14 +63,16 @@
 //    return ret;
 //}
 //
-//void add(int num) {
-//    --cnt2[cnt1[num]];
-//    ++cnt2[++cnt1[num]];
+//void del(int num) {
+//    cnt2[cnt1[num]]--;
+//    cnt1[num]--;
+//    cnt2[cnt1[num]]++;
 //}
 //
-//void del(int num) {
-//    --cnt2[cnt1[num]];
-//    ++cnt2[--cnt1[num]];
+//void add(int num) {
+//    cnt2[cnt1[num]]--;
+//    cnt1[num]++;
+//    cnt2[cnt1[num]]++;
 //}
 //
 //void moveTime(int jobl, int jobr, int tim) {
diff --git a/src/class176/Code08_MinimumDifference1.java b/src/class176/Code08_MinimumDifference1.java
deleted file mode 100644
index 407cd784e..000000000
--- a/src/class176/Code08_MinimumDifference1.java
+++ /dev/null
@@ -1,232 +0,0 @@
-package class176;
-
-// 最小化极差，java版
-// 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
-// 操作 1 l r k   : arr[l..r]范围上，选出k个真的出现并且互不相同的数
-//                  这些数假设为a1、a2 .. ak，对应的出现次数假设为cnt1、cnt2 .. cntk
-//                  打印 max{cnt1 .. cntk} - min{cnt1 .. cntk} 的最小值
-//                  如果无法选出k个数，打印-1
-// 操作 2 pos val : 把arr[pos]的值设置成val
-// 1 <= 所有数据 <= 10^5
-// 测试链接 : https://www.luogu.com.cn/problem/CF1476G
-// 测试链接 : https://codeforces.com/problemset/problem/1476/G
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
-
-import java.io.IOException;
-import java.io.InputStream;
-import java.io.OutputStreamWriter;
-import java.io.PrintWriter;
-import java.util.Arrays;
-import java.util.Comparator;
-
-public class Code08_MinimumDifference1 {
-
-	public static class QueryCmp implements Comparator<int[]> {
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return bi[a[0]] - bi[b[0]];
-			}
-			if (bi[a[1]] != bi[b[1]]) {
-				return bi[a[1]] - bi[b[1]];
-			}
-			return a[3] - b[3];
-		}
-	}
-
-	public static int MAXN = 100001;
-	public static int MAXB = 3001;
-	public static int n, m;
-	public static int[] arr = new int[MAXN];
-	public static int[] bi = new int[MAXN];
-	public static int[] bl = new int[MAXB];
-	public static int[] br = new int[MAXB];
-
-	// query : l, r, k, t, id
-	// update : pos, val
-	public static int[][] query = new int[MAXN][5];
-	public static int[][] update = new int[MAXN][2];
-	public static int cntq, cntu;
-
-	public static int[] cnt1 = new int[MAXN];
-	public static int[] cnt2 = new int[MAXN];
-	public static int[] sum = new int[MAXB];
-	public static int[] cntFreq = new int[MAXN];
-	public static int[] freqVal = new int[MAXN];
-	public static int[] ans = new int[MAXN];
-
-	public static void del(int num) {
-		cnt2[cnt1[num]]--;
-		sum[bi[cnt1[num]]]--;
-		cnt1[num]--;
-		cnt2[cnt1[num]]++;
-		sum[bi[cnt1[num]]]++;
-	}
-
-	public static void add(int num) {
-		cnt2[cnt1[num]]--;
-		sum[bi[cnt1[num]]]--;
-		cnt1[num]++;
-		cnt2[cnt1[num]]++;
-		sum[bi[cnt1[num]]]++;
-	}
-
-	public static void moveTime(int jobl, int jobr, int tim) {
-		int pos = update[tim][0];
-		int val = update[tim][1];
-		if (jobl <= pos && pos <= jobr) {
-			del(arr[pos]);
-			add(val);
-		}
-		int tmp = arr[pos];
-		arr[pos] = val;
-		update[tim][1] = tmp;
-	}
-
-	public static int getAns(int k) {
-		int size = 0;
-		for (int b = 1; b <= bi[n]; b++) {
-			if (sum[b] != 0) {
-				for (int f = bl[b]; f <= br[b]; f++) {
-					if (cnt2[f] > 0) {
-						cntFreq[++size] = cnt2[f];
-						freqVal[size] = f;
-					}
-				}
-			}
-		}
-		int minDiff = Integer.MAX_VALUE;
-		int cntSum = 0;
-		for (int l = 1, r = 0; l <= size; l++) {
-			while (cntSum < k && r < size) {
-				r++;
-				cntSum += cntFreq[r];
-			}
-			if (cntSum >= k) {
-				minDiff = Math.min(minDiff, freqVal[r] - freqVal[l]);
-			}
-			cntSum -= cntFreq[l];
-		}
-		return minDiff == Integer.MAX_VALUE ? -1 : minDiff;
-	}
-
-	public static void compute() {
-		int winl = 1, winr = 0, wint = 0;
-		for (int i = 1; i <= cntq; i++) {
-			int jobl = query[i][0];
-			int jobr = query[i][1];
-			int jobk = query[i][2];
-			int jobt = query[i][3];
-			int id = query[i][4];
-			while (winl > jobl) {
-				add(arr[--winl]);
-			}
-			while (winr < jobr) {
-				add(arr[++winr]);
-			}
-			while (winl < jobl) {
-				del(arr[winl++]);
-			}
-			while (winr > jobr) {
-				del(arr[winr--]);
-			}
-			while (wint < jobt) {
-				moveTime(jobl, jobr, ++wint);
-			}
-			while (wint > jobt) {
-				moveTime(jobl, jobr, wint--);
-			}
-			ans[id] = getAns(jobk);
-		}
-	}
-
-	public static void prepare() {
-		int blen = Math.max(1, (int) Math.pow(n, 2.0 / 3));
-		int bnum = (n + blen - 1) / blen;
-		for (int i = 1; i <= n; i++) {
-			bi[i] = (i - 1) / blen + 1;
-		}
-		for (int i = 1; i <= bnum; i++) {
-			bl[i] = (i - 1) * blen + 1;
-			br[i] = Math.min(i * blen, n);
-		}
-		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
-	}
-
-	public static void main(String[] args) throws Exception {
-		FastReader in = new FastReader(System.in);
-		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		n = in.nextInt();
-		m = in.nextInt();
-		for (int i = 1; i <= n; i++) {
-			arr[i] = in.nextInt();
-		}
-		for (int i = 1, op, l, r, k, pos, val; i <= m; i++) {
-			op = in.nextInt();
-			if (op == 1) {
-				l = in.nextInt();
-				r = in.nextInt();
-				k = in.nextInt();
-				cntq++;
-				query[cntq][0] = l;
-				query[cntq][1] = r;
-				query[cntq][2] = k;
-				query[cntq][3] = cntu;
-				query[cntq][4] = cntq;
-			} else {
-				pos = in.nextInt();
-				val = in.nextInt();
-				cntu++;
-				update[cntu][0] = pos;
-				update[cntu][1] = val;
-			}
-		}
-		prepare();
-		compute();
-		for (int i = 1; i <= cntq; i++) {
-			out.println(ans[i]);
-		}
-		out.flush();
-		out.close();
-	}
-
-	// 读写工具类
-	static class FastReader {
-		private final byte[] buffer = new byte[1 << 16];
-		private int ptr = 0, len = 0;
-		private final InputStream in;
-
-		FastReader(InputStream in) {
-			this.in = in;
-		}
-
-		private int readByte() throws IOException {
-			if (ptr >= len) {
-				len = in.read(buffer);
-				ptr = 0;
-				if (len <= 0)
-					return -1;
-			}
-			return buffer[ptr++];
-		}
-
-		int nextInt() throws IOException {
-			int c;
-			do {
-				c = readByte();
-			} while (c <= ' ' && c != -1);
-			boolean neg = false;
-			if (c == '-') {
-				neg = true;
-				c = readByte();
-			}
-			int val = 0;
-			while (c > ' ' && c != -1) {
-				val = val * 10 + (c - '0');
-				c = readByte();
-			}
-			return neg ? -val : val;
-		}
-	}
-
-}

From 41094e0307323edc79b5d5b2acd9d89caeda7558 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Aug 2025 15:48:54 +0800
Subject: [PATCH 1302/1712] modify code

---
 src/class176/Code07_UniqueNumbers1.java | 14 ++++++++------
 src/class176/Code07_UniqueNumbers2.java | 12 ++++++------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/class176/Code07_UniqueNumbers1.java b/src/class176/Code07_UniqueNumbers1.java
index 8d18790f1..6d1c6d9e0 100644
--- a/src/class176/Code07_UniqueNumbers1.java
+++ b/src/class176/Code07_UniqueNumbers1.java
@@ -30,8 +30,10 @@ public class Code07_UniqueNumbers1 {
 	public static int[][] update = new int[MAXN][2];
 	public static int cntq, cntu;
 
+	// 每种数字的词频统计
 	public static int[] cnt = new int[MAXN];
-	public static int curAns = 0;
+	// curCnt代表出现次数1次的数有几种
+	public static int curCnt = 0;
 
 	public static int[] ans = new int[MAXN];
 
@@ -50,20 +52,20 @@ public int compare(int[] a, int[] b) {
 
 	public static void del(int num) {
 		if (cnt[num] == 1) {
-			curAns--;
+			curCnt--;
 		}
 		if (cnt[num] == 2) {
-			curAns++;
+			curCnt++;
 		}
 		cnt[num]--;
 	}
 
 	public static void add(int num) {
 		if (cnt[num] == 0) {
-			curAns++;
+			curCnt++;
 		}
 		if (cnt[num] == 1) {
-			curAns--;
+			curCnt--;
 		}
 		cnt[num]++;
 	}
@@ -105,7 +107,7 @@ public static void compute() {
 			while (wint > jobt) {
 				moveTime(jobl, jobr, wint--);
 			}
-			ans[id] = curAns;
+			ans[id] = curCnt;
 		}
 	}
 
diff --git a/src/class176/Code07_UniqueNumbers2.java b/src/class176/Code07_UniqueNumbers2.java
index 05cba1d82..97b6217ea 100644
--- a/src/class176/Code07_UniqueNumbers2.java
+++ b/src/class176/Code07_UniqueNumbers2.java
@@ -32,7 +32,7 @@
 //int cntq, cntu;
 //
 //int cnt[MAXN];
-//int curAns;
+//int curCnt;
 //
 //int ans[MAXN];
 //
@@ -48,20 +48,20 @@
 //
 //void del(int num) {
 //    if (cnt[num] == 1) {
-//        curAns--;
+//        curCnt--;
 //    }
 //    if (cnt[num] == 2) {
-//        curAns++;
+//        curCnt++;
 //    }
 //    cnt[num]--;
 //}
 //
 //void add(int num) {
 //    if (cnt[num] == 0) {
-//        curAns++;
+//        curCnt++;
 //    }
 //    if (cnt[num] == 1) {
-//        curAns--;
+//        curCnt--;
 //    }
 //    cnt[num]++;
 //}
@@ -103,7 +103,7 @@
 //        while (wint > jobt) {
 //            moveTime(jobl, jobr, wint--);
 //        }
-//        ans[id] = curAns;
+//        ans[id] = curCnt;
 //     }
 //}
 //

From 6bc56187d31e7dff1d332ab282e1fb463239b56b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Aug 2025 15:50:55 +0800
Subject: [PATCH 1303/1712] modify code

---
 .../{Code08_MachineLearning1.java => Code08_CntMex1.java}     | 4 ++--
 .../{Code08_MachineLearning2.java => Code08_CntMex2.java}     | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class176/{Code08_MachineLearning1.java => Code08_CntMex1.java} (98%)
 rename src/class176/{Code08_MachineLearning2.java => Code08_CntMex2.java} (99%)

diff --git a/src/class176/Code08_MachineLearning1.java b/src/class176/Code08_CntMex1.java
similarity index 98%
rename from src/class176/Code08_MachineLearning1.java
rename to src/class176/Code08_CntMex1.java
index f51730060..ebeba53c3 100644
--- a/src/class176/Code08_MachineLearning1.java
+++ b/src/class176/Code08_CntMex1.java
@@ -1,6 +1,6 @@
 package class176;
 
-// 机器学习，java版
+// 次数的mex，java版
 // 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
 // 操作 1 l r     : arr[l..r]范围上，每种数字出现的次数，假设构成一个集合
 //                  打印这个集合中，没出现的最小非负整数，就是打印次数的mex
@@ -18,7 +18,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code08_MachineLearning1 {
+public class Code08_CntMex1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class176/Code08_MachineLearning2.java b/src/class176/Code08_CntMex2.java
similarity index 99%
rename from src/class176/Code08_MachineLearning2.java
rename to src/class176/Code08_CntMex2.java
index 065b2be6c..f33113fbf 100644
--- a/src/class176/Code08_MachineLearning2.java
+++ b/src/class176/Code08_CntMex2.java
@@ -1,6 +1,6 @@
 package class176;
 
-// 机器学习，C++版
+// 次数的mex，C++版
 // 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
 // 操作 1 l r     : arr[l..r]范围上，每种数字出现的次数，假设构成一个集合
 //                  打印这个集合中，没出现的最小非负整数，就是打印次数的mex

From e477efa67ffc75e8823e12f3a448bd7ba6e44a27 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Aug 2025 15:55:28 +0800
Subject: [PATCH 1304/1712] modify code

---
 src/class176/Code08_CntMex1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class176/Code08_CntMex1.java b/src/class176/Code08_CntMex1.java
index ebeba53c3..497ab23bd 100644
--- a/src/class176/Code08_CntMex1.java
+++ b/src/class176/Code08_CntMex1.java
@@ -30,6 +30,8 @@ public class Code08_CntMex1 {
 	public static int[][] update = new int[MAXN][2];
 	public static int cntq, cntu;
 
+	// cnt1[i] = j，表示i这种数出现了j次
+	// cnt2[i] = j，表示出现次数为i的数有j种
 	public static int[] cnt1 = new int[MAXN << 1];
 	public static int[] cnt2 = new int[MAXN];
 

From 48da4340aa9ed1ae0c562b73fcf373f9ac94aec9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Aug 2025 16:00:37 +0800
Subject: [PATCH 1305/1712] modify code

---
 .../{Code08_CntMex1.java => Code08_MachineLearning1.java}   | 6 +++---
 .../{Code08_CntMex2.java => Code08_MachineLearning2.java}   | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)
 rename src/class176/{Code08_CntMex1.java => Code08_MachineLearning1.java} (97%)
 rename src/class176/{Code08_CntMex2.java => Code08_MachineLearning2.java} (97%)

diff --git a/src/class176/Code08_CntMex1.java b/src/class176/Code08_MachineLearning1.java
similarity index 97%
rename from src/class176/Code08_CntMex1.java
rename to src/class176/Code08_MachineLearning1.java
index 497ab23bd..72f973300 100644
--- a/src/class176/Code08_CntMex1.java
+++ b/src/class176/Code08_MachineLearning1.java
@@ -1,9 +1,9 @@
 package class176;
 
-// 次数的mex，java版
+// 机器学习，java版
 // 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
 // 操作 1 l r     : arr[l..r]范围上，每种数字出现的次数，假设构成一个集合
-//                  打印这个集合中，没出现的最小非负整数，就是打印次数的mex
+//                  打印这个集合中，没出现过的最小正数
 // 操作 2 pos val : 把arr[pos]的值设置成val
 // 1 <= n、m <= 10^5
 // 1 <= arr[i]、val <= 10^9
@@ -18,7 +18,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code08_CntMex1 {
+public class Code08_MachineLearning1 {
 
 	public static int MAXN = 100001;
 	public static int n, m;
diff --git a/src/class176/Code08_CntMex2.java b/src/class176/Code08_MachineLearning2.java
similarity index 97%
rename from src/class176/Code08_CntMex2.java
rename to src/class176/Code08_MachineLearning2.java
index f33113fbf..ec53d2360 100644
--- a/src/class176/Code08_CntMex2.java
+++ b/src/class176/Code08_MachineLearning2.java
@@ -1,9 +1,9 @@
 package class176;
 
-// 次数的mex，C++版
+// 机器学习，java版
 // 给定一个长度为n的数组arr，一共有m条操作，操作格式如下
 // 操作 1 l r     : arr[l..r]范围上，每种数字出现的次数，假设构成一个集合
-//                  打印这个集合中，没出现的最小非负整数，就是打印次数的mex
+//                  打印这个集合中，没出现过的最小正数
 // 操作 2 pos val : 把arr[pos]的值设置成val
 // 1 <= n、m <= 10^5
 // 1 <= arr[i]、val <= 10^9

From a84e44cbbb6e5a864e78f4ddb73727848e149f11 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Aug 2025 16:34:48 +0800
Subject: [PATCH 1306/1712] modify code

---
 src/class176/Code08_MachineLearning1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class176/Code08_MachineLearning1.java b/src/class176/Code08_MachineLearning1.java
index 72f973300..dde8f622f 100644
--- a/src/class176/Code08_MachineLearning1.java
+++ b/src/class176/Code08_MachineLearning1.java
@@ -24,8 +24,8 @@ public class Code08_MachineLearning1 {
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	public static int[] sorted = new int[MAXN << 1];
-
 	public static int[] bi = new int[MAXN];
+
 	public static int[][] query = new int[MAXN][4];
 	public static int[][] update = new int[MAXN][2];
 	public static int cntq, cntu;
@@ -113,6 +113,7 @@ public static void compute() {
 			while (wint > jobt) {
 				moveTime(jobl, jobr, wint--);
 			}
+			// 如下枚举看似暴力，其实O(根号n)的复杂度
 			int ret = 1;
 			while (ret <= n && cnt2[ret] > 0) {
 				ret++;

From 478e248aaf10951421546f649bed56a6d204bb19 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 21 Aug 2025 16:41:25 +0800
Subject: [PATCH 1307/1712] modify code

---
 ...46\344\277\256\350\216\253\351\230\237.pptx" | Bin 0 -> 56677 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243176\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2301-\346\231\256\351\200\232\350\216\253\351\230\237\343\200\201\345\270\246\344\277\256\350\216\253\351\230\237.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243176\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2301-\346\231\256\351\200\232\350\216\253\351\230\237\343\200\201\345\270\246\344\277\256\350\216\253\351\230\237.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243176\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2301-\346\231\256\351\200\232\350\216\253\351\230\237\343\200\201\345\270\246\344\277\256\350\216\253\351\230\237.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..6e1e73b7a3e0e8b850ee99b0507edb1e8b0d5c24
GIT binary patch
literal 56677
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
V+rYdV21WvSQvklabf12G`(I+fXfpr+

literal 0
HcmV?d00001


From 6ebcde04d343177917df0ab07b434512b8ae1be8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Aug 2025 13:49:07 +0800
Subject: [PATCH 1308/1712] modify code

---
 src/class177/Code01_MoOnlyAdd1.java         | 200 +++++++++++++++++
 src/class177/Code02_ThresholdMajority1.java | 171 +++++++++++++++
 src/class177/Code03_SameNumberMaxDist1.java | 218 +++++++++++++++++++
 src/class177/Code04_ZeroQuery1.java         | 224 ++++++++++++++++++++
 src/class177/Code05_MoOnlyDel1.java         | 165 ++++++++++++++
 src/class177/Code06_BaldChief1.java         | 185 ++++++++++++++++
 src/class177/Code06_BaldChief2.java         | 132 ++++++++++++
 7 files changed, 1295 insertions(+)
 create mode 100644 src/class177/Code01_MoOnlyAdd1.java
 create mode 100644 src/class177/Code02_ThresholdMajority1.java
 create mode 100644 src/class177/Code03_SameNumberMaxDist1.java
 create mode 100644 src/class177/Code04_ZeroQuery1.java
 create mode 100644 src/class177/Code05_MoOnlyDel1.java
 create mode 100644 src/class177/Code06_BaldChief1.java
 create mode 100644 src/class177/Code06_BaldChief2.java

diff --git a/src/class177/Code01_MoOnlyAdd1.java b/src/class177/Code01_MoOnlyAdd1.java
new file mode 100644
index 000000000..a24f5c97c
--- /dev/null
+++ b/src/class177/Code01_MoOnlyAdd1.java
@@ -0,0 +1,200 @@
+package class177;
+
+// 只加不减的回滚莫队入门题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_joisc2014_c
+// 测试链接 : https://atcoder.jp/contests/joisc2014/tasks/joisc2014_c
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code01_MoOnlyAdd1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 401;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] br = new int[MAXB];
+
+	public static int[] forceCnt = new int[MAXN];
+	public static int[] cnt = new int[MAXN];
+
+	public static long curAns = 0;
+	public static long[] ans = new long[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static long force(int l, int r) {
+		long ret = 0;
+		for (int i = l; i <= r; i++) {
+			forceCnt[arr[i]]++;
+		}
+		for (int i = l; i <= r; i++) {
+			ret = Math.max(ret, (long) forceCnt[arr[i]] * sorted[arr[i]]);
+		}
+		for (int i = l; i <= r; i++) {
+			forceCnt[arr[i]]--;
+		}
+		return ret;
+	}
+
+	public static void del(int num) {
+		cnt[num]--;
+	}
+
+	public static void add(int num) {
+		cnt[num]++;
+		curAns = Math.max(curAns, (long) cnt[num] * sorted[num]);
+	}
+
+	public static void compute() {
+		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+			curAns = 0;
+			Arrays.fill(cnt, 1, cntv + 1, 0);
+			int winl = br[block] + 1;
+			int winr = br[block];
+			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
+				int jobl = query[qi][0];
+				int jobr = query[qi][1];
+				int id = query[qi][2];
+				if (jobr <= br[block]) {
+					ans[id] = force(jobl, jobr);
+				} else {
+					while (winr < jobr) {
+						add(arr[++winr]);
+					}
+					long backup = curAns;
+					while (winl > jobl) {
+						add(arr[--winl]);
+					}
+					ans[id] = curAns;
+					curAns = backup;
+					while (winl <= br[block]) {
+						del(arr[winl++]);
+					}
+				}
+			}
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		cntv = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			br[i] = Math.min(i * blen, n);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
new file mode 100644
index 000000000..234062dea
--- /dev/null
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -0,0 +1,171 @@
+package class177;
+
+// 到达阈值的最小众数，java版
+// 测试链接 : https://leetcode.cn/problems/threshold-majority-queries/
+
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code02_ThresholdMajority1 {
+
+	public static int MAXN = 10001;
+	public static int MAXM = 50001;
+	public static int MAXB = 301;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXM][4];
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] br = new int[MAXB];
+
+	public static int[] forceCnt = new int[MAXN];
+	public static int[] cnt = new int[MAXN];
+
+	public static int maxCnt;
+	public static int numAns;
+	public static int[] ans = new int[MAXM];
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static int force(int l, int r, int k) {
+		int maxCnt = 0;
+		int numAns = 0;
+		for (int i = l; i <= r; i++) {
+			forceCnt[arr[i]]++;
+		}
+		for (int i = l; i <= r; i++) {
+			if (forceCnt[arr[i]] > maxCnt || (forceCnt[arr[i]] == maxCnt && arr[i] < numAns)) {
+				maxCnt = forceCnt[arr[i]];
+				numAns = arr[i];
+			}
+		}
+		for (int i = l; i <= r; i++) {
+			forceCnt[arr[i]]--;
+		}
+		return maxCnt >= k ? sorted[numAns] : -1;
+	}
+
+	public static void del(int num) {
+		cnt[num]--;
+	}
+
+	public static void add(int num) {
+		cnt[num]++;
+		if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < numAns)) {
+			maxCnt = cnt[num];
+			numAns = num;
+		}
+	}
+
+	public static void compute() {
+		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+			maxCnt = 0;
+			numAns = 0;
+			Arrays.fill(cnt, 1, cntv + 1, 0);
+			int winl = br[block] + 1;
+			int winr = br[block];
+			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
+				int jobl = query[qi][0];
+				int jobr = query[qi][1];
+				int jobk = query[qi][2];
+				int id = query[qi][3];
+				if (jobr <= br[block]) {
+					ans[id] = force(jobl, jobr, jobk);
+				} else {
+					while (winr < jobr) {
+						add(arr[++winr]);
+					}
+					int backupCnt = maxCnt;
+					int backupNum = numAns;
+					while (winl > jobl) {
+						add(arr[--winl]);
+					}
+					if (maxCnt >= jobk) {
+						ans[id] = sorted[numAns];
+					} else {
+						ans[id] = -1;
+					}
+					maxCnt = backupCnt;
+					numAns = backupNum;
+					while (winl <= br[block]) {
+						del(arr[winl++]);
+					}
+				}
+			}
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		cntv = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			br[i] = Math.min(i * blen, n);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static int[] subarrayMajority(int[] nums, int[][] queries) {
+		n = nums.length;
+		m = queries.length;
+		for (int i = 1, j = 0; i <= n; i++, j++) {
+			arr[i] = nums[j];
+		}
+		for (int i = 1, j = 0; i <= m; i++, j++) {
+			query[i][0] = queries[j][0] + 1;
+			query[i][1] = queries[j][1] + 1;
+			query[i][2] = queries[j][2];
+			query[i][3] = i;
+		}
+		prepare();
+		compute();
+		int[] ret = new int[m];
+		for (int i = 1, j = 0; i <= m; i++, j++) {
+			ret[j] = ans[i];
+		}
+		return ret;
+	}
+
+}
diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
new file mode 100644
index 000000000..228183a5e
--- /dev/null
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -0,0 +1,218 @@
+package class177;
+
+// 相同数的最远距离，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5906
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code03_SameNumberMaxDist1 {
+
+	public static int MAXN = 200001;
+	public static int MAXB = 501;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] br = new int[MAXB];
+
+	public static int[] forceEnd = new int[MAXN];
+	public static int[] start = new int[MAXN];
+	public static int[] end = new int[MAXN];
+
+	public static int curAns = 0;
+	public static int[] ans = new int[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static int force(int l, int r) {
+		int ret = 0;
+		for (int i = l; i <= r; i++) {
+			if (forceEnd[arr[i]] == 0) {
+				forceEnd[arr[i]] = i;
+			} else {
+				ret = Math.max(ret, i - forceEnd[arr[i]]);
+			}
+		}
+		for (int i = l; i <= r; i++) {
+			forceEnd[arr[i]] = 0;
+		}
+		return ret;
+	}
+
+	public static void delLeft(int idx) {
+		int num = arr[idx];
+		if (end[num] == idx) {
+			end[num] = 0;
+		}
+	}
+
+	public static void addRight(int idx) {
+		int num = arr[idx];
+		end[num] = idx;
+		if (start[num] == 0) {
+			start[num] = idx;
+		}
+		curAns = Math.max(curAns, idx - start[num]);
+	}
+
+	public static void addLeft(int idx) {
+		int num = arr[idx];
+		if (end[num] != 0) {
+			curAns = Math.max(curAns, end[num] - idx);
+		} else {
+			end[num] = idx;
+		}
+	}
+
+	public static void compute() {
+		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+			curAns = 0;
+			Arrays.fill(start, 1, cntv + 1, 0);
+			Arrays.fill(end, 1, cntv + 1, 0);
+			int winl = br[block] + 1;
+			int winr = br[block];
+			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
+				int jobl = query[qi][0];
+				int jobr = query[qi][1];
+				int id = query[qi][2];
+				if (jobr <= br[block]) {
+					ans[id] = force(jobl, jobr);
+				} else {
+					while (winr < jobr) {
+						addRight(++winr);
+					}
+					int backup = curAns;
+					while (winl > jobl) {
+						addLeft(--winl);
+					}
+					ans[id] = curAns;
+					curAns = backup;
+					while (winl <= br[block]) {
+						delLeft(winl++);
+					}
+				}
+			}
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		cntv = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			br[i] = Math.min(i * blen, n);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		m = in.nextInt();
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
new file mode 100644
index 000000000..f3ed89776
--- /dev/null
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -0,0 +1,224 @@
+package class177;
+
+// 累加和为0的最长子数组，java版
+// 测试链接 : https://www.luogu.com.cn/problem/SP20644
+// 测试链接 : https://www.spoj.com/problems/ZQUERY/
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code04_ZeroQuery1 {
+
+	public static int MAXN = 50001;
+	public static int MAXB = 301;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+	public static int[] sorted = new int[MAXN + 1];
+	public static int cntv;
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] br = new int[MAXB];
+
+	public static int[] forceEnd = new int[MAXN + 1];
+	public static int[] start = new int[MAXN + 1];
+	public static int[] end = new int[MAXN + 1];
+
+	public static int curAns = 0;
+	public static int[] ans = new int[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static int force(int l, int r) {
+		int ret = 0;
+		for (int i = l; i <= r; i++) {
+			if (forceEnd[arr[i]] == 0) {
+				forceEnd[arr[i]] = i;
+			} else {
+				ret = Math.max(ret, i - forceEnd[arr[i]]);
+			}
+		}
+		for (int i = l; i <= r; i++) {
+			forceEnd[arr[i]] = 0;
+		}
+		return ret;
+	}
+
+	public static void delLeft(int idx) {
+		int num = arr[idx];
+		if (end[num] == idx) {
+			end[num] = 0;
+		}
+	}
+
+	public static void addRight(int idx) {
+		int num = arr[idx];
+		end[num] = idx;
+		if (start[num] == 0) {
+			start[num] = idx;
+		}
+		curAns = Math.max(curAns, idx - start[num]);
+	}
+
+	public static void addLeft(int idx) {
+		int num = arr[idx];
+		if (end[num] != 0) {
+			curAns = Math.max(curAns, end[num] - idx);
+		} else {
+			end[num] = idx;
+		}
+	}
+
+	public static void compute() {
+		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+			curAns = 0;
+			Arrays.fill(start, 1, cntv + 1, 0);
+			Arrays.fill(end, 1, cntv + 1, 0);
+			int winl = br[block] + 1;
+			int winr = br[block];
+			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
+				int jobl = query[qi][0] - 1;
+				int jobr = query[qi][1];
+				int id = query[qi][2];
+				if (jobr <= br[block]) {
+					ans[id] = force(jobl, jobr);
+				} else {
+					while (winr < jobr) {
+						addRight(++winr);
+					}
+					int backup = curAns;
+					while (winl > jobl) {
+						addLeft(--winl);
+					}
+					ans[id] = curAns;
+					curAns = backup;
+					while (winl <= br[block]) {
+						delLeft(winl++);
+					}
+				}
+			}
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			arr[i] += arr[i - 1];
+		}
+		int len = 0;
+		sorted[++len] = 0;
+		for (int i = 1; i <= n; i++) {
+			sorted[++len] = arr[i];
+		}
+		Arrays.sort(sorted, 1, len + 1);
+		cntv = 1;
+		for (int i = 2; i <= len; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
+			}
+		}
+		for (int i = 0; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			br[i] = Math.min(i * blen, n);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class177/Code05_MoOnlyDel1.java b/src/class177/Code05_MoOnlyDel1.java
new file mode 100644
index 000000000..bcf1bb426
--- /dev/null
+++ b/src/class177/Code05_MoOnlyDel1.java
@@ -0,0 +1,165 @@
+package class177;
+
+// 只减不加的回滚莫队入门题，java版
+// 本题最优解为主席树，讲解158，题目2，已经讲述
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
+// 0 <= n、m、arr[i] <= 2 * 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P4137
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code05_MoOnlyDel1 {
+
+	public static int MAXN = 200001;
+	public static int MAXB = 501;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+
+	public static int[] cnt = new int[MAXN + 1];
+	public static int mex;
+	public static int[] ans = new int[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return b[1] - a[1];
+		}
+
+	}
+
+	public static void del(int num) {
+		if (--cnt[num] == 0) {
+			mex = Math.min(mex, num);
+		}
+	}
+
+	public static void add(int num) {
+		cnt[num]++;
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= n; i++) {
+			add(arr[i]);
+		}
+		int winl = 1, winr = n;
+		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+			while (winr < n) {
+				add(arr[++winr]);
+			}
+			while (winl < bl[block]) {
+				del(arr[winl++]);
+			}
+			mex = 0;
+			while (cnt[mex] != 0) {
+				mex++;
+			}
+			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
+				int jobl = query[qi][0];
+				int jobr = query[qi][1];
+				int id = query[qi][2];
+				while (winr > jobr) {
+					del(arr[winr--]);
+				}
+				int backup = mex;
+				while (winl < jobl) {
+					del(arr[winl++]);
+				}
+				ans[id] = mex;
+				mex = backup;
+				while (winl > bl[block]) {
+					add(arr[--winl]);
+				}
+			}
+		}
+	}
+
+	public static void prepare() {
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
new file mode 100644
index 000000000..e36d50442
--- /dev/null
+++ b/src/class177/Code06_BaldChief1.java
@@ -0,0 +1,185 @@
+package class177;
+
+// 秃子酋长，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P8078
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code06_BaldChief2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code06_BaldChief1 {
+
+	public static int MAXN = 500001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+	public static int[] pos = new int[MAXN];
+
+	public static int blen, bnum;
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXN];
+
+	public static int[] last = new int[MAXN + 1];
+	public static int[] next = new int[MAXN + 1];
+	public static long sum;
+	public static long[] ans = new long[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return b[1] - a[1];
+		}
+
+	}
+
+	// 删除num
+	public static void del(int num) {
+		int less = last[num], more = next[num];
+		if (less != 0) {
+			sum -= Math.abs(pos[num] - pos[less]);
+		}
+		if (more != n + 1) {
+			sum -= Math.abs(pos[more] - pos[num]);
+		}
+		if (less != 0 && more != n + 1) {
+			sum += Math.abs(pos[more] - pos[less]);
+		}
+		next[less] = more;
+		last[more] = less;
+	}
+
+	// 加入num，必须保证num是最近一次删除的数字
+	public static void undo(int num) {
+		next[last[num]] = num;
+		last[next[num]] = num;
+	}
+
+	public static void compute() {
+		for (int v = 1; v <= n; v++) {
+			last[v] = v - 1;
+			next[v] = v + 1;
+		}
+		next[0] = 1;
+		last[n + 1] = n;
+		for (int v = 2; v <= n; v++) {
+			sum += Math.abs(pos[v] - pos[v - 1]);
+		}
+		int winl = 1, winr = n;
+		long lastBlockSum = sum;
+		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+			while (winr < n) {
+				undo(arr[++winr]);
+			}
+			sum = lastBlockSum;
+			while (winl < bl[block]) {
+				del(arr[winl++]);
+			}
+			lastBlockSum = sum;
+			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
+				int jobl = query[qi][0];
+				int jobr = query[qi][1];
+				int id = query[qi][2];
+				while (winr > jobr) {
+					del(arr[winr--]);
+				}
+				long backup = sum;
+				while (winl < jobl) {
+					del(arr[winl++]);
+				}
+				ans[id] = sum;
+				while (winl > bl[block]) {
+					undo(arr[--winl]);
+				}
+				sum = backup;
+			}
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			pos[arr[i]] = i;
+		}
+		blen = (int) Math.sqrt(n);
+		bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class177/Code06_BaldChief2.java b/src/class177/Code06_BaldChief2.java
new file mode 100644
index 000000000..22ca4170e
--- /dev/null
+++ b/src/class177/Code06_BaldChief2.java
@@ -0,0 +1,132 @@
+package class177;
+
+// 秃子酋长，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P8078
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 500001;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//int pos[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXN];
+//
+//int lst[MAXN + 1];
+//int nxt[MAXN + 1];
+//long long sum;
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r > b.r;
+//}
+//
+//inline void del(int num) {
+//    int less = lst[num], more = nxt[num];
+//    if (less != 0) {
+//        sum -= abs(pos[num] - pos[less]);
+//    }
+//    if (more != n + 1) {
+//        sum -= abs(pos[more] - pos[num]);
+//    }
+//    if (less != 0 && more != n + 1) {
+//        sum += abs(pos[more] - pos[less]);
+//    }
+//    nxt[less] = more;
+//    lst[more] = less;
+//}
+//
+//inline void undo(int num) {
+//    nxt[lst[num]] = num;
+//    lst[nxt[num]] = num;
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        pos[arr[i]] = i;
+//    }
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//    }
+//    sort(query + 1, query + 1 + m, QueryCmp);
+//}
+//
+//void compute() {
+//    for (int v = 1; v <= n; v++) {
+//        lst[v] = v - 1;
+//        nxt[v] = v + 1;
+//    }
+//    nxt[0] = 1;
+//    lst[n + 1] = n;
+//    sum = 0;
+//    for (int v = 2; v <= n; v++) {
+//        sum += abs(pos[v] - pos[v - 1]);
+//    }
+//    int winl = 1, winr = n;
+//    long long lastBlockSum = sum;
+//    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+//        while (winr < n) {
+//            undo(arr[++winr]);
+//        }
+//        sum = lastBlockSum;
+//        while (winl < bl[block]) {
+//            del(arr[winl++]);
+//        }
+//        lastBlockSum = sum;
+//        for (; qi <= m && bi[query[qi].l] == block; qi++) {
+//            int jobl = query[qi].l;
+//            int jobr = query[qi].r;
+//            int id = query[qi].id;
+//            while (winr > jobr) {
+//                del(arr[winr--]);
+//            }
+//            long long backup = sum;
+//            while (winl < jobl) {
+//                del(arr[winl++]);
+//            }
+//            ans[id] = sum;
+//            while (winl > bl[block]) {
+//                undo(arr[--winl]);
+//            }
+//            sum = backup;
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 65c227ab1778961212888cfd5fb6b2e00d6c4676 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Aug 2025 13:55:20 +0800
Subject: [PATCH 1309/1712] modify code

---
 src/class177/Code06_BaldChief1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index e36d50442..80f4a03c2 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -59,7 +59,8 @@ public static void del(int num) {
 		last[more] = less;
 	}
 
-	// 加入num，必须保证num是最近一次删除的数字
+	// 加入num，必须保证num上一次删除的数字
+	// 也就是说，undo的调用就是del操作的回滚
 	public static void undo(int num) {
 		next[last[num]] = num;
 		last[next[num]] = num;

From 71ba0fc84e6df65564b89e473c7e5b3a10eb09ee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Aug 2025 13:55:52 +0800
Subject: [PATCH 1310/1712] modify code

---
 src/class177/Code06_BaldChief1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index 80f4a03c2..9f545ad67 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -60,7 +60,7 @@ public static void del(int num) {
 	}
 
 	// 加入num，必须保证num上一次删除的数字
-	// 也就是说，undo的调用就是del操作的回滚
+	// 也就是说，undo的调用必须是del操作的回滚
 	public static void undo(int num) {
 		next[last[num]] = num;
 		last[next[num]] = num;

From 47aa35ad5c0e365aa401224816574ec042fea825 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Aug 2025 18:04:13 +0800
Subject: [PATCH 1311/1712] modify code

---
 ...MoOnlyAdd1.java => Code01_MoAddUndo1.java} | 14 +++++-----
 src/class177/Code02_ThresholdMajority1.java   | 10 +++----
 src/class177/Code03_SameNumberMaxDist1.java   |  4 +--
 src/class177/Code04_ZeroQuery1.java           | 16 ++++++------
 ...MoOnlyDel1.java => Code05_MoDelUndo1.java} | 26 ++++++++++---------
 src/class177/Code06_BaldChief1.java           | 11 ++++----
 src/class177/Code06_BaldChief2.java           | 11 ++++----
 7 files changed, 46 insertions(+), 46 deletions(-)
 rename src/class177/{Code01_MoOnlyAdd1.java => Code01_MoAddUndo1.java} (96%)
 rename src/class177/{Code05_MoOnlyDel1.java => Code05_MoDelUndo1.java} (92%)

diff --git a/src/class177/Code01_MoOnlyAdd1.java b/src/class177/Code01_MoAddUndo1.java
similarity index 96%
rename from src/class177/Code01_MoOnlyAdd1.java
rename to src/class177/Code01_MoAddUndo1.java
index a24f5c97c..b84c883dd 100644
--- a/src/class177/Code01_MoOnlyAdd1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -1,6 +1,6 @@
 package class177;
 
-// 只加不减的回滚莫队入门题，java版
+// 只增回滚莫队入门题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/AT_joisc2014_c
 // 测试链接 : https://atcoder.jp/contests/joisc2014/tasks/joisc2014_c
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -12,7 +12,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code01_MoOnlyAdd1 {
+public class Code01_MoAddUndo1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 401;
@@ -72,15 +72,15 @@ public static long force(int l, int r) {
 		return ret;
 	}
 
-	public static void del(int num) {
-		cnt[num]--;
-	}
-
 	public static void add(int num) {
 		cnt[num]++;
 		curAns = Math.max(curAns, (long) cnt[num] * sorted[num]);
 	}
 
+	public static void undo(int num) {
+		cnt[num]--;
+	}
+
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			curAns = 0;
@@ -104,7 +104,7 @@ public static void compute() {
 					ans[id] = curAns;
 					curAns = backup;
 					while (winl <= br[block]) {
-						del(arr[winl++]);
+						undo(arr[winl++]);
 					}
 				}
 			}
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index 234062dea..9ca5b90f4 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -72,10 +72,6 @@ public static int force(int l, int r, int k) {
 		return maxCnt >= k ? sorted[numAns] : -1;
 	}
 
-	public static void del(int num) {
-		cnt[num]--;
-	}
-
 	public static void add(int num) {
 		cnt[num]++;
 		if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < numAns)) {
@@ -83,6 +79,10 @@ public static void add(int num) {
 			numAns = num;
 		}
 	}
+	
+	public static void undo(int num) {
+		cnt[num]--;
+	}
 
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
@@ -115,7 +115,7 @@ public static void compute() {
 					maxCnt = backupCnt;
 					numAns = backupNum;
 					while (winl <= br[block]) {
-						del(arr[winl++]);
+						undo(arr[winl++]);
 					}
 				}
 			}
diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index 228183a5e..70f0665a5 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -89,7 +89,7 @@ public static void addRight(int idx) {
 		curAns = Math.max(curAns, idx - start[num]);
 	}
 
-	public static void addLeft(int idx) {
+	public static void undoLeft(int idx) {
 		int num = arr[idx];
 		if (end[num] != 0) {
 			curAns = Math.max(curAns, end[num] - idx);
@@ -117,7 +117,7 @@ public static void compute() {
 					}
 					int backup = curAns;
 					while (winl > jobl) {
-						addLeft(--winl);
+						undoLeft(--winl);
 					}
 					ans[id] = curAns;
 					curAns = backup;
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index f3ed89776..0de082bd9 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -74,13 +74,6 @@ public static int force(int l, int r) {
 		return ret;
 	}
 
-	public static void delLeft(int idx) {
-		int num = arr[idx];
-		if (end[num] == idx) {
-			end[num] = 0;
-		}
-	}
-
 	public static void addRight(int idx) {
 		int num = arr[idx];
 		end[num] = idx;
@@ -99,6 +92,13 @@ public static void addLeft(int idx) {
 		}
 	}
 
+	public static void undoLeft(int idx) {
+		int num = arr[idx];
+		if (end[num] == idx) {
+			end[num] = 0;
+		}
+	}
+
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			curAns = 0;
@@ -123,7 +123,7 @@ public static void compute() {
 					ans[id] = curAns;
 					curAns = backup;
 					while (winl <= br[block]) {
-						delLeft(winl++);
+						undoLeft(winl++);
 					}
 				}
 			}
diff --git a/src/class177/Code05_MoOnlyDel1.java b/src/class177/Code05_MoDelUndo1.java
similarity index 92%
rename from src/class177/Code05_MoOnlyDel1.java
rename to src/class177/Code05_MoDelUndo1.java
index bcf1bb426..b4ed8075a 100644
--- a/src/class177/Code05_MoOnlyDel1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -1,6 +1,6 @@
 package class177;
 
-// 只减不加的回滚莫队入门题，java版
+// 只减回滚莫队入门题，java版
 // 本题最优解为主席树，讲解158，题目2，已经讲述
 // 给定一个长度为n的数组arr，一共有m条查询，格式如下
 // 查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
@@ -15,7 +15,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code05_MoOnlyDel1 {
+public class Code05_MoDelUndo1 {
 
 	public static int MAXN = 200001;
 	public static int MAXB = 501;
@@ -49,26 +49,24 @@ public static void del(int num) {
 		}
 	}
 
-	public static void add(int num) {
+	public static void undo(int num) {
 		cnt[num]++;
 	}
 
 	public static void compute() {
 		for (int i = 1; i <= n; i++) {
-			add(arr[i]);
+			undo(arr[i]);
+		}
+		mex = 0;
+		while (cnt[mex] != 0) {
+			mex++;
 		}
 		int winl = 1, winr = n;
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-			while (winr < n) {
-				add(arr[++winr]);
-			}
 			while (winl < bl[block]) {
 				del(arr[winl++]);
 			}
-			mex = 0;
-			while (cnt[mex] != 0) {
-				mex++;
-			}
+			int before = mex;
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
 				int jobr = query[qi][1];
@@ -83,9 +81,13 @@ public static void compute() {
 				ans[id] = mex;
 				mex = backup;
 				while (winl > bl[block]) {
-					add(arr[--winl]);
+					undo(arr[--winl]);
 				}
 			}
+			while (winr < n) {
+				undo(arr[++winr]);
+			}
+			mex = before;
 		}
 	}
 
diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index 9f545ad67..91e184f42 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -77,16 +77,11 @@ public static void compute() {
 			sum += Math.abs(pos[v] - pos[v - 1]);
 		}
 		int winl = 1, winr = n;
-		long lastBlockSum = sum;
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-			while (winr < n) {
-				undo(arr[++winr]);
-			}
-			sum = lastBlockSum;
 			while (winl < bl[block]) {
 				del(arr[winl++]);
 			}
-			lastBlockSum = sum;
+			long before = sum;
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
 				int jobr = query[qi][1];
@@ -104,6 +99,10 @@ public static void compute() {
 				}
 				sum = backup;
 			}
+			while (winr < n) {
+				undo(arr[++winr]);
+			}
+			sum = before;
 		}
 	}
 
diff --git a/src/class177/Code06_BaldChief2.java b/src/class177/Code06_BaldChief2.java
index 22ca4170e..350f34e61 100644
--- a/src/class177/Code06_BaldChief2.java
+++ b/src/class177/Code06_BaldChief2.java
@@ -82,16 +82,11 @@
 //        sum += abs(pos[v] - pos[v - 1]);
 //    }
 //    int winl = 1, winr = n;
-//    long long lastBlockSum = sum;
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-//        while (winr < n) {
-//            undo(arr[++winr]);
-//        }
-//        sum = lastBlockSum;
 //        while (winl < bl[block]) {
 //            del(arr[winl++]);
 //        }
-//        lastBlockSum = sum;
+//        long long before = sum;
 //        for (; qi <= m && bi[query[qi].l] == block; qi++) {
 //            int jobl = query[qi].l;
 //            int jobr = query[qi].r;
@@ -109,6 +104,10 @@
 //            }
 //            sum = backup;
 //        }
+//        while (winr < n) {
+//            undo(arr[++winr]);
+//        }
+//        sum = before;
 //    }
 //}
 //

From d604c42bc6713237db015ff68522976136519150 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Aug 2025 18:07:18 +0800
Subject: [PATCH 1312/1712] modify code

---
 src/class177/Code05_MoDelUndo1.java | 4 ++--
 src/class177/Code06_BaldChief1.java | 4 ++--
 src/class177/Code06_BaldChief2.java | 4 ++--
 3 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class177/Code05_MoDelUndo1.java b/src/class177/Code05_MoDelUndo1.java
index b4ed8075a..976f33a15 100644
--- a/src/class177/Code05_MoDelUndo1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -66,7 +66,7 @@ public static void compute() {
 			while (winl < bl[block]) {
 				del(arr[winl++]);
 			}
-			int before = mex;
+			int beforeJob = mex;
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
 				int jobr = query[qi][1];
@@ -87,7 +87,7 @@ public static void compute() {
 			while (winr < n) {
 				undo(arr[++winr]);
 			}
-			mex = before;
+			mex = beforeJob;
 		}
 	}
 
diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index 91e184f42..42db55a79 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -81,7 +81,7 @@ public static void compute() {
 			while (winl < bl[block]) {
 				del(arr[winl++]);
 			}
-			long before = sum;
+			long beforeJob = sum;
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
 				int jobr = query[qi][1];
@@ -102,7 +102,7 @@ public static void compute() {
 			while (winr < n) {
 				undo(arr[++winr]);
 			}
-			sum = before;
+			sum = beforeJob;
 		}
 	}
 
diff --git a/src/class177/Code06_BaldChief2.java b/src/class177/Code06_BaldChief2.java
index 350f34e61..bd5fe178c 100644
--- a/src/class177/Code06_BaldChief2.java
+++ b/src/class177/Code06_BaldChief2.java
@@ -86,7 +86,7 @@
 //        while (winl < bl[block]) {
 //            del(arr[winl++]);
 //        }
-//        long long before = sum;
+//        long long beforeJob = sum;
 //        for (; qi <= m && bi[query[qi].l] == block; qi++) {
 //            int jobl = query[qi].l;
 //            int jobr = query[qi].r;
@@ -107,7 +107,7 @@
 //        while (winr < n) {
 //            undo(arr[++winr]);
 //        }
-//        sum = before;
+//        sum = beforeJob;
 //    }
 //}
 //

From e9f516fb9e93452591bedea8387c0f9e9c2c9bb3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Aug 2025 18:10:14 +0800
Subject: [PATCH 1313/1712] modify code

---
 src/class177/Code02_ThresholdMajority1.java | 267 ++++++++++----------
 1 file changed, 136 insertions(+), 131 deletions(-)

diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index 9ca5b90f4..4f13c3293 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -2,170 +2,175 @@
 
 // 到达阈值的最小众数，java版
 // 测试链接 : https://leetcode.cn/problems/threshold-majority-queries/
+// 提交如下代码中的Solution类，可以通过所有测试用例
 
 import java.util.Arrays;
 import java.util.Comparator;
 
 public class Code02_ThresholdMajority1 {
 
-	public static int MAXN = 10001;
-	public static int MAXM = 50001;
-	public static int MAXB = 301;
-	public static int n, m;
-	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXM][4];
-	public static int[] sorted = new int[MAXN];
-	public static int cntv;
+	class Solution {
 
-	public static int blen, bnum;
-	public static int[] bi = new int[MAXN];
-	public static int[] br = new int[MAXB];
+		public static int MAXN = 10001;
+		public static int MAXM = 50001;
+		public static int MAXB = 301;
+		public static int n, m;
+		public static int[] arr = new int[MAXN];
+		public static int[][] query = new int[MAXM][4];
+		public static int[] sorted = new int[MAXN];
+		public static int cntv;
 
-	public static int[] forceCnt = new int[MAXN];
-	public static int[] cnt = new int[MAXN];
+		public static int blen, bnum;
+		public static int[] bi = new int[MAXN];
+		public static int[] br = new int[MAXB];
 
-	public static int maxCnt;
-	public static int numAns;
-	public static int[] ans = new int[MAXM];
+		public static int[] forceCnt = new int[MAXN];
+		public static int[] cnt = new int[MAXN];
 
-	public static class QueryCmp implements Comparator<int[]> {
+		public static int maxCnt;
+		public static int numAns;
+		public static int[] ans = new int[MAXM];
 
-		@Override
-		public int compare(int[] a, int[] b) {
-			if (bi[a[0]] != bi[b[0]]) {
-				return bi[a[0]] - bi[b[0]];
+		public static class QueryCmp implements Comparator<int[]> {
+
+			@Override
+			public int compare(int[] a, int[] b) {
+				if (bi[a[0]] != bi[b[0]]) {
+					return bi[a[0]] - bi[b[0]];
+				}
+				return a[1] - b[1];
 			}
-			return a[1] - b[1];
-		}
 
-	}
+		}
 
-	public static int kth(int num) {
-		int left = 1, right = cntv, mid, ret = 0;
-		while (left <= right) {
-			mid = (left + right) / 2;
-			if (sorted[mid] <= num) {
-				ret = mid;
-				left = mid + 1;
-			} else {
-				right = mid - 1;
+		public static int kth(int num) {
+			int left = 1, right = cntv, mid, ret = 0;
+			while (left <= right) {
+				mid = (left + right) / 2;
+				if (sorted[mid] <= num) {
+					ret = mid;
+					left = mid + 1;
+				} else {
+					right = mid - 1;
+				}
 			}
+			return ret;
 		}
-		return ret;
-	}
 
-	public static int force(int l, int r, int k) {
-		int maxCnt = 0;
-		int numAns = 0;
-		for (int i = l; i <= r; i++) {
-			forceCnt[arr[i]]++;
-		}
-		for (int i = l; i <= r; i++) {
-			if (forceCnt[arr[i]] > maxCnt || (forceCnt[arr[i]] == maxCnt && arr[i] < numAns)) {
-				maxCnt = forceCnt[arr[i]];
-				numAns = arr[i];
+		public static int force(int l, int r, int k) {
+			int maxCnt = 0;
+			int numAns = 0;
+			for (int i = l; i <= r; i++) {
+				forceCnt[arr[i]]++;
 			}
+			for (int i = l; i <= r; i++) {
+				if (forceCnt[arr[i]] > maxCnt || (forceCnt[arr[i]] == maxCnt && arr[i] < numAns)) {
+					maxCnt = forceCnt[arr[i]];
+					numAns = arr[i];
+				}
+			}
+			for (int i = l; i <= r; i++) {
+				forceCnt[arr[i]]--;
+			}
+			return maxCnt >= k ? sorted[numAns] : -1;
 		}
-		for (int i = l; i <= r; i++) {
-			forceCnt[arr[i]]--;
+
+		public static void add(int num) {
+			cnt[num]++;
+			if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < numAns)) {
+				maxCnt = cnt[num];
+				numAns = num;
+			}
 		}
-		return maxCnt >= k ? sorted[numAns] : -1;
-	}
 
-	public static void add(int num) {
-		cnt[num]++;
-		if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < numAns)) {
-			maxCnt = cnt[num];
-			numAns = num;
+		public static void undo(int num) {
+			cnt[num]--;
 		}
-	}
-	
-	public static void undo(int num) {
-		cnt[num]--;
-	}
 
-	public static void compute() {
-		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-			maxCnt = 0;
-			numAns = 0;
-			Arrays.fill(cnt, 1, cntv + 1, 0);
-			int winl = br[block] + 1;
-			int winr = br[block];
-			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
-				int jobl = query[qi][0];
-				int jobr = query[qi][1];
-				int jobk = query[qi][2];
-				int id = query[qi][3];
-				if (jobr <= br[block]) {
-					ans[id] = force(jobl, jobr, jobk);
-				} else {
-					while (winr < jobr) {
-						add(arr[++winr]);
-					}
-					int backupCnt = maxCnt;
-					int backupNum = numAns;
-					while (winl > jobl) {
-						add(arr[--winl]);
-					}
-					if (maxCnt >= jobk) {
-						ans[id] = sorted[numAns];
+		public static void compute() {
+			for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+				maxCnt = 0;
+				numAns = 0;
+				Arrays.fill(cnt, 1, cntv + 1, 0);
+				int winl = br[block] + 1;
+				int winr = br[block];
+				for (; qi <= m && bi[query[qi][0]] == block; qi++) {
+					int jobl = query[qi][0];
+					int jobr = query[qi][1];
+					int jobk = query[qi][2];
+					int id = query[qi][3];
+					if (jobr <= br[block]) {
+						ans[id] = force(jobl, jobr, jobk);
 					} else {
-						ans[id] = -1;
-					}
-					maxCnt = backupCnt;
-					numAns = backupNum;
-					while (winl <= br[block]) {
-						undo(arr[winl++]);
+						while (winr < jobr) {
+							add(arr[++winr]);
+						}
+						int backupCnt = maxCnt;
+						int backupNum = numAns;
+						while (winl > jobl) {
+							add(arr[--winl]);
+						}
+						if (maxCnt >= jobk) {
+							ans[id] = sorted[numAns];
+						} else {
+							ans[id] = -1;
+						}
+						maxCnt = backupCnt;
+						numAns = backupNum;
+						while (winl <= br[block]) {
+							undo(arr[winl++]);
+						}
 					}
 				}
 			}
 		}
-	}
 
-	public static void prepare() {
-		for (int i = 1; i <= n; i++) {
-			sorted[i] = arr[i];
-		}
-		Arrays.sort(sorted, 1, n + 1);
-		cntv = 1;
-		for (int i = 2; i <= n; i++) {
-			if (sorted[cntv] != sorted[i]) {
-				sorted[++cntv] = sorted[i];
+		public static void prepare() {
+			for (int i = 1; i <= n; i++) {
+				sorted[i] = arr[i];
 			}
+			Arrays.sort(sorted, 1, n + 1);
+			cntv = 1;
+			for (int i = 2; i <= n; i++) {
+				if (sorted[cntv] != sorted[i]) {
+					sorted[++cntv] = sorted[i];
+				}
+			}
+			for (int i = 1; i <= n; i++) {
+				arr[i] = kth(arr[i]);
+			}
+			blen = (int) Math.sqrt(n);
+			bnum = (n + blen - 1) / blen;
+			for (int i = 1; i <= n; i++) {
+				bi[i] = (i - 1) / blen + 1;
+			}
+			for (int i = 1; i <= bnum; i++) {
+				br[i] = Math.min(i * blen, n);
+			}
+			Arrays.sort(query, 1, m + 1, new QueryCmp());
 		}
-		for (int i = 1; i <= n; i++) {
-			arr[i] = kth(arr[i]);
-		}
-		blen = (int) Math.sqrt(n);
-		bnum = (n + blen - 1) / blen;
-		for (int i = 1; i <= n; i++) {
-			bi[i] = (i - 1) / blen + 1;
-		}
-		for (int i = 1; i <= bnum; i++) {
-			br[i] = Math.min(i * blen, n);
-		}
-		Arrays.sort(query, 1, m + 1, new QueryCmp());
-	}
 
-	public static int[] subarrayMajority(int[] nums, int[][] queries) {
-		n = nums.length;
-		m = queries.length;
-		for (int i = 1, j = 0; i <= n; i++, j++) {
-			arr[i] = nums[j];
-		}
-		for (int i = 1, j = 0; i <= m; i++, j++) {
-			query[i][0] = queries[j][0] + 1;
-			query[i][1] = queries[j][1] + 1;
-			query[i][2] = queries[j][2];
-			query[i][3] = i;
-		}
-		prepare();
-		compute();
-		int[] ret = new int[m];
-		for (int i = 1, j = 0; i <= m; i++, j++) {
-			ret[j] = ans[i];
+		public static int[] subarrayMajority(int[] nums, int[][] queries) {
+			n = nums.length;
+			m = queries.length;
+			for (int i = 1, j = 0; i <= n; i++, j++) {
+				arr[i] = nums[j];
+			}
+			for (int i = 1, j = 0; i <= m; i++, j++) {
+				query[i][0] = queries[j][0] + 1;
+				query[i][1] = queries[j][1] + 1;
+				query[i][2] = queries[j][2];
+				query[i][3] = i;
+			}
+			prepare();
+			compute();
+			int[] ret = new int[m];
+			for (int i = 1, j = 0; i <= m; i++, j++) {
+				ret[j] = ans[i];
+			}
+			return ret;
 		}
-		return ret;
+
 	}
 
 }

From d19e549f8790cf6dee64fc9c893f4b7bb3e1996c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 26 Aug 2025 18:45:48 +0800
Subject: [PATCH 1314/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist1.java | 20 ++++++++++----------
 1 file changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index 70f0665a5..f72adf0f9 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -73,13 +73,6 @@ public static int force(int l, int r) {
 		return ret;
 	}
 
-	public static void delLeft(int idx) {
-		int num = arr[idx];
-		if (end[num] == idx) {
-			end[num] = 0;
-		}
-	}
-
 	public static void addRight(int idx) {
 		int num = arr[idx];
 		end[num] = idx;
@@ -89,7 +82,7 @@ public static void addRight(int idx) {
 		curAns = Math.max(curAns, idx - start[num]);
 	}
 
-	public static void undoLeft(int idx) {
+	public static void addLeft(int idx) {
 		int num = arr[idx];
 		if (end[num] != 0) {
 			curAns = Math.max(curAns, end[num] - idx);
@@ -98,6 +91,13 @@ public static void undoLeft(int idx) {
 		}
 	}
 
+	public static void undoLeft(int idx) {
+		int num = arr[idx];
+		if (end[num] == idx) {
+			end[num] = 0;
+		}
+	}
+
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			curAns = 0;
@@ -117,12 +117,12 @@ public static void compute() {
 					}
 					int backup = curAns;
 					while (winl > jobl) {
-						undoLeft(--winl);
+						addLeft(--winl);
 					}
 					ans[id] = curAns;
 					curAns = backup;
 					while (winl <= br[block]) {
-						delLeft(winl++);
+						undoLeft(winl++);
 					}
 				}
 			}

From 4a2b83f91fb4cf65039e019624499d6d0ac97412 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 10:40:05 +0800
Subject: [PATCH 1315/1712] modify code

---
 src/class177/Code02_ThresholdMajority1.java |  2 +-
 src/class177/Code05_MoDelUndo1.java         |  2 +-
 src/class177/Code07_MoOnTree1.java          | 10 ++++++++++
 3 files changed, 12 insertions(+), 2 deletions(-)
 create mode 100644 src/class177/Code07_MoOnTree1.java

diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index 4f13c3293..7a8fea772 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -1,6 +1,6 @@
 package class177;
 
-// 到达阈值的最小众数，java版
+// 达到阈值的最小众数，java版
 // 测试链接 : https://leetcode.cn/problems/threshold-majority-queries/
 // 提交如下代码中的Solution类，可以通过所有测试用例
 
diff --git a/src/class177/Code05_MoDelUndo1.java b/src/class177/Code05_MoDelUndo1.java
index 976f33a15..d7ede8847 100644
--- a/src/class177/Code05_MoDelUndo1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -1,6 +1,6 @@
 package class177;
 
-// 只减回滚莫队入门题，java版
+// 只删回滚莫队入门题，java版
 // 本题最优解为主席树，讲解158，题目2，已经讲述
 // 给定一个长度为n的数组arr，一共有m条查询，格式如下
 // 查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
new file mode 100644
index 000000000..d079f367c
--- /dev/null
+++ b/src/class177/Code07_MoOnTree1.java
@@ -0,0 +1,10 @@
+package class177;
+
+// 树上莫队入门题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/SP10707
+// 测试链接 : https://www.spoj.com/problems/COT2/
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code07_MoOnTree1 {
+
+}

From c7b905f8db591e989a043ed027e13183ea2abf23 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 12:35:10 +0800
Subject: [PATCH 1316/1712] modify code

---
 src/class177/Code07_MoOnTree1.java | 261 ++++++++++++++++++++++++++++-
 src/class177/Code07_MoOnTree2.java | 209 +++++++++++++++++++++++
 2 files changed, 469 insertions(+), 1 deletion(-)
 create mode 100644 src/class177/Code07_MoOnTree2.java

diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index d079f367c..51088f3f8 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -3,8 +3,267 @@
 // 树上莫队入门题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/SP10707
 // 测试链接 : https://www.spoj.com/problems/COT2/
-// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code07_MoOnTree2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
 
 public class Code07_MoOnTree1 {
 
+	public static int MAXN = 40001;
+	public static int MAXM = 100001;
+	public static int MAXP = 20;
+	public static int n, m;
+	public static int[] color = new int[MAXN];
+	public static int[][] query = new int[MAXM][4];
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
+
+	public static int[] head = new int[MAXN];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] next = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] seg = new int[MAXN << 1];
+	public static int[] startId = new int[MAXN];
+	public static int[] endId = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int cntd;
+
+	public static int[] bi = new int[MAXN << 1];
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] cnt = new int[MAXN];
+	public static int kind = 0;
+
+	public static int[] ans = new int[MAXM];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static void dfs(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		seg[++cntd] = u;
+		startId[u] = cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa) {
+				dfs(v, u);
+			}
+		}
+		seg[++cntd] = u;
+		endId[u] = cntd;
+	}
+
+	public static int lca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+
+	}
+
+	public static void update(int node) {
+		int val = color[node];
+		if (vis[node]) {
+			if (--cnt[val] == 0) {
+				kind--;
+			}
+		} else {
+			if (++cnt[val] == 1) {
+				kind++;
+			}
+		}
+		vis[node] = !vis[node];
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int jobLca = query[i][2];
+			int id = query[i][3];
+			while (winl > jobl) {
+				update(seg[--winl]);
+			}
+			while (winr < jobr) {
+				update(seg[++winr]);
+			}
+			while (winl < jobl) {
+				update(seg[winl++]);
+			}
+			while (winr > jobr) {
+				update(seg[winr--]);
+			}
+			if (jobLca > 0) {
+				update(jobLca);
+			}
+			ans[id] = kind;
+			if (jobLca > 0) {
+				update(jobLca);
+			}
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = color[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		cntv = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			color[i] = kth(color[i]);
+		}
+		// 括号序列分块
+		int blen = (int) Math.sqrt(cntd);
+		for (int i = 1; i <= cntd; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			color[i] = in.nextInt();
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		dfs(1, 0);
+		for (int i = 1, u, v, uvlca; i <= m; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			if (startId[v] < startId[u]) {
+				int tmp = u;
+				u = v;
+				v = tmp;
+			}
+			uvlca = lca(u, v);
+			if (u == uvlca) {
+				query[i][0] = startId[u];
+				query[i][1] = startId[v];
+				query[i][2] = 0;
+			} else {
+				query[i][0] = endId[u];
+				query[i][1] = startId[v];
+				query[i][2] = uvlca;
+			}
+			query[i][3] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class177/Code07_MoOnTree2.java b/src/class177/Code07_MoOnTree2.java
new file mode 100644
index 000000000..aa6ffc90a
--- /dev/null
+++ b/src/class177/Code07_MoOnTree2.java
@@ -0,0 +1,209 @@
+package class177;
+
+// 树上莫队入门题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/SP10707
+// 测试链接 : https://www.spoj.com/problems/COT2/
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, lca, id;
+//};
+//
+//const int MAXN = 40001;
+//const int MAXM = 100001;
+//const int MAXP = 20;
+//int n, m;
+//int color[MAXN];
+//Query query[MAXM];
+//int sorted[MAXN];
+//int cntv;
+//
+//int head[MAXN];
+//int to[MAXN << 1];
+//int nxt[MAXN << 1];
+//int cntg;
+//
+//int dep[MAXN];
+//int seg[MAXN << 1];
+//int startId[MAXN];
+//int endId[MAXN];
+//int stjump[MAXN][MAXP];
+//int cntd;
+//
+//int bi[MAXN << 1];
+//bool vis[MAXN];
+//int cnt[MAXN];
+//int kind;
+//
+//int ans[MAXM];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, mid, ret = 0;
+//    while (left <= right) {
+//        mid = (left + right) / 2;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    seg[++cntd] = u;
+//    startId[u] = cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            dfs(v, u);
+//        }
+//    }
+//    seg[++cntd] = u;
+//    endId[u] = cntd;
+//}
+//
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        int tmp = a; a = b; b = tmp;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) return a;
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//void update(int node) {
+//    int val = color[node];
+//    if (vis[node]) {
+//        if (--cnt[val] == 0) {
+//            kind--;
+//        }
+//    } else {
+//        if (++cnt[val] == 1) {
+//            kind++;
+//        }
+//    }
+//    vis[node] = !vis[node];
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int jobLca = query[i].lca;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            update(seg[--winl]);
+//        }
+//        while (winr < jobr) {
+//            update(seg[++winr]);
+//        }
+//        while (winl < jobl) {
+//            update(seg[winl++]);
+//        }
+//        while (winr > jobr) {
+//            update(seg[winr--]);
+//        }
+//        if (jobLca > 0) {
+//            update(jobLca);
+//        }
+//        ans[id] = kind;
+//        if (jobLca > 0) {
+//            update(jobLca);
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = color[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[cntv] != sorted[i]) {
+//            sorted[++cntv] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        color[i] = kth(color[i]);
+//    }
+//    int blen = (int) sqrt(cntd);
+//    for (int i = 1; i <= cntd; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> color[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs(1, 0);
+//    for (int i = 1, u, v, uvlca; i <= m; i++) {
+//        cin >> u >> v;
+//        if (startId[v] < startId[u]) {
+//            int tmp = u; u = v; v = tmp;
+//        }
+//        uvlca = lca(u, v);
+//        if (u == uvlca) {
+//        	query[i].l = startId[u];
+//        	query[i].r = startId[v];
+//        	query[i].lca = 0;
+//        } else {
+//        	query[i].l = endId[u];
+//        	query[i].r = startId[v];
+//        	query[i].lca = uvlca;
+//        }
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From db159aca6b85b84043d8fb22f6f47f0e664dd135 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 13:20:25 +0800
Subject: [PATCH 1317/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist1.java | 36 ++++++++++-----------
 src/class177/Code04_ZeroQuery1.java         | 36 ++++++++++-----------
 src/class177/Code07_MoOnTree1.java          | 18 +++++------
 src/class177/Code07_MoOnTree2.java          | 18 +++++------
 4 files changed, 54 insertions(+), 54 deletions(-)

diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index f72adf0f9..debf1770c 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -25,9 +25,9 @@ public class Code03_SameNumberMaxDist1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	public static int[] forceEnd = new int[MAXN];
-	public static int[] start = new int[MAXN];
-	public static int[] end = new int[MAXN];
+	public static int[] forceEd = new int[MAXN];
+	public static int[] st = new int[MAXN];
+	public static int[] ed = new int[MAXN];
 
 	public static int curAns = 0;
 	public static int[] ans = new int[MAXN];
@@ -61,48 +61,48 @@ public static int kth(int num) {
 	public static int force(int l, int r) {
 		int ret = 0;
 		for (int i = l; i <= r; i++) {
-			if (forceEnd[arr[i]] == 0) {
-				forceEnd[arr[i]] = i;
+			if (forceEd[arr[i]] == 0) {
+				forceEd[arr[i]] = i;
 			} else {
-				ret = Math.max(ret, i - forceEnd[arr[i]]);
+				ret = Math.max(ret, i - forceEd[arr[i]]);
 			}
 		}
 		for (int i = l; i <= r; i++) {
-			forceEnd[arr[i]] = 0;
+			forceEd[arr[i]] = 0;
 		}
 		return ret;
 	}
 
 	public static void addRight(int idx) {
 		int num = arr[idx];
-		end[num] = idx;
-		if (start[num] == 0) {
-			start[num] = idx;
+		ed[num] = idx;
+		if (st[num] == 0) {
+			st[num] = idx;
 		}
-		curAns = Math.max(curAns, idx - start[num]);
+		curAns = Math.max(curAns, idx - st[num]);
 	}
 
 	public static void addLeft(int idx) {
 		int num = arr[idx];
-		if (end[num] != 0) {
-			curAns = Math.max(curAns, end[num] - idx);
+		if (ed[num] != 0) {
+			curAns = Math.max(curAns, ed[num] - idx);
 		} else {
-			end[num] = idx;
+			ed[num] = idx;
 		}
 	}
 
 	public static void undoLeft(int idx) {
 		int num = arr[idx];
-		if (end[num] == idx) {
-			end[num] = 0;
+		if (ed[num] == idx) {
+			ed[num] = 0;
 		}
 	}
 
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			curAns = 0;
-			Arrays.fill(start, 1, cntv + 1, 0);
-			Arrays.fill(end, 1, cntv + 1, 0);
+			Arrays.fill(st, 1, cntv + 1, 0);
+			Arrays.fill(ed, 1, cntv + 1, 0);
 			int winl = br[block] + 1;
 			int winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index 0de082bd9..d9d629747 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -26,9 +26,9 @@ public class Code04_ZeroQuery1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	public static int[] forceEnd = new int[MAXN + 1];
-	public static int[] start = new int[MAXN + 1];
-	public static int[] end = new int[MAXN + 1];
+	public static int[] forceEd = new int[MAXN + 1];
+	public static int[] st = new int[MAXN + 1];
+	public static int[] ed = new int[MAXN + 1];
 
 	public static int curAns = 0;
 	public static int[] ans = new int[MAXN];
@@ -62,48 +62,48 @@ public static int kth(int num) {
 	public static int force(int l, int r) {
 		int ret = 0;
 		for (int i = l; i <= r; i++) {
-			if (forceEnd[arr[i]] == 0) {
-				forceEnd[arr[i]] = i;
+			if (forceEd[arr[i]] == 0) {
+				forceEd[arr[i]] = i;
 			} else {
-				ret = Math.max(ret, i - forceEnd[arr[i]]);
+				ret = Math.max(ret, i - forceEd[arr[i]]);
 			}
 		}
 		for (int i = l; i <= r; i++) {
-			forceEnd[arr[i]] = 0;
+			forceEd[arr[i]] = 0;
 		}
 		return ret;
 	}
 
 	public static void addRight(int idx) {
 		int num = arr[idx];
-		end[num] = idx;
-		if (start[num] == 0) {
-			start[num] = idx;
+		ed[num] = idx;
+		if (st[num] == 0) {
+			st[num] = idx;
 		}
-		curAns = Math.max(curAns, idx - start[num]);
+		curAns = Math.max(curAns, idx - st[num]);
 	}
 
 	public static void addLeft(int idx) {
 		int num = arr[idx];
-		if (end[num] != 0) {
-			curAns = Math.max(curAns, end[num] - idx);
+		if (ed[num] != 0) {
+			curAns = Math.max(curAns, ed[num] - idx);
 		} else {
-			end[num] = idx;
+			ed[num] = idx;
 		}
 	}
 
 	public static void undoLeft(int idx) {
 		int num = arr[idx];
-		if (end[num] == idx) {
-			end[num] = 0;
+		if (ed[num] == idx) {
+			ed[num] = 0;
 		}
 	}
 
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			curAns = 0;
-			Arrays.fill(start, 1, cntv + 1, 0);
-			Arrays.fill(end, 1, cntv + 1, 0);
+			Arrays.fill(st, 1, cntv + 1, 0);
+			Arrays.fill(ed, 1, cntv + 1, 0);
 			int winl = br[block] + 1;
 			int winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index 51088f3f8..c140bc95e 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -33,8 +33,8 @@ public class Code07_MoOnTree1 {
 
 	public static int[] dep = new int[MAXN];
 	public static int[] seg = new int[MAXN << 1];
-	public static int[] startId = new int[MAXN];
-	public static int[] endId = new int[MAXN];
+	public static int[] st = new int[MAXN];
+	public static int[] ed = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
 	public static int cntd;
 
@@ -68,7 +68,7 @@ public static int kth(int num) {
 	public static void dfs(int u, int fa) {
 		dep[u] = dep[fa] + 1;
 		seg[++cntd] = u;
-		startId[u] = cntd;
+		st[u] = cntd;
 		stjump[u][0] = fa;
 		for (int p = 1; p < MAXP; p++) {
 			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -80,7 +80,7 @@ public static void dfs(int u, int fa) {
 			}
 		}
 		seg[++cntd] = u;
-		endId[u] = cntd;
+		ed[u] = cntd;
 	}
 
 	public static int lca(int a, int b) {
@@ -201,19 +201,19 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1, u, v, uvlca; i <= m; i++) {
 			u = in.nextInt();
 			v = in.nextInt();
-			if (startId[v] < startId[u]) {
+			if (st[v] < st[u]) {
 				int tmp = u;
 				u = v;
 				v = tmp;
 			}
 			uvlca = lca(u, v);
 			if (u == uvlca) {
-				query[i][0] = startId[u];
-				query[i][1] = startId[v];
+				query[i][0] = st[u];
+				query[i][1] = st[v];
 				query[i][2] = 0;
 			} else {
-				query[i][0] = endId[u];
-				query[i][1] = startId[v];
+				query[i][0] = ed[u];
+				query[i][1] = st[v];
 				query[i][2] = uvlca;
 			}
 			query[i][3] = i;
diff --git a/src/class177/Code07_MoOnTree2.java b/src/class177/Code07_MoOnTree2.java
index aa6ffc90a..2f0c239c1 100644
--- a/src/class177/Code07_MoOnTree2.java
+++ b/src/class177/Code07_MoOnTree2.java
@@ -30,8 +30,8 @@
 //
 //int dep[MAXN];
 //int seg[MAXN << 1];
-//int startId[MAXN];
-//int endId[MAXN];
+//int st[MAXN];
+//int ed[MAXN];
 //int stjump[MAXN][MAXP];
 //int cntd;
 //
@@ -65,7 +65,7 @@
 //void dfs(int u, int fa) {
 //    dep[u] = dep[fa] + 1;
 //    seg[++cntd] = u;
-//    startId[u] = cntd;
+//    st[u] = cntd;
 //    stjump[u][0] = fa;
 //    for (int p = 1; p < MAXP; p++) {
 //        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
@@ -77,7 +77,7 @@
 //        }
 //    }
 //    seg[++cntd] = u;
-//    endId[u] = cntd;
+//    ed[u] = cntd;
 //}
 //
 //int lca(int a, int b) {
@@ -185,17 +185,17 @@
 //    dfs(1, 0);
 //    for (int i = 1, u, v, uvlca; i <= m; i++) {
 //        cin >> u >> v;
-//        if (startId[v] < startId[u]) {
+//        if (st[v] < st[u]) {
 //            int tmp = u; u = v; v = tmp;
 //        }
 //        uvlca = lca(u, v);
 //        if (u == uvlca) {
-//        	query[i].l = startId[u];
-//        	query[i].r = startId[v];
+//        	query[i].l = st[u];
+//        	query[i].r = st[v];
 //        	query[i].lca = 0;
 //        } else {
-//        	query[i].l = endId[u];
-//        	query[i].r = startId[v];
+//        	query[i].l = ed[u];
+//        	query[i].r = st[v];
 //        	query[i].lca = uvlca;
 //        }
 //        query[i].id = i;

From c210e9a022d14b75be126eba7c2329d824515f5e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 16:48:41 +0800
Subject: [PATCH 1318/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java |   1 +
 src/class177/Code05_MoDelUndo1.java |   1 +
 src/class177/Code07_MoOnTree1.java  |  21 +-
 src/class177/Code07_MoOnTree2.java  |  41 ++--
 src/class177/Code08_CandyPark1.java | 329 ++++++++++++++++++++++++++++
 src/class177/Code08_CandyPark2.java | 216 ++++++++++++++++++
 6 files changed, 580 insertions(+), 29 deletions(-)
 create mode 100644 src/class177/Code08_CandyPark1.java
 create mode 100644 src/class177/Code08_CandyPark2.java

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index b84c883dd..e0b31d50d 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -32,6 +32,7 @@ public class Code01_MoAddUndo1 {
 	public static long curAns = 0;
 	public static long[] ans = new long[MAXN];
 
+	// 只增回滚莫队经典排序
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
diff --git a/src/class177/Code05_MoDelUndo1.java b/src/class177/Code05_MoDelUndo1.java
index d7ede8847..fde0c16d7 100644
--- a/src/class177/Code05_MoDelUndo1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -31,6 +31,7 @@ public class Code05_MoDelUndo1 {
 	public static int mex;
 	public static int[] ans = new int[MAXN];
 
+	// 只删回滚莫队经典排序
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index c140bc95e..91f0e4fae 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -106,6 +106,7 @@ public static int lca(int a, int b) {
 		return stjump[a][0];
 	}
 
+	// 普通莫队经典排序
 	public static class QueryCmp implements Comparator<int[]> {
 
 		@Override
@@ -118,7 +119,7 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static void update(int node) {
+	public static void modify(int node) {
 		int val = color[node];
 		if (vis[node]) {
 			if (--cnt[val] == 0) {
@@ -137,26 +138,26 @@ public static void compute() {
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
-			int jobLca = query[i][2];
+			int lca = query[i][2];
 			int id = query[i][3];
 			while (winl > jobl) {
-				update(seg[--winl]);
+				modify(seg[--winl]);
 			}
 			while (winr < jobr) {
-				update(seg[++winr]);
+				modify(seg[++winr]);
 			}
 			while (winl < jobl) {
-				update(seg[winl++]);
+				modify(seg[winl++]);
 			}
 			while (winr > jobr) {
-				update(seg[winr--]);
+				modify(seg[winr--]);
 			}
-			if (jobLca > 0) {
-				update(jobLca);
+			if (lca > 0) {
+				modify(lca);
 			}
 			ans[id] = kind;
-			if (jobLca > 0) {
-				update(jobLca);
+			if (lca > 0) {
+				modify(lca);
 			}
 		}
 	}
diff --git a/src/class177/Code07_MoOnTree2.java b/src/class177/Code07_MoOnTree2.java
index 2f0c239c1..9853b4a86 100644
--- a/src/class177/Code07_MoOnTree2.java
+++ b/src/class177/Code07_MoOnTree2.java
@@ -17,6 +17,7 @@
 //const int MAXN = 40001;
 //const int MAXM = 100001;
 //const int MAXP = 20;
+//
 //int n, m;
 //int color[MAXN];
 //Query query[MAXM];
@@ -82,14 +83,16 @@
 //
 //int lca(int a, int b) {
 //    if (dep[a] < dep[b]) {
-//        int tmp = a; a = b; b = tmp;
+//        swap(a, b);
 //    }
 //    for (int p = MAXP - 1; p >= 0; p--) {
 //        if (dep[stjump[a][p]] >= dep[b]) {
 //            a = stjump[a][p];
 //        }
 //    }
-//    if (a == b) return a;
+//    if (a == b) {
+//        return a;
+//    }
 //    for (int p = MAXP - 1; p >= 0; p--) {
 //        if (stjump[a][p] != stjump[b][p]) {
 //            a = stjump[a][p];
@@ -106,7 +109,7 @@
 //    return a.r < b.r;
 //}
 //
-//void update(int node) {
+//void modify(int node) {
 //    int val = color[node];
 //    if (vis[node]) {
 //        if (--cnt[val] == 0) {
@@ -125,26 +128,26 @@
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
-//        int jobLca = query[i].lca;
+//        int lca = query[i].lca;
 //        int id = query[i].id;
 //        while (winl > jobl) {
-//            update(seg[--winl]);
+//            modify(seg[--winl]);
 //        }
 //        while (winr < jobr) {
-//            update(seg[++winr]);
+//            modify(seg[++winr]);
 //        }
 //        while (winl < jobl) {
-//            update(seg[winl++]);
+//            modify(seg[winl++]);
 //        }
 //        while (winr > jobr) {
-//            update(seg[winr--]);
+//            modify(seg[winr--]);
 //        }
-//        if (jobLca > 0) {
-//            update(jobLca);
+//        if (lca > 0) {
+//            modify(lca);
 //        }
 //        ans[id] = kind;
-//        if (jobLca > 0) {
-//            update(jobLca);
+//        if (lca > 0) {
+//            modify(lca);
 //        }
 //    }
 //}
@@ -186,17 +189,17 @@
 //    for (int i = 1, u, v, uvlca; i <= m; i++) {
 //        cin >> u >> v;
 //        if (st[v] < st[u]) {
-//            int tmp = u; u = v; v = tmp;
+//            swap(u, v);
 //        }
 //        uvlca = lca(u, v);
 //        if (u == uvlca) {
-//        	query[i].l = st[u];
-//        	query[i].r = st[v];
-//        	query[i].lca = 0;
+//            query[i].l = st[u];
+//            query[i].r = st[v];
+//            query[i].lca = 0;
 //        } else {
-//        	query[i].l = ed[u];
-//        	query[i].r = st[v];
-//        	query[i].lca = uvlca;
+//            query[i].l = ed[u];
+//            query[i].r = st[v];
+//            query[i].lca = uvlca;
 //        }
 //        query[i].id = i;
 //    }
diff --git a/src/class177/Code08_CandyPark1.java b/src/class177/Code08_CandyPark1.java
new file mode 100644
index 000000000..787c33eec
--- /dev/null
+++ b/src/class177/Code08_CandyPark1.java
@@ -0,0 +1,329 @@
+package class177;
+
+// 糖果公园，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4074
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code08_CandyPark1 {
+
+	public static int MAXN = 100001;
+	public static int MAXP = 20;
+	public static int n, m, q;
+	public static int[] v = new int[MAXN];
+	public static int[] w = new int[MAXN];
+	public static int[] c = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] next = new int[MAXN << 1];
+	public static int cntg;
+
+	// 每条查询 : l、r、t、lca、id
+	public static int[][] query = new int[MAXN][5];
+	// 每条修改 : pos、val
+	public static int[][] update = new int[MAXN][2];
+	public static int cntq, cntu;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] seg = new int[MAXN << 1];
+	public static int[] st = new int[MAXN];
+	public static int[] ed = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int cntd;
+
+	public static int[] bi = new int[MAXN << 1];
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] cnt = new int[MAXN];
+	public static long curAns;
+	public static long[] ans = new long[MAXN];
+
+	public static void addEdge(int u, int v) {
+		next[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，C++可以通过，java会爆栈，需要改迭代
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		seg[++cntd] = u;
+		st[u] = cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u], v; e > 0; e = next[e]) {
+			v = to[e];
+			if (v != fa) {
+				dfs1(v, u);
+			}
+		}
+		seg[++cntd] = u;
+		ed[u] = cntd;
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// dfs1的迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				seg[++cntd] = u;
+				st[u] = cntd;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXP; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = next[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				seg[++cntd] = u;
+				ed[u] = cntd;
+			}
+		}
+	}
+
+	public static int lca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	// 带修莫队经典排序
+	public static class QueryCmp implements Comparator<int[]> {
+
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if (bi[a[1]] != bi[b[1]]) {
+				return bi[a[1]] - bi[b[1]];
+			}
+			return a[2] - b[2];
+		}
+
+	}
+
+	public static void modify(int node) {
+		int candy = c[node];
+		if (vis[node]) {
+			curAns -= (long) v[candy] * w[cnt[candy]--];
+		} else {
+			curAns += (long) v[candy] * w[++cnt[candy]];
+		}
+		vis[node] = !vis[node];
+	}
+
+	public static void moveTime(int tim) {
+		int pos = update[tim][0];
+		int oldVal = c[pos];
+		int newVal = update[tim][1];
+		if (vis[pos]) {
+			modify(pos);
+			c[pos] = newVal;
+			update[tim][1] = oldVal;
+			modify(pos);
+		} else {
+			c[pos] = newVal;
+			update[tim][1] = oldVal;
+		}
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0, wint = 0;
+		for (int i = 1; i <= cntq; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int jobt = query[i][2];
+			int lca = query[i][3];
+			int id = query[i][4];
+			while (winl > jobl) {
+				modify(seg[--winl]);
+			}
+			while (winr < jobr) {
+				modify(seg[++winr]);
+			}
+			while (winl < jobl) {
+				modify(seg[winl++]);
+			}
+			while (winr > jobr) {
+				modify(seg[winr--]);
+			}
+			while (wint < jobt) {
+				moveTime(++wint);
+			}
+			while (wint > jobt) {
+				moveTime(wint--);
+			}
+			if (lca > 0) {
+				modify(lca);
+			}
+			ans[id] = curAns;
+			if (lca > 0) {
+				modify(lca);
+			}
+		}
+	}
+
+	public static void prapare() {
+		int blen = Math.max(1, (int) Math.pow(cntd, 2.0 / 3));
+		for (int i = 1; i <= cntd; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		q = in.nextInt();
+		for (int i = 1; i <= m; i++) {
+			v[i] = in.nextInt();
+		}
+		for (int i = 1; i <= n; i++) {
+			w[i] = in.nextInt();
+		}
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			c[i] = in.nextInt();
+		}
+		dfs2();
+		for (int i = 1, op, x, y; i <= q; i++) {
+			op = in.nextInt();
+			x = in.nextInt();
+			y = in.nextInt();
+			if (op == 0) {
+				cntu++;
+				update[cntu][0] = x;
+				update[cntu][1] = y;
+			} else {
+				if (st[x] > st[y]) {
+					int tmp = x;
+					x = y;
+					y = tmp;
+				}
+				int xylca = lca(x, y);
+				if (x == xylca) {
+					query[++cntq][0] = st[x];
+					query[cntq][1] = st[y];
+					query[cntq][2] = cntu;
+					query[cntq][3] = 0;
+					query[cntq][4] = cntq;
+				} else {
+					query[++cntq][0] = ed[x];
+					query[cntq][1] = st[y];
+					query[cntq][2] = cntu;
+					query[cntq][3] = xylca;
+					query[cntq][4] = cntq;
+				}
+			}
+		}
+		prapare();
+		compute();
+		for (int i = 1; i <= cntq; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class177/Code08_CandyPark2.java b/src/class177/Code08_CandyPark2.java
new file mode 100644
index 000000000..e15a0e912
--- /dev/null
+++ b/src/class177/Code08_CandyPark2.java
@@ -0,0 +1,216 @@
+package class177;
+
+// 糖果公园，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4074
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, t, lca, id;
+//};
+//
+//struct Update {
+//    int pos, val;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXP = 20;
+//int n, m, q;
+//int v[MAXN];
+//int w[MAXN];
+//int c[MAXN];
+//
+//int head[MAXN];
+//int to[MAXN << 1];
+//int nxt[MAXN << 1];
+//int cntg;
+//
+//Query query[MAXN];
+//Update update[MAXN];
+//int cntq, cntu;
+//
+//int dep[MAXN];
+//int seg[MAXN << 1];
+//int st[MAXN];
+//int ed[MAXN];
+//int stjump[MAXN][MAXP];
+//int cntd;
+//
+//int bi[MAXN << 1];
+//bool vis[MAXN];
+//int cnt[MAXN];
+//long long curAns;
+//long long ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    seg[++cntd] = u;
+//    st[u] = cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u], v; e > 0; e = nxt[e]) {
+//        v = to[e];
+//        if (v != fa) {
+//            dfs(v, u);
+//        }
+//    }
+//    seg[++cntd] = u;
+//    ed[u] = cntd;
+//}
+//
+//int lca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.r] != bi[b.r]) {
+//        return bi[a.r] < bi[b.r];
+//    }
+//    return a.t < b.t;
+//}
+//
+//void modify(int node) {
+//    int candy = c[node];
+//    if (vis[node]) {
+//        curAns -= 1LL * v[candy] * w[cnt[candy]--];
+//    } else {
+//        curAns += 1LL * v[candy] * w[++cnt[candy]];
+//    }
+//    vis[node] = !vis[node];
+//}
+//
+//void moveTime(int tim) {
+//    int pos = update[tim].pos;
+//    int oldVal = c[pos];
+//    int newVal = update[tim].val;
+//    if (vis[pos]) {
+//        modify(pos);
+//        c[pos] = newVal;
+//        update[tim].val = oldVal;
+//        modify(pos);
+//    } else {
+//        c[pos] = newVal;
+//        update[tim].val = oldVal;
+//    }
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0, wint = 0;
+//    for (int i = 1; i <= cntq; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int jobt = query[i].t;
+//        int lca = query[i].lca;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            modify(seg[--winl]);
+//        }
+//        while (winr < jobr) {
+//            modify(seg[++winr]);
+//        }
+//        while (winl < jobl) {
+//            modify(seg[winl++]);
+//        }
+//        while (winr > jobr) {
+//            modify(seg[winr--]);
+//        }
+//        while (wint < jobt) {
+//            moveTime(++wint);
+//        }
+//        while (wint > jobt) {
+//            moveTime(wint--);
+//        }
+//        if (lca > 0) {
+//            modify(lca);
+//        }
+//        ans[id] = curAns;
+//        if (lca > 0) {
+//            modify(lca);
+//        }
+//    }
+//}
+//
+//void prapare() {
+//    int blen = max(1, (int)pow(cntd, 2.0 / 3.0));
+//    for (int i = 1; i <= cntd; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> q;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> v[i];
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> w[i];
+//    }
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> c[i];
+//    }
+//    dfs(1, 0);
+//    for (int i = 1, op, x, y; i <= q; i++) {
+//        cin >> op >> x >> y;
+//        if (op == 0) {
+//            cntu++;
+//            update[cntu].pos = x;
+//            update[cntu].val = y;
+//        } else {
+//            if (st[x] > st[y]) {
+//                swap(x, y);
+//            }
+//            int xylca = lca(x, y);
+//            if (x == xylca) {
+//                query[++cntq] = {st[x], st[y], cntu, 0, cntq};
+//            } else {
+//                query[++cntq] = {ed[x], st[y], cntu, xylca, cntq};
+//            }
+//        }
+//    }
+//    prapare();
+//    compute();
+//    for (int i = 1; i <= cntq; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 428df5863b443df403d9e4aa08315d4b0c2b320f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 16:51:56 +0800
Subject: [PATCH 1319/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java         | 3 +--
 src/class177/Code02_ThresholdMajority1.java | 3 +--
 src/class177/Code03_SameNumberMaxDist1.java | 3 +--
 src/class177/Code04_ZeroQuery1.java         | 3 +--
 4 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index e0b31d50d..ff79f3008 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -86,8 +86,7 @@ public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			curAns = 0;
 			Arrays.fill(cnt, 1, cntv + 1, 0);
-			int winl = br[block] + 1;
-			int winr = br[block];
+			int winl = br[block] + 1, winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
 				int jobr = query[qi][1];
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index 7a8fea772..909b1dddc 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -92,8 +92,7 @@ public static void compute() {
 				maxCnt = 0;
 				numAns = 0;
 				Arrays.fill(cnt, 1, cntv + 1, 0);
-				int winl = br[block] + 1;
-				int winr = br[block];
+				int winl = br[block] + 1, winr = br[block];
 				for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 					int jobl = query[qi][0];
 					int jobr = query[qi][1];
diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index debf1770c..9f27478ad 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -103,8 +103,7 @@ public static void compute() {
 			curAns = 0;
 			Arrays.fill(st, 1, cntv + 1, 0);
 			Arrays.fill(ed, 1, cntv + 1, 0);
-			int winl = br[block] + 1;
-			int winr = br[block];
+			int winl = br[block] + 1, winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
 				int jobr = query[qi][1];
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index d9d629747..057125182 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -104,8 +104,7 @@ public static void compute() {
 			curAns = 0;
 			Arrays.fill(st, 1, cntv + 1, 0);
 			Arrays.fill(ed, 1, cntv + 1, 0);
-			int winl = br[block] + 1;
-			int winr = br[block];
+			int winl = br[block] + 1, winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0] - 1;
 				int jobr = query[qi][1];

From 957f8dca70d84d484a71d4f7f5db5ea2f82b57c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 17:11:01 +0800
Subject: [PATCH 1320/1712] modify code

---
 src/class177/Code01_MoAddUndo2.java | 150 ++++++++++++++++++++++++++++
 1 file changed, 150 insertions(+)
 create mode 100644 src/class177/Code01_MoAddUndo2.java

diff --git a/src/class177/Code01_MoAddUndo2.java b/src/class177/Code01_MoAddUndo2.java
new file mode 100644
index 000000000..be344297a
--- /dev/null
+++ b/src/class177/Code01_MoAddUndo2.java
@@ -0,0 +1,150 @@
+package class177;
+
+// 只增回滚莫队入门题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/AT_joisc2014_c
+// 测试链接 : https://atcoder.jp/contests/joisc2014/tasks/joisc2014_c
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXB = 401;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//int sorted[MAXN];
+//int cntv;
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int br[MAXB];
+//
+//int forceCnt[MAXN];
+//int cnt[MAXN];
+//
+//long long curAns = 0;
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//long long force(int l, int r) {
+//    long long ret = 0;
+//    for (int i = l; i <= r; i++) {
+//        forceCnt[arr[i]]++;
+//    }
+//    for (int i = l; i <= r; i++) {
+//        ret = max(ret, 1LL * forceCnt[arr[i]] * sorted[arr[i]]);
+//    }
+//    for (int i = l; i <= r; i++) {
+//        forceCnt[arr[i]]--;
+//    }
+//    return ret;
+//}
+//
+//void add(int num) {
+//    cnt[num]++;
+//    curAns = max(curAns, 1LL * cnt[num] * sorted[num]);
+//}
+//
+//void undo(int num) {
+//    cnt[num]--;
+//}
+//
+//void compute() {
+//    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+//        curAns = 0;
+//        fill(cnt + 1, cnt + cntv + 1, 0);
+//        int winl = br[block] + 1, winr = br[block];
+//        for (; qi <= m && bi[query[qi].l] == block; qi++) {
+//            int jobl = query[qi].l;
+//            int jobr = query[qi].r;
+//            int id = query[qi].id;
+//            if (jobr <= br[block]) {
+//                ans[id] = force(jobl, jobr);
+//            } else {
+//                while (winr < jobr) {
+//                    add(arr[++winr]);
+//                }
+//                long long backup = curAns;
+//                while (winl > jobl) {
+//                    add(arr[--winl]);
+//                }
+//                ans[id] = curAns;
+//                curAns = backup;
+//                while (winl <= br[block]) {
+//                    undo(arr[winl++]);
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//    	sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[cntv] != sorted[i]) {
+//        	sorted[++cntv] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        br[i] = min(i * blen, n);
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 0671bd3f6bf13af1d8e0991799112bed9730a163 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 17:19:13 +0800
Subject: [PATCH 1321/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist2.java | 169 ++++++++++++++++++++
 1 file changed, 169 insertions(+)
 create mode 100644 src/class177/Code03_SameNumberMaxDist2.java

diff --git a/src/class177/Code03_SameNumberMaxDist2.java b/src/class177/Code03_SameNumberMaxDist2.java
new file mode 100644
index 000000000..cd8d863bf
--- /dev/null
+++ b/src/class177/Code03_SameNumberMaxDist2.java
@@ -0,0 +1,169 @@
+package class177;
+
+// 相同数的最远距离，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5906
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 200001;
+//const int MAXB = 501;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//int sortedv[MAXN];
+//int cntv;
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int br[MAXB];
+//
+//int forceEd[MAXN];
+//int st[MAXN];
+//int ed[MAXN];
+//
+//int curAns = 0;
+//int ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sortedv[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//int force(int l, int r) {
+//    int ret = 0;
+//    for (int i = l; i <= r; i++) {
+//        if (forceEd[arr[i]] == 0) {
+//            forceEd[arr[i]] = i;
+//        } else {
+//            ret = max(ret, i - forceEd[arr[i]]);
+//        }
+//    }
+//    for (int i = l; i <= r; i++) {
+//        forceEd[arr[i]] = 0;
+//    }
+//    return ret;
+//}
+//
+//void addRight(int idx) {
+//    int num = arr[idx];
+//    ed[num] = idx;
+//    if (st[num] == 0) {
+//        st[num] = idx;
+//    }
+//    curAns = max(curAns, idx - st[num]);
+//}
+//
+//void addLeft(int idx) {
+//    int num = arr[idx];
+//    if (ed[num] != 0) {
+//        curAns = max(curAns, ed[num] - idx);
+//    } else {
+//        ed[num] = idx;
+//    }
+//}
+//
+//void undoLeft(int idx) {
+//    int num = arr[idx];
+//    if (ed[num] == idx) {
+//        ed[num] = 0;
+//    }
+//}
+//
+//void compute() {
+//    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+//        curAns = 0;
+//        fill(st + 1, st + cntv + 1, 0);
+//        fill(ed + 1, ed + cntv + 1, 0);
+//        int winl = br[block] + 1, winr = br[block];
+//        for (; qi <= m && bi[query[qi].l] == block; qi++) {
+//            int jobl = query[qi].l;
+//            int jobr = query[qi].r;
+//            int id = query[qi].id;
+//            if (jobr <= br[block]) {
+//                ans[id] = force(jobl, jobr);
+//            } else {
+//                while (winr < jobr) {
+//                    addRight(++winr);
+//                }
+//                int backup = curAns;
+//                while (winl > jobl) {
+//                    addLeft(--winl);
+//                }
+//                ans[id] = curAns;
+//                curAns = backup;
+//                while (winl <= br[block]) {
+//                    undoLeft(winl++);
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sortedv[i] = arr[i];
+//    }
+//    sort(sortedv + 1, sortedv + n + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sortedv[cntv] != sortedv[i]) {
+//            sortedv[++cntv] = sortedv[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        br[i] = min(i * blen, n);
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    cin >> m;
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 004f412b8f51d4e54f39a39dde312cd36afc2fd1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 17:26:37 +0800
Subject: [PATCH 1322/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist2.java |  12 +-
 src/class177/Code04_ZeroQuery2.java         | 174 ++++++++++++++++++++
 2 files changed, 180 insertions(+), 6 deletions(-)
 create mode 100644 src/class177/Code04_ZeroQuery2.java

diff --git a/src/class177/Code03_SameNumberMaxDist2.java b/src/class177/Code03_SameNumberMaxDist2.java
index cd8d863bf..52d0e75a8 100644
--- a/src/class177/Code03_SameNumberMaxDist2.java
+++ b/src/class177/Code03_SameNumberMaxDist2.java
@@ -18,7 +18,7 @@
 //int n, m;
 //int arr[MAXN];
 //Query query[MAXN];
-//int sortedv[MAXN];
+//int sorted[MAXN];
 //int cntv;
 //
 //int blen, bnum;
@@ -43,7 +43,7 @@
 //    int left = 1, right = cntv, ret = 0;
 //    while (left <= right) {
 //        int mid = (left + right) >> 1;
-//        if (sortedv[mid] <= num) {
+//        if (sorted[mid] <= num) {
 //            ret = mid;
 //            left = mid + 1;
 //        } else {
@@ -125,13 +125,13 @@
 //
 //void prepare() {
 //    for (int i = 1; i <= n; i++) {
-//        sortedv[i] = arr[i];
+//        sorted[i] = arr[i];
 //    }
-//    sort(sortedv + 1, sortedv + n + 1);
+//    sort(sorted + 1, sorted + n + 1);
 //    cntv = 1;
 //    for (int i = 2; i <= n; i++) {
-//        if (sortedv[cntv] != sortedv[i]) {
-//            sortedv[++cntv] = sortedv[i];
+//        if (sorted[cntv] != sorted[i]) {
+//            sorted[++cntv] = sorted[i];
 //        }
 //    }
 //    for (int i = 1; i <= n; i++) {
diff --git a/src/class177/Code04_ZeroQuery2.java b/src/class177/Code04_ZeroQuery2.java
new file mode 100644
index 000000000..0093e943a
--- /dev/null
+++ b/src/class177/Code04_ZeroQuery2.java
@@ -0,0 +1,174 @@
+package class177;
+
+// 累加和为0的最长子数组，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/SP20644
+// 测试链接 : https://www.spoj.com/problems/ZQUERY/
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 50001;
+//const int MAXB = 301;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//int sorted[MAXN + 1];
+//int cntv;
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int br[MAXB];
+//
+//int forceEd[MAXN + 1];
+//int st[MAXN + 1];
+//int ed[MAXN + 1];
+//
+//int curAns = 0;
+//int ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//int force(int l, int r) {
+//    int ret = 0;
+//    for (int i = l; i <= r; i++) {
+//        if (forceEd[arr[i]] == 0) {
+//            forceEd[arr[i]] = i;
+//        } else {
+//            ret = max(ret, i - forceEd[arr[i]]);
+//        }
+//    }
+//    for (int i = l; i <= r; i++) {
+//        forceEd[arr[i]] = 0;
+//    }
+//    return ret;
+//}
+//
+//void addRight(int idx) {
+//    int num = arr[idx];
+//    ed[num] = idx;
+//    if (st[num] == 0) {
+//        st[num] = idx;
+//    }
+//    curAns = max(curAns, idx - st[num]);
+//}
+//
+//void addLeft(int idx) {
+//    int num = arr[idx];
+//    if (ed[num] != 0) {
+//        curAns = max(curAns, ed[num] - idx);
+//    } else {
+//        ed[num] = idx;
+//    }
+//}
+//
+//void undoLeft(int idx) {
+//    int num = arr[idx];
+//    if (ed[num] == idx) {
+//        ed[num] = 0;
+//    }
+//}
+//
+//void compute() {
+//    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+//        curAns = 0;
+//        fill(st + 1, st + cntv + 1, 0);
+//        fill(ed + 1, ed + cntv + 1, 0);
+//        int winl = br[block] + 1, winr = br[block];
+//        for (; qi <= m && bi[query[qi].l] == block; qi++) {
+//            int jobl = query[qi].l - 1;
+//            int jobr = query[qi].r;
+//            int id = query[qi].id;
+//            if (jobr <= br[block]) {
+//                ans[id] = force(jobl, jobr);
+//            } else {
+//                while (winr < jobr) {
+//                    addRight(++winr);
+//                }
+//                int backup = curAns;
+//                while (winl > jobl) {
+//                    addLeft(--winl);
+//                }
+//                ans[id] = curAns;
+//                curAns = backup;
+//                while (winl <= br[block]) {
+//                    undoLeft(winl++);
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] += arr[i - 1];
+//    }
+//    int len = 0;
+//    sorted[++len] = 0;
+//    for (int i = 1; i <= n; i++) {
+//        sorted[++len] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + len + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (sorted[cntv] != sorted[i]) {
+//            sorted[++cntv] = sorted[i];
+//        }
+//    }
+//    for (int i = 0; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        br[i] = min(i * blen, n);
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From cae297c70818870598ef51841811ae1e47c6fff6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 17:31:14 +0800
Subject: [PATCH 1323/1712] modify code

---
 src/class177/Code05_MoDelUndo2.java | 118 ++++++++++++++++++++++++++++
 1 file changed, 118 insertions(+)
 create mode 100644 src/class177/Code05_MoDelUndo2.java

diff --git a/src/class177/Code05_MoDelUndo2.java b/src/class177/Code05_MoDelUndo2.java
new file mode 100644
index 000000000..d37e06223
--- /dev/null
+++ b/src/class177/Code05_MoDelUndo2.java
@@ -0,0 +1,118 @@
+package class177;
+
+// 只删回滚莫队入门题，C++版
+// 本题最优解为主席树，讲解158，题目2，已经讲述
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : 打印arr[l..r]内没有出现过的最小自然数，注意0是自然数
+// 0 <= n、m、arr[i] <= 2 * 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P4137
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 200001;
+//const int MAXB = 501;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int bl[MAXB];
+//
+//int cnt[MAXN + 1];
+//int mex;
+//int ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return b.r < a.r;
+//}
+//
+//void del(int num) {
+//    if (--cnt[num] == 0) {
+//        mex = min(mex, num);
+//    }
+//}
+//
+//void undo(int num) {
+//    cnt[num]++;
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= n; i++) {
+//        undo(arr[i]);
+//    }
+//    mex = 0;
+//    while (cnt[mex] != 0) {
+//        mex++;
+//    }
+//    int winl = 1, winr = n;
+//    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+//        while (winl < bl[block]) {
+//            del(arr[winl++]);
+//        }
+//        int beforeJob = mex;
+//        for (; qi <= m && bi[query[qi].l] == block; qi++) {
+//            int jobl = query[qi].l;
+//            int jobr = query[qi].r;
+//            int id = query[qi].id;
+//            while (winr > jobr) {
+//                del(arr[winr--]);
+//            }
+//            int backup = mex;
+//            while (winl < jobl) {
+//                del(arr[winl++]);
+//            }
+//            ans[id] = mex;
+//            mex = backup;
+//            while (winl > bl[block]) {
+//                undo(arr[--winl]);
+//            }
+//        }
+//        while (winr < n) {
+//            undo(arr[++winr]);
+//        }
+//        mex = beforeJob;
+//    }
+//}
+//
+//void prepare() {
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From cba5c01b1ff3455b439aaad5491ca502bbe8d1f2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 17:44:15 +0800
Subject: [PATCH 1324/1712] modify code

---
 src/class177/Code02_ThresholdMajority1.java |  15 +-
 src/class177/Code02_ThresholdMajority2.java | 171 ++++++++++++++++++++
 2 files changed, 179 insertions(+), 7 deletions(-)
 create mode 100644 src/class177/Code02_ThresholdMajority2.java

diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index 909b1dddc..592745d8c 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -2,7 +2,7 @@
 
 // 达到阈值的最小众数，java版
 // 测试链接 : https://leetcode.cn/problems/threshold-majority-queries/
-// 提交如下代码中的Solution类，可以通过所有测试用例
+// 提交以下代码中的Solution类，可以通过所有测试用例
 
 import java.util.Arrays;
 import java.util.Comparator;
@@ -58,21 +58,22 @@ public static int kth(int num) {
 		}
 
 		public static int force(int l, int r, int k) {
-			int maxCnt = 0;
-			int numAns = 0;
+			int mx = 0;
+			int who = 0;
 			for (int i = l; i <= r; i++) {
 				forceCnt[arr[i]]++;
 			}
 			for (int i = l; i <= r; i++) {
-				if (forceCnt[arr[i]] > maxCnt || (forceCnt[arr[i]] == maxCnt && arr[i] < numAns)) {
-					maxCnt = forceCnt[arr[i]];
-					numAns = arr[i];
+				int num = arr[i];
+				if (forceCnt[num] > mx || (forceCnt[num] == mx && num < who)) {
+					mx = forceCnt[num];
+					who = num;
 				}
 			}
 			for (int i = l; i <= r; i++) {
 				forceCnt[arr[i]]--;
 			}
-			return maxCnt >= k ? sorted[numAns] : -1;
+			return mx >= k ? sorted[who] : -1;
 		}
 
 		public static void add(int num) {
diff --git a/src/class177/Code02_ThresholdMajority2.java b/src/class177/Code02_ThresholdMajority2.java
new file mode 100644
index 000000000..036b0fd6a
--- /dev/null
+++ b/src/class177/Code02_ThresholdMajority2.java
@@ -0,0 +1,171 @@
+package class177;
+
+// 达到阈值的最小众数，C++版
+// 测试链接 : https://leetcode.cn/problems/threshold-majority-queries/
+// 提交以下全部代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, k, id;
+//};
+//
+//const int MAXN = 10001;
+//const int MAXM = 50001;
+//const int MAXB = 301;
+//
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXM];
+//int sorted[MAXN];
+//int cntv;
+//
+//int blen, bnum;
+//int bi[MAXN];
+//int br[MAXB];
+//
+//int forceCnt[MAXN];
+//int cnt[MAXN];
+//
+//int maxCnt;
+//int numAns;
+//int ans[MAXM];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//int force(int l, int r, int k) {
+//    int mx = 0, who = 0;
+//    for (int i = l; i <= r; i++) {
+//        forceCnt[arr[i]]++;
+//    }
+//    for (int i = l; i <= r; i++) {
+//        int num = arr[i];
+//        if (forceCnt[num] > mx || (forceCnt[num] == mx && num < who)) {
+//            mx = forceCnt[num];
+//            who = num;
+//        }
+//    }
+//    for (int i = l; i <= r; i++) {
+//        forceCnt[arr[i]]--;
+//    }
+//    return mx >= k ? sorted[who] : -1;
+//}
+//
+//void add(int num) {
+//    cnt[num]++;
+//    if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < numAns)) {
+//        maxCnt = cnt[num];
+//        numAns = num;
+//    }
+//}
+//
+//void undo(int num) {
+//    cnt[num]--;
+//}
+//
+//void compute() {
+//    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
+//        maxCnt = 0;
+//        numAns = 0;
+//        fill(cnt + 1, cnt + cntv + 1, 0);
+//        int winl = br[block] + 1, winr = br[block];
+//        for (; qi <= m && bi[query[qi].l] == block; qi++) {
+//            int jobl = query[qi].l;
+//            int jobr = query[qi].r;
+//            int jobk = query[qi].k;
+//            int id = query[qi].id;
+//            if (jobr <= br[block]) {
+//                ans[id] = force(jobl, jobr, jobk);
+//            } else {
+//                while (winr < jobr) {
+//                    add(arr[++winr]);
+//                }
+//                int backupCnt = maxCnt;
+//                int backupNum = numAns;
+//                while (winl > jobl) {
+//                    add(arr[--winl]);
+//                }
+//                if (maxCnt >= jobk) {
+//                    ans[id] = sorted[numAns];
+//                } else {
+//                	ans[id] = -1;
+//                }
+//                maxCnt = backupCnt;
+//                numAns = backupNum;
+//                while (winl <= br[block]) {
+//                    undo(arr[winl++]);
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[cntv] != sorted[i]) {
+//            sorted[++cntv] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    blen = (int)sqrt(n);
+//    bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        br[i] = min(i * blen, n);
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//class Solution {
+//public:
+//    vector<int> subarrayMajority(vector<int>& nums, vector<vector<int>>& queries) {
+//        n = (int)nums.size();
+//        m = (int)queries.size();
+//        for (int i = 1; i <= n; i++) {
+//            arr[i] = nums[i - 1];
+//        }
+//        for (int i = 1; i <= m; i++) {
+//            query[i].l = queries[i - 1][0] + 1;
+//            query[i].r = queries[i - 1][1] + 1;
+//            query[i].k = queries[i - 1][2];
+//            query[i].id = i;
+//        }
+//        prepare();
+//        compute();
+//        vector<int> ret(m);
+//        for (int i = 1; i <= m; i++) {
+//            ret[i - 1] = ans[i];
+//        }
+//        return ret;
+//    }
+//};
\ No newline at end of file

From 8d7d3b627e65cf72e9b8e9c31bea51faf257c5ac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 27 Aug 2025 18:56:51 +0800
Subject: [PATCH 1325/1712] modify code

---
 src/class177/Code05_MoDelUndo1.java | 18 +++++++++++-------
 src/class177/Code05_MoDelUndo2.java | 18 +++++++++++-------
 src/class177/Code06_BaldChief1.java | 24 ++++++++++++++----------
 src/class177/Code06_BaldChief2.java | 25 ++++++++++++++-----------
 4 files changed, 50 insertions(+), 35 deletions(-)

diff --git a/src/class177/Code05_MoDelUndo1.java b/src/class177/Code05_MoDelUndo1.java
index fde0c16d7..6c986cb88 100644
--- a/src/class177/Code05_MoDelUndo1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -44,6 +44,16 @@ public int compare(int[] a, int[] b) {
 
 	}
 
+	public static void init() {
+		for (int i = 1; i <= n; i++) {
+			cnt[arr[i]]++;
+		}
+		mex = 0;
+		while (cnt[mex] != 0) {
+			mex++;
+		}
+	}
+
 	public static void del(int num) {
 		if (--cnt[num] == 0) {
 			mex = Math.min(mex, num);
@@ -55,13 +65,7 @@ public static void undo(int num) {
 	}
 
 	public static void compute() {
-		for (int i = 1; i <= n; i++) {
-			undo(arr[i]);
-		}
-		mex = 0;
-		while (cnt[mex] != 0) {
-			mex++;
-		}
+		init();
 		int winl = 1, winr = n;
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			while (winl < bl[block]) {
diff --git a/src/class177/Code05_MoDelUndo2.java b/src/class177/Code05_MoDelUndo2.java
index d37e06223..891d452ac 100644
--- a/src/class177/Code05_MoDelUndo2.java
+++ b/src/class177/Code05_MoDelUndo2.java
@@ -38,6 +38,16 @@
 //    return b.r < a.r;
 //}
 //
+//void init() {
+//    for (int i = 1; i <= n; i++) {
+//        cnt[arr[i]]++;
+//    }
+//    mex = 0;
+//    while (cnt[mex] != 0) {
+//        mex++;
+//    }
+//}
+//
 //void del(int num) {
 //    if (--cnt[num] == 0) {
 //        mex = min(mex, num);
@@ -49,13 +59,7 @@
 //}
 //
 //void compute() {
-//    for (int i = 1; i <= n; i++) {
-//        undo(arr[i]);
-//    }
-//    mex = 0;
-//    while (cnt[mex] != 0) {
-//        mex++;
-//    }
+//    init();
 //    int winl = 1, winr = n;
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 //        while (winl < bl[block]) {
diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index 42db55a79..858009e31 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -43,6 +43,18 @@ public int compare(int[] a, int[] b) {
 
 	}
 
+	public static void init() {
+		for (int v = 1; v <= n; v++) {
+			last[v] = v - 1;
+			next[v] = v + 1;
+		}
+		next[0] = 1;
+		last[n + 1] = n;
+		for (int v = 2; v <= n; v++) {
+			sum += Math.abs(pos[v] - pos[v - 1]);
+		}
+	}
+
 	// 删除num
 	public static void del(int num) {
 		int less = last[num], more = next[num];
@@ -67,15 +79,7 @@ public static void undo(int num) {
 	}
 
 	public static void compute() {
-		for (int v = 1; v <= n; v++) {
-			last[v] = v - 1;
-			next[v] = v + 1;
-		}
-		next[0] = 1;
-		last[n + 1] = n;
-		for (int v = 2; v <= n; v++) {
-			sum += Math.abs(pos[v] - pos[v - 1]);
-		}
+		init();
 		int winl = 1, winr = n;
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			while (winl < bl[block]) {
@@ -94,10 +98,10 @@ public static void compute() {
 					del(arr[winl++]);
 				}
 				ans[id] = sum;
+				sum = backup;
 				while (winl > bl[block]) {
 					undo(arr[--winl]);
 				}
-				sum = backup;
 			}
 			while (winr < n) {
 				undo(arr[++winr]);
diff --git a/src/class177/Code06_BaldChief2.java b/src/class177/Code06_BaldChief2.java
index bd5fe178c..5806741e1 100644
--- a/src/class177/Code06_BaldChief2.java
+++ b/src/class177/Code06_BaldChief2.java
@@ -35,6 +35,18 @@
 //    return a.r > b.r;
 //}
 //
+//inline void init() {
+//    for (int v = 1; v <= n; v++) {
+//        lst[v] = v - 1;
+//        nxt[v] = v + 1;
+//    }
+//    nxt[0] = 1;
+//    lst[n + 1] = n;
+//    for (int v = 2; v <= n; v++) {
+//        sum += abs(pos[v] - pos[v - 1]);
+//    }
+//}
+//
 //inline void del(int num) {
 //    int less = lst[num], more = nxt[num];
 //    if (less != 0) {
@@ -71,16 +83,7 @@
 //}
 //
 //void compute() {
-//    for (int v = 1; v <= n; v++) {
-//        lst[v] = v - 1;
-//        nxt[v] = v + 1;
-//    }
-//    nxt[0] = 1;
-//    lst[n + 1] = n;
-//    sum = 0;
-//    for (int v = 2; v <= n; v++) {
-//        sum += abs(pos[v] - pos[v - 1]);
-//    }
+//    init();
 //    int winl = 1, winr = n;
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 //        while (winl < bl[block]) {
@@ -99,10 +102,10 @@
 //                del(arr[winl++]);
 //            }
 //            ans[id] = sum;
+//            sum = backup;
 //            while (winl > bl[block]) {
 //                undo(arr[--winl]);
 //            }
-//            sum = backup;
 //        }
 //        while (winr < n) {
 //            undo(arr[++winr]);

From 95467f5b754847ac4ea55dd2a9d54b9f13368042 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 15:30:37 +0800
Subject: [PATCH 1326/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java         |  6 ++++
 src/class177/Code01_MoAddUndo2.java         |  6 ++++
 src/class177/Code02_ThresholdMajority1.java |  6 ++++
 src/class177/Code02_ThresholdMajority2.java |  6 ++++
 src/class177/Code03_SameNumberMaxDist1.java |  5 +++
 src/class177/Code03_SameNumberMaxDist2.java |  5 +++
 src/class177/Code04_ZeroQuery1.java         | 37 ++++++++++++++-------
 src/class177/Code04_ZeroQuery2.java         | 29 +++++++++-------
 8 files changed, 76 insertions(+), 24 deletions(-)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index ff79f3008..ee15d2a6e 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -1,6 +1,12 @@
 package class177;
 
 // 只增回滚莫队入门题，java版
+// 给定一个长度为n的数组arr，下面定义重要度的概念
+// 如果一段范围上，数字x出现c次，那么这个数字的重要度为x * c
+// 范围上的最大重要度，就是该范围上，每种数字的重要度取最大值
+// 一共有m条查询，格式 l r : 打印arr[l..r]范围上的最大重要度
+// 1 <= n、m <= 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/AT_joisc2014_c
 // 测试链接 : https://atcoder.jp/contests/joisc2014/tasks/joisc2014_c
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class177/Code01_MoAddUndo2.java b/src/class177/Code01_MoAddUndo2.java
index be344297a..472170ed2 100644
--- a/src/class177/Code01_MoAddUndo2.java
+++ b/src/class177/Code01_MoAddUndo2.java
@@ -1,6 +1,12 @@
 package class177;
 
 // 只增回滚莫队入门题，C++版
+// 给定一个长度为n的数组arr，下面定义重要度的概念
+// 如果一段范围上，数字x出现c次，那么这个数字的重要度为x * c
+// 范围上的最大重要度，就是该范围上，每种数字的重要度取最大值
+// 一共有m条查询，格式 l r : 打印arr[l..r]范围上的最大重要度
+// 1 <= n、m <= 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/AT_joisc2014_c
 // 测试链接 : https://atcoder.jp/contests/joisc2014/tasks/joisc2014_c
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index 592745d8c..dac3415f6 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -1,6 +1,12 @@
 package class177;
 
 // 达到阈值的最小众数，java版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r k : arr[l..r]范围上，如果所有数字的出现次数 < k，打印-1
+//              如果有些数字的出现次数 >= k，打印其中的最小众数
+// 1 <= n <= 10^4
+// 1 <= m <= 5 * 10^4
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://leetcode.cn/problems/threshold-majority-queries/
 // 提交以下代码中的Solution类，可以通过所有测试用例
 
diff --git a/src/class177/Code02_ThresholdMajority2.java b/src/class177/Code02_ThresholdMajority2.java
index 036b0fd6a..530a03aee 100644
--- a/src/class177/Code02_ThresholdMajority2.java
+++ b/src/class177/Code02_ThresholdMajority2.java
@@ -1,6 +1,12 @@
 package class177;
 
 // 达到阈值的最小众数，C++版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r k : arr[l..r]范围上，如果所有数字的出现次数 < k，打印-1
+//              如果有些数字的出现次数 >= k，打印其中的最小众数
+// 1 <= n <= 10^4
+// 1 <= m <= 5 * 10^4
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://leetcode.cn/problems/threshold-majority-queries/
 // 提交以下全部代码，可以通过所有测试用例
 
diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index 9f27478ad..141cbca4e 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -1,6 +1,11 @@
 package class177;
 
 // 相同数的最远距离，java版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : 打印arr[l..r]范围上，相同的数的最远间隔距离
+//            序列中两个元素的间隔距离指的是两个元素下标差的绝对值
+// 1 <= n、m <= 2 * 10^5
+// 1 <= arr[i] <= 2 * 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5906
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class177/Code03_SameNumberMaxDist2.java b/src/class177/Code03_SameNumberMaxDist2.java
index 52d0e75a8..26f75d17f 100644
--- a/src/class177/Code03_SameNumberMaxDist2.java
+++ b/src/class177/Code03_SameNumberMaxDist2.java
@@ -1,6 +1,11 @@
 package class177;
 
 // 相同数的最远距离，C++版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : 打印arr[l..r]范围上，相同的数的最远间隔距离
+//            序列中两个元素的间隔距离指的是两个元素下标差的绝对值
+// 1 <= n、m <= 2 * 10^5
+// 1 <= arr[i] <= 2 * 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5906
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index 057125182..cfed91ea1 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -1,6 +1,9 @@
 package class177;
 
 // 累加和为0的最长子数组，java版
+// 给定一个长度为n的数组arr，其中只有1和-1两种值
+// 一共有m条查询，格式 l r : 打印arr[l..r]范围上，累加和为0的最长子数组长度
+// 1 <= n、m <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/SP20644
 // 测试链接 : https://www.spoj.com/problems/ZQUERY/
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -14,21 +17,21 @@
 
 public class Code04_ZeroQuery1 {
 
-	public static int MAXN = 50001;
+	public static int MAXN = 50002;
 	public static int MAXB = 301;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	public static int[][] query = new int[MAXN][3];
-	public static int[] sorted = new int[MAXN + 1];
+	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
 	public static int blen, bnum;
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	public static int[] forceEd = new int[MAXN + 1];
-	public static int[] st = new int[MAXN + 1];
-	public static int[] ed = new int[MAXN + 1];
+	public static int[] forceEd = new int[MAXN];
+	public static int[] st = new int[MAXN];
+	public static int[] ed = new int[MAXN];
 
 	public static int curAns = 0;
 	public static int[] ans = new int[MAXN];
@@ -106,7 +109,7 @@ public static void compute() {
 			Arrays.fill(ed, 1, cntv + 1, 0);
 			int winl = br[block] + 1, winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
-				int jobl = query[qi][0] - 1;
+				int jobl = query[qi][0];
 				int jobr = query[qi][1];
 				int id = query[qi][2];
 				if (jobr <= br[block]) {
@@ -130,24 +133,29 @@ public static void compute() {
 	}
 
 	public static void prepare() {
+		// 生成前缀和数组，下标从1开始，补充一个前缀长度为0的前缀和
 		for (int i = 1; i <= n; i++) {
 			arr[i] += arr[i - 1];
 		}
-		int len = 0;
-		sorted[++len] = 0;
+		for (int i = n; i >= 0; i--) {
+			arr[i + 1] = arr[i];
+		}
+		n++;
+		// 离散化
 		for (int i = 1; i <= n; i++) {
-			sorted[++len] = arr[i];
+			sorted[i] = arr[i];
 		}
-		Arrays.sort(sorted, 1, len + 1);
+		Arrays.sort(sorted, 1, n + 1);
 		cntv = 1;
-		for (int i = 2; i <= len; i++) {
+		for (int i = 2; i <= n; i++) {
 			if (sorted[cntv] != sorted[i]) {
 				sorted[++cntv] = sorted[i];
 			}
 		}
-		for (int i = 0; i <= n; i++) {
+		for (int i = 1; i <= n; i++) {
 			arr[i] = kth(arr[i]);
 		}
+		// 分块
 		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
@@ -156,6 +164,11 @@ public static void prepare() {
 		for (int i = 1; i <= bnum; i++) {
 			br[i] = Math.min(i * blen, n);
 		}
+		// 原来查询范围 l..r，对应前缀查询范围 l-1..r
+		// 但是前缀和平移了，所以对应的前缀查询范围 l..r+1
+		for (int i = 1; i <= m; i++) {
+			query[i][1]++;
+		}
 		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
diff --git a/src/class177/Code04_ZeroQuery2.java b/src/class177/Code04_ZeroQuery2.java
index 0093e943a..8d2bac2ca 100644
--- a/src/class177/Code04_ZeroQuery2.java
+++ b/src/class177/Code04_ZeroQuery2.java
@@ -14,21 +14,21 @@
 //    int l, r, id;
 //};
 //
-//const int MAXN = 50001;
+//const int MAXN = 50002;
 //const int MAXB = 301;
 //int n, m;
 //int arr[MAXN];
 //Query query[MAXN];
-//int sorted[MAXN + 1];
+//int sorted[MAXN];
 //int cntv;
 //
 //int blen, bnum;
 //int bi[MAXN];
 //int br[MAXB];
 //
-//int forceEd[MAXN + 1];
-//int st[MAXN + 1];
-//int ed[MAXN + 1];
+//int forceEd[MAXN];
+//int st[MAXN];
+//int ed[MAXN];
 //
 //int curAns = 0;
 //int ans[MAXN];
@@ -101,7 +101,7 @@
 //        fill(ed + 1, ed + cntv + 1, 0);
 //        int winl = br[block] + 1, winr = br[block];
 //        for (; qi <= m && bi[query[qi].l] == block; qi++) {
-//            int jobl = query[qi].l - 1;
+//            int jobl = query[qi].l;
 //            int jobr = query[qi].r;
 //            int id = query[qi].id;
 //            if (jobr <= br[block]) {
@@ -128,19 +128,21 @@
 //    for (int i = 1; i <= n; i++) {
 //        arr[i] += arr[i - 1];
 //    }
-//    int len = 0;
-//    sorted[++len] = 0;
+//    for (int i = n; i >= 0; i--) {
+//        arr[i + 1] = arr[i];
+//    }
+//    n++;
 //    for (int i = 1; i <= n; i++) {
-//        sorted[++len] = arr[i];
+//        sorted[i] = arr[i];
 //    }
-//    sort(sorted + 1, sorted + len + 1);
+//    sort(sorted + 1, sorted + n + 1);
 //    cntv = 1;
-//    for (int i = 2; i <= len; i++) {
+//    for (int i = 2; i <= n; i++) {
 //        if (sorted[cntv] != sorted[i]) {
 //            sorted[++cntv] = sorted[i];
 //        }
 //    }
-//    for (int i = 0; i <= n; i++) {
+//    for (int i = 1; i <= n; i++) {
 //        arr[i] = kth(arr[i]);
 //    }
 //    blen = (int)sqrt(n);
@@ -151,6 +153,9 @@
 //    for (int i = 1; i <= bnum; i++) {
 //        br[i] = min(i * blen, n);
 //    }
+//    for (int i = 1; i <= m; i++) {
+//        query[i].r++;
+//    }
 //    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //

From adf6d99a9ca3094c33c8e963cb8332aa514920c6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 15:34:52 +0800
Subject: [PATCH 1327/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java | 2 +-
 src/class177/Code01_MoAddUndo2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index ee15d2a6e..c5876137b 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -3,7 +3,7 @@
 // 只增回滚莫队入门题，java版
 // 给定一个长度为n的数组arr，下面定义重要度的概念
 // 如果一段范围上，数字x出现c次，那么这个数字的重要度为x * c
-// 范围上的最大重要度，就是该范围上，每种数字的重要度取最大值
+// 范围上的最大重要度，就是该范围上，每种数字的重要度，取最大值
 // 一共有m条查询，格式 l r : 打印arr[l..r]范围上的最大重要度
 // 1 <= n、m <= 10^5
 // 1 <= arr[i] <= 10^9
diff --git a/src/class177/Code01_MoAddUndo2.java b/src/class177/Code01_MoAddUndo2.java
index 472170ed2..93c83084f 100644
--- a/src/class177/Code01_MoAddUndo2.java
+++ b/src/class177/Code01_MoAddUndo2.java
@@ -3,7 +3,7 @@
 // 只增回滚莫队入门题，C++版
 // 给定一个长度为n的数组arr，下面定义重要度的概念
 // 如果一段范围上，数字x出现c次，那么这个数字的重要度为x * c
-// 范围上的最大重要度，就是该范围上，每种数字的重要度取最大值
+// 范围上的最大重要度，就是该范围上，每种数字的重要度，取最大值
 // 一共有m条查询，格式 l r : 打印arr[l..r]范围上的最大重要度
 // 1 <= n、m <= 10^5
 // 1 <= arr[i] <= 10^9

From f4ec7aebab06c1c656e342e5a97517330ff4eaf3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 15:44:19 +0800
Subject: [PATCH 1328/1712] modify code

---
 src/class177/Code06_BaldChief1.java | 5 +++++
 src/class177/Code06_BaldChief2.java | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index 858009e31..578482b70 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -1,6 +1,11 @@
 package class177;
 
 // 秃子酋长，java版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : 打印arr[l..r]范围上，如果所有数排序后，
+//            相邻的数在原序列中的位置的差的绝对值之和
+// 注意arr很特殊，1~n这些数字在arr中都只出现1次
+// 1 <= n、m <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P8078
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class177/Code06_BaldChief2.java b/src/class177/Code06_BaldChief2.java
index 5806741e1..6a64e31b1 100644
--- a/src/class177/Code06_BaldChief2.java
+++ b/src/class177/Code06_BaldChief2.java
@@ -1,6 +1,11 @@
 package class177;
 
 // 秃子酋长，C++版
+// 给定一个长度为n的数组arr，一共有m条查询，格式如下
+// 查询 l r : 打印arr[l..r]范围上，如果所有数排序后，
+//            相邻的数在原序列中的位置的差的绝对值之和
+// 注意arr很特殊，1~n这些数字在arr中都只出现1次
+// 1 <= n、m <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P8078
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From af6b6572f85d868a0f3e58c4897d92aa34fba7ad Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 15:51:17 +0800
Subject: [PATCH 1329/1712] modify code

---
 src/class177/Code07_MoOnTree1.java | 5 +++++
 src/class177/Code07_MoOnTree2.java | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index 91f0e4fae..bf54d9477 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -1,6 +1,11 @@
 package class177;
 
 // 树上莫队入门题，java版
+// 一共有n个节点，每个节点给定颜色值，给定n-1条边，所有节点连成一棵树
+// 一共有m条查询，格式 u v : 打印点u到点v的简单路径上，有几种不同的颜色
+// 1 <= n <= 4 * 10^4
+// 1 <= m <= 10^5
+// 1 <= 颜色值 <= 2 * 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP10707
 // 测试链接 : https://www.spoj.com/problems/COT2/
 // 提交以下的code，提交时请把类名改成"Main"
diff --git a/src/class177/Code07_MoOnTree2.java b/src/class177/Code07_MoOnTree2.java
index 9853b4a86..8bdb751d4 100644
--- a/src/class177/Code07_MoOnTree2.java
+++ b/src/class177/Code07_MoOnTree2.java
@@ -1,6 +1,11 @@
 package class177;
 
 // 树上莫队入门题，C++版
+// 一共有n个节点，每个节点给定颜色值，给定n-1条边，所有节点连成一棵树
+// 一共有m条查询，格式 u v : 打印点u到点v的简单路径上，有几种不同的颜色
+// 1 <= n <= 4 * 10^4
+// 1 <= m <= 10^5
+// 1 <= 颜色值 <= 2 * 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/SP10707
 // 测试链接 : https://www.spoj.com/problems/COT2/
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 12443e5a4a385783fdbf1654cb52c8adf5f8820e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 16:53:13 +0800
Subject: [PATCH 1330/1712] modify code

---
 src/class177/Code08_CandyPark1.java | 8 ++++++++
 src/class177/Code08_CandyPark2.java | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/class177/Code08_CandyPark1.java b/src/class177/Code08_CandyPark1.java
index 787c33eec..b694ce432 100644
--- a/src/class177/Code08_CandyPark1.java
+++ b/src/class177/Code08_CandyPark1.java
@@ -1,6 +1,14 @@
 package class177;
 
 // 糖果公园，java版
+// 一共有n个公园，给定n-1条边，所有公园连成一棵树，c[i]为i号公园的糖果型号
+// 一共有m种糖果，v[y]表示y号糖果的美味指数，给定长度为n的数组w，用于计算愉悦值
+// 假设游客当前遇到了y号糖果，并且是第x次遇到，那么愉悦值会增加 v[y] * w[x]
+// 随着游客遇到各种各样的糖果，愉悦值会不断上升，接下来有q条操作，操作类型如下
+// 操作 0 x y : 第x号公园的糖果型号改成y
+// 操作 1 x y : 游客从点x出发走过简单路径到达y，依次遇到每个公园的糖果，打印最终的愉悦值
+// 1 <= n、m、q <= 10^5
+// 1 <= v[i]、w[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P4074
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class177/Code08_CandyPark2.java b/src/class177/Code08_CandyPark2.java
index e15a0e912..9cca3143b 100644
--- a/src/class177/Code08_CandyPark2.java
+++ b/src/class177/Code08_CandyPark2.java
@@ -1,6 +1,14 @@
 package class177;
 
 // 糖果公园，C++版
+// 一共有n个公园，给定n-1条边，所有公园连成一棵树，c[i]为i号公园的糖果型号
+// 一共有m种糖果，v[y]表示y号糖果的美味指数，给定长度为n的数组w，用于计算愉悦值
+// 假设游客当前遇到了y号糖果，并且是第x次遇到，那么愉悦值会增加 v[y] * w[x]
+// 随着游客遇到各种各样的糖果，愉悦值会不断上升，接下来有q条操作，操作类型如下
+// 操作 0 x y : 第x号公园的糖果型号改成y
+// 操作 1 x y : 游客从点x出发走过简单路径到达y，依次遇到每个公园的糖果，打印最终的愉悦值
+// 1 <= n、m、q <= 10^5
+// 1 <= v[i]、w[i] <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P4074
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 1ed9ce8cf11b3beccbc207b9ded875dfaa32d9b5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 17:09:20 +0800
Subject: [PATCH 1331/1712] modify code

---
 src/class177/Code04_ZeroQuery1.java | 12 +++++-------
 src/class177/Code04_ZeroQuery2.java |  9 ++++++---
 2 files changed, 11 insertions(+), 10 deletions(-)

diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index cfed91ea1..7a1539d44 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -141,7 +141,11 @@ public static void prepare() {
 			arr[i + 1] = arr[i];
 		}
 		n++;
-		// 离散化
+		// 原来查询范围 l..r，对应前缀和查询范围 l-1..r
+		// 现在前缀和平移了，所以对应前缀查询范围 l..r+1
+		for (int i = 1; i <= m; i++) {
+			query[i][1]++;
+		}
 		for (int i = 1; i <= n; i++) {
 			sorted[i] = arr[i];
 		}
@@ -155,7 +159,6 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = kth(arr[i]);
 		}
-		// 分块
 		blen = (int) Math.sqrt(n);
 		bnum = (n + blen - 1) / blen;
 		for (int i = 1; i <= n; i++) {
@@ -164,11 +167,6 @@ public static void prepare() {
 		for (int i = 1; i <= bnum; i++) {
 			br[i] = Math.min(i * blen, n);
 		}
-		// 原来查询范围 l..r，对应前缀查询范围 l-1..r
-		// 但是前缀和平移了，所以对应的前缀查询范围 l..r+1
-		for (int i = 1; i <= m; i++) {
-			query[i][1]++;
-		}
 		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
diff --git a/src/class177/Code04_ZeroQuery2.java b/src/class177/Code04_ZeroQuery2.java
index 8d2bac2ca..51c96c0b9 100644
--- a/src/class177/Code04_ZeroQuery2.java
+++ b/src/class177/Code04_ZeroQuery2.java
@@ -1,6 +1,9 @@
 package class177;
 
 // 累加和为0的最长子数组，C++版
+// 给定一个长度为n的数组arr，其中只有1和-1两种值
+// 一共有m条查询，格式 l r : 打印arr[l..r]范围上，累加和为0的最长子数组长度
+// 1 <= n、m <= 5 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/SP20644
 // 测试链接 : https://www.spoj.com/problems/ZQUERY/
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -132,6 +135,9 @@
 //        arr[i + 1] = arr[i];
 //    }
 //    n++;
+//    for (int i = 1; i <= m; i++) {
+//        query[i].r++;
+//    }
 //    for (int i = 1; i <= n; i++) {
 //        sorted[i] = arr[i];
 //    }
@@ -153,9 +159,6 @@
 //    for (int i = 1; i <= bnum; i++) {
 //        br[i] = min(i * blen, n);
 //    }
-//    for (int i = 1; i <= m; i++) {
-//        query[i].r++;
-//    }
 //    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //

From ec2123319ca5b61ad33674d78813a33918ccd0c5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 17:56:08 +0800
Subject: [PATCH 1332/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java         | 4 ++--
 src/class177/Code01_MoAddUndo2.java         | 4 ++--
 src/class177/Code02_ThresholdMajority1.java | 4 ++--
 src/class177/Code02_ThresholdMajority2.java | 4 ++--
 src/class177/Code03_SameNumberMaxDist1.java | 4 ++--
 src/class177/Code03_SameNumberMaxDist2.java | 4 ++--
 src/class177/Code04_ZeroQuery1.java         | 4 ++--
 src/class177/Code04_ZeroQuery2.java         | 4 ++--
 src/class177/Code05_MoDelUndo1.java         | 6 +++---
 src/class177/Code05_MoDelUndo2.java         | 6 +++---
 src/class177/Code06_BaldChief1.java         | 9 +++------
 src/class177/Code06_BaldChief2.java         | 6 +++---
 12 files changed, 28 insertions(+), 31 deletions(-)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index c5876137b..66f0c46ae 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -84,7 +84,7 @@ public static void add(int num) {
 		curAns = Math.max(curAns, (long) cnt[num] * sorted[num]);
 	}
 
-	public static void undo(int num) {
+	public static void del(int num) {
 		cnt[num]--;
 	}
 
@@ -110,7 +110,7 @@ public static void compute() {
 					ans[id] = curAns;
 					curAns = backup;
 					while (winl <= br[block]) {
-						undo(arr[winl++]);
+						del(arr[winl++]);
 					}
 				}
 			}
diff --git a/src/class177/Code01_MoAddUndo2.java b/src/class177/Code01_MoAddUndo2.java
index 93c83084f..0e5df71ef 100644
--- a/src/class177/Code01_MoAddUndo2.java
+++ b/src/class177/Code01_MoAddUndo2.java
@@ -78,7 +78,7 @@
 //    curAns = max(curAns, 1LL * cnt[num] * sorted[num]);
 //}
 //
-//void undo(int num) {
+//void del(int num) {
 //    cnt[num]--;
 //}
 //
@@ -104,7 +104,7 @@
 //                ans[id] = curAns;
 //                curAns = backup;
 //                while (winl <= br[block]) {
-//                    undo(arr[winl++]);
+//                    del(arr[winl++]);
 //                }
 //            }
 //        }
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index dac3415f6..17ba5dc1f 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -90,7 +90,7 @@ public static void add(int num) {
 			}
 		}
 
-		public static void undo(int num) {
+		public static void del(int num) {
 			cnt[num]--;
 		}
 
@@ -124,7 +124,7 @@ public static void compute() {
 						maxCnt = backupCnt;
 						numAns = backupNum;
 						while (winl <= br[block]) {
-							undo(arr[winl++]);
+							del(arr[winl++]);
 						}
 					}
 				}
diff --git a/src/class177/Code02_ThresholdMajority2.java b/src/class177/Code02_ThresholdMajority2.java
index 530a03aee..9b312e834 100644
--- a/src/class177/Code02_ThresholdMajority2.java
+++ b/src/class177/Code02_ThresholdMajority2.java
@@ -86,7 +86,7 @@
 //    }
 //}
 //
-//void undo(int num) {
+//void del(int num) {
 //    cnt[num]--;
 //}
 //
@@ -120,7 +120,7 @@
 //                maxCnt = backupCnt;
 //                numAns = backupNum;
 //                while (winl <= br[block]) {
-//                    undo(arr[winl++]);
+//                    del(arr[winl++]);
 //                }
 //            }
 //        }
diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index 141cbca4e..7d32836bf 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -96,7 +96,7 @@ public static void addLeft(int idx) {
 		}
 	}
 
-	public static void undoLeft(int idx) {
+	public static void delLeft(int idx) {
 		int num = arr[idx];
 		if (ed[num] == idx) {
 			ed[num] = 0;
@@ -126,7 +126,7 @@ public static void compute() {
 					ans[id] = curAns;
 					curAns = backup;
 					while (winl <= br[block]) {
-						undoLeft(winl++);
+						delLeft(winl++);
 					}
 				}
 			}
diff --git a/src/class177/Code03_SameNumberMaxDist2.java b/src/class177/Code03_SameNumberMaxDist2.java
index 26f75d17f..ee9e7e463 100644
--- a/src/class177/Code03_SameNumberMaxDist2.java
+++ b/src/class177/Code03_SameNumberMaxDist2.java
@@ -91,7 +91,7 @@
 //    }
 //}
 //
-//void undoLeft(int idx) {
+//void delLeft(int idx) {
 //    int num = arr[idx];
 //    if (ed[num] == idx) {
 //        ed[num] = 0;
@@ -121,7 +121,7 @@
 //                ans[id] = curAns;
 //                curAns = backup;
 //                while (winl <= br[block]) {
-//                    undoLeft(winl++);
+//                    delLeft(winl++);
 //                }
 //            }
 //        }
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index 7a1539d44..3983075e5 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -95,7 +95,7 @@ public static void addLeft(int idx) {
 		}
 	}
 
-	public static void undoLeft(int idx) {
+	public static void delLeft(int idx) {
 		int num = arr[idx];
 		if (ed[num] == idx) {
 			ed[num] = 0;
@@ -125,7 +125,7 @@ public static void compute() {
 					ans[id] = curAns;
 					curAns = backup;
 					while (winl <= br[block]) {
-						undoLeft(winl++);
+						delLeft(winl++);
 					}
 				}
 			}
diff --git a/src/class177/Code04_ZeroQuery2.java b/src/class177/Code04_ZeroQuery2.java
index 51c96c0b9..a420ad38d 100644
--- a/src/class177/Code04_ZeroQuery2.java
+++ b/src/class177/Code04_ZeroQuery2.java
@@ -90,7 +90,7 @@
 //    }
 //}
 //
-//void undoLeft(int idx) {
+//void delLeft(int idx) {
 //    int num = arr[idx];
 //    if (ed[num] == idx) {
 //        ed[num] = 0;
@@ -120,7 +120,7 @@
 //                ans[id] = curAns;
 //                curAns = backup;
 //                while (winl <= br[block]) {
-//                    undoLeft(winl++);
+//                    delLeft(winl++);
 //                }
 //            }
 //        }
diff --git a/src/class177/Code05_MoDelUndo1.java b/src/class177/Code05_MoDelUndo1.java
index 6c986cb88..c3b48c47c 100644
--- a/src/class177/Code05_MoDelUndo1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -60,7 +60,7 @@ public static void del(int num) {
 		}
 	}
 
-	public static void undo(int num) {
+	public static void add(int num) {
 		cnt[num]++;
 	}
 
@@ -86,11 +86,11 @@ public static void compute() {
 				ans[id] = mex;
 				mex = backup;
 				while (winl > bl[block]) {
-					undo(arr[--winl]);
+					add(arr[--winl]);
 				}
 			}
 			while (winr < n) {
-				undo(arr[++winr]);
+				add(arr[++winr]);
 			}
 			mex = beforeJob;
 		}
diff --git a/src/class177/Code05_MoDelUndo2.java b/src/class177/Code05_MoDelUndo2.java
index 891d452ac..abaa604a8 100644
--- a/src/class177/Code05_MoDelUndo2.java
+++ b/src/class177/Code05_MoDelUndo2.java
@@ -54,7 +54,7 @@
 //    }
 //}
 //
-//void undo(int num) {
+//void add(int num) {
 //    cnt[num]++;
 //}
 //
@@ -80,11 +80,11 @@
 //            ans[id] = mex;
 //            mex = backup;
 //            while (winl > bl[block]) {
-//                undo(arr[--winl]);
+//                add(arr[--winl]);
 //            }
 //        }
 //        while (winr < n) {
-//            undo(arr[++winr]);
+//            add(arr[++winr]);
 //        }
 //        mex = beforeJob;
 //    }
diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index 578482b70..b522f054e 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -60,7 +60,6 @@ public static void init() {
 		}
 	}
 
-	// 删除num
 	public static void del(int num) {
 		int less = last[num], more = next[num];
 		if (less != 0) {
@@ -76,9 +75,7 @@ public static void del(int num) {
 		last[more] = less;
 	}
 
-	// 加入num，必须保证num上一次删除的数字
-	// 也就是说，undo的调用必须是del操作的回滚
-	public static void undo(int num) {
+	public static void add(int num) {
 		next[last[num]] = num;
 		last[next[num]] = num;
 	}
@@ -105,11 +102,11 @@ public static void compute() {
 				ans[id] = sum;
 				sum = backup;
 				while (winl > bl[block]) {
-					undo(arr[--winl]);
+					add(arr[--winl]);
 				}
 			}
 			while (winr < n) {
-				undo(arr[++winr]);
+				add(arr[++winr]);
 			}
 			sum = beforeJob;
 		}
diff --git a/src/class177/Code06_BaldChief2.java b/src/class177/Code06_BaldChief2.java
index 6a64e31b1..1e02e390f 100644
--- a/src/class177/Code06_BaldChief2.java
+++ b/src/class177/Code06_BaldChief2.java
@@ -67,7 +67,7 @@
 //    lst[more] = less;
 //}
 //
-//inline void undo(int num) {
+//inline void add(int num) {
 //    nxt[lst[num]] = num;
 //    lst[nxt[num]] = num;
 //}
@@ -109,11 +109,11 @@
 //            ans[id] = sum;
 //            sum = backup;
 //            while (winl > bl[block]) {
-//                undo(arr[--winl]);
+//                add(arr[--winl]);
 //            }
 //        }
 //        while (winr < n) {
-//            undo(arr[++winr]);
+//            add(arr[++winr]);
 //        }
 //        sum = beforeJob;
 //    }

From 534fbbed574c4a8d0103b59662eb9d4fd41c866d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 29 Aug 2025 22:07:58 +0800
Subject: [PATCH 1333/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index 66f0c46ae..fec170f88 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -29,13 +29,19 @@ public class Code01_MoAddUndo1 {
 	public static int cntv;
 
 	public static int blen, bnum;
+	// 查询块号
 	public static int[] bi = new int[MAXN];
+	// 查询每块的右边界
 	public static int[] br = new int[MAXB];
 
+	// 每组暴力遍历的任务，需要的词频表为forceCnt
 	public static int[] forceCnt = new int[MAXN];
+	// 每组滑窗回滚的任务，需要的词频表为cnt
 	public static int[] cnt = new int[MAXN];
 
+	// 当前窗口的最大重要度
 	public static long curAns = 0;
+	// 收集所有答案
 	public static long[] ans = new long[MAXN];
 
 	// 只增回滚莫队经典排序

From d9592adf8e45c64390661175ce44c234a2504177 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 30 Aug 2025 11:08:04 +0800
Subject: [PATCH 1334/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java         |  2 +-
 src/class177/Code01_MoAddUndo2.java         |  2 +-
 src/class177/Code02_ThresholdMajority1.java | 16 ++++++++--------
 src/class177/Code02_ThresholdMajority2.java |  2 +-
 4 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index fec170f88..6518f0bfa 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -38,9 +38,9 @@ public class Code01_MoAddUndo1 {
 	public static int[] forceCnt = new int[MAXN];
 	// 每组滑窗回滚的任务，需要的词频表为cnt
 	public static int[] cnt = new int[MAXN];
-
 	// 当前窗口的最大重要度
 	public static long curAns = 0;
+
 	// 收集所有答案
 	public static long[] ans = new long[MAXN];
 
diff --git a/src/class177/Code01_MoAddUndo2.java b/src/class177/Code01_MoAddUndo2.java
index 0e5df71ef..f0beb584b 100644
--- a/src/class177/Code01_MoAddUndo2.java
+++ b/src/class177/Code01_MoAddUndo2.java
@@ -34,8 +34,8 @@
 //
 //int forceCnt[MAXN];
 //int cnt[MAXN];
-//
 //long long curAns = 0;
+//
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index 17ba5dc1f..fd5711aef 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -32,9 +32,9 @@ class Solution {
 
 		public static int[] forceCnt = new int[MAXN];
 		public static int[] cnt = new int[MAXN];
-
 		public static int maxCnt;
-		public static int numAns;
+		public static int minMode;
+
 		public static int[] ans = new int[MAXM];
 
 		public static class QueryCmp implements Comparator<int[]> {
@@ -84,9 +84,9 @@ public static int force(int l, int r, int k) {
 
 		public static void add(int num) {
 			cnt[num]++;
-			if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < numAns)) {
+			if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < minMode)) {
 				maxCnt = cnt[num];
-				numAns = num;
+				minMode = num;
 			}
 		}
 
@@ -97,7 +97,7 @@ public static void del(int num) {
 		public static void compute() {
 			for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 				maxCnt = 0;
-				numAns = 0;
+				minMode = 0;
 				Arrays.fill(cnt, 1, cntv + 1, 0);
 				int winl = br[block] + 1, winr = br[block];
 				for (; qi <= m && bi[query[qi][0]] == block; qi++) {
@@ -112,17 +112,17 @@ public static void compute() {
 							add(arr[++winr]);
 						}
 						int backupCnt = maxCnt;
-						int backupNum = numAns;
+						int backupNum = minMode;
 						while (winl > jobl) {
 							add(arr[--winl]);
 						}
 						if (maxCnt >= jobk) {
-							ans[id] = sorted[numAns];
+							ans[id] = sorted[minMode];
 						} else {
 							ans[id] = -1;
 						}
 						maxCnt = backupCnt;
-						numAns = backupNum;
+						minMode = backupNum;
 						while (winl <= br[block]) {
 							del(arr[winl++]);
 						}
diff --git a/src/class177/Code02_ThresholdMajority2.java b/src/class177/Code02_ThresholdMajority2.java
index 9b312e834..6f9600fec 100644
--- a/src/class177/Code02_ThresholdMajority2.java
+++ b/src/class177/Code02_ThresholdMajority2.java
@@ -34,9 +34,9 @@
 //
 //int forceCnt[MAXN];
 //int cnt[MAXN];
-//
 //int maxCnt;
 //int numAns;
+//
 //int ans[MAXM];
 //
 //bool QueryCmp(Query &a, Query &b) {

From 11ce78dc2d80ed8a0083dcb97ae6c14bb6cc6071 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 30 Aug 2025 17:05:15 +0800
Subject: [PATCH 1335/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java         | 10 ++---
 src/class177/Code01_MoAddUndo2.java         |  7 ++--
 src/class177/Code02_ThresholdMajority1.java |  9 ++---
 src/class177/Code02_ThresholdMajority2.java | 23 +++++------
 src/class177/Code03_SameNumberMaxDist1.java | 45 ++++++++++-----------
 src/class177/Code03_SameNumberMaxDist2.java | 45 ++++++++++-----------
 6 files changed, 66 insertions(+), 73 deletions(-)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index 6518f0bfa..6f273d736 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -34,9 +34,7 @@ public class Code01_MoAddUndo1 {
 	// 查询每块的右边界
 	public static int[] br = new int[MAXB];
 
-	// 每组暴力遍历的任务，需要的词频表为forceCnt
-	public static int[] forceCnt = new int[MAXN];
-	// 每组滑窗回滚的任务，需要的词频表为cnt
+	// 词频表
 	public static int[] cnt = new int[MAXN];
 	// 当前窗口的最大重要度
 	public static long curAns = 0;
@@ -74,13 +72,13 @@ public static int kth(int num) {
 	public static long force(int l, int r) {
 		long ret = 0;
 		for (int i = l; i <= r; i++) {
-			forceCnt[arr[i]]++;
+			cnt[arr[i]]++;
 		}
 		for (int i = l; i <= r; i++) {
-			ret = Math.max(ret, (long) forceCnt[arr[i]] * sorted[arr[i]]);
+			ret = Math.max(ret, (long) cnt[arr[i]] * sorted[arr[i]]);
 		}
 		for (int i = l; i <= r; i++) {
-			forceCnt[arr[i]]--;
+			cnt[arr[i]]--;
 		}
 		return ret;
 	}
diff --git a/src/class177/Code01_MoAddUndo2.java b/src/class177/Code01_MoAddUndo2.java
index f0beb584b..fae0b8c91 100644
--- a/src/class177/Code01_MoAddUndo2.java
+++ b/src/class177/Code01_MoAddUndo2.java
@@ -32,7 +32,6 @@
 //int bi[MAXN];
 //int br[MAXB];
 //
-//int forceCnt[MAXN];
 //int cnt[MAXN];
 //long long curAns = 0;
 //
@@ -62,13 +61,13 @@
 //long long force(int l, int r) {
 //    long long ret = 0;
 //    for (int i = l; i <= r; i++) {
-//        forceCnt[arr[i]]++;
+//        cnt[arr[i]]++;
 //    }
 //    for (int i = l; i <= r; i++) {
-//        ret = max(ret, 1LL * forceCnt[arr[i]] * sorted[arr[i]]);
+//        ret = max(ret, 1LL * cnt[arr[i]] * sorted[arr[i]]);
 //    }
 //    for (int i = l; i <= r; i++) {
-//        forceCnt[arr[i]]--;
+//        cnt[arr[i]]--;
 //    }
 //    return ret;
 //}
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index fd5711aef..e6d3a1bd9 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -30,7 +30,6 @@ class Solution {
 		public static int[] bi = new int[MAXN];
 		public static int[] br = new int[MAXB];
 
-		public static int[] forceCnt = new int[MAXN];
 		public static int[] cnt = new int[MAXN];
 		public static int maxCnt;
 		public static int minMode;
@@ -67,17 +66,17 @@ public static int force(int l, int r, int k) {
 			int mx = 0;
 			int who = 0;
 			for (int i = l; i <= r; i++) {
-				forceCnt[arr[i]]++;
+				cnt[arr[i]]++;
 			}
 			for (int i = l; i <= r; i++) {
 				int num = arr[i];
-				if (forceCnt[num] > mx || (forceCnt[num] == mx && num < who)) {
-					mx = forceCnt[num];
+				if (cnt[num] > mx || (cnt[num] == mx && num < who)) {
+					mx = cnt[num];
 					who = num;
 				}
 			}
 			for (int i = l; i <= r; i++) {
-				forceCnt[arr[i]]--;
+				cnt[arr[i]]--;
 			}
 			return mx >= k ? sorted[who] : -1;
 		}
diff --git a/src/class177/Code02_ThresholdMajority2.java b/src/class177/Code02_ThresholdMajority2.java
index 6f9600fec..f92d837ca 100644
--- a/src/class177/Code02_ThresholdMajority2.java
+++ b/src/class177/Code02_ThresholdMajority2.java
@@ -32,10 +32,9 @@
 //int bi[MAXN];
 //int br[MAXB];
 //
-//int forceCnt[MAXN];
 //int cnt[MAXN];
 //int maxCnt;
-//int numAns;
+//int minMode;
 //
 //int ans[MAXM];
 //
@@ -63,26 +62,26 @@
 //int force(int l, int r, int k) {
 //    int mx = 0, who = 0;
 //    for (int i = l; i <= r; i++) {
-//        forceCnt[arr[i]]++;
+//        cnt[arr[i]]++;
 //    }
 //    for (int i = l; i <= r; i++) {
 //        int num = arr[i];
-//        if (forceCnt[num] > mx || (forceCnt[num] == mx && num < who)) {
-//            mx = forceCnt[num];
+//        if (cnt[num] > mx || (cnt[num] == mx && num < who)) {
+//            mx = cnt[num];
 //            who = num;
 //        }
 //    }
 //    for (int i = l; i <= r; i++) {
-//        forceCnt[arr[i]]--;
+//        cnt[arr[i]]--;
 //    }
 //    return mx >= k ? sorted[who] : -1;
 //}
 //
 //void add(int num) {
 //    cnt[num]++;
-//    if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < numAns)) {
+//    if (cnt[num] > maxCnt || (cnt[num] == maxCnt && num < minMode)) {
 //        maxCnt = cnt[num];
-//        numAns = num;
+//        minMode = num;
 //    }
 //}
 //
@@ -93,7 +92,7 @@
 //void compute() {
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 //        maxCnt = 0;
-//        numAns = 0;
+//        minMode = 0;
 //        fill(cnt + 1, cnt + cntv + 1, 0);
 //        int winl = br[block] + 1, winr = br[block];
 //        for (; qi <= m && bi[query[qi].l] == block; qi++) {
@@ -108,17 +107,17 @@
 //                    add(arr[++winr]);
 //                }
 //                int backupCnt = maxCnt;
-//                int backupNum = numAns;
+//                int backupNum = minMode;
 //                while (winl > jobl) {
 //                    add(arr[--winl]);
 //                }
 //                if (maxCnt >= jobk) {
-//                    ans[id] = sorted[numAns];
+//                    ans[id] = sorted[minMode];
 //                } else {
 //                	ans[id] = -1;
 //                }
 //                maxCnt = backupCnt;
-//                numAns = backupNum;
+//                minMode = backupNum;
 //                while (winl <= br[block]) {
 //                    del(arr[winl++]);
 //                }
diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index 7d32836bf..b0ca212ce 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -30,11 +30,10 @@ public class Code03_SameNumberMaxDist1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	public static int[] forceEd = new int[MAXN];
-	public static int[] st = new int[MAXN];
-	public static int[] ed = new int[MAXN];
+	public static int[] first = new int[MAXN];
+	public static int[] mostRight = new int[MAXN];
+	public static int maxDist;
 
-	public static int curAns = 0;
 	public static int[] ans = new int[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
@@ -66,48 +65,48 @@ public static int kth(int num) {
 	public static int force(int l, int r) {
 		int ret = 0;
 		for (int i = l; i <= r; i++) {
-			if (forceEd[arr[i]] == 0) {
-				forceEd[arr[i]] = i;
+			if (first[arr[i]] == 0) {
+				first[arr[i]] = i;
 			} else {
-				ret = Math.max(ret, i - forceEd[arr[i]]);
+				ret = Math.max(ret, i - first[arr[i]]);
 			}
 		}
 		for (int i = l; i <= r; i++) {
-			forceEd[arr[i]] = 0;
+			first[arr[i]] = 0;
 		}
 		return ret;
 	}
 
 	public static void addRight(int idx) {
 		int num = arr[idx];
-		ed[num] = idx;
-		if (st[num] == 0) {
-			st[num] = idx;
+		mostRight[num] = idx;
+		if (first[num] == 0) {
+			first[num] = idx;
 		}
-		curAns = Math.max(curAns, idx - st[num]);
+		maxDist = Math.max(maxDist, idx - first[num]);
 	}
 
 	public static void addLeft(int idx) {
 		int num = arr[idx];
-		if (ed[num] != 0) {
-			curAns = Math.max(curAns, ed[num] - idx);
+		if (mostRight[num] != 0) {
+			maxDist = Math.max(maxDist, mostRight[num] - idx);
 		} else {
-			ed[num] = idx;
+			mostRight[num] = idx;
 		}
 	}
 
 	public static void delLeft(int idx) {
 		int num = arr[idx];
-		if (ed[num] == idx) {
-			ed[num] = 0;
+		if (mostRight[num] == idx) {
+			mostRight[num] = 0;
 		}
 	}
 
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-			curAns = 0;
-			Arrays.fill(st, 1, cntv + 1, 0);
-			Arrays.fill(ed, 1, cntv + 1, 0);
+			maxDist = 0;
+			Arrays.fill(first, 1, cntv + 1, 0);
+			Arrays.fill(mostRight, 1, cntv + 1, 0);
 			int winl = br[block] + 1, winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
@@ -119,12 +118,12 @@ public static void compute() {
 					while (winr < jobr) {
 						addRight(++winr);
 					}
-					int backup = curAns;
+					int backup = maxDist;
 					while (winl > jobl) {
 						addLeft(--winl);
 					}
-					ans[id] = curAns;
-					curAns = backup;
+					ans[id] = maxDist;
+					maxDist = backup;
 					while (winl <= br[block]) {
 						delLeft(winl++);
 					}
diff --git a/src/class177/Code03_SameNumberMaxDist2.java b/src/class177/Code03_SameNumberMaxDist2.java
index ee9e7e463..9e1cc213c 100644
--- a/src/class177/Code03_SameNumberMaxDist2.java
+++ b/src/class177/Code03_SameNumberMaxDist2.java
@@ -30,11 +30,10 @@
 //int bi[MAXN];
 //int br[MAXB];
 //
-//int forceEd[MAXN];
-//int st[MAXN];
-//int ed[MAXN];
+//int first[MAXN];
+//int mostRight[MAXN];
+//int maxDist;
 //
-//int curAns = 0;
 //int ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -61,48 +60,48 @@
 //int force(int l, int r) {
 //    int ret = 0;
 //    for (int i = l; i <= r; i++) {
-//        if (forceEd[arr[i]] == 0) {
-//            forceEd[arr[i]] = i;
+//        if (first[arr[i]] == 0) {
+//            first[arr[i]] = i;
 //        } else {
-//            ret = max(ret, i - forceEd[arr[i]]);
+//            ret = max(ret, i - first[arr[i]]);
 //        }
 //    }
 //    for (int i = l; i <= r; i++) {
-//        forceEd[arr[i]] = 0;
+//        first[arr[i]] = 0;
 //    }
 //    return ret;
 //}
 //
 //void addRight(int idx) {
 //    int num = arr[idx];
-//    ed[num] = idx;
-//    if (st[num] == 0) {
-//        st[num] = idx;
+//    mostRight[num] = idx;
+//    if (first[num] == 0) {
+//        first[num] = idx;
 //    }
-//    curAns = max(curAns, idx - st[num]);
+//    maxDist = max(maxDist, idx - first[num]);
 //}
 //
 //void addLeft(int idx) {
 //    int num = arr[idx];
-//    if (ed[num] != 0) {
-//        curAns = max(curAns, ed[num] - idx);
+//    if (mostRight[num] != 0) {
+//        maxDist = max(maxDist, mostRight[num] - idx);
 //    } else {
-//        ed[num] = idx;
+//        mostRight[num] = idx;
 //    }
 //}
 //
 //void delLeft(int idx) {
 //    int num = arr[idx];
-//    if (ed[num] == idx) {
-//        ed[num] = 0;
+//    if (mostRight[num] == idx) {
+//        mostRight[num] = 0;
 //    }
 //}
 //
 //void compute() {
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-//        curAns = 0;
-//        fill(st + 1, st + cntv + 1, 0);
-//        fill(ed + 1, ed + cntv + 1, 0);
+//        maxDist = 0;
+//        fill(first + 1, first + cntv + 1, 0);
+//        fill(mostRight + 1, mostRight + cntv + 1, 0);
 //        int winl = br[block] + 1, winr = br[block];
 //        for (; qi <= m && bi[query[qi].l] == block; qi++) {
 //            int jobl = query[qi].l;
@@ -114,12 +113,12 @@
 //                while (winr < jobr) {
 //                    addRight(++winr);
 //                }
-//                int backup = curAns;
+//                int backup = maxDist;
 //                while (winl > jobl) {
 //                    addLeft(--winl);
 //                }
-//                ans[id] = curAns;
-//                curAns = backup;
+//                ans[id] = maxDist;
+//                maxDist = backup;
 //                while (winl <= br[block]) {
 //                    delLeft(winl++);
 //                }

From eed77e62a1f1e21f6227549bdb39f7e0fda25915 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 30 Aug 2025 17:14:17 +0800
Subject: [PATCH 1336/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist1.java |  3 ++
 src/class177/Code04_ZeroQuery1.java         | 45 ++++++++++----------
 src/class177/Code04_ZeroQuery2.java         | 47 ++++++++++-----------
 3 files changed, 48 insertions(+), 47 deletions(-)

diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index b0ca212ce..a81cbdb9b 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -30,8 +30,11 @@ public class Code03_SameNumberMaxDist1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
+	// first[x] = i，不考虑窗口左扩的情况下，数字x首次出现在i位置
 	public static int[] first = new int[MAXN];
+	// mostRight[x] = i，窗口中数字x最右出现在i位置
 	public static int[] mostRight = new int[MAXN];
+	// 答案信息，相同的数的最远间隔距离
 	public static int maxDist;
 
 	public static int[] ans = new int[MAXN];
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index 3983075e5..566bf8370 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -29,11 +29,10 @@ public class Code04_ZeroQuery1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	public static int[] forceEd = new int[MAXN];
-	public static int[] st = new int[MAXN];
-	public static int[] ed = new int[MAXN];
+	public static int[] first = new int[MAXN];
+	public static int[] mostRight = new int[MAXN];
+	public static int maxDist;
 
-	public static int curAns = 0;
 	public static int[] ans = new int[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
@@ -65,48 +64,48 @@ public static int kth(int num) {
 	public static int force(int l, int r) {
 		int ret = 0;
 		for (int i = l; i <= r; i++) {
-			if (forceEd[arr[i]] == 0) {
-				forceEd[arr[i]] = i;
+			if (first[arr[i]] == 0) {
+				first[arr[i]] = i;
 			} else {
-				ret = Math.max(ret, i - forceEd[arr[i]]);
+				ret = Math.max(ret, i - first[arr[i]]);
 			}
 		}
 		for (int i = l; i <= r; i++) {
-			forceEd[arr[i]] = 0;
+			first[arr[i]] = 0;
 		}
 		return ret;
 	}
 
 	public static void addRight(int idx) {
 		int num = arr[idx];
-		ed[num] = idx;
-		if (st[num] == 0) {
-			st[num] = idx;
+		mostRight[num] = idx;
+		if (first[num] == 0) {
+			first[num] = idx;
 		}
-		curAns = Math.max(curAns, idx - st[num]);
+		maxDist = Math.max(maxDist, idx - first[num]);
 	}
 
 	public static void addLeft(int idx) {
 		int num = arr[idx];
-		if (ed[num] != 0) {
-			curAns = Math.max(curAns, ed[num] - idx);
+		if (mostRight[num] != 0) {
+			maxDist = Math.max(maxDist, mostRight[num] - idx);
 		} else {
-			ed[num] = idx;
+			mostRight[num] = idx;
 		}
 	}
 
 	public static void delLeft(int idx) {
 		int num = arr[idx];
-		if (ed[num] == idx) {
-			ed[num] = 0;
+		if (mostRight[num] == idx) {
+			mostRight[num] = 0;
 		}
 	}
 
 	public static void compute() {
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-			curAns = 0;
-			Arrays.fill(st, 1, cntv + 1, 0);
-			Arrays.fill(ed, 1, cntv + 1, 0);
+			maxDist = 0;
+			Arrays.fill(first, 1, cntv + 1, 0);
+			Arrays.fill(mostRight, 1, cntv + 1, 0);
 			int winl = br[block] + 1, winr = br[block];
 			for (; qi <= m && bi[query[qi][0]] == block; qi++) {
 				int jobl = query[qi][0];
@@ -118,12 +117,12 @@ public static void compute() {
 					while (winr < jobr) {
 						addRight(++winr);
 					}
-					int backup = curAns;
+					int backup = maxDist;
 					while (winl > jobl) {
 						addLeft(--winl);
 					}
-					ans[id] = curAns;
-					curAns = backup;
+					ans[id] = maxDist;
+					maxDist = backup;
 					while (winl <= br[block]) {
 						delLeft(winl++);
 					}
diff --git a/src/class177/Code04_ZeroQuery2.java b/src/class177/Code04_ZeroQuery2.java
index a420ad38d..ff66b7f60 100644
--- a/src/class177/Code04_ZeroQuery2.java
+++ b/src/class177/Code04_ZeroQuery2.java
@@ -29,11 +29,10 @@
 //int bi[MAXN];
 //int br[MAXB];
 //
-//int forceEd[MAXN];
-//int st[MAXN];
-//int ed[MAXN];
-//
-//int curAns = 0;
+//int first[MAXN];
+//int mostRight[MAXN];
+//int maxDist;
+// 
 //int ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -60,48 +59,48 @@
 //int force(int l, int r) {
 //    int ret = 0;
 //    for (int i = l; i <= r; i++) {
-//        if (forceEd[arr[i]] == 0) {
-//            forceEd[arr[i]] = i;
+//        if (first[arr[i]] == 0) {
+//            first[arr[i]] = i;
 //        } else {
-//            ret = max(ret, i - forceEd[arr[i]]);
+//            ret = max(ret, i - first[arr[i]]);
 //        }
 //    }
 //    for (int i = l; i <= r; i++) {
-//        forceEd[arr[i]] = 0;
+//        first[arr[i]] = 0;
 //    }
 //    return ret;
 //}
 //
 //void addRight(int idx) {
 //    int num = arr[idx];
-//    ed[num] = idx;
-//    if (st[num] == 0) {
-//        st[num] = idx;
+//    mostRight[num] = idx;
+//    if (first[num] == 0) {
+//        first[num] = idx;
 //    }
-//    curAns = max(curAns, idx - st[num]);
+//    maxDist = max(maxDist, idx - first[num]);
 //}
 //
 //void addLeft(int idx) {
 //    int num = arr[idx];
-//    if (ed[num] != 0) {
-//        curAns = max(curAns, ed[num] - idx);
+//    if (mostRight[num] != 0) {
+//        maxDist = max(maxDist, mostRight[num] - idx);
 //    } else {
-//        ed[num] = idx;
+//        mostRight[num] = idx;
 //    }
 //}
 //
 //void delLeft(int idx) {
 //    int num = arr[idx];
-//    if (ed[num] == idx) {
-//        ed[num] = 0;
+//    if (mostRight[num] == idx) {
+//        mostRight[num] = 0;
 //    }
 //}
 //
 //void compute() {
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
-//        curAns = 0;
-//        fill(st + 1, st + cntv + 1, 0);
-//        fill(ed + 1, ed + cntv + 1, 0);
+//        maxDist = 0;
+//        fill(first + 1, first + cntv + 1, 0);
+//        fill(mostRight + 1, mostRight + cntv + 1, 0);
 //        int winl = br[block] + 1, winr = br[block];
 //        for (; qi <= m && bi[query[qi].l] == block; qi++) {
 //            int jobl = query[qi].l;
@@ -113,12 +112,12 @@
 //                while (winr < jobr) {
 //                    addRight(++winr);
 //                }
-//                int backup = curAns;
+//                int backup = maxDist;
 //                while (winl > jobl) {
 //                    addLeft(--winl);
 //                }
-//                ans[id] = curAns;
-//                curAns = backup;
+//                ans[id] = maxDist;
+//                maxDist = backup;
 //                while (winl <= br[block]) {
 //                    delLeft(winl++);
 //                }

From b10e7da1639847ef0a80b70b60b2645d75350a4d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 30 Aug 2025 17:15:51 +0800
Subject: [PATCH 1337/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java | 2 --
 1 file changed, 2 deletions(-)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index 6f273d736..fc9067301 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -29,9 +29,7 @@ public class Code01_MoAddUndo1 {
 	public static int cntv;
 
 	public static int blen, bnum;
-	// 查询块号
 	public static int[] bi = new int[MAXN];
-	// 查询每块的右边界
 	public static int[] br = new int[MAXB];
 
 	// 词频表

From 7a320f60dcb9e64283a120941bb8d83e3dd9c2f8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 30 Aug 2025 17:17:16 +0800
Subject: [PATCH 1338/1712] modify code

---
 src/class177/Code01_MoAddUndo1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index fc9067301..30bdb5a71 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -67,6 +67,7 @@ public static int kth(int num) {
 		return ret;
 	}
 
+	// 暴力遍历arr[l..r]得到答案
 	public static long force(int l, int r) {
 		long ret = 0;
 		for (int i = l; i <= r; i++) {
@@ -81,11 +82,13 @@ public static long force(int l, int r) {
 		return ret;
 	}
 
+	// 窗口增加num，词频和答案都更新
 	public static void add(int num) {
 		cnt[num]++;
 		curAns = Math.max(curAns, (long) cnt[num] * sorted[num]);
 	}
 
+	// 窗口减少num，词频更新、答案不更新
 	public static void del(int num) {
 		cnt[num]--;
 	}

From 4a77aab63ebcd283469745f41eea912b9aa8b517 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 31 Aug 2025 11:50:24 +0800
Subject: [PATCH 1339/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist1.java | 8 ++++----
 src/class177/Code03_SameNumberMaxDist2.java | 6 +++---
 src/class177/Code04_ZeroQuery1.java         | 6 +++---
 src/class177/Code04_ZeroQuery2.java         | 6 +++---
 4 files changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index a81cbdb9b..ab1a61960 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -30,7 +30,7 @@ public class Code03_SameNumberMaxDist1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	// first[x] = i，不考虑窗口左扩的情况下，数字x首次出现在i位置
+	// first[x] = i，只考虑右扩的情况下，数字x首次出现在i位置
 	public static int[] first = new int[MAXN];
 	// mostRight[x] = i，窗口中数字x最右出现在i位置
 	public static int[] mostRight = new int[MAXN];
@@ -91,10 +91,10 @@ public static void addRight(int idx) {
 
 	public static void addLeft(int idx) {
 		int num = arr[idx];
-		if (mostRight[num] != 0) {
-			maxDist = Math.max(maxDist, mostRight[num] - idx);
-		} else {
+		if (mostRight[num] == 0) {
 			mostRight[num] = idx;
+		} else {
+			maxDist = Math.max(maxDist, mostRight[num] - idx);
 		}
 	}
 
diff --git a/src/class177/Code03_SameNumberMaxDist2.java b/src/class177/Code03_SameNumberMaxDist2.java
index 9e1cc213c..42c91be11 100644
--- a/src/class177/Code03_SameNumberMaxDist2.java
+++ b/src/class177/Code03_SameNumberMaxDist2.java
@@ -83,10 +83,10 @@
 //
 //void addLeft(int idx) {
 //    int num = arr[idx];
-//    if (mostRight[num] != 0) {
-//        maxDist = max(maxDist, mostRight[num] - idx);
-//    } else {
+//    if (mostRight[num] == 0) {
 //        mostRight[num] = idx;
+//    } else {
+//        maxDist = max(maxDist, mostRight[num] - idx);
 //    }
 //}
 //
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index 566bf8370..88c31b2f8 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -87,10 +87,10 @@ public static void addRight(int idx) {
 
 	public static void addLeft(int idx) {
 		int num = arr[idx];
-		if (mostRight[num] != 0) {
-			maxDist = Math.max(maxDist, mostRight[num] - idx);
-		} else {
+		if (mostRight[num] == 0) {
 			mostRight[num] = idx;
+		} else {
+			maxDist = Math.max(maxDist, mostRight[num] - idx);
 		}
 	}
 
diff --git a/src/class177/Code04_ZeroQuery2.java b/src/class177/Code04_ZeroQuery2.java
index ff66b7f60..a0c36399e 100644
--- a/src/class177/Code04_ZeroQuery2.java
+++ b/src/class177/Code04_ZeroQuery2.java
@@ -82,10 +82,10 @@
 //
 //void addLeft(int idx) {
 //    int num = arr[idx];
-//    if (mostRight[num] != 0) {
-//        maxDist = max(maxDist, mostRight[num] - idx);
-//    } else {
+//    if (mostRight[num] == 0) {
 //        mostRight[num] = idx;
+//    } else {
+//        maxDist = max(maxDist, mostRight[num] - idx);
 //    }
 //}
 //

From e9ab4dac029fe5a7b37758f4f696df68c2e02f7c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 31 Aug 2025 11:51:21 +0800
Subject: [PATCH 1340/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index ab1a61960..65529fe6d 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -30,9 +30,9 @@ public class Code03_SameNumberMaxDist1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	// first[x] = i，只考虑右扩的情况下，数字x首次出现在i位置
+	// first[x]表示只考虑右扩的情况下，数字x首次出现的位置
 	public static int[] first = new int[MAXN];
-	// mostRight[x] = i，窗口中数字x最右出现在i位置
+	// mostRight[x]表示窗口中数字x最右出现的位置
 	public static int[] mostRight = new int[MAXN];
 	// 答案信息，相同的数的最远间隔距离
 	public static int maxDist;

From ca80ad55f239a3a3a9f3ea7a336a417db579d4fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 31 Aug 2025 15:39:46 +0800
Subject: [PATCH 1341/1712] modify code

---
 src/class177/Code03_SameNumberMaxDist1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index 65529fe6d..a28a9afbb 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -30,7 +30,7 @@ public class Code03_SameNumberMaxDist1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
-	// first[x]表示只考虑右扩的情况下，数字x首次出现的位置
+	// first[x]表示只考虑窗口右扩阶段，数字x首次出现的位置
 	public static int[] first = new int[MAXN];
 	// mostRight[x]表示窗口中数字x最右出现的位置
 	public static int[] mostRight = new int[MAXN];

From b36053efc38650b5829d6185cbf88086eb663f01 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 31 Aug 2025 16:46:31 +0800
Subject: [PATCH 1342/1712] modify code

---
 src/class177/Code06_BaldChief1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index b522f054e..fbedf2bc5 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -75,6 +75,7 @@ public static void del(int num) {
 		last[more] = less;
 	}
 
+	// 加数字的顺序，就是删数字的顺序的回滚，才能这么方便的更新
 	public static void add(int num) {
 		next[last[num]] = num;
 		last[next[num]] = num;

From 1c0b06e73a5b77b3a75cb41a565f185f6a72763e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 31 Aug 2025 16:50:11 +0800
Subject: [PATCH 1343/1712] modify code

---
 src/class177/Code05_MoDelUndo1.java | 18 +++++++-----------
 src/class177/Code05_MoDelUndo2.java | 18 +++++++-----------
 src/class177/Code06_BaldChief1.java | 22 +++++++++-------------
 src/class177/Code06_BaldChief2.java | 22 +++++++++-------------
 4 files changed, 32 insertions(+), 48 deletions(-)

diff --git a/src/class177/Code05_MoDelUndo1.java b/src/class177/Code05_MoDelUndo1.java
index c3b48c47c..61dfac117 100644
--- a/src/class177/Code05_MoDelUndo1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -44,16 +44,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static void init() {
-		for (int i = 1; i <= n; i++) {
-			cnt[arr[i]]++;
-		}
-		mex = 0;
-		while (cnt[mex] != 0) {
-			mex++;
-		}
-	}
-
 	public static void del(int num) {
 		if (--cnt[num] == 0) {
 			mex = Math.min(mex, num);
@@ -65,7 +55,13 @@ public static void add(int num) {
 	}
 
 	public static void compute() {
-		init();
+		for (int i = 1; i <= n; i++) {
+			cnt[arr[i]]++;
+		}
+		mex = 0;
+		while (cnt[mex] != 0) {
+			mex++;
+		}
 		int winl = 1, winr = n;
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			while (winl < bl[block]) {
diff --git a/src/class177/Code05_MoDelUndo2.java b/src/class177/Code05_MoDelUndo2.java
index abaa604a8..ccf9001c1 100644
--- a/src/class177/Code05_MoDelUndo2.java
+++ b/src/class177/Code05_MoDelUndo2.java
@@ -38,16 +38,6 @@
 //    return b.r < a.r;
 //}
 //
-//void init() {
-//    for (int i = 1; i <= n; i++) {
-//        cnt[arr[i]]++;
-//    }
-//    mex = 0;
-//    while (cnt[mex] != 0) {
-//        mex++;
-//    }
-//}
-//
 //void del(int num) {
 //    if (--cnt[num] == 0) {
 //        mex = min(mex, num);
@@ -59,7 +49,13 @@
 //}
 //
 //void compute() {
-//    init();
+//    for (int i = 1; i <= n; i++) {
+//        cnt[arr[i]]++;
+//    }
+//    mex = 0;
+//    while (cnt[mex] != 0) {
+//        mex++;
+//    }
 //    int winl = 1, winr = n;
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 //        while (winl < bl[block]) {
diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index fbedf2bc5..78b415eb8 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -48,18 +48,6 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static void init() {
-		for (int v = 1; v <= n; v++) {
-			last[v] = v - 1;
-			next[v] = v + 1;
-		}
-		next[0] = 1;
-		last[n + 1] = n;
-		for (int v = 2; v <= n; v++) {
-			sum += Math.abs(pos[v] - pos[v - 1]);
-		}
-	}
-
 	public static void del(int num) {
 		int less = last[num], more = next[num];
 		if (less != 0) {
@@ -82,7 +70,15 @@ public static void add(int num) {
 	}
 
 	public static void compute() {
-		init();
+		for (int v = 1; v <= n; v++) {
+			last[v] = v - 1;
+			next[v] = v + 1;
+		}
+		next[0] = 1;
+		last[n + 1] = n;
+		for (int v = 2; v <= n; v++) {
+			sum += Math.abs(pos[v] - pos[v - 1]);
+		}
 		int winl = 1, winr = n;
 		for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 			while (winl < bl[block]) {
diff --git a/src/class177/Code06_BaldChief2.java b/src/class177/Code06_BaldChief2.java
index 1e02e390f..f70765deb 100644
--- a/src/class177/Code06_BaldChief2.java
+++ b/src/class177/Code06_BaldChief2.java
@@ -40,18 +40,6 @@
 //    return a.r > b.r;
 //}
 //
-//inline void init() {
-//    for (int v = 1; v <= n; v++) {
-//        lst[v] = v - 1;
-//        nxt[v] = v + 1;
-//    }
-//    nxt[0] = 1;
-//    lst[n + 1] = n;
-//    for (int v = 2; v <= n; v++) {
-//        sum += abs(pos[v] - pos[v - 1]);
-//    }
-//}
-//
 //inline void del(int num) {
 //    int less = lst[num], more = nxt[num];
 //    if (less != 0) {
@@ -88,7 +76,15 @@
 //}
 //
 //void compute() {
-//    init();
+//    for (int v = 1; v <= n; v++) {
+//        lst[v] = v - 1;
+//        nxt[v] = v + 1;
+//    }
+//    nxt[0] = 1;
+//    lst[n + 1] = n;
+//    for (int v = 2; v <= n; v++) {
+//        sum += abs(pos[v] - pos[v - 1]);
+//    }
 //    int winl = 1, winr = n;
 //    for (int block = 1, qi = 1; block <= bnum && qi <= m; block++) {
 //        while (winl < bl[block]) {

From ed62b1afa2aba0ad18f492e1af6cc941e531a7ff Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 31 Aug 2025 18:33:25 +0800
Subject: [PATCH 1344/1712] modify code

---
 src/class177/Code05_MoDelUndo1.java | 2 +-
 src/class177/Code05_MoDelUndo2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class177/Code05_MoDelUndo1.java b/src/class177/Code05_MoDelUndo1.java
index 61dfac117..3ccf17658 100644
--- a/src/class177/Code05_MoDelUndo1.java
+++ b/src/class177/Code05_MoDelUndo1.java
@@ -27,7 +27,7 @@ public class Code05_MoDelUndo1 {
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 
-	public static int[] cnt = new int[MAXN + 1];
+	public static int[] cnt = new int[MAXN];
 	public static int mex;
 	public static int[] ans = new int[MAXN];
 
diff --git a/src/class177/Code05_MoDelUndo2.java b/src/class177/Code05_MoDelUndo2.java
index ccf9001c1..b9bff7d70 100644
--- a/src/class177/Code05_MoDelUndo2.java
+++ b/src/class177/Code05_MoDelUndo2.java
@@ -27,7 +27,7 @@
 //int bi[MAXN];
 //int bl[MAXB];
 //
-//int cnt[MAXN + 1];
+//int cnt[MAXN];
 //int mex;
 //int ans[MAXN];
 //

From 7c653aa26f3294e3571a62fa2005f0c81dbbce20 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 31 Aug 2025 18:55:26 +0800
Subject: [PATCH 1345/1712] modify code

---
 src/class177/Code06_BaldChief1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class177/Code06_BaldChief1.java b/src/class177/Code06_BaldChief1.java
index 78b415eb8..895ce911b 100644
--- a/src/class177/Code06_BaldChief1.java
+++ b/src/class177/Code06_BaldChief1.java
@@ -63,7 +63,7 @@ public static void del(int num) {
 		last[more] = less;
 	}
 
-	// 加数字的顺序，就是删数字的顺序的回滚，才能这么方便的更新
+	// 加数字的顺序，就是删数字顺序的回滚，才能这么方便的更新
 	public static void add(int num) {
 		next[last[num]] = num;
 		last[next[num]] = num;

From 84dce240441138101b1bae664062b533c2a7c328 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 1 Sep 2025 14:42:50 +0800
Subject: [PATCH 1346/1712] modify code

---
 src/class177/Code07_MoOnTree1.java | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index bf54d9477..ce4c075e7 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -31,11 +31,18 @@ public class Code07_MoOnTree1 {
 	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
+	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] to = new int[MAXN << 1];
 	public static int[] next = new int[MAXN << 1];
 	public static int cntg;
 
+	// dep是深度
+	// seg是括号序
+	// st是节点开始序
+	// ed是节点结束序
+	// stjump是倍增表
+	// cntd是括号序列的长度
 	public static int[] dep = new int[MAXN];
 	public static int[] seg = new int[MAXN << 1];
 	public static int[] st = new int[MAXN];
@@ -43,7 +50,10 @@ public class Code07_MoOnTree1 {
 	public static int[][] stjump = new int[MAXN][MAXP];
 	public static int cntd;
 
+	// 分块
 	public static int[] bi = new int[MAXN << 1];
+
+	// 窗口信息
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] cnt = new int[MAXN];
 	public static int kind = 0;

From 40981b4850fe0446118061f0b0a3a853bf063e9e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 1 Sep 2025 16:35:16 +0800
Subject: [PATCH 1347/1712] modify code

---
 src/class177/Code07_MoOnTree1.java  | 21 +++++++++++++--------
 src/class177/Code07_MoOnTree2.java  | 18 ++++++++++--------
 src/class177/Code08_CandyPark1.java | 19 ++++++++++---------
 src/class177/Code08_CandyPark2.java | 18 +++++++++---------
 4 files changed, 42 insertions(+), 34 deletions(-)

diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index ce4c075e7..2f3233403 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -27,10 +27,14 @@ public class Code07_MoOnTree1 {
 	public static int MAXP = 20;
 	public static int n, m;
 	public static int[] color = new int[MAXN];
-	public static int[][] query = new int[MAXM][4];
 	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
+	// 查询的参数，jobl、jobr、lca、id
+	// 如果是类型1，那么lca == 0，表示空缺
+	// 如果是类型2，那么lca > 0，查询结果需要补充这个单点信息
+	public static int[][] query = new int[MAXM][4];
+
 	// 链式前向星
 	public static int[] head = new int[MAXN];
 	public static int[] to = new int[MAXN << 1];
@@ -134,7 +138,8 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static void modify(int node) {
+	// 窗口不管是加入还是删除node，遇到node就翻转信息即可
+	public static void invert(int node) {
 		int val = color[node];
 		if (vis[node]) {
 			if (--cnt[val] == 0) {
@@ -156,23 +161,23 @@ public static void compute() {
 			int lca = query[i][2];
 			int id = query[i][3];
 			while (winl > jobl) {
-				modify(seg[--winl]);
+				invert(seg[--winl]);
 			}
 			while (winr < jobr) {
-				modify(seg[++winr]);
+				invert(seg[++winr]);
 			}
 			while (winl < jobl) {
-				modify(seg[winl++]);
+				invert(seg[winl++]);
 			}
 			while (winr > jobr) {
-				modify(seg[winr--]);
+				invert(seg[winr--]);
 			}
 			if (lca > 0) {
-				modify(lca);
+				invert(lca);
 			}
 			ans[id] = kind;
 			if (lca > 0) {
-				modify(lca);
+				invert(lca);
 			}
 		}
 	}
diff --git a/src/class177/Code07_MoOnTree2.java b/src/class177/Code07_MoOnTree2.java
index 8bdb751d4..31201b655 100644
--- a/src/class177/Code07_MoOnTree2.java
+++ b/src/class177/Code07_MoOnTree2.java
@@ -25,10 +25,11 @@
 //
 //int n, m;
 //int color[MAXN];
-//Query query[MAXM];
 //int sorted[MAXN];
 //int cntv;
 //
+//Query query[MAXM];
+//
 //int head[MAXN];
 //int to[MAXN << 1];
 //int nxt[MAXN << 1];
@@ -42,6 +43,7 @@
 //int cntd;
 //
 //int bi[MAXN << 1];
+//
 //bool vis[MAXN];
 //int cnt[MAXN];
 //int kind;
@@ -114,7 +116,7 @@
 //    return a.r < b.r;
 //}
 //
-//void modify(int node) {
+//void invert(int node) {
 //    int val = color[node];
 //    if (vis[node]) {
 //        if (--cnt[val] == 0) {
@@ -136,23 +138,23 @@
 //        int lca = query[i].lca;
 //        int id = query[i].id;
 //        while (winl > jobl) {
-//            modify(seg[--winl]);
+//            invert(seg[--winl]);
 //        }
 //        while (winr < jobr) {
-//            modify(seg[++winr]);
+//            invert(seg[++winr]);
 //        }
 //        while (winl < jobl) {
-//            modify(seg[winl++]);
+//            invert(seg[winl++]);
 //        }
 //        while (winr > jobr) {
-//            modify(seg[winr--]);
+//            invert(seg[winr--]);
 //        }
 //        if (lca > 0) {
-//            modify(lca);
+//            invert(lca);
 //        }
 //        ans[id] = kind;
 //        if (lca > 0) {
-//            modify(lca);
+//            invert(lca);
 //        }
 //    }
 //}
diff --git a/src/class177/Code08_CandyPark1.java b/src/class177/Code08_CandyPark1.java
index b694ce432..11b67b83f 100644
--- a/src/class177/Code08_CandyPark1.java
+++ b/src/class177/Code08_CandyPark1.java
@@ -165,7 +165,8 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	public static void modify(int node) {
+	// 窗口不管是加入还是删除node，遇到node就翻转信息即可
+	public static void invert(int node) {
 		int candy = c[node];
 		if (vis[node]) {
 			curAns -= (long) v[candy] * w[cnt[candy]--];
@@ -180,10 +181,10 @@ public static void moveTime(int tim) {
 		int oldVal = c[pos];
 		int newVal = update[tim][1];
 		if (vis[pos]) {
-			modify(pos);
+			invert(pos);
 			c[pos] = newVal;
 			update[tim][1] = oldVal;
-			modify(pos);
+			invert(pos);
 		} else {
 			c[pos] = newVal;
 			update[tim][1] = oldVal;
@@ -199,16 +200,16 @@ public static void compute() {
 			int lca = query[i][3];
 			int id = query[i][4];
 			while (winl > jobl) {
-				modify(seg[--winl]);
+				invert(seg[--winl]);
 			}
 			while (winr < jobr) {
-				modify(seg[++winr]);
+				invert(seg[++winr]);
 			}
 			while (winl < jobl) {
-				modify(seg[winl++]);
+				invert(seg[winl++]);
 			}
 			while (winr > jobr) {
-				modify(seg[winr--]);
+				invert(seg[winr--]);
 			}
 			while (wint < jobt) {
 				moveTime(++wint);
@@ -217,11 +218,11 @@ public static void compute() {
 				moveTime(wint--);
 			}
 			if (lca > 0) {
-				modify(lca);
+				invert(lca);
 			}
 			ans[id] = curAns;
 			if (lca > 0) {
-				modify(lca);
+				invert(lca);
 			}
 		}
 	}
diff --git a/src/class177/Code08_CandyPark2.java b/src/class177/Code08_CandyPark2.java
index 9cca3143b..d75297324 100644
--- a/src/class177/Code08_CandyPark2.java
+++ b/src/class177/Code08_CandyPark2.java
@@ -109,7 +109,7 @@
 //    return a.t < b.t;
 //}
 //
-//void modify(int node) {
+//void invert(int node) {
 //    int candy = c[node];
 //    if (vis[node]) {
 //        curAns -= 1LL * v[candy] * w[cnt[candy]--];
@@ -124,10 +124,10 @@
 //    int oldVal = c[pos];
 //    int newVal = update[tim].val;
 //    if (vis[pos]) {
-//        modify(pos);
+//        invert(pos);
 //        c[pos] = newVal;
 //        update[tim].val = oldVal;
-//        modify(pos);
+//        invert(pos);
 //    } else {
 //        c[pos] = newVal;
 //        update[tim].val = oldVal;
@@ -143,16 +143,16 @@
 //        int lca = query[i].lca;
 //        int id = query[i].id;
 //        while (winl > jobl) {
-//            modify(seg[--winl]);
+//            invert(seg[--winl]);
 //        }
 //        while (winr < jobr) {
-//            modify(seg[++winr]);
+//            invert(seg[++winr]);
 //        }
 //        while (winl < jobl) {
-//            modify(seg[winl++]);
+//            invert(seg[winl++]);
 //        }
 //        while (winr > jobr) {
-//            modify(seg[winr--]);
+//            invert(seg[winr--]);
 //        }
 //        while (wint < jobt) {
 //            moveTime(++wint);
@@ -161,11 +161,11 @@
 //            moveTime(wint--);
 //        }
 //        if (lca > 0) {
-//            modify(lca);
+//            invert(lca);
 //        }
 //        ans[id] = curAns;
 //        if (lca > 0) {
-//            modify(lca);
+//            invert(lca);
 //        }
 //    }
 //}

From 02f6abd1bfa21e8892087f025dca85cf6fd99006 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 1 Sep 2025 17:05:11 +0800
Subject: [PATCH 1348/1712] modify code

---
 src/class177/Code07_MoOnTree1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index 2f3233403..0533df402 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -138,7 +138,8 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	// 窗口不管是加入还是删除node，遇到node就翻转信息即可
+	// 窗口不管是加入还是删除node
+	// 只要遇到node就翻转信息即可
 	public static void invert(int node) {
 		int val = color[node];
 		if (vis[node]) {

From dcded4c1c955c662a161d711f582fc689372c4fd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 1 Sep 2025 17:06:29 +0800
Subject: [PATCH 1349/1712] modify code

---
 src/class177/Code08_CandyPark1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class177/Code08_CandyPark1.java b/src/class177/Code08_CandyPark1.java
index 11b67b83f..2732fe760 100644
--- a/src/class177/Code08_CandyPark1.java
+++ b/src/class177/Code08_CandyPark1.java
@@ -165,7 +165,8 @@ public int compare(int[] a, int[] b) {
 
 	}
 
-	// 窗口不管是加入还是删除node，遇到node就翻转信息即可
+	// 窗口不管是加入还是删除node
+	// 只要遇到node就翻转信息即可
 	public static void invert(int node) {
 		int candy = c[node];
 		if (vis[node]) {

From 42ca4998eb1339770c9ee82d61b007b769117b2e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 1 Sep 2025 17:32:27 +0800
Subject: [PATCH 1350/1712] modify code

---
 src/class177/Code08_CandyPark1.java | 8 ++++----
 src/class177/Code08_CandyPark2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class177/Code08_CandyPark1.java b/src/class177/Code08_CandyPark1.java
index 2732fe760..8472c1809 100644
--- a/src/class177/Code08_CandyPark1.java
+++ b/src/class177/Code08_CandyPark1.java
@@ -49,7 +49,7 @@ public class Code08_CandyPark1 {
 	public static int[] bi = new int[MAXN << 1];
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] cnt = new int[MAXN];
-	public static long curAns;
+	public static long happy;
 	public static long[] ans = new long[MAXN];
 
 	public static void addEdge(int u, int v) {
@@ -170,9 +170,9 @@ public int compare(int[] a, int[] b) {
 	public static void invert(int node) {
 		int candy = c[node];
 		if (vis[node]) {
-			curAns -= (long) v[candy] * w[cnt[candy]--];
+			happy -= (long) v[candy] * w[cnt[candy]--];
 		} else {
-			curAns += (long) v[candy] * w[++cnt[candy]];
+			happy += (long) v[candy] * w[++cnt[candy]];
 		}
 		vis[node] = !vis[node];
 	}
@@ -221,7 +221,7 @@ public static void compute() {
 			if (lca > 0) {
 				invert(lca);
 			}
-			ans[id] = curAns;
+			ans[id] = happy;
 			if (lca > 0) {
 				invert(lca);
 			}
diff --git a/src/class177/Code08_CandyPark2.java b/src/class177/Code08_CandyPark2.java
index d75297324..f4f1930bb 100644
--- a/src/class177/Code08_CandyPark2.java
+++ b/src/class177/Code08_CandyPark2.java
@@ -51,7 +51,7 @@
 //int bi[MAXN << 1];
 //bool vis[MAXN];
 //int cnt[MAXN];
-//long long curAns;
+//long long happy;
 //long long ans[MAXN];
 //
 //void addEdge(int u, int v) {
@@ -112,9 +112,9 @@
 //void invert(int node) {
 //    int candy = c[node];
 //    if (vis[node]) {
-//        curAns -= 1LL * v[candy] * w[cnt[candy]--];
+//        happy -= 1LL * v[candy] * w[cnt[candy]--];
 //    } else {
-//        curAns += 1LL * v[candy] * w[++cnt[candy]];
+//        happy += 1LL * v[candy] * w[++cnt[candy]];
 //    }
 //    vis[node] = !vis[node];
 //}
@@ -163,7 +163,7 @@
 //        if (lca > 0) {
 //            invert(lca);
 //        }
-//        ans[id] = curAns;
+//        ans[id] = happy;
 //        if (lca > 0) {
 //            invert(lca);
 //        }

From f6fa4782145b1435cd054295b0d9d18f0d317406 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 1 Sep 2025 18:35:43 +0800
Subject: [PATCH 1351/1712] modify code

---
 ...21\344\270\212\350\216\253\351\230\237.pptx" | Bin 0 -> 59825 bytes
 src/class177/Code08_CandyPark1.java             |  10 ++++++++--
 2 files changed, 8 insertions(+), 2 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243177\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2302-\345\233\236\346\273\232\350\216\253\351\230\237\343\200\201\346\240\221\344\270\212\350\216\253\351\230\237.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243177\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2302-\345\233\236\346\273\232\350\216\253\351\230\237\343\200\201\346\240\221\344\270\212\350\216\253\351\230\237.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243177\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2302-\345\233\236\346\273\232\350\216\253\351\230\237\343\200\201\346\240\221\344\270\212\350\216\253\351\230\237.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..83056ab8c409f15f96b0dc44ed31b2c12b4a41cc
GIT binary patch
literal 59825
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
I{`&O)0G=%{;{X5v

literal 0
HcmV?d00001

diff --git a/src/class177/Code08_CandyPark1.java b/src/class177/Code08_CandyPark1.java
index 8472c1809..89d13f2ee 100644
--- a/src/class177/Code08_CandyPark1.java
+++ b/src/class177/Code08_CandyPark1.java
@@ -177,16 +177,22 @@ public static void invert(int node) {
 		vis[node] = !vis[node];
 	}
 
+	// 上节课带修莫队的重要过程
+	// tim为生效或者撤销的修改时间点，公园更换糖果
 	public static void moveTime(int tim) {
 		int pos = update[tim][0];
 		int oldVal = c[pos];
 		int newVal = update[tim][1];
-		if (vis[pos]) {
+		if (vis[pos]) { // 如果当前公园生效中
+			// 老糖果invert效果
 			invert(pos);
+			// 新老糖果换位
 			c[pos] = newVal;
 			update[tim][1] = oldVal;
+			// 新糖果invert效果
 			invert(pos);
-		} else {
+		} else { // 如果当前公园不在生效中
+			// 新老糖果换位即可
 			c[pos] = newVal;
 			update[tim][1] = oldVal;
 		}

From a7c7ab678bdf662956110606330a2ed343ad4a50 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 4 Sep 2025 15:43:32 +0800
Subject: [PATCH 1352/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 203 +++++++++++++++++++++++
 src/class178/Code01_MoOfflineTwice2.java | 151 +++++++++++++++++
 2 files changed, 354 insertions(+)
 create mode 100644 src/class178/Code01_MoOfflineTwice1.java
 create mode 100644 src/class178/Code01_MoOfflineTwice2.java

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
new file mode 100644
index 000000000..20147eb63
--- /dev/null
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -0,0 +1,203 @@
+package class178;
+
+// 莫队二次离线入门题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4887
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code01_MoOfflineTwice2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code01_MoOfflineTwice1 {
+
+	public static int MAXN = 100001;
+	public static int MAXQ = 200001;
+	public static int MAXV = 1 << 14;
+	public static int n, m, k;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] kOneArr = new int[MAXV];
+	public static int cntk;
+
+	public static int[] bi = new int[MAXN];
+	public static int[] pre = new int[MAXN];
+	public static int[] cnt = new int[MAXV];
+
+	public static int[] head = new int[MAXN];
+	public static int[] next = new int[MAXQ];
+	public static int[] qid = new int[MAXQ];
+	public static int[] ql = new int[MAXQ];
+	public static int[] qr = new int[MAXQ];
+	public static int[] qop = new int[MAXQ];
+	public static int cntq;
+
+	public static long[] ans = new long[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+	}
+
+	public static int countOne(int num) {
+		int ret = 0;
+		while (num > 0) {
+			ret++;
+			num -= num & -num;
+		}
+		return ret;
+	}
+
+	public static void addQuery(int pos, int id, int l, int r, int op) {
+		next[++cntq] = head[pos];
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
+		head[pos] = cntq;
+	}
+
+	public static void prepare() {
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+		for (int v = 0; v < MAXV; v++) {
+			if (countOne(v) == k) {
+				kOneArr[++cntk] = v;
+			}
+		}
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= n; i++) {
+			pre[i] = cnt[arr[i]];
+			for (int j = 1; j <= cntk; j++) {
+				cnt[arr[i] ^ kOneArr[j]]++;
+			}
+		}
+		// 莫队
+		int winl = 1, winr = 0;
+		int kIs0 = (k == 0 ? 1 : 0);
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			if (winr < jobr) {
+				addQuery(winl - 1, id, winr + 1, jobr, -1);
+			}
+			while (winr < jobr) {
+				ans[id] += pre[++winr];
+			}
+			if (winr > jobr) {
+				addQuery(winl - 1, id, jobr + 1, winr, 1);
+			}
+			while (winr > jobr) {
+				ans[id] -= pre[winr--];
+			}
+			if (winl > jobl) {
+				addQuery(winr, id, jobl, winl - 1, 1);
+			}
+			while (winl > jobl) {
+				ans[id] -= pre[--winl] + kIs0;
+			}
+			if (winl < jobl) {
+				addQuery(winr, id, winl, jobl - 1, -1);
+			}
+			while (winl < jobl) {
+				ans[id] += pre[winl++] + kIs0;
+			}
+		}
+		// 第二次离线
+		Arrays.fill(cnt, 0);
+		for (int i = 1; i <= n; i++) {
+			for (int j = 1; j <= cntk; j++) {
+				cnt[arr[i] ^ kOneArr[j]]++;
+			}
+			for (int q = head[i]; q > 0; q = next[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				for (int x = l; x <= r; x++) {
+					ans[id] += (long) op * cnt[arr[x]];
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 2; i <= m; i++) {
+			ans[query[i][2]] += ans[query[i - 1][2]];
+		}
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
new file mode 100644
index 000000000..e4c6ed9b2
--- /dev/null
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -0,0 +1,151 @@
+package class178;
+
+// 莫队二次离线入门题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4887
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXQ = 200001;
+//const int MAXV = 1 << 14;
+//
+//int n, m, k;
+//int arr[MAXN];
+//Query query[MAXN];
+//
+//int kOneArr[MAXV];
+//int cntk;
+//
+//int bi[MAXN];
+//int pre[MAXN];
+//int cnt[MAXV];
+//
+//int head[MAXN];
+//int nxt[MAXQ];
+//int qid[MAXQ];
+//int ql[MAXQ];
+//int qr[MAXQ];
+//int qop[MAXQ];
+//int cntq;
+//
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//int countOne(int num) {
+//    int ret = 0;
+//    while (num > 0) {
+//        ret++;
+//        num -= num & -num;
+//    }
+//    return ret;
+//}
+//
+//void addQuery(int pos, int id, int l, int r, int op) {
+//    nxt[++cntq] = head[pos];
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
+//    head[pos] = cntq;
+//}
+//
+//void prepare() {
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//    for (int v = 0; v < MAXV; v++) {
+//        if (countOne(v) == k) {
+//            kOneArr[++cntk] = v;
+//        }
+//    }
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= n; i++) {
+//        pre[i] = cnt[arr[i]];
+//        for (int j = 1; j <= cntk; j++) {
+//            cnt[arr[i] ^ kOneArr[j]]++;
+//        }
+//    }
+//    int winl = 1, winr = 0;
+//    int kIs0 = (k == 0 ? 1 : 0);
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
+//        if (winr < jobr) {
+//            addQuery(winl - 1, id, winr + 1, jobr, -1);
+//        }
+//        while (winr < jobr) {
+//            ans[id] += pre[++winr];
+//        }
+//        if (winr > jobr) {
+//            addQuery(winl - 1, id, jobr + 1, winr, 1);
+//        }
+//        while (winr > jobr) {
+//            ans[id] -= pre[winr--];
+//        }
+//        if (winl > jobl) {
+//            addQuery(winr, id, jobl, winl - 1, 1);
+//        }
+//        while (winl > jobl) {
+//            ans[id] -= pre[--winl] + kIs0;
+//        }
+//        if (winl < jobl) {
+//            addQuery(winr, id, winl, jobl - 1, -1);
+//        }
+//        while (winl < jobl) {
+//            ans[id] += pre[winl++] + kIs0;
+//        }
+//    }
+//    memset(cnt, 0, sizeof(cnt));
+//    for (int i = 1; i <= n; i++) {
+//        for (int j = 1; j <= cntk; j++) {
+//            cnt[arr[i] ^ kOneArr[j]]++;
+//        }
+//        for (int q = head[i]; q > 0; q = nxt[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            for (int x = l; x <= r; x++) {
+//                ans[id] += 1LL * op * cnt[arr[x]];
+//            }
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> k;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 2; i <= m; i++) {
+//        ans[query[i].id] += ans[query[i - 1].id];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 690337b36d8ad0ed36e9248f5a3442e546df5aae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 4 Sep 2025 18:52:17 +0800
Subject: [PATCH 1353/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 6 +++---
 src/class178/Code01_MoOfflineTwice2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 20147eb63..f8b8051a7 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -90,7 +90,7 @@ public static void compute() {
 		}
 		// 莫队
 		int winl = 1, winr = 0;
-		int kIs0 = (k == 0 ? 1 : 0);
+		int k0 = (k == 0 ? 1 : 0);
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
@@ -111,13 +111,13 @@ public static void compute() {
 				addQuery(winr, id, jobl, winl - 1, 1);
 			}
 			while (winl > jobl) {
-				ans[id] -= pre[--winl] + kIs0;
+				ans[id] -= pre[--winl] + k0;
 			}
 			if (winl < jobl) {
 				addQuery(winr, id, winl, jobl - 1, -1);
 			}
 			while (winl < jobl) {
-				ans[id] += pre[winl++] + kIs0;
+				ans[id] += pre[winl++] + k0;
 			}
 		}
 		// 第二次离线
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index e4c6ed9b2..bd3999f17 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -84,7 +84,7 @@
 //        }
 //    }
 //    int winl = 1, winr = 0;
-//    int kIs0 = (k == 0 ? 1 : 0);
+//    int k0 = (k == 0 ? 1 : 0);
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
@@ -105,13 +105,13 @@
 //            addQuery(winr, id, jobl, winl - 1, 1);
 //        }
 //        while (winl > jobl) {
-//            ans[id] -= pre[--winl] + kIs0;
+//            ans[id] -= pre[--winl] + k0;
 //        }
 //        if (winl < jobl) {
 //            addQuery(winr, id, winl, jobl - 1, -1);
 //        }
 //        while (winl < jobl) {
-//            ans[id] += pre[winl++] + kIs0;
+//            ans[id] += pre[winl++] + k0;
 //        }
 //    }
 //    memset(cnt, 0, sizeof(cnt));

From e005870b03811e77ed153b0d5557f1889dea96a5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 4 Sep 2025 22:09:14 +0800
Subject: [PATCH 1354/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 13 ++++++++-----
 src/class178/Code01_MoOfflineTwice2.java | 13 ++++++++-----
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index f8b8051a7..335d89c8d 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -90,7 +90,6 @@ public static void compute() {
 		}
 		// 莫队
 		int winl = 1, winr = 0;
-		int k0 = (k == 0 ? 1 : 0);
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
@@ -111,13 +110,13 @@ public static void compute() {
 				addQuery(winr, id, jobl, winl - 1, 1);
 			}
 			while (winl > jobl) {
-				ans[id] -= pre[--winl] + k0;
+				ans[id] -= pre[--winl];
 			}
 			if (winl < jobl) {
 				addQuery(winr, id, winl, jobl - 1, -1);
 			}
 			while (winl < jobl) {
-				ans[id] += pre[winl++] + k0;
+				ans[id] += pre[winl++];
 			}
 		}
 		// 第二次离线
@@ -128,8 +127,12 @@ public static void compute() {
 			}
 			for (int q = head[i]; q > 0; q = next[q]) {
 				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
-				for (int x = l; x <= r; x++) {
-					ans[id] += (long) op * cnt[arr[x]];
+				for (int j = l; j <= r; j++) {
+					if (j <= i && k == 0) {
+						ans[id] += (long) op * (cnt[arr[j]] - 1);
+					} else {
+						ans[id] += (long) op * cnt[arr[j]];
+					}
 				}
 			}
 		}
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index bd3999f17..f32c89dee 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -84,7 +84,6 @@
 //        }
 //    }
 //    int winl = 1, winr = 0;
-//    int k0 = (k == 0 ? 1 : 0);
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
@@ -105,13 +104,13 @@
 //            addQuery(winr, id, jobl, winl - 1, 1);
 //        }
 //        while (winl > jobl) {
-//            ans[id] -= pre[--winl] + k0;
+//            ans[id] -= pre[--winl];
 //        }
 //        if (winl < jobl) {
 //            addQuery(winr, id, winl, jobl - 1, -1);
 //        }
 //        while (winl < jobl) {
-//            ans[id] += pre[winl++] + k0;
+//            ans[id] += pre[winl++];
 //        }
 //    }
 //    memset(cnt, 0, sizeof(cnt));
@@ -121,8 +120,12 @@
 //        }
 //        for (int q = head[i]; q > 0; q = nxt[q]) {
 //            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
-//            for (int x = l; x <= r; x++) {
-//                ans[id] += 1LL * op * cnt[arr[x]];
+//            for (int j = l; j <= r; j++) {
+//                if (j <= i && k == 0) {
+//                    ans[id] += 1LL * op * (cnt[arr[j]] - 1);
+//                } else {
+//                    ans[id] += 1LL * op * cnt[arr[j]];
+//                }
 //            }
 //        }
 //    }

From 2e2ab888163da0afe1ff00c0a686c5a1e4c55fae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 4 Sep 2025 22:39:03 +0800
Subject: [PATCH 1355/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 8 ++++++++
 1 file changed, 8 insertions(+)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 335d89c8d..bd62a1c6e 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -128,9 +128,17 @@ public static void compute() {
 			for (int q = head[i]; q > 0; q = next[q]) {
 				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 				for (int j = l; j <= r; j++) {
+					// 计算j 对 1..i范围的贡献
+					// 此时1..i范围上的数字都更新过cnt
 					if (j <= i && k == 0) {
+						// j在1..i范围上，此时又有k==0
+						// 那么arr[j]一定更新过cnt，并且(arr[j], arr[j])一定算进贡献了
+						// 但是题目要求的二元组必须是不同位置，所以贡献要进行减1修正
 						ans[id] += (long) op * (cnt[arr[j]] - 1);
 					} else {
+						// 要么j不在1..i范围上，arr[j]没更新过cnt
+						// 要么k!=0，(arr[j], arr[j])无法被算成贡献
+						// 无论哪种情况，贡献都是正确的，不用进行减1修正
 						ans[id] += (long) op * cnt[arr[j]];
 					}
 				}

From 91a021ad175b9264fb598e21c179b6e442e70978 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 4 Sep 2025 22:56:04 +0800
Subject: [PATCH 1356/1712] modify code

---
 src/class178/Code01_MoOfflineTwice2.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index f32c89dee..de444c9fc 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -16,7 +16,6 @@
 //const int MAXN = 100001;
 //const int MAXQ = 200001;
 //const int MAXV = 1 << 14;
-//
 //int n, m, k;
 //int arr[MAXN];
 //Query query[MAXN];

From ba55ea61d3931d768dffca964d09f4917412bd88 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 5 Sep 2025 22:46:12 +0800
Subject: [PATCH 1357/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 304 +++++++++++++++++++++
 src/class178/Code02_OfflineInversion2.java | 245 +++++++++++++++++
 2 files changed, 549 insertions(+)
 create mode 100644 src/class178/Code02_OfflineInversion1.java
 create mode 100644 src/class178/Code02_OfflineInversion2.java

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
new file mode 100644
index 000000000..f681da41a
--- /dev/null
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -0,0 +1,304 @@
+package class178;
+
+// 离线查询逆序对，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5047
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code02_OfflineInversion2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code02_OfflineInversion1 {
+
+	public static int MAXN = 100002;
+	public static int MAXQ = 200001;
+	public static int MAXB = 401;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+
+	// 值的离散化
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
+
+	// bi用于序列分块 + 值域分块
+	// bl和br用于值域分块
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
+
+	// 前后缀信息
+	public static long[] pre = new long[MAXN];
+	public static long[] suf = new long[MAXN];
+
+	// 树状数组
+	public static int[] tree = new int[MAXN];
+
+	// 每种值加了多少词频
+	public static long[] cnt = new long[MAXN];
+	// 块的懒信息，整块加了多少词频
+	public static long[] lazy = new long[MAXB];
+
+	// 链式前向星，二次离线的任务列表
+	public static int[] headl = new int[MAXN];
+	public static int[] headr = new int[MAXN];
+	public static int[] next = new int[MAXQ];
+	public static int[] qid = new int[MAXQ];
+	public static int[] ql = new int[MAXQ];
+	public static int[] qr = new int[MAXQ];
+	public static int[] qop = new int[MAXQ];
+	public static int cntq;
+
+	public static long[] ans = new long[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= cntv) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void clear() {
+		Arrays.fill(tree, 1, cntv + 1, 0);
+	}
+
+	public static void addLeftQuery(int pos, int id, int l, int r, int op) {
+		next[++cntq] = headl[pos];
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
+		headl[pos] = cntq;
+	}
+
+	public static void addRightQuery(int pos, int id, int l, int r, int op) {
+		next[++cntq] = headr[pos];
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
+		headr[pos] = cntq;
+	}
+
+	public static void addLeftCnt(int val) {
+		if (val <= 0) {
+			return;
+		}
+		for (int i = bl[bi[val]]; i <= val; i++) {
+			cnt[i]++;
+		}
+		for (int b = 1; b <= bi[val] - 1; b++) {
+			lazy[b]++;
+		}
+	}
+
+	public static void addRightCnt(int val) {
+		if (val > cntv) {
+			return;
+		}
+		for (int i = val; i <= br[bi[val]]; i++) {
+			cnt[i]++;
+		}
+		for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
+			lazy[b]++;
+		}
+	}
+
+	public static long getCnt(int val) {
+		return cnt[val] + lazy[bi[val]];
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		cntv = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		int blen = (int) Math.sqrt(n);
+		int bnum = (n + blen - 1) / blen;
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, cntv);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= n; i++) {
+			pre[i] = pre[i - 1] + sum(cntv) - sum(arr[i]);
+			add(arr[i], 1);
+		}
+		clear();
+		for (int i = n; i >= 1; i--) {
+			suf[i] = suf[i + 1] + sum(arr[i] - 1);
+			add(arr[i], 1);
+		}
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			if (winr < jobr) {
+				addLeftQuery(winl - 1, id, winr + 1, jobr, -1);
+				ans[id] += pre[jobr] - pre[winr];
+			}
+			if (winr > jobr) {
+				addLeftQuery(winl - 1, id, jobr + 1, winr, 1);
+				ans[id] -= pre[winr] - pre[jobr];
+			}
+			if (winl > jobl) {
+				addRightQuery(jobr + 1, id, jobl, winl - 1, -1);
+				ans[id] += suf[jobl] - suf[winl];
+			}
+			if (winl < jobl) {
+				addRightQuery(jobr + 1, id, winl, jobl - 1, 1);
+				ans[id] -= suf[winl] - suf[jobl];
+			}
+			winl = jobl;
+			winr = jobr;
+		}
+		for (int i = 1; i <= n; i++) {
+			addLeftCnt(arr[i] - 1);
+			for (int q = headl[i]; q > 0; q = next[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				long ret = 0;
+				for (int j = l; j <= r; j++) {
+					ret += getCnt(arr[j]);
+				}
+				ans[id] += ret * op;
+			}
+		}
+		Arrays.fill(lazy, 0);
+		Arrays.fill(cnt, 0);
+		for (int i = n; i >= 1; i--) {
+			addRightCnt(arr[i] + 1);
+			for (int q = headr[i]; q > 0; q = next[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				long ret = 0;
+				for (int j = l; j <= r; j++) {
+					ret += getCnt(arr[j]);
+				}
+				ans[id] += ret * op;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 2; i <= m; i++) {
+			ans[query[i][2]] += ans[query[i - 1][2]];
+		}
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
new file mode 100644
index 000000000..dad32ae4c
--- /dev/null
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -0,0 +1,245 @@
+package class178;
+
+// 离线查询逆序对，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5047
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 100002;
+//const int MAXQ = 200001;
+//const int MAXB = 401;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//
+//int sorted[MAXN];
+//int cntv;
+//
+//int bi[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
+//
+//long long pre[MAXN];
+//long long suf[MAXN];
+//
+//int tree[MAXN];
+//long long cnt[MAXN];
+//long long lazy[MAXB];
+//
+//int headl[MAXN];
+//int headr[MAXN];
+//int nxt[MAXQ];
+//int qid[MAXQ];
+//int ql[MAXQ];
+//int qr[MAXQ];
+//int qop[MAXQ];
+//int cntq;
+//
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= cntv) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void clear() {
+//    fill(tree + 1, tree + cntv + 1, 0);
+//}
+//
+//void addLeftQuery(int pos, int id, int l, int r, int op) {
+//    nxt[++cntq] = headl[pos];
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
+//    headl[pos] = cntq;
+//}
+//
+//void addRightQuery(int pos, int id, int l, int r, int op) {
+//    nxt[++cntq] = headr[pos];
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
+//    headr[pos] = cntq;
+//}
+//
+//void addLeftCnt(int val) {
+//    if (val <= 0) {
+//        return;
+//    }
+//    for (int i = bl[bi[val]]; i <= val; i++) {
+//        cnt[i]++;
+//    }
+//    for (int b = 1; b <= bi[val] - 1; b++) {
+//        lazy[b]++;
+//    }
+//}
+//
+//void addRightCnt(int val) {
+//    if (val > cntv) {
+//        return;
+//    }
+//    for (int i = val; i <= br[bi[val]]; i++) {
+//        cnt[i]++;
+//    }
+//    for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
+//        lazy[b]++;
+//    }
+//}
+//
+//long long getCnt(int val) {
+//    return cnt[val] + lazy[bi[val]];
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[cntv] != sorted[i]) {
+//            sorted[++cntv] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    int blen = (int)sqrt(n);
+//    int bnum = (n + blen - 1) / blen;
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, cntv);
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= n; i++) {
+//        pre[i] = pre[i - 1] + sum(cntv) - sum(arr[i]);
+//        add(arr[i], 1);
+//    }
+//    clear();
+//    for (int i = n; i >= 1; i--) {
+//        suf[i] = suf[i + 1] + sum(arr[i] - 1);
+//        add(arr[i], 1);
+//    }
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
+//        if (winr < jobr) {
+//            addLeftQuery(winl - 1, id, winr + 1, jobr, -1);
+//            ans[id] += pre[jobr] - pre[winr];
+//        }
+//        if (winr > jobr) {
+//            addLeftQuery(winl - 1, id, jobr + 1, winr, 1);
+//            ans[id] -= pre[winr] - pre[jobr];
+//        }
+//        if (winl > jobl) {
+//            addRightQuery(jobr + 1, id, jobl, winl - 1, -1);
+//            ans[id] += suf[jobl] - suf[winl];
+//        }
+//        if (winl < jobl) {
+//            addRightQuery(jobr + 1, id, winl, jobl - 1, 1);
+//            ans[id] -= suf[winl] - suf[jobl];
+//        }
+//        winl = jobl;
+//        winr = jobr;
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        addLeftCnt(arr[i] - 1);
+//        for (int q = headl[i]; q > 0; q = nxt[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            long long ret = 0;
+//            for (int j = l; j <= r; j++) {
+//                ret += getCnt(arr[j]);
+//            }
+//            ans[id] += ret * op;
+//        }
+//    }
+//    memset(cnt,  0, sizeof(cnt));
+//    memset(lazy, 0, sizeof(lazy));
+//    for (int i = n; i >= 1; i--) {
+//        addRightCnt(arr[i] + 1);
+//        for (int q = headr[i]; q > 0; q = nxt[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            long long ret = 0;
+//            for (int j = l; j <= r; j++) {
+//                ret += getCnt(arr[j]);
+//            }
+//            ans[id] += ret * op;
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 2; i <= m; i++) {
+//    	ans[query[i].id] += ans[query[i - 1].id];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From df89de3b1d180a90e044d78ac16ec6103e060361 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 5 Sep 2025 22:49:04 +0800
Subject: [PATCH 1358/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 5 ++---
 1 file changed, 2 insertions(+), 3 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index f681da41a..465a626f1 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -23,12 +23,11 @@ public class Code02_OfflineInversion1 {
 	public static int[] arr = new int[MAXN];
 	public static int[][] query = new int[MAXN][3];
 
-	// 值的离散化
+	// 离散化
 	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
-	// bi用于序列分块 + 值域分块
-	// bl和br用于值域分块
+	// bi用于序列分块、值域分块，bl和br用于值域分块
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];

From 3ba99ccfc657af05d2c41635f80cbec2ed2251ba Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 6 Sep 2025 09:44:34 +0800
Subject: [PATCH 1359/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 8 ++++----
 src/class178/Code02_OfflineInversion2.java | 2 +-
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 465a626f1..74fd2bcf2 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -32,12 +32,12 @@ public class Code02_OfflineInversion1 {
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
-	// 前后缀信息
-	public static long[] pre = new long[MAXN];
-	public static long[] suf = new long[MAXN];
-
 	// 树状数组
 	public static int[] tree = new int[MAXN];
+	// 前缀信息
+	public static long[] pre = new long[MAXN];
+	// 后缀信息
+	public static long[] suf = new long[MAXN];
 
 	// 每种值加了多少词频
 	public static long[] cnt = new long[MAXN];
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index dad32ae4c..55e931257 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -27,10 +27,10 @@
 //int bl[MAXB];
 //int br[MAXB];
 //
+//int tree[MAXN];
 //long long pre[MAXN];
 //long long suf[MAXN];
 //
-//int tree[MAXN];
 //long long cnt[MAXN];
 //long long lazy[MAXB];
 //

From 8ab57655c6332231c881141e31c5b05c5d9158c8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 6 Sep 2025 22:30:43 +0800
Subject: [PATCH 1360/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java   | 78 +++++++++----------
 src/class178/Code01_MoOfflineTwice2.java   | 67 ++++++++--------
 src/class178/Code02_OfflineInversion1.java | 90 +++++++++++----------
 src/class178/Code02_OfflineInversion2.java | 91 ++++++++++++----------
 4 files changed, 167 insertions(+), 159 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index bd62a1c6e..87190723c 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -17,30 +17,25 @@
 public class Code01_MoOfflineTwice1 {
 
 	public static int MAXN = 100001;
-	public static int MAXQ = 200001;
 	public static int MAXV = 1 << 14;
 	public static int n, m, k;
 	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXN][3];
-
 	public static int[] kOneArr = new int[MAXV];
 	public static int cntk;
 
+	// 第一次离线任务，l、r、id
+	// 第二次离线任务，pos、id、l、r、op
+	public static int[][] query1 = new int[MAXN][3];
+	public static int[][] query2 = new int[MAXN << 1][5];
+	public static int cntq;
+
 	public static int[] bi = new int[MAXN];
 	public static int[] pre = new int[MAXN];
 	public static int[] cnt = new int[MAXV];
 
-	public static int[] head = new int[MAXN];
-	public static int[] next = new int[MAXQ];
-	public static int[] qid = new int[MAXQ];
-	public static int[] ql = new int[MAXQ];
-	public static int[] qr = new int[MAXQ];
-	public static int[] qop = new int[MAXQ];
-	public static int cntq;
-
 	public static long[] ans = new long[MAXN];
 
-	public static class QueryCmp implements Comparator<int[]> {
+	public static class Cmp1 implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
@@ -50,6 +45,13 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
+	public static class Cmp2 implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			return a[0] - b[0];
+		}
+	}
+
 	public static int countOne(int num) {
 		int ret = 0;
 		while (num > 0) {
@@ -60,12 +62,11 @@ public static int countOne(int num) {
 	}
 
 	public static void addQuery(int pos, int id, int l, int r, int op) {
-		next[++cntq] = head[pos];
-		qid[cntq] = id;
-		ql[cntq] = l;
-		qr[cntq] = r;
-		qop[cntq] = op;
-		head[pos] = cntq;
+		query2[++cntq][0] = pos;
+		query2[cntq][1] = id;
+		query2[cntq][2] = l;
+		query2[cntq][3] = r;
+		query2[cntq][4] = op;
 	}
 
 	public static void prepare() {
@@ -73,7 +74,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		Arrays.sort(query, 1, m + 1, new QueryCmp());
+		Arrays.sort(query1, 1, m + 1, new Cmp1());
 		for (int v = 0; v < MAXV; v++) {
 			if (countOne(v) == k) {
 				kOneArr[++cntk] = v;
@@ -88,12 +89,12 @@ public static void compute() {
 				cnt[arr[i] ^ kOneArr[j]]++;
 			}
 		}
-		// 莫队
+		// 第一次离线
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
-			int jobl = query[i][0];
-			int jobr = query[i][1];
-			int id = query[i][2];
+			int jobl = query1[i][0];
+			int jobr = query1[i][1];
+			int id = query1[i][2];
 			if (winr < jobr) {
 				addQuery(winl - 1, id, winr + 1, jobr, -1);
 			}
@@ -121,24 +122,19 @@ public static void compute() {
 		}
 		// 第二次离线
 		Arrays.fill(cnt, 0);
-		for (int i = 1; i <= n; i++) {
-			for (int j = 1; j <= cntk; j++) {
-				cnt[arr[i] ^ kOneArr[j]]++;
+		Arrays.sort(query2, 1, cntq + 1, new Cmp2());
+		for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
+			if (pos >= 1) {
+				for (int j = 1; j <= cntk; j++) {
+					cnt[arr[pos] ^ kOneArr[j]]++;
+				}
 			}
-			for (int q = head[i]; q > 0; q = next[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+			for (; qi <= cntq && query2[qi][0] == pos; qi++) {
+				int id = query2[qi][1], l = query2[qi][2], r = query2[qi][3], op = query2[qi][4];
 				for (int j = l; j <= r; j++) {
-					// 计算j 对 1..i范围的贡献
-					// 此时1..i范围上的数字都更新过cnt
-					if (j <= i && k == 0) {
-						// j在1..i范围上，此时又有k==0
-						// 那么arr[j]一定更新过cnt，并且(arr[j], arr[j])一定算进贡献了
-						// 但是题目要求的二元组必须是不同位置，所以贡献要进行减1修正
+					if (j <= pos && k == 0) {
 						ans[id] += (long) op * (cnt[arr[j]] - 1);
 					} else {
-						// 要么j不在1..i范围上，arr[j]没更新过cnt
-						// 要么k!=0，(arr[j], arr[j])无法被算成贡献
-						// 无论哪种情况，贡献都是正确的，不用进行减1修正
 						ans[id] += (long) op * cnt[arr[j]];
 					}
 				}
@@ -156,14 +152,14 @@ public static void main(String[] args) throws Exception {
 			arr[i] = in.nextInt();
 		}
 		for (int i = 1; i <= m; i++) {
-			query[i][0] = in.nextInt();
-			query[i][1] = in.nextInt();
-			query[i][2] = i;
+			query1[i][0] = in.nextInt();
+			query1[i][1] = in.nextInt();
+			query1[i][2] = i;
 		}
 		prepare();
 		compute();
 		for (int i = 2; i <= m; i++) {
-			ans[query[i][2]] += ans[query[i - 1][2]];
+			ans[query1[i][2]] += ans[query1[i - 1][2]];
 		}
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index de444c9fc..42b42252f 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -9,41 +9,42 @@
 //
 //using namespace std;
 //
-//struct Query {
+//struct Query1 {
 //    int l, r, id;
 //};
 //
+//struct Query2 {
+//    int pos, id, l, r, op;
+//};
+//
 //const int MAXN = 100001;
-//const int MAXQ = 200001;
 //const int MAXV = 1 << 14;
 //int n, m, k;
 //int arr[MAXN];
-//Query query[MAXN];
-//
 //int kOneArr[MAXV];
 //int cntk;
 //
+//Query1 query1[MAXN];
+//Query2 query2[MAXN << 1];
+//int cntq;
+//
 //int bi[MAXN];
 //int pre[MAXN];
 //int cnt[MAXV];
 //
-//int head[MAXN];
-//int nxt[MAXQ];
-//int qid[MAXQ];
-//int ql[MAXQ];
-//int qr[MAXQ];
-//int qop[MAXQ];
-//int cntq;
-//
 //long long ans[MAXN];
 //
-//bool QueryCmp(Query &a, Query &b) {
+//bool Cmp1(Query1 &a, Query1 &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
+//bool Cmp2(Query2 &a, Query2 &b) {
+//    return a.pos < b.pos;
+//}
+//
 //int countOne(int num) {
 //    int ret = 0;
 //    while (num > 0) {
@@ -54,12 +55,11 @@
 //}
 //
 //void addQuery(int pos, int id, int l, int r, int op) {
-//    nxt[++cntq] = head[pos];
-//    qid[cntq] = id;
-//    ql[cntq] = l;
-//    qr[cntq] = r;
-//    qop[cntq] = op;
-//    head[pos] = cntq;
+//    query2[++cntq].pos = pos;
+//    query2[cntq].id = id;
+//    query2[cntq].l = l;
+//    query2[cntq].r = r;
+//    query2[cntq].op = op;
 //}
 //
 //void prepare() {
@@ -67,7 +67,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query + 1, query + m + 1, QueryCmp);
+//    sort(query1 + 1, query1 + m + 1, Cmp1);
 //    for (int v = 0; v < MAXV; v++) {
 //        if (countOne(v) == k) {
 //            kOneArr[++cntk] = v;
@@ -84,9 +84,9 @@
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
-//        int jobl = query[i].l;
-//        int jobr = query[i].r;
-//        int id = query[i].id;
+//        int jobl = query1[i].l;
+//        int jobr = query1[i].r;
+//        int id = query1[i].id;
 //        if (winr < jobr) {
 //            addQuery(winl - 1, id, winr + 1, jobr, -1);
 //        }
@@ -113,14 +113,17 @@
 //        }
 //    }
 //    memset(cnt, 0, sizeof(cnt));
-//    for (int i = 1; i <= n; i++) {
-//        for (int j = 1; j <= cntk; j++) {
-//            cnt[arr[i] ^ kOneArr[j]]++;
+//    sort(query2 + 1, query2 + cntq + 1, Cmp2);
+//    for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
+//        if (pos >= 1) {
+//            for (int j = 1; j <= cntk; j++) {
+//                cnt[arr[pos] ^ kOneArr[j]]++;
+//            }
 //        }
-//        for (int q = head[i]; q > 0; q = nxt[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//        for (; qi <= cntq && query2[qi].pos == pos; qi++) {
+//            int id = query2[qi].id, l = query2[qi].l, r = query2[qi].r, op = query2[qi].op;
 //            for (int j = l; j <= r; j++) {
-//                if (j <= i && k == 0) {
+//                if (j <= pos && k == 0) {
 //                    ans[id] += 1LL * op * (cnt[arr[j]] - 1);
 //                } else {
 //                    ans[id] += 1LL * op * cnt[arr[j]];
@@ -138,13 +141,13 @@
 //        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> query[i].l >> query[i].r;
-//        query[i].id = i;
+//        cin >> query1[i].l >> query1[i].r;
+//        query1[i].id = i;
 //    }
 //    prepare();
 //    compute();
 //    for (int i = 2; i <= m; i++) {
-//        ans[query[i].id] += ans[query[i - 1].id];
+//        ans[query1[i].id] += ans[query1[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';
diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 74fd2bcf2..9abe33ca8 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -17,16 +17,19 @@
 public class Code02_OfflineInversion1 {
 
 	public static int MAXN = 100002;
-	public static int MAXQ = 200001;
 	public static int MAXB = 401;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXN][3];
-
-	// 离散化
 	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
+	// 第一次离线任务，l、r、id
+	// 第二次离线任务，pos、id、l、r、op
+	public static int[][] query1 = new int[MAXN][3];
+	public static int[][] lquery = new int[MAXN][5];
+	public static int[][] rquery = new int[MAXN][5];
+	public static int cntl, cntr;
+
 	// bi用于序列分块、值域分块，bl和br用于值域分块
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
@@ -44,19 +47,9 @@ public class Code02_OfflineInversion1 {
 	// 块的懒信息，整块加了多少词频
 	public static long[] lazy = new long[MAXB];
 
-	// 链式前向星，二次离线的任务列表
-	public static int[] headl = new int[MAXN];
-	public static int[] headr = new int[MAXN];
-	public static int[] next = new int[MAXQ];
-	public static int[] qid = new int[MAXQ];
-	public static int[] ql = new int[MAXQ];
-	public static int[] qr = new int[MAXQ];
-	public static int[] qop = new int[MAXQ];
-	public static int cntq;
-
 	public static long[] ans = new long[MAXN];
 
-	public static class QueryCmp implements Comparator<int[]> {
+	public static class Cmp1 implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
@@ -66,6 +59,13 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
+	public static class Cmp2 implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			return a[0] - b[0];
+		}
+	}
+
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
@@ -105,21 +105,19 @@ public static void clear() {
 	}
 
 	public static void addLeftQuery(int pos, int id, int l, int r, int op) {
-		next[++cntq] = headl[pos];
-		qid[cntq] = id;
-		ql[cntq] = l;
-		qr[cntq] = r;
-		qop[cntq] = op;
-		headl[pos] = cntq;
+		lquery[++cntl][0] = pos;
+		lquery[cntl][1] = id;
+		lquery[cntl][2] = l;
+		lquery[cntl][3] = r;
+		lquery[cntl][4] = op;
 	}
 
 	public static void addRightQuery(int pos, int id, int l, int r, int op) {
-		next[++cntq] = headr[pos];
-		qid[cntq] = id;
-		ql[cntq] = l;
-		qr[cntq] = r;
-		qop[cntq] = op;
-		headr[pos] = cntq;
+		rquery[++cntr][0] = pos;
+		rquery[cntr][1] = id;
+		rquery[cntr][2] = l;
+		rquery[cntr][3] = r;
+		rquery[cntr][4] = op;
 	}
 
 	public static void addLeftCnt(int val) {
@@ -173,7 +171,7 @@ public static void prepare() {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, cntv);
 		}
-		Arrays.sort(query, 1, m + 1, new QueryCmp());
+		Arrays.sort(query1, 1, m + 1, new Cmp1());
 	}
 
 	public static void compute() {
@@ -188,9 +186,9 @@ public static void compute() {
 		}
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
-			int jobl = query[i][0];
-			int jobr = query[i][1];
-			int id = query[i][2];
+			int jobl = query1[i][0];
+			int jobr = query1[i][1];
+			int id = query1[i][2];
 			if (winr < jobr) {
 				addLeftQuery(winl - 1, id, winr + 1, jobr, -1);
 				ans[id] += pre[jobr] - pre[winr];
@@ -210,10 +208,14 @@ public static void compute() {
 			winl = jobl;
 			winr = jobr;
 		}
-		for (int i = 1; i <= n; i++) {
-			addLeftCnt(arr[i] - 1);
-			for (int q = headl[i]; q > 0; q = next[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+		Arrays.sort(lquery, 1, cntl + 1, new Cmp2());
+		Arrays.sort(rquery, 1, cntr + 1, new Cmp2());
+		for (int pos = 0, qi = 1; pos <= n && qi <= cntl; pos++) {
+			if (pos >= 1) {
+				addLeftCnt(arr[pos] - 1);
+			}
+			for (; qi <= cntl && lquery[qi][0] == pos; qi++) {
+				int id = lquery[qi][1], l = lquery[qi][2], r = lquery[qi][3], op = lquery[qi][4];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
@@ -223,10 +225,12 @@ public static void compute() {
 		}
 		Arrays.fill(lazy, 0);
 		Arrays.fill(cnt, 0);
-		for (int i = n; i >= 1; i--) {
-			addRightCnt(arr[i] + 1);
-			for (int q = headr[i]; q > 0; q = next[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+		for (int pos = n + 1, qi = cntr; pos >= 1 && qi >= 1; pos--) {
+			if (pos <= n) {
+				addRightCnt(arr[pos] + 1);
+			}
+			for (; qi >= 1 && rquery[qi][0] == pos; qi--) {
+				int id = rquery[qi][1], l = rquery[qi][2], r = rquery[qi][3], op = rquery[qi][4];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
@@ -245,14 +249,14 @@ public static void main(String[] args) throws Exception {
 			arr[i] = in.nextInt();
 		}
 		for (int i = 1; i <= m; i++) {
-			query[i][0] = in.nextInt();
-			query[i][1] = in.nextInt();
-			query[i][2] = i;
+			query1[i][0] = in.nextInt();
+			query1[i][1] = in.nextInt();
+			query1[i][2] = i;
 		}
 		prepare();
 		compute();
 		for (int i = 2; i <= m; i++) {
-			ans[query[i][2]] += ans[query[i - 1][2]];
+			ans[query1[i][2]] += ans[query1[i - 1][2]];
 		}
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 55e931257..ae0cc735f 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -9,20 +9,26 @@
 //
 //using namespace std;
 //
-//struct Query {
+//struct Query1 {
 //    int l, r, id;
 //};
 //
+//struct Query2 {
+//    int pos, id, l, r, op;
+//};
+//
 //const int MAXN = 100002;
-//const int MAXQ = 200001;
 //const int MAXB = 401;
 //int n, m;
 //int arr[MAXN];
-//Query query[MAXN];
-//
 //int sorted[MAXN];
 //int cntv;
 //
+//Query1 query1[MAXN];
+//Query2 lquery[MAXN];
+//Query2 rquery[MAXN];
+//int cntl, cntr;
+//
 //int bi[MAXN];
 //int bl[MAXB];
 //int br[MAXB];
@@ -34,24 +40,19 @@
 //long long cnt[MAXN];
 //long long lazy[MAXB];
 //
-//int headl[MAXN];
-//int headr[MAXN];
-//int nxt[MAXQ];
-//int qid[MAXQ];
-//int ql[MAXQ];
-//int qr[MAXQ];
-//int qop[MAXQ];
-//int cntq;
-//
 //long long ans[MAXN];
 //
-//bool QueryCmp(Query &a, Query &b) {
+//bool Cmp1(Query1 &a, Query1 &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
+//bool Cmp2(Query2 &a, Query2 &b) {
+//    return a.pos < b.pos;
+//}
+//
 //int kth(int num) {
 //    int left = 1, right = cntv, ret = 0;
 //    while (left <= right) {
@@ -87,25 +88,23 @@
 //}
 //
 //void clear() {
-//    fill(tree + 1, tree + cntv + 1, 0);
+//    memset(tree + 1, 0, cntv * sizeof(int));
 //}
 //
 //void addLeftQuery(int pos, int id, int l, int r, int op) {
-//    nxt[++cntq] = headl[pos];
-//    qid[cntq] = id;
-//    ql[cntq] = l;
-//    qr[cntq] = r;
-//    qop[cntq] = op;
-//    headl[pos] = cntq;
+//    lquery[++cntl].pos = pos;
+//    lquery[cntl].id = id;
+//    lquery[cntl].l = l;
+//    lquery[cntl].r = r;
+//    lquery[cntl].op = op;
 //}
 //
 //void addRightQuery(int pos, int id, int l, int r, int op) {
-//    nxt[++cntq] = headr[pos];
-//    qid[cntq] = id;
-//    ql[cntq] = l;
-//    qr[cntq] = r;
-//    qop[cntq] = op;
-//    headr[pos] = cntq;
+//    rquery[++cntr].pos = pos;
+//    rquery[cntr].id = id;
+//    rquery[cntr].l = l;
+//    rquery[cntr].r = r;
+//    rquery[cntr].op = op;
 //}
 //
 //void addLeftCnt(int val) {
@@ -159,7 +158,7 @@
 //        bl[i] = (i - 1) * blen + 1;
 //        br[i] = min(i * blen, cntv);
 //    }
-//    sort(query + 1, query + m + 1, QueryCmp);
+//    sort(query1 + 1, query1 + m + 1, Cmp1);
 //}
 //
 //void compute() {
@@ -174,9 +173,9 @@
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
-//        int jobl = query[i].l;
-//        int jobr = query[i].r;
-//        int id = query[i].id;
+//        int jobl = query1[i].l;
+//        int jobr = query1[i].r;
+//        int id = query1[i].id;
 //        if (winr < jobr) {
 //            addLeftQuery(winl - 1, id, winr + 1, jobr, -1);
 //            ans[id] += pre[jobr] - pre[winr];
@@ -196,10 +195,14 @@
 //        winl = jobl;
 //        winr = jobr;
 //    }
-//    for (int i = 1; i <= n; i++) {
-//        addLeftCnt(arr[i] - 1);
-//        for (int q = headl[i]; q > 0; q = nxt[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//    sort(lquery + 1, lquery + cntl + 1, Cmp2);
+//    sort(rquery + 1, rquery + cntr + 1, Cmp2);
+//    for (int pos = 0, qi = 1; pos <= n && qi <= cntl; pos++) {
+//        if (pos >= 1) {
+//            addLeftCnt(arr[pos] - 1);
+//        }
+//        for (; qi <= cntl && lquery[qi].pos == pos; qi++) {
+//            int id = lquery[qi].id, l = lquery[qi].l, r = lquery[qi].r, op = lquery[qi].op;
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);
@@ -207,12 +210,14 @@
 //            ans[id] += ret * op;
 //        }
 //    }
-//    memset(cnt,  0, sizeof(cnt));
 //    memset(lazy, 0, sizeof(lazy));
-//    for (int i = n; i >= 1; i--) {
-//        addRightCnt(arr[i] + 1);
-//        for (int q = headr[i]; q > 0; q = nxt[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//    memset(cnt, 0, sizeof(cnt));
+//    for (int pos = n + 1, qi = cntr; pos >= 1 && qi >= 1; pos--) {
+//        if (pos <= n) {
+//            addRightCnt(arr[pos] + 1);
+//        }
+//        for (; qi >= 1 && rquery[qi].pos == pos; qi--) {
+//            int id = rquery[qi].id, l = rquery[qi].l, r = rquery[qi].r, op = rquery[qi].op;
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);
@@ -230,13 +235,13 @@
 //        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> query[i].l >> query[i].r;
-//        query[i].id = i;
+//        cin >> query1[i].l >> query1[i].r;
+//        query1[i].id = i;
 //    }
 //    prepare();
 //    compute();
 //    for (int i = 2; i <= m; i++) {
-//    	ans[query[i].id] += ans[query[i - 1].id];
+//        ans[query1[i].id] += ans[query1[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';

From 85b4a59dc72fd7fcbc7ff5478cd1f2d69d3c9e73 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 7 Sep 2025 19:09:22 +0800
Subject: [PATCH 1361/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java |   2 +-
 src/class178/Code02_OfflineInversion2.java |   2 +-
 src/class178/Code04_Gosick1.java           | 239 +++++++++++++++++++++
 src/class178/Code04_Gosick2.java           | 187 ++++++++++++++++
 4 files changed, 428 insertions(+), 2 deletions(-)
 create mode 100644 src/class178/Code04_Gosick1.java
 create mode 100644 src/class178/Code04_Gosick2.java

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 9abe33ca8..a44825299 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -197,6 +197,7 @@ public static void compute() {
 				addLeftQuery(winl - 1, id, jobr + 1, winr, 1);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
+			winr = jobr;
 			if (winl > jobl) {
 				addRightQuery(jobr + 1, id, jobl, winl - 1, -1);
 				ans[id] += suf[jobl] - suf[winl];
@@ -206,7 +207,6 @@ public static void compute() {
 				ans[id] -= suf[winl] - suf[jobl];
 			}
 			winl = jobl;
-			winr = jobr;
 		}
 		Arrays.sort(lquery, 1, cntl + 1, new Cmp2());
 		Arrays.sort(rquery, 1, cntr + 1, new Cmp2());
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index ae0cc735f..8fc8a34f9 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -184,6 +184,7 @@
 //            addLeftQuery(winl - 1, id, jobr + 1, winr, 1);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
+//        winr = jobr;
 //        if (winl > jobl) {
 //            addRightQuery(jobr + 1, id, jobl, winl - 1, -1);
 //            ans[id] += suf[jobl] - suf[winl];
@@ -193,7 +194,6 @@
 //            ans[id] -= suf[winl] - suf[jobl];
 //        }
 //        winl = jobl;
-//        winr = jobr;
 //    }
 //    sort(lquery + 1, lquery + cntl + 1, Cmp2);
 //    sort(rquery + 1, rquery + cntr + 1, Cmp2);
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
new file mode 100644
index 000000000..55bcb9620
--- /dev/null
+++ b/src/class178/Code04_Gosick1.java
@@ -0,0 +1,239 @@
+package class178;
+
+// 区间查倍数，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5398
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code04_Gosick2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code04_Gosick1 {
+
+	public static int MAXN = 500001;
+	public static int MAXF = 5000001;
+	public static int LIMIT = 80;
+	public static int n, m, maxv;
+	public static int[] arr = new int[MAXN];
+
+	// l、r、id
+	public static int[][] query1 = new int[MAXN][3];
+	// pos、id、l、r、op
+	public static int[][] query2 = new int[MAXN << 1][5];
+	public static int cntq;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXF];
+	public static int[] fac = new int[MAXF];
+	public static int cntf;
+
+	public static int[] bi = new int[MAXN];
+	public static int[] fcnt = new int[MAXN];
+	public static int[] xcnt = new int[MAXN];
+	public static int[] pre = new int[MAXN];
+
+	public static int[] cnt1 = new int[MAXN];
+	public static int[] cnt2 = new int[MAXN];
+
+	public static long[] ans = new long[MAXN];
+
+	// 莫队奇偶排序优化常数时间
+	public static class Cmp1 implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static class Cmp2 implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			return a[0] - b[0];
+		}
+	}
+
+	public static void addFactor(int v, int f) {
+		nxt[++cntf] = head[v];
+		fac[cntf] = f;
+		head[v] = cntf;
+	}
+
+	public static void buildFactors(int x) {
+		if (head[x] > 0) {
+			return;
+		}
+		for (int f = 1, other; f * f <= x; f++) {
+			if (x % f == 0) {
+				addFactor(x, f);
+				other = x / f;
+				if (f != other) {
+					addFactor(x, other);
+				}
+			}
+		}
+	}
+
+	public static void addQuery(int pos, int id, int l, int r, int op) {
+		query2[++cntq][0] = pos;
+		query2[cntq][1] = id;
+		query2[cntq][2] = l;
+		query2[cntq][3] = r;
+		query2[cntq][4] = op;
+	}
+
+	public static void prepare() {
+		int blen = Math.max(n / (int) Math.sqrt(m), 1);
+		for (int i = 1, num; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+			num = arr[i];
+			maxv = Math.max(maxv, num);
+			buildFactors(num);
+			for (int e = head[num], f; e > 0; e = nxt[e]) {
+				f = fac[e];
+				fcnt[f]++;
+				pre[i] += xcnt[f];
+			}
+			pre[i] += pre[i - 1] + fcnt[num];
+			xcnt[num]++;
+		}
+		Arrays.sort(query1, 1, m + 1, new Cmp1());
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query1[i][0];
+			int jobr = query1[i][1];
+			int id = query1[i][2];
+			if (winr < jobr) {
+				ans[id] += pre[jobr] - pre[winr];
+				addQuery(winl - 1, id, winr + 1, jobr, -1);
+			}
+			if (winr > jobr) {
+				ans[id] -= pre[winr] - pre[jobr];
+				addQuery(winl - 1, id, jobr + 1, winr, 1);
+			}
+			winr = jobr;
+			if (winl > jobl) {
+				ans[id] -= pre[winl - 1] - pre[jobl - 1];
+				addQuery(winr, id, jobl, winl - 1, 1);
+			}
+			if (winl < jobl) {
+				ans[id] += pre[jobl - 1] - pre[winl - 1];
+				addQuery(winr, id, winl, jobl - 1, -1);
+			}
+			winl = jobl;
+		}
+		Arrays.sort(query2, 1, cntq + 1, new Cmp2());
+		Arrays.fill(fcnt, 0);
+		for (int i = 1, j = 1; i <= cntq; i++) {
+			int pos = query2[i][0], id = query2[i][1], l = query2[i][2], r = query2[i][3], op = query2[i][4];
+			while (j <= pos) {
+				int x = arr[j++];
+				buildFactors(x);
+				for (int e = head[x], f; e > 0; e = nxt[e]) {
+					f = fac[e];
+					fcnt[f]++;
+				}
+				if (x > LIMIT) {
+					for (int k = x; k <= maxv; k += x) {
+						fcnt[k]++;
+					}
+				}
+			}
+			for (int k = l; k <= r; k++) {
+				ans[id] += (long) op * fcnt[arr[k]];
+			}
+		}
+		for (int i = 1; i <= LIMIT; i++) {
+			cnt1[0] = 0;
+			cnt2[0] = 0;
+			for (int j = 1; j <= n; j++) {
+				cnt1[j] = cnt1[j - 1] + (arr[j] == i ? 1 : 0);
+				cnt2[j] = cnt2[j - 1] + (arr[j] % i == 0 ? 1 : 0);
+			}
+			for (int j = 1; j <= cntq; j++) {
+				int pos = query2[j][0], id = query2[j][1], l = query2[j][2], r = query2[j][3], op = query2[j][4];
+				ans[id] += (long) (cnt2[r] - cnt2[l - 1]) * cnt1[pos] * op;
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query1[i][0] = in.nextInt();
+			query1[i][1] = in.nextInt();
+			query1[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 2; i <= m; i++) {
+			ans[query1[i][2]] += ans[query1[i - 1][2]];
+		}
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
new file mode 100644
index 000000000..d58ee6f75
--- /dev/null
+++ b/src/class178/Code04_Gosick2.java
@@ -0,0 +1,187 @@
+package class178;
+
+// 区间查倍数，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5398
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query1 {
+//    int l, r, id;
+//};
+//
+//struct Query2 {
+//    int pos, id, l, r, op;
+//};
+//
+//const int MAXN = 500001;
+//const int MAXF = 5000001;
+//const int LIMIT = 80;
+//int n, m, maxv;
+//int arr[MAXN];
+//
+//Query1 query1[MAXN];
+//Query2 query2[MAXN << 1];
+//int cntq;
+//
+//int head[MAXN];
+//int nxt[MAXF];
+//int fac[MAXF];
+//int cntf;
+//
+//int bi[MAXN];
+//int fcnt[MAXN];
+//int xcnt[MAXN];
+//int pre[MAXN];
+//
+//int cnt1[MAXN];
+//int cnt2[MAXN];
+//
+//long long ans[MAXN];
+//
+//bool Cmp1(Query1 &a, Query1 &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.l] & 1) {
+//        return a.r < b.r;
+//    } else {
+//        return b.r < a.r;
+//    }
+//}
+//
+//bool Cmp2(Query2 &a, Query2 &b) {
+//    return a.pos < b.pos;
+//}
+//
+//void addFactor(int v, int f) {
+//    nxt[++cntf] = head[v];
+//    fac[cntf] = f;
+//    head[v] = cntf;
+//}
+//
+//void buildFactors(int x) {
+//    if (head[x] > 0) {
+//        return;
+//    }
+//    for (int f = 1; 1LL * f * f <= x; f++) {
+//        if (x % f == 0) {
+//            addFactor(x, f);
+//            int other = x / f;
+//            if (f != other) {
+//                addFactor(x, other);
+//            }
+//        }
+//    }
+//}
+//
+//void addQuery(int pos, int id, int l, int r, int op) {
+//	query2[++cntq].pos = pos;
+//	query2[cntq].id = id;
+//	query2[cntq].l = l;
+//	query2[cntq].r = r;
+//	query2[cntq].op = op;
+//}
+//
+//void prepare() {
+//    int blen = max(n / (int)sqrt((double)m), 1);
+//    for (int i = 1, num; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//        num = arr[i];
+//        maxv = max(maxv, num);
+//        buildFactors(num);
+//        for (int e = head[num], f; e > 0; e = nxt[e]) {
+//            f = fac[e];
+//            fcnt[f]++;
+//            pre[i] += xcnt[f];
+//        }
+//        pre[i] += pre[i - 1] + fcnt[num];
+//        xcnt[num]++;
+//    }
+//    sort(query1 + 1, query1 + m + 1, Cmp1);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query1[i].l;
+//        int jobr = query1[i].r;
+//        int id = query1[i].id;
+//        if (winr < jobr) {
+//            ans[id] += pre[jobr] - pre[winr];
+//            addQuery(winl - 1, id, winr + 1, jobr, -1);
+//        }
+//        if (winr > jobr) {
+//            ans[id] -= pre[winr] - pre[jobr];
+//            addQuery(winl - 1, id, jobr + 1, winr, 1);
+//        }
+//        winr = jobr;
+//        if (winl > jobl) {
+//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
+//            addQuery(winr, id, jobl, winl - 1, 1);
+//        }
+//        if (winl < jobl) {
+//            ans[id] += pre[jobl - 1] - pre[winl - 1];
+//            addQuery(winr, id, winl, jobl - 1, -1);
+//        }
+//        winl = jobl;
+//    }
+//    sort(query2 + 1, query2 + cntq + 1, Cmp2);
+//    memset(fcnt, 0, sizeof(fcnt));
+//    for (int i = 1, j = 1; i <= cntq; i++) {
+//        int pos = query2[i].pos, id = query2[i].id, l = query2[i].l, r = query2[i].r, op = query2[i].op;
+//        while (j <= pos) {
+//            int x = arr[j++];
+//            buildFactors(x);
+//            for (int e = head[x], f; e > 0; e = nxt[e]) {
+//                f = fac[e];
+//                fcnt[f]++;
+//            }
+//            if (x > LIMIT) {
+//                for (int k = x; k <= maxv; k += x) {
+//                    fcnt[k]++;
+//                }
+//            }
+//        }
+//        for (int k = l; k <= r; k++) {
+//            ans[id] += 1LL * op * fcnt[arr[k]];
+//        }
+//    }
+//    for (int i = 1; i <= LIMIT; i++) {
+//        cnt1[0] = 0;
+//        cnt2[0] = 0;
+//        for (int j = 1; j <= n; j++) {
+//            cnt1[j] = cnt1[j - 1] + (arr[j] == i ? 1 : 0);
+//            cnt2[j] = cnt2[j - 1] + (arr[j] % i == 0 ? 1 : 0);
+//        }
+//        for (int j = 1; j <= cntq; j++) {
+//            int pos = query2[j].pos, id = query2[j].id, l = query2[j].l, r = query2[j].r, op = query2[j].op;
+//            ans[id] += 1LL * (cnt2[r] - cnt2[l - 1]) * cnt1[pos] * op;
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query1[i].l >> query1[i].r;
+//        query1[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 2; i <= m; i++) {
+//        ans[query1[i].id] += ans[query1[i - 1].id];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 84de4fc0293102c44fdcfe81c5bddef3f0db1eb9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 8 Sep 2025 19:04:45 +0800
Subject: [PATCH 1362/1712] modify code

---
 src/class178/Code04_Gosick1.java | 143 +++++++++++++------------
 src/class178/Code04_Gosick2.java | 174 ++++++++++++++++++-------------
 2 files changed, 173 insertions(+), 144 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 55bcb9620..74aef4386 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -18,9 +18,16 @@ public class Code04_Gosick1 {
 
 	public static int MAXN = 500001;
 	public static int MAXF = 5000001;
-	public static int LIMIT = 80;
+	public static int LIMIT = 100;
 	public static int n, m, maxv;
 	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	// 每个数的因子表
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXF];
+	public static int[] fac = new int[MAXF];
+	public static int cntf;
 
 	// l、r、id
 	public static int[][] query1 = new int[MAXN][3];
@@ -28,22 +35,16 @@ public class Code04_Gosick1 {
 	public static int[][] query2 = new int[MAXN << 1][5];
 	public static int cntq;
 
-	public static int[] head = new int[MAXN];
-	public static int[] nxt = new int[MAXF];
-	public static int[] fac = new int[MAXF];
-	public static int cntf;
-
-	public static int[] bi = new int[MAXN];
 	public static int[] fcnt = new int[MAXN];
 	public static int[] xcnt = new int[MAXN];
-	public static int[] pre = new int[MAXN];
+	public static long[] pre = new long[MAXN];
 
 	public static int[] cnt1 = new int[MAXN];
 	public static int[] cnt2 = new int[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
-	// 莫队奇偶排序优化常数时间
+	// 莫队奇偶排序，优化一下常数
 	public static class Cmp1 implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
@@ -65,22 +66,13 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
-	public static void addFactor(int v, int f) {
-		nxt[++cntf] = head[v];
-		fac[cntf] = f;
-		head[v] = cntf;
-	}
-
-	public static void buildFactors(int x) {
-		if (head[x] > 0) {
-			return;
-		}
-		for (int f = 1, other; f * f <= x; f++) {
-			if (x % f == 0) {
-				addFactor(x, f);
-				other = x / f;
-				if (f != other) {
-					addFactor(x, other);
+	public static void addFactors(int num) {
+		if (head[num] == 0) {
+			for (int f = 1; f * f <= num; f++) {
+				if (num % f == 0) {
+					nxt[++cntf] = head[num];
+					fac[cntf] = f;
+					head[num] = cntf;
 				}
 			}
 		}
@@ -94,84 +86,97 @@ public static void addQuery(int pos, int id, int l, int r, int op) {
 		query2[cntq][4] = op;
 	}
 
-	public static void prepare() {
-		int blen = Math.max(n / (int) Math.sqrt(m), 1);
-		for (int i = 1, num; i <= n; i++) {
-			bi[i] = (i - 1) / blen + 1;
-			num = arr[i];
-			maxv = Math.max(maxv, num);
-			buildFactors(num);
-			for (int e = head[num], f; e > 0; e = nxt[e]) {
+	public static void compute() {
+		for (int i = 1, x; i <= n; i++) {
+			x = arr[i];
+			for (int e = head[x], f, other; e > 0; e = nxt[e]) {
 				f = fac[e];
+				other = x / f;
 				fcnt[f]++;
 				pre[i] += xcnt[f];
+				if (other != f) {
+					fcnt[other]++;
+					pre[i] += xcnt[other];
+				}
 			}
-			pre[i] += pre[i - 1] + fcnt[num];
-			xcnt[num]++;
+			pre[i] += fcnt[x] + pre[i - 1];
+			xcnt[x]++;
 		}
-		Arrays.sort(query1, 1, m + 1, new Cmp1());
-	}
-
-	public static void compute() {
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
 			int jobl = query1[i][0];
 			int jobr = query1[i][1];
 			int id = query1[i][2];
 			if (winr < jobr) {
-				ans[id] += pre[jobr] - pre[winr];
 				addQuery(winl - 1, id, winr + 1, jobr, -1);
+				ans[id] += pre[jobr] - pre[winr];
+				winr = jobr;
 			}
-			if (winr > jobr) {
-				ans[id] -= pre[winr] - pre[jobr];
-				addQuery(winl - 1, id, jobr + 1, winr, 1);
-			}
-			winr = jobr;
 			if (winl > jobl) {
-				ans[id] -= pre[winl - 1] - pre[jobl - 1];
 				addQuery(winr, id, jobl, winl - 1, 1);
+				ans[id] -= pre[winl - 1] - pre[jobl - 1];
+				winl = jobl;
+			}
+			if (winr > jobr) {
+				addQuery(winl - 1, id, jobr + 1, winr, 1);
+				ans[id] -= pre[winr] - pre[jobr];
+				winr = jobr;
 			}
 			if (winl < jobl) {
-				ans[id] += pre[jobl - 1] - pre[winl - 1];
 				addQuery(winr, id, winl, jobl - 1, -1);
+				ans[id] += pre[jobl - 1] - pre[winl - 1];
+				winl = jobl;
 			}
-			winl = jobl;
 		}
 		Arrays.sort(query2, 1, cntq + 1, new Cmp2());
 		Arrays.fill(fcnt, 0);
-		for (int i = 1, j = 1; i <= cntq; i++) {
-			int pos = query2[i][0], id = query2[i][1], l = query2[i][2], r = query2[i][3], op = query2[i][4];
-			while (j <= pos) {
-				int x = arr[j++];
-				buildFactors(x);
-				for (int e = head[x], f; e > 0; e = nxt[e]) {
+		for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
+			if (pos >= 1) {
+				int num = arr[pos];
+				for (int e = head[num], f, other; e > 0; e = nxt[e]) {
 					f = fac[e];
+					other = num / f;
 					fcnt[f]++;
+					if (other != f) {
+						fcnt[other]++;
+					}
 				}
-				if (x > LIMIT) {
-					for (int k = x; k <= maxv; k += x) {
-						fcnt[k]++;
+				if (num > LIMIT) {
+					for (int v = num; v <= maxv; v += num) {
+						fcnt[v]++;
 					}
 				}
 			}
-			for (int k = l; k <= r; k++) {
-				ans[id] += (long) op * fcnt[arr[k]];
+			for (; qi <= cntq && query2[qi][0] == pos; qi++) {
+				int id = query2[qi][1], l = query2[qi][2], r = query2[qi][3], op = query2[qi][4];
+				for (int i = l; i <= r; i++) {
+					ans[id] += (long) op * fcnt[arr[i]];
+				}
 			}
 		}
-		for (int i = 1; i <= LIMIT; i++) {
-			cnt1[0] = 0;
-			cnt2[0] = 0;
-			for (int j = 1; j <= n; j++) {
-				cnt1[j] = cnt1[j - 1] + (arr[j] == i ? 1 : 0);
-				cnt2[j] = cnt2[j - 1] + (arr[j] % i == 0 ? 1 : 0);
+		for (int v = 1; v <= LIMIT; v++) {
+			cnt1[0] = cnt2[0] = 0;
+			for (int i = 1; i <= n; i++) {
+				cnt1[i] = cnt1[i - 1] + (arr[i] == v ? 1 : 0);
+				cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 			}
-			for (int j = 1; j <= cntq; j++) {
-				int pos = query2[j][0], id = query2[j][1], l = query2[j][2], r = query2[j][3], op = query2[j][4];
-				ans[id] += (long) (cnt2[r] - cnt2[l - 1]) * cnt1[pos] * op;
+			for (int i = 1; i <= cntq; i++) {
+				int pos = query2[i][0], id = query2[i][1], l = query2[i][2], r = query2[i][3], op = query2[i][4];
+				ans[id] += (long) op * cnt1[pos] * (cnt2[r] - cnt2[l - 1]);
 			}
 		}
 	}
 
+	public static void prepare() {
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+			maxv = Math.max(maxv, arr[i]);
+			addFactors(arr[i]);
+		}
+		Arrays.sort(query1, 1, m + 1, new Cmp1());
+	}
+
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -236,4 +241,4 @@ int nextInt() throws IOException {
 		}
 	}
 
-}
+}
\ No newline at end of file
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index d58ee6f75..4f00e259f 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -9,6 +9,25 @@
 //
 //using namespace std;
 //
+//char buf[1000000], *p1 = buf, *p2 = buf;
+//
+//inline char getChar() {
+//    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;
+//}
+//
+//inline int read() {
+//    int s = 0;
+//    char c = getChar();
+//    while (!isdigit(c)) {
+//        c = getChar();
+//    }
+//    while (isdigit(c)) {
+//        s = s * 10 + c - '0';
+//        c = getChar();
+//    }
+//    return s;
+//}
+//
 //struct Query1 {
 //    int l, r, id;
 //};
@@ -19,23 +38,23 @@
 //
 //const int MAXN = 500001;
 //const int MAXF = 5000001;
-//const int LIMIT = 80;
+//const int LIMIT = 100;
 //int n, m, maxv;
 //int arr[MAXN];
-//
-//Query1 query1[MAXN];
-//Query2 query2[MAXN << 1];
-//int cntq;
+//int bi[MAXN];
 //
 //int head[MAXN];
 //int nxt[MAXF];
 //int fac[MAXF];
 //int cntf;
 //
-//int bi[MAXN];
+//Query1 query1[MAXN];
+//Query2 query2[MAXN << 1];
+//int cntq;
+//
 //int fcnt[MAXN];
 //int xcnt[MAXN];
-//int pre[MAXN];
+//long long pre[MAXN];
 //
 //int cnt1[MAXN];
 //int cnt2[MAXN];
@@ -57,122 +76,127 @@
 //    return a.pos < b.pos;
 //}
 //
-//void addFactor(int v, int f) {
-//    nxt[++cntf] = head[v];
-//    fac[cntf] = f;
-//    head[v] = cntf;
-//}
-//
-//void buildFactors(int x) {
-//    if (head[x] > 0) {
-//        return;
-//    }
-//    for (int f = 1; 1LL * f * f <= x; f++) {
-//        if (x % f == 0) {
-//            addFactor(x, f);
-//            int other = x / f;
-//            if (f != other) {
-//                addFactor(x, other);
+//void addFactors(int num) {
+//    if (head[num] == 0) {
+//        for (int f = 1; f * f <= num; f++) {
+//            if (num % f == 0) {
+//                nxt[++cntf] = head[num];
+//                fac[cntf] = f;
+//                head[num] = cntf;
 //            }
 //        }
 //    }
 //}
 //
 //void addQuery(int pos, int id, int l, int r, int op) {
-//	query2[++cntq].pos = pos;
-//	query2[cntq].id = id;
-//	query2[cntq].l = l;
-//	query2[cntq].r = r;
-//	query2[cntq].op = op;
+//    query2[++cntq].pos = pos;
+//    query2[cntq].id = id;
+//    query2[cntq].l = l;
+//    query2[cntq].r = r;
+//    query2[cntq].op = op;
 //}
 //
-//void prepare() {
-//    int blen = max(n / (int)sqrt((double)m), 1);
-//    for (int i = 1, num; i <= n; i++) {
-//        bi[i] = (i - 1) / blen + 1;
-//        num = arr[i];
-//        maxv = max(maxv, num);
-//        buildFactors(num);
-//        for (int e = head[num], f; e > 0; e = nxt[e]) {
+//void compute() {
+//    for (int i = 1, x; i <= n; i++) {
+//        x = arr[i];
+//        for (int e = head[x], f, other; e > 0; e = nxt[e]) {
 //            f = fac[e];
+//            other = x / f;
 //            fcnt[f]++;
 //            pre[i] += xcnt[f];
+//            if (other != f) {
+//                fcnt[other]++;
+//                pre[i] += xcnt[other];
+//            }
 //        }
-//        pre[i] += pre[i - 1] + fcnt[num];
-//        xcnt[num]++;
+//        pre[i] += fcnt[x] + pre[i - 1];
+//        xcnt[x]++;
 //    }
-//    sort(query1 + 1, query1 + m + 1, Cmp1);
-//}
-//
-//void compute() {
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query1[i].l;
 //        int jobr = query1[i].r;
 //        int id = query1[i].id;
 //        if (winr < jobr) {
-//            ans[id] += pre[jobr] - pre[winr];
 //            addQuery(winl - 1, id, winr + 1, jobr, -1);
+//            ans[id] += pre[jobr] - pre[winr];
+//            winr = jobr;
 //        }
-//        if (winr > jobr) {
-//            ans[id] -= pre[winr] - pre[jobr];
-//            addQuery(winl - 1, id, jobr + 1, winr, 1);
-//        }
-//        winr = jobr;
 //        if (winl > jobl) {
-//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
 //            addQuery(winr, id, jobl, winl - 1, 1);
+//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
+//            winl = jobl;
+//        }
+//        if (winr > jobr) {
+//            addQuery(winl - 1, id, jobr + 1, winr, 1);
+//            ans[id] -= pre[winr] - pre[jobr];
+//            winr = jobr;
 //        }
 //        if (winl < jobl) {
-//            ans[id] += pre[jobl - 1] - pre[winl - 1];
 //            addQuery(winr, id, winl, jobl - 1, -1);
+//            ans[id] += pre[jobl - 1] - pre[winl - 1];
+//            winl = jobl;
 //        }
-//        winl = jobl;
 //    }
 //    sort(query2 + 1, query2 + cntq + 1, Cmp2);
 //    memset(fcnt, 0, sizeof(fcnt));
-//    for (int i = 1, j = 1; i <= cntq; i++) {
-//        int pos = query2[i].pos, id = query2[i].id, l = query2[i].l, r = query2[i].r, op = query2[i].op;
-//        while (j <= pos) {
-//            int x = arr[j++];
-//            buildFactors(x);
-//            for (int e = head[x], f; e > 0; e = nxt[e]) {
+//    for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
+//        if (pos >= 1) {
+//            int num = arr[pos];
+//            for (int e = head[num], f, other; e > 0; e = nxt[e]) {
 //                f = fac[e];
+//                other = num / f;
 //                fcnt[f]++;
+//                if (other != f) {
+//                    fcnt[other]++;
+//                }
 //            }
-//            if (x > LIMIT) {
-//                for (int k = x; k <= maxv; k += x) {
-//                    fcnt[k]++;
+//            if (num > LIMIT) {
+//                for (int v = num; v <= maxv; v += num) {
+//                    fcnt[v]++;
 //                }
 //            }
 //        }
-//        for (int k = l; k <= r; k++) {
-//            ans[id] += 1LL * op * fcnt[arr[k]];
+//        for (; qi <= cntq && query2[qi].pos == pos; qi++) {
+//            int id = query2[qi].id, l = query2[qi].l, r = query2[qi].r, op = query2[qi].op;
+//            for (int i = l; i <= r; i++) {
+//                ans[id] += 1LL * op * fcnt[arr[i]];
+//            }
 //        }
 //    }
-//    for (int i = 1; i <= LIMIT; i++) {
+//    for (int v = 1; v <= LIMIT; v++) {
 //        cnt1[0] = 0;
 //        cnt2[0] = 0;
-//        for (int j = 1; j <= n; j++) {
-//            cnt1[j] = cnt1[j - 1] + (arr[j] == i ? 1 : 0);
-//            cnt2[j] = cnt2[j - 1] + (arr[j] % i == 0 ? 1 : 0);
+//        for (int i = 1; i <= n; i++) {
+//            cnt1[i] = cnt1[i - 1] + (arr[i] == v ? 1 : 0);
+//            cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 //        }
-//        for (int j = 1; j <= cntq; j++) {
-//            int pos = query2[j].pos, id = query2[j].id, l = query2[j].l, r = query2[j].r, op = query2[j].op;
-//            ans[id] += 1LL * (cnt2[r] - cnt2[l - 1]) * cnt1[pos] * op;
+//        for (int i = 1; i <= cntq; i++) {
+//            int pos = query2[i].pos, id = query2[i].id, l = query2[i].l, r = query2[i].r, op = query2[i].op;
+//            ans[id] += 1LL * op * cnt1[pos] * (cnt2[r] - cnt2[l - 1]);
 //        }
 //    }
 //}
 //
+//void prepare() {
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//        maxv = max(maxv, arr[i]);
+//        addFactors(arr[i]);
+//    }
+//    sort(query1 + 1, query1 + m + 1, Cmp1);
+//}
+//
 //int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n >> m;
+//    n = read();
+//    m = read();
 //    for (int i = 1; i <= n; i++) {
-//        cin >> arr[i];
+//        arr[i] = read();
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> query1[i].l >> query1[i].r;
+//        query1[i].l = read();
+//        query1[i].r = read();
 //        query1[i].id = i;
 //    }
 //    prepare();
@@ -181,7 +205,7 @@
 //        ans[query1[i].id] += ans[query1[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cout << ans[i] << '\n';
+//        printf("%lld\n", ans[i]);
 //    }
 //    return 0;
 //}
\ No newline at end of file

From 6617ae98b3c669d0e6bc7b18fb5df1bea25c8803 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 8 Sep 2025 19:20:48 +0800
Subject: [PATCH 1363/1712] modify code

---
 src/class178/Code04_Gosick1.java | 18 ++++++++----------
 src/class178/Code04_Gosick2.java | 16 +++++++---------
 2 files changed, 15 insertions(+), 19 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 74aef4386..82ea519a7 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -18,7 +18,7 @@ public class Code04_Gosick1 {
 
 	public static int MAXN = 500001;
 	public static int MAXF = 5000001;
-	public static int LIMIT = 100;
+	public static int LIMIT = 80;
 	public static int n, m, maxv;
 	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
@@ -44,7 +44,7 @@ public class Code04_Gosick1 {
 
 	public static long[] ans = new long[MAXN];
 
-	// 莫队奇偶排序，优化一下常数
+	// 莫队奇偶排序，优化常数时间
 	public static class Cmp1 implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
@@ -110,23 +110,21 @@ public static void compute() {
 			if (winr < jobr) {
 				addQuery(winl - 1, id, winr + 1, jobr, -1);
 				ans[id] += pre[jobr] - pre[winr];
-				winr = jobr;
-			}
-			if (winl > jobl) {
-				addQuery(winr, id, jobl, winl - 1, 1);
-				ans[id] -= pre[winl - 1] - pre[jobl - 1];
-				winl = jobl;
 			}
 			if (winr > jobr) {
 				addQuery(winl - 1, id, jobr + 1, winr, 1);
 				ans[id] -= pre[winr] - pre[jobr];
-				winr = jobr;
+			}
+			winr = jobr;
+			if (winl > jobl) {
+				addQuery(winr, id, jobl, winl - 1, 1);
+				ans[id] -= pre[winl - 1] - pre[jobl - 1];
 			}
 			if (winl < jobl) {
 				addQuery(winr, id, winl, jobl - 1, -1);
 				ans[id] += pre[jobl - 1] - pre[winl - 1];
-				winl = jobl;
 			}
+			winl = jobl;
 		}
 		Arrays.sort(query2, 1, cntq + 1, new Cmp2());
 		Arrays.fill(fcnt, 0);
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 4f00e259f..5e74e696c 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -38,7 +38,7 @@
 //
 //const int MAXN = 500001;
 //const int MAXF = 5000001;
-//const int LIMIT = 100;
+//const int LIMIT = 80;
 //int n, m, maxv;
 //int arr[MAXN];
 //int bi[MAXN];
@@ -120,23 +120,21 @@
 //        if (winr < jobr) {
 //            addQuery(winl - 1, id, winr + 1, jobr, -1);
 //            ans[id] += pre[jobr] - pre[winr];
-//            winr = jobr;
-//        }
-//        if (winl > jobl) {
-//            addQuery(winr, id, jobl, winl - 1, 1);
-//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
-//            winl = jobl;
 //        }
 //        if (winr > jobr) {
 //            addQuery(winl - 1, id, jobr + 1, winr, 1);
 //            ans[id] -= pre[winr] - pre[jobr];
-//            winr = jobr;
+//        }
+//        winr = jobr;
+//        if (winl > jobl) {
+//            addQuery(winr, id, jobl, winl - 1, 1);
+//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
 //        }
 //        if (winl < jobl) {
 //            addQuery(winr, id, winl, jobl - 1, -1);
 //            ans[id] += pre[jobl - 1] - pre[winl - 1];
-//            winl = jobl;
 //        }
+//        winl = jobl;
 //    }
 //    sort(query2 + 1, query2 + cntq + 1, Cmp2);
 //    memset(fcnt, 0, sizeof(fcnt));

From edf09a9c8494faa4983b74e1ff1e4827f810574f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 8 Sep 2025 19:24:04 +0800
Subject: [PATCH 1364/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 4 ++--
 src/class178/Code02_OfflineInversion2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index a44825299..7007eb958 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -199,11 +199,11 @@ public static void compute() {
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addRightQuery(jobr + 1, id, jobl, winl - 1, -1);
+				addRightQuery(winr + 1, id, jobl, winl - 1, -1);
 				ans[id] += suf[jobl] - suf[winl];
 			}
 			if (winl < jobl) {
-				addRightQuery(jobr + 1, id, winl, jobl - 1, 1);
+				addRightQuery(winr + 1, id, winl, jobl - 1, 1);
 				ans[id] -= suf[winl] - suf[jobl];
 			}
 			winl = jobl;
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 8fc8a34f9..bf71b4ff7 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -186,11 +186,11 @@
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addRightQuery(jobr + 1, id, jobl, winl - 1, -1);
+//            addRightQuery(winr + 1, id, jobl, winl - 1, -1);
 //            ans[id] += suf[jobl] - suf[winl];
 //        }
 //        if (winl < jobl) {
-//            addRightQuery(jobr + 1, id, winl, jobl - 1, 1);
+//            addRightQuery(winr + 1, id, winl, jobl - 1, 1);
 //            ans[id] -= suf[winl] - suf[jobl];
 //        }
 //        winl = jobl;

From 57305736daba3cbd47dce63b55cfb1b21dd5eb29 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 8 Sep 2025 22:22:21 +0800
Subject: [PATCH 1365/1712] modify code

---
 src/class178/Code04_Gosick1.java |  7 +-----
 src/class178/Code04_Gosick2.java | 37 ++++++--------------------------
 2 files changed, 8 insertions(+), 36 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 82ea519a7..7be189708 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -44,18 +44,13 @@ public class Code04_Gosick1 {
 
 	public static long[] ans = new long[MAXN];
 
-	// 莫队奇偶排序，优化常数时间
 	public static class Cmp1 implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
 				return bi[a[0]] - bi[b[0]];
 			}
-			if ((bi[a[0]] & 1) == 1) {
-				return a[1] - b[1];
-			} else {
-				return b[1] - a[1];
-			}
+			return a[1] - b[1];
 		}
 	}
 
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 5e74e696c..96bd5e00b 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -9,25 +9,6 @@
 //
 //using namespace std;
 //
-//char buf[1000000], *p1 = buf, *p2 = buf;
-//
-//inline char getChar() {
-//    return p1 == p2 && (p2 = (p1 = buf) + fread(buf, 1, 1000000, stdin), p1 == p2) ? EOF : *p1++;
-//}
-//
-//inline int read() {
-//    int s = 0;
-//    char c = getChar();
-//    while (!isdigit(c)) {
-//        c = getChar();
-//    }
-//    while (isdigit(c)) {
-//        s = s * 10 + c - '0';
-//        c = getChar();
-//    }
-//    return s;
-//}
-//
 //struct Query1 {
 //    int l, r, id;
 //};
@@ -65,11 +46,7 @@
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
-//    if (bi[a.l] & 1) {
-//        return a.r < b.r;
-//    } else {
-//        return b.r < a.r;
-//    }
+//    return a.r < b.r;
 //}
 //
 //bool Cmp2(Query2 &a, Query2 &b) {
@@ -187,14 +164,14 @@
 //}
 //
 //int main() {
-//    n = read();
-//    m = read();
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
 //    for (int i = 1; i <= n; i++) {
-//        arr[i] = read();
+//        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        query1[i].l = read();
-//        query1[i].r = read();
+//        cin >> query1[i].l >> query1[i].r;
 //        query1[i].id = i;
 //    }
 //    prepare();
@@ -203,7 +180,7 @@
 //        ans[query1[i].id] += ans[query1[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        printf("%lld\n", ans[i]);
+//        cout << ans[i] << '\n';
 //    }
 //    return 0;
 //}
\ No newline at end of file

From 671fde8e94126ecdb545ecebdcdf2e91b4d02fe9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 8 Sep 2025 22:34:30 +0800
Subject: [PATCH 1366/1712] modify code

---
 src/class164/Code02_Training1.java | 2 +-
 src/class164/Code02_Training2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class164/Code02_Training1.java b/src/class164/Code02_Training1.java
index 9a1c8febc..fee7238d8 100644
--- a/src/class164/Code02_Training1.java
+++ b/src/class164/Code02_Training1.java
@@ -4,7 +4,7 @@
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
 // 一开始limit = 0，接下来有q条操作，每种操作的格式如下
 // 操作 1 x   : 所有修改操作生效，然后limit设置成x
-// 操作 2 x   : 从点x出发，只能走过 边权 < limit 的边，查询最多到达几个点
+// 操作 2 x   : 从点x出发，只能走 边权 >= limit 的边，查询最多到达几个点
 // 操作 3 x y : 第x条边的边权修改为y，不是立刻生效，等到下次操作1发生时生效
 // 题目保证边权不管如何修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5
diff --git a/src/class164/Code02_Training2.java b/src/class164/Code02_Training2.java
index 7e8636dc9..49953549e 100644
--- a/src/class164/Code02_Training2.java
+++ b/src/class164/Code02_Training2.java
@@ -4,7 +4,7 @@
 // 图里有n个点，m条无向边，每条边给定不同的边权，图里可能有若干个连通的部分
 // 一开始limit = 0，接下来有q条操作，每种操作的格式如下
 // 操作 1 x   : 所有修改操作生效，然后limit设置成x
-// 操作 2 x   : 从点x出发，只能走过 边权 < limit 的边，查询最多到达几个点
+// 操作 2 x   : 从点x出发，只能走 边权 >= limit 的边，查询最多到达几个点
 // 操作 3 x y : 第x条边的边权修改为y，不是立刻生效，等到下次操作1发生时生效
 // 题目保证边权不管如何修改，所有边权都不相等，并且每条边的边权排名不发生变化
 // 1 <= n、m、q <= 4 * 10^5

From 9ad3cfe4ed541408dc4732711b7682c4c1efeac7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 8 Sep 2025 23:50:07 +0800
Subject: [PATCH 1367/1712] modify code

---
 src/class164/Code04_Journey1.java | 11 ++++++-----
 src/class164/Code04_Journey2.java | 11 ++++++-----
 2 files changed, 12 insertions(+), 10 deletions(-)

diff --git a/src/class164/Code04_Journey1.java b/src/class164/Code04_Journey1.java
index 9621d5bdc..98327c090 100644
--- a/src/class164/Code04_Journey1.java
+++ b/src/class164/Code04_Journey1.java
@@ -1,11 +1,12 @@
 package class164;
 
 // 归程，java版
-// 图里有n个点，m条无向边，每条边给定长度l和海拔a，所有点都连通
-// 一共有q条查询，查询格式如下
-// 查询 x y : 海拔 > y的边，走过没有代价
-//            海拔 <= y的边，走过的代价为边的长度
-//            从点x出发到达1号点，打印最小的代价
+// 一共有n个点，m条无向边，原图连通，每条边有长度l和海拔a
+// 一共有q条查询，格式如下
+// 查询 x y : 起初走过海拔 > y的边免费，可视为开车，但是车不能走海拔 <= y的边
+//            你可以在任意节点下车，车不能再用
+//            下车后经过每条边的长度(包括海拔 > y 的边)，都算入步行长度
+//            你想从点x到1号点，打印最小步行长度
 // 1 <= n <= 2 * 10^5
 // 1 <= m、q <= 4 * 10^5
 // 本题要求强制在线，具体规定请打开测试链接查看
diff --git a/src/class164/Code04_Journey2.java b/src/class164/Code04_Journey2.java
index e91df1ecd..b661868eb 100644
--- a/src/class164/Code04_Journey2.java
+++ b/src/class164/Code04_Journey2.java
@@ -1,11 +1,12 @@
 package class164;
 
 // 归程，C++版
-// 图里有n个点，m条无向边，每条边给定长度l和海拔a，所有点都连通
-// 一共有q条查询，查询格式如下
-// 查询 x y : 海拔 > y的边，走过没有代价
-//            海拔 <= y的边，走过的代价为边的长度
-//            从点x出发到达1号点，打印最小的代价
+// 一共有n个点，m条无向边，原图连通，每条边有长度l和海拔a
+// 一共有q条查询，格式如下
+// 查询 x y : 起初走过海拔 > y的边免费，可视为开车，但是车不能走海拔 <= y的边
+//            你可以在任意节点下车，车不能再用
+//            下车后经过每条边的长度(包括海拔 > y 的边)，都算入步行长度
+//            你想从点x到1号点，打印最小步行长度
 // 1 <= n <= 2 * 10^5
 // 1 <= m、q <= 4 * 10^5
 // 本题要求强制在线，具体规定请打开测试链接查看

From a163766e04d87728f1ee6780304cb2b0ad117dc4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 9 Sep 2025 00:31:45 +0800
Subject: [PATCH 1368/1712] modify code

---
 ...\345\205\263\351\242\230\347\233\256.pptx" | Bin 54204 -> 54285 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243164\343\200\220\346\214\272\351\232\276\343\200\221Kruskal\351\207\215\346\236\204\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
index 656af71ca9d046493096e90d84196503c661afeb..ec51dfcce1b1de2bbfb628952bf228d75dad3849 100644
GIT binary patch
delta 5000
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
DaDBgl

delta 4991
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
Kz<bqrlK3B%kMO$y


From b7d35edf20604f33571155f17ad64d75460564df Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 9 Sep 2025 17:04:11 +0800
Subject: [PATCH 1369/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java |  74 +++----
 src/class178/Code01_MoOfflineTwice2.java |  70 ++++---
 src/class178/Code03_Abbi1.java           | 247 +++++++++++++++++++++++
 src/class178/Code03_Abbi2.java           | 202 ++++++++++++++++++
 4 files changed, 520 insertions(+), 73 deletions(-)
 create mode 100644 src/class178/Code03_Abbi1.java
 create mode 100644 src/class178/Code03_Abbi2.java

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 87190723c..fc2560b30 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -23,10 +23,18 @@ public class Code01_MoOfflineTwice1 {
 	public static int[] kOneArr = new int[MAXV];
 	public static int cntk;
 
-	// 第一次离线任务，l、r、id
+	// 莫队任务，l、r、id
 	// 第二次离线任务，pos、id、l、r、op
-	public static int[][] query1 = new int[MAXN][3];
-	public static int[][] query2 = new int[MAXN << 1][5];
+	public static int[][] query = new int[MAXN][3];
+
+	// 第二次离线任务，x、id、l、r、op
+	// 位置x的任务列表用链式前向星表示
+	public static int[] headq = new int[MAXN];
+	public static int[] nextq = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
+	public static int[] ql = new int[MAXN << 1];
+	public static int[] qr = new int[MAXN << 1];
+	public static int[] qop = new int[MAXN << 1];
 	public static int cntq;
 
 	public static int[] bi = new int[MAXN];
@@ -35,7 +43,7 @@ public class Code01_MoOfflineTwice1 {
 
 	public static long[] ans = new long[MAXN];
 
-	public static class Cmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
@@ -45,13 +53,6 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
-	public static class Cmp2 implements Comparator<int[]> {
-		@Override
-		public int compare(int[] a, int[] b) {
-			return a[0] - b[0];
-		}
-	}
-
 	public static int countOne(int num) {
 		int ret = 0;
 		while (num > 0) {
@@ -61,12 +62,13 @@ public static int countOne(int num) {
 		return ret;
 	}
 
-	public static void addQuery(int pos, int id, int l, int r, int op) {
-		query2[++cntq][0] = pos;
-		query2[cntq][1] = id;
-		query2[cntq][2] = l;
-		query2[cntq][3] = r;
-		query2[cntq][4] = op;
+	public static void addOffline(int x, int id, int l, int r, int op) {
+		nextq[++cntq] = headq[x];
+		headq[x] = cntq;
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
 	}
 
 	public static void prepare() {
@@ -74,7 +76,7 @@ public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		Arrays.sort(query1, 1, m + 1, new Cmp1());
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
 		for (int v = 0; v < MAXV; v++) {
 			if (countOne(v) == k) {
 				kOneArr[++cntk] = v;
@@ -89,32 +91,31 @@ public static void compute() {
 				cnt[arr[i] ^ kOneArr[j]]++;
 			}
 		}
-		// 第一次离线
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
-			int jobl = query1[i][0];
-			int jobr = query1[i][1];
-			int id = query1[i][2];
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
 			if (winr < jobr) {
-				addQuery(winl - 1, id, winr + 1, jobr, -1);
+				addOffline(winl - 1, id, winr + 1, jobr, -1);
 			}
 			while (winr < jobr) {
 				ans[id] += pre[++winr];
 			}
 			if (winr > jobr) {
-				addQuery(winl - 1, id, jobr + 1, winr, 1);
+				addOffline(winl - 1, id, jobr + 1, winr, 1);
 			}
 			while (winr > jobr) {
 				ans[id] -= pre[winr--];
 			}
 			if (winl > jobl) {
-				addQuery(winr, id, jobl, winl - 1, 1);
+				addOffline(winr, id, jobl, winl - 1, 1);
 			}
 			while (winl > jobl) {
 				ans[id] -= pre[--winl];
 			}
 			if (winl < jobl) {
-				addQuery(winr, id, winl, jobl - 1, -1);
+				addOffline(winr, id, winl, jobl - 1, -1);
 			}
 			while (winl < jobl) {
 				ans[id] += pre[winl++];
@@ -122,17 +123,16 @@ public static void compute() {
 		}
 		// 第二次离线
 		Arrays.fill(cnt, 0);
-		Arrays.sort(query2, 1, cntq + 1, new Cmp2());
-		for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
-			if (pos >= 1) {
+		for (int i = 0; i <= n; i++) {
+			if (i >= 1) {
 				for (int j = 1; j <= cntk; j++) {
-					cnt[arr[pos] ^ kOneArr[j]]++;
+					cnt[arr[i] ^ kOneArr[j]]++;
 				}
 			}
-			for (; qi <= cntq && query2[qi][0] == pos; qi++) {
-				int id = query2[qi][1], l = query2[qi][2], r = query2[qi][3], op = query2[qi][4];
+			for (int q = headq[i]; q > 0; q = nextq[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 				for (int j = l; j <= r; j++) {
-					if (j <= pos && k == 0) {
+					if (j <= i && k == 0) {
 						ans[id] += (long) op * (cnt[arr[j]] - 1);
 					} else {
 						ans[id] += (long) op * cnt[arr[j]];
@@ -152,14 +152,14 @@ public static void main(String[] args) throws Exception {
 			arr[i] = in.nextInt();
 		}
 		for (int i = 1; i <= m; i++) {
-			query1[i][0] = in.nextInt();
-			query1[i][1] = in.nextInt();
-			query1[i][2] = i;
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
 		}
 		prepare();
 		compute();
 		for (int i = 2; i <= m; i++) {
-			ans[query1[i][2]] += ans[query1[i - 1][2]];
+			ans[query[i][2]] += ans[query[i - 1][2]];
 		}
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index 42b42252f..5e73aeaff 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -9,14 +9,10 @@
 //
 //using namespace std;
 //
-//struct Query1 {
+//struct Query {
 //    int l, r, id;
 //};
 //
-//struct Query2 {
-//    int pos, id, l, r, op;
-//};
-//
 //const int MAXN = 100001;
 //const int MAXV = 1 << 14;
 //int n, m, k;
@@ -24,8 +20,14 @@
 //int kOneArr[MAXV];
 //int cntk;
 //
-//Query1 query1[MAXN];
-//Query2 query2[MAXN << 1];
+//Query query[MAXN];
+//
+//int headq[MAXN];
+//int nextq[MAXN << 1];
+//int qid[MAXN << 1];
+//int ql[MAXN << 1];
+//int qr[MAXN << 1];
+//int qop[MAXN << 1];
 //int cntq;
 //
 //int bi[MAXN];
@@ -34,17 +36,13 @@
 //
 //long long ans[MAXN];
 //
-//bool Cmp1(Query1 &a, Query1 &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
-//bool Cmp2(Query2 &a, Query2 &b) {
-//    return a.pos < b.pos;
-//}
-//
 //int countOne(int num) {
 //    int ret = 0;
 //    while (num > 0) {
@@ -54,12 +52,13 @@
 //    return ret;
 //}
 //
-//void addQuery(int pos, int id, int l, int r, int op) {
-//    query2[++cntq].pos = pos;
-//    query2[cntq].id = id;
-//    query2[cntq].l = l;
-//    query2[cntq].r = r;
-//    query2[cntq].op = op;
+//void addOffline(int x, int id, int l, int r, int op) {
+//    nextq[++cntq] = headq[x];
+//    headq[x] = cntq;
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
 //}
 //
 //void prepare() {
@@ -67,7 +66,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(query1 + 1, query1 + m + 1, Cmp1);
+//    sort(query + 1, query + m + 1, QueryCmp);
 //    for (int v = 0; v < MAXV; v++) {
 //        if (countOne(v) == k) {
 //            kOneArr[++cntk] = v;
@@ -84,46 +83,45 @@
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
-//        int jobl = query1[i].l;
-//        int jobr = query1[i].r;
-//        int id = query1[i].id;
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
 //        if (winr < jobr) {
-//            addQuery(winl - 1, id, winr + 1, jobr, -1);
+//            addOffline(winl - 1, id, winr + 1, jobr, -1);
 //        }
 //        while (winr < jobr) {
 //            ans[id] += pre[++winr];
 //        }
 //        if (winr > jobr) {
-//            addQuery(winl - 1, id, jobr + 1, winr, 1);
+//            addOffline(winl - 1, id, jobr + 1, winr, 1);
 //        }
 //        while (winr > jobr) {
 //            ans[id] -= pre[winr--];
 //        }
 //        if (winl > jobl) {
-//            addQuery(winr, id, jobl, winl - 1, 1);
+//            addOffline(winr, id, jobl, winl - 1, 1);
 //        }
 //        while (winl > jobl) {
 //            ans[id] -= pre[--winl];
 //        }
 //        if (winl < jobl) {
-//            addQuery(winr, id, winl, jobl - 1, -1);
+//            addOffline(winr, id, winl, jobl - 1, -1);
 //        }
 //        while (winl < jobl) {
 //            ans[id] += pre[winl++];
 //        }
 //    }
 //    memset(cnt, 0, sizeof(cnt));
-//    sort(query2 + 1, query2 + cntq + 1, Cmp2);
-//    for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
-//        if (pos >= 1) {
+//    for (int i = 0; i <= n; i++) {
+//        if (i >= 1) {
 //            for (int j = 1; j <= cntk; j++) {
-//                cnt[arr[pos] ^ kOneArr[j]]++;
+//                cnt[arr[i] ^ kOneArr[j]]++;
 //            }
 //        }
-//        for (; qi <= cntq && query2[qi].pos == pos; qi++) {
-//            int id = query2[qi].id, l = query2[qi].l, r = query2[qi].r, op = query2[qi].op;
+//        for (int q = headq[i]; q > 0; q = nextq[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 //            for (int j = l; j <= r; j++) {
-//                if (j <= pos && k == 0) {
+//                if (j <= i && k == 0) {
 //                    ans[id] += 1LL * op * (cnt[arr[j]] - 1);
 //                } else {
 //                    ans[id] += 1LL * op * cnt[arr[j]];
@@ -141,13 +139,13 @@
 //        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> query1[i].l >> query1[i].r;
-//        query1[i].id = i;
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
 //    }
 //    prepare();
 //    compute();
 //    for (int i = 2; i <= m; i++) {
-//        ans[query1[i].id] += ans[query1[i - 1].id];
+//        ans[query[i].id] += ans[query[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';
diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
new file mode 100644
index 000000000..4fb358e65
--- /dev/null
+++ b/src/class178/Code03_Abbi1.java
@@ -0,0 +1,247 @@
+package class178;
+
+// 区间查询Abbi值，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5501
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code03_Abbi1 {
+
+	public static int MAXN = 500001;
+	public static int MAXV = 100000;
+	public static int MAXB = 401;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static long[] presum = new long[MAXN];
+	public static int[] bi = new int[MAXN];
+	public static int[] br = new int[MAXB];
+
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] headq = new int[MAXN];
+	public static int[] nextq = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
+	public static int[] ql = new int[MAXN << 1];
+	public static int[] qr = new int[MAXN << 1];
+	public static int[] qop = new int[MAXN << 1];
+	public static int cntq;
+
+	public static long[] treeCnt = new long[MAXV + 1];
+	public static long[] treeSum = new long[MAXV + 1];
+
+	public static long[] pre = new long[MAXN];
+	public static int[] cnt1 = new int[MAXB];
+	public static int[] cnt2 = new int[MAXN];
+	public static long[] sum1 = new long[MAXB];
+	public static long[] sum2 = new long[MAXN];
+
+	public static long[] ans = new long[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			return a[1] - b[1];
+		}
+	}
+
+	public static void addOffline(int x, int id, int l, int r, int op) {
+		nextq[++cntq] = headq[x];
+		headq[x] = cntq;
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
+	}
+
+	public static int lowbit(int x) {
+		return x & -x;
+	}
+
+	public static void add(long[] tree, int x, int v) {
+		while (x <= MAXV) {
+			tree[x] += v;
+			x += lowbit(x);
+		}
+	}
+
+	public static long sum(long[] tree, int x) {
+		long ret = 0;
+		while (x > 0) {
+			ret += tree[x];
+			x -= lowbit(x);
+		}
+		return ret;
+	}
+
+	public static void addVal(int val) {
+		if (val <= 0) {
+			return;
+		}
+		for (int b = bi[val]; b <= bi[MAXV]; b++) {
+			cnt1[b]++;
+			sum1[b] += val;
+		}
+		for (int i = val; i <= br[bi[val]]; i++) {
+			cnt2[i]++;
+			sum2[i] += val;
+		}
+	}
+
+	public static long getSum(int x) {
+		if (x <= 0) {
+			return 0;
+		}
+		return sum1[bi[x] - 1] + sum2[x];
+	}
+
+	public static int getCnt(int x) {
+		if (x <= 0) {
+			return 0;
+		}
+		return cnt1[bi[x] - 1] + cnt2[x];
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			presum[i] = presum[i - 1] + arr[i];
+		}
+		int blen = (int) Math.sqrt(MAXV);
+		int bnum = (MAXV + blen - 1) / blen;
+		for (int i = 1; i <= MAXV; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int b = 1; b <= bnum; b++) {
+			br[b] = Math.min(b * blen, MAXV);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= n; i++) {
+			pre[i] = pre[i - 1] + sum(treeCnt, arr[i] - 1) * arr[i] + sum(treeSum, MAXV) - sum(treeSum, arr[i]);
+			add(treeCnt, arr[i], 1);
+			add(treeSum, arr[i], arr[i]);
+		}
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			if (winr < jobr) {
+				addOffline(winl - 1, id, winr + 1, jobr, -1);
+				ans[id] += pre[jobr] - pre[winr];
+			}
+			if (winr > jobr) {
+				addOffline(winl - 1, id, jobr + 1, winr, 1);
+				ans[id] -= pre[winr] - pre[jobr];
+			}
+			winr = jobr;
+			if (winl > jobl) {
+				addOffline(winr, id, jobl, winl - 1, 1);
+				ans[id] -= pre[winl - 1] - pre[jobl - 1];
+
+			}
+			if (winl < jobl) {
+				addOffline(winr, id, winl, jobl - 1, -1);
+				ans[id] += pre[jobl - 1] - pre[winl - 1];
+			}
+			winl = jobl;
+		}
+		long sum = 0;
+		long tmp;
+		for (int i = 0; i <= n; i++) {
+			if (i >= 1) {
+				addVal(arr[i]);
+				sum += arr[i];
+			}
+			for (int q = headq[i]; q > 0; q = nextq[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				for (int j = l; j <= r; j++) {
+					tmp = (long) getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
+					if (op == 1) {
+						ans[id] += tmp;
+					} else {
+						ans[id] -= tmp;
+					}
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 2; i <= m; i++) {
+			ans[query[i][2]] += ans[query[i - 1][2]];
+		}
+		for (int i = 1; i <= m; i++) {
+			ans[query[i][2]] += presum[query[i][1]] - presum[query[i][0] - 1];
+		}
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
new file mode 100644
index 000000000..6c3b008f2
--- /dev/null
+++ b/src/class178/Code03_Abbi2.java
@@ -0,0 +1,202 @@
+package class178;
+
+// 区间查询Abbi值，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5501
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 500001;
+//const int MAXV = 100000;
+//const int MAXB = 401;
+//
+//int n, m;
+//int arr[MAXN];
+//long long presum[MAXN];
+//int bi[MAXN];
+//int br[MAXB];
+//
+//Query query[MAXN];
+//
+//int headq[MAXN];
+//int nextq[MAXN << 1];
+//int qid[MAXN << 1];
+//int ql[MAXN << 1];
+//int qr[MAXN << 1];
+//int qop[MAXN << 1];
+//int cntq;
+//
+//long long treeCnt[MAXV + 1];
+//long long treeSum[MAXV + 1];
+//
+//long long pre[MAXN];
+//int cnt1[MAXB];
+//int cnt2[MAXN];
+//long long sum1[MAXB];
+//long long sum2[MAXN];
+//
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    return a.r < b.r;
+//}
+//
+//void addOffline(int x, int id, int l, int r, int op) {
+//    nextq[++cntq] = headq[x];
+//    headq[x] = cntq;
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
+//}
+//
+//int lowbit(int x) {
+//    return x & -x;
+//}
+//
+//void bitAdd(long long *tree, int x, long long v) {
+//    while (x <= MAXV) {
+//        tree[x] += v;
+//        x += lowbit(x);
+//    }
+//}
+//
+//long long bitSum(long long *tree, int x) {
+//    long long ret = 0;
+//    while (x > 0) {
+//        ret += tree[x];
+//        x -= lowbit(x);
+//    }
+//    return ret;
+//}
+//
+//void addVal(int val) {
+//    if (val <= 0) {
+//        return;
+//    }
+//    for (int b = bi[val]; b <= bi[MAXV]; b++) {
+//        cnt1[b]++;
+//        sum1[b] += val;
+//    }
+//    for (int i = val; i <= br[bi[val]]; i++) {
+//        cnt2[i]++;
+//        sum2[i] += val;
+//    }
+//}
+//
+//long long getSum(int x) {
+//    if (x <= 0) {
+//        return 0;
+//    }
+//    return sum1[bi[x] - 1] + sum2[x];
+//}
+//
+//int getCnt(int x) {
+//    if (x <= 0) {
+//        return 0;
+//    }
+//    return cnt1[bi[x] - 1] + cnt2[x];
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        presum[i] = presum[i - 1] + arr[i];
+//    }
+//    int blen = (int)std::sqrt(MAXV);
+//    int bnum = (MAXV + blen - 1) / blen;
+//    for (int i = 1; i <= MAXV; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int b = 1; b <= bnum; b++) {
+//        br[b] = min(b * blen, MAXV);
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= n; i++) {
+//        pre[i] = pre[i - 1]
+//               + bitSum(treeCnt, arr[i] - 1) * arr[i]
+//               + bitSum(treeSum, MAXV) - bitSum(treeSum, arr[i]);
+//        bitAdd(treeCnt, arr[i], 1);
+//        bitAdd(treeSum, arr[i], arr[i]);
+//    }
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
+//        if (winr < jobr) {
+//            addOffline(winl - 1, id, winr + 1, jobr, -1);
+//            ans[id] += pre[jobr] - pre[winr];
+//        }
+//        if (winr > jobr) {
+//            addOffline(winl - 1, id, jobr + 1, winr, 1);
+//            ans[id] -= pre[winr] - pre[jobr];
+//        }
+//        winr = jobr;
+//        if (winl > jobl) {
+//            addOffline(winr, id, jobl, winl - 1, 1);
+//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
+//        }
+//        if (winl < jobl) {
+//            addOffline(winr, id, winl, jobl - 1, -1);
+//            ans[id] += pre[jobl - 1] - pre[winl - 1];
+//        }
+//        winl = jobl;
+//    }
+//    long long sum = 0;
+//    long long tmp;
+//    for (int i = 0; i <= n; i++) {
+//        if (i >= 1) {
+//            addVal(arr[i]);
+//            sum += arr[i];
+//        }
+//        for (int q = headq[i]; q > 0; q = nextq[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            for (int j = l; j <= r; j++) {
+//                tmp = 1LL * getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
+//                if (op == 1) {
+//                    ans[id] += tmp;
+//                } else {
+//                    ans[id] -= tmp;
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 2; i <= m; i++) {
+//        ans[query[i].id] += ans[query[i - 1].id];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        ans[query[i].id] += presum[query[i].r] - presum[query[i].l - 1];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From d20384c7094c42eb9e6372150331daf15606b886 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 9 Sep 2025 17:19:21 +0800
Subject: [PATCH 1370/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 72 +++++++++++-----------
 src/class178/Code02_OfflineInversion2.java | 60 +++++++++---------
 src/class178/Code04_Gosick1.java           | 54 ++++++++--------
 src/class178/Code04_Gosick2.java           | 54 ++++++++--------
 4 files changed, 118 insertions(+), 122 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 7007eb958..4f5c49f31 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -23,11 +23,9 @@ public class Code02_OfflineInversion1 {
 	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
-	// 第一次离线任务，l、r、id
-	// 第二次离线任务，pos、id、l、r、op
-	public static int[][] query1 = new int[MAXN][3];
-	public static int[][] lquery = new int[MAXN][5];
-	public static int[][] rquery = new int[MAXN][5];
+	public static int[][] query = new int[MAXN][3];
+	public static int[][] loffline = new int[MAXN][5];
+	public static int[][] roffline = new int[MAXN][5];
 	public static int cntl, cntr;
 
 	// bi用于序列分块、值域分块，bl和br用于值域分块
@@ -49,7 +47,7 @@ public class Code02_OfflineInversion1 {
 
 	public static long[] ans = new long[MAXN];
 
-	public static class Cmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
@@ -59,7 +57,7 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
-	public static class Cmp2 implements Comparator<int[]> {
+	public static class OfflineCmp implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			return a[0] - b[0];
@@ -104,20 +102,20 @@ public static void clear() {
 		Arrays.fill(tree, 1, cntv + 1, 0);
 	}
 
-	public static void addLeftQuery(int pos, int id, int l, int r, int op) {
-		lquery[++cntl][0] = pos;
-		lquery[cntl][1] = id;
-		lquery[cntl][2] = l;
-		lquery[cntl][3] = r;
-		lquery[cntl][4] = op;
+	public static void addLeftOffline(int pos, int id, int l, int r, int op) {
+		loffline[++cntl][0] = pos;
+		loffline[cntl][1] = id;
+		loffline[cntl][2] = l;
+		loffline[cntl][3] = r;
+		loffline[cntl][4] = op;
 	}
 
-	public static void addRightQuery(int pos, int id, int l, int r, int op) {
-		rquery[++cntr][0] = pos;
-		rquery[cntr][1] = id;
-		rquery[cntr][2] = l;
-		rquery[cntr][3] = r;
-		rquery[cntr][4] = op;
+	public static void addRightOffline(int pos, int id, int l, int r, int op) {
+		roffline[++cntr][0] = pos;
+		roffline[cntr][1] = id;
+		roffline[cntr][2] = l;
+		roffline[cntr][3] = r;
+		roffline[cntr][4] = op;
 	}
 
 	public static void addLeftCnt(int val) {
@@ -171,7 +169,7 @@ public static void prepare() {
 			bl[i] = (i - 1) * blen + 1;
 			br[i] = Math.min(i * blen, cntv);
 		}
-		Arrays.sort(query1, 1, m + 1, new Cmp1());
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
 	public static void compute() {
@@ -186,36 +184,36 @@ public static void compute() {
 		}
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
-			int jobl = query1[i][0];
-			int jobr = query1[i][1];
-			int id = query1[i][2];
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
 			if (winr < jobr) {
-				addLeftQuery(winl - 1, id, winr + 1, jobr, -1);
+				addLeftOffline(winl - 1, id, winr + 1, jobr, -1);
 				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
-				addLeftQuery(winl - 1, id, jobr + 1, winr, 1);
+				addLeftOffline(winl - 1, id, jobr + 1, winr, 1);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addRightQuery(winr + 1, id, jobl, winl - 1, -1);
+				addRightOffline(winr + 1, id, jobl, winl - 1, -1);
 				ans[id] += suf[jobl] - suf[winl];
 			}
 			if (winl < jobl) {
-				addRightQuery(winr + 1, id, winl, jobl - 1, 1);
+				addRightOffline(winr + 1, id, winl, jobl - 1, 1);
 				ans[id] -= suf[winl] - suf[jobl];
 			}
 			winl = jobl;
 		}
-		Arrays.sort(lquery, 1, cntl + 1, new Cmp2());
-		Arrays.sort(rquery, 1, cntr + 1, new Cmp2());
+		Arrays.sort(loffline, 1, cntl + 1, new OfflineCmp());
+		Arrays.sort(roffline, 1, cntr + 1, new OfflineCmp());
 		for (int pos = 0, qi = 1; pos <= n && qi <= cntl; pos++) {
 			if (pos >= 1) {
 				addLeftCnt(arr[pos] - 1);
 			}
-			for (; qi <= cntl && lquery[qi][0] == pos; qi++) {
-				int id = lquery[qi][1], l = lquery[qi][2], r = lquery[qi][3], op = lquery[qi][4];
+			for (; qi <= cntl && loffline[qi][0] == pos; qi++) {
+				int id = loffline[qi][1], l = loffline[qi][2], r = loffline[qi][3], op = loffline[qi][4];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
@@ -229,8 +227,8 @@ public static void compute() {
 			if (pos <= n) {
 				addRightCnt(arr[pos] + 1);
 			}
-			for (; qi >= 1 && rquery[qi][0] == pos; qi--) {
-				int id = rquery[qi][1], l = rquery[qi][2], r = rquery[qi][3], op = rquery[qi][4];
+			for (; qi >= 1 && roffline[qi][0] == pos; qi--) {
+				int id = roffline[qi][1], l = roffline[qi][2], r = roffline[qi][3], op = roffline[qi][4];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
@@ -249,14 +247,14 @@ public static void main(String[] args) throws Exception {
 			arr[i] = in.nextInt();
 		}
 		for (int i = 1; i <= m; i++) {
-			query1[i][0] = in.nextInt();
-			query1[i][1] = in.nextInt();
-			query1[i][2] = i;
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
 		}
 		prepare();
 		compute();
 		for (int i = 2; i <= m; i++) {
-			ans[query1[i][2]] += ans[query1[i - 1][2]];
+			ans[query[i][2]] += ans[query[i - 1][2]];
 		}
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index bf71b4ff7..5c2934612 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -9,11 +9,11 @@
 //
 //using namespace std;
 //
-//struct Query1 {
+//struct Query {
 //    int l, r, id;
 //};
 //
-//struct Query2 {
+//struct Offline {
 //    int pos, id, l, r, op;
 //};
 //
@@ -24,9 +24,9 @@
 //int sorted[MAXN];
 //int cntv;
 //
-//Query1 query1[MAXN];
-//Query2 lquery[MAXN];
-//Query2 rquery[MAXN];
+//Query query1[MAXN];
+//Offline loffline[MAXN];
+//Offline roffline[MAXN];
 //int cntl, cntr;
 //
 //int bi[MAXN];
@@ -42,14 +42,14 @@
 //
 //long long ans[MAXN];
 //
-//bool Cmp1(Query1 &a, Query1 &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
-//bool Cmp2(Query2 &a, Query2 &b) {
+//bool OfflineCmp(Offline &a, Offline &b) {
 //    return a.pos < b.pos;
 //}
 //
@@ -91,20 +91,20 @@
 //    memset(tree + 1, 0, cntv * sizeof(int));
 //}
 //
-//void addLeftQuery(int pos, int id, int l, int r, int op) {
-//    lquery[++cntl].pos = pos;
-//    lquery[cntl].id = id;
-//    lquery[cntl].l = l;
-//    lquery[cntl].r = r;
-//    lquery[cntl].op = op;
+//void addLeftOffline(int pos, int id, int l, int r, int op) {
+//    loffline[++cntl].pos = pos;
+//    loffline[cntl].id = id;
+//    loffline[cntl].l = l;
+//    loffline[cntl].r = r;
+//    loffline[cntl].op = op;
 //}
 //
-//void addRightQuery(int pos, int id, int l, int r, int op) {
-//    rquery[++cntr].pos = pos;
-//    rquery[cntr].id = id;
-//    rquery[cntr].l = l;
-//    rquery[cntr].r = r;
-//    rquery[cntr].op = op;
+//void addRightOffline(int pos, int id, int l, int r, int op) {
+//    roffline[++cntr].pos = pos;
+//    roffline[cntr].id = id;
+//    roffline[cntr].l = l;
+//    roffline[cntr].r = r;
+//    roffline[cntr].op = op;
 //}
 //
 //void addLeftCnt(int val) {
@@ -158,7 +158,7 @@
 //        bl[i] = (i - 1) * blen + 1;
 //        br[i] = min(i * blen, cntv);
 //    }
-//    sort(query1 + 1, query1 + m + 1, Cmp1);
+//    sort(query1 + 1, query1 + m + 1, QueryCmp);
 //}
 //
 //void compute() {
@@ -177,32 +177,32 @@
 //        int jobr = query1[i].r;
 //        int id = query1[i].id;
 //        if (winr < jobr) {
-//            addLeftQuery(winl - 1, id, winr + 1, jobr, -1);
+//            addLeftOffline(winl - 1, id, winr + 1, jobr, -1);
 //            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
-//            addLeftQuery(winl - 1, id, jobr + 1, winr, 1);
+//            addLeftOffline(winl - 1, id, jobr + 1, winr, 1);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addRightQuery(winr + 1, id, jobl, winl - 1, -1);
+//            addRightOffline(winr + 1, id, jobl, winl - 1, -1);
 //            ans[id] += suf[jobl] - suf[winl];
 //        }
 //        if (winl < jobl) {
-//            addRightQuery(winr + 1, id, winl, jobl - 1, 1);
+//            addRightOffline(winr + 1, id, winl, jobl - 1, 1);
 //            ans[id] -= suf[winl] - suf[jobl];
 //        }
 //        winl = jobl;
 //    }
-//    sort(lquery + 1, lquery + cntl + 1, Cmp2);
-//    sort(rquery + 1, rquery + cntr + 1, Cmp2);
+//    sort(loffline + 1, loffline + cntl + 1, OfflineCmp);
+//    sort(roffline + 1, roffline + cntr + 1, OfflineCmp);
 //    for (int pos = 0, qi = 1; pos <= n && qi <= cntl; pos++) {
 //        if (pos >= 1) {
 //            addLeftCnt(arr[pos] - 1);
 //        }
-//        for (; qi <= cntl && lquery[qi].pos == pos; qi++) {
-//            int id = lquery[qi].id, l = lquery[qi].l, r = lquery[qi].r, op = lquery[qi].op;
+//        for (; qi <= cntl && loffline[qi].pos == pos; qi++) {
+//            int id = loffline[qi].id, l = loffline[qi].l, r = loffline[qi].r, op = loffline[qi].op;
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);
@@ -216,8 +216,8 @@
 //        if (pos <= n) {
 //            addRightCnt(arr[pos] + 1);
 //        }
-//        for (; qi >= 1 && rquery[qi].pos == pos; qi--) {
-//            int id = rquery[qi].id, l = rquery[qi].l, r = rquery[qi].r, op = rquery[qi].op;
+//        for (; qi >= 1 && roffline[qi].pos == pos; qi--) {
+//            int id = roffline[qi].id, l = roffline[qi].l, r = roffline[qi].r, op = roffline[qi].op;
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 7be189708..dbcfd9f3d 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -29,10 +29,8 @@ public class Code04_Gosick1 {
 	public static int[] fac = new int[MAXF];
 	public static int cntf;
 
-	// l、r、id
-	public static int[][] query1 = new int[MAXN][3];
-	// pos、id、l、r、op
-	public static int[][] query2 = new int[MAXN << 1][5];
+	public static int[][] query = new int[MAXN][3];
+	public static int[][] offline = new int[MAXN << 1][5];
 	public static int cntq;
 
 	public static int[] fcnt = new int[MAXN];
@@ -44,7 +42,7 @@ public class Code04_Gosick1 {
 
 	public static long[] ans = new long[MAXN];
 
-	public static class Cmp1 implements Comparator<int[]> {
+	public static class QueryCmp implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			if (bi[a[0]] != bi[b[0]]) {
@@ -54,7 +52,7 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
-	public static class Cmp2 implements Comparator<int[]> {
+	public static class OfflineCmp implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
 			return a[0] - b[0];
@@ -73,12 +71,12 @@ public static void addFactors(int num) {
 		}
 	}
 
-	public static void addQuery(int pos, int id, int l, int r, int op) {
-		query2[++cntq][0] = pos;
-		query2[cntq][1] = id;
-		query2[cntq][2] = l;
-		query2[cntq][3] = r;
-		query2[cntq][4] = op;
+	public static void addOffline(int pos, int id, int l, int r, int op) {
+		offline[++cntq][0] = pos;
+		offline[cntq][1] = id;
+		offline[cntq][2] = l;
+		offline[cntq][3] = r;
+		offline[cntq][4] = op;
 	}
 
 	public static void compute() {
@@ -99,29 +97,29 @@ public static void compute() {
 		}
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
-			int jobl = query1[i][0];
-			int jobr = query1[i][1];
-			int id = query1[i][2];
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
 			if (winr < jobr) {
-				addQuery(winl - 1, id, winr + 1, jobr, -1);
+				addOffline(winl - 1, id, winr + 1, jobr, -1);
 				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
-				addQuery(winl - 1, id, jobr + 1, winr, 1);
+				addOffline(winl - 1, id, jobr + 1, winr, 1);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addQuery(winr, id, jobl, winl - 1, 1);
+				addOffline(winr, id, jobl, winl - 1, 1);
 				ans[id] -= pre[winl - 1] - pre[jobl - 1];
 			}
 			if (winl < jobl) {
-				addQuery(winr, id, winl, jobl - 1, -1);
+				addOffline(winr, id, winl, jobl - 1, -1);
 				ans[id] += pre[jobl - 1] - pre[winl - 1];
 			}
 			winl = jobl;
 		}
-		Arrays.sort(query2, 1, cntq + 1, new Cmp2());
+		Arrays.sort(offline, 1, cntq + 1, new OfflineCmp());
 		Arrays.fill(fcnt, 0);
 		for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
 			if (pos >= 1) {
@@ -140,8 +138,8 @@ public static void compute() {
 					}
 				}
 			}
-			for (; qi <= cntq && query2[qi][0] == pos; qi++) {
-				int id = query2[qi][1], l = query2[qi][2], r = query2[qi][3], op = query2[qi][4];
+			for (; qi <= cntq && offline[qi][0] == pos; qi++) {
+				int id = offline[qi][1], l = offline[qi][2], r = offline[qi][3], op = offline[qi][4];
 				for (int i = l; i <= r; i++) {
 					ans[id] += (long) op * fcnt[arr[i]];
 				}
@@ -154,7 +152,7 @@ public static void compute() {
 				cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 			}
 			for (int i = 1; i <= cntq; i++) {
-				int pos = query2[i][0], id = query2[i][1], l = query2[i][2], r = query2[i][3], op = query2[i][4];
+				int pos = offline[i][0], id = offline[i][1], l = offline[i][2], r = offline[i][3], op = offline[i][4];
 				ans[id] += (long) op * cnt1[pos] * (cnt2[r] - cnt2[l - 1]);
 			}
 		}
@@ -167,7 +165,7 @@ public static void prepare() {
 			maxv = Math.max(maxv, arr[i]);
 			addFactors(arr[i]);
 		}
-		Arrays.sort(query1, 1, m + 1, new Cmp1());
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -179,14 +177,14 @@ public static void main(String[] args) throws Exception {
 			arr[i] = in.nextInt();
 		}
 		for (int i = 1; i <= m; i++) {
-			query1[i][0] = in.nextInt();
-			query1[i][1] = in.nextInt();
-			query1[i][2] = i;
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
 		}
 		prepare();
 		compute();
 		for (int i = 2; i <= m; i++) {
-			ans[query1[i][2]] += ans[query1[i - 1][2]];
+			ans[query[i][2]] += ans[query[i - 1][2]];
 		}
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 96bd5e00b..2c977cc2a 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -9,11 +9,11 @@
 //
 //using namespace std;
 //
-//struct Query1 {
+//struct Query {
 //    int l, r, id;
 //};
 //
-//struct Query2 {
+//struct Offline {
 //    int pos, id, l, r, op;
 //};
 //
@@ -29,8 +29,8 @@
 //int fac[MAXF];
 //int cntf;
 //
-//Query1 query1[MAXN];
-//Query2 query2[MAXN << 1];
+//Query query[MAXN];
+//Offline offline[MAXN << 1];
 //int cntq;
 //
 //int fcnt[MAXN];
@@ -42,14 +42,14 @@
 //
 //long long ans[MAXN];
 //
-//bool Cmp1(Query1 &a, Query1 &b) {
+//bool QueryCmp(Query &a, Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
 //    return a.r < b.r;
 //}
 //
-//bool Cmp2(Query2 &a, Query2 &b) {
+//bool OfflineCmp(Offline &a, Offline &b) {
 //    return a.pos < b.pos;
 //}
 //
@@ -65,12 +65,12 @@
 //    }
 //}
 //
-//void addQuery(int pos, int id, int l, int r, int op) {
-//    query2[++cntq].pos = pos;
-//    query2[cntq].id = id;
-//    query2[cntq].l = l;
-//    query2[cntq].r = r;
-//    query2[cntq].op = op;
+//void addOffline(int pos, int id, int l, int r, int op) {
+//    offline[++cntq].pos = pos;
+//    offline[cntq].id = id;
+//    offline[cntq].l = l;
+//    offline[cntq].r = r;
+//    offline[cntq].op = op;
 //}
 //
 //void compute() {
@@ -91,29 +91,29 @@
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
-//        int jobl = query1[i].l;
-//        int jobr = query1[i].r;
-//        int id = query1[i].id;
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
 //        if (winr < jobr) {
-//            addQuery(winl - 1, id, winr + 1, jobr, -1);
+//            addOffline(winl - 1, id, winr + 1, jobr, -1);
 //            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
-//            addQuery(winl - 1, id, jobr + 1, winr, 1);
+//            addOffline(winl - 1, id, jobr + 1, winr, 1);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addQuery(winr, id, jobl, winl - 1, 1);
+//            addOffline(winr, id, jobl, winl - 1, 1);
 //            ans[id] -= pre[winl - 1] - pre[jobl - 1];
 //        }
 //        if (winl < jobl) {
-//            addQuery(winr, id, winl, jobl - 1, -1);
+//            addOffline(winr, id, winl, jobl - 1, -1);
 //            ans[id] += pre[jobl - 1] - pre[winl - 1];
 //        }
 //        winl = jobl;
 //    }
-//    sort(query2 + 1, query2 + cntq + 1, Cmp2);
+//    sort(offline + 1, offline + cntq + 1, OfflineCmp);
 //    memset(fcnt, 0, sizeof(fcnt));
 //    for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
 //        if (pos >= 1) {
@@ -132,8 +132,8 @@
 //                }
 //            }
 //        }
-//        for (; qi <= cntq && query2[qi].pos == pos; qi++) {
-//            int id = query2[qi].id, l = query2[qi].l, r = query2[qi].r, op = query2[qi].op;
+//        for (; qi <= cntq && offline[qi].pos == pos; qi++) {
+//            int id = offline[qi].id, l = offline[qi].l, r = offline[qi].r, op = offline[qi].op;
 //            for (int i = l; i <= r; i++) {
 //                ans[id] += 1LL * op * fcnt[arr[i]];
 //            }
@@ -147,7 +147,7 @@
 //            cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 //        }
 //        for (int i = 1; i <= cntq; i++) {
-//            int pos = query2[i].pos, id = query2[i].id, l = query2[i].l, r = query2[i].r, op = query2[i].op;
+//            int pos = offline[i].pos, id = offline[i].id, l = offline[i].l, r = offline[i].r, op = offline[i].op;
 //            ans[id] += 1LL * op * cnt1[pos] * (cnt2[r] - cnt2[l - 1]);
 //        }
 //    }
@@ -160,7 +160,7 @@
 //        maxv = max(maxv, arr[i]);
 //        addFactors(arr[i]);
 //    }
-//    sort(query1 + 1, query1 + m + 1, Cmp1);
+//    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //
 //int main() {
@@ -171,13 +171,13 @@
 //        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> query1[i].l >> query1[i].r;
-//        query1[i].id = i;
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
 //    }
 //    prepare();
 //    compute();
 //    for (int i = 2; i <= m; i++) {
-//        ans[query1[i].id] += ans[query1[i - 1].id];
+//        ans[query[i].id] += ans[query[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';

From b39734fe15ebcf5be897dbe573b281059a4b2628 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 9 Sep 2025 18:34:06 +0800
Subject: [PATCH 1371/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 67 +++++++++--------
 src/class178/Code02_OfflineInversion2.java | 85 +++++++++++-----------
 src/class178/Code04_Gosick1.java           | 65 ++++++++---------
 src/class178/Code04_Gosick2.java           | 66 ++++++++---------
 4 files changed, 140 insertions(+), 143 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 4f5c49f31..c9b1f31e1 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -24,9 +24,15 @@ public class Code02_OfflineInversion1 {
 	public static int cntv;
 
 	public static int[][] query = new int[MAXN][3];
-	public static int[][] loffline = new int[MAXN][5];
-	public static int[][] roffline = new int[MAXN][5];
-	public static int cntl, cntr;
+
+	public static int[] headl = new int[MAXN];
+	public static int[] headr = new int[MAXN];
+	public static int[] nextq = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
+	public static int[] ql = new int[MAXN << 1];
+	public static int[] qr = new int[MAXN << 1];
+	public static int[] qop = new int[MAXN << 1];
+	public static int cntq;
 
 	// bi用于序列分块、值域分块，bl和br用于值域分块
 	public static int[] bi = new int[MAXN];
@@ -57,13 +63,6 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
-	public static class OfflineCmp implements Comparator<int[]> {
-		@Override
-		public int compare(int[] a, int[] b) {
-			return a[0] - b[0];
-		}
-	}
-
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
@@ -102,20 +101,22 @@ public static void clear() {
 		Arrays.fill(tree, 1, cntv + 1, 0);
 	}
 
-	public static void addLeftOffline(int pos, int id, int l, int r, int op) {
-		loffline[++cntl][0] = pos;
-		loffline[cntl][1] = id;
-		loffline[cntl][2] = l;
-		loffline[cntl][3] = r;
-		loffline[cntl][4] = op;
+	public static void addLeftOffline(int x, int id, int l, int r, int op) {
+		nextq[++cntq] = headl[x];
+		headl[x] = cntq;
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
 	}
 
-	public static void addRightOffline(int pos, int id, int l, int r, int op) {
-		roffline[++cntr][0] = pos;
-		roffline[cntr][1] = id;
-		roffline[cntr][2] = l;
-		roffline[cntr][3] = r;
-		roffline[cntr][4] = op;
+	public static void addRightOffline(int x, int id, int l, int r, int op) {
+		nextq[++cntq] = headr[x];
+		headr[x] = cntq;
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
 	}
 
 	public static void addLeftCnt(int val) {
@@ -206,14 +207,12 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
-		Arrays.sort(loffline, 1, cntl + 1, new OfflineCmp());
-		Arrays.sort(roffline, 1, cntr + 1, new OfflineCmp());
-		for (int pos = 0, qi = 1; pos <= n && qi <= cntl; pos++) {
-			if (pos >= 1) {
-				addLeftCnt(arr[pos] - 1);
+		for (int i = 0; i <= n; i++) {
+			if (i >= 1) {
+				addLeftCnt(arr[i] - 1);
 			}
-			for (; qi <= cntl && loffline[qi][0] == pos; qi++) {
-				int id = loffline[qi][1], l = loffline[qi][2], r = loffline[qi][3], op = loffline[qi][4];
+			for (int q = headl[i]; q > 0; q = nextq[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
@@ -223,12 +222,12 @@ public static void compute() {
 		}
 		Arrays.fill(lazy, 0);
 		Arrays.fill(cnt, 0);
-		for (int pos = n + 1, qi = cntr; pos >= 1 && qi >= 1; pos--) {
-			if (pos <= n) {
-				addRightCnt(arr[pos] + 1);
+		for (int i = n + 1; i >= 1; i--) {
+			if (i <= n) {
+				addRightCnt(arr[i] + 1);
 			}
-			for (; qi >= 1 && roffline[qi][0] == pos; qi--) {
-				int id = roffline[qi][1], l = roffline[qi][2], r = roffline[qi][3], op = roffline[qi][4];
+			for (int q = headr[i]; q > 0; q = nextq[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 5c2934612..db0740fef 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -13,21 +13,24 @@
 //    int l, r, id;
 //};
 //
-//struct Offline {
-//    int pos, id, l, r, op;
-//};
-//
 //const int MAXN = 100002;
 //const int MAXB = 401;
+//
 //int n, m;
 //int arr[MAXN];
 //int sorted[MAXN];
 //int cntv;
 //
-//Query query1[MAXN];
-//Offline loffline[MAXN];
-//Offline roffline[MAXN];
-//int cntl, cntr;
+//Query query[MAXN];
+//
+//int headl[MAXN];
+//int headr[MAXN];
+//int nextq[MAXN << 1];
+//int qid[MAXN << 1];
+//int ql[MAXN << 1];
+//int qr[MAXN << 1];
+//int qop[MAXN << 1];
+//int cntq;
 //
 //int bi[MAXN];
 //int bl[MAXB];
@@ -49,10 +52,6 @@
 //    return a.r < b.r;
 //}
 //
-//bool OfflineCmp(Offline &a, Offline &b) {
-//    return a.pos < b.pos;
-//}
-//
 //int kth(int num) {
 //    int left = 1, right = cntv, ret = 0;
 //    while (left <= right) {
@@ -91,20 +90,22 @@
 //    memset(tree + 1, 0, cntv * sizeof(int));
 //}
 //
-//void addLeftOffline(int pos, int id, int l, int r, int op) {
-//    loffline[++cntl].pos = pos;
-//    loffline[cntl].id = id;
-//    loffline[cntl].l = l;
-//    loffline[cntl].r = r;
-//    loffline[cntl].op = op;
+//void addLeftOffline(int x, int id, int l, int r, int op) {
+//    nextq[++cntq] = headl[x];
+//    headl[x] = cntq;
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
 //}
 //
-//void addRightOffline(int pos, int id, int l, int r, int op) {
-//    roffline[++cntr].pos = pos;
-//    roffline[cntr].id = id;
-//    roffline[cntr].l = l;
-//    roffline[cntr].r = r;
-//    roffline[cntr].op = op;
+//void addRightOffline(int x, int id, int l, int r, int op) {
+//    nextq[++cntq] = headr[x];
+//    headr[x] = cntq;
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
 //}
 //
 //void addLeftCnt(int val) {
@@ -158,7 +159,7 @@
 //        bl[i] = (i - 1) * blen + 1;
 //        br[i] = min(i * blen, cntv);
 //    }
-//    sort(query1 + 1, query1 + m + 1, QueryCmp);
+//    sort(query + 1, query + m + 1, QueryCmp);
 //}
 //
 //void compute() {
@@ -173,9 +174,9 @@
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
-//        int jobl = query1[i].l;
-//        int jobr = query1[i].r;
-//        int id = query1[i].id;
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
 //        if (winr < jobr) {
 //            addLeftOffline(winl - 1, id, winr + 1, jobr, -1);
 //            ans[id] += pre[jobr] - pre[winr];
@@ -195,14 +196,12 @@
 //        }
 //        winl = jobl;
 //    }
-//    sort(loffline + 1, loffline + cntl + 1, OfflineCmp);
-//    sort(roffline + 1, roffline + cntr + 1, OfflineCmp);
-//    for (int pos = 0, qi = 1; pos <= n && qi <= cntl; pos++) {
-//        if (pos >= 1) {
-//            addLeftCnt(arr[pos] - 1);
+//    for (int i = 0; i <= n; i++) {
+//        if (i >= 1) {
+//            addLeftCnt(arr[i] - 1);
 //        }
-//        for (; qi <= cntl && loffline[qi].pos == pos; qi++) {
-//            int id = loffline[qi].id, l = loffline[qi].l, r = loffline[qi].r, op = loffline[qi].op;
+//        for (int q = headl[i]; q > 0; q = nextq[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);
@@ -212,12 +211,12 @@
 //    }
 //    memset(lazy, 0, sizeof(lazy));
 //    memset(cnt, 0, sizeof(cnt));
-//    for (int pos = n + 1, qi = cntr; pos >= 1 && qi >= 1; pos--) {
-//        if (pos <= n) {
-//            addRightCnt(arr[pos] + 1);
+//    for (int i = n + 1; i >= 1; i--) {
+//        if (i <= n) {
+//            addRightCnt(arr[i] + 1);
 //        }
-//        for (; qi >= 1 && roffline[qi].pos == pos; qi--) {
-//            int id = roffline[qi].id, l = roffline[qi].l, r = roffline[qi].r, op = roffline[qi].op;
+//        for (int q = headr[i]; q > 0; q = nextq[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);
@@ -235,13 +234,13 @@
 //        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> query1[i].l >> query1[i].r;
-//        query1[i].id = i;
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
 //    }
 //    prepare();
 //    compute();
 //    for (int i = 2; i <= m; i++) {
-//        ans[query1[i].id] += ans[query1[i - 1].id];
+//        ans[query[i].id] += ans[query[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index dbcfd9f3d..c7c66e9ac 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -23,14 +23,19 @@ public class Code04_Gosick1 {
 	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
 
-	// 每个数的因子表
-	public static int[] head = new int[MAXN];
-	public static int[] nxt = new int[MAXF];
+	public static int[] headf = new int[MAXN];
+	public static int[] nextf = new int[MAXF];
 	public static int[] fac = new int[MAXF];
 	public static int cntf;
 
 	public static int[][] query = new int[MAXN][3];
-	public static int[][] offline = new int[MAXN << 1][5];
+	public static int[] headq = new int[MAXN];
+	public static int[] nextq = new int[MAXN << 1];
+	public static int[] qx = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
+	public static int[] ql = new int[MAXN << 1];
+	public static int[] qr = new int[MAXN << 1];
+	public static int[] qop = new int[MAXN << 1];
 	public static int cntq;
 
 	public static int[] fcnt = new int[MAXN];
@@ -52,37 +57,32 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
-	public static class OfflineCmp implements Comparator<int[]> {
-		@Override
-		public int compare(int[] a, int[] b) {
-			return a[0] - b[0];
-		}
-	}
-
 	public static void addFactors(int num) {
-		if (head[num] == 0) {
+		if (headf[num] == 0) {
 			for (int f = 1; f * f <= num; f++) {
 				if (num % f == 0) {
-					nxt[++cntf] = head[num];
+					nextf[++cntf] = headf[num];
 					fac[cntf] = f;
-					head[num] = cntf;
+					headf[num] = cntf;
 				}
 			}
 		}
 	}
 
-	public static void addOffline(int pos, int id, int l, int r, int op) {
-		offline[++cntq][0] = pos;
-		offline[cntq][1] = id;
-		offline[cntq][2] = l;
-		offline[cntq][3] = r;
-		offline[cntq][4] = op;
+	public static void addOffline(int x, int id, int l, int r, int op) {
+		nextq[++cntq] = headq[x];
+		headq[x] = cntq;
+		qx[cntq] = x;
+		qid[cntq] = id;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
 	}
 
 	public static void compute() {
 		for (int i = 1, x; i <= n; i++) {
 			x = arr[i];
-			for (int e = head[x], f, other; e > 0; e = nxt[e]) {
+			for (int e = headf[x], f, other; e > 0; e = nextf[e]) {
 				f = fac[e];
 				other = x / f;
 				fcnt[f]++;
@@ -119,12 +119,11 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
-		Arrays.sort(offline, 1, cntq + 1, new OfflineCmp());
 		Arrays.fill(fcnt, 0);
-		for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
-			if (pos >= 1) {
-				int num = arr[pos];
-				for (int e = head[num], f, other; e > 0; e = nxt[e]) {
+		for (int i = 0; i <= n; i++) {
+			if (i >= 1) {
+				int num = arr[i];
+				for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 					f = fac[e];
 					other = num / f;
 					fcnt[f]++;
@@ -138,10 +137,10 @@ public static void compute() {
 					}
 				}
 			}
-			for (; qi <= cntq && offline[qi][0] == pos; qi++) {
-				int id = offline[qi][1], l = offline[qi][2], r = offline[qi][3], op = offline[qi][4];
-				for (int i = l; i <= r; i++) {
-					ans[id] += (long) op * fcnt[arr[i]];
+			for (int q = headq[i]; q > 0; q = nextq[q]) {
+				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				for (int j = l; j <= r; j++) {
+					ans[id] += (long) op * fcnt[arr[j]];
 				}
 			}
 		}
@@ -152,8 +151,8 @@ public static void compute() {
 				cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 			}
 			for (int i = 1; i <= cntq; i++) {
-				int pos = offline[i][0], id = offline[i][1], l = offline[i][2], r = offline[i][3], op = offline[i][4];
-				ans[id] += (long) op * cnt1[pos] * (cnt2[r] - cnt2[l - 1]);
+				int x = qx[i], id = qid[i], l = ql[i], r = qr[i], op = qop[i];
+				ans[id] += (long) op * cnt1[x] * (cnt2[r] - cnt2[l - 1]);
 			}
 		}
 	}
@@ -232,4 +231,4 @@ int nextInt() throws IOException {
 		}
 	}
 
-}
\ No newline at end of file
+}
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 2c977cc2a..a66fbb051 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -13,24 +13,27 @@
 //    int l, r, id;
 //};
 //
-//struct Offline {
-//    int pos, id, l, r, op;
-//};
-//
 //const int MAXN = 500001;
 //const int MAXF = 5000001;
 //const int LIMIT = 80;
+//
 //int n, m, maxv;
 //int arr[MAXN];
 //int bi[MAXN];
 //
-//int head[MAXN];
-//int nxt[MAXF];
+//int headf[MAXN];
+//int nextf[MAXF];
 //int fac[MAXF];
 //int cntf;
 //
 //Query query[MAXN];
-//Offline offline[MAXN << 1];
+//int headq[MAXN];
+//int nextq[MAXN << 1];
+//int qx[MAXN << 1];
+//int qid[MAXN << 1];
+//int ql[MAXN << 1];
+//int qr[MAXN << 1];
+//int qop[MAXN << 1];
 //int cntq;
 //
 //int fcnt[MAXN];
@@ -49,34 +52,32 @@
 //    return a.r < b.r;
 //}
 //
-//bool OfflineCmp(Offline &a, Offline &b) {
-//    return a.pos < b.pos;
-//}
-//
 //void addFactors(int num) {
-//    if (head[num] == 0) {
+//    if (headf[num] == 0) {
 //        for (int f = 1; f * f <= num; f++) {
 //            if (num % f == 0) {
-//                nxt[++cntf] = head[num];
+//                nextf[++cntf] = headf[num];
 //                fac[cntf] = f;
-//                head[num] = cntf;
+//                headf[num] = cntf;
 //            }
 //        }
 //    }
 //}
 //
-//void addOffline(int pos, int id, int l, int r, int op) {
-//    offline[++cntq].pos = pos;
-//    offline[cntq].id = id;
-//    offline[cntq].l = l;
-//    offline[cntq].r = r;
-//    offline[cntq].op = op;
+//void addOffline(int x, int id, int l, int r, int op) {
+//    nextq[++cntq] = headq[x];
+//    headq[x] = cntq;
+//    qx[cntq] = x;
+//    qid[cntq] = id;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
 //}
 //
 //void compute() {
 //    for (int i = 1, x; i <= n; i++) {
 //        x = arr[i];
-//        for (int e = head[x], f, other; e > 0; e = nxt[e]) {
+//        for (int e = headf[x], f, other; e > 0; e = nextf[e]) {
 //            f = fac[e];
 //            other = x / f;
 //            fcnt[f]++;
@@ -113,12 +114,11 @@
 //        }
 //        winl = jobl;
 //    }
-//    sort(offline + 1, offline + cntq + 1, OfflineCmp);
 //    memset(fcnt, 0, sizeof(fcnt));
-//    for (int pos = 0, qi = 1; pos <= n && qi <= cntq; pos++) {
-//        if (pos >= 1) {
-//            int num = arr[pos];
-//            for (int e = head[num], f, other; e > 0; e = nxt[e]) {
+//    for (int i = 0; i <= n; i++) {
+//        if (i >= 1) {
+//            int num = arr[i];
+//            for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 //                f = fac[e];
 //                other = num / f;
 //                fcnt[f]++;
@@ -132,10 +132,10 @@
 //                }
 //            }
 //        }
-//        for (; qi <= cntq && offline[qi].pos == pos; qi++) {
-//            int id = offline[qi].id, l = offline[qi].l, r = offline[qi].r, op = offline[qi].op;
-//            for (int i = l; i <= r; i++) {
-//                ans[id] += 1LL * op * fcnt[arr[i]];
+//        for (int q = headq[i]; q > 0; q = nextq[q]) {
+//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            for (int j = l; j <= r; j++) {
+//                ans[id] += 1LL * op * fcnt[arr[j]];
 //            }
 //        }
 //    }
@@ -146,9 +146,9 @@
 //            cnt1[i] = cnt1[i - 1] + (arr[i] == v ? 1 : 0);
 //            cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 //        }
-//        for (int i = 1; i <= cntq; i++) {
-//            int pos = offline[i].pos, id = offline[i].id, l = offline[i].l, r = offline[i].r, op = offline[i].op;
-//            ans[id] += 1LL * op * cnt1[pos] * (cnt2[r] - cnt2[l - 1]);
+//        for(int i = 1; i <= cntq; i++) {
+//             int x = qx[i], id = qid[i], l = ql[i], r = qr[i], op = qop[i];
+//             ans[id] += 1LL * op * cnt1[x] * (cnt2[r] - cnt2[l - 1]);
 //        }
 //    }
 //}

From 6cd31f838907be1a95b0b6faf36705babd4866e7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 9 Sep 2025 18:36:57 +0800
Subject: [PATCH 1372/1712] modify code

---
 src/class178/Code03_Abbi1.java   | 2 +-
 src/class178/Code03_Abbi2.java   | 2 +-
 src/class178/Code04_Gosick1.java | 2 +-
 src/class178/Code04_Gosick2.java | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 4fb358e65..44c503def 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 区间查询Abbi值，java版
+// 查询Abbi值，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5501
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 6c3b008f2..7368439e1 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 区间查询Abbi值，C++版
+// 查询Abbi值，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P5501
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index c7c66e9ac..e27fa0eba 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 区间查倍数，java版
+// 查询倍数，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index a66fbb051..7d8757ee1 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 区间查倍数，C++版
+// 查询倍数，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 3a34c6dab10f6ea4380307a523ce57304e9255d9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 9 Sep 2025 21:10:45 +0800
Subject: [PATCH 1373/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 30 +++++++++++++-----------
 src/class178/Code01_MoOfflineTwice2.java | 22 +++++++----------
 src/class178/Code03_Abbi1.java           |  1 -
 3 files changed, 24 insertions(+), 29 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index fc2560b30..a87cd9112 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -38,8 +38,8 @@ public class Code01_MoOfflineTwice1 {
 	public static int cntq;
 
 	public static int[] bi = new int[MAXN];
-	public static int[] pre = new int[MAXN];
 	public static int[] cnt = new int[MAXV];
+	public static long[] pre = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -86,7 +86,7 @@ public static void prepare() {
 
 	public static void compute() {
 		for (int i = 1; i <= n; i++) {
-			pre[i] = cnt[arr[i]];
+			pre[i] = pre[i - 1] + cnt[arr[i]];
 			for (int j = 1; j <= cntk; j++) {
 				cnt[arr[i] ^ kOneArr[j]]++;
 			}
@@ -98,28 +98,22 @@ public static void compute() {
 			int id = query[i][2];
 			if (winr < jobr) {
 				addOffline(winl - 1, id, winr + 1, jobr, -1);
-			}
-			while (winr < jobr) {
-				ans[id] += pre[++winr];
+				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
 				addOffline(winl - 1, id, jobr + 1, winr, 1);
+				ans[id] -= pre[winr] - pre[jobr];
 			}
-			while (winr > jobr) {
-				ans[id] -= pre[winr--];
-			}
+			winr = jobr;
 			if (winl > jobl) {
 				addOffline(winr, id, jobl, winl - 1, 1);
-			}
-			while (winl > jobl) {
-				ans[id] -= pre[--winl];
+				ans[id] -= pre[winl - 1] - pre[jobl - 1];
 			}
 			if (winl < jobl) {
 				addOffline(winr, id, winl, jobl - 1, -1);
+				ans[id] += pre[jobl - 1] - pre[winl - 1];
 			}
-			while (winl < jobl) {
-				ans[id] += pre[winl++];
-			}
+			winl = jobl;
 		}
 		// 第二次离线
 		Arrays.fill(cnt, 0);
@@ -132,9 +126,17 @@ public static void compute() {
 			for (int q = headq[i]; q > 0; q = nextq[q]) {
 				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 				for (int j = l; j <= r; j++) {
+					// 计算j 对 1..i范围的贡献
+					// 此时1..i范围上的数字都更新过cnt
 					if (j <= i && k == 0) {
+						// j在1..i范围上，此时又有k==0
+						// 那么arr[j]一定更新过cnt，并且(arr[j], arr[j])一定算进贡献了
+						// 但是题目要求的二元组必须是不同位置，所以贡献要进行减1修正
 						ans[id] += (long) op * (cnt[arr[j]] - 1);
 					} else {
+						// 要么j不在1..i范围上，arr[j]没更新过cnt
+						// 要么k!=0，(arr[j], arr[j])无法被算成贡献
+						// 无论哪种情况，贡献都是正确的，不用进行减1修正
 						ans[id] += (long) op * cnt[arr[j]];
 					}
 				}
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index 5e73aeaff..cdc0c735f 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -31,8 +31,8 @@
 //int cntq;
 //
 //int bi[MAXN];
-//int pre[MAXN];
 //int cnt[MAXV];
+//long long pre[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -76,7 +76,7 @@
 //
 //void compute() {
 //    for (int i = 1; i <= n; i++) {
-//        pre[i] = cnt[arr[i]];
+//        pre[i] = pre[i - 1] + cnt[arr[i]];
 //        for (int j = 1; j <= cntk; j++) {
 //            cnt[arr[i] ^ kOneArr[j]]++;
 //        }
@@ -88,28 +88,22 @@
 //        int id = query[i].id;
 //        if (winr < jobr) {
 //            addOffline(winl - 1, id, winr + 1, jobr, -1);
-//        }
-//        while (winr < jobr) {
-//            ans[id] += pre[++winr];
+//            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
 //            addOffline(winl - 1, id, jobr + 1, winr, 1);
+//            ans[id] -= pre[winr] - pre[jobr];
 //        }
-//        while (winr > jobr) {
-//            ans[id] -= pre[winr--];
-//        }
+//        winr = jobr;
 //        if (winl > jobl) {
 //            addOffline(winr, id, jobl, winl - 1, 1);
-//        }
-//        while (winl > jobl) {
-//            ans[id] -= pre[--winl];
+//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
 //        }
 //        if (winl < jobl) {
 //            addOffline(winr, id, winl, jobl - 1, -1);
+//            ans[id] += pre[jobl - 1] - pre[winl - 1];
 //        }
-//        while (winl < jobl) {
-//            ans[id] += pre[winl++];
-//        }
+//        winl = jobl;
 //    }
 //    memset(cnt, 0, sizeof(cnt));
 //    for (int i = 0; i <= n; i++) {
diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 44c503def..b2db74069 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -148,7 +148,6 @@ public static void compute() {
 			if (winl > jobl) {
 				addOffline(winr, id, jobl, winl - 1, 1);
 				ans[id] -= pre[winl - 1] - pre[jobl - 1];
-
 			}
 			if (winl < jobl) {
 				addOffline(winr, id, winl, jobl - 1, -1);

From 8269643c73a560a50899e5e9fbc0a05c115066a6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 10:43:11 +0800
Subject: [PATCH 1374/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 10 +++++-----
 src/class178/Code02_OfflineInversion2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index c9b1f31e1..bd2375f4d 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -198,11 +198,11 @@ public static void compute() {
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addRightOffline(winr + 1, id, jobl, winl - 1, -1);
+				addRightOffline(winr, id, jobl, winl - 1, -1);
 				ans[id] += suf[jobl] - suf[winl];
 			}
 			if (winl < jobl) {
-				addRightOffline(winr + 1, id, winl, jobl - 1, 1);
+				addRightOffline(winr, id, winl, jobl - 1, 1);
 				ans[id] -= suf[winl] - suf[jobl];
 			}
 			winl = jobl;
@@ -223,9 +223,6 @@ public static void compute() {
 		Arrays.fill(lazy, 0);
 		Arrays.fill(cnt, 0);
 		for (int i = n + 1; i >= 1; i--) {
-			if (i <= n) {
-				addRightCnt(arr[i] + 1);
-			}
 			for (int q = headr[i]; q > 0; q = nextq[q]) {
 				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 				long ret = 0;
@@ -234,6 +231,9 @@ public static void compute() {
 				}
 				ans[id] += ret * op;
 			}
+			if (i <= n) {
+				addRightCnt(arr[i] + 1);
+			}
 		}
 	}
 
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index db0740fef..405f83802 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -187,11 +187,11 @@
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addRightOffline(winr + 1, id, jobl, winl - 1, -1);
+//            addRightOffline(winr, id, jobl, winl - 1, -1);
 //            ans[id] += suf[jobl] - suf[winl];
 //        }
 //        if (winl < jobl) {
-//            addRightOffline(winr + 1, id, winl, jobl - 1, 1);
+//            addRightOffline(winr, id, winl, jobl - 1, 1);
 //            ans[id] -= suf[winl] - suf[jobl];
 //        }
 //        winl = jobl;
@@ -212,9 +212,6 @@
 //    memset(lazy, 0, sizeof(lazy));
 //    memset(cnt, 0, sizeof(cnt));
 //    for (int i = n + 1; i >= 1; i--) {
-//        if (i <= n) {
-//            addRightCnt(arr[i] + 1);
-//        }
 //        for (int q = headr[i]; q > 0; q = nextq[q]) {
 //            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 //            long long ret = 0;
@@ -223,6 +220,9 @@
 //            }
 //            ans[id] += ret * op;
 //        }
+//        if (i <= n) {
+//            addRightCnt(arr[i] + 1);
+//        }
 //    }
 //}
 //

From db84838385de3bb6ca3985f475b4d7b1fd6d6c86 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 10:50:44 +0800
Subject: [PATCH 1375/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 19 +++++++++----------
 src/class178/Code01_MoOfflineTwice2.java | 16 ++++++++--------
 2 files changed, 17 insertions(+), 18 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index a87cd9112..85a47aaea 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -24,17 +24,16 @@ public class Code01_MoOfflineTwice1 {
 	public static int cntk;
 
 	// 莫队任务，l、r、id
-	// 第二次离线任务，pos、id、l、r、op
 	public static int[][] query = new int[MAXN][3];
 
-	// 第二次离线任务，x、id、l、r、op
+	// 第二次离线任务，x、l、r、op、id
 	// 位置x的任务列表用链式前向星表示
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
-	public static int[] qid = new int[MAXN << 1];
 	public static int[] ql = new int[MAXN << 1];
 	public static int[] qr = new int[MAXN << 1];
 	public static int[] qop = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
 	public static int[] bi = new int[MAXN];
@@ -62,13 +61,13 @@ public static int countOne(int num) {
 		return ret;
 	}
 
-	public static void addOffline(int x, int id, int l, int r, int op) {
+	public static void addOffline(int x, int l, int r, int op, int id) {
 		nextq[++cntq] = headq[x];
 		headq[x] = cntq;
-		qid[cntq] = id;
 		ql[cntq] = l;
 		qr[cntq] = r;
 		qop[cntq] = op;
+		qid[cntq] = id;
 	}
 
 	public static void prepare() {
@@ -97,20 +96,20 @@ public static void compute() {
 			int jobr = query[i][1];
 			int id = query[i][2];
 			if (winr < jobr) {
-				addOffline(winl - 1, id, winr + 1, jobr, -1);
+				addOffline(winl - 1, winr + 1, jobr, -1, id);
 				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
-				addOffline(winl - 1, id, jobr + 1, winr, 1);
+				addOffline(winl - 1, jobr + 1, winr, 1, id);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addOffline(winr, id, jobl, winl - 1, 1);
+				addOffline(winr, jobl, winl - 1, 1, id);
 				ans[id] -= pre[winl - 1] - pre[jobl - 1];
 			}
 			if (winl < jobl) {
-				addOffline(winr, id, winl, jobl - 1, -1);
+				addOffline(winr, winl, jobl - 1, -1, id);
 				ans[id] += pre[jobl - 1] - pre[winl - 1];
 			}
 			winl = jobl;
@@ -124,7 +123,7 @@ public static void compute() {
 				}
 			}
 			for (int q = headq[i]; q > 0; q = nextq[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
 					// 计算j 对 1..i范围的贡献
 					// 此时1..i范围上的数字都更新过cnt
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index cdc0c735f..8ef6ead48 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -24,10 +24,10 @@
 //
 //int headq[MAXN];
 //int nextq[MAXN << 1];
-//int qid[MAXN << 1];
 //int ql[MAXN << 1];
 //int qr[MAXN << 1];
 //int qop[MAXN << 1];
+//int qid[MAXN << 1];
 //int cntq;
 //
 //int bi[MAXN];
@@ -52,13 +52,13 @@
 //    return ret;
 //}
 //
-//void addOffline(int x, int id, int l, int r, int op) {
+//void addOffline(int x, int l, int r, int op, int id) {
 //    nextq[++cntq] = headq[x];
 //    headq[x] = cntq;
-//    qid[cntq] = id;
 //    ql[cntq] = l;
 //    qr[cntq] = r;
 //    qop[cntq] = op;
+//    qid[cntq] = id;
 //}
 //
 //void prepare() {
@@ -87,20 +87,20 @@
 //        int jobr = query[i].r;
 //        int id = query[i].id;
 //        if (winr < jobr) {
-//            addOffline(winl - 1, id, winr + 1, jobr, -1);
+//            addOffline(winl - 1, winr + 1, jobr, -1, id);
 //            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
-//            addOffline(winl - 1, id, jobr + 1, winr, 1);
+//            addOffline(winl - 1, jobr + 1, winr, 1, id);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addOffline(winr, id, jobl, winl - 1, 1);
+//            addOffline(winr, jobl, winl - 1, 1, id);
 //            ans[id] -= pre[winl - 1] - pre[jobl - 1];
 //        }
 //        if (winl < jobl) {
-//            addOffline(winr, id, winl, jobl - 1, -1);
+//            addOffline(winr, winl, jobl - 1, -1, id);
 //            ans[id] += pre[jobl - 1] - pre[winl - 1];
 //        }
 //        winl = jobl;
@@ -113,7 +113,7 @@
 //            }
 //        }
 //        for (int q = headq[i]; q > 0; q = nextq[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
 //                if (j <= i && k == 0) {
 //                    ans[id] += 1LL * op * (cnt[arr[j]] - 1);

From e3d43da2fae2064607d71318f6ba13af60c2f3be Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 10:53:55 +0800
Subject: [PATCH 1376/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 10 +++++-----
 src/class178/Code02_OfflineInversion2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index bd2375f4d..c9b1f31e1 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -198,11 +198,11 @@ public static void compute() {
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addRightOffline(winr, id, jobl, winl - 1, -1);
+				addRightOffline(winr + 1, id, jobl, winl - 1, -1);
 				ans[id] += suf[jobl] - suf[winl];
 			}
 			if (winl < jobl) {
-				addRightOffline(winr, id, winl, jobl - 1, 1);
+				addRightOffline(winr + 1, id, winl, jobl - 1, 1);
 				ans[id] -= suf[winl] - suf[jobl];
 			}
 			winl = jobl;
@@ -223,6 +223,9 @@ public static void compute() {
 		Arrays.fill(lazy, 0);
 		Arrays.fill(cnt, 0);
 		for (int i = n + 1; i >= 1; i--) {
+			if (i <= n) {
+				addRightCnt(arr[i] + 1);
+			}
 			for (int q = headr[i]; q > 0; q = nextq[q]) {
 				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 				long ret = 0;
@@ -231,9 +234,6 @@ public static void compute() {
 				}
 				ans[id] += ret * op;
 			}
-			if (i <= n) {
-				addRightCnt(arr[i] + 1);
-			}
 		}
 	}
 
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 405f83802..db0740fef 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -187,11 +187,11 @@
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addRightOffline(winr, id, jobl, winl - 1, -1);
+//            addRightOffline(winr + 1, id, jobl, winl - 1, -1);
 //            ans[id] += suf[jobl] - suf[winl];
 //        }
 //        if (winl < jobl) {
-//            addRightOffline(winr, id, winl, jobl - 1, 1);
+//            addRightOffline(winr + 1, id, winl, jobl - 1, 1);
 //            ans[id] -= suf[winl] - suf[jobl];
 //        }
 //        winl = jobl;
@@ -212,6 +212,9 @@
 //    memset(lazy, 0, sizeof(lazy));
 //    memset(cnt, 0, sizeof(cnt));
 //    for (int i = n + 1; i >= 1; i--) {
+//        if (i <= n) {
+//            addRightCnt(arr[i] + 1);
+//        }
 //        for (int q = headr[i]; q > 0; q = nextq[q]) {
 //            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
 //            long long ret = 0;
@@ -220,9 +223,6 @@
 //            }
 //            ans[id] += ret * op;
 //        }
-//        if (i <= n) {
-//            addRightCnt(arr[i] + 1);
-//        }
 //    }
 //}
 //

From 5b40e7b2e4a55af4ba82dbeaec3fde4c4b0f53f2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 10:58:34 +0800
Subject: [PATCH 1377/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 22 +++++++++++-----------
 src/class178/Code02_OfflineInversion2.java | 22 +++++++++++-----------
 2 files changed, 22 insertions(+), 22 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index c9b1f31e1..6303a2149 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -28,10 +28,10 @@ public class Code02_OfflineInversion1 {
 	public static int[] headl = new int[MAXN];
 	public static int[] headr = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
-	public static int[] qid = new int[MAXN << 1];
 	public static int[] ql = new int[MAXN << 1];
 	public static int[] qr = new int[MAXN << 1];
 	public static int[] qop = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
 	// bi用于序列分块、值域分块，bl和br用于值域分块
@@ -101,22 +101,22 @@ public static void clear() {
 		Arrays.fill(tree, 1, cntv + 1, 0);
 	}
 
-	public static void addLeftOffline(int x, int id, int l, int r, int op) {
+	public static void addLeftOffline(int x, int l, int r, int op, int id) {
 		nextq[++cntq] = headl[x];
 		headl[x] = cntq;
-		qid[cntq] = id;
 		ql[cntq] = l;
 		qr[cntq] = r;
 		qop[cntq] = op;
+		qid[cntq] = id;
 	}
 
-	public static void addRightOffline(int x, int id, int l, int r, int op) {
+	public static void addRightOffline(int x, int l, int r, int op, int id) {
 		nextq[++cntq] = headr[x];
 		headr[x] = cntq;
-		qid[cntq] = id;
 		ql[cntq] = l;
 		qr[cntq] = r;
 		qop[cntq] = op;
+		qid[cntq] = id;
 	}
 
 	public static void addLeftCnt(int val) {
@@ -189,20 +189,20 @@ public static void compute() {
 			int jobr = query[i][1];
 			int id = query[i][2];
 			if (winr < jobr) {
-				addLeftOffline(winl - 1, id, winr + 1, jobr, -1);
+				addLeftOffline(winl - 1, winr + 1, jobr, -1, id);
 				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
-				addLeftOffline(winl - 1, id, jobr + 1, winr, 1);
+				addLeftOffline(winl - 1, jobr + 1, winr, 1, id);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addRightOffline(winr + 1, id, jobl, winl - 1, -1);
+				addRightOffline(winr + 1, jobl, winl - 1, -1, id);
 				ans[id] += suf[jobl] - suf[winl];
 			}
 			if (winl < jobl) {
-				addRightOffline(winr + 1, id, winl, jobl - 1, 1);
+				addRightOffline(winr + 1, winl, jobl - 1, 1, id);
 				ans[id] -= suf[winl] - suf[jobl];
 			}
 			winl = jobl;
@@ -212,7 +212,7 @@ public static void compute() {
 				addLeftCnt(arr[i] - 1);
 			}
 			for (int q = headl[i]; q > 0; q = nextq[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
@@ -227,7 +227,7 @@ public static void compute() {
 				addRightCnt(arr[i] + 1);
 			}
 			for (int q = headr[i]; q > 0; q = nextq[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
 					ret += getCnt(arr[j]);
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index db0740fef..73842ba6a 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -26,10 +26,10 @@
 //int headl[MAXN];
 //int headr[MAXN];
 //int nextq[MAXN << 1];
-//int qid[MAXN << 1];
 //int ql[MAXN << 1];
 //int qr[MAXN << 1];
 //int qop[MAXN << 1];
+//int qid[MAXN << 1];
 //int cntq;
 //
 //int bi[MAXN];
@@ -90,22 +90,22 @@
 //    memset(tree + 1, 0, cntv * sizeof(int));
 //}
 //
-//void addLeftOffline(int x, int id, int l, int r, int op) {
+//void addLeftOffline(int x, int l, int r, int op, int id) {
 //    nextq[++cntq] = headl[x];
 //    headl[x] = cntq;
-//    qid[cntq] = id;
 //    ql[cntq] = l;
 //    qr[cntq] = r;
 //    qop[cntq] = op;
+//    qid[cntq] = id;
 //}
 //
-//void addRightOffline(int x, int id, int l, int r, int op) {
+//void addRightOffline(int x, int l, int r, int op, int id) {
 //    nextq[++cntq] = headr[x];
 //    headr[x] = cntq;
-//    qid[cntq] = id;
 //    ql[cntq] = l;
 //    qr[cntq] = r;
 //    qop[cntq] = op;
+//    qid[cntq] = id;
 //}
 //
 //void addLeftCnt(int val) {
@@ -178,20 +178,20 @@
 //        int jobr = query[i].r;
 //        int id = query[i].id;
 //        if (winr < jobr) {
-//            addLeftOffline(winl - 1, id, winr + 1, jobr, -1);
+//            addLeftOffline(winl - 1, winr + 1, jobr, -1, id);
 //            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
-//            addLeftOffline(winl - 1, id, jobr + 1, winr, 1);
+//            addLeftOffline(winl - 1, jobr + 1, winr, 1, id);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addRightOffline(winr + 1, id, jobl, winl - 1, -1);
+//            addRightOffline(winr + 1, jobl, winl - 1, -1, id);
 //            ans[id] += suf[jobl] - suf[winl];
 //        }
 //        if (winl < jobl) {
-//            addRightOffline(winr + 1, id, winl, jobl - 1, 1);
+//            addRightOffline(winr + 1, winl, jobl - 1, 1, id);
 //            ans[id] -= suf[winl] - suf[jobl];
 //        }
 //        winl = jobl;
@@ -201,7 +201,7 @@
 //            addLeftCnt(arr[i] - 1);
 //        }
 //        for (int q = headl[i]; q > 0; q = nextq[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);
@@ -216,7 +216,7 @@
 //            addRightCnt(arr[i] + 1);
 //        }
 //        for (int q = headr[i]; q > 0; q = nextq[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
 //                ret += getCnt(arr[j]);

From b94ddf3f2e3a30bcce47ada5b8b0c3a80eb687e8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:05:38 +0800
Subject: [PATCH 1378/1712] modify code

---
 src/class178/Code03_Abbi1.java | 16 ++++++++--------
 src/class178/Code03_Abbi2.java | 30 ++++++++++++++----------------
 2 files changed, 22 insertions(+), 24 deletions(-)

diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index b2db74069..610728cf7 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -26,10 +26,10 @@ public class Code03_Abbi1 {
 
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
-	public static int[] qid = new int[MAXN << 1];
 	public static int[] ql = new int[MAXN << 1];
 	public static int[] qr = new int[MAXN << 1];
 	public static int[] qop = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
 	public static long[] treeCnt = new long[MAXV + 1];
@@ -53,13 +53,13 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
-	public static void addOffline(int x, int id, int l, int r, int op) {
+	public static void addOffline(int x, int l, int r, int op, int id) {
 		nextq[++cntq] = headq[x];
 		headq[x] = cntq;
-		qid[cntq] = id;
 		ql[cntq] = l;
 		qr[cntq] = r;
 		qop[cntq] = op;
+		qid[cntq] = id;
 	}
 
 	public static int lowbit(int x) {
@@ -137,20 +137,20 @@ public static void compute() {
 			int jobr = query[i][1];
 			int id = query[i][2];
 			if (winr < jobr) {
-				addOffline(winl - 1, id, winr + 1, jobr, -1);
+				addOffline(winl - 1, winr + 1, jobr, -1, id);
 				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
-				addOffline(winl - 1, id, jobr + 1, winr, 1);
+				addOffline(winl - 1, jobr + 1, winr, 1, id);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addOffline(winr, id, jobl, winl - 1, 1);
+				addOffline(winr, jobl, winl - 1, 1, id);
 				ans[id] -= pre[winl - 1] - pre[jobl - 1];
 			}
 			if (winl < jobl) {
-				addOffline(winr, id, winl, jobl - 1, -1);
+				addOffline(winr, winl, jobl - 1, -1, id);
 				ans[id] += pre[jobl - 1] - pre[winl - 1];
 			}
 			winl = jobl;
@@ -163,7 +163,7 @@ public static void compute() {
 				sum += arr[i];
 			}
 			for (int q = headq[i]; q > 0; q = nextq[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
 					tmp = (long) getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
 					if (op == 1) {
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 7368439e1..65e6a773b 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -27,10 +27,10 @@
 //
 //int headq[MAXN];
 //int nextq[MAXN << 1];
-//int qid[MAXN << 1];
 //int ql[MAXN << 1];
 //int qr[MAXN << 1];
 //int qop[MAXN << 1];
+//int qid[MAXN << 1];
 //int cntq;
 //
 //long long treeCnt[MAXV + 1];
@@ -51,27 +51,27 @@
 //    return a.r < b.r;
 //}
 //
-//void addOffline(int x, int id, int l, int r, int op) {
+//void addOffline(int x, int l, int r, int op, int id) {
 //    nextq[++cntq] = headq[x];
 //    headq[x] = cntq;
-//    qid[cntq] = id;
 //    ql[cntq] = l;
 //    qr[cntq] = r;
 //    qop[cntq] = op;
+//    qid[cntq] = id;
 //}
 //
 //int lowbit(int x) {
 //    return x & -x;
 //}
 //
-//void bitAdd(long long *tree, int x, long long v) {
+//void add(long long *tree, int x, long long v) {
 //    while (x <= MAXV) {
 //        tree[x] += v;
 //        x += lowbit(x);
 //    }
 //}
 //
-//long long bitSum(long long *tree, int x) {
+//long long sum(long long *tree, int x) {
 //    long long ret = 0;
 //    while (x > 0) {
 //        ret += tree[x];
@@ -112,7 +112,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        presum[i] = presum[i - 1] + arr[i];
 //    }
-//    int blen = (int)std::sqrt(MAXV);
+//    int blen = (int)sqrt(MAXV);
 //    int bnum = (MAXV + blen - 1) / blen;
 //    for (int i = 1; i <= MAXV; i++) {
 //        bi[i] = (i - 1) / blen + 1;
@@ -125,11 +125,9 @@
 //
 //void compute() {
 //    for (int i = 1; i <= n; i++) {
-//        pre[i] = pre[i - 1]
-//               + bitSum(treeCnt, arr[i] - 1) * arr[i]
-//               + bitSum(treeSum, MAXV) - bitSum(treeSum, arr[i]);
-//        bitAdd(treeCnt, arr[i], 1);
-//        bitAdd(treeSum, arr[i], arr[i]);
+//        pre[i] = pre[i - 1] + sum(treeCnt, arr[i] - 1) * arr[i] + sum(treeSum, MAXV) - sum(treeSum, arr[i]);
+//        add(treeCnt, arr[i], 1);
+//        add(treeSum, arr[i], arr[i]);
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
@@ -137,20 +135,20 @@
 //        int jobr = query[i].r;
 //        int id = query[i].id;
 //        if (winr < jobr) {
-//            addOffline(winl - 1, id, winr + 1, jobr, -1);
+//            addOffline(winl - 1, winr + 1, jobr, -1, id);
 //            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
-//            addOffline(winl - 1, id, jobr + 1, winr, 1);
+//            addOffline(winl - 1, jobr + 1, winr, 1, id);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addOffline(winr, id, jobl, winl - 1, 1);
+//            addOffline(winr, jobl, winl - 1, 1, id);
 //            ans[id] -= pre[winl - 1] - pre[jobl - 1];
 //        }
 //        if (winl < jobl) {
-//            addOffline(winr, id, winl, jobl - 1, -1);
+//            addOffline(winr, winl, jobl - 1, -1, id);
 //            ans[id] += pre[jobl - 1] - pre[winl - 1];
 //        }
 //        winl = jobl;
@@ -163,7 +161,7 @@
 //            sum += arr[i];
 //        }
 //        for (int q = headq[i]; q > 0; q = nextq[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
 //                tmp = 1LL * getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
 //                if (op == 1) {

From 2ae5f60fc2eaf0025374b79a73e8aa8a233437e3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:13:15 +0800
Subject: [PATCH 1379/1712] modify code

---
 src/class178/Code04_Gosick1.java | 18 +++++++++---------
 src/class178/Code04_Gosick2.java | 18 +++++++++---------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index e27fa0eba..3b5541dad 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -32,10 +32,10 @@ public class Code04_Gosick1 {
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
 	public static int[] qx = new int[MAXN << 1];
-	public static int[] qid = new int[MAXN << 1];
 	public static int[] ql = new int[MAXN << 1];
 	public static int[] qr = new int[MAXN << 1];
 	public static int[] qop = new int[MAXN << 1];
+	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
 	public static int[] fcnt = new int[MAXN];
@@ -69,14 +69,14 @@ public static void addFactors(int num) {
 		}
 	}
 
-	public static void addOffline(int x, int id, int l, int r, int op) {
+	public static void addOffline(int x, int l, int r, int op, int id) {
 		nextq[++cntq] = headq[x];
 		headq[x] = cntq;
 		qx[cntq] = x;
-		qid[cntq] = id;
 		ql[cntq] = l;
 		qr[cntq] = r;
 		qop[cntq] = op;
+		qid[cntq] = id;
 	}
 
 	public static void compute() {
@@ -101,20 +101,20 @@ public static void compute() {
 			int jobr = query[i][1];
 			int id = query[i][2];
 			if (winr < jobr) {
-				addOffline(winl - 1, id, winr + 1, jobr, -1);
+				addOffline(winl - 1, winr + 1, jobr, -1, id);
 				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
-				addOffline(winl - 1, id, jobr + 1, winr, 1);
+				addOffline(winl - 1, jobr + 1, winr, 1, id);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addOffline(winr, id, jobl, winl - 1, 1);
+				addOffline(winr, jobl, winl - 1, 1, id);
 				ans[id] -= pre[winl - 1] - pre[jobl - 1];
 			}
 			if (winl < jobl) {
-				addOffline(winr, id, winl, jobl - 1, -1);
+				addOffline(winr, winl, jobl - 1, -1, id);
 				ans[id] += pre[jobl - 1] - pre[winl - 1];
 			}
 			winl = jobl;
@@ -138,7 +138,7 @@ public static void compute() {
 				}
 			}
 			for (int q = headq[i]; q > 0; q = nextq[q]) {
-				int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
 					ans[id] += (long) op * fcnt[arr[j]];
 				}
@@ -151,7 +151,7 @@ public static void compute() {
 				cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 			}
 			for (int i = 1; i <= cntq; i++) {
-				int x = qx[i], id = qid[i], l = ql[i], r = qr[i], op = qop[i];
+				int x = qx[i], l = ql[i], r = qr[i], op = qop[i], id = qid[i];
 				ans[id] += (long) op * cnt1[x] * (cnt2[r] - cnt2[l - 1]);
 			}
 		}
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 7d8757ee1..cb44b59c2 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -30,10 +30,10 @@
 //int headq[MAXN];
 //int nextq[MAXN << 1];
 //int qx[MAXN << 1];
-//int qid[MAXN << 1];
 //int ql[MAXN << 1];
 //int qr[MAXN << 1];
 //int qop[MAXN << 1];
+//int qid[MAXN << 1];
 //int cntq;
 //
 //int fcnt[MAXN];
@@ -64,14 +64,14 @@
 //    }
 //}
 //
-//void addOffline(int x, int id, int l, int r, int op) {
+//void addOffline(int x, int l, int r, int op, int id) {
 //    nextq[++cntq] = headq[x];
 //    headq[x] = cntq;
 //    qx[cntq] = x;
-//    qid[cntq] = id;
 //    ql[cntq] = l;
 //    qr[cntq] = r;
 //    qop[cntq] = op;
+//    qid[cntq] = id;
 //}
 //
 //void compute() {
@@ -96,20 +96,20 @@
 //        int jobr = query[i].r;
 //        int id = query[i].id;
 //        if (winr < jobr) {
-//            addOffline(winl - 1, id, winr + 1, jobr, -1);
+//            addOffline(winl - 1, winr + 1, jobr, -1, id);
 //            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
-//            addOffline(winl - 1, id, jobr + 1, winr, 1);
+//            addOffline(winl - 1, jobr + 1, winr, 1, id);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addOffline(winr, id, jobl, winl - 1, 1);
+//            addOffline(winr, jobl, winl - 1, 1, id);
 //            ans[id] -= pre[winl - 1] - pre[jobl - 1];
 //        }
 //        if (winl < jobl) {
-//            addOffline(winr, id, winl, jobl - 1, -1);
+//            addOffline(winr, winl, jobl - 1, -1, id);
 //            ans[id] += pre[jobl - 1] - pre[winl - 1];
 //        }
 //        winl = jobl;
@@ -133,7 +133,7 @@
 //            }
 //        }
 //        for (int q = headq[i]; q > 0; q = nextq[q]) {
-//            int id = qid[q], l = ql[q], r = qr[q], op = qop[q];
+//            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
 //                ans[id] += 1LL * op * fcnt[arr[j]];
 //            }
@@ -147,7 +147,7 @@
 //            cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 //        }
 //        for(int i = 1; i <= cntq; i++) {
-//             int x = qx[i], id = qid[i], l = ql[i], r = qr[i], op = qop[i];
+//             int x = qx[i], l = ql[i], r = qr[i], op = qop[i], id = qid[i];
 //             ans[id] += 1LL * op * cnt1[x] * (cnt2[r] - cnt2[l - 1]);
 //        }
 //    }

From c5b11d42409462efefa46064ecd58349a58f906f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:17:40 +0800
Subject: [PATCH 1380/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 6 +++++-
 src/class178/Code01_MoOfflineTwice2.java | 6 +++++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 85a47aaea..5d730a7c8 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -52,11 +52,15 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
 	public static int countOne(int num) {
 		int ret = 0;
 		while (num > 0) {
 			ret++;
-			num -= num & -num;
+			num -= lowbit(num);
 		}
 		return ret;
 	}
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index 8ef6ead48..9790edbe5 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -43,11 +43,15 @@
 //    return a.r < b.r;
 //}
 //
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
 //int countOne(int num) {
 //    int ret = 0;
 //    while (num > 0) {
 //        ret++;
-//        num -= num & -num;
+//        num -= lowbit(num);
 //    }
 //    return ret;
 //}

From dae3c686fd431979a27c49bb9e1e4555bbb3277c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:27:28 +0800
Subject: [PATCH 1381/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 29 +++++++++++-----------
 src/class178/Code02_OfflineInversion2.java | 27 ++++++++++----------
 src/class178/Code03_Abbi1.java             |  1 -
 src/class178/Code03_Abbi2.java             |  1 -
 4 files changed, 27 insertions(+), 31 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 6303a2149..385c6818f 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -24,7 +24,6 @@ public class Code02_OfflineInversion1 {
 	public static int cntv;
 
 	public static int[][] query = new int[MAXN][3];
-
 	public static int[] headl = new int[MAXN];
 	public static int[] headr = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
@@ -46,10 +45,10 @@ public class Code02_OfflineInversion1 {
 	// 后缀信息
 	public static long[] suf = new long[MAXN];
 
+	// 整块加了多少词频
+	public static long[] cnt1 = new long[MAXB];
 	// 每种值加了多少词频
-	public static long[] cnt = new long[MAXN];
-	// 块的懒信息，整块加了多少词频
-	public static long[] lazy = new long[MAXB];
+	public static long[] cnt2 = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -123,11 +122,11 @@ public static void addLeftCnt(int val) {
 		if (val <= 0) {
 			return;
 		}
-		for (int i = bl[bi[val]]; i <= val; i++) {
-			cnt[i]++;
-		}
 		for (int b = 1; b <= bi[val] - 1; b++) {
-			lazy[b]++;
+			cnt1[b]++;
+		}
+		for (int i = bl[bi[val]]; i <= val; i++) {
+			cnt2[i]++;
 		}
 	}
 
@@ -135,16 +134,16 @@ public static void addRightCnt(int val) {
 		if (val > cntv) {
 			return;
 		}
-		for (int i = val; i <= br[bi[val]]; i++) {
-			cnt[i]++;
-		}
 		for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
-			lazy[b]++;
+			cnt1[b]++;
+		}
+		for (int i = val; i <= br[bi[val]]; i++) {
+			cnt2[i]++;
 		}
 	}
 
 	public static long getCnt(int val) {
-		return cnt[val] + lazy[bi[val]];
+		return cnt1[bi[val]] + cnt2[val];
 	}
 
 	public static void prepare() {
@@ -220,8 +219,8 @@ public static void compute() {
 				ans[id] += ret * op;
 			}
 		}
-		Arrays.fill(lazy, 0);
-		Arrays.fill(cnt, 0);
+		Arrays.fill(cnt1, 0);
+		Arrays.fill(cnt2, 0);
 		for (int i = n + 1; i >= 1; i--) {
 			if (i <= n) {
 				addRightCnt(arr[i] + 1);
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 73842ba6a..862f6de45 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -22,7 +22,6 @@
 //int cntv;
 //
 //Query query[MAXN];
-//
 //int headl[MAXN];
 //int headr[MAXN];
 //int nextq[MAXN << 1];
@@ -40,8 +39,8 @@
 //long long pre[MAXN];
 //long long suf[MAXN];
 //
-//long long cnt[MAXN];
-//long long lazy[MAXB];
+//long long cnt1[MAXB];
+//long long cnt2[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -112,11 +111,11 @@
 //    if (val <= 0) {
 //        return;
 //    }
-//    for (int i = bl[bi[val]]; i <= val; i++) {
-//        cnt[i]++;
-//    }
 //    for (int b = 1; b <= bi[val] - 1; b++) {
-//        lazy[b]++;
+//        cnt1[b]++;
+//    }
+//    for (int i = bl[bi[val]]; i <= val; i++) {
+//        cnt2[i]++;
 //    }
 //}
 //
@@ -124,16 +123,16 @@
 //    if (val > cntv) {
 //        return;
 //    }
-//    for (int i = val; i <= br[bi[val]]; i++) {
-//        cnt[i]++;
-//    }
 //    for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
-//        lazy[b]++;
+//        cnt1[b]++;
+//    }
+//    for (int i = val; i <= br[bi[val]]; i++) {
+//        cnt2[i]++;
 //    }
 //}
 //
 //long long getCnt(int val) {
-//    return cnt[val] + lazy[bi[val]];
+//    return cnt1[bi[val]] + cnt2[val];
 //}
 //
 //void prepare() {
@@ -209,8 +208,8 @@
 //            ans[id] += ret * op;
 //        }
 //    }
-//    memset(lazy, 0, sizeof(lazy));
-//    memset(cnt, 0, sizeof(cnt));
+//    memset(cnt1, 0, sizeof(cnt1));
+//    memset(cnt2, 0, sizeof(cnt2));
 //    for (int i = n + 1; i >= 1; i--) {
 //        if (i <= n) {
 //            addRightCnt(arr[i] + 1);
diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 610728cf7..1bd413d0b 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -23,7 +23,6 @@ public class Code03_Abbi1 {
 	public static int[] br = new int[MAXB];
 
 	public static int[][] query = new int[MAXN][3];
-
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
 	public static int[] ql = new int[MAXN << 1];
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 65e6a773b..ec1043163 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -24,7 +24,6 @@
 //int br[MAXB];
 //
 //Query query[MAXN];
-//
 //int headq[MAXN];
 //int nextq[MAXN << 1];
 //int ql[MAXN << 1];

From 6287152e3e1f1e74c25d11354a786f778e0f58cd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:30:02 +0800
Subject: [PATCH 1382/1712] modify code

---
 src/class178/Code03_Abbi1.java | 2 +-
 src/class178/Code03_Abbi2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 1bd413d0b..9b514c514 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -33,8 +33,8 @@ public class Code03_Abbi1 {
 
 	public static long[] treeCnt = new long[MAXV + 1];
 	public static long[] treeSum = new long[MAXV + 1];
-
 	public static long[] pre = new long[MAXN];
+
 	public static int[] cnt1 = new int[MAXB];
 	public static int[] cnt2 = new int[MAXN];
 	public static long[] sum1 = new long[MAXB];
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index ec1043163..b164b9d2c 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -34,8 +34,8 @@
 //
 //long long treeCnt[MAXV + 1];
 //long long treeSum[MAXV + 1];
-//
 //long long pre[MAXN];
+//
 //int cnt1[MAXB];
 //int cnt2[MAXN];
 //long long sum1[MAXB];

From 02e5f0e9402acff311dc0d6831c35764ff20f98f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:32:51 +0800
Subject: [PATCH 1383/1712] modify code

---
 src/class178/Code04_Gosick1.java | 3 ++-
 src/class178/Code04_Gosick2.java | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 3b5541dad..e840bda85 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -81,6 +81,7 @@ public static void addOffline(int x, int l, int r, int op, int id) {
 
 	public static void compute() {
 		for (int i = 1, x; i <= n; i++) {
+			pre[i] = pre[i - 1];
 			x = arr[i];
 			for (int e = headf[x], f, other; e > 0; e = nextf[e]) {
 				f = fac[e];
@@ -92,7 +93,7 @@ public static void compute() {
 					pre[i] += xcnt[other];
 				}
 			}
-			pre[i] += fcnt[x] + pre[i - 1];
+			pre[i] += fcnt[x];
 			xcnt[x]++;
 		}
 		int winl = 1, winr = 0;
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index cb44b59c2..6999de829 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -76,6 +76,7 @@
 //
 //void compute() {
 //    for (int i = 1, x; i <= n; i++) {
+//        pre[i] = pre[i - 1];
 //        x = arr[i];
 //        for (int e = headf[x], f, other; e > 0; e = nextf[e]) {
 //            f = fac[e];
@@ -87,7 +88,7 @@
 //                pre[i] += xcnt[other];
 //            }
 //        }
-//        pre[i] += fcnt[x] + pre[i - 1];
+//        pre[i] += fcnt[x];
 //        xcnt[x]++;
 //    }
 //    int winl = 1, winr = 0;

From d3aa1084b2b62ad2ac5345f041c52cf507a2de0f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:35:47 +0800
Subject: [PATCH 1384/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 5d730a7c8..2514f46cb 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -26,7 +26,7 @@ public class Code01_MoOfflineTwice1 {
 	// 莫队任务，l、r、id
 	public static int[][] query = new int[MAXN][3];
 
-	// 第二次离线任务，x、l、r、op、id
+	// 离线任务，x、l、r、op、id
 	// 位置x的任务列表用链式前向星表示
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
@@ -94,6 +94,7 @@ public static void compute() {
 				cnt[arr[i] ^ kOneArr[j]]++;
 			}
 		}
+		// 第一次离线，执行莫队
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
@@ -118,7 +119,7 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
-		// 第二次离线
+		// 第二次离线，执行离线任务
 		Arrays.fill(cnt, 0);
 		for (int i = 0; i <= n; i++) {
 			if (i >= 1) {

From e0003172c75643746c9b35eb3706e5a64e8d8a1f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:39:02 +0800
Subject: [PATCH 1385/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 3 ++-
 src/class178/Code02_OfflineInversion2.java | 3 ++-
 2 files changed, 4 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 385c6818f..c508b707a 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -1,6 +1,7 @@
 package class178;
 
-// 离线查询逆序对，java版
+// 允许离线查询逆序对，java版
+// 讲解173，题目4，必须在线查询区间逆序对，本题允许离线
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 862f6de45..ec830ba7d 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -1,6 +1,7 @@
 package class178;
 
-// 离线查询逆序对，C++版
+// 允许离线查询逆序对，C++版
+// 讲解173，题目4，必须在线查询区间逆序对，本题允许离线
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 51822e60e633deedc421b0aa4128d1c9e93d423d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 11:41:23 +0800
Subject: [PATCH 1386/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 2 +-
 src/class178/Code02_OfflineInversion2.java | 2 +-
 src/class178/Code03_Abbi1.java             | 2 +-
 src/class178/Code03_Abbi2.java             | 2 +-
 src/class178/Code04_Gosick1.java           | 2 +-
 src/class178/Code04_Gosick2.java           | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index c508b707a..e06b34e81 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 允许离线查询逆序对，java版
+// 区间逆序对，java版
 // 讲解173，题目4，必须在线查询区间逆序对，本题允许离线
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 提交以下的code，提交时请把类名改成"Main"
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index ec830ba7d..b884e64aa 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 允许离线查询逆序对，C++版
+// 区间逆序对，C++版
 // 讲解173，题目4，必须在线查询区间逆序对，本题允许离线
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 9b514c514..9cbc05296 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 查询Abbi值，java版
+// 区间Abbi值，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5501
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index b164b9d2c..1ee4d5729 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 查询Abbi值，C++版
+// 区间Abbi值，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P5501
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index e840bda85..463dd1d6c 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 查询倍数，java版
+// 区间倍数对，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 6999de829..4032a849b 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -1,6 +1,6 @@
 package class178;
 
-// 查询倍数，C++版
+// 区间倍数对，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 7346c09d1592efb912cfabb5ce5532aa643da8ec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 12:17:51 +0800
Subject: [PATCH 1387/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 4 +---
 src/class178/Code01_MoOfflineTwice2.java | 4 +---
 2 files changed, 2 insertions(+), 6 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 2514f46cb..dd9a49c36 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -20,12 +20,12 @@ public class Code01_MoOfflineTwice1 {
 	public static int MAXV = 1 << 14;
 	public static int n, m, k;
 	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
 	public static int[] kOneArr = new int[MAXV];
 	public static int cntk;
 
 	// 莫队任务，l、r、id
 	public static int[][] query = new int[MAXN][3];
-
 	// 离线任务，x、l、r、op、id
 	// 位置x的任务列表用链式前向星表示
 	public static int[] headq = new int[MAXN];
@@ -36,10 +36,8 @@ public class Code01_MoOfflineTwice1 {
 	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
-	public static int[] bi = new int[MAXN];
 	public static int[] cnt = new int[MAXV];
 	public static long[] pre = new long[MAXN];
-
 	public static long[] ans = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index 9790edbe5..ce2c2fed3 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -17,11 +17,11 @@
 //const int MAXV = 1 << 14;
 //int n, m, k;
 //int arr[MAXN];
+//int bi[MAXN];
 //int kOneArr[MAXV];
 //int cntk;
 //
 //Query query[MAXN];
-//
 //int headq[MAXN];
 //int nextq[MAXN << 1];
 //int ql[MAXN << 1];
@@ -30,10 +30,8 @@
 //int qid[MAXN << 1];
 //int cntq;
 //
-//int bi[MAXN];
 //int cnt[MAXV];
 //long long pre[MAXN];
-//
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {

From 257405886fbade83267847d38b41470e79910281 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 13:12:00 +0800
Subject: [PATCH 1388/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java   | 6 ++++++
 src/class178/Code01_MoOfflineTwice2.java   | 6 ++++++
 src/class178/Code02_OfflineInversion1.java | 6 +++++-
 src/class178/Code02_OfflineInversion2.java | 6 +++++-
 src/class178/Code03_Abbi1.java             | 7 +++++++
 src/class178/Code03_Abbi2.java             | 7 +++++++
 src/class178/Code04_Gosick1.java           | 7 ++++++-
 src/class178/Code04_Gosick2.java           | 7 ++++++-
 8 files changed, 48 insertions(+), 4 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index dd9a49c36..7e4df9b1d 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -1,6 +1,12 @@
 package class178;
 
 // 莫队二次离线入门题，java版
+// 给定一个长度为n的数组arr，给定一个非负整数k，下面给出合法二元组的定义
+// 二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
+// 二元组(i, j)和(j, i)认为是同一个二元组，不要重复统计
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少合法二元组
+// 1 <= n、m <= 10^5
+// 0 <= arr[i]、k < 16384(2的14次方)
 // 测试链接 : https://www.luogu.com.cn/problem/P4887
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index ce2c2fed3..4b6d528fd 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -1,6 +1,12 @@
 package class178;
 
 // 莫队二次离线入门题，C++版
+// 给定一个长度为n的数组arr，给定一个非负整数k，下面给出合法二元组的定义
+// 二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
+// 二元组(i, j)和(j, i)认为是同一个二元组，不要重复统计
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少合法二元组
+// 1 <= n、m <= 10^5
+// 0 <= arr[i]、k < 16384(2的14次方)
 // 测试链接 : https://www.luogu.com.cn/problem/P4887
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index e06b34e81..cc7ee9b5a 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -1,7 +1,11 @@
 package class178;
 
 // 区间逆序对，java版
-// 讲解173，题目4，必须在线查询区间逆序对，本题允许离线
+// 给定一个长度为n的数组arr，如果i < j，并且arr[i] > arr[j]，那么(i,j)就是逆序对
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，逆序对的数量
+// 1 <= n、m <= 10^5
+// 0 <= arr[i] <= 10^9
+// 本题允许离线，讲解173，题目4，讲了必须在线查询区间逆序对
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index b884e64aa..3aaf5ce8b 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -1,7 +1,11 @@
 package class178;
 
 // 区间逆序对，C++版
-// 讲解173，题目4，必须在线查询区间逆序对，本题允许离线
+// 给定一个长度为n的数组arr，如果i < j，并且arr[i] > arr[j]，那么(i,j)就是逆序对
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，逆序对的数量
+// 1 <= n、m <= 10^5
+// 0 <= arr[i] <= 10^9
+// 本题允许离线，讲解173，题目4，讲了必须在线查询区间逆序对
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 9cbc05296..d8ac48362 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -1,6 +1,13 @@
 package class178;
 
 // 区间Abbi值，java版
+// 给定一个长度为n的数组arr，区间Abbi值的定义如下
+// 如果arr[l..r]包含数字v，并且v是第k小，那么这个数字的Abbi值 = v * k
+// 区间Abbi值 = 区间内所有数字Abbi值的累加和
+// 比如[1, 2, 2, 3]的Abbi值 = 1 * 1 + 2 * 2 + 2 * 2 + 3 * 4 = 21
+// 一共有m条查询，格式为 l r : 打印arr[l..r]的区间Abbi值
+// 1 <= n、m <= 5 * 10^5
+// 1 <= arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5501
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 1ee4d5729..239f3022d 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -1,6 +1,13 @@
 package class178;
 
 // 区间Abbi值，C++版
+// 给定一个长度为n的数组arr，区间Abbi值的定义如下
+// 如果arr[l..r]包含数字v，并且v是第k小，那么这个数字的Abbi值 = v * k
+// 区间Abbi值 = 区间内所有数字Abbi值的累加和
+// 比如[1, 2, 2, 3]的Abbi值 = 1 * 1 + 2 * 2 + 2 * 2 + 3 * 4 = 21
+// 一共有m条查询，格式为 l r : 打印arr[l..r]的区间Abbi值
+// 1 <= n、m <= 5 * 10^5
+// 1 <= arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5501
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 463dd1d6c..8999c6f78 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -1,6 +1,11 @@
 package class178;
 
-// 区间倍数对，java版
+// 区间倍数二元组，java版
+// 给定一个长度为n的数组arr，下面给出倍数二元组的定义
+// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数，倍数>=1即可
+// 二元组(i, j)和(j, i)认为是不同的二元组，不要漏算
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
+// 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 4032a849b..77a911fe7 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -1,6 +1,11 @@
 package class178;
 
-// 区间倍数对，C++版
+// 区间倍数二元组，C++版
+// 给定一个长度为n的数组arr，下面给出倍数二元组的定义
+// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数，倍数>=1即可
+// 二元组(i, j)和(j, i)认为是不同的二元组，不要漏算
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
+// 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 2340fae31987395224e9279edfe262c4e142f0bb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 14:52:14 +0800
Subject: [PATCH 1389/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 4 ++--
 src/class178/Code01_MoOfflineTwice2.java | 4 ++--
 src/class178/Code04_Gosick1.java         | 5 +++--
 src/class178/Code04_Gosick2.java         | 4 ++--
 4 files changed, 9 insertions(+), 8 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 7e4df9b1d..efeef3c72 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -2,8 +2,8 @@
 
 // 莫队二次离线入门题，java版
 // 给定一个长度为n的数组arr，给定一个非负整数k，下面给出合法二元组的定义
-// 二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
-// 二元组(i, j)和(j, i)认为是同一个二元组，不要重复统计
+// 位置二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
+// 当i != j时，(i, j)和(j, i)认为是相同的二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少合法二元组
 // 1 <= n、m <= 10^5
 // 0 <= arr[i]、k < 16384(2的14次方)
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index 4b6d528fd..0f73cff26 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -2,8 +2,8 @@
 
 // 莫队二次离线入门题，C++版
 // 给定一个长度为n的数组arr，给定一个非负整数k，下面给出合法二元组的定义
-// 二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
-// 二元组(i, j)和(j, i)认为是同一个二元组，不要重复统计
+// 位置二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
+// 当i != j时，(i, j)和(j, i)认为是相同的二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少合法二元组
 // 1 <= n、m <= 10^5
 // 0 <= arr[i]、k < 16384(2的14次方)
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 8999c6f78..c9abfe466 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -2,8 +2,8 @@
 
 // 区间倍数二元组，java版
 // 给定一个长度为n的数组arr，下面给出倍数二元组的定义
-// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数，倍数>=1即可
-// 二元组(i, j)和(j, i)认为是不同的二元组，不要漏算
+// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数(>=1倍)
+// 当i != j时，(i, j)和(j, i)认为是不同的二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
 // 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
@@ -174,6 +174,7 @@ public static void prepare() {
 	}
 
 	public static void main(String[] args) throws Exception {
+		System.out.println("测试");
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 77a911fe7..bdebce0b0 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -2,8 +2,8 @@
 
 // 区间倍数二元组，C++版
 // 给定一个长度为n的数组arr，下面给出倍数二元组的定义
-// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数，倍数>=1即可
-// 二元组(i, j)和(j, i)认为是不同的二元组，不要漏算
+// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数(>=1倍)
+// 当i != j时，(i, j)和(j, i)认为是不同的二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
 // 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398

From 741e33e657514c37bba0ae0082b16ba5ab0de982 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 16:05:39 +0800
Subject: [PATCH 1390/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 3 +++
 src/class178/Code01_MoOfflineTwice2.java | 1 +
 2 files changed, 4 insertions(+)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index efeef3c72..75268dc36 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -42,8 +42,11 @@ public class Code01_MoOfflineTwice1 {
 	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
+	// cnt[v] : 当前的数字v作为第二个数，之前出现的数字作为第一个数，有多少合法的二元组
 	public static int[] cnt = new int[MAXV];
+	// pre[i] : 单点信息的前缀和，课上重点图解了
 	public static long[] pre = new long[MAXN];
+
 	public static long[] ans = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index 0f73cff26..b6fa69050 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -38,6 +38,7 @@
 //
 //int cnt[MAXV];
 //long long pre[MAXN];
+//
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {

From 22a02f5b5a5091fb42cde60ba6ce5b35abb773ee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 16:06:50 +0800
Subject: [PATCH 1391/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 75268dc36..31c1e1bba 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -42,7 +42,7 @@ public class Code01_MoOfflineTwice1 {
 	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
-	// cnt[v] : 当前的数字v作为第二个数，之前出现的数字作为第一个数，有多少合法的二元组
+	// cnt[v] : 当前的数字v作为第二个数，之前出现的数字作为第一个数，产生多少合法二元组
 	public static int[] cnt = new int[MAXV];
 	// pre[i] : 单点信息的前缀和，课上重点图解了
 	public static long[] pre = new long[MAXN];

From 18d7920def647bf02c3bc0635c7b66d8ba38d6d3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 16:27:55 +0800
Subject: [PATCH 1392/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 6 +++---
 src/class178/Code01_MoOfflineTwice2.java | 4 ++--
 2 files changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 31c1e1bba..539672608 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -1,10 +1,10 @@
 package class178;
 
 // 莫队二次离线入门题，java版
-// 给定一个长度为n的数组arr，给定一个非负整数k，下面给出合法二元组的定义
+// 给定一个长度为n的数组arr，给定一个非负整数k，下面给出k1二元组的定义
 // 位置二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
 // 当i != j时，(i, j)和(j, i)认为是相同的二元组
-// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少合法二元组
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少k1二元组
 // 1 <= n、m <= 10^5
 // 0 <= arr[i]、k < 16384(2的14次方)
 // 测试链接 : https://www.luogu.com.cn/problem/P4887
@@ -42,7 +42,7 @@ public class Code01_MoOfflineTwice1 {
 	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
-	// cnt[v] : 当前的数字v作为第二个数，之前出现的数字作为第一个数，产生多少合法二元组
+	// cnt[v] : 当前的数字v作为第二个数，之前出现的数字作为第一个数，产生多少k1二元组
 	public static int[] cnt = new int[MAXV];
 	// pre[i] : 单点信息的前缀和，课上重点图解了
 	public static long[] pre = new long[MAXN];
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index b6fa69050..ecea2506d 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -1,10 +1,10 @@
 package class178;
 
 // 莫队二次离线入门题，C++版
-// 给定一个长度为n的数组arr，给定一个非负整数k，下面给出合法二元组的定义
+// 给定一个长度为n的数组arr，给定一个非负整数k，下面给出k1二元组的定义
 // 位置二元组(i, j)，i和j必须是不同的，并且 arr[i]异或arr[j] 的二进制状态里有k个1
 // 当i != j时，(i, j)和(j, i)认为是相同的二元组
-// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少合法二元组
+// 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少k1二元组
 // 1 <= n、m <= 10^5
 // 0 <= arr[i]、k < 16384(2的14次方)
 // 测试链接 : https://www.luogu.com.cn/problem/P4887

From 07bf36a899ea0cabb55ed8c0a10fb78a9d676b9c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 20:10:26 +0800
Subject: [PATCH 1393/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 79 +++++++++++++++---------
 src/class178/Code01_MoOfflineTwice2.java | 67 ++++++++++++++------
 2 files changed, 99 insertions(+), 47 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 539672608..5be9ef09f 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -22,7 +22,7 @@
 
 public class Code01_MoOfflineTwice1 {
 
-	public static int MAXN = 100001;
+	public static int MAXN = 100002;
 	public static int MAXV = 1 << 14;
 	public static int n, m, k;
 	public static int[] arr = new int[MAXN];
@@ -32,9 +32,13 @@ public class Code01_MoOfflineTwice1 {
 
 	// 莫队任务，l、r、id
 	public static int[][] query = new int[MAXN][3];
+
 	// 离线任务，x、l、r、op、id
 	// 位置x的任务列表用链式前向星表示
-	public static int[] headq = new int[MAXN];
+	// headl是winr变动时，加入的离线任务
+	// headr是winl变动时，加入的离线任务
+	public static int[] headl = new int[MAXN];
+	public static int[] headr = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
 	public static int[] ql = new int[MAXN << 1];
 	public static int[] qr = new int[MAXN << 1];
@@ -44,8 +48,10 @@ public class Code01_MoOfflineTwice1 {
 
 	// cnt[v] : 当前的数字v作为第二个数，之前出现的数字作为第一个数，产生多少k1二元组
 	public static int[] cnt = new int[MAXV];
-	// pre[i] : 单点信息的前缀和，课上重点图解了
+	// 前缀和
 	public static long[] pre = new long[MAXN];
+	// 后缀和
+	public static long[] suf = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -72,9 +78,18 @@ public static int countOne(int num) {
 		return ret;
 	}
 
-	public static void addOffline(int x, int l, int r, int op, int id) {
-		nextq[++cntq] = headq[x];
-		headq[x] = cntq;
+	public static void addLeftOffline(int x, int l, int r, int op, int id) {
+		nextq[++cntq] = headl[x];
+		headl[x] = cntq;
+		ql[cntq] = l;
+		qr[cntq] = r;
+		qop[cntq] = op;
+		qid[cntq] = id;
+	}
+
+	public static void addRightOffline(int x, int l, int r, int op, int id) {
+		nextq[++cntq] = headr[x];
+		headr[x] = cntq;
 		ql[cntq] = l;
 		qr[cntq] = r;
 		qop[cntq] = op;
@@ -101,32 +116,38 @@ public static void compute() {
 				cnt[arr[i] ^ kOneArr[j]]++;
 			}
 		}
-		// 第一次离线，执行莫队
+		Arrays.fill(cnt, 0);
+		for (int i = n; i >= 1; i--) {
+			suf[i] = suf[i + 1] + cnt[arr[i]];
+			for (int j = 1; j <= cntk; j++) {
+				cnt[arr[i] ^ kOneArr[j]]++;
+			}
+		}
+		// 执行莫队
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
 			int id = query[i][2];
 			if (winr < jobr) {
-				addOffline(winl - 1, winr + 1, jobr, -1, id);
+				addLeftOffline(winl - 1, winr + 1, jobr, -1, id);
 				ans[id] += pre[jobr] - pre[winr];
 			}
 			if (winr > jobr) {
-				addOffline(winl - 1, jobr + 1, winr, 1, id);
+				addLeftOffline(winl - 1, jobr + 1, winr, 1, id);
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
 			if (winl > jobl) {
-				addOffline(winr, jobl, winl - 1, 1, id);
-				ans[id] -= pre[winl - 1] - pre[jobl - 1];
+				addRightOffline(winr + 1, jobl, winl - 1, -1, id);
+				ans[id] += suf[jobl] - suf[winl];
 			}
 			if (winl < jobl) {
-				addOffline(winr, winl, jobl - 1, -1, id);
-				ans[id] += pre[jobl - 1] - pre[winl - 1];
+				addRightOffline(winr + 1, winl, jobl - 1, 1, id);
+				ans[id] -= suf[winl] - suf[jobl];
 			}
 			winl = jobl;
 		}
-		// 第二次离线，执行离线任务
 		Arrays.fill(cnt, 0);
 		for (int i = 0; i <= n; i++) {
 			if (i >= 1) {
@@ -134,22 +155,24 @@ public static void compute() {
 					cnt[arr[i] ^ kOneArr[j]]++;
 				}
 			}
-			for (int q = headq[i]; q > 0; q = nextq[q]) {
+			for (int q = headl[i]; q > 0; q = nextq[q]) {
+				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
+				for (int j = l; j <= r; j++) {
+					ans[id] += (long) op * cnt[arr[j]];
+				}
+			}
+		}
+		Arrays.fill(cnt, 0);
+		for (int i = n + 1; i >= 1; i--) {
+			if (i <= n) {
+				for (int j = 1; j <= cntk; j++) {
+					cnt[arr[i] ^ kOneArr[j]]++;
+				}
+			}
+			for (int q = headr[i]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
-					// 计算j 对 1..i范围的贡献
-					// 此时1..i范围上的数字都更新过cnt
-					if (j <= i && k == 0) {
-						// j在1..i范围上，此时又有k==0
-						// 那么arr[j]一定更新过cnt，并且(arr[j], arr[j])一定算进贡献了
-						// 但是题目要求的二元组必须是不同位置，所以贡献要进行减1修正
-						ans[id] += (long) op * (cnt[arr[j]] - 1);
-					} else {
-						// 要么j不在1..i范围上，arr[j]没更新过cnt
-						// 要么k!=0，(arr[j], arr[j])无法被算成贡献
-						// 无论哪种情况，贡献都是正确的，不用进行减1修正
-						ans[id] += (long) op * cnt[arr[j]];
-					}
+					ans[id] += (long) op * cnt[arr[j]];
 				}
 			}
 		}
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index ecea2506d..535c0ac4d 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -19,7 +19,7 @@
 //    int l, r, id;
 //};
 //
-//const int MAXN = 100001;
+//const int MAXN = 100002;
 //const int MAXV = 1 << 14;
 //int n, m, k;
 //int arr[MAXN];
@@ -28,7 +28,9 @@
 //int cntk;
 //
 //Query query[MAXN];
-//int headq[MAXN];
+//
+//int headl[MAXN];
+//int headr[MAXN];
 //int nextq[MAXN << 1];
 //int ql[MAXN << 1];
 //int qr[MAXN << 1];
@@ -38,6 +40,7 @@
 //
 //int cnt[MAXV];
 //long long pre[MAXN];
+//long long suf[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -48,8 +51,8 @@
 //    return a.r < b.r;
 //}
 //
-//int lowbit(int i) {
-//    return i & -i;
+//int lowbit(int x) {
+//    return x & -x;
 //}
 //
 //int countOne(int num) {
@@ -61,9 +64,18 @@
 //    return ret;
 //}
 //
-//void addOffline(int x, int l, int r, int op, int id) {
-//    nextq[++cntq] = headq[x];
-//    headq[x] = cntq;
+//void addLeftOffline(int x, int l, int r, int op, int id) {
+//    nextq[++cntq] = headl[x];
+//    headl[x] = cntq;
+//    ql[cntq] = l;
+//    qr[cntq] = r;
+//    qop[cntq] = op;
+//    qid[cntq] = id;
+//}
+//
+//void addRightOffline(int x, int l, int r, int op, int id) {
+//    nextq[++cntq] = headr[x];
+//    headr[x] = cntq;
 //    ql[cntq] = l;
 //    qr[cntq] = r;
 //    qop[cntq] = op;
@@ -90,27 +102,34 @@
 //            cnt[arr[i] ^ kOneArr[j]]++;
 //        }
 //    }
+//    memset(cnt, 0, sizeof(cnt));
+//    for (int i = n; i >= 1; i--) {
+//        suf[i] = suf[i + 1] + cnt[arr[i]];
+//        for (int j = 1; j <= cntk; j++) {
+//            cnt[arr[i] ^ kOneArr[j]]++;
+//        }
+//    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
 //        int id = query[i].id;
 //        if (winr < jobr) {
-//            addOffline(winl - 1, winr + 1, jobr, -1, id);
+//            addLeftOffline(winl - 1, winr + 1, jobr, -1, id);
 //            ans[id] += pre[jobr] - pre[winr];
 //        }
 //        if (winr > jobr) {
-//            addOffline(winl - 1, jobr + 1, winr, 1, id);
+//            addLeftOffline(winl - 1, jobr + 1, winr, 1, id);
 //            ans[id] -= pre[winr] - pre[jobr];
 //        }
 //        winr = jobr;
 //        if (winl > jobl) {
-//            addOffline(winr, jobl, winl - 1, 1, id);
-//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
+//            addRightOffline(winr + 1, jobl, winl - 1, -1, id);
+//            ans[id] += suf[jobl] - suf[winl];
 //        }
 //        if (winl < jobl) {
-//            addOffline(winr, winl, jobl - 1, -1, id);
-//            ans[id] += pre[jobl - 1] - pre[winl - 1];
+//            addRightOffline(winr + 1, winl, jobl - 1, 1, id);
+//            ans[id] -= suf[winl] - suf[jobl];
 //        }
 //        winl = jobl;
 //    }
@@ -121,14 +140,24 @@
 //                cnt[arr[i] ^ kOneArr[j]]++;
 //            }
 //        }
-//        for (int q = headq[i]; q > 0; q = nextq[q]) {
+//        for (int q = headl[i]; q > 0; q = nextq[q]) {
+//            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
+//            for (int j = l; j <= r; j++) {
+//                ans[id] += 1LL * op * cnt[arr[j]];
+//            }
+//        }
+//    }
+//    memset(cnt, 0, sizeof(cnt));
+//    for (int i = n + 1; i >= 1; i--) {
+//        if (i <= n) {
+//            for (int j = 1; j <= cntk; j++) {
+//                cnt[arr[i] ^ kOneArr[j]]++;
+//            }
+//        }
+//        for (int q = headr[i]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
-//                if (j <= i && k == 0) {
-//                    ans[id] += 1LL * op * (cnt[arr[j]] - 1);
-//                } else {
-//                    ans[id] += 1LL * op * cnt[arr[j]];
-//                }
+//                ans[id] += 1LL * op * cnt[arr[j]];
 //            }
 //        }
 //    }

From 2f0c6c0e57a83cedbdb3a0ceb93ca1b057bf4ede Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 20:57:41 +0800
Subject: [PATCH 1394/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 5be9ef09f..6de10caa8 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -35,8 +35,8 @@ public class Code01_MoOfflineTwice1 {
 
 	// 离线任务，x、l、r、op、id
 	// 位置x的任务列表用链式前向星表示
-	// headl是winr变动时，加入的离线任务
-	// headr是winl变动时，加入的离线任务
+	// headl[x]，x在l~r左侧的离线任务列表
+	// headr[x]，x在l~r右侧的离线任务列表
 	public static int[] headl = new int[MAXN];
 	public static int[] headr = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];

From 7bc5c5cd525b8ff73b864a0449ae26415735504d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 10 Sep 2025 22:14:56 +0800
Subject: [PATCH 1395/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index 6de10caa8..e1bc93855 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -194,6 +194,9 @@ public static void main(String[] args) throws Exception {
 		}
 		prepare();
 		compute();
+		// ans[i]代表答案变化量
+		// 所以加工出前缀和才是每个查询的答案
+		// 注意在普通莫队的顺序下，去生成前缀和
 		for (int i = 2; i <= m; i++) {
 			ans[query[i][2]] += ans[query[i - 1][2]];
 		}

From 172d8e6131bafca5c2f1a6dc34010357656e7a3c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 08:24:07 +0800
Subject: [PATCH 1396/1712] modify code

---
 src/class178/Code04_Gosick1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index c9abfe466..908acf7c6 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -174,7 +174,6 @@ public static void prepare() {
 	}
 
 	public static void main(String[] args) throws Exception {
-		System.out.println("测试");
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();

From c1b1f05ed720fb872458830b8e9f1e2b32f8e1e9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 13:59:39 +0800
Subject: [PATCH 1397/1712] modify code

---
 src/class178/Code01_MoOfflineTwice1.java   | 16 ++++-----
 src/class178/Code01_MoOfflineTwice2.java   | 16 ++++-----
 src/class178/Code02_OfflineInversion1.java | 38 +++++++++++-----------
 src/class178/Code02_OfflineInversion2.java | 34 +++++++++----------
 src/class178/Code03_Abbi1.java             | 30 ++++++++---------
 src/class178/Code03_Abbi2.java             | 30 ++++++++---------
 src/class178/Code04_Gosick1.java           | 20 ++++++------
 src/class178/Code04_Gosick2.java           | 20 ++++++------
 8 files changed, 102 insertions(+), 102 deletions(-)

diff --git a/src/class178/Code01_MoOfflineTwice1.java b/src/class178/Code01_MoOfflineTwice1.java
index e1bc93855..de824b37b 100644
--- a/src/class178/Code01_MoOfflineTwice1.java
+++ b/src/class178/Code01_MoOfflineTwice1.java
@@ -149,13 +149,13 @@ public static void compute() {
 			winl = jobl;
 		}
 		Arrays.fill(cnt, 0);
-		for (int i = 0; i <= n; i++) {
-			if (i >= 1) {
+		for (int x = 0; x <= n; x++) {
+			if (x >= 1) {
 				for (int j = 1; j <= cntk; j++) {
-					cnt[arr[i] ^ kOneArr[j]]++;
+					cnt[arr[x] ^ kOneArr[j]]++;
 				}
 			}
-			for (int q = headl[i]; q > 0; q = nextq[q]) {
+			for (int q = headl[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
 					ans[id] += (long) op * cnt[arr[j]];
@@ -163,13 +163,13 @@ public static void compute() {
 			}
 		}
 		Arrays.fill(cnt, 0);
-		for (int i = n + 1; i >= 1; i--) {
-			if (i <= n) {
+		for (int x = n + 1; x >= 1; x--) {
+			if (x <= n) {
 				for (int j = 1; j <= cntk; j++) {
-					cnt[arr[i] ^ kOneArr[j]]++;
+					cnt[arr[x] ^ kOneArr[j]]++;
 				}
 			}
-			for (int q = headr[i]; q > 0; q = nextq[q]) {
+			for (int q = headr[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
 					ans[id] += (long) op * cnt[arr[j]];
diff --git a/src/class178/Code01_MoOfflineTwice2.java b/src/class178/Code01_MoOfflineTwice2.java
index 535c0ac4d..fa5b732cf 100644
--- a/src/class178/Code01_MoOfflineTwice2.java
+++ b/src/class178/Code01_MoOfflineTwice2.java
@@ -134,13 +134,13 @@
 //        winl = jobl;
 //    }
 //    memset(cnt, 0, sizeof(cnt));
-//    for (int i = 0; i <= n; i++) {
-//        if (i >= 1) {
+//    for (int x = 0; x <= n; x++) {
+//        if (x >= 1) {
 //            for (int j = 1; j <= cntk; j++) {
-//                cnt[arr[i] ^ kOneArr[j]]++;
+//                cnt[arr[x] ^ kOneArr[j]]++;
 //            }
 //        }
-//        for (int q = headl[i]; q > 0; q = nextq[q]) {
+//        for (int q = headl[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
 //                ans[id] += 1LL * op * cnt[arr[j]];
@@ -148,13 +148,13 @@
 //        }
 //    }
 //    memset(cnt, 0, sizeof(cnt));
-//    for (int i = n + 1; i >= 1; i--) {
-//        if (i <= n) {
+//    for (int x = n + 1; x >= 1; x--) {
+//        if (x <= n) {
 //            for (int j = 1; j <= cntk; j++) {
-//                cnt[arr[i] ^ kOneArr[j]]++;
+//                cnt[arr[x] ^ kOneArr[j]]++;
 //            }
 //        }
-//        for (int q = headr[i]; q > 0; q = nextq[q]) {
+//        for (int q = headr[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
 //                ans[id] += 1LL * op * cnt[arr[j]];
diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index cc7ee9b5a..9fcac3552 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -50,10 +50,10 @@ public class Code02_OfflineInversion1 {
 	// 后缀信息
 	public static long[] suf = new long[MAXN];
 
-	// 整块加了多少词频
-	public static long[] cnt1 = new long[MAXB];
-	// 每种值加了多少词频
-	public static long[] cnt2 = new long[MAXN];
+	// 整块增加的词频
+	public static long[] blockCnt = new long[MAXB];
+	// 块内单个数值的词频
+	public static long[] innerCnt = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -128,10 +128,10 @@ public static void addLeftCnt(int val) {
 			return;
 		}
 		for (int b = 1; b <= bi[val] - 1; b++) {
-			cnt1[b]++;
+			blockCnt[b]++;
 		}
 		for (int i = bl[bi[val]]; i <= val; i++) {
-			cnt2[i]++;
+			innerCnt[i]++;
 		}
 	}
 
@@ -140,15 +140,15 @@ public static void addRightCnt(int val) {
 			return;
 		}
 		for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
-			cnt1[b]++;
+			blockCnt[b]++;
 		}
 		for (int i = val; i <= br[bi[val]]; i++) {
-			cnt2[i]++;
+			innerCnt[i]++;
 		}
 	}
 
 	public static long getCnt(int val) {
-		return cnt1[bi[val]] + cnt2[val];
+		return blockCnt[bi[val]] + innerCnt[val];
 	}
 
 	public static void prepare() {
@@ -211,11 +211,11 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
-		for (int i = 0; i <= n; i++) {
-			if (i >= 1) {
-				addLeftCnt(arr[i] - 1);
+		for (int x = 0; x <= n; x++) {
+			if (x >= 1) {
+				addLeftCnt(arr[x] - 1);
 			}
-			for (int q = headl[i]; q > 0; q = nextq[q]) {
+			for (int q = headl[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
@@ -224,13 +224,13 @@ public static void compute() {
 				ans[id] += ret * op;
 			}
 		}
-		Arrays.fill(cnt1, 0);
-		Arrays.fill(cnt2, 0);
-		for (int i = n + 1; i >= 1; i--) {
-			if (i <= n) {
-				addRightCnt(arr[i] + 1);
+		Arrays.fill(blockCnt, 0);
+		Arrays.fill(innerCnt, 0);
+		for (int x = n + 1; x >= 1; x--) {
+			if (x <= n) {
+				addRightCnt(arr[x] + 1);
 			}
-			for (int q = headr[i]; q > 0; q = nextq[q]) {
+			for (int q = headr[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				long ret = 0;
 				for (int j = l; j <= r; j++) {
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 3aaf5ce8b..066ab20e9 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -44,8 +44,8 @@
 //long long pre[MAXN];
 //long long suf[MAXN];
 //
-//long long cnt1[MAXB];
-//long long cnt2[MAXN];
+//long long blockCnt[MAXB];
+//long long innerCnt[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -117,10 +117,10 @@
 //        return;
 //    }
 //    for (int b = 1; b <= bi[val] - 1; b++) {
-//        cnt1[b]++;
+//        blockCnt[b]++;
 //    }
 //    for (int i = bl[bi[val]]; i <= val; i++) {
-//        cnt2[i]++;
+//        innerCnt[i]++;
 //    }
 //}
 //
@@ -129,15 +129,15 @@
 //        return;
 //    }
 //    for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
-//        cnt1[b]++;
+//        blockCnt[b]++;
 //    }
 //    for (int i = val; i <= br[bi[val]]; i++) {
-//        cnt2[i]++;
+//        innerCnt[i]++;
 //    }
 //}
 //
 //long long getCnt(int val) {
-//    return cnt1[bi[val]] + cnt2[val];
+//    return blockCnt[bi[val]] + innerCnt[val];
 //}
 //
 //void prepare() {
@@ -200,11 +200,11 @@
 //        }
 //        winl = jobl;
 //    }
-//    for (int i = 0; i <= n; i++) {
-//        if (i >= 1) {
-//            addLeftCnt(arr[i] - 1);
+//    for (int x = 0; x <= n; x++) {
+//        if (x >= 1) {
+//            addLeftCnt(arr[x] - 1);
 //        }
-//        for (int q = headl[i]; q > 0; q = nextq[q]) {
+//        for (int q = headl[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
@@ -213,13 +213,13 @@
 //            ans[id] += ret * op;
 //        }
 //    }
-//    memset(cnt1, 0, sizeof(cnt1));
-//    memset(cnt2, 0, sizeof(cnt2));
-//    for (int i = n + 1; i >= 1; i--) {
-//        if (i <= n) {
-//            addRightCnt(arr[i] + 1);
+//    memset(blockCnt, 0, sizeof(blockCnt));
+//    memset(innerCnt, 0, sizeof(innerCnt));
+//    for (int x = n + 1; x >= 1; x--) {
+//        if (x <= n) {
+//            addRightCnt(arr[x] + 1);
 //        }
-//        for (int q = headr[i]; q > 0; q = nextq[q]) {
+//        for (int q = headr[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            long long ret = 0;
 //            for (int j = l; j <= r; j++) {
diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index d8ac48362..291b9a229 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -42,10 +42,10 @@ public class Code03_Abbi1 {
 	public static long[] treeSum = new long[MAXV + 1];
 	public static long[] pre = new long[MAXN];
 
-	public static int[] cnt1 = new int[MAXB];
-	public static int[] cnt2 = new int[MAXN];
-	public static long[] sum1 = new long[MAXB];
-	public static long[] sum2 = new long[MAXN];
+	public static int[] blockCnt = new int[MAXB];
+	public static int[] innerCnt = new int[MAXN];
+	public static long[] blockSum = new long[MAXB];
+	public static long[] innerSum = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -93,12 +93,12 @@ public static void addVal(int val) {
 			return;
 		}
 		for (int b = bi[val]; b <= bi[MAXV]; b++) {
-			cnt1[b]++;
-			sum1[b] += val;
+			blockCnt[b]++;
+			blockSum[b] += val;
 		}
 		for (int i = val; i <= br[bi[val]]; i++) {
-			cnt2[i]++;
-			sum2[i] += val;
+			innerCnt[i]++;
+			innerSum[i] += val;
 		}
 	}
 
@@ -106,14 +106,14 @@ public static long getSum(int x) {
 		if (x <= 0) {
 			return 0;
 		}
-		return sum1[bi[x] - 1] + sum2[x];
+		return blockSum[bi[x] - 1] + innerSum[x];
 	}
 
 	public static int getCnt(int x) {
 		if (x <= 0) {
 			return 0;
 		}
-		return cnt1[bi[x] - 1] + cnt2[x];
+		return blockCnt[bi[x] - 1] + innerCnt[x];
 	}
 
 	public static void prepare() {
@@ -163,12 +163,12 @@ public static void compute() {
 		}
 		long sum = 0;
 		long tmp;
-		for (int i = 0; i <= n; i++) {
-			if (i >= 1) {
-				addVal(arr[i]);
-				sum += arr[i];
+		for (int x = 0; x <= n; x++) {
+			if (x >= 1) {
+				addVal(arr[x]);
+				sum += arr[x];
 			}
-			for (int q = headq[i]; q > 0; q = nextq[q]) {
+			for (int q = headq[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
 					tmp = (long) getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 239f3022d..3da476b63 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -43,10 +43,10 @@
 //long long treeSum[MAXV + 1];
 //long long pre[MAXN];
 //
-//int cnt1[MAXB];
-//int cnt2[MAXN];
-//long long sum1[MAXB];
-//long long sum2[MAXN];
+//int blockCnt[MAXB];
+//int innerCnt[MAXN];
+//long long blockSum[MAXB];
+//long long innerSum[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -91,12 +91,12 @@
 //        return;
 //    }
 //    for (int b = bi[val]; b <= bi[MAXV]; b++) {
-//        cnt1[b]++;
-//        sum1[b] += val;
+//        blockCnt[b]++;
+//        blockSum[b] += val;
 //    }
 //    for (int i = val; i <= br[bi[val]]; i++) {
-//        cnt2[i]++;
-//        sum2[i] += val;
+//        innerCnt[i]++;
+//        innerSum[i] += val;
 //    }
 //}
 //
@@ -104,14 +104,14 @@
 //    if (x <= 0) {
 //        return 0;
 //    }
-//    return sum1[bi[x] - 1] + sum2[x];
+//    return blockSum[bi[x] - 1] + innerSum[x];
 //}
 //
 //int getCnt(int x) {
 //    if (x <= 0) {
 //        return 0;
 //    }
-//    return cnt1[bi[x] - 1] + cnt2[x];
+//    return blockCnt[bi[x] - 1] + innerCnt[x];
 //}
 //
 //void prepare() {
@@ -161,12 +161,12 @@
 //    }
 //    long long sum = 0;
 //    long long tmp;
-//    for (int i = 0; i <= n; i++) {
-//        if (i >= 1) {
-//            addVal(arr[i]);
-//            sum += arr[i];
+//    for (int x = 0; x <= n; x++) {
+//        if (x >= 1) {
+//            addVal(arr[x]);
+//            sum += arr[x];
 //        }
-//        for (int q = headq[i]; q > 0; q = nextq[q]) {
+//        for (int q = headq[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
 //                tmp = 1LL * getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 908acf7c6..d1ec01f23 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -85,12 +85,12 @@ public static void addOffline(int x, int l, int r, int op, int id) {
 	}
 
 	public static void compute() {
-		for (int i = 1, x; i <= n; i++) {
+		for (int i = 1; i <= n; i++) {
 			pre[i] = pre[i - 1];
-			x = arr[i];
-			for (int e = headf[x], f, other; e > 0; e = nextf[e]) {
+			int num = arr[i];
+			for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 				f = fac[e];
-				other = x / f;
+				other = num / f;
 				fcnt[f]++;
 				pre[i] += xcnt[f];
 				if (other != f) {
@@ -98,8 +98,8 @@ public static void compute() {
 					pre[i] += xcnt[other];
 				}
 			}
-			pre[i] += fcnt[x];
-			xcnt[x]++;
+			pre[i] += fcnt[num];
+			xcnt[num]++;
 		}
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
@@ -126,9 +126,9 @@ public static void compute() {
 			winl = jobl;
 		}
 		Arrays.fill(fcnt, 0);
-		for (int i = 0; i <= n; i++) {
-			if (i >= 1) {
-				int num = arr[i];
+		for (int x = 0; x <= n; x++) {
+			if (x >= 1) {
+				int num = arr[x];
 				for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 					f = fac[e];
 					other = num / f;
@@ -143,7 +143,7 @@ public static void compute() {
 					}
 				}
 			}
-			for (int q = headq[i]; q > 0; q = nextq[q]) {
+			for (int q = headq[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
 					ans[id] += (long) op * fcnt[arr[j]];
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index bdebce0b0..6445b2948 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -80,12 +80,12 @@
 //}
 //
 //void compute() {
-//    for (int i = 1, x; i <= n; i++) {
+//    for (int i = 1; i <= n; i++) {
 //        pre[i] = pre[i - 1];
-//        x = arr[i];
-//        for (int e = headf[x], f, other; e > 0; e = nextf[e]) {
+//        int num = arr[i];
+//        for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 //            f = fac[e];
-//            other = x / f;
+//            other = num / f;
 //            fcnt[f]++;
 //            pre[i] += xcnt[f];
 //            if (other != f) {
@@ -93,8 +93,8 @@
 //                pre[i] += xcnt[other];
 //            }
 //        }
-//        pre[i] += fcnt[x];
-//        xcnt[x]++;
+//        pre[i] += fcnt[num];
+//        xcnt[num]++;
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
@@ -121,9 +121,9 @@
 //        winl = jobl;
 //    }
 //    memset(fcnt, 0, sizeof(fcnt));
-//    for (int i = 0; i <= n; i++) {
-//        if (i >= 1) {
-//            int num = arr[i];
+//    for (int x = 0; x <= n; x++) {
+//        if (x >= 1) {
+//            int num = arr[x];
 //            for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 //                f = fac[e];
 //                other = num / f;
@@ -138,7 +138,7 @@
 //                }
 //            }
 //        }
-//        for (int q = headq[i]; q > 0; q = nextq[q]) {
+//        for (int q = headq[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
 //                ans[id] += 1LL * op * fcnt[arr[j]];

From 5cff01ff845c582d38b5c0806ee5d1b4da310824 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 15:38:43 +0800
Subject: [PATCH 1398/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 2 +-
 src/class178/Code02_OfflineInversion2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 9fcac3552..7c0aaff8b 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -5,7 +5,7 @@
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，逆序对的数量
 // 1 <= n、m <= 10^5
 // 0 <= arr[i] <= 10^9
-// 本题允许离线，讲解173，题目4，讲了必须在线查询区间逆序对
+// 本题允许离线，讲解173，题目4，讲了在线查询区间逆序对，但是给定的数组为排列
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 066ab20e9..aedddc4ef 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -5,7 +5,7 @@
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，逆序对的数量
 // 1 <= n、m <= 10^5
 // 0 <= arr[i] <= 10^9
-// 本题允许离线，讲解173，题目4，讲了必须在线查询区间逆序对
+// 本题允许离线，讲解173，题目4，讲了在线查询区间逆序对，但是给定的数组为排列
 // 测试链接 : https://www.luogu.com.cn/problem/P5047
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 672082239ff2522acad8332690198abe2419433f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 16:46:39 +0800
Subject: [PATCH 1399/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 12 ++++++------
 src/class178/Code02_OfflineInversion2.java | 10 +++++-----
 src/class178/Code03_Abbi1.java             | 12 ++++++------
 src/class178/Code03_Abbi2.java             | 12 ++++++------
 4 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 7c0aaff8b..6faac61ca 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -52,8 +52,8 @@ public class Code02_OfflineInversion1 {
 
 	// 整块增加的词频
 	public static long[] blockCnt = new long[MAXB];
-	// 块内单个数值的词频
-	public static long[] innerCnt = new long[MAXN];
+	// 单个数值的词频
+	public static long[] numCnt = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -131,7 +131,7 @@ public static void addLeftCnt(int val) {
 			blockCnt[b]++;
 		}
 		for (int i = bl[bi[val]]; i <= val; i++) {
-			innerCnt[i]++;
+			numCnt[i]++;
 		}
 	}
 
@@ -143,12 +143,12 @@ public static void addRightCnt(int val) {
 			blockCnt[b]++;
 		}
 		for (int i = val; i <= br[bi[val]]; i++) {
-			innerCnt[i]++;
+			numCnt[i]++;
 		}
 	}
 
 	public static long getCnt(int val) {
-		return blockCnt[bi[val]] + innerCnt[val];
+		return blockCnt[bi[val]] + numCnt[val];
 	}
 
 	public static void prepare() {
@@ -225,7 +225,7 @@ public static void compute() {
 			}
 		}
 		Arrays.fill(blockCnt, 0);
-		Arrays.fill(innerCnt, 0);
+		Arrays.fill(numCnt, 0);
 		for (int x = n + 1; x >= 1; x--) {
 			if (x <= n) {
 				addRightCnt(arr[x] + 1);
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index aedddc4ef..73ed02b8e 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -45,7 +45,7 @@
 //long long suf[MAXN];
 //
 //long long blockCnt[MAXB];
-//long long innerCnt[MAXN];
+//long long numCnt[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -120,7 +120,7 @@
 //        blockCnt[b]++;
 //    }
 //    for (int i = bl[bi[val]]; i <= val; i++) {
-//        innerCnt[i]++;
+//        numCnt[i]++;
 //    }
 //}
 //
@@ -132,12 +132,12 @@
 //        blockCnt[b]++;
 //    }
 //    for (int i = val; i <= br[bi[val]]; i++) {
-//        innerCnt[i]++;
+//        numCnt[i]++;
 //    }
 //}
 //
 //long long getCnt(int val) {
-//    return blockCnt[bi[val]] + innerCnt[val];
+//    return blockCnt[bi[val]] + numCnt[val];
 //}
 //
 //void prepare() {
@@ -214,7 +214,7 @@
 //        }
 //    }
 //    memset(blockCnt, 0, sizeof(blockCnt));
-//    memset(innerCnt, 0, sizeof(innerCnt));
+//    memset(numCnt, 0, sizeof(numCnt));
 //    for (int x = n + 1; x >= 1; x--) {
 //        if (x <= n) {
 //            addRightCnt(arr[x] + 1);
diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 291b9a229..bd60aef7a 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -43,9 +43,9 @@ public class Code03_Abbi1 {
 	public static long[] pre = new long[MAXN];
 
 	public static int[] blockCnt = new int[MAXB];
-	public static int[] innerCnt = new int[MAXN];
+	public static int[] numCnt = new int[MAXN];
 	public static long[] blockSum = new long[MAXB];
-	public static long[] innerSum = new long[MAXN];
+	public static long[] numSum = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -97,8 +97,8 @@ public static void addVal(int val) {
 			blockSum[b] += val;
 		}
 		for (int i = val; i <= br[bi[val]]; i++) {
-			innerCnt[i]++;
-			innerSum[i] += val;
+			numCnt[i]++;
+			numSum[i] += val;
 		}
 	}
 
@@ -106,14 +106,14 @@ public static long getSum(int x) {
 		if (x <= 0) {
 			return 0;
 		}
-		return blockSum[bi[x] - 1] + innerSum[x];
+		return blockSum[bi[x] - 1] + numSum[x];
 	}
 
 	public static int getCnt(int x) {
 		if (x <= 0) {
 			return 0;
 		}
-		return blockCnt[bi[x] - 1] + innerCnt[x];
+		return blockCnt[bi[x] - 1] + numCnt[x];
 	}
 
 	public static void prepare() {
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 3da476b63..e889ddb2a 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -44,9 +44,9 @@
 //long long pre[MAXN];
 //
 //int blockCnt[MAXB];
-//int innerCnt[MAXN];
+//int numCnt[MAXN];
 //long long blockSum[MAXB];
-//long long innerSum[MAXN];
+//long long numSum[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -95,8 +95,8 @@
 //        blockSum[b] += val;
 //    }
 //    for (int i = val; i <= br[bi[val]]; i++) {
-//        innerCnt[i]++;
-//        innerSum[i] += val;
+//        numCnt[i]++;
+//        numSum[i] += val;
 //    }
 //}
 //
@@ -104,14 +104,14 @@
 //    if (x <= 0) {
 //        return 0;
 //    }
-//    return blockSum[bi[x] - 1] + innerSum[x];
+//    return blockSum[bi[x] - 1] + numSum[x];
 //}
 //
 //int getCnt(int x) {
 //    if (x <= 0) {
 //        return 0;
 //    }
-//    return blockCnt[bi[x] - 1] + innerCnt[x];
+//    return blockCnt[bi[x] - 1] + numCnt[x];
 //}
 //
 //void prepare() {

From d74c1a55f36bd3bf156b1d93812ac46f166b8409 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 16:48:46 +0800
Subject: [PATCH 1400/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 6 +-----
 src/class178/Code02_OfflineInversion2.java | 6 +-----
 2 files changed, 2 insertions(+), 10 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 6faac61ca..016ec3ba0 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -101,10 +101,6 @@ public static int sum(int i) {
 		return ret;
 	}
 
-	public static void clear() {
-		Arrays.fill(tree, 1, cntv + 1, 0);
-	}
-
 	public static void addLeftOffline(int x, int l, int r, int op, int id) {
 		nextq[++cntq] = headl[x];
 		headl[x] = cntq;
@@ -182,7 +178,7 @@ public static void compute() {
 			pre[i] = pre[i - 1] + sum(cntv) - sum(arr[i]);
 			add(arr[i], 1);
 		}
-		clear();
+		Arrays.fill(tree, 1, cntv + 1, 0);
 		for (int i = n; i >= 1; i--) {
 			suf[i] = suf[i + 1] + sum(arr[i] - 1);
 			add(arr[i], 1);
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index 73ed02b8e..eed620174 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -90,10 +90,6 @@
 //    return ret;
 //}
 //
-//void clear() {
-//    memset(tree + 1, 0, cntv * sizeof(int));
-//}
-//
 //void addLeftOffline(int x, int l, int r, int op, int id) {
 //    nextq[++cntq] = headl[x];
 //    headl[x] = cntq;
@@ -171,7 +167,7 @@
 //        pre[i] = pre[i - 1] + sum(cntv) - sum(arr[i]);
 //        add(arr[i], 1);
 //    }
-//    clear();
+//    memset(tree + 1, 0, cntv * sizeof(int));
 //    for (int i = n; i >= 1; i--) {
 //        suf[i] = suf[i + 1] + sum(arr[i] - 1);
 //        add(arr[i], 1);

From daafe80bfce40a3d5a2b29cf18df95ada5a3b7eb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 17:29:41 +0800
Subject: [PATCH 1401/1712] modify code

---
 src/class178/Code02_OfflineInversion1.java | 16 ++++++----------
 src/class178/Code02_OfflineInversion2.java | 14 ++++----------
 2 files changed, 10 insertions(+), 20 deletions(-)

diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 016ec3ba0..2b660f744 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -119,26 +119,22 @@ public static void addRightOffline(int x, int l, int r, int op, int id) {
 		qid[cntq] = id;
 	}
 
+	// 增加1 ~ val-1，这些数字的词频
 	public static void addLeftCnt(int val) {
-		if (val <= 0) {
-			return;
-		}
 		for (int b = 1; b <= bi[val] - 1; b++) {
 			blockCnt[b]++;
 		}
-		for (int i = bl[bi[val]]; i <= val; i++) {
+		for (int i = bl[bi[val]]; i < val; i++) {
 			numCnt[i]++;
 		}
 	}
 
+	// 增加val+1 ~ cntv，这些数字的词频
 	public static void addRightCnt(int val) {
-		if (val > cntv) {
-			return;
-		}
 		for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
 			blockCnt[b]++;
 		}
-		for (int i = val; i <= br[bi[val]]; i++) {
+		for (int i = val + 1; i <= br[bi[val]]; i++) {
 			numCnt[i]++;
 		}
 	}
@@ -209,7 +205,7 @@ public static void compute() {
 		}
 		for (int x = 0; x <= n; x++) {
 			if (x >= 1) {
-				addLeftCnt(arr[x] - 1);
+				addLeftCnt(arr[x]);
 			}
 			for (int q = headl[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
@@ -224,7 +220,7 @@ public static void compute() {
 		Arrays.fill(numCnt, 0);
 		for (int x = n + 1; x >= 1; x--) {
 			if (x <= n) {
-				addRightCnt(arr[x] + 1);
+				addRightCnt(arr[x]);
 			}
 			for (int q = headr[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
diff --git a/src/class178/Code02_OfflineInversion2.java b/src/class178/Code02_OfflineInversion2.java
index eed620174..b9595f66b 100644
--- a/src/class178/Code02_OfflineInversion2.java
+++ b/src/class178/Code02_OfflineInversion2.java
@@ -109,25 +109,19 @@
 //}
 //
 //void addLeftCnt(int val) {
-//    if (val <= 0) {
-//        return;
-//    }
 //    for (int b = 1; b <= bi[val] - 1; b++) {
 //        blockCnt[b]++;
 //    }
-//    for (int i = bl[bi[val]]; i <= val; i++) {
+//    for (int i = bl[bi[val]]; i < val; i++) {
 //        numCnt[i]++;
 //    }
 //}
 //
 //void addRightCnt(int val) {
-//    if (val > cntv) {
-//        return;
-//    }
 //    for (int b = bi[val] + 1; b <= bi[cntv]; b++) {
 //        blockCnt[b]++;
 //    }
-//    for (int i = val; i <= br[bi[val]]; i++) {
+//    for (int i = val + 1; i <= br[bi[val]]; i++) {
 //        numCnt[i]++;
 //    }
 //}
@@ -198,7 +192,7 @@
 //    }
 //    for (int x = 0; x <= n; x++) {
 //        if (x >= 1) {
-//            addLeftCnt(arr[x] - 1);
+//            addLeftCnt(arr[x]);
 //        }
 //        for (int q = headl[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
@@ -213,7 +207,7 @@
 //    memset(numCnt, 0, sizeof(numCnt));
 //    for (int x = n + 1; x >= 1; x--) {
 //        if (x <= n) {
-//            addRightCnt(arr[x] + 1);
+//            addRightCnt(arr[x]);
 //        }
 //        for (int q = headr[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];

From b673f7e7d8a163d593e539dfe2a4a6e09766412b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 17:54:37 +0800
Subject: [PATCH 1402/1712] modify code

---
 src/class178/Code03_Abbi1.java | 1 +
 src/class178/Code03_Abbi2.java | 2 +-
 2 files changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index bd60aef7a..5f89a8498 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -26,6 +26,7 @@ public class Code03_Abbi1 {
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	public static long[] presum = new long[MAXN];
+
 	public static int[] bi = new int[MAXN];
 	public static int[] br = new int[MAXB];
 
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index e889ddb2a..4fd0495b9 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -23,10 +23,10 @@
 //const int MAXN = 500001;
 //const int MAXV = 100000;
 //const int MAXB = 401;
-//
 //int n, m;
 //int arr[MAXN];
 //long long presum[MAXN];
+//
 //int bi[MAXN];
 //int br[MAXB];
 //

From ed9e8d27eefa3b2cc09865f805e9d9ec413db784 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 21:12:21 +0800
Subject: [PATCH 1403/1712] modify code

---
 src/class178/Code03_Abbi1.java | 57 ++++++++++++++++------------------
 src/class178/Code03_Abbi2.java | 55 +++++++++++++++-----------------
 2 files changed, 52 insertions(+), 60 deletions(-)

diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 5f89a8498..8654c71dc 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -25,9 +25,10 @@ public class Code03_Abbi1 {
 	public static int MAXB = 401;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	public static long[] presum = new long[MAXN];
+	public static long[] preSum = new long[MAXN];
 
 	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
 	public static int[][] query = new int[MAXN][3];
@@ -43,10 +44,10 @@ public class Code03_Abbi1 {
 	public static long[] treeSum = new long[MAXV + 1];
 	public static long[] pre = new long[MAXN];
 
-	public static int[] blockCnt = new int[MAXB];
-	public static int[] numCnt = new int[MAXN];
-	public static long[] blockSum = new long[MAXB];
-	public static long[] numSum = new long[MAXN];
+	public static int[] blockLessCnt = new int[MAXB];
+	public static int[] numLessCnt = new int[MAXN];
+	public static long[] blockMoreSum = new long[MAXB];
+	public static long[] numMoreSum = new long[MAXN];
 
 	public static long[] ans = new long[MAXN];
 
@@ -90,44 +91,40 @@ public static long sum(long[] tree, int x) {
 	}
 
 	public static void addVal(int val) {
-		if (val <= 0) {
-			return;
+		for (int b = bi[val] + 1; b <= bi[MAXV]; b++) {
+			blockLessCnt[b]++;
 		}
-		for (int b = bi[val]; b <= bi[MAXV]; b++) {
-			blockCnt[b]++;
-			blockSum[b] += val;
+		for (int i = val + 1; i <= br[bi[val]]; i++) {
+			numLessCnt[i]++;
 		}
-		for (int i = val; i <= br[bi[val]]; i++) {
-			numCnt[i]++;
-			numSum[i] += val;
+		for (int b = 1; b <= bi[val] - 1; b++) {
+			blockMoreSum[b] += val;
+		}
+		for (int i = bl[bi[val]]; i < val; i++) {
+			numMoreSum[i] += val;
 		}
 	}
 
-	public static long getSum(int x) {
-		if (x <= 0) {
-			return 0;
-		}
-		return blockSum[bi[x] - 1] + numSum[x];
+	public static int lessCnt(int x) {
+		return blockLessCnt[bi[x]] + numLessCnt[x];
 	}
 
-	public static int getCnt(int x) {
-		if (x <= 0) {
-			return 0;
-		}
-		return blockCnt[bi[x] - 1] + numCnt[x];
+	public static long moreSum(int x) {
+		return blockMoreSum[bi[x]] + numMoreSum[x];
 	}
 
 	public static void prepare() {
 		for (int i = 1; i <= n; i++) {
-			presum[i] = presum[i - 1] + arr[i];
+			preSum[i] = preSum[i - 1] + arr[i];
 		}
 		int blen = (int) Math.sqrt(MAXV);
 		int bnum = (MAXV + blen - 1) / blen;
 		for (int i = 1; i <= MAXV; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		for (int b = 1; b <= bnum; b++) {
-			br[b] = Math.min(b * blen, MAXV);
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, MAXV);
 		}
 		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
@@ -162,17 +159,15 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
-		long sum = 0;
 		long tmp;
 		for (int x = 0; x <= n; x++) {
 			if (x >= 1) {
 				addVal(arr[x]);
-				sum += arr[x];
 			}
 			for (int q = headq[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
-					tmp = (long) getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
+					tmp = (long) lessCnt(arr[j]) * arr[j] + moreSum(arr[j]);
 					if (op == 1) {
 						ans[id] += tmp;
 					} else {
@@ -198,11 +193,13 @@ public static void main(String[] args) throws Exception {
 		}
 		prepare();
 		compute();
+		// 加工前缀和
 		for (int i = 2; i <= m; i++) {
 			ans[query[i][2]] += ans[query[i - 1][2]];
 		}
+		// 贡献是修正过的概念，现在补偿回来
 		for (int i = 1; i <= m; i++) {
-			ans[query[i][2]] += presum[query[i][1]] - presum[query[i][0] - 1];
+			ans[query[i][2]] += preSum[query[i][1]] - preSum[query[i][0] - 1];
 		}
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 4fd0495b9..8c333b130 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -25,9 +25,10 @@
 //const int MAXB = 401;
 //int n, m;
 //int arr[MAXN];
-//long long presum[MAXN];
+//long long preSum[MAXN];
 //
 //int bi[MAXN];
+//int bl[MAXB];
 //int br[MAXB];
 //
 //Query query[MAXN];
@@ -43,10 +44,10 @@
 //long long treeSum[MAXV + 1];
 //long long pre[MAXN];
 //
-//int blockCnt[MAXB];
-//int numCnt[MAXN];
-//long long blockSum[MAXB];
-//long long numSum[MAXN];
+//int blockLessCnt[MAXB];
+//int numLessCnt[MAXN];
+//long long blockMoreSum[MAXB];
+//long long numMoreSum[MAXN];
 //
 //long long ans[MAXN];
 //
@@ -87,44 +88,40 @@
 //}
 //
 //void addVal(int val) {
-//    if (val <= 0) {
-//        return;
+//    for (int b = bi[val] + 1; b <= bi[MAXV]; b++) {
+//        blockLessCnt[b]++;
 //    }
-//    for (int b = bi[val]; b <= bi[MAXV]; b++) {
-//        blockCnt[b]++;
-//        blockSum[b] += val;
+//    for (int i = val + 1; i <= br[bi[val]]; i++) {
+//        numLessCnt[i]++;
 //    }
-//    for (int i = val; i <= br[bi[val]]; i++) {
-//        numCnt[i]++;
-//        numSum[i] += val;
+//    for (int b = 1; b <= bi[val] - 1; b++) {
+//        blockMoreSum[b] += val;
+//    }
+//    for (int i = bl[bi[val]]; i < val; i++) {
+//        numMoreSum[i] += val;
 //    }
 //}
 //
-//long long getSum(int x) {
-//    if (x <= 0) {
-//        return 0;
-//    }
-//    return blockSum[bi[x] - 1] + numSum[x];
+//int lessCnt(int x) {
+//    return blockLessCnt[bi[x]] + numLessCnt[x];
 //}
 //
-//int getCnt(int x) {
-//    if (x <= 0) {
-//        return 0;
-//    }
-//    return blockCnt[bi[x] - 1] + numCnt[x];
+//long long moreSum(int x) {
+//    return blockMoreSum[bi[x]] + numMoreSum[x];
 //}
 //
 //void prepare() {
 //    for (int i = 1; i <= n; i++) {
-//        presum[i] = presum[i - 1] + arr[i];
+//        preSum[i] = preSum[i - 1] + arr[i];
 //    }
 //    int blen = (int)sqrt(MAXV);
 //    int bnum = (MAXV + blen - 1) / blen;
 //    for (int i = 1; i <= MAXV; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    for (int b = 1; b <= bnum; b++) {
-//        br[b] = min(b * blen, MAXV);
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, MAXV);
 //    }
 //    sort(query + 1, query + m + 1, QueryCmp);
 //}
@@ -159,17 +156,15 @@
 //        }
 //        winl = jobl;
 //    }
-//    long long sum = 0;
 //    long long tmp;
 //    for (int x = 0; x <= n; x++) {
 //        if (x >= 1) {
 //            addVal(arr[x]);
-//            sum += arr[x];
 //        }
 //        for (int q = headq[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
-//                tmp = 1LL * getCnt(arr[j] - 1) * arr[j] + sum - getSum(arr[j]);
+//                tmp = 1LL * lessCnt(arr[j]) * arr[j] + moreSum(arr[j]);
 //                if (op == 1) {
 //                    ans[id] += tmp;
 //                } else {
@@ -197,7 +192,7 @@
 //        ans[query[i].id] += ans[query[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        ans[query[i].id] += presum[query[i].r] - presum[query[i].l - 1];
+//        ans[query[i].id] += preSum[query[i].r] - preSum[query[i].l - 1];
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';

From d5b46dd4a709f5c31f83ecf4be5b66363136c315 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 11 Sep 2025 21:18:12 +0800
Subject: [PATCH 1404/1712] modify code

---
 src/class178/Code03_Abbi1.java | 1 +
 src/class178/Code03_Abbi2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 8654c71dc..815afc8b1 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -46,6 +46,7 @@ public class Code03_Abbi1 {
 
 	public static int[] blockLessCnt = new int[MAXB];
 	public static int[] numLessCnt = new int[MAXN];
+
 	public static long[] blockMoreSum = new long[MAXB];
 	public static long[] numMoreSum = new long[MAXN];
 
diff --git a/src/class178/Code03_Abbi2.java b/src/class178/Code03_Abbi2.java
index 8c333b130..677b5a5bf 100644
--- a/src/class178/Code03_Abbi2.java
+++ b/src/class178/Code03_Abbi2.java
@@ -46,6 +46,7 @@
 //
 //int blockLessCnt[MAXB];
 //int numLessCnt[MAXN];
+//
 //long long blockMoreSum[MAXB];
 //long long numMoreSum[MAXN];
 //

From 5887d5ab55a9317c02527bfac1f0d5b3bf681839 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 15:17:50 +0800
Subject: [PATCH 1405/1712] modify code

---
 src/class178/Code03_Abbi1.java | 10 ++++++++++
 1 file changed, 10 insertions(+)

diff --git a/src/class178/Code03_Abbi1.java b/src/class178/Code03_Abbi1.java
index 815afc8b1..9f3960459 100644
--- a/src/class178/Code03_Abbi1.java
+++ b/src/class178/Code03_Abbi1.java
@@ -27,10 +27,12 @@ public class Code03_Abbi1 {
 	public static int[] arr = new int[MAXN];
 	public static long[] preSum = new long[MAXN];
 
+	// 序列分块 + 值域分块
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXB];
 	public static int[] br = new int[MAXB];
 
+	// 莫队任务 + 二次离线任务(x, l, r, op)
 	public static int[][] query = new int[MAXN][3];
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
@@ -40,13 +42,18 @@ public class Code03_Abbi1 {
 	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
+	// 值域树状数组，统计<x的个数
 	public static long[] treeCnt = new long[MAXV + 1];
+	// 值域树状数组，统计>x所有数的累加和
 	public static long[] treeSum = new long[MAXV + 1];
+	// 前缀信息
 	public static long[] pre = new long[MAXN];
 
+	// 值域分块，统计<x的个数
 	public static int[] blockLessCnt = new int[MAXB];
 	public static int[] numLessCnt = new int[MAXN];
 
+	// 值域分块，统计>x所有数的累加和
 	public static long[] blockMoreSum = new long[MAXB];
 	public static long[] numMoreSum = new long[MAXN];
 
@@ -91,6 +98,7 @@ public static long sum(long[] tree, int x) {
 		return ret;
 	}
 
+	// 执行二次离线的过程中，加入数字val，修改相关信息
 	public static void addVal(int val) {
 		for (int b = bi[val] + 1; b <= bi[MAXV]; b++) {
 			blockLessCnt[b]++;
@@ -106,10 +114,12 @@ public static void addVal(int val) {
 		}
 	}
 
+	// 查询<x的个数
 	public static int lessCnt(int x) {
 		return blockLessCnt[bi[x]] + numLessCnt[x];
 	}
 
+	// 查询>x的所有数累加和
 	public static long moreSum(int x) {
 		return blockMoreSum[bi[x]] + numMoreSum[x];
 	}

From edf7f9da24fd64922a0394d29bc8d8369114ffeb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 17:51:30 +0800
Subject: [PATCH 1406/1712] modify code

---
 src/class178/Code04_Gosick1.java | 1 +
 src/class178/Code04_Gosick2.java | 1 +
 2 files changed, 2 insertions(+)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index d1ec01f23..b29728660 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -5,6 +5,7 @@
 // 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数(>=1倍)
 // 当i != j时，(i, j)和(j, i)认为是不同的二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
+// 比如，[1, 1, 4, 5]有10个倍数二元组
 // 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 提交以下的code，提交时请把类名改成"Main"
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index 6445b2948..f11fb9838 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -5,6 +5,7 @@
 // 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数(>=1倍)
 // 当i != j时，(i, j)和(j, i)认为是不同的二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
+// 比如，[1, 1, 4, 5]有10个倍数二元组
 // 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From e78f96a157aa365c734ea6a0b535d69777d258c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 18:04:19 +0800
Subject: [PATCH 1407/1712] modify code

---
 src/class178/Code04_Gosick1.java | 2 +-
 src/class178/Code04_Gosick2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index b29728660..230d93b6e 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -24,7 +24,7 @@ public class Code04_Gosick1 {
 
 	public static int MAXN = 500001;
 	public static int MAXF = 5000001;
-	public static int LIMIT = 80;
+	public static int LIMIT = 100;
 	public static int n, m, maxv;
 	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index f11fb9838..cf535798c 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -21,7 +21,7 @@
 //
 //const int MAXN = 500001;
 //const int MAXF = 5000001;
-//const int LIMIT = 80;
+//const int LIMIT = 100;
 //
 //int n, m, maxv;
 //int arr[MAXN];

From 128bfc25e82c5a7240375feb61473d963887585f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 18:25:56 +0800
Subject: [PATCH 1408/1712] modify code

---
 src/class178/Code04_Gosick1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 230d93b6e..4d09b7a47 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -126,6 +126,7 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
+		// 二次离线阶段，fcnt[v]表示v这个数字获得的，因子的数量 + 倍数的数量
 		Arrays.fill(fcnt, 0);
 		for (int x = 0; x <= n; x++) {
 			if (x >= 1) {

From 0810ea48cd17050e3ebf1e0df61fc46d3cd2bdfe Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 18:41:52 +0800
Subject: [PATCH 1409/1712] modify code

---
 src/class178/Code04_Gosick1.java | 5 +++++
 1 file changed, 5 insertions(+)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 4d09b7a47..e5e70c31b 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -44,8 +44,11 @@ public class Code04_Gosick1 {
 	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
+	// 每个数分解出的因子v，都会让fcnt[v]增加计数
 	public static int[] fcnt = new int[MAXN];
+	// 每个数x，都会让xcnt[x]增加计数
 	public static int[] xcnt = new int[MAXN];
+	// 前缀信息
 	public static long[] pre = new long[MAXN];
 
 	public static int[] cnt1 = new int[MAXN];
@@ -86,6 +89,8 @@ public static void addOffline(int x, int l, int r, int op, int id) {
 	}
 
 	public static void compute() {
+		// 单点贡献 = (之前数, 当前数) + (当前数，之前数) + (当前数，当前数)算1次
+		// 然后把每一步的单点贡献，生成前缀和数组pre
 		for (int i = 1; i <= n; i++) {
 			pre[i] = pre[i - 1];
 			int num = arr[i];

From ad385a244981d788cf63c3473789c940db29cc12 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 22:10:54 +0800
Subject: [PATCH 1410/1712] modify code

---
 src/class178/Code04_Gosick1.java | 69 ++++++++++++++++++--------------
 src/class178/Code04_Gosick2.java | 53 ++++++++++++------------
 2 files changed, 65 insertions(+), 57 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index e5e70c31b..b6f85627b 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -2,10 +2,11 @@
 
 // 区间倍数二元组，java版
 // 给定一个长度为n的数组arr，下面给出倍数二元组的定义
-// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数(>=1倍)
-// 当i != j时，(i, j)和(j, i)认为是不同的二元组
+// 如果arr[i]是arr[j]的倍数(>=1倍)，那么(i, j)就是一个倍数二元组
+// 当i != j时，(i, j)和(j, i)认为是不同的二元组，不要漏算
+// 当i == j时，(i, j)和(j, i)认为是相同的二元组，不要多算
+// 比如[2, 4, 2, 6]，有10个倍数二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
-// 比如，[1, 1, 4, 5]有10个倍数二元组
 // 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 提交以下的code，提交时请把类名改成"Main"
@@ -29,12 +30,16 @@ public class Code04_Gosick1 {
 	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
 
+	// 每个数的因子表，用链式前向星表达
 	public static int[] headf = new int[MAXN];
 	public static int[] nextf = new int[MAXF];
 	public static int[] fac = new int[MAXF];
 	public static int cntf;
 
+	// 莫队任务
 	public static int[][] query = new int[MAXN][3];
+
+	// 二次离线的任务，也是链式前向星
 	public static int[] headq = new int[MAXN];
 	public static int[] nextq = new int[MAXN << 1];
 	public static int[] qx = new int[MAXN << 1];
@@ -44,16 +49,13 @@ public class Code04_Gosick1 {
 	public static int[] qid = new int[MAXN << 1];
 	public static int cntq;
 
-	// 每个数分解出的因子v，都会让fcnt[v]增加计数
-	public static int[] fcnt = new int[MAXN];
-	// 每个数x，都会让xcnt[x]增加计数
+	// xcnt[v] = 之前出现的数中，有多少数是此时数字v的倍数
 	public static int[] xcnt = new int[MAXN];
+	// vcnt[v] = 之前出现的数中，数字v出现了多少次
+	public static int[] vcnt = new int[MAXN];
 	// 前缀信息
 	public static long[] pre = new long[MAXN];
 
-	public static int[] cnt1 = new int[MAXN];
-	public static int[] cnt2 = new int[MAXN];
-
 	public static long[] ans = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
@@ -89,23 +91,21 @@ public static void addOffline(int x, int l, int r, int op, int id) {
 	}
 
 	public static void compute() {
-		// 单点贡献 = (之前数, 当前数) + (当前数，之前数) + (当前数，当前数)算1次
-		// 然后把每一步的单点贡献，生成前缀和数组pre
 		for (int i = 1; i <= n; i++) {
-			pre[i] = pre[i - 1];
 			int num = arr[i];
+			pre[i] = pre[i - 1];
+			pre[i] += xcnt[num];
 			for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 				f = fac[e];
 				other = num / f;
-				fcnt[f]++;
-				pre[i] += xcnt[f];
+				xcnt[f]++;
+				pre[i] += vcnt[f];
 				if (other != f) {
-					fcnt[other]++;
-					pre[i] += xcnt[other];
+					xcnt[other]++;
+					pre[i] += vcnt[other];
 				}
 			}
-			pre[i] += fcnt[num];
-			xcnt[num]++;
+			vcnt[num]++;
 		}
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
@@ -121,51 +121,55 @@ public static void compute() {
 				ans[id] -= pre[winr] - pre[jobr];
 			}
 			winr = jobr;
+			// 接下来是winl滑动
+			// 课上重点图解了，需要考虑 (2 * 滑动窗口长度) 的修正
 			if (winl > jobl) {
 				addOffline(winr, jobl, winl - 1, 1, id);
-				ans[id] -= pre[winl - 1] - pre[jobl - 1];
+				ans[id] -= pre[winl - 1] - pre[jobl - 1] + 2 * (winl - jobl);
 			}
 			if (winl < jobl) {
 				addOffline(winr, winl, jobl - 1, -1, id);
-				ans[id] += pre[jobl - 1] - pre[winl - 1];
+				ans[id] += pre[jobl - 1] - pre[winl - 1] + 2 * (jobl - winl);
 			}
 			winl = jobl;
 		}
-		// 二次离线阶段，fcnt[v]表示v这个数字获得的，因子的数量 + 倍数的数量
-		Arrays.fill(fcnt, 0);
+		// 接下来的过程，v的(因子的数量 + 倍数的数量)，都计入xcnt[v]
+		Arrays.fill(xcnt, 0);
 		for (int x = 0; x <= n; x++) {
 			if (x >= 1) {
 				int num = arr[x];
 				for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 					f = fac[e];
 					other = num / f;
-					fcnt[f]++;
+					xcnt[f]++;
 					if (other != f) {
-						fcnt[other]++;
+						xcnt[other]++;
 					}
 				}
+				// 只关心大于LIMIT值的num，去关心num的倍数能否得到计数
 				if (num > LIMIT) {
 					for (int v = num; v <= maxv; v += num) {
-						fcnt[v]++;
+						xcnt[v]++;
 					}
 				}
 			}
 			for (int q = headq[x]; q > 0; q = nextq[q]) {
 				int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 				for (int j = l; j <= r; j++) {
-					ans[id] += (long) op * fcnt[arr[j]];
+					ans[id] += (long) op * xcnt[arr[j]];
 				}
 			}
 		}
+		// 1 ~ LIMIT 这些值的倍数之前是忽略的，现在计算，复用vcnt和xcnt
 		for (int v = 1; v <= LIMIT; v++) {
-			cnt1[0] = cnt2[0] = 0;
+			vcnt[0] = xcnt[0] = 0;
 			for (int i = 1; i <= n; i++) {
-				cnt1[i] = cnt1[i - 1] + (arr[i] == v ? 1 : 0);
-				cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
+				vcnt[i] = vcnt[i - 1] + (arr[i] == v ? 1 : 0);
+				xcnt[i] = xcnt[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 			}
 			for (int i = 1; i <= cntq; i++) {
 				int x = qx[i], l = ql[i], r = qr[i], op = qop[i], id = qid[i];
-				ans[id] += (long) op * cnt1[x] * (cnt2[r] - cnt2[l - 1]);
+				ans[id] += (long) op * vcnt[x] * (xcnt[r] - xcnt[l - 1]);
 			}
 		}
 	}
@@ -195,9 +199,14 @@ public static void main(String[] args) throws Exception {
 		}
 		prepare();
 		compute();
+		// 加工前缀和
 		for (int i = 2; i <= m; i++) {
 			ans[query[i][2]] += ans[query[i - 1][2]];
 		}
+		// 贡献是重新定义的，答案需要补偿回来
+		for (int i = 1; i <= m; i++) {
+			ans[query[i][2]] += query[i][1] - query[i][0] + 1;
+		}
 		for (int i = 1; i <= m; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class178/Code04_Gosick2.java b/src/class178/Code04_Gosick2.java
index cf535798c..68b880172 100644
--- a/src/class178/Code04_Gosick2.java
+++ b/src/class178/Code04_Gosick2.java
@@ -2,10 +2,11 @@
 
 // 区间倍数二元组，C++版
 // 给定一个长度为n的数组arr，下面给出倍数二元组的定义
-// 位置二元组(i, j)，i和j可以相同，并且arr[i]是arr[j]的倍数(>=1倍)
-// 当i != j时，(i, j)和(j, i)认为是不同的二元组
+// 如果arr[i]是arr[j]的倍数(>=1倍)，那么(i, j)就是一个倍数二元组
+// 当i != j时，(i, j)和(j, i)认为是不同的二元组，不要漏算
+// 当i == j时，(i, j)和(j, i)认为是相同的二元组，不要多算
+// 比如[2, 4, 2, 6]，有10个倍数二元组
 // 一共有m条查询，格式为 l r : 打印arr[l..r]范围上，有多少倍数二元组
-// 比如，[1, 1, 4, 5]有10个倍数二元组
 // 1 <= n、m、arr[i] <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5398
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -22,7 +23,6 @@
 //const int MAXN = 500001;
 //const int MAXF = 5000001;
 //const int LIMIT = 100;
-//
 //int n, m, maxv;
 //int arr[MAXN];
 //int bi[MAXN];
@@ -42,13 +42,10 @@
 //int qid[MAXN << 1];
 //int cntq;
 //
-//int fcnt[MAXN];
 //int xcnt[MAXN];
+//int vcnt[MAXN];
 //long long pre[MAXN];
 //
-//int cnt1[MAXN];
-//int cnt2[MAXN];
-//
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -82,20 +79,20 @@
 //
 //void compute() {
 //    for (int i = 1; i <= n; i++) {
-//        pre[i] = pre[i - 1];
 //        int num = arr[i];
+//        pre[i] = pre[i - 1];
+//        pre[i] += xcnt[num];
 //        for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 //            f = fac[e];
 //            other = num / f;
-//            fcnt[f]++;
-//            pre[i] += xcnt[f];
+//            xcnt[f]++;
+//            pre[i] += vcnt[f];
 //            if (other != f) {
-//                fcnt[other]++;
-//                pre[i] += xcnt[other];
+//                xcnt[other]++;
+//                pre[i] += vcnt[other];
 //            }
 //        }
-//        pre[i] += fcnt[num];
-//        xcnt[num]++;
+//        vcnt[num]++;
 //    }
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= m; i++) {
@@ -113,49 +110,48 @@
 //        winr = jobr;
 //        if (winl > jobl) {
 //            addOffline(winr, jobl, winl - 1, 1, id);
-//            ans[id] -= pre[winl - 1] - pre[jobl - 1];
+//            ans[id] -= pre[winl - 1] - pre[jobl - 1] + 2 * (winl - jobl);
 //        }
 //        if (winl < jobl) {
 //            addOffline(winr, winl, jobl - 1, -1, id);
-//            ans[id] += pre[jobl - 1] - pre[winl - 1];
+//            ans[id] += pre[jobl - 1] - pre[winl - 1] + 2 * (jobl - winl);
 //        }
 //        winl = jobl;
 //    }
-//    memset(fcnt, 0, sizeof(fcnt));
+//    memset(xcnt, 0, sizeof(xcnt));
 //    for (int x = 0; x <= n; x++) {
 //        if (x >= 1) {
 //            int num = arr[x];
 //            for (int e = headf[num], f, other; e > 0; e = nextf[e]) {
 //                f = fac[e];
 //                other = num / f;
-//                fcnt[f]++;
+//                xcnt[f]++;
 //                if (other != f) {
-//                    fcnt[other]++;
+//                    xcnt[other]++;
 //                }
 //            }
 //            if (num > LIMIT) {
 //                for (int v = num; v <= maxv; v += num) {
-//                    fcnt[v]++;
+//                    xcnt[v]++;
 //                }
 //            }
 //        }
 //        for (int q = headq[x]; q > 0; q = nextq[q]) {
 //            int l = ql[q], r = qr[q], op = qop[q], id = qid[q];
 //            for (int j = l; j <= r; j++) {
-//                ans[id] += 1LL * op * fcnt[arr[j]];
+//                ans[id] += 1LL * op * xcnt[arr[j]];
 //            }
 //        }
 //    }
 //    for (int v = 1; v <= LIMIT; v++) {
-//        cnt1[0] = 0;
-//        cnt2[0] = 0;
+//        vcnt[0] = xcnt[0] = 0;
 //        for (int i = 1; i <= n; i++) {
-//            cnt1[i] = cnt1[i - 1] + (arr[i] == v ? 1 : 0);
-//            cnt2[i] = cnt2[i - 1] + (arr[i] % v == 0 ? 1 : 0);
+//            vcnt[i] = vcnt[i - 1] + (arr[i] == v ? 1 : 0);
+//            xcnt[i] = xcnt[i - 1] + (arr[i] % v == 0 ? 1 : 0);
 //        }
 //        for(int i = 1; i <= cntq; i++) {
 //             int x = qx[i], l = ql[i], r = qr[i], op = qop[i], id = qid[i];
-//             ans[id] += 1LL * op * cnt1[x] * (cnt2[r] - cnt2[l - 1]);
+//             ans[id] += 1LL * op * vcnt[x] * (xcnt[r] - xcnt[l - 1]);
 //        }
 //    }
 //}
@@ -187,6 +183,9 @@
 //        ans[query[i].id] += ans[query[i - 1].id];
 //    }
 //    for (int i = 1; i <= m; i++) {
+//        ans[query[i].id] += query[i].r - query[i].l + 1;
+//    }
+//    for (int i = 1; i <= m; i++) {
 //        cout << ans[i] << '\n';
 //    }
 //    return 0;

From 5408c9caa97360addbdbd8275f5491354715c7da Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 22:15:57 +0800
Subject: [PATCH 1411/1712] modify code

---
 src/class178/Code04_Gosick1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index b6f85627b..fb904bf21 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -122,7 +122,7 @@ public static void compute() {
 			}
 			winr = jobr;
 			// 接下来是winl滑动
-			// 课上重点图解了，需要考虑 (2 * 滑动窗口长度) 的修正
+			// 课上重点图解了，需要考虑 (2 * 滑动长度) 的修正
 			if (winl > jobl) {
 				addOffline(winr, jobl, winl - 1, 1, id);
 				ans[id] -= pre[winl - 1] - pre[jobl - 1] + 2 * (winl - jobl);

From 01ebdbd09224139da9df7a09c037981984fd2c55 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 12 Sep 2025 22:42:30 +0800
Subject: [PATCH 1412/1712] modify code

---
 src/class178/Code04_Gosick1.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index fb904bf21..96dd2ba5a 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -107,6 +107,7 @@ public static void compute() {
 			}
 			vcnt[num]++;
 		}
+		// 第一次离线，执行莫队
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
@@ -133,7 +134,7 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
-		// 接下来的过程，v的(因子的数量 + 倍数的数量)，都计入xcnt[v]
+		// 第二次离线，因子的数量 + 部分num倍数的数量，都计入xcnt[v]
 		Arrays.fill(xcnt, 0);
 		for (int x = 0; x <= n; x++) {
 			if (x >= 1) {
@@ -160,7 +161,7 @@ public static void compute() {
 				}
 			}
 		}
-		// 1 ~ LIMIT 这些值的倍数之前是忽略的，现在计算，复用vcnt和xcnt
+		// 第三次离线，1 ~ LIMIT 这些值的倍数之前是忽略的，复用vcnt和xcnt
 		for (int v = 1; v <= LIMIT; v++) {
 			vcnt[0] = xcnt[0] = 0;
 			for (int i = 1; i <= n; i++) {

From fdfab739b24ff1cca865b97482de2fb81d5d153f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 13 Sep 2025 14:04:30 +0800
Subject: [PATCH 1413/1712] modify code

---
 ...14\346\254\241\347\246\273\347\272\277.pptx" | Bin 0 -> 47603 bytes
 src/class178/Code04_Gosick1.java                |  11 +++++++----
 2 files changed, 7 insertions(+), 4 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243178\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2303-\350\216\253\351\230\237\344\272\214\346\254\241\347\246\273\347\272\277.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243178\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2303-\350\216\253\351\230\237\344\272\214\346\254\241\347\246\273\347\272\277.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243178\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2303-\350\216\253\351\230\237\344\272\214\346\254\241\347\246\273\347\272\277.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..13a4577e8685deb391776cf6599db1724eaee207
GIT binary patch
literal 47603
zcmdqJV|1lmwy+)B72CFL+h)bKT}j2<QH2%Twry8zn-wQt`sqI7?We!<oPOVN{`DSX
z-|Jp$|5|gbc}=W2x1tOv7%C7D5EM{|1D#G~kQK+u=S&a;2nZGk70AHJ)W(^C{%=oU
zAf(S9{`{!`j9Gy)!HGRQ!Q}ahC!k70Uz@1FEGGf{0&3V0u~&uFWu70{0%s9|kt|YL
zTe&m7H@2zprXd2D_f3oz>J2HMa0^*AJ@|O(2n>JGH8QxkXw#TxH2?5Qi1@CQ#1S?S
zi>hbItWuiJFXN&uffbkO?+m)#YI~{V$C91SG{LVK=c^gW<-`0I9UVUpUWDL_u3bBC
zJrgedod-*jF8J)HweDneApn>Gw!$7`)K|dMYy6#0c~(Z>MOiwq*OhF@XX5BWAo?Jh
z0Lx4aotllesq4GLZ>aShSj9hy1&nABt@U&3IKV(a$e&^{u{Tz9vUhN1Ft&FxrT4J4
z`R{~d8zW~OEQlm}`3{rX)@VlvrgfjJf({~OSS7MLW0Z+l$b;qYM_&6wCPu8oYu<D1
zOxsVzWLK|hrB#WH>n_33xr%?|XBh<>!T^>?DF3YWU0^Qe4)Z0hJEm7dSTI6>BT-q)
zWboL2QLMU5jAKalb)oq;l{wyTWHSlq@Lj#sxZ<uF@*b3Z8oKU1!GbhePQBBMbgwnS
zGdEp99bCiF6G8=vCwJA(PfD=A#>Q6tI+<g{cu2uTu0j92`G=T9hN#cY|N8tQ{qyFH
z931{?@0pVmFujaOU|ZfliT5@Ny^yHhT2QC(OCJC>D*?;!BibjcILJOgv3-mLa|mtz
zVens_f-`wl8&Ct%qWTIFnvRvT_NOt<*^~o@5dg!WvYEQ6B6+H_G>=?rErV;C5q<}_
zySc;KMMk7=cLC)wuD;6EEZM*+Aq13NU+b>BiizHyQZD9bOcd@1aQ?iT+I1^P22da%
zaXg^Uy`Ta)IJhu4IGH+|+PN6HSlZkD)sD_nZS7YWk%l%eRYW~`8azp%ixnGIOXW|f
zRa+4aqd>LrC~EN_e4aBigM*c4>}EYoiF%el+HTjcVUZkNJ4Q+x$aPJ?aaK19taXC7
zzsA?>FTFqcxW_O3N>I?)FWwVHB98}?fc^FZGpD8lP>ahI(@g^)anwo-4opVpl|V`M
zIi}@&h97Y{d91|Y;u`(2-hUh0k71c+bkoqShA{L?iZiDbp=MNi#*9V)P_a3nL$?2+
zjS^PI4t>*`$Lbm4Nfe=~ze8-#TwfOmm!*@!6etDT`WP5Y`uegXG_1j+-iW!{i7{w|
zB5L$i$0y%S5Nm02Z`6|}0}T+S;;jd0mby`gBIU0?)rL^23KJb57<E*@#~*t`=Y7y5
z`0aWr8N1ebL2#;XfEeT2RTa7p_fj$GhQ1Ntj7gev+8gcx`%4<hJ6@aX#gpAniCOZu
zod^TmgFY-EH)7PhHlC%Wz{KhM{D#YD1@3id4ZM&cuO*2wY`08$82$E1ek1tglm-84
zgJ+J1RD+B*qi5c_A{p$evIdm5Vbd$PbVCK&R~bQDZKiUS(gdpXBu%W`eihmZwr{Fg
zr|kROq4-Utw!Q_$zB)~y_vA?wuh_2ozB#X+yYs(onm8`Aqu+LF3`NsXCbrid(j57E
znh#o!xln@5qK?4DuaLV5!NiL=wwj;SZqB|_+7{9+1p<48V;d}lw5xh1V|1NJ7FN2Y
zoe%qR(A<wlv_;LjvA0fqGlOj?!SLY<?My3t3F37iv6Qa1!6}_@v|F}pvz{nn-p*&c
zAB`pYMs_KZ8wUSv&p5F;1Yj)vdi9~q{8)(ZF9N-%YM(~dMCOxbSp4WbNnc#wAU;hK
zn62HtlN2CE7iPPmasjRPCDq7;4-l~=p~_CnuK8S40|!}iiOmk5Zf-nxxdbO)x9sQt
zx9On~%h3{?Lf!IfJ*xvY=M=d4QV*90<Yd1B3TRQ_t&al&H)r0Q!?R!R<p_KR#3V}(
zmaD_yWj9u6U<(1WLl*L6a}Wy`d=c^78WI-g6qNaF50?+*qy<ts4l(E<);6vcXJ*rT
zog=~re5TLyzaT_vBC>+#lbujdKtKflP`baHmVZ^fzce)+3+wWIgs6~LFMMKs9R&ub
zg<5StFcb8CU{)Y@A012B<N&j;ua4!)uh90x&dR*wB6Q)>FWCsZO!9n-qcg{Xc?0t7
zrex4jH$STIXxGZK?ObXXlt`qHm*bIC_-Vu}60O{aHwa*#{&IW^{9~h}`6zr=Mrk*2
z+Fcnm<{RNa?^)oDl7hX4ndI3hlIMVBz{lNz+Jdsj*4;FyibiF35YQ8CbLTisSh0}l
z5z135PVX<|c$xm1@3GK3D9cDSGGO~}o~Q5G*z|BCoK21>DY#<4@!CsOAVUVAY~u=K
z!p>Guvcgme-wDMzOQCGb=Z}5vv>3^q_5DKC`$h`_9l@Qru}N^%G_|Y`8Q49`e$GcU
zXF?+{BN;I!5I0iyrlN+cAy4FMYNK7tM$DH=nkkq2p?Tcp97Zzy8GzE7-8o~QC~y0R
zE&DG3{$bGmihh~#a*>}r54n7g0JO<b*GgKRit&0cy#W&yl24BWr#@cax+}ttwL&f%
z|7b^?YM-;UXH>&bz-78GEr~Amaq@^do-eDKdUMKa?8_aqC7<F))7je%qz)&uv#k=Q
zYFS9ryE1GUJWCiCC#@FCa+#H=)#&NT*BJD%sAeiL&)OK-<rF`3Kbj;2L4<lbw(BJ_
z%d&jJTbbf}SN`@vJ;FGSv|4V!h=fP9t7#Q_MLNC?mBWM>E!27tpmFRWoR}0fD^lc7
zV5sTyFDJAA*$KYyQyN+SBn>x9Q}_Q_8Z$k1y^L@WTRaL%`|@+S&~j+s`^YD88zIBK
z$q+9%nm~^3PT`ze@?_(Y9Ddx5ZQxySs&g2ICwk2-MwbwJau2y2PaF<8zF8r>EYQ0*
zLCuBJyk+G(cR&~HO=@2QPfN*R0VW~7x`_SssWEp;VCGzro3o*7{V|?#Xnw;AH`B-S
zL?cX%7;NMsRwf;$g-$1sX9}ToK=GzQ_G(Xt7Xt2hKE?o%XO4m`eGYAIv>Xj%%knEu
za1LjigVqb$_@V4y&cxz<#qQty8^EU&(Ep*I#`d<hpGHy0)y2Zz$@wo2#<bku3_bXk
zuYyu-lcktwL<Q8&XaPQ9zU7xAlU~_Zu1=wIX^esWD-VL$<qLeq0}he1X^vcK>3E!~
z8fQO?{(T=^oBqm)#+=3KF7Zg0ogYOphuUntgP2xSS~{Q+uyBJ#<q{xhb5cQPlIscJ
zdAiB_+TWb?eV$p1Vtp^`xw1RIU0+AXVX4V_FSm9lpdVNS!ciP7yt6^SXC?~s5S42C
zGHtOE856)pUm+K6lIBovvY4dv0smPm&XVzoVIYBkI^}?Xi2fk~XB$fsQ#m7N7gHx^
zhJTtc{gp7zGgj?ZIgtc6U(mkkV^oTUw=NZ{a2~hP#px@W3j`!v>Oi?_MYv_6gFn-~
zR1+*REEAEfI5{iru%R!dc~(pGVd+oBq4w<!jL8j_v+b*C?}^~>x!Xn_NHNLW4otuA
zTCGK%r<hOaCk91KY{W||+67AJ!w*mE!zdx(7D*?wk}TZj=5yswz-A!>$NFrKb3Vaw
znT}uUa=0)94%~L92zCv|4=sfa&_<~9T8de=6On-%Dv~X=j@L$q_SBuUh1f@5DydCF
z)uB;RxW9b6s<5eL-4;_DAGpmQPQ!KC6hs)VD075Z&yZb`^;5vOKa}wM{SB`4TS1-U
z=nt>0$Yb!`#kA@iK6Qac=ij}{EY9_HdAFsbH1Z{hH}}^1^3tg=;GG8kd+OXlJxvuE
zCN36ZYpTM=2lMjM4t`Ds7V&WG&RHY&7C#%XRs?6GUtRKJ?1Gc#M@@?4k_j%V<&wKL
zjn0oiGSqWw)m-=OIELmXQU!|?PpQ$O>~zQ{=xVqa*lX8UAx1BqEW^`LUW0F{lk;0O
z)pCdVZ-{Bcj4v%9i}bu)-8BfO;6a=0NS*RJ6CYX!MBboU?B?`?eF?t5>z9pW?<IN2
zMUDe{rw>?>8|M@5P06fOY>5|WoA}27B*SX_<|R>j$sl`6Ndj`eY3->&T8^kIJh<z-
z^ugjeBEI=C;DQ&2#^XGQll(gEz>Zyuj~v4A^?8TCnFM<3F_#}jap(l`KU!cSiNsc{
zkFJ!E5Eln@q=M#f^Pj+o06*)fEzhj$BkToC+L_Q4Ucr-$ZyYR4Bdlq<RagjI{qC#3
zC+u(zdzg_%y;aq`CB{eyW~2_4zfT{ykxKQ+ty3eOFE44UrB`+JBO~7lQDPe|cvhSd
zfuPpPX!wzs<r?Y17gj3ON);pi>No8R-+EU~f1JjADkAUi^YJ3pJhrkLm&44(e!tY`
zxU~~n9NR(Y5^rAou~71}5;LzCWjc{(Y132NW&-=7k&Cyt$GbG>Lltsu|Em6R;01Q!
zMUB1SRVoM8o8_vu;$&?4-C2y2aZ|L`U2?t^>fz=7>pm!+ug6lPjzF*`!b$Nx32y6!
zKSn*GBSW5}#i1BN*>7Mb!+2gT^lFC8Qf<`&xDZF`i$2{E>ySO5iKEvDS&Hcop{R~R
zyzEynODEMhgxVK(C%d+i^URFN;)|fxZf!d?6Na?|o5JB|>`;uuN8GLxF$|KfU+zp7
z14<qnk;Wgq-MgGoxf+{ibYcMp2)JAi&Sz)8<0tLv(iq=k5*J+pL)gDCK7_+d)>+3D
z!YZ8bmfYqekOD}nT_GaHr?C~R8`(P-AGL!TAgtxG*#Z}XwZHUo56-?~lN&yn_SFw=
z%)`(vAcF(DNZCasdGM&zon{qo$PwdiFCj94K@dp7`}5q|d0s9<*o`e-R*TW;tQnm)
z*aRWybeZC~E$t-R&Ku#>+w3B&R-3L~R!3_$4xcl|tPU3UHS;+Y8z1%lp3aG>fn7BY
z<%VFeLBv17?5O7RqO>8uU9E?azoAY#t@R`DJFCp2<yX;1FY!uRV8~Th6OPBq6cU|S
z#GsX{Y>JFsD&{Iuu3hWeNP}hRWmss#f%=&kcfeQ!MTXKC&;eSf!%`Ufw)C*C2vcaY
z_u}i9`t#QMNwW&6`k|O&f6tis1e#?-2ipze(4|sNY+<~@OWU?6=3oc7joh{M8}zf)
z?)=T(m^yABg5}E<{vs|J40A<F^ZA*8T6zyv38gGYy<gEfol1$aprc4zC@~dGmcB|V
zuaa^{@sJfkhgCa*j>NDb+4sW9(%6N50Sf5E2c6`H9~O(AH!2`x6X~A!D#FSO&<k>l
z(w-vAX%VbMi{7oda&i~ieTheW<8UEw&DPyaTbw%D*bc9uJ;x+b@SG4C5V-!32!5Ej
zdlHnadzenxPFFD**+Cggk;Wo1L`6gtOYvX$Wn&Hpa;%4$_E`6Vd7N?)oQTiT;cJN`
z626=dhZB%Xd^L6(4#Aa^Zzn0*6q3gjH4C*Fp4qz_J7|(Q2klXQ8{NyA>zO{M39!pq
zn4^*qE&K4Oci6&@t+WM?J8XL%9a1RQqlIoldBj{1==?C<jLm$ZJi9PO7@~0e7REdO
z0H+C2Zv2zc&fpyWZ*N(G(xTPCV*##bpwgR3@N9-y)iFMPExs=-e|z(65AR@PPIm`g
zoKX;P#Qkn|YuC;FyloM%J8iQ8uQ|lYW1E?r93)IjC9r2^O5E)G!v3rxC35kx&-!k#
z6U^-Z&@ewnr>qg`I_i)PnvgPfKC1Zpc$F#LHzDQhd=>qV(f1#t?LS7ne~fZ}jCFjl
zHUuAB=Upvs+8<%(XUhVAHm<hbp_!PUt_3*^5D@KuXI%dt3;e5z{mWQjU~$Sih!M5>
z+WP}$#5a7ZaWTe<!B}z0(#2nJ`Vg@&ob*`p;{_ZhPuTN}(F3FB2d@A{7k<p<+z+3e
z+aR_ApwtL3IotFemx4#mE`GEf%?gA|&J(1jN53DwC{vgQ5&XeVT2uxPoR$pdQRMuV
z73nTvO_eHjl>)Az)G~9rEiYKP+T*hFa#U+2!0{PXEbpd`wyQaV7&->ztlK>_s$u3#
z2=kSFiZE36G)*+aoC?K5QD*{Jez@2^a~j^zu;c5`U%yc4IFB+*H*P0ZP%S5`H0GFa
z71_v)xMkF40MIgO@yJ%4M`5HPs3>d|W&`eZ(gExn2ysL}izq;;AcnTUaZEsq*g&bE
zhUdVq5JGf*52Xu;f0nv(VPQE51Q3vj`v1vvxLBClnlk+H{A({p_YW_|_fiAOORv6_
z$4#+FG96Qo@EltT-B))S#k3@cl1}RI_dQvOH|daFnv2dEXF%T=kvS(XZiGmW{pPw^
zfAe5e5m#pVB+e=;Bm6C8!D-9W!~V|wypQ|c2^}{o^kg;BOd>&UODdESt~NTNDbtSq
z4Ty>s#v!eUu-WoT1ZHb|he^Mat@l?`$^x^6tn)ek*j?6s3eV;dMl@3jxG$vng}hR*
zcG#$<9(Jvh0++}NeGF36)t;)SUeeW8!)ij3OJc>4)fG}M`^Ekl6&eIkES1Qq={+US
zEERc8>Y#*Q!*q@mzLx>bB(;?ZG@aRp@j%ZT%>9JOW=ssi8f`o`Zi-(AP8u=VoZP$H
z5+T?;-o)9Wm>ii;zq`_pe2}nlWWHU)->|>#f%4mVDdO{)-k~7z*yMBb@_?6?l&%sl
zH(rf)#g@!Sh|Rki$OW}mQV$h0^`>^4rV=r5Zj9sP8v@kLBe{deC{b<`FtrR4!^dA^
z*;k{4A~3B0Lp|jIod%B676=#wsuwOa02;L#$4nfhhrc(IJVsd;c*@UO5W%{NH`$Vx
zN}ALHR{AQiW-WvEcVwsmkzi=bX?bMjo(uPBIAW7zeB%|q)*Jw3r3ziK{8>2Ma0O3Q
zbZ<93JJ;5k7Pd>68&${`m|Fxt*&iw(4~Yk0yR+XU3bgR7N5#GpHt2DFX+pKVLPEx+
zYD>YJpS$^{vbU7UC9N1N5y7+Tyq5aP+r}1jsl4MEWrG-H1F!KV=PkpLg~L1$=ZAP$
zL<^P-22p|*(aWxjEp}M>{;eS8DDZ`TB%(Mkj(L*t%WC<?7bQk|c_f8V_14l21k186
zoX1gwDHfp95^WEaLxK5TFU|(e7)Q#+#Ck0)4L4@(msdk;*}4U<YgiuN52?sTv_1dW
z-K!v`A*S@VA22VRRWY3IKK*t`XQzcQq$nc3QnN+0r00vD7Hn*p1Dn7ytmVl|n_Nq!
z8NjW;6QrW|R*q+4)%DuB%GB62u+;d*JcuA}gU4%UW!)@VF`1V!2|ua*bW)b+OH6>u
zkx#q*eLN|g45#uY6!Gl*sI7W-nfpR$bGei{jV4Zw|2NDy9KdYhrp_Co?KC@)U0)Tt
z^iF$!W*tDKO|^pA4uw&2*J&OWN%mDzNj5WSz~F|4yk(xEO1Ut8@64}UcYEJaV=-+I
zUd8LypCim@j?iDZve2-UqBz}XeY`Y1C;d!BzMfc_C$s!F0eRTuC~0m^qJ|yMV4>kL
zH}V8GWekV#O4-fKeprLA=jkvBE<*txbN{4ED6?bb7pmwz))e8i%!#-wnflh|6dB1j
zn2IQf5|-{72x2NV1T8$#$s=#Kg0e49q6xG2P9lBcLM`cNMkSWbaFB@Z>IB!F<m%0+
z?YW8*S$5}+wD>)04Q0`L+xr!2g$x(z`P_4?sZ(47+*H%0g@F3*7S<){SgY@x$+6a&
z=Bz3uHpI~y38k+LnqJ@4*1yY-pjZk{sU57&%T=;#rR^JxC98r<NP5KzG&Y{hbZtNV
zzF&Y<yEA-is8JeNh$9f-!~W@zXjhvVI*fl2UuS|ibXn^gpw0*C>ZIlPoW?oeCrYk|
zJ%ziunKFnl?ICGw{#?tt(J5z>=lGKtjfpy@xf^+F7*k>`nFQYfjFWi~xoSTQ5f?Zn
z%CX;`3k66bfW#OVT02HIfTTN~DMnU12KVo4Tozo+;4wfFgPhE^T+E<<f1^2Zp<o<8
z1<N_)WS>21WOnd8zp5@rWfzoY;V@kRO3Iq}j2evukAl*J<cs~s@UB$g>-N*`-P@Jp
z#^%x&G+_K3w#H9rzL%OUR6JGEfHO5KX1BB|hW$Jh27Vp?7?~0*#-{|y@!En4J_#g2
zDus;sT;TlE0+0luDkAPvlE}SWu>RTw%tBw=OV?f7OXZ~;pFIr2rNFXU^ZQt9#Kt8g
z@Adwh0P}NNSbWpH8n`$~)nQpg+@&7@fqsAJI&AJsH*(kos03jvB5vRjzXRAmF962~
zx)5;Qc#A!hWp}c@s{MRU@sH8>{g)gHPWU&WxzCh(E#kk#&ay_H_O34fh@JmF`Ae&_
zprQA-*xB!r3ao?Yxxp`rTkOmx5`4D5xC1hqj2lIrxP|n5i4J{f?yToGDINe&Kt9So
zNiMjEcoUXk&$>BoQSA9)WT3H#;H;#~+|a@DtC4ZULLabN^0s=iOIah3(d9iwo;zAK
z9cWho4n<6EVTGYw8@?M>-pz($o@fN(jWcRZx}Chq%_ZS(SW=0*=}J;0PF91%>kpG<
z$8H+JVA)u~6h8<xga+8Epp+)pwmzd;#2f+{x44Uwxp&t4Hj&Hrt^F!6wRM~m&4px&
zS(^iWWhnrB%62UdGNh=H*7Uor4C>tl3ku3DS@rERY~;?j#0G8N&~cM7>L#dC;MQ5i
z2Fj%f<8sp4m;Pk{UGrkc23@n-!Af?|l6>7vF&9KW_#yslBif8f*LK4*B>SSDmB>2o
z{DP9T2Sdd;t=YPj`WoDk*#HCRiu?;u(Szc^C?|*D;qc*C8rV@fQKwTBDWCiz#^klB
zBmH=RTGfwo3*oN9Ct#2_SF4X2F<fHXAjj#49<RWD9~#mMjEqHDcJYkGh`9$DILMJ8
zUC5lAOV1HbIpU9@uqS<N?@F8>ilRb^gU5*1f?o!|zXn^{QW;q}XGrN(<gF*gi8rXt
z=!Xwdi17(f$_=1=ReF=|pGO#~NfAE2xA*ukTW_1`R2Qb-&*|0PP|J$2j($v<G?a4k
zpsW9}I{{OXf;8Sw5UZ!*trbr;mPn}CIGo=gg4W-w))iuIU>w3xQHd(vq;~4|YjywE
z!Uoe08<}S0)g8mu(n>q`mMD^IETcY7%TUO1WTg-540Ph*!>E){J_I)B9Fv{#X+7C9
z!}pV>@2y7-BxCI@Me|m3<oboQd5qC6TF<+jvMTn~)FLWLMyTY9!&Pd@VJ1ip9vB1_
zjrv|WFonN|5q%Pjr@Zw61cf_Yhg=r7<%El98{4C;M2|na-u>c}?*Mosze-|#1+J9c
z8Sk^C_-ta=HDumCTG}iyF3_^j--JM><+sPSqwB7C(0d3Y=VALerihO;gM(<>2^Vd5
zZRenPuy>8H!+(<6XAM4T(RsG$jY+gRg*JBk%z?(LX8~O)fP)o*^!@~v=hf={ZK9=a
z8dGs<+Yw^CohSkx!X*grcl`be<(cGm$y*!*FUuBj(L|ay)vM*f6>*5sL+RS*kk~(C
zlStZQgX<@o%h~xl$Il!ThqQITi?3UR6N}5je>|=B%JP+iXQF1&c~O^viLC%@K^{EH
zNmR6CtS(jPC-)PRS14Cr0X{)&-%mrq#=#cb93PIV(X)pOK>>u#!^_Tpp@g>~YGC<i
zj*<K`5cpFN@L!bpry$^;Sn-!ZKy>UMSB$}zz7f^#35!8ttmk6E`0bLu0dY2ShPNUp
zVw)SdI#*kc=H{J7EAO@#H@!ci+;OqBL4_zfnB|?DV^h|VpDV5Go5OTzE!m0U0gmB)
z8P1$c$$L@iq$i-QH>p1L#3?LR=)pcv(KZIZAklxp9kI(YQzAGj!pB{Ixgu!%NltQo
zwm+9UCP1yJ9o1VViDldqQOx9=?NVVc3r~mE-I{EB;I@GAXU81m<JgoD3<$^s`QP)B
z`LA+~3z~X%yX;7Qn<_|NN9iO=A5Oot`lZ~J2-7iLy@0fHNpf<B0rkI@a|IRVg6>K2
zlmX}cD>fPAf+vuX#D_Q&9JleP_wRin3l?$(r5-GfSK)_*D|_w5X{+J4rxQa;CqA6M
z5BgDRdb$9f&RHm=XzYY=6)U>I%CZ{(bFO@IHhdIai-~AoMY}7kRA&H%dRyn=06mG?
zu8YSLDz5>3S%&_V&wxdq4h3LQRHVMNJouy|yvXAVfZD-$Mue#5Fa#{f^fGwssvEw{
zX#~ySBq5`2QsgJjRX_(loG-;u{|pXf3BdnJHnGqNVgAZ*sGQfD+KgKvhxVzRUQq;d
z%Z^%4<qp(nM}n26<zP`T97n3elI>JMd3-=tdu_psTuDvykZ!}VEpT$&R;Y2CKVb8>
z9P<V(8H+~tclIxkU@qqGdUFyS*!#BTou?CHr@*W2ua?~_=LB09eDl>-K|J}p_D>lV
zp7Jo2NR}|F8d0TmecpHDYKeL`Vo5w(=EivU{n62FADnFCzQK;DWco7J!EdxM9gwM4
zyQERRRe52?h(%gRYsS)p!qji!P9d_!JCbSELw5=H1+x{F_Fq9&^fbL#_6IU+bi2_|
zlt0#r!xOd{hXwV1lSiSzaX9&#)Np*Ah8NJW>@06JZ<rhxthm$NT$ooz`CXM1+TrYu
z-0T~UPnEcdVb#dN5U+OKAxyOEVjRq^%WR8WOnTx|z-rDik~*FFrgY!ei6No)gmM--
zB6RPNY*<yLj~QBW=~<=5JG(~~YU(sIIDNR$_>1j=64m7i7Lz7EXzvvWP}&LdMNyq#
zX>qCJ(xl4I#K!k{u1^^=u~GABoEvf#x@A^ySbhjLH<qS$L`vrT0WH27?swh1f5|9?
z<DxpgF~gvclj0L+^u*3rY63{dWRof$>$Y%iM(eipH?0@C?}Xxe1$s(lg#o=Q<dO#=
zv<Gox^RZDIblItqYpjA&b-H<MB}8ahPxss_bw6fJ?aS1xSJThMG0L8PrAM!_S9#3Q
z<766QoHs%UflVcxfU>>0XNGjh!-MI~vQ^BuihMksUScRw`(2Zb%HGiS#a1d|M%51c
zla;*xG&L9TAmmxSgM{wpty}$_Znk}?2^K_a*oU~u8)-O1jB5g1R=2*n!5-}(L4sWv
z|7`huU@1D~<^H1z{TZhUk%txJVV$`7{st_-pO%ml9mx;TVQ&%TUT3Vm5+<Tj-3Iuj
zm#GZ~w+oo<5#sKRZ%-}R`#}&=hBE@Y)j$9Gi8UhxBX94O7SmK8GiH`FD`uAUhxqmo
zt2`i5Ad`+oQVMhppG%^-&AEIv%hUG6>M1qsv|)evZ2NJ|4cfWVPR^ZtOBEolrk=H~
z5mc150RACdu$9DjWgmMg4WuOw3mN~_S6}1Fz75a!rDgAKz3a~i`hSP<A0YY<gmKSq
zJ3hoGj3*HOJ&alY3dR!}pD7b@B;P3w+Q;dl;r7TxY_94(a>}hG;R3(z2;EfC=9CM1
zS1F}zg9OB}6c>hkO0s%mEVeBSCkB=}=L1@E&dZHU2XOYVNB|&w*T4fokTlOz>VjhO
z=NMwpyr=)u0Uk~ybyuLbwoEo_7-nC%isZ;(B~2}e5hXpPi0F9*)sSK-RhPRnLenTp
z<y!Y`2z>~dBew55s&A`)3RY{ORy1<_B9sJL;;4>NqHO)*l1e#KOfa)?{flnzl&h32
zdIj>4guss;)4`H#YtMM4HBAfSJlaS7-H<gFR>!?b;N0w01x3kz445?kc1DIu$?*G~
zf?P5kRW3p#nhsMc8Zf`WA8#-R;7O>uYO_$#jeAhX$jd%^Ha!PxM;mqrxQQ)X-75}j
zW_ifY6#%T}&63R~5zdVYu0?xr_%rgDR#ERamwW6Lskr5Va-E5YHvHxC#|nuRTSSLg
zgoWaAXMtYmAoQt3JDO@bQ(&-iMl!;npYa}L=8XQZgd;*q#=4Q9S6}9zCn7>H)Xid;
zt1@7HilRf49b-F?-iWR{lu+`s#CV|E74<Ua9v=e<#4LYkZu#wn)?8-pgc^T(uVIuB
zUW|^MqpW=na2y=M+B53?k7U?Ydv?;d9m%>SO)x6=Jjh?n_awF@*LhgNcltHH__fz@
zugt6j>n{K*#|~(%W$jgk>GwK?Ay8Nly)DPb&v_kmcJOl;Y>stQO=ALDmMFl0ZRLi>
zkBg+S;S~j$%D(4&Oj4QE#tXzYb>j@e+xo?MY&_IQ15ENU;H@3gAcRmlQ7z+4z}3Q?
zP4zq|4;*abhR5=*jz#jhA_Ni=i(d+F_?m@qR0Dawb-uma(^|2jCQWwAW^{cf!1%2@
zsXqLRXs$!_GvEmFXk>RO!}P-{zr>7ts625CW8UB-Y)b>mu)l_IX)|nF<@5p|YQzmu
zhrgM65o)qekuG&hn*)BMv=*VL)Z3XBRM%E$Hno*v7$o!jLa?W*Ns-8W4|TFJm5Fxh
zZJx$8>aYU>>i|;yHvM$wng_*=YQzAObepRYOMIp%+CllscpX}WFFxNB_F|MTl-B8m
zSrfRO<#&i!v?JC5Ks4Evho@|lyWlAn5F+B#AmY^^dQR<4MI+;<yKQ3AFL82^XHt?2
zpFN?W=y8?~J(S3cr@PNd85F|ILXUO$F{p22E%8IN595XJMat8l%-;{Mr)zH823s!g
zREW6^29ks!0>Y9x17VgmV{j(a<p=4n56)1-63Q=Vl@fkqYn56Kw$4UN#g7!j7wqIV
zOD;q#b^R`&#$r6krimiN((7go=gTVT#Nth1EZS+4C({_vh238hd4LYmwbaahw)qE%
z7<fG${7cgN{~fV^;N?FMu_z_QmP()bfsW7g|DW#G|I73LBk}+D3F}`Wc0qm2X_Xyy
z{g8%H*M%Y|zu26_oVaDgWw3^=;29VRIyGZQ4Jfz3g?p~*ICNje2^fHqL|L(K67N9-
zvc(7apo`o4uwRB}UYxs<s677dh#C$FEp=Sxni1B|pyN0?NaGiSerbu(6W#Jyg;)TR
znY5XZQAOHUo7!(qUn}!-K{jmj5Bhsm1-5h(Bn)@phKxA-GZKj{uAZqpT9y;BI^sWb
z_(s+!a#%HS6;#ru+U)nJ>;)yj*s=U6DE@ZRSG5*Wl8HXzePgmRBpkn~6WWa|tU=+F
zmhz1rA|^rFVB@Ivc6q+iE>KBEw!)6>G*Gtaw1*gvC?}H$ac-#>n4-RkHa}xcG({;{
z`-Cac$d%xPpH!%qXj{d$mnCB-wG>rhfvmM#^g6)bfWAV%=HLO2?ebc@zcJRQgB#{_
zybRbyU(k-844gHmp*@&?t=maqnQ2}Ja%XofJ=x<=N$9W0N=)Js>!gRYq{m-g*S*NN
z3KD)$74rtc4}|%Ou47DQU^S9tyW<Gky?!pI0$UL6D?=t>#|X<hVY9U;<!WtHQ3!tx
zSJ=}Qb<+{4+c&3?A)8uLvd(fsG5W!3|EmAHm1LSpXR7K{kJncwa`oGr#PV~IsZ5i#
zx8uI<jp5=$-PRP{%+?}MGZBAGmd2z)IoiOs1JYt)_)DG#bCiNDx<rB!YDly{`I`wV
zKif<b4^h7#8pJ3&rr4K9m$onKndLkQ2`cxy5n`3)8Am$yFUork6^};p95l7^Imx>o
zTdLjxl4=JK;-+Kcxe<(%GDq*&nd@O(>-9B@^EI|h*XLg8od)L)eC-LjjW}oTIHZl0
z_5_l>MbkD)=6bO_R-HC8i?Rlnv-z$iLD@RmN+B2EZ&y=YQ;ek#W_P<j$JYK8B(QD*
zDkCH)J<x2#2yhBO{V5>NDIkCkP~D@Dp5si{rhV&XXL=@(JGKCBZ*yM`{H5*>4~mDX
zYX>HUgAqCVdXM!>xn9!aXo)^gd)|vF$dUAG2iDdn9!|<20Mv9ym#(gl4Wh%k?Bguc
zTTJoGsP$gwspccuK6Wzq9VSSA8k9<FW2x;>)(RNalVk&+;4&Y<H%^H#d5%|*v<kg^
z{GHP;K9v9Nc|hWS>k$5-ssDkr3TB@LP5LZ<zxup7`**Zr`zu;?sL9x^G9s-XqJljj
zyv5rNgyD+HC&=+bWZ(zn97$68lTnG;DG?SO_jmySi6%JFGn{%ZBuaUn3YYMqdAE^i
zEQ(6DFjOd<oaZ8f;PF~SSzjKXu3ItsBA-TD(y)@(ccN+O9H5NMI0IW6tU}_5xb~Ma
zq{Y5_HzlVTpW@%MjI#PU%4XykbqNUJVt_Py_`>N|{sPa@03>F>tj1Z4R=Zls=~K?t
zlo&5177osU-4RK>8j!W5cuIVOoWa4?N1}_?T~#6W9GhMkWP*FHfNN7?4QveQ-n-dH
zz>&Eh)xtT0Onxe$Y(|`1Z;V453+P_ko&_*j$wA@V7gOESD6LyGD9hm0UX~R=h@n&B
zpo*SHvct1wR}1=g|7;`6TCkpYTTcac1<_lzc}07|te_*5i#y9D_2-O}xlw?uReAuf
ze^9zCMSfVE^jLb5GHnEIs?UYvg?c`{KU~a~0M;q0{r$U%|4nb-_WUO<Huqp0h?5O^
zK@EVRVQ;jNaejNc6MYU{+|t;-c(0oQrI@N_ddTsUQpOcB&~SwV-bTxV=3emfC6rIX
zwP4)l;_=nEcT+pp%@w#TZl)YjA&_YFMsruRN7c7zG|Vtr!WuxQ>;wL*5a6vdHL+mj
zUn_d(`j7**C4lo{L2@5}EHrrM?}rVzP3K*uRertz1eD%#$Q|>hbJiMtWVU{xSi4iM
zW?{W|y?YcvF51z0v~BK=5J%4*m2&9m#(0^(QJxIUNv%ZgDsjhD?vA*4-Gka?wg8$3
zt*5qnc5>HUgeG303yhx;%0j6<_KXzige9M_e&t^%<CYBeqWYn@e|cSMDcOTvkVZFp
zw38@Onxrkl0^=-0FDEo`D{_4~P5b!@@xRshKTi99pvEtKhc5^H3;|8y|Gmbu|CPr7
zEd>0`$N6qn5#CJ~akgqEo499+ow;Cu*M=*#5eUktk|s6*?&!n<{p1A74Q7eRo@QO^
zq~hpKAiYH=;mjv-;fF2-Y_P<vb6w~jmtYw{5s|YZa}N-WFAoQX^bdTSy&m*qSn2Gp
z<;&qfU@Ij&&eR5n<1bI!iQ!IVh@e9|lqo~tc}pR?6g@z*Fz@pSC4EAyFB*QIaQ)7u
zJ<V7P^BI8Ri2fo*$&OS}X;s2wf5WwrPmI0BdFo75^D6`_UF{Go^curXGm|Dq%#z-@
zM;j53eTxWgg>hUSP-EVRKby4VGq{4p7CPU%`(4X*!rBa@Dx3Bx13k<b!Yy(|(J7Fe
zMml`vh-ZB7!9pFHB%?4HRxB*(@i_tD%%w8fv+h->sMoB5Es?cpS8wHKya)C{aDbQ@
zCb6o_^aA^obG`&hety<u|7&<LyIpG>vCPxeU!0@Lk2CMw9r95kbfr9Pt5cQ&y4B~P
zo*pW#DtVB&erhs}ur4#KV#4=l{#%loPGkY48_@gi(u?bNwCu}3`{`Jqa+uR&X`CK2
zX+}$J3ctev0R)+!LzGe9OpsWYCEi%E$!Dna`&jWHgd+Q@35u4fFg-|<*nfr@4#OBL
z#IJd{;Z@l;SgP`%VI<g*)P`g5lvz51ksihB#&&qbg@_pLTnBOcY2x!WE0(Z3*X8w(
zSYvCeVyQP(`mix<(K&t<8U@#%1RkZuUdqn|{yDY=qkT}fmd#ceAZ;jMn>B>}McJ)Y
z(4lCx1kWv{>}mJwDaTIcR)4s|vjWmmt!FAB6o#<3=oeQK0#lOplsrECmYdWv6?!e$
z-7{?KW5SE<dmb--q1iVXbGd0ctuGN5Tu-O50tO><FmttJ$E(h)F*`O${R$4KR_UZ~
z_F}VNdY=@2SsXtTG9w+NGUL%ACw2{(UT$MS%*en$Gq8nqnOzB&ib0mzQlgLnG^NX7
zKsW=-;l<NeR0*l&Mi78lr?2SaP=0Sv1<1q(-z3doK;44ak+z4ZO`C}t$81#wo!$pG
z9JWxOwx8zC&@5ph<YgBaGa$@TO35E%Li90?%r<WuV<JKXl@s``R&v4ZzCTqiU*NjS
zSx*eykA~ISO<85|iCt)@wflR4((C)Yv0)tOxW_X}hT1;7rO<<9!}o4|OpBr0&mHW}
zNv~Bbp_qlIB!V2+S99}3`gCA^AUlzb=d!PF)|zmKQ(Vh2Wa>Y7_YuZ;Yo*D0X)XSQ
z+lkcz6moQVzl;N+AhhraIe##AJx@%ZX6K!-BtKZEkT}m>&(lfqXmXT7qB)c@{%XMc
zXzPNX!dom@LLw78Cx3ryuOuTKliViKEibB{^yg~Fe)*8mxP1R#^Yst5{0H(?-t{}<
z;ipGc@mXK}?>s7wzv63y+N#rM|J7$zlEt0;9?l>mQ>tLv9T7%hK0)@d(^-jW3BVyc
z^WB^5Nm%j+!i22BRV}}Hhq-Gzf7eni46AA>;1|{16fcy8oQL}26xHi*4?gLwf!Dc~
zA0^an13aBG-HcXjeN?pd=q$mgRFr)uQLx(S-drhg*0&n`d9phgD&cCBSM8Wgx{KAj
zV=9llQ!>I;oXd>br;TCxXp4n9YKg-43;k3J!TF<!j%UVnHL;B*cIdvyXA+mA)d0y#
zkIK)c8NKg*?1kShU2Tstv#I8Fpj3MdE~;l$E2CLIT)(R6E|S%av~Z!<Rx&FZn|WAE
zmoulR?<gr-<+ZlNf2C8O&ACiZ0y903Zln!s#leGXAjQb$xI5(Uud}63?Z9R-Ocypz
z&wLYOmuSL{W0(4^rOb=l1K7DmW<4PY(C3>kwMzG9FlRnGE(F4t(VG#<Fa_$+yQ)ay
zx2V@px^s4iQ#5Q?qnuclb|QBPmEZ&JuoJ}l8A9OU$QqqFX@MJ}ayelF;?I4}$6!S!
z;g|@vk>kMoMfn(K6suYYreFr#7N4U@x@j7Jr&U=`LEW^mZkWQEt=3Tv#!jCj*K}2^
z;7<FJ`edi@h6fpIq6_;mfd__65=KG@^T$<@(%w*^kOX6u!Z~@e@z=uN-__w4$a=Q2
z>?oV_v|5ZZwSBN-isu}xhU9^B^&?;*1CJD&9Rwy1JPz(op90-!g?O}O(CtRwT$C;c
zyF8dNd9{+Tz#njai|z|(&C=@iS;cM*LCD-bi>Rz}ACVN^y;^X)R^Ev)U_lyrSd1~s
z4{kKGnR15jd>o8`;^evy#iwVQQ9ROwr$kyH>qV1~jXAL1=UODn?hH^$^$u{h%I}Qq
zop9iWm=@|H;&XcGTXbP7wehZ7s@@<(h7LwYx6rk@P#Iykz^;qPDur9CahJLL{Hc=C
zxy7Igqu<IfRQ-^|_!Vn{uv@FHT>8eh%QfWk;&qPTf9s?Dp+EnD41s{FN<{n2Aw7R~
zko`M`aQ+oTI@DL4(mxq8rNQXs4#v*D1wGO)pKvUj<`MA%%pBH@sz?2~Q1qcM6%dV6
zB<FPtTCUzE;q8V|F-6aw?_@=5GGYPOu7bh&qmY*7SOkurt_qT<nNxskS4GRT$zp7A
zbOv8lUI`AS;1N|g75xXH=O|~P7lZjX!h)0?U^5UtD^lg2oKty1Au{laE{|w|v0LT=
z4O+b~vTC5j4&M`F)X~XO@UZ>iu`x8QFi(AHNpISSjwf<Kg|a^2LJ~_10sAMcrukw=
zPI<_@P4FVNTrq(wKoaO@*PsBHNKuvB=Lj)JDVeW{hpn`h%BBcnqAzqZYDR}y>N;&C
zPs)Ziq}rQMSy$hy5!~;EIZe%!a3p|MqZi@W<<$cOngv{l)9jpt#&vET*_oy@>(~@5
zTs-nJ>Xiz;ZMD}3YUCo_CCZK5fzI%(G}(IiioS^A{miFkIa_i$E5`Dcur;$W4!gum
z<6vm**Fh{2bm~lwi2rUFT(*eshEVO_&YJ~me<VL>*Ej1NG&~IHiRGoV)nX^JbSvSv
zCjnVMlL%X4$4C-`{FTt5G+-w0S-o_yo~1@<gq^&Pc@=vs$#0c9*OE*vw-K!o){fvj
zCfXqL0bmxFG=MQdh29zTT@P8GUhD`znOLi8KE2H7+b`b_)F1|HQkPxOXj_$sUoxz?
z;C&X%uUg@`@dUva0;O>(9YxF#@0?dIU&`Kv?=Z?XcCt&=D`}?klL#HH1quLW&mpy6
zLvG2m$+%Ot9c(mpAk(hqp#VjZs$6WPvQ23QV|DgSeV*oJCdR9&=k6M(dzLMM(H=t<
zb9T>nvE0>a&hf{DgS&6Ya`Vw^#<xz9ZWDKhdM9{p$Lne3E-4)a68DPp`Vwt-zu=#K
zc3$ctLWw+BbEZzcruwr%9i-$5?LEH}!jabrVaAvle{g4j^(=5y8yBhwvvE8+Ic@t5
zcblOs&#Uc#?mRT?OP&p<>7a4URWhxoTPOw=(@w}<m_1ojP@2bTI;gKOwd3RhtZTu{
zyM?s)sz&c_-@TUJ!np*V5dOEs`9s_O1Bqi`1vQlUNgRa#i>fxRzaq~6scM7j<aur~
z$&*IrS<Mwp!%TVrsuz{$jUbkpjadJz(Wrx5O-Rfqm9d<+$ym<~BPb{0+H~klMK1At
zGgFXOG^U5q9+>8;BkER@uFGwW-u`*olmOMq<$s?xA(pC_1G+Aijg<5w5A#5|w#77@
zbqFk+Wz?Zyu`%%r=|bG5HkO3@C<+zbuf`&DAu({BKWf^V#3C3hTS=M$(a13}q)AQ0
z3_p&_Yl<|DabZmdvxjtvKko(U4l<GV9uddmi1$^eD|lt7Ea_Zol+bb8Tt)CPV{+C+
z2%WqhfT6=ZbBnq9!qxng&_oro%Ifo_QUhU-zqd6HsD+G|8(PQIB$qzpnM3P1=K1JV
zaZ)lH*8mHZ=~*n4LzsY_LO$A3<UaY0h5J#{8xn}9u|dAsA9J;*5ZaQ@`LR#fi@VId
z#v<F6t#)JElxnd}^5uUKyV6JMZjB@3cbWqte1L8JH6Dw4pRlht4-c{@N$W1GT)UIV
zxO}36*NuI_Fc`Gm{F}8JCoKkVvfhV*v62NAZ`BTqrxSzox9^6<WOLjlBbgv9(;jD%
z;#A(V^ssn?3X^{LBE<wVkHti^R~l=sCzS~?A{jfV+4~CGZWk|sxLkU&8R&+M@tM0@
z1wDK$sqt?SX2805RtDmEC-ut|(`&tm?gF3cpxo8_18Ix?(PZI;u~eF;ALd&rZs3hC
z+1De;oIGKQP*8qc8;BrpPc|n#ZtilhYnoejG_^tmN)j`VHt}@P0cI!Ai4~yI-~w$V
zTD=04`QrKeQh&OsoIwzK9z81Tb@>W|^)tZKX~#m?uX-yO`SW)ru13pArhQSQI~`Vi
zj+=l960sGvIseMJ)b)jukN_IpU6eJ|$Dj880(r`Ej{J4({v%`W-VwdwXJ1Z*O9mWJ
zzyzw`Nm}!G=f}2I7=oi#6RyQa#&I|OsZ83lq6DM|uZ7K@m6sm*(hW1@_QYpojJ{-e
z<W^GAC^I=_{ie(wZ<JU@egg~ertaoJ+xo!S>gU;hG|EU63+cI!v6(L#qWTqRm56F}
zH@DBR4u&Z3(pYLa?b0PWx8G~<n3CY&xh-ebc&U)<(E39(z6t8JX@(V!p{tjK1q~qW
zSm%eYTV~H+UdY3gL-PdLZ)epP|AXDkvhc@60QQ2u7}kC<%J+-8*7u7NJ+wUcA1vBG
z7SEP6p$msmGK2zZy|mDe4c<C@Y;2|sd?Ek0<oiSG{{zX#`<8d){YgHb&yon@e{R?L
zZ|>`u82<`==Nd9jp9Q_2DR9aQ(<_Q_Wifd%CxF&t9=0a}P*C;=%r(~MeO<nC(%g8@
z0cj8-)u{2JXx8j3PAPc%ud@e1>Gey2GYfcZVzq%~;xPJNAfyma{hA@MtD(0;C3K%=
zp9lSMwM>INzD+AbOxcMUV#)?|XDBp!Xt9%Tu)X8@J!E1lK1s2RDMuqFxolB=4j@#e
zn$tJ?R6hEsXyh8W_EbhI6!H1uE2?Fq(#7=YoMh>7qN%Jge5xpKU1X^fwKCsw@5HdR
zjYiNI?!XV~C#F4(nMI9sLN;J)q3-B`O7|2vBrS<K#I;@8tLX)5BUT1voM}Is76OQ@
zJaF=&mU7oZP#yqCI5h{6s5mvr2>z?(WW`P?^S2;NcJ+)$QuF~IxdLuPX_qik=SA_L
zZjs%*oZjBw-J;J}yZw+K%9`78x_55ofUw;-0wg#ZN_`v|_Qz}GrvQiE4szJaK|JE`
z?@zykvQ2?IbZ#<}{HHAi#Fkq>43`Ek><^HX^uWlQK!Z?97St`}e*si-R>7*rfMUy(
z`_RQ4Ik7_ZeYhk0Xyvk2(Io0DQ9~*arP$>XD18qg(qK#OFnXz~dx+z}R&T|f=XGh$
zbMX4r3Rcp}&wT9T)pM?anRK0Q(ZAC9qBYFobX0{$rgPVtDUnvK_o&ixC?vxwy$$nD
z5G{)v;!p<u(hP!Fh$MuqfH9b0GL(uyC`}4=tM+>^YI}0)3gU0yk7{P57`QAX1l0k{
z;|zbp5}WB?8(uKdw?3Gx7F^2Mwa>Q;t7HUeGLh+qA1R}=Jr^(9uI7d>`hAB=cqZzh
z)81FHe4V{~?13F>AM<nSy4jr<%f$!1;5dEP+=cfTPXQ7y7Em(xVD{8PtKdC0)R%1T
znB1Y|Cq6cm8yWj9@@b{mVJ6nYkH$n|&3aapc$IKj0;HDNF(D72gC84$_ZoulG{BZP
zu&YlO-}B7VUHMiEE1f{>n(hLJH5#nVXqjj~px#=<W?6@Ar_euI1$Z<V?#q3@F-&$c
z(zPbN@THe0A2WAg%V`iK%+SitDY0kLN@yk14jmubFlXw&K_QGrk)3^(L8igJ@Dn_1
zb!%yi;gDWn7sa>c80{wqXL9h?hyKV%VNzQzDNZkx&olz_Csw{1g%=KG5{D*92CThy
z?@g3eUj6FS;g5<>xqSbZ*7kocM4<cc)cOBkc>9M^{|Ax{334{I;FD}CpPBxDOSb=^
zRYB=*tqO0StqQ<zE|enxG91^4m1R`e{O}riL_w8$GF4P9fZG`=?3v|nLvO%m?QKE6
z)hXDqgkL@pn?0*N=N{Z<$7WscvQmkYzP#SYxHFzMO4h-?*@<6g2QKNw%Pq%czbM)<
z8vj*=8<0{dbXIHX;@59+#8{@9nT|p-kBtWaBY2S(p^|=g!*I0Ev=s7JPKI@C28Ev6
zdv1!mZwYjH1(i{f+J^8OrL-8OHRSR&<fLkbgSjudU#DE5`OTt{&q6m-jkw}<uN(MD
zG8WL&K06gQ%hsnMg^DUS+G0i@*D1<blVq|F+$qqPLz&IZZg7*o(?-ryF@dhpZgQsl
zu;8icugIU5+`q^}m8pqSfAeaJlh4vlM;jNr57mZOBc#cexRN8;8S$e_^#sK+7jPxA
zM>q%{$6dD$RZYmxBwLn?r5|}enh~EsR6HySQQOx=#Iv7AO1r+>(w)Jh%SZ>jKTLH=
zgg_h|y+vKZe~>8MqHE#3p=IkaTB>Ehl|89jPND-?a;!0}9Ewk)PGX}7Jo1LiIA8Q}
zqk|re5<&cNU$QjjVuPk*0arpuSE7;y0?L!PB(i!^=ghm%8+ufFCG6CTG-@v<!-bG}
zmL9;~x`3#@4IMRpRB49$oNV<Cv`%QGzMIiXas9%$9rgYJh#1J+f;Vd=dT^$1C?-Pn
zb$tW#a=d*xHw9&kd8guPWzr2w)?Jm2V=t?GrTy0W$~1*8Zy22QrEUR)D(*<4ThXnd
z#bTM8YFWQXzv-hGp+at08=}<9hIGgd`eAm$koP4^EsgaP489+!DMIT|D+wf#N&+;5
z$ZA!m`#KoT`m&xpzNVfyb0%zH^Vv4gL>*D{7*_Bj$7X*4>QMpi`|JoX09N#7&Mho`
zEpP0Xvt_zRTWq(2%8vFBw`7vJag8KPylI^TV=%A)7@|IgKhz1c;D<Qwyj60mylPQ<
zA3Yl%S+{~N<CSv<nWK|JI(?v5B|n6?nt)vOMVk+QY-B>pYhvIp6nt@8-5vJ|ESF0w
z*F*P|&OD{l5t`&9GtN1NRJEUc=jJn@PQl*;f2Q}dwg`aVv>&nHhc(|GAk6Z|L>Sb^
zL;!fO;*gFwpnp#pp^Ra8cZ(e-BqehY5s0C;TD4GhU14|mY$q9*m~=8}B>TBaWz_m4
z-Jk}Xhmu0gA+xfkCf`8><tI_F)zV>x%K-hidRLVt&|^FOy*(LkO<V@cL;Lst!MXdt
zWZ)m_{~yS}y=7arlTQXxeg2)_zh&TGwjZ2ptbUeb{VkQ|@JN5_Hzzu&>6YL&n7lCh
z1{4M+Cl3t*E~q74#PS~Zn~mUrVFZL!j4Q{OE1_KraSw&JZH<o;)qS&b6)?JFNH48D
zC41P<4zF9pN^`oJ`gAz)B4yLb<9nMdCzhm_i)Wh;jNkAhH&sh=q%fIm7UT=5JY^r-
z+87muWG`7)1M~mK-8%)z-fijLWvsGo+qP}n_A1-9ZQE6=Y}<CNs#;|mU%lsaN9?_$
z-`*W@uD-s@oRJq98Tp^j7|(d-Z^m5WBbHOIv<OA!HL!B|`b6<fefw%?%r+1;CRjlS
zKO{y~kx7uenO&rrhwJ_5*FC98Zo4S@rV8K!u)iwli=;VFm{Z9pNOXd7u)=m%bufR9
zTu&xxEx?0zbqER?b_dL74FsDwsHO_j<n*@`RZ=op3in<;g-BMRfp+YnQ&nzz?OG3|
zXd9trlCX_SgIjw`S9Z+xRV_<kEu&qwc7>O0WFa|+C`MgOg3O&S&M8{CQAIcDNQW*p
z{le`l8KNUHuk`hEzLr-}$=np@kex+yA|;_)iC*9Lwi)k>+u+!$7=I$EV4~ujUt!(=
zoWL_X+JV{UZ-k5oyaG}IMLdp<OQPl=k#-TN;*D@lOF}mrec;(}0oLg-3RTzz-!^L3
z#ws!fx1A6=36@CWCIptjK)VGl8I&KM{BC(mG{rKd2(--M<}|`-$y7XAl*Cm?>=iy#
zBh&wY$0z!oz|uYM4ZZFP9&19jC3O6-@>Jr8Pz!i2-tKOg-VL5L4Y|W=(gjSf#{y}o
zZmc>*kxC{|Z<j8v7f9Y0{AlNdLvYM`Qm4?ghQqq7$y^%AtX|51(loN^U-<GHT)yxG
zmT=p<4r4uA<}C~P6PUu2aSD@E3a+SVU!JY0R`PP;-t1xHBb9GZEC1U_dmpAI>I{=_
z)Av<28?|hlEB+Hbnp0tyq^6YRluQ>f^f47Nx^NcqU9~{>JlNLyi#VFMuyr=lxuWZY
z)F+KNd)6n+0{~1Rd(?I;=7}<-R;>DoP>kYyr1sakzDCKY`Ysrj8aox%{9H)PK=D3%
z)@r<wpQ_$~QJ>Yq2UuVXRu>|>WF8m%36D(P)mtBxe<6qmu>a=*2x-e*MXv+Uhkx&`
z1rQEhnBEu22nKY_$0^_DS8E<(HI?;A$m`zcSA6Z)t`-0FrBz3)Lr~zGBKTD??586v
z-GzQZcc6xfNl3Ja(DE#4Pm#Mn24bh^#`$qaa_+o_y51OmsJrCSn;dq|%txCqL-_Pe
zr-b3#C&+s43vo=B`)*I{0D1fK%BC7v(xT@@bb}R4VEPiQZAN>99)U~O919}PUiKMD
zNyq>yCqF*9STnhb(t2$72y9l=w!yS{dFk@UBn3LMl)Wh?`9_wS$?M82*QMF#0$c9?
zdolUH_2j@wihGLU_eN^`9c%r!8|mL39r&%PWw$_&>~pN9?xTDBYpS_G=nM=Ze4?ly
z&K{{Wyw1potIO~C3j4Uhxeya;KRR`gmo4|syE`kj_E9m9hOI?)3TWXDfN1-$qAYU?
z$oJ*lG+|#2jZXKp4Q0sFMZQ{ScW#wKYj>Q3hivc&C3P}~Y6@#Md0hNR-;%Y6-Woi<
z2!8=TEZo>R5Zw0;*;ggSdAe3*TXOpsZ`fV{$LO+ZbBhu4N0RxvJ(L0Gl@i5Rj|^ne
z5_-_wbt`?tbaX?7({WpZP!IxE7=IuEjO(nI{}wKhR{0jVDGnPIc{DDRZN)@Mimn@A
z(;<~YUWmkXM|qNxd4TCj<fW6UFKgDDLZi3Uz2r{X^zVbm;k@>f{l}U#=!m|kd)X~N
zZu^}mA=aH#(N{j@phqZZ&*R;m!HMVX{7$qZ*ZIy@r+(I2-P}6T1E5251wEDA&G4Tk
zd+M`_7a)ox4bpW$7nW-I^NXGQV0nB(Rw__w*Hgne1k1?ewMi{C(>?22<d=K9U+tI>
z^UknAUV6KBG)%n^Axi{L6hlPX+y2;O7IH+Qg~YH4dEkLy%&-CA*Ccz?Pz_a~B;)<m
zvh$w1b#1K6UB4v>`PB6X97DUZY<9F(GGj<}R9!~LE>bJl-6mMx0flaA>Y=g})Da&I
z*&qvp`UkPCmc=lyw#p`!%NuZ)PXpb9>ui6+2DpO$xm>s^vlYE$#3!nZb->y>XemTq
zO|B5&cpLX0i8;%eu1IcZKH<<-l};jxUpPkMhy-FE;fZggmME2Q$`!{1a5JE{w&yHX
z;8%L}Rm9-qF3GT%lI{!MrEiIOcn_HT;lqEn+{eHrB>I8{e`2!JX0FMGt*cc}Bi^U^
zb3&g_8JqUCG+{@H*OT=((hqL9s89`NPq&{I*h;>6V*LZ;G6B0^#M~H=dg1N6Cq`5&
z_BOakL0;Ukn7lG5O?bP`x9cBFj$c1aZqXU7b^Ddh&pzUZ)h6sQbmbB%C)S9e`t1`)
zZ+<3}G@2lHOB@ileTLgn0gGdnT_8A(Z5heFvh@VYrol=3uDh^|*Kqtg6<&Wr>H3om
z3BpoU-+bjWT=S>AD?*jawyB~c<hVtr9y21jvo{Q7g9@<rxEGJZ^80W94)pi7-v6-j
z``?<w|JBa;wf&vL0RGNl{M!xdZ-e;ND*p$B`?;-W@ZwmG1VJYvQz^J&Ilo>o_W_W|
zKA3^z*#cQ-@#SqsMqwbN!x9Zwf93V`eA#yA;M_<BQjx~0ox%W12Nb2AKAMzzhVJX$
zb|rH?^{|$lff?^p;MrCW!7a&D%rIT8q9iDt&=~M-NU1}br7wau<DarfuxtS-5{UCb
zh!*8_4o3I*#P&=w=G1YeTmMj9#}sA~pb@tEStA`;vK?5$%mi@IB^RvxZY6G?){4&@
z_3209R!|(D-X(54hu^dbAc)Rvu-awF(83iZP1_o~s9us9r@5*^eY=r>ChHDkB9THU
zLPFDP7cWKCHD87{m9~+*6sRiIJiGl^u4z7~1gHL{Kab69TI6zzb({ItzBT`cb|F}c
z0HrCCfq81%JA9!&TSTH-8g`x7m)9Wk5KmS;@eydgZP7#p+?6m}V3D*bLCfDb1R8}|
zM9bDO$zocu$p6l<DM8z>ciGA@#yq`%ICWe-$BU&_8T)2eHJL40fxFM1AZP>5VIr=P
zVC&bUMS{nkK0P{^^Jmvy9UjMCSi>hfdWgWR{T!T_0zG65MZVH^QeVG;-xkSe3NbP}
zM>RL9T1E>AFU_LAp(9=TY5FH96+Ibm3h8jF0rRh*<vT%U>`?rZ%drZ_{Z1+Oj(Wy}
zDIJzHF8E>E3tjr$gxlQq*iK<sgt(RzI~Au@RVNC!@!5qEbp~%`qQh&KnshleC{k3n
zzJ(Xu13RpWy^E%$H_w|-w27jLs2w#z>q~Ks$F^+@NQrGng3i2^%C_0E0>a^^&y^<r
zktpm<3GgIrz2$PCY*Ts)>{dR~!WZfc5!bGpcbC}?=z=mfj9AmIF=Kix(Wk^YH?Jq8
zo^LNUwf6uknK(3F=rsOtg7}_DWhQy1?z++HQe`~4YyDmyC@&)=q+@Rr_Tec;k)&0c
zYV3pCC%Z&cpaE2hp}>L#?Rq#<mmu4>@vKqr|9SKH-x`Z|c@D87`rbT-zJs#=cJuh#
zTzt0j#CMA8uTwnS>w$j1b{QGc(KD=X^+WD~ku`=h)MF+4(_CJ!x)N;kHBqJ6Qk<M;
z=6J-^x;yNIQI;mvYm6g?2M{9CiYSkNW)@ss#Rh_G(b-<!Z>qj9ag=380uWqe6_q*3
z&M>qz83(N9&rA2~=11YfrkF-L3O)7`Q*vWOm#D+jDulAF?5Zf(kE=#pf+W_EFjNu3
zRy32Ww3scd)L9Hr&w|_+Ck%e2fMlA;2@c=zF$X9WR#9%oQO+^kZvzatEhg{5W)zRI
zkT(>s_rRZ}t@$<Gxa;fiiqm@81Fi_Nso+Ww0;H-4`-J2zU4=04B|aq1VRf+*JT>cP
zh8_FY4dHLvI9dDx4Tk)L>b@v7-bNOEMko@NiO92n{fzXEVxcXtiOVTy^6H3_ny^D_
zaPS4-<yx$?jO@TC%efC=MVZmKZ%4wL#2#`NKFpA2(S21Y#B*M2gZ+RZr++nz@Hr0y
zEJcU|HVp7!;s(i0)#u`Cs=o}UKzNaefG&i6VK2|EwnBNJ@b7bR(^K-fPRFAMTN&$Y
zuswi9fr7%}-I4`#y?FSPESaF5-e1yh@%n}1g)?-6pDxoVkg#d0w?AUcnOW^qSjbo>
z9MDn|Coka3XzM*xTGD5u1bRk!CwQ-g!yGZ|Jpn)8?Xa<^^dk<FkmhNo(l=#=7p(em
z(tKzjlCvAUQlLtoBSKu4j!KrV<88p~t8i%Qzezy-59RxRYfK&Fb(abFyWhb5hd_d@
zos)^<e<EuC;mzNA*T2<t<TmJ$z5i-AvU^`FGnGMzn_x%*g{a;DYYvzZ!VlI;tX>{E
zWDOHsmIfc0Q3#gUj(rYujNT}-^lVRmRJYBW5GkJLx}!VvWmF+oBK!Kjdtn|-L?$|N
zphfS!##j!Z1YqYMGY<tb{FDtd1+6XTwIW8_oxoC20*<v5VHEKdtZpatKbDb@k@A1@
zdPsREosk;mV?A#>>UR=Bt}XNTaaNGLs2FQiPK>Z3Uoge9EdN|d>DBl}xESk0rIaeo
z(mpnYVRhOaumDE+th+J{3NeMMVyZ@ihjP4(cxFX{b}P_)`SuVfXabfQ9G}M`$3WUu
z2uGx&XcgCWpUm{fE3tCDW)^0>2;IfU$~S!Ic^H4$-<n_J=7FD@iWeu0^b*wgUU8zr
z>JlKE+$9JVG#Oi?mtiB{L`?&~F&VzH@?5H`Kc?a#;Rfp7prsoxIA`T1Z8&jtg9ul~
zRN$;NsGnS%+b$I~TdH`9#m>?=8kuSux`kb5$8sUKJ+6gp%hi}wO{S$eUP@g{*Gbo+
zk$xkh6|Ujq&tt7Op%AJA=BLD%vEJArjO4m4{X8AT=Z!SVrX%!Hm9j65?Y@{otqpSj
zPWLY)I&mN}TM#XTFTMSQy~p@H!3N1Kh42(AzM*9Q4Kr4K6FGevHUA-?NKjPZNJg*&
zKthiJ0)HW0Bf-!h*l=t_4&(i}aG?^|bVFt3Vz+>NBeba7lJ-9UX3iZuG1sbLs!7hj
z1EI+eUWjyPbvM&TMrG9;sA?7yyC!U^)WuC<Xx4z4%w?!NgH0t8?%y6U0e^Q3sCY&J
zX;sU#f^I0KD1nh(2+_z=E#yMBAMZBdQF+YtIUUb#cpSFvEoEdTC^*gJy6?!W2(PG%
zHJV|o4;PQ}vu@~dH+#kE`RmK$V^i%u<MsgU<?%DC=H-4|@%x+0>ocnM!kitb=`)hk
z<4|3{(%8QvN`ph1av=sWePvJfui*=H5&>TOk`2(~5{tVKhXp=oOAiRQ$F9wZA*{Wy
zJ?$U<3ydZG#&y5!8%u-q4_KOic#s_F{_k|`AC~@y#xSqQYKO$eH<sp)NRVzZFTZ%J
zMcoTQc!8Z=9vT#GC-vm?WUKW?*STO0dg4utkPH?6NfKW40=DgdiEohX`8pLXW2$(D
zjChfg_CEbFwrms$OJQ>Ot6vR!Vyx;BVWFu&MaSZ3Mg?cx^Ate6L4waA{98R3V<+(E
zz~h23a!!|ry3@-DWQr6Tl)PwkI&krsX*LWEw|;?1=FZ^dzrcBZv*@P~{5>o3?``1!
zU`6iK!r!->n`~iol_?d;MA62%L=#8y(wc`iEXpUT7A+9#^$4Bfj)iBEZlQ9)!r%QI
z#ejti-Iu@4Y-OWhs<9wQh@z8zdl+OUhijnU%M5;5`F*=I>E(I9f%TKzC_@o=RvSAZ
z7(*%@PcsD~FD-0ELzZJvL?a#%a?Q{v81&^wSJC88(!}!QgrH27H^baV4P+8Pp0NNM
z$u?>(3UVSuW)z16sD)kPVyK1sFCQ^sM6VbmiK#-(6(vy>q5K~}s@fnP038`YYAvsb
zL#7`&D8noUP>uzBCC>N5mH^VQ4pJZG_9*zBKf&0)ls{NLI81znHp6Q_Gd`L9Kmegl
zrALfP{{tBLcz?g^{TDD2XSeimY%=@t+BWh@^cxuInvJ_{b@K_~bLw8o)48)>O5`@f
z(c<X_6QR*xD{59(FAE&b_-KIKt?jZ)GkywRW<B$p$VqZ6wMrf6yQHyC!MbHFMSukO
z^lz}DO!Py~JxQT-IE+gW1Mqi)*WXG^Cw(8GnjLRySDj~-!ei1%qIV&%!{9;Ew1}@K
z))vg4K53Z}{>?y4RnD_ng3oD#oc^9Q`b<d5A>P;=6kXQ74M8*mGCQ!j*6Kn8nYuJy
zjRTk${+<?WQorF0FT=*!il8G<bE>araM||+*(kM}GjHvyo$-~&TxleuP7J275zON(
zITr!}QJCN0xhB9vL&q-iSi~g80QpDU!OW|LDRib$YvGHOBxhta(LcU=&(g3nm#Ld}
zvhC`*1R>7LKy;T7KmBMncNc2`-x_!Z*q<8w`B}4*ZU2S6@;tnC;*<x$o!}4>!C_5O
zZE1tR?!nbdZf(yUOrJ*u%GLBMR8#$_G({8v<}fCK70TI!tgv|ou4R~6%Pxhle&H#n
z$y`fdyOkYw2G0@u?&YbxF81y;%yC%k{Q0xnmXeH-b&(I>TM?vcYn`sqG0nU1CO$+v
zt=80}!TiTc-dz<F`_fYEx`1h7>W(Ydu!}3YC!;%t(Hl|ABOYrri*|wPv4ZR|m|3;;
z2dHswZ{U7PG6`X*cDg#sfJ*n>=u%+v^s)==>$IxMjkJH&ZN1ujzrKVfO^?Kkfh$hZ
z{4flaK(g)`b*BzWglYt9$Y`Jm(DqXlL>nQf0<w~s$qU(gq&nEEvC25}e$_85Dm6Fu
zOTlUjFPfz7{ahM~GK)ICU-C-y3rLGo$Xk=`nR^@e-os6VdD*h6Z*m0b(}D@t0EfvN
zG4)fC#z+&UIEN!zkdGB!P8^0ddUKq&aiUapLXr_oTLi?@&V+je(vB2GYirPcdI=9h
zIMf6elueA7MbiKynBx4D(0`#KpF8#?)kdy`6R)Q%CjvzUR;O<B7MayS14FqgW8Kt{
zsMIAC6v|BHS|8aH;C3t4A5h)g+>Mg|M0SvtPczFLDGis)N;cG#gP^j52Ub6nEep%L
zX%})9rjO@CqSunDywF4*MpU#zWd|VA=be$?*_@H8Z7@qT(wRur1Q1cT72;`XJ)G=Z
zdp*6L22*;}eXg%o>|2h)<>E%iGE2AoDg28R>HkfNB(q)k4^pJcHz{)M#Yfomn-pm?
zvynQ?I{!_I^nCm#MRv)Y7yJh)l6@56@S7Bwl|n@O6NKZN6xsSaEEHSdFH)ox$3Br*
z+&3xmMk_`-o@n$hQlwT4Hva!v`->DQ6oda4Dbk9AQSAS|nmPL>MN*%F92_$<CR~^N
zMT)fV`HK`8ke<nC<0m<DR8rSQum8S1B|x^=a{&8X9<t^z^-85n(R=H3{E!@QjJJCC
zDw$uQ;cC_WM^XTm7TK+Y7P;WKU7nxs&i9rHy+SNPzYLcnAm8H<BIGol=zAgNpB6?D
zpqGfme2(P3k@8d7VuMd_wmx!Sx4cIj&1$#?QlE0qDY36ibVRP6fODR2Kd&f!hYm+K
zUMm6;;#cleMDTHa@$mEpN4B5}-$oIlE{VkG+hei&PI!NU{NsW^jJ^{d$F0>rks^KG
z{zYs*b56!2Kmh;@umAv1{xOR3AB@PqEn6=%wB)eFkbP!q)i1ctht4Vu2}6_06c_T+
zKK%^1hbu2-8Uy`RlQ+o&5)|=a5Ga&oGMeHl5EP`61M>HKnjSIve$yG#c06*XAvbdi
z_xW6JPG@l(Pd-hZPil8FT4^bw80<J@cUHkvHUwdxq)3}l()ltnuqMUVMrpU7|MsdR
zR?rxk@$b|o7@VMpfTJ1(`>Z=72yIE$u?7~5bd#hopcispO)03fl&tsvGiu=LmGWuZ
zW-aJ66}-UuGfX}p9u%T^p*AfC&*E;nU}|8r)Y9$Bhji_0iFjQ-JPBZmJ%5;$z{R^&
zIwapJ6tiGe9wq}bV^3`}9jlk@n;I*m*=g9RXfK_q5;JSzCsH}6xRconQJ<yM71LF~
z7UO<5vgAOWPEs=f$T~jJfXEtT7;!SlG>)}ZT0lKIl~O;YXxYe|nMy%>wA#~uI!hg&
zR~EFTsou6GhN{YYLR2jb{EY!mSL^@9dr8a%i$nLd?(<xxp!Xx^YjvH|d?}Wbw!sH6
zz3X(k0l<mdq+Bh2G)t^QD1c1bkbvVhx0&ij;p3BF)``W$m}!%P$b@)N*pAtWCUaSN
z3EuXUlE$nV*Gyn~fVVA1Tgx!LGYWy2u@ZbK){9V>2*EZ9FJsV)a*AP0BIC9Vm}7!W
zgwc#3r&bfwu{&rSNx$J)LwEXQtf=DWMT*ir{=_pbcBpU#P-J^ygPysbSiobC$ddH!
zpMrhD;?wqV@<?pl2}VEW95!umel}=O_F}--Qs!qzmmO3RMv*kKPNbK#72GeVfxhFY
zsH`CHGZ8nv{Jw+yXu%5MI!~<UdkC*7zE;hdZrjDH53Hl4#=r=X6o1JDB}kfh$%o)%
zQvKwTi_<SbluT=jkmwXxvqjcFj6@pN@eCdU2<rmP!l*JvOmx1y8PaFLPK;bhl*G*h
zLP|_R!2uO;I#^U?piAgjQ<!Q!dF?jsq(`Ro*WB&fGP9q|l18X$KM+<md}cbG)&U-^
zX);Jr<qha@@Fm;E><HqFy-%Kzmn=g-a|fZ=b<?8I{D7%wkEFt=Pn6S0FVirF)y;XM
z(|a=txTsU!l$Z~3j5G;RmS1X2Qii1`_CdK>I4lhiI9PaPcnq&Nxwzgrz!gciR}mgB
zTXVUsZ8j|~slg_8K6N%Y#bPkmsE^BXWXu@b*Ha7H^UPV}B^5=X**#>jSrRO0u;vtz
z)1rj<rqDmeN#n<Bgd*V8%NnaCyu><!B^TnZ<u=Im$s{TU>oMmSJ>V=b13FwY&woqf
zDe7j;YBT$C$;0E%>f+df>|8WiVF6)&Ep}U9+OWj92;VI2&EHI4jcmv@J6QrGMnWNF
z_ZPLj2-(jDOI$ze8eLsNrWJwHbIAFwr9^V#0z<?LC1}?$Mz4-#uE3c%1=_~-Yx1{0
ztQDc=s8w5ZXjK;@iW2_NW*+Q_>;@6p83WdZcEZSj>-P2WdU^!#Mstm4<fOO2!DdzK
zv0Pr!w3;!bAA_A`xOUyWdUG$cxTpf}fJ5JC&1F4y4IKJ-?Ek@YP)E0(jAl5YFP2m6
z;rS7}J2x{zm(#T3deR`!(PY*7M-pMNCG$<J@A4>Emvr9%M%NaMs&XpWqmUPmkHpDv
ztNpH_t$mYIor71?9J_|icb%Lc%K-EE@yP3-_N{N-r{gj0YC2LG+{Vtv7m50F{{5ma
zy(S>(GBb4E8_XZI8?ZA|#kOo}M@rNkrDGC)g^K~90vULOZ7rJr-pgrO3uY!;VAWCP
z^LD|z^+wWtO_W3fsQ9$Zq+f0TiZr+<En3?H=AZpdxe=wp>i=MJ;{Wr0{12hPf7kHz
z{dEJ7@YTnEayY*mo&d6PJotGVOzXtBBEzr$<Zy1&JKv>~-44S?H)2z20tr-V+f^N1
zpWB8qF&C8Kv5zIuI56`jWYxzHq$Tvwqb`LtMlHHGy)gZvpGca?OHVx|VQDbZ$WdQq
z<Uda<y5I<Esr7TJ9PwSXMgN9xDosSOew67uF!F5wK21rgXEc|_Cf_>cQW9|lrB`U&
z(pK>Lmti(x*~Zo6x1ULm`CrS?-?u#)8@5;?=-pRJRgc?ifh%H5<(tTA;z6R$Zhm9u
z>$(h{vy+1k{K?wN-)A2Azb{*&2nrC75Br`WAY%*cfbLh_p-vjCXe7#5&S@(Tc3)?G
zzC3;PymYT^twpAK;3~GmlG^UBC>zPDp^Sw3U%Xyqyw3e3Qd6ay())$33fX{SdX`98
zR*oY%P*H-g>cGu^6fk?UrcTw1n^zUSkrCa8dACO}wfInQ1h}Gh@Zy&7B2f8T@K_Q+
zjc25E9?}Iq?|XXbAe7(+ReFPJ7)sA(=%OmV?F$nQ<AO-mTNl%Iqa6l}*mQyo-MK0h
z0CT5*;(%U+R7C?Mh_h)7iSZ|<Sa!>mXPaXt1&}p<N(zzIXk?G2#}g%V${sRu53WN>
z-N9yW06a%YNreVCY>JsfLb=IT#*R!y{-U{VL<+TWzOp<D?d)Cez*{z!Qr@M%P<OR0
z#Q=)y%0%62476!c#9fu~SCrF_VB-9_4?S2syGyuBTx-6_mdAp=GlvMT96`_2KwNPB
zEDE}T7{L`GRvg97bH&3liBB(WDZON4A^kLuxr!u_pQ>}?XD<@W(uInQPFo2U8Jt#X
zQQ^h{EQ3M1&OmZ|$r%wi;wsy4?RfB%GDt`W$l*f!9BXHrKZBDEFZfXq){D+Y5guq6
z-ELbJG{LB*<SZ@MsF9s?+{ApCf;t5Se}R<GgN79s-sxfQtOiW=Om9|&{Wd&mFush*
zVnBHTnn3k~o*C)|rw_{qAcN-r*$<%c#3<H8jEs>pDZ8ws5xP$oB2<Nu%_j@T8yV3y
zFGQXvgTI8ho-NvKDA>JMS$%R$_XrNRGst1%q3B@DQ4Zah#&$boNLmdoQHhAPvJ;`=
zRiDh_)2!H8kTcPO0eT}doIxyt4Sts(+!V2u@%l$F-*{OnSh7Z)4xM9ScB0Kghs{w9
z)48igD>^vB`33CmqMoO|JwyP#;lnn4%8Z-^-h2ca+pb5+E*sYmsTFk~4yz10O$VPs
zWV94QT;S?0s9uxK@!F!@e<3>A3HZ4VNxwe0Oi}hh1(SIb-RRE?u?f(ksjGUGsTA`v
zj+$mS`cphWo6CTRIJ3Q{37|oER*r57WTUH2w$VqHKe?2Vf{zc~s}b4yyT!fXLG9-<
zhU7wpauD;BWVtr$gS1J8VtTSyeQywb;t__#0%cN^WP#|~E-SAm;X#E}o3aHcuZ^Hz
z*3FhQ0$ambOxKTcw*naet{NE{nK||B6W_Aww9W8OMa8kWT@GR6rn{f_?_!0<lpH4P
zZuFfW=5C%w&lf}_ACcXg`l8@+tzxdcSY6Ld9zU&qafIbOn8BA2P%}cnb#HT=^Top%
zFhT5q?75dl=^iD$d>S|%uLRb*6n1GLC1E7~z78FkW8*s7`N(WY;qzL@v)Rfjr>pJ`
z@VkB53skcP=5lLu#Y|d;?$zi%7Qr{VbS&=N&W``ozDyX230_4KZ|ds$(&F>*vHNwW
z<K(M$p7b-2dH4y_aX1x2Ptglwb8278XA;e-A`#}|1VWFCb14*pF5p^IZE!dI;0tta
zNN@gky~ubF$51aBt?z<NcZl>`3oe)yEG)2^*C_idG{QQ|lB2Z>po=SD+x5Zot}qgw
z-x1yWzZgOPGe!7!k)HqGDgv!7GndM@4_1i%Un|1j#&|9?Z0r_Pkw2$v>)tIgm93Af
zC4?gcHRg&KDAzv#Rva*`d=f88E=nZw>sXVLQUI;gR4Wu!;pr&C%3&lVzMvYj50QKg
zj<>BkBr+Q!ZUCbXg}l74I7W`SpSX|LpK>_3ibs`onWZI^l$c#JiYXLOnxcwgN>8rD
zLSOgq*Zh^t?u#hQ$m3L|h;s`ZQ;NwjhLL|3^k<f`=qMXdS7Q9I>#Js%Hiq^=v?gan
zGF(G1yiSnxd>xj!Z?;xN9K6e*&kw5*i9#=!)Y>ggPjp&nEy*3suni+k>s#N_R^(kI
zL7#jPb))?`7)1yfVrr>z)|5w)1B!=L*IS>1Wh$H5IhvVb9>veE?KxskTP^wH6x+`N
zUi1*UJ>#{EAfl}Jhz|WVjMsX1@9K5{jKri4CRuF|S%zubk8Bv8WK$ouJoZh7mm`@4
z*$Fhayc`+Eogw-YW06c&BZ;3gI8c|swLG#a?yWtN`GC*Q!jn8Af_;S~%e)`1%>B;7
z%4Dl1Wz!5Rx>~ca9WN;Cp4{p*i!~Skf>1<_M@(aZvkWSQfl{ME{OzXDq2#07)D_|v
zJXR#}KKn0mYDCk4Z1bRB!h9nQ2#BU(!EYcd2-LZYFbnPYmOp|qDc0dZBSk;FKD8DI
z3%Vg(#_zQS8BD(K>p<7O*}RchYZ9%p&=|bvoXp>4GIUA8!+K#584;QzpD;XY;4FYD
zGdS(9(^qiU4Y60hzk7!w=Ko?$!x&fq-9P+s1RDhysT^gJf(9@XnK2HP0S@Xr>8Fp&
zq%TXQBZj_%vX2`c)3i~re3J_fp2K9dYwm$h19gT7#Tl|3nsl>p$uov#^l|9u(ux^t
zx4NYDmEt%#miU7pG9dzLs9&2M^(;dbTcXkj-Rw(AHGiyxbZ+6b3qysNoGB?PLb`~F
zf}5{5;%Y94p!g&gtnee>$(MN!O-ih-8)9VmZQg=)(bb21s$^|+R-f?arCD7yzl^jj
zW@n917Z#{DzlHeGNEbBp_*J-6X+IQ>6x2vOkR)~p__NyittW)=*iIR#F$<R1uGR&c
z=-ZU~8%*sFj;UUfAW|nuIra6pLj!4Qyb)<#+)$L|ybh(s0~|w5_M?aN3~G}QVvS+8
z;pf#nYxu*}M~hSVx5YJ#>tmw01TG&D^D13O+ZwhM(`-GdsSggf!;SuBu_9~Y_}(NK
zlGlS9_>JUxg8o%uc2v-Sd-At<a;)%2N66gbL$I;3>ynVwv}9_^%JSu~-U-9HaRoR3
z4r)_U5U8F%uYNecsTXqEajkxT5m<E{^13W>OXkxieL%<WZ(k&Do&_I8Ziq1i5*(-E
zlzQ#xthG=D4;KcTepp&H!>S|hEeE0;`@o4q8$$rTc($pildQ%O3&Af(`lUC1HL0k(
zo=(W#h#b7&xE4YPRj13mInU8lu|TO|$)#iu$sEUyOz%f1y-w+D3$$x7J!W=XPNW|d
z$`l0OqC+(up?dZfJ`X^Qg0E!!Ztv(eR=eVe+?cjqqnKWQ!@5kqaP<^9eibyT1sMG5
zupiQBmsr1gtO+zcSckp;b$17{1)v$^?SLxZN~O|qJ6pqTq2nE8y}aUwOHVMZ-3-nb
z!508ET6iQX_DJ-Os>_nY6WBhdAV&`fltz#l4lRHN*|}X$<%;RLytR*rc}l%^`I<X*
z0q#<LG--FgD|RCW{0x^L{CZWpp6uZ|T3HNmd$dXQ^fDj>g3mHSk-B-&!BeF0UM~cS
z>t}7FoPAoL(}rN&qVvr{%s(ERv&30^dn|{LL?VEmbCz6MzSXP#%~(}y-d<Ne<ALaL
z<3mb(rg-as;0VRi(PFXUQjWYNE7<A+rJEI}p1-`Q155+|>poc0TcnGorb6#geIfE`
z;6MZm&=8)14x+$Pq+Z)rP<RCRR}UR-M6VgwO-d{5E0V(WhH@%dQlKp@YD|##?z@;*
zg5KPQa|h#2hL-tcr_1Hio;N_XqRrLviBO%kT?*T5Ci9C=pB2`NwZnF&lPw(x9+z0T
z3~ziGs5($~DAeV8l+qUGoGGTGz2zV_HZf#_L;MQeZwHVcybhRyI_6)Y=V8s^ehPtV
zGLSX}&*1iCTM+Zj5_7XGkh$47SzdqAk*mWnGWMBX1T+wRt{)H4y^h%JPyb~U{y&rE
ze-~c+|E)CZc^4QQe|v|4X#ce||7~FHLS4%a>DxQJs!h8T0!19VTtBmNh=XJiq$KIz
zD=(Ngb+xf$^qe~%l+{%E5exz3pE3_XBL5=*qFE&mQAP$a<7?hy<wogCaAxw7Q`X3Q
z@m9Y1G4R-BI^D6GW9NJlo0rkZK$$JfjMGIRE|dfiqvhzNM27~#Y*<Q2V{dd+D|D+f
z)ET6qB~=YdFj|p~E+R*jiFygkMSCEmK0=5(SujyqB)bfz&cJ|yK*C~9QAR85e$3}S
zTXJYI$|#1_27?tQ8XmY3`TgFq<ZNhp^F!S+e9s@FW^0Dz?5Z6kuz59%lFD;Zy+jmy
zrhL|5s-6&vfmL51g^;Z?V}ZTgV-ep3Lj3Xqy%NP{!7!Vs4q6lAtm=N#!4SR5bR`z4
z^*jcF_g%m{3Sa4%)q08XM*zMkaC{m%<xRvh*@LCF${iDmVLhUkC=)2)tzpVXWYtVs
zzBm+DbGB}^OGRvzs%LF%6S^G!qx5*ekL)ufSxyY_Chv>4>5I4OhoRk2@QdW=$5&N0
z;gZmkNd>bIz}e`eWLuay4YWlT$zhoY7=oDG=*X@{j}L-4Bt^|J6L)(_O$o`dEpy^S
zZP65B5@;p@0WPwuAF5LwgM}k7BZ5_m@L~B1{tuN8Pdu0r!-Sg@bU(v~ie?zcAjx0W
z%iYiC7_*1KYFFwf16HEPe{m{&{=zp#Do-MII9sLdz^rtuVJ%TmR$~Yvs@FTzQv<q}
z3rvUX*2c$8(YGBzuNys5S5=0&=Kix<aU?8XR*OE{sRr%VsJer|;6ma=7e!n3Bz$q(
z0|DD@>SS!^K~FR8ECfXx${L~^wQ%V?RysI#{M9+{^Ru|w=cD$g?53|GgRzF<Sh$m-
zY{`Q6f+Xw$CGf#K-#BH<YFVG@gfNw5dfgQMBrArAtD>-vU-D|9g&}H?oTyT|Fhk-v
zOmQTIyLf!@xqLl2Nk~j`grb6?WFg1zlT!VS03L=N{ED-FA2!%mKSjvOC34`7jjQff
zS*ax#Z%t#4O@5(JgMeR$v^^pG5V>_cqm~pCy`^0+^BZX=Hf1fUju1P7L2<G}7N<#*
z5C^ljm1*VslwJnmv$+KbSLh1~f68VY>&jE5quc|P$wV0-;}bnnEmBu|va@wQI{_6-
z3>95)w{7Wa$9tx$I|WoJ+px_{2vf&Qkree5Nd*;;68<3D>-Ubc4N8(E$2&4041gup
z@6iuKs4-Afu(Q%wQL?t<F%I?^l)`vx7QWMC0k@>47}~jr4i0t=25}&L0UC;q;V94<
zO5p8(!1b+qN?sr1x!Upo#(@FUKW|{^y;ZtuPPM7tbxhBv^mNZ#)@)pGp#>D1T|`4s
z67<;7ULv+XO+DVd_02oNrv=oj-bo&B3z0fFcuRs6eZ1V|L7=9MM+O5<QhzQ_R9>W3
z>Nvrsh0Y!d@Xy@$XlLEG9&y3325iV_O;vuPMFQYNJ<}~~PSwIw_l6#6_}(?{&daFg
zeqR@X4Q*pb^Om~2p1Kmy=9nEB*|!x;p`HzRF>o+4fko=k;YS*%W#wlA!N%{ce+$nD
zXIsk~Kn&iwF);;yb=eQSd$6{ib$9F=l++O52^a7d+nUP@f*fea_AxaB$Pt7f;Eqha
zd0oqEBoQ7OI<|H(boY6Cr+UYT)YY-e*M7j)vE4`noo8}0ae^bgLxca;+UBULoLU^K
z2<)W(t{5c#>kLp>sS|kYkFhF896-tV53jMnOgdOt0HYglKAkn6_QkdvDf<fs`JZUy
zH+p6A10_5x5i&ME;<-E2<B>Qwt)#IGnID)yfPypaoJv9}e<r7hKi7qo9q3!OS7|cw
zoW^PRc$cNC&}&vJ*e3VjW3=eDJY+MuGqd3stU$qCqD6}uq04bCS-8}qFI&%%OoOme
zJ4lb2GQG7^M{v~^>`x1ohm1)q@u(c%X}pU#C%M*7$hqO1BLEf(H}fQlVDZskJ)s_Q
z!UX<`8QTeQ)pgN<*kE+(m9G`^8=c!I1gGtO_?H8JG6hvMN8iro`gg43@14#6KCD?C
z-zN#o@O|mMcSKyrm@R@%(VDI@IeFM3c-WXVEAv<o@mY(V9r7UU{chjE<on$ec;gyw
z7ZF}u!w|mt1g0cD`64U2z|Lc=8qU^Z<rEdWh9z+<tEr-^AgU8J$+knz5`?a42!dcX
zbXq5Mvvi19IqW=u9@`X*+%fbzU7B$zs0`PZVgsMZGZa>6ALTDG7I%o>{g64?OV`A5
z?8y<yWBdq7^>?3yiwzzDw-cskU(8rk6dYKvJ-T|U+HH5-Ol<k-X@WD#y9|3Bz%zO^
z9hZ+}Us3H9+}Kb>_&wP#`ywBwNdN2zlN!78F@86|2sr<>%KmM#^Ls+~e^mBZt?Cib
zf8F>yKiJGZS_C6VDHAlHBvL$ex!ytlt+K0ssVuUfAF?o@00FbMaD-+Czleq5{85j5
zEuGv46c1B}6_>vG`Vk<?TOU^{liBpkk(c9EtM9s?w#Z1%pH&WBOjLK-RuwU(3&j{d
zP7c<jqo>&O^<z_>A_sgcPYse0te{^S0@unyt;lw(4$fGo5wI=DKpNVJ%vH()p}|3E
z<fPxZUmITQ*w%$@3RD@DuUUnO6x&38$mMv!UfCIX9lH4=Td~YYXSl_><qzqG&uR&I
z3t>rQ2_KPYlZw@wEJ6%b9I8cl17J*I2Ic{#tW$#_B2HRAAw|2sp!imqNYt2K`ZCa>
zx!Pk{L!DBJj-T)ypsqlTr*f1?X-q671FF<KBX@%82oaD1L@DsPmbwuMk}mCGG_RnU
zZGW)g92kVYKs8I`kYr(gEZLS@Mm@!=M9030Ln(j@%9Sow_Wm`cQ;HX=j^t~xqh7Lt
ziWYOtoS4aMo{EWV!VxQhV_!h_iz&T7!^BQ^$ZwOpE|Q3w7W-WA$Zu7v<pWWamL5-M
zc9fMJcVOs7iB3zBkSHJrw;dK9H7lZ-rqn?5Jj}aP$Cf#CtEvnt{Vn<1C>Eq39)f8c
zN~VC<f=T)3k8bPpB<fpn|4IDpVk+^1X)6y0#dJ!qoP&jWVL{|{7h^Q-WKwRmY<WmE
z1^8b?^MB3hfY$K<S(L1Q@pC^1wAV1|$4}K!Q&R4_uhye1LFUWrD&>3BmS3Azb+ZT>
zOX}<H>cm~%tef}}U|Ua)j#lmoXdx`K&h9dr6Nv|tpKl|3{ULvT*GtWWqg%8}{h~bz
zx&TKJNdZenmKrX0V_ajaD#EW)l&AYFEh`9|Qn9crw-=^CD#3uAlMvm;M9#;_BWWm$
zn!^4XGABftC`C-qH|8aP8B0jR9X}pgoeec|XP_H5D#Uo{P0iZ~;9$@iia6`{VuQQ@
zEM_Q5>W4U&?%BxUq!HO_XcAYX_Xh(L0-sAwe+L6{IElLuP>!_t!TV=wcY9LVPPATS
zpwIfp9x&(ci9rk|p(x;~TBDKx$+~{SZaxvAZH1DdM1%BWd?hR<1Vaq%3``Mre%W)J
z5*kB0uJ1wJ8la*np<>I`mie}3cvsqYgQz;54sB#YohVsqWT>Y&45VnfKL+xb%HkLn
zXNgOshlL4*jIY*V6b4ac1W|FaQk4Ce=Yql*S*{~$S5<}Fm=yKvl9bA4;}kM1&@~jy
zt^WdK7}$j^M{6j8yV(|?e-GAtdtG=u&(iBStgV6L&;Ml0^*yWItg4+_Uhy&4+qk!y
zcxcYp>U3{+xNx|8u>d{bV?%xatrUHQDr3t=h-W`y(f8W;x~@|8zQ{d%K`THZgU1J^
za-sBec6R4E`4oHgfX8RCsg48C4QlVV&UaT-?>23@*}b9eF{{}HUdD21{fw0g-~sE9
zHt{psQSH4JPf336nx1!A^Lf1Ip{d&?2MBu)16uLzycn=<(KkHUET-`*jmIL`LgJm8
zfj{(>E+kAiD|&YfdiVRwqvG{x{>kN7)6{^Hjq7b%9-pbcx{@kqH^I@8_?_3Jn|X(Z
z7a-relZuKOSN_Ec&ZI}*>T;y0?|QJ$_WAw*cnE!~N86-Y+g$s;{p%UPw38-J*jE4;
zIQ=nP!MK8qJ*)T_z)L*P=9fiaY>5kUV4=M{RI8tT164c&_GX~NpaVREP6o4dEW2CC
zg$qn0h@=#lf#zCpsI3*K)|oBAK=&BL7K~>dPK|2iK-qcHxDyt4)p|f=Hbs$Ezp!AE
z($#$$>^si$TkLx=nN-(7eL+RL45IWj`Psc>dNN$G5n~oGuocQY%?xqTH6dzpwQYS;
z)Wi+Mud>M2pQjy;ZSJ2Mb(Hp34xi^CJxzx*GcT<>7tIFnW?Wv&Cv6C!HsV%y)Lmg(
zZ{e3_sAgIdWS&H^wpy%em})B{Pn~H!7FWfkh%H?hJ46>-%S+j_-i3(mGpdyRp(w7M
z{nibuZ_DIV1!@X?zqMl_$cG{>(w!J$bKY7!$$oRH;B>@{>7KS<S<_aXrquMI3RDK2
zbs=|yxa;rN^Z@*`@Z?D&Ss(vf!T#^F-PQ3ke+hQze+YKDZ=9)Ty`X?V5ih^AX=A<w
zDX~VYw`U=~OFlRpuGtaWju-ve)Ew6>AcYomKuc9VNPwVCAi}-Pmz%Q~+m_+S57`vV
zvB2o`#q2mx9LeyfEHf6r)O3R&c`_bSIw_jOJ%x%u=H65p$AJZoKo=&`H4A|S+18|U
zIfT#t;qKNSxbo4sf^GHzW@aqhV@NT@h9->iASUOXd{E6*IeG65Yqxw;A(E2QAp^B5
zXsl|N%rcYF=AtFDOek*B&zHS-sb{9nZ;8I5Iw~zAKop~PX1tyXt<NC;{KH+$NK(ar
zD|RsMf34VmODzA-OwHAIrbY;Fy<gX>&&B9FRzv<BtKrWnP}W?w@*LV`=31StNI)VX
zCl2BllDy<66kmiFqRRLw^-Ndoy2AZHcRzVvL)RyvAXQw(BABz0&UEbM*xhzfe_+%;
zjErJjSrTs=Y@1_(EX3Ma5ii$x9QxXUcz&}T8>2y?HNl8)wMs!Tg-YL|h;23jDw29`
zyPybdK9Me-N{_6NGeKAm!s!%^<jy<&C&98#z}G45)0DP!d|W~acL@dfO){=P0{y%R
zs>0-(4nAPs7-txWx!#d2@w&qTi3ydDC=rG$Us%b=Xu}lRVWI@b9JJ~O<_|Yn2W9#v
z%Gd}LCO}BgafqM5sEo7xJlG-*yqQ|U#tMSs#~8+t(kNyV7`)AA1-l<Qi<C2ZLQRoI
z3KS*~!}OIf)27zeoq?)k^zS%X#kzD1sYZCTgTquJ=W%pX;~quZ#qr=q8{^;oXf{P{
z_5d{&^83kl+E}h0r?5*UdgnVjWwvr{l~UW|F|A!{uJQLq*Q=0@Q2_E!NkyvueFvyc
zsSKEk^(A%rUq#tgxJ$Nh{`j{y=8OW_k;8=uyz>zu<iwsJIkB&{5!^|Mf{~4i<ASWb
z#c7;Ej25UAjHVJ@%J1{T-R9(i(G9?fVRCB@gdETm*<2LGYi{tdRzIfDSp3;@RelQ1
zU+=PgUwk=i$Sv1wHJnG17-cgC%xD^s0CstONLN=&3-~ePpJBkMgMV3?SCbE|ZY)pj
zm;mjT!vG_}3QS()$~^kWg?aAKWdntlv7dSDd3>DN*>WNW0G`dX=}FHm{vGLk#iagW
z13`fnvh@}q2OT)`;ymQ(Q`pY)rp7RW!&?T?KwJjGfQvwQ<F-+U_+EGF@A8Q!f|71s
zA}o3aX{xMdkZ!=-Fe<DSNLUBl6oeX0$TH=#fp&(##8Ypq#*Kv3UI3JPGH&cve`f3(
zGIKrm*=>A3=$fY$%EF)`m|)W9!3OdHSnMM+4vwI%=L6T}begc)&<qjK<M#?S0AL^~
z;{)f9e$iwgq<jYn#A{2Nchqn1D8P6a5PpK#|LQazW!R_(L;uLq6Pccn5{iRbe?ftH
z9Yarp2zP3&q}2FPQ8EWK4)<g+Di&jxQ-WF#m!0kWi490WL_qPByZL~tOxTmG7892|
zXPnTWDE&x`NVt=dR3JBQOpFT*>!j{3TopC!5o9bb+{14S%^ro&|66(TP#PF+JfUQf
zjWOiX;5g~LEb5N|E66!MP2154bXYkH64Eg87w{l-09T%FZvyM!8(zSkw9VCwopDI0
zN@?eYf6(*Q#ik?WQ)TAw)1%lo*T<}j<kO>;y{(@8ZH*_F8gYn^dak7atfqKet;Ff^
z?+-=8Mlm<2(ssn+0coN&UD`U$rMI6>b^<_Tr{0MG?JifI9%;{YbsSaK#IT>W=GlJT
zE}SkmuW$44Z>NG714pGZD;e_|h;r`Y=F#vUq-KX#UK+1?v;PTP36r%mnriDl@#0$&
zh<(1QnG$f)h37RAe#L8BMKl8%Oz-s?4~vVCu>hGTZ;BKI7v1Nhj-Ou2#ou&#noH=Y
z)7J6?B6dM@&EC?gGiJmLOhZ19-FC69Sy=&WP<46CYRyMZi)DFt&tUMO)0+?UiV7n5
za;^%LXA&fiTZ|OQ2bS}ec>67Cb20sS!FGAi7*_+DbUkt<KdWq1B&YNn0jziw6ft|c
z|3ikQSB%9I*T2wy0PYf&I`Hln-V0nAG^-3uCF&TeGFGN}mTuw?OWdR*s5HxBI+KWa
z9Oj1T4l#PxOOh3GtV@Mr#d0kymb=2k&qW%ntl&ulnYlK9^{B7Z6}6wiN~evKV-1G8
z=*d)3l!q57%dRAY<l4X9G2-nDc`=Xz(By2C?UbQz#F-Jn#MlSHktuP|V^bW!chtrN
ztejCSJI&a#$Bpbfa9RdVk7UeDe`HuDA2*M;ybYk9#}xS-m$$l&dDrb#%_J1sxtBhg
zqDE{_1D#h2?>>NF$83F{01G6sWSekqp1!rRGc9;Lw+JP}$?-bjF27XSY^z=$PGD2X
zXI8(ZyyJ!0mA;^z_E^z-VY4Fd_n*~Jx37_5k3Et&8)#r+($Ug%p}laYJKij|3iY7<
zjkyEbHe4#GA!J5;W*xs?ykHmM-4wz7^#WHQLzssw5mKGtP5(aVvFge{K}|8rsPgLE
zbYrs+0HdJRP}gA^*{4bYqPJsBe^bc!FX5a?+^4C3-@*U)%=~}p;PVORt?8QO%kUNP
z@JSojW{Hs!sy4d26yQ5%1HogN?q=BVCOsS<W4!psQ3La6tjPWI<Tvy|ytytfaZgIL
zs`UEC6p7sH7!uo&8uElFZsPB%z^)mYqTo-9Mh;ENO&GZ)ofE*G8!Rr}+f8R}hlxFD
z%-7FS5)MfE^;TD(RQphuP6(2)$lP312LyEOsZppB{Rzp9Rz5V!Odddfw@#&eS+FWA
z{$$Pa>FTa)`&nvXXe-Rb7@SkyYt-)wp3_sMD)WEqft+bj#kiemug3!08_0jI2MBBj
zn5Dk!0p`D{2mY3@f1zRZJ;Fx+9$~ZJfrDsiZG=1GP>hd9kVY%aT_T+luQ(vOcK=zG
zSeHp0w~-g8h|&^kOBPVGiA#wVkm$J4Ygv`xy`Vei8F9&&N3N(&oK2C8p83sFyYs{`
z;~3-ZwYwWsQcw^@Gc>CNy)(ifzDz<?c+!S^_h(e!E{kKe=h!d3X%QMoYfCbMg4Axq
zG{J<1g3hX7$t<k_)>{MEssKhM%ZN#x+8<8FL<k$rghgQv!<Tz|%#A2hh4>|o0EJnj
zm4{4SRRn9l={CXwbbB(}jj7(+AB(eHNql_=29op6A1NNK<<}fCBvwj%^Bb|y9S_K=
zA9&8)K;5nApD^<^M%<8~=f{wIFHJS(`Bk_De3(j%pUsm9)DuNTXmCc3tJwWbZ;AWx
zqLLx6vm!FG4A5t;&!$yuVW_KWA;$p)X<4I&(b@#2%<+bPXo-iZBsRA}(Zsb1>*mR~
zVqB||FK}GyjeRhyEtv^box7YxNRc3rEVQ4iSshxHDO+Mt4@1o!4<=M1jIe7+c<4wV
zeySyhmPheC7X9{P!$c9)<I-__f6O+nES*FA;2abP5K6}&6$mDS*$NT%kr;9gK<K96
z!5=_+C^Q%>3@3Q0u`mgPkpoS}OvO9Y-&Y%W7J7rgOkN1$vltTxe?r$dT@Dsmt_?gE
zQ7-&c_$_gZ!NEls1LGTSxSuZ`bWrB1g2zgtSSM{E-k_kMOn?*f{&Leyt^dwo&m>w3
zHQ7b=Yr`Ila-JeZLjj087QLMugBN+96(^xtCX}Vz`P?8-zVo{Cyz{5lGU><7UY?`r
zlU*@5hRH&G4tSy<7XLU{lPAtg0pLs4apXfWRP*U?Hiwukj&g{GAZ0Id%%g!hb1}^u
z+-k$wnGYh>_%TtEpRH+pg&9B-(28S(MAoFic;If3gp~RuLtY&4;lcCu;stCOG1px{
zGee#W7PO0==JZp=90vCI1YXxD&&&EU(kXT38Fkyyy>9##@+gkHz*-YmF{!dLNvt+B
z+*dT;YHA<2D=Fj??HBhNZwpx2#tyh+Tf6%>uI?$aSlsFV2eIGnrzD!Sk^BwABez|t
zw8B&$Y-IX0;)AnT5^Bt=O-epxx`2p^1?cfGnDRNnNVD7mX=AHSHqFO*0J)JrdFIpc
z=^e`6Q~8jNa&ervyh;dSy&LzSGqTAjk_jPpv>#Y|#U_c$k9hQ4h@caduxMB~BVl`u
zAyEyX)=(0KWGyU=0?$<j4y8EjS9&af7L^ohE-r6_ii`dr&yY{x{`;{DsTnm1@V#%h
z+<tuND7tidG0M{hGzTS%sr1yUv|~2z{mg2IGdZ()seJtuZpw--`_#~;xnjjG2doT$
z7~z0#WukcrYHH&t{Lk7c6?p&&#+P9`6q(8TzQofs4gbY2#?xt<#QtaUzOaIC^K;sV
zZ%D|5FK?auMdxCu&07)<bLXmx8_>}Xvz_|_<h)i5`Cj%%bO&1wpbM|%PSR8K6TXRW
z;Vpo<6vF>k-I>Qjwe|s=ibQ0eqSTZnOk-clQr2r5W0z#R4B5v%c1b8(mP=z9DdCE`
zMpq>g>Y_rDWEZ96+M`AC9^<{&IWuQIz5l*vK4y%M=R4nXp7WgN%sJ2V`{nzge`B2E
zkH~r;m-3ir=9^c&|FtAnw)U5TT@{_Td=g3)M_mz^{g{xi5+8mL%C_%NV*zFyGh~K)
z=Dx4>m`UD^3hW??F{Don+v8`|y-*`!mxgRZUb&qO)6>~4lCBc@m}rCaEbH%0_(kxY
zdB^we{*R%%>>RID``=^p-A)L-ZGAq4c{19l;Q8ptK-%}eSi%tVgKp_)3yb>=r_Z1q
zJng@>*MH$W{EK}Iim+AUH-kuz##X-8JZxccwW#7>7B<ca2j6IaA32{|7twZPPFp`C
zNJVpcfr*%3`(k;Rpci8;BIVaLd<LscSgSBQaz?N{LLL=&?kJ1TJb$|$;;$i*<yV=e
zuUn?lgft9SSN4?pmqz(9@te85I~y=TTv^Nr597C=v<#Uh2Sl}nqsopy_=wIAaDAV@
zur$$UvwNfrr6AFRUcLV*dSG()*+_tp!<JV~=9Qn5Ii(4VB-^g=viZOw`<wEe9d~=J
z>y%EO8BCpjZfRTKBfg`2rXJDpcfk9>-WjZ?%CR9ACH3(tL5F2wzWrS7*K`E_)IH9~
z@m$pZ)cXR58e)t&>SMNMYF(_<RTZ@wxs;4#j8@TpIVE+STq5tawmr-jh+{G3dW9=u
zWvEq_!G`z1fY+_tc!4kTEDZ7ZBewtBjq9IfuK2&baV=AR|L;WL#&tz7Fw6A6gRBFc
ze)Ync2Znm#0_et1F0l2@)8ma9S&`(NHAl-m<m~zVZVLH@kM&2_mDG98Lw;2ZVwF~_
zvrixU{qeClI6To$Raf?r>*%?M@8#T>zs${hW*dC2tH?N5*w!CznN1MlOA>C#Yg-$Z
z)qa=OJF6aNy`;KY`XhVc_>EH@Pu})eDre>d)z_M3Nt{|hRSY8}NlGJ+b%^JK7TrQi
zQBUTIY^<^+YRhvC_(kv4i8~0HJxClE9*g3tlq2=7Y8sH@gPLuRWLk<CvI%v*UE7&g
zR)SM*RX_=HnX_NQM6mDC?hWdE^lYwRc45iUu(&*O&AE$LRA@QSyqj~rVj?A!`D#fw
zN~7AY@b_n;xvO?FY!R$->Y4j<-VTdTzicM!eVtaFR!{M1SeCrp`8M7mJ0of^Y7ZiG
zmDplN{&Fm{T3G7I%y@ZSUbwsXP{O2<)%~17)X6@6LTJgf#LChx(IK5a<6_mD_x;dn
z@@uX`9v2Nv@8-7oRZE4(9mMdX^t*Gc|CAdjukbitk-Zu*WbJ?FIJtP@dX{LPk!bS^
z_u(`}Wt{(=eD2=tQnVFMQ~&d4NwsM54nH+Uk<i~zU)tkdGi$HD&1q|l?90EO7a%{3
zl9%d#41~j+k;CE5B=3`n312lEzG|qX@Tg4RcE%O*X1x(89QnksUH3%v;HUS`N%*ni
zJ|!T=b>cnFu_Db!7Cf4~z$3yYQLDGu$ub%(6c;>fzc<)lkae16dgpC96O7w|qJ5^T
z;X2d#rxP?)N|S<*^&ZByRk(56lHQdI1leg@wrIxL@cUzaL#EXp`|ClujINYY70$7n
zJoo7tb0^cUiUic<7*-Nnhu54}jH@7<v2cxc*=I6m(7C#^CRi3zmibQ?j&LOwL>>^8
zwQW){U+6gRQlq_!y*<8Tx-K_3SfgLvAtH%em#fpWa;tG~--zE}^i5*c$+WmM9gfP|
z`!dDZVjsQ`U*=rit@~&}P5X$Q*6XY4envw*OKcrkrh^>aaw4jTMDaIOjz&8=ncNHr
ziYLrdnL;>-vJIxr40+-M&W|2kv=zH&5p6rKoGj2hJokyztIumt_$AjcdR~Xz@h#=e
z8>dB`9^|4pc4w(9YJR{eHr{f;DJ-6;Ws59I8F9s_vF`x83iqH!)dvn19EVfF%8Z$R
z;MLE4*nq&5a(SNQEpMVdw6T{aOD44|f)uOxRS|j>OleEYYRsL?AF8TGQ&aym>bX-D
z<WdoIrdLTfs69mdS7AJtUt;{;_8?AIQu7uzXMt^q!KHSEz0E|&?(ND5BkV3b>Iz9{
z^mGhn|ESj`%>F}-`zlXNNK5{)%X+kx*br&C`^EIrce%c{IO!s0<Z4qwr9yW6w1amA
zSEv@!A9yTO^BoNuifm*2P*=n`jANT^eGuF3G-*`Toys|UUFYUOTk$xtgR027MLwbG
zwl1#Wvwa51cE7aTjQ6tZ<!p3~DRWoWv&49P^cdxwaPX<gxI8W0$SjCQUk08~SJr=f
z2s|maGUug_c3fF0!bUVJ8AleOr|ge&jdd6uYKhZOF~TOMPAaFW9Yu!S-B%)}O+YIn
zo2nUE{ZMzWIcs+I?0d@8@vZ)><do<~F#`IMuw4Le-%9G$%wC(u5QJj^Up_mz;~4j#
z)JvP~GCM3XX1<S$eNldgX~E7V$R!t!h9L3_NBbC7<@pD@qR8IuGOv}7{^^=ylF7Y`
z%R!DyM&aV&nmuOh=a?B6Bls_m{mwB~Lu$CdR~cRr9A>KDo?iNS(V)jeWhh6mBW%p}
zP_ovl03tS73r#}E^dz0{Y*6$Hn?B%kL(D?bLXxD7oZ$&ut{QJsV*^s#kBA^e=JQ#R
z*Q*oBqu8i<LcU?GN+X+{qR|LjR6}7tdGUGQRLC0D_~=i*f;DI$3=WEK<6v&9<?9oO
z^9gjY2*u+9?C2fL+b`Ss=1KF$&jJVYJC+BEz56lx<?cf_mrdP=cH!SJ%*-WtiD7=M
zrs~^vC8iZ4o0KkiEk2kXcXr-ZJ)j_2$9EXRRJdX)y{tA`rFXb<;>SqB>@~r)U_Zt1
z*Lu%|?4K?TcBZ5kHk-5@mA<+ad3Ib+g7*+}o&=l7g|+mZO>G2KcIQTRyqxT-W`}1p
z2SlDW5k_9Uu5Z`5Hyb%*?{;lMJ)L|-Mn-vWf7c&YrB|LGY2w2Mf6$e3VU&348EAZ6
z-Pf3qacNrE#I<x;xSILG+a=Zkhg$>}vX#@y6yF|<Ctpp2y^{cMi77Jk_Vt?J+x9Jw
z%5@U1@d{+!c;#(UoqG`DzVkw2&Q1}=kF&g?B`N3a5n+)QvDvJ8R|6QDFJAe6$FyOd
z!%UuWmUMVAN%|AJX~3<xmv`6rwoPf3F4vk?h6#7EWEIWTSlaS*eVcn&K#Z+CwWW>J
zXO_$9dCl~c=-vVcg=VvcMc256NXI80`LV_FGY20={)pg?RT@Xfo|L|^MwY*4Qtw<B
zGW)B{+p3u3uI49Z5AaQ)S?wI(W3RHS&zGl^`IcM^al_5Yunvrj%NXR{)JE_8&?{jf
zP;Xr{R^R)iuA<G|YMe8+ZFC#r9M5SEW4wZLV<0|u>J3ZOrIeEbcHa3D9fM)fS?*&8
zy3e08%Hfc;JK8EAbZN3*qeO5!QT=EuZ;D-<|GaS8Y1Jo(5S<IHkDFBm7UXZ$>0rJ^
zCb2$ED@>|hGcjb`q7IxX{Br_z^PGoLKk)7Zu;Z}-uh3;<rWPeqF?GRh$X9%|z<&z@
zqae5-r4YbhTzs8P{C)8OQqI2qxb;1ky7=eREU9FmSTFDcL<<HjynxBS#hvhYxYFby
zkL^-Gyc%6#D8c%=Y%XI!X*@nq3h$2#0NRdIpu4XR96`T5sZs?HWdV|Y?cXd8{ALYY
z;8-VYtUEOac3T*nd|31pD0-h}TZ{wo@cz-EY!En?N8kL}n}Oman&R_--Foq0cU%bF
z;;)t}$Jc8j11Qc9ylyU^cWe}Q_VxA#Hikw};2B?k%2^?Gb^M(zbdVKreSlfdfd*c_
z0wGA(6#~56U2y+|0|LFF%;2NOd50$y>;`m1fx;*-jlqf=1_zoDxbX>_(*mi<W+f#R
zhkzQ=vZAi}XFMC^z%w{+oD}65)=lt2tVTDm?~p06j=*vXz+An5R~0TH30&oYQy@TB
z)fTu)MuP*b>c%I~U)3#ZlQ?N$3ZV<oyr6Z01NK-NGNn#7n3Op*)LV|e=!ZivI2zH-
zi8<8d#_>8KW<azZNa_L=T@Z#LgG4DKim7q*MGeJaa5SQu!<4DX+`pH(n*vo|5A2pu
zQA-IJGDws%nu{7oU-at{7#xl0<`6MzavUU4Ja`}7Dg{FZiBj%jQ{(81PRYRFXhb(}
zjZ>4M`K`gCOR_LzkSOKqIyH{IsG$-Jjz)Czl07xq7?LO!ENZC?Lk5XbE*?<h=!>SQ
zz~E>^H?K%glcCut!J<S}7&1tdk}Z!KM_-ij1PqQwbTb7XH5r=34lK&10Ye6fQj%Ly
z<LHa7Xv5%WL^m^LQInxLr@*32x-evr=tc%AY981WXy>5ir9KRg#&m-Udm;f%A_F2b
zj2OV6!K$!*9evf;#xOiuRr<XXG}i-IbsP(W2CM$GdxCCNqy-F*R+WDL1dXN+Rz+FD
zpuws??VzBlFHXYnXjSR=P|!HaVAUZT7&KV*r(G0Ob(b9sk5-j_9|eut3RV@che3l?
zf7(ewRnr||c(khYdnssmOR#Fb(*_z8gD*e|^ai$7LF4*?aSJXmxD8WkC~W(O#>xYe
zzu-2=ptD=pW&{m`1SU9mfwm$zC=&JY4SG!-jF|O<AV5_>|2P2+gaM|__(N!v9Rzlr
z=nF9tAPA5U{i6YN9yVBrArwNR2*Dlz=nLgXLl7V#`fVOM`wT3U7XzVDgkYOFbV>pk
z(H0LufQ0C`Z0JCJFpV)0LZb-5HfHFMOE4lV6@mZ>(Qm)dafo1AbsB_55rRFlgbw)t
zBa*Tq2#^r{vq|Vc2r#WV2STF=!Ja|V--j$o5Clkw{#hgRMi5xYqHu#obz6wK(L*mj
gf&s|u3=A-rB25gLfUn^U4649GANW$ARl5G}KS<6kegFUf

literal 0
HcmV?d00001

diff --git a/src/class178/Code04_Gosick1.java b/src/class178/Code04_Gosick1.java
index 96dd2ba5a..47c8f117a 100644
--- a/src/class178/Code04_Gosick1.java
+++ b/src/class178/Code04_Gosick1.java
@@ -134,7 +134,7 @@ public static void compute() {
 			}
 			winl = jobl;
 		}
-		// 第二次离线，因子的数量 + 部分num倍数的数量，都计入xcnt[v]
+		// 第二次离线，num倍数的数量 + num一部分因子的数量，都计入xcnt[num]
 		Arrays.fill(xcnt, 0);
 		for (int x = 0; x <= n; x++) {
 			if (x >= 1) {
@@ -147,7 +147,7 @@ public static void compute() {
 						xcnt[other]++;
 					}
 				}
-				// 只关心大于LIMIT值的num，去关心num的倍数能否得到计数
+				// 只处理大于LIMIT值的num
 				if (num > LIMIT) {
 					for (int v = num; v <= maxv; v += num) {
 						xcnt[v]++;
@@ -161,8 +161,11 @@ public static void compute() {
 				}
 			}
 		}
-		// 第三次离线，1 ~ LIMIT 这些值的倍数之前是忽略的，复用vcnt和xcnt
+		// 第三次离线，1 ~ LIMIT 这些因子是少算了的，如今补回来
 		for (int v = 1; v <= LIMIT; v++) {
+			// 复用vcnt和xcnt
+			// vcnt[i]，当前表示，1~i范围上，v出现的次数
+			// xcnt[i]，当前表示，1~i范围上，v的倍数出现的次数
 			vcnt[0] = xcnt[0] = 0;
 			for (int i = 1; i <= n; i++) {
 				vcnt[i] = vcnt[i - 1] + (arr[i] == v ? 1 : 0);
@@ -200,7 +203,7 @@ public static void main(String[] args) throws Exception {
 		}
 		prepare();
 		compute();
-		// 加工前缀和
+		// 答案变化量生成前缀和
 		for (int i = 2; i <= m; i++) {
 			ans[query[i][2]] += ans[query[i - 1][2]];
 		}

From 22bd49ce1ae2184e1a20fdee889de9bfb4b66253 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 15 Sep 2025 22:48:33 +0800
Subject: [PATCH 1414/1712] modify code

---
 src/class179/Code01_QueryMatch1.java | 203 +++++++++++++++++++++++++++
 1 file changed, 203 insertions(+)
 create mode 100644 src/class179/Code01_QueryMatch1.java

diff --git a/src/class179/Code01_QueryMatch1.java b/src/class179/Code01_QueryMatch1.java
new file mode 100644
index 000000000..80c9a8e50
--- /dev/null
+++ b/src/class179/Code01_QueryMatch1.java
@@ -0,0 +1,203 @@
+package class179;
+
+// 区间最大匹配，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4477
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code01_QueryMatch1 {
+
+	public static int MAXN = 152502;
+	public static int MAXM = 52502;
+	public static int MAXQ = 52502;
+	public static int n, m, z, q;
+	public static int[] a = new int[MAXN];
+	public static int[] b = new int[MAXM];
+	public static int[][] query = new int[MAXQ][3];
+	public static int[] bi = new int[MAXM];
+
+	public static int[] match = new int[MAXN << 2];
+	public static int[] resta = new int[MAXN << 2];
+	public static int[] overb = new int[MAXN << 2];
+
+	public static int[] ans = new int[MAXQ];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static void up(int i) {
+		int l = i << 1;
+		int r = i << 1 | 1;
+		int newMatch = Math.min(resta[l], overb[r]);
+		resta[i] = resta[l] + resta[r] - newMatch;
+		overb[i] = overb[l] + overb[r] - newMatch;
+		match[i] = match[l] + match[r] + newMatch;
+	}
+
+	public static void build(int l, int r, int i) {
+		if (l == r) {
+			resta[i] = 1;
+		} else {
+			int mid = (l + r) >> 1;
+			build(l, mid, i << 1);
+			build(mid + 1, r, i << 1 | 1);
+			up(i);
+		}
+	}
+
+	public static void add(int jobv, int l, int r, int i) {
+		if (l == r) {
+			if (resta[i] == 1) {
+				resta[i] = 0;
+				match[i] = 1;
+			} else if (resta[i] == 0) {
+				overb[i]++;
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobv + a[mid + 1] <= z) {
+				add(jobv, mid + 1, r, i << 1 | 1);
+			} else if (jobv + a[l] <= z) {
+				add(jobv, l, mid, i << 1);
+			}
+			up(i);
+		}
+	}
+
+	public static void del(int jobv, int l, int r, int i) {
+		if (l == r) {
+			if (overb[i] == 0) {
+				match[i] = 0;
+				resta[i] = 1;
+			} else {
+				overb[i]--;
+				match[i] = 1;
+				resta[i] = 0;
+			}
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobv + a[mid + 1] <= z) {
+				del(jobv, mid + 1, r, i << 1 | 1);
+			} else if (jobv + a[l] <= z) {
+				del(jobv, l, mid, i << 1);
+			}
+			up(i);
+		}
+	}
+
+	public static void prepare() {
+		Arrays.sort(a, 1, n + 1);
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= m; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, q + 1, new QueryCmp());
+		build(1, n, 1);
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= q; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			while (winl > jobl) {
+				add(b[--winl], 1, n, 1);
+			}
+			while (winr < jobr) {
+				add(b[++winr], 1, n, 1);
+			}
+			while (winl < jobl) {
+				del(b[winl++], 1, n, 1);
+			}
+			while (winr > jobr) {
+				del(b[winr--], 1, n, 1);
+			}
+			ans[id] = match[1];
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		z = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			a[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			b[i] = in.nextInt();
+		}
+		q = in.nextInt();
+		for (int i = 1; i <= q; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= q; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From a3787ea35454b1a3780a58675568375378da6af7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 01:17:05 +0800
Subject: [PATCH 1415/1712] modify code

---
 src/class179/Code01_QueryMatch1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class179/Code01_QueryMatch1.java b/src/class179/Code01_QueryMatch1.java
index 80c9a8e50..4d5f02f65 100644
--- a/src/class179/Code01_QueryMatch1.java
+++ b/src/class179/Code01_QueryMatch1.java
@@ -53,7 +53,9 @@ public static void up(int i) {
 
 	public static void build(int l, int r, int i) {
 		if (l == r) {
+			match[i] = 0;
 			resta[i] = 1;
+			overb[i] = 0;
 		} else {
 			int mid = (l + r) >> 1;
 			build(l, mid, i << 1);
@@ -65,9 +67,9 @@ public static void build(int l, int r, int i) {
 	public static void add(int jobv, int l, int r, int i) {
 		if (l == r) {
 			if (resta[i] == 1) {
-				resta[i] = 0;
 				match[i] = 1;
-			} else if (resta[i] == 0) {
+				resta[i] = 0;
+			} else {
 				overb[i]++;
 			}
 		} else {
@@ -88,8 +90,6 @@ public static void del(int jobv, int l, int r, int i) {
 				resta[i] = 1;
 			} else {
 				overb[i]--;
-				match[i] = 1;
-				resta[i] = 0;
 			}
 		} else {
 			int mid = (l + r) >> 1;

From a56069cb755d586bcace7d6f49fd42c89392eda1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 17:22:06 +0800
Subject: [PATCH 1416/1712] modify code

---
 ...yMatch1.java => Code01_MaximumMatch1.java} |   2 +-
 src/class179/Code02_SimpleQuery1.java         | 163 ++++++++++++++++++
 2 files changed, 164 insertions(+), 1 deletion(-)
 rename src/class179/{Code01_QueryMatch1.java => Code01_MaximumMatch1.java} (99%)
 create mode 100644 src/class179/Code02_SimpleQuery1.java

diff --git a/src/class179/Code01_QueryMatch1.java b/src/class179/Code01_MaximumMatch1.java
similarity index 99%
rename from src/class179/Code01_QueryMatch1.java
rename to src/class179/Code01_MaximumMatch1.java
index 4d5f02f65..42c7a47fa 100644
--- a/src/class179/Code01_QueryMatch1.java
+++ b/src/class179/Code01_MaximumMatch1.java
@@ -11,7 +11,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code01_QueryMatch1 {
+public class Code01_MaximumMatch1 {
 
 	public static int MAXN = 152502;
 	public static int MAXM = 52502;
diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
new file mode 100644
index 000000000..df41b72cc
--- /dev/null
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -0,0 +1,163 @@
+package class179;
+
+// 一个简单的询问，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5268
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code02_SimpleQuery1 {
+
+	public static int MAXN = 50001;
+	public static int n, m, cntq;
+	public static int[] arr = new int[MAXN];
+	// siz1、siz2、op、id
+	public static int[][] query = new int[MAXN << 2][4];
+
+	public static int[] bi = new int[MAXN];
+	public static int[] cntl = new int[MAXN];
+	public static int[] cntr = new int[MAXN];
+
+	public static long sum = 0;
+	public static long[] ans = new long[MAXN];
+
+	public static void addQuery(int siz1, int siz2, int op, int id) {
+		query[++cntq][0] = siz1;
+		query[cntq][1] = siz2;
+		query[cntq][2] = op;
+		query[cntq][3] = id;
+	}
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static void compute() {
+		// 注意win1和win2
+		// 不代表普通莫队中，一前一后的一段区间
+		// 代表的是arr中两个覆盖的区域，并且一开始都没覆盖到数字
+		// 同理job1和job2也不代表一段区间
+		// 而是代表两个区域在arr中要覆盖多大
+		int win1 = 0, win2 = 0;
+		for (int i = 1; i <= cntq; i++) {
+			int job1 = query[i][0];
+			int job2 = query[i][1];
+			int op = query[i][2];
+			int id = query[i][3];
+			while (win1 < job1) {
+				++cntl[arr[++win1]];
+				sum += cntr[arr[win1]];
+			}
+			while (win1 > job1) {
+				--cntl[arr[win1]];
+				sum -= cntr[arr[win1--]];
+			}
+			while (win2 < job2) {
+				++cntr[arr[++win2]];
+				sum += cntl[arr[win2]];
+			}
+			while (win2 > job2) {
+				--cntr[arr[win2]];
+				sum -= cntl[arr[win2--]];
+			}
+			ans[id] += sum * op;
+		}
+	}
+
+	public static void prepare() {
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= cntq; i++) {
+			if (query[i][0] > query[i][1]) {
+				int tmp = query[i][0];
+				query[i][0] = query[i][1];
+				query[i][1] = tmp;
+			}
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		m = in.nextInt();
+		for (int i = 1, l1, r1, l2, r2; i <= m; i++) {
+			l1 = in.nextInt();
+			r1 = in.nextInt();
+			l2 = in.nextInt();
+			r2 = in.nextInt();
+			addQuery(r1, r2, 1, i);
+			addQuery(r1, l2 - 1, -1, i);
+			addQuery(l1 - 1, r2, -1, i);
+			addQuery(l1 - 1, l2 - 1, 1, i);
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 3b3b2f4a57fa9af01f734a108a114325b2523ac0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 17:25:00 +0800
Subject: [PATCH 1417/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 43 +++++++++++++--------------
 1 file changed, 21 insertions(+), 22 deletions(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index df41b72cc..520e6b87e 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -16,23 +16,17 @@ public class Code02_SimpleQuery1 {
 	public static int MAXN = 50001;
 	public static int n, m, cntq;
 	public static int[] arr = new int[MAXN];
+
 	// siz1、siz2、op、id
 	public static int[][] query = new int[MAXN << 2][4];
 
 	public static int[] bi = new int[MAXN];
-	public static int[] cntl = new int[MAXN];
-	public static int[] cntr = new int[MAXN];
+	public static int[] cnt1 = new int[MAXN];
+	public static int[] cnt2 = new int[MAXN];
 
 	public static long sum = 0;
 	public static long[] ans = new long[MAXN];
 
-	public static void addQuery(int siz1, int siz2, int op, int id) {
-		query[++cntq][0] = siz1;
-		query[cntq][1] = siz2;
-		query[cntq][2] = op;
-		query[cntq][3] = id;
-	}
-
 	public static class QueryCmp implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
@@ -47,12 +41,17 @@ public int compare(int[] a, int[] b) {
 		}
 	}
 
+	public static void addQuery(int siz1, int siz2, int op, int id) {
+		query[++cntq][0] = siz1;
+		query[cntq][1] = siz2;
+		query[cntq][2] = op;
+		query[cntq][3] = id;
+	}
+
 	public static void compute() {
-		// 注意win1和win2
-		// 不代表普通莫队中，一前一后的一段区间
-		// 代表的是arr中两个覆盖的区域，并且一开始都没覆盖到数字
-		// 同理job1和job2也不代表一段区间
-		// 而是代表两个区域在arr中要覆盖多大
+		// 注意win1和win2不代表一段区间，而是代表arr中的两个覆盖区域
+		// win1 = 0，win2 = 0，表示两个覆盖区域一开始都没有数字
+		// 同理job1和job2也不代表区间，而是代表两个区域在arr中要覆盖多大
 		int win1 = 0, win2 = 0;
 		for (int i = 1; i <= cntq; i++) {
 			int job1 = query[i][0];
@@ -60,20 +59,20 @@ public static void compute() {
 			int op = query[i][2];
 			int id = query[i][3];
 			while (win1 < job1) {
-				++cntl[arr[++win1]];
-				sum += cntr[arr[win1]];
+				++cnt1[arr[++win1]];
+				sum += cnt2[arr[win1]];
 			}
 			while (win1 > job1) {
-				--cntl[arr[win1]];
-				sum -= cntr[arr[win1--]];
+				--cnt1[arr[win1]];
+				sum -= cnt2[arr[win1--]];
 			}
 			while (win2 < job2) {
-				++cntr[arr[++win2]];
-				sum += cntl[arr[win2]];
+				++cnt2[arr[++win2]];
+				sum += cnt1[arr[win2]];
 			}
 			while (win2 > job2) {
-				--cntr[arr[win2]];
-				sum -= cntl[arr[win2--]];
+				--cnt2[arr[win2]];
+				sum -= cnt1[arr[win2--]];
 			}
 			ans[id] += sum * op;
 		}

From 1fd1627b786260962adaf595856c696196c3844d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 17:26:29 +0800
Subject: [PATCH 1418/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index 520e6b87e..eafb44146 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -48,10 +48,10 @@ public static void addQuery(int siz1, int siz2, int op, int id) {
 		query[cntq][3] = id;
 	}
 
+	// 注意win1和win2不代表一段区间，而是代表arr中的两个覆盖区域
+	// win1 = 0，win2 = 0，表示两个覆盖区域一开始都没有数字
+	// 同理job1和job2也不代表区间，而是代表两个区域在arr中各自覆盖多大
 	public static void compute() {
-		// 注意win1和win2不代表一段区间，而是代表arr中的两个覆盖区域
-		// win1 = 0，win2 = 0，表示两个覆盖区域一开始都没有数字
-		// 同理job1和job2也不代表区间，而是代表两个区域在arr中要覆盖多大
 		int win1 = 0, win2 = 0;
 		for (int i = 1; i <= cntq; i++) {
 			int job1 = query[i][0];

From 5175c967f1388b3f2bb9bd1338db4cb9f582a443 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 17:31:52 +0800
Subject: [PATCH 1419/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index eafb44146..bb06f63b2 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -48,9 +48,9 @@ public static void addQuery(int siz1, int siz2, int op, int id) {
 		query[cntq][3] = id;
 	}
 
-	// 注意win1和win2不代表一段区间，而是代表arr中的两个覆盖区域
-	// win1 = 0，win2 = 0，表示两个覆盖区域一开始都没有数字
-	// 同理job1和job2也不代表区间，而是代表两个区域在arr中各自覆盖多大
+	// 注意win1和win2不代表一段区间，而是代表两个独立的区域，各自覆盖arr
+	// 初始时，win1 = 0，win2 = 0，表示两个覆盖区域一开始都没有数字
+	// 同理job1和job2也不代表区间，而是代表这两个区域各自覆盖多大
 	public static void compute() {
 		int win1 = 0, win2 = 0;
 		for (int i = 1; i <= cntq; i++) {

From bb402a9c785c11486403654730ecec4b4cdcd30d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 17:32:58 +0800
Subject: [PATCH 1420/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index bb06f63b2..28342eaab 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -1,6 +1,6 @@
 package class179;
 
-// 一个简单的询问，java版
+// 简单的询问，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5268
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From d9f176953496f20d4ff3e51120b95302984994cb Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 17:35:08 +0800
Subject: [PATCH 1421/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index 28342eaab..74af8eeb1 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -48,9 +48,9 @@ public static void addQuery(int siz1, int siz2, int op, int id) {
 		query[cntq][3] = id;
 	}
 
-	// 注意win1和win2不代表一段区间，而是代表两个独立的区域，各自覆盖arr
-	// 初始时，win1 = 0，win2 = 0，表示两个覆盖区域一开始都没有数字
-	// 同理job1和job2也不代表区间，而是代表这两个区域各自覆盖多大
+	// win1和win2不代表一段区间，而是代表两个独立区域各自去覆盖arr
+	// win1 = 0，win2 = 0，表示两个覆盖区域一开始都没有数字
+	// job1和job2也不代表区间，而是代表两个区域各自要覆盖多大
 	public static void compute() {
 		int win1 = 0, win2 = 0;
 		for (int i = 1; i <= cntq; i++) {

From 4f6f5676a2e3995f49aa87088701a8b9adc3d38c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 16 Sep 2025 18:59:06 +0800
Subject: [PATCH 1422/1712] modify code

---
 src/class179/Code03_NiceDay1.java | 177 ++++++++++++++++++++++++++++++
 src/class179/Code03_NiceDay2.java | 111 +++++++++++++++++++
 2 files changed, 288 insertions(+)
 create mode 100644 src/class179/Code03_NiceDay1.java
 create mode 100644 src/class179/Code03_NiceDay2.java

diff --git a/src/class179/Code03_NiceDay1.java b/src/class179/Code03_NiceDay1.java
new file mode 100644
index 000000000..216550a2a
--- /dev/null
+++ b/src/class179/Code03_NiceDay1.java
@@ -0,0 +1,177 @@
+package class179;
+
+// 美好的每一天，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3604
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code03_NiceDay2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code03_NiceDay1 {
+
+	public static int MAXN = 60002;
+	public static int MAXV = 1 << 26;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][3];
+	public static int[] bi = new int[MAXN];
+
+	public static short[] cnt = new short[MAXV];
+	public static long num = 0;
+	public static long[] ans = new long[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static void add(int s) {
+		num += cnt[s]++;
+		for (int i = 0; i < 26; i++) {
+			num += cnt[s ^ (1 << i)];
+		}
+	}
+
+	public static void del(int s) {
+		num -= --cnt[s];
+		for (int i = 0; i < 26; i++) {
+			num -= cnt[s ^ (1 << i)];
+		}
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			ans[id] = num;
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			arr[i] ^= arr[i - 1];
+		}
+		for (int i = n; i >= 0; i--) {
+			arr[i + 1] = arr[i];
+		}
+		n++;
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][1]++;
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		char c;
+		for (int i = 1; i <= n; i++) {
+			c = in.nextLowerCase();
+			arr[i] = 1 << (c - 'a');
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextLowerCase() throws IOException {
+			int c;
+			while (true) {
+				c = readByte();
+				if (c >= 'a' && c <= 'z')
+					return (char) c;
+			}
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class179/Code03_NiceDay2.java b/src/class179/Code03_NiceDay2.java
new file mode 100644
index 000000000..8d3d36615
--- /dev/null
+++ b/src/class179/Code03_NiceDay2.java
@@ -0,0 +1,111 @@
+package class179;
+
+// 美好的每一天，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3604
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 60002;
+//const int MAXV = 1 << 26;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//
+//int bi[MAXN];
+//short cnt[MAXV];
+//long long num = 0;
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.l] & 1) {
+//        return a.r < b.r;
+//    } else {
+//        return a.r > b.r;
+//    }
+//}
+//
+//void add(int s) {
+//    num += cnt[s]++;
+//    for (int i = 0; i < 26; i++) {
+//        num += cnt[s ^ (1 << i)];
+//    }
+//}
+//
+//void del(int s) {
+//    num -= --cnt[s];
+//    for (int i = 0; i < 26; i++) {
+//        num -= cnt[s ^ (1 << i)];
+//    }
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        ans[id] = num;
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] ^= arr[i - 1];
+//    }
+//    for (int i = n; i >= 0; i--) {
+//        arr[i + 1] = arr[i];
+//    }
+//    n++;
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        query[i].r++;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    char c;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> c;
+//        arr[i] = 1 << (c - 'a');
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 3ce65bef379d60286331955582b08441023fec78 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 18 Sep 2025 15:22:24 +0800
Subject: [PATCH 1423/1712] modify code

---
 src/class179/Code04_SubsequenceSum1.java | 216 +++++++++++++++++++++++
 src/class179/Code04_SubsequenceSum2.java | 158 +++++++++++++++++
 2 files changed, 374 insertions(+)
 create mode 100644 src/class179/Code04_SubsequenceSum1.java
 create mode 100644 src/class179/Code04_SubsequenceSum2.java

diff --git a/src/class179/Code04_SubsequenceSum1.java b/src/class179/Code04_SubsequenceSum1.java
new file mode 100644
index 000000000..f1534ad55
--- /dev/null
+++ b/src/class179/Code04_SubsequenceSum1.java
@@ -0,0 +1,216 @@
+package class179;
+
+// 区间子序列的和，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5072
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code04_SubsequenceSum2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code04_SubsequenceSum1 {
+
+	public static int MAXN = 100001;
+	public static int MAXB = 401;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	// 每条查询的格式 : l、r、mod、id
+	public static int[][] query = new int[MAXN][4];
+	public static int[] bi = new int[MAXN];
+
+	public static int head;
+	public static int[] last = new int[MAXN];
+	public static int[] next = new int[MAXN];
+
+	public static int[] cnt = new int[MAXN];
+	public static long[] sum = new long[MAXN];
+
+	public static long[] inpow = new long[MAXB];
+	public static long[] outpow = new long[MAXB];
+
+	public static long[] ans = new long[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static void addNode(int x) {
+		last[head] = x;
+		next[x] = head;
+		head = x;
+	}
+
+	public static void removeNode(int x) {
+		if (x == head) {
+			head = next[head];
+			last[head] = next[x] = 0;
+		} else {
+			next[last[x]] = next[x];
+			last[next[x]] = last[x];
+			last[x] = next[x] = 0;
+		}
+	}
+
+	public static void add(int num) {
+		if (cnt[num] > 0) {
+			sum[cnt[num]] -= num;
+		}
+		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+			removeNode(cnt[num]);
+		}
+		cnt[num]++;
+		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+			addNode(cnt[num]);
+		}
+		if (cnt[num] > 0) {
+			sum[cnt[num]] += num;
+		}
+	}
+
+	public static void del(int num) {
+		if (cnt[num] > 0) {
+			sum[cnt[num]] -= num;
+		}
+		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+			removeNode(cnt[num]);
+		}
+		cnt[num]--;
+		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+			addNode(cnt[num]);
+		}
+		if (cnt[num] > 0) {
+			sum[cnt[num]] += num;
+		}
+	}
+
+	public static long getAns(int len, int mod) {
+		int blen = (int) Math.sqrt(len);
+		int bnum = (len + blen - 1) / blen;
+		inpow[0] = 1;
+		for (int i = 1; i <= blen; i++) {
+			inpow[i] = (inpow[i - 1] << 1) % mod;
+		}
+		outpow[0] = 1;
+		for (int i = 1; i <= bnum; i++) {
+			outpow[i] = (outpow[i - 1] * inpow[blen]) % mod;
+		}
+		long ret = 0, tmp;
+		for (int p = head; p > 0; p = next[p]) {
+			tmp = outpow[len / blen] * inpow[len % blen] % mod;
+			tmp -= outpow[(len - p) / blen] * inpow[(len - p) % blen] % mod;
+			tmp = (tmp * sum[p]) % mod;
+			ret = ((ret + tmp) % mod + mod) % mod;
+		}
+		return ret;
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int mod = query[i][2];
+			int id = query[i][3];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			ans[id] = getAns(jobr - jobl + 1, mod);
+		}
+	}
+
+	public static void prepare() {
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = in.nextInt();
+			query[i][3] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class179/Code04_SubsequenceSum2.java b/src/class179/Code04_SubsequenceSum2.java
new file mode 100644
index 000000000..81e74570c
--- /dev/null
+++ b/src/class179/Code04_SubsequenceSum2.java
@@ -0,0 +1,158 @@
+package class179;
+
+// 区间子序列的和，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5072
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, mod, id;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXB = 401;
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//int bi[MAXN];
+//
+//int head;
+//int lst[MAXN];
+//int nxt[MAXN];
+//
+//int cnt[MAXN];
+//long long sum[MAXN];
+//
+//long long inpow[MAXB];
+//long long outpow[MAXB];
+//
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    } else {
+//        return a.r > b.r;
+//    }
+//}
+//
+//void addNode(int x) {
+//    lst[head] = x;
+//    nxt[x] = head;
+//    head = x;
+//}
+//
+//void removeNode(int x) {
+//    if (x == head) {
+//        head = nxt[head];
+//        lst[head] = 0;
+//        nxt[x] = 0;
+//    } else {
+//        nxt[lst[x]] = nxt[x];
+//        lst[nxt[x]] = lst[x];
+//        lst[x] = 0;
+//        nxt[x] = 0;
+//    }
+//}
+//
+//void add(int num) {
+//    if (cnt[num] > 0) {
+//        sum[cnt[num]] -= num;
+//    }
+//    if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+//        removeNode(cnt[num]);
+//    }
+//    cnt[num]++;
+//    if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+//        addNode(cnt[num]);
+//    }
+//    if (cnt[num] > 0) {
+//        sum[cnt[num]] += num;
+//    }
+//}
+//
+//void del(int num) {
+//    if (cnt[num] > 0) {
+//        sum[cnt[num]] -= num;
+//    }
+//    if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+//        removeNode(cnt[num]);
+//    }
+//    cnt[num]--;
+//    if (cnt[num] > 0 && sum[cnt[num]] == 0) {
+//        addNode(cnt[num]);
+//    }
+//    if (cnt[num] > 0) {
+//        sum[cnt[num]] += num;
+//    }
+//}
+//
+//long long getAns(int len, int mod) {
+//    int blen = (int)sqrt(len);
+//    int bnum = (len + blen - 1) / blen;
+//    inpow[0] = 1;
+//    for (int i = 1; i <= blen; i++) {
+//        inpow[i] = (inpow[i - 1] << 1) % mod;
+//    }
+//    outpow[0] = 1;
+//    for (int i = 1; i <= bnum; i++) {
+//        outpow[i] = (outpow[i - 1] * inpow[blen]) % mod;
+//    }
+//    long long ret = 0, tmp;
+//    for (int p = head; p > 0; p = nxt[p]) {
+//        tmp = outpow[len / blen] * inpow[len % blen] % mod;
+//        tmp -= outpow[(len - p) / blen] * inpow[(len - p) % blen] % mod;
+//        tmp = (tmp * sum[p]) % mod;
+//        ret = ((ret + tmp) % mod + mod) % mod;
+//    }
+//    return ret;
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int mod  = query[i].mod;
+//        int id   = query[i].id;
+//        while (winl > jobl) add(arr[--winl]);
+//        while (winr < jobr) add(arr[++winr]);
+//        while (winl < jobl) del(arr[winl++]);
+//        while (winr > jobr) del(arr[winr--]);
+//        ans[id] = getAns(jobr - jobl + 1, mod);
+//    }
+//}
+//
+//void prepare() {
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r >> query[i].mod;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 701f59944199ce999019764a9a64d4432eee0137 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 18 Sep 2025 15:24:46 +0800
Subject: [PATCH 1424/1712] modify code

---
 src/class179/Code04_SubsequenceSum1.java | 6 +++---
 src/class179/Code04_SubsequenceSum2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class179/Code04_SubsequenceSum1.java b/src/class179/Code04_SubsequenceSum1.java
index f1534ad55..393433d67 100644
--- a/src/class179/Code04_SubsequenceSum1.java
+++ b/src/class179/Code04_SubsequenceSum1.java
@@ -56,7 +56,7 @@ public static void addNode(int x) {
 		head = x;
 	}
 
-	public static void removeNode(int x) {
+	public static void delNode(int x) {
 		if (x == head) {
 			head = next[head];
 			last[head] = next[x] = 0;
@@ -72,7 +72,7 @@ public static void add(int num) {
 			sum[cnt[num]] -= num;
 		}
 		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
-			removeNode(cnt[num]);
+			delNode(cnt[num]);
 		}
 		cnt[num]++;
 		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
@@ -88,7 +88,7 @@ public static void del(int num) {
 			sum[cnt[num]] -= num;
 		}
 		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
-			removeNode(cnt[num]);
+			delNode(cnt[num]);
 		}
 		cnt[num]--;
 		if (cnt[num] > 0 && sum[cnt[num]] == 0) {
diff --git a/src/class179/Code04_SubsequenceSum2.java b/src/class179/Code04_SubsequenceSum2.java
index 81e74570c..96645987a 100644
--- a/src/class179/Code04_SubsequenceSum2.java
+++ b/src/class179/Code04_SubsequenceSum2.java
@@ -49,7 +49,7 @@
 //    head = x;
 //}
 //
-//void removeNode(int x) {
+//void delNode(int x) {
 //    if (x == head) {
 //        head = nxt[head];
 //        lst[head] = 0;
@@ -67,7 +67,7 @@
 //        sum[cnt[num]] -= num;
 //    }
 //    if (cnt[num] > 0 && sum[cnt[num]] == 0) {
-//        removeNode(cnt[num]);
+//        delNode(cnt[num]);
 //    }
 //    cnt[num]++;
 //    if (cnt[num] > 0 && sum[cnt[num]] == 0) {
@@ -83,7 +83,7 @@
 //        sum[cnt[num]] -= num;
 //    }
 //    if (cnt[num] > 0 && sum[cnt[num]] == 0) {
-//        removeNode(cnt[num]);
+//        delNode(cnt[num]);
 //    }
 //    cnt[num]--;
 //    if (cnt[num] > 0 && sum[cnt[num]] == 0) {

From 8a0189c5863355a6f674b7196dc63bf94d06359a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 18 Sep 2025 15:33:38 +0800
Subject: [PATCH 1425/1712] modify code

---
 src/class179/Code04_SubsequenceSum1.java | 16 ++++++++--------
 src/class179/Code04_SubsequenceSum2.java | 20 ++++++++++----------
 2 files changed, 18 insertions(+), 18 deletions(-)

diff --git a/src/class179/Code04_SubsequenceSum1.java b/src/class179/Code04_SubsequenceSum1.java
index 393433d67..47dd54248 100644
--- a/src/class179/Code04_SubsequenceSum1.java
+++ b/src/class179/Code04_SubsequenceSum1.java
@@ -31,8 +31,8 @@ public class Code04_SubsequenceSum1 {
 	public static int[] cnt = new int[MAXN];
 	public static long[] sum = new long[MAXN];
 
-	public static long[] inpow = new long[MAXB];
-	public static long[] outpow = new long[MAXB];
+	public static long[] smlPow = new long[MAXB];
+	public static long[] bigPow = new long[MAXB];
 
 	public static long[] ans = new long[MAXN];
 
@@ -102,18 +102,18 @@ public static void del(int num) {
 	public static long getAns(int len, int mod) {
 		int blen = (int) Math.sqrt(len);
 		int bnum = (len + blen - 1) / blen;
-		inpow[0] = 1;
+		smlPow[0] = 1;
 		for (int i = 1; i <= blen; i++) {
-			inpow[i] = (inpow[i - 1] << 1) % mod;
+			smlPow[i] = (smlPow[i - 1] << 1) % mod;
 		}
-		outpow[0] = 1;
+		bigPow[0] = 1;
 		for (int i = 1; i <= bnum; i++) {
-			outpow[i] = (outpow[i - 1] * inpow[blen]) % mod;
+			bigPow[i] = (bigPow[i - 1] * smlPow[blen]) % mod;
 		}
 		long ret = 0, tmp;
 		for (int p = head; p > 0; p = next[p]) {
-			tmp = outpow[len / blen] * inpow[len % blen] % mod;
-			tmp -= outpow[(len - p) / blen] * inpow[(len - p) % blen] % mod;
+			tmp = bigPow[len / blen] * smlPow[len % blen] % mod;
+			tmp -= bigPow[(len - p) / blen] * smlPow[(len - p) % blen] % mod;
 			tmp = (tmp * sum[p]) % mod;
 			ret = ((ret + tmp) % mod + mod) % mod;
 		}
diff --git a/src/class179/Code04_SubsequenceSum2.java b/src/class179/Code04_SubsequenceSum2.java
index 96645987a..71cc0b6d9 100644
--- a/src/class179/Code04_SubsequenceSum2.java
+++ b/src/class179/Code04_SubsequenceSum2.java
@@ -27,8 +27,8 @@
 //int cnt[MAXN];
 //long long sum[MAXN];
 //
-//long long inpow[MAXB];
-//long long outpow[MAXB];
+//long long smlPow[MAXB];
+//long long bigPow[MAXB];
 //
 //long long ans[MAXN];
 //
@@ -97,18 +97,18 @@
 //long long getAns(int len, int mod) {
 //    int blen = (int)sqrt(len);
 //    int bnum = (len + blen - 1) / blen;
-//    inpow[0] = 1;
+//    smlPow[0] = 1;
 //    for (int i = 1; i <= blen; i++) {
-//        inpow[i] = (inpow[i - 1] << 1) % mod;
+//        smlPow[i] = (smlPow[i - 1] << 1) % mod;
 //    }
-//    outpow[0] = 1;
+//    bigPow[0] = 1;
 //    for (int i = 1; i <= bnum; i++) {
-//        outpow[i] = (outpow[i - 1] * inpow[blen]) % mod;
+//        bigPow[i] = (bigPow[i - 1] * smlPow[blen]) % mod;
 //    }
 //    long long ret = 0, tmp;
 //    for (int p = head; p > 0; p = nxt[p]) {
-//        tmp = outpow[len / blen] * inpow[len % blen] % mod;
-//        tmp -= outpow[(len - p) / blen] * inpow[(len - p) % blen] % mod;
+//        tmp = bigPow[len / blen] * smlPow[len % blen] % mod;
+//        tmp -= bigPow[(len - p) / blen] * smlPow[(len - p) % blen] % mod;
 //        tmp = (tmp * sum[p]) % mod;
 //        ret = ((ret + tmp) % mod + mod) % mod;
 //    }
@@ -120,8 +120,8 @@
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
-//        int mod  = query[i].mod;
-//        int id   = query[i].id;
+//        int mod = query[i].mod;
+//        int id = query[i].id;
 //        while (winl > jobl) add(arr[--winl]);
 //        while (winr < jobr) add(arr[++winr]);
 //        while (winl < jobl) del(arr[winl++]);

From 425c136ee23b444cb1b085a78aca94196ed6fb93 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 18 Sep 2025 15:40:01 +0800
Subject: [PATCH 1426/1712] modify code

---
 src/class179/Code04_SubsequenceSum2.java | 16 ++++++++++++----
 1 file changed, 12 insertions(+), 4 deletions(-)

diff --git a/src/class179/Code04_SubsequenceSum2.java b/src/class179/Code04_SubsequenceSum2.java
index 71cc0b6d9..d5d0c5199 100644
--- a/src/class179/Code04_SubsequenceSum2.java
+++ b/src/class179/Code04_SubsequenceSum2.java
@@ -122,10 +122,18 @@
 //        int jobr = query[i].r;
 //        int mod = query[i].mod;
 //        int id = query[i].id;
-//        while (winl > jobl) add(arr[--winl]);
-//        while (winr < jobr) add(arr[++winr]);
-//        while (winl < jobl) del(arr[winl++]);
-//        while (winr > jobr) del(arr[winr--]);
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
 //        ans[id] = getAns(jobr - jobl + 1, mod);
 //    }
 //}

From 6a6a96d14ff23665bd90944811009af938980163 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 18 Sep 2025 21:39:02 +0800
Subject: [PATCH 1427/1712] modify code

---
 src/class179/Code04_SubsequenceSum1.java |  10 +-
 src/class179/Code04_SubsequenceSum2.java |  10 +-
 src/class179/Code05_Homework1.java       | 191 +++++++++++++++++++++++
 3 files changed, 201 insertions(+), 10 deletions(-)
 create mode 100644 src/class179/Code05_Homework1.java

diff --git a/src/class179/Code04_SubsequenceSum1.java b/src/class179/Code04_SubsequenceSum1.java
index 47dd54248..105426317 100644
--- a/src/class179/Code04_SubsequenceSum1.java
+++ b/src/class179/Code04_SubsequenceSum1.java
@@ -99,7 +99,7 @@ public static void del(int num) {
 		}
 	}
 
-	public static long getAns(int len, int mod) {
+	public static void setAns(int len, int mod, int id) {
 		int blen = (int) Math.sqrt(len);
 		int bnum = (len + blen - 1) / blen;
 		smlPow[0] = 1;
@@ -110,14 +110,14 @@ public static long getAns(int len, int mod) {
 		for (int i = 1; i <= bnum; i++) {
 			bigPow[i] = (bigPow[i - 1] * smlPow[blen]) % mod;
 		}
-		long ret = 0, tmp;
+		long res = 0, tmp;
 		for (int p = head; p > 0; p = next[p]) {
 			tmp = bigPow[len / blen] * smlPow[len % blen] % mod;
 			tmp -= bigPow[(len - p) / blen] * smlPow[(len - p) % blen] % mod;
 			tmp = (tmp * sum[p]) % mod;
-			ret = ((ret + tmp) % mod + mod) % mod;
+			res = ((res + tmp) % mod + mod) % mod;
 		}
-		return ret;
+		ans[id] = res;
 	}
 
 	public static void compute() {
@@ -139,7 +139,7 @@ public static void compute() {
 			while (winr > jobr) {
 				del(arr[winr--]);
 			}
-			ans[id] = getAns(jobr - jobl + 1, mod);
+			setAns(jobr - jobl + 1, mod, id);
 		}
 	}
 
diff --git a/src/class179/Code04_SubsequenceSum2.java b/src/class179/Code04_SubsequenceSum2.java
index d5d0c5199..9645e270d 100644
--- a/src/class179/Code04_SubsequenceSum2.java
+++ b/src/class179/Code04_SubsequenceSum2.java
@@ -94,7 +94,7 @@
 //    }
 //}
 //
-//long long getAns(int len, int mod) {
+//void setAns(int len, int mod, int id) {
 //    int blen = (int)sqrt(len);
 //    int bnum = (len + blen - 1) / blen;
 //    smlPow[0] = 1;
@@ -105,14 +105,14 @@
 //    for (int i = 1; i <= bnum; i++) {
 //        bigPow[i] = (bigPow[i - 1] * smlPow[blen]) % mod;
 //    }
-//    long long ret = 0, tmp;
+//    long long res = 0, tmp;
 //    for (int p = head; p > 0; p = nxt[p]) {
 //        tmp = bigPow[len / blen] * smlPow[len % blen] % mod;
 //        tmp -= bigPow[(len - p) / blen] * smlPow[(len - p) % blen] % mod;
 //        tmp = (tmp * sum[p]) % mod;
-//        ret = ((ret + tmp) % mod + mod) % mod;
+//        res = ((res + tmp) % mod + mod) % mod;
 //    }
-//    return ret;
+//    ans[id] = res;
 //}
 //
 //void compute() {
@@ -134,7 +134,7 @@
 //        while (winr > jobr) {
 //            del(arr[winr--]);
 //        }
-//        ans[id] = getAns(jobr - jobl + 1, mod);
+//        setAns(jobr - jobl + 1, mod, id);
 //    }
 //}
 //
diff --git a/src/class179/Code05_Homework1.java b/src/class179/Code05_Homework1.java
new file mode 100644
index 000000000..73bca379b
--- /dev/null
+++ b/src/class179/Code05_Homework1.java
@@ -0,0 +1,191 @@
+package class179;
+
+// 作业，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4396
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code05_Homework1 {
+
+	public static int MAXN = 100001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	// l、r、a、b、id
+	public static int[][] query = new int[MAXN][5];
+	public static int[] bi = new int[MAXN];
+	public static int[] bl = new int[MAXN];
+	public static int[] br = new int[MAXN];
+
+	public static int[] numCnt = new int[MAXN];
+	public static int[] blockCnt = new int[MAXN];
+	public static int[] blockKind = new int[MAXN];
+
+	public static int[] ans1 = new int[MAXN];
+	public static int[] ans2 = new int[MAXN];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static void add(int x) {
+		numCnt[x]++;
+		blockCnt[bi[x]]++;
+		if (numCnt[x] == 1) {
+			blockKind[bi[x]]++;
+		}
+	}
+
+	public static void del(int x) {
+		numCnt[x]--;
+		blockCnt[bi[x]]--;
+		if (numCnt[x] == 0) {
+			blockKind[bi[x]]--;
+		}
+	}
+
+	public static void setAns(int a, int b, int id) {
+		if (bi[a] == bi[b]) {
+			for (int i = a; i <= b; i++) {
+				if (numCnt[i] > 0) {
+					ans1[id] += numCnt[i];
+					ans2[id]++;
+				}
+			}
+		} else {
+			for (int i = a; i <= br[bi[a]]; i++) {
+				if (numCnt[i] > 0) {
+					ans1[id] += numCnt[i];
+					ans2[id]++;
+				}
+			}
+			for (int i = bl[bi[b]]; i <= b; i++) {
+				if (numCnt[i] > 0) {
+					ans1[id] += numCnt[i];
+					ans2[id]++;
+				}
+			}
+			for (int i = bi[a] + 1; i <= bi[b] - 1; i++) {
+				ans1[id] += blockCnt[i];
+				ans2[id] += blockKind[i];
+			}
+		}
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int joba = query[i][2];
+			int jobb = query[i][3];
+			int id = query[i][4];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			setAns(joba, jobb, id);
+		}
+	}
+
+	public static void prepare() {
+		int limit = MAXN - 1;
+		int blen = (int) Math.sqrt(limit);
+		int bnum = (limit + blen - 1) / blen;
+		for (int i = 1; i <= limit; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= bnum; i++) {
+			bl[i] = (i - 1) * blen + 1;
+			br[i] = Math.min(i * blen, limit);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = in.nextInt();
+			query[i][3] = in.nextInt();
+			query[i][4] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans1[i] + " " + ans2[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 40032f7f0e014ee135403fc867153e5551d57833 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 18 Sep 2025 21:39:53 +0800
Subject: [PATCH 1428/1712] modify code

---
 src/class179/Code05_Homework1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class179/Code05_Homework1.java b/src/class179/Code05_Homework1.java
index 73bca379b..b43a2b38c 100644
--- a/src/class179/Code05_Homework1.java
+++ b/src/class179/Code05_Homework1.java
@@ -112,15 +112,15 @@ public static void compute() {
 	}
 
 	public static void prepare() {
-		int limit = MAXN - 1;
-		int blen = (int) Math.sqrt(limit);
-		int bnum = (limit + blen - 1) / blen;
-		for (int i = 1; i <= limit; i++) {
+		int nv = MAXN - 1;
+		int blen = (int) Math.sqrt(nv);
+		int bnum = (nv + blen - 1) / blen;
+		for (int i = 1; i <= nv; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
 		for (int i = 1; i <= bnum; i++) {
 			bl[i] = (i - 1) * blen + 1;
-			br[i] = Math.min(i * blen, limit);
+			br[i] = Math.min(i * blen, nv);
 		}
 		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}

From e523b908fe3fd0ebca2c9ddbb625af93c777e617 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 24 Sep 2025 11:59:51 +0900
Subject: [PATCH 1429/1712] modify code

---
 src/class179/Code06_LCP1.java | 214 ++++++++++++++++++++++++++++++++++
 1 file changed, 214 insertions(+)
 create mode 100644 src/class179/Code06_LCP1.java

diff --git a/src/class179/Code06_LCP1.java b/src/class179/Code06_LCP1.java
new file mode 100644
index 000000000..80f269a02
--- /dev/null
+++ b/src/class179/Code06_LCP1.java
@@ -0,0 +1,214 @@
+package class179;
+
+// 区间LCP达标对，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5112
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code06_LCP1 {
+
+	public static int MAXN = 3000001;
+	public static int MAXM = 100001;
+	public static int n, m, k;
+	public static long[] arr = new long[MAXN];
+	public static int[][] query = new int[MAXM][3];
+
+	public static int base = 499;
+	public static long[] pow = new long[MAXN];
+	public static long[] hash = new long[MAXN];
+
+	public static long[] sorted = new long[MAXN];
+	public static int[] val = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	public static long[] cnt = new long[MAXN];
+	public static long curAns;
+	public static long[] ans = new long[MAXM];
+
+	public static int kth(int len, long num) {
+		int left = 1, right = len, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static void add(int x) {
+		curAns -= cnt[x] * cnt[x];
+		cnt[x]++;
+		curAns += cnt[x] * cnt[x];
+	}
+
+	public static void del(int x) {
+		curAns -= cnt[x] * cnt[x];
+		cnt[x]--;
+		curAns += cnt[x] * cnt[x];
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= m; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			if (jobl > jobr) {
+				ans[id] = 0;
+			} else {
+				while (winl > jobl) {
+					add(val[--winl]);
+				}
+				while (winr < jobr) {
+					add(val[++winr]);
+				}
+				while (winl < jobl) {
+					del(val[winl++]);
+				}
+				while (winr > jobr) {
+					del(val[winr--]);
+				}
+				ans[id] = (curAns - (jobr - jobl + 1)) / 2;
+			}
+		}
+	}
+
+	public static void prepare() {
+		pow[0] = 1;
+		for (int i = 1; i <= n; i++) {
+			pow[i] = pow[i - 1] * base;
+			hash[i] = hash[i - 1] * base + arr[i];
+		}
+		for (int l = 1, r = k; r <= n; l++, r++) {
+			arr[l] = hash[r] - hash[l - 1] * pow[r - l + 1];
+			sorted[l] = arr[l];
+		}
+		n = n - k + 1;
+		Arrays.sort(sorted, 1, n + 1);
+		int len = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			val[i] = kth(len, arr[i]);
+		}
+		int blen = Math.max(1, (int) ((double) n / Math.sqrt(m)));
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][1] = Math.min(query[i][1], n);
+		}
+		Arrays.sort(query, 1, m + 1, new QueryCmp());
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		k = in.nextInt();
+		char c;
+		for (int i = 1; i <= n; i++) {
+			c = in.nextLowerCase();
+			arr[i] = c - 'a' + 1;
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = i;
+		}
+		prepare();
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextLowerCase() throws IOException {
+			int c;
+			while (true) {
+				c = readByte();
+				if (c >= 'a' && c <= 'z')
+					return (char) c;
+			}
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}

From 70ce3085527e654b258ff5263e605f4006792c8a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 24 Sep 2025 14:16:21 +0900
Subject: [PATCH 1430/1712] modify code

---
 src/class179/Code06_LCP1.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/class179/Code06_LCP1.java b/src/class179/Code06_LCP1.java
index 80f269a02..dda179658 100644
--- a/src/class179/Code06_LCP1.java
+++ b/src/class179/Code06_LCP1.java
@@ -105,9 +105,11 @@ public static void prepare() {
 		}
 		for (int l = 1, r = k; r <= n; l++, r++) {
 			arr[l] = hash[r] - hash[l - 1] * pow[r - l + 1];
-			sorted[l] = arr[l];
 		}
 		n = n - k + 1;
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
 		Arrays.sort(sorted, 1, n + 1);
 		int len = 1;
 		for (int i = 2; i <= n; i++) {

From e5c28120e7f15c3d0cbbb65e363d123ff1468b79 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 24 Sep 2025 14:28:43 +0900
Subject: [PATCH 1431/1712] modify code

---
 src/class179/Code06_LCP1.java | 26 +++++++++++++-------------
 1 file changed, 13 insertions(+), 13 deletions(-)

diff --git a/src/class179/Code06_LCP1.java b/src/class179/Code06_LCP1.java
index dda179658..4a3c127ac 100644
--- a/src/class179/Code06_LCP1.java
+++ b/src/class179/Code06_LCP1.java
@@ -16,15 +16,17 @@ public class Code06_LCP1 {
 	public static int MAXN = 3000001;
 	public static int MAXM = 100001;
 	public static int n, m, k;
-	public static long[] arr = new long[MAXN];
+
+	public static char[] str = new char[MAXN];
 	public static int[][] query = new int[MAXM][3];
 
 	public static int base = 499;
 	public static long[] pow = new long[MAXN];
 	public static long[] hash = new long[MAXN];
 
+	public static long[] val = new long[MAXN];
 	public static long[] sorted = new long[MAXN];
-	public static int[] val = new int[MAXN];
+	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
 
 	public static long[] cnt = new long[MAXN];
@@ -81,16 +83,16 @@ public static void compute() {
 				ans[id] = 0;
 			} else {
 				while (winl > jobl) {
-					add(val[--winl]);
+					add(arr[--winl]);
 				}
 				while (winr < jobr) {
-					add(val[++winr]);
+					add(arr[++winr]);
 				}
 				while (winl < jobl) {
-					del(val[winl++]);
+					del(arr[winl++]);
 				}
 				while (winr > jobr) {
-					del(val[winr--]);
+					del(arr[winr--]);
 				}
 				ans[id] = (curAns - (jobr - jobl + 1)) / 2;
 			}
@@ -101,14 +103,14 @@ public static void prepare() {
 		pow[0] = 1;
 		for (int i = 1; i <= n; i++) {
 			pow[i] = pow[i - 1] * base;
-			hash[i] = hash[i - 1] * base + arr[i];
+			hash[i] = hash[i - 1] * base + (str[i] - 'a' + 1);
 		}
 		for (int l = 1, r = k; r <= n; l++, r++) {
-			arr[l] = hash[r] - hash[l - 1] * pow[r - l + 1];
+			val[l] = hash[r] - hash[l - 1] * pow[r - l + 1];
 		}
 		n = n - k + 1;
 		for (int i = 1; i <= n; i++) {
-			sorted[i] = arr[i];
+			sorted[i] = val[i];
 		}
 		Arrays.sort(sorted, 1, n + 1);
 		int len = 1;
@@ -118,7 +120,7 @@ public static void prepare() {
 			}
 		}
 		for (int i = 1; i <= n; i++) {
-			val[i] = kth(len, arr[i]);
+			arr[i] = kth(len, val[i]);
 		}
 		int blen = Math.max(1, (int) ((double) n / Math.sqrt(m)));
 		for (int i = 1; i <= n; i++) {
@@ -136,10 +138,8 @@ public static void main(String[] args) throws Exception {
 		n = in.nextInt();
 		m = in.nextInt();
 		k = in.nextInt();
-		char c;
 		for (int i = 1; i <= n; i++) {
-			c = in.nextLowerCase();
-			arr[i] = c - 'a' + 1;
+			str[i] = in.nextLowerCase();
 		}
 		for (int i = 1; i <= m; i++) {
 			query[i][0] = in.nextInt();

From 79b7038e6edcc342f99d3815b7e9c5418da7bea2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 26 Sep 2025 11:38:25 +0800
Subject: [PATCH 1432/1712] modify code

---
 src/class179/Code06_LCP1.java | 75 +++++++++++++++++------------------
 1 file changed, 37 insertions(+), 38 deletions(-)

diff --git a/src/class179/Code06_LCP1.java b/src/class179/Code06_LCP1.java
index 4a3c127ac..feefa8896 100644
--- a/src/class179/Code06_LCP1.java
+++ b/src/class179/Code06_LCP1.java
@@ -17,6 +17,7 @@ public class Code06_LCP1 {
 	public static int MAXM = 100001;
 	public static int n, m, k;
 
+	public static int len, cntq;
 	public static char[] str = new char[MAXN];
 	public static int[][] query = new int[MAXM][3];
 
@@ -33,8 +34,8 @@ public class Code06_LCP1 {
 	public static long curAns;
 	public static long[] ans = new long[MAXM];
 
-	public static int kth(int len, long num) {
-		int left = 1, right = len, mid, ret = 0;
+	public static int kth(int siz, long num) {
+		int left = 1, right = siz, mid, ret = 0;
 		while (left <= right) {
 			mid = (left + right) / 2;
 			if (sorted[mid] <= num) {
@@ -75,27 +76,23 @@ public static void del(int x) {
 
 	public static void compute() {
 		int winl = 1, winr = 0;
-		for (int i = 1; i <= m; i++) {
+		for (int i = 1; i <= cntq; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
 			int id = query[i][2];
-			if (jobl > jobr) {
-				ans[id] = 0;
-			} else {
-				while (winl > jobl) {
-					add(arr[--winl]);
-				}
-				while (winr < jobr) {
-					add(arr[++winr]);
-				}
-				while (winl < jobl) {
-					del(arr[winl++]);
-				}
-				while (winr > jobr) {
-					del(arr[winr--]);
-				}
-				ans[id] = (curAns - (jobr - jobl + 1)) / 2;
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
 			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			ans[id] = (curAns - (jobr - jobl + 1)) / 2;
 		}
 	}
 
@@ -108,28 +105,24 @@ public static void prepare() {
 		for (int l = 1, r = k; r <= n; l++, r++) {
 			val[l] = hash[r] - hash[l - 1] * pow[r - l + 1];
 		}
-		n = n - k + 1;
-		for (int i = 1; i <= n; i++) {
+		for (int i = 1; i <= len; i++) {
 			sorted[i] = val[i];
 		}
-		Arrays.sort(sorted, 1, n + 1);
-		int len = 1;
-		for (int i = 2; i <= n; i++) {
-			if (sorted[len] != sorted[i]) {
-				sorted[++len] = sorted[i];
+		Arrays.sort(sorted, 1, len + 1);
+		int cntv = 1;
+		for (int i = 2; i <= len; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
 			}
 		}
-		for (int i = 1; i <= n; i++) {
-			arr[i] = kth(len, val[i]);
+		for (int i = 1; i <= len; i++) {
+			arr[i] = kth(cntv, val[i]);
 		}
-		int blen = Math.max(1, (int) ((double) n / Math.sqrt(m)));
-		for (int i = 1; i <= n; i++) {
+		int blen = Math.max(1, (int) ((double) len / Math.sqrt(cntq)));
+		for (int i = 1; i <= len; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
-		for (int i = 1; i <= m; i++) {
-			query[i][1] = Math.min(query[i][1], n);
-		}
-		Arrays.sort(query, 1, m + 1, new QueryCmp());
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -141,10 +134,16 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			str[i] = in.nextLowerCase();
 		}
-		for (int i = 1; i <= m; i++) {
-			query[i][0] = in.nextInt();
-			query[i][1] = in.nextInt();
-			query[i][2] = i;
+		len = n - k + 1;
+		cntq = 0;
+		for (int i = 1, l, r; i <= m; i++) {
+			l = in.nextInt();
+			r = in.nextInt();
+			if (l <= len) {
+				query[++cntq][0] = l;
+				query[cntq][1] = Math.min(r, len);
+				query[cntq][2] = i;
+			}
 		}
 		prepare();
 		compute();

From 92a30669c1da8fc15a5d7dc1c601c5b7af136ead Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 27 Sep 2025 13:17:37 +0800
Subject: [PATCH 1433/1712] modify code

---
 src/class179/Code06_LCP1.java | 11 +++++------
 1 file changed, 5 insertions(+), 6 deletions(-)

diff --git a/src/class179/Code06_LCP1.java b/src/class179/Code06_LCP1.java
index feefa8896..8ddda89a6 100644
--- a/src/class179/Code06_LCP1.java
+++ b/src/class179/Code06_LCP1.java
@@ -16,8 +16,7 @@ public class Code06_LCP1 {
 	public static int MAXN = 3000001;
 	public static int MAXM = 100001;
 	public static int n, m, k;
-
-	public static int len, cntq;
+	public static int len, cntq, cntv;
 	public static char[] str = new char[MAXN];
 	public static int[][] query = new int[MAXM][3];
 
@@ -34,8 +33,8 @@ public class Code06_LCP1 {
 	public static long curAns;
 	public static long[] ans = new long[MAXM];
 
-	public static int kth(int siz, long num) {
-		int left = 1, right = siz, mid, ret = 0;
+	public static int kth(long num) {
+		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
 			mid = (left + right) / 2;
 			if (sorted[mid] <= num) {
@@ -109,14 +108,14 @@ public static void prepare() {
 			sorted[i] = val[i];
 		}
 		Arrays.sort(sorted, 1, len + 1);
-		int cntv = 1;
+		cntv = 1;
 		for (int i = 2; i <= len; i++) {
 			if (sorted[cntv] != sorted[i]) {
 				sorted[++cntv] = sorted[i];
 			}
 		}
 		for (int i = 1; i <= len; i++) {
-			arr[i] = kth(cntv, val[i]);
+			arr[i] = kth(val[i]);
 		}
 		int blen = Math.max(1, (int) ((double) len / Math.sqrt(cntq)));
 		for (int i = 1; i <= len; i++) {

From 8d45faf889b284cb66ee4f55fd82694068e76291 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 27 Sep 2025 17:00:35 +0800
Subject: [PATCH 1434/1712] modify code

---
 src/class179/Code07_RabbitHole1.java | 240 +++++++++++++++++++++++++++
 1 file changed, 240 insertions(+)
 create mode 100644 src/class179/Code07_RabbitHole1.java

diff --git a/src/class179/Code07_RabbitHole1.java b/src/class179/Code07_RabbitHole1.java
new file mode 100644
index 000000000..29a5a2957
--- /dev/null
+++ b/src/class179/Code07_RabbitHole1.java
@@ -0,0 +1,240 @@
+package class179;
+
+// 掉进兔子洞，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4688
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
+
+public class Code07_RabbitHole1 {
+
+	static class BitSet {
+
+		final int POW = 6;
+
+		final int MASK = 63;
+
+		int len;
+
+		long[] status;
+
+		public BitSet(int siz) {
+			len = (siz + MASK) >> POW;
+			status = new long[len];
+		}
+
+		public void clear() {
+			for (int i = 0; i < len; i++) {
+				status[i] = 0;
+			}
+		}
+
+		public void clone(BitSet obj) {
+			for (int i = 0; i < len; i++) {
+				status[i] = obj.status[i];
+			}
+		}
+
+		public void and(BitSet obj) {
+			for (int i = 0; i < len; i++) {
+				status[i] &= obj.status[i];
+			}
+		}
+
+		public void setOne(int bit) {
+			status[bit >> POW] |= 1L << (bit & MASK);
+		}
+
+		public void setZero(int bit) {
+			status[bit >> POW] &= ~(1L << (bit & MASK));
+		}
+
+		public int getOnes() {
+			int ret = 0;
+			for (int i = 0; i < len; i++) {
+				ret += Long.bitCount(status[i]);
+			}
+			return ret;
+		}
+	}
+
+	public static int MAXN = 100001;
+	public static int MAXT = 30001;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXT * 3][3];
+	public static int[] sorted = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	public static int[] cnt = new int[MAXN];
+	public static boolean[] hasSet = new boolean[MAXT];
+	public static BitSet[] bitSet = new BitSet[MAXT];
+	public static BitSet curSet;
+
+	public static int[] ans = new int[MAXT];
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
+			}
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
+			} else {
+				return b[1] - a[1];
+			}
+		}
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = n, mid, ret = -1;
+		while (left <= right) {
+			mid = (left + right) >> 1;
+			if (sorted[mid] >= num) {
+				ret = mid;
+				right = mid - 1;
+			} else {
+				left = mid + 1;
+			}
+		}
+		return ret;
+	}
+
+	public static void add(int x) {
+		cnt[x]++;
+		curSet.setOne(x + cnt[x] - 1);
+	}
+
+	public static void del(int x) {
+		cnt[x]--;
+		curSet.setZero(x + cnt[x]);
+	}
+
+	public static void compute(int q) {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= q; i++) {
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int id = query[i][2];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			if (!hasSet[id]) {
+				hasSet[id] = true;
+				bitSet[id].clone(curSet);
+			} else {
+				bitSet[id].and(curSet);
+			}
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		int blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i < MAXT; i++) {
+			bitSet[i] = new BitSet(n + 1);
+		}
+		curSet = new BitSet(n + 1);
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		prepare();
+		for (int t = MAXT - 1; m > 0; m -= t) {
+			int k = Math.min(m, t);
+			Arrays.fill(cnt, 1, n + 1, 0);
+			Arrays.fill(hasSet, 1, k + 1, false);
+			Arrays.fill(ans, 1, k + 1, 0);
+			curSet.clear();
+			int cntq = 0;
+			for (int i = 1; i <= k; i++) {
+				for (int j = 1; j <= 3; j++) {
+					query[++cntq][0] = in.nextInt();
+					query[cntq][1] = in.nextInt();
+					query[cntq][2] = i;
+					ans[i] += query[cntq][1] - query[cntq][0] + 1;
+				}
+			}
+			Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+			compute(cntq);
+			for (int i = 1; i <= k; i++) {
+				ans[i] -= bitSet[i].getOnes() * 3;
+			}
+			for (int i = 1; i <= k; i++) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 49035037e9cca92a9e1df5da701a74e736538090 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 27 Sep 2025 17:56:50 +0800
Subject: [PATCH 1435/1712] modify code

---
 src/class179/Code07_RabbitHole1.java | 5 +++--
 src/class179/Code08_CornField1.java  | 8 ++++++++
 2 files changed, 11 insertions(+), 2 deletions(-)
 create mode 100644 src/class179/Code08_CornField1.java

diff --git a/src/class179/Code07_RabbitHole1.java b/src/class179/Code07_RabbitHole1.java
index 29a5a2957..1b736f27b 100644
--- a/src/class179/Code07_RabbitHole1.java
+++ b/src/class179/Code07_RabbitHole1.java
@@ -34,7 +34,7 @@ public void clear() {
 			}
 		}
 
-		public void clone(BitSet obj) {
+		public void copy(BitSet obj) {
 			for (int i = 0; i < len; i++) {
 				status[i] = obj.status[i];
 			}
@@ -61,6 +61,7 @@ public int getOnes() {
 			}
 			return ret;
 		}
+
 	}
 
 	public static int MAXN = 100001;
@@ -136,7 +137,7 @@ public static void compute(int q) {
 			}
 			if (!hasSet[id]) {
 				hasSet[id] = true;
-				bitSet[id].clone(curSet);
+				bitSet[id].copy(curSet);
 			} else {
 				bitSet[id].and(curSet);
 			}
diff --git a/src/class179/Code08_CornField1.java b/src/class179/Code08_CornField1.java
new file mode 100644
index 000000000..905bdd8ff
--- /dev/null
+++ b/src/class179/Code08_CornField1.java
@@ -0,0 +1,8 @@
+package class179;
+
+// 由乃的玉米田，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5355
+
+public class Code08_CornField1 {
+
+}

From 12f00242a375479c99f7ecd90a1c401c035c0ea8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 27 Sep 2025 21:49:34 +0800
Subject: [PATCH 1436/1712] modify code

---
 src/class179/Code07_RabbitHole1.java |  12 +-
 src/class179/Code08_CornField1.java  | 303 +++++++++++++++++++++++++++
 2 files changed, 306 insertions(+), 9 deletions(-)

diff --git a/src/class179/Code07_RabbitHole1.java b/src/class179/Code07_RabbitHole1.java
index 1b736f27b..03a2115a2 100644
--- a/src/class179/Code07_RabbitHole1.java
+++ b/src/class179/Code07_RabbitHole1.java
@@ -14,17 +14,11 @@
 public class Code07_RabbitHole1 {
 
 	static class BitSet {
-
-		final int POW = 6;
-
-		final int MASK = 63;
-
 		int len;
-
 		long[] status;
 
 		public BitSet(int siz) {
-			len = (siz + MASK) >> POW;
+			len = (siz + 63) >> 6;
 			status = new long[len];
 		}
 
@@ -47,11 +41,11 @@ public void and(BitSet obj) {
 		}
 
 		public void setOne(int bit) {
-			status[bit >> POW] |= 1L << (bit & MASK);
+			status[bit >> 6] |= 1L << (bit & 63);
 		}
 
 		public void setZero(int bit) {
-			status[bit >> POW] &= ~(1L << (bit & MASK));
+			status[bit >> 6] &= ~(1L << (bit & 63));
 		}
 
 		public int getOnes() {
diff --git a/src/class179/Code08_CornField1.java b/src/class179/Code08_CornField1.java
index 905bdd8ff..7c0ccdf84 100644
--- a/src/class179/Code08_CornField1.java
+++ b/src/class179/Code08_CornField1.java
@@ -2,7 +2,310 @@
 
 // 由乃的玉米田，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5355
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+import java.util.Comparator;
 
 public class Code08_CornField1 {
 
+	static class BitSet {
+		int len;
+		long[] status;
+
+		public BitSet(int siz) {
+			len = (siz + 63) >> 6;
+			status = new long[len];
+		}
+
+		public void setOne(int bit) {
+			status[bit >> 6] |= 1L << (bit & 63);
+		}
+
+		public void setZero(int bit) {
+			status[bit >> 6] &= ~(1L << (bit & 63));
+		}
+
+		public boolean status(int bit) {
+			return ((status[bit >> 6] >> (bit & 63)) & 1L) != 0L;
+		}
+
+		public boolean andOther(BitSet other) {
+			for (int i = 0; i < len; i++) {
+				if ((status[i] & other.status[i]) != 0L) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+		// 检查 自己 & 自己左移k位 是否有非零位
+		public boolean andSelfMoveLeft(int k) {
+			int ws = k >> 6;
+			int bs = k & 63;
+			for (int i = len - 1; i >= 0; i--) {
+				int src = i - ws;
+				if (src < 0) {
+					break;
+				}
+				long shifted = (status[src] << bs);
+				if (bs != 0 && src - 1 >= 0) {
+					shifted |= (status[src - 1] >>> (64 - bs));
+				}
+				if ((status[i] & shifted) != 0L) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+		// 检查 自己 & other右移k位 是否有非零位
+		public boolean andOtherMoveRight(BitSet other, int k) {
+			int ws = k >> 6;
+			int bs = k & 63;
+			for (int i = 0; i < len; i++) {
+				int src = i + ws;
+				if (src >= len) {
+					break;
+				}
+				long shifted = (other.status[src] >>> bs);
+				if (bs != 0 && src + 1 < len) {
+					shifted |= (other.status[src + 1] << (64 - bs));
+				}
+				if ((status[i] & shifted) != 0L) {
+					return true;
+				}
+			}
+			return false;
+		}
+
+	}
+
+	public static int MAXN = 100001;
+	public static int MAXV = 100000;
+	public static int MAXB = 401;
+	public static int n, m, blen;
+	public static int[] arr = new int[MAXN];
+	public static int[] bi = new int[MAXN];
+
+	// 普通查询，op、l、r、x、id
+	public static int[][] query = new int[MAXN][5];
+	public static int cntq;
+
+	// 特别查询，l、r、id
+	public static int[] headq = new int[MAXB];
+	public static int[] nextq = new int[MAXN];
+	public static int[] ql = new int[MAXN];
+	public static int[] qr = new int[MAXN];
+	public static int[] qid = new int[MAXN];
+	public static int cnts;
+
+	public static BitSet bitSet1 = new BitSet(MAXN);
+	public static BitSet bitSet2 = new BitSet(MAXN);
+
+	public static int[] cnt = new int[MAXN];
+	public static int[] pre = new int[MAXN];
+	public static int[] maxLeft = new int[MAXN];
+
+	public static boolean[] ans = new boolean[MAXN];
+
+	public static void addSpecial(int x, int l, int r, int id) {
+		nextq[++cnts] = headq[x];
+		headq[x] = cnts;
+		ql[cnts] = l;
+		qr[cnts] = r;
+		qid[cnts] = id;
+	}
+
+	public static class QueryCmp implements Comparator<int[]> {
+		@Override
+		public int compare(int[] a, int[] b) {
+			if (bi[a[1]] != bi[b[1]]) {
+				return bi[a[1]] - bi[b[1]];
+			}
+			if ((bi[a[1]] & 1) == 1) {
+				return a[2] - b[2];
+			} else {
+				return b[2] - a[2];
+			}
+		}
+	}
+
+	public static void add(int x) {
+		cnt[x]++;
+		if (cnt[x] == 1) {
+			bitSet1.setOne(x);
+			bitSet2.setOne(MAXV - x);
+		}
+	}
+
+	public static void del(int x) {
+		cnt[x]--;
+		if (cnt[x] == 0) {
+			bitSet1.setZero(x);
+			bitSet2.setZero(MAXV - x);
+		}
+	}
+
+	public static boolean getAns(int op, int x) {
+		if (op == 1) {
+			return bitSet1.andSelfMoveLeft(x);
+		} else if (op == 2) {
+			return bitSet1.andOtherMoveRight(bitSet2, MAXV - x);
+		} else if (op == 3) {
+			for (int d = 1; d * d <= x; d++) {
+				if (x % d == 0) {
+					if (bitSet1.status(d) && bitSet1.status(x / d)) {
+						return true;
+					}
+				}
+			}
+			return false;
+		} else {
+			if (x >= 1) {
+				for (int i = 1; i * x <= MAXV; i++) {
+					if (bitSet1.status(i) && bitSet1.status(i * x)) {
+						return true;
+					}
+				}
+			}
+			return false;
+		}
+	}
+
+	public static void compute() {
+		int winl = 1, winr = 0;
+		for (int i = 1; i <= cntq; i++) {
+			int op = query[i][0];
+			int jobl = query[i][1];
+			int jobr = query[i][2];
+			int jobx = query[i][3];
+			int id = query[i][4];
+			while (winl > jobl) {
+				add(arr[--winl]);
+			}
+			while (winr < jobr) {
+				add(arr[++winr]);
+			}
+			while (winl < jobl) {
+				del(arr[winl++]);
+			}
+			while (winr > jobr) {
+				del(arr[winr--]);
+			}
+			ans[id] = getAns(op, jobx);
+		}
+	}
+
+	public static void special() {
+		for (int x = 1; x < blen; x++) {
+			if (headq[x] != 0) {
+				Arrays.fill(pre, 0);
+				Arrays.fill(maxLeft, 0);
+				int last = 0;
+				for (int i = 1; i <= n; i++) {
+					int val = arr[i];
+					pre[val] = i;
+					if (val * x <= MAXV) {
+						last = Math.max(last, pre[val * x]);
+					}
+					if (val % x == 0) {
+						last = Math.max(last, pre[val / x]);
+					}
+					maxLeft[i] = last;
+				}
+				for (int q = headq[x]; q > 0; q = nextq[q]) {
+					int l = ql[q];
+					int r = qr[q];
+					int id = qid[q];
+					ans[id] = l <= maxLeft[r];
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		blen = (int) Math.sqrt(n);
+		for (int i = 1; i <= n; i++) {
+			bi[i] = (i - 1) / blen + 1;
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1, op, l, r, x; i <= m; i++) {
+			op = in.nextInt();
+			l = in.nextInt();
+			r = in.nextInt();
+			x = in.nextInt();
+			if (op == 4 && x < blen) {
+				addSpecial(x, l, r, i);
+			} else {
+				query[++cntq][0] = op;
+				query[cntq][1] = l;
+				query[cntq][2] = r;
+				query[cntq][3] = x;
+				query[cntq][4] = i;
+			}
+		}
+		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
+		compute();
+		special();
+		for (int i = 1; i <= m; i++) {
+			if (ans[i]) {
+				out.println("yuno");
+			} else {
+				out.println("yumi");
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }

From 7b59d0f474ef6ae3a25deddaff3fa068dd8eeecf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 27 Sep 2025 21:52:38 +0800
Subject: [PATCH 1437/1712] modify code

---
 src/class179/Code08_CornField1.java | 10 +++++-----
 1 file changed, 5 insertions(+), 5 deletions(-)

diff --git a/src/class179/Code08_CornField1.java b/src/class179/Code08_CornField1.java
index 7c0ccdf84..8ebc21cb6 100644
--- a/src/class179/Code08_CornField1.java
+++ b/src/class179/Code08_CornField1.java
@@ -108,7 +108,7 @@ public boolean andOtherMoveRight(BitSet other, int k) {
 	public static BitSet bitSet2 = new BitSet(MAXN);
 
 	public static int[] cnt = new int[MAXN];
-	public static int[] pre = new int[MAXN];
+	public static int[] lastPos = new int[MAXN];
 	public static int[] maxLeft = new int[MAXN];
 
 	public static boolean[] ans = new boolean[MAXN];
@@ -204,17 +204,17 @@ public static void compute() {
 	public static void special() {
 		for (int x = 1; x < blen; x++) {
 			if (headq[x] != 0) {
-				Arrays.fill(pre, 0);
+				Arrays.fill(lastPos, 0);
 				Arrays.fill(maxLeft, 0);
 				int last = 0;
 				for (int i = 1; i <= n; i++) {
 					int val = arr[i];
-					pre[val] = i;
+					lastPos[val] = i;
 					if (val * x <= MAXV) {
-						last = Math.max(last, pre[val * x]);
+						last = Math.max(last, lastPos[val * x]);
 					}
 					if (val % x == 0) {
-						last = Math.max(last, pre[val / x]);
+						last = Math.max(last, lastPos[val / x]);
 					}
 					maxLeft[i] = last;
 				}

From dfc8d68f18bed083ee7ef47a2d01b43c6389002f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 27 Sep 2025 21:56:04 +0800
Subject: [PATCH 1438/1712] modify code

---
 .../{Code08_CornField1.java => Code08_YnoiCornfield1.java}      | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/class179/{Code08_CornField1.java => Code08_YnoiCornfield1.java} (99%)

diff --git a/src/class179/Code08_CornField1.java b/src/class179/Code08_YnoiCornfield1.java
similarity index 99%
rename from src/class179/Code08_CornField1.java
rename to src/class179/Code08_YnoiCornfield1.java
index 8ebc21cb6..6274f954b 100644
--- a/src/class179/Code08_CornField1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -11,7 +11,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code08_CornField1 {
+public class Code08_YnoiCornfield1 {
 
 	static class BitSet {
 		int len;

From 35cf1733992a0087a00d8127ad1bdc91fbd0b520 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 27 Sep 2025 22:03:18 +0800
Subject: [PATCH 1439/1712] modify code

---
 .../{Code04_SubsequenceSum1.java => Code04_NotForget1.java} | 6 +++---
 .../{Code04_SubsequenceSum2.java => Code04_NotForget2.java} | 2 +-
 2 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class179/{Code04_SubsequenceSum1.java => Code04_NotForget1.java} (96%)
 rename src/class179/{Code04_SubsequenceSum2.java => Code04_NotForget2.java} (99%)

diff --git a/src/class179/Code04_SubsequenceSum1.java b/src/class179/Code04_NotForget1.java
similarity index 96%
rename from src/class179/Code04_SubsequenceSum1.java
rename to src/class179/Code04_NotForget1.java
index 105426317..fdcaa0032 100644
--- a/src/class179/Code04_SubsequenceSum1.java
+++ b/src/class179/Code04_NotForget1.java
@@ -1,10 +1,10 @@
 package class179;
 
-// 区间子序列的和，java版
+// 盼君勿忘，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5072
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code04_SubsequenceSum2文件就是C++的实现
+// 想通过用C++实现，本节课Code04_NotForget2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code04_SubsequenceSum1 {
+public class Code04_NotForget1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 401;
diff --git a/src/class179/Code04_SubsequenceSum2.java b/src/class179/Code04_NotForget2.java
similarity index 99%
rename from src/class179/Code04_SubsequenceSum2.java
rename to src/class179/Code04_NotForget2.java
index 9645e270d..e56e4220c 100644
--- a/src/class179/Code04_SubsequenceSum2.java
+++ b/src/class179/Code04_NotForget2.java
@@ -1,6 +1,6 @@
 package class179;
 
-// 区间子序列的和，C++版
+// 盼君勿忘，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P5072
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From ee0927efafc9b31b4489e61d4518cfed8ae6cb8d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 28 Sep 2025 09:10:06 +0800
Subject: [PATCH 1440/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 30 ++++++++++++-------------
 1 file changed, 15 insertions(+), 15 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index 6274f954b..328cc80d2 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -92,11 +92,11 @@ public boolean andOtherMoveRight(BitSet other, int k) {
 	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
 
-	// 普通查询，op、l、r、x、id
+	// 普通查询，l、r、x、op、id
 	public static int[][] query = new int[MAXN][5];
 	public static int cntq;
 
-	// 特别查询，l、r、id
+	// 特别查询，x的问题列表 : l、r、id
 	public static int[] headq = new int[MAXB];
 	public static int[] nextq = new int[MAXN];
 	public static int[] ql = new int[MAXN];
@@ -124,13 +124,13 @@ public static void addSpecial(int x, int l, int r, int id) {
 	public static class QueryCmp implements Comparator<int[]> {
 		@Override
 		public int compare(int[] a, int[] b) {
-			if (bi[a[1]] != bi[b[1]]) {
-				return bi[a[1]] - bi[b[1]];
+			if (bi[a[0]] != bi[b[0]]) {
+				return bi[a[0]] - bi[b[0]];
 			}
-			if ((bi[a[1]] & 1) == 1) {
-				return a[2] - b[2];
+			if ((bi[a[0]] & 1) == 1) {
+				return a[1] - b[1];
 			} else {
-				return b[2] - a[2];
+				return b[1] - a[1];
 			}
 		}
 	}
@@ -180,10 +180,10 @@ public static boolean getAns(int op, int x) {
 	public static void compute() {
 		int winl = 1, winr = 0;
 		for (int i = 1; i <= cntq; i++) {
-			int op = query[i][0];
-			int jobl = query[i][1];
-			int jobr = query[i][2];
-			int jobx = query[i][3];
+			int jobl = query[i][0];
+			int jobr = query[i][1];
+			int jobx = query[i][2];
+			int op = query[i][3];
 			int id = query[i][4];
 			while (winl > jobl) {
 				add(arr[--winl]);
@@ -248,10 +248,10 @@ public static void main(String[] args) throws Exception {
 			if (op == 4 && x < blen) {
 				addSpecial(x, l, r, i);
 			} else {
-				query[++cntq][0] = op;
-				query[cntq][1] = l;
-				query[cntq][2] = r;
-				query[cntq][3] = x;
+				query[++cntq][0] = l;
+				query[cntq][1] = r;
+				query[cntq][2] = x;
+				query[cntq][3] = op;
 				query[cntq][4] = i;
 			}
 		}

From 7cd4b8d7434b5817f7b3bcd37889c6bc95d23a05 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 28 Sep 2025 09:11:58 +0800
Subject: [PATCH 1441/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index 328cc80d2..fc0d7b3d2 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -151,7 +151,7 @@ public static void del(int x) {
 		}
 	}
 
-	public static boolean getAns(int op, int x) {
+	public static boolean calc(int op, int x) {
 		if (op == 1) {
 			return bitSet1.andSelfMoveLeft(x);
 		} else if (op == 2) {
@@ -197,7 +197,7 @@ public static void compute() {
 			while (winr > jobr) {
 				del(arr[winr--]);
 			}
-			ans[id] = getAns(op, jobx);
+			ans[id] = calc(op, jobx);
 		}
 	}
 

From 38b512b04db2931c7b934a4ef492bdeee96eb0af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 29 Sep 2025 15:18:50 +0800
Subject: [PATCH 1442/1712] modify code

---
 src/class179/Code01_MaximumMatch2.java | 155 +++++++++++++++++++++++++
 src/class179/Code02_SimpleQuery2.java  | 107 +++++++++++++++++
 src/class179/Code05_Homework2.java     | 142 ++++++++++++++++++++++
 src/class179/Code06_LCP1.java          |  12 +-
 src/class179/Code06_LCP2.java          | 150 ++++++++++++++++++++++++
 5 files changed, 560 insertions(+), 6 deletions(-)
 create mode 100644 src/class179/Code01_MaximumMatch2.java
 create mode 100644 src/class179/Code02_SimpleQuery2.java
 create mode 100644 src/class179/Code05_Homework2.java
 create mode 100644 src/class179/Code06_LCP2.java

diff --git a/src/class179/Code01_MaximumMatch2.java b/src/class179/Code01_MaximumMatch2.java
new file mode 100644
index 000000000..8c0314e8b
--- /dev/null
+++ b/src/class179/Code01_MaximumMatch2.java
@@ -0,0 +1,155 @@
+package class179;
+
+// 区间最大匹配，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4477
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 152502;
+//const int MAXM = 52502;
+//const int MAXQ = 52502;
+//int n, m, z, q;
+//int a[MAXN];
+//int b[MAXM];
+//Query querys[MAXQ];
+//int bi[MAXM];
+//
+//int match[MAXN << 2];
+//int resta[MAXN << 2];
+//int overb[MAXN << 2];
+//
+//int ans[MAXQ];
+//
+//bool QueryCmp(Query &A, Query &B) {
+//    if (bi[A.l] != bi[B.l]) {
+//        return bi[A.l] < bi[B.l];
+//    }
+//    if ((bi[A.l] & 1) == 1) {
+//        return A.r < B.r;
+//    } else {
+//        return A.r > B.r;
+//    }
+//}
+//
+//void up(int i) {
+//    int l = i << 1;
+//    int r = i << 1 | 1;
+//    int newMatch = min(resta[l], overb[r]);
+//    resta[i] = resta[l] + resta[r] - newMatch;
+//    overb[i] = overb[l] + overb[r] - newMatch;
+//    match[i] = match[l] + match[r] + newMatch;
+//}
+//
+//void build(int l, int r, int i) {
+//    if (l == r) {
+//    	match[i] = 0;
+//        resta[i] = 1;
+//        overb[i] = 0;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        build(l, mid, i << 1);
+//        build(mid + 1, r, i << 1 | 1);
+//        up(i);
+//    }
+//}
+//
+//void add(int jobv, int l, int r, int i) {
+//    if (l == r) {
+//        if (resta[i] == 1) {
+//        	match[i] = 1;
+//            resta[i] = 0;
+//        } else {
+//            overb[i]++;
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobv + a[mid + 1] <= z) {
+//            add(jobv, mid + 1, r, i << 1 | 1);
+//        } else if (jobv + a[l] <= z) {
+//            add(jobv, l, mid, i << 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//void del(int jobv, int l, int r, int i) {
+//    if (l == r) {
+//        if (overb[i] == 0) {
+//        	match[i] = 0;
+//            resta[i] = 1;
+//        } else {
+//            overb[i]--;
+//        }
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobv + a[mid + 1] <= z) {
+//            del(jobv, mid + 1, r, i << 1 | 1);
+//        } else if (jobv + a[l] <= z) {
+//            del(jobv, l, mid, i << 1);
+//        }
+//        up(i);
+//    }
+//}
+//
+//void prepare() {
+//    sort(a + 1, a + n + 1);
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= m; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(querys + 1, querys + q + 1, QueryCmp);
+//    build(1, n, 1);
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= q; i++) {
+//        int jobl = querys[i].l;
+//        int jobr = querys[i].r;
+//        int id   = querys[i].id;
+//        while (winl > jobl) {
+//            add(b[--winl], 1, n, 1);
+//        }
+//        while (winr < jobr) {
+//            add(b[++winr], 1, n, 1);
+//        }
+//        while (winl < jobl) {
+//            del(b[winl++], 1, n, 1);
+//        }
+//        while (winr > jobr) {
+//            del(b[winr--], 1, n, 1);
+//        }
+//        ans[id] = match[1];
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> z;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> a[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> b[i];
+//    }
+//    cin >> q;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> querys[i].l >> querys[i].r;
+//        querys[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= q; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class179/Code02_SimpleQuery2.java b/src/class179/Code02_SimpleQuery2.java
new file mode 100644
index 000000000..ae8a3a31c
--- /dev/null
+++ b/src/class179/Code02_SimpleQuery2.java
@@ -0,0 +1,107 @@
+package class179;
+
+// 简单的询问，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5268
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int siz1, siz2, op, id;
+//};
+//
+//const int MAXN = 50001;
+//int n, m, cntq;
+//int arr[MAXN];
+//Query query[MAXN << 2];
+//
+//int bi[MAXN];
+//int cnt1[MAXN];
+//int cnt2[MAXN];
+//
+//long long sumv = 0;
+//long long ans[MAXN];
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.siz1] != bi[b.siz1]) {
+//        return bi[a.siz1] < bi[b.siz1];
+//    }
+//    if ((bi[a.siz1] & 1) == 1) {
+//        return a.siz2 < b.siz2;
+//    } else {
+//        return a.siz2 > b.siz2;
+//    }
+//}
+//
+//void addQuery(int siz1, int siz2, int op, int id) {
+//    query[++cntq].siz1 = siz1;
+//    query[cntq].siz2 = siz2;
+//    query[cntq].op = op;
+//    query[cntq].id = id;
+//}
+//
+//void compute() {
+//    int win1 = 0, win2 = 0;
+//    for (int i = 1; i <= cntq; i++) {
+//        int job1 = query[i].siz1;
+//        int job2 = query[i].siz2;
+//        int op = query[i].op;
+//        int id = query[i].id;
+//        while (win1 < job1) {
+//            ++cnt1[arr[++win1]];
+//            sumv += cnt2[arr[win1]];
+//        }
+//        while (win1 > job1) {
+//            --cnt1[arr[win1]];
+//            sumv -= cnt2[arr[win1--]];
+//        }
+//        while (win2 < job2) {
+//            ++cnt2[arr[++win2]];
+//            sumv += cnt1[arr[win2]];
+//        }
+//        while (win2 > job2) {
+//            --cnt2[arr[win2]];
+//            sumv -= cnt1[arr[win2--]];
+//        }
+//        ans[id] += sumv * op;
+//    }
+//}
+//
+//void prepare() {
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= cntq; i++) {
+//        if (query[i].siz1 > query[i].siz2) {
+//            swap(query[i].siz1, query[i].siz2);
+//        }
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    cin >> m;
+//    for (int i = 1, l1, r1, l2, r2; i <= m; i++) {
+//        cin >> l1 >> r1 >> l2 >> r2;
+//        addQuery(r1, r2, 1, i);
+//        addQuery(r1, l2 - 1, -1, i);
+//        addQuery(l1 - 1, r2, -1, i);
+//        addQuery(l1 - 1, l2 - 1, 1, i);
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class179/Code05_Homework2.java b/src/class179/Code05_Homework2.java
new file mode 100644
index 000000000..54a378763
--- /dev/null
+++ b/src/class179/Code05_Homework2.java
@@ -0,0 +1,142 @@
+package class179;
+
+// 作业，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4396
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, a, b, id;
+//};
+//
+//const int MAXN = 100001;
+//
+//int n, m;
+//int arr[MAXN];
+//Query query[MAXN];
+//int bi[MAXN];
+//int bl[MAXN];
+//int br[MAXN];
+//
+//int numCnt[MAXN];
+//int blockCnt[MAXN];
+//int blockKind[MAXN];
+//
+//int ans1[MAXN];
+//int ans2[MAXN];
+//
+//bool QueryCmp(Query &A, Query &B) {
+//    if (bi[A.l] != bi[B.l]) {
+//        return bi[A.l] < bi[B.l];
+//    }
+//    if ((bi[A.l] & 1) == 1) {
+//        return A.r < B.r;
+//    } else {
+//        return A.r > B.r;
+//    }
+//}
+//
+//void add(int x) {
+//    numCnt[x]++;
+//    blockCnt[bi[x]]++;
+//    if (numCnt[x] == 1) {
+//        blockKind[bi[x]]++;
+//    }
+//}
+//
+//void del(int x) {
+//    numCnt[x]--;
+//    blockCnt[bi[x]]--;
+//    if (numCnt[x] == 0) {
+//        blockKind[bi[x]]--;
+//    }
+//}
+//
+//void setAns(int a, int b, int id) {
+//    if (bi[a] == bi[b]) {
+//        for (int i = a; i <= b; i++) {
+//            if (numCnt[i] > 0) {
+//                ans1[id] += numCnt[i];
+//                ans2[id]++;
+//            }
+//        }
+//    } else {
+//        for (int i = a; i <= br[bi[a]]; i++) {
+//            if (numCnt[i] > 0) {
+//                ans1[id] += numCnt[i];
+//                ans2[id]++;
+//            }
+//        }
+//        for (int i = bl[bi[b]]; i <= b; i++) {
+//            if (numCnt[i] > 0) {
+//                ans1[id] += numCnt[i];
+//                ans2[id]++;
+//            }
+//        }
+//        for (int i = bi[a] + 1; i <= bi[b] - 1; i++) {
+//            ans1[id] += blockCnt[i];
+//            ans2[id] += blockKind[i];
+//        }
+//    }
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int joba = query[i].a;
+//        int jobb = query[i].b;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        setAns(joba, jobb, id);
+//    }
+//}
+//
+//void prepare() {
+//    int nv = MAXN - 1;
+//    int blen = (int)sqrt(nv);
+//    int bnum = (nv + blen - 1) / blen;
+//    for (int i = 1; i <= nv; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= bnum; i++) {
+//        bl[i] = (i - 1) * blen + 1;
+//        br[i] = min(i * blen, nv);
+//    }
+//    sort(query + 1, query + m + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i].l >> query[i].r >> query[i].a >> query[i].b;
+//        query[i].id = i;
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans1[i] << ' ' << ans2[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class179/Code06_LCP1.java b/src/class179/Code06_LCP1.java
index 8ddda89a6..f77ceb91b 100644
--- a/src/class179/Code06_LCP1.java
+++ b/src/class179/Code06_LCP1.java
@@ -21,8 +21,8 @@ public class Code06_LCP1 {
 	public static int[][] query = new int[MAXM][3];
 
 	public static int base = 499;
-	public static long[] pow = new long[MAXN];
-	public static long[] hash = new long[MAXN];
+	public static long[] basePower = new long[MAXN];
+	public static long[] hashValue = new long[MAXN];
 
 	public static long[] val = new long[MAXN];
 	public static long[] sorted = new long[MAXN];
@@ -96,13 +96,13 @@ public static void compute() {
 	}
 
 	public static void prepare() {
-		pow[0] = 1;
+		basePower[0] = 1;
 		for (int i = 1; i <= n; i++) {
-			pow[i] = pow[i - 1] * base;
-			hash[i] = hash[i - 1] * base + (str[i] - 'a' + 1);
+			basePower[i] = basePower[i - 1] * base;
+			hashValue[i] = hashValue[i - 1] * base + (str[i] - 'a' + 1);
 		}
 		for (int l = 1, r = k; r <= n; l++, r++) {
-			val[l] = hash[r] - hash[l - 1] * pow[r - l + 1];
+			val[l] = hashValue[r] - hashValue[l - 1] * basePower[r - l + 1];
 		}
 		for (int i = 1; i <= len; i++) {
 			sorted[i] = val[i];
diff --git a/src/class179/Code06_LCP2.java b/src/class179/Code06_LCP2.java
new file mode 100644
index 000000000..fa564f938
--- /dev/null
+++ b/src/class179/Code06_LCP2.java
@@ -0,0 +1,150 @@
+package class179;
+
+// 区间LCP达标对，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5112
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 3000001;
+//const int MAXM = 100001;
+//int n, m, k;
+//int len, cntq, cntv;
+//char str[MAXN];
+//Query query[MAXM];
+//
+//int base = 499;
+//long long basePower[MAXN];
+//long long hashValue[MAXN];
+//
+//long long val[MAXN];
+//long long sorted[MAXN];
+//int arr[MAXN];
+//int bi[MAXN];
+//
+//long long cnt[MAXN];
+//long long curAns;
+//long long ans[MAXM];
+//
+//int kth(long long num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    } else {
+//        return a.r > b.r;
+//    }
+//}
+//
+//void add(int x) {
+//    curAns -= cnt[x] * cnt[x];
+//    cnt[x]++;
+//    curAns += cnt[x] * cnt[x];
+//}
+//
+//void del(int x) {
+//    curAns -= cnt[x] * cnt[x];
+//    cnt[x]--;
+//    curAns += cnt[x] * cnt[x];
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= cntq; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id   = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        ans[id] = (curAns - (jobr - jobl + 1)) / 2;
+//    }
+//}
+//
+//void prepare() {
+//	basePower[0] = 1;
+//    for (int i = 1; i <= n; i++) {
+//    	basePower[i] = basePower[i - 1] * base;
+//    	hashValue[i] = hashValue[i - 1] * base + (str[i] - 'a' + 1);
+//    }
+//    for (int l = 1, r = k; r <= n; l++, r++) {
+//        val[l] = hashValue[r] - hashValue[l - 1] * basePower[r - l + 1];
+//    }
+//    for (int i = 1; i <= len; i++) {
+//    	sorted[i] = val[i];
+//    }
+//    sort(sorted + 1, sorted + len + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (sorted[cntv] != sorted[i]) {
+//        	sorted[++cntv] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= len; i++) {
+//        arr[i] = kth(val[i]);
+//    }
+//    int blen = max(1, (int)((double)len / sqrt((double)cntq)));
+//    for (int i = 1; i <= len; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m >> k;
+//    string s;
+//    s.reserve(n);
+//    cin >> s;
+//    for (int i = 1; i <= n; i++) {
+//    	str[i] = s[i - 1];
+//    }
+//    len = n - k + 1;
+//    cntq = 0;
+//    for (int i = 1, l, r; i <= m; i++) {
+//        cin >> l >> r;
+//        if (l <= len) {
+//            query[++cntq].l = l;
+//            query[cntq].r = min(r, len);
+//            query[cntq].id = i;
+//        }
+//    }
+//    prepare();
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From c1130cc477d33edb2f5de19f818e65b37425edc9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 29 Sep 2025 15:32:22 +0800
Subject: [PATCH 1443/1712] modify code

---
 src/class179/Code07_RabbitHole2.java | 140 +++++++++++++++++++++++++++
 1 file changed, 140 insertions(+)
 create mode 100644 src/class179/Code07_RabbitHole2.java

diff --git a/src/class179/Code07_RabbitHole2.java b/src/class179/Code07_RabbitHole2.java
new file mode 100644
index 000000000..30cc835f3
--- /dev/null
+++ b/src/class179/Code07_RabbitHole2.java
@@ -0,0 +1,140 @@
+package class179;
+
+// 掉进兔子洞，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4688
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, id;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXT = 30001;
+//int n, m;
+//int arr[MAXN];
+//int sorted[MAXN];
+//int bi[MAXN];
+//
+//int cnt[MAXN];
+//bool hasSet[MAXT];
+//bitset<MAXN> bitSet[MAXT];
+//bitset<MAXN> curSet;
+//
+//Query query[MAXT * 3];
+//
+//int ans[MAXT];
+//
+//int kth(int num) {
+//    int left = 1, right = n, ret = -1;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] >= num) {
+//            ret = mid;
+//            right = mid - 1;
+//        } else {
+//            left = mid + 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//bool QueryCmp(const Query& a, const Query& b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if ((bi[a.l] & 1) == 1) {
+//        return a.r < b.r;
+//    } else {
+//    	return a.r > b.r;
+//    }
+//}
+//
+//void add(int x) {
+//    cnt[x]++;
+//    curSet[x + cnt[x] - 1] = 1;
+//}
+//
+//void del(int x) {
+//    cnt[x]--;
+//    curSet[x + cnt[x]] = 0;
+//}
+//
+//void compute(int q) {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= q; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        if (!hasSet[id]) {
+//            hasSet[id] = true;
+//            bitSet[id] = curSet;
+//        } else {
+//            bitSet[id] &= curSet;
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//    	sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    int blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    prepare();
+//    for (int t = MAXT - 1; m > 0; m -= t) {
+//        int k = min(m, t);
+//        memset(cnt, 0, sizeof(int) * (n + 2));
+//        memset(hasSet, 0, sizeof(bool) * (k + 2));
+//        memset(ans, 0, sizeof(int) * (k + 2));
+//        curSet.reset();
+//        int cntq = 0, l, r;
+//        for (int i = 1; i <= k; i++) {
+//            for (int j = 1; j <= 3; j++) {
+//                cin >> l >> r;
+//                query[++cntq] = { l, r, i };
+//                ans[i] += r - l + 1;
+//            }
+//        }
+//        sort(query + 1, query + cntq + 1, QueryCmp);
+//        compute(cntq);
+//        for (int i = 1; i <= k; i++) {
+//            ans[i] -= bitSet[i].count() * 3;
+//        }
+//        for (int i = 1; i <= k; i++) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 957f55286897562c452b77aee9d5827843a105d4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 29 Sep 2025 15:47:17 +0800
Subject: [PATCH 1444/1712] modify code

---
 src/class179/Code08_YnoiCornfield2.java | 173 ++++++++++++++++++++++++
 1 file changed, 173 insertions(+)
 create mode 100644 src/class179/Code08_YnoiCornfield2.java

diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
new file mode 100644
index 000000000..8096154d5
--- /dev/null
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -0,0 +1,173 @@
+package class179;
+
+// 由乃的玉米田，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5355
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Query {
+//    int l, r, x, op, id;
+//};
+//
+//const int MAXN = 100001;
+//const int MAXV = 100000;
+//const int MAXB = 401;
+//int n, m, blen;
+//int arr[MAXN];
+//int bi[MAXN];
+//
+//Query query[MAXN];
+//int cntq = 0;
+//
+//int headq[MAXB];
+//int nextq[MAXN];
+//int ql[MAXN];
+//int qr[MAXN];
+//int qid[MAXN];
+//int cnts = 0;
+//
+//bitset<MAXN> bitSet1;
+//bitset<MAXN> bitSet2;
+//
+//int cnt[MAXN];
+//int lastPos[MAXN];
+//int maxLeft[MAXN];
+//
+//bool ans[MAXN];
+//
+//void addSpecial(int x, int l, int r, int id) {
+//    nextq[++cnts] = headq[x];
+//    headq[x] = cnts;
+//    ql[cnts] = l;
+//    qr[cnts] = r;
+//    qid[cnts] = id;
+//}
+//
+//bool QueryCmp(const Query &a, const Query &b) {
+//    if (bi[a.l] != bi[b.l]) return bi[a.l] < bi[b.l];
+//    if ((bi[a.l] & 1) == 1) return a.r < b.r;
+//    return a.r > b.r;
+//}
+//
+//void add(int x) {
+//    cnt[x]++;
+//    if (cnt[x] == 1) {
+//        bitSet1[x] = 1;
+//        bitSet2[MAXV - x] = 1;
+//    }
+//}
+//
+//void del(int x) {
+//    cnt[x]--;
+//    if (cnt[x] == 0) {
+//        bitSet1[x] = 0;
+//        bitSet2[MAXV - x] = 0;
+//    }
+//}
+//
+//bool calc(int op, int x) {
+//    if (op == 1) {
+//        return (bitSet1 & (bitSet1 << x)).any();
+//    } else if (op == 2) {
+//        return (bitSet1 & (bitSet2 >> (MAXV - x))).any();
+//    } else if (op == 3) {
+//        for (int d = 1; d * d <= x; d++) {
+//            if (x % d == 0) {
+//                if (bitSet1[d] && bitSet1[x / d]) {
+//                    return true;
+//                }
+//            }
+//        }
+//        return false;
+//    } else {
+//        for (int i = 1; i * x <= MAXV; i++) {
+//            if (bitSet1[i] && bitSet1[i * x]) {
+//                return true;
+//            }
+//        }
+//        return false;
+//    }
+//}
+//
+//void compute() {
+//    int winl = 1, winr = 0;
+//    for (int i = 1; i <= cntq; i++) {
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int jobx = query[i].x;
+//        int op = query[i].op;
+//        int id = query[i].id;
+//        while (winl > jobl) {
+//            add(arr[--winl]);
+//        }
+//        while (winr < jobr) {
+//            add(arr[++winr]);
+//        }
+//        while (winl < jobl) {
+//            del(arr[winl++]);
+//        }
+//        while (winr > jobr) {
+//            del(arr[winr--]);
+//        }
+//        ans[id] = calc(op, jobx);
+//    }
+//}
+//
+//void special() {
+//    for (int x = 1; x < blen; x++) {
+//        if (headq[x] != 0) {
+//            memset(lastPos, 0, sizeof(int) * (MAXV + 1));
+//            memset(maxLeft, 0, sizeof(int) * (n + 1));
+//            int last = 0;
+//            for (int i = 1; i <= n; i++) {
+//                int val = arr[i];
+//                lastPos[val] = i;
+//                if (1LL * val * x <= MAXV) {
+//                    last = max(last, lastPos[val * x]);
+//                }
+//                if (val % x == 0) {
+//                    last = max(last, lastPos[val / x]);
+//                }
+//                maxLeft[i] = last;
+//            }
+//            for (int q = headq[x]; q > 0; q = nextq[q]) {
+//                int l = ql[q];
+//                int r = qr[q];
+//                int id = qid[q];
+//                ans[id] = (l <= maxLeft[r]);
+//            }
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    blen = (int)sqrt(n);
+//    for (int i = 1; i <= n; i++) {
+//        bi[i] = (i - 1) / blen + 1;
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 1, op, l, r, x; i <= m; i++) {
+//        cin >> op >> l >> r >> x;
+//        if (op == 4 && x < blen) {
+//            addSpecial(x, l, r, i);
+//        } else {
+//            query[++cntq] = {l, r, x, op, i};
+//        }
+//    }
+//    sort(query + 1, query + cntq + 1, QueryCmp);
+//    compute();
+//    special();
+//    for (int i = 1; i <= m; i++) {
+//        cout << (ans[i] ? "yuno" : "yumi") << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From fb30e8ad0b02a478b8b43ef7518c96b42911148f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 10:11:18 +0800
Subject: [PATCH 1445/1712] modify code

---
 src/class179/Code01_MaximumMatch1.java  |  7 +++++++
 src/class179/Code01_MaximumMatch2.java  | 19 +++++++++++++------
 src/class179/Code02_SimpleQuery1.java   | 18 +++++++++++-------
 src/class179/Code02_SimpleQuery2.java   | 19 ++++++++++++-------
 src/class179/Code03_NiceDay1.java       |  6 ++++--
 src/class179/Code03_NiceDay2.java       |  6 ++++--
 src/class179/Code04_NotForget2.java     |  2 +-
 src/class179/Code05_Homework2.java      | 12 ++++++------
 src/class179/Code06_LCP2.java           |  2 +-
 src/class179/Code07_RabbitHole2.java    |  6 +++---
 src/class179/Code08_YnoiCornfield2.java | 11 ++++++++---
 11 files changed, 70 insertions(+), 38 deletions(-)

diff --git a/src/class179/Code01_MaximumMatch1.java b/src/class179/Code01_MaximumMatch1.java
index 42c7a47fa..58ccb10a6 100644
--- a/src/class179/Code01_MaximumMatch1.java
+++ b/src/class179/Code01_MaximumMatch1.java
@@ -1,6 +1,13 @@
 package class179;
 
 // 区间最大匹配，java版
+// 给定长度为n的数组a、长度为m的数组b、一个正数z
+// 数组a中数字x、数组b中数字y，如果x + y <= z，那么构成一个匹配
+// 已经匹配的数字，不可以重复使用，一共有q条查询，格式如下
+// 查询 l r : 数组b[l..r]范围上的数字，随意选择数组a中的数字，打印最多匹配数
+// 1 <= n <= 152501
+// 1 <= m、q <= 52501
+// 1 <= a[i]、b[i]、z <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4477
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class179/Code01_MaximumMatch2.java b/src/class179/Code01_MaximumMatch2.java
index 8c0314e8b..6fe2f30cf 100644
--- a/src/class179/Code01_MaximumMatch2.java
+++ b/src/class179/Code01_MaximumMatch2.java
@@ -1,6 +1,13 @@
 package class179;
 
 // 区间最大匹配，C++版
+// 给定长度为n的数组a、长度为m的数组b、一个正数z
+// 数组a中数字x、数组b中数字y，如果x + y <= z，那么构成一个匹配
+// 已经匹配的数字，不可以重复使用，一共有q条查询，格式如下
+// 查询 l r : 数组b[l..r]范围上的数字，随意选择数组a中的数字，打印最多匹配数
+// 1 <= n <= 152501
+// 1 <= m、q <= 52501
+// 1 <= a[i]、b[i]、z <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4477
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -28,14 +35,14 @@
 //
 //int ans[MAXQ];
 //
-//bool QueryCmp(Query &A, Query &B) {
-//    if (bi[A.l] != bi[B.l]) {
-//        return bi[A.l] < bi[B.l];
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
 //    }
-//    if ((bi[A.l] & 1) == 1) {
-//        return A.r < B.r;
+//    if (bi[a.l] & 1) {
+//        return a.r < b.r;
 //    } else {
-//        return A.r > B.r;
+//        return a.r > b.r;
 //    }
 //}
 //
diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index 74af8eeb1..5bfab3c42 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -1,6 +1,12 @@
 package class179;
 
 // 简单的询问，java版
+// 给定一个长度为n的数组arr，下标从1到n
+// 函数get(l, r, x) = arr[l..r]范围上，数组x出现的次数
+// 接下来有q条查询，格式如下
+// 查询 l1 r1 l2 r2 : 每种x都算，打印 get(l1, r1, x) * get(l2, r2, x) 的累加和
+// 1 <= n、q <= 5 * 10^4
+// 1 <= arr[i] <= n
 // 测试链接 : https://www.luogu.com.cn/problem/P5268
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,16 +20,14 @@
 public class Code02_SimpleQuery1 {
 
 	public static int MAXN = 50001;
-	public static int n, m, cntq;
+	public static int n, q, cntq;
 	public static int[] arr = new int[MAXN];
-
 	// siz1、siz2、op、id
 	public static int[][] query = new int[MAXN << 2][4];
-
 	public static int[] bi = new int[MAXN];
+
 	public static int[] cnt1 = new int[MAXN];
 	public static int[] cnt2 = new int[MAXN];
-
 	public static long sum = 0;
 	public static long[] ans = new long[MAXN];
 
@@ -100,8 +104,8 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
-		m = in.nextInt();
-		for (int i = 1, l1, r1, l2, r2; i <= m; i++) {
+		q = in.nextInt();
+		for (int i = 1, l1, r1, l2, r2; i <= q; i++) {
 			l1 = in.nextInt();
 			r1 = in.nextInt();
 			l2 = in.nextInt();
@@ -113,7 +117,7 @@ public static void main(String[] args) throws Exception {
 		}
 		prepare();
 		compute();
-		for (int i = 1; i <= m; i++) {
+		for (int i = 1; i <= q; i++) {
 			out.println(ans[i]);
 		}
 		out.flush();
diff --git a/src/class179/Code02_SimpleQuery2.java b/src/class179/Code02_SimpleQuery2.java
index ae8a3a31c..a11f5337b 100644
--- a/src/class179/Code02_SimpleQuery2.java
+++ b/src/class179/Code02_SimpleQuery2.java
@@ -1,6 +1,12 @@
 package class179;
 
 // 简单的询问，C++版
+// 给定一个长度为n的数组arr，下标从1到n
+// 函数get(l, r, x) = arr[l..r]范围上，数组x出现的次数
+// 接下来有q条查询，格式如下
+// 查询 l1 r1 l2 r2 : 每种x都算，打印 get(l1, r1, x) * get(l2, r2, x) 的累加和
+// 1 <= n、q <= 5 * 10^4
+// 1 <= arr[i] <= n
 // 测试链接 : https://www.luogu.com.cn/problem/P5268
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -14,14 +20,13 @@
 //};
 //
 //const int MAXN = 50001;
-//int n, m, cntq;
+//int n, q, cntq;
 //int arr[MAXN];
 //Query query[MAXN << 2];
-//
 //int bi[MAXN];
+//
 //int cnt1[MAXN];
 //int cnt2[MAXN];
-//
 //long long sumv = 0;
 //long long ans[MAXN];
 //
@@ -29,7 +34,7 @@
 //    if (bi[a.siz1] != bi[b.siz1]) {
 //        return bi[a.siz1] < bi[b.siz1];
 //    }
-//    if ((bi[a.siz1] & 1) == 1) {
+//    if (bi[a.siz1] & 1) {
 //        return a.siz2 < b.siz2;
 //    } else {
 //        return a.siz2 > b.siz2;
@@ -90,8 +95,8 @@
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
-//    cin >> m;
-//    for (int i = 1, l1, r1, l2, r2; i <= m; i++) {
+//    cin >> q;
+//    for (int i = 1, l1, r1, l2, r2; i <= q; i++) {
 //        cin >> l1 >> r1 >> l2 >> r2;
 //        addQuery(r1, r2, 1, i);
 //        addQuery(r1, l2 - 1, -1, i);
@@ -100,7 +105,7 @@
 //    }
 //    prepare();
 //    compute();
-//    for (int i = 1; i <= m; i++) {
+//    for (int i = 1; i <= q; i++) {
 //        cout << ans[i] << '\n';
 //    }
 //    return 0;
diff --git a/src/class179/Code03_NiceDay1.java b/src/class179/Code03_NiceDay1.java
index 216550a2a..9e26b64b5 100644
--- a/src/class179/Code03_NiceDay1.java
+++ b/src/class179/Code03_NiceDay1.java
@@ -42,14 +42,16 @@ public int compare(int[] a, int[] b) {
 	}
 
 	public static void add(int s) {
-		num += cnt[s]++;
+		num += cnt[s];
+		cnt[s]++;
 		for (int i = 0; i < 26; i++) {
 			num += cnt[s ^ (1 << i)];
 		}
 	}
 
 	public static void del(int s) {
-		num -= --cnt[s];
+		cnt[s]--;
+		num -= cnt[s];
 		for (int i = 0; i < 26; i++) {
 			num -= cnt[s ^ (1 << i)];
 		}
diff --git a/src/class179/Code03_NiceDay2.java b/src/class179/Code03_NiceDay2.java
index 8d3d36615..507fb8527 100644
--- a/src/class179/Code03_NiceDay2.java
+++ b/src/class179/Code03_NiceDay2.java
@@ -36,14 +36,16 @@
 //}
 //
 //void add(int s) {
-//    num += cnt[s]++;
+//    num += cnt[s];
+//    cnt[s]++;
 //    for (int i = 0; i < 26; i++) {
 //        num += cnt[s ^ (1 << i)];
 //    }
 //}
 //
 //void del(int s) {
-//    num -= --cnt[s];
+//    cnt[s]--;
+//    num -= cnt[s];
 //    for (int i = 0; i < 26; i++) {
 //        num -= cnt[s ^ (1 << i)];
 //    }
diff --git a/src/class179/Code04_NotForget2.java b/src/class179/Code04_NotForget2.java
index e56e4220c..1618f1eec 100644
--- a/src/class179/Code04_NotForget2.java
+++ b/src/class179/Code04_NotForget2.java
@@ -36,7 +36,7 @@
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
-//    if ((bi[a.l] & 1) == 1) {
+//    if (bi[a.l] & 1) {
 //        return a.r < b.r;
 //    } else {
 //        return a.r > b.r;
diff --git a/src/class179/Code05_Homework2.java b/src/class179/Code05_Homework2.java
index 54a378763..6a313d1f5 100644
--- a/src/class179/Code05_Homework2.java
+++ b/src/class179/Code05_Homework2.java
@@ -29,14 +29,14 @@
 //int ans1[MAXN];
 //int ans2[MAXN];
 //
-//bool QueryCmp(Query &A, Query &B) {
-//    if (bi[A.l] != bi[B.l]) {
-//        return bi[A.l] < bi[B.l];
+//bool QueryCmp(Query &a, Query &b) {
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
 //    }
-//    if ((bi[A.l] & 1) == 1) {
-//        return A.r < B.r;
+//    if (bi[a.l] & 1) {
+//        return a.r < b.r;
 //    } else {
-//        return A.r > B.r;
+//        return a.r > b.r;
 //    }
 //}
 //
diff --git a/src/class179/Code06_LCP2.java b/src/class179/Code06_LCP2.java
index fa564f938..e00f17a38 100644
--- a/src/class179/Code06_LCP2.java
+++ b/src/class179/Code06_LCP2.java
@@ -51,7 +51,7 @@
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
-//    if ((bi[a.l] & 1) == 1) {
+//    if (bi[a.l] & 1) {
 //        return a.r < b.r;
 //    } else {
 //        return a.r > b.r;
diff --git a/src/class179/Code07_RabbitHole2.java b/src/class179/Code07_RabbitHole2.java
index 30cc835f3..4743b38fb 100644
--- a/src/class179/Code07_RabbitHole2.java
+++ b/src/class179/Code07_RabbitHole2.java
@@ -43,14 +43,14 @@
 //    return ret;
 //}
 //
-//bool QueryCmp(const Query& a, const Query& b) {
+//bool QueryCmp(const Query &a, const Query &b) {
 //    if (bi[a.l] != bi[b.l]) {
 //        return bi[a.l] < bi[b.l];
 //    }
-//    if ((bi[a.l] & 1) == 1) {
+//    if (bi[a.l] & 1) {
 //        return a.r < b.r;
 //    } else {
-//    	return a.r > b.r;
+//        return a.r > b.r;
 //    }
 //}
 //
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index 8096154d5..f68d9206d 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -48,9 +48,14 @@
 //}
 //
 //bool QueryCmp(const Query &a, const Query &b) {
-//    if (bi[a.l] != bi[b.l]) return bi[a.l] < bi[b.l];
-//    if ((bi[a.l] & 1) == 1) return a.r < b.r;
-//    return a.r > b.r;
+//    if (bi[a.l] != bi[b.l]) {
+//        return bi[a.l] < bi[b.l];
+//    }
+//    if (bi[a.l] & 1) {
+//        return a.r < b.r;
+//    } else {
+//        return a.r > b.r;
+//    }
 //}
 //
 //void add(int x) {

From 5587e20f6e06997b0c458936fb8987af1d189b69 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 10:35:19 +0800
Subject: [PATCH 1446/1712] modify code

---
 src/class179/Code03_NiceDay1.java                             | 4 ++++
 src/class179/Code03_NiceDay2.java                             | 4 ++++
 src/class179/{Code06_LCP1.java => Code04_LCP1.java}           | 2 +-
 src/class179/{Code06_LCP2.java => Code04_LCP2.java}           | 0
 .../{Code04_NotForget1.java => Code06_NotForget1.java}        | 4 ++--
 .../{Code04_NotForget2.java => Code06_NotForget2.java}        | 0
 6 files changed, 11 insertions(+), 3 deletions(-)
 rename src/class179/{Code06_LCP1.java => Code04_LCP1.java} (99%)
 rename src/class179/{Code06_LCP2.java => Code04_LCP2.java} (100%)
 rename src/class179/{Code04_NotForget1.java => Code06_NotForget1.java} (98%)
 rename src/class179/{Code04_NotForget2.java => Code06_NotForget2.java} (100%)

diff --git a/src/class179/Code03_NiceDay1.java b/src/class179/Code03_NiceDay1.java
index 9e26b64b5..979d812ef 100644
--- a/src/class179/Code03_NiceDay1.java
+++ b/src/class179/Code03_NiceDay1.java
@@ -1,6 +1,10 @@
 package class179;
 
 // 美好的每一天，java版
+// 给定一个长度为n的字符串str，其中都是小写字母
+// 如果一个子串重新排列字符之后能成为回文串，那么该子串叫做达标子串
+// 接下来有m条操作，格式为 l r : 打印str[l..r]范围上有多少达标子串
+// 1 <= n、m <= 6 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P3604
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class179/Code03_NiceDay2.java b/src/class179/Code03_NiceDay2.java
index 507fb8527..228ed0d26 100644
--- a/src/class179/Code03_NiceDay2.java
+++ b/src/class179/Code03_NiceDay2.java
@@ -1,6 +1,10 @@
 package class179;
 
 // 美好的每一天，C++版
+// 给定一个长度为n的字符串str，其中都是小写字母
+// 如果一个子串重新排列字符之后能成为回文串，那么该子串叫做达标子串
+// 接下来有m条操作，格式为 l r : 打印str[l..r]范围上有多少达标子串
+// 1 <= n、m <= 6 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P3604
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class179/Code06_LCP1.java b/src/class179/Code04_LCP1.java
similarity index 99%
rename from src/class179/Code06_LCP1.java
rename to src/class179/Code04_LCP1.java
index f77ceb91b..1c3c07d98 100644
--- a/src/class179/Code06_LCP1.java
+++ b/src/class179/Code04_LCP1.java
@@ -11,7 +11,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code06_LCP1 {
+public class Code04_LCP1 {
 
 	public static int MAXN = 3000001;
 	public static int MAXM = 100001;
diff --git a/src/class179/Code06_LCP2.java b/src/class179/Code04_LCP2.java
similarity index 100%
rename from src/class179/Code06_LCP2.java
rename to src/class179/Code04_LCP2.java
diff --git a/src/class179/Code04_NotForget1.java b/src/class179/Code06_NotForget1.java
similarity index 98%
rename from src/class179/Code04_NotForget1.java
rename to src/class179/Code06_NotForget1.java
index fdcaa0032..faa86cce1 100644
--- a/src/class179/Code04_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P5072
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code04_NotForget2文件就是C++的实现
+// 想通过用C++实现，本节课Code06_NotForget2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -14,7 +14,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code04_NotForget1 {
+public class Code06_NotForget1 {
 
 	public static int MAXN = 100001;
 	public static int MAXB = 401;
diff --git a/src/class179/Code04_NotForget2.java b/src/class179/Code06_NotForget2.java
similarity index 100%
rename from src/class179/Code04_NotForget2.java
rename to src/class179/Code06_NotForget2.java

From 74055ba7bd4dc12332a1faf5c8dbad40c8319988 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 10:56:56 +0800
Subject: [PATCH 1447/1712] modify code

---
 src/class179/Code03_NiceDay1.java | 2 +-
 src/class179/Code03_NiceDay2.java | 2 +-
 src/class179/Code04_LCP1.java     | 8 +++++++-
 src/class179/Code04_LCP2.java     | 8 +++++++-
 4 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/src/class179/Code03_NiceDay1.java b/src/class179/Code03_NiceDay1.java
index 979d812ef..ee5759480 100644
--- a/src/class179/Code03_NiceDay1.java
+++ b/src/class179/Code03_NiceDay1.java
@@ -3,7 +3,7 @@
 // 美好的每一天，java版
 // 给定一个长度为n的字符串str，其中都是小写字母
 // 如果一个子串重新排列字符之后能成为回文串，那么该子串叫做达标子串
-// 接下来有m条操作，格式为 l r : 打印str[l..r]范围上有多少达标子串
+// 接下来有m条查询，格式为 l r : 打印str[l..r]范围上有多少达标子串
 // 1 <= n、m <= 6 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P3604
 // 提交以下的code，提交时请把类名改成"Main"
diff --git a/src/class179/Code03_NiceDay2.java b/src/class179/Code03_NiceDay2.java
index 228ed0d26..c95f62221 100644
--- a/src/class179/Code03_NiceDay2.java
+++ b/src/class179/Code03_NiceDay2.java
@@ -3,7 +3,7 @@
 // 美好的每一天，C++版
 // 给定一个长度为n的字符串str，其中都是小写字母
 // 如果一个子串重新排列字符之后能成为回文串，那么该子串叫做达标子串
-// 接下来有m条操作，格式为 l r : 打印str[l..r]范围上有多少达标子串
+// 接下来有m条查询，格式为 l r : 打印str[l..r]范围上有多少达标子串
 // 1 <= n、m <= 6 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P3604
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class179/Code04_LCP1.java b/src/class179/Code04_LCP1.java
index 1c3c07d98..ab5d63290 100644
--- a/src/class179/Code04_LCP1.java
+++ b/src/class179/Code04_LCP1.java
@@ -1,6 +1,12 @@
 package class179;
 
-// 区间LCP达标对，java版
+// 区间lcp达标对，java版
+// 给定一个长度为n的字符串str，还有一个参数k
+// 位置a开头的字符串 和 位置b开头的字符串，如果最长公共前缀 >= k，则(a, b)构成达标对
+// 构成达标对的必须是不同的两个位置，并且(a, b)和(b, a)只算一个达标对，不要重复统计
+// 接下来有m条查询，格式为 l r : str[l..r]范围上，可以任选开头位置，打印达标对的数量
+// 1 <= n、k <= 3 * 10^6       1 <= m <= 10^5
+// 1 <= n * n * m <= 10^15    字符集为 f z o u t s y
 // 测试链接 : https://www.luogu.com.cn/problem/P5112
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class179/Code04_LCP2.java b/src/class179/Code04_LCP2.java
index e00f17a38..79c2cb351 100644
--- a/src/class179/Code04_LCP2.java
+++ b/src/class179/Code04_LCP2.java
@@ -1,6 +1,12 @@
 package class179;
 
-// 区间LCP达标对，C++版
+// 区间lcp达标对，C++版
+// 给定一个长度为n的字符串str，还有一个参数k
+// 位置a开头的字符串 和 位置b开头的字符串，如果最长公共前缀 >= k，则(a, b)构成达标对
+// 构成达标对的必须是不同的两个位置，并且(a, b)和(b, a)只算一个达标对，不要重复统计
+// 接下来有m条查询，格式为 l r : str[l..r]范围上，可以任选开头位置，打印达标对的数量
+// 1 <= n、k <= 3 * 10^6       1 <= m <= 10^5
+// 1 <= n * n * m <= 10^15    字符集为 f z o u t s y
 // 测试链接 : https://www.luogu.com.cn/problem/P5112
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 383ee5bb53b78cc03be5a4a285ebfcc981ac14a0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 11:05:45 +0800
Subject: [PATCH 1448/1712] modify code

---
 src/class179/Code05_Homework1.java | 5 +++++
 src/class179/Code05_Homework2.java | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/src/class179/Code05_Homework1.java b/src/class179/Code05_Homework1.java
index b43a2b38c..7cba8f9c2 100644
--- a/src/class179/Code05_Homework1.java
+++ b/src/class179/Code05_Homework1.java
@@ -1,6 +1,11 @@
 package class179;
 
 // 作业，java版
+// 给定一个长度为n的数组arr，接下来有m条查询，格式如下
+// 查询 l r a b : 打印arr[l..r]范围上的两个答案
+//                答案1，数值范围在[a, b]的数字个数
+//                答案2，数值范围在[a, b]的数字种数
+// 1 <= n、m、arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4396
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class179/Code05_Homework2.java b/src/class179/Code05_Homework2.java
index 6a313d1f5..e88e3efe6 100644
--- a/src/class179/Code05_Homework2.java
+++ b/src/class179/Code05_Homework2.java
@@ -1,6 +1,11 @@
 package class179;
 
 // 作业，C++版
+// 给定一个长度为n的数组arr，接下来有m条查询，格式如下
+// 查询 l r a b : 打印arr[l..r]范围上的两个答案
+//                答案1，数值范围在[a, b]的数字个数
+//                答案2，数值范围在[a, b]的数字种数
+// 1 <= n、m、arr[i] <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4396
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From ee466b4862afe205b408c046c1ac32c3b30db4e2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 11:27:29 +0800
Subject: [PATCH 1449/1712] modify code

---
 src/class179/Code06_NotForget1.java | 21 +++++++++++++--------
 src/class179/Code06_NotForget2.java | 21 +++++++++++++--------
 2 files changed, 26 insertions(+), 16 deletions(-)

diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index faa86cce1..461545d4e 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -1,6 +1,11 @@
 package class179;
 
 // 盼君勿忘，java版
+// 一个序列中每种数字只保留一个，得到的累加和，叫做去重累加和
+// 给定一个长度为n的数组arr，接下来是m条查询，查询格式如下
+// 查询 l r p : arr[l..r]范围上，累加每个子序列的去重累加和 % p 的结果打印
+// 1 <= n、m、arr[i] <= 10^5
+// 1 <= p <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5072
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
@@ -31,8 +36,8 @@ public class Code06_NotForget1 {
 	public static int[] cnt = new int[MAXN];
 	public static long[] sum = new long[MAXN];
 
-	public static long[] smlPow = new long[MAXB];
-	public static long[] bigPow = new long[MAXB];
+	public static long[] smlPower = new long[MAXB];
+	public static long[] bigPower = new long[MAXB];
 
 	public static long[] ans = new long[MAXN];
 
@@ -102,18 +107,18 @@ public static void del(int num) {
 	public static void setAns(int len, int mod, int id) {
 		int blen = (int) Math.sqrt(len);
 		int bnum = (len + blen - 1) / blen;
-		smlPow[0] = 1;
+		smlPower[0] = 1;
 		for (int i = 1; i <= blen; i++) {
-			smlPow[i] = (smlPow[i - 1] << 1) % mod;
+			smlPower[i] = (smlPower[i - 1] << 1) % mod;
 		}
-		bigPow[0] = 1;
+		bigPower[0] = 1;
 		for (int i = 1; i <= bnum; i++) {
-			bigPow[i] = (bigPow[i - 1] * smlPow[blen]) % mod;
+			bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % mod;
 		}
 		long res = 0, tmp;
 		for (int p = head; p > 0; p = next[p]) {
-			tmp = bigPow[len / blen] * smlPow[len % blen] % mod;
-			tmp -= bigPow[(len - p) / blen] * smlPow[(len - p) % blen] % mod;
+			tmp = bigPower[len / blen] * smlPower[len % blen] % mod;
+			tmp -= bigPower[(len - p) / blen] * smlPower[(len - p) % blen] % mod;
 			tmp = (tmp * sum[p]) % mod;
 			res = ((res + tmp) % mod + mod) % mod;
 		}
diff --git a/src/class179/Code06_NotForget2.java b/src/class179/Code06_NotForget2.java
index 1618f1eec..cd851a8ad 100644
--- a/src/class179/Code06_NotForget2.java
+++ b/src/class179/Code06_NotForget2.java
@@ -1,6 +1,11 @@
 package class179;
 
 // 盼君勿忘，C++版
+// 一个序列中每种数字只保留一个，得到的累加和，叫做去重累加和
+// 给定一个长度为n的数组arr，接下来是m条查询，查询格式如下
+// 查询 l r p : arr[l..r]范围上，累加每个子序列的去重累加和 % p 的结果打印
+// 1 <= n、m、arr[i] <= 10^5
+// 1 <= p <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5072
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -27,8 +32,8 @@
 //int cnt[MAXN];
 //long long sum[MAXN];
 //
-//long long smlPow[MAXB];
-//long long bigPow[MAXB];
+//long long smlPower[MAXB];
+//long long bigPower[MAXB];
 //
 //long long ans[MAXN];
 //
@@ -97,18 +102,18 @@
 //void setAns(int len, int mod, int id) {
 //    int blen = (int)sqrt(len);
 //    int bnum = (len + blen - 1) / blen;
-//    smlPow[0] = 1;
+//    smlPower[0] = 1;
 //    for (int i = 1; i <= blen; i++) {
-//        smlPow[i] = (smlPow[i - 1] << 1) % mod;
+//        smlPower[i] = (smlPower[i - 1] << 1) % mod;
 //    }
-//    bigPow[0] = 1;
+//    bigPower[0] = 1;
 //    for (int i = 1; i <= bnum; i++) {
-//        bigPow[i] = (bigPow[i - 1] * smlPow[blen]) % mod;
+//        bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % mod;
 //    }
 //    long long res = 0, tmp;
 //    for (int p = head; p > 0; p = nxt[p]) {
-//        tmp = bigPow[len / blen] * smlPow[len % blen] % mod;
-//        tmp -= bigPow[(len - p) / blen] * smlPow[(len - p) % blen] % mod;
+//        tmp = bigPower[len / blen] * smlPower[len % blen] % mod;
+//        tmp -= bigPower[(len - p) / blen] * smlPower[(len - p) % blen] % mod;
 //        tmp = (tmp * sum[p]) % mod;
 //        res = ((res + tmp) % mod + mod) % mod;
 //    }

From c4a36c12557465b840ea94cfa1fd12745ecf0380 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 11:41:10 +0800
Subject: [PATCH 1450/1712] modify code

---
 src/class179/Code07_RabbitHole1.java | 8 ++++++++
 src/class179/Code07_RabbitHole2.java | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/class179/Code07_RabbitHole1.java b/src/class179/Code07_RabbitHole1.java
index 03a2115a2..9815ae5a5 100644
--- a/src/class179/Code07_RabbitHole1.java
+++ b/src/class179/Code07_RabbitHole1.java
@@ -1,6 +1,14 @@
 package class179;
 
 // 掉进兔子洞，java版
+// 三个区间同时出现的数，一个一个删掉，直到无法再删，剩下数字的个数叫做 剩余个数
+// A = [1 2 2 3 3 3]  B = [1 2 2 3 3 3]  C = [1 1 2 3 3]
+// 删除的过程为，一起删掉一个1、一起删掉一个2、一起删掉2个3，然后状况为
+// A = [2 3]  B = [2 3]  C = [1]，剩余个数为5
+// 给定一个长度为n的数组arr，下来有m条查询，格式如下
+// 查询 l1 r1 l2 r2 l3 r3 : 给定了三个区间，打印剩余个数
+// 1 <= n、m <= 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4688
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class179/Code07_RabbitHole2.java b/src/class179/Code07_RabbitHole2.java
index 4743b38fb..83e249411 100644
--- a/src/class179/Code07_RabbitHole2.java
+++ b/src/class179/Code07_RabbitHole2.java
@@ -1,6 +1,14 @@
 package class179;
 
 // 掉进兔子洞，C++版
+// 三个区间同时出现的数，一个一个删掉，直到无法再删，剩下数字的个数叫做 剩余个数
+// A = [1 2 2 3 3 3]  B = [1 2 2 3 3 3]  C = [1 1 2 3 3]
+// 删除的过程为，一起删掉一个1、一起删掉一个2、一起删掉2个3，然后状况为
+// A = [2 3]  B = [2 3]  C = [1]，剩余个数为5
+// 给定一个长度为n的数组arr，下来有m条查询，格式如下
+// 查询 l1 r1 l2 r2 l3 r3 : 给定了三个区间，打印剩余个数
+// 1 <= n、m <= 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4688
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 92184d0d5f25e86d947a0dcec5e2585b5cc9d6f7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 11:50:43 +0800
Subject: [PATCH 1451/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 7 +++++++
 src/class179/Code08_YnoiCornfield2.java | 7 +++++++
 2 files changed, 14 insertions(+)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index fc0d7b3d2..336f5079a 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -1,6 +1,13 @@
 package class179;
 
 // 由乃的玉米田，java版
+// 给定一个长度为n的数组arr，接下来有m条查询，查询格式如下
+// 查询 1 l r x : 打印arr[l..r]范围上能否选出两个数，减的结果为x
+// 查询 2 l r x : 打印arr[l..r]范围上能否选出两个数，加的结果为x
+// 查询 3 l r x : 打印arr[l..r]范围上能否选出两个数，乘的结果为x
+// 查询 4 l r x : 打印arr[l..r]范围上能否选出两个数，除的结果为x，并且没有余数
+// 选出的这两个数可以是同一个位置的数，答案如果为是，打印 "yuno"，否则打印 "yumi"
+// 1 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5355
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index f68d9206d..bedc3de69 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -1,6 +1,13 @@
 package class179;
 
 // 由乃的玉米田，C++版
+// 给定一个长度为n的数组arr，接下来有m条查询，查询格式如下
+// 查询 1 l r x : 打印arr[l..r]范围上能否选出两个数，减的结果为x
+// 查询 2 l r x : 打印arr[l..r]范围上能否选出两个数，加的结果为x
+// 查询 3 l r x : 打印arr[l..r]范围上能否选出两个数，乘的结果为x
+// 查询 4 l r x : 打印arr[l..r]范围上能否选出两个数，除的结果为x，并且没有余数
+// 选出的这两个数可以是同一个位置的数，答案如果为是，打印 "yuno"，否则打印 "yumi"
+// 1 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5355
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From f15a3f9df1864edda8fc9b4580b2f6080f681b20 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 12:32:40 +0800
Subject: [PATCH 1452/1712] modify code

---
 src/class179/Code07_RabbitHole1.java | 4 ++--
 src/class179/Code07_RabbitHole2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class179/Code07_RabbitHole1.java b/src/class179/Code07_RabbitHole1.java
index 9815ae5a5..b1ac8f65b 100644
--- a/src/class179/Code07_RabbitHole1.java
+++ b/src/class179/Code07_RabbitHole1.java
@@ -2,9 +2,9 @@
 
 // 掉进兔子洞，java版
 // 三个区间同时出现的数，一个一个删掉，直到无法再删，剩下数字的个数叫做 剩余个数
-// A = [1 2 2 3 3 3]  B = [1 2 2 3 3 3]  C = [1 1 2 3 3]
+// A = [1 2 2 3 3 3]    B = [1 2 2 3 3 3]    C = [1 1 2 3 3]
 // 删除的过程为，一起删掉一个1、一起删掉一个2、一起删掉2个3，然后状况为
-// A = [2 3]  B = [2 3]  C = [1]，剩余个数为5
+// A = [2 3]    B = [2 3]    C = [1]    剩余个数为5
 // 给定一个长度为n的数组arr，下来有m条查询，格式如下
 // 查询 l1 r1 l2 r2 l3 r3 : 给定了三个区间，打印剩余个数
 // 1 <= n、m <= 10^5
diff --git a/src/class179/Code07_RabbitHole2.java b/src/class179/Code07_RabbitHole2.java
index 83e249411..703130278 100644
--- a/src/class179/Code07_RabbitHole2.java
+++ b/src/class179/Code07_RabbitHole2.java
@@ -2,9 +2,9 @@
 
 // 掉进兔子洞，C++版
 // 三个区间同时出现的数，一个一个删掉，直到无法再删，剩下数字的个数叫做 剩余个数
-// A = [1 2 2 3 3 3]  B = [1 2 2 3 3 3]  C = [1 1 2 3 3]
+// A = [1 2 2 3 3 3]    B = [1 2 2 3 3 3]    C = [1 1 2 3 3]
 // 删除的过程为，一起删掉一个1、一起删掉一个2、一起删掉2个3，然后状况为
-// A = [2 3]  B = [2 3]  C = [1]，剩余个数为5
+// A = [2 3]    B = [2 3]    C = [1]    剩余个数为5
 // 给定一个长度为n的数组arr，下来有m条查询，格式如下
 // 查询 l1 r1 l2 r2 l3 r3 : 给定了三个区间，打印剩余个数
 // 1 <= n、m <= 10^5

From 428627d8af4bcce3577b2fd9d9ca4362360d005f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 14:46:05 +0800
Subject: [PATCH 1453/1712] modify code

---
 src/class179/Code04_LCP1.java | 6 +++---
 src/class179/Code04_LCP2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class179/Code04_LCP1.java b/src/class179/Code04_LCP1.java
index ab5d63290..341319b45 100644
--- a/src/class179/Code04_LCP1.java
+++ b/src/class179/Code04_LCP1.java
@@ -2,9 +2,9 @@
 
 // 区间lcp达标对，java版
 // 给定一个长度为n的字符串str，还有一个参数k
-// 位置a开头的字符串 和 位置b开头的字符串，如果最长公共前缀 >= k，则(a, b)构成达标对
-// 构成达标对的必须是不同的两个位置，并且(a, b)和(b, a)只算一个达标对，不要重复统计
-// 接下来有m条查询，格式为 l r : str[l..r]范围上，可以任选开头位置，打印达标对的数量
+// 位置a开头和位置b开头的字符串，如果最长公共前缀的长度 >= k，那么(a, b)构成lcp达标对
+// 构成lcp达标对，必须是不同的位置，并且(a, b)和(b, a)只算一个达标对，不要重复统计
+// 接下来有m条查询，格式为 l r : str[l..r]范围上，可以任选开头位置，打印lcp达标对的数量
 // 1 <= n、k <= 3 * 10^6       1 <= m <= 10^5
 // 1 <= n * n * m <= 10^15    字符集为 f z o u t s y
 // 测试链接 : https://www.luogu.com.cn/problem/P5112
diff --git a/src/class179/Code04_LCP2.java b/src/class179/Code04_LCP2.java
index 79c2cb351..7952d06be 100644
--- a/src/class179/Code04_LCP2.java
+++ b/src/class179/Code04_LCP2.java
@@ -2,9 +2,9 @@
 
 // 区间lcp达标对，C++版
 // 给定一个长度为n的字符串str，还有一个参数k
-// 位置a开头的字符串 和 位置b开头的字符串，如果最长公共前缀 >= k，则(a, b)构成达标对
-// 构成达标对的必须是不同的两个位置，并且(a, b)和(b, a)只算一个达标对，不要重复统计
-// 接下来有m条查询，格式为 l r : str[l..r]范围上，可以任选开头位置，打印达标对的数量
+// 位置a开头和位置b开头的字符串，如果最长公共前缀的长度 >= k，那么(a, b)构成lcp达标对
+// 构成lcp达标对，必须是不同的位置，并且(a, b)和(b, a)只算一个达标对，不要重复统计
+// 接下来有m条查询，格式为 l r : str[l..r]范围上，可以任选开头位置，打印lcp达标对的数量
 // 1 <= n、k <= 3 * 10^6       1 <= m <= 10^5
 // 1 <= n * n * m <= 10^15    字符集为 f z o u t s y
 // 测试链接 : https://www.luogu.com.cn/problem/P5112

From 0bb201808993acaefe861ffcc4385fd2d09789a0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 15:03:31 +0800
Subject: [PATCH 1454/1712] modify code

---
 src/class179/Code01_MaximumMatch1.java | 6 +++++-
 src/class179/Code01_MaximumMatch2.java | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code01_MaximumMatch1.java b/src/class179/Code01_MaximumMatch1.java
index 58ccb10a6..1f09c807b 100644
--- a/src/class179/Code01_MaximumMatch1.java
+++ b/src/class179/Code01_MaximumMatch1.java
@@ -29,6 +29,10 @@ public class Code01_MaximumMatch1 {
 	public static int[][] query = new int[MAXQ][3];
 	public static int[] bi = new int[MAXM];
 
+	// 关于数组a的线段树，a[l..r]和b数组的数字进行匹配，l..r对应的信息在i位置
+	// match[i] = v，表示a[l..r]和b数组的数字，一共匹配了v对
+	// resta[i] = v，表示a[l..r]中还有v个数，可用于匹配b数组的数字
+	// overb[i] = v，表示a[l..r]已经没有可用数字，并且有v个b数组的数字等待匹配
 	public static int[] match = new int[MAXN << 2];
 	public static int[] resta = new int[MAXN << 2];
 	public static int[] overb = new int[MAXN << 2];
@@ -111,7 +115,7 @@ public static void del(int jobv, int l, int r, int i) {
 
 	public static void prepare() {
 		Arrays.sort(a, 1, n + 1);
-		int blen = (int) Math.sqrt(n);
+		int blen = (int) Math.sqrt(m);
 		for (int i = 1; i <= m; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
diff --git a/src/class179/Code01_MaximumMatch2.java b/src/class179/Code01_MaximumMatch2.java
index 6fe2f30cf..3a56775f5 100644
--- a/src/class179/Code01_MaximumMatch2.java
+++ b/src/class179/Code01_MaximumMatch2.java
@@ -108,7 +108,7 @@
 //
 //void prepare() {
 //    sort(a + 1, a + n + 1);
-//    int blen = (int)sqrt(n);
+//    int blen = (int)sqrt(m);
 //    for (int i = 1; i <= m; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }

From 21ac0572f13bb9d2c4a607fdfd2125725a5f4051 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 15:08:49 +0800
Subject: [PATCH 1455/1712] modify code

---
 src/class179/Code01_MaximumMatch1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code01_MaximumMatch1.java b/src/class179/Code01_MaximumMatch1.java
index 1f09c807b..b5d07e448 100644
--- a/src/class179/Code01_MaximumMatch1.java
+++ b/src/class179/Code01_MaximumMatch1.java
@@ -29,10 +29,10 @@ public class Code01_MaximumMatch1 {
 	public static int[][] query = new int[MAXQ][3];
 	public static int[] bi = new int[MAXM];
 
-	// 关于数组a的线段树，a[l..r]和b数组的数字进行匹配，l..r对应的信息在i位置
+	// 线段树维护匹配信息，a[l..r]和b数组的数字进行匹配，l..r对应的信息在i位置
 	// match[i] = v，表示a[l..r]和b数组的数字，一共匹配了v对
 	// resta[i] = v，表示a[l..r]中还有v个数，可用于匹配b数组的数字
-	// overb[i] = v，表示a[l..r]已经没有可用数字，并且有v个b数组的数字等待匹配
+	// overb[i] = v，表示a[l..r]已经耗尽，但是还有v个b数组的数字需要匹配
 	public static int[] match = new int[MAXN << 2];
 	public static int[] resta = new int[MAXN << 2];
 	public static int[] overb = new int[MAXN << 2];

From 5318a79ff519a2c53c2d0b959eaac3bfd2f66dec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 15:14:09 +0800
Subject: [PATCH 1456/1712] modify code

---
 src/class179/Code01_MaximumMatch1.java | 6 +++---
 src/class179/Code01_MaximumMatch2.java | 8 ++++----
 2 files changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class179/Code01_MaximumMatch1.java b/src/class179/Code01_MaximumMatch1.java
index b5d07e448..00c7a925e 100644
--- a/src/class179/Code01_MaximumMatch1.java
+++ b/src/class179/Code01_MaximumMatch1.java
@@ -96,11 +96,11 @@ public static void add(int jobv, int l, int r, int i) {
 
 	public static void del(int jobv, int l, int r, int i) {
 		if (l == r) {
-			if (overb[i] == 0) {
+			if (overb[i] > 0) {
+				overb[i]--;
+			} else {
 				match[i] = 0;
 				resta[i] = 1;
-			} else {
-				overb[i]--;
 			}
 		} else {
 			int mid = (l + r) >> 1;
diff --git a/src/class179/Code01_MaximumMatch2.java b/src/class179/Code01_MaximumMatch2.java
index 3a56775f5..09a04c36d 100644
--- a/src/class179/Code01_MaximumMatch2.java
+++ b/src/class179/Code01_MaximumMatch2.java
@@ -89,11 +89,11 @@
 //
 //void del(int jobv, int l, int r, int i) {
 //    if (l == r) {
-//        if (overb[i] == 0) {
-//        	match[i] = 0;
-//            resta[i] = 1;
-//        } else {
+//        if (overb[i] > 0) {
 //            overb[i]--;
+//        } else {
+//            match[i] = 0;
+//            resta[i] = 1;
 //        }
 //    } else {
 //        int mid = (l + r) >> 1;

From 27c43a0658c061b669a693bebe9cbbcabc5894e3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 30 Sep 2025 17:36:41 +0800
Subject: [PATCH 1457/1712] modify code

---
 src/class179/{Code03_NiceDay1.java => Code01_NiceDay1.java}   | 4 ++--
 src/class179/{Code03_NiceDay2.java => Code01_NiceDay2.java}   | 0
 src/class179/{Code04_LCP1.java => Code03_LCP1.java}           | 2 +-
 src/class179/{Code04_LCP2.java => Code03_LCP2.java}           | 0
 .../{Code01_MaximumMatch1.java => Code04_MaximumMatch1.java}  | 2 +-
 .../{Code01_MaximumMatch2.java => Code04_MaximumMatch2.java}  | 0
 6 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class179/{Code03_NiceDay1.java => Code01_NiceDay1.java} (97%)
 rename src/class179/{Code03_NiceDay2.java => Code01_NiceDay2.java} (100%)
 rename src/class179/{Code04_LCP1.java => Code03_LCP1.java} (99%)
 rename src/class179/{Code04_LCP2.java => Code03_LCP2.java} (100%)
 rename src/class179/{Code01_MaximumMatch1.java => Code04_MaximumMatch1.java} (99%)
 rename src/class179/{Code01_MaximumMatch2.java => Code04_MaximumMatch2.java} (100%)

diff --git a/src/class179/Code03_NiceDay1.java b/src/class179/Code01_NiceDay1.java
similarity index 97%
rename from src/class179/Code03_NiceDay1.java
rename to src/class179/Code01_NiceDay1.java
index ee5759480..bccbfb9db 100644
--- a/src/class179/Code03_NiceDay1.java
+++ b/src/class179/Code01_NiceDay1.java
@@ -8,7 +8,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3604
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code03_NiceDay2文件就是C++的实现
+// 想通过用C++实现，本节课Code01_NiceDay2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -18,7 +18,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code03_NiceDay1 {
+public class Code01_NiceDay1 {
 
 	public static int MAXN = 60002;
 	public static int MAXV = 1 << 26;
diff --git a/src/class179/Code03_NiceDay2.java b/src/class179/Code01_NiceDay2.java
similarity index 100%
rename from src/class179/Code03_NiceDay2.java
rename to src/class179/Code01_NiceDay2.java
diff --git a/src/class179/Code04_LCP1.java b/src/class179/Code03_LCP1.java
similarity index 99%
rename from src/class179/Code04_LCP1.java
rename to src/class179/Code03_LCP1.java
index 341319b45..546902d51 100644
--- a/src/class179/Code04_LCP1.java
+++ b/src/class179/Code03_LCP1.java
@@ -17,7 +17,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code04_LCP1 {
+public class Code03_LCP1 {
 
 	public static int MAXN = 3000001;
 	public static int MAXM = 100001;
diff --git a/src/class179/Code04_LCP2.java b/src/class179/Code03_LCP2.java
similarity index 100%
rename from src/class179/Code04_LCP2.java
rename to src/class179/Code03_LCP2.java
diff --git a/src/class179/Code01_MaximumMatch1.java b/src/class179/Code04_MaximumMatch1.java
similarity index 99%
rename from src/class179/Code01_MaximumMatch1.java
rename to src/class179/Code04_MaximumMatch1.java
index 00c7a925e..eae88e726 100644
--- a/src/class179/Code01_MaximumMatch1.java
+++ b/src/class179/Code04_MaximumMatch1.java
@@ -18,7 +18,7 @@
 import java.util.Arrays;
 import java.util.Comparator;
 
-public class Code01_MaximumMatch1 {
+public class Code04_MaximumMatch1 {
 
 	public static int MAXN = 152502;
 	public static int MAXM = 52502;
diff --git a/src/class179/Code01_MaximumMatch2.java b/src/class179/Code04_MaximumMatch2.java
similarity index 100%
rename from src/class179/Code01_MaximumMatch2.java
rename to src/class179/Code04_MaximumMatch2.java

From 8c6e895e68f0ccf96a57146362b7787e5865586d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 10:32:47 +0800
Subject: [PATCH 1458/1712] modify code

---
 src/class149/SkipList2.java            |  9 ++-------
 src/class179/Code04_MaximumMatch2.java |  4 ++--
 src/class179/Code06_NotForget1.java    | 22 +++++++++++-----------
 src/class179/Code06_NotForget2.java    | 24 ++++++++++++------------
 src/class179/Code07_RabbitHole2.java   |  2 +-
 5 files changed, 28 insertions(+), 33 deletions(-)

diff --git a/src/class149/SkipList2.java b/src/class149/SkipList2.java
index 29dab5a16..c2ea1cc14 100644
--- a/src/class149/SkipList2.java
+++ b/src/class149/SkipList2.java
@@ -14,12 +14,7 @@
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
 
-//#include <iostream>
-//#include <vector>
-//#include <algorithm>
-//#include <climits>
-//#include <cstdlib>
-//#include <cstring>
+//#include <bits/stdc++.h>
 //
 //using namespace std;
 //
@@ -52,7 +47,7 @@
 //
 //int randomLevel() {
 //    int ans = 1;
-//    while ((std::rand() / double(RAND_MAX)) < 0.5) {
+//    while ((rand() / double(RAND_MAX)) < 0.5) {
 //        ans++;
 //    }
 //    return min(ans, MAXL);
diff --git a/src/class179/Code04_MaximumMatch2.java b/src/class179/Code04_MaximumMatch2.java
index 09a04c36d..f0250d01b 100644
--- a/src/class179/Code04_MaximumMatch2.java
+++ b/src/class179/Code04_MaximumMatch2.java
@@ -57,7 +57,7 @@
 //
 //void build(int l, int r, int i) {
 //    if (l == r) {
-//    	match[i] = 0;
+//        match[i] = 0;
 //        resta[i] = 1;
 //        overb[i] = 0;
 //    } else {
@@ -71,7 +71,7 @@
 //void add(int jobv, int l, int r, int i) {
 //    if (l == r) {
 //        if (resta[i] == 1) {
-//        	match[i] = 1;
+//            match[i] = 1;
 //            resta[i] = 0;
 //        } else {
 //            overb[i]++;
diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index 461545d4e..22893d1f7 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -25,7 +25,7 @@ public class Code06_NotForget1 {
 	public static int MAXB = 401;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	// 每条查询的格式 : l、r、mod、id
+	// 每条查询的格式 : l、r、p、id
 	public static int[][] query = new int[MAXN][4];
 	public static int[] bi = new int[MAXN];
 
@@ -104,23 +104,23 @@ public static void del(int num) {
 		}
 	}
 
-	public static void setAns(int len, int mod, int id) {
+	public static void setAns(int len, int p, int id) {
 		int blen = (int) Math.sqrt(len);
 		int bnum = (len + blen - 1) / blen;
 		smlPower[0] = 1;
 		for (int i = 1; i <= blen; i++) {
-			smlPower[i] = (smlPower[i - 1] << 1) % mod;
+			smlPower[i] = (smlPower[i - 1] << 1) % p;
 		}
 		bigPower[0] = 1;
 		for (int i = 1; i <= bnum; i++) {
-			bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % mod;
+			bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % p;
 		}
 		long res = 0, tmp;
-		for (int p = head; p > 0; p = next[p]) {
-			tmp = bigPower[len / blen] * smlPower[len % blen] % mod;
-			tmp -= bigPower[(len - p) / blen] * smlPower[(len - p) % blen] % mod;
-			tmp = (tmp * sum[p]) % mod;
-			res = ((res + tmp) % mod + mod) % mod;
+		for (int t = head; t > 0; t = next[t]) {
+			tmp = bigPower[len / blen] * smlPower[len % blen] % p;
+			tmp -= bigPower[(len - t) / blen] * smlPower[(len - t) % blen] % p;
+			tmp = (tmp * sum[t]) % p;
+			res = ((res + tmp) % p + p) % p;
 		}
 		ans[id] = res;
 	}
@@ -130,7 +130,7 @@ public static void compute() {
 		for (int i = 1; i <= m; i++) {
 			int jobl = query[i][0];
 			int jobr = query[i][1];
-			int mod = query[i][2];
+			int jobp = query[i][2];
 			int id = query[i][3];
 			while (winl > jobl) {
 				add(arr[--winl]);
@@ -144,7 +144,7 @@ public static void compute() {
 			while (winr > jobr) {
 				del(arr[winr--]);
 			}
-			setAns(jobr - jobl + 1, mod, id);
+			setAns(jobr - jobl + 1, jobp, id);
 		}
 	}
 
diff --git a/src/class179/Code06_NotForget2.java b/src/class179/Code06_NotForget2.java
index cd851a8ad..cc0c70ab7 100644
--- a/src/class179/Code06_NotForget2.java
+++ b/src/class179/Code06_NotForget2.java
@@ -15,7 +15,7 @@
 //using namespace std;
 //
 //struct Query {
-//    int l, r, mod, id;
+//    int l, r, p, id;
 //};
 //
 //const int MAXN = 100001;
@@ -99,23 +99,23 @@
 //    }
 //}
 //
-//void setAns(int len, int mod, int id) {
+//void setAns(int len, int p, int id) {
 //    int blen = (int)sqrt(len);
 //    int bnum = (len + blen - 1) / blen;
 //    smlPower[0] = 1;
 //    for (int i = 1; i <= blen; i++) {
-//        smlPower[i] = (smlPower[i - 1] << 1) % mod;
+//        smlPower[i] = (smlPower[i - 1] << 1) % p;
 //    }
 //    bigPower[0] = 1;
 //    for (int i = 1; i <= bnum; i++) {
-//        bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % mod;
+//        bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % p;
 //    }
 //    long long res = 0, tmp;
-//    for (int p = head; p > 0; p = nxt[p]) {
-//        tmp = bigPower[len / blen] * smlPower[len % blen] % mod;
-//        tmp -= bigPower[(len - p) / blen] * smlPower[(len - p) % blen] % mod;
-//        tmp = (tmp * sum[p]) % mod;
-//        res = ((res + tmp) % mod + mod) % mod;
+//    for (int t = head; t > 0; t = nxt[t]) {
+//        tmp = bigPower[len / blen] * smlPower[len % blen] % p;
+//        tmp -= bigPower[(len - t) / blen] * smlPower[(len - t) % blen] % p;
+//        tmp = (tmp * sum[t]) % p;
+//        res = ((res + tmp) % p + p) % p;
 //    }
 //    ans[id] = res;
 //}
@@ -125,7 +125,7 @@
 //    for (int i = 1; i <= m; i++) {
 //        int jobl = query[i].l;
 //        int jobr = query[i].r;
-//        int mod = query[i].mod;
+//        int jobp = query[i].p;
 //        int id = query[i].id;
 //        while (winl > jobl) {
 //            add(arr[--winl]);
@@ -139,7 +139,7 @@
 //        while (winr > jobr) {
 //            del(arr[winr--]);
 //        }
-//        setAns(jobr - jobl + 1, mod, id);
+//        setAns(jobr - jobl + 1, jobp, id);
 //    }
 //}
 //
@@ -159,7 +159,7 @@
 //        cin >> arr[i];
 //    }
 //    for (int i = 1; i <= m; i++) {
-//        cin >> query[i].l >> query[i].r >> query[i].mod;
+//        cin >> query[i].l >> query[i].r >> query[i].p;
 //        query[i].id = i;
 //    }
 //    prepare();
diff --git a/src/class179/Code07_RabbitHole2.java b/src/class179/Code07_RabbitHole2.java
index 703130278..ca8b90594 100644
--- a/src/class179/Code07_RabbitHole2.java
+++ b/src/class179/Code07_RabbitHole2.java
@@ -101,7 +101,7 @@
 //
 //void prepare() {
 //    for (int i = 1; i <= n; i++) {
-//    	sorted[i] = arr[i];
+//        sorted[i] = arr[i];
 //    }
 //    sort(sorted + 1, sorted + n + 1);
 //    for (int i = 1; i <= n; i++) {

From 50caf64190db0614a069b744958e81383965b15b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 11:00:13 +0800
Subject: [PATCH 1459/1712] modify code

---
 src/class179/Code01_NiceDay1.java | 2 +-
 src/class179/Code01_NiceDay2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code01_NiceDay1.java b/src/class179/Code01_NiceDay1.java
index bccbfb9db..db5b0bd5f 100644
--- a/src/class179/Code01_NiceDay1.java
+++ b/src/class179/Code01_NiceDay1.java
@@ -27,7 +27,7 @@ public class Code01_NiceDay1 {
 	public static int[][] query = new int[MAXN][3];
 	public static int[] bi = new int[MAXN];
 
-	public static short[] cnt = new short[MAXV];
+	public static int[] cnt = new int[MAXV];
 	public static long num = 0;
 	public static long[] ans = new long[MAXN];
 
diff --git a/src/class179/Code01_NiceDay2.java b/src/class179/Code01_NiceDay2.java
index c95f62221..277c4da5a 100644
--- a/src/class179/Code01_NiceDay2.java
+++ b/src/class179/Code01_NiceDay2.java
@@ -24,7 +24,7 @@
 //Query query[MAXN];
 //
 //int bi[MAXN];
-//short cnt[MAXV];
+//int cnt[MAXV];
 //long long num = 0;
 //long long ans[MAXN];
 //

From 32f7d1531edbfbc9d94f5296ee5b66cf3add321a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 11:12:16 +0800
Subject: [PATCH 1460/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 16 ++++++++++------
 src/class179/Code02_SimpleQuery2.java | 16 ++++++++++------
 2 files changed, 20 insertions(+), 12 deletions(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index 5bfab3c42..893706391 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -63,20 +63,24 @@ public static void compute() {
 			int op = query[i][2];
 			int id = query[i][3];
 			while (win1 < job1) {
-				++cnt1[arr[++win1]];
+				win1++;
+				cnt1[arr[win1]]++;
 				sum += cnt2[arr[win1]];
 			}
 			while (win1 > job1) {
-				--cnt1[arr[win1]];
-				sum -= cnt2[arr[win1--]];
+				cnt1[arr[win1]]--;
+				sum -= cnt2[arr[win1]];
+				win1--;
 			}
 			while (win2 < job2) {
-				++cnt2[arr[++win2]];
+				win2++;
+				cnt2[arr[win2]]++;
 				sum += cnt1[arr[win2]];
 			}
 			while (win2 > job2) {
-				--cnt2[arr[win2]];
-				sum -= cnt1[arr[win2--]];
+				cnt2[arr[win2]]--;
+				sum -= cnt1[arr[win2]];
+				win2--;
 			}
 			ans[id] += sum * op;
 		}
diff --git a/src/class179/Code02_SimpleQuery2.java b/src/class179/Code02_SimpleQuery2.java
index a11f5337b..9980be569 100644
--- a/src/class179/Code02_SimpleQuery2.java
+++ b/src/class179/Code02_SimpleQuery2.java
@@ -56,20 +56,24 @@
 //        int op = query[i].op;
 //        int id = query[i].id;
 //        while (win1 < job1) {
-//            ++cnt1[arr[++win1]];
+//            win1++;
+//            cnt1[arr[win1]]++;
 //            sumv += cnt2[arr[win1]];
 //        }
 //        while (win1 > job1) {
-//            --cnt1[arr[win1]];
-//            sumv -= cnt2[arr[win1--]];
+//            cnt1[arr[win1]]--;
+//            sumv -= cnt2[arr[win1]];
+//            win1--;
 //        }
 //        while (win2 < job2) {
-//            ++cnt2[arr[++win2]];
+//            win2++;
+//            cnt2[arr[win2]]++;
 //            sumv += cnt1[arr[win2]];
 //        }
 //        while (win2 > job2) {
-//            --cnt2[arr[win2]];
-//            sumv -= cnt1[arr[win2--]];
+//            cnt2[arr[win2]]--;
+//            sumv -= cnt1[arr[win2]];
+//            win2--;
 //        }
 //        ans[id] += sumv * op;
 //    }

From 044de193037365d386fe2dc0818bd091c77df687 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 11:18:19 +0800
Subject: [PATCH 1461/1712] modify code

---
 src/class179/Code03_LCP2.java | 15 ++++++---------
 1 file changed, 6 insertions(+), 9 deletions(-)

diff --git a/src/class179/Code03_LCP2.java b/src/class179/Code03_LCP2.java
index 7952d06be..36ec5f3d5 100644
--- a/src/class179/Code03_LCP2.java
+++ b/src/class179/Code03_LCP2.java
@@ -99,22 +99,22 @@
 //}
 //
 //void prepare() {
-//	basePower[0] = 1;
+//    basePower[0] = 1;
 //    for (int i = 1; i <= n; i++) {
-//    	basePower[i] = basePower[i - 1] * base;
-//    	hashValue[i] = hashValue[i - 1] * base + (str[i] - 'a' + 1);
+//        basePower[i] = basePower[i - 1] * base;
+//        hashValue[i] = hashValue[i - 1] * base + (str[i] - 'a' + 1);
 //    }
 //    for (int l = 1, r = k; r <= n; l++, r++) {
 //        val[l] = hashValue[r] - hashValue[l - 1] * basePower[r - l + 1];
 //    }
 //    for (int i = 1; i <= len; i++) {
-//    	sorted[i] = val[i];
+//        sorted[i] = val[i];
 //    }
 //    sort(sorted + 1, sorted + len + 1);
 //    cntv = 1;
 //    for (int i = 2; i <= len; i++) {
 //        if (sorted[cntv] != sorted[i]) {
-//        	sorted[++cntv] = sorted[i];
+//            sorted[++cntv] = sorted[i];
 //        }
 //    }
 //    for (int i = 1; i <= len; i++) {
@@ -131,11 +131,8 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m >> k;
-//    string s;
-//    s.reserve(n);
-//    cin >> s;
 //    for (int i = 1; i <= n; i++) {
-//    	str[i] = s[i - 1];
+//        cin >> str[i];
 //    }
 //    len = n - k + 1;
 //    cntq = 0;

From ca56b6b8f57788e3ecf10bd9c028ee12eb68a59e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 11:20:12 +0800
Subject: [PATCH 1462/1712] modify code

---
 src/class179/Code04_MaximumMatch2.java | 14 +++++++-------
 1 file changed, 7 insertions(+), 7 deletions(-)

diff --git a/src/class179/Code04_MaximumMatch2.java b/src/class179/Code04_MaximumMatch2.java
index f0250d01b..a7a08f3fe 100644
--- a/src/class179/Code04_MaximumMatch2.java
+++ b/src/class179/Code04_MaximumMatch2.java
@@ -26,7 +26,7 @@
 //int n, m, z, q;
 //int a[MAXN];
 //int b[MAXM];
-//Query querys[MAXQ];
+//Query query[MAXQ];
 //int bi[MAXM];
 //
 //int match[MAXN << 2];
@@ -112,16 +112,16 @@
 //    for (int i = 1; i <= m; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
-//    sort(querys + 1, querys + q + 1, QueryCmp);
+//    sort(query + 1, query + q + 1, QueryCmp);
 //    build(1, n, 1);
 //}
 //
 //void compute() {
 //    int winl = 1, winr = 0;
 //    for (int i = 1; i <= q; i++) {
-//        int jobl = querys[i].l;
-//        int jobr = querys[i].r;
-//        int id   = querys[i].id;
+//        int jobl = query[i].l;
+//        int jobr = query[i].r;
+//        int id   = query[i].id;
 //        while (winl > jobl) {
 //            add(b[--winl], 1, n, 1);
 //        }
@@ -150,8 +150,8 @@
 //    }
 //    cin >> q;
 //    for (int i = 1; i <= q; i++) {
-//        cin >> querys[i].l >> querys[i].r;
-//        querys[i].id = i;
+//        cin >> query[i].l >> query[i].r;
+//        query[i].id = i;
 //    }
 //    prepare();
 //    compute();

From 8bc4f93bde02fdbb9b0abbeba398ec84fa80ec51 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 11:48:39 +0800
Subject: [PATCH 1463/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index 893706391..87df58a98 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -22,7 +22,7 @@ public class Code02_SimpleQuery1 {
 	public static int MAXN = 50001;
 	public static int n, q, cntq;
 	public static int[] arr = new int[MAXN];
-	// siz1、siz2、op、id
+	// 查询任务，siz1、siz2、op、id
 	public static int[][] query = new int[MAXN << 2][4];
 	public static int[] bi = new int[MAXN];
 

From 4e9fb35165c221ba13360f3f941887e650dd6a14 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 11:52:46 +0800
Subject: [PATCH 1464/1712] modify code

---
 src/class179/Code05_Homework1.java  | 2 +-
 src/class179/Code06_NotForget1.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code05_Homework1.java b/src/class179/Code05_Homework1.java
index 7cba8f9c2..82729a64a 100644
--- a/src/class179/Code05_Homework1.java
+++ b/src/class179/Code05_Homework1.java
@@ -21,7 +21,7 @@ public class Code05_Homework1 {
 	public static int MAXN = 100001;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	// l、r、a、b、id
+	// 查询任务，l、r、a、b、id
 	public static int[][] query = new int[MAXN][5];
 	public static int[] bi = new int[MAXN];
 	public static int[] bl = new int[MAXN];
diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index 22893d1f7..ca9bc2960 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -25,7 +25,7 @@ public class Code06_NotForget1 {
 	public static int MAXB = 401;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	// 每条查询的格式 : l、r、p、id
+	// 查询任务，l、r、p、id
 	public static int[][] query = new int[MAXN][4];
 	public static int[] bi = new int[MAXN];
 

From 1bc05b33f1d60e2a5a8a693fb051bdf6a82386c7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 1 Oct 2025 14:54:55 +0800
Subject: [PATCH 1465/1712] modify code

---
 src/class179/Code01_NiceDay1.java | 12 ++++++------
 src/class179/Code01_NiceDay2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class179/Code01_NiceDay1.java b/src/class179/Code01_NiceDay1.java
index db5b0bd5f..df6fdbe19 100644
--- a/src/class179/Code01_NiceDay1.java
+++ b/src/class179/Code01_NiceDay1.java
@@ -28,7 +28,7 @@ public class Code01_NiceDay1 {
 	public static int[] bi = new int[MAXN];
 
 	public static int[] cnt = new int[MAXV];
-	public static long num = 0;
+	public static long curAns = 0;
 	public static long[] ans = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
@@ -46,18 +46,18 @@ public int compare(int[] a, int[] b) {
 	}
 
 	public static void add(int s) {
-		num += cnt[s];
+		curAns += cnt[s];
 		cnt[s]++;
 		for (int i = 0; i < 26; i++) {
-			num += cnt[s ^ (1 << i)];
+			curAns += cnt[s ^ (1 << i)];
 		}
 	}
 
 	public static void del(int s) {
 		cnt[s]--;
-		num -= cnt[s];
+		curAns -= cnt[s];
 		for (int i = 0; i < 26; i++) {
-			num -= cnt[s ^ (1 << i)];
+			curAns -= cnt[s ^ (1 << i)];
 		}
 	}
 
@@ -79,7 +79,7 @@ public static void compute() {
 			while (winr > jobr) {
 				del(arr[winr--]);
 			}
-			ans[id] = num;
+			ans[id] = curAns;
 		}
 	}
 
diff --git a/src/class179/Code01_NiceDay2.java b/src/class179/Code01_NiceDay2.java
index 277c4da5a..ea16c0247 100644
--- a/src/class179/Code01_NiceDay2.java
+++ b/src/class179/Code01_NiceDay2.java
@@ -25,7 +25,7 @@
 //
 //int bi[MAXN];
 //int cnt[MAXV];
-//long long num = 0;
+//long long curAns = 0;
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -40,18 +40,18 @@
 //}
 //
 //void add(int s) {
-//    num += cnt[s];
+//    curAns += cnt[s];
 //    cnt[s]++;
 //    for (int i = 0; i < 26; i++) {
-//        num += cnt[s ^ (1 << i)];
+//        curAns += cnt[s ^ (1 << i)];
 //    }
 //}
 //
 //void del(int s) {
 //    cnt[s]--;
-//    num -= cnt[s];
+//    curAns -= cnt[s];
 //    for (int i = 0; i < 26; i++) {
-//        num -= cnt[s ^ (1 << i)];
+//        curAns -= cnt[s ^ (1 << i)];
 //    }
 //}
 //
@@ -73,7 +73,7 @@
 //        while (winr > jobr) {
 //            del(arr[winr--]);
 //        }
-//        ans[id] = num;
+//        ans[id] = curAns;
 //    }
 //}
 //

From 0a730c10d8402ddb9b418971aae528e20eb3ef4e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 13:31:56 +0800
Subject: [PATCH 1466/1712] modify code

---
 src/class179/Code02_SimpleQuery1.java | 15 +++++++++------
 src/class179/Code02_SimpleQuery2.java | 12 ++++++------
 2 files changed, 15 insertions(+), 12 deletions(-)

diff --git a/src/class179/Code02_SimpleQuery1.java b/src/class179/Code02_SimpleQuery1.java
index 87df58a98..ca739911d 100644
--- a/src/class179/Code02_SimpleQuery1.java
+++ b/src/class179/Code02_SimpleQuery1.java
@@ -26,9 +26,12 @@ public class Code02_SimpleQuery1 {
 	public static int[][] query = new int[MAXN << 2][4];
 	public static int[] bi = new int[MAXN];
 
+	// cnt1 : arr[1..siz1]范围内每种数字出现的次数
+	// cnt2 : arr[1..siz2]范围内每种数字出现的次数
 	public static int[] cnt1 = new int[MAXN];
 	public static int[] cnt2 = new int[MAXN];
-	public static long sum = 0;
+	public static long curAns = 0;
+
 	public static long[] ans = new long[MAXN];
 
 	public static class QueryCmp implements Comparator<int[]> {
@@ -65,24 +68,24 @@ public static void compute() {
 			while (win1 < job1) {
 				win1++;
 				cnt1[arr[win1]]++;
-				sum += cnt2[arr[win1]];
+				curAns += cnt2[arr[win1]];
 			}
 			while (win1 > job1) {
 				cnt1[arr[win1]]--;
-				sum -= cnt2[arr[win1]];
+				curAns -= cnt2[arr[win1]];
 				win1--;
 			}
 			while (win2 < job2) {
 				win2++;
 				cnt2[arr[win2]]++;
-				sum += cnt1[arr[win2]];
+				curAns += cnt1[arr[win2]];
 			}
 			while (win2 > job2) {
 				cnt2[arr[win2]]--;
-				sum -= cnt1[arr[win2]];
+				curAns -= cnt1[arr[win2]];
 				win2--;
 			}
-			ans[id] += sum * op;
+			ans[id] += curAns * op;
 		}
 	}
 
diff --git a/src/class179/Code02_SimpleQuery2.java b/src/class179/Code02_SimpleQuery2.java
index 9980be569..0379bc455 100644
--- a/src/class179/Code02_SimpleQuery2.java
+++ b/src/class179/Code02_SimpleQuery2.java
@@ -27,7 +27,7 @@
 //
 //int cnt1[MAXN];
 //int cnt2[MAXN];
-//long long sumv = 0;
+//long long curAns = 0;
 //long long ans[MAXN];
 //
 //bool QueryCmp(Query &a, Query &b) {
@@ -58,24 +58,24 @@
 //        while (win1 < job1) {
 //            win1++;
 //            cnt1[arr[win1]]++;
-//            sumv += cnt2[arr[win1]];
+//            curAns += cnt2[arr[win1]];
 //        }
 //        while (win1 > job1) {
 //            cnt1[arr[win1]]--;
-//            sumv -= cnt2[arr[win1]];
+//            curAns -= cnt2[arr[win1]];
 //            win1--;
 //        }
 //        while (win2 < job2) {
 //            win2++;
 //            cnt2[arr[win2]]++;
-//            sumv += cnt1[arr[win2]];
+//            curAns += cnt1[arr[win2]];
 //        }
 //        while (win2 > job2) {
 //            cnt2[arr[win2]]--;
-//            sumv -= cnt1[arr[win2]];
+//            curAns -= cnt1[arr[win2]];
 //            win2--;
 //        }
-//        ans[id] += sumv * op;
+//        ans[id] += curAns * op;
 //    }
 //}
 //

From e0942670a2fd503b6104cf382b98c2edc3429ac7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 14:19:24 +0800
Subject: [PATCH 1467/1712] modify code

---
 src/class179/Code03_LCP1.java | 5 +++--
 src/class179/Code03_LCP2.java | 4 ++--
 2 files changed, 5 insertions(+), 4 deletions(-)

diff --git a/src/class179/Code03_LCP1.java b/src/class179/Code03_LCP1.java
index 546902d51..d9451a655 100644
--- a/src/class179/Code03_LCP1.java
+++ b/src/class179/Code03_LCP1.java
@@ -123,8 +123,9 @@ public static void prepare() {
 		for (int i = 1; i <= len; i++) {
 			arr[i] = kth(val[i]);
 		}
-		int blen = Math.max(1, (int) ((double) len / Math.sqrt(cntq)));
-		for (int i = 1; i <= len; i++) {
+		// 块长优化
+		int blen = Math.max(1, (int) ((double) n / Math.sqrt(m)));
+		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
 		Arrays.sort(query, 1, cntq + 1, new QueryCmp());
diff --git a/src/class179/Code03_LCP2.java b/src/class179/Code03_LCP2.java
index 36ec5f3d5..3bddfcaee 100644
--- a/src/class179/Code03_LCP2.java
+++ b/src/class179/Code03_LCP2.java
@@ -120,8 +120,8 @@
 //    for (int i = 1; i <= len; i++) {
 //        arr[i] = kth(val[i]);
 //    }
-//    int blen = max(1, (int)((double)len / sqrt((double)cntq)));
-//    for (int i = 1; i <= len; i++) {
+//    int blen = max(1, (int)((double)n / sqrt((double)m)));
+//    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
 //    sort(query + 1, query + cntq + 1, QueryCmp);

From 77b2c2e969b13a0451736e1553e09ce2e72c201b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 14:37:50 +0800
Subject: [PATCH 1468/1712] modify code

---
 src/class179/Code03_LCP1.java | 8 +++-----
 src/class179/Code03_LCP2.java | 8 +++-----
 2 files changed, 6 insertions(+), 10 deletions(-)

diff --git a/src/class179/Code03_LCP1.java b/src/class179/Code03_LCP1.java
index d9451a655..390c4514d 100644
--- a/src/class179/Code03_LCP1.java
+++ b/src/class179/Code03_LCP1.java
@@ -68,15 +68,13 @@ public int compare(int[] a, int[] b) {
 	}
 
 	public static void add(int x) {
-		curAns -= cnt[x] * cnt[x];
+		curAns += cnt[x];
 		cnt[x]++;
-		curAns += cnt[x] * cnt[x];
 	}
 
 	public static void del(int x) {
-		curAns -= cnt[x] * cnt[x];
 		cnt[x]--;
-		curAns += cnt[x] * cnt[x];
+		curAns -= cnt[x];
 	}
 
 	public static void compute() {
@@ -97,7 +95,7 @@ public static void compute() {
 			while (winr > jobr) {
 				del(arr[winr--]);
 			}
-			ans[id] = (curAns - (jobr - jobl + 1)) / 2;
+			ans[id] = curAns;
 		}
 	}
 
diff --git a/src/class179/Code03_LCP2.java b/src/class179/Code03_LCP2.java
index 3bddfcaee..2947a62bd 100644
--- a/src/class179/Code03_LCP2.java
+++ b/src/class179/Code03_LCP2.java
@@ -65,15 +65,13 @@
 //}
 //
 //void add(int x) {
-//    curAns -= cnt[x] * cnt[x];
+//    curAns += cnt[x];
 //    cnt[x]++;
-//    curAns += cnt[x] * cnt[x];
 //}
 //
 //void del(int x) {
-//    curAns -= cnt[x] * cnt[x];
 //    cnt[x]--;
-//    curAns += cnt[x] * cnt[x];
+//    curAns -= cnt[x];
 //}
 //
 //void compute() {
@@ -94,7 +92,7 @@
 //        while (winr > jobr) {
 //            del(arr[winr--]);
 //        }
-//        ans[id] = (curAns - (jobr - jobl + 1)) / 2;
+//        ans[id] = curAns;
 //    }
 //}
 //

From 6dc85e8cb5468d9bdfdbd66c19323a91f8cf42b7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 14:54:20 +0800
Subject: [PATCH 1469/1712] modify code

---
 src/class179/Code03_LCP1.java | 8 ++++++--
 src/class179/Code03_LCP2.java | 2 +-
 2 files changed, 7 insertions(+), 3 deletions(-)

diff --git a/src/class179/Code03_LCP1.java b/src/class179/Code03_LCP1.java
index 390c4514d..7991882f0 100644
--- a/src/class179/Code03_LCP1.java
+++ b/src/class179/Code03_LCP1.java
@@ -26,16 +26,18 @@ public class Code03_LCP1 {
 	public static char[] str = new char[MAXN];
 	public static int[][] query = new int[MAXM][3];
 
+	// 字符串哈希
 	public static int base = 499;
 	public static long[] basePower = new long[MAXN];
 	public static long[] hashValue = new long[MAXN];
 
+	// 哈希值离散化，用哈希值替代字符串，再用排名替代哈希值
 	public static long[] val = new long[MAXN];
 	public static long[] sorted = new long[MAXN];
 	public static int[] arr = new int[MAXN];
 	public static int[] bi = new int[MAXN];
 
-	public static long[] cnt = new long[MAXN];
+	public static int[] cnt = new int[MAXN];
 	public static long curAns;
 	public static long[] ans = new long[MAXM];
 
@@ -121,7 +123,7 @@ public static void prepare() {
 		for (int i = 1; i <= len; i++) {
 			arr[i] = kth(val[i]);
 		}
-		// 块长优化
+		// 优化块长
 		int blen = Math.max(1, (int) ((double) n / Math.sqrt(m)));
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
@@ -138,11 +140,13 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			str[i] = in.nextLowerCase();
 		}
+		// 有效开头的个数，剩下的开头舍弃
 		len = n - k + 1;
 		cntq = 0;
 		for (int i = 1, l, r; i <= m; i++) {
 			l = in.nextInt();
 			r = in.nextInt();
+			// 过滤查询并调整查询参数
 			if (l <= len) {
 				query[++cntq][0] = l;
 				query[cntq][1] = Math.min(r, len);
diff --git a/src/class179/Code03_LCP2.java b/src/class179/Code03_LCP2.java
index 2947a62bd..548f6200c 100644
--- a/src/class179/Code03_LCP2.java
+++ b/src/class179/Code03_LCP2.java
@@ -35,7 +35,7 @@
 //int arr[MAXN];
 //int bi[MAXN];
 //
-//long long cnt[MAXN];
+//int cnt[MAXN];
 //long long curAns;
 //long long ans[MAXM];
 //

From 13151a7ed1deaf620d88760eade0f8905d431194 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 17:00:52 +0800
Subject: [PATCH 1470/1712] modify code

---
 src/class179/Code04_MaximumMatch1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class179/Code04_MaximumMatch1.java b/src/class179/Code04_MaximumMatch1.java
index eae88e726..f540dd9c4 100644
--- a/src/class179/Code04_MaximumMatch1.java
+++ b/src/class179/Code04_MaximumMatch1.java
@@ -30,9 +30,9 @@ public class Code04_MaximumMatch1 {
 	public static int[] bi = new int[MAXM];
 
 	// 线段树维护匹配信息，a[l..r]和b数组的数字进行匹配，l..r对应的信息在i位置
-	// match[i] = v，表示a[l..r]和b数组的数字，一共匹配了v对
-	// resta[i] = v，表示a[l..r]中还有v个数，可用于匹配b数组的数字
-	// overb[i] = v，表示a[l..r]已经耗尽，但是还有v个b数组的数字需要匹配
+	// match[i] = v，a[l..r]和b数组的数字，一共匹配了v对
+	// resta[i] = v，a[l..r]中还有v个数，可用于匹配b数组的数字
+	// overb[i] = v，a[l..r]已经耗尽，但是还有v个b数组的数字需要匹配
 	public static int[] match = new int[MAXN << 2];
 	public static int[] resta = new int[MAXN << 2];
 	public static int[] overb = new int[MAXN << 2];

From 8935a9532847fdce0ef3f4dc9f69152b647a0bb1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 18:44:43 +0800
Subject: [PATCH 1471/1712] modify code

---
 src/class179/Code04_MaximumMatch1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class179/Code04_MaximumMatch1.java b/src/class179/Code04_MaximumMatch1.java
index f540dd9c4..202331baa 100644
--- a/src/class179/Code04_MaximumMatch1.java
+++ b/src/class179/Code04_MaximumMatch1.java
@@ -32,7 +32,7 @@ public class Code04_MaximumMatch1 {
 	// 线段树维护匹配信息，a[l..r]和b数组的数字进行匹配，l..r对应的信息在i位置
 	// match[i] = v，a[l..r]和b数组的数字，一共匹配了v对
 	// resta[i] = v，a[l..r]中还有v个数，可用于匹配b数组的数字
-	// overb[i] = v，a[l..r]已经耗尽，但是还有v个b数组的数字需要匹配
+	// overb[i] = v，a[l..r]已经耗尽，但是还有v个b数组的数字没有满足
 	public static int[] match = new int[MAXN << 2];
 	public static int[] resta = new int[MAXN << 2];
 	public static int[] overb = new int[MAXN << 2];

From cdfbf04bc074446bee5b53eeadd5f8c032aa1c04 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 18:49:22 +0800
Subject: [PATCH 1472/1712] modify code

---
 src/class179/Code05_Homework1.java | 2 +-
 src/class179/Code05_Homework2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code05_Homework1.java b/src/class179/Code05_Homework1.java
index 82729a64a..35ab7635c 100644
--- a/src/class179/Code05_Homework1.java
+++ b/src/class179/Code05_Homework1.java
@@ -5,7 +5,7 @@
 // 查询 l r a b : 打印arr[l..r]范围上的两个答案
 //                答案1，数值范围在[a, b]的数字个数
 //                答案2，数值范围在[a, b]的数字种数
-// 1 <= n、m、arr[i] <= 10^5
+// 1 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4396
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class179/Code05_Homework2.java b/src/class179/Code05_Homework2.java
index e88e3efe6..8e1e34026 100644
--- a/src/class179/Code05_Homework2.java
+++ b/src/class179/Code05_Homework2.java
@@ -5,7 +5,7 @@
 // 查询 l r a b : 打印arr[l..r]范围上的两个答案
 //                答案1，数值范围在[a, b]的数字个数
 //                答案2，数值范围在[a, b]的数字种数
-// 1 <= n、m、arr[i] <= 10^5
+// 1 <= 所有数据 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4396
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 4a8f6c3a437d48ad1ac46d33c9b50ccd8de95d64 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 18:52:52 +0800
Subject: [PATCH 1473/1712] modify code

---
 src/class179/Code05_Homework1.java | 10 +++++-----
 src/class179/Code05_Homework2.java | 11 +++++------
 2 files changed, 10 insertions(+), 11 deletions(-)

diff --git a/src/class179/Code05_Homework1.java b/src/class179/Code05_Homework1.java
index 35ab7635c..e7c722c29 100644
--- a/src/class179/Code05_Homework1.java
+++ b/src/class179/Code05_Homework1.java
@@ -19,6 +19,7 @@
 public class Code05_Homework1 {
 
 	public static int MAXN = 100001;
+	public static int MAXV = 100000;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	// 查询任务，l、r、a、b、id
@@ -117,15 +118,14 @@ public static void compute() {
 	}
 
 	public static void prepare() {
-		int nv = MAXN - 1;
-		int blen = (int) Math.sqrt(nv);
-		int bnum = (nv + blen - 1) / blen;
-		for (int i = 1; i <= nv; i++) {
+		int blen = (int) Math.sqrt(MAXV);
+		int bnum = (MAXV + blen - 1) / blen;
+		for (int i = 1; i <= MAXV; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
 		for (int i = 1; i <= bnum; i++) {
 			bl[i] = (i - 1) * blen + 1;
-			br[i] = Math.min(i * blen, nv);
+			br[i] = Math.min(i * blen, MAXV);
 		}
 		Arrays.sort(query, 1, m + 1, new QueryCmp());
 	}
diff --git a/src/class179/Code05_Homework2.java b/src/class179/Code05_Homework2.java
index 8e1e34026..36c516ec6 100644
--- a/src/class179/Code05_Homework2.java
+++ b/src/class179/Code05_Homework2.java
@@ -19,7 +19,7 @@
 //};
 //
 //const int MAXN = 100001;
-//
+//const int MAXV = 100000;
 //int n, m;
 //int arr[MAXN];
 //Query query[MAXN];
@@ -114,15 +114,14 @@
 //}
 //
 //void prepare() {
-//    int nv = MAXN - 1;
-//    int blen = (int)sqrt(nv);
-//    int bnum = (nv + blen - 1) / blen;
-//    for (int i = 1; i <= nv; i++) {
+//    int blen = (int)sqrt(MAXV);
+//    int bnum = (MAXV + blen - 1) / blen;
+//    for (int i = 1; i <= MAXV; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }
 //    for (int i = 1; i <= bnum; i++) {
 //        bl[i] = (i - 1) * blen + 1;
-//        br[i] = min(i * blen, nv);
+//        br[i] = min(i * blen, MAXV);
 //    }
 //    sort(query + 1, query + m + 1, QueryCmp);
 //}

From 640b237fc254e3aaf5148febbeb23722ead048f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 2 Oct 2025 19:12:35 +0800
Subject: [PATCH 1474/1712] modify code

---
 src/class179/Code05_Homework1.java | 9 +++++----
 src/class179/Code05_Homework2.java | 9 +++++----
 2 files changed, 10 insertions(+), 8 deletions(-)

diff --git a/src/class179/Code05_Homework1.java b/src/class179/Code05_Homework1.java
index e7c722c29..fd7630692 100644
--- a/src/class179/Code05_Homework1.java
+++ b/src/class179/Code05_Homework1.java
@@ -20,17 +20,18 @@ public class Code05_Homework1 {
 
 	public static int MAXN = 100001;
 	public static int MAXV = 100000;
+	public static int MAXB = 401;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	// 查询任务，l、r、a、b、id
 	public static int[][] query = new int[MAXN][5];
 	public static int[] bi = new int[MAXN];
-	public static int[] bl = new int[MAXN];
-	public static int[] br = new int[MAXN];
+	public static int[] bl = new int[MAXB];
+	public static int[] br = new int[MAXB];
 
 	public static int[] numCnt = new int[MAXN];
-	public static int[] blockCnt = new int[MAXN];
-	public static int[] blockKind = new int[MAXN];
+	public static int[] blockCnt = new int[MAXB];
+	public static int[] blockKind = new int[MAXB];
 
 	public static int[] ans1 = new int[MAXN];
 	public static int[] ans2 = new int[MAXN];
diff --git a/src/class179/Code05_Homework2.java b/src/class179/Code05_Homework2.java
index 36c516ec6..e36803ddf 100644
--- a/src/class179/Code05_Homework2.java
+++ b/src/class179/Code05_Homework2.java
@@ -20,16 +20,17 @@
 //
 //const int MAXN = 100001;
 //const int MAXV = 100000;
+//const int MAXB = 401;
 //int n, m;
 //int arr[MAXN];
 //Query query[MAXN];
 //int bi[MAXN];
-//int bl[MAXN];
-//int br[MAXN];
+//int bl[MAXB];
+//int br[MAXB];
 //
 //int numCnt[MAXN];
-//int blockCnt[MAXN];
-//int blockKind[MAXN];
+//int blockCnt[MAXB];
+//int blockKind[MAXB];
 //
 //int ans1[MAXN];
 //int ans2[MAXN];

From 7f4ecca8316b0d1d3b8e8d373fb447c9eebd98a5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 09:54:08 +0800
Subject: [PATCH 1475/1712] modify code

---
 src/class179/Code06_NotForget1.java | 21 ++++++++++++++-------
 src/class179/Code06_NotForget2.java | 14 +++++++-------
 2 files changed, 21 insertions(+), 14 deletions(-)

diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index ca9bc2960..0a201778b 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -29,13 +29,20 @@ public class Code06_NotForget1 {
 	public static int[][] query = new int[MAXN][4];
 	public static int[] bi = new int[MAXN];
 
+	// 次数桶组成的链表
+	// 有数字进入次数桶，该次数桶才进入链表，链表内部不需要有序组织
 	public static int head;
 	public static int[] last = new int[MAXN];
 	public static int[] next = new int[MAXN];
 
+	// cnt[v] = c，表示v这个数出现了c次，也可以说v在c次桶里
+	// sum[c] = x，表示c次桶内的所有数字，每种数字只统计一次，累加和为x
 	public static int[] cnt = new int[MAXN];
 	public static long[] sum = new long[MAXN];
 
+	// 假设[l..r]范围长度len，blockLen为块的长度，blockNum为块的数量
+	// smlPower[i]，表示p的i次方的值，i <= blockLen
+	// bigPower[i]，表示p的(i * blockLen)次方的值，i <= blockNum
 	public static long[] smlPower = new long[MAXB];
 	public static long[] bigPower = new long[MAXB];
 
@@ -105,20 +112,20 @@ public static void del(int num) {
 	}
 
 	public static void setAns(int len, int p, int id) {
-		int blen = (int) Math.sqrt(len);
-		int bnum = (len + blen - 1) / blen;
+		int blockLen = (int) Math.sqrt(len);
+		int blockNum = (len + blockLen - 1) / blockLen;
 		smlPower[0] = 1;
-		for (int i = 1; i <= blen; i++) {
+		for (int i = 1; i <= blockLen; i++) {
 			smlPower[i] = (smlPower[i - 1] << 1) % p;
 		}
 		bigPower[0] = 1;
-		for (int i = 1; i <= bnum; i++) {
-			bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % p;
+		for (int i = 1; i <= blockNum; i++) {
+			bigPower[i] = (bigPower[i - 1] * smlPower[blockLen]) % p;
 		}
 		long res = 0, tmp;
 		for (int t = head; t > 0; t = next[t]) {
-			tmp = bigPower[len / blen] * smlPower[len % blen] % p;
-			tmp -= bigPower[(len - t) / blen] * smlPower[(len - t) % blen] % p;
+			tmp = bigPower[len / blockLen] * smlPower[len % blockLen] % p;
+			tmp -= bigPower[(len - t) / blockLen] * smlPower[(len - t) % blockLen] % p;
 			tmp = (tmp * sum[t]) % p;
 			res = ((res + tmp) % p + p) % p;
 		}
diff --git a/src/class179/Code06_NotForget2.java b/src/class179/Code06_NotForget2.java
index cc0c70ab7..7d9b74740 100644
--- a/src/class179/Code06_NotForget2.java
+++ b/src/class179/Code06_NotForget2.java
@@ -100,20 +100,20 @@
 //}
 //
 //void setAns(int len, int p, int id) {
-//    int blen = (int)sqrt(len);
-//    int bnum = (len + blen - 1) / blen;
+//    int blockLen = (int)sqrt(len);
+//    int blockNum = (len + blockLen - 1) / blockLen;
 //    smlPower[0] = 1;
-//    for (int i = 1; i <= blen; i++) {
+//    for (int i = 1; i <= blockLen; i++) {
 //        smlPower[i] = (smlPower[i - 1] << 1) % p;
 //    }
 //    bigPower[0] = 1;
-//    for (int i = 1; i <= bnum; i++) {
-//        bigPower[i] = (bigPower[i - 1] * smlPower[blen]) % p;
+//    for (int i = 1; i <= blockNum; i++) {
+//        bigPower[i] = (bigPower[i - 1] * smlPower[blockLen]) % p;
 //    }
 //    long long res = 0, tmp;
 //    for (int t = head; t > 0; t = nxt[t]) {
-//        tmp = bigPower[len / blen] * smlPower[len % blen] % p;
-//        tmp -= bigPower[(len - t) / blen] * smlPower[(len - t) % blen] % p;
+//        tmp = bigPower[len / blockLen] * smlPower[len % blockLen] % p;
+//        tmp -= bigPower[(len - t) / blockLen] * smlPower[(len - t) % blockLen] % p;
 //        tmp = (tmp * sum[t]) % p;
 //        res = ((res + tmp) % p + p) % p;
 //    }

From f085d46a59bccaf604f3a631aa72a6644a3fe8a9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 09:56:55 +0800
Subject: [PATCH 1476/1712] modify code

---
 src/class179/Code06_NotForget1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index 0a201778b..1b4605518 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -36,7 +36,7 @@ public class Code06_NotForget1 {
 	public static int[] next = new int[MAXN];
 
 	// cnt[v] = c，表示v这个数出现了c次，也可以说v在c次桶里
-	// sum[c] = x，表示c次桶内的所有数字，每种数字只统计一次，累加和为x
+	// sum[c] = x，表示c次桶内的数字，每种数字只统计一次，累加和为x
 	public static int[] cnt = new int[MAXN];
 	public static long[] sum = new long[MAXN];
 

From 90059de11c3bc50b34fe923dc5f74f44fbb59b10 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 10:27:07 +0800
Subject: [PATCH 1477/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 25 ++++++++++++-------------
 src/class179/Code08_YnoiCornfield2.java | 25 ++++++++++++-------------
 2 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index 336f5079a..53b8f2c96 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -115,8 +115,8 @@ public boolean andOtherMoveRight(BitSet other, int k) {
 	public static BitSet bitSet2 = new BitSet(MAXN);
 
 	public static int[] cnt = new int[MAXN];
-	public static int[] lastPos = new int[MAXN];
-	public static int[] maxLeft = new int[MAXN];
+	public static int[] pre = new int[MAXN];
+	public static int[] dp = new int[MAXN];
 
 	public static boolean[] ans = new boolean[MAXN];
 
@@ -211,25 +211,24 @@ public static void compute() {
 	public static void special() {
 		for (int x = 1; x < blen; x++) {
 			if (headq[x] != 0) {
-				Arrays.fill(lastPos, 0);
-				Arrays.fill(maxLeft, 0);
-				int last = 0;
+				Arrays.fill(pre, 0);
+				Arrays.fill(dp, 0);
 				for (int i = 1; i <= n; i++) {
-					int val = arr[i];
-					lastPos[val] = i;
-					if (val * x <= MAXV) {
-						last = Math.max(last, lastPos[val * x]);
+					int v = arr[i];
+					pre[v] = i;
+					dp[i] = dp[i - 1];
+					if (v * x <= MAXV) {
+						dp[i] = Math.max(dp[i], pre[v * x]);
 					}
-					if (val % x == 0) {
-						last = Math.max(last, lastPos[val / x]);
+					if (v % x == 0) {
+						dp[i] = Math.max(dp[i], pre[v / x]);
 					}
-					maxLeft[i] = last;
 				}
 				for (int q = headq[x]; q > 0; q = nextq[q]) {
 					int l = ql[q];
 					int r = qr[q];
 					int id = qid[q];
-					ans[id] = l <= maxLeft[r];
+					ans[id] = l <= dp[r];
 				}
 			}
 		}
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index bedc3de69..ec3240b34 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -41,8 +41,8 @@
 //bitset<MAXN> bitSet2;
 //
 //int cnt[MAXN];
-//int lastPos[MAXN];
-//int maxLeft[MAXN];
+//int pre[MAXN];
+//int dp[MAXN];
 //
 //bool ans[MAXN];
 //
@@ -132,25 +132,24 @@
 //void special() {
 //    for (int x = 1; x < blen; x++) {
 //        if (headq[x] != 0) {
-//            memset(lastPos, 0, sizeof(int) * (MAXV + 1));
-//            memset(maxLeft, 0, sizeof(int) * (n + 1));
-//            int last = 0;
+//            memset(pre, 0, sizeof(int) * (MAXV + 1));
+//            memset(dp, 0, sizeof(int) * (n + 1));
 //            for (int i = 1; i <= n; i++) {
-//                int val = arr[i];
-//                lastPos[val] = i;
-//                if (1LL * val * x <= MAXV) {
-//                    last = max(last, lastPos[val * x]);
+//                int v = arr[i];
+//                pre[v] = i;
+//                dp[i] = dp[i-1];
+//                if (v * x <= MAXV) {
+//                    dp[i] = max(dp[i], pre[v * x]);
 //                }
-//                if (val % x == 0) {
-//                    last = max(last, lastPos[val / x]);
+//                if (v % x == 0) {
+//                    dp[i] = max(dp[i], pre[v / x]);
 //                }
-//                maxLeft[i] = last;
 //            }
 //            for (int q = headq[x]; q > 0; q = nextq[q]) {
 //                int l = ql[q];
 //                int r = qr[q];
 //                int id = qid[q];
-//                ans[id] = (l <= maxLeft[r]);
+//                ans[id] = (l <= dp[r]);
 //            }
 //        }
 //    }

From 0859a3d813d8ae4188af46685244b8eaeae8b6c0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 10:42:12 +0800
Subject: [PATCH 1478/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 6 +++---
 src/class179/Code08_YnoiCornfield2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index 53b8f2c96..e3657feed 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -164,9 +164,9 @@ public static boolean calc(int op, int x) {
 		} else if (op == 2) {
 			return bitSet1.andOtherMoveRight(bitSet2, MAXV - x);
 		} else if (op == 3) {
-			for (int d = 1; d * d <= x; d++) {
-				if (x % d == 0) {
-					if (bitSet1.status(d) && bitSet1.status(x / d)) {
+			for (int f = 1; f * f <= x; f++) {
+				if (x % f == 0) {
+					if (bitSet1.status(f) && bitSet1.status(x / f)) {
 						return true;
 					}
 				}
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index ec3240b34..d186c8b09 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -87,9 +87,9 @@
 //    } else if (op == 2) {
 //        return (bitSet1 & (bitSet2 >> (MAXV - x))).any();
 //    } else if (op == 3) {
-//        for (int d = 1; d * d <= x; d++) {
-//            if (x % d == 0) {
-//                if (bitSet1[d] && bitSet1[x / d]) {
+//        for (int f = 1; f * f <= x; f++) {
+//            if (x % f == 0) {
+//                if (bitSet1[f] && bitSet1[x / f]) {
 //                    return true;
 //                }
 //            }

From 22492a73cc6df052e63292adb8eab13755f717e9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 11:04:03 +0800
Subject: [PATCH 1479/1712] modify code

---
 src/class179/Code06_NotForget1.java | 2 +-
 src/class179/Code06_NotForget2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index 1b4605518..2f5fb22c3 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -3,7 +3,7 @@
 // 盼君勿忘，java版
 // 一个序列中每种数字只保留一个，得到的累加和，叫做去重累加和
 // 给定一个长度为n的数组arr，接下来是m条查询，查询格式如下
-// 查询 l r p : arr[l..r]范围上，累加每个子序列的去重累加和 % p 的结果打印
+// 查询 l r p : arr[l..r]范围上，每个子序列的去重累加和，都累加起来 % p 的结果打印
 // 1 <= n、m、arr[i] <= 10^5
 // 1 <= p <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5072
diff --git a/src/class179/Code06_NotForget2.java b/src/class179/Code06_NotForget2.java
index 7d9b74740..0d5a56ba3 100644
--- a/src/class179/Code06_NotForget2.java
+++ b/src/class179/Code06_NotForget2.java
@@ -3,7 +3,7 @@
 // 盼君勿忘，C++版
 // 一个序列中每种数字只保留一个，得到的累加和，叫做去重累加和
 // 给定一个长度为n的数组arr，接下来是m条查询，查询格式如下
-// 查询 l r p : arr[l..r]范围上，累加每个子序列的去重累加和 % p 的结果打印
+// 查询 l r p : arr[l..r]范围上，每个子序列的去重累加和，都累加起来 % p 的结果打印
 // 1 <= n、m、arr[i] <= 10^5
 // 1 <= p <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P5072

From 421c7b76e64a4764a5c558b01de2fcf46e12001e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 12:42:15 +0800
Subject: [PATCH 1480/1712] modify code

---
 src/class179/Code06_NotForget1.java | 8 ++++----
 src/class179/Code06_NotForget2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index 2f5fb22c3..3a3623939 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -122,11 +122,11 @@ public static void setAns(int len, int p, int id) {
 		for (int i = 1; i <= blockNum; i++) {
 			bigPower[i] = (bigPower[i - 1] * smlPower[blockLen]) % p;
 		}
-		long res = 0, tmp;
+		long res = 0, p1, p2, tmp;
+		p1 = bigPower[len / blockLen] * smlPower[len % blockLen] % p;
 		for (int t = head; t > 0; t = next[t]) {
-			tmp = bigPower[len / blockLen] * smlPower[len % blockLen] % p;
-			tmp -= bigPower[(len - t) / blockLen] * smlPower[(len - t) % blockLen] % p;
-			tmp = (tmp * sum[t]) % p;
+			p2 = bigPower[(len - t) / blockLen] * smlPower[(len - t) % blockLen] % p;
+			tmp = (p1 - p2) * sum[t] % p;
 			res = ((res + tmp) % p + p) % p;
 		}
 		ans[id] = res;
diff --git a/src/class179/Code06_NotForget2.java b/src/class179/Code06_NotForget2.java
index 0d5a56ba3..53ff0b97b 100644
--- a/src/class179/Code06_NotForget2.java
+++ b/src/class179/Code06_NotForget2.java
@@ -110,11 +110,11 @@
 //    for (int i = 1; i <= blockNum; i++) {
 //        bigPower[i] = (bigPower[i - 1] * smlPower[blockLen]) % p;
 //    }
-//    long long res = 0, tmp;
+//    long long res = 0, p1, p2, tmp;
+//    p1 = bigPower[len / blockLen] * smlPower[len % blockLen] % p;
 //    for (int t = head; t > 0; t = nxt[t]) {
-//        tmp = bigPower[len / blockLen] * smlPower[len % blockLen] % p;
-//        tmp -= bigPower[(len - t) / blockLen] * smlPower[(len - t) % blockLen] % p;
-//        tmp = (tmp * sum[t]) % p;
+//        p2 = bigPower[(len - t) / blockLen] * smlPower[(len - t) % blockLen] % p;
+//        tmp = (p1 - p2) * sum[t] % p;
 //        res = ((res + tmp) % p + p) % p;
 //    }
 //    ans[id] = res;

From fc6b663dbdebabc2dbf11d79da80b3542145e44b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 13:24:49 +0800
Subject: [PATCH 1481/1712] modify code

---
 src/class179/Code06_NotForget1.java | 3 ++-
 1 file changed, 2 insertions(+), 1 deletion(-)

diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index 3a3623939..627e6ec8a 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -29,7 +29,7 @@ public class Code06_NotForget1 {
 	public static int[][] query = new int[MAXN][4];
 	public static int[] bi = new int[MAXN];
 
-	// 次数桶组成的链表
+	// 有效次数桶组成的双向链表
 	// 有数字进入次数桶，该次数桶才进入链表，链表内部不需要有序组织
 	public static int head;
 	public static int[] last = new int[MAXN];
@@ -122,6 +122,7 @@ public static void setAns(int len, int p, int id) {
 		for (int i = 1; i <= blockNum; i++) {
 			bigPower[i] = (bigPower[i - 1] * smlPower[blockLen]) % p;
 		}
+		// t次桶的贡献 = [2的len次方 - 2的(len-t)次方] * sum[t]
 		long res = 0, p1, p2, tmp;
 		p1 = bigPower[len / blockLen] * smlPower[len % blockLen] % p;
 		for (int t = head; t > 0; t = next[t]) {

From 486088e54a2316acde6e6c1384674950dd890716 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 15:37:21 +0800
Subject: [PATCH 1482/1712] modify code

---
 src/class179/Code07_RabbitHole1.java | 9 ++++++++-
 src/class179/Code07_RabbitHole2.java | 3 ++-
 2 files changed, 10 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code07_RabbitHole1.java b/src/class179/Code07_RabbitHole1.java
index b1ac8f65b..60c8f0545 100644
--- a/src/class179/Code07_RabbitHole1.java
+++ b/src/class179/Code07_RabbitHole1.java
@@ -71,13 +71,20 @@ public int getOnes() {
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
 	public static int[][] query = new int[MAXT * 3][3];
+
+	// 排序之后不去重
+	// 得到每个数字的排名
 	public static int[] sorted = new int[MAXN];
 	public static int[] bi = new int[MAXN];
 
+	// cnt[v] = c，表示窗口中数字v出现c次
 	public static int[] cnt = new int[MAXN];
+	// 当前窗口的位图
+	public static BitSet curSet;
+	// 问题从来没获得位图就拷贝，问题获得过位图就做&运算
 	public static boolean[] hasSet = new boolean[MAXT];
+	// 每个问题的位图
 	public static BitSet[] bitSet = new BitSet[MAXT];
-	public static BitSet curSet;
 
 	public static int[] ans = new int[MAXT];
 
diff --git a/src/class179/Code07_RabbitHole2.java b/src/class179/Code07_RabbitHole2.java
index ca8b90594..bab7f4ebc 100644
--- a/src/class179/Code07_RabbitHole2.java
+++ b/src/class179/Code07_RabbitHole2.java
@@ -25,13 +25,14 @@
 //const int MAXT = 30001;
 //int n, m;
 //int arr[MAXN];
+//
 //int sorted[MAXN];
 //int bi[MAXN];
 //
 //int cnt[MAXN];
+//bitset<MAXN> curSet;
 //bool hasSet[MAXT];
 //bitset<MAXN> bitSet[MAXT];
-//bitset<MAXN> curSet;
 //
 //Query query[MAXT * 3];
 //

From 916e033436320a7699ac49c2a453ad1dcc5dabea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 16:05:44 +0800
Subject: [PATCH 1483/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 28 ++++---------------------
 src/class179/Code08_YnoiCornfield2.java |  2 +-
 2 files changed, 5 insertions(+), 25 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index e3657feed..ddae22a49 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -50,27 +50,7 @@ public boolean andOther(BitSet other) {
 			return false;
 		}
 
-		// 检查 自己 & 自己左移k位 是否有非零位
-		public boolean andSelfMoveLeft(int k) {
-			int ws = k >> 6;
-			int bs = k & 63;
-			for (int i = len - 1; i >= 0; i--) {
-				int src = i - ws;
-				if (src < 0) {
-					break;
-				}
-				long shifted = (status[src] << bs);
-				if (bs != 0 && src - 1 >= 0) {
-					shifted |= (status[src - 1] >>> (64 - bs));
-				}
-				if ((status[i] & shifted) != 0L) {
-					return true;
-				}
-			}
-			return false;
-		}
-
-		// 检查 自己 & other右移k位 是否有非零位
+		// 检查 自己 & other右移k位 是否有1存在
 		public boolean andOtherMoveRight(BitSet other, int k) {
 			int ws = k >> 6;
 			int bs = k & 63;
@@ -79,9 +59,9 @@ public boolean andOtherMoveRight(BitSet other, int k) {
 				if (src >= len) {
 					break;
 				}
-				long shifted = (other.status[src] >>> bs);
+				long shifted = other.status[src] >>> bs;
 				if (bs != 0 && src + 1 < len) {
-					shifted |= (other.status[src + 1] << (64 - bs));
+					shifted |= other.status[src + 1] << (64 - bs);
 				}
 				if ((status[i] & shifted) != 0L) {
 					return true;
@@ -160,7 +140,7 @@ public static void del(int x) {
 
 	public static boolean calc(int op, int x) {
 		if (op == 1) {
-			return bitSet1.andSelfMoveLeft(x);
+			return bitSet1.andOtherMoveRight(bitSet1, x);
 		} else if (op == 2) {
 			return bitSet1.andOtherMoveRight(bitSet2, MAXV - x);
 		} else if (op == 3) {
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index d186c8b09..c4fbda333 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -83,7 +83,7 @@
 //
 //bool calc(int op, int x) {
 //    if (op == 1) {
-//        return (bitSet1 & (bitSet1 << x)).any();
+//        return (bitSet1 & (bitSet1 >> x)).any();
 //    } else if (op == 2) {
 //        return (bitSet1 & (bitSet2 >> (MAXV - x))).any();
 //    } else if (op == 3) {

From e688fa7dc36216af0e81344d32426dc0720d86f5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 17:35:05 +0800
Subject: [PATCH 1484/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 6 ++----
 src/class179/Code08_YnoiCornfield2.java | 4 +---
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index ddae22a49..c26add98c 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -145,10 +145,8 @@ public static boolean calc(int op, int x) {
 			return bitSet1.andOtherMoveRight(bitSet2, MAXV - x);
 		} else if (op == 3) {
 			for (int f = 1; f * f <= x; f++) {
-				if (x % f == 0) {
-					if (bitSet1.status(f) && bitSet1.status(x / f)) {
-						return true;
-					}
+				if (x % f == 0 && bitSet1.status(f) && bitSet1.status(x / f)) {
+					return true;
 				}
 			}
 			return false;
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index c4fbda333..e5586a9d5 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -88,10 +88,8 @@
 //        return (bitSet1 & (bitSet2 >> (MAXV - x))).any();
 //    } else if (op == 3) {
 //        for (int f = 1; f * f <= x; f++) {
-//            if (x % f == 0) {
-//                if (bitSet1[f] && bitSet1[x / f]) {
+//            if (x % f == 0 && bitSet1[f] && bitSet1[x / f]) {
 //                    return true;
-//                }
 //            }
 //        }
 //        return false;

From a140ab6be60765e2f6ce74536c60b6f6d99340ea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 17:56:18 +0800
Subject: [PATCH 1485/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 25 +++++++++----------------
 src/class179/Code08_YnoiCornfield2.java |  2 +-
 2 files changed, 10 insertions(+), 17 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index c26add98c..83aeb6f02 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -37,23 +37,14 @@ public void setZero(int bit) {
 			status[bit >> 6] &= ~(1L << (bit & 63));
 		}
 
-		public boolean status(int bit) {
+		public boolean getStatus(int bit) {
 			return ((status[bit >> 6] >> (bit & 63)) & 1L) != 0L;
 		}
 
-		public boolean andOther(BitSet other) {
-			for (int i = 0; i < len; i++) {
-				if ((status[i] & other.status[i]) != 0L) {
-					return true;
-				}
-			}
-			return false;
-		}
-
 		// 检查 自己 & other右移k位 是否有1存在
-		public boolean andOtherMoveRight(BitSet other, int k) {
-			int ws = k >> 6;
-			int bs = k & 63;
+		public boolean andOtherMoveRight(BitSet other, int move) {
+			int ws = move >> 6;
+			int bs = move & 63;
 			for (int i = 0; i < len; i++) {
 				int src = i + ws;
 				if (src >= len) {
@@ -91,10 +82,12 @@ public boolean andOtherMoveRight(BitSet other, int k) {
 	public static int[] qid = new int[MAXN];
 	public static int cnts;
 
+	// 数字出现的词频
+	public static int[] cnt = new int[MAXN];
 	public static BitSet bitSet1 = new BitSet(MAXN);
 	public static BitSet bitSet2 = new BitSet(MAXN);
 
-	public static int[] cnt = new int[MAXN];
+	// 特别查询的dp过程
 	public static int[] pre = new int[MAXN];
 	public static int[] dp = new int[MAXN];
 
@@ -145,7 +138,7 @@ public static boolean calc(int op, int x) {
 			return bitSet1.andOtherMoveRight(bitSet2, MAXV - x);
 		} else if (op == 3) {
 			for (int f = 1; f * f <= x; f++) {
-				if (x % f == 0 && bitSet1.status(f) && bitSet1.status(x / f)) {
+				if (x % f == 0 && bitSet1.getStatus(f) && bitSet1.getStatus(x / f)) {
 					return true;
 				}
 			}
@@ -153,7 +146,7 @@ public static boolean calc(int op, int x) {
 		} else {
 			if (x >= 1) {
 				for (int i = 1; i * x <= MAXV; i++) {
-					if (bitSet1.status(i) && bitSet1.status(i * x)) {
+					if (bitSet1.getStatus(i) && bitSet1.getStatus(i * x)) {
 						return true;
 					}
 				}
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index e5586a9d5..cca64204f 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -37,10 +37,10 @@
 //int qid[MAXN];
 //int cnts = 0;
 //
+//int cnt[MAXN];
 //bitset<MAXN> bitSet1;
 //bitset<MAXN> bitSet2;
 //
-//int cnt[MAXN];
 //int pre[MAXN];
 //int dp[MAXN];
 //

From 931d279d81d5258ff7fb38321f538ba0ef99b127 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 18:04:13 +0800
Subject: [PATCH 1486/1712] modify code

---
 src/class179/Code08_YnoiCornfield1.java | 2 +-
 src/class179/Code08_YnoiCornfield2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class179/Code08_YnoiCornfield1.java b/src/class179/Code08_YnoiCornfield1.java
index 83aeb6f02..d97b8ee75 100644
--- a/src/class179/Code08_YnoiCornfield1.java
+++ b/src/class179/Code08_YnoiCornfield1.java
@@ -210,7 +210,7 @@ public static void main(String[] args) throws Exception {
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		m = in.nextInt();
-		blen = (int) Math.sqrt(n);
+		blen = (int) Math.sqrt(MAXV);
 		for (int i = 1; i <= n; i++) {
 			bi[i] = (i - 1) / blen + 1;
 		}
diff --git a/src/class179/Code08_YnoiCornfield2.java b/src/class179/Code08_YnoiCornfield2.java
index cca64204f..ccd8851fd 100644
--- a/src/class179/Code08_YnoiCornfield2.java
+++ b/src/class179/Code08_YnoiCornfield2.java
@@ -157,7 +157,7 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m;
-//    blen = (int)sqrt(n);
+//    blen = (int)sqrt(MAXV);
 //    for (int i = 1; i <= n; i++) {
 //        bi[i] = (i - 1) / blen + 1;
 //    }

From addd8092bcebf84a878fca5d197c40f7fa3bc6d7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 18:23:56 +0800
Subject: [PATCH 1487/1712] modify code

---
 ...74\345\220\210\345\272\224\347\224\250.pptx" | Bin 0 -> 54011 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243179\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2304-\350\216\253\351\230\237\347\273\274\345\220\210\345\272\224\347\224\250.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243179\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2304-\350\216\253\351\230\237\347\273\274\345\220\210\345\272\224\347\224\250.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243179\343\200\220\346\214\272\351\232\276\343\200\221\350\216\253\351\230\237\344\270\223\351\242\2304-\350\216\253\351\230\237\347\273\274\345\220\210\345\272\224\347\224\250.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..873f6938995dd6bdf5928935257a63413e3cb5b4
GIT binary patch
literal 54011
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%0AfCz5Vjmf
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
Mfc=uM%@?2k2Mi?>SpWb4

literal 0
HcmV?d00001


From d31e15fdc55b416bac353e118fdb2252a6b01f2b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 3 Oct 2025 19:56:09 +0800
Subject: [PATCH 1488/1712] modify code

---
 src/class179/Code06_NotForget1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class179/Code06_NotForget1.java b/src/class179/Code06_NotForget1.java
index 627e6ec8a..28c9efe44 100644
--- a/src/class179/Code06_NotForget1.java
+++ b/src/class179/Code06_NotForget1.java
@@ -40,6 +40,7 @@ public class Code06_NotForget1 {
 	public static int[] cnt = new int[MAXN];
 	public static long[] sum = new long[MAXN];
 
+	// 光速幂
 	// 假设[l..r]范围长度len，blockLen为块的长度，blockNum为块的数量
 	// smlPower[i]，表示p的i次方的值，i <= blockLen
 	// bigPower[i]，表示p的(i * blockLen)次方的值，i <= blockNum
@@ -112,6 +113,8 @@ public static void del(int num) {
 	}
 
 	public static void setAns(int len, int p, int id) {
+		// 光速幂
+		// 构建smlPower和bigPower
 		int blockLen = (int) Math.sqrt(len);
 		int blockNum = (len + blockLen - 1) / blockLen;
 		smlPower[0] = 1;

From ad968808d99e36145ef8122913563bc455851e4b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 5 Oct 2025 22:34:54 +0800
Subject: [PATCH 1489/1712] modify code

---
 src/class180/Code01_VirtualTree1.java | 270 ++++++++++++++++++++++++++
 src/class180/Code02_War1.java         | 246 +++++++++++++++++++++++
 2 files changed, 516 insertions(+)
 create mode 100644 src/class180/Code01_VirtualTree1.java
 create mode 100644 src/class180/Code02_War1.java

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
new file mode 100644
index 000000000..303b8c086
--- /dev/null
+++ b/src/class180/Code01_VirtualTree1.java
@@ -0,0 +1,270 @@
+package class180;
+
+// 虚树模版题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF613D
+// 测试链接 : https://codeforces.com/problemset/problem/613/D
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_VirtualTree1 {
+
+	public static int MAXN = 100001;
+	public static int MAXP = 20;
+	public static int n, q, k;
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headv = new int[MAXN];
+	public static int[] nextv = new int[MAXN];
+	public static int[] tov = new int[MAXN];
+	public static int cntv;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int cntd;
+
+	// 节点编号、dfn序
+	public static int[][] arr = new int[MAXN][2];
+	public static boolean[] isKey = new boolean[MAXN];
+
+	// 第一种建树方式
+	public static int[][] tmp = new int[MAXN << 1][2];
+
+	// 第二种建树方式
+	public static int[] stack = new int[MAXN];
+	public static int top;
+
+	public static int[] siz = new int[MAXN];
+	public static int[] dp = new int[MAXN];
+
+	public static void addEdgeG(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addEdgeV(int u, int v) {
+		nextv[++cntv] = headv[u];
+		tov[cntv] = v;
+		headv[u] = cntv;
+	}
+
+	public static void dfs(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		dfn[u] = ++cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			if (tog[e] != fa) {
+				dfs(tog[e], u);
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	// 二次排序 + LCA连边的方式建立虚树
+	public static void buildVirtualTree1() {
+		Arrays.sort(arr, 1, k + 1, (a, b) -> a[1] - b[1]);
+		int len = 0;
+		for (int i = 1; i < k; i++) {
+			tmp[++len][0] = arr[i][0];
+			tmp[len][1] = arr[i][1];
+			int lca = getLca(arr[i][0], arr[i + 1][0]);
+			tmp[++len][0] = lca;
+			tmp[len][1] = dfn[lca];
+		}
+		tmp[++len][0] = arr[k][0];
+		tmp[len][1] = arr[k][1];
+		tmp[++len][0] = 1;
+		tmp[len][1] = dfn[1];
+		Arrays.sort(tmp, 1, len + 1, (a, b) -> a[1] - b[1]);
+		int unique = 1;
+		for (int i = 2; i <= len; i++) {
+			if (tmp[unique][0] != tmp[i][0]) {
+				tmp[++unique][0] = tmp[i][0];
+				tmp[unique][1] = tmp[i][1];
+			}
+		}
+		cntv = 0;
+		for (int i = 1; i <= unique; i++) {
+			headv[tmp[i][0]] = 0;
+		}
+		for (int i = 1; i < unique; i++) {
+			addEdgeV(getLca(tmp[i][0], tmp[i + 1][0]), tmp[i + 1][0]);
+		}
+	}
+
+	// 单调栈的方式建立虚树
+	public static void buildVirtualTree2() {
+		Arrays.sort(arr, 1, k + 1, (a, b) -> a[1] - b[1]);
+		cntv = 0;
+		top = 0;
+		headv[1] = 0;
+		stack[++top] = 1;
+		for (int i = 1; i <= k; i++) {
+			int x = arr[i][0];
+			if (x == 1) {
+				continue;
+			}
+			int y = stack[top];
+			int lca = getLca(x, y);
+			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
+				addEdgeV(stack[top - 1], stack[top]);
+				top--;
+			}
+			if (lca != stack[top]) {
+				headv[lca] = 0;
+				addEdgeV(lca, stack[top]);
+				top--;
+				stack[++top] = lca;
+			}
+			headv[x] = 0;
+			stack[++top] = x;
+		}
+		while (top > 1) {
+			addEdgeV(stack[top - 1], stack[top]);
+			top--;
+		}
+	}
+
+	public static void dpOnTree(int u, int fa) {
+		dp[u] = siz[u] = 0;
+		for (int e = headv[u], v; e > 0; e = nextv[e]) {
+			v = tov[e];
+			if (v != fa) {
+				dpOnTree(v, u);
+				dp[u] += dp[v];
+				siz[u] += siz[v];
+			}
+		}
+		if (isKey[u]) {
+			dp[u] += siz[u];
+			siz[u] = 1;
+		} else if (siz[u] > 1) {
+			dp[u]++;
+			siz[u] = 0;
+		}
+	}
+
+	public static int compute() {
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i][0]] = true;
+		}
+		boolean check = true;
+		for (int i = 1; i <= k; i++) {
+			if (isKey[stjump[arr[i][0]][0]]) {
+				check = false;
+				break;
+			}
+		}
+		int ans = -1;
+		if (check) {
+			// buildVirtualTree1();
+			buildVirtualTree2();
+			dpOnTree(1, 0);
+			ans = dp[1];
+		}
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i][0]] = false;
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdgeG(u, v);
+			addEdgeG(v, u);
+		}
+		dfs(1, 0);
+		q = in.nextInt();
+		for (int t = 1; t <= q; t++) {
+			k = in.nextInt();
+			for (int i = 1, node; i <= k; i++) {
+				node = in.nextInt();
+				arr[i][0] = node;
+				arr[i][1] = dfn[node];
+			}
+			out.println(compute());
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class180/Code02_War1.java b/src/class180/Code02_War1.java
new file mode 100644
index 000000000..64cc76b71
--- /dev/null
+++ b/src/class180/Code02_War1.java
@@ -0,0 +1,246 @@
+package class180;
+
+// 消耗战，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2495
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_War1 {
+
+	public static int MAXN = 300001;
+	public static int MAXP = 20;
+	public static int n, m, k;
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int[] weightg = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headv = new int[MAXN];
+	public static int[] nextv = new int[MAXN];
+	public static int[] tov = new int[MAXN];
+	public static int[] weightv = new int[MAXN];
+	public static int cntv;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int[][] mindist = new int[MAXN][MAXP];
+	public static int cntd;
+
+	// 节点编号、dfn序
+	public static int[][] arr = new int[MAXN][2];
+	public static boolean[] isKey = new boolean[MAXN];
+	public static int[] stack = new int[MAXN];
+	public static int top;
+
+	public static long[] dp = new long[MAXN];
+
+	public static void addEdgeG(int u, int v, int w) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		weightg[cntg] = w;
+		headg[u] = cntg;
+	}
+
+	public static void addEdgeV(int u, int v, int w) {
+		nextv[++cntv] = headv[u];
+		tov[cntv] = v;
+		weightv[cntv] = w;
+		headv[u] = cntv;
+	}
+
+	public static void dfs(int u, int fa, int w) {
+		dep[u] = dep[fa] + 1;
+		dfn[u] = ++cntd;
+		stjump[u][0] = fa;
+		mindist[u][0] = w;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+			mindist[u][p] = Math.min(mindist[u][p - 1], mindist[stjump[u][p - 1]][p - 1]);
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			if (tog[e] != fa) {
+				dfs(tog[e], u, weightg[e]);
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int getDist(int a, int b) {
+		int dist = 100000001;
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				dist = Math.min(dist, mindist[a][p]);
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return dist;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				dist = Math.min(dist, Math.min(mindist[a][p], mindist[b][p]));
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return dist;
+	}
+
+	public static void buildVirtualTree() {
+		Arrays.sort(arr, 1, k + 1, (a, b) -> a[1] - b[1]);
+		cntv = 0;
+		top = 0;
+		headv[1] = 0;
+		stack[++top] = 1;
+		for (int i = 1; i <= k; i++) {
+			int x = arr[i][0];
+			int y = stack[top];
+			int lca = getLca(x, y);
+			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
+				addEdgeV(stack[top - 1], stack[top], getDist(stack[top - 1], stack[top]));
+				top--;
+			}
+			if (lca != stack[top]) {
+				headv[lca] = 0;
+				addEdgeV(lca, stack[top], getDist(lca, stack[top]));
+				top--;
+				stack[++top] = lca;
+			}
+			headv[x] = 0;
+			stack[++top] = x;
+		}
+		while (top > 1) {
+			addEdgeV(stack[top - 1], stack[top], getDist(stack[top - 1], stack[top]));
+			top--;
+		}
+	}
+
+	public static void dpOnTree(int u) {
+		for (int e = headv[u]; e > 0; e = nextv[e]) {
+			dpOnTree(tov[e]);
+		}
+		dp[u] = 0;
+		for (int e = headv[u], v, w; e > 0; e = nextv[e]) {
+			v = tov[e];
+			w = weightv[e];
+			if (isKey[v]) {
+				dp[u] += w;
+			} else {
+				dp[u] += Math.min(dp[v], w);
+			}
+		}
+	}
+
+	public static long compute() {
+		buildVirtualTree();
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i][0]] = true;
+		}
+		dpOnTree(1);
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i][0]] = false;
+		}
+		return dp[1];
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1, u, v, w; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextInt();
+			addEdgeG(u, v, w);
+			addEdgeG(v, u, w);
+		}
+		dfs(1, 0, 0);
+		m = in.nextInt();
+		for (int t = 1; t <= m; t++) {
+			k = in.nextInt();
+			for (int i = 1, node; i <= k; i++) {
+				node = in.nextInt();
+				arr[i][0] = node;
+				arr[i][1] = dfn[node];
+			}
+			out.println(compute());
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 0ef834afd986b2ffaecbc452d81c7832f6d71fa5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 5 Oct 2025 22:36:20 +0800
Subject: [PATCH 1490/1712] modify code

---
 src/class180/Code02_War1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class180/Code02_War1.java b/src/class180/Code02_War1.java
index 64cc76b71..81f8f7b58 100644
--- a/src/class180/Code02_War1.java
+++ b/src/class180/Code02_War1.java
@@ -121,6 +121,7 @@ public static int getDist(int a, int b) {
 		return dist;
 	}
 
+	// 单调栈的方式建立虚树
 	public static void buildVirtualTree() {
 		Arrays.sort(arr, 1, k + 1, (a, b) -> a[1] - b[1]);
 		cntv = 0;

From 809d2bfc3ce5224f77aa42ada26ab35ff0c7da45 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 6 Oct 2025 09:19:21 +0800
Subject: [PATCH 1491/1712] modify code

---
 src/class142/Code04_Measurer1.java | 32 ++++++++++++++++++++----------
 src/class142/Code04_Measurer2.java |  5 ++++-
 2 files changed, 26 insertions(+), 11 deletions(-)

diff --git a/src/class142/Code04_Measurer1.java b/src/class142/Code04_Measurer1.java
index 9fa58f560..11a1a7e00 100644
--- a/src/class142/Code04_Measurer1.java
+++ b/src/class142/Code04_Measurer1.java
@@ -105,7 +105,10 @@ public static boolean check(double limit) {
 		// 倍杀关系的建边
 		for (int i = 1; i <= m1; i++) {
 			if (vow[i][0] == 1) {
-				addEdge(vow[i][1], vow[i][2], -Math.log(-limit + vow[i][3]));
+				// 课上的代码没有这个判断，加上才是正确的，防止log里出现负数
+				if (-limit + vow[i][3] >= 0) {
+					addEdge(vow[i][1], vow[i][2], -Math.log(-limit + vow[i][3]));
+				}
 			} else {
 				// 因为类型2的誓言是<关系，所以减去最小精度后，就可以认为是<=关系
 				addEdge(vow[i][1], vow[i][2], Math.log(limit + vow[i][3] - sml));
@@ -152,18 +155,27 @@ public static void main(String[] args) throws IOException {
 		BufferedReader br = new BufferedReader(new InputStreamReader(System.in));
 		StreamTokenizer in = new StreamTokenizer(br);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
-		in.nextToken(); n = (int) in.nval;
-		in.nextToken(); m1 = (int) in.nval;
-		in.nextToken(); m2 = (int) in.nval;
+		in.nextToken();
+		n = (int) in.nval;
+		in.nextToken();
+		m1 = (int) in.nval;
+		in.nextToken();
+		m2 = (int) in.nval;
 		for (int i = 1; i <= m1; i++) {
-			in.nextToken(); vow[i][0] = (int) in.nval;
-			in.nextToken(); vow[i][1] = (int) in.nval;
-			in.nextToken(); vow[i][2] = (int) in.nval;
-			in.nextToken(); vow[i][3] = (int) in.nval;
+			in.nextToken();
+			vow[i][0] = (int) in.nval;
+			in.nextToken();
+			vow[i][1] = (int) in.nval;
+			in.nextToken();
+			vow[i][2] = (int) in.nval;
+			in.nextToken();
+			vow[i][3] = (int) in.nval;
 		}
 		for (int i = 1; i <= m2; i++) {
-			in.nextToken(); score[i][0] = (int) in.nval;
-			in.nextToken(); score[i][1] = (int) in.nval;
+			in.nextToken();
+			score[i][0] = (int) in.nval;
+			in.nextToken();
+			score[i][1] = (int) in.nval;
 		}
 		double ans = compute();
 		if (ans == 0) {
diff --git a/src/class142/Code04_Measurer2.java b/src/class142/Code04_Measurer2.java
index e31364eba..7e4ec34a6 100644
--- a/src/class142/Code04_Measurer2.java
+++ b/src/class142/Code04_Measurer2.java
@@ -89,7 +89,10 @@ public static boolean check(double limit) {
 		}
 		for (int i = 1; i <= m1; i++) {
 			if (vow[i][0] == 1) {
-				addEdge(vow[i][1], vow[i][2], -Math.log(-limit + vow[i][3]));
+				// 课上的代码没有这个判断，加上才是正确的，防止log里出现负数
+				if (-limit + vow[i][3] >= 0) {
+					addEdge(vow[i][1], vow[i][2], -Math.log(-limit + vow[i][3]));
+				}
 			} else {
 				addEdge(vow[i][1], vow[i][2], Math.log(limit + vow[i][3]));
 			}

From a4775115a1dfcfb0c5bc11af4efad941c929992b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 6 Oct 2025 09:47:45 +0800
Subject: [PATCH 1492/1712] modify code

---
 src/class180/Code01_VirtualTree1.java | 65 +++++++++++++++------------
 src/class180/Code02_War1.java         | 35 ++++++++++-----
 2 files changed, 60 insertions(+), 40 deletions(-)

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
index 303b8c086..bd7a1b5e1 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_VirtualTree1.java
@@ -9,7 +9,6 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.util.Arrays;
 
 public class Code01_VirtualTree1 {
 
@@ -32,12 +31,11 @@ public class Code01_VirtualTree1 {
 	public static int[][] stjump = new int[MAXN][MAXP];
 	public static int cntd;
 
-	// 节点编号、dfn序
-	public static int[][] arr = new int[MAXN][2];
+	public static int[] arr = new int[MAXN];
 	public static boolean[] isKey = new boolean[MAXN];
 
 	// 第一种建树方式
-	public static int[][] tmp = new int[MAXN << 1][2];
+	public static int[] tmp = new int[MAXN << 1];
 
 	// 第二种建树方式
 	public static int[] stack = new int[MAXN];
@@ -58,6 +56,23 @@ public static void addEdgeV(int u, int v) {
 		headv[u] = cntv;
 	}
 
+	// nums中的数，根据dfn的大小排序，手撸双指针快排
+	public static void sortByDfn(int[] nums, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r;
+		int pivot = nums[(l + r) >> 1];
+		while (i <= j) {
+			while (dfn[nums[i]] < dfn[pivot]) i++;
+			while (dfn[nums[j]] > dfn[pivot]) j--;
+			if (i <= j) {
+				int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
+				i++; j--;
+			}
+		}
+		sortByDfn(nums, l, j);
+		sortByDfn(nums, i, r);
+	}
+
 	public static void dfs(int u, int fa) {
 		dep[u] = dep[fa] + 1;
 		dfn[u] = ++cntd;
@@ -97,45 +112,39 @@ public static int getLca(int a, int b) {
 
 	// 二次排序 + LCA连边的方式建立虚树
 	public static void buildVirtualTree1() {
-		Arrays.sort(arr, 1, k + 1, (a, b) -> a[1] - b[1]);
+		sortByDfn(arr, 1, k);
 		int len = 0;
 		for (int i = 1; i < k; i++) {
-			tmp[++len][0] = arr[i][0];
-			tmp[len][1] = arr[i][1];
-			int lca = getLca(arr[i][0], arr[i + 1][0]);
-			tmp[++len][0] = lca;
-			tmp[len][1] = dfn[lca];
+			tmp[++len] = arr[i];
+			tmp[++len] = getLca(arr[i], arr[i + 1]);
 		}
-		tmp[++len][0] = arr[k][0];
-		tmp[len][1] = arr[k][1];
-		tmp[++len][0] = 1;
-		tmp[len][1] = dfn[1];
-		Arrays.sort(tmp, 1, len + 1, (a, b) -> a[1] - b[1]);
+		tmp[++len] = arr[k];
+		tmp[++len] = 1;
+		sortByDfn(tmp, 1, len);
 		int unique = 1;
 		for (int i = 2; i <= len; i++) {
-			if (tmp[unique][0] != tmp[i][0]) {
-				tmp[++unique][0] = tmp[i][0];
-				tmp[unique][1] = tmp[i][1];
+			if (tmp[unique] != tmp[i]) {
+				tmp[++unique] = tmp[i];
 			}
 		}
 		cntv = 0;
 		for (int i = 1; i <= unique; i++) {
-			headv[tmp[i][0]] = 0;
+			headv[tmp[i]] = 0;
 		}
 		for (int i = 1; i < unique; i++) {
-			addEdgeV(getLca(tmp[i][0], tmp[i + 1][0]), tmp[i + 1][0]);
+			addEdgeV(getLca(tmp[i], tmp[i + 1]), tmp[i + 1]);
 		}
 	}
 
 	// 单调栈的方式建立虚树
 	public static void buildVirtualTree2() {
-		Arrays.sort(arr, 1, k + 1, (a, b) -> a[1] - b[1]);
+		sortByDfn(arr, 1, k);
 		cntv = 0;
 		top = 0;
 		headv[1] = 0;
 		stack[++top] = 1;
 		for (int i = 1; i <= k; i++) {
-			int x = arr[i][0];
+			int x = arr[i];
 			if (x == 1) {
 				continue;
 			}
@@ -181,11 +190,11 @@ public static void dpOnTree(int u, int fa) {
 
 	public static int compute() {
 		for (int i = 1; i <= k; i++) {
-			isKey[arr[i][0]] = true;
+			isKey[arr[i]] = true;
 		}
 		boolean check = true;
 		for (int i = 1; i <= k; i++) {
-			if (isKey[stjump[arr[i][0]][0]]) {
+			if (isKey[stjump[arr[i]][0]]) {
 				check = false;
 				break;
 			}
@@ -198,7 +207,7 @@ public static int compute() {
 			ans = dp[1];
 		}
 		for (int i = 1; i <= k; i++) {
-			isKey[arr[i][0]] = false;
+			isKey[arr[i]] = false;
 		}
 		return ans;
 	}
@@ -217,10 +226,8 @@ public static void main(String[] args) throws Exception {
 		q = in.nextInt();
 		for (int t = 1; t <= q; t++) {
 			k = in.nextInt();
-			for (int i = 1, node; i <= k; i++) {
-				node = in.nextInt();
-				arr[i][0] = node;
-				arr[i][1] = dfn[node];
+			for (int i = 1; i <= k; i++) {
+				arr[i] = in.nextInt();
 			}
 			out.println(compute());
 		}
diff --git a/src/class180/Code02_War1.java b/src/class180/Code02_War1.java
index 81f8f7b58..fc7498f27 100644
--- a/src/class180/Code02_War1.java
+++ b/src/class180/Code02_War1.java
@@ -8,7 +8,6 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
-import java.util.Arrays;
 
 public class Code02_War1 {
 
@@ -34,8 +33,7 @@ public class Code02_War1 {
 	public static int[][] mindist = new int[MAXN][MAXP];
 	public static int cntd;
 
-	// 节点编号、dfn序
-	public static int[][] arr = new int[MAXN][2];
+	public static int[] arr = new int[MAXN];
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] stack = new int[MAXN];
 	public static int top;
@@ -56,6 +54,23 @@ public static void addEdgeV(int u, int v, int w) {
 		headv[u] = cntv;
 	}
 
+	// nums中的数，根据dfn的大小排序，手撸双指针快排
+	public static void sortByDfn(int[] nums, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r;
+		int pivot = nums[(l + r) >> 1];
+		while (i <= j) {
+			while (dfn[nums[i]] < dfn[pivot]) i++;
+			while (dfn[nums[j]] > dfn[pivot]) j--;
+			if (i <= j) {
+				int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
+				i++; j--;
+			}
+		}
+		sortByDfn(nums, l, j);
+		sortByDfn(nums, i, r);
+	}
+
 	public static void dfs(int u, int fa, int w) {
 		dep[u] = dep[fa] + 1;
 		dfn[u] = ++cntd;
@@ -123,13 +138,13 @@ public static int getDist(int a, int b) {
 
 	// 单调栈的方式建立虚树
 	public static void buildVirtualTree() {
-		Arrays.sort(arr, 1, k + 1, (a, b) -> a[1] - b[1]);
+		sortByDfn(arr, 1, k);
 		cntv = 0;
 		top = 0;
 		headv[1] = 0;
 		stack[++top] = 1;
 		for (int i = 1; i <= k; i++) {
-			int x = arr[i][0];
+			int x = arr[i];
 			int y = stack[top];
 			int lca = getLca(x, y);
 			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
@@ -170,11 +185,11 @@ public static void dpOnTree(int u) {
 	public static long compute() {
 		buildVirtualTree();
 		for (int i = 1; i <= k; i++) {
-			isKey[arr[i][0]] = true;
+			isKey[arr[i]] = true;
 		}
 		dpOnTree(1);
 		for (int i = 1; i <= k; i++) {
-			isKey[arr[i][0]] = false;
+			isKey[arr[i]] = false;
 		}
 		return dp[1];
 	}
@@ -194,10 +209,8 @@ public static void main(String[] args) throws Exception {
 		m = in.nextInt();
 		for (int t = 1; t <= m; t++) {
 			k = in.nextInt();
-			for (int i = 1, node; i <= k; i++) {
-				node = in.nextInt();
-				arr[i][0] = node;
-				arr[i][1] = dfn[node];
+			for (int i = 1; i <= k; i++) {
+				arr[i] = in.nextInt();
 			}
 			out.println(compute());
 		}

From c4f4fb4a43419807e2bdfd5e65ba1555a1869d4c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 6 Oct 2025 09:48:15 +0800
Subject: [PATCH 1493/1712] modify code

---
 src/class180/Code02_War1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class180/Code02_War1.java b/src/class180/Code02_War1.java
index fc7498f27..679c7c945 100644
--- a/src/class180/Code02_War1.java
+++ b/src/class180/Code02_War1.java
@@ -54,7 +54,6 @@ public static void addEdgeV(int u, int v, int w) {
 		headv[u] = cntv;
 	}
 
-	// nums中的数，根据dfn的大小排序，手撸双指针快排
 	public static void sortByDfn(int[] nums, int l, int r) {
 		if (l >= r) return;
 		int i = l, j = r;

From 23c9dd536f863864166502aca416308c514110c0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 6 Oct 2025 09:55:50 +0800
Subject: [PATCH 1494/1712] modify code

---
 src/class180/Code02_War1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class180/Code02_War1.java b/src/class180/Code02_War1.java
index 679c7c945..68f8cb45d 100644
--- a/src/class180/Code02_War1.java
+++ b/src/class180/Code02_War1.java
@@ -144,6 +144,9 @@ public static void buildVirtualTree() {
 		stack[++top] = 1;
 		for (int i = 1; i <= k; i++) {
 			int x = arr[i];
+			if (x == 1) {
+				continue;
+			}
 			int y = stack[top];
 			int lca = getLca(x, y);
 			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {

From f42b690631dc99c7b0fd6b75692d2abec905b1e0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 6 Oct 2025 15:46:49 +0800
Subject: [PATCH 1495/1712] modify code

---
 src/class180/Code01_VirtualTree1.java | 3 +--
 src/class180/Code02_War1.java         | 4 +---
 2 files changed, 2 insertions(+), 5 deletions(-)

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
index bd7a1b5e1..50d7b9c3d 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_VirtualTree1.java
@@ -39,7 +39,6 @@ public class Code01_VirtualTree1 {
 
 	// 第二种建树方式
 	public static int[] stack = new int[MAXN];
-	public static int top;
 
 	public static int[] siz = new int[MAXN];
 	public static int[] dp = new int[MAXN];
@@ -140,8 +139,8 @@ public static void buildVirtualTree1() {
 	public static void buildVirtualTree2() {
 		sortByDfn(arr, 1, k);
 		cntv = 0;
-		top = 0;
 		headv[1] = 0;
+		int top = 0;
 		stack[++top] = 1;
 		for (int i = 1; i <= k; i++) {
 			int x = arr[i];
diff --git a/src/class180/Code02_War1.java b/src/class180/Code02_War1.java
index 68f8cb45d..8127cb731 100644
--- a/src/class180/Code02_War1.java
+++ b/src/class180/Code02_War1.java
@@ -36,8 +36,6 @@ public class Code02_War1 {
 	public static int[] arr = new int[MAXN];
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] stack = new int[MAXN];
-	public static int top;
-
 	public static long[] dp = new long[MAXN];
 
 	public static void addEdgeG(int u, int v, int w) {
@@ -139,8 +137,8 @@ public static int getDist(int a, int b) {
 	public static void buildVirtualTree() {
 		sortByDfn(arr, 1, k);
 		cntv = 0;
-		top = 0;
 		headv[1] = 0;
+		int top = 0;
 		stack[++top] = 1;
 		for (int i = 1; i <= k; i++) {
 			int x = arr[i];

From 8e6833ecbd5bd90d396b762033cb1b8796ff4a13 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Oct 2025 10:53:26 +0800
Subject: [PATCH 1496/1712] modify code

---
 src/class106/HashFunction.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class106/HashFunction.java b/src/class106/HashFunction.java
index 271bd35ea..aa1964e00 100644
--- a/src/class106/HashFunction.java
+++ b/src/class106/HashFunction.java
@@ -99,7 +99,7 @@ public static void main(String[] args) {
 //		for (String str : set) {
 //			System.out.println(str);
 //		}
-		System.out.println("不同哈希值的数量 : " + strs.size());
+		System.out.println("不同哈希值的数量 : " + set.size());
 		System.out.println();
 
 		int m = 13;

From 75d9745247be1540d9723fb8cf30fcdf8e179110 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 7 Oct 2025 11:05:56 +0800
Subject: [PATCH 1497/1712] modify code

---
 src/class105/{Code06_LikeLotusRoot.java => Code06_DNA.java} | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/class105/{Code06_LikeLotusRoot.java => Code06_DNA.java} (98%)

diff --git a/src/class105/Code06_LikeLotusRoot.java b/src/class105/Code06_DNA.java
similarity index 98%
rename from src/class105/Code06_LikeLotusRoot.java
rename to src/class105/Code06_DNA.java
index a35690401..3f6773cd4 100644
--- a/src/class105/Code06_LikeLotusRoot.java
+++ b/src/class105/Code06_DNA.java
@@ -15,7 +15,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code06_LikeLotusRoot {
+public class Code06_DNA {
 
 	public static int MAXN = 100001;
 

From 1f7a9f2a11116f6b07323511d94db65386c449a2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 8 Oct 2025 21:23:30 +0800
Subject: [PATCH 1498/1712] modify code

---
 src/class180/Code01_VirtualTree1.java | 34 +++++++++----------
 src/class180/Code02_War1.java         | 48 ++++++++++++++++++++++-----
 2 files changed, 55 insertions(+), 27 deletions(-)

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
index 50d7b9c3d..e8758fa57 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_VirtualTree1.java
@@ -110,7 +110,7 @@ public static int getLca(int a, int b) {
 	}
 
 	// 二次排序 + LCA连边的方式建立虚树
-	public static void buildVirtualTree1() {
+	public static int buildVirtualTree1() {
 		sortByDfn(arr, 1, k);
 		int len = 0;
 		for (int i = 1; i < k; i++) {
@@ -118,7 +118,6 @@ public static void buildVirtualTree1() {
 			tmp[++len] = getLca(arr[i], arr[i + 1]);
 		}
 		tmp[++len] = arr[k];
-		tmp[++len] = 1;
 		sortByDfn(tmp, 1, len);
 		int unique = 1;
 		for (int i = 2; i <= len; i++) {
@@ -133,20 +132,18 @@ public static void buildVirtualTree1() {
 		for (int i = 1; i < unique; i++) {
 			addEdgeV(getLca(tmp[i], tmp[i + 1]), tmp[i + 1]);
 		}
+		return tmp[1];
 	}
 
 	// 单调栈的方式建立虚树
-	public static void buildVirtualTree2() {
+	public static int buildVirtualTree2() {
 		sortByDfn(arr, 1, k);
 		cntv = 0;
-		headv[1] = 0;
+		headv[arr[1]] = 0;
 		int top = 0;
-		stack[++top] = 1;
-		for (int i = 1; i <= k; i++) {
+		stack[++top] = arr[1];
+		for (int i = 2; i <= k; i++) {
 			int x = arr[i];
-			if (x == 1) {
-				continue;
-			}
 			int y = stack[top];
 			int lca = getLca(x, y);
 			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
@@ -166,17 +163,16 @@ public static void buildVirtualTree2() {
 			addEdgeV(stack[top - 1], stack[top]);
 			top--;
 		}
+		return stack[1];
 	}
 
-	public static void dpOnTree(int u, int fa) {
+	public static void dpOnTree(int u) {
 		dp[u] = siz[u] = 0;
 		for (int e = headv[u], v; e > 0; e = nextv[e]) {
 			v = tov[e];
-			if (v != fa) {
-				dpOnTree(v, u);
-				dp[u] += dp[v];
-				siz[u] += siz[v];
-			}
+			dpOnTree(v);
+			dp[u] += dp[v];
+			siz[u] += siz[v];
 		}
 		if (isKey[u]) {
 			dp[u] += siz[u];
@@ -200,10 +196,10 @@ public static int compute() {
 		}
 		int ans = -1;
 		if (check) {
-			// buildVirtualTree1();
-			buildVirtualTree2();
-			dpOnTree(1, 0);
-			ans = dp[1];
+			int tree = buildVirtualTree1();
+			// int tree = buildVirtualTree2();
+			dpOnTree(tree);
+			ans = dp[tree];
 		}
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
diff --git a/src/class180/Code02_War1.java b/src/class180/Code02_War1.java
index 8127cb731..ea1d99d89 100644
--- a/src/class180/Code02_War1.java
+++ b/src/class180/Code02_War1.java
@@ -34,8 +34,9 @@ public class Code02_War1 {
 	public static int cntd;
 
 	public static int[] arr = new int[MAXN];
-	public static boolean[] isKey = new boolean[MAXN];
+	public static int[] tmp = new int[MAXN << 1];
 	public static int[] stack = new int[MAXN];
+	public static boolean[] isKey = new boolean[MAXN];
 	public static long[] dp = new long[MAXN];
 
 	public static void addEdgeG(int u, int v, int w) {
@@ -133,18 +134,47 @@ public static int getDist(int a, int b) {
 		return dist;
 	}
 
+	// 二次排序 + LCA连边的方式建立虚树
+	public static int buildVirtualTree1() {
+		sortByDfn(arr, 1, k);
+		int len = 0;
+		for (int i = 1; i < k; i++) {
+			tmp[++len] = arr[i];
+			tmp[++len] = getLca(arr[i], arr[i + 1]);
+		}
+		tmp[++len] = arr[k];
+		// 因为题目是让所有关键点不能和1号点连通
+		// 所以一定要让1号点加入
+		tmp[++len] = 1;
+		sortByDfn(tmp, 1, len);
+		int unique = 1;
+		for (int i = 2; i <= len; i++) {
+			if (tmp[unique] != tmp[i]) {
+				tmp[++unique] = tmp[i];
+			}
+		}
+		cntv = 0;
+		for (int i = 1; i <= unique; i++) {
+			headv[tmp[i]] = 0;
+		}
+		for (int i = 1; i < unique; i++) {
+			int lca = getLca(tmp[i], tmp[i + 1]);
+			addEdgeV(lca, tmp[i + 1], getDist(lca, tmp[i + 1]));
+		}
+		return tmp[1];
+	}
+
 	// 单调栈的方式建立虚树
-	public static void buildVirtualTree() {
+	public static int buildVirtualTree2() {
 		sortByDfn(arr, 1, k);
+		// 因为题目是让所有关键点不能和1号点连通
+		// 所以一定要让1号点加入
 		cntv = 0;
 		headv[1] = 0;
 		int top = 0;
 		stack[++top] = 1;
 		for (int i = 1; i <= k; i++) {
 			int x = arr[i];
-			if (x == 1) {
-				continue;
-			}
 			int y = stack[top];
 			int lca = getLca(x, y);
 			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
@@ -164,6 +194,7 @@ public static void buildVirtualTree() {
 			addEdgeV(stack[top - 1], stack[top], getDist(stack[top - 1], stack[top]));
 			top--;
 		}
+		return stack[1];
 	}
 
 	public static void dpOnTree(int u) {
@@ -183,15 +214,16 @@ public static void dpOnTree(int u) {
 	}
 
 	public static long compute() {
-		buildVirtualTree();
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = true;
 		}
-		dpOnTree(1);
+		int tree = buildVirtualTree1();
+		// int tree = buildVirtualTree2();
+		dpOnTree(tree);
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
 		}
-		return dp[1];
+		return dp[tree];
 	}
 
 	public static void main(String[] args) throws Exception {

From 850c34a9088cd71a75e69dab09c0579c1879cda9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 8 Oct 2025 22:49:52 +0800
Subject: [PATCH 1499/1712] modify code

---
 src/class180/Code03_BigProject1.java | 327 +++++++++++++++++++++++++++
 1 file changed, 327 insertions(+)
 create mode 100644 src/class180/Code03_BigProject1.java

diff --git a/src/class180/Code03_BigProject1.java b/src/class180/Code03_BigProject1.java
new file mode 100644
index 000000000..071cbfb73
--- /dev/null
+++ b/src/class180/Code03_BigProject1.java
@@ -0,0 +1,327 @@
+package class180;
+
+// 大工程，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4103
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_BigProject1 {
+
+	public static int MAXN = 1000001;
+	public static int MAXP = 21;
+	public static long INF = 1L << 60;
+	public static int n, q, k;
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headv = new int[MAXN];
+	public static int[] nextv = new int[MAXN];
+	public static int[] tov = new int[MAXN];
+	public static int cntv;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int cntd;
+
+	public static int[] arr = new int[MAXN];
+	public static boolean[] isKey = new boolean[MAXN];
+	public static int[] tmp = new int[MAXN << 1];
+
+	public static int[] siz = new int[MAXN];
+	public static long[] dp = new long[MAXN];
+	public static long[] minv = new long[MAXN];
+	public static long[] maxv = new long[MAXN];
+	public static long costSum, costMin, costMax;
+
+	// dfs过程和dp过程，C++同学可以使用递归版
+	// 但是java同学必须改迭代版否则会爆栈
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	// ufe不仅用于dfs改迭代，也用于dp改迭代
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	public static void addEdgeG(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addEdgeV(int u, int v) {
+		nextv[++cntv] = headv[u];
+		tov[cntv] = v;
+		headv[u] = cntv;
+	}
+
+	// nums中的数，根据dfn的大小排序，手撸双指针快排
+	public static void sortByDfn(int[] nums, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r;
+		int pivot = nums[(l + r) >> 1];
+		while (i <= j) {
+			while (dfn[nums[i]] < dfn[pivot]) i++;
+			while (dfn[nums[j]] > dfn[pivot]) j--;
+			if (i <= j) {
+				int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
+				i++; j--;
+			}
+		}
+		sortByDfn(nums, l, j);
+		sortByDfn(nums, i, r);
+	}
+
+	// dfs递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		dfn[u] = ++cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			if (tog[e] != fa) {
+				dfs1(tog[e], u);
+			}
+		}
+	}
+
+	// dfs1的迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				dfn[u] = ++cntd;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXP; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = headg[u];
+			} else {
+				e = nextg[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (tog[e] != f) {
+					push(tog[e], u, -1);
+				}
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int buildVirtualTree() {
+		sortByDfn(arr, 1, k);
+		int len = 0;
+		for (int i = 1; i < k; i++) {
+			tmp[++len] = arr[i];
+			tmp[++len] = getLca(arr[i], arr[i + 1]);
+		}
+		tmp[++len] = arr[k];
+		sortByDfn(tmp, 1, len);
+		int unique = 1;
+		for (int i = 2; i <= len; i++) {
+			if (tmp[unique] != tmp[i]) {
+				tmp[++unique] = tmp[i];
+			}
+		}
+		cntv = 0;
+		for (int i = 1; i <= unique; i++) {
+			headv[tmp[i]] = 0;
+		}
+		for (int i = 1; i < unique; i++) {
+			addEdgeV(getLca(tmp[i], tmp[i + 1]), tmp[i + 1]);
+		}
+		return tmp[1];
+	}
+
+	// dp递归版，java会爆栈，C++可以通过
+	public static void dpOnTree1(int u) {
+		siz[u] = isKey[u] ? 1 : 0;
+		dp[u] = 0;
+		if (isKey[u]) {
+			maxv[u] = minv[u] = 0;
+		} else {
+			minv[u] = INF;
+			maxv[u] = -INF;
+		}
+		for (int e = headv[u]; e > 0; e = nextv[e]) {
+			dpOnTree1(tov[e]);
+		}
+		for (int ei = headv[u]; ei > 0; ei = nextv[ei]) {
+			int v = tov[ei];
+			long len = dep[v] - dep[u];
+			costSum += (dp[u] + 1L * siz[u] * len) * siz[v] + dp[v] * siz[u];
+			siz[u] += siz[v];
+			dp[u] += dp[v] + len * siz[v];
+			costMin = Math.min(costMin, minv[u] + minv[v] + len);
+			costMax = Math.max(costMax, maxv[u] + maxv[v] + len);
+			minv[u] = Math.min(minv[u], minv[v] + len);
+			maxv[u] = Math.max(maxv[u], maxv[v] + len);
+		}
+	}
+
+	// dpOnTree1的迭代版
+	public static void dpOnTree2(int tree) {
+		stacksize = 0;
+		push(tree, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				siz[u] = isKey[u] ? 1 : 0;
+				dp[u] = 0;
+				if (isKey[u]) {
+					maxv[u] = minv[u] = 0;
+				} else {
+					minv[u] = INF;
+					maxv[u] = -INF;
+				}
+				e = headv[u];
+			} else {
+				e = nextv[e];
+			}
+			if (e != 0) {
+				push(u, 0, e);
+				push(tov[e], 0, -1);
+			} else {
+				for (int ei = headv[u]; ei > 0; ei = nextv[ei]) {
+					int v = tov[ei];
+					long len = dep[v] - dep[u];
+					costSum += (dp[u] + 1L * siz[u] * len) * siz[v] + dp[v] * siz[u];
+					siz[u] += siz[v];
+					dp[u] += dp[v] + len * siz[v];
+					costMin = Math.min(costMin, minv[u] + minv[v] + len);
+					costMax = Math.max(costMax, maxv[u] + maxv[v] + len);
+					minv[u] = Math.min(minv[u], minv[v] + len);
+					maxv[u] = Math.max(maxv[u], maxv[v] + len);
+				}
+			}
+		}
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i]] = true;
+		}
+		int tree = buildVirtualTree();
+		costSum = 0;
+		costMin = INF;
+		costMax = -INF;
+		// dpOnTree1(tree);
+		dpOnTree2(tree);
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i]] = false;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdgeG(u, v);
+			addEdgeG(v, u);
+		}
+		// dfs1(1, 0);
+		dfs2();
+		q = in.nextInt();
+		for (int t = 1; t <= q; t++) {
+			k = in.nextInt();
+			for (int i = 1; i <= k; i++) {
+				arr[i] = in.nextInt();
+			}
+			compute();
+			out.println(costSum + " " + costMin + " " + costMax);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 3593f93e51fb0e3dd9e7bddc2b4f653b7ae31b69 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 9 Oct 2025 20:08:20 +0800
Subject: [PATCH 1500/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 274 ++++++++++++++++++++++++++++
 src/class180/Code04_WorldTree2.java | 209 +++++++++++++++++++++
 2 files changed, 483 insertions(+)
 create mode 100644 src/class180/Code04_WorldTree1.java
 create mode 100644 src/class180/Code04_WorldTree2.java

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
new file mode 100644
index 000000000..c427c6050
--- /dev/null
+++ b/src/class180/Code04_WorldTree1.java
@@ -0,0 +1,274 @@
+package class180;
+
+// 世界树，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3233
+// 提交以下的code，提交时请把类名改成"Main"
+// 本题递归函数较多，java版不改成迭代会爆栈，导致无法通过
+// 但是改动其实没啥价值，因为和算法无关，纯粹语言歧视，索性不改了
+// 想通过用C++实现，本节课Code04_WorldTree2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code04_WorldTree1 {
+
+	public static int MAXN = 300001;
+	public static int MAXP = 20;
+	public static int INF = 1000000001;
+	public static int n, q, k;
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headv = new int[MAXN];
+	public static int[] nextv = new int[MAXN];
+	public static int[] tov = new int[MAXN];
+	public static int cntv;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int cntd;
+
+	public static int[] order = new int[MAXN];
+	public static int[] arr = new int[MAXN];
+	public static boolean[] isKey = new boolean[MAXN];
+	public static int[] tmp = new int[MAXN << 1];
+	public static int[] dp = new int[MAXN];
+	public static int[] pick = new int[MAXN];
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdgeG(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addEdgeV(int u, int v) {
+		nextv[++cntv] = headv[u];
+		tov[cntv] = v;
+		headv[u] = cntv;
+	}
+
+	// nums中的数，根据dfn的大小排序，手撸双指针快排
+	public static void sortByDfn(int[] nums, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r;
+		int pivot = nums[(l + r) >> 1];
+		while (i <= j) {
+			while (dfn[nums[i]] < dfn[pivot]) i++;
+			while (dfn[nums[j]] > dfn[pivot]) j--;
+			if (i <= j) {
+				int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
+				i++; j--;
+			}
+		}
+		sortByDfn(nums, l, j);
+		sortByDfn(nums, i, r);
+	}
+
+	public static void dfs(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		siz[u] = 1;
+		dfn[u] = ++cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (v != fa) {
+				dfs(v, u);
+				siz[u] += siz[v];
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int buildVirtualTree() {
+		sortByDfn(arr, 1, k);
+		int len = 0;
+		for (int i = 1; i < k; i++) {
+			tmp[++len] = arr[i];
+			tmp[++len] = getLca(arr[i], arr[i + 1]);
+		}
+		tmp[++len] = arr[k];
+		// 一定要加入1号点
+		// 因为题目问的是所有节点的归属问题
+		tmp[++len] = 1;
+		sortByDfn(tmp, 1, len);
+		int unique = 1;
+		for (int i = 2; i <= len; i++) {
+			if (tmp[unique] != tmp[i]) {
+				tmp[++unique] = tmp[i];
+			}
+		}
+		cntv = 0;
+		for (int i = 1; i <= unique; i++) {
+			headv[tmp[i]] = 0;
+		}
+		for (int i = 1; i < unique; i++) {
+			addEdgeV(getLca(tmp[i], tmp[i + 1]), tmp[i + 1]);
+		}
+		return tmp[1];
+	}
+
+	public static void dp1(int u) {
+		dp[u] = INF;
+		for (int e = headv[u]; e > 0; e = nextv[e]) {
+			int v = tov[e];
+			dp1(v);
+			int dis = dep[v] - dep[u];
+			if (dp[u] > dp[v] + dis) {
+				dp[u] = dp[v] + dis;
+				pick[u] = pick[v];
+			} else if (dp[u] == dp[v] + dis) {
+				pick[u] = Math.min(pick[u], pick[v]);
+			}
+		}
+		if (isKey[u]) {
+			dp[u] = 0;
+			pick[u] = u;
+		}
+	}
+
+	public static void calc(int x, int y) {
+		int b = y;
+		for (int p = MAXP - 1; p >= 0; p--) {
+			int l = dep[y] - dep[stjump[b][p]] + dp[y];
+			int r = dep[stjump[b][p]] - dep[x] + dp[x];
+			if (dep[stjump[b][p]] > dep[x] && (l < r || (l == r && pick[y] < pick[x]))) {
+				b = stjump[b][p];
+			}
+		}
+		ans[pick[y]] += siz[b] - siz[y];
+		ans[pick[x]] -= siz[b];
+	}
+
+	public static void dp2(int u) {
+		for (int e = headv[u]; e > 0; e = nextv[e]) {
+			int v = tov[e];
+			int dis = dep[v] - dep[u];
+			if (dp[v] > dp[u] + dis) {
+				dp[v] = dp[u] + dis;
+				pick[v] = pick[u];
+			} else if (dp[v] == dp[u] + dis) {
+				pick[v] = Math.min(pick[v], pick[u]);
+			}
+			calc(u, v);
+			dp2(v);
+		}
+		ans[pick[u]] += siz[u];
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= k; i++) {
+			arr[i] = order[i];
+		}
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i]] = true;
+			ans[arr[i]] = 0;
+		}
+		int tree = buildVirtualTree();
+		dp1(tree);
+		dp2(tree);
+		for (int i = 1; i <= k; i++) {
+			isKey[arr[i]] = false;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdgeG(u, v);
+			addEdgeG(v, u);
+		}
+		dfs(1, 0);
+		q = in.nextInt();
+		for (int t = 1; t <= q; t++) {
+			k = in.nextInt();
+			for (int i = 1; i <= k; i++) {
+				order[i] = in.nextInt();
+			}
+			compute();
+			for (int i = 1; i <= k; i++) {
+				out.print(ans[order[i]] + " ");
+			}
+			out.println();
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
new file mode 100644
index 000000000..e79d432f0
--- /dev/null
+++ b/src/class180/Code04_WorldTree2.java
@@ -0,0 +1,209 @@
+package class180;
+
+// 世界树，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3233
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//const int MAXP = 20;
+//const int INF = 1000000001;
+//int n, q, k;
+//
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int cntg;
+//
+//int headv[MAXN];
+//int nextv[MAXN];
+//int tov[MAXN];
+//int cntv;
+//
+//int dep[MAXN];
+//int siz[MAXN];
+//int dfn[MAXN];
+//int stjump[MAXN][MAXP];
+//int cntd;
+//
+//int order[MAXN];
+//int arr[MAXN];
+//bool isKey[MAXN];
+//int tmp[MAXN << 1];
+//
+//int dp[MAXN];
+//int pick[MAXN];
+//int ans[MAXN];
+//
+//void addEdgeG(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addEdgeV(int u, int v) {
+//    nextv[++cntv] = headv[u];
+//    tov[cntv] = v;
+//    headv[u] = cntv;
+//}
+//
+//bool cmp(int x, int y) {
+//    return dfn[x] < dfn[y];
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    siz[u] = 1;
+//    dfn[u] = ++cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        int v = tog[e];
+//        if (v != fa) {
+//            dfs(v, u);
+//            siz[u] += siz[v];
+//        }
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int buildVirtualTree() {
+//    sort(arr + 1, arr + k + 1, cmp);
+//    int len = 0;
+//    for (int i = 1; i < k; i++) {
+//    	tmp[++len] = arr[i];
+//    	tmp[++len] = getLca(arr[i], arr[i + 1]);
+//    }
+//    tmp[++len] = arr[k];
+//    tmp[++len] = 1;
+//    sort(tmp + 1, tmp + len + 1, cmp);
+//    int unique = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (tmp[unique] != tmp[i]) {
+//        	tmp[++unique] = tmp[i];
+//        }
+//    }
+//    cntv = 0;
+//    for (int i = 1; i <= unique; i++) {
+//        headv[tmp[i]] = 0;
+//    }
+//    for (int i = 1; i < unique; i++) {
+//        addEdgeV(getLca(tmp[i], tmp[i + 1]), tmp[i + 1]);
+//    }
+//    return tmp[1];
+//}
+//
+//void dp1(int u) {
+//    dp[u] = INF;
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        int v = tov[e];
+//        dp1(v);
+//        int dis = dep[v] - dep[u];
+//        if (dp[u] > dp[v] + dis) {
+//            dp[u] = dp[v] + dis;
+//            pick[u] = pick[v];
+//        } else if (dp[u] == dp[v] + dis) {
+//            pick[u] = min(pick[u], pick[v]);
+//        }
+//    }
+//    if (isKey[u]) {
+//        dp[u] = 0;
+//        pick[u] = u;
+//    }
+//}
+//
+//void calc(int x, int y) {
+//    int b = y;
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        int l = (dep[y] - dep[stjump[b][p]]) + dp[y];
+//        int r = (dep[stjump[b][p]] - dep[x]) + dp[x];
+//        if (dep[stjump[b][p]] > dep[x] && (l < r || (l == r && pick[y] < pick[x]))) {
+//            b = stjump[b][p];
+//        }
+//    }
+//    ans[pick[y]] += siz[b] - siz[y];
+//    ans[pick[x]] -= siz[b];
+//}
+//
+//void dp2(int u) {
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        int v = tov[e];
+//        int dis = dep[v] - dep[u];
+//        if (dp[v] > dp[u] + dis) {
+//            dp[v] = dp[u] + dis;
+//            pick[v] = pick[u];
+//        } else if (dp[v] == dp[u] + dis) {
+//            pick[v] = min(pick[v], pick[u]);
+//        }
+//        calc(u, v);
+//        dp2(v);
+//    }
+//    ans[pick[u]] += siz[u];
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= k; i++) {
+//        arr[i] = order[i];
+//    }
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = true;
+//        ans[arr[i]] = 0;
+//    }
+//    int tree = buildVirtualTree();
+//    dp1(tree);
+//    dp2(tree);
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = false;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdgeG(u, v);
+//        addEdgeG(v, u);
+//    }
+//    dfs(1, 0);
+//    cin >> q;
+//    for (int t = 1; t <= q; t++) {
+//        cin >> k;
+//        for (int i = 1; i <= k; i++) {
+//            cin >> order[i];
+//        }
+//        compute();
+//        for (int i = 1; i <= k; i++) {
+//            cout << ans[order[i]] << ' ';
+//        }
+//        cout << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 28382ec99581344704c1daa90134a0dc0c945fd9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 9 Oct 2025 20:09:36 +0800
Subject: [PATCH 1501/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index c427c6050..270a09fd6 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -4,7 +4,7 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P3233
 // 提交以下的code，提交时请把类名改成"Main"
 // 本题递归函数较多，java版不改成迭代会爆栈，导致无法通过
-// 但是改动其实没啥价值，因为和算法无关，纯粹语言歧视，索性不改了
+// 但是这种改动没啥价值，因为和算法无关，纯粹语言歧视，索性不改了
 // 想通过用C++实现，本节课Code04_WorldTree2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 

From 901ef146e8e6ee1190e17e68f30e7770a1d93b69 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 11:32:29 +0800
Subject: [PATCH 1502/1712] modify code

---
 .../{Code03_BigProject1.java => Code02_BigProject1.java}  | 2 +-
 src/class180/{Code02_War1.java => Code03_War1.java}       | 8 ++++----
 src/class180/Code04_WorldTree1.java                       | 6 +++---
 src/class180/Code04_WorldTree2.java                       | 2 +-
 4 files changed, 9 insertions(+), 9 deletions(-)
 rename src/class180/{Code03_BigProject1.java => Code02_BigProject1.java} (99%)
 rename src/class180/{Code02_War1.java => Code03_War1.java} (99%)

diff --git a/src/class180/Code03_BigProject1.java b/src/class180/Code02_BigProject1.java
similarity index 99%
rename from src/class180/Code03_BigProject1.java
rename to src/class180/Code02_BigProject1.java
index 071cbfb73..a1c14e3ec 100644
--- a/src/class180/Code03_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_BigProject1 {
+public class Code02_BigProject1 {
 
 	public static int MAXN = 1000001;
 	public static int MAXP = 21;
diff --git a/src/class180/Code02_War1.java b/src/class180/Code03_War1.java
similarity index 99%
rename from src/class180/Code02_War1.java
rename to src/class180/Code03_War1.java
index ea1d99d89..4e8b5aae8 100644
--- a/src/class180/Code02_War1.java
+++ b/src/class180/Code03_War1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_War1 {
+public class Code03_War1 {
 
 	public static int MAXN = 300001;
 	public static int MAXP = 20;
@@ -137,15 +137,15 @@ public static int getDist(int a, int b) {
 	// 二次排序 + LCA连边的方式建立虚树
 	public static int buildVirtualTree1() {
 		sortByDfn(arr, 1, k);
+		// 因为题目是让所有关键点不能和1号点连通
+		// 所以一定要让1号点加入
 		int len = 0;
+		tmp[++len] = 1;
 		for (int i = 1; i < k; i++) {
 			tmp[++len] = arr[i];
 			tmp[++len] = getLca(arr[i], arr[i + 1]);
 		}
 		tmp[++len] = arr[k];
-		// 因为题目是让所有关键点不能和1号点连通
-		// 所以一定要让1号点加入
-		tmp[++len] = 1;
 		sortByDfn(tmp, 1, len);
 		int unique = 1;
 		for (int i = 2; i <= len; i++) {
diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index 270a09fd6..176335e9b 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -115,15 +115,15 @@ public static int getLca(int a, int b) {
 
 	public static int buildVirtualTree() {
 		sortByDfn(arr, 1, k);
+		// 一定要加入1号点
+		// 因为题目问的是所有节点的归属问题
 		int len = 0;
+		tmp[++len] = 1;
 		for (int i = 1; i < k; i++) {
 			tmp[++len] = arr[i];
 			tmp[++len] = getLca(arr[i], arr[i + 1]);
 		}
 		tmp[++len] = arr[k];
-		// 一定要加入1号点
-		// 因为题目问的是所有节点的归属问题
-		tmp[++len] = 1;
 		sortByDfn(tmp, 1, len);
 		int unique = 1;
 		for (int i = 2; i <= len; i++) {
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index e79d432f0..ea654dc0c 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -96,12 +96,12 @@
 //int buildVirtualTree() {
 //    sort(arr + 1, arr + k + 1, cmp);
 //    int len = 0;
+//    tmp[++len] = 1;
 //    for (int i = 1; i < k; i++) {
 //    	tmp[++len] = arr[i];
 //    	tmp[++len] = getLca(arr[i], arr[i + 1]);
 //    }
 //    tmp[++len] = arr[k];
-//    tmp[++len] = 1;
 //    sort(tmp + 1, tmp + len + 1, cmp);
 //    int unique = 1;
 //    for (int i = 2; i <= len; i++) {

From e332177a4d49adf8eaec484c20ded0c6bfbfe4a0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 13:06:19 +0800
Subject: [PATCH 1503/1712] modify code

---
 src/class180/Code05_TreasureHunt1.java | 228 +++++++++++++++++++++++++
 1 file changed, 228 insertions(+)
 create mode 100644 src/class180/Code05_TreasureHunt1.java

diff --git a/src/class180/Code05_TreasureHunt1.java b/src/class180/Code05_TreasureHunt1.java
new file mode 100644
index 000000000..481f997e1
--- /dev/null
+++ b/src/class180/Code05_TreasureHunt1.java
@@ -0,0 +1,228 @@
+package class180;
+
+// 寻宝游戏，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3320
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.TreeSet;
+
+public class Code05_TreasureHunt1 {
+
+	public static int MAXN = 100001;
+	public static int MAXP = 20;
+	public static int n, m;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[] seg = new int[MAXN];
+	public static long[] dist = new long[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int cntd;
+
+	public static int[] arr = new int[MAXN];
+	public static boolean[] vis = new boolean[MAXN];
+	public static TreeSet<Integer> set = new TreeSet<>();
+	public static long[] ans = new long[MAXN];
+
+	public static void addEdge(int u, int v, int w) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	// dfs递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa, int w) {
+		dep[u] = dep[fa] + 1;
+		dfn[u] = ++cntd;
+		seg[cntd] = u;
+		dist[u] = dist[fa] + w;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			if (to[e] != fa) {
+				dfs1(to[e], u, weight[e]);
+			}
+		}
+	}
+
+	// 不会改迭代版，去看讲解118，详解了从递归版改迭代版
+	public static int[][] ufwe = new int[MAXN][4];
+
+	public static int stacksize, u, f, w, e;
+
+	public static void push(int u, int f, int w, int e) {
+		ufwe[stacksize][0] = u;
+		ufwe[stacksize][1] = f;
+		ufwe[stacksize][2] = w;
+		ufwe[stacksize][3] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufwe[stacksize][0];
+		f = ufwe[stacksize][1];
+		w = ufwe[stacksize][2];
+		e = ufwe[stacksize][3];
+	}
+
+	// dfs1的迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				dfn[u] = ++cntd;
+				seg[cntd] = u;
+				dist[u] = dist[f] + w;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXP; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, w, e);
+				if (to[e] != f) {
+					push(to[e], u, weight[e], -1);
+				}
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static long getDist(int x, int y) {
+		return dist[x] + dist[y] - 2 * dist[getLca(x, y)];
+	}
+
+	public static void compute() {
+		long curAns = 0;
+		for (int i = 1; i <= m; i++) {
+			int nodeId = arr[i];
+			int dfnId = dfn[nodeId];
+			if (!vis[nodeId]) {
+				set.add(dfnId);
+			}
+			int pre = set.lower(dfnId) != null ? set.lower(dfnId) : set.last();
+			int post = set.higher(dfnId) != null ? set.higher(dfnId) : set.first();
+			if (vis[nodeId]) {
+				set.remove(dfnId);
+			}
+			pre = seg[pre];
+			post = seg[post];
+			long curDist = getDist(nodeId, pre) + getDist(nodeId, post) - getDist(pre, post);
+			if (!vis[nodeId]) {
+				vis[nodeId] = true;
+				curAns += curDist;
+			} else {
+				vis[nodeId] = false;
+				curAns -= curDist;
+			}
+			ans[i] = curAns;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, u, v, w; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextInt();
+			addEdge(u, v, w);
+			addEdge(v, u, w);
+		}
+		// dfs1(1, 0, 0);
+		dfs2();
+		for (int i = 1; i <= m; i++) {
+			arr[i] = in.nextInt();
+		}
+		compute();
+		for (int i = 1; i <= m; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From fb3b696ed7c6178f9933313c5c5a4073b512622d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 13:11:16 +0800
Subject: [PATCH 1504/1712] modify code

---
 src/class180/Code05_TreasureHunt1.java | 2 ++
 1 file changed, 2 insertions(+)

diff --git a/src/class180/Code05_TreasureHunt1.java b/src/class180/Code05_TreasureHunt1.java
index 481f997e1..c041eeb16 100644
--- a/src/class180/Code05_TreasureHunt1.java
+++ b/src/class180/Code05_TreasureHunt1.java
@@ -31,7 +31,9 @@ public class Code05_TreasureHunt1 {
 
 	public static int[] arr = new int[MAXN];
 	public static boolean[] vis = new boolean[MAXN];
+	// 这里为了方便，使用语言自带的有序表
 	public static TreeSet<Integer> set = new TreeSet<>();
+
 	public static long[] ans = new long[MAXN];
 
 	public static void addEdge(int u, int v, int w) {

From 4d2e11f2d59d630686b227a1d0cf9c093520f6e0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 13:22:17 +0800
Subject: [PATCH 1505/1712] modify code

---
 src/class180/Code02_BigProject1.java | 38 ++++++++++++++++++++++++++--
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index a1c14e3ec..832ebb475 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -34,6 +34,7 @@ public class Code02_BigProject1 {
 	public static int[] arr = new int[MAXN];
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
+	public static int[] stack = new int[MAXN];
 
 	public static int[] siz = new int[MAXN];
 	public static long[] dp = new long[MAXN];
@@ -156,7 +157,8 @@ public static int getLca(int a, int b) {
 		return stjump[a][0];
 	}
 
-	public static int buildVirtualTree() {
+	// 二次排序 + LCA连边的方式建立虚树
+	public static int buildVirtualTree1() {
 		sortByDfn(arr, 1, k);
 		int len = 0;
 		for (int i = 1; i < k; i++) {
@@ -181,6 +183,37 @@ public static int buildVirtualTree() {
 		return tmp[1];
 	}
 
+	// 单调栈的方式建立虚树
+	public static int buildVirtualTree2() {
+		sortByDfn(arr, 1, k);
+		cntv = 0;
+		headv[arr[1]] = 0;
+		int top = 0;
+		stack[++top] = arr[1];
+		for (int i = 2; i <= k; i++) {
+			int x = arr[i];
+			int y = stack[top];
+			int lca = getLca(x, y);
+			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
+				addEdgeV(stack[top - 1], stack[top]);
+				top--;
+			}
+			if (lca != stack[top]) {
+				headv[lca] = 0;
+				addEdgeV(lca, stack[top]);
+				top--;
+				stack[++top] = lca;
+			}
+			headv[x] = 0;
+			stack[++top] = x;
+		}
+		while (top > 1) {
+			addEdgeV(stack[top - 1], stack[top]);
+			top--;
+		}
+		return stack[1];
+	}
+
 	// dp递归版，java会爆栈，C++可以通过
 	public static void dpOnTree1(int u) {
 		siz[u] = isKey[u] ? 1 : 0;
@@ -249,7 +282,8 @@ public static void compute() {
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = true;
 		}
-		int tree = buildVirtualTree();
+		int tree = buildVirtualTree1();
+		// int tree = buildVirtualTree2();
 		costSum = 0;
 		costMin = INF;
 		costMax = -INF;

From 0f1bb1a01460afe9153a33e4d39bd331db95906b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 13:23:25 +0800
Subject: [PATCH 1506/1712] modify code

---
 src/class180/Code02_BigProject1.java | 1 -
 1 file changed, 1 deletion(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index 832ebb475..b8e67a691 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -76,7 +76,6 @@ public static void addEdgeV(int u, int v) {
 		headv[u] = cntv;
 	}
 
-	// nums中的数，根据dfn的大小排序，手撸双指针快排
 	public static void sortByDfn(int[] nums, int l, int r) {
 		if (l >= r) return;
 		int i = l, j = r;

From c6c191dcd0838a1240d38805c401295c06320b79 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 17:19:55 +0800
Subject: [PATCH 1507/1712] modify code

---
 src/class180/Code06_TreelandAndViruses1.java | 280 +++++++++++++++++++
 1 file changed, 280 insertions(+)
 create mode 100644 src/class180/Code06_TreelandAndViruses1.java

diff --git a/src/class180/Code06_TreelandAndViruses1.java b/src/class180/Code06_TreelandAndViruses1.java
new file mode 100644
index 000000000..7f597e4f8
--- /dev/null
+++ b/src/class180/Code06_TreelandAndViruses1.java
@@ -0,0 +1,280 @@
+package class180;
+
+// 树上病毒传播，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1320E
+// 测试链接 : https://codeforces.com/problemset/problem/1320/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.PriorityQueue;
+
+public class Code06_TreelandAndViruses1 {
+
+	public static int MAXN = 200001;
+	public static int MAXP = 20;
+	public static int n, q, k, m;
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headv = new int[MAXN];
+	public static int[] nextv = new int[MAXN << 1];
+	public static int[] tov = new int[MAXN << 1];
+	public static int cntv;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] dfn = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+	public static int cntd;
+
+	public static int[] start = new int[MAXN];
+	public static int[] speed = new int[MAXN];
+	public static int[] order = new int[MAXN];
+	public static int[] key = new int[MAXN];
+
+	public static int[] arr = new int[MAXN << 1];
+	public static int[] tmp = new int[MAXN << 2];
+	public static int unique;
+
+	// dijkstra算法需要
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] bestDist = new int[MAXN];
+	public static int[] bestTime = new int[MAXN];
+	public static int[] bestPre = new int[MAXN];
+
+	public static void addEdgeG(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addEdgeV(int u, int v) {
+		nextv[++cntv] = headv[u];
+		tov[cntv] = v;
+		headv[u] = cntv;
+	}
+
+	public static void sortByDfn(int[] nums, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r;
+		int pivot = nums[(l + r) >> 1];
+		while (i <= j) {
+			while (dfn[nums[i]] < dfn[pivot]) i++;
+			while (dfn[nums[j]] > dfn[pivot]) j--;
+			if (i <= j) {
+				int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
+				i++; j--;
+			}
+		}
+		sortByDfn(nums, l, j);
+		sortByDfn(nums, i, r);
+	}
+
+	public static void dfs(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		dfn[u] = ++cntd;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			if (tog[e] != fa) {
+				dfs(tog[e], u);
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a; a = b; b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static int buildVirtualTree() {
+		int tot = 0;
+		for (int i = 1; i <= k; i++) {
+			arr[++tot] = start[i];
+		}
+		for (int i = 1; i <= m; i++) {
+			arr[++tot] = key[i];
+		}
+		sortByDfn(arr, 1, tot);
+		int len = 0;
+		for (int i = 1; i < tot; i++) {
+			tmp[++len] = arr[i];
+			tmp[++len] = getLca(arr[i], arr[i + 1]);
+		}
+		tmp[++len] = arr[tot];
+		sortByDfn(tmp, 1, len);
+		unique = 1;
+		for (int i = 2; i <= len; i++) {
+			if (tmp[unique] != tmp[i]) {
+				tmp[++unique] = tmp[i];
+			}
+		}
+		cntv = 0;
+		for (int i = 1; i <= unique; i++) {
+			headv[tmp[i]] = 0;
+		}
+		for (int i = 1; i < unique; i++) {
+			// 这里要两个方向加边
+			// 因为病毒感染既可以向上也可以向下
+			// 所以跑dijkstra算法时需要无向图
+			int lca = getLca(tmp[i], tmp[i + 1]);
+			addEdgeV(lca, tmp[i + 1]);
+			addEdgeV(tmp[i + 1], lca);
+		}
+		return tmp[1];
+	}
+
+	static class Node {
+		int id, dist, time, pre;
+
+		Node(int id_, int dist_, int time_, int pre_) {
+			id = id_;
+			dist = dist_;
+			time = time_;
+			pre = pre_;
+		}
+	}
+
+	public static int getTime(int dist, int pre) {
+		return (dist + speed[pre] - 1) / speed[pre];
+	}
+
+	public static void dijkstra() {
+		PriorityQueue<Node> heap = new PriorityQueue<>((a, b) -> {
+			if (a.time != b.time) {
+				return a.time - b.time;
+			}
+			return order[a.pre] - order[b.pre];
+		});
+		for (int i = 1; i <= unique; i++) {
+			int u = tmp[i];
+			bestDist[u] = n + 1;
+			bestTime[u] = n + 1;
+			bestPre[u] = 0;
+			vis[u] = false;
+		}
+		for (int i = 1; i <= k; i++) {
+			int s = start[i];
+			bestDist[s] = 0;
+			bestPre[s] = s;
+			bestTime[s] = 0;
+			heap.add(new Node(s, 0, 0, s));
+		}
+		while (!heap.isEmpty()) {
+			Node cur = heap.poll();
+			int u = cur.id;
+			if (!vis[u]) {
+				vis[u] = true;
+				for (int e = headv[u]; e > 0; e = nextv[e]) {
+					int v = tov[e];
+					int dist = cur.dist + Math.abs(dep[u] - dep[v]);
+					int pre = cur.pre;
+					int time = getTime(dist, pre);
+					if (!vis[v] && (time < bestTime[v] || (time == bestTime[v] && order[pre] < order[bestPre[v]]))) {
+						bestTime[v] = time;
+						bestDist[v] = dist;
+						bestPre[v] = pre;
+						heap.add(new Node(v, dist, time, pre));
+					}
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i < n; i++) {
+			int x = in.nextInt();
+			int y = in.nextInt();
+			addEdgeG(x, y);
+			addEdgeG(y, x);
+		}
+		dfs(1, 0);
+		q = in.nextInt();
+		for (int t = 1; t <= q; t++) {
+			k = in.nextInt();
+			m = in.nextInt();
+			for (int i = 1; i <= k; i++) {
+				start[i] = in.nextInt();
+				speed[start[i]] = in.nextInt();
+				order[start[i]] = i;
+			}
+			for (int i = 1; i <= m; i++) {
+				key[i] = in.nextInt();
+			}
+			buildVirtualTree();
+			dijkstra();
+			for (int i = 1; i <= m; i++) {
+				out.print(order[bestPre[key[i]]] + " ");
+			}
+			out.println();
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 865ad5f19343edc745fa57ef71603c740faf41da Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 17:26:37 +0800
Subject: [PATCH 1508/1712] modify code

---
 src/class180/Code06_TreelandAndViruses1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class180/Code06_TreelandAndViruses1.java b/src/class180/Code06_TreelandAndViruses1.java
index 7f597e4f8..f8c66a6a9 100644
--- a/src/class180/Code06_TreelandAndViruses1.java
+++ b/src/class180/Code06_TreelandAndViruses1.java
@@ -173,14 +173,14 @@ public static void dijkstra() {
 			int u = tmp[i];
 			bestDist[u] = n + 1;
 			bestTime[u] = n + 1;
-			bestPre[u] = 0;
+			bestPre[u] = n + 1;
 			vis[u] = false;
 		}
 		for (int i = 1; i <= k; i++) {
 			int s = start[i];
 			bestDist[s] = 0;
-			bestPre[s] = s;
 			bestTime[s] = 0;
+			bestPre[s] = s;
 			heap.add(new Node(s, 0, 0, s));
 		}
 		while (!heap.isEmpty()) {

From 9799df92696a05e1cbb522b3e6a3082305e294d9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 10 Oct 2025 18:29:05 +0800
Subject: [PATCH 1509/1712] modify code

---
 src/class180/Code06_TreelandAndViruses1.java | 78 ++++++++++----------
 1 file changed, 41 insertions(+), 37 deletions(-)

diff --git a/src/class180/Code06_TreelandAndViruses1.java b/src/class180/Code06_TreelandAndViruses1.java
index f8c66a6a9..166506f48 100644
--- a/src/class180/Code06_TreelandAndViruses1.java
+++ b/src/class180/Code06_TreelandAndViruses1.java
@@ -9,10 +9,33 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
+import java.util.Comparator;
 import java.util.PriorityQueue;
 
 public class Code06_TreelandAndViruses1 {
 
+	static class Node {
+		int id, dist, time, source, sourceOrder;
+
+		Node(int id_, int dist_, int time_, int source_, int sourceOrder_) {
+			id = id_;
+			dist = dist_;
+			time = time_;
+			source = source_;
+			sourceOrder = sourceOrder_;
+		}
+	}
+
+	static class NodeCmp implements Comparator<Node> {
+		@Override
+		public int compare(Node o1, Node o2) {
+			if (o1.time != o2.time) {
+				return o1.time - o2.time;
+			}
+			return o1.sourceOrder - o2.sourceOrder;
+		}
+	}
+
 	public static int MAXN = 200001;
 	public static int MAXP = 20;
 	public static int n, q, k, m;
@@ -42,10 +65,10 @@ public class Code06_TreelandAndViruses1 {
 	public static int unique;
 
 	// dijkstra算法需要
+	public static PriorityQueue<Node> heap = new PriorityQueue<>(new NodeCmp());
 	public static boolean[] vis = new boolean[MAXN];
-	public static int[] bestDist = new int[MAXN];
-	public static int[] bestTime = new int[MAXN];
-	public static int[] bestPre = new int[MAXN];
+	public static int[] minTime = new int[MAXN];
+	public static int[] bestSource = new int[MAXN];
 
 	public static void addEdgeG(int u, int v) {
 		nextg[++cntg] = headg[u];
@@ -147,57 +170,38 @@ public static int buildVirtualTree() {
 		return tmp[1];
 	}
 
-	static class Node {
-		int id, dist, time, pre;
-
-		Node(int id_, int dist_, int time_, int pre_) {
-			id = id_;
-			dist = dist_;
-			time = time_;
-			pre = pre_;
-		}
-	}
-
-	public static int getTime(int dist, int pre) {
-		return (dist + speed[pre] - 1) / speed[pre];
+	public static int getTime(int dist, int source) {
+		return (dist + speed[source] - 1) / speed[source];
 	}
 
 	public static void dijkstra() {
-		PriorityQueue<Node> heap = new PriorityQueue<>((a, b) -> {
-			if (a.time != b.time) {
-				return a.time - b.time;
-			}
-			return order[a.pre] - order[b.pre];
-		});
 		for (int i = 1; i <= unique; i++) {
 			int u = tmp[i];
-			bestDist[u] = n + 1;
-			bestTime[u] = n + 1;
-			bestPre[u] = n + 1;
+			minTime[u] = n + 1;
+			bestSource[u] = n + 1;
 			vis[u] = false;
 		}
 		for (int i = 1; i <= k; i++) {
 			int s = start[i];
-			bestDist[s] = 0;
-			bestTime[s] = 0;
-			bestPre[s] = s;
-			heap.add(new Node(s, 0, 0, s));
+			minTime[s] = 0;
+			bestSource[s] = s;
+			heap.add(new Node(s, 0, 0, s, order[s]));
 		}
 		while (!heap.isEmpty()) {
 			Node cur = heap.poll();
 			int u = cur.id;
+			int source = cur.source;
+			int sourceOrder = cur.sourceOrder;
 			if (!vis[u]) {
 				vis[u] = true;
 				for (int e = headv[u]; e > 0; e = nextv[e]) {
 					int v = tov[e];
 					int dist = cur.dist + Math.abs(dep[u] - dep[v]);
-					int pre = cur.pre;
-					int time = getTime(dist, pre);
-					if (!vis[v] && (time < bestTime[v] || (time == bestTime[v] && order[pre] < order[bestPre[v]]))) {
-						bestTime[v] = time;
-						bestDist[v] = dist;
-						bestPre[v] = pre;
-						heap.add(new Node(v, dist, time, pre));
+					int time = getTime(dist, source);
+					if (!vis[v] && (time < minTime[v] || (time == minTime[v] && sourceOrder < order[bestSource[v]]))) {
+						minTime[v] = time;
+						bestSource[v] = source;
+						heap.add(new Node(v, dist, time, source, sourceOrder));
 					}
 				}
 			}
@@ -230,7 +234,7 @@ public static void main(String[] args) throws Exception {
 			buildVirtualTree();
 			dijkstra();
 			for (int i = 1; i <= m; i++) {
-				out.print(order[bestPre[key[i]]] + " ");
+				out.print(order[bestSource[key[i]]] + " ");
 			}
 			out.println();
 		}

From 362186170e42d2c9d356f86dc2a7f1080d49f068 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 12:24:35 +0800
Subject: [PATCH 1510/1712] modify code

---
 src/class180/Code06_TreelandAndViruses1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class180/Code06_TreelandAndViruses1.java b/src/class180/Code06_TreelandAndViruses1.java
index 166506f48..d2f3734a4 100644
--- a/src/class180/Code06_TreelandAndViruses1.java
+++ b/src/class180/Code06_TreelandAndViruses1.java
@@ -58,7 +58,7 @@ public int compare(Node o1, Node o2) {
 	public static int[] start = new int[MAXN];
 	public static int[] speed = new int[MAXN];
 	public static int[] order = new int[MAXN];
-	public static int[] key = new int[MAXN];
+	public static int[] query = new int[MAXN];
 
 	public static int[] arr = new int[MAXN << 1];
 	public static int[] tmp = new int[MAXN << 2];
@@ -139,7 +139,7 @@ public static int buildVirtualTree() {
 			arr[++tot] = start[i];
 		}
 		for (int i = 1; i <= m; i++) {
-			arr[++tot] = key[i];
+			arr[++tot] = query[i];
 		}
 		sortByDfn(arr, 1, tot);
 		int len = 0;
@@ -229,12 +229,12 @@ public static void main(String[] args) throws Exception {
 				order[start[i]] = i;
 			}
 			for (int i = 1; i <= m; i++) {
-				key[i] = in.nextInt();
+				query[i] = in.nextInt();
 			}
 			buildVirtualTree();
 			dijkstra();
 			for (int i = 1; i <= m; i++) {
-				out.print(order[bestSource[key[i]]] + " ");
+				out.print(order[bestSource[query[i]]] + " ");
 			}
 			out.println();
 		}

From e56f4ea62b968ff7779a0fa713d869c462701eb4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 12:38:20 +0800
Subject: [PATCH 1511/1712] modify code

---
 src/class180/Code05_TreasureHunt1.java       | 10 ++++----
 src/class180/Code06_TreelandAndViruses1.java | 27 ++++++++++++--------
 2 files changed, 22 insertions(+), 15 deletions(-)

diff --git a/src/class180/Code05_TreasureHunt1.java b/src/class180/Code05_TreasureHunt1.java
index c041eeb16..d651e5798 100644
--- a/src/class180/Code05_TreasureHunt1.java
+++ b/src/class180/Code05_TreasureHunt1.java
@@ -144,14 +144,14 @@ public static void compute() {
 			if (!vis[nodeId]) {
 				set.add(dfnId);
 			}
-			int pre = set.lower(dfnId) != null ? set.lower(dfnId) : set.last();
-			int post = set.higher(dfnId) != null ? set.higher(dfnId) : set.first();
+			int low = set.lower(dfnId) != null ? set.lower(dfnId) : set.last();
+			int high = set.higher(dfnId) != null ? set.higher(dfnId) : set.first();
 			if (vis[nodeId]) {
 				set.remove(dfnId);
 			}
-			pre = seg[pre];
-			post = seg[post];
-			long curDist = getDist(nodeId, pre) + getDist(nodeId, post) - getDist(pre, post);
+			low = seg[low];
+			high = seg[high];
+			long curDist = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
 			if (!vis[nodeId]) {
 				vis[nodeId] = true;
 				curAns += curDist;
diff --git a/src/class180/Code06_TreelandAndViruses1.java b/src/class180/Code06_TreelandAndViruses1.java
index d2f3734a4..65d6c6de3 100644
--- a/src/class180/Code06_TreelandAndViruses1.java
+++ b/src/class180/Code06_TreelandAndViruses1.java
@@ -57,8 +57,8 @@ public int compare(Node o1, Node o2) {
 
 	public static int[] start = new int[MAXN];
 	public static int[] speed = new int[MAXN];
-	public static int[] order = new int[MAXN];
 	public static int[] query = new int[MAXN];
+	public static int[] order = new int[MAXN];
 
 	public static int[] arr = new int[MAXN << 1];
 	public static int[] tmp = new int[MAXN << 2];
@@ -70,6 +70,8 @@ public int compare(Node o1, Node o2) {
 	public static int[] minTime = new int[MAXN];
 	public static int[] bestSource = new int[MAXN];
 
+	public static int[] ans = new int[MAXN];
+
 	public static void addEdgeG(int u, int v) {
 		nextg[++cntg] = headg[u];
 		tog[cntg] = v;
@@ -170,10 +172,6 @@ public static int buildVirtualTree() {
 		return tmp[1];
 	}
 
-	public static int getTime(int dist, int source) {
-		return (dist + speed[source] - 1) / speed[source];
-	}
-
 	public static void dijkstra() {
 		for (int i = 1; i <= unique; i++) {
 			int u = tmp[i];
@@ -197,7 +195,7 @@ public static void dijkstra() {
 				for (int e = headv[u]; e > 0; e = nextv[e]) {
 					int v = tov[e];
 					int dist = cur.dist + Math.abs(dep[u] - dep[v]);
-					int time = getTime(dist, source);
+					int time = (dist + speed[source] - 1) / speed[source];
 					if (!vis[v] && (time < minTime[v] || (time == minTime[v] && sourceOrder < order[bestSource[v]]))) {
 						minTime[v] = time;
 						bestSource[v] = source;
@@ -208,6 +206,17 @@ public static void dijkstra() {
 		}
 	}
 
+	public static void compute() {
+		for (int i = 1; i <= k; i++) {
+			order[start[i]] = i;
+		}
+		buildVirtualTree();
+		dijkstra();
+		for (int i = 1; i <= m; i++) {
+			ans[i] = order[bestSource[query[i]]];
+		}
+	}
+
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -226,15 +235,13 @@ public static void main(String[] args) throws Exception {
 			for (int i = 1; i <= k; i++) {
 				start[i] = in.nextInt();
 				speed[start[i]] = in.nextInt();
-				order[start[i]] = i;
 			}
 			for (int i = 1; i <= m; i++) {
 				query[i] = in.nextInt();
 			}
-			buildVirtualTree();
-			dijkstra();
+			compute();
 			for (int i = 1; i <= m; i++) {
-				out.print(order[bestSource[query[i]]] + " ");
+				out.print(ans[i] + " ");
 			}
 			out.println();
 		}

From 40c61dab2f46fac16c88c6788f4de40e82625a15 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 13:16:45 +0800
Subject: [PATCH 1512/1712] modify code

---
 src/class180/Code01_VirtualTree1.java |  27 ++--
 src/class180/Code01_VirtualTree2.java | 205 +++++++++++++++++++++++++
 src/class180/Code02_BigProject1.java  |  27 ++--
 src/class180/Code02_BigProject2.java  | 207 ++++++++++++++++++++++++++
 src/class180/Code04_WorldTree1.java   |   1 +
 5 files changed, 439 insertions(+), 28 deletions(-)
 create mode 100644 src/class180/Code01_VirtualTree2.java
 create mode 100644 src/class180/Code02_BigProject2.java

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
index e8758fa57..7f5643b44 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_VirtualTree1.java
@@ -36,9 +36,8 @@ public class Code01_VirtualTree1 {
 
 	// 第一种建树方式
 	public static int[] tmp = new int[MAXN << 1];
-
 	// 第二种建树方式
-	public static int[] stack = new int[MAXN];
+	public static int[] stk = new int[MAXN];
 
 	public static int[] siz = new int[MAXN];
 	public static int[] dp = new int[MAXN];
@@ -88,9 +87,7 @@ public static void dfs(int u, int fa) {
 
 	public static int getLca(int a, int b) {
 		if (dep[a] < dep[b]) {
-			int tmp = a;
-			a = b;
-			b = tmp;
+			int tmp = a; a = b; b = tmp;
 		}
 		for (int p = MAXP - 1; p >= 0; p--) {
 			if (dep[stjump[a][p]] >= dep[b]) {
@@ -141,29 +138,29 @@ public static int buildVirtualTree2() {
 		cntv = 0;
 		headv[arr[1]] = 0;
 		int top = 0;
-		stack[++top] = arr[1];
+		stk[++top] = arr[1];
 		for (int i = 2; i <= k; i++) {
 			int x = arr[i];
-			int y = stack[top];
+			int y = stk[top];
 			int lca = getLca(x, y);
-			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
-				addEdgeV(stack[top - 1], stack[top]);
+			while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+				addEdgeV(stk[top - 1], stk[top]);
 				top--;
 			}
-			if (lca != stack[top]) {
+			if (lca != stk[top]) {
 				headv[lca] = 0;
-				addEdgeV(lca, stack[top]);
+				addEdgeV(lca, stk[top]);
 				top--;
-				stack[++top] = lca;
+				stk[++top] = lca;
 			}
 			headv[x] = 0;
-			stack[++top] = x;
+			stk[++top] = x;
 		}
 		while (top > 1) {
-			addEdgeV(stack[top - 1], stack[top]);
+			addEdgeV(stk[top - 1], stk[top]);
 			top--;
 		}
-		return stack[1];
+		return stk[1];
 	}
 
 	public static void dpOnTree(int u) {
diff --git a/src/class180/Code01_VirtualTree2.java b/src/class180/Code01_VirtualTree2.java
new file mode 100644
index 000000000..99e71ff16
--- /dev/null
+++ b/src/class180/Code01_VirtualTree2.java
@@ -0,0 +1,205 @@
+package class180;
+
+// 虚树模版题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF613D
+// 测试链接 : https://codeforces.com/problemset/problem/613/D
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXP = 20;
+//int n, q, k;
+//
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int cntg;
+//
+//int headv[MAXN];
+//int nextv[MAXN];
+//int tov[MAXN];
+//int cntv;
+//
+//int dep[MAXN];
+//int dfn[MAXN];
+//int stjump[MAXN][MAXP];
+//int cntd;
+//
+//int arr[MAXN];
+//bool isKey[MAXN];
+//
+//int tmp[MAXN << 1];
+//int stk[MAXN];
+//
+//int siz[MAXN];
+//int dp[MAXN];
+//
+//bool cmp(int x, int y) {
+//    return dfn[x] < dfn[y];
+//}
+//
+//void addEdgeG(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addEdgeV(int u, int v) {
+//    nextv[++cntv] = headv[u];
+//    tov[cntv] = v;
+//    headv[u] = cntv;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    dfn[u] = ++cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        if (tog[e] != fa) {
+//            dfs(tog[e], u);
+//        }
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) a = stjump[a][p];
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int buildVirtualTree1() {
+//    sort(arr + 1, arr + k + 1, cmp);
+//    int len = 0;
+//    for (int i = 1; i < k; i++) {
+//        tmp[++len] = arr[i];
+//        tmp[++len] = getLca(arr[i], arr[i + 1]);
+//    }
+//    tmp[++len] = arr[k];
+//    sort(tmp + 1, tmp + len + 1, cmp);
+//    int unique = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (tmp[unique] != tmp[i]) {
+//            tmp[++unique] = tmp[i];
+//        }
+//    }
+//    cntv = 0;
+//    for (int i = 1; i <= unique; i++) {
+//        headv[tmp[i]] = 0;
+//    }
+//    for (int i = 1; i < unique; i++) {
+//        addEdgeV(getLca(tmp[i], tmp[i + 1]), tmp[i + 1]);
+//    }
+//    return tmp[1];
+//}
+//
+//int buildVirtualTree2() {
+//    sort(arr + 1, arr + k + 1, cmp);
+//    cntv = 0;
+//    headv[arr[1]] = 0;
+//    int top = 0;
+//    stk[++top] = arr[1];
+//    for (int i = 2; i <= k; i++) {
+//        int x = arr[i];
+//        int y = stk[top];
+//        int lca = getLca(x, y);
+//        while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+//            addEdgeV(stk[top - 1], stk[top]);
+//            top--;
+//        }
+//        if (lca != stk[top]) {
+//            headv[lca] = 0;
+//            addEdgeV(lca, stk[top]);
+//            top--;
+//            stk[++top] = lca;
+//        }
+//        headv[x] = 0;
+//        stk[++top] = x;
+//    }
+//    while (top > 1) {
+//        addEdgeV(stk[top - 1], stk[top]);
+//        top--;
+//    }
+//    return stk[1];
+//}
+//
+//void dpOnTree(int u) {
+//    dp[u] = siz[u] = 0;
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        int v = tov[e];
+//        dpOnTree(v);
+//        dp[u] += dp[v];
+//        siz[u] += siz[v];
+//    }
+//    if (isKey[u]) {
+//        dp[u] += siz[u];
+//        siz[u] = 1;
+//    } else if (siz[u] > 1) {
+//        dp[u] += 1;
+//        siz[u] = 0;
+//    }
+//}
+//
+//int compute() {
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = true;
+//    }
+//    bool check = true;
+//    for (int i = 1; i <= k; i++) {
+//        if (isKey[stjump[arr[i]][0]]) {
+//            check = false;
+//            break;
+//        }
+//    }
+//    int ans = -1;
+//    if (check) {
+//        int tree = buildVirtualTree1();
+//        // int tree = buildVirtualTree2();
+//        dpOnTree(tree);
+//        ans = dp[tree];
+//    }
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = false;
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdgeG(u, v);
+//        addEdgeG(v, u);
+//    }
+//    dfs(1, 0);
+//    cin >> q;
+//    for (int t = 1; t <= q; t++) {
+//        cin >> k;
+//        for (int i = 1; i <= k; i++) {
+//            cin >> arr[i];
+//        }
+//        cout << compute() << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index b8e67a691..18ff72b33 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -33,8 +33,9 @@ public class Code02_BigProject1 {
 
 	public static int[] arr = new int[MAXN];
 	public static boolean[] isKey = new boolean[MAXN];
+
 	public static int[] tmp = new int[MAXN << 1];
-	public static int[] stack = new int[MAXN];
+	public static int[] stk = new int[MAXN];
 
 	public static int[] siz = new int[MAXN];
 	public static long[] dp = new long[MAXN];
@@ -188,29 +189,29 @@ public static int buildVirtualTree2() {
 		cntv = 0;
 		headv[arr[1]] = 0;
 		int top = 0;
-		stack[++top] = arr[1];
+		stk[++top] = arr[1];
 		for (int i = 2; i <= k; i++) {
 			int x = arr[i];
-			int y = stack[top];
+			int y = stk[top];
 			int lca = getLca(x, y);
-			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
-				addEdgeV(stack[top - 1], stack[top]);
+			while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+				addEdgeV(stk[top - 1], stk[top]);
 				top--;
 			}
-			if (lca != stack[top]) {
+			if (lca != stk[top]) {
 				headv[lca] = 0;
-				addEdgeV(lca, stack[top]);
+				addEdgeV(lca, stk[top]);
 				top--;
-				stack[++top] = lca;
+				stk[++top] = lca;
 			}
 			headv[x] = 0;
-			stack[++top] = x;
+			stk[++top] = x;
 		}
 		while (top > 1) {
-			addEdgeV(stack[top - 1], stack[top]);
+			addEdgeV(stk[top - 1], stk[top]);
 			top--;
 		}
-		return stack[1];
+		return stk[1];
 	}
 
 	// dp递归版，java会爆栈，C++可以通过
@@ -226,8 +227,8 @@ public static void dpOnTree1(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			dpOnTree1(tov[e]);
 		}
-		for (int ei = headv[u]; ei > 0; ei = nextv[ei]) {
-			int v = tov[ei];
+		for (int e = headv[u]; e > 0; e = nextv[e]) {
+			int v = tov[e];
 			long len = dep[v] - dep[u];
 			costSum += (dp[u] + 1L * siz[u] * len) * siz[v] + dp[v] * siz[u];
 			siz[u] += siz[v];
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
new file mode 100644
index 000000000..f6a8abe82
--- /dev/null
+++ b/src/class180/Code02_BigProject2.java
@@ -0,0 +1,207 @@
+package class180;
+
+// 大工程，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4103
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 1000001;
+//const int MAXP = 21;
+//const long long INF = 1LL << 60;
+//int n, q, k;
+//
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int cntg;
+//
+//int headv[MAXN];
+//int nextv[MAXN];
+//int tov[MAXN];
+//int cntv;
+//
+//int dep[MAXN];
+//int dfn[MAXN];
+//int stjump[MAXN][MAXP];
+//int cntd;
+//
+//int arr[MAXN];
+//bool isKey[MAXN];
+//
+//int tmp[MAXN << 1];
+//int stk[MAXN];
+//
+//int siz[MAXN];
+//long long dp[MAXN];
+//long long minv[MAXN];
+//long long maxv[MAXN];
+//long long costSum, costMin, costMax;
+//
+//bool cmp(int x, int y) {
+//    return dfn[x] < dfn[y];
+//}
+//
+//void addEdgeG(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addEdgeV(int u, int v) {
+//    nextv[++cntv] = headv[u];
+//    tov[cntv] = v;
+//    headv[u] = cntv;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    dfn[u] = ++cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[ stjump[u][p - 1] ][p - 1];
+//    }
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        int v = tog[e];
+//        if (v != fa) dfs(v, u);
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[ stjump[a][p] ] >= dep[b]) a = stjump[a][p];
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int buildVirtualTree1() {
+//	sort(arr + 1, arr + k + 1, cmp);
+//    int len = 0;
+//    for (int i = 1; i < k; i++) {
+//        tmp[++len] = arr[i];
+//        tmp[++len] = getLca(arr[i], arr[i + 1]);
+//    }
+//    tmp[++len] = arr[k];
+//    sort(tmp + 1, tmp + len + 1, cmp);
+//    int unique = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (tmp[unique] != tmp[i]) {
+//            tmp[++unique] = tmp[i];
+//        }
+//    }
+//    cntv = 0;
+//    for (int i = 1; i <= unique; i++) {
+//        headv[tmp[i]] = 0;
+//    }
+//    for (int i = 1; i < unique; i++) {
+//        addEdgeV(getLca(tmp[i], tmp[i + 1]), tmp[i + 1]);
+//    }
+//    return tmp[1];
+//}
+//
+//int buildVirtualTree2() {
+//	sort(arr + 1, arr + k + 1, cmp);
+//    cntv = 0;
+//    headv[arr[1]] = 0;
+//    int top = 0;
+//    stk[++top] = arr[1];
+//    for (int i = 2; i <= k; i++) {
+//        int x = arr[i];
+//        int y = stk[top];
+//        int lca = getLca(x, y);
+//        while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+//            addEdgeV(stk[top - 1], stk[top]);
+//            top--;
+//        }
+//        if (lca != stk[top]) {
+//            headv[lca] = 0;
+//            addEdgeV(lca, stk[top]);
+//            top--;
+//            stk[++top] = lca;
+//        }
+//        headv[x] = 0;
+//        stk[++top] = x;
+//    }
+//    while (top > 1) {
+//        addEdgeV(stk[top - 1], stk[top]);
+//        top--;
+//    }
+//    return stk[1];
+//}
+//
+//void dpOnTree(int u) {
+//    siz[u] = isKey[u] ? 1 : 0;
+//    dp[u] = 0;
+//    if (isKey[u]) {
+//        minv[u] = maxv[u] = 0;
+//    } else {
+//        minv[u] = INF;
+//        maxv[u] = -INF;
+//    }
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        dpOnTree(tov[e]);
+//    }
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        int v = tov[e];
+//        long long len = (long long)dep[v] - dep[u];
+//        costSum += (dp[u] + 1LL * siz[u] * len) * siz[v] + dp[v] * siz[u];
+//        siz[u] += siz[v];
+//        dp[u] += dp[v] + len * siz[v];
+//        costMin = min(costMin, minv[u] + minv[v] + len);
+//        costMax = max(costMax, maxv[u] + maxv[v] + len);
+//        minv[u] = min(minv[u], minv[v] + len);
+//        maxv[u] = max(maxv[u], maxv[v] + len);
+//    }
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = true;
+//    }
+//    int tree = buildVirtualTree1();
+//    // int tree = buildVirtualTree2();
+//    costSum = 0;
+//    costMin = INF;
+//    costMax = -INF;
+//    dpOnTree(tree);
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = false;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdgeG(u, v);
+//        addEdgeG(v, u);
+//    }
+//    dfs(1, 0);
+//    cin >> q;
+//    for (int t = 1; t <= q; t++) {
+//        cin >> k;
+//        for (int i = 1; i <= k; i++) {
+//            cin >> arr[i];
+//        }
+//        compute();
+//        cout << costSum << ' ' << costMin << ' ' << costMax << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index 176335e9b..e4c500542 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -40,6 +40,7 @@ public class Code04_WorldTree1 {
 	public static int[] arr = new int[MAXN];
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
+
 	public static int[] dp = new int[MAXN];
 	public static int[] pick = new int[MAXN];
 	public static int[] ans = new int[MAXN];

From 613a8db8598fe56d3c4f8a30d1e7b3452af61de6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 13:36:07 +0800
Subject: [PATCH 1513/1712] modify code

---
 src/class180/Code02_BigProject2.java |   4 +-
 src/class180/Code03_War1.java        |  30 ++--
 src/class180/Code03_War2.java        | 219 +++++++++++++++++++++++++++
 src/class180/Code04_WorldTree2.java  |   8 +-
 4 files changed, 240 insertions(+), 21 deletions(-)
 create mode 100644 src/class180/Code03_War2.java

diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index f6a8abe82..0d3e6c94c 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -90,7 +90,7 @@
 //}
 //
 //int buildVirtualTree1() {
-//	sort(arr + 1, arr + k + 1, cmp);
+//    sort(arr + 1, arr + k + 1, cmp);
 //    int len = 0;
 //    for (int i = 1; i < k; i++) {
 //        tmp[++len] = arr[i];
@@ -115,7 +115,7 @@
 //}
 //
 //int buildVirtualTree2() {
-//	sort(arr + 1, arr + k + 1, cmp);
+//    sort(arr + 1, arr + k + 1, cmp);
 //    cntv = 0;
 //    headv[arr[1]] = 0;
 //    int top = 0;
diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index 4e8b5aae8..88a53e6f0 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -13,7 +13,7 @@ public class Code03_War1 {
 
 	public static int MAXN = 300001;
 	public static int MAXP = 20;
-	public static int n, m, k;
+	public static int n, q, k;
 
 	public static int[] headg = new int[MAXN];
 	public static int[] nextg = new int[MAXN << 1];
@@ -34,9 +34,9 @@ public class Code03_War1 {
 	public static int cntd;
 
 	public static int[] arr = new int[MAXN];
-	public static int[] tmp = new int[MAXN << 1];
-	public static int[] stack = new int[MAXN];
 	public static boolean[] isKey = new boolean[MAXN];
+	public static int[] tmp = new int[MAXN << 1];
+	public static int[] stk = new int[MAXN];
 	public static long[] dp = new long[MAXN];
 
 	public static void addEdgeG(int u, int v, int w) {
@@ -172,29 +172,29 @@ public static int buildVirtualTree2() {
 		cntv = 0;
 		headv[1] = 0;
 		int top = 0;
-		stack[++top] = 1;
+		stk[++top] = 1;
 		for (int i = 1; i <= k; i++) {
 			int x = arr[i];
-			int y = stack[top];
+			int y = stk[top];
 			int lca = getLca(x, y);
-			while (top > 1 && dfn[stack[top - 1]] >= dfn[lca]) {
-				addEdgeV(stack[top - 1], stack[top], getDist(stack[top - 1], stack[top]));
+			while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+				addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
 				top--;
 			}
-			if (lca != stack[top]) {
+			if (lca != stk[top]) {
 				headv[lca] = 0;
-				addEdgeV(lca, stack[top], getDist(lca, stack[top]));
+				addEdgeV(lca, stk[top], getDist(lca, stk[top]));
 				top--;
-				stack[++top] = lca;
+				stk[++top] = lca;
 			}
 			headv[x] = 0;
-			stack[++top] = x;
+			stk[++top] = x;
 		}
 		while (top > 1) {
-			addEdgeV(stack[top - 1], stack[top], getDist(stack[top - 1], stack[top]));
+			addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
 			top--;
 		}
-		return stack[1];
+		return stk[1];
 	}
 
 	public static void dpOnTree(int u) {
@@ -238,8 +238,8 @@ public static void main(String[] args) throws Exception {
 			addEdgeG(v, u, w);
 		}
 		dfs(1, 0, 0);
-		m = in.nextInt();
-		for (int t = 1; t <= m; t++) {
+		q = in.nextInt();
+		for (int t = 1; t <= q; t++) {
 			k = in.nextInt();
 			for (int i = 1; i <= k; i++) {
 				arr[i] = in.nextInt();
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
new file mode 100644
index 000000000..7f83a8813
--- /dev/null
+++ b/src/class180/Code03_War2.java
@@ -0,0 +1,219 @@
+package class180;
+
+// 消耗战，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P2495
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//const int MAXP = 20;
+//int n, q, k;
+//
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int weightg[MAXN << 1];
+//int cntg;
+//
+//int headv[MAXN];
+//int nextv[MAXN];
+//int tov[MAXN];
+//int weightv[MAXN];
+//int cntv;
+//
+//int dep[MAXN];
+//int dfn[MAXN];
+//int stjump[MAXN][MAXP];
+//int mindist[MAXN][MAXP];
+//int cntd;
+//
+//int arr[MAXN];
+//bool isKey[MAXN];
+//int tmp[MAXN << 1];
+//int stk[MAXN];
+//long long dp[MAXN];
+//
+//bool cmp(int x, int y) {
+//    return dfn[x] < dfn[y];
+//}
+//
+//void addEdgeG(int u, int v, int w) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    weightg[cntg] = w;
+//    headg[u] = cntg;
+//}
+//
+//void addEdgeV(int u, int v, int w) {
+//    nextv[++cntv] = headv[u];
+//    tov[cntv] = v;
+//    weightv[cntv] = w;
+//    headv[u] = cntv;
+//}
+//
+//void dfs(int u, int fa, int w) {
+//    dep[u] = dep[fa] + 1;
+//    dfn[u] = ++cntd;
+//    stjump[u][0] = fa;
+//    mindist[u][0] = w;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//        mindist[u][p] = min(mindist[u][p - 1], mindist[stjump[u][p - 1]][p - 1]);
+//    }
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        int v = tog[e];
+//        if (v != fa) dfs(v, u, weightg[e]);
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int getDist(int a, int b) {
+//    int dist = 100000001;
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            dist = min(dist, mindist[a][p]);
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return dist;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            dist = min(dist, min(mindist[a][p], mindist[b][p]));
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return dist;
+//}
+//
+//int buildVirtualTree1() {
+//    sort(arr + 1, arr + k + 1, cmp);
+//    int len = 0;
+//    tmp[++len] = 1;
+//    for (int i = 1; i < k; i++) {
+//        tmp[++len] = arr[i];
+//        tmp[++len] = getLca(arr[i], arr[i + 1]);
+//    }
+//    tmp[++len] = arr[k];
+//    sort(tmp + 1, tmp + len + 1, cmp);
+//    int uniqueCnt = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (tmp[uniqueCnt] != tmp[i]) tmp[++uniqueCnt] = tmp[i];
+//    }
+//    cntv = 0;
+//    for (int i = 1; i <= uniqueCnt; i++) headv[tmp[i]] = 0;
+//    for (int i = 1; i < uniqueCnt; i++) {
+//        int lca = getLca(tmp[i], tmp[i + 1]);
+//        addEdgeV(lca, tmp[i + 1], getDist(lca, tmp[i + 1]));
+//    }
+//    return tmp[1];
+//}
+//
+//int buildVirtualTree2() {
+//    sort(arr + 1, arr + k + 1, cmp);
+//    cntv = 0;
+//    headv[1] = 0;
+//    int top = 0;
+//    stk[++top] = 1;
+//    for (int i = 1; i <= k; i++) {
+//        int x = arr[i];
+//        int y = stk[top];
+//        int lca = getLca(x, y);
+//        while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+//            addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
+//            top--;
+//        }
+//        if (lca != stk[top]) {
+//            headv[lca] = 0;
+//            addEdgeV(lca, stk[top], getDist(lca, stk[top]));
+//            top--;
+//            stk[++top] = lca;
+//        }
+//        headv[x] = 0;
+//        stk[++top] = x;
+//    }
+//    while (top > 1) {
+//        addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
+//        top--;
+//    }
+//    return stk[1];
+//}
+//
+//void dpOnTree(int u) {
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        dpOnTree(tov[e]);
+//    }
+//    dp[u] = 0;
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        int v = tov[e];
+//        int w = weightv[e];
+//        if (isKey[v]) {
+//            dp[u] += w;
+//        } else {
+//            dp[u] += min(dp[v], (long long)w);
+//        }
+//    }
+//}
+//
+//long long compute() {
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = true;
+//    }
+//    int tree = buildVirtualTree1();
+//    // int tree = buildVirtualTree2();
+//    dpOnTree(tree);
+//    for (int i = 1; i <= k; i++) {
+//        isKey[arr[i]] = false;
+//    }
+//    return dp[tree];
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        addEdgeG(u, v, w);
+//        addEdgeG(v, u, w);
+//    }
+//    dfs(1, 0, 0);
+//    cin >> q;
+//    for (int t = 1; t <= q; t++) {
+//        cin >> k;
+//        for (int i = 1; i <= k; i++) {
+//            cin >> arr[i];
+//        }
+//        cout << compute() << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index ea654dc0c..238d883e0 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -39,6 +39,10 @@
 //int pick[MAXN];
 //int ans[MAXN];
 //
+//bool cmp(int x, int y) {
+//    return dfn[x] < dfn[y];
+//}
+//
 //void addEdgeG(int u, int v) {
 //    nextg[++cntg] = headg[u];
 //    tog[cntg] = v;
@@ -51,10 +55,6 @@
 //    headv[u] = cntv;
 //}
 //
-//bool cmp(int x, int y) {
-//    return dfn[x] < dfn[y];
-//}
-//
 //void dfs(int u, int fa) {
 //    dep[u] = dep[fa] + 1;
 //    siz[u] = 1;

From dc11d7319309cc5c826f4c07923cfd576eec0c10 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 13:58:09 +0800
Subject: [PATCH 1514/1712] modify code

---
 src/class180/Code05_TreasureHunt1.java |   6 +-
 src/class180/Code05_TreasureHunt2.java | 130 +++++++++++++++++++++++++
 2 files changed, 133 insertions(+), 3 deletions(-)
 create mode 100644 src/class180/Code05_TreasureHunt2.java

diff --git a/src/class180/Code05_TreasureHunt1.java b/src/class180/Code05_TreasureHunt1.java
index d651e5798..ebded195f 100644
--- a/src/class180/Code05_TreasureHunt1.java
+++ b/src/class180/Code05_TreasureHunt1.java
@@ -151,13 +151,13 @@ public static void compute() {
 			}
 			low = seg[low];
 			high = seg[high];
-			long curDist = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
+			long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
 			if (!vis[nodeId]) {
 				vis[nodeId] = true;
-				curAns += curDist;
+				curAns += delta;
 			} else {
 				vis[nodeId] = false;
-				curAns -= curDist;
+				curAns -= delta;
 			}
 			ans[i] = curAns;
 		}
diff --git a/src/class180/Code05_TreasureHunt2.java b/src/class180/Code05_TreasureHunt2.java
new file mode 100644
index 000000000..aca0add39
--- /dev/null
+++ b/src/class180/Code05_TreasureHunt2.java
@@ -0,0 +1,130 @@
+package class180;
+
+// 寻宝游戏，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3320
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXP = 20;
+//int n, m;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//int dep[MAXN];
+//int dfn[MAXN];
+//int seg[MAXN];
+//long long dist[MAXN];
+//int stjump[MAXN][MAXP];
+//int cntd;
+//
+//int arr[MAXN];
+//bool vis[MAXN];
+//std::set<int> st;
+//std::set<int>::iterator it;
+//
+//long long ans[MAXN];
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int fa, int w) {
+//    dep[u] = dep[fa] + 1;
+//    dfn[u] = ++cntd;
+//    seg[cntd] = u;
+//    dist[u] = dist[fa] + w;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            dfs(v, u, weight[e]);
+//        }
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//long long getDist(int x, int y) {
+//    return dist[x] + dist[y] - 2LL * dist[getLca(x, y)];
+//}
+//
+//void compute() {
+//    long long curAns = 0;
+//    for (int i = 1; i <= m; i++) {
+//        int nodeId = arr[i];
+//        int dfnId = dfn[nodeId];
+//        if (!vis[nodeId]) {
+//            st.insert(dfnId);
+//        }
+//        int low = (it = st.lower_bound(dfnId)) == st.begin() ? *--st.end() : *--it;
+//        int high = (it = st.upper_bound(dfnId)) == st.end() ? *st.begin() : *it;
+//        if (vis[nodeId]) {
+//            st.erase(dfnId);
+//        }
+//        low = seg[low];
+//        high = seg[high];
+//        long long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
+//        if (!vis[nodeId]) {
+//            vis[nodeId] = true;
+//            curAns += delta;
+//        } else {
+//            vis[nodeId] = false;
+//            curAns -= delta;
+//        }
+//        ans[i] = curAns;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        addEdge(u, v, w);
+//        addEdge(v, u, w);
+//    }
+//    dfs(1, 0, 0);
+//    for (int i = 1; i <= m; i++) {
+//        cin >> arr[i];
+//    }
+//    compute();
+//    for (int i = 1; i <= m; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 7c30d1123e66bb3e81db60a71b4a645f10b9e213 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 14:43:27 +0800
Subject: [PATCH 1515/1712] modify code

---
 src/class180/Code03_War2.java                |  12 +-
 src/class180/Code06_TreelandAndViruses1.java |  14 +-
 src/class180/Code06_TreelandAndViruses2.java | 215 +++++++++++++++++++
 3 files changed, 231 insertions(+), 10 deletions(-)
 create mode 100644 src/class180/Code06_TreelandAndViruses2.java

diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index 7f83a8813..a5e1caf0c 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -125,13 +125,17 @@
 //    }
 //    tmp[++len] = arr[k];
 //    sort(tmp + 1, tmp + len + 1, cmp);
-//    int uniqueCnt = 1;
+//    int unique = 1;
 //    for (int i = 2; i <= len; i++) {
-//        if (tmp[uniqueCnt] != tmp[i]) tmp[++uniqueCnt] = tmp[i];
+//        if (tmp[unique] != tmp[i]) {
+//            tmp[++unique] = tmp[i];
+//        }
 //    }
 //    cntv = 0;
-//    for (int i = 1; i <= uniqueCnt; i++) headv[tmp[i]] = 0;
-//    for (int i = 1; i < uniqueCnt; i++) {
+//    for (int i = 1; i <= unique; i++) {
+//        headv[tmp[i]] = 0;
+//    }
+//    for (int i = 1; i < unique; i++) {
 //        int lca = getLca(tmp[i], tmp[i + 1]);
 //        addEdgeV(lca, tmp[i + 1], getDist(lca, tmp[i + 1]));
 //    }
diff --git a/src/class180/Code06_TreelandAndViruses1.java b/src/class180/Code06_TreelandAndViruses1.java
index 65d6c6de3..5d9aa1db2 100644
--- a/src/class180/Code06_TreelandAndViruses1.java
+++ b/src/class180/Code06_TreelandAndViruses1.java
@@ -62,9 +62,8 @@ public int compare(Node o1, Node o2) {
 
 	public static int[] arr = new int[MAXN << 1];
 	public static int[] tmp = new int[MAXN << 2];
-	public static int unique;
+	public static int len;
 
-	// dijkstra算法需要
 	public static PriorityQueue<Node> heap = new PriorityQueue<>(new NodeCmp());
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] minTime = new int[MAXN];
@@ -92,7 +91,9 @@ public static void sortByDfn(int[] nums, int l, int r) {
 			while (dfn[nums[i]] < dfn[pivot]) i++;
 			while (dfn[nums[j]] > dfn[pivot]) j--;
 			if (i <= j) {
-				int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
+				int tmp = nums[i];
+				nums[i] = nums[j];
+				nums[j] = tmp;
 				i++; j--;
 			}
 		}
@@ -144,14 +145,14 @@ public static int buildVirtualTree() {
 			arr[++tot] = query[i];
 		}
 		sortByDfn(arr, 1, tot);
-		int len = 0;
+		len = 0;
 		for (int i = 1; i < tot; i++) {
 			tmp[++len] = arr[i];
 			tmp[++len] = getLca(arr[i], arr[i + 1]);
 		}
 		tmp[++len] = arr[tot];
 		sortByDfn(tmp, 1, len);
-		unique = 1;
+		int unique = 1;
 		for (int i = 2; i <= len; i++) {
 			if (tmp[unique] != tmp[i]) {
 				tmp[++unique] = tmp[i];
@@ -169,11 +170,12 @@ public static int buildVirtualTree() {
 			addEdgeV(lca, tmp[i + 1]);
 			addEdgeV(tmp[i + 1], lca);
 		}
+		len = unique;
 		return tmp[1];
 	}
 
 	public static void dijkstra() {
-		for (int i = 1; i <= unique; i++) {
+		for (int i = 1; i <= len; i++) {
 			int u = tmp[i];
 			minTime[u] = n + 1;
 			bestSource[u] = n + 1;
diff --git a/src/class180/Code06_TreelandAndViruses2.java b/src/class180/Code06_TreelandAndViruses2.java
new file mode 100644
index 000000000..62b0ed402
--- /dev/null
+++ b/src/class180/Code06_TreelandAndViruses2.java
@@ -0,0 +1,215 @@
+package class180;
+
+// 树上病毒传播，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/CF1320E
+// 测试链接 : https://codeforces.com/problemset/problem/1320/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int id, dist, time, source, sourceOrder;
+//    bool operator<(const Node &other) const {
+//        if (time != other.time) {
+//            return time > other.time;
+//        }
+//        return sourceOrder > other.sourceOrder;
+//    }
+//};
+//
+//const int MAXN = 200001;
+//const int MAXP = 20;
+//int n, q, k, m;
+//
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int cntg;
+//
+//int headv[MAXN];
+//int nextv[MAXN << 1];
+//int tov[MAXN << 1];
+//int cntv;
+//
+//int dep[MAXN];
+//int dfn[MAXN];
+//int stjump[MAXN][MAXP];
+//int cntd;
+//
+//int start[MAXN];
+//int speed[MAXN];
+//int query[MAXN];
+//int order[MAXN];
+//
+//int arr[MAXN << 1];
+//int tmp[MAXN << 2];
+//int len;
+//
+//priority_queue<Node> heap;
+//bool vis[MAXN];
+//int minTime[MAXN];
+//int bestSource[MAXN];
+//int ans[MAXN];
+//
+//bool cmp(int x, int y) {
+//    return dfn[x] < dfn[y];
+//}
+//
+//void addEdgeG(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addEdgeV(int u, int v) {
+//    nextv[++cntv] = headv[u];
+//    tov[cntv] = v;
+//    headv[u] = cntv;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    dfn[u] = ++cntd;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        if (tog[e] != fa) {
+//            dfs(tog[e], u);
+//        }
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//int buildVirtualTree() {
+//    int tot = 0;
+//    for (int i = 1; i <= k; i++) {
+//        arr[++tot] = start[i];
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        arr[++tot] = query[i];
+//    }
+//    sort(arr + 1, arr + tot + 1, cmp);
+//    len = 0;
+//    for (int i = 1; i < tot; i++) {
+//        tmp[++len] = arr[i];
+//        tmp[++len] = getLca(arr[i], arr[i + 1]);
+//    }
+//    tmp[++len] = arr[tot];
+//    sort(tmp + 1, tmp + len + 1, cmp);
+//    int unique = 1;
+//    for (int i = 2; i <= len; i++) {
+//        if (tmp[unique] != tmp[i]) {
+//            tmp[++unique] = tmp[i];
+//        }
+//    }
+//    cntv = 0;
+//    for (int i = 1; i <= unique; i++) {
+//        headv[tmp[i]] = 0;
+//    }
+//    for (int i = 1; i < unique; i++) {
+//        int lca = getLca(tmp[i], tmp[i + 1]);
+//        addEdgeV(lca, tmp[i + 1]);
+//        addEdgeV(tmp[i + 1], lca);
+//    }
+//    len = unique;
+//    return tmp[1];
+//}
+//
+//void dijkstra() {
+//    for (int i = 1; i <= len; i++) {
+//        int u = tmp[i];
+//        minTime[u] = n + 1;
+//        bestSource[u] = n + 1;
+//        vis[u] = false;
+//    }
+//    for (int i = 1; i <= k; i++) {
+//        int s = start[i];
+//        minTime[s] = 0;
+//        bestSource[s] = s;
+//        heap.push(Node{s, 0, 0, s, order[s]});
+//    }
+//    while (!heap.empty()) {
+//        Node cur = heap.top();
+//        heap.pop();
+//        int u = cur.id;
+//        if (!vis[u]) {
+//            vis[u] = true;
+//            for (int e = headv[u]; e; e = nextv[e]) {
+//                int v = tov[e];
+//                int dist = cur.dist + abs(dep[u] - dep[v]);
+//                int time = (dist + speed[cur.source] - 1) / speed[cur.source];
+//                if (!vis[v] && (time < minTime[v] || (time == minTime[v] && cur.sourceOrder < order[bestSource[v]]))) {
+//                    minTime[v] = time;
+//                    bestSource[v] = cur.source;
+//                    heap.push(Node{v, dist, time, cur.source, cur.sourceOrder});
+//                }
+//            }
+//        }
+//    }
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= k; i++) {
+//        order[start[i]] = i;
+//    }
+//    buildVirtualTree();
+//    dijkstra();
+//    for (int i = 1; i <= m; i++) {
+//        ans[i] = order[bestSource[query[i]]];
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdgeG(u, v);
+//        addEdgeG(v, u);
+//    }
+//    dfs(1, 0);
+//    cin >> q;
+//    for (int t = 1; t <= q; t++) {
+//        cin >> k >> m;
+//        for (int i = 1, s, v; i <= k; i++) {
+//            cin >> s >> v;
+//            start[i] = s;
+//            speed[s] = v;
+//        }
+//        for (int i = 1; i <= m; i++) {
+//            cin >> query[i];
+//        }
+//        compute();
+//        for (int i = 1; i <= m; i++) {
+//            cout << ans[i] << ' ';
+//        }
+//        cout << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 19823912bdf54493a12ecbeecb07eea0f65cb325 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 14:48:38 +0800
Subject: [PATCH 1516/1712] modify code

---
 ...TreelandAndViruses1.java => Code05_TreelandAndViruses1.java} | 2 +-
 ...TreelandAndViruses2.java => Code05_TreelandAndViruses2.java} | 0
 .../{Code05_TreasureHunt1.java => Code06_TreasureHunt1.java}    | 2 +-
 .../{Code05_TreasureHunt2.java => Code06_TreasureHunt2.java}    | 0
 4 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class180/{Code06_TreelandAndViruses1.java => Code05_TreelandAndViruses1.java} (99%)
 rename src/class180/{Code06_TreelandAndViruses2.java => Code05_TreelandAndViruses2.java} (100%)
 rename src/class180/{Code05_TreasureHunt1.java => Code06_TreasureHunt1.java} (99%)
 rename src/class180/{Code05_TreasureHunt2.java => Code06_TreasureHunt2.java} (100%)

diff --git a/src/class180/Code06_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
similarity index 99%
rename from src/class180/Code06_TreelandAndViruses1.java
rename to src/class180/Code05_TreelandAndViruses1.java
index 5d9aa1db2..db2d05685 100644
--- a/src/class180/Code06_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -12,7 +12,7 @@
 import java.util.Comparator;
 import java.util.PriorityQueue;
 
-public class Code06_TreelandAndViruses1 {
+public class Code05_TreelandAndViruses1 {
 
 	static class Node {
 		int id, dist, time, source, sourceOrder;
diff --git a/src/class180/Code06_TreelandAndViruses2.java b/src/class180/Code05_TreelandAndViruses2.java
similarity index 100%
rename from src/class180/Code06_TreelandAndViruses2.java
rename to src/class180/Code05_TreelandAndViruses2.java
diff --git a/src/class180/Code05_TreasureHunt1.java b/src/class180/Code06_TreasureHunt1.java
similarity index 99%
rename from src/class180/Code05_TreasureHunt1.java
rename to src/class180/Code06_TreasureHunt1.java
index ebded195f..34fedadc1 100644
--- a/src/class180/Code05_TreasureHunt1.java
+++ b/src/class180/Code06_TreasureHunt1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.TreeSet;
 
-public class Code05_TreasureHunt1 {
+public class Code06_TreasureHunt1 {
 
 	public static int MAXN = 100001;
 	public static int MAXP = 20;
diff --git a/src/class180/Code05_TreasureHunt2.java b/src/class180/Code06_TreasureHunt2.java
similarity index 100%
rename from src/class180/Code05_TreasureHunt2.java
rename to src/class180/Code06_TreasureHunt2.java

From 0fc93ff1cfb4978337763ff1dae88eec4308a073 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 17:15:11 +0800
Subject: [PATCH 1517/1712] modify code

---
 src/class180/Code05_TreelandAndViruses1.java | 3 +--
 1 file changed, 1 insertion(+), 2 deletions(-)

diff --git a/src/class180/Code05_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
index db2d05685..01b344ea6 100644
--- a/src/class180/Code05_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -163,9 +163,8 @@ public static int buildVirtualTree() {
 			headv[tmp[i]] = 0;
 		}
 		for (int i = 1; i < unique; i++) {
-			// 这里要两个方向加边
+			// 虚树的边不是单向的，是双向的
 			// 因为病毒感染既可以向上也可以向下
-			// 所以跑dijkstra算法时需要无向图
 			int lca = getLca(tmp[i], tmp[i + 1]);
 			addEdgeV(lca, tmp[i + 1]);
 			addEdgeV(tmp[i + 1], lca);

From cfaaaae0936107329e1e864404a744c927c664fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 18:08:18 +0800
Subject: [PATCH 1518/1712] modify code

---
 src/class180/Code01_VirtualTree1.java | 26 ++++++++++++-------
 src/class180/Code01_VirtualTree2.java | 26 ++++++++++++-------
 src/class180/Code02_BigProject1.java  | 36 +++++++++++++++++----------
 src/class180/Code02_BigProject2.java  | 24 ++++++++++++------
 4 files changed, 74 insertions(+), 38 deletions(-)

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
index 7f5643b44..af367a905 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_VirtualTree1.java
@@ -1,6 +1,14 @@
 package class180;
 
 // 虚树模版题，java版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的重要点，其他点是非重要点
+//                       你可以攻占非重要点，被攻占的点无法通行
+//                       要让重要点两两之间不再连通，打印至少需要攻占几个非重要点
+//                       如果攻占非重要点无法达成目标，打印-1
+// 1 <= n、q <= 10^5
+// 1 <= 所有查询给出的点的总数 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF613D
 // 测试链接 : https://codeforces.com/problemset/problem/613/D
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -40,7 +48,7 @@ public class Code01_VirtualTree1 {
 	public static int[] stk = new int[MAXN];
 
 	public static int[] siz = new int[MAXN];
-	public static int[] dp = new int[MAXN];
+	public static int[] cost = new int[MAXN];
 
 	public static void addEdgeG(int u, int v) {
 		nextg[++cntg] = headg[u];
@@ -163,19 +171,19 @@ public static int buildVirtualTree2() {
 		return stk[1];
 	}
 
-	public static void dpOnTree(int u) {
-		dp[u] = siz[u] = 0;
+	public static void dp(int u) {
+		cost[u] = siz[u] = 0;
 		for (int e = headv[u], v; e > 0; e = nextv[e]) {
 			v = tov[e];
-			dpOnTree(v);
-			dp[u] += dp[v];
+			dp(v);
+			cost[u] += cost[v];
 			siz[u] += siz[v];
 		}
 		if (isKey[u]) {
-			dp[u] += siz[u];
+			cost[u] += siz[u];
 			siz[u] = 1;
 		} else if (siz[u] > 1) {
-			dp[u]++;
+			cost[u]++;
 			siz[u] = 0;
 		}
 	}
@@ -195,8 +203,8 @@ public static int compute() {
 		if (check) {
 			int tree = buildVirtualTree1();
 			// int tree = buildVirtualTree2();
-			dpOnTree(tree);
-			ans = dp[tree];
+			dp(tree);
+			ans = cost[tree];
 		}
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
diff --git a/src/class180/Code01_VirtualTree2.java b/src/class180/Code01_VirtualTree2.java
index 99e71ff16..7a025398f 100644
--- a/src/class180/Code01_VirtualTree2.java
+++ b/src/class180/Code01_VirtualTree2.java
@@ -1,6 +1,14 @@
 package class180;
 
 // 虚树模版题，C++版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的重要点，其他点是非重要点
+//                       你可以攻占非重要点，被攻占的点无法通行
+//                       要让重要点两两之间不再连通，打印至少需要攻占几个非重要点
+//                       如果攻占非重要点无法达成目标，打印-1
+// 1 <= n、q <= 10^5
+// 1 <= 所有查询给出的点的总数 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF613D
 // 测试链接 : https://codeforces.com/problemset/problem/613/D
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -36,7 +44,7 @@
 //int stk[MAXN];
 //
 //int siz[MAXN];
-//int dp[MAXN];
+//int cost[MAXN];
 //
 //bool cmp(int x, int y) {
 //    return dfn[x] < dfn[y];
@@ -142,19 +150,19 @@
 //    return stk[1];
 //}
 //
-//void dpOnTree(int u) {
-//    dp[u] = siz[u] = 0;
+//void dp(int u) {
+//    cost[u] = siz[u] = 0;
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
-//        dpOnTree(v);
-//        dp[u] += dp[v];
+//        dp(v);
+//        cost[u] += cost[v];
 //        siz[u] += siz[v];
 //    }
 //    if (isKey[u]) {
-//        dp[u] += siz[u];
+//        cost[u] += siz[u];
 //        siz[u] = 1;
 //    } else if (siz[u] > 1) {
-//        dp[u] += 1;
+//        cost[u] += 1;
 //        siz[u] = 0;
 //    }
 //}
@@ -174,8 +182,8 @@
 //    if (check) {
 //        int tree = buildVirtualTree1();
 //        // int tree = buildVirtualTree2();
-//        dpOnTree(tree);
-//        ans = dp[tree];
+//        dp(tree);
+//        ans = cost[tree];
 //    }
 //    for (int i = 1; i <= k; i++) {
 //        isKey[arr[i]] = false;
diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index 18ff72b33..af4c42fbc 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -1,6 +1,16 @@
 package class180;
 
 // 大工程，java版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 如果在节点a和节点b之间建立新通道，那么代价是两个节点在树上的距离
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的节点，任意两个节点之间都会建立新通道
+//                       打印新通道的代价和
+//                       打印新通道中代价最小的值
+//                       打印新通道中代价最大的值
+// 1 <= n <= 10^6
+// 1 <= q <= 5 * 10^4
+// 1 <= 所有查询给出的点的总数 <= 2 * n
 // 测试链接 : https://www.luogu.com.cn/problem/P4103
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -38,7 +48,7 @@ public class Code02_BigProject1 {
 	public static int[] stk = new int[MAXN];
 
 	public static int[] siz = new int[MAXN];
-	public static long[] dp = new long[MAXN];
+	public static long[] sum = new long[MAXN];
 	public static long[] minv = new long[MAXN];
 	public static long[] maxv = new long[MAXN];
 	public static long costSum, costMin, costMax;
@@ -215,9 +225,9 @@ public static int buildVirtualTree2() {
 	}
 
 	// dp递归版，java会爆栈，C++可以通过
-	public static void dpOnTree1(int u) {
+	public static void dp1(int u) {
 		siz[u] = isKey[u] ? 1 : 0;
-		dp[u] = 0;
+		sum[u] = 0;
 		if (isKey[u]) {
 			maxv[u] = minv[u] = 0;
 		} else {
@@ -225,14 +235,14 @@ public static void dpOnTree1(int u) {
 			maxv[u] = -INF;
 		}
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
-			dpOnTree1(tov[e]);
+			dp1(tov[e]);
 		}
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			long len = dep[v] - dep[u];
-			costSum += (dp[u] + 1L * siz[u] * len) * siz[v] + dp[v] * siz[u];
+			costSum += (sum[u] + 1L * siz[u] * len) * siz[v] + sum[v] * siz[u];
 			siz[u] += siz[v];
-			dp[u] += dp[v] + len * siz[v];
+			sum[u] += sum[v] + len * siz[v];
 			costMin = Math.min(costMin, minv[u] + minv[v] + len);
 			costMax = Math.max(costMax, maxv[u] + maxv[v] + len);
 			minv[u] = Math.min(minv[u], minv[v] + len);
@@ -240,15 +250,15 @@ public static void dpOnTree1(int u) {
 		}
 	}
 
-	// dpOnTree1的迭代版
-	public static void dpOnTree2(int tree) {
+	// dp1的迭代版
+	public static void dp2(int tree) {
 		stacksize = 0;
 		push(tree, 0, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
 				siz[u] = isKey[u] ? 1 : 0;
-				dp[u] = 0;
+				sum[u] = 0;
 				if (isKey[u]) {
 					maxv[u] = minv[u] = 0;
 				} else {
@@ -266,9 +276,9 @@ public static void dpOnTree2(int tree) {
 				for (int ei = headv[u]; ei > 0; ei = nextv[ei]) {
 					int v = tov[ei];
 					long len = dep[v] - dep[u];
-					costSum += (dp[u] + 1L * siz[u] * len) * siz[v] + dp[v] * siz[u];
+					costSum += (sum[u] + 1L * siz[u] * len) * siz[v] + sum[v] * siz[u];
 					siz[u] += siz[v];
-					dp[u] += dp[v] + len * siz[v];
+					sum[u] += sum[v] + len * siz[v];
 					costMin = Math.min(costMin, minv[u] + minv[v] + len);
 					costMax = Math.max(costMax, maxv[u] + maxv[v] + len);
 					minv[u] = Math.min(minv[u], minv[v] + len);
@@ -287,8 +297,8 @@ public static void compute() {
 		costSum = 0;
 		costMin = INF;
 		costMax = -INF;
-		// dpOnTree1(tree);
-		dpOnTree2(tree);
+		// dp1(tree);
+		dp2(tree);
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
 		}
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index 0d3e6c94c..20acba1db 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -1,6 +1,16 @@
 package class180;
 
 // 大工程，C++版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 如果在节点a和节点b之间建立新通道，那么代价是两个节点在树上的距离
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的节点，任意两个节点之间都会建立新通道
+//                       打印新通道的代价和
+//                       打印新通道中代价最小的值
+//                       打印新通道中代价最大的值
+// 1 <= n <= 10^6
+// 1 <= q <= 5 * 10^4
+// 1 <= 所有查询给出的点的总数 <= 2 * n
 // 测试链接 : https://www.luogu.com.cn/problem/P4103
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -36,7 +46,7 @@
 //int stk[MAXN];
 //
 //int siz[MAXN];
-//long long dp[MAXN];
+//long long sum[MAXN];
 //long long minv[MAXN];
 //long long maxv[MAXN];
 //long long costSum, costMin, costMax;
@@ -144,9 +154,9 @@
 //    return stk[1];
 //}
 //
-//void dpOnTree(int u) {
+//void dp(int u) {
 //    siz[u] = isKey[u] ? 1 : 0;
-//    dp[u] = 0;
+//    sum[u] = 0;
 //    if (isKey[u]) {
 //        minv[u] = maxv[u] = 0;
 //    } else {
@@ -154,14 +164,14 @@
 //        maxv[u] = -INF;
 //    }
 //    for (int e = headv[u]; e; e = nextv[e]) {
-//        dpOnTree(tov[e]);
+//        dp(tov[e]);
 //    }
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        long long len = (long long)dep[v] - dep[u];
-//        costSum += (dp[u] + 1LL * siz[u] * len) * siz[v] + dp[v] * siz[u];
+//        costSum += (sum[u] + 1LL * siz[u] * len) * siz[v] + sum[v] * siz[u];
 //        siz[u] += siz[v];
-//        dp[u] += dp[v] + len * siz[v];
+//        sum[u] += sum[v] + len * siz[v];
 //        costMin = min(costMin, minv[u] + minv[v] + len);
 //        costMax = max(costMax, maxv[u] + maxv[v] + len);
 //        minv[u] = min(minv[u], minv[v] + len);
@@ -178,7 +188,7 @@
 //    costSum = 0;
 //    costMin = INF;
 //    costMax = -INF;
-//    dpOnTree(tree);
+//    dp(tree);
 //    for (int i = 1; i <= k; i++) {
 //        isKey[arr[i]] = false;
 //    }

From 8157f3a570ac6170a3b2c6c73eff68c4f0dbd9ae Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 18:36:07 +0800
Subject: [PATCH 1519/1712] modify code

---
 src/class180/Code01_VirtualTree1.java |  2 +-
 src/class180/Code01_VirtualTree2.java |  2 +-
 src/class180/Code02_BigProject1.java  |  2 +-
 src/class180/Code02_BigProject2.java  |  2 +-
 src/class180/Code03_War1.java         | 26 +++++++++++++++++---------
 src/class180/Code03_War2.java         | 26 +++++++++++++++++---------
 6 files changed, 38 insertions(+), 22 deletions(-)

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
index af367a905..f697bdede 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_VirtualTree1.java
@@ -1,7 +1,7 @@
 package class180;
 
 // 虚树模版题，java版
-// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的重要点，其他点是非重要点
 //                       你可以攻占非重要点，被攻占的点无法通行
diff --git a/src/class180/Code01_VirtualTree2.java b/src/class180/Code01_VirtualTree2.java
index 7a025398f..164d1c40b 100644
--- a/src/class180/Code01_VirtualTree2.java
+++ b/src/class180/Code01_VirtualTree2.java
@@ -1,7 +1,7 @@
 package class180;
 
 // 虚树模版题，C++版
-// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的重要点，其他点是非重要点
 //                       你可以攻占非重要点，被攻占的点无法通行
diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index af4c42fbc..11d4d6ec9 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -1,7 +1,7 @@
 package class180;
 
 // 大工程，java版
-// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 如果在节点a和节点b之间建立新通道，那么代价是两个节点在树上的距离
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的节点，任意两个节点之间都会建立新通道
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index 20acba1db..be47ad5f4 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -1,7 +1,7 @@
 package class180;
 
 // 大工程，C++版
-// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 如果在节点a和节点b之间建立新通道，那么代价是两个节点在树上的距离
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的节点，任意两个节点之间都会建立新通道
diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index 88a53e6f0..d434c360a 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -1,6 +1,13 @@
 package class180;
 
 // 消耗战，java版
+// 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，并且一定不包含1号节点
+//                       你可以随意选择边进行切断，切断的代价就是边权
+//                       目的是让所有关键点都无法到达1号节点，打印最小总代价
+// 1 <= n、m <= 5 * 10^5
+// 1 <= 所有查询给出的点的总数 <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2495
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -11,7 +18,7 @@
 
 public class Code03_War1 {
 
-	public static int MAXN = 300001;
+	public static int MAXN = 500001;
 	public static int MAXP = 20;
 	public static int n, q, k;
 
@@ -37,7 +44,8 @@ public class Code03_War1 {
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
 	public static int[] stk = new int[MAXN];
-	public static long[] dp = new long[MAXN];
+
+	public static long[] cut = new long[MAXN];
 
 	public static void addEdgeG(int u, int v, int w) {
 		nextg[++cntg] = headg[u];
@@ -197,18 +205,18 @@ public static int buildVirtualTree2() {
 		return stk[1];
 	}
 
-	public static void dpOnTree(int u) {
+	public static void dp(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
-			dpOnTree(tov[e]);
+			dp(tov[e]);
 		}
-		dp[u] = 0;
+		cut[u] = 0;
 		for (int e = headv[u], v, w; e > 0; e = nextv[e]) {
 			v = tov[e];
 			w = weightv[e];
 			if (isKey[v]) {
-				dp[u] += w;
+				cut[u] += w;
 			} else {
-				dp[u] += Math.min(dp[v], w);
+				cut[u] += Math.min(cut[v], w);
 			}
 		}
 	}
@@ -219,11 +227,11 @@ public static long compute() {
 		}
 		int tree = buildVirtualTree1();
 		// int tree = buildVirtualTree2();
-		dpOnTree(tree);
+		dp(tree);
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
 		}
-		return dp[tree];
+		return cut[tree];
 	}
 
 	public static void main(String[] args) throws Exception {
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index a5e1caf0c..3b2371615 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -1,6 +1,13 @@
 package class180;
 
 // 消耗战，C++版
+// 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，并且一定不包含1号节点
+//                       你可以随意选择边进行切断，切断的代价就是边权
+//                       目的是让所有关键点都无法到达1号节点，打印最小总代价
+// 1 <= n、m <= 5 * 10^5
+// 1 <= 所有查询给出的点的总数 <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2495
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -9,7 +16,7 @@
 //
 //using namespace std;
 //
-//const int MAXN = 300001;
+//const int MAXN = 500001;
 //const int MAXP = 20;
 //int n, q, k;
 //
@@ -35,7 +42,8 @@
 //bool isKey[MAXN];
 //int tmp[MAXN << 1];
 //int stk[MAXN];
-//long long dp[MAXN];
+//
+//long long cut[MAXN];
 //
 //bool cmp(int x, int y) {
 //    return dfn[x] < dfn[y];
@@ -172,18 +180,18 @@
 //    return stk[1];
 //}
 //
-//void dpOnTree(int u) {
+//void dp(int u) {
 //    for (int e = headv[u]; e; e = nextv[e]) {
-//        dpOnTree(tov[e]);
+//        dp(tov[e]);
 //    }
-//    dp[u] = 0;
+//    cut[u] = 0;
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        int w = weightv[e];
 //        if (isKey[v]) {
-//            dp[u] += w;
+//            cut[u] += w;
 //        } else {
-//            dp[u] += min(dp[v], (long long)w);
+//            cut[u] += min(cut[v], (long long)w);
 //        }
 //    }
 //}
@@ -194,11 +202,11 @@
 //    }
 //    int tree = buildVirtualTree1();
 //    // int tree = buildVirtualTree2();
-//    dpOnTree(tree);
+//    dp(tree);
 //    for (int i = 1; i <= k; i++) {
 //        isKey[arr[i]] = false;
 //    }
-//    return dp[tree];
+//    return cut[tree];
 //}
 //
 //int main() {

From c8aa8aa61f2af4c5a1d50172a8094b2f6ef458fa Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 18:51:26 +0800
Subject: [PATCH 1520/1712] modify code

---
 src/class180/Code03_War1.java       |  2 +-
 src/class180/Code03_War2.java       |  2 +-
 src/class180/Code04_WorldTree1.java | 29 ++++++++++++++++++-----------
 src/class180/Code04_WorldTree2.java | 29 ++++++++++++++++++-----------
 4 files changed, 38 insertions(+), 24 deletions(-)

diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index d434c360a..7bba45b91 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -6,7 +6,7 @@
 // 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，并且一定不包含1号节点
 //                       你可以随意选择边进行切断，切断的代价就是边权
 //                       目的是让所有关键点都无法到达1号节点，打印最小总代价
-// 1 <= n、m <= 5 * 10^5
+// 1 <= n、q <= 5 * 10^5
 // 1 <= 所有查询给出的点的总数 <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2495
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index 3b2371615..e4ec2eada 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -6,7 +6,7 @@
 // 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，并且一定不包含1号节点
 //                       你可以随意选择边进行切断，切断的代价就是边权
 //                       目的是让所有关键点都无法到达1号节点，打印最小总代价
-// 1 <= n、m <= 5 * 10^5
+// 1 <= n、q <= 5 * 10^5
 // 1 <= 所有查询给出的点的总数 <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P2495
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index e4c500542..82ce09fbb 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -1,6 +1,13 @@
 package class180;
 
 // 世界树，java版
+// 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，树上每个点都找最近的关键点来管理自己
+//                       最近的关键点如果有多个，选择编号最小的关键点
+//                       打印每个关键点的管理节点数量
+// 1 <= n、q <= 3 * 10^5
+// 1 <= 所有查询给出的点的总数 <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3233
 // 提交以下的code，提交时请把类名改成"Main"
 // 本题递归函数较多，java版不改成迭代会爆栈，导致无法通过
@@ -41,7 +48,7 @@ public class Code04_WorldTree1 {
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
 
-	public static int[] dp = new int[MAXN];
+	public static int[] mindist = new int[MAXN];
 	public static int[] pick = new int[MAXN];
 	public static int[] ans = new int[MAXN];
 
@@ -143,20 +150,20 @@ public static int buildVirtualTree() {
 	}
 
 	public static void dp1(int u) {
-		dp[u] = INF;
+		mindist[u] = INF;
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			dp1(v);
 			int dis = dep[v] - dep[u];
-			if (dp[u] > dp[v] + dis) {
-				dp[u] = dp[v] + dis;
+			if (mindist[u] > mindist[v] + dis) {
+				mindist[u] = mindist[v] + dis;
 				pick[u] = pick[v];
-			} else if (dp[u] == dp[v] + dis) {
+			} else if (mindist[u] == mindist[v] + dis) {
 				pick[u] = Math.min(pick[u], pick[v]);
 			}
 		}
 		if (isKey[u]) {
-			dp[u] = 0;
+			mindist[u] = 0;
 			pick[u] = u;
 		}
 	}
@@ -164,8 +171,8 @@ public static void dp1(int u) {
 	public static void calc(int x, int y) {
 		int b = y;
 		for (int p = MAXP - 1; p >= 0; p--) {
-			int l = dep[y] - dep[stjump[b][p]] + dp[y];
-			int r = dep[stjump[b][p]] - dep[x] + dp[x];
+			int l = dep[y] - dep[stjump[b][p]] + mindist[y];
+			int r = dep[stjump[b][p]] - dep[x] + mindist[x];
 			if (dep[stjump[b][p]] > dep[x] && (l < r || (l == r && pick[y] < pick[x]))) {
 				b = stjump[b][p];
 			}
@@ -178,10 +185,10 @@ public static void dp2(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			int dis = dep[v] - dep[u];
-			if (dp[v] > dp[u] + dis) {
-				dp[v] = dp[u] + dis;
+			if (mindist[v] > mindist[u] + dis) {
+				mindist[v] = mindist[u] + dis;
 				pick[v] = pick[u];
-			} else if (dp[v] == dp[u] + dis) {
+			} else if (mindist[v] == mindist[u] + dis) {
 				pick[v] = Math.min(pick[v], pick[u]);
 			}
 			calc(u, v);
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 238d883e0..3fb964aaf 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -1,6 +1,13 @@
 package class180;
 
 // 世界树，C++版
+// 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
+// 一共有q条查询，每条查询格式如下
+// 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，树上每个点都找最近的关键点来管理自己
+//                       最近的关键点如果有多个，选择编号最小的关键点
+//                       打印每个关键点的管理节点数量
+// 1 <= n、q <= 3 * 10^5
+// 1 <= 所有查询给出的点的总数 <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3233
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -35,7 +42,7 @@
 //bool isKey[MAXN];
 //int tmp[MAXN << 1];
 //
-//int dp[MAXN];
+//int mindist[MAXN];
 //int pick[MAXN];
 //int ans[MAXN];
 //
@@ -120,20 +127,20 @@
 //}
 //
 //void dp1(int u) {
-//    dp[u] = INF;
+//    mindist[u] = INF;
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        dp1(v);
 //        int dis = dep[v] - dep[u];
-//        if (dp[u] > dp[v] + dis) {
-//            dp[u] = dp[v] + dis;
+//        if (mindist[u] > mindist[v] + dis) {
+//            mindist[u] = mindist[v] + dis;
 //            pick[u] = pick[v];
-//        } else if (dp[u] == dp[v] + dis) {
+//        } else if (mindist[u] == mindist[v] + dis) {
 //            pick[u] = min(pick[u], pick[v]);
 //        }
 //    }
 //    if (isKey[u]) {
-//        dp[u] = 0;
+//        mindist[u] = 0;
 //        pick[u] = u;
 //    }
 //}
@@ -141,8 +148,8 @@
 //void calc(int x, int y) {
 //    int b = y;
 //    for (int p = MAXP - 1; p >= 0; p--) {
-//        int l = (dep[y] - dep[stjump[b][p]]) + dp[y];
-//        int r = (dep[stjump[b][p]] - dep[x]) + dp[x];
+//        int l = (dep[y] - dep[stjump[b][p]]) + mindist[y];
+//        int r = (dep[stjump[b][p]] - dep[x]) + mindist[x];
 //        if (dep[stjump[b][p]] > dep[x] && (l < r || (l == r && pick[y] < pick[x]))) {
 //            b = stjump[b][p];
 //        }
@@ -155,10 +162,10 @@
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        int dis = dep[v] - dep[u];
-//        if (dp[v] > dp[u] + dis) {
-//            dp[v] = dp[u] + dis;
+//        if (mindist[v] > mindist[u] + dis) {
+//            mindist[v] = mindist[u] + dis;
 //            pick[v] = pick[u];
-//        } else if (dp[v] == dp[u] + dis) {
+//        } else if (mindist[v] == mindist[u] + dis) {
 //            pick[v] = min(pick[v], pick[u]);
 //        }
 //        calc(u, v);

From f6c8731fdd0fd748eb662939db83f2445f380030 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 19:24:02 +0800
Subject: [PATCH 1521/1712] modify code

---
 src/class180/Code05_TreelandAndViruses1.java | 9 +++++++++
 src/class180/Code05_TreelandAndViruses2.java | 9 +++++++++
 2 files changed, 18 insertions(+)

diff --git a/src/class180/Code05_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
index 01b344ea6..3d1d95288 100644
--- a/src/class180/Code05_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -1,6 +1,15 @@
 package class180;
 
 // 树上病毒传播，java版
+// 一共有n个城市，有n-1条无向边，所有城市组成一棵树，一共有q条查询，每条查询数据如下
+// 首先给定k种病毒，每种病毒有初次感染的城市start[i]，还有传播速度speed[i]
+// 然后给定m个关键城市，打印每个城市被第几号病毒感染，病毒传播的规则如下
+// 病毒的传播按轮次进行，每一轮病毒1先传播，然后是病毒2 .. 直到病毒k，下一轮又从病毒1开始
+// 如果第i种病毒已经感染了城市x，当自己传播时，想要感染城市y的条件如下
+// 1，城市x到城市y的路径包含的边数 <= speed[i]
+// 2，城市x到城市y的路径上，除了城市x之外，所有城市都未被感染
+// 一旦城市被某种病毒感染就永久保持，不会再被其他病毒感染，传播一直持续，直到所有城市都被感染
+// 1 <= n、q、所有查询病毒总数、所有查询关键城市总数 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1320E
 // 测试链接 : https://codeforces.com/problemset/problem/1320/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class180/Code05_TreelandAndViruses2.java b/src/class180/Code05_TreelandAndViruses2.java
index 62b0ed402..b99c096e0 100644
--- a/src/class180/Code05_TreelandAndViruses2.java
+++ b/src/class180/Code05_TreelandAndViruses2.java
@@ -1,6 +1,15 @@
 package class180;
 
 // 树上病毒传播，C++版
+// 一共有n个城市，有n-1条无向边，所有城市组成一棵树，一共有q条查询，每条查询数据如下
+// 首先给定k种病毒，每种病毒有初次感染的城市start[i]，还有传播速度speed[i]
+// 然后给定m个关键城市，打印每个城市被第几号病毒感染，病毒传播的规则如下
+// 病毒的传播按轮次进行，每一轮病毒1先传播，然后是病毒2 .. 直到病毒k，下一轮又从病毒1开始
+// 如果第i种病毒已经感染了城市x，当自己传播时，想要感染城市y的条件如下
+// 1，城市x到城市y的路径包含的边数 <= speed[i]
+// 2，城市x到城市y的路径上，除了城市x之外，所有城市都未被感染
+// 一旦城市被某种病毒感染就永久保持，不会再被其他病毒感染，传播一直持续，直到所有城市都被感染
+// 1 <= n、q、所有查询病毒总数、所有查询关键城市总数 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1320E
 // 测试链接 : https://codeforces.com/problemset/problem/1320/E
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 8f373473e52a3aefabad8ebabba36e32dba9f4c3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 19:28:22 +0800
Subject: [PATCH 1522/1712] modify code

---
 src/class180/Code02_BigProject1.java | 2 +-
 src/class180/Code02_BigProject2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index 11d4d6ec9..4a753e7b4 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -22,7 +22,7 @@
 public class Code02_BigProject1 {
 
 	public static int MAXN = 1000001;
-	public static int MAXP = 21;
+	public static int MAXP = 20;
 	public static long INF = 1L << 60;
 	public static int n, q, k;
 
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index be47ad5f4..637119bdf 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -20,7 +20,7 @@
 //using namespace std;
 //
 //const int MAXN = 1000001;
-//const int MAXP = 21;
+//const int MAXP = 20;
 //const long long INF = 1LL << 60;
 //int n, q, k;
 //

From 716a588ee7a927bca6a6acee04124c0515d3a9e9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 11 Oct 2025 21:54:42 +0800
Subject: [PATCH 1523/1712] modify code

---
 src/class180/Code06_TreasureHunt1.java | 15 +++++++++------
 src/class180/Code06_TreasureHunt2.java | 15 +++++++++------
 2 files changed, 18 insertions(+), 12 deletions(-)

diff --git a/src/class180/Code06_TreasureHunt1.java b/src/class180/Code06_TreasureHunt1.java
index 34fedadc1..e66f04f05 100644
--- a/src/class180/Code06_TreasureHunt1.java
+++ b/src/class180/Code06_TreasureHunt1.java
@@ -1,6 +1,12 @@
 package class180;
 
 // 寻宝游戏，java版
+// 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
+// 一开始所有的节点都没有宝物，接下来有m条操作，每条操作格式如下
+// 操作 x : 如果x号点上无宝物，那么变成有宝物，如果x号点上有宝物，那么变成无宝物
+// 每次操作后，树上会形成新的宝物分布，所以每次你都可以选择任何点作为出发点
+// 目标是拿完当前状况下的所有宝物，最后回到出发点，打印最小的总路程，一共有m条打印
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3320
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -143,14 +149,11 @@ public static void compute() {
 			int dfnId = dfn[nodeId];
 			if (!vis[nodeId]) {
 				set.add(dfnId);
-			}
-			int low = set.lower(dfnId) != null ? set.lower(dfnId) : set.last();
-			int high = set.higher(dfnId) != null ? set.higher(dfnId) : set.first();
-			if (vis[nodeId]) {
+			} else {
 				set.remove(dfnId);
 			}
-			low = seg[low];
-			high = seg[high];
+			int low = seg[set.lower(dfnId) != null ? set.lower(dfnId) : set.last()];
+			int high = seg[set.higher(dfnId) != null ? set.higher(dfnId) : set.first()];
 			long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
 			if (!vis[nodeId]) {
 				vis[nodeId] = true;
diff --git a/src/class180/Code06_TreasureHunt2.java b/src/class180/Code06_TreasureHunt2.java
index aca0add39..8d1990eab 100644
--- a/src/class180/Code06_TreasureHunt2.java
+++ b/src/class180/Code06_TreasureHunt2.java
@@ -1,6 +1,12 @@
 package class180;
 
 // 寻宝游戏，C++版
+// 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
+// 一开始所有的节点都没有宝物，接下来有m条操作，每条操作格式如下
+// 操作 x : 如果x号点上无宝物，那么变成有宝物，如果x号点上有宝物，那么变成无宝物
+// 每次操作后，树上会形成新的宝物分布，所以每次你都可以选择任何点作为出发点
+// 目标是拿完当前状况下的所有宝物，最后回到出发点，打印最小的总路程，一共有m条打印
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3320
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -89,14 +95,11 @@
 //        int dfnId = dfn[nodeId];
 //        if (!vis[nodeId]) {
 //            st.insert(dfnId);
-//        }
-//        int low = (it = st.lower_bound(dfnId)) == st.begin() ? *--st.end() : *--it;
-//        int high = (it = st.upper_bound(dfnId)) == st.end() ? *st.begin() : *it;
-//        if (vis[nodeId]) {
+//        } else {
 //            st.erase(dfnId);
 //        }
-//        low = seg[low];
-//        high = seg[high];
+//        int low = seg[(it = st.lower_bound(dfnId)) == st.begin() ? *--st.end() : *--it];
+//        int high = seg[(it = st.upper_bound(dfnId)) == st.end() ? *st.begin() : *it];
 //        long long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
 //        if (!vis[nodeId]) {
 //            vis[nodeId] = true;

From d80c5708b5d5759c6259767c34e05549debfeb6f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 08:16:26 +0800
Subject: [PATCH 1524/1712] modify code

---
 src/class180/Code06_TreasureHunt1.java | 20 ++++++++++++--------
 src/class180/Code06_TreasureHunt2.java | 20 ++++++++++++--------
 2 files changed, 24 insertions(+), 16 deletions(-)

diff --git a/src/class180/Code06_TreasureHunt1.java b/src/class180/Code06_TreasureHunt1.java
index e66f04f05..58e0357c9 100644
--- a/src/class180/Code06_TreasureHunt1.java
+++ b/src/class180/Code06_TreasureHunt1.java
@@ -148,19 +148,23 @@ public static void compute() {
 			int nodeId = arr[i];
 			int dfnId = dfn[nodeId];
 			if (!vis[nodeId]) {
+				vis[nodeId] = true;
 				set.add(dfnId);
 			} else {
+				vis[nodeId] = false;
 				set.remove(dfnId);
 			}
-			int low = seg[set.lower(dfnId) != null ? set.lower(dfnId) : set.last()];
-			int high = seg[set.higher(dfnId) != null ? set.higher(dfnId) : set.first()];
-			long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
-			if (!vis[nodeId]) {
-				vis[nodeId] = true;
-				curAns += delta;
+			if (set.size() <= 1) {
+				curAns = 0;
 			} else {
-				vis[nodeId] = false;
-				curAns -= delta;
+				int low = seg[set.lower(dfnId) != null ? set.lower(dfnId) : set.last()];
+				int high = seg[set.higher(dfnId) != null ? set.higher(dfnId) : set.first()];
+				long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
+				if (vis[nodeId]) {
+					curAns += delta;
+				} else {
+					curAns -= delta;
+				}
 			}
 			ans[i] = curAns;
 		}
diff --git a/src/class180/Code06_TreasureHunt2.java b/src/class180/Code06_TreasureHunt2.java
index 8d1990eab..91bbf5fcc 100644
--- a/src/class180/Code06_TreasureHunt2.java
+++ b/src/class180/Code06_TreasureHunt2.java
@@ -94,19 +94,23 @@
 //        int nodeId = arr[i];
 //        int dfnId = dfn[nodeId];
 //        if (!vis[nodeId]) {
+//            vis[nodeId] = true;
 //            st.insert(dfnId);
 //        } else {
+//            vis[nodeId] = false;
 //            st.erase(dfnId);
 //        }
-//        int low = seg[(it = st.lower_bound(dfnId)) == st.begin() ? *--st.end() : *--it];
-//        int high = seg[(it = st.upper_bound(dfnId)) == st.end() ? *st.begin() : *it];
-//        long long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
-//        if (!vis[nodeId]) {
-//            vis[nodeId] = true;
-//            curAns += delta;
+//        if (st.size() <= 1) {
+//            curAns = 0;
 //        } else {
-//            vis[nodeId] = false;
-//            curAns -= delta;
+//            int low = seg[(it = st.lower_bound(dfnId)) == st.begin() ? *--st.end() : *--it];
+//            int high = seg[(it = st.upper_bound(dfnId)) == st.end() ? *st.begin() : *it];
+//            long long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
+//            if (vis[nodeId]) {
+//                curAns += delta;
+//            } else {
+//                curAns -= delta;
+//            }
 //        }
 //        ans[i] = curAns;
 //    }

From 6f22a36c3d4bae8d741b87ae9b13b88458c3fc31 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 13:52:27 +0800
Subject: [PATCH 1525/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 18 +++++++++---------
 src/class180/Code04_WorldTree2.java | 24 ++++++++++++------------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index 82ce09fbb..9cfb3be02 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -5,7 +5,7 @@
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，树上每个点都找最近的关键点来管理自己
 //                       最近的关键点如果有多个，选择编号最小的关键点
-//                       打印每个关键点的管理节点数量
+//                       打印每个关键点所管理的节点数量
 // 1 <= n、q <= 3 * 10^5
 // 1 <= 所有查询给出的点的总数 <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3233
@@ -169,19 +169,20 @@ public static void dp1(int u) {
 	}
 
 	public static void calc(int x, int y) {
-		int b = y;
+		int f = y;
 		for (int p = MAXP - 1; p >= 0; p--) {
-			int l = dep[y] - dep[stjump[b][p]] + mindist[y];
-			int r = dep[stjump[b][p]] - dep[x] + mindist[x];
-			if (dep[stjump[b][p]] > dep[x] && (l < r || (l == r && pick[y] < pick[x]))) {
-				b = stjump[b][p];
+			int tox = dep[stjump[f][p]] - dep[x] + mindist[x];
+			int toy = dep[y] - dep[stjump[f][p]] + mindist[y];
+			if (dep[x] < dep[stjump[f][p]] && (toy < tox || (toy == tox && pick[y] < pick[x]))) {
+				f = stjump[f][p];
 			}
 		}
-		ans[pick[y]] += siz[b] - siz[y];
-		ans[pick[x]] -= siz[b];
+		ans[pick[y]] += siz[f] - siz[y];
+		ans[pick[x]] -= siz[f];
 	}
 
 	public static void dp2(int u) {
+		ans[pick[u]] += siz[u];
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			int dis = dep[v] - dep[u];
@@ -194,7 +195,6 @@ public static void dp2(int u) {
 			calc(u, v);
 			dp2(v);
 		}
-		ans[pick[u]] += siz[u];
 	}
 
 	public static void compute() {
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 3fb964aaf..463e17af9 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -5,7 +5,7 @@
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，树上每个点都找最近的关键点来管理自己
 //                       最近的关键点如果有多个，选择编号最小的关键点
-//                       打印每个关键点的管理节点数量
+//                       打印每个关键点所管理的节点数量
 // 1 <= n、q <= 3 * 10^5
 // 1 <= 所有查询给出的点的总数 <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3233
@@ -105,15 +105,15 @@
 //    int len = 0;
 //    tmp[++len] = 1;
 //    for (int i = 1; i < k; i++) {
-//    	tmp[++len] = arr[i];
-//    	tmp[++len] = getLca(arr[i], arr[i + 1]);
+//        tmp[++len] = arr[i];
+//        tmp[++len] = getLca(arr[i], arr[i + 1]);
 //    }
 //    tmp[++len] = arr[k];
 //    sort(tmp + 1, tmp + len + 1, cmp);
 //    int unique = 1;
 //    for (int i = 2; i <= len; i++) {
 //        if (tmp[unique] != tmp[i]) {
-//        	tmp[++unique] = tmp[i];
+//            tmp[++unique] = tmp[i];
 //        }
 //    }
 //    cntv = 0;
@@ -146,19 +146,20 @@
 //}
 //
 //void calc(int x, int y) {
-//    int b = y;
+//    int f = y;
 //    for (int p = MAXP - 1; p >= 0; p--) {
-//        int l = (dep[y] - dep[stjump[b][p]]) + mindist[y];
-//        int r = (dep[stjump[b][p]] - dep[x]) + mindist[x];
-//        if (dep[stjump[b][p]] > dep[x] && (l < r || (l == r && pick[y] < pick[x]))) {
-//            b = stjump[b][p];
+//        int tox = (dep[stjump[f][p]] - dep[x]) + mindist[x];
+//        int toy = (dep[y] - dep[stjump[f][p]]) + mindist[y];
+//        if (dep[x] < dep[stjump[f][p]] && (toy < tox || (toy == tox && pick[y] < pick[x]))) {
+//            f = stjump[f][p];
 //        }
 //    }
-//    ans[pick[y]] += siz[b] - siz[y];
-//    ans[pick[x]] -= siz[b];
+//    ans[pick[y]] += siz[f] - siz[y];
+//    ans[pick[x]] -= siz[f];
 //}
 //
 //void dp2(int u) {
+//    ans[pick[u]] += siz[u];
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        int dis = dep[v] - dep[u];
@@ -171,7 +172,6 @@
 //        calc(u, v);
 //        dp2(v);
 //    }
-//    ans[pick[u]] += siz[u];
 //}
 //
 //void compute() {

From ce6474cc9d655805d5cea85188febbd54fdef676 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 14:11:13 +0800
Subject: [PATCH 1526/1712] modify code

---
 src/class180/Code05_TreelandAndViruses1.java | 23 ++++++++++----------
 src/class180/Code05_TreelandAndViruses2.java | 17 ++++++++++-----
 2 files changed, 23 insertions(+), 17 deletions(-)

diff --git a/src/class180/Code05_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
index 3d1d95288..5c6b9a733 100644
--- a/src/class180/Code05_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -100,9 +100,7 @@ public static void sortByDfn(int[] nums, int l, int r) {
 			while (dfn[nums[i]] < dfn[pivot]) i++;
 			while (dfn[nums[j]] > dfn[pivot]) j--;
 			if (i <= j) {
-				int tmp = nums[i];
-				nums[i] = nums[j];
-				nums[j] = tmp;
+				int tmp = nums[i]; nums[i] = nums[j]; nums[j] = tmp;
 				i++; j--;
 			}
 		}
@@ -198,18 +196,21 @@ public static void dijkstra() {
 		while (!heap.isEmpty()) {
 			Node cur = heap.poll();
 			int u = cur.id;
-			int source = cur.source;
-			int sourceOrder = cur.sourceOrder;
+			int udist = cur.dist;
+			int usource = cur.source;
+			int usourceOrder = cur.sourceOrder;
 			if (!vis[u]) {
 				vis[u] = true;
 				for (int e = headv[u]; e > 0; e = nextv[e]) {
 					int v = tov[e];
-					int dist = cur.dist + Math.abs(dep[u] - dep[v]);
-					int time = (dist + speed[source] - 1) / speed[source];
-					if (!vis[v] && (time < minTime[v] || (time == minTime[v] && sourceOrder < order[bestSource[v]]))) {
-						minTime[v] = time;
-						bestSource[v] = source;
-						heap.add(new Node(v, dist, time, source, sourceOrder));
+					if (!vis[v]) {
+						int vdist = udist + Math.abs(dep[u] - dep[v]);
+						int vtime = (vdist + speed[usource] - 1) / speed[usource];
+						if (vtime < minTime[v] || (vtime == minTime[v] && usourceOrder < order[bestSource[v]])) {
+							minTime[v] = vtime;
+							bestSource[v] = usource;
+							heap.add(new Node(v, vdist, vtime, usource, usourceOrder));
+						}
 					}
 				}
 			}
diff --git a/src/class180/Code05_TreelandAndViruses2.java b/src/class180/Code05_TreelandAndViruses2.java
index b99c096e0..dc58a7da2 100644
--- a/src/class180/Code05_TreelandAndViruses2.java
+++ b/src/class180/Code05_TreelandAndViruses2.java
@@ -166,16 +166,21 @@
 //        Node cur = heap.top();
 //        heap.pop();
 //        int u = cur.id;
+//        int udist = cur.dist;
+//        int usource = cur.source;
+//        int usourceOrder = cur.sourceOrder;
 //        if (!vis[u]) {
 //            vis[u] = true;
 //            for (int e = headv[u]; e; e = nextv[e]) {
 //                int v = tov[e];
-//                int dist = cur.dist + abs(dep[u] - dep[v]);
-//                int time = (dist + speed[cur.source] - 1) / speed[cur.source];
-//                if (!vis[v] && (time < minTime[v] || (time == minTime[v] && cur.sourceOrder < order[bestSource[v]]))) {
-//                    minTime[v] = time;
-//                    bestSource[v] = cur.source;
-//                    heap.push(Node{v, dist, time, cur.source, cur.sourceOrder});
+//                if (!vis[v]) {
+//                    int vdist = udist + abs(dep[u] - dep[v]);
+//                    int vtime = (vdist + speed[usource] - 1) / speed[usource];
+//                    if (vtime < minTime[v] || (vtime == minTime[v] && usourceOrder < order[bestSource[v]])) {
+//                        minTime[v] = vtime;
+//                        bestSource[v] = usource;
+//                        heap.push(Node{v, vdist, vtime, usource, usourceOrder});
+//                    }
 //                }
 //            }
 //        }

From 700bc0aa5c0b9773f09a1fcba9c6ec484dbe11b6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 14:13:49 +0800
Subject: [PATCH 1527/1712] modify code

---
 src/class180/Code02_BigProject1.java   | 4 +---
 src/class180/Code03_War1.java          | 4 +---
 src/class180/Code04_WorldTree1.java    | 4 +---
 src/class180/Code06_TreasureHunt1.java | 4 +---
 4 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index 4a753e7b4..f09a051d7 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -146,9 +146,7 @@ public static void dfs2() {
 
 	public static int getLca(int a, int b) {
 		if (dep[a] < dep[b]) {
-			int tmp = a;
-			a = b;
-			b = tmp;
+			int tmp = a; a = b; b = tmp;
 		}
 		for (int p = MAXP - 1; p >= 0; p--) {
 			if (dep[stjump[a][p]] >= dep[b]) {
diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index 7bba45b91..95ceb49f5 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -95,9 +95,7 @@ public static void dfs(int u, int fa, int w) {
 
 	public static int getLca(int a, int b) {
 		if (dep[a] < dep[b]) {
-			int tmp = a;
-			a = b;
-			b = tmp;
+			int tmp = a; a = b; b = tmp;
 		}
 		for (int p = MAXP - 1; p >= 0; p--) {
 			if (dep[stjump[a][p]] >= dep[b]) {
diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index 9cfb3be02..ff2bf840e 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -100,9 +100,7 @@ public static void dfs(int u, int fa) {
 
 	public static int getLca(int a, int b) {
 		if (dep[a] < dep[b]) {
-			int tmp = a;
-			a = b;
-			b = tmp;
+			int tmp = a; a = b; b = tmp;
 		}
 		for (int p = MAXP - 1; p >= 0; p--) {
 			if (dep[stjump[a][p]] >= dep[b]) {
diff --git a/src/class180/Code06_TreasureHunt1.java b/src/class180/Code06_TreasureHunt1.java
index 58e0357c9..551785654 100644
--- a/src/class180/Code06_TreasureHunt1.java
+++ b/src/class180/Code06_TreasureHunt1.java
@@ -117,9 +117,7 @@ public static void dfs2() {
 
 	public static int getLca(int a, int b) {
 		if (dep[a] < dep[b]) {
-			int tmp = a;
-			a = b;
-			b = tmp;
+			int tmp = a; a = b; b = tmp;
 		}
 		for (int p = MAXP - 1; p >= 0; p--) {
 			if (dep[stjump[a][p]] >= dep[b]) {

From bc4636f27b06240fbb52e817644b6a75de8bf1d9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 14:18:17 +0800
Subject: [PATCH 1528/1712] modify code

---
 src/class180/Code01_VirtualTree1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_VirtualTree1.java
index f697bdede..10887d432 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_VirtualTree1.java
@@ -173,8 +173,8 @@ public static int buildVirtualTree2() {
 
 	public static void dp(int u) {
 		cost[u] = siz[u] = 0;
-		for (int e = headv[u], v; e > 0; e = nextv[e]) {
-			v = tov[e];
+		for (int e = headv[u]; e > 0; e = nextv[e]) {
+			int v = tov[e];
 			dp(v);
 			cost[u] += cost[v];
 			siz[u] += siz[v];

From c6fe9e62125b5abcb0966461cb7b4802557f5637 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 14:20:38 +0800
Subject: [PATCH 1529/1712] modify code

---
 src/class180/Code01_VirtualTree2.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class180/Code01_VirtualTree2.java b/src/class180/Code01_VirtualTree2.java
index 164d1c40b..c9d4f4a0c 100644
--- a/src/class180/Code01_VirtualTree2.java
+++ b/src/class180/Code01_VirtualTree2.java
@@ -162,7 +162,7 @@
 //        cost[u] += siz[u];
 //        siz[u] = 1;
 //    } else if (siz[u] > 1) {
-//        cost[u] += 1;
+//        cost[u]++;
 //        siz[u] = 0;
 //    }
 //}

From 661cd0b73185ec0e72a193aea5b583bb1b293841 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 21:50:56 +0800
Subject: [PATCH 1530/1712] modify code

---
 src/class180/Code03_War1.java       |  4 +---
 src/class180/Code04_WorldTree1.java | 19 ++++++++++---------
 src/class180/Code04_WorldTree2.java | 18 ++++++++++--------
 3 files changed, 21 insertions(+), 20 deletions(-)

diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index 95ceb49f5..631468285 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -117,9 +117,7 @@ public static int getLca(int a, int b) {
 	public static int getDist(int a, int b) {
 		int dist = 100000001;
 		if (dep[a] < dep[b]) {
-			int tmp = a;
-			a = b;
-			b = tmp;
+			int tmp = a; a = b; b = tmp;
 		}
 		for (int p = MAXP - 1; p >= 0; p--) {
 			if (dep[stjump[a][p]] >= dep[b]) {
diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index ff2bf840e..a20da36d7 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -64,7 +64,6 @@ public static void addEdgeV(int u, int v) {
 		headv[u] = cntv;
 	}
 
-	// nums中的数，根据dfn的大小排序，手撸双指针快排
 	public static void sortByDfn(int[] nums, int l, int r) {
 		if (l >= r) return;
 		int i = l, j = r;
@@ -166,17 +165,18 @@ public static void dp1(int u) {
 		}
 	}
 
-	public static void calc(int x, int y) {
-		int f = y;
+	public static void calc(int u, int v) {
+		int x = v;
 		for (int p = MAXP - 1; p >= 0; p--) {
-			int tox = dep[stjump[f][p]] - dep[x] + mindist[x];
-			int toy = dep[y] - dep[stjump[f][p]] + mindist[y];
-			if (dep[x] < dep[stjump[f][p]] && (toy < tox || (toy == tox && pick[y] < pick[x]))) {
-				f = stjump[f][p];
+			int tou = dep[stjump[x][p]] - dep[u] + mindist[u];
+			int tov = dep[v] - dep[stjump[x][p]] + mindist[v];
+			if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && pick[v] < pick[u]))) {
+				x = stjump[x][p];
 			}
 		}
-		ans[pick[y]] += siz[f] - siz[y];
-		ans[pick[x]] -= siz[f];
+		int delta = siz[x] - siz[v];
+		ans[pick[u]] -= delta;
+		ans[pick[v]] += delta;
 	}
 
 	public static void dp2(int u) {
@@ -191,6 +191,7 @@ public static void dp2(int u) {
 				pick[v] = Math.min(pick[v], pick[u]);
 			}
 			calc(u, v);
+			ans[pick[u]] -= siz[v];
 			dp2(v);
 		}
 	}
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 463e17af9..49621c1b3 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -145,17 +145,18 @@
 //    }
 //}
 //
-//void calc(int x, int y) {
-//    int f = y;
+//void calc(int u, int v) {
+//    int x = v;
 //    for (int p = MAXP - 1; p >= 0; p--) {
-//        int tox = (dep[stjump[f][p]] - dep[x]) + mindist[x];
-//        int toy = (dep[y] - dep[stjump[f][p]]) + mindist[y];
-//        if (dep[x] < dep[stjump[f][p]] && (toy < tox || (toy == tox && pick[y] < pick[x]))) {
-//            f = stjump[f][p];
+//        int tou = (dep[stjump[x][p]] - dep[u]) + mindist[u];
+//        int tov = (dep[v] - dep[stjump[x][p]]) + mindist[v];
+//        if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && pick[v] < pick[u]))) {
+//            x = stjump[x][p];
 //        }
 //    }
-//    ans[pick[y]] += siz[f] - siz[y];
-//    ans[pick[x]] -= siz[f];
+//    int delta = siz[x] - siz[v];
+//    ans[pick[u]] -= delta;
+//    ans[pick[v]] += delta;
 //}
 //
 //void dp2(int u) {
@@ -170,6 +171,7 @@
 //            pick[v] = min(pick[v], pick[u]);
 //        }
 //        calc(u, v);
+//        ans[pick[u]] -= siz[v];
 //        dp2(v);
 //    }
 //}

From 9408b44080fc3839f2da15500923f329c0c981ac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 12 Oct 2025 21:56:20 +0800
Subject: [PATCH 1531/1712] modify code

---
 src/class180/Code02_BigProject1.java | 37 ++--------------------------
 src/class180/Code02_BigProject2.java | 35 ++------------------------
 2 files changed, 4 insertions(+), 68 deletions(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index f09a051d7..9ba54d975 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -165,8 +165,7 @@ public static int getLca(int a, int b) {
 		return stjump[a][0];
 	}
 
-	// 二次排序 + LCA连边的方式建立虚树
-	public static int buildVirtualTree1() {
+	public static int buildVirtualTree() {
 		sortByDfn(arr, 1, k);
 		int len = 0;
 		for (int i = 1; i < k; i++) {
@@ -191,37 +190,6 @@ public static int buildVirtualTree1() {
 		return tmp[1];
 	}
 
-	// 单调栈的方式建立虚树
-	public static int buildVirtualTree2() {
-		sortByDfn(arr, 1, k);
-		cntv = 0;
-		headv[arr[1]] = 0;
-		int top = 0;
-		stk[++top] = arr[1];
-		for (int i = 2; i <= k; i++) {
-			int x = arr[i];
-			int y = stk[top];
-			int lca = getLca(x, y);
-			while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
-				addEdgeV(stk[top - 1], stk[top]);
-				top--;
-			}
-			if (lca != stk[top]) {
-				headv[lca] = 0;
-				addEdgeV(lca, stk[top]);
-				top--;
-				stk[++top] = lca;
-			}
-			headv[x] = 0;
-			stk[++top] = x;
-		}
-		while (top > 1) {
-			addEdgeV(stk[top - 1], stk[top]);
-			top--;
-		}
-		return stk[1];
-	}
-
 	// dp递归版，java会爆栈，C++可以通过
 	public static void dp1(int u) {
 		siz[u] = isKey[u] ? 1 : 0;
@@ -290,8 +258,7 @@ public static void compute() {
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = true;
 		}
-		int tree = buildVirtualTree1();
-		// int tree = buildVirtualTree2();
+		int tree = buildVirtualTree();
 		costSum = 0;
 		costMin = INF;
 		costMax = -INF;
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index 637119bdf..d90a73fd1 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -99,7 +99,7 @@
 //    return stjump[a][0];
 //}
 //
-//int buildVirtualTree1() {
+//int buildVirtualTree() {
 //    sort(arr + 1, arr + k + 1, cmp);
 //    int len = 0;
 //    for (int i = 1; i < k; i++) {
@@ -124,36 +124,6 @@
 //    return tmp[1];
 //}
 //
-//int buildVirtualTree2() {
-//    sort(arr + 1, arr + k + 1, cmp);
-//    cntv = 0;
-//    headv[arr[1]] = 0;
-//    int top = 0;
-//    stk[++top] = arr[1];
-//    for (int i = 2; i <= k; i++) {
-//        int x = arr[i];
-//        int y = stk[top];
-//        int lca = getLca(x, y);
-//        while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
-//            addEdgeV(stk[top - 1], stk[top]);
-//            top--;
-//        }
-//        if (lca != stk[top]) {
-//            headv[lca] = 0;
-//            addEdgeV(lca, stk[top]);
-//            top--;
-//            stk[++top] = lca;
-//        }
-//        headv[x] = 0;
-//        stk[++top] = x;
-//    }
-//    while (top > 1) {
-//        addEdgeV(stk[top - 1], stk[top]);
-//        top--;
-//    }
-//    return stk[1];
-//}
-//
 //void dp(int u) {
 //    siz[u] = isKey[u] ? 1 : 0;
 //    sum[u] = 0;
@@ -183,8 +153,7 @@
 //    for (int i = 1; i <= k; i++) {
 //        isKey[arr[i]] = true;
 //    }
-//    int tree = buildVirtualTree1();
-//    // int tree = buildVirtualTree2();
+//    int tree = buildVirtualTree();
 //    costSum = 0;
 //    costMin = INF;
 //    costMax = -INF;

From e0aab67ef4210638fc90c8541f6551f52fc4d8ac Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Oct 2025 12:55:42 +0800
Subject: [PATCH 1532/1712] modify code

---
 src/class180/Code02_BigProject1.java | 37 ++++++++++++++++++++++++++--
 src/class180/Code02_BigProject2.java | 35 ++++++++++++++++++++++++--
 2 files changed, 68 insertions(+), 4 deletions(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index 9ba54d975..f09a051d7 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -165,7 +165,8 @@ public static int getLca(int a, int b) {
 		return stjump[a][0];
 	}
 
-	public static int buildVirtualTree() {
+	// 二次排序 + LCA连边的方式建立虚树
+	public static int buildVirtualTree1() {
 		sortByDfn(arr, 1, k);
 		int len = 0;
 		for (int i = 1; i < k; i++) {
@@ -190,6 +191,37 @@ public static int buildVirtualTree() {
 		return tmp[1];
 	}
 
+	// 单调栈的方式建立虚树
+	public static int buildVirtualTree2() {
+		sortByDfn(arr, 1, k);
+		cntv = 0;
+		headv[arr[1]] = 0;
+		int top = 0;
+		stk[++top] = arr[1];
+		for (int i = 2; i <= k; i++) {
+			int x = arr[i];
+			int y = stk[top];
+			int lca = getLca(x, y);
+			while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+				addEdgeV(stk[top - 1], stk[top]);
+				top--;
+			}
+			if (lca != stk[top]) {
+				headv[lca] = 0;
+				addEdgeV(lca, stk[top]);
+				top--;
+				stk[++top] = lca;
+			}
+			headv[x] = 0;
+			stk[++top] = x;
+		}
+		while (top > 1) {
+			addEdgeV(stk[top - 1], stk[top]);
+			top--;
+		}
+		return stk[1];
+	}
+
 	// dp递归版，java会爆栈，C++可以通过
 	public static void dp1(int u) {
 		siz[u] = isKey[u] ? 1 : 0;
@@ -258,7 +290,8 @@ public static void compute() {
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = true;
 		}
-		int tree = buildVirtualTree();
+		int tree = buildVirtualTree1();
+		// int tree = buildVirtualTree2();
 		costSum = 0;
 		costMin = INF;
 		costMax = -INF;
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index d90a73fd1..637119bdf 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -99,7 +99,7 @@
 //    return stjump[a][0];
 //}
 //
-//int buildVirtualTree() {
+//int buildVirtualTree1() {
 //    sort(arr + 1, arr + k + 1, cmp);
 //    int len = 0;
 //    for (int i = 1; i < k; i++) {
@@ -124,6 +124,36 @@
 //    return tmp[1];
 //}
 //
+//int buildVirtualTree2() {
+//    sort(arr + 1, arr + k + 1, cmp);
+//    cntv = 0;
+//    headv[arr[1]] = 0;
+//    int top = 0;
+//    stk[++top] = arr[1];
+//    for (int i = 2; i <= k; i++) {
+//        int x = arr[i];
+//        int y = stk[top];
+//        int lca = getLca(x, y);
+//        while (top > 1 && dfn[stk[top - 1]] >= dfn[lca]) {
+//            addEdgeV(stk[top - 1], stk[top]);
+//            top--;
+//        }
+//        if (lca != stk[top]) {
+//            headv[lca] = 0;
+//            addEdgeV(lca, stk[top]);
+//            top--;
+//            stk[++top] = lca;
+//        }
+//        headv[x] = 0;
+//        stk[++top] = x;
+//    }
+//    while (top > 1) {
+//        addEdgeV(stk[top - 1], stk[top]);
+//        top--;
+//    }
+//    return stk[1];
+//}
+//
 //void dp(int u) {
 //    siz[u] = isKey[u] ? 1 : 0;
 //    sum[u] = 0;
@@ -153,7 +183,8 @@
 //    for (int i = 1; i <= k; i++) {
 //        isKey[arr[i]] = true;
 //    }
-//    int tree = buildVirtualTree();
+//    int tree = buildVirtualTree1();
+//    // int tree = buildVirtualTree2();
 //    costSum = 0;
 //    costMin = INF;
 //    costMax = -INF;

From b0347304627c6a4262ab4d35d6250c3a0d0aa817 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Oct 2025 13:05:05 +0800
Subject: [PATCH 1533/1712] modify code

---
 ...Code01_VirtualTree1.java => Code01_KingdomAndCities1.java} | 4 ++--
 ...Code01_VirtualTree2.java => Code01_KingdomAndCities2.java} | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class180/{Code01_VirtualTree1.java => Code01_KingdomAndCities1.java} (98%)
 rename src/class180/{Code01_VirtualTree2.java => Code01_KingdomAndCities2.java} (99%)

diff --git a/src/class180/Code01_VirtualTree1.java b/src/class180/Code01_KingdomAndCities1.java
similarity index 98%
rename from src/class180/Code01_VirtualTree1.java
rename to src/class180/Code01_KingdomAndCities1.java
index 10887d432..93eda99e6 100644
--- a/src/class180/Code01_VirtualTree1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -1,6 +1,6 @@
 package class180;
 
-// 虚树模版题，java版
+// 王国和城市，java版
 // 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的重要点，其他点是非重要点
@@ -18,7 +18,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code01_VirtualTree1 {
+public class Code01_KingdomAndCities1 {
 
 	public static int MAXN = 100001;
 	public static int MAXP = 20;
diff --git a/src/class180/Code01_VirtualTree2.java b/src/class180/Code01_KingdomAndCities2.java
similarity index 99%
rename from src/class180/Code01_VirtualTree2.java
rename to src/class180/Code01_KingdomAndCities2.java
index c9d4f4a0c..77ac8403f 100644
--- a/src/class180/Code01_VirtualTree2.java
+++ b/src/class180/Code01_KingdomAndCities2.java
@@ -1,6 +1,6 @@
 package class180;
 
-// 虚树模版题，C++版
+// 王国和城市，C++版
 // 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的重要点，其他点是非重要点

From 15afdd4ed834ec366cd1303267a59f3eff798c75 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Oct 2025 13:19:39 +0800
Subject: [PATCH 1534/1712] modify code

---
 src/class180/Code02_BigProject1.java         | 4 +---
 src/class180/Code02_BigProject2.java         | 4 +---
 src/class180/Code05_TreelandAndViruses1.java | 3 +--
 src/class180/Code05_TreelandAndViruses2.java | 3 +--
 4 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index f09a051d7..6da430b9e 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -5,9 +5,7 @@
 // 如果在节点a和节点b之间建立新通道，那么代价是两个节点在树上的距离
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的节点，任意两个节点之间都会建立新通道
-//                       打印新通道的代价和
-//                       打印新通道中代价最小的值
-//                       打印新通道中代价最大的值
+//                       打印新通道的代价和、新通道中代价最小的值、新通道中代价最大的值
 // 1 <= n <= 10^6
 // 1 <= q <= 5 * 10^4
 // 1 <= 所有查询给出的点的总数 <= 2 * n
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index 637119bdf..3db875281 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -5,9 +5,7 @@
 // 如果在节点a和节点b之间建立新通道，那么代价是两个节点在树上的距离
 // 一共有q条查询，每条查询格式如下
 // 查询 k a1 a2 ... ak : 给出了k个不同的节点，任意两个节点之间都会建立新通道
-//                       打印新通道的代价和
-//                       打印新通道中代价最小的值
-//                       打印新通道中代价最大的值
+//                       打印新通道的代价和、新通道中代价最小的值、新通道中代价最大的值
 // 1 <= n <= 10^6
 // 1 <= q <= 5 * 10^4
 // 1 <= 所有查询给出的点的总数 <= 2 * n
diff --git a/src/class180/Code05_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
index 5c6b9a733..8207d084d 100644
--- a/src/class180/Code05_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -6,8 +6,7 @@
 // 然后给定m个关键城市，打印每个城市被第几号病毒感染，病毒传播的规则如下
 // 病毒的传播按轮次进行，每一轮病毒1先传播，然后是病毒2 .. 直到病毒k，下一轮又从病毒1开始
 // 如果第i种病毒已经感染了城市x，当自己传播时，想要感染城市y的条件如下
-// 1，城市x到城市y的路径包含的边数 <= speed[i]
-// 2，城市x到城市y的路径上，除了城市x之外，所有城市都未被感染
+// 城市x到城市y的路径包含的边数<=speed[i]，城市x到城市y的路径上，除了x所有城市都未被感染
 // 一旦城市被某种病毒感染就永久保持，不会再被其他病毒感染，传播一直持续，直到所有城市都被感染
 // 1 <= n、q、所有查询病毒总数、所有查询关键城市总数 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1320E
diff --git a/src/class180/Code05_TreelandAndViruses2.java b/src/class180/Code05_TreelandAndViruses2.java
index dc58a7da2..ea9dadb70 100644
--- a/src/class180/Code05_TreelandAndViruses2.java
+++ b/src/class180/Code05_TreelandAndViruses2.java
@@ -6,8 +6,7 @@
 // 然后给定m个关键城市，打印每个城市被第几号病毒感染，病毒传播的规则如下
 // 病毒的传播按轮次进行，每一轮病毒1先传播，然后是病毒2 .. 直到病毒k，下一轮又从病毒1开始
 // 如果第i种病毒已经感染了城市x，当自己传播时，想要感染城市y的条件如下
-// 1，城市x到城市y的路径包含的边数 <= speed[i]
-// 2，城市x到城市y的路径上，除了城市x之外，所有城市都未被感染
+// 城市x到城市y的路径包含的边数<=speed[i]，城市x到城市y的路径上，除了x所有城市都未被感染
 // 一旦城市被某种病毒感染就永久保持，不会再被其他病毒感染，传播一直持续，直到所有城市都被感染
 // 1 <= n、q、所有查询病毒总数、所有查询关键城市总数 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/CF1320E

From 2c812ff0eec9b6ec1b995dc20da3c8cd0b8bf155 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Oct 2025 13:27:37 +0800
Subject: [PATCH 1535/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 26 +++++++++++++++++---------
 src/class180/Code04_WorldTree2.java | 26 +++++++++++++++++---------
 2 files changed, 34 insertions(+), 18 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index a20da36d7..ade402f15 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -165,6 +165,20 @@ public static void dp1(int u) {
 		}
 	}
 
+	public static void dp2(int u) {
+		for (int e = headv[u]; e > 0; e = nextv[e]) {
+			int v = tov[e];
+			int dis = dep[v] - dep[u];
+			if (mindist[v] > mindist[u] + dis) {
+				mindist[v] = mindist[u] + dis;
+				pick[v] = pick[u];
+			} else if (mindist[v] == mindist[u] + dis) {
+				pick[v] = Math.min(pick[v], pick[u]);
+			}
+			dp2(v);
+		}
+	}
+
 	public static void calc(int u, int v) {
 		int x = v;
 		for (int p = MAXP - 1; p >= 0; p--) {
@@ -179,20 +193,13 @@ public static void calc(int u, int v) {
 		ans[pick[v]] += delta;
 	}
 
-	public static void dp2(int u) {
+	public static void dp3(int u) {
 		ans[pick[u]] += siz[u];
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
-			int dis = dep[v] - dep[u];
-			if (mindist[v] > mindist[u] + dis) {
-				mindist[v] = mindist[u] + dis;
-				pick[v] = pick[u];
-			} else if (mindist[v] == mindist[u] + dis) {
-				pick[v] = Math.min(pick[v], pick[u]);
-			}
 			calc(u, v);
 			ans[pick[u]] -= siz[v];
-			dp2(v);
+			dp3(v);
 		}
 	}
 
@@ -207,6 +214,7 @@ public static void compute() {
 		int tree = buildVirtualTree();
 		dp1(tree);
 		dp2(tree);
+		dp3(tree);
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
 		}
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 49621c1b3..7b14ff653 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -145,6 +145,20 @@
 //    }
 //}
 //
+//void dp2(int u) {
+//    for (int e = headv[u]; e; e = nextv[e]) {
+//        int v = tov[e];
+//        int dis = dep[v] - dep[u];
+//        if (mindist[v] > mindist[u] + dis) {
+//            mindist[v] = mindist[u] + dis;
+//            pick[v] = pick[u];
+//        } else if (mindist[v] == mindist[u] + dis) {
+//            pick[v] = min(pick[v], pick[u]);
+//        }
+//        dp2(v);
+//    }
+//}
+//
 //void calc(int u, int v) {
 //    int x = v;
 //    for (int p = MAXP - 1; p >= 0; p--) {
@@ -159,20 +173,13 @@
 //    ans[pick[v]] += delta;
 //}
 //
-//void dp2(int u) {
+//void dp3(int u) {
 //    ans[pick[u]] += siz[u];
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
-//        int dis = dep[v] - dep[u];
-//        if (mindist[v] > mindist[u] + dis) {
-//            mindist[v] = mindist[u] + dis;
-//            pick[v] = pick[u];
-//        } else if (mindist[v] == mindist[u] + dis) {
-//            pick[v] = min(pick[v], pick[u]);
-//        }
 //        calc(u, v);
 //        ans[pick[u]] -= siz[v];
-//        dp2(v);
+//        dp3(v);
 //    }
 //}
 //
@@ -187,6 +194,7 @@
 //    int tree = buildVirtualTree();
 //    dp1(tree);
 //    dp2(tree);
+//    dp3(tree);
 //    for (int i = 1; i <= k; i++) {
 //        isKey[arr[i]] = false;
 //    }

From 322d9c5530caceb06fb473ed57e65467861f4d5f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 13 Oct 2025 14:00:51 +0800
Subject: [PATCH 1536/1712] modify code

---
 src/class180/Code01_KingdomAndCities1.java | 3 +--
 src/class180/Code01_KingdomAndCities2.java | 3 +--
 src/class180/Code02_BigProject1.java       | 3 +--
 src/class180/Code02_BigProject2.java       | 3 +--
 src/class180/Code03_War1.java              | 3 +--
 src/class180/Code03_War2.java              | 3 +--
 6 files changed, 6 insertions(+), 12 deletions(-)

diff --git a/src/class180/Code01_KingdomAndCities1.java b/src/class180/Code01_KingdomAndCities1.java
index 93eda99e6..bafeff6e8 100644
--- a/src/class180/Code01_KingdomAndCities1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -158,8 +158,7 @@ public static int buildVirtualTree2() {
 			if (lca != stk[top]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top]);
-				top--;
-				stk[++top] = lca;
+				stk[top] = lca;
 			}
 			headv[x] = 0;
 			stk[++top] = x;
diff --git a/src/class180/Code01_KingdomAndCities2.java b/src/class180/Code01_KingdomAndCities2.java
index 77ac8403f..94aca1b51 100644
--- a/src/class180/Code01_KingdomAndCities2.java
+++ b/src/class180/Code01_KingdomAndCities2.java
@@ -137,8 +137,7 @@
 //        if (lca != stk[top]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top]);
-//            top--;
-//            stk[++top] = lca;
+//            stk[top] = lca;
 //        }
 //        headv[x] = 0;
 //        stk[++top] = x;
diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index 6da430b9e..da83af8b3 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -207,8 +207,7 @@ public static int buildVirtualTree2() {
 			if (lca != stk[top]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top]);
-				top--;
-				stk[++top] = lca;
+				stk[top] = lca;
 			}
 			headv[x] = 0;
 			stk[++top] = x;
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index 3db875281..cd00884d8 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -139,8 +139,7 @@
 //        if (lca != stk[top]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top]);
-//            top--;
-//            stk[++top] = lca;
+//            stk[top] = lca;
 //        }
 //        headv[x] = 0;
 //        stk[++top] = x;
diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index 631468285..ecc2c00a4 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -188,8 +188,7 @@ public static int buildVirtualTree2() {
 			if (lca != stk[top]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top], getDist(lca, stk[top]));
-				top--;
-				stk[++top] = lca;
+				stk[top] = lca;
 			}
 			headv[x] = 0;
 			stk[++top] = x;
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index e4ec2eada..5f337d515 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -167,8 +167,7 @@
 //        if (lca != stk[top]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top], getDist(lca, stk[top]));
-//            top--;
-//            stk[++top] = lca;
+//            stk[top] = lca;
 //        }
 //        headv[x] = 0;
 //        stk[++top] = x;

From 8a306e50a823422890fde2b3e81d351d1237fc5f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 14:10:39 +0800
Subject: [PATCH 1537/1712] modify code

---
 src/class180/Code01_KingdomAndCities1.java | 2 +-
 src/class180/Code01_KingdomAndCities2.java | 2 +-
 src/class180/Code02_BigProject1.java       | 2 +-
 src/class180/Code02_BigProject2.java       | 6 ++++--
 src/class180/Code03_War1.java              | 2 +-
 src/class180/Code03_War2.java              | 2 +-
 6 files changed, 9 insertions(+), 7 deletions(-)

diff --git a/src/class180/Code01_KingdomAndCities1.java b/src/class180/Code01_KingdomAndCities1.java
index bafeff6e8..139c25a78 100644
--- a/src/class180/Code01_KingdomAndCities1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -155,7 +155,7 @@ public static int buildVirtualTree2() {
 				addEdgeV(stk[top - 1], stk[top]);
 				top--;
 			}
-			if (lca != stk[top]) {
+			if (dfn[stk[top]] > dfn[lca]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top]);
 				stk[top] = lca;
diff --git a/src/class180/Code01_KingdomAndCities2.java b/src/class180/Code01_KingdomAndCities2.java
index 94aca1b51..93442566d 100644
--- a/src/class180/Code01_KingdomAndCities2.java
+++ b/src/class180/Code01_KingdomAndCities2.java
@@ -134,7 +134,7 @@
 //            addEdgeV(stk[top - 1], stk[top]);
 //            top--;
 //        }
-//        if (lca != stk[top]) {
+//        if (dfn[stk[top]] > dfn[lca]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top]);
 //            stk[top] = lca;
diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index da83af8b3..ce13b48d4 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -204,7 +204,7 @@ public static int buildVirtualTree2() {
 				addEdgeV(stk[top - 1], stk[top]);
 				top--;
 			}
-			if (lca != stk[top]) {
+			if (dfn[stk[top]] > dfn[lca]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top]);
 				stk[top] = lca;
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index cd00884d8..28c08a866 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -83,7 +83,9 @@
 //        swap(a, b);
 //    }
 //    for (int p = MAXP - 1; p >= 0; p--) {
-//        if (dep[ stjump[a][p] ] >= dep[b]) a = stjump[a][p];
+//        if (dep[ stjump[a][p] ] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
 //    }
 //    if (a == b) {
 //        return a;
@@ -136,7 +138,7 @@
 //            addEdgeV(stk[top - 1], stk[top]);
 //            top--;
 //        }
-//        if (lca != stk[top]) {
+//        if (dfn[stk[top]] > dfn[lca]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top]);
 //            stk[top] = lca;
diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index ecc2c00a4..cdf4de14e 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -185,7 +185,7 @@ public static int buildVirtualTree2() {
 				addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
 				top--;
 			}
-			if (lca != stk[top]) {
+			if (dfn[stk[top]] > dfn[lca]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top], getDist(lca, stk[top]));
 				stk[top] = lca;
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index 5f337d515..ce3e9d9da 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -164,7 +164,7 @@
 //            addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
 //            top--;
 //        }
-//        if (lca != stk[top]) {
+//        if (dfn[stk[top]] > dfn[lca]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top], getDist(lca, stk[top]));
 //            stk[top] = lca;

From 6b5e91c67a5e4af157bc66b9234d538917308665 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 15:15:14 +0800
Subject: [PATCH 1538/1712] modify code

---
 src/class180/Code01_KingdomAndCities1.java | 18 ++++++++++++++++++
 1 file changed, 18 insertions(+)

diff --git a/src/class180/Code01_KingdomAndCities1.java b/src/class180/Code01_KingdomAndCities1.java
index 139c25a78..5e2366edc 100644
--- a/src/class180/Code01_KingdomAndCities1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -24,22 +24,27 @@ public class Code01_KingdomAndCities1 {
 	public static int MAXP = 20;
 	public static int n, q, k;
 
+	// 原始树
 	public static int[] headg = new int[MAXN];
 	public static int[] nextg = new int[MAXN << 1];
 	public static int[] tog = new int[MAXN << 1];
 	public static int cntg;
 
+	// 虚树
 	public static int[] headv = new int[MAXN];
 	public static int[] nextv = new int[MAXN];
 	public static int[] tov = new int[MAXN];
 	public static int cntv;
 
+	// 树上倍增求LCA + 生成dfn序
 	public static int[] dep = new int[MAXN];
 	public static int[] dfn = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
 	public static int cntd;
 
+	// 关键点数组
 	public static int[] arr = new int[MAXN];
+	// 标记节点是否是关键点
 	public static boolean[] isKey = new boolean[MAXN];
 
 	// 第一种建树方式
@@ -47,15 +52,20 @@ public class Code01_KingdomAndCities1 {
 	// 第二种建树方式
 	public static int[] stk = new int[MAXN];
 
+	// 动态规划相关
+	// siz[u]，表示还有几个关键点与u相连
+	// cost[u]，表示节点u的子树中，做到关键点之间不连通，至少需要攻占几个点
 	public static int[] siz = new int[MAXN];
 	public static int[] cost = new int[MAXN];
 
+	// 原始树连边
 	public static void addEdgeG(int u, int v) {
 		nextg[++cntg] = headg[u];
 		tog[cntg] = v;
 		headg[u] = cntg;
 	}
 
+	// 虚树连边
 	public static void addEdgeV(int u, int v) {
 		nextv[++cntv] = headv[u];
 		tov[cntv] = v;
@@ -79,6 +89,7 @@ public static void sortByDfn(int[] nums, int l, int r) {
 		sortByDfn(nums, i, r);
 	}
 
+	// 树上倍增的dfs过程
 	public static void dfs(int u, int fa) {
 		dep[u] = dep[fa] + 1;
 		dfn[u] = ++cntd;
@@ -93,6 +104,7 @@ public static void dfs(int u, int fa) {
 		}
 	}
 
+	// 返回a和b的最低公共祖先
 	public static int getLca(int a, int b) {
 		if (dep[a] < dep[b]) {
 			int tmp = a; a = b; b = tmp;
@@ -170,6 +182,7 @@ public static int buildVirtualTree2() {
 		return stk[1];
 	}
 
+	// 树型dp的过程
 	public static void dp(int u) {
 		cost[u] = siz[u] = 0;
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
@@ -188,11 +201,15 @@ public static void dp(int u) {
 	}
 
 	public static int compute() {
+		// 节点标记关键点信息
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = true;
 		}
 		boolean check = true;
 		for (int i = 1; i <= k; i++) {
+			// 只能通过攻占非关键点的方式，来隔开关键点
+			// 所以如果 a 和 a的父节点 都是关键点，这是怎么也隔不开的
+			// 直接返回-1即可
 			if (isKey[stjump[arr[i]][0]]) {
 				check = false;
 				break;
@@ -205,6 +222,7 @@ public static int compute() {
 			dp(tree);
 			ans = cost[tree];
 		}
+		// 节点撤销关键点信息
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
 		}

From 25dfd6c62b9081cf68ad13b1531cf5f03f84b99e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 15:30:37 +0800
Subject: [PATCH 1539/1712] modify code

---
 src/class180/Code01_KingdomAndCities1.java | 2 +-
 src/class180/Code01_KingdomAndCities2.java | 2 +-
 src/class180/Code02_BigProject1.java       | 2 +-
 src/class180/Code02_BigProject2.java       | 2 +-
 src/class180/Code03_War1.java              | 2 +-
 src/class180/Code03_War2.java              | 2 +-
 6 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class180/Code01_KingdomAndCities1.java b/src/class180/Code01_KingdomAndCities1.java
index 5e2366edc..d0acdce75 100644
--- a/src/class180/Code01_KingdomAndCities1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -167,7 +167,7 @@ public static int buildVirtualTree2() {
 				addEdgeV(stk[top - 1], stk[top]);
 				top--;
 			}
-			if (dfn[stk[top]] > dfn[lca]) {
+			if (lca != stk[top]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top]);
 				stk[top] = lca;
diff --git a/src/class180/Code01_KingdomAndCities2.java b/src/class180/Code01_KingdomAndCities2.java
index 93442566d..94aca1b51 100644
--- a/src/class180/Code01_KingdomAndCities2.java
+++ b/src/class180/Code01_KingdomAndCities2.java
@@ -134,7 +134,7 @@
 //            addEdgeV(stk[top - 1], stk[top]);
 //            top--;
 //        }
-//        if (dfn[stk[top]] > dfn[lca]) {
+//        if (lca != stk[top]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top]);
 //            stk[top] = lca;
diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index ce13b48d4..da83af8b3 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -204,7 +204,7 @@ public static int buildVirtualTree2() {
 				addEdgeV(stk[top - 1], stk[top]);
 				top--;
 			}
-			if (dfn[stk[top]] > dfn[lca]) {
+			if (lca != stk[top]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top]);
 				stk[top] = lca;
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index 28c08a866..a35238356 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -138,7 +138,7 @@
 //            addEdgeV(stk[top - 1], stk[top]);
 //            top--;
 //        }
-//        if (dfn[stk[top]] > dfn[lca]) {
+//        if (lca != stk[top]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top]);
 //            stk[top] = lca;
diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index cdf4de14e..ecc2c00a4 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -185,7 +185,7 @@ public static int buildVirtualTree2() {
 				addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
 				top--;
 			}
-			if (dfn[stk[top]] > dfn[lca]) {
+			if (lca != stk[top]) {
 				headv[lca] = 0;
 				addEdgeV(lca, stk[top], getDist(lca, stk[top]));
 				stk[top] = lca;
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index ce3e9d9da..5f337d515 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -164,7 +164,7 @@
 //            addEdgeV(stk[top - 1], stk[top], getDist(stk[top - 1], stk[top]));
 //            top--;
 //        }
-//        if (dfn[stk[top]] > dfn[lca]) {
+//        if (lca != stk[top]) {
 //            headv[lca] = 0;
 //            addEdgeV(lca, stk[top], getDist(lca, stk[top]));
 //            stk[top] = lca;

From 8721c91216bd115ab9883b29a01ffbb3f7143cd2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 16:09:25 +0800
Subject: [PATCH 1540/1712] modify code

---
 src/class180/Code01_KingdomAndCities1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class180/Code01_KingdomAndCities1.java b/src/class180/Code01_KingdomAndCities1.java
index d0acdce75..240bb55db 100644
--- a/src/class180/Code01_KingdomAndCities1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -53,7 +53,7 @@ public class Code01_KingdomAndCities1 {
 	public static int[] stk = new int[MAXN];
 
 	// 动态规划相关
-	// siz[u]，表示还有几个关键点与u相连
+	// siz[u]，表示节点u的子树中，有几个重要点和u相连
 	// cost[u]，表示节点u的子树中，做到关键点之间不连通，至少需要攻占几个点
 	public static int[] siz = new int[MAXN];
 	public static int[] cost = new int[MAXN];

From 202af1666d4532f9e5c7aeeeb11e6cfbf216edca Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 16:15:22 +0800
Subject: [PATCH 1541/1712] modify code

---
 src/class180/Code01_KingdomAndCities1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class180/Code01_KingdomAndCities1.java b/src/class180/Code01_KingdomAndCities1.java
index 240bb55db..a851114fd 100644
--- a/src/class180/Code01_KingdomAndCities1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -53,7 +53,7 @@ public class Code01_KingdomAndCities1 {
 	public static int[] stk = new int[MAXN];
 
 	// 动态规划相关
-	// siz[u]，表示节点u的子树中，有几个重要点和u相连
+	// siz[u]，表示节点u的子树中，还有几个重要点和u相连
 	// cost[u]，表示节点u的子树中，做到关键点之间不连通，至少需要攻占几个点
 	public static int[] siz = new int[MAXN];
 	public static int[] cost = new int[MAXN];

From 1cba939c6a0bb1f01ae4f73160cc6f6d2b854fa2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 17:09:50 +0800
Subject: [PATCH 1542/1712] modify code

---
 src/class180/Code01_KingdomAndCities1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class180/Code01_KingdomAndCities1.java b/src/class180/Code01_KingdomAndCities1.java
index a851114fd..bd79ebc37 100644
--- a/src/class180/Code01_KingdomAndCities1.java
+++ b/src/class180/Code01_KingdomAndCities1.java
@@ -53,8 +53,8 @@ public class Code01_KingdomAndCities1 {
 	public static int[] stk = new int[MAXN];
 
 	// 动态规划相关
-	// siz[u]，表示节点u的子树中，还有几个重要点和u相连
-	// cost[u]，表示节点u的子树中，做到关键点之间不连通，至少需要攻占几个点
+	// siz[u]，还有几个重要点没和u断开，值为0或者1
+	// cost[u]，表示节点u的子树中，做到不违规，至少需要攻占几个非重要点
 	public static int[] siz = new int[MAXN];
 	public static int[] cost = new int[MAXN];
 

From 4ca85b553d581c3ded72a4909b6da3fd1aa2c613 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 17:57:15 +0800
Subject: [PATCH 1543/1712] modify code

---
 src/class180/Code02_BigProject1.java | 38 ++++++++++++++++------------
 src/class180/Code02_BigProject2.java | 18 ++++++-------
 2 files changed, 31 insertions(+), 25 deletions(-)

diff --git a/src/class180/Code02_BigProject1.java b/src/class180/Code02_BigProject1.java
index da83af8b3..50c937ed6 100644
--- a/src/class180/Code02_BigProject1.java
+++ b/src/class180/Code02_BigProject1.java
@@ -45,10 +45,16 @@ public class Code02_BigProject1 {
 	public static int[] tmp = new int[MAXN << 1];
 	public static int[] stk = new int[MAXN];
 
+	// siz[u]表示子树u上，关键点的数量
+	// sum[u]表示子树u上，所有关键点到u的总距离
+	// near[u]表示子树u上，到u最近关键点的距离
+	// far[u]表示子树u上，到u最远关键点的距离
 	public static int[] siz = new int[MAXN];
 	public static long[] sum = new long[MAXN];
-	public static long[] minv = new long[MAXN];
-	public static long[] maxv = new long[MAXN];
+	public static long[] near = new long[MAXN];
+	public static long[] far = new long[MAXN];
+
+	// 新通道的代价和、新通道中代价最小的值、新通道中代价最大的值
 	public static long costSum, costMin, costMax;
 
 	// dfs过程和dp过程，C++同学可以使用递归版
@@ -224,10 +230,10 @@ public static void dp1(int u) {
 		siz[u] = isKey[u] ? 1 : 0;
 		sum[u] = 0;
 		if (isKey[u]) {
-			maxv[u] = minv[u] = 0;
+			far[u] = near[u] = 0;
 		} else {
-			minv[u] = INF;
-			maxv[u] = -INF;
+			near[u] = INF;
+			far[u] = -INF;
 		}
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			dp1(tov[e]);
@@ -238,10 +244,10 @@ public static void dp1(int u) {
 			costSum += (sum[u] + 1L * siz[u] * len) * siz[v] + sum[v] * siz[u];
 			siz[u] += siz[v];
 			sum[u] += sum[v] + len * siz[v];
-			costMin = Math.min(costMin, minv[u] + minv[v] + len);
-			costMax = Math.max(costMax, maxv[u] + maxv[v] + len);
-			minv[u] = Math.min(minv[u], minv[v] + len);
-			maxv[u] = Math.max(maxv[u], maxv[v] + len);
+			costMin = Math.min(costMin, near[u] + near[v] + len);
+			costMax = Math.max(costMax, far[u] + far[v] + len);
+			near[u] = Math.min(near[u], near[v] + len);
+			far[u] = Math.max(far[u], far[v] + len);
 		}
 	}
 
@@ -255,10 +261,10 @@ public static void dp2(int tree) {
 				siz[u] = isKey[u] ? 1 : 0;
 				sum[u] = 0;
 				if (isKey[u]) {
-					maxv[u] = minv[u] = 0;
+					far[u] = near[u] = 0;
 				} else {
-					minv[u] = INF;
-					maxv[u] = -INF;
+					near[u] = INF;
+					far[u] = -INF;
 				}
 				e = headv[u];
 			} else {
@@ -274,10 +280,10 @@ public static void dp2(int tree) {
 					costSum += (sum[u] + 1L * siz[u] * len) * siz[v] + sum[v] * siz[u];
 					siz[u] += siz[v];
 					sum[u] += sum[v] + len * siz[v];
-					costMin = Math.min(costMin, minv[u] + minv[v] + len);
-					costMax = Math.max(costMax, maxv[u] + maxv[v] + len);
-					minv[u] = Math.min(minv[u], minv[v] + len);
-					maxv[u] = Math.max(maxv[u], maxv[v] + len);
+					costMin = Math.min(costMin, near[u] + near[v] + len);
+					costMax = Math.max(costMax, far[u] + far[v] + len);
+					near[u] = Math.min(near[u], near[v] + len);
+					far[u] = Math.max(far[u], far[v] + len);
 				}
 			}
 		}
diff --git a/src/class180/Code02_BigProject2.java b/src/class180/Code02_BigProject2.java
index a35238356..9c1a581db 100644
--- a/src/class180/Code02_BigProject2.java
+++ b/src/class180/Code02_BigProject2.java
@@ -45,8 +45,8 @@
 //
 //int siz[MAXN];
 //long long sum[MAXN];
-//long long minv[MAXN];
-//long long maxv[MAXN];
+//long long near[MAXN];
+//long long far[MAXN];
 //long long costSum, costMin, costMax;
 //
 //bool cmp(int x, int y) {
@@ -157,10 +157,10 @@
 //    siz[u] = isKey[u] ? 1 : 0;
 //    sum[u] = 0;
 //    if (isKey[u]) {
-//        minv[u] = maxv[u] = 0;
+//        near[u] = far[u] = 0;
 //    } else {
-//        minv[u] = INF;
-//        maxv[u] = -INF;
+//        near[u] = INF;
+//        far[u] = -INF;
 //    }
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        dp(tov[e]);
@@ -171,10 +171,10 @@
 //        costSum += (sum[u] + 1LL * siz[u] * len) * siz[v] + sum[v] * siz[u];
 //        siz[u] += siz[v];
 //        sum[u] += sum[v] + len * siz[v];
-//        costMin = min(costMin, minv[u] + minv[v] + len);
-//        costMax = max(costMax, maxv[u] + maxv[v] + len);
-//        minv[u] = min(minv[u], minv[v] + len);
-//        maxv[u] = max(maxv[u], maxv[v] + len);
+//        costMin = min(costMin, near[u] + near[v] + len);
+//        costMax = max(costMax, far[u] + far[v] + len);
+//        near[u] = min(near[u], near[v] + len);
+//        far[u] = max(far[u], far[v] + len);
 //    }
 //}
 //

From e8e0b4fd6f8e18a79820734f29b652b7d419b792 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 14 Oct 2025 20:27:42 +0800
Subject: [PATCH 1544/1712] modify code

---
 src/class180/Code03_War1.java | 22 +++++-----------------
 src/class180/Code03_War2.java | 21 ++++-----------------
 2 files changed, 9 insertions(+), 34 deletions(-)

diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index ecc2c00a4..625e91070 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -114,25 +114,13 @@ public static int getLca(int a, int b) {
 		return stjump[a][0];
 	}
 
-	public static int getDist(int a, int b) {
+	// 已知u一定是v的祖先节点，返回u到v路径上的最小边权
+	public static int getDist(int u, int v) {
 		int dist = 100000001;
-		if (dep[a] < dep[b]) {
-			int tmp = a; a = b; b = tmp;
-		}
 		for (int p = MAXP - 1; p >= 0; p--) {
-			if (dep[stjump[a][p]] >= dep[b]) {
-				dist = Math.min(dist, mindist[a][p]);
-				a = stjump[a][p];
-			}
-		}
-		if (a == b) {
-			return dist;
-		}
-		for (int p = MAXP - 1; p >= 0; p--) {
-			if (stjump[a][p] != stjump[b][p]) {
-				dist = Math.min(dist, Math.min(mindist[a][p], mindist[b][p]));
-				a = stjump[a][p];
-				b = stjump[b][p];
+			if (dep[stjump[v][p]] >= dep[u]) {
+				dist = Math.min(dist, mindist[v][p]);
+				v = stjump[v][p];
 			}
 		}
 		return dist;
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index 5f337d515..b6cb42444 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -99,25 +99,12 @@
 //    return stjump[a][0];
 //}
 //
-//int getDist(int a, int b) {
+//int getDist(int u, int v) {
 //    int dist = 100000001;
-//    if (dep[a] < dep[b]) {
-//        swap(a, b);
-//    }
 //    for (int p = MAXP - 1; p >= 0; p--) {
-//        if (dep[stjump[a][p]] >= dep[b]) {
-//            dist = min(dist, mindist[a][p]);
-//            a = stjump[a][p];
-//        }
-//    }
-//    if (a == b) {
-//        return dist;
-//    }
-//    for (int p = MAXP - 1; p >= 0; p--) {
-//        if (stjump[a][p] != stjump[b][p]) {
-//            dist = min(dist, min(mindist[a][p], mindist[b][p]));
-//            a = stjump[a][p];
-//            b = stjump[b][p];
+//        if (dep[stjump[v][p]] >= dep[u]) {
+//            dist = min(dist, mindist[v][p]);
+//            v = stjump[v][p];
 //        }
 //    }
 //    return dist;

From 4d99c9db9e152b1f45d8505e9f4d6c21ca06469f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 10:56:23 +0800
Subject: [PATCH 1545/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 24 ++++++++++++++++++++++--
 src/class180/Code04_WorldTree2.java |  7 +++++--
 2 files changed, 27 insertions(+), 4 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index ade402f15..b1cc32dd0 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -38,6 +38,7 @@ public class Code04_WorldTree1 {
 	public static int cntv;
 
 	public static int[] dep = new int[MAXN];
+	// 注意siz[u]表示在原树里，子树u有几个节点
 	public static int[] siz = new int[MAXN];
 	public static int[] dfn = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
@@ -48,8 +49,11 @@ public class Code04_WorldTree1 {
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
 
+	// mindist[u]表示u节点到管理点的最短距离
 	public static int[] mindist = new int[MAXN];
+	// mindist[u]表示u节点的最近管理点
 	public static int[] pick = new int[MAXN];
+	// ans[i]表示i这个管理点，管理了几个点
 	public static int[] ans = new int[MAXN];
 
 	public static void addEdgeG(int u, int v) {
@@ -146,6 +150,8 @@ public static int buildVirtualTree() {
 		return tmp[1];
 	}
 
+	// 从下往上更新最近管理点
+	// 节点u根据孩子的管理点，找到离u最近的管理点
 	public static void dp1(int u) {
 		mindist[u] = INF;
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
@@ -165,6 +171,8 @@ public static void dp1(int u) {
 		}
 	}
 
+	// 从上往下更新最近管理点
+	// 根据u找到的最近管理点，更新每个孩子节点v的最近管理点
 	public static void dp2(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
@@ -179,7 +187,13 @@ public static void dp2(int u) {
 		}
 	}
 
-	public static void calc(int u, int v) {
+	// 已知u一定是v的祖先节点，u到v之间的大量节点没有被纳入到虚树
+	// 这部分节点之前都分配给了pick[u]，现在根据最近距离做重新分配
+	// 可能有若干节点会重新分配给pick[v]，修正相关的计数
+	public static void amend(int u, int v) {
+		if (pick[u] == pick[v]) {
+			return;
+		}
 		int x = v;
 		for (int p = MAXP - 1; p >= 0; p--) {
 			int tou = dep[stjump[x][p]] - dep[u] + mindist[u];
@@ -193,12 +207,18 @@ public static void calc(int u, int v) {
 		ans[pick[v]] += delta;
 	}
 
+	// 每个点都有了最近的管理点，更新相关的管理点的计数
 	public static void dp3(int u) {
+		// 管理u的关键节点，先获得原树里子树u的所有节点
+		// 然后经历修正的过程，把管理节点的数量更新正确
 		ans[pick[u]] += siz[u];
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
-			calc(u, v);
+			// 修正的过程
+			amend(u, v);
+			// 马上去往v执行dp3的过程，所以子树v的节点现在扣除
 			ans[pick[u]] -= siz[v];
+			// 子树v怎么分配节点，那是后续dp3(v)的事情
 			dp3(v);
 		}
 	}
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 7b14ff653..10d7041e8 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -159,7 +159,10 @@
 //    }
 //}
 //
-//void calc(int u, int v) {
+//void amend(int u, int v) {
+//    if (pick[u] == pick[v]) {
+//        return;
+//    }
 //    int x = v;
 //    for (int p = MAXP - 1; p >= 0; p--) {
 //        int tou = (dep[stjump[x][p]] - dep[u]) + mindist[u];
@@ -177,7 +180,7 @@
 //    ans[pick[u]] += siz[u];
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
-//        calc(u, v);
+//        amend(u, v);
 //        ans[pick[u]] -= siz[v];
 //        dp3(v);
 //    }

From 5ea40105ba524188096a3746721aaf6df62c456e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 11:02:37 +0800
Subject: [PATCH 1546/1712] modify code

---
 src/class180/Code03_War1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index 625e91070..8651b0a18 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -45,6 +45,7 @@ public class Code03_War1 {
 	public static int[] tmp = new int[MAXN << 1];
 	public static int[] stk = new int[MAXN];
 
+	// cut[u]表示子树u上的所有关键节点，都连不上u的话，需要切除边的最小代价
 	public static long[] cut = new long[MAXN];
 
 	public static void addEdgeG(int u, int v, int w) {

From 07cbaa3fe476d7ea213049789c8a24d7ebe6d442 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 11:04:21 +0800
Subject: [PATCH 1547/1712] modify code

---
 src/class180/Code03_War1.java | 1 +
 1 file changed, 1 insertion(+)

diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index 8651b0a18..e0174f907 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -37,6 +37,7 @@ public class Code03_War1 {
 	public static int[] dep = new int[MAXN];
 	public static int[] dfn = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
+	// 上方最小距离的倍增表
 	public static int[][] mindist = new int[MAXN][MAXP];
 	public static int cntd;
 

From 5f5ffa500ae5c1870752a3bdc189f5b205cffb27 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 11:32:14 +0800
Subject: [PATCH 1548/1712] modify code

---
 src/class180/Code03_War1.java | 12 ++++++------
 src/class180/Code03_War2.java | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/class180/Code03_War1.java b/src/class180/Code03_War1.java
index e0174f907..199f7f24b 100644
--- a/src/class180/Code03_War1.java
+++ b/src/class180/Code03_War1.java
@@ -46,8 +46,8 @@ public class Code03_War1 {
 	public static int[] tmp = new int[MAXN << 1];
 	public static int[] stk = new int[MAXN];
 
-	// cut[u]表示子树u上的所有关键节点，都连不上u的话，需要切除边的最小代价
-	public static long[] cut = new long[MAXN];
+	// cost[u]表示虚树中，u下方的所有关键节点，都连不上u的话，最小总代价
+	public static long[] cost = new long[MAXN];
 
 	public static void addEdgeG(int u, int v, int w) {
 		nextg[++cntg] = headg[u];
@@ -194,14 +194,14 @@ public static void dp(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			dp(tov[e]);
 		}
-		cut[u] = 0;
+		cost[u] = 0;
 		for (int e = headv[u], v, w; e > 0; e = nextv[e]) {
 			v = tov[e];
 			w = weightv[e];
 			if (isKey[v]) {
-				cut[u] += w;
+				cost[u] += w;
 			} else {
-				cut[u] += Math.min(cut[v], w);
+				cost[u] += Math.min(cost[v], w);
 			}
 		}
 	}
@@ -216,7 +216,7 @@ public static long compute() {
 		for (int i = 1; i <= k; i++) {
 			isKey[arr[i]] = false;
 		}
-		return cut[tree];
+		return cost[tree];
 	}
 
 	public static void main(String[] args) throws Exception {
diff --git a/src/class180/Code03_War2.java b/src/class180/Code03_War2.java
index b6cb42444..ada035e28 100644
--- a/src/class180/Code03_War2.java
+++ b/src/class180/Code03_War2.java
@@ -43,7 +43,7 @@
 //int tmp[MAXN << 1];
 //int stk[MAXN];
 //
-//long long cut[MAXN];
+//long long cost[MAXN];
 //
 //bool cmp(int x, int y) {
 //    return dfn[x] < dfn[y];
@@ -170,14 +170,14 @@
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        dp(tov[e]);
 //    }
-//    cut[u] = 0;
+//    cost[u] = 0;
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        int w = weightv[e];
 //        if (isKey[v]) {
-//            cut[u] += w;
+//            cost[u] += w;
 //        } else {
-//            cut[u] += min(cut[v], (long long)w);
+//            cost[u] += min(cost[v], (long long)w);
 //        }
 //    }
 //}
@@ -192,7 +192,7 @@
 //    for (int i = 1; i <= k; i++) {
 //        isKey[arr[i]] = false;
 //    }
-//    return cut[tree];
+//    return cost[tree];
 //}
 //
 //int main() {

From 09fdface1cfcde4380ebf1a7a511bb80d04d231e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 12:24:56 +0800
Subject: [PATCH 1549/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 54 ++++++++++++++---------------
 src/class180/Code04_WorldTree2.java | 46 ++++++++++++------------
 2 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index b1cc32dd0..8ae845a14 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -49,10 +49,10 @@ public class Code04_WorldTree1 {
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
 
-	// mindist[u]表示u节点到管理点的最短距离
-	public static int[] mindist = new int[MAXN];
-	// mindist[u]表示u节点的最近管理点
-	public static int[] pick = new int[MAXN];
+	// near[u]表示u节点的最近管理点
+	public static int[] near = new int[MAXN];
+	// dist[u]表示u节点到最近管理点的距离
+	public static int[] dist = new int[MAXN];
 	// ans[i]表示i这个管理点，管理了几个点
 	public static int[] ans = new int[MAXN];
 
@@ -153,21 +153,21 @@ public static int buildVirtualTree() {
 	// 从下往上更新最近管理点
 	// 节点u根据孩子的管理点，找到离u最近的管理点
 	public static void dp1(int u) {
-		mindist[u] = INF;
+		dist[u] = INF;
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			dp1(v);
 			int dis = dep[v] - dep[u];
-			if (mindist[u] > mindist[v] + dis) {
-				mindist[u] = mindist[v] + dis;
-				pick[u] = pick[v];
-			} else if (mindist[u] == mindist[v] + dis) {
-				pick[u] = Math.min(pick[u], pick[v]);
+			if (dist[u] > dist[v] + dis) {
+				dist[u] = dist[v] + dis;
+				near[u] = near[v];
+			} else if (dist[u] == dist[v] + dis) {
+				near[u] = Math.min(near[u], near[v]);
 			}
 		}
 		if (isKey[u]) {
-			mindist[u] = 0;
-			pick[u] = u;
+			dist[u] = 0;
+			near[u] = u;
 		}
 	}
 
@@ -177,47 +177,47 @@ public static void dp2(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			int dis = dep[v] - dep[u];
-			if (mindist[v] > mindist[u] + dis) {
-				mindist[v] = mindist[u] + dis;
-				pick[v] = pick[u];
-			} else if (mindist[v] == mindist[u] + dis) {
-				pick[v] = Math.min(pick[v], pick[u]);
+			if (dist[v] > dist[u] + dis) {
+				dist[v] = dist[u] + dis;
+				near[v] = near[u];
+			} else if (dist[v] == dist[u] + dis) {
+				near[v] = Math.min(near[v], near[u]);
 			}
 			dp2(v);
 		}
 	}
 
 	// 已知u一定是v的祖先节点，u到v之间的大量节点没有被纳入到虚树
-	// 这部分节点之前都分配给了pick[u]，现在根据最近距离做重新分配
-	// 可能有若干节点会重新分配给pick[v]，修正相关的计数
+	// 这部分节点之前都分配给了near[u]，现在根据最近距离做重新分配
+	// 可能若干节点会重新分配给near[v]，修正相关的计数
 	public static void amend(int u, int v) {
-		if (pick[u] == pick[v]) {
+		if (near[u] == near[v]) {
 			return;
 		}
 		int x = v;
 		for (int p = MAXP - 1; p >= 0; p--) {
-			int tou = dep[stjump[x][p]] - dep[u] + mindist[u];
-			int tov = dep[v] - dep[stjump[x][p]] + mindist[v];
-			if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && pick[v] < pick[u]))) {
+			int tou = dep[stjump[x][p]] - dep[u] + dist[u];
+			int tov = dep[v] - dep[stjump[x][p]] + dist[v];
+			if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && near[v] < near[u]))) {
 				x = stjump[x][p];
 			}
 		}
 		int delta = siz[x] - siz[v];
-		ans[pick[u]] -= delta;
-		ans[pick[v]] += delta;
+		ans[near[u]] -= delta;
+		ans[near[v]] += delta;
 	}
 
 	// 每个点都有了最近的管理点，更新相关的管理点的计数
 	public static void dp3(int u) {
 		// 管理u的关键节点，先获得原树里子树u的所有节点
 		// 然后经历修正的过程，把管理节点的数量更新正确
-		ans[pick[u]] += siz[u];
+		ans[near[u]] += siz[u];
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			// 修正的过程
 			amend(u, v);
 			// 马上去往v执行dp3的过程，所以子树v的节点现在扣除
-			ans[pick[u]] -= siz[v];
+			ans[near[u]] -= siz[v];
 			// 子树v怎么分配节点，那是后续dp3(v)的事情
 			dp3(v);
 		}
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 10d7041e8..2b1de7b10 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -42,8 +42,8 @@
 //bool isKey[MAXN];
 //int tmp[MAXN << 1];
 //
-//int mindist[MAXN];
-//int pick[MAXN];
+//int near[MAXN];
+//int dist[MAXN];
 //int ans[MAXN];
 //
 //bool cmp(int x, int y) {
@@ -127,21 +127,21 @@
 //}
 //
 //void dp1(int u) {
-//    mindist[u] = INF;
+//    dist[u] = INF;
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        dp1(v);
 //        int dis = dep[v] - dep[u];
-//        if (mindist[u] > mindist[v] + dis) {
-//            mindist[u] = mindist[v] + dis;
-//            pick[u] = pick[v];
-//        } else if (mindist[u] == mindist[v] + dis) {
-//            pick[u] = min(pick[u], pick[v]);
+//        if (dist[u] > dist[v] + dis) {
+//            dist[u] = dist[v] + dis;
+//            near[u] = near[v];
+//        } else if (dist[u] == dist[v] + dis) {
+//            near[u] = min(near[u], near[v]);
 //        }
 //    }
 //    if (isKey[u]) {
-//        mindist[u] = 0;
-//        pick[u] = u;
+//        dist[u] = 0;
+//        near[u] = u;
 //    }
 //}
 //
@@ -149,39 +149,39 @@
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        int dis = dep[v] - dep[u];
-//        if (mindist[v] > mindist[u] + dis) {
-//            mindist[v] = mindist[u] + dis;
-//            pick[v] = pick[u];
-//        } else if (mindist[v] == mindist[u] + dis) {
-//            pick[v] = min(pick[v], pick[u]);
+//        if (dist[v] > dist[u] + dis) {
+//            dist[v] = dist[u] + dis;
+//            near[v] = near[u];
+//        } else if (dist[v] == dist[u] + dis) {
+//            near[v] = min(near[v], near[u]);
 //        }
 //        dp2(v);
 //    }
 //}
 //
 //void amend(int u, int v) {
-//    if (pick[u] == pick[v]) {
+//    if (near[u] == near[v]) {
 //        return;
 //    }
 //    int x = v;
 //    for (int p = MAXP - 1; p >= 0; p--) {
-//        int tou = (dep[stjump[x][p]] - dep[u]) + mindist[u];
-//        int tov = (dep[v] - dep[stjump[x][p]]) + mindist[v];
-//        if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && pick[v] < pick[u]))) {
+//        int tou = (dep[stjump[x][p]] - dep[u]) + dist[u];
+//        int tov = (dep[v] - dep[stjump[x][p]]) + dist[v];
+//        if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && near[v] < near[u]))) {
 //            x = stjump[x][p];
 //        }
 //    }
 //    int delta = siz[x] - siz[v];
-//    ans[pick[u]] -= delta;
-//    ans[pick[v]] += delta;
+//    ans[near[u]] -= delta;
+//    ans[near[v]] += delta;
 //}
 //
 //void dp3(int u) {
-//    ans[pick[u]] += siz[u];
+//    ans[near[u]] += siz[u];
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        amend(u, v);
-//        ans[pick[u]] -= siz[v];
+//        ans[near[u]] -= siz[v];
 //        dp3(v);
 //    }
 //}

From 87b81ad46f557f4db3fb545c0c3434b42b89a33f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 12:34:39 +0800
Subject: [PATCH 1550/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 6 ++----
 1 file changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index 8ae845a14..de6938e40 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -150,8 +150,7 @@ public static int buildVirtualTree() {
 		return tmp[1];
 	}
 
-	// 从下往上更新最近管理点
-	// 节点u根据孩子的管理点，找到离u最近的管理点
+	// 下方找最近管理点，节点u根据孩子的管理点，找到离u最近的管理点
 	public static void dp1(int u) {
 		dist[u] = INF;
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
@@ -171,8 +170,7 @@ public static void dp1(int u) {
 		}
 	}
 
-	// 从上往下更新最近管理点
-	// 根据u找到的最近管理点，更新每个孩子节点v的最近管理点
+	// 上方找最近管理点，根据u找到的最近管理点，更新每个孩子节点v的最近管理点
 	public static void dp2(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];

From f7dddd58b2a9ac590812db61086318cdd349280c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 12:37:07 +0800
Subject: [PATCH 1551/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index de6938e40..a30044572 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -49,7 +49,7 @@ public class Code04_WorldTree1 {
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
 
-	// near[u]表示u节点的最近管理点
+	// near[u]表示u节点找到的最近管理点
 	public static int[] near = new int[MAXN];
 	// dist[u]表示u节点到最近管理点的距离
 	public static int[] dist = new int[MAXN];
@@ -207,7 +207,7 @@ public static void amend(int u, int v) {
 
 	// 每个点都有了最近的管理点，更新相关的管理点的计数
 	public static void dp3(int u) {
-		// 管理u的关键节点，先获得原树里子树u的所有节点
+		// u的管理节点，先获得原树里子树u的所有节点
 		// 然后经历修正的过程，把管理节点的数量更新正确
 		ans[near[u]] += siz[u];
 		for (int e = headv[u]; e > 0; e = nextv[e]) {

From 98c031af29d9d4c6d7ed1b946a8b3ef515d85afe Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 12:45:22 +0800
Subject: [PATCH 1552/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 46 ++++++++++++++---------------
 src/class180/Code04_WorldTree2.java | 40 ++++++++++++-------------
 2 files changed, 43 insertions(+), 43 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index a30044572..ae1e08f78 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -49,8 +49,8 @@ public class Code04_WorldTree1 {
 	public static boolean[] isKey = new boolean[MAXN];
 	public static int[] tmp = new int[MAXN << 1];
 
-	// near[u]表示u节点找到的最近管理点
-	public static int[] near = new int[MAXN];
+	// manager[u]表示u节点找到的最近管理点
+	public static int[] manager = new int[MAXN];
 	// dist[u]表示u节点到最近管理点的距离
 	public static int[] dist = new int[MAXN];
 	// ans[i]表示i这个管理点，管理了几个点
@@ -156,17 +156,17 @@ public static void dp1(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			dp1(v);
-			int dis = dep[v] - dep[u];
-			if (dist[u] > dist[v] + dis) {
-				dist[u] = dist[v] + dis;
-				near[u] = near[v];
-			} else if (dist[u] == dist[v] + dis) {
-				near[u] = Math.min(near[u], near[v]);
+			int w = dep[v] - dep[u];
+			if (dist[u] > dist[v] + w) {
+				dist[u] = dist[v] + w;
+				manager[u] = manager[v];
+			} else if (dist[u] == dist[v] + w) {
+				manager[u] = Math.min(manager[u], manager[v]);
 			}
 		}
 		if (isKey[u]) {
 			dist[u] = 0;
-			near[u] = u;
+			manager[u] = u;
 		}
 	}
 
@@ -174,48 +174,48 @@ public static void dp1(int u) {
 	public static void dp2(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
-			int dis = dep[v] - dep[u];
-			if (dist[v] > dist[u] + dis) {
-				dist[v] = dist[u] + dis;
-				near[v] = near[u];
-			} else if (dist[v] == dist[u] + dis) {
-				near[v] = Math.min(near[v], near[u]);
+			int w = dep[v] - dep[u];
+			if (dist[v] > dist[u] + w) {
+				dist[v] = dist[u] + w;
+				manager[v] = manager[u];
+			} else if (dist[v] == dist[u] + w) {
+				manager[v] = Math.min(manager[v], manager[u]);
 			}
 			dp2(v);
 		}
 	}
 
 	// 已知u一定是v的祖先节点，u到v之间的大量节点没有被纳入到虚树
-	// 这部分节点之前都分配给了near[u]，现在根据最近距离做重新分配
-	// 可能若干节点会重新分配给near[v]，修正相关的计数
+	// 这部分节点之前都分配给了manager[u]，现在根据最近距离做重新分配
+	// 可能若干节点会重新分配给manager[v]，修正相关的计数
 	public static void amend(int u, int v) {
-		if (near[u] == near[v]) {
+		if (manager[u] == manager[v]) {
 			return;
 		}
 		int x = v;
 		for (int p = MAXP - 1; p >= 0; p--) {
 			int tou = dep[stjump[x][p]] - dep[u] + dist[u];
 			int tov = dep[v] - dep[stjump[x][p]] + dist[v];
-			if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && near[v] < near[u]))) {
+			if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && manager[v] < manager[u]))) {
 				x = stjump[x][p];
 			}
 		}
 		int delta = siz[x] - siz[v];
-		ans[near[u]] -= delta;
-		ans[near[v]] += delta;
+		ans[manager[u]] -= delta;
+		ans[manager[v]] += delta;
 	}
 
 	// 每个点都有了最近的管理点，更新相关的管理点的计数
 	public static void dp3(int u) {
 		// u的管理节点，先获得原树里子树u的所有节点
 		// 然后经历修正的过程，把管理节点的数量更新正确
-		ans[near[u]] += siz[u];
+		ans[manager[u]] += siz[u];
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			// 修正的过程
 			amend(u, v);
 			// 马上去往v执行dp3的过程，所以子树v的节点现在扣除
-			ans[near[u]] -= siz[v];
+			ans[manager[u]] -= siz[v];
 			// 子树v怎么分配节点，那是后续dp3(v)的事情
 			dp3(v);
 		}
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 2b1de7b10..0fea14df1 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -42,7 +42,7 @@
 //bool isKey[MAXN];
 //int tmp[MAXN << 1];
 //
-//int near[MAXN];
+//int manager[MAXN];
 //int dist[MAXN];
 //int ans[MAXN];
 //
@@ -131,57 +131,57 @@
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        dp1(v);
-//        int dis = dep[v] - dep[u];
-//        if (dist[u] > dist[v] + dis) {
-//            dist[u] = dist[v] + dis;
-//            near[u] = near[v];
-//        } else if (dist[u] == dist[v] + dis) {
-//            near[u] = min(near[u], near[v]);
+//        int w = dep[v] - dep[u];
+//        if (dist[u] > dist[v] + w) {
+//            dist[u] = dist[v] + w;
+//            manager[u] = manager[v];
+//        } else if (dist[u] == dist[v] + w) {
+//            manager[u] = min(manager[u], manager[v]);
 //        }
 //    }
 //    if (isKey[u]) {
 //        dist[u] = 0;
-//        near[u] = u;
+//        manager[u] = u;
 //    }
 //}
 //
 //void dp2(int u) {
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
-//        int dis = dep[v] - dep[u];
-//        if (dist[v] > dist[u] + dis) {
-//            dist[v] = dist[u] + dis;
-//            near[v] = near[u];
-//        } else if (dist[v] == dist[u] + dis) {
-//            near[v] = min(near[v], near[u]);
+//        int w = dep[v] - dep[u];
+//        if (dist[v] > dist[u] + w) {
+//            dist[v] = dist[u] + w;
+//            manager[v] = manager[u];
+//        } else if (dist[v] == dist[u] + w) {
+//            manager[v] = min(manager[v], manager[u]);
 //        }
 //        dp2(v);
 //    }
 //}
 //
 //void amend(int u, int v) {
-//    if (near[u] == near[v]) {
+//    if (manager[u] == manager[v]) {
 //        return;
 //    }
 //    int x = v;
 //    for (int p = MAXP - 1; p >= 0; p--) {
 //        int tou = (dep[stjump[x][p]] - dep[u]) + dist[u];
 //        int tov = (dep[v] - dep[stjump[x][p]]) + dist[v];
-//        if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && near[v] < near[u]))) {
+//        if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && manager[v] < manager[u]))) {
 //            x = stjump[x][p];
 //        }
 //    }
 //    int delta = siz[x] - siz[v];
-//    ans[near[u]] -= delta;
-//    ans[near[v]] += delta;
+//    ans[manager[u]] -= delta;
+//    ans[manager[v]] += delta;
 //}
 //
 //void dp3(int u) {
-//    ans[near[u]] += siz[u];
+//    ans[manager[u]] += siz[u];
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        amend(u, v);
-//        ans[near[u]] -= siz[v];
+//        ans[manager[u]] -= siz[v];
 //        dp3(v);
 //    }
 //}

From 760f512e533a22f609a4e88e3bef336ca158f396 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 12:52:22 +0800
Subject: [PATCH 1553/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 6 +++---
 src/class180/Code04_WorldTree2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index ae1e08f78..76b336e36 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -3,9 +3,9 @@
 // 世界树，java版
 // 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 一共有q条查询，每条查询格式如下
-// 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，树上每个点都找最近的关键点来管理自己
-//                       最近的关键点如果有多个，选择编号最小的关键点
-//                       打印每个关键点所管理的节点数量
+// 查询 k a1 a2 ... ak : 给出了k个不同的管理点，树上每个点都找最近的管理点来管理自己
+//                       如果某个节点的最近管理点有多个，选择编号最小的管理点
+//                       打印每个管理点，管理的节点数量
 // 1 <= n、q <= 3 * 10^5
 // 1 <= 所有查询给出的点的总数 <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3233
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 0fea14df1..3f389fd66 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -3,9 +3,9 @@
 // 世界树，C++版
 // 一共有n个节点，给定n-1条无向边，所有节点组成一棵树
 // 一共有q条查询，每条查询格式如下
-// 查询 k a1 a2 ... ak : 给出了k个不同的关键节点，树上每个点都找最近的关键点来管理自己
-//                       最近的关键点如果有多个，选择编号最小的关键点
-//                       打印每个关键点所管理的节点数量
+// 查询 k a1 a2 ... ak : 给出了k个不同的管理点，树上每个点都找最近的管理点来管理自己
+//                       如果某个节点的最近管理点有多个，选择编号最小的管理点
+//                       打印每个管理点，管理的节点数量
 // 1 <= n、q <= 3 * 10^5
 // 1 <= 所有查询给出的点的总数 <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3233

From c06e440348fa71cabb8f0ee9220cb83997b43c8f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 13:19:17 +0800
Subject: [PATCH 1554/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 8 ++------
 src/class180/Code04_WorldTree2.java | 8 ++------
 2 files changed, 4 insertions(+), 12 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index 76b336e36..c2420f093 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -157,11 +157,9 @@ public static void dp1(int u) {
 			int v = tov[e];
 			dp1(v);
 			int w = dep[v] - dep[u];
-			if (dist[u] > dist[v] + w) {
+			if (dist[v] + w < dist[u] || (dist[v] + w == dist[u] && manager[v] < manager[u])) {
 				dist[u] = dist[v] + w;
 				manager[u] = manager[v];
-			} else if (dist[u] == dist[v] + w) {
-				manager[u] = Math.min(manager[u], manager[v]);
 			}
 		}
 		if (isKey[u]) {
@@ -175,11 +173,9 @@ public static void dp2(int u) {
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			int w = dep[v] - dep[u];
-			if (dist[v] > dist[u] + w) {
+			if (dist[u] + w < dist[v] || (dist[u] + w == dist[v] && manager[u] < manager[v])) {
 				dist[v] = dist[u] + w;
 				manager[v] = manager[u];
-			} else if (dist[v] == dist[u] + w) {
-				manager[v] = Math.min(manager[v], manager[u]);
 			}
 			dp2(v);
 		}
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 3f389fd66..ac75e1214 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -132,11 +132,9 @@
 //        int v = tov[e];
 //        dp1(v);
 //        int w = dep[v] - dep[u];
-//        if (dist[u] > dist[v] + w) {
+//        if (dist[v] + w < dist[u] || (dist[v] + w == dist[u] && manager[v] < manager[u])) {
 //            dist[u] = dist[v] + w;
 //            manager[u] = manager[v];
-//        } else if (dist[u] == dist[v] + w) {
-//            manager[u] = min(manager[u], manager[v]);
 //        }
 //    }
 //    if (isKey[u]) {
@@ -149,11 +147,9 @@
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        int w = dep[v] - dep[u];
-//        if (dist[v] > dist[u] + w) {
+//        if (dist[u] + w < dist[v] || (dist[u] + w == dist[v] && manager[u] < manager[v])) {
 //            dist[v] = dist[u] + w;
 //            manager[v] = manager[u];
-//        } else if (dist[v] == dist[u] + w) {
-//            manager[v] = min(manager[v], manager[u]);
 //        }
 //        dp2(v);
 //    }

From 4ca26b13d1b502d6fa6ca70a988e43b59a938a71 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 13:20:48 +0800
Subject: [PATCH 1555/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 3 +--
 src/class180/Code04_WorldTree2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index c2420f093..48875c81e 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -24,7 +24,6 @@ public class Code04_WorldTree1 {
 
 	public static int MAXN = 300001;
 	public static int MAXP = 20;
-	public static int INF = 1000000001;
 	public static int n, q, k;
 
 	public static int[] headg = new int[MAXN];
@@ -152,7 +151,7 @@ public static int buildVirtualTree() {
 
 	// 下方找最近管理点，节点u根据孩子的管理点，找到离u最近的管理点
 	public static void dp1(int u) {
-		dist[u] = INF;
+		dist[u] = 1000000001;
 		for (int e = headv[u]; e > 0; e = nextv[e]) {
 			int v = tov[e];
 			dp1(v);
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index ac75e1214..7e6445b12 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -18,7 +18,6 @@
 //
 //const int MAXN = 300001;
 //const int MAXP = 20;
-//const int INF = 1000000001;
 //int n, q, k;
 //
 //int headg[MAXN];
@@ -127,7 +126,7 @@
 //}
 //
 //void dp1(int u) {
-//    dist[u] = INF;
+//    dist[u] = 1000000001;
 //    for (int e = headv[u]; e; e = nextv[e]) {
 //        int v = tov[e];
 //        dp1(v);

From cdc805516f3e5121cfd8b818664376e13c2993f4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 15:12:17 +0800
Subject: [PATCH 1556/1712] modify code

---
 src/class180/Code04_WorldTree1.java | 15 +++++++++------
 src/class180/Code04_WorldTree2.java | 11 +++++++----
 2 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/src/class180/Code04_WorldTree1.java b/src/class180/Code04_WorldTree1.java
index 48875c81e..11938fdc8 100644
--- a/src/class180/Code04_WorldTree1.java
+++ b/src/class180/Code04_WorldTree1.java
@@ -189,10 +189,13 @@ public static void amend(int u, int v) {
 		}
 		int x = v;
 		for (int p = MAXP - 1; p >= 0; p--) {
-			int tou = dep[stjump[x][p]] - dep[u] + dist[u];
-			int tov = dep[v] - dep[stjump[x][p]] + dist[v];
-			if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && manager[v] < manager[u]))) {
-				x = stjump[x][p];
+			int jump = stjump[x][p];
+			if (dep[u] < dep[jump]) {
+				int tou = dep[jump] - dep[u] + dist[u];
+				int tov = dep[v] - dep[jump] + dist[v];
+				if (tov < tou || (tov == tou && manager[v] < manager[u])) {
+					x = jump;
+				}
 			}
 		}
 		int delta = siz[x] - siz[v];
@@ -200,7 +203,7 @@ public static void amend(int u, int v) {
 		ans[manager[v]] += delta;
 	}
 
-	// 每个点都有了最近的管理点，更新相关的管理点的计数
+	// 每个点都有了最近的管理点，更新相关管理点的管理节点计数
 	public static void dp3(int u) {
 		// u的管理节点，先获得原树里子树u的所有节点
 		// 然后经历修正的过程，把管理节点的数量更新正确
@@ -209,7 +212,7 @@ public static void dp3(int u) {
 			int v = tov[e];
 			// 修正的过程
 			amend(u, v);
-			// 马上去往v执行dp3的过程，所以子树v的节点现在扣除
+			// 马上要执行dp3(v)，所以子树v的节点现在扣除
 			ans[manager[u]] -= siz[v];
 			// 子树v怎么分配节点，那是后续dp3(v)的事情
 			dp3(v);
diff --git a/src/class180/Code04_WorldTree2.java b/src/class180/Code04_WorldTree2.java
index 7e6445b12..c2ee977d5 100644
--- a/src/class180/Code04_WorldTree2.java
+++ b/src/class180/Code04_WorldTree2.java
@@ -160,10 +160,13 @@
 //    }
 //    int x = v;
 //    for (int p = MAXP - 1; p >= 0; p--) {
-//        int tou = (dep[stjump[x][p]] - dep[u]) + dist[u];
-//        int tov = (dep[v] - dep[stjump[x][p]]) + dist[v];
-//        if (dep[u] < dep[stjump[x][p]] && (tov < tou || (tov == tou && manager[v] < manager[u]))) {
-//            x = stjump[x][p];
+//        int jump = stjump[x][p];
+//        if (dep[u] < dep[jump]) {
+//            int tou = dep[jump] - dep[u] + dist[u];
+//            int tov = dep[v] - dep[jump] + dist[v];
+//            if (tov < tou || (tov == tou && manager[v] < manager[u])) {
+//                x = jump;
+//            }
 //        }
 //    }
 //    int delta = siz[x] - siz[v];

From e3bdd9ce348ff40ab8c67f1e54fb702d4fd01b39 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 16:55:18 +0800
Subject: [PATCH 1557/1712] modify code

---
 src/class180/Code05_TreelandAndViruses1.java | 30 ++++++++++----------
 src/class180/Code05_TreelandAndViruses2.java | 26 ++++++++---------
 2 files changed, 28 insertions(+), 28 deletions(-)

diff --git a/src/class180/Code05_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
index 8207d084d..f9056068e 100644
--- a/src/class180/Code05_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -23,14 +23,14 @@
 public class Code05_TreelandAndViruses1 {
 
 	static class Node {
-		int id, dist, time, source, sourceOrder;
+		int id, dist, time, source, virus;
 
-		Node(int id_, int dist_, int time_, int source_, int sourceOrder_) {
+		Node(int id_, int dist_, int time_, int source_, int virus_) {
 			id = id_;
 			dist = dist_;
 			time = time_;
 			source = source_;
-			sourceOrder = sourceOrder_;
+			virus = virus_;
 		}
 	}
 
@@ -40,7 +40,7 @@ public int compare(Node o1, Node o2) {
 			if (o1.time != o2.time) {
 				return o1.time - o2.time;
 			}
-			return o1.sourceOrder - o2.sourceOrder;
+			return o1.virus - o2.virus;
 		}
 	}
 
@@ -66,7 +66,7 @@ public int compare(Node o1, Node o2) {
 	public static int[] start = new int[MAXN];
 	public static int[] speed = new int[MAXN];
 	public static int[] query = new int[MAXN];
-	public static int[] order = new int[MAXN];
+	public static int[] virusId = new int[MAXN];
 
 	public static int[] arr = new int[MAXN << 1];
 	public static int[] tmp = new int[MAXN << 2];
@@ -75,7 +75,7 @@ public int compare(Node o1, Node o2) {
 	public static PriorityQueue<Node> heap = new PriorityQueue<>(new NodeCmp());
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] minTime = new int[MAXN];
-	public static int[] bestSource = new int[MAXN];
+	public static int[] sourceCity = new int[MAXN];
 
 	public static int[] ans = new int[MAXN];
 
@@ -183,21 +183,21 @@ public static void dijkstra() {
 		for (int i = 1; i <= len; i++) {
 			int u = tmp[i];
 			minTime[u] = n + 1;
-			bestSource[u] = n + 1;
+			sourceCity[u] = n + 1;
 			vis[u] = false;
 		}
 		for (int i = 1; i <= k; i++) {
 			int s = start[i];
 			minTime[s] = 0;
-			bestSource[s] = s;
-			heap.add(new Node(s, 0, 0, s, order[s]));
+			sourceCity[s] = s;
+			heap.add(new Node(s, 0, 0, s, virusId[s]));
 		}
 		while (!heap.isEmpty()) {
 			Node cur = heap.poll();
 			int u = cur.id;
 			int udist = cur.dist;
 			int usource = cur.source;
-			int usourceOrder = cur.sourceOrder;
+			int uvirus = cur.virus;
 			if (!vis[u]) {
 				vis[u] = true;
 				for (int e = headv[u]; e > 0; e = nextv[e]) {
@@ -205,10 +205,10 @@ public static void dijkstra() {
 					if (!vis[v]) {
 						int vdist = udist + Math.abs(dep[u] - dep[v]);
 						int vtime = (vdist + speed[usource] - 1) / speed[usource];
-						if (vtime < minTime[v] || (vtime == minTime[v] && usourceOrder < order[bestSource[v]])) {
+						if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < virusId[sourceCity[v]])) {
 							minTime[v] = vtime;
-							bestSource[v] = usource;
-							heap.add(new Node(v, vdist, vtime, usource, usourceOrder));
+							sourceCity[v] = usource;
+							heap.add(new Node(v, vdist, vtime, usource, uvirus));
 						}
 					}
 				}
@@ -218,12 +218,12 @@ public static void dijkstra() {
 
 	public static void compute() {
 		for (int i = 1; i <= k; i++) {
-			order[start[i]] = i;
+			virusId[start[i]] = i;
 		}
 		buildVirtualTree();
 		dijkstra();
 		for (int i = 1; i <= m; i++) {
-			ans[i] = order[bestSource[query[i]]];
+			ans[i] = virusId[sourceCity[query[i]]];
 		}
 	}
 
diff --git a/src/class180/Code05_TreelandAndViruses2.java b/src/class180/Code05_TreelandAndViruses2.java
index ea9dadb70..9ae3a3f53 100644
--- a/src/class180/Code05_TreelandAndViruses2.java
+++ b/src/class180/Code05_TreelandAndViruses2.java
@@ -19,12 +19,12 @@
 //using namespace std;
 //
 //struct Node {
-//    int id, dist, time, source, sourceOrder;
+//    int id, dist, time, source, virus;
 //    bool operator<(const Node &other) const {
 //        if (time != other.time) {
 //            return time > other.time;
 //        }
-//        return sourceOrder > other.sourceOrder;
+//        return virus > other.virus;
 //    }
 //};
 //
@@ -50,7 +50,7 @@
 //int start[MAXN];
 //int speed[MAXN];
 //int query[MAXN];
-//int order[MAXN];
+//int virusId[MAXN];
 //
 //int arr[MAXN << 1];
 //int tmp[MAXN << 2];
@@ -59,7 +59,7 @@
 //priority_queue<Node> heap;
 //bool vis[MAXN];
 //int minTime[MAXN];
-//int bestSource[MAXN];
+//int sourceCity[MAXN];
 //int ans[MAXN];
 //
 //bool cmp(int x, int y) {
@@ -152,14 +152,14 @@
 //    for (int i = 1; i <= len; i++) {
 //        int u = tmp[i];
 //        minTime[u] = n + 1;
-//        bestSource[u] = n + 1;
+//        sourceCity[u] = n + 1;
 //        vis[u] = false;
 //    }
 //    for (int i = 1; i <= k; i++) {
 //        int s = start[i];
 //        minTime[s] = 0;
-//        bestSource[s] = s;
-//        heap.push(Node{s, 0, 0, s, order[s]});
+//        sourceCity[s] = s;
+//        heap.push(Node{s, 0, 0, s, virusId[s]});
 //    }
 //    while (!heap.empty()) {
 //        Node cur = heap.top();
@@ -167,7 +167,7 @@
 //        int u = cur.id;
 //        int udist = cur.dist;
 //        int usource = cur.source;
-//        int usourceOrder = cur.sourceOrder;
+//        int uvirus = cur.virus;
 //        if (!vis[u]) {
 //            vis[u] = true;
 //            for (int e = headv[u]; e; e = nextv[e]) {
@@ -175,10 +175,10 @@
 //                if (!vis[v]) {
 //                    int vdist = udist + abs(dep[u] - dep[v]);
 //                    int vtime = (vdist + speed[usource] - 1) / speed[usource];
-//                    if (vtime < minTime[v] || (vtime == minTime[v] && usourceOrder < order[bestSource[v]])) {
+//                    if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < virusId[sourceCity[v]])) {
 //                        minTime[v] = vtime;
-//                        bestSource[v] = usource;
-//                        heap.push(Node{v, vdist, vtime, usource, usourceOrder});
+//                        sourceCity[v] = usource;
+//                        heap.push(Node{v, vdist, vtime, usource, uvirus});
 //                    }
 //                }
 //            }
@@ -188,12 +188,12 @@
 //
 //void compute() {
 //    for (int i = 1; i <= k; i++) {
-//        order[start[i]] = i;
+//        virusId[start[i]] = i;
 //    }
 //    buildVirtualTree();
 //    dijkstra();
 //    for (int i = 1; i <= m; i++) {
-//        ans[i] = order[bestSource[query[i]]];
+//        ans[i] = virusId[sourceCity[query[i]]];
 //    }
 //}
 //

From 632fc7a1f27382eea2a5b81d3687199eabc7b4d1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 17:27:27 +0800
Subject: [PATCH 1558/1712] modify code

---
 src/class180/Code05_TreelandAndViruses1.java | 33 +++++++-------------
 src/class180/Code05_TreelandAndViruses2.java | 32 +++++++------------
 2 files changed, 22 insertions(+), 43 deletions(-)

diff --git a/src/class180/Code05_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
index f9056068e..4b0c3cffd 100644
--- a/src/class180/Code05_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -65,8 +65,8 @@ public int compare(Node o1, Node o2) {
 
 	public static int[] start = new int[MAXN];
 	public static int[] speed = new int[MAXN];
+	public static int[] order = new int[MAXN];
 	public static int[] query = new int[MAXN];
-	public static int[] virusId = new int[MAXN];
 
 	public static int[] arr = new int[MAXN << 1];
 	public static int[] tmp = new int[MAXN << 2];
@@ -75,9 +75,7 @@ public int compare(Node o1, Node o2) {
 	public static PriorityQueue<Node> heap = new PriorityQueue<>(new NodeCmp());
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] minTime = new int[MAXN];
-	public static int[] sourceCity = new int[MAXN];
-
-	public static int[] ans = new int[MAXN];
+	public static int[] findVirus = new int[MAXN];
 
 	public static void addEdgeG(int u, int v) {
 		nextg[++cntg] = headg[u];
@@ -183,14 +181,14 @@ public static void dijkstra() {
 		for (int i = 1; i <= len; i++) {
 			int u = tmp[i];
 			minTime[u] = n + 1;
-			sourceCity[u] = n + 1;
+			findVirus[u] = k + 1;
 			vis[u] = false;
 		}
 		for (int i = 1; i <= k; i++) {
 			int s = start[i];
 			minTime[s] = 0;
-			sourceCity[s] = s;
-			heap.add(new Node(s, 0, 0, s, virusId[s]));
+			findVirus[s] = order[s];
+			heap.add(new Node(s, 0, 0, s, order[s]));
 		}
 		while (!heap.isEmpty()) {
 			Node cur = heap.poll();
@@ -205,9 +203,9 @@ public static void dijkstra() {
 					if (!vis[v]) {
 						int vdist = udist + Math.abs(dep[u] - dep[v]);
 						int vtime = (vdist + speed[usource] - 1) / speed[usource];
-						if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < virusId[sourceCity[v]])) {
+						if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < findVirus[v])) {
 							minTime[v] = vtime;
-							sourceCity[v] = usource;
+							findVirus[v] = uvirus;
 							heap.add(new Node(v, vdist, vtime, usource, uvirus));
 						}
 					}
@@ -216,17 +214,6 @@ public static void dijkstra() {
 		}
 	}
 
-	public static void compute() {
-		for (int i = 1; i <= k; i++) {
-			virusId[start[i]] = i;
-		}
-		buildVirtualTree();
-		dijkstra();
-		for (int i = 1; i <= m; i++) {
-			ans[i] = virusId[sourceCity[query[i]]];
-		}
-	}
-
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -245,13 +232,15 @@ public static void main(String[] args) throws Exception {
 			for (int i = 1; i <= k; i++) {
 				start[i] = in.nextInt();
 				speed[start[i]] = in.nextInt();
+				order[start[i]] = i;
 			}
 			for (int i = 1; i <= m; i++) {
 				query[i] = in.nextInt();
 			}
-			compute();
+			buildVirtualTree();
+			dijkstra();
 			for (int i = 1; i <= m; i++) {
-				out.print(ans[i] + " ");
+				out.print(findVirus[query[i]] + " ");
 			}
 			out.println();
 		}
diff --git a/src/class180/Code05_TreelandAndViruses2.java b/src/class180/Code05_TreelandAndViruses2.java
index 9ae3a3f53..1c0c71b47 100644
--- a/src/class180/Code05_TreelandAndViruses2.java
+++ b/src/class180/Code05_TreelandAndViruses2.java
@@ -49,8 +49,8 @@
 //
 //int start[MAXN];
 //int speed[MAXN];
+//int order[MAXN];
 //int query[MAXN];
-//int virusId[MAXN];
 //
 //int arr[MAXN << 1];
 //int tmp[MAXN << 2];
@@ -59,8 +59,7 @@
 //priority_queue<Node> heap;
 //bool vis[MAXN];
 //int minTime[MAXN];
-//int sourceCity[MAXN];
-//int ans[MAXN];
+//int findVirus[MAXN];
 //
 //bool cmp(int x, int y) {
 //    return dfn[x] < dfn[y];
@@ -152,14 +151,14 @@
 //    for (int i = 1; i <= len; i++) {
 //        int u = tmp[i];
 //        minTime[u] = n + 1;
-//        sourceCity[u] = n + 1;
+//        findVirus[u] = k + 1;
 //        vis[u] = false;
 //    }
 //    for (int i = 1; i <= k; i++) {
 //        int s = start[i];
 //        minTime[s] = 0;
-//        sourceCity[s] = s;
-//        heap.push(Node{s, 0, 0, s, virusId[s]});
+//        findVirus[s] = order[s];
+//        heap.push(Node{s, 0, 0, s, order[s]});
 //    }
 //    while (!heap.empty()) {
 //        Node cur = heap.top();
@@ -175,9 +174,9 @@
 //                if (!vis[v]) {
 //                    int vdist = udist + abs(dep[u] - dep[v]);
 //                    int vtime = (vdist + speed[usource] - 1) / speed[usource];
-//                    if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < virusId[sourceCity[v]])) {
+//                    if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < findVirus[v])) {
 //                        minTime[v] = vtime;
-//                        sourceCity[v] = usource;
+//                        findVirus[v] = uvirus;
 //                        heap.push(Node{v, vdist, vtime, usource, uvirus});
 //                    }
 //                }
@@ -186,17 +185,6 @@
 //    }
 //}
 //
-//void compute() {
-//    for (int i = 1; i <= k; i++) {
-//        virusId[start[i]] = i;
-//    }
-//    buildVirtualTree();
-//    dijkstra();
-//    for (int i = 1; i <= m; i++) {
-//        ans[i] = virusId[sourceCity[query[i]]];
-//    }
-//}
-//
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
@@ -214,13 +202,15 @@
 //            cin >> s >> v;
 //            start[i] = s;
 //            speed[s] = v;
+//            order[s] = i;
 //        }
 //        for (int i = 1; i <= m; i++) {
 //            cin >> query[i];
 //        }
-//        compute();
+//        buildVirtualTree();
+//        dijkstra();
 //        for (int i = 1; i <= m; i++) {
-//            cout << ans[i] << ' ';
+//            cout << findVirus[query[i]] << ' ';
 //        }
 //        cout << '\n';
 //    }

From 1ac3a7b373858b426e0e8b33888ec81a47690d02 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 18:03:22 +0800
Subject: [PATCH 1559/1712] modify code

---
 src/class180/Code05_TreelandAndViruses1.java | 18 +++++++-----------
 src/class180/Code05_TreelandAndViruses2.java | 17 ++++++-----------
 2 files changed, 13 insertions(+), 22 deletions(-)

diff --git a/src/class180/Code05_TreelandAndViruses1.java b/src/class180/Code05_TreelandAndViruses1.java
index 4b0c3cffd..3259bc83e 100644
--- a/src/class180/Code05_TreelandAndViruses1.java
+++ b/src/class180/Code05_TreelandAndViruses1.java
@@ -23,13 +23,12 @@
 public class Code05_TreelandAndViruses1 {
 
 	static class Node {
-		int id, dist, time, source, virus;
+		int id, dist, time, virus;
 
-		Node(int id_, int dist_, int time_, int source_, int virus_) {
+		Node(int id_, int dist_, int time_, int virus_) {
 			id = id_;
 			dist = dist_;
 			time = time_;
-			source = source_;
 			virus = virus_;
 		}
 	}
@@ -65,7 +64,6 @@ public int compare(Node o1, Node o2) {
 
 	public static int[] start = new int[MAXN];
 	public static int[] speed = new int[MAXN];
-	public static int[] order = new int[MAXN];
 	public static int[] query = new int[MAXN];
 
 	public static int[] arr = new int[MAXN << 1];
@@ -187,14 +185,13 @@ public static void dijkstra() {
 		for (int i = 1; i <= k; i++) {
 			int s = start[i];
 			minTime[s] = 0;
-			findVirus[s] = order[s];
-			heap.add(new Node(s, 0, 0, s, order[s]));
+			findVirus[s] = i;
+			heap.add(new Node(s, 0, 0, i));
 		}
 		while (!heap.isEmpty()) {
 			Node cur = heap.poll();
 			int u = cur.id;
 			int udist = cur.dist;
-			int usource = cur.source;
 			int uvirus = cur.virus;
 			if (!vis[u]) {
 				vis[u] = true;
@@ -202,11 +199,11 @@ public static void dijkstra() {
 					int v = tov[e];
 					if (!vis[v]) {
 						int vdist = udist + Math.abs(dep[u] - dep[v]);
-						int vtime = (vdist + speed[usource] - 1) / speed[usource];
+						int vtime = (vdist + speed[uvirus] - 1) / speed[uvirus];
 						if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < findVirus[v])) {
 							minTime[v] = vtime;
 							findVirus[v] = uvirus;
-							heap.add(new Node(v, vdist, vtime, usource, uvirus));
+							heap.add(new Node(v, vdist, vtime, uvirus));
 						}
 					}
 				}
@@ -231,8 +228,7 @@ public static void main(String[] args) throws Exception {
 			m = in.nextInt();
 			for (int i = 1; i <= k; i++) {
 				start[i] = in.nextInt();
-				speed[start[i]] = in.nextInt();
-				order[start[i]] = i;
+				speed[i] = in.nextInt();
 			}
 			for (int i = 1; i <= m; i++) {
 				query[i] = in.nextInt();
diff --git a/src/class180/Code05_TreelandAndViruses2.java b/src/class180/Code05_TreelandAndViruses2.java
index 1c0c71b47..d300e6626 100644
--- a/src/class180/Code05_TreelandAndViruses2.java
+++ b/src/class180/Code05_TreelandAndViruses2.java
@@ -19,7 +19,7 @@
 //using namespace std;
 //
 //struct Node {
-//    int id, dist, time, source, virus;
+//    int id, dist, time, virus;
 //    bool operator<(const Node &other) const {
 //        if (time != other.time) {
 //            return time > other.time;
@@ -49,7 +49,6 @@
 //
 //int start[MAXN];
 //int speed[MAXN];
-//int order[MAXN];
 //int query[MAXN];
 //
 //int arr[MAXN << 1];
@@ -157,15 +156,14 @@
 //    for (int i = 1; i <= k; i++) {
 //        int s = start[i];
 //        minTime[s] = 0;
-//        findVirus[s] = order[s];
-//        heap.push(Node{s, 0, 0, s, order[s]});
+//        findVirus[s] = i;
+//        heap.push(Node{s, 0, 0, i});
 //    }
 //    while (!heap.empty()) {
 //        Node cur = heap.top();
 //        heap.pop();
 //        int u = cur.id;
 //        int udist = cur.dist;
-//        int usource = cur.source;
 //        int uvirus = cur.virus;
 //        if (!vis[u]) {
 //            vis[u] = true;
@@ -173,11 +171,11 @@
 //                int v = tov[e];
 //                if (!vis[v]) {
 //                    int vdist = udist + abs(dep[u] - dep[v]);
-//                    int vtime = (vdist + speed[usource] - 1) / speed[usource];
+//                    int vtime = (vdist + speed[uvirus] - 1) / speed[uvirus];
 //                    if (vtime < minTime[v] || (vtime == minTime[v] && uvirus < findVirus[v])) {
 //                        minTime[v] = vtime;
 //                        findVirus[v] = uvirus;
-//                        heap.push(Node{v, vdist, vtime, usource, uvirus});
+//                        heap.push(Node{v, vdist, vtime, uvirus});
 //                    }
 //                }
 //            }
@@ -199,10 +197,7 @@
 //    for (int t = 1; t <= q; t++) {
 //        cin >> k >> m;
 //        for (int i = 1, s, v; i <= k; i++) {
-//            cin >> s >> v;
-//            start[i] = s;
-//            speed[s] = v;
-//            order[s] = i;
+//            cin >> start[i] >> speed[i];
 //        }
 //        for (int i = 1; i <= m; i++) {
 //            cin >> query[i];

From 63e8aaaa0d4aae50b68e30dff9f106e430754797 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 18:57:20 +0800
Subject: [PATCH 1560/1712] modify code

---
 src/class180/Code06_TreasureHunt1.java | 10 +++++-----
 src/class180/Code06_TreasureHunt2.java | 10 +++++-----
 2 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class180/Code06_TreasureHunt1.java b/src/class180/Code06_TreasureHunt1.java
index 551785654..6ed91a09b 100644
--- a/src/class180/Code06_TreasureHunt1.java
+++ b/src/class180/Code06_TreasureHunt1.java
@@ -36,7 +36,7 @@ public class Code06_TreasureHunt1 {
 	public static int cntd;
 
 	public static int[] arr = new int[MAXN];
-	public static boolean[] vis = new boolean[MAXN];
+	public static boolean[] treasure = new boolean[MAXN];
 	// 这里为了方便，使用语言自带的有序表
 	public static TreeSet<Integer> set = new TreeSet<>();
 
@@ -145,11 +145,11 @@ public static void compute() {
 		for (int i = 1; i <= m; i++) {
 			int nodeId = arr[i];
 			int dfnId = dfn[nodeId];
-			if (!vis[nodeId]) {
-				vis[nodeId] = true;
+			if (!treasure[nodeId]) {
+				treasure[nodeId] = true;
 				set.add(dfnId);
 			} else {
-				vis[nodeId] = false;
+				treasure[nodeId] = false;
 				set.remove(dfnId);
 			}
 			if (set.size() <= 1) {
@@ -158,7 +158,7 @@ public static void compute() {
 				int low = seg[set.lower(dfnId) != null ? set.lower(dfnId) : set.last()];
 				int high = seg[set.higher(dfnId) != null ? set.higher(dfnId) : set.first()];
 				long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
-				if (vis[nodeId]) {
+				if (treasure[nodeId]) {
 					curAns += delta;
 				} else {
 					curAns -= delta;
diff --git a/src/class180/Code06_TreasureHunt2.java b/src/class180/Code06_TreasureHunt2.java
index 91bbf5fcc..0841bb8a0 100644
--- a/src/class180/Code06_TreasureHunt2.java
+++ b/src/class180/Code06_TreasureHunt2.java
@@ -33,7 +33,7 @@
 //int cntd;
 //
 //int arr[MAXN];
-//bool vis[MAXN];
+//bool treasure[MAXN];
 //std::set<int> st;
 //std::set<int>::iterator it;
 //
@@ -93,11 +93,11 @@
 //    for (int i = 1; i <= m; i++) {
 //        int nodeId = arr[i];
 //        int dfnId = dfn[nodeId];
-//        if (!vis[nodeId]) {
-//            vis[nodeId] = true;
+//        if (!treasure[nodeId]) {
+//            treasure[nodeId] = true;
 //            st.insert(dfnId);
 //        } else {
-//            vis[nodeId] = false;
+//            treasure[nodeId] = false;
 //            st.erase(dfnId);
 //        }
 //        if (st.size() <= 1) {
@@ -106,7 +106,7 @@
 //            int low = seg[(it = st.lower_bound(dfnId)) == st.begin() ? *--st.end() : *--it];
 //            int high = seg[(it = st.upper_bound(dfnId)) == st.end() ? *st.begin() : *it];
 //            long long delta = getDist(nodeId, low) + getDist(nodeId, high) - getDist(low, high);
-//            if (vis[nodeId]) {
+//            if (treasure[nodeId]) {
 //                curAns += delta;
 //            } else {
 //                curAns -= delta;

From d21a7713c2d6b77c5619480bc92c1b70e9608515 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 15 Oct 2025 21:56:52 +0800
Subject: [PATCH 1561/1712] modify code

---
 src/class180/Code06_TreasureHunt1.java | 8 ++++----
 src/class180/Code06_TreasureHunt2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class180/Code06_TreasureHunt1.java b/src/class180/Code06_TreasureHunt1.java
index 6ed91a09b..c786425ff 100644
--- a/src/class180/Code06_TreasureHunt1.java
+++ b/src/class180/Code06_TreasureHunt1.java
@@ -2,10 +2,10 @@
 
 // 寻宝游戏，java版
 // 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
-// 一开始所有的节点都没有宝物，接下来有m条操作，每条操作格式如下
-// 操作 x : 如果x号点上无宝物，那么变成有宝物，如果x号点上有宝物，那么变成无宝物
-// 每次操作后，树上会形成新的宝物分布，所以每次你都可以选择任何点作为出发点
-// 目标是拿完当前状况下的所有宝物，最后回到出发点，打印最小的总路程，一共有m条打印
+// 开始时所有节点都是无宝点，接下来有m条操作，每条操作格式如下
+// 操作 x : 如果x号点是无宝点，那么变成有宝点，如果x号点是有宝点，那么变成无宝点
+// 每次操作后，每个有宝点都会刷新宝物，你可以瞬移到任何地点作为出发点，瞬移无代价
+// 然后你需要走路去拿所有的宝物，最后回到出发点，打印最小的行走总路程，一共m条打印
 // 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3320
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class180/Code06_TreasureHunt2.java b/src/class180/Code06_TreasureHunt2.java
index 0841bb8a0..16165bb46 100644
--- a/src/class180/Code06_TreasureHunt2.java
+++ b/src/class180/Code06_TreasureHunt2.java
@@ -2,10 +2,10 @@
 
 // 寻宝游戏，C++版
 // 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
-// 一开始所有的节点都没有宝物，接下来有m条操作，每条操作格式如下
-// 操作 x : 如果x号点上无宝物，那么变成有宝物，如果x号点上有宝物，那么变成无宝物
-// 每次操作后，树上会形成新的宝物分布，所以每次你都可以选择任何点作为出发点
-// 目标是拿完当前状况下的所有宝物，最后回到出发点，打印最小的总路程，一共有m条打印
+// 开始时所有节点都是无宝点，接下来有m条操作，每条操作格式如下
+// 操作 x : 如果x号点是无宝点，那么变成有宝点，如果x号点是有宝点，那么变成无宝点
+// 每次操作后，每个有宝点都会刷新宝物，你可以瞬移到任何地点作为出发点，瞬移无代价
+// 然后你需要走路去拿所有的宝物，最后回到出发点，打印最小的行走总路程，一共m条打印
 // 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3320
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 802d1da3451e891acc5f8e5acc78b51a49899b51 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Oct 2025 10:23:53 +0800
Subject: [PATCH 1562/1712] modify code

---
 src/class180/Code06_TreasureHunt1.java | 13 +++++++------
 src/class180/Code06_TreasureHunt2.java | 13 +++++++------
 2 files changed, 14 insertions(+), 12 deletions(-)

diff --git a/src/class180/Code06_TreasureHunt1.java b/src/class180/Code06_TreasureHunt1.java
index c786425ff..d510b0693 100644
--- a/src/class180/Code06_TreasureHunt1.java
+++ b/src/class180/Code06_TreasureHunt1.java
@@ -1,11 +1,12 @@
 package class180;
 
 // 寻宝游戏，java版
-// 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
-// 开始时所有节点都是无宝点，接下来有m条操作，每条操作格式如下
-// 操作 x : 如果x号点是无宝点，那么变成有宝点，如果x号点是有宝点，那么变成无宝点
-// 每次操作后，每个有宝点都会刷新宝物，你可以瞬移到任何地点作为出发点，瞬移无代价
-// 然后你需要走路去拿所有的宝物，最后回到出发点，打印最小的行走总路程，一共m条打印
+// 一共有n个节点，节点有两种类型，刷宝的点 和 不刷宝的点
+// 一共有n-1条无向边，每条边有边权，所有节点组成一棵树
+// 开始时所有节点都是不刷宝的点，接下来有m条操作，格式如下
+// 操作 x : x号点的类型翻转，刷宝的点 变成 不刷宝的点，不刷宝的点 变成 刷宝的点
+// 一次操作后，每个刷宝的点都会产生宝物，你可以瞬移到任何点作为出发点，瞬移是无代价的
+// 你需要走路拿到所有的宝物，最后回到出发点，打印最小的行走总路程，一共有m条打印
 // 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3320
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -29,9 +30,9 @@ public class Code06_TreasureHunt1 {
 	public static int cntg;
 
 	public static int[] dep = new int[MAXN];
+	public static long[] dist = new long[MAXN];
 	public static int[] dfn = new int[MAXN];
 	public static int[] seg = new int[MAXN];
-	public static long[] dist = new long[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
 	public static int cntd;
 
diff --git a/src/class180/Code06_TreasureHunt2.java b/src/class180/Code06_TreasureHunt2.java
index 16165bb46..6781fde1a 100644
--- a/src/class180/Code06_TreasureHunt2.java
+++ b/src/class180/Code06_TreasureHunt2.java
@@ -1,11 +1,12 @@
 package class180;
 
 // 寻宝游戏，C++版
-// 一共有n个节点，给定n-1条无向边，每条边有边权，所有节点组成一棵树
-// 开始时所有节点都是无宝点，接下来有m条操作，每条操作格式如下
-// 操作 x : 如果x号点是无宝点，那么变成有宝点，如果x号点是有宝点，那么变成无宝点
-// 每次操作后，每个有宝点都会刷新宝物，你可以瞬移到任何地点作为出发点，瞬移无代价
-// 然后你需要走路去拿所有的宝物，最后回到出发点，打印最小的行走总路程，一共m条打印
+// 一共有n个节点，节点有两种类型，刷宝的点 和 不刷宝的点
+// 一共有n-1条无向边，每条边有边权，所有节点组成一棵树
+// 开始时所有节点都是不刷宝的点，接下来有m条操作，格式如下
+// 操作 x : x号点的类型翻转，刷宝的点 变成 不刷宝的点，不刷宝的点 变成 刷宝的点
+// 一次操作后，每个刷宝的点都会产生宝物，你可以瞬移到任何点作为出发点，瞬移是无代价的
+// 你需要走路拿到所有的宝物，最后回到出发点，打印最小的行走总路程，一共有m条打印
 // 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3320
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
@@ -26,9 +27,9 @@
 //int cntg;
 //
 //int dep[MAXN];
+//long long dist[MAXN];
 //int dfn[MAXN];
 //int seg[MAXN];
-//long long dist[MAXN];
 //int stjump[MAXN][MAXP];
 //int cntd;
 //

From fac5642e6fadecf0f4590bdeaf51488ba3a12e42 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 16 Oct 2025 12:06:51 +0800
Subject: [PATCH 1563/1712] modify code

---
 ...70\345\205\263\351\242\230\347\233\256.pptx" | Bin 0 -> 52151 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243180\343\200\220\346\214\272\351\232\276\343\200\221\350\231\232\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243180\343\200\220\346\214\272\351\232\276\343\200\221\350\231\232\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243180\343\200\220\346\214\272\351\232\276\343\200\221\350\231\232\346\240\221\347\232\204\345\216\237\347\220\206\345\222\214\347\233\270\345\205\263\351\242\230\347\233\256.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..2664c00f8c87eab92a67153481687309d16e2b08
GIT binary patch
literal 52151
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
Zrfd~u5P`=xU}_C`Spbt095uf_{ST3MqJ97X

literal 0
HcmV?d00001


From df9820497e32f5a76fbf93f7f87e6970fd3188e5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 17 Oct 2025 13:35:20 +0800
Subject: [PATCH 1564/1712] modify code

---
 src/class181/Code01_PromotionCounting1.java | 255 ++++++++++++++++++++
 src/class181/Code01_PromotionCounting2.java | 162 +++++++++++++
 2 files changed, 417 insertions(+)
 create mode 100644 src/class181/Code01_PromotionCounting1.java
 create mode 100644 src/class181/Code01_PromotionCounting2.java

diff --git a/src/class181/Code01_PromotionCounting1.java b/src/class181/Code01_PromotionCounting1.java
new file mode 100644
index 000000000..3e1313639
--- /dev/null
+++ b/src/class181/Code01_PromotionCounting1.java
@@ -0,0 +1,255 @@
+package class181;
+
+// 晋升者计数，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3605
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code01_PromotionCounting1 {
+
+	public static int MAXN = 100001;
+	public static int MAXT = MAXN * 40;
+	public static int n;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] arr = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
+
+	public static int[] root = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] siz = new int[MAXT];
+	public static int cntt;
+
+	public static int[] ans = new int[MAXN];
+
+	public static void addEdge(int u, int v) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) / 2;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static void up(int i) {
+		siz[i] = siz[ls[i]] + siz[rs[i]];
+	}
+
+	public static int insert(int jobi, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = ++cntt;
+		}
+		if (l == r) {
+			siz[rt]++;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				ls[rt] = insert(jobi, l, mid, ls[rt]);
+			} else {
+				rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			return t1 + t2;
+		}
+		if (l == r) {
+			siz[t1] += siz[t2];
+		} else {
+			int mid = (l + r) / 2;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+		}
+		return t1;
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (jobl > jobr || i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return siz[i];
+		}
+		int mid = (l + r) / 2;
+		int ret = 0;
+		if (jobl <= mid) {
+			ret += query(jobl, jobr, l, mid, ls[i]);
+		}
+		if (jobr > mid) {
+			ret += query(jobl, jobr, mid + 1, r, rs[i]);
+		}
+		return ret;
+	}
+
+	// 递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa) {
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				dfs1(v, u);
+			}
+		}
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				root[u] = merge(1, cntv, root[u], root[v]);
+			}
+		}
+		ans[u] = query(arr[u] + 1, cntv, 1, cntv, root[u]);
+	}
+
+	public static int[][] ufe = new int[MAXN][3];
+
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// dfs1改的迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+					int v = to[ei];
+					if (v != f) {
+						root[u] = merge(1, cntv, root[u], root[v]);
+					}
+				}
+				ans[u] = query(arr[u] + 1, cntv, 1, cntv, root[u]);
+			}
+		}
+	}
+
+	public static void compute() {
+		for (int i = 1; i <= n; i++) {
+			sorted[i] = arr[i];
+		}
+		Arrays.sort(sorted, 1, n + 1);
+		cntv = 1;
+		for (int i = 2; i <= n; i++) {
+			if (sorted[cntv] != sorted[i]) {
+				sorted[++cntv] = sorted[i];
+			}
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
+		}
+		for (int i = 1; i <= n; i++) {
+			root[i] = insert(arr[i], 1, cntv, root[i]);
+		}
+		// dfs1(1, 0);
+		dfs2();
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 2, fa; i <= n; i++) {
+			fa = in.nextInt();
+			addEdge(fa, i);
+			addEdge(i, fa);
+		}
+		compute();
+		for (int i = 1; i <= n; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class181/Code01_PromotionCounting2.java b/src/class181/Code01_PromotionCounting2.java
new file mode 100644
index 000000000..9f0322682
--- /dev/null
+++ b/src/class181/Code01_PromotionCounting2.java
@@ -0,0 +1,162 @@
+package class181;
+
+// 晋升者计数，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3605
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXT = MAXN * 40;
+//int n;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int arr[MAXN];
+//int sorted[MAXN];
+//int cntv;
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int siz[MAXT];
+//int cntt;
+//
+//int ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//void up(int i) {
+//    siz[i] = siz[ls[i]] + siz[rs[i]];
+//}
+//
+//int insert(int jobi, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = ++cntt;
+//    }
+//    if (l == r) {
+//        siz[rt]++;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2) {
+//    if (t1 == 0 || t2 == 0) {
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        siz[t1] += siz[t2];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//    }
+//    return t1;
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (jobl > jobr || i == 0) {
+//        return 0;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        return siz[i];
+//    }
+//    int mid = (l + r) >> 1;
+//    int ret = 0;
+//    if (jobl <= mid) {
+//        ret += query(jobl, jobr, l, mid, ls[i]);
+//    }
+//    if (jobr > mid) {
+//        ret += query(jobl, jobr, mid + 1, r, rs[i]);
+//    }
+//    return ret;
+//}
+//
+//void dfs(int u, int fa) {
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            dfs(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            root[u] = merge(1, cntv, root[u], root[v]);
+//        }
+//    }
+//    ans[u] = query(arr[u] + 1, cntv, 1, cntv, root[u]);
+//}
+//
+//void compute() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[i] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + n + 1);
+//    cntv = 1;
+//    for (int i = 2; i <= n; i++) {
+//        if (sorted[cntv] != sorted[i]) {
+//            sorted[++cntv] = sorted[i];
+//        }
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        root[i] = insert(arr[i], 1, cntv, root[i]);
+//    }
+//    dfs(1, 0);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 2, fa; i <= n; i++) {
+//        cin >> fa;
+//        addEdge(fa, i);
+//        addEdge(i, fa);
+//    }
+//    compute();
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 9ab33e1b918fd06e2cb2f9487b83cf3e004e46b0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 17 Oct 2025 13:37:34 +0800
Subject: [PATCH 1565/1712] modify code

---
 src/class181/Code01_PromotionCounting1.java | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class181/Code01_PromotionCounting1.java b/src/class181/Code01_PromotionCounting1.java
index 3e1313639..94d26cc2d 100644
--- a/src/class181/Code01_PromotionCounting1.java
+++ b/src/class181/Code01_PromotionCounting1.java
@@ -109,7 +109,7 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 		return ret;
 	}
 
-	// 递归版，java会爆栈，C++可以通过
+	// dfs递归版，java会爆栈，C++可以通过
 	public static void dfs1(int u, int fa) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
@@ -144,7 +144,7 @@ public static void pop() {
 		e = ufe[stacksize][2];
 	}
 
-	// dfs1改的迭代版
+	// dfs1改迭代
 	public static void dfs2() {
 		stacksize = 0;
 		push(1, 0, -1);

From eb58c9ea0703e37f69c9a13dec4c09fead9e6cd6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 17 Oct 2025 17:44:32 +0800
Subject: [PATCH 1566/1712] modify code

---
 src/class181/Code01_PromotionCounting1.java |   8 +-
 src/class181/Code01_PromotionCounting2.java |   8 +-
 src/class181/Code02_TailOfRainyDay1.java    | 302 ++++++++++++++++++++
 3 files changed, 310 insertions(+), 8 deletions(-)
 create mode 100644 src/class181/Code02_TailOfRainyDay1.java

diff --git a/src/class181/Code01_PromotionCounting1.java b/src/class181/Code01_PromotionCounting1.java
index 94d26cc2d..9324ad95d 100644
--- a/src/class181/Code01_PromotionCounting1.java
+++ b/src/class181/Code01_PromotionCounting1.java
@@ -57,7 +57,7 @@ public static void up(int i) {
 		siz[i] = siz[ls[i]] + siz[rs[i]];
 	}
 
-	public static int insert(int jobi, int l, int r, int i) {
+	public static int add(int jobi, int l, int r, int i) {
 		int rt = i;
 		if (rt == 0) {
 			rt = ++cntt;
@@ -67,9 +67,9 @@ public static int insert(int jobi, int l, int r, int i) {
 		} else {
 			int mid = (l + r) / 2;
 			if (jobi <= mid) {
-				ls[rt] = insert(jobi, l, mid, ls[rt]);
+				ls[rt] = add(jobi, l, mid, ls[rt]);
 			} else {
-				rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+				rs[rt] = add(jobi, mid + 1, r, rs[rt]);
 			}
 			up(rt);
 		}
@@ -187,7 +187,7 @@ public static void compute() {
 			arr[i] = kth(arr[i]);
 		}
 		for (int i = 1; i <= n; i++) {
-			root[i] = insert(arr[i], 1, cntv, root[i]);
+			root[i] = add(arr[i], 1, cntv, root[i]);
 		}
 		// dfs1(1, 0);
 		dfs2();
diff --git a/src/class181/Code01_PromotionCounting2.java b/src/class181/Code01_PromotionCounting2.java
index 9f0322682..d6e185c1b 100644
--- a/src/class181/Code01_PromotionCounting2.java
+++ b/src/class181/Code01_PromotionCounting2.java
@@ -54,7 +54,7 @@
 //    siz[i] = siz[ls[i]] + siz[rs[i]];
 //}
 //
-//int insert(int jobi, int l, int r, int i) {
+//int add(int jobi, int l, int r, int i) {
 //    int rt = i;
 //    if (rt == 0) {
 //        rt = ++cntt;
@@ -64,9 +64,9 @@
 //    } else {
 //        int mid = (l + r) >> 1;
 //        if (jobi <= mid) {
-//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//            ls[rt] = add(jobi, l, mid, ls[rt]);
 //        } else {
-//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//            rs[rt] = add(jobi, mid + 1, r, rs[rt]);
 //        }
 //        up(rt);
 //    }
@@ -137,7 +137,7 @@
 //        arr[i] = kth(arr[i]);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        root[i] = insert(arr[i], 1, cntv, root[i]);
+//        root[i] = add(arr[i], 1, cntv, root[i]);
 //    }
 //    dfs(1, 0);
 //}
diff --git a/src/class181/Code02_TailOfRainyDay1.java b/src/class181/Code02_TailOfRainyDay1.java
new file mode 100644
index 000000000..87f7b9172
--- /dev/null
+++ b/src/class181/Code02_TailOfRainyDay1.java
@@ -0,0 +1,302 @@
+package class181;
+
+// 雨天的尾巴，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4556
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code02_TailOfRainyDay1 {
+
+	public static int MAXN = 100001;
+	public static int MAXV = 100000;
+	public static int MAXT = MAXN * 80;
+	public static int MAXP = 20;
+	public static int n, m;
+	public static int[][] query = new int[MAXN][3];
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] dep = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+
+	public static int[] root = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] maxCnt = new int[MAXT];
+	public static int cntt;
+
+	public static int[] ans = new int[MAXN];
+
+	// 递归改迭代需要
+	public static int[][] ufe = new int[MAXN][3];
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	public static void addEdge(int u, int v) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				dfs1(v, u);
+			}
+		}
+	}
+
+	// dfs1改迭代
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXP; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static void up(int i) {
+		maxCnt[i] = Math.max(maxCnt[ls[i]], maxCnt[rs[i]]);
+	}
+
+	public static int add(int jobi, int jobv, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = ++cntt;
+		}
+		if (l == r) {
+			maxCnt[rt] += jobv;
+		} else {
+			int mid = (l + r) / 2;
+			if (jobi <= mid) {
+				ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+			} else {
+				rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			return t1 + t2;
+		}
+		if (l == r) {
+			maxCnt[t1] += maxCnt[t2];
+		} else {
+			int mid = (l + r) / 2;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+		}
+		return t1;
+	}
+
+	public static int query(int l, int r, int i) {
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) / 2;
+		if (maxCnt[i] == maxCnt[ls[i]]) {
+			return query(l, mid, ls[i]);
+		} else {
+			return query(mid + 1, r, rs[i]);
+		}
+	}
+
+	public static void calc1(int u, int fa) {
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				calc1(v, u);
+			}
+		}
+		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+			int v = to[ei];
+			if (v != fa) {
+				root[u] = merge(1, MAXV, root[u], root[v]);
+			}
+		}
+		if (maxCnt[root[u]] > 0) {
+			ans[u] = query(1, MAXV, root[u]);
+		}
+	}
+
+	// calc1改迭代
+	public static void calc2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+					int v = to[ei];
+					if (v != f) {
+						root[u] = merge(1, MAXV, root[u], root[v]);
+					}
+				}
+				if (maxCnt[root[u]] > 0) {
+					ans[u] = query(1, MAXV, root[u]);
+				}
+			}
+		}
+	}
+
+	public static void compute() {
+		// dfs1(1, 0);
+		dfs2();
+		for (int i = 1; i <= m; i++) {
+			int x = query[i][0];
+			int y = query[i][1];
+			int food = query[i][2];
+			int lca = getLca(x, y);
+			int lcafa = stjump[lca][0];
+			root[x] = add(food, 1, 1, MAXV, root[x]);
+			root[y] = add(food, 1, 1, MAXV, root[y]);
+			root[lca] = add(food, -1, 1, MAXV, root[lca]);
+			root[lcafa] = add(food, -1, 1, MAXV, root[lcafa]);
+		}
+		// calc1(1, 0);
+		calc2();
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+			query[i][2] = in.nextInt();
+		}
+		compute();
+		for (int i = 1; i <= n; i++) {
+			out.println(ans[i]);
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 3334becf3bbaf09a8d007c6d3cfa51e003c1a1ec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 17 Oct 2025 22:38:32 +0800
Subject: [PATCH 1567/1712] modify code

---
 .../{Code02_TailOfRainyDay1.java => Code02_RainDayTail1.java} | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)
 rename src/class181/{Code02_TailOfRainyDay1.java => Code02_RainDayTail1.java} (98%)

diff --git a/src/class181/Code02_TailOfRainyDay1.java b/src/class181/Code02_RainDayTail1.java
similarity index 98%
rename from src/class181/Code02_TailOfRainyDay1.java
rename to src/class181/Code02_RainDayTail1.java
index 87f7b9172..10f7b1681 100644
--- a/src/class181/Code02_TailOfRainyDay1.java
+++ b/src/class181/Code02_RainDayTail1.java
@@ -9,11 +9,11 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_TailOfRainyDay1 {
+public class Code02_RainDayTail1 {
 
 	public static int MAXN = 100001;
 	public static int MAXV = 100000;
-	public static int MAXT = MAXN * 80;
+	public static int MAXT = MAXN * 50;
 	public static int MAXP = 20;
 	public static int n, m;
 	public static int[][] query = new int[MAXN][3];

From 86ffcb36e4e7cd38f91a67d2f9ca619cbe3fba27 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Oct 2025 14:49:08 +0800
Subject: [PATCH 1568/1712] modify code

---
 .../{Code02_RainDayTail1.java => Code02_RainyDayTail1.java}     | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)
 rename src/class181/{Code02_RainDayTail1.java => Code02_RainyDayTail1.java} (99%)

diff --git a/src/class181/Code02_RainDayTail1.java b/src/class181/Code02_RainyDayTail1.java
similarity index 99%
rename from src/class181/Code02_RainDayTail1.java
rename to src/class181/Code02_RainyDayTail1.java
index 10f7b1681..0b9c4fe05 100644
--- a/src/class181/Code02_RainDayTail1.java
+++ b/src/class181/Code02_RainyDayTail1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_RainDayTail1 {
+public class Code02_RainyDayTail1 {
 
 	public static int MAXN = 100001;
 	public static int MAXV = 100000;

From 1afa50acf0ebedbddc2743be1ec42aa4e705b0bd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Oct 2025 15:37:58 +0800
Subject: [PATCH 1569/1712] modify code

---
 src/class181/Code01_PromotionCounting1.java |  22 +-
 src/class181/Code01_PromotionCounting2.java |   6 +-
 src/class181/Code02_RainyDayTail1.java      |   8 +-
 src/class181/Code03_LoveRunning1.java       | 308 ++++++++++++++++++++
 4 files changed, 327 insertions(+), 17 deletions(-)
 create mode 100644 src/class181/Code03_LoveRunning1.java

diff --git a/src/class181/Code01_PromotionCounting1.java b/src/class181/Code01_PromotionCounting1.java
index 9324ad95d..bf8c5d47e 100644
--- a/src/class181/Code01_PromotionCounting1.java
+++ b/src/class181/Code01_PromotionCounting1.java
@@ -42,7 +42,7 @@ public static void addEdge(int u, int v) {
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
@@ -65,7 +65,7 @@ public static int add(int jobi, int l, int r, int i) {
 		if (l == r) {
 			siz[rt]++;
 		} else {
-			int mid = (l + r) / 2;
+			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
 				ls[rt] = add(jobi, l, mid, ls[rt]);
 			} else {
@@ -83,7 +83,7 @@ public static int merge(int l, int r, int t1, int t2) {
 		if (l == r) {
 			siz[t1] += siz[t2];
 		} else {
-			int mid = (l + r) / 2;
+			int mid = (l + r) >> 1;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
@@ -98,7 +98,7 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 		if (jobl <= l && r <= jobr) {
 			return siz[i];
 		}
-		int mid = (l + r) / 2;
+		int mid = (l + r) >> 1;
 		int ret = 0;
 		if (jobl <= mid) {
 			ret += query(jobl, jobr, l, mid, ls[i]);
@@ -109,12 +109,12 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 		return ret;
 	}
 
-	// dfs递归版，java会爆栈，C++可以通过
-	public static void dfs1(int u, int fa) {
+	// 递归版，java会爆栈，C++可以通过
+	public static void calc1(int u, int fa) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa) {
-				dfs1(v, u);
+				calc1(v, u);
 			}
 		}
 		for (int e = head[u]; e > 0; e = nxt[e]) {
@@ -144,8 +144,8 @@ public static void pop() {
 		e = ufe[stacksize][2];
 	}
 
-	// dfs1改迭代
-	public static void dfs2() {
+	// calc1改迭代
+	public static void calc2() {
 		stacksize = 0;
 		push(1, 0, -1);
 		while (stacksize > 0) {
@@ -189,8 +189,8 @@ public static void compute() {
 		for (int i = 1; i <= n; i++) {
 			root[i] = add(arr[i], 1, cntv, root[i]);
 		}
-		// dfs1(1, 0);
-		dfs2();
+		// calc1(1, 0);
+		calc2();
 	}
 
 	public static void main(String[] args) throws Exception {
diff --git a/src/class181/Code01_PromotionCounting2.java b/src/class181/Code01_PromotionCounting2.java
index d6e185c1b..ce63ac8b9 100644
--- a/src/class181/Code01_PromotionCounting2.java
+++ b/src/class181/Code01_PromotionCounting2.java
@@ -106,11 +106,11 @@
 //    return ret;
 //}
 //
-//void dfs(int u, int fa) {
+//void calc(int u, int fa) {
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa) {
-//            dfs(v, u);
+//            calc(v, u);
 //        }
 //    }
 //    for (int e = head[u]; e; e = nxt[e]) {
@@ -139,7 +139,7 @@
 //    for (int i = 1; i <= n; i++) {
 //        root[i] = add(arr[i], 1, cntv, root[i]);
 //    }
-//    dfs(1, 0);
+//    calc(1, 0);
 //}
 //
 //int main() {
diff --git a/src/class181/Code02_RainyDayTail1.java b/src/class181/Code02_RainyDayTail1.java
index 0b9c4fe05..9b9052aea 100644
--- a/src/class181/Code02_RainyDayTail1.java
+++ b/src/class181/Code02_RainyDayTail1.java
@@ -58,6 +58,7 @@ public static void addEdge(int u, int v) {
 		head[u] = cntg;
 	}
 
+	// 递归版，java会爆栈，C++可以通过
 	public static void dfs1(int u, int fa) {
 		dep[u] = dep[fa] + 1;
 		stjump[u][0] = fa;
@@ -132,7 +133,7 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 		if (l == r) {
 			maxCnt[rt] += jobv;
 		} else {
-			int mid = (l + r) / 2;
+			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
 				ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
 			} else {
@@ -150,7 +151,7 @@ public static int merge(int l, int r, int t1, int t2) {
 		if (l == r) {
 			maxCnt[t1] += maxCnt[t2];
 		} else {
-			int mid = (l + r) / 2;
+			int mid = (l + r) >> 1;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
@@ -162,7 +163,7 @@ public static int query(int l, int r, int i) {
 		if (l == r) {
 			return l;
 		}
-		int mid = (l + r) / 2;
+		int mid = (l + r) >> 1;
 		if (maxCnt[i] == maxCnt[ls[i]]) {
 			return query(l, mid, ls[i]);
 		} else {
@@ -170,6 +171,7 @@ public static int query(int l, int r, int i) {
 		}
 	}
 
+	// 递归版，java会爆栈，C++可以通过
 	public static void calc1(int u, int fa) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
diff --git a/src/class181/Code03_LoveRunning1.java b/src/class181/Code03_LoveRunning1.java
new file mode 100644
index 000000000..e5c8d5df6
--- /dev/null
+++ b/src/class181/Code03_LoveRunning1.java
@@ -0,0 +1,308 @@
+package class181;
+
+// 天天爱跑步，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P1600
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code03_LoveRunning1 {
+
+	public static int MAXN = 300001;
+	public static int MAXT = MAXN * 50;
+	public static int MAXP = 20;
+	public static int n, m;
+	public static int[] arr = new int[MAXN];
+	public static int[][] query = new int[MAXN][2];
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] dep = new int[MAXN];
+	public static int[][] stjump = new int[MAXN][MAXP];
+
+	public static int[] rootl = new int[MAXN];
+	public static int[] rootr = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] sum = new int[MAXT];
+	public static int cntt;
+
+	public static int[] ans = new int[MAXN];
+
+	// 递归改迭代需要
+	public static int[][] ufe = new int[MAXN][3];
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	public static void addEdge(int u, int v) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	// 递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		stjump[u][0] = fa;
+		for (int p = 1; p < MAXP; p++) {
+			stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+		}
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				dfs1(v, u);
+			}
+		}
+	}
+
+	// dfs1改迭代
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				stjump[u][0] = f;
+				for (int p = 1; p < MAXP; p++) {
+					stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+				}
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			}
+		}
+	}
+
+	public static int getLca(int a, int b) {
+		if (dep[a] < dep[b]) {
+			int tmp = a;
+			a = b;
+			b = tmp;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (dep[stjump[a][p]] >= dep[b]) {
+				a = stjump[a][p];
+			}
+		}
+		if (a == b) {
+			return a;
+		}
+		for (int p = MAXP - 1; p >= 0; p--) {
+			if (stjump[a][p] != stjump[b][p]) {
+				a = stjump[a][p];
+				b = stjump[b][p];
+			}
+		}
+		return stjump[a][0];
+	}
+
+	public static void up(int i) {
+		sum[i] = sum[ls[i]] + sum[rs[i]];
+	}
+
+	public static int add(int jobi, int jobv, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = ++cntt;
+		}
+		if (l == r) {
+			sum[rt] += jobv;
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+			} else {
+				rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			return t1 + t2;
+		}
+		if (l == r) {
+			sum[t1] += sum[t2];
+		} else {
+			int mid = (l + r) >> 1;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+		}
+		return t1;
+	}
+
+	public static int query(int jobi, int l, int r, int i) {
+		if (jobi < l || jobi > r || i == 0) {
+			return 0;
+		}
+		if (l == r) {
+			return sum[i];
+		}
+		int mid = (l + r) >> 1;
+		if (jobi <= mid) {
+			return query(jobi, l, mid, ls[i]);
+		} else {
+			return query(jobi, mid + 1, r, rs[i]);
+		}
+	}
+
+	// 递归版，java会爆栈，C++可以通过
+	public static void calc1(int u, int fa) {
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				calc1(v, u);
+			}
+		}
+		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+			int v = to[ei];
+			if (v != fa) {
+				rootl[u] = merge(1, n, rootl[u], rootl[v]);
+				rootr[u] = merge(-n, n, rootr[u], rootr[v]);
+			}
+		}
+		ans[u] = query(dep[u] + arr[u], 1, n, rootl[u]) + query(dep[u] - arr[u], -n, n, rootr[u]);
+	}
+
+	// calc1改迭代
+	public static void calc2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+					int v = to[ei];
+					if (v != f) {
+						rootl[u] = merge(1, n, rootl[u], rootl[v]);
+						rootr[u] = merge(-n, n, rootr[u], rootr[v]);
+					}
+				}
+				ans[u] = query(dep[u] + arr[u], 1, n, rootl[u]) + query(dep[u] - arr[u], -n, n, rootr[u]);
+			}
+		}
+	}
+
+	public static void compute() {
+		// dfs1(1, 0);
+		dfs2();
+		for (int i = 1; i <= m; i++) {
+			int x = query[i][0];
+			int y = query[i][1];
+			int lca = getLca(x, y);
+			int lcafa = stjump[lca][0];
+			rootl[x] = add(dep[x], 1, 1, n, rootl[x]);
+			rootl[lca] = add(dep[x], -1, 1, n, rootl[lca]);
+			rootr[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rootr[y]);
+			rootr[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rootr[lcafa]);
+		}
+		// calc1(1, 0);
+		calc2();
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i][0] = in.nextInt();
+			query[i][1] = in.nextInt();
+		}
+		compute();
+		for (int i = 1; i <= n; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 5dafcdbb3645efc4fe6b6c5e013374fc4cd66cef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Oct 2025 15:55:25 +0800
Subject: [PATCH 1570/1712] modify code

---
 src/class176/Code04_BloodyString1.java      | 2 +-
 src/class176/Code08_MachineLearning1.java   | 2 +-
 src/class177/Code01_MoAddUndo1.java         | 2 +-
 src/class177/Code02_ThresholdMajority1.java | 2 +-
 src/class177/Code03_SameNumberMaxDist1.java | 2 +-
 src/class177/Code04_ZeroQuery1.java         | 2 +-
 src/class177/Code07_MoOnTree1.java          | 2 +-
 src/class177/Code07_MoOnTree2.java          | 2 +-
 src/class178/Code02_OfflineInversion1.java  | 2 +-
 src/class179/Code03_LCP1.java               | 2 +-
 10 files changed, 10 insertions(+), 10 deletions(-)

diff --git a/src/class176/Code04_BloodyString1.java b/src/class176/Code04_BloodyString1.java
index 77e842ffb..ebc8d6044 100644
--- a/src/class176/Code04_BloodyString1.java
+++ b/src/class176/Code04_BloodyString1.java
@@ -48,7 +48,7 @@ public int compare(int[] a, int[] b) {
 	public static int kth(int len, int num) {
 		int left = 1, right = len, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
diff --git a/src/class176/Code08_MachineLearning1.java b/src/class176/Code08_MachineLearning1.java
index dde8f622f..0f24823c4 100644
--- a/src/class176/Code08_MachineLearning1.java
+++ b/src/class176/Code08_MachineLearning1.java
@@ -53,7 +53,7 @@ public int compare(int[] a, int[] b) {
 	public static int kth(int len, int num) {
 		int left = 1, right = len, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
diff --git a/src/class177/Code01_MoAddUndo1.java b/src/class177/Code01_MoAddUndo1.java
index 30bdb5a71..51984ed57 100644
--- a/src/class177/Code01_MoAddUndo1.java
+++ b/src/class177/Code01_MoAddUndo1.java
@@ -56,7 +56,7 @@ public int compare(int[] a, int[] b) {
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
diff --git a/src/class177/Code02_ThresholdMajority1.java b/src/class177/Code02_ThresholdMajority1.java
index e6d3a1bd9..c0bddda48 100644
--- a/src/class177/Code02_ThresholdMajority1.java
+++ b/src/class177/Code02_ThresholdMajority1.java
@@ -51,7 +51,7 @@ public int compare(int[] a, int[] b) {
 		public static int kth(int num) {
 			int left = 1, right = cntv, mid, ret = 0;
 			while (left <= right) {
-				mid = (left + right) / 2;
+				mid = (left + right) >> 1;
 				if (sorted[mid] <= num) {
 					ret = mid;
 					left = mid + 1;
diff --git a/src/class177/Code03_SameNumberMaxDist1.java b/src/class177/Code03_SameNumberMaxDist1.java
index a28a9afbb..b39f0c71d 100644
--- a/src/class177/Code03_SameNumberMaxDist1.java
+++ b/src/class177/Code03_SameNumberMaxDist1.java
@@ -54,7 +54,7 @@ public int compare(int[] a, int[] b) {
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
diff --git a/src/class177/Code04_ZeroQuery1.java b/src/class177/Code04_ZeroQuery1.java
index 88c31b2f8..ed2d5a4a9 100644
--- a/src/class177/Code04_ZeroQuery1.java
+++ b/src/class177/Code04_ZeroQuery1.java
@@ -50,7 +50,7 @@ public int compare(int[] a, int[] b) {
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
diff --git a/src/class177/Code07_MoOnTree1.java b/src/class177/Code07_MoOnTree1.java
index 0533df402..095b90b32 100644
--- a/src/class177/Code07_MoOnTree1.java
+++ b/src/class177/Code07_MoOnTree1.java
@@ -73,7 +73,7 @@ public static void addEdge(int u, int v) {
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
diff --git a/src/class177/Code07_MoOnTree2.java b/src/class177/Code07_MoOnTree2.java
index 31201b655..c4e515538 100644
--- a/src/class177/Code07_MoOnTree2.java
+++ b/src/class177/Code07_MoOnTree2.java
@@ -59,7 +59,7 @@
 //int kth(int num) {
 //    int left = 1, right = cntv, mid, ret = 0;
 //    while (left <= right) {
-//        mid = (left + right) / 2;
+//        mid = (left + right) >> 1;
 //        if (sorted[mid] <= num) {
 //            ret = mid;
 //            left = mid + 1;
diff --git a/src/class178/Code02_OfflineInversion1.java b/src/class178/Code02_OfflineInversion1.java
index 2b660f744..d032bdcd3 100644
--- a/src/class178/Code02_OfflineInversion1.java
+++ b/src/class178/Code02_OfflineInversion1.java
@@ -70,7 +70,7 @@ public int compare(int[] a, int[] b) {
 	public static int kth(int num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;
diff --git a/src/class179/Code03_LCP1.java b/src/class179/Code03_LCP1.java
index 7991882f0..6eed590cf 100644
--- a/src/class179/Code03_LCP1.java
+++ b/src/class179/Code03_LCP1.java
@@ -44,7 +44,7 @@ public class Code03_LCP1 {
 	public static int kth(long num) {
 		int left = 1, right = cntv, mid, ret = 0;
 		while (left <= right) {
-			mid = (left + right) / 2;
+			mid = (left + right) >> 1;
 			if (sorted[mid] <= num) {
 				ret = mid;
 				left = mid + 1;

From 90872a29fa16b005f91765e4359940dd41f2a4fc Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 19 Oct 2025 21:38:20 +0800
Subject: [PATCH 1571/1712] modify code

---
 src/class181/Code02_RainyDayTail1.java |  36 ++---
 src/class181/Code03_LoveRunning1.java  |  33 ++---
 src/class181/Code04_NeverLand1.java    | 196 +++++++++++++++++++++++++
 3 files changed, 221 insertions(+), 44 deletions(-)
 create mode 100644 src/class181/Code04_NeverLand1.java

diff --git a/src/class181/Code02_RainyDayTail1.java b/src/class181/Code02_RainyDayTail1.java
index 9b9052aea..952a33774 100644
--- a/src/class181/Code02_RainyDayTail1.java
+++ b/src/class181/Code02_RainyDayTail1.java
@@ -16,7 +16,6 @@ public class Code02_RainyDayTail1 {
 	public static int MAXT = MAXN * 50;
 	public static int MAXP = 20;
 	public static int n, m;
-	public static int[][] query = new int[MAXN][3];
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -220,24 +219,6 @@ public static void calc2() {
 		}
 	}
 
-	public static void compute() {
-		// dfs1(1, 0);
-		dfs2();
-		for (int i = 1; i <= m; i++) {
-			int x = query[i][0];
-			int y = query[i][1];
-			int food = query[i][2];
-			int lca = getLca(x, y);
-			int lcafa = stjump[lca][0];
-			root[x] = add(food, 1, 1, MAXV, root[x]);
-			root[y] = add(food, 1, 1, MAXV, root[y]);
-			root[lca] = add(food, -1, 1, MAXV, root[lca]);
-			root[lcafa] = add(food, -1, 1, MAXV, root[lcafa]);
-		}
-		// calc1(1, 0);
-		calc2();
-	}
-
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -249,12 +230,21 @@ public static void main(String[] args) throws Exception {
 			addEdge(u, v);
 			addEdge(v, u);
 		}
+		// dfs1(1, 0);
+		dfs2();
 		for (int i = 1; i <= m; i++) {
-			query[i][0] = in.nextInt();
-			query[i][1] = in.nextInt();
-			query[i][2] = in.nextInt();
+			int x = in.nextInt();
+			int y = in.nextInt();
+			int food = in.nextInt();
+			int lca = getLca(x, y);
+			int lcafa = stjump[lca][0];
+			root[x] = add(food, 1, 1, MAXV, root[x]);
+			root[y] = add(food, 1, 1, MAXV, root[y]);
+			root[lca] = add(food, -1, 1, MAXV, root[lca]);
+			root[lcafa] = add(food, -1, 1, MAXV, root[lcafa]);
 		}
-		compute();
+		// calc1(1, 0);
+		calc2();
 		for (int i = 1; i <= n; i++) {
 			out.println(ans[i]);
 		}
diff --git a/src/class181/Code03_LoveRunning1.java b/src/class181/Code03_LoveRunning1.java
index e5c8d5df6..cf1b557b5 100644
--- a/src/class181/Code03_LoveRunning1.java
+++ b/src/class181/Code03_LoveRunning1.java
@@ -16,7 +16,6 @@ public class Code03_LoveRunning1 {
 	public static int MAXP = 20;
 	public static int n, m;
 	public static int[] arr = new int[MAXN];
-	public static int[][] query = new int[MAXN][2];
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -222,23 +221,6 @@ public static void calc2() {
 		}
 	}
 
-	public static void compute() {
-		// dfs1(1, 0);
-		dfs2();
-		for (int i = 1; i <= m; i++) {
-			int x = query[i][0];
-			int y = query[i][1];
-			int lca = getLca(x, y);
-			int lcafa = stjump[lca][0];
-			rootl[x] = add(dep[x], 1, 1, n, rootl[x]);
-			rootl[lca] = add(dep[x], -1, 1, n, rootl[lca]);
-			rootr[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rootr[y]);
-			rootr[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rootr[lcafa]);
-		}
-		// calc1(1, 0);
-		calc2();
-	}
-
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
@@ -253,11 +235,20 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
+		// dfs1(1, 0);
+		dfs2();
 		for (int i = 1; i <= m; i++) {
-			query[i][0] = in.nextInt();
-			query[i][1] = in.nextInt();
+			int x = in.nextInt();
+			int y = in.nextInt();
+			int lca = getLca(x, y);
+			int lcafa = stjump[lca][0];
+			rootl[x] = add(dep[x], 1, 1, n, rootl[x]);
+			rootl[lca] = add(dep[x], -1, 1, n, rootl[lca]);
+			rootr[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rootr[y]);
+			rootr[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rootr[lcafa]);
 		}
-		compute();
+		// calc1(1, 0);
+		calc2();
 		for (int i = 1; i <= n; i++) {
 			out.print(ans[i] + " ");
 		}
diff --git a/src/class181/Code04_NeverLand1.java b/src/class181/Code04_NeverLand1.java
new file mode 100644
index 000000000..b6134e501
--- /dev/null
+++ b/src/class181/Code04_NeverLand1.java
@@ -0,0 +1,196 @@
+package class181;
+
+// 永无乡，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3224
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code04_NeverLand1 {
+
+	public static int MAXN = 100001;
+	public static int MAXT = MAXN * 40;
+	public static int n, m, q;
+	public static int[] pos = new int[MAXN];
+
+	public static int[] root = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] sum = new int[MAXT];
+	public static int cntt;
+
+	public static int[] father = new int[MAXN];
+
+	public static void up(int i) {
+		sum[i] = sum[ls[i]] + sum[rs[i]];
+	}
+
+	public static int add(int jobi, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = ++cntt;
+		}
+		if (l == r) {
+			sum[rt]++;
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = add(jobi, l, mid, ls[rt]);
+			} else {
+				rs[rt] = add(jobi, mid + 1, r, rs[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			return t1 + t2;
+		}
+		if (l == r) {
+			sum[t1] += sum[t2];
+		} else {
+			int mid = (l + r) >> 1;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+		}
+		return t1;
+	}
+
+	public static int query(int jobk, int l, int r, int i) {
+		if (i == 0 || jobk > sum[i]) {
+			return -1;
+		}
+		if (l == r) {
+			return pos[l];
+		}
+		int mid = (l + r) >> 1;
+		if (sum[ls[i]] >= jobk) {
+			return query(jobk, l, mid, ls[i]);
+		} else {
+			return query(jobk - sum[ls[i]], mid + 1, r, rs[i]);
+		}
+	}
+
+	public static int find(int i) {
+		if (i != father[i]) {
+			father[i] = find(father[i]);
+		}
+		return father[i];
+	}
+
+	public static void union(int x, int y) {
+		int xfa = find(x);
+		int yfa = find(y);
+		if (xfa != yfa) {
+			father[xfa] = yfa;
+			root[yfa] = merge(1, n, root[yfa], root[xfa]);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader();
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		int num;
+		for (int i = 1; i <= n; i++) {
+			num = in.nextInt();
+			pos[num] = i;
+			father[i] = i;
+			root[i] = add(num, 1, n, root[i]);
+		}
+		for (int i = 1, x, y; i <= m; i++) {
+			x = in.nextInt();
+			y = in.nextInt();
+			union(x, y);
+		}
+		q = in.nextInt();
+		char op;
+		int x, y, k;
+		for (int i = 1; i <= q; i++) {
+			op = in.nextChar();
+			if (op == 'B') {
+				x = in.nextInt();
+				y = in.nextInt();
+				union(x, y);
+			} else {
+				x = in.nextInt();
+				k = in.nextInt();
+				out.println(query(k, 1, n, root[find(x)]));
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		final private int BUFFER_SIZE = 1 << 16;
+		private final InputStream in;
+		private final byte[] buffer;
+		private int ptr, len;
+
+		public FastReader() {
+			in = System.in;
+			buffer = new byte[BUFFER_SIZE];
+			ptr = len = 0;
+		}
+
+		private boolean hasNextByte() throws IOException {
+			if (ptr < len)
+				return true;
+			ptr = 0;
+			len = in.read(buffer);
+			return len > 0;
+		}
+
+		private byte readByte() throws IOException {
+			if (!hasNextByte())
+				return -1;
+			return buffer[ptr++];
+		}
+
+		public char nextChar() throws IOException {
+			byte c;
+			do {
+				c = readByte();
+				if (c == -1)
+					return 0;
+			} while (c <= ' ');
+			char ans = 0;
+			while (c > ' ') {
+				ans = (char) c;
+				c = readByte();
+			}
+			return ans;
+		}
+
+		public int nextInt() throws IOException {
+			int num = 0;
+			byte b = readByte();
+			while (isWhitespace(b))
+				b = readByte();
+			boolean minus = false;
+			if (b == '-') {
+				minus = true;
+				b = readByte();
+			}
+			while (!isWhitespace(b) && b != -1) {
+				num = num * 10 + (b - '0');
+				b = readByte();
+			}
+			return minus ? -num : num;
+		}
+
+		private boolean isWhitespace(byte b) {
+			return b == ' ' || b == '\n' || b == '\r' || b == '\t';
+		}
+	}
+
+}

From 3781315fc047d8d92736953efcb229a07a38a7e4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Oct 2025 15:04:41 +0800
Subject: [PATCH 1572/1712] modify code

---
 src/class181/Code05_LeadersGroup1.java | 187 +++++++++++++++++++++++++
 1 file changed, 187 insertions(+)
 create mode 100644 src/class181/Code05_LeadersGroup1.java

diff --git a/src/class181/Code05_LeadersGroup1.java b/src/class181/Code05_LeadersGroup1.java
new file mode 100644
index 000000000..ffe86c5fd
--- /dev/null
+++ b/src/class181/Code05_LeadersGroup1.java
@@ -0,0 +1,187 @@
+package class181;
+
+// 领导集团问题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4577
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code05_LeadersGroup1 {
+
+	public static int MAXN = 200001;
+	public static int MAXV = 1000000000;
+	public static int MAXT = MAXN * 40;
+	public static int n;
+	public static int[] arr = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN];
+	public static int[] to = new int[MAXN];
+	public static int cntg;
+
+	public static int[] root = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] max = new int[MAXT];
+	// 懒更新信息，不是对整个区间加，而是对已存在的节点统一加
+	public static int[] addTag = new int[MAXT];
+	public static int cntt;
+
+	public static void addEdge(int u, int v) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void up(int i) {
+		max[i] = Math.max(max[ls[i]], max[rs[i]]);
+	}
+
+	public static void lazy(int i, int v) {
+		if (i != 0) {
+			max[i] += v;
+			addTag[i] += v;
+		}
+	}
+
+	public static void down(int i) {
+		if (addTag[i] > 0) {
+			lazy(ls[i], addTag[i]);
+			lazy(rs[i], addTag[i]);
+			addTag[i] = 0;
+		}
+	}
+
+	public static int add(int jobi, int jobv, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = ++cntt;
+		}
+		if (l == r) {
+			max[rt] = Math.max(max[rt], jobv);
+		} else {
+			down(rt);
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+			} else {
+				rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2, int t1max, int t2max) {
+		if (t1 == 0 || t2 == 0) {
+			if (t1 != 0) {
+				lazy(t1, t2max);
+			}
+			if (t2 != 0) {
+				lazy(t2, t1max);
+			}
+			return t1 + t2;
+		}
+		if (l == r) {
+			max[t1] = Math.max(max[t1], t1max) + Math.max(max[t2], t2max);
+		} else {
+			down(t1);
+			down(t2);
+			int mid = (l + r) >> 1;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2], Math.max(max[rs[t1]], t1max), Math.max(max[rs[t2]], t2max));
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], t1max, t2max);
+			up(t1);
+		}
+		return t1;
+	}
+
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return max[i];
+		}
+		down(i);
+		int mid = (l + r) >> 1;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans = Math.max(ans, query(jobl, jobr, l, mid, ls[i]));
+		}
+		if (jobr > mid) {
+			ans = Math.max(ans, query(jobl, jobr, mid + 1, r, rs[i]));
+		}
+		return ans;
+	}
+
+	public static void dp(int u) {
+		int val = 1;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			dp(v);
+			val += query(arr[u], MAXV, 1, MAXV, root[v]);
+			root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
+		}
+		root[u] = add(arr[u], val, 1, MAXV, root[u]);
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		for (int i = 2, fa; i <= n; i++) {
+			fa = in.nextInt();
+			addEdge(fa, i);
+		}
+		dp(1);
+		out.println(max[root[1]]);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From 3284681a2e5eef3c4cf9b3f9064e2f7990776824 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Oct 2025 15:10:33 +0800
Subject: [PATCH 1573/1712] modify code

---
 src/class181/Code05_LeadersGroup1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class181/Code05_LeadersGroup1.java b/src/class181/Code05_LeadersGroup1.java
index ffe86c5fd..60b3c71ac 100644
--- a/src/class181/Code05_LeadersGroup1.java
+++ b/src/class181/Code05_LeadersGroup1.java
@@ -41,6 +41,9 @@ public static void up(int i) {
 	}
 
 	public static void lazy(int i, int v) {
+		// 如果区间信息不存在
+		// 说明没有插入过节点
+		// 那么无需保留懒信息
 		if (i != 0) {
 			max[i] += v;
 			addTag[i] += v;

From d4f001a366ac845de447c65ca00b0edbbd97354c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Oct 2025 17:02:10 +0800
Subject: [PATCH 1574/1712] modify code

---
 src/class181/Code05_LeadersGroup1.java | 17 +++++++----------
 1 file changed, 7 insertions(+), 10 deletions(-)

diff --git a/src/class181/Code05_LeadersGroup1.java b/src/class181/Code05_LeadersGroup1.java
index 60b3c71ac..e1e59c659 100644
--- a/src/class181/Code05_LeadersGroup1.java
+++ b/src/class181/Code05_LeadersGroup1.java
@@ -26,7 +26,6 @@ public class Code05_LeadersGroup1 {
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static int[] max = new int[MAXT];
-	// 懒更新信息，不是对整个区间加，而是对已存在的节点统一加
 	public static int[] addTag = new int[MAXT];
 	public static int cntt;
 
@@ -41,9 +40,7 @@ public static void up(int i) {
 	}
 
 	public static void lazy(int i, int v) {
-		// 如果区间信息不存在
-		// 说明没有插入过节点
-		// 那么无需保留懒信息
+		// 如果区间信息不存在，说明没有建立过dp信息，那么不需要加v
 		if (i != 0) {
 			max[i] += v;
 			addTag[i] += v;
@@ -78,24 +75,24 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static int merge(int l, int r, int t1, int t2, int t1max, int t2max) {
+	public static int merge(int l, int r, int t1, int t2, int rmax1, int rmax2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
-				lazy(t1, t2max);
+				lazy(t1, rmax2);
 			}
 			if (t2 != 0) {
-				lazy(t2, t1max);
+				lazy(t2, rmax1);
 			}
 			return t1 + t2;
 		}
 		if (l == r) {
-			max[t1] = Math.max(max[t1], t1max) + Math.max(max[t2], t2max);
+			max[t1] = Math.max(max[t1], rmax1) + Math.max(max[t2], rmax2);
 		} else {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			ls[t1] = merge(l, mid, ls[t1], ls[t2], Math.max(max[rs[t1]], t1max), Math.max(max[rs[t2]], t2max));
-			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], t1max, t2max);
+			ls[t1] = merge(l, mid, ls[t1], ls[t2], Math.max(max[rs[t1]], rmax1), Math.max(max[rs[t2]], rmax2));
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], rmax1, rmax2);
 			up(t1);
 		}
 		return t1;

From 36408b63f71874b049f61f896ad80a524e115f86 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Oct 2025 21:26:54 +0800
Subject: [PATCH 1575/1712] modify code

---
 .../{Code05_LeadersGroup1.java => Code01_LeadersGroup1.java}      | 0
 1 file changed, 0 insertions(+), 0 deletions(-)
 rename src/class181/{Code05_LeadersGroup1.java => Code01_LeadersGroup1.java} (100%)

diff --git a/src/class181/Code05_LeadersGroup1.java b/src/class181/Code01_LeadersGroup1.java
similarity index 100%
rename from src/class181/Code05_LeadersGroup1.java
rename to src/class181/Code01_LeadersGroup1.java

From c903779aac984f1c0ff136ba325635f059fd660b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 20 Oct 2025 21:27:00 +0800
Subject: [PATCH 1576/1712] modify code

---
 src/class181/Code05_MinimizeInversion1.java   | 130 ++++++++++++++++++
 src/class181/Code05_MinimizeInversion2.java   |  82 +++++++++++
 .../Code01_LeadersGroup1.java                 |   4 +-
 3 files changed, 214 insertions(+), 2 deletions(-)
 create mode 100644 src/class181/Code05_MinimizeInversion1.java
 create mode 100644 src/class181/Code05_MinimizeInversion2.java
 rename src/{class181 => class182}/Code01_LeadersGroup1.java (98%)

diff --git a/src/class181/Code05_MinimizeInversion1.java b/src/class181/Code05_MinimizeInversion1.java
new file mode 100644
index 000000000..aaabdb116
--- /dev/null
+++ b/src/class181/Code05_MinimizeInversion1.java
@@ -0,0 +1,130 @@
+package class181;
+
+// 最小化逆序对，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3521
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code05_MinimizeInversion2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code05_MinimizeInversion1 {
+
+	public static int MAXT = 5000001;
+	public static int n;
+
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] siz = new int[MAXT];
+	public static int cntt;
+
+	public static long ans, u, v;
+
+	public static void up(int i) {
+		siz[i] = siz[ls[i]] + siz[rs[i]];
+	}
+
+	public static int build(int jobi, int l, int r) {
+		int rt = ++cntt;
+		if (l == r) {
+			siz[rt]++;
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = build(jobi, l, mid);
+			} else {
+				rs[rt] = build(jobi, mid + 1, r);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			return t1 + t2;
+		}
+		if (l == r) {
+			siz[t1] += siz[t2];
+		} else {
+			u += (long) siz[rs[t1]] * siz[ls[t2]];
+			v += (long) siz[ls[t1]] * siz[rs[t2]];
+			int mid = (l + r) >> 1;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+		}
+		return t1;
+	}
+
+	public static int dfs() throws IOException {
+		int rt;
+		int val = in.nextInt();
+		if (val == 0) {
+			int left = dfs();
+			int right = dfs();
+			u = v = 0;
+			rt = merge(1, n, left, right);
+			ans += Math.min(u, v);
+		} else {
+			rt = build(val, 1, n);
+		}
+		return rt;
+	}
+
+	public static FastReader in = new FastReader(System.in);
+
+	public static PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+
+	public static void main(String[] args) throws Exception {
+		n = in.nextInt();
+		dfs();
+		out.println(ans);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class181/Code05_MinimizeInversion2.java b/src/class181/Code05_MinimizeInversion2.java
new file mode 100644
index 000000000..a075d1bf1
--- /dev/null
+++ b/src/class181/Code05_MinimizeInversion2.java
@@ -0,0 +1,82 @@
+package class181;
+
+// 最小化逆序对，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3521
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXT = 5000001;
+//int n;
+//
+//int ls[MAXT];
+//int rs[MAXT];
+//int siz[MAXT];
+//int cntt;
+//
+//long long ans, u, v;
+//
+//void up(int i) {
+//    siz[i] = siz[ls[i]] + siz[rs[i]];
+//}
+//
+//int build(int jobi, int l, int r) {
+//    int rt = ++cntt;
+//    if (l == r) {
+//        siz[rt]++;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = build(jobi, l, mid);
+//        } else {
+//            rs[rt] = build(jobi, mid + 1, r);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2) {
+//    if (t1 == 0 || t2 == 0) {
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        siz[t1] += siz[t2];
+//    } else {
+//        u += 1LL * siz[rs[t1]] * siz[ls[t2]];
+//        v += 1LL * siz[ls[t1]] * siz[rs[t2]];
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//    }
+//    return t1;
+//}
+//
+//int dfs() {
+//    int rt;
+//    int val;
+//    cin >> val;
+//    if (val == 0) {
+//        int left = dfs();
+//        int right = dfs();
+//        u = v = 0;
+//        rt = merge(1, n, left, right);
+//        ans += min(u, v);
+//    } else {
+//        rt = build(val, 1, n);
+//    }
+//    return rt;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    dfs();
+//    cout << ans << '\n';
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class181/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
similarity index 98%
rename from src/class181/Code01_LeadersGroup1.java
rename to src/class182/Code01_LeadersGroup1.java
index e1e59c659..fc8c50922 100644
--- a/src/class181/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -1,4 +1,4 @@
-package class181;
+package class182;
 
 // 领导集团问题，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4577
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_LeadersGroup1 {
+public class Code01_LeadersGroup1 {
 
 	public static int MAXN = 200001;
 	public static int MAXV = 1000000000;

From f77b98264be7c650b56dfd876c133a28285ff888 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Oct 2025 11:50:44 +0800
Subject: [PATCH 1577/1712] modify code

---
 src/class182/Code02_Minimax1.java | 251 ++++++++++++++++++++++++++++++
 src/class182/Code02_Minimax2.java | 204 ++++++++++++++++++++++++
 2 files changed, 455 insertions(+)
 create mode 100644 src/class182/Code02_Minimax1.java
 create mode 100644 src/class182/Code02_Minimax2.java

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
new file mode 100644
index 000000000..c34be7940
--- /dev/null
+++ b/src/class182/Code02_Minimax1.java
@@ -0,0 +1,251 @@
+package class182;
+
+// 根节点的概率问题，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5298
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code02_Minimax2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
+public class Code02_Minimax1 {
+
+	public static int MAXN = 300001;
+	public static int MAXT = MAXN * 40;
+	public static int MOD = 998244353;
+	public static int n;
+
+	public static int[] fa = new int[MAXN];
+	public static int[] val = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
+
+	public static int[] childCnt = new int[MAXN];
+	public static int[][] child = new int[MAXN][2];
+
+	public static int[] root = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static long[] sum = new long[MAXT];
+	public static long[] mul = new long[MAXT];
+	public static int cntt;
+
+	public static long[] d = new long[MAXN];
+
+	public static long power(long x, int p) {
+		long ans = 1;
+		while (p != 0) {
+			if ((p & 1) != 0) {
+				ans = ans * x % MOD;
+			}
+			p >>= 1;
+			x = x * x % MOD;
+		}
+		return ans;
+	}
+
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) >> 1;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
+	public static void up(int i) {
+		sum[i] = (sum[ls[i]] + sum[rs[i]]) % MOD;
+	}
+
+	public static void lazy(int i, long v) {
+		if (i != 0) {
+			sum[i] = sum[i] * v % MOD;
+			mul[i] = mul[i] * v % MOD;
+		}
+	}
+
+	public static void down(int i) {
+		if (mul[i] != 1) {
+			lazy(ls[i], mul[i]);
+			lazy(rs[i], mul[i]);
+			mul[i] = 1;
+		}
+	}
+
+	public static int update(int jobi, int jobv, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = ++cntt;
+			mul[rt] = 1;
+		}
+		if (l == r) {
+			sum[rt] = jobv % MOD;
+		} else {
+			down(rt);
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+			} else {
+				rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2, long mul1, long mul2, long v) {
+		if (t1 == 0 || t2 == 0) {
+			if (t1 != 0) {
+				lazy(t1, mul1);
+			}
+			if (t2 != 0) {
+				lazy(t2, mul2);
+			}
+			return t1 + t2;
+		}
+		down(t1);
+		down(t2);
+		int mid = (l + r) >> 1;
+		int ls1 = ls[t1];
+		int rs1 = rs[t1];
+		int ls2 = ls[t2];
+		int rs2 = rs[t2];
+		long lsum1 = sum[ls1];
+		long rsum1 = sum[rs1];
+		long lsum2 = sum[ls2];
+		long rsum2 = sum[rs2];
+		long tmp = (1 - v + MOD) % MOD;
+		ls[t1] = merge(l, mid, ls1, ls2, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD, v);
+		rs[t1] = merge(mid + 1, r, rs1, rs2, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD, v);
+		up(t1);
+		return t1;
+	}
+
+	public static void dfs(int u) {
+		if (childCnt[u] == 0) {
+			root[u] = update(val[u], 1, 1, cntv, root[u]);
+		} else if (childCnt[u] == 1) {
+			dfs(child[u][0]);
+			root[u] = root[child[u][0]];
+		} else {
+			dfs(child[u][0]);
+			dfs(child[u][1]);
+			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], 0, 0, val[u]);
+		}
+	}
+
+	public static void getd(int l, int r, int i) {
+		if (i == 0) {
+			return;
+		}
+		if (l == r) {
+			d[l] = sum[i] % MOD;
+		} else {
+			down(i);
+			int mid = (l + r) >> 1;
+			getd(l, mid, ls[i]);
+			getd(mid + 1, r, rs[i]);
+		}
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			if (fa[i] != 0) {
+				child[fa[i]][childCnt[fa[i]]++] = i;
+			}
+		}
+		long inv = power(10000, MOD - 2);
+		for (int i = 1; i <= n; i++) {
+			if (childCnt[i] == 0) {
+				sorted[++cntv] = val[i];
+			} else {
+				val[i] = (int) (inv * val[i] % MOD);
+			}
+		}
+		Arrays.sort(sorted, 1, cntv + 1);
+		int len = 1;
+		for (int i = 2; i <= cntv; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		cntv = len;
+		for (int i = 1; i <= n; i++) {
+			if (childCnt[i] == 0) {
+				val[i] = kth(val[i]);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			fa[i] = in.nextInt();
+		}
+		for (int i = 1; i <= n; i++) {
+			val[i] = in.nextInt();
+		}
+		prepare();
+		dfs(1);
+		getd(1, cntv, root[1]);
+		long ans = 0;
+		for (int i = 1; i <= cntv; i++) {
+			ans = (ans + 1L * i * sorted[i] % MOD * d[i] % MOD * d[i]) % MOD;
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
new file mode 100644
index 000000000..176f36160
--- /dev/null
+++ b/src/class182/Code02_Minimax2.java
@@ -0,0 +1,204 @@
+package class182;
+
+// 根节点的概率问题，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5298
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//const int MAXT = MAXN * 40;
+//const int MOD = 998244353;
+//int n;
+//
+//int fa[MAXN];
+//int val[MAXN];
+//int sorted[MAXN];
+//int cntv;
+//
+//int childCnt[MAXN];
+//int child[MAXN][2];
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int cntt;
+//
+//long long sum[MAXT];
+//long long mul[MAXT];
+//
+//long long d[MAXN];
+//
+//long long power(long long x, int p) {
+//    long long ans = 1;
+//    while (p) {
+//        if (p & 1) {
+//            ans = ans * x % MOD;
+//        }
+//        x = x * x % MOD;
+//        p >>= 1;
+//    }
+//    return ans;
+//}
+//
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
+//void up(int i) {
+//	sum[i] = (sum[ls[i]] + sum[rs[i]]) % MOD;
+//}
+//
+//void lazy(int i, long long v) {
+//    if (i) {
+//    	sum[i] = sum[i] * v % MOD;
+//        mul[i] = mul[i] * v % MOD;
+//    }
+//}
+//
+//void down(int i) {
+//    if (mul[i] != 1) {
+//        lazy(ls[i], mul[i]);
+//        lazy(rs[i], mul[i]);
+//        mul[i] = 1;
+//    }
+//}
+//
+//int update(int jobi, int jobv, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = ++cntt;
+//        mul[rt] = 1;
+//    }
+//    if (l == r) {
+//    	sum[rt] = jobv % MOD;
+//    } else {
+//        down(rt);
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2, long long mul1, long long mul2, long long v) {
+//    if (t1 == 0 || t2 == 0) {
+//        if (t1) {
+//            lazy(t1, mul1);
+//        }
+//        if (t2) {
+//            lazy(t2, mul2);
+//        }
+//        return t1 + t2;
+//    }
+//    down(t1);
+//    down(t2);
+//    int mid = (l + r) >> 1;
+//    int ls1 = ls[t1];
+//    int rs1 = rs[t1];
+//    int ls2 = ls[t2];
+//    int rs2 = rs[t2];
+//    long long lsum1 = sum[ls1];
+//    long long rsum1 = sum[rs1];
+//    long long lsum2 = sum[ls2];
+//    long long rsum2 = sum[rs2];
+//    long long tmp = (1 - v + MOD) % MOD;
+//    ls[t1] = merge(l, mid, ls1, ls2, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD, v);
+//    rs[t1] = merge(mid + 1, r, rs1, rs2, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD, v);
+//    up(t1);
+//    return t1;
+//}
+//
+//void dfs(int u) {
+//    if (childCnt[u] == 0) {
+//        root[u] = update(val[u], 1, 1, cntv, root[u]);
+//    } else if (childCnt[u] == 1) {
+//        dfs(child[u][0]);
+//        root[u] = root[child[u][0]];
+//    } else {
+//        dfs(child[u][0]);
+//        dfs(child[u][1]);
+//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], 0, 0, val[u]);
+//    }
+//}
+//
+//void getd(int l, int r, int i) {
+//    if (i == 0) {
+//        return;
+//    }
+//    if (l == r) {
+//        d[l] = sum[i] % MOD;
+//    } else {
+//        down(i);
+//        int mid = (l + r) >> 1;
+//        getd(l, mid, ls[i]);
+//        getd(mid + 1, r, rs[i]);
+//    }
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        if (fa[i] != 0) {
+//            child[fa[i]][childCnt[fa[i]]++] = i;
+//        }
+//    }
+//    long long inv = power(10000, MOD - 2);
+//    for (int i = 1; i <= n; i++) {
+//        if (childCnt[i] == 0) {
+//        	sorted[++cntv] = val[i];
+//        } else {
+//            val[i] = (int)(inv * val[i] % MOD);
+//        }
+//    }
+//    sort(sorted + 1, sorted + cntv + 1);
+//    int len = 1;
+//    for (int i = 2; i <= cntv; i++) {
+//        if (sorted[len] != sorted[i]) {
+//        	sorted[++len] = sorted[i];
+//        }
+//    }
+//    cntv = len;
+//    for (int i = 1; i <= n; i++) {
+//        if (childCnt[i] == 0) {
+//            val[i] = kth(val[i]);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> fa[i];
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> val[i];
+//    }
+//    prepare();
+//    dfs(1);
+//    getd(1, cntv, root[1]);
+//    long long ans = 0;
+//    for (int i = 1; i <= cntv; i++) {
+//        ans = (ans + (1LL * i * sorted[i]) % MOD * d[i] % MOD * d[i] % MOD) % MOD;
+//    }
+//    cout << ans << '\n';
+//    return 0;
+//}
\ No newline at end of file

From cdcf285fba7e584ea0ec38b5487e26ddfcab8791 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Oct 2025 12:12:53 +0800
Subject: [PATCH 1578/1712] modify code

---
 src/class182/Code02_Minimax1.java | 49 +++++++++++++++++++++++++++----
 src/class182/Code02_Minimax2.java |  2 +-
 2 files changed, 44 insertions(+), 7 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index c34be7940..fae588352 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -1,6 +1,6 @@
 package class182;
 
-// 根节点的概率问题，java版
+// 根节点的概率，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
@@ -131,19 +131,55 @@ public static int merge(int l, int r, int t1, int t2, long mul1, long mul2, long
 		return t1;
 	}
 
-	public static void dfs(int u) {
+	// 递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u) {
 		if (childCnt[u] == 0) {
 			root[u] = update(val[u], 1, 1, cntv, root[u]);
 		} else if (childCnt[u] == 1) {
-			dfs(child[u][0]);
+			dfs1(child[u][0]);
 			root[u] = root[child[u][0]];
 		} else {
-			dfs(child[u][0]);
-			dfs(child[u][1]);
+			dfs1(child[u][0]);
+			dfs1(child[u][1]);
 			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], 0, 0, val[u]);
 		}
 	}
 
+	// dfs1改成迭代版
+	public static void dfs2() {
+		int[][] stack = new int[n][2];
+		int siz = 0;
+		stack[++siz][0] = 1;
+		stack[siz][1] = 0;
+		while (siz > 0) {
+			int u = stack[siz][0];
+			int s = stack[siz--][1];
+			if (childCnt[u] == 0) {
+				root[u] = update(val[u], 1, 1, cntv, root[u]);
+			} else if (childCnt[u] == 1) {
+				if (s == 0) {
+					stack[++siz][0] = u;
+					stack[siz][1] = 1;
+					stack[++siz][0] = child[u][0];
+					stack[siz][1] = 0;
+				} else {
+					root[u] = root[child[u][0]];
+				}
+			} else {
+				if (s == 0) {
+					stack[++siz][0] = u;
+					stack[siz][1] = 1;
+					stack[++siz][0] = child[u][1];
+					stack[siz][1] = 0;
+					stack[++siz][0] = child[u][0];
+					stack[siz][1] = 0;
+				} else {
+					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], 0, 0, val[u]);
+				}
+			}
+		}
+	}
+
 	public static void getd(int l, int r, int i) {
 		if (i == 0) {
 			return;
@@ -198,7 +234,8 @@ public static void main(String[] args) throws Exception {
 			val[i] = in.nextInt();
 		}
 		prepare();
-		dfs(1);
+		// dfs1(1);
+		dfs2();
 		getd(1, cntv, root[1]);
 		long ans = 0;
 		for (int i = 1; i <= cntv; i++) {
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 176f36160..168fe591a 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -1,6 +1,6 @@
 package class182;
 
-// 根节点的概率问题，C++版
+// 根节点的概率，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 5cc8569af5f72a96b965813c7884983e5568ec4c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Oct 2025 12:21:25 +0800
Subject: [PATCH 1579/1712] modify code

---
 src/class182/Code02_Minimax1.java | 59 ++++++-------------------------
 src/class182/Code02_Minimax2.java |  8 ++---
 2 files changed, 15 insertions(+), 52 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index fae588352..dca86afd5 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -3,8 +3,8 @@
 // 根节点的概率，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code02_Minimax2文件就是C++的实现
+// java实现的逻辑一定是正确的，但是递归函数会爆栈，即便改了迭代，也会卡常超时
+// 索性不改了，想通过用C++实现，本节课Code02_Minimax2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -103,7 +103,7 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static int merge(int l, int r, int t1, int t2, long mul1, long mul2, long v) {
+	public static int merge(int l, int r, int t1, int t2, long v, long mul1, long mul2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
 				lazy(t1, mul1);
@@ -125,58 +125,22 @@ public static int merge(int l, int r, int t1, int t2, long mul1, long mul2, long
 		long lsum2 = sum[ls2];
 		long rsum2 = sum[rs2];
 		long tmp = (1 - v + MOD) % MOD;
-		ls[t1] = merge(l, mid, ls1, ls2, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD, v);
-		rs[t1] = merge(mid + 1, r, rs1, rs2, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD, v);
+		ls[t1] = merge(l, mid, ls1, ls2, v, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD);
+		rs[t1] = merge(mid + 1, r, rs1, rs2, v, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD);
 		up(t1);
 		return t1;
 	}
 
-	// 递归版，java会爆栈，C++可以通过
-	public static void dfs1(int u) {
+	public static void dfs(int u) {
 		if (childCnt[u] == 0) {
 			root[u] = update(val[u], 1, 1, cntv, root[u]);
 		} else if (childCnt[u] == 1) {
-			dfs1(child[u][0]);
+			dfs(child[u][0]);
 			root[u] = root[child[u][0]];
 		} else {
-			dfs1(child[u][0]);
-			dfs1(child[u][1]);
-			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], 0, 0, val[u]);
-		}
-	}
-
-	// dfs1改成迭代版
-	public static void dfs2() {
-		int[][] stack = new int[n][2];
-		int siz = 0;
-		stack[++siz][0] = 1;
-		stack[siz][1] = 0;
-		while (siz > 0) {
-			int u = stack[siz][0];
-			int s = stack[siz--][1];
-			if (childCnt[u] == 0) {
-				root[u] = update(val[u], 1, 1, cntv, root[u]);
-			} else if (childCnt[u] == 1) {
-				if (s == 0) {
-					stack[++siz][0] = u;
-					stack[siz][1] = 1;
-					stack[++siz][0] = child[u][0];
-					stack[siz][1] = 0;
-				} else {
-					root[u] = root[child[u][0]];
-				}
-			} else {
-				if (s == 0) {
-					stack[++siz][0] = u;
-					stack[siz][1] = 1;
-					stack[++siz][0] = child[u][1];
-					stack[siz][1] = 0;
-					stack[++siz][0] = child[u][0];
-					stack[siz][1] = 0;
-				} else {
-					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], 0, 0, val[u]);
-				}
-			}
+			dfs(child[u][0]);
+			dfs(child[u][1]);
+			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
 		}
 	}
 
@@ -234,8 +198,7 @@ public static void main(String[] args) throws Exception {
 			val[i] = in.nextInt();
 		}
 		prepare();
-		// dfs1(1);
-		dfs2();
+		dfs(1);
 		getd(1, cntv, root[1]);
 		long ans = 0;
 		for (int i = 1; i <= cntv; i++) {
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 168fe591a..5b72e3eff 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -98,7 +98,7 @@
 //    return rt;
 //}
 //
-//int merge(int l, int r, int t1, int t2, long long mul1, long long mul2, long long v) {
+//int merge(int l, int r, int t1, int t2, long long v, long long mul1, long long mul2) {
 //    if (t1 == 0 || t2 == 0) {
 //        if (t1) {
 //            lazy(t1, mul1);
@@ -120,8 +120,8 @@
 //    long long lsum2 = sum[ls2];
 //    long long rsum2 = sum[rs2];
 //    long long tmp = (1 - v + MOD) % MOD;
-//    ls[t1] = merge(l, mid, ls1, ls2, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD, v);
-//    rs[t1] = merge(mid + 1, r, rs1, rs2, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD, v);
+//    ls[t1] = merge(l, mid, ls1, ls2, v, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD);
+//    rs[t1] = merge(mid + 1, r, rs1, rs2, v, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD);
 //    up(t1);
 //    return t1;
 //}
@@ -135,7 +135,7 @@
 //    } else {
 //        dfs(child[u][0]);
 //        dfs(child[u][1]);
-//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], 0, 0, val[u]);
+//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
 //    }
 //}
 //

From c0e32cad92baa55d269eb0e532d603ae7f2ba2da Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 21 Oct 2025 12:27:16 +0800
Subject: [PATCH 1580/1712] modify code

---
 src/class182/Code02_Minimax1.java | 51 ++++++++++++++++++++++++++-----
 1 file changed, 44 insertions(+), 7 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index dca86afd5..cd6e41755 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -3,8 +3,8 @@
 // 根节点的概率，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
 // 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是递归函数会爆栈，即便改了迭代，也会卡常超时
-// 索性不改了，想通过用C++实现，本节课Code02_Minimax2文件就是C++的实现
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code02_Minimax2文件就是C++的实现
 // 两个版本的逻辑完全一样，C++版本可以通过所有测试
 
 import java.io.IOException;
@@ -131,19 +131,55 @@ public static int merge(int l, int r, int t1, int t2, long v, long mul1, long mu
 		return t1;
 	}
 
-	public static void dfs(int u) {
+	// 迭代版，java会爆栈，C++可以通过
+	public static void dfs1(int u) {
 		if (childCnt[u] == 0) {
 			root[u] = update(val[u], 1, 1, cntv, root[u]);
 		} else if (childCnt[u] == 1) {
-			dfs(child[u][0]);
+			dfs1(child[u][0]);
 			root[u] = root[child[u][0]];
 		} else {
-			dfs(child[u][0]);
-			dfs(child[u][1]);
+			dfs1(child[u][0]);
+			dfs1(child[u][1]);
 			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
 		}
 	}
 
+	// dfs1改成迭代版
+	public static void dfs2() {
+		int[][] stack = new int[n][2];
+		int siz = 0;
+		stack[++siz][0] = 1;
+		stack[siz][1] = 0;
+		while (siz > 0) {
+			int u = stack[siz][0];
+			int s = stack[siz--][1];
+			if (childCnt[u] == 0) {
+				root[u] = update(val[u], 1, 1, cntv, root[u]);
+			} else if (childCnt[u] == 1) {
+				if (s == 0) {
+					stack[++siz][0] = u;
+					stack[siz][1] = 1;
+					stack[++siz][0] = child[u][0];
+					stack[siz][1] = 0;
+				} else {
+					root[u] = root[child[u][0]];
+				}
+			} else {
+				if (s == 0) {
+					stack[++siz][0] = u;
+					stack[siz][1] = 1;
+					stack[++siz][0] = child[u][1];
+					stack[siz][1] = 0;
+					stack[++siz][0] = child[u][0];
+					stack[siz][1] = 0;
+				} else {
+					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
+				}
+			}
+		}
+	}
+
 	public static void getd(int l, int r, int i) {
 		if (i == 0) {
 			return;
@@ -198,7 +234,8 @@ public static void main(String[] args) throws Exception {
 			val[i] = in.nextInt();
 		}
 		prepare();
-		dfs(1);
+		// dfs1(1);
+		dfs2();
 		getd(1, cntv, root[1]);
 		long ans = 0;
 		for (int i = 1; i <= cntv; i++) {

From 24023a71ad411801f6cfd14db738962371e5e2d5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 22 Oct 2025 16:22:34 +0800
Subject: [PATCH 1581/1712] modify code

---
 src/class182/Code03_Fate1.java | 278 +++++++++++++++++++++++++++++++++
 1 file changed, 278 insertions(+)
 create mode 100644 src/class182/Code03_Fate1.java

diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
new file mode 100644
index 000000000..c841676eb
--- /dev/null
+++ b/src/class182/Code03_Fate1.java
@@ -0,0 +1,278 @@
+package class182;
+
+// 命运，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P6773
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+
+public class Code03_Fate1 {
+
+	public static int MAXN = 500001;
+	public static int MAXT = MAXN * 40;
+	public static int MOD = 998244353;
+	public static int n, m;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] root = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static long[] sum = new long[MAXT];
+	public static long[] mul = new long[MAXT];
+	public static int cntt;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] maxdep = new int[MAXN];
+
+	// 讲解118，递归改迭代需要的栈
+	public static int[][] ufe = new int[MAXN][3];
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	public static void addEdge(int u, int v) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		head[u] = cntg;
+	}
+
+	public static void lazy(int i, long v) {
+		if (i != 0) {
+			sum[i] = sum[i] * v % MOD;
+			mul[i] = mul[i] * v % MOD;
+		}
+	}
+
+	public static void down(int i) {
+		if (mul[i] != 1) {
+			lazy(ls[i], mul[i]);
+			lazy(rs[i], mul[i]);
+			mul[i] = 1;
+		}
+	}
+
+	public static int build(int jobi, int l, int r) {
+		int rt = ++cntt;
+		sum[rt] = 1;
+		mul[rt] = 1;
+		if (l < r) {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = build(jobi, l, mid);
+			} else {
+				rs[rt] = build(jobi, mid + 1, r);
+			}
+		}
+		return rt;
+	}
+
+	public static long sum1, sum2;
+
+	public static int merge(int l, int r, int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			if (t1 != 0) {
+				sum2 = (sum2 + sum[t1]) % MOD;
+				lazy(t1, sum1);
+			}
+			if (t2 != 0) {
+				sum1 = (sum1 + sum[t2]) % MOD;
+				lazy(t2, sum2);
+			}
+			return t1 + t2;
+		}
+		if (l == r) {
+			sum1 = (sum1 + sum[t2]) % MOD;
+			long tmp = sum[t1];
+			sum[t1] = ((sum[t1] * sum1) % MOD + (sum[t2] * sum2) % MOD) % MOD;
+			sum2 = (sum2 + tmp) % MOD;
+		} else {
+			down(t1);
+			down(t2);
+			int mid = (l + r) >> 1;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			sum[t1] = (sum[ls[t1]] + sum[rs[t1]]) % MOD;
+		}
+		return t1;
+	}
+
+	public static long query(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return sum[i] % MOD;
+		}
+		down(i);
+		int mid = (l + r) >> 1;
+		long ans = 0;
+		if (jobl <= mid) {
+			ans = query(jobl, jobr, l, mid, ls[i]);
+		}
+		if (jobr > mid) {
+			ans = (ans + query(jobl, jobr, mid + 1, r, rs[i])) % MOD;
+		}
+		return ans;
+	}
+
+	// 递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				dfs1(v, u);
+			}
+		}
+	}
+
+	// dfs1的迭代版
+	public static void dfs2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			}
+		}
+	}
+
+	// 递归版，java会爆栈，C++可以通过
+	public static void dp1(int u, int fa) {
+		root[u] = build(maxdep[u], 0, n);
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa) {
+				dp1(v, u);
+			}
+		}
+		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+			int v = to[ei];
+			if (v != fa) {
+				sum1 = query(0, dep[u], 0, n, root[v]);
+				sum2 = 0;
+				root[u] = merge(0, n, root[u], root[v]);
+			}
+		}
+	}
+
+	// dp1的迭代版
+	public static void dp2() {
+		stacksize = 0;
+		push(1, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				root[u] = build(maxdep[u], 0, n);
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				if (to[e] != f) {
+					push(to[e], u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+					int v = to[ei];
+					if (v != f) {
+						sum1 = query(0, dep[u], 0, n, root[v]);
+						sum2 = 0;
+						root[u] = merge(0, n, root[u], root[v]);
+					}
+				}
+			}
+		}
+	}
+
+	public static void main(String[] args) throws IOException {
+		FastReader in = new FastReader(System.in);
+		n = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		// dfs1(1, 0);
+		dfs2();
+		m = in.nextInt();
+		for (int i = 1, x, y; i <= m; i++) {
+			x = in.nextInt();
+			y = in.nextInt();
+			maxdep[y] = Math.max(maxdep[y], dep[x]);
+		}
+		// dp1(1, 0);
+		dp2();
+		long ans = query(0, 0, 0, n, root[1]) % MOD;
+		System.out.println(ans);
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
\ No newline at end of file

From e5ab9efcdff90637388b244eca84cacc56f838ff Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 22 Oct 2025 16:29:11 +0800
Subject: [PATCH 1582/1712] modify code

---
 src/class182/Code03_Fate1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index c841676eb..e0d6f6cd7 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -99,9 +99,9 @@ public static int merge(int l, int r, int t1, int t2) {
 		}
 		if (l == r) {
 			sum1 = (sum1 + sum[t2]) % MOD;
-			long tmp = sum[t1];
-			sum[t1] = ((sum[t1] * sum1) % MOD + (sum[t2] * sum2) % MOD) % MOD;
-			sum2 = (sum2 + tmp) % MOD;
+			long tmp = sum2;
+			sum2 = (sum2 + sum[t1]) % MOD;
+			sum[t1] = ((sum[t1] * sum1) % MOD + (sum[t2] * tmp) % MOD) % MOD;
 		} else {
 			down(t1);
 			down(t2);

From 070a959b9b0e17a0af08b4d4b13d200709121024 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 22 Oct 2025 19:12:01 +0800
Subject: [PATCH 1583/1712] modify code

---
 src/class181/Code02_RainyDayTail2.java | 167 ++++++++++++++++++++++++
 src/class181/Code03_LoveRunning2.java  | 172 +++++++++++++++++++++++++
 src/class181/Code04_NeverLand2.java    | 122 ++++++++++++++++++
 3 files changed, 461 insertions(+)
 create mode 100644 src/class181/Code02_RainyDayTail2.java
 create mode 100644 src/class181/Code03_LoveRunning2.java
 create mode 100644 src/class181/Code04_NeverLand2.java

diff --git a/src/class181/Code02_RainyDayTail2.java b/src/class181/Code02_RainyDayTail2.java
new file mode 100644
index 000000000..5cff6344d
--- /dev/null
+++ b/src/class181/Code02_RainyDayTail2.java
@@ -0,0 +1,167 @@
+package class181;
+
+// 雨天的尾巴，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4556
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXV = 100000;
+//const int MAXT = MAXN * 50;
+//const int MAXP = 20;
+//int n, m;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int dep[MAXN];
+//int stjump[MAXN][MAXP];
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int maxCnt[MAXT];
+//int cntt;
+//
+//int ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            dfs(v, u);
+//        }
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//void up(int i) {
+//    maxCnt[i] = max(maxCnt[ls[i]], maxCnt[rs[i]]);
+//}
+//
+//int add(int jobi, int jobv, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = ++cntt;
+//    }
+//    if (l == r) {
+//        maxCnt[rt] += jobv;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2) {
+//    if (t1 == 0 || t2 == 0) {
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        maxCnt[t1] += maxCnt[t2];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//    }
+//    return t1;
+//}
+//
+//int query(int l, int r, int i) {
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) >> 1;
+//    if (maxCnt[i] == maxCnt[ls[i]]) {
+//        return query(l, mid, ls[i]);
+//    } else {
+//        return query(mid + 1, r, rs[i]);
+//    }
+//}
+//
+//void calc(int u, int fa) {
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            calc(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            root[u] = merge(1, MAXV, root[u], root[v]);
+//        }
+//    }
+//    if (root[u] && maxCnt[root[u]] > 0) {
+//        ans[u] = query(1, MAXV, root[u]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs(1, 0);
+//    for (int i = 1, x, y, food; i <= m; i++) {
+//        cin >> x >> y >> food;
+//        int lca = getLca(x, y);
+//        int lcafa = stjump[lca][0];
+//        root[x] = add(food, 1, 1, MAXV, root[x]);
+//        root[y] = add(food, 1, 1, MAXV, root[y]);
+//        root[lca] = add(food, -1, 1, MAXV, root[lca]);
+//        root[lcafa] = add(food, -1, 1, MAXV, root[lcafa]);
+//    }
+//    calc(1, 0);
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << '\n';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class181/Code03_LoveRunning2.java b/src/class181/Code03_LoveRunning2.java
new file mode 100644
index 000000000..32bc1781f
--- /dev/null
+++ b/src/class181/Code03_LoveRunning2.java
@@ -0,0 +1,172 @@
+package class181;
+
+// 天天爱跑步，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P1600
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 300001;
+//const int MAXT = MAXN * 50;
+//const int MAXP = 20;
+//int n, m;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int dep[MAXN];
+//int stjump[MAXN][MAXP];
+//int rootl[MAXN];
+//int rootr[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int sum[MAXT];
+//int cntt;
+//
+//int ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    stjump[u][0] = fa;
+//    for (int p = 1; p < MAXP; p++) {
+//        stjump[u][p] = stjump[stjump[u][p - 1]][p - 1];
+//    }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            dfs(v, u);
+//        }
+//    }
+//}
+//
+//int getLca(int a, int b) {
+//    if (dep[a] < dep[b]) {
+//        swap(a, b);
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (dep[stjump[a][p]] >= dep[b]) {
+//            a = stjump[a][p];
+//        }
+//    }
+//    if (a == b) {
+//        return a;
+//    }
+//    for (int p = MAXP - 1; p >= 0; p--) {
+//        if (stjump[a][p] != stjump[b][p]) {
+//            a = stjump[a][p];
+//            b = stjump[b][p];
+//        }
+//    }
+//    return stjump[a][0];
+//}
+//
+//void up(int i) {
+//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//}
+//
+//int add(int jobi, int jobv, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = ++cntt;
+//    }
+//    if (l == r) {
+//        sum[rt] += jobv;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2) {
+//    if (t1 == 0 || t2 == 0) {
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        sum[t1] += sum[t2];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//    }
+//    return t1;
+//}
+//
+//int query(int jobi, int l, int r, int i) {
+//    if (jobi < l || jobi > r || i == 0) {
+//        return 0;
+//    }
+//    if (l == r) {
+//        return sum[i];
+//    }
+//    int mid = (l + r) >> 1;
+//    if (jobi <= mid) {
+//        return query(jobi, l, mid, ls[i]);
+//    } else {
+//        return query(jobi, mid + 1, r, rs[i]);
+//    }
+//}
+//
+//void calc(int u, int fa) {
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            calc(v, u);
+//        }
+//    }
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            rootl[u] = merge(1, n, rootl[u], rootl[v]);
+//            rootr[u] = merge(-n, n, rootr[u], rootr[v]);
+//        }
+//    }
+//    ans[u] = query(dep[u] + arr[u], 1, n, rootl[u]) + query(dep[u] - arr[u], -n, n, rootr[u]);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    dfs(1, 0);
+//    for (int i = 1, x, y; i <= m; i++) {
+//        cin >> x >> y;
+//        int lca = getLca(x, y);
+//        int lcafa = stjump[lca][0];
+//        rootl[x] = add(dep[x], 1, 1, n, rootl[x]);
+//        rootl[lca] = add(dep[x], -1, 1, n, rootl[lca]);
+//        rootr[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rootr[y]);
+//        rootr[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rootr[lcafa]);
+//    }
+//    calc(1, 0);
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << ' ';
+//    }
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class181/Code04_NeverLand2.java b/src/class181/Code04_NeverLand2.java
new file mode 100644
index 000000000..62fc75866
--- /dev/null
+++ b/src/class181/Code04_NeverLand2.java
@@ -0,0 +1,122 @@
+package class181;
+
+// 永无乡，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3224
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 100001;
+//const int MAXT = MAXN * 40;
+//int n, m, q;
+//int pos[MAXN];
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int sum[MAXT];
+//int cntt;
+//
+//int father[MAXN];
+//
+//void up(int i) {
+//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//}
+//
+//int add(int jobi, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = ++cntt;
+//    }
+//    if (l == r) {
+//        sum[rt]++;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = add(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = add(jobi, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2) {
+//    if (t1 == 0 || t2 == 0) {
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        sum[t1] += sum[t2];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//    }
+//    return t1;
+//}
+//
+//int query(int jobk, int l, int r, int i) {
+//    if (i == 0 || jobk > sum[i]) {
+//        return -1;
+//    }
+//    if (l == r) {
+//        return pos[l];
+//    }
+//    int mid = (l + r) >> 1;
+//    if (sum[ls[i]] >= jobk) {
+//        return query(jobk, l, mid, ls[i]);
+//    } else {
+//        return query(jobk - sum[ls[i]], mid + 1, r, rs[i]);
+//    }
+//}
+//
+//int find(int i) {
+//    if (i != father[i]) {
+//        father[i] = find(father[i]);
+//    }
+//    return father[i];
+//}
+//
+//void Union(int x, int y) {
+//    int xfa = find(x);
+//    int yfa = find(y);
+//    if (xfa != yfa) {
+//        father[xfa] = yfa;
+//        root[yfa] = merge(1, n, root[yfa], root[xfa]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, num; i <= n; i++) {
+//        cin >> num;
+//        pos[num] = i;
+//        father[i] = i;
+//        root[i] = add(num, 1, n, root[i]);
+//    }
+//    for (int i = 1, x, y; i <= m; i++) {
+//        cin >> x >> y;
+//        Union(x, y);
+//    }
+//    cin >> q;
+//    char op;
+//    int x, y, k;
+//    for (int i = 1; i <= q; i++) {
+//        cin >> op;
+//        if (op == 'B') {
+//            cin >> x >> y;
+//            Union(x, y);
+//        } else {
+//            cin >> x >> k;
+//            cout << query(k, 1, n, root[find(x)]) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 1068af129406aa8c24b0bbb936e5d40cdfc33f5e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 23 Oct 2025 12:40:16 +0800
Subject: [PATCH 1584/1712] modify code

---
 src/class181/Code01_PromotionCounting1.java | 6 +-----
 src/class181/Code01_PromotionCounting2.java | 5 -----
 src/class181/Code02_RainyDayTail1.java      | 5 -----
 src/class181/Code02_RainyDayTail2.java      | 5 -----
 src/class181/Code03_LoveRunning1.java       | 5 -----
 src/class181/Code03_LoveRunning2.java       | 5 -----
 6 files changed, 1 insertion(+), 30 deletions(-)

diff --git a/src/class181/Code01_PromotionCounting1.java b/src/class181/Code01_PromotionCounting1.java
index bf8c5d47e..56a7047a5 100644
--- a/src/class181/Code01_PromotionCounting1.java
+++ b/src/class181/Code01_PromotionCounting1.java
@@ -115,17 +115,13 @@ public static void calc1(int u, int fa) {
 			int v = to[e];
 			if (v != fa) {
 				calc1(v, u);
-			}
-		}
-		for (int e = head[u]; e > 0; e = nxt[e]) {
-			int v = to[e];
-			if (v != fa) {
 				root[u] = merge(1, cntv, root[u], root[v]);
 			}
 		}
 		ans[u] = query(arr[u] + 1, cntv, 1, cntv, root[u]);
 	}
 
+	// 递归函数改迭代需要的栈，不会改去看讲解118
 	public static int[][] ufe = new int[MAXN][3];
 
 	public static int stacksize, u, f, e;
diff --git a/src/class181/Code01_PromotionCounting2.java b/src/class181/Code01_PromotionCounting2.java
index ce63ac8b9..31e97926d 100644
--- a/src/class181/Code01_PromotionCounting2.java
+++ b/src/class181/Code01_PromotionCounting2.java
@@ -111,11 +111,6 @@
 //        int v = to[e];
 //        if (v != fa) {
 //            calc(v, u);
-//        }
-//    }
-//    for (int e = head[u]; e; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != fa) {
 //            root[u] = merge(1, cntv, root[u], root[v]);
 //        }
 //    }
diff --git a/src/class181/Code02_RainyDayTail1.java b/src/class181/Code02_RainyDayTail1.java
index 952a33774..b90d4e8d5 100644
--- a/src/class181/Code02_RainyDayTail1.java
+++ b/src/class181/Code02_RainyDayTail1.java
@@ -176,11 +176,6 @@ public static void calc1(int u, int fa) {
 			int v = to[e];
 			if (v != fa) {
 				calc1(v, u);
-			}
-		}
-		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
-			int v = to[ei];
-			if (v != fa) {
 				root[u] = merge(1, MAXV, root[u], root[v]);
 			}
 		}
diff --git a/src/class181/Code02_RainyDayTail2.java b/src/class181/Code02_RainyDayTail2.java
index 5cff6344d..7b8d67f77 100644
--- a/src/class181/Code02_RainyDayTail2.java
+++ b/src/class181/Code02_RainyDayTail2.java
@@ -127,11 +127,6 @@
 //        int v = to[e];
 //        if (v != fa) {
 //            calc(v, u);
-//        }
-//    }
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != fa) {
 //            root[u] = merge(1, MAXV, root[u], root[v]);
 //        }
 //    }
diff --git a/src/class181/Code03_LoveRunning1.java b/src/class181/Code03_LoveRunning1.java
index cf1b557b5..f4cee55f3 100644
--- a/src/class181/Code03_LoveRunning1.java
+++ b/src/class181/Code03_LoveRunning1.java
@@ -180,11 +180,6 @@ public static void calc1(int u, int fa) {
 			int v = to[e];
 			if (v != fa) {
 				calc1(v, u);
-			}
-		}
-		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
-			int v = to[ei];
-			if (v != fa) {
 				rootl[u] = merge(1, n, rootl[u], rootl[v]);
 				rootr[u] = merge(-n, n, rootr[u], rootr[v]);
 			}
diff --git a/src/class181/Code03_LoveRunning2.java b/src/class181/Code03_LoveRunning2.java
index 32bc1781f..78e48ed82 100644
--- a/src/class181/Code03_LoveRunning2.java
+++ b/src/class181/Code03_LoveRunning2.java
@@ -130,11 +130,6 @@
 //        int v = to[e];
 //        if (v != fa) {
 //            calc(v, u);
-//        }
-//    }
-//    for (int e = head[u]; e; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != fa) {
 //            rootl[u] = merge(1, n, rootl[u], rootl[v]);
 //            rootr[u] = merge(-n, n, rootr[u], rootr[v]);
 //        }

From 84966e2df122019ea4f0782da1c86b7644896372 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 23 Oct 2025 14:59:21 +0800
Subject: [PATCH 1585/1712] modify code

---
 src/class181/Code01_PromotionCounting1.java |  5 +++++
 src/class181/Code01_PromotionCounting2.java |  5 +++++
 src/class181/Code02_RainyDayTail1.java      | 14 +++++++++-----
 src/class181/Code02_RainyDayTail2.java      | 16 ++++++++++------
 4 files changed, 29 insertions(+), 11 deletions(-)

diff --git a/src/class181/Code01_PromotionCounting1.java b/src/class181/Code01_PromotionCounting1.java
index 56a7047a5..5aae1318f 100644
--- a/src/class181/Code01_PromotionCounting1.java
+++ b/src/class181/Code01_PromotionCounting1.java
@@ -1,6 +1,11 @@
 package class181;
 
 // 晋升者计数，java版
+// 一共有n个人，给定每个人的能力值arr[i]，所有人组成一棵树，代表公司的组织
+// 1号人是整个公司的老板，从2号人开始，给定每个人的上司编号fa[i]
+// 打印第i号人为头的子树中，有多少个人的能力值 > 第i号人的能力值，一共n条打印
+// 1 <= n <= 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3605
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class181/Code01_PromotionCounting2.java b/src/class181/Code01_PromotionCounting2.java
index 31e97926d..272c87698 100644
--- a/src/class181/Code01_PromotionCounting2.java
+++ b/src/class181/Code01_PromotionCounting2.java
@@ -1,6 +1,11 @@
 package class181;
 
 // 晋升者计数，C++版
+// 一共有n个人，给定每个人的能力值arr[i]，所有人组成一棵树，代表公司的组织
+// 1号人是整个公司的老板，从2号人开始，给定每个人的上司编号fa[i]
+// 打印第i号人为头的子树中，有多少个人的能力值 > 第i号人的能力值，一共n条打印
+// 1 <= n <= 10^5
+// 1 <= arr[i] <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P3605
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
diff --git a/src/class181/Code02_RainyDayTail1.java b/src/class181/Code02_RainyDayTail1.java
index b90d4e8d5..b0f73e457 100644
--- a/src/class181/Code02_RainyDayTail1.java
+++ b/src/class181/Code02_RainyDayTail1.java
@@ -1,6 +1,10 @@
 package class181;
 
 // 雨天的尾巴，java版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 给定m条路径，格式 x y v，表示x到y路径上的每个点都收到一个数字v
+// 打印第i号点上，收到次数最多的数字，如果不止一种，打印值最小的数字，一共n条打印
+// 1 <= n、m、v <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4556
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -230,13 +234,13 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= m; i++) {
 			int x = in.nextInt();
 			int y = in.nextInt();
-			int food = in.nextInt();
+			int v = in.nextInt();
 			int lca = getLca(x, y);
 			int lcafa = stjump[lca][0];
-			root[x] = add(food, 1, 1, MAXV, root[x]);
-			root[y] = add(food, 1, 1, MAXV, root[y]);
-			root[lca] = add(food, -1, 1, MAXV, root[lca]);
-			root[lcafa] = add(food, -1, 1, MAXV, root[lcafa]);
+			root[x] = add(v, 1, 1, MAXV, root[x]);
+			root[y] = add(v, 1, 1, MAXV, root[y]);
+			root[lca] = add(v, -1, 1, MAXV, root[lca]);
+			root[lcafa] = add(v, -1, 1, MAXV, root[lcafa]);
 		}
 		// calc1(1, 0);
 		calc2();
diff --git a/src/class181/Code02_RainyDayTail2.java b/src/class181/Code02_RainyDayTail2.java
index 7b8d67f77..d8d314622 100644
--- a/src/class181/Code02_RainyDayTail2.java
+++ b/src/class181/Code02_RainyDayTail2.java
@@ -1,6 +1,10 @@
 package class181;
 
 // 雨天的尾巴，C++版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 给定m条路径，格式 x y v，表示x到y路径上的每个点都收到一个数字v
+// 打印第i号点上，收到次数最多的数字，如果不止一种，打印值最小的数字，一共n条打印
+// 1 <= n、m、v <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4556
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -145,14 +149,14 @@
 //        addEdge(v, u);
 //    }
 //    dfs(1, 0);
-//    for (int i = 1, x, y, food; i <= m; i++) {
-//        cin >> x >> y >> food;
+//    for (int i = 1, x, y, v; i <= m; i++) {
+//        cin >> x >> y >> v;
 //        int lca = getLca(x, y);
 //        int lcafa = stjump[lca][0];
-//        root[x] = add(food, 1, 1, MAXV, root[x]);
-//        root[y] = add(food, 1, 1, MAXV, root[y]);
-//        root[lca] = add(food, -1, 1, MAXV, root[lca]);
-//        root[lcafa] = add(food, -1, 1, MAXV, root[lcafa]);
+//        root[x] = add(v, 1, 1, MAXV, root[x]);
+//        root[y] = add(v, 1, 1, MAXV, root[y]);
+//        root[lca] = add(v, -1, 1, MAXV, root[lca]);
+//        root[lcafa] = add(v, -1, 1, MAXV, root[lcafa]);
 //    }
 //    calc(1, 0);
 //    for (int i = 1; i <= n; i++) {

From b1fccdc0c4163f519793ff47cb5e98ecbd72eec1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 23 Oct 2025 15:19:42 +0800
Subject: [PATCH 1586/1712] modify code

---
 src/class181/Code03_LoveRunning1.java | 15 +++++++++++----
 src/class181/Code03_LoveRunning2.java | 13 ++++++++++---
 2 files changed, 21 insertions(+), 7 deletions(-)

diff --git a/src/class181/Code03_LoveRunning1.java b/src/class181/Code03_LoveRunning1.java
index f4cee55f3..e64626129 100644
--- a/src/class181/Code03_LoveRunning1.java
+++ b/src/class181/Code03_LoveRunning1.java
@@ -1,6 +1,13 @@
 package class181;
 
 // 天天爱跑步，java版
+// 一共有n个点，给定n-1条边，所有节点组成一棵树
+// 每个点上都有一个观察员，给出每个观察员的观测时刻w[i]
+// 给出m个跑步者的路线，格式 x y : 该跑步者出发时刻为0，从x跑到y
+// 任何跑步者通过任何一条边，耗时都是1秒
+// 某个跑步者到达i号点的时刻 == w[i]，那么该跑步者才会被i号点的观察员观测到
+// 打印i号点的观察员，能观测到多少人，一共n条打印
+// 1 <= n、m、w[i] <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P1600
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -15,7 +22,7 @@ public class Code03_LoveRunning1 {
 	public static int MAXT = MAXN * 50;
 	public static int MAXP = 20;
 	public static int n, m;
-	public static int[] arr = new int[MAXN];
+	public static int[] w = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -184,7 +191,7 @@ public static void calc1(int u, int fa) {
 				rootr[u] = merge(-n, n, rootr[u], rootr[v]);
 			}
 		}
-		ans[u] = query(dep[u] + arr[u], 1, n, rootl[u]) + query(dep[u] - arr[u], -n, n, rootr[u]);
+		ans[u] = query(dep[u] + w[u], 1, n, rootl[u]) + query(dep[u] - w[u], -n, n, rootr[u]);
 	}
 
 	// calc1改迭代
@@ -211,7 +218,7 @@ public static void calc2() {
 						rootr[u] = merge(-n, n, rootr[u], rootr[v]);
 					}
 				}
-				ans[u] = query(dep[u] + arr[u], 1, n, rootl[u]) + query(dep[u] - arr[u], -n, n, rootr[u]);
+				ans[u] = query(dep[u] + w[u], 1, n, rootl[u]) + query(dep[u] - w[u], -n, n, rootr[u]);
 			}
 		}
 	}
@@ -228,7 +235,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(v, u);
 		}
 		for (int i = 1; i <= n; i++) {
-			arr[i] = in.nextInt();
+			w[i] = in.nextInt();
 		}
 		// dfs1(1, 0);
 		dfs2();
diff --git a/src/class181/Code03_LoveRunning2.java b/src/class181/Code03_LoveRunning2.java
index 78e48ed82..529758c7d 100644
--- a/src/class181/Code03_LoveRunning2.java
+++ b/src/class181/Code03_LoveRunning2.java
@@ -1,6 +1,13 @@
 package class181;
 
 // 天天爱跑步，C++版
+// 一共有n个点，给定n-1条边，所有节点组成一棵树
+// 每个点上都有一个观察员，给出每个观察员的观测时刻w[i]
+// 给出m个跑步者的路线，格式 x y : 该跑步者出发时刻为0，从x跑到y
+// 任何跑步者通过任何一条边，耗时都是1秒
+// 某个跑步者到达i号点的时刻 == w[i]，那么该跑步者才会被i号点的观察员观测到
+// 打印i号点的观察员，能观测到多少人，一共n条打印
+// 1 <= n、m、w[i] <= 3 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P1600
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -13,7 +20,7 @@
 //const int MAXT = MAXN * 50;
 //const int MAXP = 20;
 //int n, m;
-//int arr[MAXN];
+//int w[MAXN];
 //
 //int head[MAXN];
 //int nxt[MAXN << 1];
@@ -134,7 +141,7 @@
 //            rootr[u] = merge(-n, n, rootr[u], rootr[v]);
 //        }
 //    }
-//    ans[u] = query(dep[u] + arr[u], 1, n, rootl[u]) + query(dep[u] - arr[u], -n, n, rootr[u]);
+//    ans[u] = query(dep[u] + w[u], 1, n, rootl[u]) + query(dep[u] - w[u], -n, n, rootr[u]);
 //}
 //
 //int main() {
@@ -147,7 +154,7 @@
 //        addEdge(v, u);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        cin >> arr[i];
+//        cin >> w[i];
 //    }
 //    dfs(1, 0);
 //    for (int i = 1, x, y; i <= m; i++) {

From 97aa9dbe5994b63ea503ca5cdeedea042f8995fd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 23 Oct 2025 15:31:56 +0800
Subject: [PATCH 1587/1712] modify code

---
 src/class181/Code04_NeverLand1.java | 5 +++++
 src/class181/Code04_NeverLand2.java | 5 +++++
 2 files changed, 10 insertions(+)

diff --git a/src/class181/Code04_NeverLand1.java b/src/class181/Code04_NeverLand1.java
index b6134e501..02878b9cf 100644
--- a/src/class181/Code04_NeverLand1.java
+++ b/src/class181/Code04_NeverLand1.java
@@ -1,6 +1,11 @@
 package class181;
 
 // 永无乡，java版
+// 一共有n个岛，每个岛分配到一个不同的数字，数字范围1~n
+// 给定初始的m座桥梁，若干点会连通起来，接下来有q条操作，格式如下
+// 操作 B x y : x号岛和y号岛之间新修建了一座桥
+// 操作 Q x k : x号岛所在的连通区里，打印第k小的数字来自几号岛，不存在打印-1
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3224
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class181/Code04_NeverLand2.java b/src/class181/Code04_NeverLand2.java
index 62fc75866..5f99a62da 100644
--- a/src/class181/Code04_NeverLand2.java
+++ b/src/class181/Code04_NeverLand2.java
@@ -1,6 +1,11 @@
 package class181;
 
 // 永无乡，C++版
+// 一共有n个岛，每个岛分配到一个不同的数字，数字范围1~n
+// 给定初始的m座桥梁，若干点会连通起来，接下来有q条操作，格式如下
+// 操作 B x y : x号岛和y号岛之间新修建了一座桥
+// 操作 Q x k : x号岛所在的连通区里，打印第k小的数字来自几号岛，不存在打印-1
+// 1 <= n、m <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3224
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 019bb9963a1053d9344948cd2e9d2dfa8210705b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 23 Oct 2025 16:14:33 +0800
Subject: [PATCH 1588/1712] modify code

---
 src/class181/Code05_MinimizeInversion1.java | 19 ++++++++++++++-----
 src/class181/Code05_MinimizeInversion2.java | 19 ++++++++++++++-----
 2 files changed, 28 insertions(+), 10 deletions(-)

diff --git a/src/class181/Code05_MinimizeInversion1.java b/src/class181/Code05_MinimizeInversion1.java
index aaabdb116..7869f72ef 100644
--- a/src/class181/Code05_MinimizeInversion1.java
+++ b/src/class181/Code05_MinimizeInversion1.java
@@ -1,6 +1,13 @@
 package class181;
 
 // 最小化逆序对，java版
+// 给定数字n，表示一棵二叉树有n个叶节点，叶节点的权值都不同并且都是1~n范围的数字
+// 树上的任何节点，要么是叶节点，要么一定有两个孩子，请从输入流中不断读取数字x来建树
+// 如果 x != 0，表示当前来到叶节点并且权值为x，注意只有叶节点有权值
+// 如果 x == 0，表示当前来到非叶节点，先递归建立左树，再递归建立右树
+// 输入流保证根据规则可以建好这棵二叉树，你可以任选一些节点，交换这些节点的左右子树
+// 目的是先序遍历整棵树之后，所有叶节点权值组成的序列中，逆序对数量尽可能小，打印这个最小值
+// 2 <= n <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3521
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
@@ -22,7 +29,7 @@ public class Code05_MinimizeInversion1 {
 	public static int[] siz = new int[MAXT];
 	public static int cntt;
 
-	public static long ans, u, v;
+	public static long ans;
 
 	public static void up(int i) {
 		siz[i] = siz[ls[i]] + siz[rs[i]];
@@ -44,6 +51,8 @@ public static int build(int jobi, int l, int r) {
 		return rt;
 	}
 
+	public static int no, yes;
+
 	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			return t1 + t2;
@@ -51,8 +60,8 @@ public static int merge(int l, int r, int t1, int t2) {
 		if (l == r) {
 			siz[t1] += siz[t2];
 		} else {
-			u += (long) siz[rs[t1]] * siz[ls[t2]];
-			v += (long) siz[ls[t1]] * siz[rs[t2]];
+			no += (long) siz[rs[t1]] * siz[ls[t2]];
+			yes += (long) siz[ls[t1]] * siz[rs[t2]];
 			int mid = (l + r) >> 1;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
@@ -67,9 +76,9 @@ public static int dfs() throws IOException {
 		if (val == 0) {
 			int left = dfs();
 			int right = dfs();
-			u = v = 0;
+			no = yes = 0;
 			rt = merge(1, n, left, right);
-			ans += Math.min(u, v);
+			ans += Math.min(no, yes);
 		} else {
 			rt = build(val, 1, n);
 		}
diff --git a/src/class181/Code05_MinimizeInversion2.java b/src/class181/Code05_MinimizeInversion2.java
index a075d1bf1..1f1236380 100644
--- a/src/class181/Code05_MinimizeInversion2.java
+++ b/src/class181/Code05_MinimizeInversion2.java
@@ -1,6 +1,13 @@
 package class181;
 
 // 最小化逆序对，C++版
+// 给定数字n，表示一棵二叉树有n个叶节点，叶节点的权值都不同并且都是1~n范围的数字
+// 树上的任何节点，要么是叶节点，要么一定有两个孩子，请从输入流中不断读取数字x来建树
+// 如果 x != 0，表示当前来到叶节点并且权值为x，注意只有叶节点有权值
+// 如果 x == 0，表示当前来到非叶节点，先递归建立左树，再递归建立右树
+// 输入流保证根据规则可以建好这棵二叉树，你可以任选一些节点，交换这些节点的左右子树
+// 目的是先序遍历整棵树之后，所有叶节点权值组成的序列中，逆序对数量尽可能小，打印这个最小值
+// 2 <= n <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P3521
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -17,7 +24,7 @@
 //int siz[MAXT];
 //int cntt;
 //
-//long long ans, u, v;
+//long long ans;
 //
 //void up(int i) {
 //    siz[i] = siz[ls[i]] + siz[rs[i]];
@@ -39,6 +46,8 @@
 //    return rt;
 //}
 //
+//long long no, yes;
+//
 //int merge(int l, int r, int t1, int t2) {
 //    if (t1 == 0 || t2 == 0) {
 //        return t1 + t2;
@@ -46,8 +55,8 @@
 //    if (l == r) {
 //        siz[t1] += siz[t2];
 //    } else {
-//        u += 1LL * siz[rs[t1]] * siz[ls[t2]];
-//        v += 1LL * siz[ls[t1]] * siz[rs[t2]];
+//        no += 1LL * siz[rs[t1]] * siz[ls[t2]];
+//        yes += 1LL * siz[ls[t1]] * siz[rs[t2]];
 //        int mid = (l + r) >> 1;
 //        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 //        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
@@ -63,9 +72,9 @@
 //    if (val == 0) {
 //        int left = dfs();
 //        int right = dfs();
-//        u = v = 0;
+//        no = yes = 0;
 //        rt = merge(1, n, left, right);
-//        ans += min(u, v);
+//        ans += min(no, yes);
 //    } else {
 //        rt = build(val, 1, n);
 //    }

From 60fe3a433858556ccd6a16a54e787ebdbb6af77d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 12:15:36 +0800
Subject: [PATCH 1589/1712] modify code

---
 ...04_NeverLand1.java => Code02_NeverLand1.java} | 16 ++++++++--------
 ...04_NeverLand2.java => Code02_NeverLand2.java} | 14 +++++++-------
 ...nyDayTail1.java => Code03_RainyDayTail1.java} |  2 +-
 ...nyDayTail2.java => Code03_RainyDayTail2.java} |  0
 ...oveRunning1.java => Code04_LoveRunning1.java} |  2 +-
 ...oveRunning2.java => Code04_LoveRunning2.java} |  0
 6 files changed, 17 insertions(+), 17 deletions(-)
 rename src/class181/{Code04_NeverLand1.java => Code02_NeverLand1.java} (94%)
 rename src/class181/{Code04_NeverLand2.java => Code02_NeverLand2.java} (92%)
 rename src/class181/{Code02_RainyDayTail1.java => Code03_RainyDayTail1.java} (99%)
 rename src/class181/{Code02_RainyDayTail2.java => Code03_RainyDayTail2.java} (100%)
 rename src/class181/{Code03_LoveRunning1.java => Code04_LoveRunning1.java} (99%)
 rename src/class181/{Code03_LoveRunning2.java => Code04_LoveRunning2.java} (100%)

diff --git a/src/class181/Code04_NeverLand1.java b/src/class181/Code02_NeverLand1.java
similarity index 94%
rename from src/class181/Code04_NeverLand1.java
rename to src/class181/Code02_NeverLand1.java
index 02878b9cf..7d0cc7009 100644
--- a/src/class181/Code04_NeverLand1.java
+++ b/src/class181/Code02_NeverLand1.java
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_NeverLand1 {
+public class Code02_NeverLand1 {
 
 	public static int MAXN = 100001;
 	public static int MAXT = MAXN * 40;
@@ -24,13 +24,13 @@ public class Code04_NeverLand1 {
 	public static int[] root = new int[MAXN];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
-	public static int[] sum = new int[MAXT];
+	public static int[] siz = new int[MAXT];
 	public static int cntt;
 
 	public static int[] father = new int[MAXN];
 
 	public static void up(int i) {
-		sum[i] = sum[ls[i]] + sum[rs[i]];
+		siz[i] = siz[ls[i]] + siz[rs[i]];
 	}
 
 	public static int add(int jobi, int l, int r, int i) {
@@ -39,7 +39,7 @@ public static int add(int jobi, int l, int r, int i) {
 			rt = ++cntt;
 		}
 		if (l == r) {
-			sum[rt]++;
+			siz[rt]++;
 		} else {
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
@@ -57,7 +57,7 @@ public static int merge(int l, int r, int t1, int t2) {
 			return t1 + t2;
 		}
 		if (l == r) {
-			sum[t1] += sum[t2];
+			siz[t1] += siz[t2];
 		} else {
 			int mid = (l + r) >> 1;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
@@ -68,17 +68,17 @@ public static int merge(int l, int r, int t1, int t2) {
 	}
 
 	public static int query(int jobk, int l, int r, int i) {
-		if (i == 0 || jobk > sum[i]) {
+		if (i == 0 || jobk > siz[i]) {
 			return -1;
 		}
 		if (l == r) {
 			return pos[l];
 		}
 		int mid = (l + r) >> 1;
-		if (sum[ls[i]] >= jobk) {
+		if (siz[ls[i]] >= jobk) {
 			return query(jobk, l, mid, ls[i]);
 		} else {
-			return query(jobk - sum[ls[i]], mid + 1, r, rs[i]);
+			return query(jobk - siz[ls[i]], mid + 1, r, rs[i]);
 		}
 	}
 
diff --git a/src/class181/Code04_NeverLand2.java b/src/class181/Code02_NeverLand2.java
similarity index 92%
rename from src/class181/Code04_NeverLand2.java
rename to src/class181/Code02_NeverLand2.java
index 5f99a62da..697eadd8f 100644
--- a/src/class181/Code04_NeverLand2.java
+++ b/src/class181/Code02_NeverLand2.java
@@ -22,13 +22,13 @@
 //int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
-//int sum[MAXT];
+//int siz[MAXT];
 //int cntt;
 //
 //int father[MAXN];
 //
 //void up(int i) {
-//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//    siz[i] = siz[ls[i]] + siz[rs[i]];
 //}
 //
 //int add(int jobi, int l, int r, int i) {
@@ -37,7 +37,7 @@
 //        rt = ++cntt;
 //    }
 //    if (l == r) {
-//        sum[rt]++;
+//        siz[rt]++;
 //    } else {
 //        int mid = (l + r) >> 1;
 //        if (jobi <= mid) {
@@ -55,7 +55,7 @@
 //        return t1 + t2;
 //    }
 //    if (l == r) {
-//        sum[t1] += sum[t2];
+//        siz[t1] += siz[t2];
 //    } else {
 //        int mid = (l + r) >> 1;
 //        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
@@ -66,17 +66,17 @@
 //}
 //
 //int query(int jobk, int l, int r, int i) {
-//    if (i == 0 || jobk > sum[i]) {
+//    if (i == 0 || jobk > siz[i]) {
 //        return -1;
 //    }
 //    if (l == r) {
 //        return pos[l];
 //    }
 //    int mid = (l + r) >> 1;
-//    if (sum[ls[i]] >= jobk) {
+//    if (siz[ls[i]] >= jobk) {
 //        return query(jobk, l, mid, ls[i]);
 //    } else {
-//        return query(jobk - sum[ls[i]], mid + 1, r, rs[i]);
+//        return query(jobk - siz[ls[i]], mid + 1, r, rs[i]);
 //    }
 //}
 //
diff --git a/src/class181/Code02_RainyDayTail1.java b/src/class181/Code03_RainyDayTail1.java
similarity index 99%
rename from src/class181/Code02_RainyDayTail1.java
rename to src/class181/Code03_RainyDayTail1.java
index b0f73e457..2c786e884 100644
--- a/src/class181/Code02_RainyDayTail1.java
+++ b/src/class181/Code03_RainyDayTail1.java
@@ -13,7 +13,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_RainyDayTail1 {
+public class Code03_RainyDayTail1 {
 
 	public static int MAXN = 100001;
 	public static int MAXV = 100000;
diff --git a/src/class181/Code02_RainyDayTail2.java b/src/class181/Code03_RainyDayTail2.java
similarity index 100%
rename from src/class181/Code02_RainyDayTail2.java
rename to src/class181/Code03_RainyDayTail2.java
diff --git a/src/class181/Code03_LoveRunning1.java b/src/class181/Code04_LoveRunning1.java
similarity index 99%
rename from src/class181/Code03_LoveRunning1.java
rename to src/class181/Code04_LoveRunning1.java
index e64626129..345c71d3a 100644
--- a/src/class181/Code03_LoveRunning1.java
+++ b/src/class181/Code04_LoveRunning1.java
@@ -16,7 +16,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_LoveRunning1 {
+public class Code04_LoveRunning1 {
 
 	public static int MAXN = 300001;
 	public static int MAXT = MAXN * 50;
diff --git a/src/class181/Code03_LoveRunning2.java b/src/class181/Code04_LoveRunning2.java
similarity index 100%
rename from src/class181/Code03_LoveRunning2.java
rename to src/class181/Code04_LoveRunning2.java

From 549c43174d0ca9766c288ff817d5f16cac34bd4f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 16:44:12 +0800
Subject: [PATCH 1590/1712] modify code

---
 src/class181/Code02_NeverLand1.java | 3 +--
 src/class181/Code02_NeverLand2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class181/Code02_NeverLand1.java b/src/class181/Code02_NeverLand1.java
index 7d0cc7009..0a4b60ff9 100644
--- a/src/class181/Code02_NeverLand1.java
+++ b/src/class181/Code02_NeverLand1.java
@@ -20,6 +20,7 @@ public class Code02_NeverLand1 {
 	public static int MAXT = MAXN * 40;
 	public static int n, m, q;
 	public static int[] pos = new int[MAXN];
+	public static int[] father = new int[MAXN];
 
 	public static int[] root = new int[MAXN];
 	public static int[] ls = new int[MAXT];
@@ -27,8 +28,6 @@ public class Code02_NeverLand1 {
 	public static int[] siz = new int[MAXT];
 	public static int cntt;
 
-	public static int[] father = new int[MAXN];
-
 	public static void up(int i) {
 		siz[i] = siz[ls[i]] + siz[rs[i]];
 	}
diff --git a/src/class181/Code02_NeverLand2.java b/src/class181/Code02_NeverLand2.java
index 697eadd8f..3f2f33d1f 100644
--- a/src/class181/Code02_NeverLand2.java
+++ b/src/class181/Code02_NeverLand2.java
@@ -18,6 +18,7 @@
 //const int MAXT = MAXN * 40;
 //int n, m, q;
 //int pos[MAXN];
+//int father[MAXN];
 //
 //int root[MAXN];
 //int ls[MAXT];
@@ -25,8 +26,6 @@
 //int siz[MAXT];
 //int cntt;
 //
-//int father[MAXN];
-//
 //void up(int i) {
 //    siz[i] = siz[ls[i]] + siz[rs[i]];
 //}

From 49a747976d363993010b3822a3d368b437bced54 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 16:46:02 +0800
Subject: [PATCH 1591/1712] modify code

---
 src/class181/Code02_NeverLand1.java | 4 ++++
 1 file changed, 4 insertions(+)

diff --git a/src/class181/Code02_NeverLand1.java b/src/class181/Code02_NeverLand1.java
index 0a4b60ff9..a0ba7a974 100644
--- a/src/class181/Code02_NeverLand1.java
+++ b/src/class181/Code02_NeverLand1.java
@@ -19,9 +19,13 @@ public class Code02_NeverLand1 {
 	public static int MAXN = 100001;
 	public static int MAXT = MAXN * 40;
 	public static int n, m, q;
+
+	// pos[v] = i，表示数字v属于第i号岛
 	public static int[] pos = new int[MAXN];
+	// 并查集
 	public static int[] father = new int[MAXN];
 
+	// 权值线段树
 	public static int[] root = new int[MAXN];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];

From 32f7abf77aebd9b62cfcbc209926a2024cf30f7d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 17:09:53 +0800
Subject: [PATCH 1592/1712] modify code

---
 src/class181/Code03_RainyDayTail1.java | 4 +++-
 src/class181/Code03_RainyDayTail2.java | 4 +++-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/src/class181/Code03_RainyDayTail1.java b/src/class181/Code03_RainyDayTail1.java
index 2c786e884..6ab8187ac 100644
--- a/src/class181/Code03_RainyDayTail1.java
+++ b/src/class181/Code03_RainyDayTail1.java
@@ -3,7 +3,9 @@
 // 雨天的尾巴，java版
 // 一共有n个节点，给定n-1条边，所有节点组成一棵树
 // 给定m条路径，格式 x y v，表示x到y路径上的每个点都收到一个数字v
-// 打印第i号点上，收到次数最多的数字，如果不止一种，打印值最小的数字，一共n条打印
+// 打印第i号点上，收到次数最多的数字，如果不止一种，打印值最小的数字
+// 如果某节点没有收到过数字，打印0
+// 一共n条打印
 // 1 <= n、m、v <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4556
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class181/Code03_RainyDayTail2.java b/src/class181/Code03_RainyDayTail2.java
index d8d314622..d29b0d4fa 100644
--- a/src/class181/Code03_RainyDayTail2.java
+++ b/src/class181/Code03_RainyDayTail2.java
@@ -3,7 +3,9 @@
 // 雨天的尾巴，C++版
 // 一共有n个节点，给定n-1条边，所有节点组成一棵树
 // 给定m条路径，格式 x y v，表示x到y路径上的每个点都收到一个数字v
-// 打印第i号点上，收到次数最多的数字，如果不止一种，打印值最小的数字，一共n条打印
+// 打印第i号点上，收到次数最多的数字，如果不止一种，打印值最小的数字
+// 如果某节点没有收到过数字，打印0
+// 一共n条打印
 // 1 <= n、m、v <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P4556
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样

From 461eaedd163b233e8dc25fd0059871b826225b72 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 17:16:03 +0800
Subject: [PATCH 1593/1712] modify code

---
 src/class181/Code03_RainyDayTail1.java | 8 ++++++--
 src/class181/Code03_RainyDayTail2.java | 4 +++-
 2 files changed, 9 insertions(+), 3 deletions(-)

diff --git a/src/class181/Code03_RainyDayTail1.java b/src/class181/Code03_RainyDayTail1.java
index 6ab8187ac..5a112cfa3 100644
--- a/src/class181/Code03_RainyDayTail1.java
+++ b/src/class181/Code03_RainyDayTail1.java
@@ -185,7 +185,9 @@ public static void calc1(int u, int fa) {
 				root[u] = merge(1, MAXV, root[u], root[v]);
 			}
 		}
-		if (maxCnt[root[u]] > 0) {
+		if (maxCnt[root[u]] == 0) {
+			ans[u] = 0;
+		} else {
 			ans[u] = query(1, MAXV, root[u]);
 		}
 	}
@@ -213,7 +215,9 @@ public static void calc2() {
 						root[u] = merge(1, MAXV, root[u], root[v]);
 					}
 				}
-				if (maxCnt[root[u]] > 0) {
+				if (maxCnt[root[u]] == 0) {
+					ans[u] = 0;
+				} else {
 					ans[u] = query(1, MAXV, root[u]);
 				}
 			}
diff --git a/src/class181/Code03_RainyDayTail2.java b/src/class181/Code03_RainyDayTail2.java
index d29b0d4fa..336679884 100644
--- a/src/class181/Code03_RainyDayTail2.java
+++ b/src/class181/Code03_RainyDayTail2.java
@@ -136,7 +136,9 @@
 //            root[u] = merge(1, MAXV, root[u], root[v]);
 //        }
 //    }
-//    if (root[u] && maxCnt[root[u]] > 0) {
+//    if (maxCnt[root[u]] == 0) {
+//        ans[u] = 0;
+//    } else {
 //        ans[u] = query(1, MAXV, root[u]);
 //    }
 //}

From ec0c18d32a61286107cc5a71830b0b8ad256cef8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 17:54:32 +0800
Subject: [PATCH 1594/1712] modify code

---
 src/class181/Code03_RainyDayTail1.java | 2 +-
 src/class181/Code03_RainyDayTail2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class181/Code03_RainyDayTail1.java b/src/class181/Code03_RainyDayTail1.java
index 5a112cfa3..535dd6983 100644
--- a/src/class181/Code03_RainyDayTail1.java
+++ b/src/class181/Code03_RainyDayTail1.java
@@ -169,7 +169,7 @@ public static int query(int l, int r, int i) {
 			return l;
 		}
 		int mid = (l + r) >> 1;
-		if (maxCnt[i] == maxCnt[ls[i]]) {
+		if (maxCnt[ls[i]] >= maxCnt[rs[i]]) {
 			return query(l, mid, ls[i]);
 		} else {
 			return query(mid + 1, r, rs[i]);
diff --git a/src/class181/Code03_RainyDayTail2.java b/src/class181/Code03_RainyDayTail2.java
index 336679884..5de5192df 100644
--- a/src/class181/Code03_RainyDayTail2.java
+++ b/src/class181/Code03_RainyDayTail2.java
@@ -121,7 +121,7 @@
 //        return l;
 //    }
 //    int mid = (l + r) >> 1;
-//    if (maxCnt[i] == maxCnt[ls[i]]) {
+//    if (maxCnt[ls[i]] >= maxCnt[rs[i]]) {
 //        return query(l, mid, ls[i]);
 //    } else {
 //        return query(mid + 1, r, rs[i]);

From dd55e95a6808543be7140c818a0690d59f929647 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 18:57:12 +0800
Subject: [PATCH 1595/1712] modify code

---
 src/class181/Code04_LoveRunning1.java | 24 ++++++++++++------------
 src/class181/Code04_LoveRunning2.java | 18 +++++++++---------
 2 files changed, 21 insertions(+), 21 deletions(-)

diff --git a/src/class181/Code04_LoveRunning1.java b/src/class181/Code04_LoveRunning1.java
index 345c71d3a..45f75cd2f 100644
--- a/src/class181/Code04_LoveRunning1.java
+++ b/src/class181/Code04_LoveRunning1.java
@@ -32,8 +32,8 @@ public class Code04_LoveRunning1 {
 	public static int[] dep = new int[MAXN];
 	public static int[][] stjump = new int[MAXN][MAXP];
 
-	public static int[] rootl = new int[MAXN];
-	public static int[] rootr = new int[MAXN];
+	public static int[] rtUp = new int[MAXN];
+	public static int[] rtDown = new int[MAXN];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static int[] sum = new int[MAXT];
@@ -187,11 +187,11 @@ public static void calc1(int u, int fa) {
 			int v = to[e];
 			if (v != fa) {
 				calc1(v, u);
-				rootl[u] = merge(1, n, rootl[u], rootl[v]);
-				rootr[u] = merge(-n, n, rootr[u], rootr[v]);
+				rtUp[u] = merge(1, n, rtUp[u], rtUp[v]);
+				rtDown[u] = merge(-n, n, rtDown[u], rtDown[v]);
 			}
 		}
-		ans[u] = query(dep[u] + w[u], 1, n, rootl[u]) + query(dep[u] - w[u], -n, n, rootr[u]);
+		ans[u] = query(dep[u] + w[u], 1, n, rtUp[u]) + query(dep[u] - w[u], -n, n, rtDown[u]);
 	}
 
 	// calc1改迭代
@@ -214,11 +214,11 @@ public static void calc2() {
 				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 					int v = to[ei];
 					if (v != f) {
-						rootl[u] = merge(1, n, rootl[u], rootl[v]);
-						rootr[u] = merge(-n, n, rootr[u], rootr[v]);
+						rtUp[u] = merge(1, n, rtUp[u], rtUp[v]);
+						rtDown[u] = merge(-n, n, rtDown[u], rtDown[v]);
 					}
 				}
-				ans[u] = query(dep[u] + w[u], 1, n, rootl[u]) + query(dep[u] - w[u], -n, n, rootr[u]);
+				ans[u] = query(dep[u] + w[u], 1, n, rtUp[u]) + query(dep[u] - w[u], -n, n, rtDown[u]);
 			}
 		}
 	}
@@ -244,10 +244,10 @@ public static void main(String[] args) throws Exception {
 			int y = in.nextInt();
 			int lca = getLca(x, y);
 			int lcafa = stjump[lca][0];
-			rootl[x] = add(dep[x], 1, 1, n, rootl[x]);
-			rootl[lca] = add(dep[x], -1, 1, n, rootl[lca]);
-			rootr[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rootr[y]);
-			rootr[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rootr[lcafa]);
+			rtUp[x] = add(dep[x], 1, 1, n, rtUp[x]);
+			rtUp[lca] = add(dep[x], -1, 1, n, rtUp[lca]);
+			rtDown[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rtDown[y]);
+			rtDown[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rtDown[lcafa]);
 		}
 		// calc1(1, 0);
 		calc2();
diff --git a/src/class181/Code04_LoveRunning2.java b/src/class181/Code04_LoveRunning2.java
index 529758c7d..4cc914669 100644
--- a/src/class181/Code04_LoveRunning2.java
+++ b/src/class181/Code04_LoveRunning2.java
@@ -29,8 +29,8 @@
 //
 //int dep[MAXN];
 //int stjump[MAXN][MAXP];
-//int rootl[MAXN];
-//int rootr[MAXN];
+//int rtUp[MAXN];
+//int rtDown[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
 //int sum[MAXT];
@@ -137,11 +137,11 @@
 //        int v = to[e];
 //        if (v != fa) {
 //            calc(v, u);
-//            rootl[u] = merge(1, n, rootl[u], rootl[v]);
-//            rootr[u] = merge(-n, n, rootr[u], rootr[v]);
+//            rtUp[u] = merge(1, n, rtUp[u], rtUp[v]);
+//            rtDown[u] = merge(-n, n, rtDown[u], rtDown[v]);
 //        }
 //    }
-//    ans[u] = query(dep[u] + w[u], 1, n, rootl[u]) + query(dep[u] - w[u], -n, n, rootr[u]);
+//    ans[u] = query(dep[u] + w[u], 1, n, rtUp[u]) + query(dep[u] - w[u], -n, n, rtDown[u]);
 //}
 //
 //int main() {
@@ -161,10 +161,10 @@
 //        cin >> x >> y;
 //        int lca = getLca(x, y);
 //        int lcafa = stjump[lca][0];
-//        rootl[x] = add(dep[x], 1, 1, n, rootl[x]);
-//        rootl[lca] = add(dep[x], -1, 1, n, rootl[lca]);
-//        rootr[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rootr[y]);
-//        rootr[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rootr[lcafa]);
+//        rtUp[x] = add(dep[x], 1, 1, n, rtUp[x]);
+//        rtUp[lca] = add(dep[x], -1, 1, n, rtUp[lca]);
+//        rtDown[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rtDown[y]);
+//        rtDown[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rtDown[lcafa]);
 //    }
 //    calc(1, 0);
 //    for (int i = 1; i <= n; i++) {

From b64c2087b521b980cef1b440bf04dbc1cc46f904 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 19:41:56 +0800
Subject: [PATCH 1596/1712] modify code

---
 src/class181/Code04_LoveRunning1.java | 4 ++--
 src/class181/Code04_LoveRunning2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class181/Code04_LoveRunning1.java b/src/class181/Code04_LoveRunning1.java
index 45f75cd2f..2ae3e89a4 100644
--- a/src/class181/Code04_LoveRunning1.java
+++ b/src/class181/Code04_LoveRunning1.java
@@ -245,9 +245,9 @@ public static void main(String[] args) throws Exception {
 			int lca = getLca(x, y);
 			int lcafa = stjump[lca][0];
 			rtUp[x] = add(dep[x], 1, 1, n, rtUp[x]);
-			rtUp[lca] = add(dep[x], -1, 1, n, rtUp[lca]);
+			rtUp[lcafa] = add(dep[x], -1, 1, n, rtUp[lcafa]);
 			rtDown[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rtDown[y]);
-			rtDown[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rtDown[lcafa]);
+			rtDown[lca] = add(2 * dep[lca] - dep[x], -1, -n, n, rtDown[lca]);
 		}
 		// calc1(1, 0);
 		calc2();
diff --git a/src/class181/Code04_LoveRunning2.java b/src/class181/Code04_LoveRunning2.java
index 4cc914669..404b44cf8 100644
--- a/src/class181/Code04_LoveRunning2.java
+++ b/src/class181/Code04_LoveRunning2.java
@@ -162,9 +162,9 @@
 //        int lca = getLca(x, y);
 //        int lcafa = stjump[lca][0];
 //        rtUp[x] = add(dep[x], 1, 1, n, rtUp[x]);
-//        rtUp[lca] = add(dep[x], -1, 1, n, rtUp[lca]);
+//        rtUp[lcafa] = add(dep[x], -1, 1, n, rtUp[lcafa]);
 //        rtDown[y] = add(2 * dep[lca] - dep[x], 1, -n, n, rtDown[y]);
-//        rtDown[lcafa] = add(2 * dep[lca] - dep[x], -1, -n, n, rtDown[lcafa]);
+//        rtDown[lca] = add(2 * dep[lca] - dep[x], -1, -n, n, rtDown[lca]);
 //    }
 //    calc(1, 0);
 //    for (int i = 1; i <= n; i++) {

From c9f819f933b3d919f6917a09da562d6ab3b1c4b0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 22:08:01 +0800
Subject: [PATCH 1597/1712] modify code

---
 src/class181/Code05_MinimizeInversion1.java | 2 +-
 src/class181/Code05_MinimizeInversion2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class181/Code05_MinimizeInversion1.java b/src/class181/Code05_MinimizeInversion1.java
index 7869f72ef..a30fb0386 100644
--- a/src/class181/Code05_MinimizeInversion1.java
+++ b/src/class181/Code05_MinimizeInversion1.java
@@ -61,7 +61,7 @@ public static int merge(int l, int r, int t1, int t2) {
 			siz[t1] += siz[t2];
 		} else {
 			no += (long) siz[rs[t1]] * siz[ls[t2]];
-			yes += (long) siz[ls[t1]] * siz[rs[t2]];
+			yes += (long) siz[rs[t2]] * siz[ls[t1]];
 			int mid = (l + r) >> 1;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
diff --git a/src/class181/Code05_MinimizeInversion2.java b/src/class181/Code05_MinimizeInversion2.java
index 1f1236380..e75badee4 100644
--- a/src/class181/Code05_MinimizeInversion2.java
+++ b/src/class181/Code05_MinimizeInversion2.java
@@ -56,7 +56,7 @@
 //        siz[t1] += siz[t2];
 //    } else {
 //        no += 1LL * siz[rs[t1]] * siz[ls[t2]];
-//        yes += 1LL * siz[ls[t1]] * siz[rs[t2]];
+//        yes += 1LL * siz[rs[t2]] * siz[ls[t1]];
 //        int mid = (l + r) >> 1;
 //        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 //        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);

From 1b98003614d7cb697bb6e9a98a9ccb7507157178 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 24 Oct 2025 22:51:24 +0800
Subject: [PATCH 1598/1712] modify code

---
 ...6\345\210\206\350\243\202-\344\270\212.pptx" | Bin 0 -> 47709 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243181\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\347\232\204\345\220\210\345\271\266\344\270\216\345\210\206\350\243\202-\344\270\212.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243181\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\347\232\204\345\220\210\345\271\266\344\270\216\345\210\206\350\243\202-\344\270\212.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243181\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\347\232\204\345\220\210\345\271\266\344\270\216\345\210\206\350\243\202-\344\270\212.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..0144dd136b363a6e2cde5f63071d236c0e661af9
GIT binary patch
literal 47709
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
VG{DzzU{xaU)B(QK|1A3T?mrfxs>}cY

literal 0
HcmV?d00001


From e3f972e851647c5d33ca7032f6528bb1ba0df336 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 13:22:10 +0800
Subject: [PATCH 1599/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 4 +++-
 1 file changed, 3 insertions(+), 1 deletion(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index fc8c50922..2e69a2e84 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -40,7 +40,9 @@ public static void up(int i) {
 	}
 
 	public static void lazy(int i, int v) {
-		// 如果区间信息不存在，说明没有建立过dp信息，那么不需要加v
+		// 如果区间信息不存在
+		// 说明没有建立过dp信息
+		// 那么不需要增加v
 		if (i != 0) {
 			max[i] += v;
 			addTag[i] += v;

From b9df1c3c26f7e28a91ae57f2f2808aeb4c9d32d6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 14:07:20 +0800
Subject: [PATCH 1600/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 23 ++++++++++++++++-------
 src/class182/Code02_Minimax1.java      | 25 +++++++++++++++++++------
 src/class182/Code02_Minimax2.java      | 20 +++++++++++++++-----
 3 files changed, 50 insertions(+), 18 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 2e69a2e84..285673d69 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -77,24 +77,32 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static int merge(int l, int r, int t1, int t2, int rmax1, int rmax2) {
+	public static int max1, max2;
+
+	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
-				lazy(t1, rmax2);
+				lazy(t1, max2);
 			}
 			if (t2 != 0) {
-				lazy(t2, rmax1);
+				lazy(t2, max1);
 			}
 			return t1 + t2;
 		}
 		if (l == r) {
-			max[t1] = Math.max(max[t1], rmax1) + Math.max(max[t2], rmax2);
+			max[t1] = Math.max(max[t1], max1) + Math.max(max[t2], max2);
 		} else {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			ls[t1] = merge(l, mid, ls[t1], ls[t2], Math.max(max[rs[t1]], rmax1), Math.max(max[rs[t2]], rmax2));
-			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], rmax1, rmax2);
+			int tmp1 = max1;
+			int tmp2 = max2;
+			max1 = Math.max(max1, max[rs[t1]]);
+			max2 = Math.max(max2, max[rs[t2]]);
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			max1 = tmp1;
+			max2 = tmp2;
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
 		}
 		return t1;
@@ -125,7 +133,8 @@ public static void dp(int u) {
 			int v = to[e];
 			dp(v);
 			val += query(arr[u], MAXV, 1, MAXV, root[v]);
-			root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
+			max1 = max2 = 0;
+			root[u] = merge(1, MAXV, root[u], root[v]);
 		}
 		root[u] = add(arr[u], val, 1, MAXV, root[u]);
 	}
diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index cd6e41755..0e672377a 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -103,7 +103,9 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static int merge(int l, int r, int t1, int t2, long v, long mul1, long mul2) {
+	public static long v, mul1, mul2;
+
+	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
 				lazy(t1, mul1);
@@ -124,9 +126,14 @@ public static int merge(int l, int r, int t1, int t2, long v, long mul1, long mu
 		long rsum1 = sum[rs1];
 		long lsum2 = sum[ls2];
 		long rsum2 = sum[rs2];
-		long tmp = (1 - v + MOD) % MOD;
-		ls[t1] = merge(l, mid, ls1, ls2, v, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD);
-		rs[t1] = merge(mid + 1, r, rs1, rs2, v, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD);
+		long tmp1 = mul1;
+		long tmp2 = mul2;
+		mul1 = (tmp1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
+		mul2 = (tmp2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
+		ls[t1] = merge(l, mid, ls1, ls2);
+		mul1 = (tmp1 + lsum2 * v) % MOD;
+		mul2 = (tmp2 + lsum1 * v) % MOD;
+		rs[t1] = merge(mid + 1, r, rs1, rs2);
 		up(t1);
 		return t1;
 	}
@@ -141,7 +148,10 @@ public static void dfs1(int u) {
 		} else {
 			dfs1(child[u][0]);
 			dfs1(child[u][1]);
-			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
+			v = val[u];
+			mul1 = 0;
+			mul2 = 0;
+			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 		}
 	}
 
@@ -174,7 +184,10 @@ public static void dfs2() {
 					stack[++siz][0] = child[u][0];
 					stack[siz][1] = 0;
 				} else {
-					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
+					v = val[u];
+					mul1 = 0;
+					mul2 = 0;
+					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 				}
 			}
 		}
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 5b72e3eff..53eb2e289 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -98,7 +98,9 @@
 //    return rt;
 //}
 //
-//int merge(int l, int r, int t1, int t2, long long v, long long mul1, long long mul2) {
+//long long v, mul1, mul2;
+//
+//int merge(int l, int r, int t1, int t2) {
 //    if (t1 == 0 || t2 == 0) {
 //        if (t1) {
 //            lazy(t1, mul1);
@@ -119,9 +121,14 @@
 //    long long rsum1 = sum[rs1];
 //    long long lsum2 = sum[ls2];
 //    long long rsum2 = sum[rs2];
-//    long long tmp = (1 - v + MOD) % MOD;
-//    ls[t1] = merge(l, mid, ls1, ls2, v, (mul1 + rsum2 * tmp) % MOD, (mul2 + rsum1 * tmp) % MOD);
-//    rs[t1] = merge(mid + 1, r, rs1, rs2, v, (mul1 + lsum2 * v) % MOD, (mul2 + lsum1 * v) % MOD);
+//    long long tmp1 = mul1;
+//    long long tmp2 = mul2;
+//    mul1 = (tmp1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
+//    mul2 = (tmp2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
+//    ls[t1] = merge(l, mid, ls1, ls2);
+//    mul1 = (tmp1 + lsum2 * v) % MOD;
+//    mul2 = (tmp2 + lsum1 * v) % MOD;
+//    rs[t1] = merge(mid + 1, r, rs1, rs2);
 //    up(t1);
 //    return t1;
 //}
@@ -135,7 +142,10 @@
 //    } else {
 //        dfs(child[u][0]);
 //        dfs(child[u][1]);
-//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
+//        v = val[u];
+//        mul1 = 0;
+//        mul2 = 0;
+//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 //    }
 //}
 //

From b441efc31818ab1c09179c1d16afeff49738a631 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 15:04:00 +0800
Subject: [PATCH 1601/1712] modify code

---
 src/class182/Code02_Minimax1.java | 12 ++++++------
 src/class182/Code02_Minimax2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 0e672377a..e859e7082 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -126,13 +126,13 @@ public static int merge(int l, int r, int t1, int t2) {
 		long rsum1 = sum[rs1];
 		long lsum2 = sum[ls2];
 		long rsum2 = sum[rs2];
-		long tmp1 = mul1;
-		long tmp2 = mul2;
-		mul1 = (tmp1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
-		mul2 = (tmp2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
+		long m1 = mul1;
+		long m2 = mul2;
+		mul1 = (m1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
+		mul2 = (m2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
 		ls[t1] = merge(l, mid, ls1, ls2);
-		mul1 = (tmp1 + lsum2 * v) % MOD;
-		mul2 = (tmp2 + lsum1 * v) % MOD;
+		mul1 = (m1 + lsum2 * v) % MOD;
+		mul2 = (m2 + lsum1 * v) % MOD;
 		rs[t1] = merge(mid + 1, r, rs1, rs2);
 		up(t1);
 		return t1;
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 53eb2e289..6af6a8cc1 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -121,13 +121,13 @@
 //    long long rsum1 = sum[rs1];
 //    long long lsum2 = sum[ls2];
 //    long long rsum2 = sum[rs2];
-//    long long tmp1 = mul1;
-//    long long tmp2 = mul2;
-//    mul1 = (tmp1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
-//    mul2 = (tmp2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
+//    long long m1 = mul1;
+//    long long m2 = mul2;
+//    mul1 = (m1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
+//    mul2 = (m2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
 //    ls[t1] = merge(l, mid, ls1, ls2);
-//    mul1 = (tmp1 + lsum2 * v) % MOD;
-//    mul2 = (tmp2 + lsum1 * v) % MOD;
+//    mul1 = (m1 + lsum2 * v) % MOD;
+//    mul2 = (m2 + lsum1 * v) % MOD;
 //    rs[t1] = merge(mid + 1, r, rs1, rs2);
 //    up(t1);
 //    return t1;

From 093b4d94641fdf45670b385b8284952dbe8122b0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 15:15:58 +0800
Subject: [PATCH 1602/1712] modify code

---
 src/class182/Code02_Minimax1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index e859e7082..ea060869a 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -157,7 +157,7 @@ public static void dfs1(int u) {
 
 	// dfs1改成迭代版
 	public static void dfs2() {
-		int[][] stack = new int[n][2];
+		int[][] stack = new int[n + 1][2];
 		int siz = 0;
 		stack[++siz][0] = 1;
 		stack[siz][1] = 0;

From ecd695adc3a4026f479cd173138d270c51870942 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 16:06:27 +0800
Subject: [PATCH 1603/1712] modify code

---
 src/class182/Code02_Minimax1.java | 25 +++++++++++--------------
 src/class182/Code02_Minimax2.java | 12 ++++++------
 2 files changed, 17 insertions(+), 20 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index ea060869a..d4add03ec 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -2,10 +2,7 @@
 
 // 根节点的概率，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
-// 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code02_Minimax2文件就是C++的实现
-// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -15,9 +12,9 @@
 
 public class Code02_Minimax1 {
 
-	public static int MAXN = 300001;
-	public static int MAXT = MAXN * 40;
-	public static int MOD = 998244353;
+	public static final int MAXN = 300001;
+	public static final int MAXT = MAXN * 40;
+	public static final int MOD = 998244353;
 	public static int n;
 
 	public static int[] fa = new int[MAXN];
@@ -103,7 +100,7 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static long v, mul1, mul2;
+	public static long p, mul1, mul2;
 
 	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
@@ -128,11 +125,11 @@ public static int merge(int l, int r, int t1, int t2) {
 		long rsum2 = sum[rs2];
 		long m1 = mul1;
 		long m2 = mul2;
-		mul1 = (m1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
-		mul2 = (m2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
+		mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
+		mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
 		ls[t1] = merge(l, mid, ls1, ls2);
-		mul1 = (m1 + lsum2 * v) % MOD;
-		mul2 = (m2 + lsum1 * v) % MOD;
+		mul1 = (m1 + lsum2 * p) % MOD;
+		mul2 = (m2 + lsum1 * p) % MOD;
 		rs[t1] = merge(mid + 1, r, rs1, rs2);
 		up(t1);
 		return t1;
@@ -148,7 +145,7 @@ public static void dfs1(int u) {
 		} else {
 			dfs1(child[u][0]);
 			dfs1(child[u][1]);
-			v = val[u];
+			p = val[u];
 			mul1 = 0;
 			mul2 = 0;
 			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
@@ -184,7 +181,7 @@ public static void dfs2() {
 					stack[++siz][0] = child[u][0];
 					stack[siz][1] = 0;
 				} else {
-					v = val[u];
+					p = val[u];
 					mul1 = 0;
 					mul2 = 0;
 					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 6af6a8cc1..5d95d92e9 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -98,7 +98,7 @@
 //    return rt;
 //}
 //
-//long long v, mul1, mul2;
+//long long p, mul1, mul2;
 //
 //int merge(int l, int r, int t1, int t2) {
 //    if (t1 == 0 || t2 == 0) {
@@ -123,11 +123,11 @@
 //    long long rsum2 = sum[rs2];
 //    long long m1 = mul1;
 //    long long m2 = mul2;
-//    mul1 = (m1 + rsum2 * (1 - v + MOD) % MOD) % MOD;
-//    mul2 = (m2 + rsum1 * (1 - v + MOD) % MOD) % MOD;
+//    mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
+//    mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
 //    ls[t1] = merge(l, mid, ls1, ls2);
-//    mul1 = (m1 + lsum2 * v) % MOD;
-//    mul2 = (m2 + lsum1 * v) % MOD;
+//    mul1 = (m1 + lsum2 * p) % MOD;
+//    mul2 = (m2 + lsum1 * p) % MOD;
 //    rs[t1] = merge(mid + 1, r, rs1, rs2);
 //    up(t1);
 //    return t1;
@@ -142,7 +142,7 @@
 //    } else {
 //        dfs(child[u][0]);
 //        dfs(child[u][1]);
-//        v = val[u];
+//        p = val[u];
 //        mul1 = 0;
 //        mul2 = 0;
 //        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);

From f43294305c6036d2e9329e4c7ab42bb02bbb77c5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 16:09:53 +0800
Subject: [PATCH 1604/1712] modify code

---
 src/class182/Code02_Minimax1.java | 4 ++--
 src/class182/Code03_Fate1.java    | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index d4add03ec..3d8281839 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -12,8 +12,8 @@
 
 public class Code02_Minimax1 {
 
-	public static final int MAXN = 300001;
-	public static final int MAXT = MAXN * 40;
+	public static int MAXN = 300001;
+	public static int MAXT = MAXN * 40;
 	public static final int MOD = 998244353;
 	public static int n;
 
diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index e0d6f6cd7..516d86d1a 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -11,7 +11,7 @@ public class Code03_Fate1 {
 
 	public static int MAXN = 500001;
 	public static int MAXT = MAXN * 40;
-	public static int MOD = 998244353;
+	public static final int MOD = 998244353;
 	public static int n, m;
 
 	public static int[] head = new int[MAXN];

From 85d07473c49d67eebb59af301496add2c23b625b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 16:23:17 +0800
Subject: [PATCH 1605/1712] modify code

---
 src/class182/Code02_Minimax1.java | 16 ++++++----------
 src/class182/Code02_Minimax2.java | 16 ++++++----------
 2 files changed, 12 insertions(+), 20 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 3d8281839..c919ed152 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -115,22 +115,18 @@ public static int merge(int l, int r, int t1, int t2) {
 		down(t1);
 		down(t2);
 		int mid = (l + r) >> 1;
-		int ls1 = ls[t1];
-		int rs1 = rs[t1];
-		int ls2 = ls[t2];
-		int rs2 = rs[t2];
-		long lsum1 = sum[ls1];
-		long rsum1 = sum[rs1];
-		long lsum2 = sum[ls2];
-		long rsum2 = sum[rs2];
+		long lsum1 = sum[ls[t1]];
+		long rsum1 = sum[rs[t1]];
+		long lsum2 = sum[ls[t2]];
+		long rsum2 = sum[rs[t2]];
 		long m1 = mul1;
 		long m2 = mul2;
 		mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
 		mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-		ls[t1] = merge(l, mid, ls1, ls2);
+		ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 		mul1 = (m1 + lsum2 * p) % MOD;
 		mul2 = (m2 + lsum1 * p) % MOD;
-		rs[t1] = merge(mid + 1, r, rs1, rs2);
+		rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 		up(t1);
 		return t1;
 	}
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 5d95d92e9..b0366abe0 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -113,22 +113,18 @@
 //    down(t1);
 //    down(t2);
 //    int mid = (l + r) >> 1;
-//    int ls1 = ls[t1];
-//    int rs1 = rs[t1];
-//    int ls2 = ls[t2];
-//    int rs2 = rs[t2];
-//    long long lsum1 = sum[ls1];
-//    long long rsum1 = sum[rs1];
-//    long long lsum2 = sum[ls2];
-//    long long rsum2 = sum[rs2];
+//    long long lsum1 = sum[ls[t1]];
+//    long long rsum1 = sum[rs[t1]];
+//    long long lsum2 = sum[ls[t2]];
+//    long long rsum2 = sum[rs[t2]];
 //    long long m1 = mul1;
 //    long long m2 = mul2;
 //    mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
 //    mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-//    ls[t1] = merge(l, mid, ls1, ls2);
+//    ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 //    mul1 = (m1 + lsum2 * p) % MOD;
 //    mul2 = (m2 + lsum1 * p) % MOD;
-//    rs[t1] = merge(mid + 1, r, rs1, rs2);
+//    rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 //    up(t1);
 //    return t1;
 //}

From d24a6367a565fe06368faf5e580cedfa5fdc27e8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 16:48:47 +0800
Subject: [PATCH 1606/1712] modify code

---
 src/class182/Code02_Minimax1.java | 12 ++++++------
 src/class182/Code02_Minimax2.java | 10 +++++-----
 2 files changed, 11 insertions(+), 11 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index c919ed152..a3994f793 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -79,21 +79,21 @@ public static void down(int i) {
 		}
 	}
 
-	public static int update(int jobi, int jobv, int l, int r, int i) {
+	public static int insert(int jobi, int l, int r, int i) {
 		int rt = i;
 		if (rt == 0) {
 			rt = ++cntt;
 			mul[rt] = 1;
 		}
 		if (l == r) {
-			sum[rt] = jobv % MOD;
+			sum[rt] = 1;
 		} else {
 			down(rt);
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
-				ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+				ls[rt] = insert(jobi, l, mid, ls[rt]);
 			} else {
-				rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+				rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
 			}
 			up(rt);
 		}
@@ -134,7 +134,7 @@ public static int merge(int l, int r, int t1, int t2) {
 	// 迭代版，java会爆栈，C++可以通过
 	public static void dfs1(int u) {
 		if (childCnt[u] == 0) {
-			root[u] = update(val[u], 1, 1, cntv, root[u]);
+			root[u] = insert(val[u], 1, cntv, root[u]);
 		} else if (childCnt[u] == 1) {
 			dfs1(child[u][0]);
 			root[u] = root[child[u][0]];
@@ -158,7 +158,7 @@ public static void dfs2() {
 			int u = stack[siz][0];
 			int s = stack[siz--][1];
 			if (childCnt[u] == 0) {
-				root[u] = update(val[u], 1, 1, cntv, root[u]);
+				root[u] = insert(val[u], 1, cntv, root[u]);
 			} else if (childCnt[u] == 1) {
 				if (s == 0) {
 					stack[++siz][0] = u;
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index b0366abe0..017d2a5fb 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -77,21 +77,21 @@
 //    }
 //}
 //
-//int update(int jobi, int jobv, int l, int r, int i) {
+//int insert(int jobi, int l, int r, int i) {
 //    int rt = i;
 //    if (rt == 0) {
 //        rt = ++cntt;
 //        mul[rt] = 1;
 //    }
 //    if (l == r) {
-//    	sum[rt] = jobv % MOD;
+//    	sum[rt] = 1;
 //    } else {
 //        down(rt);
 //        int mid = (l + r) >> 1;
 //        if (jobi <= mid) {
-//            ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
 //        } else {
-//            rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
 //        }
 //        up(rt);
 //    }
@@ -131,7 +131,7 @@
 //
 //void dfs(int u) {
 //    if (childCnt[u] == 0) {
-//        root[u] = update(val[u], 1, 1, cntv, root[u]);
+//        root[u] = insert(val[u], 1, cntv, root[u]);
 //    } else if (childCnt[u] == 1) {
 //        dfs(child[u][0]);
 //        root[u] = root[child[u][0]];

From 71731635132df000c2ba3293dd556248ad307f2d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 16:59:17 +0800
Subject: [PATCH 1607/1712] modify code

---
 src/class182/Code03_Fate1.java | 7 ++++++-
 1 file changed, 6 insertions(+), 1 deletion(-)

diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 516d86d1a..2e21df09b 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -6,6 +6,8 @@
 
 import java.io.IOException;
 import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
 
 public class Code03_Fate1 {
 
@@ -215,6 +217,7 @@ public static void dp2() {
 
 	public static void main(String[] args) throws IOException {
 		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
 		for (int i = 1, u, v; i < n; i++) {
 			u = in.nextInt();
@@ -233,7 +236,9 @@ public static void main(String[] args) throws IOException {
 		// dp1(1, 0);
 		dp2();
 		long ans = query(0, 0, 0, n, root[1]) % MOD;
-		System.out.println(ans);
+		out.println(ans);
+		out.flush();
+		out.close();
 	}
 
 	// 读写工具类

From 0cf9f10209e820203e41a3c09355f99f5069cacd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 18:25:46 +0800
Subject: [PATCH 1608/1712] modify code

---
 src/class182/Code02_Minimax1.java | 32 +++++++++++++++++--------------
 src/class182/Code02_Minimax2.java | 32 +++++++++++++++++--------------
 2 files changed, 36 insertions(+), 28 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index a3994f793..51706c75f 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -114,20 +114,24 @@ public static int merge(int l, int r, int t1, int t2) {
 		}
 		down(t1);
 		down(t2);
-		int mid = (l + r) >> 1;
-		long lsum1 = sum[ls[t1]];
-		long rsum1 = sum[rs[t1]];
-		long lsum2 = sum[ls[t2]];
-		long rsum2 = sum[rs[t2]];
-		long m1 = mul1;
-		long m2 = mul2;
-		mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
-		mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-		ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-		mul1 = (m1 + lsum2 * p) % MOD;
-		mul2 = (m2 + lsum1 * p) % MOD;
-		rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
-		up(t1);
+		if (l == r) {
+			sum[t1] = (sum[t1] * mul1 % MOD + sum[t2] * mul2 % MOD) % MOD;
+		} else {
+			int mid = (l + r) >> 1;
+			long lsum1 = sum[ls[t1]];
+			long rsum1 = sum[rs[t1]];
+			long lsum2 = sum[ls[t2]];
+			long rsum2 = sum[rs[t2]];
+			long m1 = mul1;
+			long m2 = mul2;
+			mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
+			mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			mul1 = (m1 + lsum2 * p) % MOD;
+			mul2 = (m2 + lsum1 * p) % MOD;
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+		}
 		return t1;
 	}
 
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 017d2a5fb..a88a65485 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -112,20 +112,24 @@
 //    }
 //    down(t1);
 //    down(t2);
-//    int mid = (l + r) >> 1;
-//    long long lsum1 = sum[ls[t1]];
-//    long long rsum1 = sum[rs[t1]];
-//    long long lsum2 = sum[ls[t2]];
-//    long long rsum2 = sum[rs[t2]];
-//    long long m1 = mul1;
-//    long long m2 = mul2;
-//    mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
-//    mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-//    ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-//    mul1 = (m1 + lsum2 * p) % MOD;
-//    mul2 = (m2 + lsum1 * p) % MOD;
-//    rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
-//    up(t1);
+//    if (l == r) {
+//        sum[t1] = (sum[t1] * mul1 % MOD + sum[t2] * mul2 % MOD) % MOD;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        long long lsum1 = sum[ls[t1]];
+//        long long rsum1 = sum[rs[t1]];
+//        long long lsum2 = sum[ls[t2]];
+//        long long rsum2 = sum[rs[t2]];
+//        long long m1 = mul1;
+//        long long m2 = mul2;
+//        mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
+//        mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        mul1 = (m1 + lsum2 * p) % MOD;
+//        mul2 = (m2 + lsum1 * p) % MOD;
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//    }
 //    return t1;
 //}
 //

From 1f2f951968b51dac1f84ba3c0d1aa0dbd2a39d63 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 27 Oct 2025 20:58:36 +0800
Subject: [PATCH 1609/1712] modify code

---
 src/class182/Code02_Minimax1.java | 4 ++--
 src/class182/Code02_Minimax2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 51706c75f..93e58551e 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -112,11 +112,11 @@ public static int merge(int l, int r, int t1, int t2) {
 			}
 			return t1 + t2;
 		}
-		down(t1);
-		down(t2);
 		if (l == r) {
 			sum[t1] = (sum[t1] * mul1 % MOD + sum[t2] * mul2 % MOD) % MOD;
 		} else {
+			down(t1);
+			down(t2);
 			int mid = (l + r) >> 1;
 			long lsum1 = sum[ls[t1]];
 			long rsum1 = sum[rs[t1]];
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index a88a65485..0bd981f9c 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -110,11 +110,11 @@
 //        }
 //        return t1 + t2;
 //    }
-//    down(t1);
-//    down(t2);
 //    if (l == r) {
 //        sum[t1] = (sum[t1] * mul1 % MOD + sum[t2] * mul2 % MOD) % MOD;
 //    } else {
+//        down(t1);
+//        down(t2);
 //        int mid = (l + r) >> 1;
 //        long long lsum1 = sum[ls[t1]];
 //        long long rsum1 = sum[rs[t1]];

From 207de0f683ebb3ed903ed73b6458641cbe18cd08 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 30 Oct 2025 17:44:38 +0800
Subject: [PATCH 1610/1712] modify code

---
 src/class182/Code02_Minimax1.java | 20 +++++++++-----------
 src/class182/Code02_Minimax2.java | 17 ++++++++---------
 src/class182/Code03_Fate1.java    | 24 ++++++++++++------------
 3 files changed, 29 insertions(+), 32 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 93e58551e..dca531356 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -105,15 +105,15 @@ public static int insert(int jobi, int l, int r, int i) {
 	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
-				lazy(t1, mul1);
+				lazy(t1, mul2);
 			}
 			if (t2 != 0) {
-				lazy(t2, mul2);
+				lazy(t2, mul1);
 			}
 			return t1 + t2;
 		}
 		if (l == r) {
-			sum[t1] = (sum[t1] * mul1 % MOD + sum[t2] * mul2 % MOD) % MOD;
+			sum[t1] = (sum[t1] * mul2 % MOD + sum[t2] * mul1 % MOD) % MOD;
 		} else {
 			down(t1);
 			down(t2);
@@ -124,11 +124,11 @@ public static int merge(int l, int r, int t1, int t2) {
 			long rsum2 = sum[rs[t2]];
 			long m1 = mul1;
 			long m2 = mul2;
-			mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
-			mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+			mul1 = (m1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+			mul2 = (m2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-			mul1 = (m1 + lsum2 * p) % MOD;
-			mul2 = (m2 + lsum1 * p) % MOD;
+			mul1 = (m1 + lsum1 * p) % MOD;
+			mul2 = (m2 + lsum2 * p) % MOD;
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
 		}
@@ -146,8 +146,7 @@ public static void dfs1(int u) {
 			dfs1(child[u][0]);
 			dfs1(child[u][1]);
 			p = val[u];
-			mul1 = 0;
-			mul2 = 0;
+			mul1 = mul2 = 0;
 			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 		}
 	}
@@ -182,8 +181,7 @@ public static void dfs2() {
 					stack[siz][1] = 0;
 				} else {
 					p = val[u];
-					mul1 = 0;
-					mul2 = 0;
+					mul1 = mul2 = 0;
 					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 				}
 			}
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 0bd981f9c..79be42751 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -103,15 +103,15 @@
 //int merge(int l, int r, int t1, int t2) {
 //    if (t1 == 0 || t2 == 0) {
 //        if (t1) {
-//            lazy(t1, mul1);
+//            lazy(t1, mul2);
 //        }
 //        if (t2) {
-//            lazy(t2, mul2);
+//            lazy(t2, mul1);
 //        }
 //        return t1 + t2;
 //    }
 //    if (l == r) {
-//        sum[t1] = (sum[t1] * mul1 % MOD + sum[t2] * mul2 % MOD) % MOD;
+//        sum[t1] = (sum[t1] * mul2 % MOD + sum[t2] * mul1 % MOD) % MOD;
 //    } else {
 //        down(t1);
 //        down(t2);
@@ -122,11 +122,11 @@
 //        long long rsum2 = sum[rs[t2]];
 //        long long m1 = mul1;
 //        long long m2 = mul2;
-//        mul1 = (m1 + rsum2 * (1 - p + MOD) % MOD) % MOD;
-//        mul2 = (m2 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+//        mul1 = (m1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+//        mul2 = (m2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
 //        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-//        mul1 = (m1 + lsum2 * p) % MOD;
-//        mul2 = (m2 + lsum1 * p) % MOD;
+//        mul1 = (m1 + lsum1 * p) % MOD;
+//        mul2 = (m2 + lsum2 * p) % MOD;
 //        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 //        up(t1);
 //    }
@@ -143,8 +143,7 @@
 //        dfs(child[u][0]);
 //        dfs(child[u][1]);
 //        p = val[u];
-//        mul1 = 0;
-//        mul2 = 0;
+//        mul1 = mul2 = 0;
 //        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 //    }
 //}
diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 2e21df09b..741e79f15 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -90,20 +90,20 @@ public static int build(int jobi, int l, int r) {
 	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
-				sum2 = (sum2 + sum[t1]) % MOD;
-				lazy(t1, sum1);
+				sum1 = (sum1 + sum[t1]) % MOD;
+				lazy(t1, sum2);
 			}
 			if (t2 != 0) {
-				sum1 = (sum1 + sum[t2]) % MOD;
-				lazy(t2, sum2);
+				sum2 = (sum2 + sum[t2]) % MOD;
+				lazy(t2, sum1);
 			}
 			return t1 + t2;
 		}
 		if (l == r) {
-			sum1 = (sum1 + sum[t2]) % MOD;
-			long tmp = sum2;
-			sum2 = (sum2 + sum[t1]) % MOD;
-			sum[t1] = ((sum[t1] * sum1) % MOD + (sum[t2] * tmp) % MOD) % MOD;
+			long tmp = sum1;
+			sum1 = (sum1 + sum[t1]) % MOD;
+			sum2 = (sum2 + sum[t2]) % MOD;
+			sum[t1] = ((sum[t1] * sum2) % MOD + (sum[t2] * tmp) % MOD) % MOD;
 		} else {
 			down(t1);
 			down(t2);
@@ -178,8 +178,8 @@ public static void dp1(int u, int fa) {
 		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 			int v = to[ei];
 			if (v != fa) {
-				sum1 = query(0, dep[u], 0, n, root[v]);
-				sum2 = 0;
+				sum1 = 0;
+				sum2 = query(0, dep[u], 0, n, root[v]);
 				root[u] = merge(0, n, root[u], root[v]);
 			}
 		}
@@ -206,8 +206,8 @@ public static void dp2() {
 				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 					int v = to[ei];
 					if (v != f) {
-						sum1 = query(0, dep[u], 0, n, root[v]);
-						sum2 = 0;
+						sum1 = 0;
+						sum2 = query(0, dep[u], 0, n, root[v]);
 						root[u] = merge(0, n, root[u], root[v]);
 					}
 				}

From cb8b447ceaa0b9a0d92b454d82e05fbfeefe6080 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 30 Oct 2025 17:51:32 +0800
Subject: [PATCH 1611/1712] modify code

---
 src/class182/Code02_Minimax1.java | 24 ++++++++++++------------
 src/class182/Code02_Minimax2.java | 22 +++++++++++-----------
 2 files changed, 23 insertions(+), 23 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index dca531356..2790435d8 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -100,20 +100,20 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
-	public static long p, mul1, mul2;
+	public static long p, sum1, sum2;
 
 	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
-				lazy(t1, mul2);
+				lazy(t1, sum2);
 			}
 			if (t2 != 0) {
-				lazy(t2, mul1);
+				lazy(t2, sum1);
 			}
 			return t1 + t2;
 		}
 		if (l == r) {
-			sum[t1] = (sum[t1] * mul2 % MOD + sum[t2] * mul1 % MOD) % MOD;
+			sum[t1] = (sum[t1] * sum2 % MOD + sum[t2] * sum1 % MOD) % MOD;
 		} else {
 			down(t1);
 			down(t2);
@@ -122,13 +122,13 @@ public static int merge(int l, int r, int t1, int t2) {
 			long rsum1 = sum[rs[t1]];
 			long lsum2 = sum[ls[t2]];
 			long rsum2 = sum[rs[t2]];
-			long m1 = mul1;
-			long m2 = mul2;
-			mul1 = (m1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-			mul2 = (m2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
+			long s1 = sum1;
+			long s2 = sum2;
+			sum1 = (s1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+			sum2 = (s2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-			mul1 = (m1 + lsum1 * p) % MOD;
-			mul2 = (m2 + lsum2 * p) % MOD;
+			sum1 = (s1 + lsum1 * p) % MOD;
+			sum2 = (s2 + lsum2 * p) % MOD;
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
 		}
@@ -146,7 +146,7 @@ public static void dfs1(int u) {
 			dfs1(child[u][0]);
 			dfs1(child[u][1]);
 			p = val[u];
-			mul1 = mul2 = 0;
+			sum1 = sum2 = 0;
 			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 		}
 	}
@@ -181,7 +181,7 @@ public static void dfs2() {
 					stack[siz][1] = 0;
 				} else {
 					p = val[u];
-					mul1 = mul2 = 0;
+					sum1 = sum2 = 0;
 					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 				}
 			}
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 79be42751..f0d0d639a 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -98,20 +98,20 @@
 //    return rt;
 //}
 //
-//long long p, mul1, mul2;
+//long long p, sum1, sum2;
 //
 //int merge(int l, int r, int t1, int t2) {
 //    if (t1 == 0 || t2 == 0) {
 //        if (t1) {
-//            lazy(t1, mul2);
+//            lazy(t1, sum2);
 //        }
 //        if (t2) {
-//            lazy(t2, mul1);
+//            lazy(t2, sum1);
 //        }
 //        return t1 + t2;
 //    }
 //    if (l == r) {
-//        sum[t1] = (sum[t1] * mul2 % MOD + sum[t2] * mul1 % MOD) % MOD;
+//        sum[t1] = (sum[t1] * sum2 % MOD + sum[t2] * sum1 % MOD) % MOD;
 //    } else {
 //        down(t1);
 //        down(t2);
@@ -120,13 +120,13 @@
 //        long long rsum1 = sum[rs[t1]];
 //        long long lsum2 = sum[ls[t2]];
 //        long long rsum2 = sum[rs[t2]];
-//        long long m1 = mul1;
-//        long long m2 = mul2;
-//        mul1 = (m1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-//        mul2 = (m2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
+//        long long s1 = sum1;
+//        long long s2 = sum2;
+//        sum1 = (s1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
+//        sum2 = (s2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
 //        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-//        mul1 = (m1 + lsum1 * p) % MOD;
-//        mul2 = (m2 + lsum2 * p) % MOD;
+//        sum1 = (s1 + lsum1 * p) % MOD;
+//        sum2 = (s2 + lsum2 * p) % MOD;
 //        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 //        up(t1);
 //    }
@@ -143,7 +143,7 @@
 //        dfs(child[u][0]);
 //        dfs(child[u][1]);
 //        p = val[u];
-//        mul1 = mul2 = 0;
+//        sum1 = sum2 = 0;
 //        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
 //    }
 //}

From cc235275caa7e18d8afa879f776cbd34f9983613 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 30 Oct 2025 23:44:30 +0800
Subject: [PATCH 1612/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java |  8 ++++----
 src/class182/Code03_Fate1.java         | 23 ++++++++++++-----------
 2 files changed, 16 insertions(+), 15 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 285673d69..59feaa0cb 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -95,13 +95,13 @@ public static int merge(int l, int r, int t1, int t2) {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			int tmp1 = max1;
-			int tmp2 = max2;
+			int mx1 = max1;
+			int mx2 = max2;
 			max1 = Math.max(max1, max[rs[t1]]);
 			max2 = Math.max(max2, max[rs[t2]]);
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-			max1 = tmp1;
-			max2 = tmp2;
+			max1 = mx1;
+			max2 = mx2;
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
 		}
diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 741e79f15..4e77c69d2 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -70,16 +70,16 @@ public static void down(int i) {
 		}
 	}
 
-	public static int build(int jobi, int l, int r) {
+	public static int insert(int jobi, int l, int r) {
 		int rt = ++cntt;
 		sum[rt] = 1;
 		mul[rt] = 1;
 		if (l < r) {
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
-				ls[rt] = build(jobi, l, mid);
+				ls[rt] = insert(jobi, l, mid);
 			} else {
-				rs[rt] = build(jobi, mid + 1, r);
+				rs[rt] = insert(jobi, mid + 1, r);
 			}
 		}
 		return rt;
@@ -90,25 +90,26 @@ public static int build(int jobi, int l, int r) {
 	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
-				sum1 = (sum1 + sum[t1]) % MOD;
 				lazy(t1, sum2);
 			}
 			if (t2 != 0) {
-				sum2 = (sum2 + sum[t2]) % MOD;
 				lazy(t2, sum1);
 			}
 			return t1 + t2;
 		}
 		if (l == r) {
-			long tmp = sum1;
-			sum1 = (sum1 + sum[t1]) % MOD;
-			sum2 = (sum2 + sum[t2]) % MOD;
-			sum[t1] = ((sum[t1] * sum2) % MOD + (sum[t2] * tmp) % MOD) % MOD;
+			sum[t1] = ((sum[t1] * (sum2 + sum[t2])) % MOD + (sum[t2] * sum1) % MOD) % MOD;
 		} else {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
+			long lsum1 = sum[ls[t1]];
+			long lsum2 = sum[ls[t2]];
+			long s1 = sum1;
+			long s2 = sum2;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			sum1 = (s1 + lsum1) % MOD;
+			sum2 = (s2 + lsum2) % MOD;
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			sum[t1] = (sum[ls[t1]] + sum[rs[t1]]) % MOD;
 		}
@@ -168,7 +169,7 @@ public static void dfs2() {
 
 	// 递归版，java会爆栈，C++可以通过
 	public static void dp1(int u, int fa) {
-		root[u] = build(maxdep[u], 0, n);
+		root[u] = insert(maxdep[u], 0, n);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa) {
@@ -192,7 +193,7 @@ public static void dp2() {
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
-				root[u] = build(maxdep[u], 0, n);
+				root[u] = insert(maxdep[u], 0, n);
 				e = head[u];
 			} else {
 				e = nxt[e];

From ecd4b566832dcd137e928d4be557ea39192cbc43 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 02:17:54 +0800
Subject: [PATCH 1613/1712] modify code

---
 src/class182/Code03_Fate1.java | 30 ++++++++++++++++++++----------
 1 file changed, 20 insertions(+), 10 deletions(-)

diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 4e77c69d2..2dabdadf7 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -55,6 +55,10 @@ public static void addEdge(int u, int v) {
 		head[u] = cntg;
 	}
 
+	public static void up(int i) {
+		sum[i] = (sum[ls[i]] + sum[rs[i]]) % MOD;
+	}
+
 	public static void lazy(int i, long v) {
 		if (i != 0) {
 			sum[i] = sum[i] * v % MOD;
@@ -70,17 +74,23 @@ public static void down(int i) {
 		}
 	}
 
-	public static int insert(int jobi, int l, int r) {
-		int rt = ++cntt;
-		sum[rt] = 1;
-		mul[rt] = 1;
-		if (l < r) {
+	public static int insert(int jobi, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = ++cntt;
+			mul[rt] = 1;
+		}
+		if (l == r) {
+			sum[rt] = 1;
+		} else {
+			down(rt);
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
-				ls[rt] = insert(jobi, l, mid);
+				ls[rt] = insert(jobi, l, mid, ls[rt]);
 			} else {
-				rs[rt] = insert(jobi, mid + 1, r);
+				rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
 			}
+			up(rt);
 		}
 		return rt;
 	}
@@ -111,7 +121,7 @@ public static int merge(int l, int r, int t1, int t2) {
 			sum1 = (s1 + lsum1) % MOD;
 			sum2 = (s2 + lsum2) % MOD;
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
-			sum[t1] = (sum[ls[t1]] + sum[rs[t1]]) % MOD;
+			up(t1);
 		}
 		return t1;
 	}
@@ -169,7 +179,7 @@ public static void dfs2() {
 
 	// 递归版，java会爆栈，C++可以通过
 	public static void dp1(int u, int fa) {
-		root[u] = insert(maxdep[u], 0, n);
+		root[u] = insert(maxdep[u], 0, n, root[u]);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa) {
@@ -193,7 +203,7 @@ public static void dp2() {
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
-				root[u] = insert(maxdep[u], 0, n);
+				root[u] = insert(maxdep[u], 0, n, root[u]);
 				e = head[u];
 			} else {
 				e = nxt[e];

From a99df689cca00770364069b598f4d489d7c68ded Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 13:36:24 +0800
Subject: [PATCH 1614/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 17 ++++-----------
 src/class182/Code02_Minimax1.java      | 30 ++++++++------------------
 src/class182/Code02_Minimax2.java      | 26 +++++++---------------
 src/class182/Code03_Fate1.java         | 24 ++++++---------------
 4 files changed, 28 insertions(+), 69 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 59feaa0cb..72ffb7843 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -77,9 +77,7 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
-	public static int max1, max2;
-
-	public static int merge(int l, int r, int t1, int t2) {
+	public static int merge(int l, int r, int t1, int t2, int max1, int max2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
 				lazy(t1, max2);
@@ -95,14 +93,8 @@ public static int merge(int l, int r, int t1, int t2) {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			int mx1 = max1;
-			int mx2 = max2;
-			max1 = Math.max(max1, max[rs[t1]]);
-			max2 = Math.max(max2, max[rs[t2]]);
-			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-			max1 = mx1;
-			max2 = mx2;
-			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			ls[t1] = merge(l, mid, ls[t1], ls[t2], Math.max(max1, max[rs[t1]]), Math.max(max2, max[rs[t2]]));
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], max1, max2);
 			up(t1);
 		}
 		return t1;
@@ -133,8 +125,7 @@ public static void dp(int u) {
 			int v = to[e];
 			dp(v);
 			val += query(arr[u], MAXV, 1, MAXV, root[v]);
-			max1 = max2 = 0;
-			root[u] = merge(1, MAXV, root[u], root[v]);
+			root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
 		}
 		root[u] = add(arr[u], val, 1, MAXV, root[u]);
 	}
diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 2790435d8..0896e1778 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -100,9 +100,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
-	public static long p, sum1, sum2;
-
-	public static int merge(int l, int r, int t1, int t2) {
+	public static int merge(int l, int r, int t1, int t2, int p, long sum1, long sum2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
 				lazy(t1, sum2);
@@ -118,18 +116,12 @@ public static int merge(int l, int r, int t1, int t2) {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			long lsum1 = sum[ls[t1]];
-			long rsum1 = sum[rs[t1]];
-			long lsum2 = sum[ls[t2]];
-			long rsum2 = sum[rs[t2]];
-			long s1 = sum1;
-			long s2 = sum2;
-			sum1 = (s1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-			sum2 = (s2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
-			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-			sum1 = (s1 + lsum1 * p) % MOD;
-			sum2 = (s2 + lsum2 * p) % MOD;
-			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			long l1 = (sum1 + sum[rs[t1]] * (1 - p + MOD)) % MOD;
+			long l2 = (sum2 + sum[rs[t2]] * (1 - p + MOD)) % MOD;
+			long r1 = (sum1 + sum[ls[t1]] * p) % MOD;
+			long r2 = (sum2 + sum[ls[t2]] * p) % MOD;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2], p, l1, l2);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], p, r1, r2);
 			up(t1);
 		}
 		return t1;
@@ -145,9 +137,7 @@ public static void dfs1(int u) {
 		} else {
 			dfs1(child[u][0]);
 			dfs1(child[u][1]);
-			p = val[u];
-			sum1 = sum2 = 0;
-			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
+			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
 		}
 	}
 
@@ -180,9 +170,7 @@ public static void dfs2() {
 					stack[++siz][0] = child[u][0];
 					stack[siz][1] = 0;
 				} else {
-					p = val[u];
-					sum1 = sum2 = 0;
-					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
+					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
 				}
 			}
 		}
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index f0d0d639a..161b4fbdd 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -98,9 +98,7 @@
 //    return rt;
 //}
 //
-//long long p, sum1, sum2;
-//
-//int merge(int l, int r, int t1, int t2) {
+//int merge(int l, int r, int t1, int t2, int p, long long sum1, long long sum2) {
 //    if (t1 == 0 || t2 == 0) {
 //        if (t1) {
 //            lazy(t1, sum2);
@@ -116,18 +114,12 @@
 //        down(t1);
 //        down(t2);
 //        int mid = (l + r) >> 1;
-//        long long lsum1 = sum[ls[t1]];
-//        long long rsum1 = sum[rs[t1]];
-//        long long lsum2 = sum[ls[t2]];
-//        long long rsum2 = sum[rs[t2]];
-//        long long s1 = sum1;
-//        long long s2 = sum2;
-//        sum1 = (s1 + rsum1 * (1 - p + MOD) % MOD) % MOD;
-//        sum2 = (s2 + rsum2 * (1 - p + MOD) % MOD) % MOD;
-//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-//        sum1 = (s1 + lsum1 * p) % MOD;
-//        sum2 = (s2 + lsum2 * p) % MOD;
-//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        long long l1 = (sum1 + sum[rs[t1]] * (1 - p + MOD)) % MOD;
+//        long long l2 = (sum2 + sum[rs[t2]] * (1 - p + MOD)) % MOD;
+//        long long r1 = (sum1 + sum[ls[t1]] * p) % MOD;
+//        long long r2 = (sum2 + sum[ls[t2]] * p) % MOD;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2], p, l1, l2);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], p, r1, r2);
 //        up(t1);
 //    }
 //    return t1;
@@ -142,9 +134,7 @@
 //    } else {
 //        dfs(child[u][0]);
 //        dfs(child[u][1]);
-//        p = val[u];
-//        sum1 = sum2 = 0;
-//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]]);
+//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
 //    }
 //}
 //
diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 2dabdadf7..763eef28b 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -95,9 +95,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
-	public static long sum1, sum2;
-
-	public static int merge(int l, int r, int t1, int t2) {
+	public static int merge(int l, int r, int t1, int t2, long sum1, long sum2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
 				lazy(t1, sum2);
@@ -113,14 +111,10 @@ public static int merge(int l, int r, int t1, int t2) {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			long lsum1 = sum[ls[t1]];
-			long lsum2 = sum[ls[t2]];
-			long s1 = sum1;
-			long s2 = sum2;
-			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
-			sum1 = (s1 + lsum1) % MOD;
-			sum2 = (s2 + lsum2) % MOD;
-			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			long tmp1 = sum[ls[t1]];
+			long tmp2 = sum[ls[t2]];
+			ls[t1] = merge(l, mid, ls[t1], ls[t2], sum1, sum2);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], sum1 + tmp1, sum2 + tmp2);
 			up(t1);
 		}
 		return t1;
@@ -189,9 +183,7 @@ public static void dp1(int u, int fa) {
 		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 			int v = to[ei];
 			if (v != fa) {
-				sum1 = 0;
-				sum2 = query(0, dep[u], 0, n, root[v]);
-				root[u] = merge(0, n, root[u], root[v]);
+				root[u] = merge(0, n, root[u], root[v], 0, query(0, dep[u], 0, n, root[v]));
 			}
 		}
 	}
@@ -217,9 +209,7 @@ public static void dp2() {
 				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 					int v = to[ei];
 					if (v != f) {
-						sum1 = 0;
-						sum2 = query(0, dep[u], 0, n, root[v]);
-						root[u] = merge(0, n, root[u], root[v]);
+						root[u] = merge(0, n, root[u], root[v], 0, query(0, dep[u], 0, n, root[v]));
 					}
 				}
 			}

From dd70c1885abc6fdeefa220ecad077515947f1972 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 18:06:39 +0800
Subject: [PATCH 1615/1712] modify code

---
 src/class182/Code02_Minimax1.java          |  38 ++--
 src/class182/Code02_Minimax2.java          |  28 +--
 src/class182/Code04_SegmentTreeSplit1.java | 215 +++++++++++++++++++++
 src/class182/Code04_SegmentTreeSplit2.java | 155 +++++++++++++++
 4 files changed, 403 insertions(+), 33 deletions(-)
 create mode 100644 src/class182/Code04_SegmentTreeSplit1.java
 create mode 100644 src/class182/Code04_SegmentTreeSplit2.java

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 0896e1778..8da6229df 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -22,8 +22,8 @@ public class Code02_Minimax1 {
 	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
-	public static int[] childCnt = new int[MAXN];
-	public static int[][] child = new int[MAXN][2];
+	public static int[] sonCnt = new int[MAXN];
+	public static int[][] son = new int[MAXN][2];
 
 	public static int[] root = new int[MAXN];
 	public static int[] ls = new int[MAXT];
@@ -129,15 +129,15 @@ public static int merge(int l, int r, int t1, int t2, int p, long sum1, long sum
 
 	// 迭代版，java会爆栈，C++可以通过
 	public static void dfs1(int u) {
-		if (childCnt[u] == 0) {
+		if (sonCnt[u] == 0) {
 			root[u] = insert(val[u], 1, cntv, root[u]);
-		} else if (childCnt[u] == 1) {
-			dfs1(child[u][0]);
-			root[u] = root[child[u][0]];
+		} else if (sonCnt[u] == 1) {
+			dfs1(son[u][0]);
+			root[u] = root[son[u][0]];
 		} else {
-			dfs1(child[u][0]);
-			dfs1(child[u][1]);
-			root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
+			dfs1(son[u][0]);
+			dfs1(son[u][1]);
+			root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], val[u], 0, 0);
 		}
 	}
 
@@ -150,27 +150,27 @@ public static void dfs2() {
 		while (siz > 0) {
 			int u = stack[siz][0];
 			int s = stack[siz--][1];
-			if (childCnt[u] == 0) {
+			if (sonCnt[u] == 0) {
 				root[u] = insert(val[u], 1, cntv, root[u]);
-			} else if (childCnt[u] == 1) {
+			} else if (sonCnt[u] == 1) {
 				if (s == 0) {
 					stack[++siz][0] = u;
 					stack[siz][1] = 1;
-					stack[++siz][0] = child[u][0];
+					stack[++siz][0] = son[u][0];
 					stack[siz][1] = 0;
 				} else {
-					root[u] = root[child[u][0]];
+					root[u] = root[son[u][0]];
 				}
 			} else {
 				if (s == 0) {
 					stack[++siz][0] = u;
 					stack[siz][1] = 1;
-					stack[++siz][0] = child[u][1];
+					stack[++siz][0] = son[u][1];
 					stack[siz][1] = 0;
-					stack[++siz][0] = child[u][0];
+					stack[++siz][0] = son[u][0];
 					stack[siz][1] = 0;
 				} else {
-					root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
+					root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], val[u], 0, 0);
 				}
 			}
 		}
@@ -193,12 +193,12 @@ public static void getd(int l, int r, int i) {
 	public static void prepare() {
 		for (int i = 1; i <= n; i++) {
 			if (fa[i] != 0) {
-				child[fa[i]][childCnt[fa[i]]++] = i;
+				son[fa[i]][sonCnt[fa[i]]++] = i;
 			}
 		}
 		long inv = power(10000, MOD - 2);
 		for (int i = 1; i <= n; i++) {
-			if (childCnt[i] == 0) {
+			if (sonCnt[i] == 0) {
 				sorted[++cntv] = val[i];
 			} else {
 				val[i] = (int) (inv * val[i] % MOD);
@@ -213,7 +213,7 @@ public static void prepare() {
 		}
 		cntv = len;
 		for (int i = 1; i <= n; i++) {
-			if (childCnt[i] == 0) {
+			if (sonCnt[i] == 0) {
 				val[i] = kth(val[i]);
 			}
 		}
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 161b4fbdd..bc3332700 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -19,8 +19,8 @@
 //int sorted[MAXN];
 //int cntv;
 //
-//int childCnt[MAXN];
-//int child[MAXN][2];
+//int sonCnt[MAXN];
+//int son[MAXN][2];
 //
 //int root[MAXN];
 //int ls[MAXT];
@@ -126,15 +126,15 @@
 //}
 //
 //void dfs(int u) {
-//    if (childCnt[u] == 0) {
+//    if (sonCnt[u] == 0) {
 //        root[u] = insert(val[u], 1, cntv, root[u]);
-//    } else if (childCnt[u] == 1) {
-//        dfs(child[u][0]);
-//        root[u] = root[child[u][0]];
+//    } else if (sonCnt[u] == 1) {
+//        dfs(son[u][0]);
+//        root[u] = root[son[u][0]];
 //    } else {
-//        dfs(child[u][0]);
-//        dfs(child[u][1]);
-//        root[u] = merge(1, cntv, root[child[u][0]], root[child[u][1]], val[u], 0, 0);
+//        dfs(son[u][0]);
+//        dfs(son[u][1]);
+//        root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], val[u], 0, 0);
 //    }
 //}
 //
@@ -155,13 +155,13 @@
 //void prepare() {
 //    for (int i = 1; i <= n; i++) {
 //        if (fa[i] != 0) {
-//            child[fa[i]][childCnt[fa[i]]++] = i;
+//            son[fa[i]][sonCnt[fa[i]]++] = i;
 //        }
 //    }
 //    long long inv = power(10000, MOD - 2);
 //    for (int i = 1; i <= n; i++) {
-//        if (childCnt[i] == 0) {
-//        	sorted[++cntv] = val[i];
+//        if (sonCnt[i] == 0) {
+//            sorted[++cntv] = val[i];
 //        } else {
 //            val[i] = (int)(inv * val[i] % MOD);
 //        }
@@ -170,12 +170,12 @@
 //    int len = 1;
 //    for (int i = 2; i <= cntv; i++) {
 //        if (sorted[len] != sorted[i]) {
-//        	sorted[++len] = sorted[i];
+//            sorted[++len] = sorted[i];
 //        }
 //    }
 //    cntv = len;
 //    for (int i = 1; i <= n; i++) {
-//        if (childCnt[i] == 0) {
+//        if (sonCnt[i] == 0) {
 //            val[i] = kth(val[i]);
 //        }
 //    }
diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
new file mode 100644
index 000000000..79a56edcb
--- /dev/null
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -0,0 +1,215 @@
+package class182;
+
+// 线段树分裂，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5494
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code04_SegmentTreeSplit2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code04_SegmentTreeSplit1 {
+
+	public static int MAXN = 200001;
+	public static int MAXT = MAXN * 40;
+	public static int n, m;
+
+	public static int[] root = new int[MAXN];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static long[] sum = new long[MAXT];
+	public static int cntRoot;
+
+	public static int[] pool = new int[MAXT];
+	public static int top;
+
+	public static void prepare() {
+		top = 0;
+		for (int i = 1; i < MAXT; i++) {
+			pool[++top] = i;
+		}
+	}
+
+	public static int newNode() {
+		return pool[top--];
+	}
+
+	public static void del(int i) {
+		pool[++top] = i;
+		ls[i] = 0;
+		rs[i] = 0;
+		sum[i] = 0;
+	}
+
+	public static int add(int jobi, int jobv, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = newNode();
+		}
+		sum[rt] += jobv;
+		if (l < r) {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+			} else {
+				rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+			}
+		}
+		return rt;
+	}
+
+	public static long query(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return sum[i];
+		}
+		int mid = (l + r) >> 1;
+		long ans = 0;
+		if (jobl <= mid) {
+			ans += query(jobl, jobr, l, mid, ls[i]);
+		}
+		if (jobr > mid) {
+			ans += query(jobl, jobr, mid + 1, r, rs[i]);
+		}
+		return ans;
+	}
+
+	public static int kth(long jobk, int l, int r, int i) {
+		if (i == 0) {
+			return -1;
+		}
+		if (l == r) {
+			return l;
+		}
+		int mid = (l + r) >> 1;
+		if (sum[ls[i]] >= jobk) {
+			return kth(jobk, l, mid, ls[i]);
+		} else {
+			return kth(jobk - sum[ls[i]], mid + 1, r, rs[i]);
+		}
+	}
+
+	public static int merge(int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			return t1 + t2;
+		}
+		sum[t1] += sum[t2];
+		ls[t1] = merge(ls[t1], ls[t2]);
+		rs[t1] = merge(rs[t1], rs[t2]);
+		del(t2);
+		return t1;
+	}
+
+	public static int split(int x, long k) {
+		if (x == 0) {
+			return 0;
+		}
+		int y = newNode();
+		long lsum = sum[ls[x]];
+		if (k > lsum) {
+			rs[y] = split(rs[x], k - lsum);
+		} else {
+			int tmp = rs[x];
+			rs[x] = rs[y];
+			rs[y] = tmp;
+		}
+		if (k < lsum) {
+			ls[y] = split(ls[x], k);
+		}
+		sum[y] = sum[x] - k;
+		sum[x] = k;
+		return y;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		prepare();
+		cntRoot = 1;
+		for (int i = 1, x; i <= n; i++) {
+			x = in.nextInt();
+			root[cntRoot] = add(i, x, 1, n, root[1]);
+		}
+		for (int i = 1, op, x, y, z; i <= m; i++) {
+			op = in.nextInt();
+			if (op == 0) {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				long k1 = query(1, z, 1, n, root[x]);
+				long k2 = query(y, z, 1, n, root[x]);
+				root[++cntRoot] = split(root[x], k1 - k2);
+				int tmp = split(root[cntRoot], k2);
+				root[x] = merge(root[x], tmp);
+			} else if (op == 1) {
+				x = in.nextInt();
+				y = in.nextInt();
+				root[x] = merge(root[x], root[y]);
+			} else if (op == 2) {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				root[x] = add(z, y, 1, n, root[x]);
+			} else if (op == 3) {
+				x = in.nextInt();
+				y = in.nextInt();
+				z = in.nextInt();
+				out.println(query(y, z, 1, n, root[x]));
+			} else {
+				x = in.nextInt();
+				y = in.nextInt();
+				out.println(kth(y, 1, n, root[x]));
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
new file mode 100644
index 000000000..e616e2f11
--- /dev/null
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -0,0 +1,155 @@
+package class182;
+
+// 线段树分裂，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P5494
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXT = MAXN * 40;
+//int n, m;
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//long long sum[MAXT];
+//int cntRoot;
+//
+//int pool[MAXT];
+//int top;
+//
+//void prepare() {
+//	top = 0;
+//    for (int i = 1; i < MAXT; i++) {
+//    	pool[++top] = i;
+//    }
+//}
+//
+//int newNode() {
+//    return pool[top--];
+//}
+//
+//void del(int i) {
+//	pool[++top] = i;
+//    ls[i] = 0;
+//    rs[i] = 0;
+//    sum[i] = 0;
+//}
+//
+//int add(int jobi, int jobv, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = newNode();
+//    }
+//    sum[rt] += jobv;
+//    if (l < r) {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//    }
+//    return rt;
+//}
+//
+//long long query(int jobl, int jobr, int l, int r, int i) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i];
+//    }
+//    int mid = (l + r) >> 1;
+//    long long ans = 0;
+//    if (jobl <= mid) {
+//        ans += query(jobl, jobr, l, mid, ls[i]);
+//    }
+//    if (jobr > mid) {
+//        ans += query(jobl, jobr, mid + 1, r, rs[i]);
+//    }
+//    return ans;
+//}
+//
+//int kth(long long jobk, int l, int r, int i) {
+//    if (i == 0) {
+//        return -1;
+//    }
+//    if (l == r) {
+//        return l;
+//    }
+//    int mid = (l + r) >> 1;
+//    if (sum[ls[i]] >= jobk) {
+//        return kth(jobk, l, mid, ls[i]);
+//    } else {
+//        return kth(jobk - sum[ls[i]], mid + 1, r, rs[i]);
+//    }
+//}
+//
+//int merge(int t1, int t2) {
+//    if (t1 == 0 || t2 == 0) {
+//        return t1 + t2;
+//    }
+//    sum[t1] += sum[t2];
+//    ls[t1] = merge(ls[t1], ls[t2]);
+//    rs[t1] = merge(rs[t1], rs[t2]);
+//    del(t2);
+//    return t1;
+//}
+//
+//int split(int x, long long k) {
+//    if (x == 0) return 0;
+//    int y = newNode();
+//    long long lsum = sum[ls[x]];
+//    if (k > lsum) {
+//        rs[y] = split(rs[x], k - lsum);
+//    } else {
+//    	swap(rs[x], rs[y]);
+//    }
+//    if (k < lsum) {
+//        ls[y] = split(ls[x], k);
+//    }
+//    sum[y] = sum[x] - k;
+//    sum[x] = k;
+//    return y;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    prepare();
+//    cntRoot = 1;
+//    for (int i = 1, x; i <= n; i++) {
+//        cin >> x;
+//        root[cntRoot] = add(i, x, 1, n, root[1]);
+//    }
+//    for (int i = 1, op, x, y, z; i <= m; i++) {
+//        cin >> op;
+//        if (op == 0) {
+//            cin >> x >> y >> z;
+//            long long k1 = query(1, z, 1, n, root[x]);
+//            long long k2 = query(y, z, 1, n, root[x]);
+//            root[++cntRoot] = split(root[x], k1 - k2);
+//            int tmp = split(root[cntRoot], k2);
+//            root[x] = merge(root[x], tmp);
+//        } else if (op == 1) {
+//            cin >> x >> y;
+//            root[x] = merge(root[x], root[y]);
+//        } else if (op == 2) {
+//            cin >> x >> y >> z;
+//            root[x] = add(z, y, 1, n, root[x]);
+//        } else if (op == 3) {
+//            cin >> x >> y >> z;
+//            cout << query(y, z, 1, n, root[x]) << '\n';
+//        } else {
+//            cin >> x >> y;
+//            cout << kth(y, 1, n, root[x]) << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 9e0488214b9895b175daa2867dca341a44c71fef Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 18:09:27 +0800
Subject: [PATCH 1616/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit2.java | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index e616e2f11..672f1004e 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -23,9 +23,9 @@
 //int top;
 //
 //void prepare() {
-//	top = 0;
+//    top = 0;
 //    for (int i = 1; i < MAXT; i++) {
-//    	pool[++top] = i;
+//        pool[++top] = i;
 //    }
 //}
 //
@@ -34,7 +34,7 @@
 //}
 //
 //void del(int i) {
-//	pool[++top] = i;
+//    pool[++top] = i;
 //    ls[i] = 0;
 //    rs[i] = 0;
 //    sum[i] = 0;
@@ -102,13 +102,15 @@
 //}
 //
 //int split(int x, long long k) {
-//    if (x == 0) return 0;
+//    if (x == 0) {
+//        return 0;
+//    }
 //    int y = newNode();
 //    long long lsum = sum[ls[x]];
 //    if (k > lsum) {
 //        rs[y] = split(rs[x], k - lsum);
 //    } else {
-//    	swap(rs[x], rs[y]);
+//        swap(rs[x], rs[y]);
 //    }
 //    if (k < lsum) {
 //        ls[y] = split(ls[x], k);

From 13b6ff92c94ae0ce6f8e58737c914ff9f5412324 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 21:18:01 +0800
Subject: [PATCH 1617/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java | 6 +++---
 src/class182/Code04_SegmentTreeSplit2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index 79a56edcb..190f65579 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -118,9 +118,9 @@ public static int split(int x, long k) {
 			int tmp = rs[x];
 			rs[x] = rs[y];
 			rs[y] = tmp;
-		}
-		if (k < lsum) {
-			ls[y] = split(ls[x], k);
+			if (k < lsum) {
+				ls[y] = split(ls[x], k);
+			}
 		}
 		sum[y] = sum[x] - k;
 		sum[x] = k;
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index 672f1004e..0f1d8364c 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -111,9 +111,9 @@
 //        rs[y] = split(rs[x], k - lsum);
 //    } else {
 //        swap(rs[x], rs[y]);
-//    }
-//    if (k < lsum) {
-//        ls[y] = split(ls[x], k);
+//        if (k < lsum) {
+//            ls[y] = split(ls[x], k);
+//        }
 //    }
 //    sum[y] = sum[x] - k;
 //    sum[x] = k;

From 4385c35897f327445b983474f40db1f5ce6c479e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 22:13:20 +0800
Subject: [PATCH 1618/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java | 57 +++++++++++++---------
 src/class182/Code04_SegmentTreeSplit2.java | 47 ++++++++++--------
 2 files changed, 62 insertions(+), 42 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index 190f65579..a4d1134ab 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -45,19 +45,25 @@ public static void del(int i) {
 		sum[i] = 0;
 	}
 
+	public static void up(int i) {
+		sum[i] = (sum[ls[i]] + sum[rs[i]]);
+	}
+
 	public static int add(int jobi, int jobv, int l, int r, int i) {
 		int rt = i;
 		if (rt == 0) {
 			rt = newNode();
 		}
-		sum[rt] += jobv;
-		if (l < r) {
+		if (l == r) {
+			sum[rt] += jobv;
+		} else {
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
 				ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
 			} else {
 				rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
 			}
+			up(rt);
 		}
 		return rt;
 	}
@@ -95,36 +101,41 @@ public static int kth(long jobk, int l, int r, int i) {
 		}
 	}
 
-	public static int merge(int t1, int t2) {
+	public static int merge(int l, int r, int t1, int t2) {
 		if (t1 == 0 || t2 == 0) {
 			return t1 + t2;
 		}
-		sum[t1] += sum[t2];
-		ls[t1] = merge(ls[t1], ls[t2]);
-		rs[t1] = merge(rs[t1], rs[t2]);
-		del(t2);
+		if (l == r) {
+			sum[t1] += sum[t2];
+		} else {
+			int mid = (l + r) >> 1;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+			del(t2);
+		}
 		return t1;
 	}
 
-	public static int split(int x, long k) {
-		if (x == 0) {
+	public static int split(int t1, long rank) {
+		if (t1 == 0) {
 			return 0;
 		}
-		int y = newNode();
-		long lsum = sum[ls[x]];
-		if (k > lsum) {
-			rs[y] = split(rs[x], k - lsum);
+		int t2 = newNode();
+		long lsum = sum[ls[t1]];
+		if (rank > lsum) {
+			rs[t2] = split(rs[t1], rank - lsum);
 		} else {
-			int tmp = rs[x];
-			rs[x] = rs[y];
-			rs[y] = tmp;
-			if (k < lsum) {
-				ls[y] = split(ls[x], k);
+			int tmp = rs[t1];
+			rs[t1] = rs[t2];
+			rs[t2] = tmp;
+			if (rank < lsum) {
+				ls[t2] = split(ls[t1], rank);
 			}
 		}
-		sum[y] = sum[x] - k;
-		sum[x] = k;
-		return y;
+		sum[t2] = sum[t1] - rank;
+		sum[t1] = rank;
+		return t2;
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -148,11 +159,11 @@ public static void main(String[] args) throws Exception {
 				long k2 = query(y, z, 1, n, root[x]);
 				root[++cntRoot] = split(root[x], k1 - k2);
 				int tmp = split(root[cntRoot], k2);
-				root[x] = merge(root[x], tmp);
+				root[x] = merge(1, n, root[x], tmp);
 			} else if (op == 1) {
 				x = in.nextInt();
 				y = in.nextInt();
-				root[x] = merge(root[x], root[y]);
+				root[x] = merge(1, n, root[x], root[y]);
 			} else if (op == 2) {
 				x = in.nextInt();
 				y = in.nextInt();
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index 0f1d8364c..996adbedd 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -40,6 +40,10 @@
 //    sum[i] = 0;
 //}
 //
+//void up(int i) {
+//    sum[i] = (sum[ls[i]] + sum[rs[i]]);
+//}
+//
 //int add(int jobi, int jobv, int l, int r, int i) {
 //    int rt = i;
 //    if (rt == 0) {
@@ -90,34 +94,39 @@
 //    }
 //}
 //
-//int merge(int t1, int t2) {
+//int merge(int l, int r, int t1, int t2) {
 //    if (t1 == 0 || t2 == 0) {
 //        return t1 + t2;
 //    }
-//    sum[t1] += sum[t2];
-//    ls[t1] = merge(ls[t1], ls[t2]);
-//    rs[t1] = merge(rs[t1], rs[t2]);
-//    del(t2);
+//    if (l == r) {
+//        sum[t1] += sum[t2];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//        del(t2);
+//    }
 //    return t1;
 //}
 //
-//int split(int x, long long k) {
-//    if (x == 0) {
+//int split(int t1, long long rank) {
+//    if (t1 == 0) {
 //        return 0;
 //    }
-//    int y = newNode();
-//    long long lsum = sum[ls[x]];
-//    if (k > lsum) {
-//        rs[y] = split(rs[x], k - lsum);
+//    int t2 = newNode();
+//    long long lsum = sum[ls[t1]];
+//    if (rank > lsum) {
+//        rs[t2] = split(rs[t1], rank - lsum);
 //    } else {
-//        swap(rs[x], rs[y]);
-//        if (k < lsum) {
-//            ls[y] = split(ls[x], k);
+//        swap(rs[t1], rs[t2]);
+//        if (rank < lsum) {
+//            ls[t2] = split(ls[t1], rank);
 //        }
 //    }
-//    sum[y] = sum[x] - k;
-//    sum[x] = k;
-//    return y;
+//    sum[t2] = sum[t1] - rank;
+//    sum[t1] = rank;
+//    return t2;
 //}
 //
 //int main() {
@@ -138,10 +147,10 @@
 //            long long k2 = query(y, z, 1, n, root[x]);
 //            root[++cntRoot] = split(root[x], k1 - k2);
 //            int tmp = split(root[cntRoot], k2);
-//            root[x] = merge(root[x], tmp);
+//            root[x] = merge(1, n, root[x], tmp);
 //        } else if (op == 1) {
 //            cin >> x >> y;
-//            root[x] = merge(root[x], root[y]);
+//            root[x] = merge(1, n, root[x], root[y]);
 //        } else if (op == 2) {
 //            cin >> x >> y >> z;
 //            root[x] = add(z, y, 1, n, root[x]);

From 65718f4f3d00070c8dcd9e6caabc52d9ccfe9ab0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 22:36:38 +0800
Subject: [PATCH 1619/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java |  4 ++--
 src/class182/Code04_SegmentTreeSplit2.java | 10 ++++++----
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index a4d1134ab..b43a4a1c7 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -133,8 +133,8 @@ public static int split(int t1, long rank) {
 				ls[t2] = split(ls[t1], rank);
 			}
 		}
-		sum[t2] = sum[t1] - rank;
-		sum[t1] = rank;
+		up(t1);
+		up(t2);
 		return t2;
 	}
 
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index 996adbedd..4cdf051dc 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -49,14 +49,16 @@
 //    if (rt == 0) {
 //        rt = newNode();
 //    }
-//    sum[rt] += jobv;
-//    if (l < r) {
+//    if (l == r) {
+//        sum[rt] += jobv;
+//    } else {
 //        int mid = (l + r) >> 1;
 //        if (jobi <= mid) {
 //            ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
 //        } else {
 //            rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
 //        }
+//        up(rt);
 //    }
 //    return rt;
 //}
@@ -124,8 +126,8 @@
 //            ls[t2] = split(ls[t1], rank);
 //        }
 //    }
-//    sum[t2] = sum[t1] - rank;
-//    sum[t1] = rank;
+//    up(t1);
+//    up(t2);
 //    return t2;
 //}
 //

From ae421d8acfaff06f850757fd2d66c115c2ffd4e6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 22:53:17 +0800
Subject: [PATCH 1620/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java | 46 +++++++++++++---------
 src/class182/Code04_SegmentTreeSplit2.java | 44 +++++++++++++--------
 2 files changed, 54 insertions(+), 36 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index b43a4a1c7..d82c4fcab 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -117,25 +117,35 @@ public static int merge(int l, int r, int t1, int t2) {
 		return t1;
 	}
 
-	public static int split(int t1, long rank) {
-		if (t1 == 0) {
-			return 0;
+	public static int tree1, tree2;
+
+	public static void split(int jobl, int jobr, int l, int r, int t1) {
+		if (jobr < l || r < jobl || t1 == 0) {
+			tree1 = t1;
+			tree2 = 0;
+			return;
+		}
+		if (jobl <= l && r <= jobr) {
+			tree1 = 0;
+			tree2 = t1;
+			return;
 		}
 		int t2 = newNode();
-		long lsum = sum[ls[t1]];
-		if (rank > lsum) {
-			rs[t2] = split(rs[t1], rank - lsum);
-		} else {
-			int tmp = rs[t1];
-			rs[t1] = rs[t2];
-			rs[t2] = tmp;
-			if (rank < lsum) {
-				ls[t2] = split(ls[t1], rank);
-			}
+		int mid = (l + r) >> 1;
+		if (jobl <= mid) {
+			split(jobl, jobr, l, mid, ls[t1]);
+			ls[t1] = tree1;
+			ls[t2] = tree2;
+		}
+		if (jobr > mid) {
+			split(jobl, jobr, mid + 1, r, rs[t1]);
+			rs[t1] = tree1;
+			rs[t2] = tree2;
 		}
 		up(t1);
 		up(t2);
-		return t2;
+		tree1 = t1;
+		tree2 = t2;
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -155,11 +165,9 @@ public static void main(String[] args) throws Exception {
 				x = in.nextInt();
 				y = in.nextInt();
 				z = in.nextInt();
-				long k1 = query(1, z, 1, n, root[x]);
-				long k2 = query(y, z, 1, n, root[x]);
-				root[++cntRoot] = split(root[x], k1 - k2);
-				int tmp = split(root[cntRoot], k2);
-				root[x] = merge(1, n, root[x], tmp);
+				split(y, z, 1, n, root[x]);
+				root[x] = tree1;
+				root[++cntRoot] = tree2;
 			} else if (op == 1) {
 				x = in.nextInt();
 				y = in.nextInt();
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index 4cdf051dc..fb432c84f 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -112,23 +112,35 @@
 //    return t1;
 //}
 //
-//int split(int t1, long long rank) {
-//    if (t1 == 0) {
-//        return 0;
+//int tree1, tree2;
+//
+//void split(int jobl, int jobr, int l, int r, int t1) {
+//    if (jobr < l || r < jobl || t1 == 0) {
+//        tree1 = t1;
+//        tree2 = 0;
+//        return;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        tree1 = 0;
+//        tree2 = t1;
+//        return;
 //    }
 //    int t2 = newNode();
-//    long long lsum = sum[ls[t1]];
-//    if (rank > lsum) {
-//        rs[t2] = split(rs[t1], rank - lsum);
-//    } else {
-//        swap(rs[t1], rs[t2]);
-//        if (rank < lsum) {
-//            ls[t2] = split(ls[t1], rank);
-//        }
+//    int mid = (l + r) >> 1;
+//    if (jobl <= mid) {
+//        split(jobl, jobr, l, mid, ls[t1]);
+//        ls[t1] = tree1;
+//        ls[t2] = tree2;
+//    }
+//    if (jobr > mid) {
+//        split(jobl, jobr, mid + 1, r, rs[t1]);
+//        rs[t1] = tree1;
+//        rs[t2] = tree2;
 //    }
 //    up(t1);
 //    up(t2);
-//    return t2;
+//    tree1 = t1;
+//    tree2 = t2;
 //}
 //
 //int main() {
@@ -145,11 +157,9 @@
 //        cin >> op;
 //        if (op == 0) {
 //            cin >> x >> y >> z;
-//            long long k1 = query(1, z, 1, n, root[x]);
-//            long long k2 = query(y, z, 1, n, root[x]);
-//            root[++cntRoot] = split(root[x], k1 - k2);
-//            int tmp = split(root[cntRoot], k2);
-//            root[x] = merge(1, n, root[x], tmp);
+//            split(y, z, 1, n, root[x]);
+//            root[x] = tree1;
+//            root[++cntRoot] = tree2;
 //        } else if (op == 1) {
 //            cin >> x >> y;
 //            root[x] = merge(1, n, root[x], root[y]);

From ad9e15f5a5a1e520eb5a34014852f9eae6d73bf6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 31 Oct 2025 23:12:55 +0800
Subject: [PATCH 1621/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java  |  2 +-
 src/class182/Code04_SegmentTreeSplit2.java  |  2 +-
 src/class182/Code05_MassChangeQueries1.java | 10 ++++++++++
 3 files changed, 12 insertions(+), 2 deletions(-)
 create mode 100644 src/class182/Code05_MassChangeQueries1.java

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index d82c4fcab..73f22ed67 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -120,7 +120,7 @@ public static int merge(int l, int r, int t1, int t2) {
 	public static int tree1, tree2;
 
 	public static void split(int jobl, int jobr, int l, int r, int t1) {
-		if (jobr < l || r < jobl || t1 == 0) {
+		if (t1 == 0) {
 			tree1 = t1;
 			tree2 = 0;
 			return;
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index fb432c84f..34af9f76b 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -115,7 +115,7 @@
 //int tree1, tree2;
 //
 //void split(int jobl, int jobr, int l, int r, int t1) {
-//    if (jobr < l || r < jobl || t1 == 0) {
+//    if (t1 == 0) {
 //        tree1 = t1;
 //        tree2 = 0;
 //        return;
diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
new file mode 100644
index 000000000..a3681db56
--- /dev/null
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -0,0 +1,10 @@
+package class182;
+
+// 值全改的操作，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF911G
+// 测试链接 : https://codeforces.com/problemset/problem/911/G
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code05_MassChangeQueries1 {
+
+}

From 3dbc159409d3fe20b038921e0cc5efbaa351a318 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 1 Nov 2025 15:57:59 +0800
Subject: [PATCH 1622/1712] modify code

---
 src/class182/Code05_MassChangeQueries1.java | 196 ++++++++++++++++++++
 1 file changed, 196 insertions(+)

diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index a3681db56..714ce2cf5 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -5,6 +5,202 @@
 // 测试链接 : https://codeforces.com/problemset/problem/911/G
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
 public class Code05_MassChangeQueries1 {
 
+	public static int MAXN = 200001;
+	public static int MAXV = 100;
+	public static int MAXT = MAXN * 40;
+	public static int n, q;
+	public static int[] arr = new int[MAXN];
+
+	public static int[] root = new int[MAXV + 1];
+	public static int[] ls = new int[MAXT];
+	public static int[] rs = new int[MAXT];
+	public static int[] sum = new int[MAXT];
+	public static int cntt;
+
+	public static int[] pool = new int[MAXT];
+	public static int top;
+
+	public static int[] ans = new int[MAXN];
+
+	public static void prepare() {
+		top = 0;
+		for (int i = 1; i < MAXT; i++) {
+			pool[++top] = i;
+		}
+	}
+
+	public static int newNode() {
+		return pool[top--];
+	}
+
+	public static void del(int i) {
+		pool[++top] = i;
+		ls[i] = 0;
+		rs[i] = 0;
+		sum[i] = 0;
+	}
+
+	public static void up(int p) {
+		sum[p] = sum[ls[p]] + sum[rs[p]];
+	}
+
+	public static int insert(int jobi, int l, int r, int i) {
+		int rt = i;
+		if (rt == 0) {
+			rt = newNode();
+		}
+		if (l == r) {
+			sum[rt]++;
+		} else {
+			int mid = (l + r) >> 1;
+			if (jobi <= mid) {
+				ls[rt] = insert(jobi, l, mid, ls[rt]);
+			} else {
+				rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+			}
+			up(rt);
+		}
+		return rt;
+	}
+
+	public static int merge(int l, int r, int t1, int t2) {
+		if (t1 == 0 || t2 == 0) {
+			return t1 + t2;
+		}
+		if (l == r) {
+			sum[t1] += sum[t2];
+		} else {
+			int mid = (l + r) >> 1;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+			up(t1);
+			del(t2);
+		}
+		return t1;
+	}
+
+	public static int tree1, tree2;
+
+	public static void split(int jobl, int jobr, int l, int r, int t1) {
+		if (t1 == 0) {
+			tree1 = t1;
+			tree2 = 0;
+			return;
+		}
+		if (jobl <= l && r <= jobr) {
+			tree1 = 0;
+			tree2 = t1;
+			return;
+		}
+		int t2 = newNode();
+		int mid = (l + r) >> 1;
+		if (jobl <= mid) {
+			split(jobl, jobr, l, mid, ls[t1]);
+			ls[t1] = tree1;
+			ls[t2] = tree2;
+		}
+		if (jobr > mid) {
+			split(jobl, jobr, mid + 1, r, rs[t1]);
+			rs[t1] = tree1;
+			rs[t2] = tree2;
+		}
+		up(t1);
+		up(t2);
+		tree1 = t1;
+		tree2 = t2;
+	}
+
+	public static void dfs(int val, int l, int r, int i) {
+		if (i == 0 || sum[i] == 0) {
+			return;
+		}
+		if (l == r) {
+			ans[l] = val;
+		} else {
+			int mid = (l + r) >> 1;
+			dfs(val, l, mid, ls[i]);
+			dfs(val, mid + 1, r, rs[i]);
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1; i <= n; i++) {
+			arr[i] = in.nextInt();
+		}
+		q = in.nextInt();
+		prepare();
+		for (int i = 1; i <= n; i++) {
+			root[arr[i]] = insert(i, 1, n, root[arr[i]]);
+		}
+		for (int i = 1, l, r, x, y; i <= q; i++) {
+			l = in.nextInt();
+			r = in.nextInt();
+			x = in.nextInt();
+			y = in.nextInt();
+			if (x != y) {
+				split(l, r, 1, n, root[x]);
+				root[x] = tree1;
+				root[y] = merge(1, n, root[y], tree2);
+			}
+		}
+		for (int v = 1; v <= MAXV; v++) {
+			dfs(v, 1, n, root[v]);
+		}
+		for (int i = 1; i <= n; i++) {
+			out.print(ans[i] + " ");
+		}
+		out.println();
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }

From b842f0acaef6b135945c6629c903eb8081e2851d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 1 Nov 2025 16:10:52 +0800
Subject: [PATCH 1623/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java  | 2 +-
 src/class182/Code04_SegmentTreeSplit2.java  | 2 +-
 src/class182/Code05_MassChangeQueries1.java | 3 +--
 3 files changed, 3 insertions(+), 4 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index 73f22ed67..1e8e50ca5 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -112,8 +112,8 @@ public static int merge(int l, int r, int t1, int t2) {
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
-			del(t2);
 		}
+		del(t2);
 		return t1;
 	}
 
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index 34af9f76b..d4653a67f 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -107,8 +107,8 @@
 //        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 //        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 //        up(t1);
-//        del(t2);
 //    }
+//    del(t2);
 //    return t1;
 //}
 //
diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index 714ce2cf5..aa4c9fd15 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -22,7 +22,6 @@ public class Code05_MassChangeQueries1 {
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static int[] sum = new int[MAXT];
-	public static int cntt;
 
 	public static int[] pool = new int[MAXT];
 	public static int top;
@@ -81,8 +80,8 @@ public static int merge(int l, int r, int t1, int t2) {
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
 			up(t1);
-			del(t2);
 		}
+		del(t2);
 		return t1;
 	}
 

From 8b42a08ef3d493b9ccde914633c376419eb54f91 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 1 Nov 2025 16:15:22 +0800
Subject: [PATCH 1624/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java  | 2 +-
 src/class182/Code04_SegmentTreeSplit2.java  | 2 +-
 src/class182/Code05_MassChangeQueries1.java | 2 +-
 3 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index 1e8e50ca5..f7ec11bb3 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -151,9 +151,9 @@ public static void split(int jobl, int jobr, int l, int r, int t1) {
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		prepare();
 		n = in.nextInt();
 		m = in.nextInt();
-		prepare();
 		cntRoot = 1;
 		for (int i = 1, x; i <= n; i++) {
 			x = in.nextInt();
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index d4653a67f..a1d8b2265 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -146,8 +146,8 @@
 //int main() {
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
-//    cin >> n >> m;
 //    prepare();
+//    cin >> n >> m;
 //    cntRoot = 1;
 //    for (int i = 1, x; i <= n; i++) {
 //        cin >> x;
diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index aa4c9fd15..d3a832f73 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -132,12 +132,12 @@ public static void dfs(int val, int l, int r, int i) {
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		prepare();
 		n = in.nextInt();
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
 		q = in.nextInt();
-		prepare();
 		for (int i = 1; i <= n; i++) {
 			root[arr[i]] = insert(i, 1, n, root[arr[i]]);
 		}

From eb692e6abc425eb20d38badd9eb04bd913a08e02 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 13:34:15 +0800
Subject: [PATCH 1625/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java |  26 +++--
 src/class182/Code01_LeadersGroup2.java | 149 +++++++++++++++++++++++++
 src/class182/Code02_Minimax2.java      |   6 +-
 3 files changed, 167 insertions(+), 14 deletions(-)
 create mode 100644 src/class182/Code01_LeadersGroup2.java

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 72ffb7843..6060c0ded 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -1,6 +1,13 @@
 package class182;
 
 // 领导集团问题，java版
+// 一共有n个节点，给定每个点的点权，所有节点组成一棵树
+// 已知1号节点是整棵树的头，其他节点的父亲节点都会给出
+// 如果你在树上选择了u、v两个节点，并且u是v的祖先节点的话
+// 那么需要保证 u的点权 <= v的点权，除此之外就没有别的限制了
+// 打印你最多能在树上选择几个点
+// 1 <= n <= 2 * 10^5
+// 0 <= 点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4577
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -25,7 +32,7 @@ public class Code01_LeadersGroup1 {
 	public static int[] root = new int[MAXN];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
-	public static int[] max = new int[MAXT];
+	public static int[] maxv = new int[MAXT];
 	public static int[] addTag = new int[MAXT];
 	public static int cntt;
 
@@ -36,15 +43,12 @@ public static void addEdge(int u, int v) {
 	}
 
 	public static void up(int i) {
-		max[i] = Math.max(max[ls[i]], max[rs[i]]);
+		maxv[i] = Math.max(maxv[ls[i]], maxv[rs[i]]);
 	}
 
 	public static void lazy(int i, int v) {
-		// 如果区间信息不存在
-		// 说明没有建立过dp信息
-		// 那么不需要增加v
 		if (i != 0) {
-			max[i] += v;
+			maxv[i] += v;
 			addTag[i] += v;
 		}
 	}
@@ -63,7 +67,7 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 			rt = ++cntt;
 		}
 		if (l == r) {
-			max[rt] = Math.max(max[rt], jobv);
+			maxv[rt] = Math.max(maxv[rt], jobv);
 		} else {
 			down(rt);
 			int mid = (l + r) >> 1;
@@ -88,12 +92,12 @@ public static int merge(int l, int r, int t1, int t2, int max1, int max2) {
 			return t1 + t2;
 		}
 		if (l == r) {
-			max[t1] = Math.max(max[t1], max1) + Math.max(max[t2], max2);
+			maxv[t1] = Math.max(maxv[t1], max1) + Math.max(maxv[t2], max2);
 		} else {
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			ls[t1] = merge(l, mid, ls[t1], ls[t2], Math.max(max1, max[rs[t1]]), Math.max(max2, max[rs[t2]]));
+			ls[t1] = merge(l, mid, ls[t1], ls[t2], Math.max(max1, maxv[rs[t1]]), Math.max(max2, maxv[rs[t2]]));
 			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], max1, max2);
 			up(t1);
 		}
@@ -105,7 +109,7 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 			return 0;
 		}
 		if (jobl <= l && r <= jobr) {
-			return max[i];
+			return maxv[i];
 		}
 		down(i);
 		int mid = (l + r) >> 1;
@@ -142,7 +146,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(fa, i);
 		}
 		dp(1);
-		out.println(max[root[1]]);
+		out.println(maxv[root[1]]);
 		out.flush();
 		out.close();
 	}
diff --git a/src/class182/Code01_LeadersGroup2.java b/src/class182/Code01_LeadersGroup2.java
new file mode 100644
index 000000000..de0b6c1e7
--- /dev/null
+++ b/src/class182/Code01_LeadersGroup2.java
@@ -0,0 +1,149 @@
+package class182;
+
+// 领导集团问题，C++版
+// 一共有n个节点，给定每个点的点权，所有节点组成一棵树
+// 已知1号节点是整棵树的头，其他节点的父亲节点都会给出
+// 如果你在树上选择了u、v两个节点，并且u是v的祖先节点的话
+// 那么需要保证 u的点权 <= v的点权，除此之外就没有别的限制了
+// 打印你最多能在树上选择几个点
+// 1 <= n <= 2 * 10^5
+// 0 <= 点权 <= 10^9
+// 测试链接 : https://www.luogu.com.cn/problem/P4577
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXV = 1000000000;
+//const int MAXT = MAXN * 40;
+//int n;
+//int arr[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN];
+//int to[MAXN];
+//int cntg;
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//int maxv[MAXT];
+//int addTag[MAXT];
+//int cntt;
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void up(int i) {
+//    maxv[i] = max(maxv[ls[i]], maxv[rs[i]]);
+//}
+//
+//void lazy(int i, int v) {
+//    if (i != 0) {
+//        maxv[i] += v;
+//        addTag[i] += v;
+//    }
+//}
+//
+//void down(int i) {
+//    if (addTag[i] > 0) {
+//        lazy(ls[i], addTag[i]);
+//        lazy(rs[i], addTag[i]);
+//        addTag[i] = 0;
+//    }
+//}
+//
+//int add(int jobi, int jobv, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = ++cntt;
+//    }
+//    if (l == r) {
+//        maxv[rt] = max(maxv[rt], jobv);
+//    } else {
+//        down(rt);
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2, int max1, int max2) {
+//    if (t1 == 0 || t2 == 0) {
+//        if (t1 != 0) {
+//            lazy(t1, max2);
+//        }
+//        if (t2 != 0) {
+//            lazy(t2, max1);
+//        }
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        maxv[t1] = max(maxv[t1], max1) + max(maxv[t2], max2);
+//    } else {
+//        down(t1);
+//        down(t2);
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2], max(max1, maxv[rs[t1]]), max(max2, maxv[rs[t2]]));
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], max1, max2);
+//        up(t1);
+//    }
+//    return t1;
+//}
+//
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        return maxv[i];
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    int ans = 0;
+//    if (jobl <= mid) {
+//        ans = max(ans, query(jobl, jobr, l, mid, ls[i]));
+//    }
+//    if (jobr > mid) {
+//        ans = max(ans, query(jobl, jobr, mid + 1, r, rs[i]));
+//    }
+//    return ans;
+//}
+//
+//void dp(int u) {
+//    int val = 1;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        dp(v);
+//        val += query(arr[u], MAXV, 1, MAXV, root[v]);
+//        root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
+//    }
+//    root[u] = add(arr[u], val, 1, MAXV, root[u]);
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    for (int i = 2, fa; i <= n; i++) {
+//        cin >> fa;
+//        addEdge(fa, i);
+//    }
+//    dp(1);
+//    cout << maxv[root[1]] << '\n';
+//    return 0;
+//}
\ No newline at end of file
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index bc3332700..4eb16d389 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -59,12 +59,12 @@
 //}
 //
 //void up(int i) {
-//	sum[i] = (sum[ls[i]] + sum[rs[i]]) % MOD;
+//    sum[i] = (sum[ls[i]] + sum[rs[i]]) % MOD;
 //}
 //
 //void lazy(int i, long long v) {
 //    if (i) {
-//    	sum[i] = sum[i] * v % MOD;
+//        sum[i] = sum[i] * v % MOD;
 //        mul[i] = mul[i] * v % MOD;
 //    }
 //}
@@ -84,7 +84,7 @@
 //        mul[rt] = 1;
 //    }
 //    if (l == r) {
-//    	sum[rt] = 1;
+//        sum[rt] = 1;
 //    } else {
 //        down(rt);
 //        int mid = (l + r) >> 1;

From d43841176a3b6b7aebde2819a1de2f3d9be99411 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 14:00:19 +0800
Subject: [PATCH 1626/1712] modify code

---
 src/class182/Code02_Minimax1.java | 28 ++++++++++++++++++----------
 src/class182/Code02_Minimax2.java | 24 ++++++++++++++++--------
 2 files changed, 34 insertions(+), 18 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 8da6229df..4295e066a 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -1,6 +1,14 @@
 package class182;
 
-// 根节点的概率，java版
+// 根节点的取值概率，java版
+// 一共有n个节点，1号节点是整棵树的头，所有节点组成一棵树
+// 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
+// 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权
+// 以arr[x]的概率是所有儿子的点权最大值，以1 - arr[x]的概率是所有儿子的点权最小值
+// 表示概率时，arr[x]范围是[1, 9999]，表示概率[0.0001 ~ 0.9999]
+// 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得的概率为Di
+// 计算 i = 1..m 时，每一项 (i * Vi * Di * Di) 的累加和，答案对 998244353 取模
+// 1 <= n <= 3 * 10^5    1 <= 叶节点权值 <= 10^9    1 <= 概率 <= 9999
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -18,7 +26,7 @@ public class Code02_Minimax1 {
 	public static int n;
 
 	public static int[] fa = new int[MAXN];
-	public static int[] val = new int[MAXN];
+	public static int[] arr = new int[MAXN];
 	public static int[] sorted = new int[MAXN];
 	public static int cntv;
 
@@ -130,14 +138,14 @@ public static int merge(int l, int r, int t1, int t2, int p, long sum1, long sum
 	// 迭代版，java会爆栈，C++可以通过
 	public static void dfs1(int u) {
 		if (sonCnt[u] == 0) {
-			root[u] = insert(val[u], 1, cntv, root[u]);
+			root[u] = insert(arr[u], 1, cntv, root[u]);
 		} else if (sonCnt[u] == 1) {
 			dfs1(son[u][0]);
 			root[u] = root[son[u][0]];
 		} else {
 			dfs1(son[u][0]);
 			dfs1(son[u][1]);
-			root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], val[u], 0, 0);
+			root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], arr[u], 0, 0);
 		}
 	}
 
@@ -151,7 +159,7 @@ public static void dfs2() {
 			int u = stack[siz][0];
 			int s = stack[siz--][1];
 			if (sonCnt[u] == 0) {
-				root[u] = insert(val[u], 1, cntv, root[u]);
+				root[u] = insert(arr[u], 1, cntv, root[u]);
 			} else if (sonCnt[u] == 1) {
 				if (s == 0) {
 					stack[++siz][0] = u;
@@ -170,7 +178,7 @@ public static void dfs2() {
 					stack[++siz][0] = son[u][0];
 					stack[siz][1] = 0;
 				} else {
-					root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], val[u], 0, 0);
+					root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], arr[u], 0, 0);
 				}
 			}
 		}
@@ -199,9 +207,9 @@ public static void prepare() {
 		long inv = power(10000, MOD - 2);
 		for (int i = 1; i <= n; i++) {
 			if (sonCnt[i] == 0) {
-				sorted[++cntv] = val[i];
+				sorted[++cntv] = arr[i];
 			} else {
-				val[i] = (int) (inv * val[i] % MOD);
+				arr[i] = (int) (inv * arr[i] % MOD);
 			}
 		}
 		Arrays.sort(sorted, 1, cntv + 1);
@@ -214,7 +222,7 @@ public static void prepare() {
 		cntv = len;
 		for (int i = 1; i <= n; i++) {
 			if (sonCnt[i] == 0) {
-				val[i] = kth(val[i]);
+				arr[i] = kth(arr[i]);
 			}
 		}
 	}
@@ -227,7 +235,7 @@ public static void main(String[] args) throws Exception {
 			fa[i] = in.nextInt();
 		}
 		for (int i = 1; i <= n; i++) {
-			val[i] = in.nextInt();
+			arr[i] = in.nextInt();
 		}
 		prepare();
 		// dfs1(1);
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 4eb16d389..7aef2c322 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -1,6 +1,14 @@
 package class182;
 
-// 根节点的概率，C++版
+// 根节点的取值概率，C++版
+// 一共有n个节点，1号节点是整棵树的头，所有节点组成一棵树
+// 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
+// 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权
+// 以arr[x]的概率是所有儿子的点权最大值，以1 - arr[x]的概率是所有儿子的点权最小值
+// 表示概率时，arr[x]范围是[1, 9999]，表示概率[0.0001 ~ 0.9999]
+// 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得的概率为Di
+// 计算 i = 1..m 时，每一项 (i * Vi * Di * Di) 的累加和，答案对 998244353 取模
+// 1 <= n <= 3 * 10^5    1 <= 叶节点权值 <= 10^9    1 <= 概率 <= 9999
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -15,7 +23,7 @@
 //int n;
 //
 //int fa[MAXN];
-//int val[MAXN];
+//int arr[MAXN];
 //int sorted[MAXN];
 //int cntv;
 //
@@ -127,14 +135,14 @@
 //
 //void dfs(int u) {
 //    if (sonCnt[u] == 0) {
-//        root[u] = insert(val[u], 1, cntv, root[u]);
+//        root[u] = insert(arr[u], 1, cntv, root[u]);
 //    } else if (sonCnt[u] == 1) {
 //        dfs(son[u][0]);
 //        root[u] = root[son[u][0]];
 //    } else {
 //        dfs(son[u][0]);
 //        dfs(son[u][1]);
-//        root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], val[u], 0, 0);
+//        root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], arr[u], 0, 0);
 //    }
 //}
 //
@@ -161,9 +169,9 @@
 //    long long inv = power(10000, MOD - 2);
 //    for (int i = 1; i <= n; i++) {
 //        if (sonCnt[i] == 0) {
-//            sorted[++cntv] = val[i];
+//            sorted[++cntv] = arr[i];
 //        } else {
-//            val[i] = (int)(inv * val[i] % MOD);
+//            arr[i] = (int)(inv * arr[i] % MOD);
 //        }
 //    }
 //    sort(sorted + 1, sorted + cntv + 1);
@@ -176,7 +184,7 @@
 //    cntv = len;
 //    for (int i = 1; i <= n; i++) {
 //        if (sonCnt[i] == 0) {
-//            val[i] = kth(val[i]);
+//            arr[i] = kth(arr[i]);
 //        }
 //    }
 //}
@@ -189,7 +197,7 @@
 //        cin >> fa[i];
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        cin >> val[i];
+//        cin >> arr[i];
 //    }
 //    prepare();
 //    dfs(1);

From 3e061e64af2d0150fc95bdcba2a19ca12eb8609b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 14:09:57 +0800
Subject: [PATCH 1627/1712] modify code

---
 src/class182/Code02_Minimax1.java | 4 ++--
 src/class182/Code02_Minimax2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 4295e066a..7b396ad2e 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -5,8 +5,8 @@
 // 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
 // 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权
 // 以arr[x]的概率是所有儿子的点权最大值，以1 - arr[x]的概率是所有儿子的点权最小值
-// 表示概率时，arr[x]范围是[1, 9999]，表示概率[0.0001 ~ 0.9999]
-// 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得的概率为Di
+// 表示概率时，arr[x]的范围是[1, 9999]，表示概率 0.0001 ~ 0.9999
+// 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得概率为Di
 // 计算 i = 1..m 时，每一项 (i * Vi * Di * Di) 的累加和，答案对 998244353 取模
 // 1 <= n <= 3 * 10^5    1 <= 叶节点权值 <= 10^9    1 <= 概率 <= 9999
 // 测试链接 : https://www.luogu.com.cn/problem/P5298
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 7aef2c322..ec4e64a51 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -5,8 +5,8 @@
 // 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
 // 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权
 // 以arr[x]的概率是所有儿子的点权最大值，以1 - arr[x]的概率是所有儿子的点权最小值
-// 表示概率时，arr[x]范围是[1, 9999]，表示概率[0.0001 ~ 0.9999]
-// 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得的概率为Di
+// 表示概率时，arr[x]的范围是[1, 9999]，表示概率 0.0001 ~ 0.9999
+// 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得概率为Di
 // 计算 i = 1..m 时，每一项 (i * Vi * Di * Di) 的累加和，答案对 998244353 取模
 // 1 <= n <= 3 * 10^5    1 <= 叶节点权值 <= 10^9    1 <= 概率 <= 9999
 // 测试链接 : https://www.luogu.com.cn/problem/P5298

From dd430cb0d0fba89a0bff562cc93aaca2b6c1598f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 14:44:13 +0800
Subject: [PATCH 1628/1712] modify code

---
 src/class182/Code03_Fate1.java |  11 ++-
 src/class182/Code03_Fate2.java | 170 +++++++++++++++++++++++++++++++++
 2 files changed, 176 insertions(+), 5 deletions(-)
 create mode 100644 src/class182/Code03_Fate2.java

diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 763eef28b..4920a6708 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -1,6 +1,12 @@
 package class182;
 
 // 命运，java版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树，规定1号节点是树头
+// 给定m个点对，每个点对(x, y)，已知x是y的祖先节点，路径由从上到下的边组成
+// 你可以给树上的每条边涂色，每条边都能涂上白色或者黑色，完全由你决定
+// 但是请保证每个点对的路径中，至少有一个黑色存在
+// 打印给树涂色的方法数，答案对 998244353 取模
+// 1 <= n、m <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P6773
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -178,11 +184,6 @@ public static void dp1(int u, int fa) {
 			int v = to[e];
 			if (v != fa) {
 				dp1(v, u);
-			}
-		}
-		for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
-			int v = to[ei];
-			if (v != fa) {
 				root[u] = merge(0, n, root[u], root[v], 0, query(0, dep[u], 0, n, root[v]));
 			}
 		}
diff --git a/src/class182/Code03_Fate2.java b/src/class182/Code03_Fate2.java
new file mode 100644
index 000000000..9ee682df8
--- /dev/null
+++ b/src/class182/Code03_Fate2.java
@@ -0,0 +1,170 @@
+package class182;
+
+// 命运，C++版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树，规定1号节点是树头
+// 给定m个点对，每个点对(x, y)，已知x是y的祖先节点，路径由从上到下的边组成
+// 你可以给树上的每条边涂色，每条边都能涂上白色或者黑色，完全由你决定
+// 但是请保证每个点对的路径中，至少有一个黑色存在
+// 打印给树涂色的方法数，答案对 998244353 取模
+// 1 <= n、m <= 5 * 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P6773
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 500001;
+//const int MAXT = MAXN * 40;
+//const int MOD = 998244353;
+//int n, m;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int cntg;
+//
+//int root[MAXN];
+//int ls[MAXT];
+//int rs[MAXT];
+//long long sum[MAXT];
+//long long mul[MAXT];
+//int cntt;
+//
+//int dep[MAXN];
+//int maxdep[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    head[u] = cntg;
+//}
+//
+//void up(int i) {
+//    sum[i] = (sum[ls[i]] + sum[rs[i]]) % MOD;
+//}
+//
+//void lazy(int i, long long v) {
+//    if (i != 0) {
+//        sum[i] = sum[i] * v % MOD;
+//        mul[i] = mul[i] * v % MOD;
+//    }
+//}
+//
+//void down(int i) {
+//    if (mul[i] != 1) {
+//        lazy(ls[i], mul[i]);
+//        lazy(rs[i], mul[i]);
+//        mul[i] = 1;
+//    }
+//}
+//
+//int insert(int jobi, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = ++cntt;
+//        mul[rt] = 1;
+//    }
+//    if (l == r) {
+//        sum[rt] = 1;
+//    } else {
+//        down(rt);
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int Merge(int l, int r, int t1, int t2, long long sum1, long long sum2) {
+//    if (t1 == 0 || t2 == 0) {
+//        if (t1 != 0) {
+//            lazy(t1, sum2);
+//        }
+//        if (t2 != 0) {
+//            lazy(t2, sum1);
+//        }
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        sum[t1] = ((sum[t1] * (sum2 + sum[t2])) % MOD + (sum[t2] * sum1) % MOD) % MOD;
+//    } else {
+//        down(t1);
+//        down(t2);
+//        int mid = (l + r) >> 1;
+//        long long tmp1 = sum[ls[t1]];
+//        long long tmp2 = sum[ls[t2]];
+//        ls[t1] = Merge(l, mid, ls[t1], ls[t2], sum1, sum2);
+//        rs[t1] = Merge(mid + 1, r, rs[t1], rs[t2], sum1 + tmp1, sum2 + tmp2);
+//        up(t1);
+//    }
+//    return t1;
+//}
+//
+//long long query(int jobl, int jobr, int l, int r, int i) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i] % MOD;
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    long long ans = 0;
+//    if (jobl <= mid) {
+//        ans = query(jobl, jobr, l, mid, ls[i]) % MOD;
+//    }
+//    if (jobr > mid) {
+//        ans = (ans + query(jobl, jobr, mid + 1, r, rs[i])) % MOD;
+//    }
+//    return ans;
+//}
+//
+//void dfs(int u, int fa) {
+//    dep[u] = dep[fa] + 1;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            dfs(v, u);
+//        }
+//    }
+//}
+//
+//void dp(int u, int fa) {
+//    root[u] = insert(maxdep[u], 0, n, root[u]);
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa) {
+//            dp(v, u);
+//            root[u] = Merge(0, n, root[u], root[v], 0, query(0, dep[u], 0, n, root[v]));
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    dfs(1, 0);
+//    cin >> m;
+//    for (int i = 1, x, y; i <= m; i++) {
+//        cin >> x >> y;
+//        if (dep[x] > maxdep[y]) {
+//            maxdep[y] = dep[x];
+//        }
+//    }
+//    dp(1, 0);
+//    long long ans = query(0, 0, 0, n, root[1]) % MOD;
+//    cout << ans << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 46c191dc725aa65b967721382b1ccf31c9e09fb2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 15:06:17 +0800
Subject: [PATCH 1629/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java | 8 ++++++++
 src/class182/Code04_SegmentTreeSplit2.java | 8 ++++++++
 2 files changed, 16 insertions(+)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index f7ec11bb3..6e745b56e 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -1,6 +1,14 @@
 package class182;
 
 // 线段树分裂，java版
+// 数字范围1~n，给定每种数字的个数，建立编号为1的可重集合，以后新集合的编号自增即可
+// 接下来有m条操作，每条操作是如下六种类型中的一种
+// 操作 0 x y z : x号集合中，取出[y, z]范围上的所有数字，生成新的集合
+// 操作 1 x y   : x号集合与y号集合合并，以后y编号的集合不会使用了
+// 操作 2 x y z : x号集合中，加入y个数字z
+// 操作 3 x y z : x号集合中，查询[y, z]范围上的数字个数
+// 操作 4 x y   : x号集合中，查询第y小的数字，不存在打印-1
+// 1 <= 所有数据 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5494
 // 提交以下的code，提交时请把类名改成"Main"
 // java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index a1d8b2265..b73daaf6b 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -1,6 +1,14 @@
 package class182;
 
 // 线段树分裂，C++版
+// 数字范围1~n，给定每种数字的个数，建立编号为1的可重集合，以后新集合的编号自增即可
+// 接下来有m条操作，每条操作是如下六种类型中的一种
+// 操作 0 x y z : x号集合中，取出[y, z]范围上的所有数字，生成新的集合
+// 操作 1 x y   : x号集合与y号集合合并，以后y编号的集合不会使用了
+// 操作 2 x y z : x号集合中，加入y个数字z
+// 操作 3 x y z : x号集合中，查询[y, z]范围上的数字个数
+// 操作 4 x y   : x号集合中，查询第y小的数字，不存在打印-1
+// 1 <= 所有数据 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5494
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 4a262cada5ce63aad2aa5055f788ee324fa636a7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 15:29:24 +0800
Subject: [PATCH 1630/1712] modify code

---
 src/class173/Code05_HLD2.java               |   2 +-
 src/class182/Code05_MassChangeQueries1.java |  18 ++-
 src/class182/Code05_MassChangeQueries2.java | 160 ++++++++++++++++++++
 3 files changed, 171 insertions(+), 9 deletions(-)
 create mode 100644 src/class182/Code05_MassChangeQueries2.java

diff --git a/src/class173/Code05_HLD2.java b/src/class173/Code05_HLD2.java
index 36d2a4e83..bb2d84f76 100644
--- a/src/class173/Code05_HLD2.java
+++ b/src/class173/Code05_HLD2.java
@@ -137,7 +137,7 @@
 //    ios::sync_with_stdio(false);
 //    cin.tie(nullptr);
 //    cin >> n >> m >> f;
-//    for (int i = 1; i <= n; ++i) {
+//    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
 //    for (int i = 1, u, v; i < n; i++) {
diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index d3a832f73..586e25758 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -1,6 +1,11 @@
 package class182;
 
 // 值全改的操作，java版
+// 给定一个长度为n的数组arr，接下来有q条操作，格式如下
+// 操作 l r x y : arr[l..r]范围上，所有数字x改成数字y
+// 所有操作做完之后，从左到右打印arr中的值
+// 1 <= n、q <= 2 * 10^5
+// 1 <= arr[i]、x、y <= 100
 // 测试链接 : https://www.luogu.com.cn/problem/CF911G
 // 测试链接 : https://codeforces.com/problemset/problem/911/G
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -46,8 +51,8 @@ public static void del(int i) {
 		sum[i] = 0;
 	}
 
-	public static void up(int p) {
-		sum[p] = sum[ls[p]] + sum[rs[p]];
+	public static void up(int i) {
+		sum[i] = sum[ls[i]] + sum[rs[i]];
 	}
 
 	public static int insert(int jobi, int l, int r, int i) {
@@ -146,11 +151,9 @@ public static void main(String[] args) throws Exception {
 			r = in.nextInt();
 			x = in.nextInt();
 			y = in.nextInt();
-			if (x != y) {
-				split(l, r, 1, n, root[x]);
-				root[x] = tree1;
-				root[y] = merge(1, n, root[y], tree2);
-			}
+			split(l, r, 1, n, root[x]);
+			root[x] = tree1;
+			root[y] = merge(1, n, root[y], tree2);
 		}
 		for (int v = 1; v <= MAXV; v++) {
 			dfs(v, 1, n, root[v]);
@@ -158,7 +161,6 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			out.print(ans[i] + " ");
 		}
-		out.println();
 		out.flush();
 		out.close();
 	}
diff --git a/src/class182/Code05_MassChangeQueries2.java b/src/class182/Code05_MassChangeQueries2.java
new file mode 100644
index 000000000..240be11c0
--- /dev/null
+++ b/src/class182/Code05_MassChangeQueries2.java
@@ -0,0 +1,160 @@
+package class182;
+
+// 值全改的操作，C++版
+// 给定一个长度为n的数组arr，接下来有q条操作，格式如下
+// 操作 l r x y : arr[l..r]范围上，所有数字x改成数字y
+// 所有操作做完之后，从左到右打印arr中的值
+// 1 <= n、q <= 2 * 10^5
+// 1 <= arr[i]、x、y <= 100
+// 测试链接 : https://www.luogu.com.cn/problem/CF911G
+// 测试链接 : https://codeforces.com/problemset/problem/911/G
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXV = 100;
+//const int MAXT = MAXN * 40;
+//int n, q;
+//int arr[MAXN];
+//
+//int root[MAXV + 1];
+//int ls[MAXT];
+//int rs[MAXT];
+//int sum[MAXT];
+//
+//int pool[MAXT];
+//int top;
+//
+//int ans[MAXN];
+//
+//void prepare() {
+//    top = 0;
+//    for (int i = 1; i < MAXT; i++) {
+//        pool[++top] = i;
+//    }
+//}
+//
+//int newNode() {
+//    return pool[top--];
+//}
+//
+//void del(int i) {
+//    pool[++top] = i;
+//    ls[i] = 0;
+//    rs[i] = 0;
+//    sum[i] = 0;
+//}
+//
+//void up(int i) {
+//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//}
+//
+//int insert(int jobi, int l, int r, int i) {
+//    int rt = i;
+//    if (rt == 0) {
+//        rt = newNode();
+//    }
+//    if (l == r) {
+//        sum[rt]++;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        if (jobi <= mid) {
+//            ls[rt] = insert(jobi, l, mid, ls[rt]);
+//        } else {
+//            rs[rt] = insert(jobi, mid + 1, r, rs[rt]);
+//        }
+//        up(rt);
+//    }
+//    return rt;
+//}
+//
+//int merge(int l, int r, int t1, int t2) {
+//    if (t1 == 0 || t2 == 0) {
+//        return t1 + t2;
+//    }
+//    if (l == r) {
+//        sum[t1] += sum[t2];
+//    } else {
+//        int mid = (l + r) >> 1;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2]);
+//        up(t1);
+//    }
+//    del(t2);
+//    return t1;
+//}
+//
+//int tree1, tree2;
+//
+//void split(int jobl, int jobr, int l, int r, int t1) {
+//    if (t1 == 0) {
+//        tree1 = t1;
+//        tree2 = 0;
+//        return;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        tree1 = 0;
+//        tree2 = t1;
+//        return;
+//    }
+//    int t2 = newNode();
+//    int mid = (l + r) >> 1;
+//    if (jobl <= mid) {
+//        split(jobl, jobr, l, mid, ls[t1]);
+//        ls[t1] = tree1;
+//        ls[t2] = tree2;
+//    }
+//    if (jobr > mid) {
+//        split(jobl, jobr, mid + 1, r, rs[t1]);
+//        rs[t1] = tree1;
+//        rs[t2] = tree2;
+//    }
+//    up(t1);
+//    up(t2);
+//    tree1 = t1;
+//    tree2 = t2;
+//}
+//
+//void dfs(int val, int l, int r, int i) {
+//    if (i == 0 || sum[i] == 0) {
+//        return;
+//    }
+//    if (l == r) {
+//        ans[l] = val;
+//    } else {
+//        int mid = (l + r) >> 1;
+//        dfs(val, l, mid, ls[i]);
+//        dfs(val, mid + 1, r, rs[i]);
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    prepare();
+//    cin >> n;
+//    for (int i = 1; i <= n; i++) {
+//        cin >> arr[i];
+//    }
+//    cin >> q;
+//    for (int i = 1; i <= n; i++) {
+//        root[arr[i]] = insert(i, 1, n, root[arr[i]]);
+//    }
+//    for (int i = 1, l, r, x, y; i <= q; i++) {
+//        cin >> l >> r >> x >> y;
+//        split(l, r, 1, n, root[x]);
+//        root[x] = tree1;
+//        root[y] = merge(1, n, root[y], tree2);
+//    }
+//    for (int v = 1; v <= MAXV; v++) {
+//        dfs(v, 1, n, root[v]);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cout << ans[i] << ' ';
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 17e50614b17592566d03dc4b401602a122fcb3b6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 15:43:32 +0800
Subject: [PATCH 1631/1712] modify code

---
 src/class182/Code02_Minimax1.java | 2 +-
 src/class182/Code02_Minimax2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 7b396ad2e..57e2e258f 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -1,6 +1,6 @@
 package class182;
 
-// 根节点的取值概率，java版
+// 根节点的取值，java版
 // 一共有n个节点，1号节点是整棵树的头，所有节点组成一棵树
 // 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
 // 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index ec4e64a51..91c7da944 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -1,6 +1,6 @@
 package class182;
 
-// 根节点的取值概率，C++版
+// 根节点的取值，C++版
 // 一共有n个节点，1号节点是整棵树的头，所有节点组成一棵树
 // 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
 // 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权

From 32915aa4e73ef786ba58eac94fe32006a54fde46 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 17:17:37 +0800
Subject: [PATCH 1632/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 14 +++++++-------
 src/class182/Code01_LeadersGroup2.java | 14 +++++++-------
 2 files changed, 14 insertions(+), 14 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 6060c0ded..1f1796e55 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -7,7 +7,7 @@
 // 那么需要保证 u的点权 <= v的点权，除此之外就没有别的限制了
 // 打印你最多能在树上选择几个点
 // 1 <= n <= 2 * 10^5
-// 0 <= 点权 <= 10^9
+// 1 <= 点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4577
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -61,7 +61,7 @@ public static void down(int i) {
 		}
 	}
 
-	public static int add(int jobi, int jobv, int l, int r, int i) {
+	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = i;
 		if (rt == 0) {
 			rt = ++cntt;
@@ -72,9 +72,9 @@ public static int add(int jobi, int jobv, int l, int r, int i) {
 			down(rt);
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
-				ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+				ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
 			} else {
-				rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+				rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
 			}
 			up(rt);
 		}
@@ -92,7 +92,7 @@ public static int merge(int l, int r, int t1, int t2, int max1, int max2) {
 			return t1 + t2;
 		}
 		if (l == r) {
-			maxv[t1] = Math.max(maxv[t1], max1) + Math.max(maxv[t2], max2);
+			maxv[t1] += Math.max(maxv[t2], max2);
 		} else {
 			down(t1);
 			down(t2);
@@ -131,7 +131,7 @@ public static void dp(int u) {
 			val += query(arr[u], MAXV, 1, MAXV, root[v]);
 			root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
 		}
-		root[u] = add(arr[u], val, 1, MAXV, root[u]);
+		root[u] = update(arr[u], val, 1, MAXV, root[u]);
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -146,7 +146,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(fa, i);
 		}
 		dp(1);
-		out.println(maxv[root[1]]);
+		out.println(query(1, MAXV, 1, MAXV, root[1]));
 		out.flush();
 		out.close();
 	}
diff --git a/src/class182/Code01_LeadersGroup2.java b/src/class182/Code01_LeadersGroup2.java
index de0b6c1e7..c4f144bf9 100644
--- a/src/class182/Code01_LeadersGroup2.java
+++ b/src/class182/Code01_LeadersGroup2.java
@@ -7,7 +7,7 @@
 // 那么需要保证 u的点权 <= v的点权，除此之外就没有别的限制了
 // 打印你最多能在树上选择几个点
 // 1 <= n <= 2 * 10^5
-// 0 <= 点权 <= 10^9
+// 1 <= 点权 <= 10^9
 // 测试链接 : https://www.luogu.com.cn/problem/P4577
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -59,7 +59,7 @@
 //    }
 //}
 //
-//int add(int jobi, int jobv, int l, int r, int i) {
+//int update(int jobi, int jobv, int l, int r, int i) {
 //    int rt = i;
 //    if (rt == 0) {
 //        rt = ++cntt;
@@ -70,9 +70,9 @@
 //        down(rt);
 //        int mid = (l + r) >> 1;
 //        if (jobi <= mid) {
-//            ls[rt] = add(jobi, jobv, l, mid, ls[rt]);
+//            ls[rt] = update(jobi, jobv, l, mid, ls[rt]);
 //        } else {
-//            rs[rt] = add(jobi, jobv, mid + 1, r, rs[rt]);
+//            rs[rt] = update(jobi, jobv, mid + 1, r, rs[rt]);
 //        }
 //        up(rt);
 //    }
@@ -90,7 +90,7 @@
 //        return t1 + t2;
 //    }
 //    if (l == r) {
-//        maxv[t1] = max(maxv[t1], max1) + max(maxv[t2], max2);
+//        maxv[t1] += max(maxv[t2], max2);
 //    } else {
 //        down(t1);
 //        down(t2);
@@ -129,7 +129,7 @@
 //        val += query(arr[u], MAXV, 1, MAXV, root[v]);
 //        root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
 //    }
-//    root[u] = add(arr[u], val, 1, MAXV, root[u]);
+//    root[u] = update(arr[u], val, 1, MAXV, root[u]);
 //}
 //
 //int main() {
@@ -144,6 +144,6 @@
 //        addEdge(fa, i);
 //    }
 //    dp(1);
-//    cout << maxv[root[1]] << '\n';
+//    cout << query(1, MAXV, 1, MAXV, root[1]) << '\n';
 //    return 0;
 //}
\ No newline at end of file

From babbc833ab642396903772cd6a85f23ef80d87c8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 17:59:24 +0800
Subject: [PATCH 1633/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 4 ++--
 src/class182/Code01_LeadersGroup2.java | 4 ++--
 2 files changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 1f1796e55..47d90c0f4 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -124,14 +124,14 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 	}
 
 	public static void dp(int u) {
-		int val = 1;
+		int val = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			dp(v);
 			val += query(arr[u], MAXV, 1, MAXV, root[v]);
 			root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
 		}
-		root[u] = update(arr[u], val, 1, MAXV, root[u]);
+		root[u] = update(arr[u], val + 1, 1, MAXV, root[u]);
 	}
 
 	public static void main(String[] args) throws Exception {
diff --git a/src/class182/Code01_LeadersGroup2.java b/src/class182/Code01_LeadersGroup2.java
index c4f144bf9..9676ef22d 100644
--- a/src/class182/Code01_LeadersGroup2.java
+++ b/src/class182/Code01_LeadersGroup2.java
@@ -122,14 +122,14 @@
 //}
 //
 //void dp(int u) {
-//    int val = 1;
+//    int val = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        dp(v);
 //        val += query(arr[u], MAXV, 1, MAXV, root[v]);
 //        root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
 //    }
-//    root[u] = update(arr[u], val, 1, MAXV, root[u]);
+//    root[u] = update(arr[u], val + 1, 1, MAXV, root[u]);
 //}
 //
 //int main() {

From ab2c73c10876c06811ddda48e8af587fe7131920 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 18:02:49 +0800
Subject: [PATCH 1634/1712] modify code

---
 src/class182/Code02_Minimax1.java | 6 +++---
 src/class182/Code02_Minimax2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 57e2e258f..c7d000208 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -40,7 +40,7 @@ public class Code02_Minimax1 {
 	public static long[] mul = new long[MAXT];
 	public static int cntt;
 
-	public static long[] d = new long[MAXN];
+	public static long[] D = new long[MAXN];
 
 	public static long power(long x, int p) {
 		long ans = 1;
@@ -189,7 +189,7 @@ public static void getd(int l, int r, int i) {
 			return;
 		}
 		if (l == r) {
-			d[l] = sum[i] % MOD;
+			D[l] = sum[i] % MOD;
 		} else {
 			down(i);
 			int mid = (l + r) >> 1;
@@ -243,7 +243,7 @@ public static void main(String[] args) throws Exception {
 		getd(1, cntv, root[1]);
 		long ans = 0;
 		for (int i = 1; i <= cntv; i++) {
-			ans = (ans + 1L * i * sorted[i] % MOD * d[i] % MOD * d[i]) % MOD;
+			ans = (ans + 1L * i * sorted[i] % MOD * D[i] % MOD * D[i]) % MOD;
 		}
 		out.println(ans);
 		out.flush();
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 91c7da944..38d58205f 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -38,7 +38,7 @@
 //long long sum[MAXT];
 //long long mul[MAXT];
 //
-//long long d[MAXN];
+//long long D[MAXN];
 //
 //long long power(long long x, int p) {
 //    long long ans = 1;
@@ -151,7 +151,7 @@
 //        return;
 //    }
 //    if (l == r) {
-//        d[l] = sum[i] % MOD;
+//        D[l] = sum[i] % MOD;
 //    } else {
 //        down(i);
 //        int mid = (l + r) >> 1;
@@ -204,7 +204,7 @@
 //    getd(1, cntv, root[1]);
 //    long long ans = 0;
 //    for (int i = 1; i <= cntv; i++) {
-//        ans = (ans + (1LL * i * sorted[i]) % MOD * d[i] % MOD * d[i] % MOD) % MOD;
+//        ans = (ans + (1LL * i * sorted[i]) % MOD * D[i] % MOD * D[i] % MOD) % MOD;
 //    }
 //    cout << ans << '\n';
 //    return 0;

From 8cdc70c92a2c095e1941942addcc304c59353084 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 18:57:29 +0800
Subject: [PATCH 1635/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 38 +++++++++++++-------------
 src/class182/Code01_LeadersGroup2.java | 38 +++++++++++++-------------
 src/class182/Code03_Fate1.java         | 38 +++++++++++++-------------
 src/class182/Code03_Fate2.java         | 38 +++++++++++++-------------
 4 files changed, 76 insertions(+), 76 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 47d90c0f4..a28f46a7f 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -81,6 +81,25 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
+	public static int query(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return maxv[i];
+		}
+		down(i);
+		int mid = (l + r) >> 1;
+		int ans = 0;
+		if (jobl <= mid) {
+			ans = Math.max(ans, query(jobl, jobr, l, mid, ls[i]));
+		}
+		if (jobr > mid) {
+			ans = Math.max(ans, query(jobl, jobr, mid + 1, r, rs[i]));
+		}
+		return ans;
+	}
+
 	public static int merge(int l, int r, int t1, int t2, int max1, int max2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
@@ -104,25 +123,6 @@ public static int merge(int l, int r, int t1, int t2, int max1, int max2) {
 		return t1;
 	}
 
-	public static int query(int jobl, int jobr, int l, int r, int i) {
-		if (i == 0) {
-			return 0;
-		}
-		if (jobl <= l && r <= jobr) {
-			return maxv[i];
-		}
-		down(i);
-		int mid = (l + r) >> 1;
-		int ans = 0;
-		if (jobl <= mid) {
-			ans = Math.max(ans, query(jobl, jobr, l, mid, ls[i]));
-		}
-		if (jobr > mid) {
-			ans = Math.max(ans, query(jobl, jobr, mid + 1, r, rs[i]));
-		}
-		return ans;
-	}
-
 	public static void dp(int u) {
 		int val = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
diff --git a/src/class182/Code01_LeadersGroup2.java b/src/class182/Code01_LeadersGroup2.java
index 9676ef22d..b6c4dc7f9 100644
--- a/src/class182/Code01_LeadersGroup2.java
+++ b/src/class182/Code01_LeadersGroup2.java
@@ -79,6 +79,25 @@
 //    return rt;
 //}
 //
+//int query(int jobl, int jobr, int l, int r, int i) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        return maxv[i];
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    int ans = 0;
+//    if (jobl <= mid) {
+//        ans = max(ans, query(jobl, jobr, l, mid, ls[i]));
+//    }
+//    if (jobr > mid) {
+//        ans = max(ans, query(jobl, jobr, mid + 1, r, rs[i]));
+//    }
+//    return ans;
+//}
+//
 //int merge(int l, int r, int t1, int t2, int max1, int max2) {
 //    if (t1 == 0 || t2 == 0) {
 //        if (t1 != 0) {
@@ -102,25 +121,6 @@
 //    return t1;
 //}
 //
-//int query(int jobl, int jobr, int l, int r, int i) {
-//    if (i == 0) {
-//        return 0;
-//    }
-//    if (jobl <= l && r <= jobr) {
-//        return maxv[i];
-//    }
-//    down(i);
-//    int mid = (l + r) >> 1;
-//    int ans = 0;
-//    if (jobl <= mid) {
-//        ans = max(ans, query(jobl, jobr, l, mid, ls[i]));
-//    }
-//    if (jobr > mid) {
-//        ans = max(ans, query(jobl, jobr, mid + 1, r, rs[i]));
-//    }
-//    return ans;
-//}
-//
 //void dp(int u) {
 //    int val = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 4920a6708..e4648b7d8 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -101,6 +101,25 @@ public static int insert(int jobi, int l, int r, int i) {
 		return rt;
 	}
 
+	public static long query(int jobl, int jobr, int l, int r, int i) {
+		if (i == 0) {
+			return 0;
+		}
+		if (jobl <= l && r <= jobr) {
+			return sum[i] % MOD;
+		}
+		down(i);
+		int mid = (l + r) >> 1;
+		long ans = 0;
+		if (jobl <= mid) {
+			ans = query(jobl, jobr, l, mid, ls[i]);
+		}
+		if (jobr > mid) {
+			ans = (ans + query(jobl, jobr, mid + 1, r, rs[i])) % MOD;
+		}
+		return ans;
+	}
+
 	public static int merge(int l, int r, int t1, int t2, long sum1, long sum2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
@@ -126,25 +145,6 @@ public static int merge(int l, int r, int t1, int t2, long sum1, long sum2) {
 		return t1;
 	}
 
-	public static long query(int jobl, int jobr, int l, int r, int i) {
-		if (i == 0) {
-			return 0;
-		}
-		if (jobl <= l && r <= jobr) {
-			return sum[i] % MOD;
-		}
-		down(i);
-		int mid = (l + r) >> 1;
-		long ans = 0;
-		if (jobl <= mid) {
-			ans = query(jobl, jobr, l, mid, ls[i]);
-		}
-		if (jobr > mid) {
-			ans = (ans + query(jobl, jobr, mid + 1, r, rs[i])) % MOD;
-		}
-		return ans;
-	}
-
 	// 递归版，java会爆栈，C++可以通过
 	public static void dfs1(int u, int fa) {
 		dep[u] = dep[fa] + 1;
diff --git a/src/class182/Code03_Fate2.java b/src/class182/Code03_Fate2.java
index 9ee682df8..76c0d1368 100644
--- a/src/class182/Code03_Fate2.java
+++ b/src/class182/Code03_Fate2.java
@@ -81,6 +81,25 @@
 //    return rt;
 //}
 //
+//long long query(int jobl, int jobr, int l, int r, int i) {
+//    if (i == 0) {
+//        return 0;
+//    }
+//    if (jobl <= l && r <= jobr) {
+//        return sum[i] % MOD;
+//    }
+//    down(i);
+//    int mid = (l + r) >> 1;
+//    long long ans = 0;
+//    if (jobl <= mid) {
+//        ans = query(jobl, jobr, l, mid, ls[i]) % MOD;
+//    }
+//    if (jobr > mid) {
+//        ans = (ans + query(jobl, jobr, mid + 1, r, rs[i])) % MOD;
+//    }
+//    return ans;
+//}
+//
 //int Merge(int l, int r, int t1, int t2, long long sum1, long long sum2) {
 //    if (t1 == 0 || t2 == 0) {
 //        if (t1 != 0) {
@@ -106,25 +125,6 @@
 //    return t1;
 //}
 //
-//long long query(int jobl, int jobr, int l, int r, int i) {
-//    if (i == 0) {
-//        return 0;
-//    }
-//    if (jobl <= l && r <= jobr) {
-//        return sum[i] % MOD;
-//    }
-//    down(i);
-//    int mid = (l + r) >> 1;
-//    long long ans = 0;
-//    if (jobl <= mid) {
-//        ans = query(jobl, jobr, l, mid, ls[i]) % MOD;
-//    }
-//    if (jobr > mid) {
-//        ans = (ans + query(jobl, jobr, mid + 1, r, rs[i])) % MOD;
-//    }
-//    return ans;
-//}
-//
 //void dfs(int u, int fa) {
 //    dep[u] = dep[fa] + 1;
 //    for (int e = head[u]; e; e = nxt[e]) {

From 94b06ceb7396c6172f9994ff0fe7908af260fc6c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 19:00:38 +0800
Subject: [PATCH 1636/1712] modify code

---
 src/class182/Code02_Minimax1.java | 12 ++++++------
 src/class182/Code02_Minimax2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index c7d000208..b8993d563 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -124,12 +124,12 @@ public static int merge(int l, int r, int t1, int t2, int p, long sum1, long sum
 			down(t1);
 			down(t2);
 			int mid = (l + r) >> 1;
-			long l1 = (sum1 + sum[rs[t1]] * (1 - p + MOD)) % MOD;
-			long l2 = (sum2 + sum[rs[t2]] * (1 - p + MOD)) % MOD;
-			long r1 = (sum1 + sum[ls[t1]] * p) % MOD;
-			long r2 = (sum2 + sum[ls[t2]] * p) % MOD;
-			ls[t1] = merge(l, mid, ls[t1], ls[t2], p, l1, l2);
-			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], p, r1, r2);
+			long lsum1 = (sum1 + sum[rs[t1]] * (1 - p + MOD)) % MOD;
+			long lsum2 = (sum2 + sum[rs[t2]] * (1 - p + MOD)) % MOD;
+			long rsum1 = (sum1 + sum[ls[t1]] * p) % MOD;
+			long rsum2 = (sum2 + sum[ls[t2]] * p) % MOD;
+			ls[t1] = merge(l, mid, ls[t1], ls[t2], p, lsum1, lsum2);
+			rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], p, rsum1, rsum2);
 			up(t1);
 		}
 		return t1;
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 38d58205f..f47a5c3c4 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -122,12 +122,12 @@
 //        down(t1);
 //        down(t2);
 //        int mid = (l + r) >> 1;
-//        long long l1 = (sum1 + sum[rs[t1]] * (1 - p + MOD)) % MOD;
-//        long long l2 = (sum2 + sum[rs[t2]] * (1 - p + MOD)) % MOD;
-//        long long r1 = (sum1 + sum[ls[t1]] * p) % MOD;
-//        long long r2 = (sum2 + sum[ls[t2]] * p) % MOD;
-//        ls[t1] = merge(l, mid, ls[t1], ls[t2], p, l1, l2);
-//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], p, r1, r2);
+//        long long lsum1 = (sum1 + sum[rs[t1]] * (1 - p + MOD)) % MOD;
+//        long long lsum2 = (sum2 + sum[rs[t2]] * (1 - p + MOD)) % MOD;
+//        long long rsum1 = (sum1 + sum[ls[t1]] * p) % MOD;
+//        long long rsum2 = (sum2 + sum[ls[t2]] * p) % MOD;
+//        ls[t1] = merge(l, mid, ls[t1], ls[t2], p, lsum1, lsum2);
+//        rs[t1] = merge(mid + 1, r, rs[t1], rs[t2], p, rsum1, rsum2);
 //        up(t1);
 //    }
 //    return t1;

From 5c09b2bfe3ad02876b200371ddeacc13de308c0a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 19:12:14 +0800
Subject: [PATCH 1637/1712] modify code

---
 src/class182/Code03_Fate1.java | 6 +++---
 src/class182/Code03_Fate2.java | 6 +++---
 2 files changed, 6 insertions(+), 6 deletions(-)

diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index e4648b7d8..6c28a064d 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -2,9 +2,9 @@
 
 // 命运，java版
 // 一共有n个节点，给定n-1条边，所有节点组成一棵树，规定1号节点是树头
-// 给定m个点对，每个点对(x, y)，已知x是y的祖先节点，路径由从上到下的边组成
-// 你可以给树上的每条边涂色，每条边都能涂上白色或者黑色，完全由你决定
-// 但是请保证每个点对的路径中，至少有一个黑色存在
+// 给定m个点对，每个点对(x, y)，x是y的祖先节点，路径由从上到下的边组成
+// 树上的每条边都要涂上白色或者黑色，完全由你决定
+// 但是请保证每个点对的路径中，至少有一条黑色的边存在
 // 打印给树涂色的方法数，答案对 998244353 取模
 // 1 <= n、m <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P6773
diff --git a/src/class182/Code03_Fate2.java b/src/class182/Code03_Fate2.java
index 76c0d1368..79fb49646 100644
--- a/src/class182/Code03_Fate2.java
+++ b/src/class182/Code03_Fate2.java
@@ -2,9 +2,9 @@
 
 // 命运，C++版
 // 一共有n个节点，给定n-1条边，所有节点组成一棵树，规定1号节点是树头
-// 给定m个点对，每个点对(x, y)，已知x是y的祖先节点，路径由从上到下的边组成
-// 你可以给树上的每条边涂色，每条边都能涂上白色或者黑色，完全由你决定
-// 但是请保证每个点对的路径中，至少有一个黑色存在
+// 给定m个点对，每个点对(x, y)，x是y的祖先节点，路径由从上到下的边组成
+// 树上的每条边都要涂上白色或者黑色，完全由你决定
+// 但是请保证每个点对的路径中，至少有一条黑色的边存在
 // 打印给树涂色的方法数，答案对 998244353 取模
 // 1 <= n、m <= 5 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P6773

From 0762169cdb70437eef35d39725014702cec85ad5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 3 Nov 2025 19:23:18 +0800
Subject: [PATCH 1638/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java | 8 ++++----
 src/class182/Code04_SegmentTreeSplit2.java | 8 ++++----
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index 6e745b56e..c89cdbe02 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -30,7 +30,7 @@ public class Code04_SegmentTreeSplit1 {
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static long[] sum = new long[MAXT];
-	public static int cntRoot;
+	public static int version;
 
 	public static int[] pool = new int[MAXT];
 	public static int top;
@@ -162,10 +162,10 @@ public static void main(String[] args) throws Exception {
 		prepare();
 		n = in.nextInt();
 		m = in.nextInt();
-		cntRoot = 1;
+		version = 1;
 		for (int i = 1, x; i <= n; i++) {
 			x = in.nextInt();
-			root[cntRoot] = add(i, x, 1, n, root[1]);
+			root[version] = add(i, x, 1, n, root[1]);
 		}
 		for (int i = 1, op, x, y, z; i <= m; i++) {
 			op = in.nextInt();
@@ -175,7 +175,7 @@ public static void main(String[] args) throws Exception {
 				z = in.nextInt();
 				split(y, z, 1, n, root[x]);
 				root[x] = tree1;
-				root[++cntRoot] = tree2;
+				root[++version] = tree2;
 			} else if (op == 1) {
 				x = in.nextInt();
 				y = in.nextInt();
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index b73daaf6b..a74848a3d 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -25,7 +25,7 @@
 //int ls[MAXT];
 //int rs[MAXT];
 //long long sum[MAXT];
-//int cntRoot;
+//int version;
 //
 //int pool[MAXT];
 //int top;
@@ -156,10 +156,10 @@
 //    cin.tie(nullptr);
 //    prepare();
 //    cin >> n >> m;
-//    cntRoot = 1;
+//    version = 1;
 //    for (int i = 1, x; i <= n; i++) {
 //        cin >> x;
-//        root[cntRoot] = add(i, x, 1, n, root[1]);
+//        root[version] = add(i, x, 1, n, root[1]);
 //    }
 //    for (int i = 1, op, x, y, z; i <= m; i++) {
 //        cin >> op;
@@ -167,7 +167,7 @@
 //            cin >> x >> y >> z;
 //            split(y, z, 1, n, root[x]);
 //            root[x] = tree1;
-//            root[++cntRoot] = tree2;
+//            root[++version] = tree2;
 //        } else if (op == 1) {
 //            cin >> x >> y;
 //            root[x] = merge(1, n, root[x], root[y]);

From f999b69d8f5befa41fe6767f5b86704b48c099ee Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Nov 2025 10:22:04 +0800
Subject: [PATCH 1639/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 48 ++++++++++++++++++++++----
 src/class182/Code01_LeadersGroup2.java | 47 +++++++++++++++++++++----
 2 files changed, 81 insertions(+), 14 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index a28f46a7f..af132cf31 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -15,14 +15,16 @@
 import java.io.InputStream;
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
+import java.util.Arrays;
 
 public class Code01_LeadersGroup1 {
 
 	public static int MAXN = 200001;
-	public static int MAXV = 1000000000;
-	public static int MAXT = MAXN * 40;
+	public static int MAXT = MAXN * 20;
 	public static int n;
 	public static int[] arr = new int[MAXN];
+	public static int[] sorted = new int[MAXN];
+	public static int cntv;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN];
@@ -36,6 +38,20 @@ public class Code01_LeadersGroup1 {
 	public static int[] addTag = new int[MAXT];
 	public static int cntt;
 
+	public static int kth(int num) {
+		int left = 1, right = cntv, mid, ret = 0;
+		while (left <= right) {
+			mid = (left + right) >> 1;
+			if (sorted[mid] <= num) {
+				ret = mid;
+				left = mid + 1;
+			} else {
+				right = mid - 1;
+			}
+		}
+		return ret;
+	}
+
 	public static void addEdge(int u, int v) {
 		nxt[++cntg] = head[u];
 		to[cntg] = v;
@@ -124,14 +140,31 @@ public static int merge(int l, int r, int t1, int t2, int max1, int max2) {
 	}
 
 	public static void dp(int u) {
-		int val = 0;
+		int sum = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			dp(v);
-			val += query(arr[u], MAXV, 1, MAXV, root[v]);
-			root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
+			sum += query(arr[u], cntv, 1, cntv, root[v]);
+			root[u] = merge(1, cntv, root[u], root[v], 0, 0);
+		}
+		root[u] = update(arr[u], sum + 1, 1, cntv, root[u]);
+	}
+
+	public static void prepare() {
+		for (int i = 1; i <= n; i++) {
+			sorted[++cntv] = arr[i];
+		}
+		Arrays.sort(sorted, 1, cntv + 1);
+		int len = 1;
+		for (int i = 2; i <= cntv; i++) {
+			if (sorted[len] != sorted[i]) {
+				sorted[++len] = sorted[i];
+			}
+		}
+		cntv = len;
+		for (int i = 1; i <= n; i++) {
+			arr[i] = kth(arr[i]);
 		}
-		root[u] = update(arr[u], val + 1, 1, MAXV, root[u]);
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -145,8 +178,9 @@ public static void main(String[] args) throws Exception {
 			fa = in.nextInt();
 			addEdge(fa, i);
 		}
+		prepare();
 		dp(1);
-		out.println(query(1, MAXV, 1, MAXV, root[1]));
+		out.println(query(1, cntv, 1, cntv, root[1]));
 		out.flush();
 		out.close();
 	}
diff --git a/src/class182/Code01_LeadersGroup2.java b/src/class182/Code01_LeadersGroup2.java
index b6c4dc7f9..2891bffed 100644
--- a/src/class182/Code01_LeadersGroup2.java
+++ b/src/class182/Code01_LeadersGroup2.java
@@ -17,10 +17,11 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//const int MAXV = 1000000000;
-//const int MAXT = MAXN * 40;
+//const int MAXT = MAXN * 20;
 //int n;
 //int arr[MAXN];
+//int sorted[MAXN];
+//int cntv;
 //
 //int head[MAXN];
 //int nxt[MAXN];
@@ -34,6 +35,20 @@
 //int addTag[MAXT];
 //int cntt;
 //
+//int kth(int num) {
+//    int left = 1, right = cntv, ret = 0;
+//    while (left <= right) {
+//        int mid = (left + right) >> 1;
+//        if (sorted[mid] <= num) {
+//            ret = mid;
+//            left = mid + 1;
+//        } else {
+//            right = mid - 1;
+//        }
+//    }
+//    return ret;
+//}
+//
 //void addEdge(int u, int v) {
 //    nxt[++cntg] = head[u];
 //    to[cntg] = v;
@@ -122,14 +137,31 @@
 //}
 //
 //void dp(int u) {
-//    int val = 0;
+//    int sum = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        dp(v);
-//        val += query(arr[u], MAXV, 1, MAXV, root[v]);
-//        root[u] = merge(1, MAXV, root[u], root[v], 0, 0);
+//        sum += query(arr[u], cntv, 1, cntv, root[v]);
+//        root[u] = merge(1, cntv, root[u], root[v], 0, 0);
+//    }
+//    root[u] = update(arr[u], sum + 1, 1, cntv, root[u]);
+//}
+//
+//void prepare() {
+//    for (int i = 1; i <= n; i++) {
+//        sorted[++cntv] = arr[i];
+//    }
+//    sort(sorted + 1, sorted + cntv + 1);
+//    int len = 1;
+//    for (int i = 2; i <= cntv; i++) {
+//        if (sorted[len] != sorted[i]) {
+//            sorted[++len] = sorted[i];
+//        }
+//    }
+//    cntv = len;
+//    for (int i = 1; i <= n; i++) {
+//        arr[i] = kth(arr[i]);
 //    }
-//    root[u] = update(arr[u], val + 1, 1, MAXV, root[u]);
 //}
 //
 //int main() {
@@ -143,7 +175,8 @@
 //        cin >> fa;
 //        addEdge(fa, i);
 //    }
+//    prepare();
 //    dp(1);
-//    cout << query(1, MAXV, 1, MAXV, root[1]) << '\n';
+//    cout << query(1, cntv, 1, cntv, root[1]) << '\n';
 //    return 0;
 //}
\ No newline at end of file

From 271939e50793c380cdfe0e6697453d56f361edc2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Nov 2025 10:27:21 +0800
Subject: [PATCH 1640/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 12 ++++++------
 src/class182/Code01_LeadersGroup2.java | 12 ++++++------
 src/class182/Code02_Minimax1.java      | 14 +++++++-------
 src/class182/Code02_Minimax2.java      | 14 +++++++-------
 src/class182/Code03_Fate1.java         | 14 +++++++-------
 src/class182/Code03_Fate2.java         | 14 +++++++-------
 6 files changed, 40 insertions(+), 40 deletions(-)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index af132cf31..623bfc839 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -35,7 +35,7 @@ public class Code01_LeadersGroup1 {
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static int[] maxv = new int[MAXT];
-	public static int[] addTag = new int[MAXT];
+	public static int[] addLazy = new int[MAXT];
 	public static int cntt;
 
 	public static int kth(int num) {
@@ -65,15 +65,15 @@ public static void up(int i) {
 	public static void lazy(int i, int v) {
 		if (i != 0) {
 			maxv[i] += v;
-			addTag[i] += v;
+			addLazy[i] += v;
 		}
 	}
 
 	public static void down(int i) {
-		if (addTag[i] > 0) {
-			lazy(ls[i], addTag[i]);
-			lazy(rs[i], addTag[i]);
-			addTag[i] = 0;
+		if (addLazy[i] > 0) {
+			lazy(ls[i], addLazy[i]);
+			lazy(rs[i], addLazy[i]);
+			addLazy[i] = 0;
 		}
 	}
 
diff --git a/src/class182/Code01_LeadersGroup2.java b/src/class182/Code01_LeadersGroup2.java
index 2891bffed..3e7a88553 100644
--- a/src/class182/Code01_LeadersGroup2.java
+++ b/src/class182/Code01_LeadersGroup2.java
@@ -32,7 +32,7 @@
 //int ls[MAXT];
 //int rs[MAXT];
 //int maxv[MAXT];
-//int addTag[MAXT];
+//int addLazy[MAXT];
 //int cntt;
 //
 //int kth(int num) {
@@ -62,15 +62,15 @@
 //void lazy(int i, int v) {
 //    if (i != 0) {
 //        maxv[i] += v;
-//        addTag[i] += v;
+//        addLazy[i] += v;
 //    }
 //}
 //
 //void down(int i) {
-//    if (addTag[i] > 0) {
-//        lazy(ls[i], addTag[i]);
-//        lazy(rs[i], addTag[i]);
-//        addTag[i] = 0;
+//    if (addLazy[i] > 0) {
+//        lazy(ls[i], addLazy[i]);
+//        lazy(rs[i], addLazy[i]);
+//        addLazy[i] = 0;
 //    }
 //}
 //
diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index b8993d563..5480956dd 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -37,7 +37,7 @@ public class Code02_Minimax1 {
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static long[] sum = new long[MAXT];
-	public static long[] mul = new long[MAXT];
+	public static long[] mulLazy = new long[MAXT];
 	public static int cntt;
 
 	public static long[] D = new long[MAXN];
@@ -75,15 +75,15 @@ public static void up(int i) {
 	public static void lazy(int i, long v) {
 		if (i != 0) {
 			sum[i] = sum[i] * v % MOD;
-			mul[i] = mul[i] * v % MOD;
+			mulLazy[i] = mulLazy[i] * v % MOD;
 		}
 	}
 
 	public static void down(int i) {
-		if (mul[i] != 1) {
-			lazy(ls[i], mul[i]);
-			lazy(rs[i], mul[i]);
-			mul[i] = 1;
+		if (mulLazy[i] != 1) {
+			lazy(ls[i], mulLazy[i]);
+			lazy(rs[i], mulLazy[i]);
+			mulLazy[i] = 1;
 		}
 	}
 
@@ -91,7 +91,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		int rt = i;
 		if (rt == 0) {
 			rt = ++cntt;
-			mul[rt] = 1;
+			mulLazy[rt] = 1;
 		}
 		if (l == r) {
 			sum[rt] = 1;
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index f47a5c3c4..51aaf4dfc 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -36,7 +36,7 @@
 //int cntt;
 //
 //long long sum[MAXT];
-//long long mul[MAXT];
+//long long mulLazy[MAXT];
 //
 //long long D[MAXN];
 //
@@ -73,15 +73,15 @@
 //void lazy(int i, long long v) {
 //    if (i) {
 //        sum[i] = sum[i] * v % MOD;
-//        mul[i] = mul[i] * v % MOD;
+//        mulLazy[i] = mulLazy[i] * v % MOD;
 //    }
 //}
 //
 //void down(int i) {
-//    if (mul[i] != 1) {
-//        lazy(ls[i], mul[i]);
-//        lazy(rs[i], mul[i]);
-//        mul[i] = 1;
+//    if (mulLazy[i] != 1) {
+//        lazy(ls[i], mulLazy[i]);
+//        lazy(rs[i], mulLazy[i]);
+//        mulLazy[i] = 1;
 //    }
 //}
 //
@@ -89,7 +89,7 @@
 //    int rt = i;
 //    if (rt == 0) {
 //        rt = ++cntt;
-//        mul[rt] = 1;
+//        mulLazy[rt] = 1;
 //    }
 //    if (l == r) {
 //        sum[rt] = 1;
diff --git a/src/class182/Code03_Fate1.java b/src/class182/Code03_Fate1.java
index 6c28a064d..5232002d8 100644
--- a/src/class182/Code03_Fate1.java
+++ b/src/class182/Code03_Fate1.java
@@ -31,7 +31,7 @@ public class Code03_Fate1 {
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
 	public static long[] sum = new long[MAXT];
-	public static long[] mul = new long[MAXT];
+	public static long[] mulLazy = new long[MAXT];
 	public static int cntt;
 
 	public static int[] dep = new int[MAXN];
@@ -68,15 +68,15 @@ public static void up(int i) {
 	public static void lazy(int i, long v) {
 		if (i != 0) {
 			sum[i] = sum[i] * v % MOD;
-			mul[i] = mul[i] * v % MOD;
+			mulLazy[i] = mulLazy[i] * v % MOD;
 		}
 	}
 
 	public static void down(int i) {
-		if (mul[i] != 1) {
-			lazy(ls[i], mul[i]);
-			lazy(rs[i], mul[i]);
-			mul[i] = 1;
+		if (mulLazy[i] != 1) {
+			lazy(ls[i], mulLazy[i]);
+			lazy(rs[i], mulLazy[i]);
+			mulLazy[i] = 1;
 		}
 	}
 
@@ -84,7 +84,7 @@ public static int insert(int jobi, int l, int r, int i) {
 		int rt = i;
 		if (rt == 0) {
 			rt = ++cntt;
-			mul[rt] = 1;
+			mulLazy[rt] = 1;
 		}
 		if (l == r) {
 			sum[rt] = 1;
diff --git a/src/class182/Code03_Fate2.java b/src/class182/Code03_Fate2.java
index 79fb49646..bb6d90f36 100644
--- a/src/class182/Code03_Fate2.java
+++ b/src/class182/Code03_Fate2.java
@@ -29,7 +29,7 @@
 //int ls[MAXT];
 //int rs[MAXT];
 //long long sum[MAXT];
-//long long mul[MAXT];
+//long long mulLazy[MAXT];
 //int cntt;
 //
 //int dep[MAXN];
@@ -48,15 +48,15 @@
 //void lazy(int i, long long v) {
 //    if (i != 0) {
 //        sum[i] = sum[i] * v % MOD;
-//        mul[i] = mul[i] * v % MOD;
+//        mulLazy[i] = mulLazy[i] * v % MOD;
 //    }
 //}
 //
 //void down(int i) {
-//    if (mul[i] != 1) {
-//        lazy(ls[i], mul[i]);
-//        lazy(rs[i], mul[i]);
-//        mul[i] = 1;
+//    if (mulLazy[i] != 1) {
+//        lazy(ls[i], mulLazy[i]);
+//        lazy(rs[i], mulLazy[i]);
+//        mulLazy[i] = 1;
 //    }
 //}
 //
@@ -64,7 +64,7 @@
 //    int rt = i;
 //    if (rt == 0) {
 //        rt = ++cntt;
-//        mul[rt] = 1;
+//        mulLazy[rt] = 1;
 //    }
 //    if (l == r) {
 //        sum[rt] = 1;

From f83161aa44fd50cd38f060e247a0b88a9396d14a Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Nov 2025 10:37:41 +0800
Subject: [PATCH 1641/1712] modify code

---
 src/class182/Code02_Minimax1.java | 16 ++++++++--------
 src/class182/Code02_Minimax2.java | 13 ++++++-------
 2 files changed, 14 insertions(+), 15 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 5480956dd..00d3ce65d 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -136,21 +136,21 @@ public static int merge(int l, int r, int t1, int t2, int p, long sum1, long sum
 	}
 
 	// 迭代版，java会爆栈，C++可以通过
-	public static void dfs1(int u) {
+	public static void dp1(int u) {
 		if (sonCnt[u] == 0) {
 			root[u] = insert(arr[u], 1, cntv, root[u]);
 		} else if (sonCnt[u] == 1) {
-			dfs1(son[u][0]);
+			dp1(son[u][0]);
 			root[u] = root[son[u][0]];
 		} else {
-			dfs1(son[u][0]);
-			dfs1(son[u][1]);
+			dp1(son[u][0]);
+			dp1(son[u][1]);
 			root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], arr[u], 0, 0);
 		}
 	}
 
-	// dfs1改成迭代版
-	public static void dfs2() {
+	// dp1改成迭代版
+	public static void dp2() {
 		int[][] stack = new int[n + 1][2];
 		int siz = 0;
 		stack[++siz][0] = 1;
@@ -238,8 +238,8 @@ public static void main(String[] args) throws Exception {
 			arr[i] = in.nextInt();
 		}
 		prepare();
-		// dfs1(1);
-		dfs2();
+		// dp1(1);
+		dp2();
 		getd(1, cntv, root[1]);
 		long ans = 0;
 		for (int i = 1; i <= cntv; i++) {
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index 51aaf4dfc..a7e1a996c 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -33,10 +33,9 @@
 //int root[MAXN];
 //int ls[MAXT];
 //int rs[MAXT];
-//int cntt;
-//
 //long long sum[MAXT];
 //long long mulLazy[MAXT];
+//int cntt;
 //
 //long long D[MAXN];
 //
@@ -133,15 +132,15 @@
 //    return t1;
 //}
 //
-//void dfs(int u) {
+//void dp(int u) {
 //    if (sonCnt[u] == 0) {
 //        root[u] = insert(arr[u], 1, cntv, root[u]);
 //    } else if (sonCnt[u] == 1) {
-//        dfs(son[u][0]);
+//        dp(son[u][0]);
 //        root[u] = root[son[u][0]];
 //    } else {
-//        dfs(son[u][0]);
-//        dfs(son[u][1]);
+//        dp(son[u][0]);
+//        dp(son[u][1]);
 //        root[u] = merge(1, cntv, root[son[u][0]], root[son[u][1]], arr[u], 0, 0);
 //    }
 //}
@@ -200,7 +199,7 @@
 //        cin >> arr[i];
 //    }
 //    prepare();
-//    dfs(1);
+//    dp(1);
 //    getd(1, cntv, root[1]);
 //    long long ans = 0;
 //    for (int i = 1; i <= cntv; i++) {

From e5ac66cef89f4110addd8d4378c3b0a1bfd65742 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Nov 2025 13:15:44 +0800
Subject: [PATCH 1642/1712] modify code

---
 src/class182/Code01_LeadersGroup1.java | 6 ++++++
 1 file changed, 6 insertions(+)

diff --git a/src/class182/Code01_LeadersGroup1.java b/src/class182/Code01_LeadersGroup1.java
index 623bfc839..c3f052376 100644
--- a/src/class182/Code01_LeadersGroup1.java
+++ b/src/class182/Code01_LeadersGroup1.java
@@ -77,6 +77,7 @@ public static void down(int i) {
 		}
 	}
 
+	// jobi来了个新值jobv，如果比之前获得的值更大就更新，否则不更新
 	public static int update(int jobi, int jobv, int l, int r, int i) {
 		int rt = i;
 		if (rt == 0) {
@@ -97,6 +98,7 @@ public static int update(int jobi, int jobv, int l, int r, int i) {
 		return rt;
 	}
 
+	// 查询[jobl..jobr]范围上的最大值
 	public static int query(int jobl, int jobr, int l, int r, int i) {
 		if (i == 0) {
 			return 0;
@@ -116,6 +118,8 @@ public static int query(int jobl, int jobr, int l, int r, int i) {
 		return ans;
 	}
 
+	// 线段树合并
+	// max1代表dp[u][r+1...]的最大值，max2代表dp[v][r+1...]的最大值
 	public static int merge(int l, int r, int t1, int t2, int max1, int max2) {
 		if (t1 == 0 || t2 == 0) {
 			if (t1 != 0) {
@@ -145,8 +149,10 @@ public static void dp(int u) {
 			int v = to[e];
 			dp(v);
 			sum += query(arr[u], cntv, 1, cntv, root[v]);
+			// 不选u的情况，每棵子树合并一遍
 			root[u] = merge(1, cntv, root[u], root[v], 0, 0);
 		}
+		// 选u的情况，最后sum需要加1
 		root[u] = update(arr[u], sum + 1, 1, cntv, root[u]);
 	}
 

From 1f31558f3d6844a71f320f11049a14c5b2340cb2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 4 Nov 2025 13:54:09 +0800
Subject: [PATCH 1643/1712] modify code

---
 src/class182/Code02_Minimax1.java | 2 +-
 src/class182/Code02_Minimax2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class182/Code02_Minimax1.java b/src/class182/Code02_Minimax1.java
index 00d3ce65d..c426013f2 100644
--- a/src/class182/Code02_Minimax1.java
+++ b/src/class182/Code02_Minimax1.java
@@ -3,7 +3,7 @@
 // 根节点的取值，java版
 // 一共有n个节点，1号节点是整棵树的头，所有节点组成一棵树
 // 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
-// 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权
+// 如果节点x不是叶，那么它最多有两个孩子，此时arr[x]代表概率，节点x按照以下规则取得点权
 // 以arr[x]的概率是所有儿子的点权最大值，以1 - arr[x]的概率是所有儿子的点权最小值
 // 表示概率时，arr[x]的范围是[1, 9999]，表示概率 0.0001 ~ 0.9999
 // 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得概率为Di
diff --git a/src/class182/Code02_Minimax2.java b/src/class182/Code02_Minimax2.java
index a7e1a996c..6891c0743 100644
--- a/src/class182/Code02_Minimax2.java
+++ b/src/class182/Code02_Minimax2.java
@@ -3,7 +3,7 @@
 // 根节点的取值，C++版
 // 一共有n个节点，1号节点是整棵树的头，所有节点组成一棵树
 // 给定一个长度为n的数组arr，如果节点x是叶，那么arr[x]表示点权，所有叶节点的点权都不同
-// 如果节点x不是叶，那么它最多有两个孩子，那么arr[x]代表概率，按如下规则决定节点x的点权
+// 如果节点x不是叶，那么它最多有两个孩子，此时arr[x]代表概率，节点x按照以下规则取得点权
 // 以arr[x]的概率是所有儿子的点权最大值，以1 - arr[x]的概率是所有儿子的点权最小值
 // 表示概率时，arr[x]的范围是[1, 9999]，表示概率 0.0001 ~ 0.9999
 // 假设1号结点的权值有m种可能性，第i小的权值是Vi，取得概率为Di

From 2ba31fd846d88e8fd8329fc60af79ed980af412c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 10:06:59 +0800
Subject: [PATCH 1644/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java | 7 ++-----
 src/class182/Code04_SegmentTreeSplit2.java | 2 +-
 2 files changed, 3 insertions(+), 6 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index c89cdbe02..a5f2c27b6 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -10,10 +10,7 @@
 // 操作 4 x y   : x号集合中，查询第y小的数字，不存在打印-1
 // 1 <= 所有数据 <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5494
-// 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code04_SegmentTreeSplit2文件就是C++的实现
-// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -23,7 +20,7 @@
 public class Code04_SegmentTreeSplit1 {
 
 	public static int MAXN = 200001;
-	public static int MAXT = MAXN * 40;
+	public static int MAXT = MAXN * 10;
 	public static int n, m;
 
 	public static int[] root = new int[MAXN];
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index a74848a3d..16e259611 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -18,7 +18,7 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//const int MAXT = MAXN * 40;
+//const int MAXT = MAXN * 10;
 //int n, m;
 //
 //int root[MAXN];

From 277a3c910076e49fe21f31d8281b50d3fb710dec Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 10:15:38 +0800
Subject: [PATCH 1645/1712] modify code

---
 src/class182/Code04_SegmentTreeSplit1.java | 2 +-
 src/class182/Code04_SegmentTreeSplit2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class182/Code04_SegmentTreeSplit1.java b/src/class182/Code04_SegmentTreeSplit1.java
index a5f2c27b6..9d337003f 100644
--- a/src/class182/Code04_SegmentTreeSplit1.java
+++ b/src/class182/Code04_SegmentTreeSplit1.java
@@ -2,7 +2,7 @@
 
 // 线段树分裂，java版
 // 数字范围1~n，给定每种数字的个数，建立编号为1的可重集合，以后新集合的编号自增即可
-// 接下来有m条操作，每条操作是如下六种类型中的一种
+// 接下来有m条操作，每条操作是如下五种类型中的一种
 // 操作 0 x y z : x号集合中，取出[y, z]范围上的所有数字，生成新的集合
 // 操作 1 x y   : x号集合与y号集合合并，以后y编号的集合不会使用了
 // 操作 2 x y z : x号集合中，加入y个数字z
diff --git a/src/class182/Code04_SegmentTreeSplit2.java b/src/class182/Code04_SegmentTreeSplit2.java
index 16e259611..c3b4eb752 100644
--- a/src/class182/Code04_SegmentTreeSplit2.java
+++ b/src/class182/Code04_SegmentTreeSplit2.java
@@ -2,7 +2,7 @@
 
 // 线段树分裂，C++版
 // 数字范围1~n，给定每种数字的个数，建立编号为1的可重集合，以后新集合的编号自增即可
-// 接下来有m条操作，每条操作是如下六种类型中的一种
+// 接下来有m条操作，每条操作是如下五种类型中的一种
 // 操作 0 x y z : x号集合中，取出[y, z]范围上的所有数字，生成新的集合
 // 操作 1 x y   : x号集合与y号集合合并，以后y编号的集合不会使用了
 // 操作 2 x y z : x号集合中，加入y个数字z

From 3810c818409071a75b222d067247886cc45398d0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 10:26:13 +0800
Subject: [PATCH 1646/1712] modify code

---
 src/class182/Code05_MassChangeQueries1.java | 2 +-
 src/class182/Code05_MassChangeQueries2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index 586e25758..399c2d3fa 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -19,7 +19,7 @@ public class Code05_MassChangeQueries1 {
 
 	public static int MAXN = 200001;
 	public static int MAXV = 100;
-	public static int MAXT = MAXN * 40;
+	public static int MAXT = MAXN * 10;
 	public static int n, q;
 	public static int[] arr = new int[MAXN];
 
diff --git a/src/class182/Code05_MassChangeQueries2.java b/src/class182/Code05_MassChangeQueries2.java
index 240be11c0..17af5eb7c 100644
--- a/src/class182/Code05_MassChangeQueries2.java
+++ b/src/class182/Code05_MassChangeQueries2.java
@@ -17,7 +17,7 @@
 //
 //const int MAXN = 200001;
 //const int MAXV = 100;
-//const int MAXT = MAXN * 40;
+//const int MAXT = MAXN * 10;
 //int n, q;
 //int arr[MAXN];
 //

From 9b7466e4d350ae1999ff2ace29bb411f411332f2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 11:34:38 +0800
Subject: [PATCH 1647/1712] modify code

---
 src/class182/Code05_MassChangeQueries1.java | 6 ++----
 src/class182/Code05_MassChangeQueries2.java | 6 ++----
 2 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index 399c2d3fa..a9be87586 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -31,8 +31,6 @@ public class Code05_MassChangeQueries1 {
 	public static int[] pool = new int[MAXT];
 	public static int top;
 
-	public static int[] ans = new int[MAXN];
-
 	public static void prepare() {
 		top = 0;
 		for (int i = 1; i < MAXT; i++) {
@@ -126,7 +124,7 @@ public static void dfs(int val, int l, int r, int i) {
 			return;
 		}
 		if (l == r) {
-			ans[l] = val;
+			arr[l] = val;
 		} else {
 			int mid = (l + r) >> 1;
 			dfs(val, l, mid, ls[i]);
@@ -159,7 +157,7 @@ public static void main(String[] args) throws Exception {
 			dfs(v, 1, n, root[v]);
 		}
 		for (int i = 1; i <= n; i++) {
-			out.print(ans[i] + " ");
+			out.print(arr[i] + " ");
 		}
 		out.flush();
 		out.close();
diff --git a/src/class182/Code05_MassChangeQueries2.java b/src/class182/Code05_MassChangeQueries2.java
index 17af5eb7c..21474545b 100644
--- a/src/class182/Code05_MassChangeQueries2.java
+++ b/src/class182/Code05_MassChangeQueries2.java
@@ -29,8 +29,6 @@
 //int pool[MAXT];
 //int top;
 //
-//int ans[MAXN];
-//
 //void prepare() {
 //    top = 0;
 //    for (int i = 1; i < MAXT; i++) {
@@ -124,7 +122,7 @@
 //        return;
 //    }
 //    if (l == r) {
-//        ans[l] = val;
+//        arr[l] = val;
 //    } else {
 //        int mid = (l + r) >> 1;
 //        dfs(val, l, mid, ls[i]);
@@ -154,7 +152,7 @@
 //        dfs(v, 1, n, root[v]);
 //    }
 //    for (int i = 1; i <= n; i++) {
-//        cout << ans[i] << ' ';
+//        cout << arr[i] << ' ';
 //    }
 //    return 0;
 //}
\ No newline at end of file

From f5c17d73a39044c122b5dd04fa1352759abd2198 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 11:43:43 +0800
Subject: [PATCH 1648/1712] modify code

---
 src/class182/Code05_MassChangeQueries1.java | 12 ++++++------
 src/class182/Code05_MassChangeQueries2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index a9be87586..ce41222be 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -26,7 +26,7 @@ public class Code05_MassChangeQueries1 {
 	public static int[] root = new int[MAXV + 1];
 	public static int[] ls = new int[MAXT];
 	public static int[] rs = new int[MAXT];
-	public static int[] sum = new int[MAXT];
+	public static boolean[] status = new boolean[MAXT];
 
 	public static int[] pool = new int[MAXT];
 	public static int top;
@@ -46,11 +46,11 @@ public static void del(int i) {
 		pool[++top] = i;
 		ls[i] = 0;
 		rs[i] = 0;
-		sum[i] = 0;
+		status[i] = false;
 	}
 
 	public static void up(int i) {
-		sum[i] = sum[ls[i]] + sum[rs[i]];
+		status[i] = status[ls[i]] | status[rs[i]];
 	}
 
 	public static int insert(int jobi, int l, int r, int i) {
@@ -59,7 +59,7 @@ public static int insert(int jobi, int l, int r, int i) {
 			rt = newNode();
 		}
 		if (l == r) {
-			sum[rt]++;
+			status[rt] = true;
 		} else {
 			int mid = (l + r) >> 1;
 			if (jobi <= mid) {
@@ -77,7 +77,7 @@ public static int merge(int l, int r, int t1, int t2) {
 			return t1 + t2;
 		}
 		if (l == r) {
-			sum[t1] += sum[t2];
+			status[t1] |= status[t2];
 		} else {
 			int mid = (l + r) >> 1;
 			ls[t1] = merge(l, mid, ls[t1], ls[t2]);
@@ -120,7 +120,7 @@ public static void split(int jobl, int jobr, int l, int r, int t1) {
 	}
 
 	public static void dfs(int val, int l, int r, int i) {
-		if (i == 0 || sum[i] == 0) {
+		if (i == 0 || !status[i]) {
 			return;
 		}
 		if (l == r) {
diff --git a/src/class182/Code05_MassChangeQueries2.java b/src/class182/Code05_MassChangeQueries2.java
index 21474545b..63a59674b 100644
--- a/src/class182/Code05_MassChangeQueries2.java
+++ b/src/class182/Code05_MassChangeQueries2.java
@@ -24,7 +24,7 @@
 //int root[MAXV + 1];
 //int ls[MAXT];
 //int rs[MAXT];
-//int sum[MAXT];
+//bool status[MAXT];
 //
 //int pool[MAXT];
 //int top;
@@ -44,11 +44,11 @@
 //    pool[++top] = i;
 //    ls[i] = 0;
 //    rs[i] = 0;
-//    sum[i] = 0;
+//    status[i] = false;
 //}
 //
 //void up(int i) {
-//    sum[i] = sum[ls[i]] + sum[rs[i]];
+//    status[i] = status[ls[i]] | status[rs[i]];
 //}
 //
 //int insert(int jobi, int l, int r, int i) {
@@ -57,7 +57,7 @@
 //        rt = newNode();
 //    }
 //    if (l == r) {
-//        sum[rt]++;
+//        status[rt] = true;
 //    } else {
 //        int mid = (l + r) >> 1;
 //        if (jobi <= mid) {
@@ -75,7 +75,7 @@
 //        return t1 + t2;
 //    }
 //    if (l == r) {
-//        sum[t1] += sum[t2];
+//        status[t1] |= status[t2];
 //    } else {
 //        int mid = (l + r) >> 1;
 //        ls[t1] = merge(l, mid, ls[t1], ls[t2]);
@@ -118,7 +118,7 @@
 //}
 //
 //void dfs(int val, int l, int r, int i) {
-//    if (i == 0 || sum[i] == 0) {
+//    if (i == 0 || !status[i]) {
 //        return;
 //    }
 //    if (l == r) {

From 27a6de18ac7f6f5d8deb6e60cdd64a693c488606 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 11:54:30 +0800
Subject: [PATCH 1649/1712] modify code

---
 src/class182/Code05_MassChangeQueries1.java | 2 +-
 src/class182/Code05_MassChangeQueries2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index ce41222be..059ea71d3 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -18,8 +18,8 @@
 public class Code05_MassChangeQueries1 {
 
 	public static int MAXN = 200001;
-	public static int MAXV = 100;
 	public static int MAXT = MAXN * 10;
+	public static int MAXV = 100;
 	public static int n, q;
 	public static int[] arr = new int[MAXN];
 
diff --git a/src/class182/Code05_MassChangeQueries2.java b/src/class182/Code05_MassChangeQueries2.java
index 63a59674b..60f0190d1 100644
--- a/src/class182/Code05_MassChangeQueries2.java
+++ b/src/class182/Code05_MassChangeQueries2.java
@@ -16,8 +16,8 @@
 //using namespace std;
 //
 //const int MAXN = 200001;
-//const int MAXV = 100;
 //const int MAXT = MAXN * 10;
+//const int MAXV = 100;
 //int n, q;
 //int arr[MAXN];
 //

From b95202f1488395969b27719fd857ab588b2edfd4 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 12:01:32 +0800
Subject: [PATCH 1650/1712] modify code

---
 src/class182/Code05_MassChangeQueries1.java | 2 +-
 src/class182/Code05_MassChangeQueries2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class182/Code05_MassChangeQueries1.java b/src/class182/Code05_MassChangeQueries1.java
index 059ea71d3..fa17c831e 100644
--- a/src/class182/Code05_MassChangeQueries1.java
+++ b/src/class182/Code05_MassChangeQueries1.java
@@ -140,10 +140,10 @@ public static void main(String[] args) throws Exception {
 		for (int i = 1; i <= n; i++) {
 			arr[i] = in.nextInt();
 		}
-		q = in.nextInt();
 		for (int i = 1; i <= n; i++) {
 			root[arr[i]] = insert(i, 1, n, root[arr[i]]);
 		}
+		q = in.nextInt();
 		for (int i = 1, l, r, x, y; i <= q; i++) {
 			l = in.nextInt();
 			r = in.nextInt();
diff --git a/src/class182/Code05_MassChangeQueries2.java b/src/class182/Code05_MassChangeQueries2.java
index 60f0190d1..e5eb7b03a 100644
--- a/src/class182/Code05_MassChangeQueries2.java
+++ b/src/class182/Code05_MassChangeQueries2.java
@@ -138,10 +138,10 @@
 //    for (int i = 1; i <= n; i++) {
 //        cin >> arr[i];
 //    }
-//    cin >> q;
 //    for (int i = 1; i <= n; i++) {
 //        root[arr[i]] = insert(i, 1, n, root[arr[i]]);
 //    }
+//    cin >> q;
 //    for (int i = 1, l, r, x, y; i <= q; i++) {
 //        cin >> l >> r >> x >> y;
 //        split(l, r, 1, n, root[x]);

From b5f510fee822bbc71fc090a9d53b93e735e455b3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 5 Nov 2025 12:15:21 +0800
Subject: [PATCH 1651/1712] modify code

---
 ...6\345\210\206\350\243\202-\344\270\213.pptx" | Bin 0 -> 45856 bytes
 1 file changed, 0 insertions(+), 0 deletions(-)
 create mode 100644 "ppt/\347\256\227\346\263\225\350\256\262\350\247\243182\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\347\232\204\345\220\210\345\271\266\344\270\216\345\210\206\350\243\202-\344\270\213.pptx"

diff --git "a/ppt/\347\256\227\346\263\225\350\256\262\350\247\243182\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\347\232\204\345\220\210\345\271\266\344\270\216\345\210\206\350\243\202-\344\270\213.pptx" "b/ppt/\347\256\227\346\263\225\350\256\262\350\247\243182\343\200\220\346\214\272\351\232\276\343\200\221\347\272\277\346\256\265\346\240\221\347\232\204\345\220\210\345\271\266\344\270\216\345\210\206\350\243\202-\344\270\213.pptx"
new file mode 100644
index 0000000000000000000000000000000000000000..74c4eed286af8d959a94e3fe61b21058441eb3cf
GIT binary patch
literal 45856
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

literal 0
HcmV?d00001


From 772415439899565317c0c7d9f951e62e07ca563d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 16:07:01 +0800
Subject: [PATCH 1652/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        | 246 ++++++++++++++++++
 .../Code01_CentroidDecomposition2.java        | 140 ++++++++++
 2 files changed, 386 insertions(+)
 create mode 100644 src/class183/Code01_CentroidDecomposition1.java
 create mode 100644 src/class183/Code01_CentroidDecomposition2.java

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
new file mode 100644
index 000000000..711911b57
--- /dev/null
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -0,0 +1,246 @@
+package class183;
+
+// 点分治，也叫重心分治，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P3806
+// 提交以下的code，提交时请把类名改成"Main"
+// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
+// 想通过用C++实现，本节课Code01_CentroidDecomposition2文件就是C++的实现
+// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code01_CentroidDecomposition1 {
+
+	public static int MAXN = 10001;
+	public static int MAXV = 20000001;
+	public static int n, m, total;
+	public static int[] query = new int[MAXN];
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cntg;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxp = new int[MAXN];
+	public static int centroid;
+
+	public static int[] dis = new int[MAXN];
+	public static int[] valArr = new int[MAXV];
+	public static int cntv;
+	public static int[] que = new int[MAXV];
+	public static int cntq;
+	public static boolean[] judge = new boolean[MAXV];
+
+	public static boolean[] ans = new boolean[MAXN];
+
+	public static void addEdge(int u, int v, int w) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	// 找重心递归版，java会爆栈，C++可以通过
+	public static void getCentroid1(int u, int fa) {
+		siz[u] = 1;
+		maxp[u] = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getCentroid1(v, u);
+				siz[u] += siz[v];
+				maxp[u] = Math.max(siz[v], maxp[u]);
+			}
+		}
+		maxp[u] = Math.max(maxp[u], total - siz[u]);
+		if (maxp[u] < maxp[centroid]) {
+			centroid = u;
+		}
+	}
+
+	// 讲解118，递归改迭代需要的栈
+	public static int[][] ufe = new int[MAXN][3];
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		ufe[stacksize][0] = u;
+		ufe[stacksize][1] = f;
+		ufe[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = ufe[stacksize][0];
+		f = ufe[stacksize][1];
+		e = ufe[stacksize][2];
+	}
+
+	// 找重心迭代版
+	public static void getCentroid2(int cur, int fa) {
+		stacksize = 0;
+		push(cur, fa, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				siz[u] = 1;
+				maxp[u] = 0;
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				int v = to[e];
+				if (v != f && !vis[v]) {
+					push(v, u, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+					int v = to[ei];
+					if (v != f && !vis[v]) {
+						siz[u] += siz[v];
+						maxp[u] = Math.max(siz[v], maxp[u]);
+					}
+				}
+				maxp[u] = Math.max(maxp[u], total - siz[u]);
+				if (maxp[u] < maxp[centroid]) {
+					centroid = u;
+				}
+			}
+		}
+	}
+
+	public static void getDistance(int u, int fa, int w) {
+		dis[u] = dis[fa] + w;
+		valArr[++cntv] = dis[u];
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getDistance(v, u, weight[e]);
+			}
+		}
+	}
+
+	public static void calc(int u) {
+		dis[u] = 0;
+		cntq = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			int w = weight[e];
+			if (!vis[v]) {
+				cntv = 0;
+				getDistance(v, u, w);
+				for (int k = cntv; k > 0; k--) {
+					for (int l = 1; l <= m; l++) {
+						if (query[l] >= valArr[k]) {
+							ans[l] |= judge[query[l] - valArr[k]];
+						}
+					}
+				}
+				for (int k = cntv; k > 0; k--) {
+					que[++cntq] = valArr[k];
+					judge[valArr[k]] = true;
+				}
+			}
+		}
+		for (int i = cntq; i > 0; i--) {
+			judge[que[i]] = false;
+		}
+	}
+
+	public static void solve(int u) {
+		vis[u] = true;
+		judge[0] = true;
+		calc(u);
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				total = siz[v];
+				centroid = 0;
+				maxp[centroid] = n;
+				// getCentroid1(v, u);
+				getCentroid2(v, u);
+				solve(centroid);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		m = in.nextInt();
+		for (int i = 1, u, v, w; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextInt();
+			addEdge(u, v, w);
+			addEdge(v, u, w);
+		}
+		for (int i = 1; i <= m; i++) {
+			query[i] = in.nextInt();
+		}
+		total = n;
+		centroid = 0;
+		maxp[centroid] = n;
+		// getCentroid1(1, 0);
+		getCentroid2(1, 0);
+		solve(centroid);
+		for (int i = 1; i <= m; i++) {
+			if (ans[i]) {
+				out.println("AYE");
+			} else {
+				out.println("NAY");
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
new file mode 100644
index 000000000..98474b2f7
--- /dev/null
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -0,0 +1,140 @@
+package class183;
+
+// 点分治，也叫重心分治，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P3806
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 10001;
+//const int MAXV = 20000001;
+//int n, m, total;
+//int query[MAXN];
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxp[MAXN];
+//int centroid;
+//
+//int dis[MAXN];
+//int valArr[MAXV];
+//int cntv;
+//int que[MAXV];
+//int cntq;
+//bool judge[MAXV];
+//
+//bool ans[MAXN];
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxp[u] = 0;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxp[u] = max(maxp[u], siz[v]);
+//        }
+//    }
+//    maxp[u] = max(maxp[u], total - siz[u]);
+//    if (maxp[u] < maxp[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void getDistance(int u, int fa, int w) {
+//    dis[u] = dis[fa] + w;
+//    valArr[++cntv] = dis[u];
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getDistance(v, u, weight[e]);
+//        }
+//    }
+//}
+//
+//void calc(int u) {
+//    dis[u] = 0;
+//    cntq = 0;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        int w = weight[e];
+//        if (!vis[v]) {
+//            cntv = 0;
+//            getDistance(v, u, w);
+//            for (int k = cntv; k > 0; k--) {
+//                for (int l = 1; l <= m; l++) {
+//                    if (query[l] >= valArr[k]) {
+//                        ans[l] |= judge[query[l] - valArr[k]];
+//                    }
+//                }
+//            }
+//            for (int k = cntv; k > 0; k--) {
+//                que[++cntq] = valArr[k];
+//                judge[valArr[k]] = true;
+//            }
+//        }
+//    }
+//    for (int i = cntq; i > 0; i--) {
+//        judge[que[i]] = false;
+//    }
+//}
+//
+//void solve(int u) {
+//    vis[u] = true;
+//    judge[0] = true;
+//    calc(u);
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            total = siz[v];
+//            centroid = 0;
+//            maxp[centroid] = n;
+//            getCentroid(v, u);
+//            solve(centroid);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        addEdge(u, v, w);
+//        addEdge(v, u, w);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i];
+//    }
+//    total = n;
+//    centroid = 0;
+//    maxp[centroid] = n;
+//    getCentroid(1, 0);
+//    solve(centroid);
+//    for (int i = 1; i <= m; i++) {
+//        if (ans[i]) {
+//            cout << "AYE" << '\n';
+//        } else {
+//            cout << "NAY" << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 237b91a453ac716f648895004cfd173153d3f7ea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 16:13:30 +0800
Subject: [PATCH 1653/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 4 ++--
 src/class183/Code01_CentroidDecomposition2.java | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 711911b57..35d09b9b0 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -15,7 +15,7 @@
 public class Code01_CentroidDecomposition1 {
 
 	public static int MAXN = 10001;
-	public static int MAXV = 20000001;
+	public static int MAXV = 15000001;
 	public static int n, m, total;
 	public static int[] query = new int[MAXN];
 
@@ -206,7 +206,7 @@ public static void main(String[] args) throws Exception {
 
 	// 读写工具类
 	static class FastReader {
-		private final byte[] buffer = new byte[1 << 16];
+		private final byte[] buffer = new byte[1 << 20];
 		private int ptr = 0, len = 0;
 		private final InputStream in;
 
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 98474b2f7..dfcf3d31b 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -10,7 +10,7 @@
 //using namespace std;
 //
 //const int MAXN = 10001;
-//const int MAXV = 20000001;
+//const int MAXV = 15000001;
 //int n, m, total;
 //int query[MAXN];
 //

From dbba838eb3a2e5387445909c34a219956cb7bda2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 17:14:43 +0800
Subject: [PATCH 1654/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        | 25 +++++++++----------
 .../Code01_CentroidDecomposition2.java        | 25 +++++++++----------
 2 files changed, 24 insertions(+), 26 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 35d09b9b0..3ee17e5e3 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -32,10 +32,9 @@ public class Code01_CentroidDecomposition1 {
 
 	public static int[] dis = new int[MAXN];
 	public static int[] valArr = new int[MAXV];
-	public static int cntv;
-	public static int[] que = new int[MAXV];
-	public static int cntq;
-	public static boolean[] judge = new boolean[MAXV];
+	public static int[] valQue = new int[MAXV];
+	public static boolean[] valJudge = new boolean[MAXV];
+	public static int cnta, cntq;
 
 	public static boolean[] ans = new boolean[MAXN];
 
@@ -119,7 +118,7 @@ public static void getCentroid2(int cur, int fa) {
 
 	public static void getDistance(int u, int fa, int w) {
 		dis[u] = dis[fa] + w;
-		valArr[++cntv] = dis[u];
+		valArr[++cnta] = dis[u];
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
@@ -135,29 +134,29 @@ public static void calc(int u) {
 			int v = to[e];
 			int w = weight[e];
 			if (!vis[v]) {
-				cntv = 0;
+				cnta = 0;
 				getDistance(v, u, w);
-				for (int k = cntv; k > 0; k--) {
+				for (int k = cnta; k > 0; k--) {
 					for (int l = 1; l <= m; l++) {
 						if (query[l] >= valArr[k]) {
-							ans[l] |= judge[query[l] - valArr[k]];
+							ans[l] |= valJudge[query[l] - valArr[k]];
 						}
 					}
 				}
-				for (int k = cntv; k > 0; k--) {
-					que[++cntq] = valArr[k];
-					judge[valArr[k]] = true;
+				for (int k = cnta; k > 0; k--) {
+					valQue[++cntq] = valArr[k];
+					valJudge[valArr[k]] = true;
 				}
 			}
 		}
 		for (int i = cntq; i > 0; i--) {
-			judge[que[i]] = false;
+			valJudge[valQue[i]] = false;
 		}
 	}
 
 	public static void solve(int u) {
 		vis[u] = true;
-		judge[0] = true;
+		valJudge[0] = true;
 		calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index dfcf3d31b..921236f5b 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -27,10 +27,9 @@
 //
 //int dis[MAXN];
 //int valArr[MAXV];
-//int cntv;
-//int que[MAXV];
-//int cntq;
-//bool judge[MAXV];
+//int valQue[MAXV];
+//bool valJudge[MAXV];
+//int cnta, cntq;
 //
 //bool ans[MAXN];
 //
@@ -60,7 +59,7 @@
 //
 //void getDistance(int u, int fa, int w) {
 //    dis[u] = dis[fa] + w;
-//    valArr[++cntv] = dis[u];
+//    valArr[++cnta] = dis[u];
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
@@ -76,29 +75,29 @@
 //        int v = to[e];
 //        int w = weight[e];
 //        if (!vis[v]) {
-//            cntv = 0;
+//            cnta = 0;
 //            getDistance(v, u, w);
-//            for (int k = cntv; k > 0; k--) {
+//            for (int k = cnta; k > 0; k--) {
 //                for (int l = 1; l <= m; l++) {
 //                    if (query[l] >= valArr[k]) {
-//                        ans[l] |= judge[query[l] - valArr[k]];
+//                        ans[l] |= valJudge[query[l] - valArr[k]];
 //                    }
 //                }
 //            }
-//            for (int k = cntv; k > 0; k--) {
-//                que[++cntq] = valArr[k];
-//                judge[valArr[k]] = true;
+//            for (int k = cnta; k > 0; k--) {
+//                valQue[++cntq] = valArr[k];
+//                valJudge[valArr[k]] = true;
 //            }
 //        }
 //    }
 //    for (int i = cntq; i > 0; i--) {
-//        judge[que[i]] = false;
+//        valJudge[valQue[i]] = false;
 //    }
 //}
 //
 //void solve(int u) {
 //    vis[u] = true;
-//    judge[0] = true;
+//    valJudge[0] = true;
 //    calc(u);
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];

From 5f5eb829a213f6615ed7b465ac4467f4870b9dd9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 17:30:08 +0800
Subject: [PATCH 1655/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        | 23 ++++++++++---------
 .../Code01_CentroidDecomposition2.java        | 23 ++++++++++---------
 src/class183/Code02_Tree1.java                |  7 ++++++
 3 files changed, 31 insertions(+), 22 deletions(-)
 create mode 100644 src/class183/Code02_Tree1.java

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 3ee17e5e3..5cd5ab1e0 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -31,10 +31,11 @@ public class Code01_CentroidDecomposition1 {
 	public static int centroid;
 
 	public static int[] dis = new int[MAXN];
-	public static int[] valArr = new int[MAXV];
-	public static int[] valQue = new int[MAXV];
-	public static boolean[] valJudge = new boolean[MAXV];
-	public static int cnta, cntq;
+	public static int[] arr = new int[MAXV];
+	public static int[] que = new int[MAXV];
+	public static boolean[] judge = new boolean[MAXV];
+	public static int cnta;
+	public static int cntq;
 
 	public static boolean[] ans = new boolean[MAXN];
 
@@ -118,7 +119,7 @@ public static void getCentroid2(int cur, int fa) {
 
 	public static void getDistance(int u, int fa, int w) {
 		dis[u] = dis[fa] + w;
-		valArr[++cnta] = dis[u];
+		arr[++cnta] = dis[u];
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
@@ -138,25 +139,25 @@ public static void calc(int u) {
 				getDistance(v, u, w);
 				for (int k = cnta; k > 0; k--) {
 					for (int l = 1; l <= m; l++) {
-						if (query[l] >= valArr[k]) {
-							ans[l] |= valJudge[query[l] - valArr[k]];
+						if (query[l] >= arr[k]) {
+							ans[l] |= judge[query[l] - arr[k]];
 						}
 					}
 				}
 				for (int k = cnta; k > 0; k--) {
-					valQue[++cntq] = valArr[k];
-					valJudge[valArr[k]] = true;
+					que[++cntq] = arr[k];
+					judge[arr[k]] = true;
 				}
 			}
 		}
 		for (int i = cntq; i > 0; i--) {
-			valJudge[valQue[i]] = false;
+			judge[que[i]] = false;
 		}
 	}
 
 	public static void solve(int u) {
 		vis[u] = true;
-		valJudge[0] = true;
+		judge[0] = true;
 		calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 921236f5b..94e68585b 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -26,10 +26,11 @@
 //int centroid;
 //
 //int dis[MAXN];
-//int valArr[MAXV];
-//int valQue[MAXV];
-//bool valJudge[MAXV];
-//int cnta, cntq;
+//int arr[MAXV];
+//int que[MAXV];
+//bool judge[MAXV];
+//int cnta;
+//int cntq;
 //
 //bool ans[MAXN];
 //
@@ -59,7 +60,7 @@
 //
 //void getDistance(int u, int fa, int w) {
 //    dis[u] = dis[fa] + w;
-//    valArr[++cnta] = dis[u];
+//    arr[++cnta] = dis[u];
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
@@ -79,25 +80,25 @@
 //            getDistance(v, u, w);
 //            for (int k = cnta; k > 0; k--) {
 //                for (int l = 1; l <= m; l++) {
-//                    if (query[l] >= valArr[k]) {
-//                        ans[l] |= valJudge[query[l] - valArr[k]];
+//                    if (query[l] >= arr[k]) {
+//                        ans[l] |= judge[query[l] - arr[k]];
 //                    }
 //                }
 //            }
 //            for (int k = cnta; k > 0; k--) {
-//                valQue[++cntq] = valArr[k];
-//                valJudge[valArr[k]] = true;
+//                que[++cntq] = arr[k];
+//                judge[arr[k]] = true;
 //            }
 //        }
 //    }
 //    for (int i = cntq; i > 0; i--) {
-//        valJudge[valQue[i]] = false;
+//        judge[que[i]] = false;
 //    }
 //}
 //
 //void solve(int u) {
 //    vis[u] = true;
-//    valJudge[0] = true;
+//    judge[0] = true;
 //    calc(u);
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];
diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code02_Tree1.java
new file mode 100644
index 000000000..da0e8930b
--- /dev/null
+++ b/src/class183/Code02_Tree1.java
@@ -0,0 +1,7 @@
+package class183;
+
+// 距离<=k的点对数量，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4178
+public class Code02_Tree1 {
+
+}

From d0f629cd38e3932080c333333fd9f296e139b8ea Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 17:37:16 +0800
Subject: [PATCH 1656/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 12 ++++++------
 src/class183/Code01_CentroidDecomposition2.java | 12 ++++++------
 2 files changed, 12 insertions(+), 12 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 5cd5ab1e0..4acf6b922 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -33,7 +33,7 @@ public class Code01_CentroidDecomposition1 {
 	public static int[] dis = new int[MAXN];
 	public static int[] arr = new int[MAXV];
 	public static int[] que = new int[MAXV];
-	public static boolean[] judge = new boolean[MAXV];
+	public static boolean[] pre = new boolean[MAXV];
 	public static int cnta;
 	public static int cntq;
 
@@ -139,25 +139,25 @@ public static void calc(int u) {
 				getDistance(v, u, w);
 				for (int k = cnta; k > 0; k--) {
 					for (int l = 1; l <= m; l++) {
-						if (query[l] >= arr[k]) {
-							ans[l] |= judge[query[l] - arr[k]];
+						if (query[l] - arr[k] >= 0) {
+							ans[l] |= pre[query[l] - arr[k]];
 						}
 					}
 				}
 				for (int k = cnta; k > 0; k--) {
 					que[++cntq] = arr[k];
-					judge[arr[k]] = true;
+					pre[arr[k]] = true;
 				}
 			}
 		}
 		for (int i = cntq; i > 0; i--) {
-			judge[que[i]] = false;
+			pre[que[i]] = false;
 		}
 	}
 
 	public static void solve(int u) {
 		vis[u] = true;
-		judge[0] = true;
+		pre[0] = true;
 		calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 94e68585b..7fb36d732 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -28,7 +28,7 @@
 //int dis[MAXN];
 //int arr[MAXV];
 //int que[MAXV];
-//bool judge[MAXV];
+//bool pre[MAXV];
 //int cnta;
 //int cntq;
 //
@@ -80,25 +80,25 @@
 //            getDistance(v, u, w);
 //            for (int k = cnta; k > 0; k--) {
 //                for (int l = 1; l <= m; l++) {
-//                    if (query[l] >= arr[k]) {
-//                        ans[l] |= judge[query[l] - arr[k]];
+//                    if (query[l] - arr[k] >= 0) {
+//                        ans[l] |= pre[query[l] - arr[k]];
 //                    }
 //                }
 //            }
 //            for (int k = cnta; k > 0; k--) {
 //                que[++cntq] = arr[k];
-//                judge[arr[k]] = true;
+//                pre[arr[k]] = true;
 //            }
 //        }
 //    }
 //    for (int i = cntq; i > 0; i--) {
-//        judge[que[i]] = false;
+//        pre[que[i]] = false;
 //    }
 //}
 //
 //void solve(int u) {
 //    vis[u] = true;
-//    judge[0] = true;
+//    pre[0] = true;
 //    calc(u);
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];

From df97a6754aa82eb63f76824824b56ce9733824e7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 18:04:07 +0800
Subject: [PATCH 1657/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 16 ++++++++--------
 src/class183/Code01_CentroidDecomposition2.java | 16 ++++++++--------
 2 files changed, 16 insertions(+), 16 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 4acf6b922..760f12fab 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -137,20 +137,20 @@ public static void calc(int u) {
 			if (!vis[v]) {
 				cnta = 0;
 				getDistance(v, u, w);
-				for (int k = cnta; k > 0; k--) {
-					for (int l = 1; l <= m; l++) {
-						if (query[l] - arr[k] >= 0) {
-							ans[l] |= pre[query[l] - arr[k]];
+				for (int i = 1; i <= m; i++) {
+					for (int j = 1; j <= cnta; j++) {
+						if (query[i] - arr[j] >= 0) {
+							ans[i] |= pre[query[i] - arr[j]];
 						}
 					}
 				}
-				for (int k = cnta; k > 0; k--) {
-					que[++cntq] = arr[k];
-					pre[arr[k]] = true;
+				for (int i = 1; i <= cnta; i++) {
+					que[++cntq] = arr[i];
+					pre[arr[i]] = true;
 				}
 			}
 		}
-		for (int i = cntq; i > 0; i--) {
+		for (int i = 1; i <= cntq; i++) {
 			pre[que[i]] = false;
 		}
 	}
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 7fb36d732..6bdde8558 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -78,20 +78,20 @@
 //        if (!vis[v]) {
 //            cnta = 0;
 //            getDistance(v, u, w);
-//            for (int k = cnta; k > 0; k--) {
-//                for (int l = 1; l <= m; l++) {
-//                    if (query[l] - arr[k] >= 0) {
-//                        ans[l] |= pre[query[l] - arr[k]];
+//            for (int i = 1; i <= m; i++) {
+//                for (int j = 1; j <= cnta; j++) {
+//                    if (query[i] - arr[j] >= 0) {
+//                        ans[i] |= pre[query[i] - arr[j]];
 //                    }
 //                }
 //            }
-//            for (int k = cnta; k > 0; k--) {
-//                que[++cntq] = arr[k];
-//                pre[arr[k]] = true;
+//            for (int i = 1; i <= cnta; i++) {
+//                que[++cntq] = arr[i];
+//                pre[arr[i]] = true;
 //            }
 //        }
 //    }
-//    for (int i = cntq; i > 0; i--) {
+//    for (int i = 1; i <= cntq; i++) {
 //        pre[que[i]] = false;
 //    }
 //}

From f4a6fe260ad909fb48fea0ff4b4a3a54ab3d848f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 20:43:41 +0800
Subject: [PATCH 1658/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        |   6 +-
 .../Code01_CentroidDecomposition2.java        |   6 +-
 src/class183/Code02_Tree1.java                | 155 ++++++++++++++++++
 3 files changed, 161 insertions(+), 6 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 760f12fab..211a5202f 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -155,7 +155,7 @@ public static void calc(int u) {
 		}
 	}
 
-	public static void solve(int u) {
+	public static void compute(int u) {
 		vis[u] = true;
 		pre[0] = true;
 		calc(u);
@@ -167,7 +167,7 @@ public static void solve(int u) {
 				maxp[centroid] = n;
 				// getCentroid1(v, u);
 				getCentroid2(v, u);
-				solve(centroid);
+				compute(centroid);
 			}
 		}
 	}
@@ -192,7 +192,7 @@ public static void main(String[] args) throws Exception {
 		maxp[centroid] = n;
 		// getCentroid1(1, 0);
 		getCentroid2(1, 0);
-		solve(centroid);
+		compute(centroid);
 		for (int i = 1; i <= m; i++) {
 			if (ans[i]) {
 				out.println("AYE");
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 6bdde8558..95cac937a 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -96,7 +96,7 @@
 //    }
 //}
 //
-//void solve(int u) {
+//void compute(int u) {
 //    vis[u] = true;
 //    pre[0] = true;
 //    calc(u);
@@ -107,7 +107,7 @@
 //            centroid = 0;
 //            maxp[centroid] = n;
 //            getCentroid(v, u);
-//            solve(centroid);
+//            compute(centroid);
 //        }
 //    }
 //}
@@ -128,7 +128,7 @@
 //    centroid = 0;
 //    maxp[centroid] = n;
 //    getCentroid(1, 0);
-//    solve(centroid);
+//    compute(centroid);
 //    for (int i = 1; i <= m; i++) {
 //        if (ans[i]) {
 //            cout << "AYE" << '\n';
diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code02_Tree1.java
index da0e8930b..6b7d0cfec 100644
--- a/src/class183/Code02_Tree1.java
+++ b/src/class183/Code02_Tree1.java
@@ -2,6 +2,161 @@
 
 // 距离<=k的点对数量，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4178
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code02_Tree1 {
 
+	public static int MAXN = 50001;
+	public static int n, k, total;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cntg;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxp = new int[MAXN];
+	public static int centroid;
+
+	public static int[] dis = new int[MAXN];
+	public static int[] arr = new int[MAXN];
+	public static int cnta;
+
+	public static void addEdge(int u, int v, int w) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	public static void getCentroid(int u, int fa) {
+		siz[u] = 1;
+		maxp[u] = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getCentroid(v, u);
+				siz[u] += siz[v];
+				maxp[u] = Math.max(siz[v], maxp[u]);
+			}
+		}
+		maxp[u] = Math.max(maxp[u], total - siz[u]);
+		if (maxp[u] < maxp[centroid]) {
+			centroid = u;
+		}
+	}
+
+	public static void getDistance(int u, int fa, int w) {
+		dis[u] = dis[fa] + w;
+		arr[++cnta] = dis[u];
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getDistance(v, u, weight[e]);
+			}
+		}
+	}
+
+	public static long calc(int u, int fa, int w) {
+		cnta = 0;
+		getDistance(u, fa, w);
+		long ans = 0;
+		Arrays.sort(arr, 1, cnta + 1);
+		for (int l = 1, r = cnta; l < r;) {
+			if (arr[l] + arr[r] <= k) {
+				ans += r - l;
+				l++;
+			} else {
+				r--;
+			}
+		}
+		return ans;
+	}
+
+	public static long compute(int u) {
+		long ans = 0;
+		ans += calc(u, 0, 0);
+		vis[u] = true;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				ans -= calc(v, u, weight[e]);
+				total = siz[v];
+				centroid = 0;
+				maxp[centroid] = n;
+				getCentroid(v, 0);
+				ans += compute(centroid);
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1, u, v, w; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextInt();
+			addEdge(u, v, w);
+			addEdge(v, u, w);
+		}
+		k = in.nextInt();
+		total = n;
+		centroid = 0;
+		maxp[centroid] = n;
+		getCentroid(1, 0);
+		out.println(compute(centroid));
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }

From 125e63109e8e0fbad6a0b1d64a5b7c01cd491152 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 21:05:10 +0800
Subject: [PATCH 1659/1712] modify code

---
 src/class183/Code02_Tree1.java | 1 +
 src/class183/Code03_Race1.java | 7 +++++++
 2 files changed, 8 insertions(+)
 create mode 100644 src/class183/Code03_Race1.java

diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code02_Tree1.java
index 6b7d0cfec..43a6b8f9c 100644
--- a/src/class183/Code02_Tree1.java
+++ b/src/class183/Code02_Tree1.java
@@ -66,6 +66,7 @@ public static void getDistance(int u, int fa, int w) {
 	}
 
 	public static long calc(int u, int fa, int w) {
+		dis[fa] = 0;
 		cnta = 0;
 		getDistance(u, fa, w);
 		long ans = 0;
diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
new file mode 100644
index 000000000..83c8f9b8b
--- /dev/null
+++ b/src/class183/Code03_Race1.java
@@ -0,0 +1,7 @@
+package class183;
+
+// 权值和等于k的路径，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P4149
+public class Code03_Race1 {
+
+}

From 3e07ac6a38b03f946ae2fa4b85988d9e9dcff126 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Mon, 10 Nov 2025 21:22:05 +0800
Subject: [PATCH 1660/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        | 22 +++++++++----------
 .../Code01_CentroidDecomposition2.java        | 14 ++++++------
 src/class183/Code02_Tree1.java                | 14 ++++++------
 3 files changed, 25 insertions(+), 25 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 211a5202f..34a8c778d 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -27,7 +27,7 @@ public class Code01_CentroidDecomposition1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxp = new int[MAXN];
+	public static int[] maxPart = new int[MAXN];
 	public static int centroid;
 
 	public static int[] dis = new int[MAXN];
@@ -49,17 +49,17 @@ public static void addEdge(int u, int v, int w) {
 	// 找重心递归版，java会爆栈，C++可以通过
 	public static void getCentroid1(int u, int fa) {
 		siz[u] = 1;
-		maxp[u] = 0;
+		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
 				getCentroid1(v, u);
 				siz[u] += siz[v];
-				maxp[u] = Math.max(siz[v], maxp[u]);
+				maxPart[u] = Math.max(siz[v], maxPart[u]);
 			}
 		}
-		maxp[u] = Math.max(maxp[u], total - siz[u]);
-		if (maxp[u] < maxp[centroid]) {
+		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+		if (maxPart[u] < maxPart[centroid]) {
 			centroid = u;
 		}
 	}
@@ -90,7 +90,7 @@ public static void getCentroid2(int cur, int fa) {
 			pop();
 			if (e == -1) {
 				siz[u] = 1;
-				maxp[u] = 0;
+				maxPart[u] = 0;
 				e = head[u];
 			} else {
 				e = nxt[e];
@@ -106,11 +106,11 @@ public static void getCentroid2(int cur, int fa) {
 					int v = to[ei];
 					if (v != f && !vis[v]) {
 						siz[u] += siz[v];
-						maxp[u] = Math.max(siz[v], maxp[u]);
+						maxPart[u] = Math.max(siz[v], maxPart[u]);
 					}
 				}
-				maxp[u] = Math.max(maxp[u], total - siz[u]);
-				if (maxp[u] < maxp[centroid]) {
+				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+				if (maxPart[u] < maxPart[centroid]) {
 					centroid = u;
 				}
 			}
@@ -164,7 +164,7 @@ public static void compute(int u) {
 			if (!vis[v]) {
 				total = siz[v];
 				centroid = 0;
-				maxp[centroid] = n;
+				maxPart[centroid] = n;
 				// getCentroid1(v, u);
 				getCentroid2(v, u);
 				compute(centroid);
@@ -189,7 +189,7 @@ public static void main(String[] args) throws Exception {
 		}
 		total = n;
 		centroid = 0;
-		maxp[centroid] = n;
+		maxPart[centroid] = n;
 		// getCentroid1(1, 0);
 		getCentroid2(1, 0);
 		compute(centroid);
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 95cac937a..825d86d7d 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -22,7 +22,7 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxp[MAXN];
+//int maxPart[MAXN];
 //int centroid;
 //
 //int dis[MAXN];
@@ -43,17 +43,17 @@
 //
 //void getCentroid(int u, int fa) {
 //    siz[u] = 1;
-//    maxp[u] = 0;
+//    maxPart[u] = 0;
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
 //            getCentroid(v, u);
 //            siz[u] += siz[v];
-//            maxp[u] = max(maxp[u], siz[v]);
+//            maxPart[u] = max(maxPart[u], siz[v]);
 //        }
 //    }
-//    maxp[u] = max(maxp[u], total - siz[u]);
-//    if (maxp[u] < maxp[centroid]) {
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (maxPart[u] < maxPart[centroid]) {
 //        centroid = u;
 //    }
 //}
@@ -105,7 +105,7 @@
 //        if (!vis[v]) {
 //            total = siz[v];
 //            centroid = 0;
-//            maxp[centroid] = n;
+//            maxPart[centroid] = n;
 //            getCentroid(v, u);
 //            compute(centroid);
 //        }
@@ -126,7 +126,7 @@
 //    }
 //    total = n;
 //    centroid = 0;
-//    maxp[centroid] = n;
+//    maxPart[centroid] = n;
 //    getCentroid(1, 0);
 //    compute(centroid);
 //    for (int i = 1; i <= m; i++) {
diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code02_Tree1.java
index 43a6b8f9c..cf5b5cce1 100644
--- a/src/class183/Code02_Tree1.java
+++ b/src/class183/Code02_Tree1.java
@@ -23,7 +23,7 @@ public class Code02_Tree1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxp = new int[MAXN];
+	public static int[] maxPart = new int[MAXN];
 	public static int centroid;
 
 	public static int[] dis = new int[MAXN];
@@ -39,17 +39,17 @@ public static void addEdge(int u, int v, int w) {
 
 	public static void getCentroid(int u, int fa) {
 		siz[u] = 1;
-		maxp[u] = 0;
+		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
 				getCentroid(v, u);
 				siz[u] += siz[v];
-				maxp[u] = Math.max(siz[v], maxp[u]);
+				maxPart[u] = Math.max(siz[v], maxPart[u]);
 			}
 		}
-		maxp[u] = Math.max(maxp[u], total - siz[u]);
-		if (maxp[u] < maxp[centroid]) {
+		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+		if (maxPart[u] < maxPart[centroid]) {
 			centroid = u;
 		}
 	}
@@ -92,7 +92,7 @@ public static long compute(int u) {
 				ans -= calc(v, u, weight[e]);
 				total = siz[v];
 				centroid = 0;
-				maxp[centroid] = n;
+				maxPart[centroid] = n;
 				getCentroid(v, 0);
 				ans += compute(centroid);
 			}
@@ -114,7 +114,7 @@ public static void main(String[] args) throws Exception {
 		k = in.nextInt();
 		total = n;
 		centroid = 0;
-		maxp[centroid] = n;
+		maxPart[centroid] = n;
 		getCentroid(1, 0);
 		out.println(compute(centroid));
 		out.flush();

From 83b556124f3f9596bf58ee36020b3c04a0300d41 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 10:40:31 +0800
Subject: [PATCH 1661/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 6 ++----
 src/class183/Code01_CentroidDecomposition2.java | 4 +---
 src/class183/Code02_Tree1.java                  | 4 +---
 3 files changed, 4 insertions(+), 10 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 34a8c778d..df294fbe9 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -59,7 +59,7 @@ public static void getCentroid1(int u, int fa) {
 			}
 		}
 		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (maxPart[u] < maxPart[centroid]) {
+		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
 			centroid = u;
 		}
 	}
@@ -110,7 +110,7 @@ public static void getCentroid2(int cur, int fa) {
 					}
 				}
 				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-				if (maxPart[u] < maxPart[centroid]) {
+				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
 					centroid = u;
 				}
 			}
@@ -164,7 +164,6 @@ public static void compute(int u) {
 			if (!vis[v]) {
 				total = siz[v];
 				centroid = 0;
-				maxPart[centroid] = n;
 				// getCentroid1(v, u);
 				getCentroid2(v, u);
 				compute(centroid);
@@ -189,7 +188,6 @@ public static void main(String[] args) throws Exception {
 		}
 		total = n;
 		centroid = 0;
-		maxPart[centroid] = n;
 		// getCentroid1(1, 0);
 		getCentroid2(1, 0);
 		compute(centroid);
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 825d86d7d..153874a01 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -53,7 +53,7 @@
 //        }
 //    }
 //    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (maxPart[u] < maxPart[centroid]) {
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
 //        centroid = u;
 //    }
 //}
@@ -105,7 +105,6 @@
 //        if (!vis[v]) {
 //            total = siz[v];
 //            centroid = 0;
-//            maxPart[centroid] = n;
 //            getCentroid(v, u);
 //            compute(centroid);
 //        }
@@ -126,7 +125,6 @@
 //    }
 //    total = n;
 //    centroid = 0;
-//    maxPart[centroid] = n;
 //    getCentroid(1, 0);
 //    compute(centroid);
 //    for (int i = 1; i <= m; i++) {
diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code02_Tree1.java
index cf5b5cce1..c8f28a0e1 100644
--- a/src/class183/Code02_Tree1.java
+++ b/src/class183/Code02_Tree1.java
@@ -49,7 +49,7 @@ public static void getCentroid(int u, int fa) {
 			}
 		}
 		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (maxPart[u] < maxPart[centroid]) {
+		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
 			centroid = u;
 		}
 	}
@@ -92,7 +92,6 @@ public static long compute(int u) {
 				ans -= calc(v, u, weight[e]);
 				total = siz[v];
 				centroid = 0;
-				maxPart[centroid] = n;
 				getCentroid(v, 0);
 				ans += compute(centroid);
 			}
@@ -114,7 +113,6 @@ public static void main(String[] args) throws Exception {
 		k = in.nextInt();
 		total = n;
 		centroid = 0;
-		maxPart[centroid] = n;
 		getCentroid(1, 0);
 		out.println(compute(centroid));
 		out.flush();

From 008e54cc66cdf4eb1ad40ba3c88a6817de424b56 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 10:56:48 +0800
Subject: [PATCH 1662/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        | 77 +++----------------
 .../Code01_CentroidDecomposition2.java        |  8 +-
 src/class183/Code03_Race1.java                |  2 +-
 3 files changed, 18 insertions(+), 69 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index df294fbe9..86dc03c1c 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -2,10 +2,7 @@
 
 // 点分治，也叫重心分治，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3806
-// 提交以下的code，提交时请把类名改成"Main"
-// java实现的逻辑一定是正确的，但是本题卡常，无法通过所有测试用例
-// 想通过用C++实现，本节课Code01_CentroidDecomposition2文件就是C++的实现
-// 两个版本的逻辑完全一样，C++版本可以通过所有测试
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 import java.io.IOException;
 import java.io.InputStream;
@@ -15,8 +12,8 @@
 public class Code01_CentroidDecomposition1 {
 
 	public static int MAXN = 10001;
-	public static int MAXV = 15000001;
-	public static int n, m, total;
+	public static int MAXV = 10000001;
+	public static int n, m, maxq, total;
 	public static int[] query = new int[MAXN];
 
 	public static int[] head = new int[MAXN];
@@ -46,14 +43,13 @@ public static void addEdge(int u, int v, int w) {
 		head[u] = cntg;
 	}
 
-	// 找重心递归版，java会爆栈，C++可以通过
-	public static void getCentroid1(int u, int fa) {
+	public static void getCentroid(int u, int fa) {
 		siz[u] = 1;
 		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getCentroid1(v, u);
+				getCentroid(v, u);
 				siz[u] += siz[v];
 				maxPart[u] = Math.max(siz[v], maxPart[u]);
 			}
@@ -64,61 +60,11 @@ public static void getCentroid1(int u, int fa) {
 		}
 	}
 
-	// 讲解118，递归改迭代需要的栈
-	public static int[][] ufe = new int[MAXN][3];
-	public static int stacksize, u, f, e;
-
-	public static void push(int u, int f, int e) {
-		ufe[stacksize][0] = u;
-		ufe[stacksize][1] = f;
-		ufe[stacksize][2] = e;
-		stacksize++;
-	}
-
-	public static void pop() {
-		--stacksize;
-		u = ufe[stacksize][0];
-		f = ufe[stacksize][1];
-		e = ufe[stacksize][2];
-	}
-
-	// 找重心迭代版
-	public static void getCentroid2(int cur, int fa) {
-		stacksize = 0;
-		push(cur, fa, -1);
-		while (stacksize > 0) {
-			pop();
-			if (e == -1) {
-				siz[u] = 1;
-				maxPart[u] = 0;
-				e = head[u];
-			} else {
-				e = nxt[e];
-			}
-			if (e != 0) {
-				push(u, f, e);
-				int v = to[e];
-				if (v != f && !vis[v]) {
-					push(v, u, -1);
-				}
-			} else {
-				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
-					int v = to[ei];
-					if (v != f && !vis[v]) {
-						siz[u] += siz[v];
-						maxPart[u] = Math.max(siz[v], maxPart[u]);
-					}
-				}
-				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-					centroid = u;
-				}
-			}
-		}
-	}
-
 	public static void getDistance(int u, int fa, int w) {
 		dis[u] = dis[fa] + w;
+		if (dis[u] > maxq) {
+			return;
+		}
 		arr[++cnta] = dis[u];
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
@@ -164,8 +110,7 @@ public static void compute(int u) {
 			if (!vis[v]) {
 				total = siz[v];
 				centroid = 0;
-				// getCentroid1(v, u);
-				getCentroid2(v, u);
+				getCentroid(v, u);
 				compute(centroid);
 			}
 		}
@@ -185,11 +130,11 @@ public static void main(String[] args) throws Exception {
 		}
 		for (int i = 1; i <= m; i++) {
 			query[i] = in.nextInt();
+			maxq = Math.max(maxq, query[i]);
 		}
 		total = n;
 		centroid = 0;
-		// getCentroid1(1, 0);
-		getCentroid2(1, 0);
+		getCentroid(1, 0);
 		compute(centroid);
 		for (int i = 1; i <= m; i++) {
 			if (ans[i]) {
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index 153874a01..b7918a60d 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -10,8 +10,8 @@
 //using namespace std;
 //
 //const int MAXN = 10001;
-//const int MAXV = 15000001;
-//int n, m, total;
+//const int MAXV = 10000001;
+//int n, m, maxq, total;
 //int query[MAXN];
 //
 //int head[MAXN];
@@ -60,6 +60,9 @@
 //
 //void getDistance(int u, int fa, int w) {
 //    dis[u] = dis[fa] + w;
+//    if (dis[u] > maxq) {
+//        return;
+//    }
 //    arr[++cnta] = dis[u];
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];
@@ -122,6 +125,7 @@
 //    }
 //    for (int i = 1; i <= m; i++) {
 //        cin >> query[i];
+//        maxq = max(maxq, query[i]);
 //    }
 //    total = n;
 //    centroid = 0;
diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
index 83c8f9b8b..58317daa8 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 权值和等于k的路径，java版
+// 边最少的权值和为k的路径，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4149
 public class Code03_Race1 {
 

From cbceb02ca3f963bb8ad4cb65567cbf0cce4c48e3 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 11:01:23 +0800
Subject: [PATCH 1663/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 3 +--
 src/class183/Code01_CentroidDecomposition2.java | 3 +--
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 86dc03c1c..20f66bee2 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -31,8 +31,7 @@ public class Code01_CentroidDecomposition1 {
 	public static int[] arr = new int[MAXV];
 	public static int[] que = new int[MAXV];
 	public static boolean[] pre = new boolean[MAXV];
-	public static int cnta;
-	public static int cntq;
+	public static int cnta, cntq;
 
 	public static boolean[] ans = new boolean[MAXN];
 
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index b7918a60d..a4efb7998 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -29,8 +29,7 @@
 //int arr[MAXV];
 //int que[MAXV];
 //bool pre[MAXV];
-//int cnta;
-//int cntq;
+//int cnta, cntq;
 //
 //bool ans[MAXN];
 //

From abdb193bcd54a360caca83a97b4c31a05642f436 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 11:03:56 +0800
Subject: [PATCH 1664/1712] modify code

---
 src/class183/Code02_Tree1.java | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code02_Tree1.java
index c8f28a0e1..aa45edfd4 100644
--- a/src/class183/Code02_Tree1.java
+++ b/src/class183/Code02_Tree1.java
@@ -56,6 +56,9 @@ public static void getCentroid(int u, int fa) {
 
 	public static void getDistance(int u, int fa, int w) {
 		dis[u] = dis[fa] + w;
+		if (dis[u] > k) {
+			return;
+		}
 		arr[++cnta] = dis[u];
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];

From 8b460eb84f43720068acc2ef35f61e55b3a643e2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 11:11:57 +0800
Subject: [PATCH 1665/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        | 19 ++++++++++---------
 .../Code01_CentroidDecomposition2.java        | 19 ++++++++++---------
 2 files changed, 20 insertions(+), 18 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 20f66bee2..19f03bc16 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -12,9 +12,10 @@
 public class Code01_CentroidDecomposition1 {
 
 	public static int MAXN = 10001;
+	public static int MAXM = 101;
 	public static int MAXV = 10000001;
 	public static int n, m, maxq, total;
-	public static int[] query = new int[MAXN];
+	public static int[] query = new int[MAXM];
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -28,12 +29,12 @@ public class Code01_CentroidDecomposition1 {
 	public static int centroid;
 
 	public static int[] dis = new int[MAXN];
-	public static int[] arr = new int[MAXV];
-	public static int[] que = new int[MAXV];
-	public static boolean[] pre = new boolean[MAXV];
+	public static int[] arr = new int[MAXN];
+	public static int[] que = new int[MAXN];
+	public static boolean[] check = new boolean[MAXV];
 	public static int cnta, cntq;
 
-	public static boolean[] ans = new boolean[MAXN];
+	public static boolean[] ans = new boolean[MAXM];
 
 	public static void addEdge(int u, int v, int w) {
 		nxt[++cntg] = head[u];
@@ -85,24 +86,24 @@ public static void calc(int u) {
 				for (int i = 1; i <= m; i++) {
 					for (int j = 1; j <= cnta; j++) {
 						if (query[i] - arr[j] >= 0) {
-							ans[i] |= pre[query[i] - arr[j]];
+							ans[i] |= check[query[i] - arr[j]];
 						}
 					}
 				}
 				for (int i = 1; i <= cnta; i++) {
 					que[++cntq] = arr[i];
-					pre[arr[i]] = true;
+					check[arr[i]] = true;
 				}
 			}
 		}
 		for (int i = 1; i <= cntq; i++) {
-			pre[que[i]] = false;
+			check[que[i]] = false;
 		}
 	}
 
 	public static void compute(int u) {
 		vis[u] = true;
-		pre[0] = true;
+		check[0] = true;
 		calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index a4efb7998..eba473ed6 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -10,9 +10,10 @@
 //using namespace std;
 //
 //const int MAXN = 10001;
+//const int MAXM = 101;
 //const int MAXV = 10000001;
 //int n, m, maxq, total;
-//int query[MAXN];
+//int query[MAXM];
 //
 //int head[MAXN];
 //int nxt[MAXN << 1];
@@ -26,12 +27,12 @@
 //int centroid;
 //
 //int dis[MAXN];
-//int arr[MAXV];
-//int que[MAXV];
-//bool pre[MAXV];
+//int arr[MAXN];
+//int que[MAXN];
+//bool check[MAXV];
 //int cnta, cntq;
 //
-//bool ans[MAXN];
+//bool ans[MAXM];
 //
 //void addEdge(int u, int v, int w) {
 //    nxt[++cntg] = head[u];
@@ -83,24 +84,24 @@
 //            for (int i = 1; i <= m; i++) {
 //                for (int j = 1; j <= cnta; j++) {
 //                    if (query[i] - arr[j] >= 0) {
-//                        ans[i] |= pre[query[i] - arr[j]];
+//                        ans[i] |= check[query[i] - arr[j]];
 //                    }
 //                }
 //            }
 //            for (int i = 1; i <= cnta; i++) {
 //                que[++cntq] = arr[i];
-//                pre[arr[i]] = true;
+//                check[arr[i]] = true;
 //            }
 //        }
 //    }
 //    for (int i = 1; i <= cntq; i++) {
-//        pre[que[i]] = false;
+//        check[que[i]] = false;
 //    }
 //}
 //
 //void compute(int u) {
 //    vis[u] = true;
-//    pre[0] = true;
+//    check[0] = true;
 //    calc(u);
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];

From b50d16f787a63fd22eabbd2397b89f258e6a49e8 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 13:23:23 +0800
Subject: [PATCH 1666/1712] modify code

---
 src/class183/Code03_Race1.java | 262 ++++++++++++++++++++++++++++++++-
 src/class183/Code03_Race2.java | 132 +++++++++++++++++
 2 files changed, 393 insertions(+), 1 deletion(-)
 create mode 100644 src/class183/Code03_Race2.java

diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
index 58317daa8..a575bdf1a 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -1,7 +1,267 @@
 package class183;
 
-// 边最少的权值和为k的路径，java版
+// 权值和为k的路径的最少边数，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P4149
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+import java.util.Arrays;
+
 public class Code03_Race1 {
 
+	public static int MAXN = 200001;
+	public static int MAXK = 1000001;
+	public static int INF = 1000000001;
+	public static int n, k, total;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cntg;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxPart = new int[MAXN];
+	public static int centroid;
+
+	public static int[] sumArr = new int[MAXN];
+	public static int[] edgeArr = new int[MAXN];
+	public static int cnta;
+
+	public static int[] dp = new int[MAXK];
+
+	// java的实现，getCentroid方法、getPath方法改成迭代才能通过，C++的实现不需要改动
+	// 讲解118，讲了如何把递归函数改成迭代
+	public static int[][] stack = new int[MAXN][5];
+	public static int stacksize, u, f, sum, edge, e;
+
+	public static void push(int u, int f, int sum, int edge, int e) {
+		stack[stacksize][0] = u;
+		stack[stacksize][1] = f;
+		stack[stacksize][2] = sum;
+		stack[stacksize][3] = edge;
+		stack[stacksize][4] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = stack[stacksize][0];
+		f = stack[stacksize][1];
+		sum = stack[stacksize][2];
+		edge = stack[stacksize][3];
+		e = stack[stacksize][4];
+	}
+
+	public static void addEdge(int u, int v, int w) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	// 找重心的递归版，java会爆栈，C++可以通过
+	public static void getCentroid1(int u, int fa) {
+		siz[u] = 1;
+		maxPart[u] = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getCentroid1(v, u);
+				siz[u] += siz[v];
+				maxPart[u] = Math.max(siz[v], maxPart[u]);
+			}
+		}
+		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+			centroid = u;
+		}
+	}
+
+	// 找重心的迭代版
+	public static void getCentroid2(int cur, int fa) {
+		stacksize = 0;
+		push(cur, fa, 0, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				siz[u] = 1;
+				maxPart[u] = 0;
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, 0, 0, e);
+				int v = to[e];
+				if (v != f && !vis[v]) {
+					push(to[e], u, 0, 0, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+					int v = to[ei];
+					if (v != f && !vis[v]) {
+						siz[u] += siz[v];
+						maxPart[u] = Math.max(siz[v], maxPart[u]);
+					}
+				}
+				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+					centroid = u;
+				}
+			}
+		}
+	}
+
+	// 收集路径的递归版，java会爆栈，C++可以通过
+	public static void getPath1(int u, int fa, int sum, int edge) {
+		if (sum > k) {
+			return;
+		}
+		sumArr[++cnta] = sum;
+		edgeArr[cnta] = edge;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getPath1(v, u, sum + weight[e], edge + 1);
+			}
+		}
+	}
+
+	// 收集路径的迭代版
+	public static void getPath2(int cur, int fa, int psum, int pedge) {
+		stacksize = 0;
+		push(cur, fa, psum, pedge, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				if (sum > k) {
+					continue;
+				}
+				sumArr[++cnta] = sum;
+				edgeArr[cnta] = edge;
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, sum, edge, e);
+				int v = to[e];
+				if (v != f && !vis[v]) {
+					push(to[e], u, sum + weight[e], edge + 1, -1);
+				}
+			}
+		}
+	}
+
+	public static int calc(int u) {
+		int ans = INF;
+		cnta = 0;
+		dp[0] = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				int tmp = cnta;
+				// getPath1(v, u, weight[e], 1);
+				getPath2(v, u, weight[e], 1);
+				for (int i = tmp + 1; i <= cnta; i++) {
+					ans = Math.min(ans, dp[k - sumArr[i]] + edgeArr[i]);
+				}
+				for (int i = tmp + 1; i <= cnta; i++) {
+					dp[sumArr[i]] = Math.min(dp[sumArr[i]], edgeArr[i]);
+				}
+			}
+		}
+		for (int i = 1; i <= cnta; i++) {
+			dp[sumArr[i]] = INF;
+		}
+		return ans;
+	}
+
+	public static int compute(int u) {
+		int ans = INF;
+		vis[u] = true;
+		ans = Math.min(ans, calc(u));
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				total = siz[v];
+				centroid = 0;
+				// getCentroid1(v, 0);
+				getCentroid2(v, 0);
+				ans = Math.min(ans, compute(centroid));
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1, u, v, w; i < n; i++) {
+			u = in.nextInt() + 1;
+			v = in.nextInt() + 1;
+			w = in.nextInt();
+			addEdge(u, v, w);
+			addEdge(v, u, w);
+		}
+		total = n;
+		centroid = 0;
+		// getCentroid1(1, 0);
+		getCentroid2(1, 0);
+		Arrays.fill(dp, INF);
+		int ans = compute(centroid);
+		if (ans == INF) {
+			ans = -1;
+		}
+		out.println(ans);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class183/Code03_Race2.java b/src/class183/Code03_Race2.java
new file mode 100644
index 000000000..f4ba109af
--- /dev/null
+++ b/src/class183/Code03_Race2.java
@@ -0,0 +1,132 @@
+package class183;
+
+// 权值和为k的路径的最少边数，C++版
+// 测试链接 : https://www.luogu.com.cn/problem/P4149
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int MAXK = 1000001;
+//const int INF = 1000000001;
+//int n, k, total;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxPart[MAXN];
+//int centroid;
+//
+//int sumArr[MAXN];
+//int edgeArr[MAXN];
+//int cnta;
+//
+//int dp[MAXK];
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxPart[u] = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxPart[u] = max(maxPart[u], siz[v]);
+//        }
+//    }
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void getPath(int u, int fa, int sum, int edge) {
+//    if (sum > k) {
+//        return;
+//    }
+//    sumArr[++cnta] = sum;
+//    edgeArr[cnta] = edge;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getPath(v, u, sum + weight[e], edge + 1);
+//        }
+//    }
+//}
+//
+//int calc(int u) {
+//    int ans = INF;
+//    cnta = 0;
+//    dp[0] = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            int tmp = cnta;
+//            getPath(v, u, weight[e], 1);
+//            for (int i = tmp + 1; i <= cnta; i++) {
+//                ans = min(ans, dp[k - sumArr[i]] + edgeArr[i]);
+//            }
+//            for (int i = tmp + 1; i <= cnta; i++) {
+//                dp[sumArr[i]] = min(dp[sumArr[i]], edgeArr[i]);
+//            }
+//        }
+//    }
+//    for (int i = 1; i <= cnta; i++) {
+//        dp[sumArr[i]] = INF;
+//    }
+//    return ans;
+//}
+//
+//int compute(int u) {
+//    int ans = INF;
+//    vis[u] = true;
+//    ans = min(ans, calc(u));
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            total = siz[v];
+//            centroid = 0;
+//            getCentroid(v, 0);
+//            ans = min(ans, compute(centroid));
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        u++;
+//        v++;
+//        addEdge(u, v, w);
+//        addEdge(v, u, w);
+//    }
+//    total = n;
+//    centroid = 0;
+//    getCentroid(1, 0);
+//    fill(dp, dp + MAXK, INF);
+//    int ans = compute(centroid);
+//    if (ans == INF) {
+//        ans = -1;
+//    }
+//    cout << ans << '\n';
+//    return 0;
+//}
\ No newline at end of file

From be77e4979c79d180dfe8de4f15765ef7d6f803bd Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 13:26:19 +0800
Subject: [PATCH 1667/1712] modify code

---
 .../{Code02_Tree1.java => Code02_PairNumber1.java}        | 2 +-
 src/class183/Code04_TreeGame1.java                        | 8 ++++++++
 2 files changed, 9 insertions(+), 1 deletion(-)
 rename src/class183/{Code02_Tree1.java => Code02_PairNumber1.java} (99%)
 create mode 100644 src/class183/Code04_TreeGame1.java

diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code02_PairNumber1.java
similarity index 99%
rename from src/class183/Code02_Tree1.java
rename to src/class183/Code02_PairNumber1.java
index aa45edfd4..54c96238e 100644
--- a/src/class183/Code02_Tree1.java
+++ b/src/class183/Code02_PairNumber1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_Tree1 {
+public class Code02_PairNumber1 {
 
 	public static int MAXN = 50001;
 	public static int n, k, total;
diff --git a/src/class183/Code04_TreeGame1.java b/src/class183/Code04_TreeGame1.java
new file mode 100644
index 000000000..ef1351d21
--- /dev/null
+++ b/src/class183/Code04_TreeGame1.java
@@ -0,0 +1,8 @@
+package class183;
+
+// 树上游戏，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P2664
+
+public class Code04_TreeGame1 {
+
+}

From a39b619a9abfb12c313c565a2fcd40aa4839d5d0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 13:50:11 +0800
Subject: [PATCH 1668/1712] modify code

---
 src/class183/{Code02_PairNumber1.java => Code02_Tree1.java} | 2 +-
 src/class183/{Code04_TreeGame1.java => Code04_Game1.java}   | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)
 rename src/class183/{Code02_PairNumber1.java => Code02_Tree1.java} (99%)
 rename src/class183/{Code04_TreeGame1.java => Code04_Game1.java} (76%)

diff --git a/src/class183/Code02_PairNumber1.java b/src/class183/Code02_Tree1.java
similarity index 99%
rename from src/class183/Code02_PairNumber1.java
rename to src/class183/Code02_Tree1.java
index 54c96238e..aa45edfd4 100644
--- a/src/class183/Code02_PairNumber1.java
+++ b/src/class183/Code02_Tree1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_PairNumber1 {
+public class Code02_Tree1 {
 
 	public static int MAXN = 50001;
 	public static int n, k, total;
diff --git a/src/class183/Code04_TreeGame1.java b/src/class183/Code04_Game1.java
similarity index 76%
rename from src/class183/Code04_TreeGame1.java
rename to src/class183/Code04_Game1.java
index ef1351d21..1e9660a7a 100644
--- a/src/class183/Code04_TreeGame1.java
+++ b/src/class183/Code04_Game1.java
@@ -3,6 +3,6 @@
 // 树上游戏，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P2664
 
-public class Code04_TreeGame1 {
+public class Code04_Game1 {
 
 }

From de8c65d7bfcab259bf1ada4a2f358715fc541752 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 20:53:28 +0800
Subject: [PATCH 1669/1712] modify code

---
 src/class183/Code03_Race1.java     |   3 +-
 src/class183/Code04_Game1.java     |   8 -
 src/class183/Code04_Maschera1.java | 337 +++++++++++++++++++++++++++++
 3 files changed, 338 insertions(+), 10 deletions(-)
 delete mode 100644 src/class183/Code04_Game1.java
 create mode 100644 src/class183/Code04_Maschera1.java

diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
index a575bdf1a..da2808277 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -34,8 +34,7 @@ public class Code03_Race1 {
 
 	public static int[] dp = new int[MAXK];
 
-	// java的实现，getCentroid方法、getPath方法改成迭代才能通过，C++的实现不需要改动
-	// 讲解118，讲了如何把递归函数改成迭代
+	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][5];
 	public static int stacksize, u, f, sum, edge, e;
 
diff --git a/src/class183/Code04_Game1.java b/src/class183/Code04_Game1.java
deleted file mode 100644
index 1e9660a7a..000000000
--- a/src/class183/Code04_Game1.java
+++ /dev/null
@@ -1,8 +0,0 @@
-package class183;
-
-// 树上游戏，java版
-// 测试链接 : https://www.luogu.com.cn/problem/P2664
-
-public class Code04_Game1 {
-
-}
diff --git a/src/class183/Code04_Maschera1.java b/src/class183/Code04_Maschera1.java
new file mode 100644
index 000000000..f12f2bfa9
--- /dev/null
+++ b/src/class183/Code04_Maschera1.java
@@ -0,0 +1,337 @@
+package class183;
+
+// 道路魔力总和，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P5351
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code04_Maschera1 {
+
+	public static int MAXN = 100001;
+	public static int n, l, r, total;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] tree = new int[MAXN];
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxPart = new int[MAXN];
+	public static int centroid;
+
+	public static int[] allMaxv = new int[MAXN];
+	public static int[] allEdge = new int[MAXN];
+	public static int cnta;
+
+	public static int[] curMaxv = new int[MAXN];
+	public static int[] curEdge = new int[MAXN];
+	public static int cntc;
+
+	public static long ans;
+
+	// 讲解118，递归函数改成迭代所需要的栈
+	public static int[][] stack = new int[MAXN][5];
+	public static int stacksize, u, f, maxv, edge, e;
+
+	public static void push(int u, int f, int maxv, int edge, int e) {
+		stack[stacksize][0] = u;
+		stack[stacksize][1] = f;
+		stack[stacksize][2] = maxv;
+		stack[stacksize][3] = edge;
+		stack[stacksize][4] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = stack[stacksize][0];
+		f = stack[stacksize][1];
+		maxv = stack[stacksize][2];
+		edge = stack[stacksize][3];
+		e = stack[stacksize][4];
+	}
+
+	public static void addEdge(int u, int v, int w) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= r) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	// 找重心的递归版，java会爆栈，C++可以通过
+	public static void getCentroid1(int u, int fa) {
+		siz[u] = 1;
+		maxPart[u] = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getCentroid1(v, u);
+				siz[u] += siz[v];
+				maxPart[u] = Math.max(siz[v], maxPart[u]);
+			}
+		}
+		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+			centroid = u;
+		}
+	}
+
+	// 找重心的迭代版
+	public static void getCentroid2(int cur, int fa) {
+		stacksize = 0;
+		push(cur, fa, 0, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				siz[u] = 1;
+				maxPart[u] = 0;
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, 0, 0, e);
+				int v = to[e];
+				if (v != f && !vis[v]) {
+					push(to[e], u, 0, 0, -1);
+				}
+			} else {
+				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
+					int v = to[ei];
+					if (v != f && !vis[v]) {
+						siz[u] += siz[v];
+						maxPart[u] = Math.max(siz[v], maxPart[u]);
+					}
+				}
+				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+					centroid = u;
+				}
+			}
+		}
+	}
+
+	// 收集路径的递归版，java会爆栈，C++可以通过
+	public static void getPath1(int u, int fa, int maxv, int edge) {
+		if (edge > r) {
+			return;
+		}
+		curMaxv[++cntc] = maxv;
+		curEdge[cntc] = edge;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getPath1(v, u, Math.max(maxv, weight[e]), edge + 1);
+			}
+		}
+	}
+
+	// 收集路径的迭代版
+	public static void getPath2(int cur, int fa, int pmaxv, int pedge) {
+		stacksize = 0;
+		push(cur, fa, pmaxv, pedge, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				if (edge > r) {
+					continue;
+				}
+				curMaxv[++cntc] = maxv;
+				curEdge[cntc] = edge;
+				e = head[u];
+			} else {
+				e = nxt[e];
+			}
+			if (e != 0) {
+				push(u, f, maxv, edge, e);
+				int v = to[e];
+				if (v != f && !vis[v]) {
+					push(to[e], u, Math.max(maxv, weight[e]), edge + 1, -1);
+				}
+			}
+		}
+	}
+
+	public static void sort(int[] maxv, int[] edge, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r, pv = maxv[(l + r) >> 1], pe = edge[(l + r) >> 1], tmp;
+		while (i <= j) {
+			while (maxv[i] < pv || (maxv[i] == pv && edge[i] < pe)) i++;
+			while (maxv[j] > pv || (maxv[j] == pv && edge[j] > pe)) j--;
+			if (i <= j) {
+				tmp = maxv[i]; maxv[i] = maxv[j]; maxv[j] = tmp;
+				tmp = edge[i]; edge[i] = edge[j]; edge[j] = tmp;
+				i++; j--;
+			}
+		}
+		sort(maxv, edge, l, j);
+		sort(maxv, edge, i, r);
+	}
+
+	public static void calc(int u) {
+		cnta = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				cntc = 0;
+				// getPath1(v, u, weight[e], 1);
+				getPath2(v, u, weight[e], 1);
+				if (cntc > 0) {
+					sort(curMaxv, curEdge, 1, cntc);
+					for (int i = 1; i <= cntc; i++) {
+						int maxv = curMaxv[i];
+						int edge = curEdge[i];
+						int left = l - edge - 1;
+						int right = r - edge;
+						if (right >= 0) {
+							left = Math.max(left, 0);
+							right = Math.min(right, r);
+							if (left <= right) {
+								ans -= 1L * maxv * (sum(right) - sum(left));
+							}
+						}
+						add(edge, 1);
+					}
+					for (int i = 1; i <= cntc; i++) {
+						add(curEdge[i], -1);
+					}
+					for (int i = 1; i <= cntc; i++) {
+						allMaxv[++cnta] = curMaxv[i];
+						allEdge[cnta] = curEdge[i];
+					}
+				}
+			}
+		}
+		if (cnta > 0) {
+			sort(allMaxv, allEdge, 1, cnta);
+			for (int i = 1; i <= cnta; i++) {
+				int maxv = allMaxv[i];
+				int edge = allEdge[i];
+				int left = l - edge - 1;
+				int right = r - edge;
+				if (right >= 0) {
+					left = Math.max(left, 0);
+					right = Math.min(right, r);
+					if (left <= right) {
+						ans += 1L * maxv * (sum(right) - sum(left));
+					}
+				}
+				add(edge, 1);
+			}
+			for (int i = 1; i <= cnta; i++) {
+				add(allEdge[i], -1);
+			}
+			for (int i = 1; i <= cnta; i++) {
+				if (allEdge[i] >= l) {
+					ans += allMaxv[i];
+				}
+			}
+		}
+	}
+
+	public static void compute(int u) {
+		calc(u);
+		vis[u] = true;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				total = siz[v];
+				centroid = 0;
+				// getCentroid1(v, 0);
+				getCentroid2(v, 0);
+				compute(centroid);
+			}
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		l = in.nextInt();
+		r = in.nextInt();
+		for (int i = 1, u, v, w; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextInt();
+			addEdge(u, v, w);
+			addEdge(v, u, w);
+		}
+		total = n;
+		centroid = 0;
+		// getCentroid1(1, 0);
+		getCentroid2(1, 0);
+		compute(centroid);
+		out.println(ans << 1);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 20];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}

From cf7ed62ebdacea48909d4efac04985a852cd1844 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Tue, 11 Nov 2025 20:57:35 +0800
Subject: [PATCH 1670/1712] modify code

---
 src/class183/Code04_Maschera1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class183/Code04_Maschera1.java b/src/class183/Code04_Maschera1.java
index f12f2bfa9..db56a3041 100644
--- a/src/class183/Code04_Maschera1.java
+++ b/src/class183/Code04_Maschera1.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 道路魔力总和，java版
+// 路径魔力总和，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5351
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 

From 83d4bb9c2b2e2cabdd82703c44dcd4c2ef9a6fc5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 11:29:15 +0800
Subject: [PATCH 1671/1712] modify code

---
 src/class183/Code04_Maschera1.java | 24 ++++++++----------------
 1 file changed, 8 insertions(+), 16 deletions(-)

diff --git a/src/class183/Code04_Maschera1.java b/src/class183/Code04_Maschera1.java
index db56a3041..8046f8f2d 100644
--- a/src/class183/Code04_Maschera1.java
+++ b/src/class183/Code04_Maschera1.java
@@ -207,18 +207,14 @@ public static void calc(int u) {
 				if (cntc > 0) {
 					sort(curMaxv, curEdge, 1, cntc);
 					for (int i = 1; i <= cntc; i++) {
-						int maxv = curMaxv[i];
-						int edge = curEdge[i];
-						int left = l - edge - 1;
-						int right = r - edge;
+						int left = l - curEdge[i] - 1;
+						int right = r - curEdge[i];
 						if (right >= 0) {
 							left = Math.max(left, 0);
 							right = Math.min(right, r);
-							if (left <= right) {
-								ans -= 1L * maxv * (sum(right) - sum(left));
-							}
+							ans -= 1L * curMaxv[i] * (sum(right) - sum(left));
 						}
-						add(edge, 1);
+						add(curEdge[i], 1);
 					}
 					for (int i = 1; i <= cntc; i++) {
 						add(curEdge[i], -1);
@@ -233,18 +229,14 @@ public static void calc(int u) {
 		if (cnta > 0) {
 			sort(allMaxv, allEdge, 1, cnta);
 			for (int i = 1; i <= cnta; i++) {
-				int maxv = allMaxv[i];
-				int edge = allEdge[i];
-				int left = l - edge - 1;
-				int right = r - edge;
+				int left = l - allEdge[i] - 1;
+				int right = r - allEdge[i];
 				if (right >= 0) {
 					left = Math.max(left, 0);
 					right = Math.min(right, r);
-					if (left <= right) {
-						ans += 1L * maxv * (sum(right) - sum(left));
-					}
+					ans += 1L * allMaxv[i] * (sum(right) - sum(left));
 				}
-				add(edge, 1);
+				add(allEdge[i], 1);
 			}
 			for (int i = 1; i <= cnta; i++) {
 				add(allEdge[i], -1);

From 3bbbc808514a6bfb31f6d5c46f8161a9d06c9a3c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 11:35:55 +0800
Subject: [PATCH 1672/1712] modify code

---
 src/class183/{Code03_Race1.java => Code02_Race1.java}  |  2 +-
 src/class183/{Code03_Race2.java => Code02_Race2.java}  |  0
 src/class183/{Code02_Tree1.java => Code03_Tree1.java}  |  2 +-
 src/class183/Code04_CloseVertices1.java                | 10 ++++++++++
 .../{Code04_Maschera1.java => Code05_Maschera1.java}   |  4 ++--
 5 files changed, 14 insertions(+), 4 deletions(-)
 rename src/class183/{Code03_Race1.java => Code02_Race1.java} (99%)
 rename src/class183/{Code03_Race2.java => Code02_Race2.java} (100%)
 rename src/class183/{Code02_Tree1.java => Code03_Tree1.java} (99%)
 create mode 100644 src/class183/Code04_CloseVertices1.java
 rename src/class183/{Code04_Maschera1.java => Code05_Maschera1.java} (99%)

diff --git a/src/class183/Code03_Race1.java b/src/class183/Code02_Race1.java
similarity index 99%
rename from src/class183/Code03_Race1.java
rename to src/class183/Code02_Race1.java
index da2808277..c84a55469 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code02_Race1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_Race1 {
+public class Code02_Race1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 1000001;
diff --git a/src/class183/Code03_Race2.java b/src/class183/Code02_Race2.java
similarity index 100%
rename from src/class183/Code03_Race2.java
rename to src/class183/Code02_Race2.java
diff --git a/src/class183/Code02_Tree1.java b/src/class183/Code03_Tree1.java
similarity index 99%
rename from src/class183/Code02_Tree1.java
rename to src/class183/Code03_Tree1.java
index aa45edfd4..1c2aa1920 100644
--- a/src/class183/Code02_Tree1.java
+++ b/src/class183/Code03_Tree1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_Tree1 {
+public class Code03_Tree1 {
 
 	public static int MAXN = 50001;
 	public static int n, k, total;
diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code04_CloseVertices1.java
new file mode 100644
index 000000000..7c2df3145
--- /dev/null
+++ b/src/class183/Code04_CloseVertices1.java
@@ -0,0 +1,10 @@
+package class183;
+
+// 相近的顶点对，java版
+// 测试链接 : https://www.luogu.com.cn/problem/CF293E
+// 测试链接 : https://codeforces.com/problemset/problem/293/E
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+public class Code04_CloseVertices1 {
+
+}
diff --git a/src/class183/Code04_Maschera1.java b/src/class183/Code05_Maschera1.java
similarity index 99%
rename from src/class183/Code04_Maschera1.java
rename to src/class183/Code05_Maschera1.java
index 8046f8f2d..cee86a57e 100644
--- a/src/class183/Code04_Maschera1.java
+++ b/src/class183/Code05_Maschera1.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 路径魔力总和，java版
+// 所有路径的魔力和，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P5351
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_Maschera1 {
+public class Code05_Maschera1 {
 
 	public static int MAXN = 100001;
 	public static int n, l, r, total;

From 41699514d7b85a135f40e1088f8da35892bc2735 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 11:36:56 +0800
Subject: [PATCH 1673/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 2 +-
 src/class183/Code01_CentroidDecomposition2.java | 2 +-
 2 files changed, 2 insertions(+), 2 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 19f03bc16..1d3f2edb9 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 点分治，也叫重心分治，java版
+// 点分治，也叫重心分解，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P3806
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index eba473ed6..ca095912f 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 点分治，也叫重心分治，C++版
+// 点分治，也叫重心分解，C++版
 // 测试链接 : https://www.luogu.com.cn/problem/P3806
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例

From 9b8eceea69027123176760a4450ff3d3704cfd56 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 12:23:23 +0800
Subject: [PATCH 1674/1712] modify code

---
 src/class183/Code03_Message1.java                         | 8 ++++++++
 src/class183/Code04_Capital1.java                         | 8 ++++++++
 src/class183/{Code03_Tree1.java => Code05_Tree1.java}     | 2 +-
 ...e04_CloseVertices1.java => Code06_CloseVertices1.java} | 2 +-
 .../{Code05_Maschera1.java => Code07_Maschera1.java}      | 2 +-
 5 files changed, 19 insertions(+), 3 deletions(-)
 create mode 100644 src/class183/Code03_Message1.java
 create mode 100644 src/class183/Code04_Capital1.java
 rename src/class183/{Code03_Tree1.java => Code05_Tree1.java} (99%)
 rename src/class183/{Code04_CloseVertices1.java => Code06_CloseVertices1.java} (87%)
 rename src/class183/{Code05_Maschera1.java => Code07_Maschera1.java} (99%)

diff --git a/src/class183/Code03_Message1.java b/src/class183/Code03_Message1.java
new file mode 100644
index 000000000..b92c343ef
--- /dev/null
+++ b/src/class183/Code03_Message1.java
@@ -0,0 +1,8 @@
+package class183;
+
+// 消息传递，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P6626
+
+public class Code03_Message1 {
+
+}
diff --git a/src/class183/Code04_Capital1.java b/src/class183/Code04_Capital1.java
new file mode 100644
index 000000000..d31909ac1
--- /dev/null
+++ b/src/class183/Code04_Capital1.java
@@ -0,0 +1,8 @@
+package class183;
+
+// 首都，java版
+// 测试链接 : https://www.luogu.com.cn/problem/P7215
+
+public class Code04_Capital1 {
+
+}
diff --git a/src/class183/Code03_Tree1.java b/src/class183/Code05_Tree1.java
similarity index 99%
rename from src/class183/Code03_Tree1.java
rename to src/class183/Code05_Tree1.java
index 1c2aa1920..caff2b33b 100644
--- a/src/class183/Code03_Tree1.java
+++ b/src/class183/Code05_Tree1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_Tree1 {
+public class Code05_Tree1 {
 
 	public static int MAXN = 50001;
 	public static int n, k, total;
diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code06_CloseVertices1.java
similarity index 87%
rename from src/class183/Code04_CloseVertices1.java
rename to src/class183/Code06_CloseVertices1.java
index 7c2df3145..53d2f3187 100644
--- a/src/class183/Code04_CloseVertices1.java
+++ b/src/class183/Code06_CloseVertices1.java
@@ -5,6 +5,6 @@
 // 测试链接 : https://codeforces.com/problemset/problem/293/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-public class Code04_CloseVertices1 {
+public class Code06_CloseVertices1 {
 
 }
diff --git a/src/class183/Code05_Maschera1.java b/src/class183/Code07_Maschera1.java
similarity index 99%
rename from src/class183/Code05_Maschera1.java
rename to src/class183/Code07_Maschera1.java
index cee86a57e..feb62b055 100644
--- a/src/class183/Code05_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_Maschera1 {
+public class Code07_Maschera1 {
 
 	public static int MAXN = 100001;
 	public static int n, l, r, total;

From 3227f09c6d3711f2515182719f6bd4715fd1df5f Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 14:43:17 +0800
Subject: [PATCH 1675/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        |  12 +-
 .../Code01_CentroidDecomposition2.java        |  12 +-
 src/class183/Code02_Race1.java                |  20 +-
 src/class183/Code02_Race2.java                |  12 +-
 src/class183/Code03_Message1.java             | 295 ++++++++++++++++++
 src/class183/Code04_Capital1.java             |   1 +
 src/class183/Code05_Tree1.java                |  12 +-
 src/class183/Code06_CloseVertices1.java       |   2 +-
 src/class183/Code07_Maschera1.java            |  20 +-
 9 files changed, 341 insertions(+), 45 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 1d3f2edb9..223bda2fb 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -60,7 +60,7 @@ public static void getCentroid(int u, int fa) {
 		}
 	}
 
-	public static void getDistance(int u, int fa, int w) {
+	public static void dfs(int u, int fa, int w) {
 		dis[u] = dis[fa] + w;
 		if (dis[u] > maxq) {
 			return;
@@ -69,7 +69,7 @@ public static void getDistance(int u, int fa, int w) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getDistance(v, u, weight[e]);
+				dfs(v, u, weight[e]);
 			}
 		}
 	}
@@ -82,7 +82,7 @@ public static void calc(int u) {
 			int w = weight[e];
 			if (!vis[v]) {
 				cnta = 0;
-				getDistance(v, u, w);
+				dfs(v, u, w);
 				for (int i = 1; i <= m; i++) {
 					for (int j = 1; j <= cnta; j++) {
 						if (query[i] - arr[j] >= 0) {
@@ -101,7 +101,7 @@ public static void calc(int u) {
 		}
 	}
 
-	public static void compute(int u) {
+	public static void solve(int u) {
 		vis[u] = true;
 		check[0] = true;
 		calc(u);
@@ -111,7 +111,7 @@ public static void compute(int u) {
 				total = siz[v];
 				centroid = 0;
 				getCentroid(v, u);
-				compute(centroid);
+				solve(centroid);
 			}
 		}
 	}
@@ -135,7 +135,7 @@ public static void main(String[] args) throws Exception {
 		total = n;
 		centroid = 0;
 		getCentroid(1, 0);
-		compute(centroid);
+		solve(centroid);
 		for (int i = 1; i <= m; i++) {
 			if (ans[i]) {
 				out.println("AYE");
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index ca095912f..22095c985 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -58,7 +58,7 @@
 //    }
 //}
 //
-//void getDistance(int u, int fa, int w) {
+//void dfs(int u, int fa, int w) {
 //    dis[u] = dis[fa] + w;
 //    if (dis[u] > maxq) {
 //        return;
@@ -67,7 +67,7 @@
 //    for (int e = head[u]; e > 0; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            getDistance(v, u, weight[e]);
+//            dfs(v, u, weight[e]);
 //        }
 //    }
 //}
@@ -80,7 +80,7 @@
 //        int w = weight[e];
 //        if (!vis[v]) {
 //            cnta = 0;
-//            getDistance(v, u, w);
+//            dfs(v, u, w);
 //            for (int i = 1; i <= m; i++) {
 //                for (int j = 1; j <= cnta; j++) {
 //                    if (query[i] - arr[j] >= 0) {
@@ -99,7 +99,7 @@
 //    }
 //}
 //
-//void compute(int u) {
+//void solve(int u) {
 //    vis[u] = true;
 //    check[0] = true;
 //    calc(u);
@@ -109,7 +109,7 @@
 //            total = siz[v];
 //            centroid = 0;
 //            getCentroid(v, u);
-//            compute(centroid);
+//            solve(centroid);
 //        }
 //    }
 //}
@@ -130,7 +130,7 @@
 //    total = n;
 //    centroid = 0;
 //    getCentroid(1, 0);
-//    compute(centroid);
+//    solve(centroid);
 //    for (int i = 1; i <= m; i++) {
 //        if (ans[i]) {
 //            cout << "AYE" << '\n';
diff --git a/src/class183/Code02_Race1.java b/src/class183/Code02_Race1.java
index c84a55469..1620e6392 100644
--- a/src/class183/Code02_Race1.java
+++ b/src/class183/Code02_Race1.java
@@ -116,8 +116,8 @@ public static void getCentroid2(int cur, int fa) {
 		}
 	}
 
-	// 收集路径的递归版，java会爆栈，C++可以通过
-	public static void getPath1(int u, int fa, int sum, int edge) {
+	// 收集信息递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa, int sum, int edge) {
 		if (sum > k) {
 			return;
 		}
@@ -126,13 +126,13 @@ public static void getPath1(int u, int fa, int sum, int edge) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getPath1(v, u, sum + weight[e], edge + 1);
+				dfs1(v, u, sum + weight[e], edge + 1);
 			}
 		}
 	}
 
-	// 收集路径的迭代版
-	public static void getPath2(int cur, int fa, int psum, int pedge) {
+	// 收集信息的迭代版
+	public static void dfs2(int cur, int fa, int psum, int pedge) {
 		stacksize = 0;
 		push(cur, fa, psum, pedge, -1);
 		while (stacksize > 0) {
@@ -165,8 +165,8 @@ public static int calc(int u) {
 			int v = to[e];
 			if (!vis[v]) {
 				int tmp = cnta;
-				// getPath1(v, u, weight[e], 1);
-				getPath2(v, u, weight[e], 1);
+				// dfs1(v, u, weight[e], 1);
+				dfs2(v, u, weight[e], 1);
 				for (int i = tmp + 1; i <= cnta; i++) {
 					ans = Math.min(ans, dp[k - sumArr[i]] + edgeArr[i]);
 				}
@@ -181,7 +181,7 @@ public static int calc(int u) {
 		return ans;
 	}
 
-	public static int compute(int u) {
+	public static int solve(int u) {
 		int ans = INF;
 		vis[u] = true;
 		ans = Math.min(ans, calc(u));
@@ -192,7 +192,7 @@ public static int compute(int u) {
 				centroid = 0;
 				// getCentroid1(v, 0);
 				getCentroid2(v, 0);
-				ans = Math.min(ans, compute(centroid));
+				ans = Math.min(ans, solve(centroid));
 			}
 		}
 		return ans;
@@ -215,7 +215,7 @@ public static void main(String[] args) throws Exception {
 		// getCentroid1(1, 0);
 		getCentroid2(1, 0);
 		Arrays.fill(dp, INF);
-		int ans = compute(centroid);
+		int ans = solve(centroid);
 		if (ans == INF) {
 			ans = -1;
 		}
diff --git a/src/class183/Code02_Race2.java b/src/class183/Code02_Race2.java
index f4ba109af..2f91e1f11 100644
--- a/src/class183/Code02_Race2.java
+++ b/src/class183/Code02_Race2.java
@@ -55,7 +55,7 @@
 //    }
 //}
 //
-//void getPath(int u, int fa, int sum, int edge) {
+//void dfs(int u, int fa, int sum, int edge) {
 //    if (sum > k) {
 //        return;
 //    }
@@ -64,7 +64,7 @@
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            getPath(v, u, sum + weight[e], edge + 1);
+//            dfs(v, u, sum + weight[e], edge + 1);
 //        }
 //    }
 //}
@@ -77,7 +77,7 @@
 //        int v = to[e];
 //        if (!vis[v]) {
 //            int tmp = cnta;
-//            getPath(v, u, weight[e], 1);
+//            dfs(v, u, weight[e], 1);
 //            for (int i = tmp + 1; i <= cnta; i++) {
 //                ans = min(ans, dp[k - sumArr[i]] + edgeArr[i]);
 //            }
@@ -92,7 +92,7 @@
 //    return ans;
 //}
 //
-//int compute(int u) {
+//int solve(int u) {
 //    int ans = INF;
 //    vis[u] = true;
 //    ans = min(ans, calc(u));
@@ -102,7 +102,7 @@
 //            total = siz[v];
 //            centroid = 0;
 //            getCentroid(v, 0);
-//            ans = min(ans, compute(centroid));
+//            ans = min(ans, solve(centroid));
 //        }
 //    }
 //    return ans;
@@ -123,7 +123,7 @@
 //    centroid = 0;
 //    getCentroid(1, 0);
 //    fill(dp, dp + MAXK, INF);
-//    int ans = compute(centroid);
+//    int ans = solve(centroid);
 //    if (ans == INF) {
 //        ans = -1;
 //    }
diff --git a/src/class183/Code03_Message1.java b/src/class183/Code03_Message1.java
index b92c343ef..970c0be66 100644
--- a/src/class183/Code03_Message1.java
+++ b/src/class183/Code03_Message1.java
@@ -2,7 +2,302 @@
 
 // 消息传递，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P6626
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
 
 public class Code03_Message1 {
 
+	public static int MAXN = 100001;
+	public static int t, n, m, total;
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headq = new int[MAXN];
+	public static int[] nextq = new int[MAXN];
+	public static int[] tim = new int[MAXN];
+	public static int[] qid = new int[MAXN];
+	public static int cntq;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxPart = new int[MAXN];
+	public static int centroid;
+
+	public static int[] dep = new int[MAXN];
+	public static int[] depCnt = new int[MAXN];
+	public static int maxDeep;
+
+	public static int[] timArr = new int[MAXN];
+	public static int[] qidArr = new int[MAXN];
+	public static int cnta;
+
+	public static int[] ans = new int[MAXN];
+
+	// 讲解118，递归函数改成迭代所需要的栈
+	public static int[][] stack = new int[MAXN][3];
+	public static int stacksize, u, f, e;
+
+	public static void push(int u, int f, int e) {
+		stack[stacksize][0] = u;
+		stack[stacksize][1] = f;
+		stack[stacksize][2] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = stack[stacksize][0];
+		f = stack[stacksize][1];
+		e = stack[stacksize][2];
+	}
+
+	public static void addEdge(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addQuery(int u, int t, int id) {
+		nextq[++cntq] = headq[u];
+		tim[cntq] = t;
+		qid[cntq] = id;
+		headq[u] = cntq;
+	}
+
+	// 找重心的递归版，java会爆栈，C++可以通过
+	public static void getCentroid1(int u, int fa) {
+		siz[u] = 1;
+		maxPart[u] = 0;
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (v != fa && !vis[v]) {
+				getCentroid1(v, u);
+				siz[u] += siz[v];
+				maxPart[u] = Math.max(siz[v], maxPart[u]);
+			}
+		}
+		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+			centroid = u;
+		}
+	}
+
+	// 找重心的迭代版
+	public static void getCentroid2(int cur, int fa) {
+		stacksize = 0;
+		push(cur, fa, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				siz[u] = 1;
+				maxPart[u] = 0;
+				e = headg[u];
+			} else {
+				e = nextg[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				int v = tog[e];
+				if (v != f && !vis[v]) {
+					push(tog[e], u, -1);
+				}
+			} else {
+				for (int ei = headg[u]; ei > 0; ei = nextg[ei]) {
+					int v = tog[ei];
+					if (v != f && !vis[v]) {
+						siz[u] += siz[v];
+						maxPart[u] = Math.max(siz[v], maxPart[u]);
+					}
+				}
+				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+					centroid = u;
+				}
+			}
+		}
+	}
+
+	// 收集信息递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa) {
+		dep[u] = dep[fa] + 1;
+		depCnt[dep[u]]++;
+		maxDeep = Math.max(maxDeep, dep[u]);
+		for (int e = headq[u]; e > 0; e = nextq[e]) {
+			if (tim[e] + 1 >= dep[u]) {
+				timArr[++cnta] = tim[e] - dep[u] + 2;
+				qidArr[cnta] = qid[e];
+			}
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (v != fa && !vis[v]) {
+				dfs1(v, u);
+			}
+		}
+	}
+
+	// 收集信息迭代版
+	public static void dfs2(int cur, int fa) {
+		stacksize = 0;
+		push(cur, fa, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				dep[u] = dep[f] + 1;
+				depCnt[dep[u]]++;
+				maxDeep = Math.max(maxDeep, dep[u]);
+				for (int e = headq[u]; e > 0; e = nextq[e]) {
+					if (tim[e] + 1 >= dep[u]) {
+						timArr[++cnta] = tim[e] - dep[u] + 2;
+						qidArr[cnta] = qid[e];
+					}
+				}
+				e = headg[u];
+			} else {
+				e = nextg[e];
+			}
+			if (e != 0) {
+				push(u, f, e);
+				int v = tog[e];
+				if (v != f && !vis[v]) {
+					push(tog[e], u, -1);
+				}
+			}
+		}
+	}
+
+	public static void calc(int u) {
+		cnta = 0;
+		maxDeep = 0;
+		// dfs1(u, 0);
+		dfs2(u, 0);
+		for (int i = 1; i <= cnta; i++) {
+			ans[qidArr[i]] += depCnt[timArr[i]];
+		}
+		for (int d = 1; d <= maxDeep; d++) {
+			depCnt[d] = 0;
+		}
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (!vis[v]) {
+				cnta = 0;
+				maxDeep = 0;
+				// dfs1(v, u);
+				dfs2(v, u);
+				for (int i = 1; i <= cnta; i++) {
+					ans[qidArr[i]] -= depCnt[timArr[i]];
+				}
+				for (int d = 1; d <= maxDeep; d++) {
+					depCnt[d] = 0;
+				}
+			}
+		}
+	}
+
+	public static void solve(int u) {
+		vis[u] = true;
+		calc(u);
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (!vis[v]) {
+				total = siz[v];
+				centroid = 0;
+				// getCentroid1(v, u);
+				getCentroid2(v, u);
+				solve(centroid);
+			}
+		}
+	}
+
+	public static void prepare() {
+		cntg = 0;
+		cntq = 0;
+		for (int i = 1; i <= n; i++) {
+			headg[i] = 0;
+			headq[i] = 0;
+			vis[i] = false;
+		}
+		for (int i = 1; i <= m; i++) {
+			ans[i] = 0;
+		}
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		t = in.nextInt();
+		for (int c = 1; c <= t; c++) {
+			n = in.nextInt();
+			m = in.nextInt();
+			prepare();
+			for (int i = 1, u, v; i < n; i++) {
+				u = in.nextInt();
+				v = in.nextInt();
+				addEdge(u, v);
+				addEdge(v, u);
+			}
+			for (int i = 1, x, k; i <= m; i++) {
+				x = in.nextInt();
+				k = in.nextInt();
+				addQuery(x, k, i);
+			}
+			total = n;
+			centroid = 0;
+			// getCentroid1(1, 0);
+			getCentroid2(1, 0);
+			solve(centroid);
+			for (int i = 1; i <= m; i++) {
+				out.println(ans[i]);
+			}
+		}
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }
diff --git a/src/class183/Code04_Capital1.java b/src/class183/Code04_Capital1.java
index d31909ac1..22e51b87a 100644
--- a/src/class183/Code04_Capital1.java
+++ b/src/class183/Code04_Capital1.java
@@ -2,6 +2,7 @@
 
 // 首都，java版
 // 测试链接 : https://www.luogu.com.cn/problem/P7215
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
 public class Code04_Capital1 {
 
diff --git a/src/class183/Code05_Tree1.java b/src/class183/Code05_Tree1.java
index caff2b33b..490781356 100644
--- a/src/class183/Code05_Tree1.java
+++ b/src/class183/Code05_Tree1.java
@@ -54,7 +54,7 @@ public static void getCentroid(int u, int fa) {
 		}
 	}
 
-	public static void getDistance(int u, int fa, int w) {
+	public static void dfs(int u, int fa, int w) {
 		dis[u] = dis[fa] + w;
 		if (dis[u] > k) {
 			return;
@@ -63,7 +63,7 @@ public static void getDistance(int u, int fa, int w) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getDistance(v, u, weight[e]);
+				dfs(v, u, weight[e]);
 			}
 		}
 	}
@@ -71,7 +71,7 @@ public static void getDistance(int u, int fa, int w) {
 	public static long calc(int u, int fa, int w) {
 		dis[fa] = 0;
 		cnta = 0;
-		getDistance(u, fa, w);
+		dfs(u, fa, w);
 		long ans = 0;
 		Arrays.sort(arr, 1, cnta + 1);
 		for (int l = 1, r = cnta; l < r;) {
@@ -85,7 +85,7 @@ public static long calc(int u, int fa, int w) {
 		return ans;
 	}
 
-	public static long compute(int u) {
+	public static long solve(int u) {
 		long ans = 0;
 		ans += calc(u, 0, 0);
 		vis[u] = true;
@@ -96,7 +96,7 @@ public static long compute(int u) {
 				total = siz[v];
 				centroid = 0;
 				getCentroid(v, 0);
-				ans += compute(centroid);
+				ans += solve(centroid);
 			}
 		}
 		return ans;
@@ -117,7 +117,7 @@ public static void main(String[] args) throws Exception {
 		total = n;
 		centroid = 0;
 		getCentroid(1, 0);
-		out.println(compute(centroid));
+		out.println(solve(centroid));
 		out.flush();
 		out.close();
 	}
diff --git a/src/class183/Code06_CloseVertices1.java b/src/class183/Code06_CloseVertices1.java
index 53d2f3187..13e4c8fd3 100644
--- a/src/class183/Code06_CloseVertices1.java
+++ b/src/class183/Code06_CloseVertices1.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 相近的顶点对，java版
+// 相近的点对数量，java版
 // 测试链接 : https://www.luogu.com.cn/problem/CF293E
 // 测试链接 : https://codeforces.com/problemset/problem/293/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code07_Maschera1.java
index feb62b055..340cdcb95 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -139,8 +139,8 @@ public static void getCentroid2(int cur, int fa) {
 		}
 	}
 
-	// 收集路径的递归版，java会爆栈，C++可以通过
-	public static void getPath1(int u, int fa, int maxv, int edge) {
+	// 收集信息递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa, int maxv, int edge) {
 		if (edge > r) {
 			return;
 		}
@@ -149,13 +149,13 @@ public static void getPath1(int u, int fa, int maxv, int edge) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getPath1(v, u, Math.max(maxv, weight[e]), edge + 1);
+				dfs1(v, u, Math.max(maxv, weight[e]), edge + 1);
 			}
 		}
 	}
 
-	// 收集路径的迭代版
-	public static void getPath2(int cur, int fa, int pmaxv, int pedge) {
+	// 收集信息迭代版
+	public static void dfs2(int cur, int fa, int pmaxv, int pedge) {
 		stacksize = 0;
 		push(cur, fa, pmaxv, pedge, -1);
 		while (stacksize > 0) {
@@ -202,8 +202,8 @@ public static void calc(int u) {
 			int v = to[e];
 			if (!vis[v]) {
 				cntc = 0;
-				// getPath1(v, u, weight[e], 1);
-				getPath2(v, u, weight[e], 1);
+				// dfs1(v, u, weight[e], 1);
+				dfs2(v, u, weight[e], 1);
 				if (cntc > 0) {
 					sort(curMaxv, curEdge, 1, cntc);
 					for (int i = 1; i <= cntc; i++) {
@@ -249,7 +249,7 @@ public static void calc(int u) {
 		}
 	}
 
-	public static void compute(int u) {
+	public static void solve(int u) {
 		calc(u);
 		vis[u] = true;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
@@ -259,7 +259,7 @@ public static void compute(int u) {
 				centroid = 0;
 				// getCentroid1(v, 0);
 				getCentroid2(v, 0);
-				compute(centroid);
+				solve(centroid);
 			}
 		}
 	}
@@ -281,7 +281,7 @@ public static void main(String[] args) throws Exception {
 		centroid = 0;
 		// getCentroid1(1, 0);
 		getCentroid2(1, 0);
-		compute(centroid);
+		solve(centroid);
 		out.println(ans << 1);
 		out.flush();
 		out.close();

From b3366b0f7eefd8e8cc5fbcfe3d783a81aeedb905 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 16:27:58 +0800
Subject: [PATCH 1676/1712] modify code

---
 src/class183/Code04_Capital1.java | 264 ++++++++++++++++++++++++++++++
 1 file changed, 264 insertions(+)

diff --git a/src/class183/Code04_Capital1.java b/src/class183/Code04_Capital1.java
index 22e51b87a..438ff2411 100644
--- a/src/class183/Code04_Capital1.java
+++ b/src/class183/Code04_Capital1.java
@@ -4,6 +4,270 @@
 // 测试链接 : https://www.luogu.com.cn/problem/P7215
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
 public class Code04_Capital1 {
 
+	public static int MAXN = 200001;
+	public static int INF = 1000000001;
+	public static int n, k, total;
+	public static int[] color = new int[MAXN];
+
+	public static int[] headg = new int[MAXN];
+	public static int[] nextg = new int[MAXN << 1];
+	public static int[] tog = new int[MAXN << 1];
+	public static int cntg;
+
+	public static int[] headc = new int[MAXN];
+	public static int[] nextc = new int[MAXN];
+	public static int[] toc = new int[MAXN];
+	public static int cntc;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxPart = new int[MAXN];
+	public static int centroid;
+
+	public static int[] father = new int[MAXN];
+	public static int[] nodeStamp = new int[MAXN];
+	public static int[] colorStamp = new int[MAXN];
+	public static int[] que = new int[MAXN];
+	public static boolean[] enter = new boolean[MAXN];
+
+	// 讲解118，递归函数改成迭代所需要的栈
+	public static int[][] stack = new int[MAXN][4];
+	public static int stacksize, u, f, rt, e;
+
+	public static void push(int u, int f, int rt, int e) {
+		stack[stacksize][0] = u;
+		stack[stacksize][1] = f;
+		stack[stacksize][2] = rt;
+		stack[stacksize][3] = e;
+		stacksize++;
+	}
+
+	public static void pop() {
+		--stacksize;
+		u = stack[stacksize][0];
+		f = stack[stacksize][1];
+		rt = stack[stacksize][2];
+		e = stack[stacksize][3];
+	}
+
+	public static void addEdge(int u, int v) {
+		nextg[++cntg] = headg[u];
+		tog[cntg] = v;
+		headg[u] = cntg;
+	}
+
+	public static void addNode(int color, int node) {
+		nextc[++cntc] = headc[color];
+		toc[cntc] = node;
+		headc[color] = cntc;
+	}
+
+	// 找重心的递归版，java会爆栈，C++可以通过
+	public static void getCentroid1(int u, int fa) {
+		siz[u] = 1;
+		maxPart[u] = 0;
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (v != fa && !vis[v]) {
+				getCentroid1(v, u);
+				siz[u] += siz[v];
+				maxPart[u] = Math.max(siz[v], maxPart[u]);
+			}
+		}
+		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+			centroid = u;
+		}
+	}
+
+	// 找重心的迭代版
+	public static void getCentroid2(int cur, int fa) {
+		stacksize = 0;
+		push(cur, fa, 0, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				siz[u] = 1;
+				maxPart[u] = 0;
+				e = headg[u];
+			} else {
+				e = nextg[e];
+			}
+			if (e != 0) {
+				push(u, f, 0, e);
+				int v = tog[e];
+				if (v != f && !vis[v]) {
+					push(tog[e], u, 0, -1);
+				}
+			} else {
+				for (int ei = headg[u]; ei > 0; ei = nextg[ei]) {
+					int v = tog[ei];
+					if (v != f && !vis[v]) {
+						siz[u] += siz[v];
+						maxPart[u] = Math.max(siz[v], maxPart[u]);
+					}
+				}
+				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+					centroid = u;
+				}
+			}
+		}
+	}
+
+	// 收集信息递归版，java会爆栈，C++可以通过
+	public static void dfs1(int u, int fa, int root) {
+		father[u] = fa;
+		nodeStamp[u] = root;
+		enter[u] = false;
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (v != fa && !vis[v]) {
+				dfs1(v, u, root);
+			}
+		}
+	}
+
+	// 收集信息迭代版
+	public static void dfs2(int cur, int fa, int root) {
+		stacksize = 0;
+		push(cur, fa, root, -1);
+		while (stacksize > 0) {
+			pop();
+			if (e == -1) {
+				father[u] = f;
+				nodeStamp[u] = rt;
+				enter[u] = false;
+				e = headg[u];
+			} else {
+				e = nextg[e];
+			}
+			if (e != 0) {
+				push(u, f, rt, e);
+				int v = tog[e];
+				if (v != f && !vis[v]) {
+					push(tog[e], u, rt, -1);
+				}
+			}
+		}
+	}
+
+	public static int calc(int u) {
+		// dfs1(u, 0, u);
+		dfs2(u, 0, u);
+		int l = 1, r = 0;
+		que[++r] = u;
+		enter[u] = true;
+		int ans = 0;
+		while (l <= r) {
+			int cur = que[l++];
+			if (cur != u && !enter[father[cur]]) {
+				que[++r] = father[cur];
+				enter[father[cur]] = true;
+			}
+			if (colorStamp[color[cur]] != u) {
+				colorStamp[color[cur]] = u;
+				ans++;
+				for (int e = headc[color[cur]]; e > 0; e = nextc[e]) {
+					int v = toc[e];
+					if (nodeStamp[v] != u) {
+						return INF;
+					}
+					if (!enter[v]) {
+						que[++r] = v;
+						enter[v] = true;
+					}
+				}
+			}
+		}
+		return ans;
+	}
+
+	public static int solve(int u) {
+		vis[u] = true;
+		int ans = calc(u);
+		for (int e = headg[u]; e > 0; e = nextg[e]) {
+			int v = tog[e];
+			if (!vis[v]) {
+				total = siz[v];
+				centroid = 0;
+				// getCentroid1(v, u);
+				getCentroid2(v, u);
+				ans = Math.min(ans, solve(centroid));
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		k = in.nextInt();
+		for (int i = 1, u, v; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			addEdge(u, v);
+			addEdge(v, u);
+		}
+		for (int i = 1; i <= n; i++) {
+			color[i] = in.nextInt();
+			addNode(color[i], i);
+		}
+		total = n;
+		centroid = 0;
+		// getCentroid1(1, 0);
+		getCentroid2(1, 0);
+		int ans = solve(centroid);
+		out.println(ans - 1);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }

From 4e8f4761d9a199d4de0ae2670a4aac21ff0f658b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 16:32:10 +0800
Subject: [PATCH 1677/1712] modify code

---
 src/class183/{Code05_Tree1.java => Code03_Tree1.java}           | 2 +-
 .../{Code06_CloseVertices1.java => Code04_CloseVertices1.java}  | 2 +-
 src/class183/{Code03_Message1.java => Code05_Message1.java}     | 2 +-
 src/class183/{Code04_Capital1.java => Code06_Capital1.java}     | 2 +-
 4 files changed, 4 insertions(+), 4 deletions(-)
 rename src/class183/{Code05_Tree1.java => Code03_Tree1.java} (99%)
 rename src/class183/{Code06_CloseVertices1.java => Code04_CloseVertices1.java} (88%)
 rename src/class183/{Code03_Message1.java => Code05_Message1.java} (99%)
 rename src/class183/{Code04_Capital1.java => Code06_Capital1.java} (99%)

diff --git a/src/class183/Code05_Tree1.java b/src/class183/Code03_Tree1.java
similarity index 99%
rename from src/class183/Code05_Tree1.java
rename to src/class183/Code03_Tree1.java
index 490781356..ebc3b6abd 100644
--- a/src/class183/Code05_Tree1.java
+++ b/src/class183/Code03_Tree1.java
@@ -10,7 +10,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code05_Tree1 {
+public class Code03_Tree1 {
 
 	public static int MAXN = 50001;
 	public static int n, k, total;
diff --git a/src/class183/Code06_CloseVertices1.java b/src/class183/Code04_CloseVertices1.java
similarity index 88%
rename from src/class183/Code06_CloseVertices1.java
rename to src/class183/Code04_CloseVertices1.java
index 13e4c8fd3..bf50b32cc 100644
--- a/src/class183/Code06_CloseVertices1.java
+++ b/src/class183/Code04_CloseVertices1.java
@@ -5,6 +5,6 @@
 // 测试链接 : https://codeforces.com/problemset/problem/293/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
-public class Code06_CloseVertices1 {
+public class Code04_CloseVertices1 {
 
 }
diff --git a/src/class183/Code03_Message1.java b/src/class183/Code05_Message1.java
similarity index 99%
rename from src/class183/Code03_Message1.java
rename to src/class183/Code05_Message1.java
index 970c0be66..1195e1012 100644
--- a/src/class183/Code03_Message1.java
+++ b/src/class183/Code05_Message1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code03_Message1 {
+public class Code05_Message1 {
 
 	public static int MAXN = 100001;
 	public static int t, n, m, total;
diff --git a/src/class183/Code04_Capital1.java b/src/class183/Code06_Capital1.java
similarity index 99%
rename from src/class183/Code04_Capital1.java
rename to src/class183/Code06_Capital1.java
index 438ff2411..17bea0022 100644
--- a/src/class183/Code04_Capital1.java
+++ b/src/class183/Code06_Capital1.java
@@ -9,7 +9,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_Capital1 {
+public class Code06_Capital1 {
 
 	public static int MAXN = 200001;
 	public static int INF = 1000000001;

From 3f5d0003666ee780bd1d7d6a5ead2cb00c14bd76 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 17:29:42 +0800
Subject: [PATCH 1678/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        |  37 +++--
 .../Code01_CentroidDecomposition2.java        | 142 ------------------
 src/class183/Code03_Tree1.java                |  17 +--
 3 files changed, 24 insertions(+), 172 deletions(-)
 delete mode 100644 src/class183/Code01_CentroidDecomposition2.java

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 223bda2fb..da92b8841 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -28,11 +28,10 @@ public class Code01_CentroidDecomposition1 {
 	public static int[] maxPart = new int[MAXN];
 	public static int centroid;
 
-	public static int[] dis = new int[MAXN];
-	public static int[] arr = new int[MAXN];
-	public static int[] que = new int[MAXN];
+	public static int[] curDis = new int[MAXN];
+	public static int[] allDis = new int[MAXN];
 	public static boolean[] check = new boolean[MAXV];
-	public static int cnta, cntq;
+	public static int cntc, cnta;
 
 	public static boolean[] ans = new boolean[MAXM];
 
@@ -60,44 +59,42 @@ public static void getCentroid(int u, int fa) {
 		}
 	}
 
-	public static void dfs(int u, int fa, int w) {
-		dis[u] = dis[fa] + w;
-		if (dis[u] > maxq) {
+	public static void dfs(int u, int fa, int dis) {
+		if (dis > maxq) {
 			return;
 		}
-		arr[++cnta] = dis[u];
+		curDis[++cntc] = dis;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				dfs(v, u, weight[e]);
+				dfs(v, u, dis + weight[e]);
 			}
 		}
 	}
 
 	public static void calc(int u) {
-		dis[u] = 0;
-		cntq = 0;
+		cnta = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			int w = weight[e];
 			if (!vis[v]) {
-				cnta = 0;
+				cntc = 0;
 				dfs(v, u, w);
 				for (int i = 1; i <= m; i++) {
-					for (int j = 1; j <= cnta; j++) {
-						if (query[i] - arr[j] >= 0) {
-							ans[i] |= check[query[i] - arr[j]];
+					for (int j = 1; j <= cntc; j++) {
+						if (query[i] - curDis[j] >= 0) {
+							ans[i] |= check[query[i] - curDis[j]];
 						}
 					}
 				}
-				for (int i = 1; i <= cnta; i++) {
-					que[++cntq] = arr[i];
-					check[arr[i]] = true;
+				for (int i = 1; i <= cntc; i++) {
+					allDis[++cnta] = curDis[i];
+					check[curDis[i]] = true;
 				}
 			}
 		}
-		for (int i = 1; i <= cntq; i++) {
-			check[que[i]] = false;
+		for (int i = 1; i <= cnta; i++) {
+			check[allDis[i]] = false;
 		}
 	}
 
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
deleted file mode 100644
index 22095c985..000000000
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ /dev/null
@@ -1,142 +0,0 @@
-package class183;
-
-// 点分治，也叫重心分解，C++版
-// 测试链接 : https://www.luogu.com.cn/problem/P3806
-// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
-// 提交如下代码，可以通过所有测试用例
-
-//#include <bits/stdc++.h>
-//
-//using namespace std;
-//
-//const int MAXN = 10001;
-//const int MAXM = 101;
-//const int MAXV = 10000001;
-//int n, m, maxq, total;
-//int query[MAXM];
-//
-//int head[MAXN];
-//int nxt[MAXN << 1];
-//int to[MAXN << 1];
-//int weight[MAXN << 1];
-//int cntg;
-//
-//bool vis[MAXN];
-//int siz[MAXN];
-//int maxPart[MAXN];
-//int centroid;
-//
-//int dis[MAXN];
-//int arr[MAXN];
-//int que[MAXN];
-//bool check[MAXV];
-//int cnta, cntq;
-//
-//bool ans[MAXM];
-//
-//void addEdge(int u, int v, int w) {
-//    nxt[++cntg] = head[u];
-//    to[cntg] = v;
-//    weight[cntg] = w;
-//    head[u] = cntg;
-//}
-//
-//void getCentroid(int u, int fa) {
-//    siz[u] = 1;
-//    maxPart[u] = 0;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
-//        }
-//    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
-//    }
-//}
-//
-//void dfs(int u, int fa, int w) {
-//    dis[u] = dis[fa] + w;
-//    if (dis[u] > maxq) {
-//        return;
-//    }
-//    arr[++cnta] = dis[u];
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        if (v != fa && !vis[v]) {
-//            dfs(v, u, weight[e]);
-//        }
-//    }
-//}
-//
-//void calc(int u) {
-//    dis[u] = 0;
-//    cntq = 0;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        int w = weight[e];
-//        if (!vis[v]) {
-//            cnta = 0;
-//            dfs(v, u, w);
-//            for (int i = 1; i <= m; i++) {
-//                for (int j = 1; j <= cnta; j++) {
-//                    if (query[i] - arr[j] >= 0) {
-//                        ans[i] |= check[query[i] - arr[j]];
-//                    }
-//                }
-//            }
-//            for (int i = 1; i <= cnta; i++) {
-//                que[++cntq] = arr[i];
-//                check[arr[i]] = true;
-//            }
-//        }
-//    }
-//    for (int i = 1; i <= cntq; i++) {
-//        check[que[i]] = false;
-//    }
-//}
-//
-//void solve(int u) {
-//    vis[u] = true;
-//    check[0] = true;
-//    calc(u);
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
-//        int v = to[e];
-//        if (!vis[v]) {
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, u);
-//            solve(centroid);
-//        }
-//    }
-//}
-//
-//int main() {
-//    ios::sync_with_stdio(false);
-//    cin.tie(nullptr);
-//    cin >> n >> m;
-//    for (int i = 1, u, v, w; i < n; i++) {
-//        cin >> u >> v >> w;
-//        addEdge(u, v, w);
-//        addEdge(v, u, w);
-//    }
-//    for (int i = 1; i <= m; i++) {
-//        cin >> query[i];
-//        maxq = max(maxq, query[i]);
-//    }
-//    total = n;
-//    centroid = 0;
-//    getCentroid(1, 0);
-//    solve(centroid);
-//    for (int i = 1; i <= m; i++) {
-//        if (ans[i]) {
-//            cout << "AYE" << '\n';
-//        } else {
-//            cout << "NAY" << '\n';
-//        }
-//    }
-//    return 0;
-//}
\ No newline at end of file
diff --git a/src/class183/Code03_Tree1.java b/src/class183/Code03_Tree1.java
index ebc3b6abd..ef598f249 100644
--- a/src/class183/Code03_Tree1.java
+++ b/src/class183/Code03_Tree1.java
@@ -26,8 +26,7 @@ public class Code03_Tree1 {
 	public static int[] maxPart = new int[MAXN];
 	public static int centroid;
 
-	public static int[] dis = new int[MAXN];
-	public static int[] arr = new int[MAXN];
+	public static int[] disArr = new int[MAXN];
 	public static int cnta;
 
 	public static void addEdge(int u, int v, int w) {
@@ -54,28 +53,26 @@ public static void getCentroid(int u, int fa) {
 		}
 	}
 
-	public static void dfs(int u, int fa, int w) {
-		dis[u] = dis[fa] + w;
-		if (dis[u] > k) {
+	public static void dfs(int u, int fa, int dis) {
+		if (dis > k) {
 			return;
 		}
-		arr[++cnta] = dis[u];
+		disArr[++cnta] = dis;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				dfs(v, u, weight[e]);
+				dfs(v, u, dis + weight[e]);
 			}
 		}
 	}
 
 	public static long calc(int u, int fa, int w) {
-		dis[fa] = 0;
 		cnta = 0;
 		dfs(u, fa, w);
 		long ans = 0;
-		Arrays.sort(arr, 1, cnta + 1);
+		Arrays.sort(disArr, 1, cnta + 1);
 		for (int l = 1, r = cnta; l < r;) {
-			if (arr[l] + arr[r] <= k) {
+			if (disArr[l] + disArr[r] <= k) {
 				ans += r - l;
 				l++;
 			} else {

From 1c36d89914e9e54c1907d2bba885e20a79c678bf Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 17:44:01 +0800
Subject: [PATCH 1679/1712] modify code

---
 src/class183/Code05_Message1.java | 57 +++++++++++++++----------------
 1 file changed, 28 insertions(+), 29 deletions(-)

diff --git a/src/class183/Code05_Message1.java b/src/class183/Code05_Message1.java
index 1195e1012..2adf13692 100644
--- a/src/class183/Code05_Message1.java
+++ b/src/class183/Code05_Message1.java
@@ -30,7 +30,6 @@ public class Code05_Message1 {
 	public static int[] maxPart = new int[MAXN];
 	public static int centroid;
 
-	public static int[] dep = new int[MAXN];
 	public static int[] depCnt = new int[MAXN];
 	public static int maxDeep;
 
@@ -41,13 +40,14 @@ public class Code05_Message1 {
 	public static int[] ans = new int[MAXN];
 
 	// 讲解118，递归函数改成迭代所需要的栈
-	public static int[][] stack = new int[MAXN][3];
-	public static int stacksize, u, f, e;
+	public static int[][] stack = new int[MAXN][4];
+	public static int stacksize, u, f, dep, e;
 
-	public static void push(int u, int f, int e) {
+	public static void push(int u, int f, int dep, int e) {
 		stack[stacksize][0] = u;
 		stack[stacksize][1] = f;
-		stack[stacksize][2] = e;
+		stack[stacksize][2] = dep;
+		stack[stacksize][3] = e;
 		stacksize++;
 	}
 
@@ -55,7 +55,8 @@ public static void pop() {
 		--stacksize;
 		u = stack[stacksize][0];
 		f = stack[stacksize][1];
-		e = stack[stacksize][2];
+		dep = stack[stacksize][2];
+		e = stack[stacksize][3];
 	}
 
 	public static void addEdge(int u, int v) {
@@ -92,7 +93,7 @@ public static void getCentroid1(int u, int fa) {
 	// 找重心的迭代版
 	public static void getCentroid2(int cur, int fa) {
 		stacksize = 0;
-		push(cur, fa, -1);
+		push(cur, fa, 0, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
@@ -103,10 +104,10 @@ public static void getCentroid2(int cur, int fa) {
 				e = nextg[e];
 			}
 			if (e != 0) {
-				push(u, f, e);
+				push(u, f, 0, e);
 				int v = tog[e];
 				if (v != f && !vis[v]) {
-					push(tog[e], u, -1);
+					push(tog[e], u, 0, -1);
 				}
 			} else {
 				for (int ei = headg[u]; ei > 0; ei = nextg[ei]) {
@@ -125,37 +126,35 @@ public static void getCentroid2(int cur, int fa) {
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
-	public static void dfs1(int u, int fa) {
-		dep[u] = dep[fa] + 1;
-		depCnt[dep[u]]++;
-		maxDeep = Math.max(maxDeep, dep[u]);
+	public static void dfs1(int u, int fa, int deep) {
+		depCnt[deep]++;
+		maxDeep = Math.max(maxDeep, deep);
 		for (int e = headq[u]; e > 0; e = nextq[e]) {
-			if (tim[e] + 1 >= dep[u]) {
-				timArr[++cnta] = tim[e] - dep[u] + 2;
+			if (tim[e] + 1 >= deep) {
+				timArr[++cnta] = tim[e] - deep + 2;
 				qidArr[cnta] = qid[e];
 			}
 		}
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (v != fa && !vis[v]) {
-				dfs1(v, u);
+				dfs1(v, u, deep + 1);
 			}
 		}
 	}
 
 	// 收集信息迭代版
-	public static void dfs2(int cur, int fa) {
+	public static void dfs2(int cur, int fa, int deep) {
 		stacksize = 0;
-		push(cur, fa, -1);
+		push(cur, fa, deep, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
-				dep[u] = dep[f] + 1;
-				depCnt[dep[u]]++;
-				maxDeep = Math.max(maxDeep, dep[u]);
+				depCnt[dep]++;
+				maxDeep = Math.max(maxDeep, dep);
 				for (int e = headq[u]; e > 0; e = nextq[e]) {
-					if (tim[e] + 1 >= dep[u]) {
-						timArr[++cnta] = tim[e] - dep[u] + 2;
+					if (tim[e] + 1 >= dep) {
+						timArr[++cnta] = tim[e] - dep + 2;
 						qidArr[cnta] = qid[e];
 					}
 				}
@@ -164,10 +163,10 @@ public static void dfs2(int cur, int fa) {
 				e = nextg[e];
 			}
 			if (e != 0) {
-				push(u, f, e);
+				push(u, f, dep, e);
 				int v = tog[e];
 				if (v != f && !vis[v]) {
-					push(tog[e], u, -1);
+					push(tog[e], u, dep + 1, -1);
 				}
 			}
 		}
@@ -176,8 +175,8 @@ public static void dfs2(int cur, int fa) {
 	public static void calc(int u) {
 		cnta = 0;
 		maxDeep = 0;
-		// dfs1(u, 0);
-		dfs2(u, 0);
+		// dfs1(u, 0, 1);
+		dfs2(u, 0, 1);
 		for (int i = 1; i <= cnta; i++) {
 			ans[qidArr[i]] += depCnt[timArr[i]];
 		}
@@ -189,8 +188,8 @@ public static void calc(int u) {
 			if (!vis[v]) {
 				cnta = 0;
 				maxDeep = 0;
-				// dfs1(v, u);
-				dfs2(v, u);
+				// dfs1(v, u, 2);
+				dfs2(v, u, 2);
 				for (int i = 1; i <= cnta; i++) {
 					ans[qidArr[i]] -= depCnt[timArr[i]];
 				}

From ea1306d728f17599f2c87898f77a3816f34bd6d5 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 17:45:27 +0800
Subject: [PATCH 1680/1712] modify code

---
 src/class183/Code07_Maschera1.java | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code07_Maschera1.java
index 340cdcb95..7141b05f3 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -27,14 +27,14 @@ public class Code07_Maschera1 {
 	public static int[] maxPart = new int[MAXN];
 	public static int centroid;
 
-	public static int[] allMaxv = new int[MAXN];
-	public static int[] allEdge = new int[MAXN];
-	public static int cnta;
-
 	public static int[] curMaxv = new int[MAXN];
 	public static int[] curEdge = new int[MAXN];
 	public static int cntc;
 
+	public static int[] allMaxv = new int[MAXN];
+	public static int[] allEdge = new int[MAXN];
+	public static int cnta;
+
 	public static long ans;
 
 	// 讲解118，递归函数改成迭代所需要的栈

From 0c935e13e3faa08a5a88528e992ca0a69e16bf4e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 17:47:43 +0800
Subject: [PATCH 1681/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index da92b8841..41ea99b19 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -29,9 +29,12 @@ public class Code01_CentroidDecomposition1 {
 	public static int centroid;
 
 	public static int[] curDis = new int[MAXN];
+	public static int cntc;
+
 	public static int[] allDis = new int[MAXN];
+	public static int cnta;
+
 	public static boolean[] check = new boolean[MAXV];
-	public static int cntc, cnta;
 
 	public static boolean[] ans = new boolean[MAXM];
 

From 64ea7820266e413e2ac6dea7521c578c67009890 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 21:17:04 +0800
Subject: [PATCH 1682/1712] modify code

---
 src/class183/Code03_Tree1.java          |  10 +-
 src/class183/Code04_CloseVertices1.java | 195 ++++++++++++++++++++++++
 2 files changed, 200 insertions(+), 5 deletions(-)

diff --git a/src/class183/Code03_Tree1.java b/src/class183/Code03_Tree1.java
index ef598f249..afcdf6275 100644
--- a/src/class183/Code03_Tree1.java
+++ b/src/class183/Code03_Tree1.java
@@ -66,9 +66,9 @@ public static void dfs(int u, int fa, int dis) {
 		}
 	}
 
-	public static long calc(int u, int fa, int w) {
+	public static long calc(int u, int dis) {
 		cnta = 0;
-		dfs(u, fa, w);
+		dfs(u, 0, dis);
 		long ans = 0;
 		Arrays.sort(disArr, 1, cnta + 1);
 		for (int l = 1, r = cnta; l < r;) {
@@ -84,12 +84,12 @@ public static long calc(int u, int fa, int w) {
 
 	public static long solve(int u) {
 		long ans = 0;
-		ans += calc(u, 0, 0);
+		ans += calc(u, 0);
 		vis[u] = true;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				ans -= calc(v, u, weight[e]);
+				ans -= calc(v, weight[e]);
 				total = siz[v];
 				centroid = 0;
 				getCentroid(v, 0);
@@ -121,7 +121,7 @@ public static void main(String[] args) throws Exception {
 
 	// 读写工具类
 	static class FastReader {
-		private final byte[] buffer = new byte[1 << 20];
+		private final byte[] buffer = new byte[1 << 16];
 		private int ptr = 0, len = 0;
 		private final InputStream in;
 
diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code04_CloseVertices1.java
index bf50b32cc..2edc219b6 100644
--- a/src/class183/Code04_CloseVertices1.java
+++ b/src/class183/Code04_CloseVertices1.java
@@ -5,6 +5,201 @@
 // 测试链接 : https://codeforces.com/problemset/problem/293/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
 public class Code04_CloseVertices1 {
 
+	public static int MAXN = 100005;
+	public static int n, limitl, limitw, total;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cntg;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+	public static int[] maxPart = new int[MAXN];
+	public static int centroid;
+
+	public static int[] disArr = new int[MAXN];
+	public static int[] depArr = new int[MAXN];
+	public static int cnta;
+
+	public static int[] tree = new int[MAXN];
+
+	public static void addEdge(int u, int v, int w) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	public static int lowbit(int i) {
+		return i & -i;
+	}
+
+	public static void add(int i, int v) {
+		while (i <= n + 1) {
+			tree[i] += v;
+			i += lowbit(i);
+		}
+	}
+
+	public static int sum(int i) {
+		int ret = 0;
+		while (i > 0) {
+			ret += tree[i];
+			i -= lowbit(i);
+		}
+		return ret;
+	}
+
+	public static void getCentroid(int u, int fa) {
+		siz[u] = 1;
+		maxPart[u] = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				getCentroid(v, u);
+				siz[u] += siz[v];
+				maxPart[u] = Math.max(siz[v], maxPart[u]);
+			}
+		}
+		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
+		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+			centroid = u;
+		}
+	}
+
+	public static void dfs(int u, int fa, int dis, int dep) {
+		if (dis > limitw || dep > limitl + 1) {
+			return;
+		}
+		disArr[++cnta] = dis;
+		depArr[cnta] = dep;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				dfs(v, u, dis + weight[e], dep + 1);
+			}
+		}
+	}
+
+	public static void sort(int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r, pivot = disArr[(l + r) >> 1], tmp;
+		while (i <= j) {
+			while (disArr[i] < pivot) i++;
+			while (disArr[j] > pivot) j--;
+			if (i <= j) {
+				tmp = disArr[i]; disArr[i] = disArr[j]; disArr[j] = tmp;
+				tmp = depArr[i]; depArr[i] = depArr[j]; depArr[j] = tmp;
+				i++; j--;
+			}
+		}
+		sort(l, j);
+		sort(i, r);
+	}
+
+	public static long calc(int u, int dis, int dep) {
+		cnta = 0;
+		dfs(u, 0, dis, dep);
+		sort(1, cnta);
+		for (int i = 1; i <= cnta; i++) {
+			add(depArr[i], 1);
+		}
+		long ret = 0;
+		for (int l = 1, r = cnta; l <= r;) {
+			if (disArr[l] + disArr[r] <= limitw) {
+				add(depArr[l], -1);
+				ret += sum(limitl - depArr[l] + 2);
+				l++;
+			} else {
+				add(depArr[r], -1);
+				r--;
+			}
+		}
+		return ret;
+	}
+
+	public static long solve(int u) {
+		vis[u] = true;
+		long ans = calc(u, 0, 1);
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				ans -= calc(v, weight[e], 2);
+				total = siz[v];
+				centroid = 0;
+				getCentroid(v, 0);
+				ans += solve(centroid);
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		limitl = in.nextInt();
+		limitw = in.nextInt();
+		for (int i = 2, fa, w; i <= n; i++) {
+			fa = in.nextInt();
+			w = in.nextInt();
+			addEdge(i, fa, w);
+			addEdge(fa, i, w);
+		}
+		total = n;
+		centroid = 0;
+		getCentroid(1, 0);
+		out.println(solve(centroid));
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
 }

From 342c68ee940d0c20fff8b993acf595329ffaaac7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 21:19:51 +0800
Subject: [PATCH 1683/1712] modify code

---
 src/class183/Code07_Maschera1.java | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code07_Maschera1.java
index 7141b05f3..4a9d13b8b 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -182,10 +182,10 @@ public static void dfs2(int cur, int fa, int pmaxv, int pedge) {
 
 	public static void sort(int[] maxv, int[] edge, int l, int r) {
 		if (l >= r) return;
-		int i = l, j = r, pv = maxv[(l + r) >> 1], pe = edge[(l + r) >> 1], tmp;
+		int i = l, j = r, pivot = maxv[(l + r) >> 1], tmp;
 		while (i <= j) {
-			while (maxv[i] < pv || (maxv[i] == pv && edge[i] < pe)) i++;
-			while (maxv[j] > pv || (maxv[j] == pv && edge[j] > pe)) j--;
+			while (maxv[i] < pivot) i++;
+			while (maxv[j] > pivot) j--;
 			if (i <= j) {
 				tmp = maxv[i]; maxv[i] = maxv[j]; maxv[j] = tmp;
 				tmp = edge[i]; edge[i] = edge[j]; edge[j] = tmp;

From 8cf546a9b8dbe6232af9be06454f5eda875a2cc2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Wed, 12 Nov 2025 21:29:01 +0800
Subject: [PATCH 1684/1712] modify code

---
 src/class183/Code04_CloseVertices1.java | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code04_CloseVertices1.java
index 2edc219b6..f5856a2bc 100644
--- a/src/class183/Code04_CloseVertices1.java
+++ b/src/class183/Code04_CloseVertices1.java
@@ -44,7 +44,7 @@ public static int lowbit(int i) {
 	}
 
 	public static void add(int i, int v) {
-		while (i <= n + 1) {
+		while (i <= limitl + 1) {
 			tree[i] += v;
 			i += lowbit(i);
 		}

From 7b3c45e6d628f2bdb91abdd15c176b251dba2dc2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 10:25:07 +0800
Subject: [PATCH 1685/1712] modify code

---
 src/class183/Code04_CloseVertices1.java | 32 ++++++++++++-------------
 src/class183/Code05_Message1.java       | 24 +++++++++----------
 src/class183/Code07_Maschera1.java      | 32 ++++++++++++-------------
 3 files changed, 44 insertions(+), 44 deletions(-)

diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code04_CloseVertices1.java
index f5856a2bc..418761748 100644
--- a/src/class183/Code04_CloseVertices1.java
+++ b/src/class183/Code04_CloseVertices1.java
@@ -32,6 +32,22 @@ public class Code04_CloseVertices1 {
 
 	public static int[] tree = new int[MAXN];
 
+	public static void sort(int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r, pivot = disArr[(l + r) >> 1], tmp;
+		while (i <= j) {
+			while (disArr[i] < pivot) i++;
+			while (disArr[j] > pivot) j--;
+			if (i <= j) {
+				tmp = disArr[i]; disArr[i] = disArr[j]; disArr[j] = tmp;
+				tmp = depArr[i]; depArr[i] = depArr[j]; depArr[j] = tmp;
+				i++; j--;
+			}
+		}
+		sort(l, j);
+		sort(i, r);
+	}
+
 	public static void addEdge(int u, int v, int w) {
 		nxt[++cntg] = head[u];
 		to[cntg] = v;
@@ -90,22 +106,6 @@ public static void dfs(int u, int fa, int dis, int dep) {
 		}
 	}
 
-	public static void sort(int l, int r) {
-		if (l >= r) return;
-		int i = l, j = r, pivot = disArr[(l + r) >> 1], tmp;
-		while (i <= j) {
-			while (disArr[i] < pivot) i++;
-			while (disArr[j] > pivot) j--;
-			if (i <= j) {
-				tmp = disArr[i]; disArr[i] = disArr[j]; disArr[j] = tmp;
-				tmp = depArr[i]; depArr[i] = depArr[j]; depArr[j] = tmp;
-				i++; j--;
-			}
-		}
-		sort(l, j);
-		sort(i, r);
-	}
-
 	public static long calc(int u, int dis, int dep) {
 		cnta = 0;
 		dfs(u, 0, dis, dep);
diff --git a/src/class183/Code05_Message1.java b/src/class183/Code05_Message1.java
index 2adf13692..c996c3ef3 100644
--- a/src/class183/Code05_Message1.java
+++ b/src/class183/Code05_Message1.java
@@ -31,7 +31,7 @@ public class Code05_Message1 {
 	public static int centroid;
 
 	public static int[] depCnt = new int[MAXN];
-	public static int maxDeep;
+	public static int maxDep;
 
 	public static int[] timArr = new int[MAXN];
 	public static int[] qidArr = new int[MAXN];
@@ -126,19 +126,19 @@ public static void getCentroid2(int cur, int fa) {
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
-	public static void dfs1(int u, int fa, int deep) {
-		depCnt[deep]++;
-		maxDeep = Math.max(maxDeep, deep);
+	public static void dfs1(int u, int fa, int dep) {
+		depCnt[dep]++;
+		maxDep = Math.max(maxDep, dep);
 		for (int e = headq[u]; e > 0; e = nextq[e]) {
-			if (tim[e] + 1 >= deep) {
-				timArr[++cnta] = tim[e] - deep + 2;
+			if (tim[e] + 1 >= dep) {
+				timArr[++cnta] = tim[e] - dep + 2;
 				qidArr[cnta] = qid[e];
 			}
 		}
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (v != fa && !vis[v]) {
-				dfs1(v, u, deep + 1);
+				dfs1(v, u, dep + 1);
 			}
 		}
 	}
@@ -151,7 +151,7 @@ public static void dfs2(int cur, int fa, int deep) {
 			pop();
 			if (e == -1) {
 				depCnt[dep]++;
-				maxDeep = Math.max(maxDeep, dep);
+				maxDep = Math.max(maxDep, dep);
 				for (int e = headq[u]; e > 0; e = nextq[e]) {
 					if (tim[e] + 1 >= dep) {
 						timArr[++cnta] = tim[e] - dep + 2;
@@ -174,26 +174,26 @@ public static void dfs2(int cur, int fa, int deep) {
 
 	public static void calc(int u) {
 		cnta = 0;
-		maxDeep = 0;
+		maxDep = 0;
 		// dfs1(u, 0, 1);
 		dfs2(u, 0, 1);
 		for (int i = 1; i <= cnta; i++) {
 			ans[qidArr[i]] += depCnt[timArr[i]];
 		}
-		for (int d = 1; d <= maxDeep; d++) {
+		for (int d = 1; d <= maxDep; d++) {
 			depCnt[d] = 0;
 		}
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (!vis[v]) {
 				cnta = 0;
-				maxDeep = 0;
+				maxDep = 0;
 				// dfs1(v, u, 2);
 				dfs2(v, u, 2);
 				for (int i = 1; i <= cnta; i++) {
 					ans[qidArr[i]] -= depCnt[timArr[i]];
 				}
-				for (int d = 1; d <= maxDeep; d++) {
+				for (int d = 1; d <= maxDep; d++) {
 					depCnt[d] = 0;
 				}
 			}
diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code07_Maschera1.java
index 4a9d13b8b..18004cc7a 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -59,6 +59,22 @@ public static void pop() {
 		e = stack[stacksize][4];
 	}
 
+	public static void sort(int[] maxv, int[] edge, int l, int r) {
+		if (l >= r) return;
+		int i = l, j = r, pivot = maxv[(l + r) >> 1], tmp;
+		while (i <= j) {
+			while (maxv[i] < pivot) i++;
+			while (maxv[j] > pivot) j--;
+			if (i <= j) {
+				tmp = maxv[i]; maxv[i] = maxv[j]; maxv[j] = tmp;
+				tmp = edge[i]; edge[i] = edge[j]; edge[j] = tmp;
+				i++; j--;
+			}
+		}
+		sort(maxv, edge, l, j);
+		sort(maxv, edge, i, r);
+	}
+
 	public static void addEdge(int u, int v, int w) {
 		nxt[++cntg] = head[u];
 		to[cntg] = v;
@@ -180,22 +196,6 @@ public static void dfs2(int cur, int fa, int pmaxv, int pedge) {
 		}
 	}
 
-	public static void sort(int[] maxv, int[] edge, int l, int r) {
-		if (l >= r) return;
-		int i = l, j = r, pivot = maxv[(l + r) >> 1], tmp;
-		while (i <= j) {
-			while (maxv[i] < pivot) i++;
-			while (maxv[j] > pivot) j--;
-			if (i <= j) {
-				tmp = maxv[i]; maxv[i] = maxv[j]; maxv[j] = tmp;
-				tmp = edge[i]; edge[i] = edge[j]; edge[j] = tmp;
-				i++; j--;
-			}
-		}
-		sort(maxv, edge, l, j);
-		sort(maxv, edge, i, r);
-	}
-
 	public static void calc(int u) {
 		cnta = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {

From c3feaa1d85bcf7101a6f2c78b954b57d317e798c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 10:34:58 +0800
Subject: [PATCH 1686/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 9 ++++++++-
 src/class183/Code02_Race1.java                  | 3 ++-
 src/class183/Code02_Race2.java                  | 3 ++-
 src/class183/Code03_Tree1.java                  | 3 ++-
 src/class183/Code04_CloseVertices1.java         | 3 ++-
 src/class183/Code05_Message1.java               | 3 ++-
 src/class183/Code06_Capital1.java               | 3 ++-
 src/class183/Code07_Maschera1.java              | 7 ++++---
 8 files changed, 24 insertions(+), 10 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 41ea99b19..a1d6d08de 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -1,6 +1,10 @@
 package class183;
 
 // 点分治，也叫重心分解，java版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 一共有m条查询，每条查询给定一个数字k，打印树上距离为k的点对是否存在
+// 1 <= n <= 10^4    1 <= 边权 <= 10^4
+// 1 <= m <= 100     1 <= k <= 10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P3806
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -14,8 +18,10 @@ public class Code01_CentroidDecomposition1 {
 	public static int MAXN = 10001;
 	public static int MAXM = 101;
 	public static int MAXV = 10000001;
-	public static int n, m, maxq, total;
+	public static int n, m;
+
 	public static int[] query = new int[MAXM];
+	public static int maxq;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -26,6 +32,7 @@ public class Code01_CentroidDecomposition1 {
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] maxPart = new int[MAXN];
+	public static int total;
 	public static int centroid;
 
 	public static int[] curDis = new int[MAXN];
diff --git a/src/class183/Code02_Race1.java b/src/class183/Code02_Race1.java
index 1620e6392..e82ace6d5 100644
--- a/src/class183/Code02_Race1.java
+++ b/src/class183/Code02_Race1.java
@@ -15,7 +15,7 @@ public class Code02_Race1 {
 	public static int MAXN = 200001;
 	public static int MAXK = 1000001;
 	public static int INF = 1000000001;
-	public static int n, k, total;
+	public static int n, k;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -26,6 +26,7 @@ public class Code02_Race1 {
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] maxPart = new int[MAXN];
+	public static int total;
 	public static int centroid;
 
 	public static int[] sumArr = new int[MAXN];
diff --git a/src/class183/Code02_Race2.java b/src/class183/Code02_Race2.java
index 2f91e1f11..f44b9e3e1 100644
--- a/src/class183/Code02_Race2.java
+++ b/src/class183/Code02_Race2.java
@@ -12,7 +12,7 @@
 //const int MAXN = 200001;
 //const int MAXK = 1000001;
 //const int INF = 1000000001;
-//int n, k, total;
+//int n, k;
 //
 //int head[MAXN];
 //int nxt[MAXN << 1];
@@ -23,6 +23,7 @@
 //bool vis[MAXN];
 //int siz[MAXN];
 //int maxPart[MAXN];
+//int total;
 //int centroid;
 //
 //int sumArr[MAXN];
diff --git a/src/class183/Code03_Tree1.java b/src/class183/Code03_Tree1.java
index afcdf6275..3a7b3db9d 100644
--- a/src/class183/Code03_Tree1.java
+++ b/src/class183/Code03_Tree1.java
@@ -13,7 +13,7 @@
 public class Code03_Tree1 {
 
 	public static int MAXN = 50001;
-	public static int n, k, total;
+	public static int n, k;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -24,6 +24,7 @@ public class Code03_Tree1 {
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] maxPart = new int[MAXN];
+	public static int total;
 	public static int centroid;
 
 	public static int[] disArr = new int[MAXN];
diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code04_CloseVertices1.java
index 418761748..b47dd3eca 100644
--- a/src/class183/Code04_CloseVertices1.java
+++ b/src/class183/Code04_CloseVertices1.java
@@ -13,7 +13,7 @@
 public class Code04_CloseVertices1 {
 
 	public static int MAXN = 100005;
-	public static int n, limitl, limitw, total;
+	public static int n, limitl, limitw;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -24,6 +24,7 @@ public class Code04_CloseVertices1 {
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] maxPart = new int[MAXN];
+	public static int total;
 	public static int centroid;
 
 	public static int[] disArr = new int[MAXN];
diff --git a/src/class183/Code05_Message1.java b/src/class183/Code05_Message1.java
index c996c3ef3..0f69122cf 100644
--- a/src/class183/Code05_Message1.java
+++ b/src/class183/Code05_Message1.java
@@ -12,7 +12,7 @@
 public class Code05_Message1 {
 
 	public static int MAXN = 100001;
-	public static int t, n, m, total;
+	public static int t, n, m;
 
 	public static int[] headg = new int[MAXN];
 	public static int[] nextg = new int[MAXN << 1];
@@ -28,6 +28,7 @@ public class Code05_Message1 {
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] maxPart = new int[MAXN];
+	public static int total;
 	public static int centroid;
 
 	public static int[] depCnt = new int[MAXN];
diff --git a/src/class183/Code06_Capital1.java b/src/class183/Code06_Capital1.java
index 17bea0022..3edb97e8d 100644
--- a/src/class183/Code06_Capital1.java
+++ b/src/class183/Code06_Capital1.java
@@ -13,7 +13,7 @@ public class Code06_Capital1 {
 
 	public static int MAXN = 200001;
 	public static int INF = 1000000001;
-	public static int n, k, total;
+	public static int n, k;
 	public static int[] color = new int[MAXN];
 
 	public static int[] headg = new int[MAXN];
@@ -29,6 +29,7 @@ public class Code06_Capital1 {
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] maxPart = new int[MAXN];
+	public static int total;
 	public static int centroid;
 
 	public static int[] father = new int[MAXN];
diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code07_Maschera1.java
index 18004cc7a..6da67b883 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -12,7 +12,7 @@
 public class Code07_Maschera1 {
 
 	public static int MAXN = 100001;
-	public static int n, l, r, total;
+	public static int n, l, r;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -20,11 +20,10 @@ public class Code07_Maschera1 {
 	public static int[] weight = new int[MAXN << 1];
 	public static int cntg;
 
-	public static int[] tree = new int[MAXN];
-
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 	public static int[] maxPart = new int[MAXN];
+	public static int total;
 	public static int centroid;
 
 	public static int[] curMaxv = new int[MAXN];
@@ -35,6 +34,8 @@ public class Code07_Maschera1 {
 	public static int[] allEdge = new int[MAXN];
 	public static int cnta;
 
+	public static int[] tree = new int[MAXN];
+
 	public static long ans;
 
 	// 讲解118，递归函数改成迭代所需要的栈

From 0848f33e99f3fc40387f574e899641e83964ee88 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 10:47:57 +0800
Subject: [PATCH 1687/1712] modify code

---
 .../Code01_CentroidDecomposition1.java        |   2 +-
 .../Code01_CentroidDecomposition2.java        | 149 ++++++++++++++++++
 2 files changed, 150 insertions(+), 1 deletion(-)
 create mode 100644 src/class183/Code01_CentroidDecomposition2.java

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index a1d6d08de..411b187a6 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -2,7 +2,7 @@
 
 // 点分治，也叫重心分解，java版
 // 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
-// 一共有m条查询，每条查询给定一个数字k，打印树上距离为k的点对是否存在
+// 一共有m条查询，每条查询给定数字k，打印树上距离为k的点对是否存在
 // 1 <= n <= 10^4    1 <= 边权 <= 10^4
 // 1 <= m <= 100     1 <= k <= 10^7
 // 测试链接 : https://www.luogu.com.cn/problem/P3806
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
new file mode 100644
index 000000000..cb1b7c376
--- /dev/null
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -0,0 +1,149 @@
+package class183;
+
+// 点分治，也叫重心分解，C++版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 一共有m条查询，每条查询给定数字k，打印树上距离为k的点对是否存在
+// 1 <= n <= 10^4    1 <= 边权 <= 10^4
+// 1 <= m <= 100     1 <= k <= 10^7
+// 测试链接 : https://www.luogu.com.cn/problem/P3806
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 10001;
+//const int MAXM = 101;
+//const int MAXV = 10000001;
+//int n, m;
+//
+//int query[MAXM];
+//int maxq;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxPart[MAXN];
+//int total;
+//int centroid;
+//
+//int curDis[MAXN];
+//int cntc;
+//
+//int allDis[MAXN];
+//int cnta;
+//
+//bool check[MAXV];
+//
+//bool ans[MAXM];
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxPart[u] = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxPart[u] = max(maxPart[u], siz[v]);
+//        }
+//    }
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void dfs(int u, int fa, int dis) {
+//    if (dis > maxq) {
+//        return;
+//    }
+//    curDis[++cntc] = dis;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            dfs(v, u, dis + weight[e]);
+//        }
+//    }
+//}
+//
+//void calc(int u) {
+//    cnta = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        int w = weight[e];
+//        if (!vis[v]) {
+//            cntc = 0;
+//            dfs(v, u, w);
+//            for (int i = 1; i <= m; i++) {
+//                for (int j = 1; j <= cntc; j++) {
+//                    if (query[i] - curDis[j] >= 0) {
+//                        ans[i] |= check[query[i] - curDis[j]];
+//                    }
+//                }
+//            }
+//            for (int i = 1; i <= cntc; i++) {
+//                allDis[++cnta] = curDis[i];
+//                check[curDis[i]] = true;
+//            }
+//        }
+//    }
+//    for (int i = 1; i <= cnta; i++) {
+//        check[allDis[i]] = false;
+//    }
+//}
+//
+//void solve(int u) {
+//    vis[u] = true;
+//    check[0] = true;
+//    calc(u);
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            total = siz[v];
+//            centroid = 0;
+//            getCentroid(v, u);
+//            solve(centroid);
+//        }
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> m;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        addEdge(u, v, w);
+//        addEdge(v, u, w);
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        cin >> query[i];
+//        maxq = max(maxq, query[i]);
+//    }
+//    total = n;
+//    centroid = 0;
+//    getCentroid(1, 0);
+//    solve(centroid);
+//    for (int i = 1; i <= m; i++) {
+//        if (ans[i]) {
+//            cout << "AYE" << '\n';
+//        } else {
+//            cout << "NAY" << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From c2a6d3c7503255953fea53209b92e20b04da7791 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 11:17:27 +0800
Subject: [PATCH 1688/1712] modify code

---
 src/class183/Code02_Race1.java | 41 +++++++++++++++++++---------------
 src/class183/Code02_Race2.java | 27 +++++++++++++---------
 2 files changed, 40 insertions(+), 28 deletions(-)

diff --git a/src/class183/Code02_Race1.java b/src/class183/Code02_Race1.java
index e82ace6d5..d12b53e83 100644
--- a/src/class183/Code02_Race1.java
+++ b/src/class183/Code02_Race1.java
@@ -1,6 +1,11 @@
 package class183;
 
 // 权值和为k的路径的最少边数，java版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 给定数字k，要求路径权值和等于k，并且边的数量最小
+// 打印最小边数，如果不存在路径打印-1，注意点的编号从0开始
+// 1 <= n <= 2 * 10^5
+// 0 <= 边权、k <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P4149
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -29,7 +34,7 @@ public class Code02_Race1 {
 	public static int total;
 	public static int centroid;
 
-	public static int[] sumArr = new int[MAXN];
+	public static int[] disArr = new int[MAXN];
 	public static int[] edgeArr = new int[MAXN];
 	public static int cnta;
 
@@ -37,12 +42,12 @@ public class Code02_Race1 {
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][5];
-	public static int stacksize, u, f, sum, edge, e;
+	public static int stacksize, u, f, dis, edge, e;
 
-	public static void push(int u, int f, int sum, int edge, int e) {
+	public static void push(int u, int f, int dis, int edge, int e) {
 		stack[stacksize][0] = u;
 		stack[stacksize][1] = f;
-		stack[stacksize][2] = sum;
+		stack[stacksize][2] = dis;
 		stack[stacksize][3] = edge;
 		stack[stacksize][4] = e;
 		stacksize++;
@@ -52,7 +57,7 @@ public static void pop() {
 		--stacksize;
 		u = stack[stacksize][0];
 		f = stack[stacksize][1];
-		sum = stack[stacksize][2];
+		dis = stack[stacksize][2];
 		edge = stack[stacksize][3];
 		e = stack[stacksize][4];
 	}
@@ -118,41 +123,41 @@ public static void getCentroid2(int cur, int fa) {
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
-	public static void dfs1(int u, int fa, int sum, int edge) {
-		if (sum > k) {
+	public static void dfs1(int u, int fa, int dis, int edge) {
+		if (dis > k) {
 			return;
 		}
-		sumArr[++cnta] = sum;
+		disArr[++cnta] = dis;
 		edgeArr[cnta] = edge;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				dfs1(v, u, sum + weight[e], edge + 1);
+				dfs1(v, u, dis + weight[e], edge + 1);
 			}
 		}
 	}
 
 	// 收集信息的迭代版
-	public static void dfs2(int cur, int fa, int psum, int pedge) {
+	public static void dfs2(int cur, int fa, int pathDis, int pathEdge) {
 		stacksize = 0;
-		push(cur, fa, psum, pedge, -1);
+		push(cur, fa, pathDis, pathEdge, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
-				if (sum > k) {
+				if (dis > k) {
 					continue;
 				}
-				sumArr[++cnta] = sum;
+				disArr[++cnta] = dis;
 				edgeArr[cnta] = edge;
 				e = head[u];
 			} else {
 				e = nxt[e];
 			}
 			if (e != 0) {
-				push(u, f, sum, edge, e);
+				push(u, f, dis, edge, e);
 				int v = to[e];
 				if (v != f && !vis[v]) {
-					push(to[e], u, sum + weight[e], edge + 1, -1);
+					push(to[e], u, dis + weight[e], edge + 1, -1);
 				}
 			}
 		}
@@ -169,15 +174,15 @@ public static int calc(int u) {
 				// dfs1(v, u, weight[e], 1);
 				dfs2(v, u, weight[e], 1);
 				for (int i = tmp + 1; i <= cnta; i++) {
-					ans = Math.min(ans, dp[k - sumArr[i]] + edgeArr[i]);
+					ans = Math.min(ans, dp[k - disArr[i]] + edgeArr[i]);
 				}
 				for (int i = tmp + 1; i <= cnta; i++) {
-					dp[sumArr[i]] = Math.min(dp[sumArr[i]], edgeArr[i]);
+					dp[disArr[i]] = Math.min(dp[disArr[i]], edgeArr[i]);
 				}
 			}
 		}
 		for (int i = 1; i <= cnta; i++) {
-			dp[sumArr[i]] = INF;
+			dp[disArr[i]] = INF;
 		}
 		return ans;
 	}
diff --git a/src/class183/Code02_Race2.java b/src/class183/Code02_Race2.java
index f44b9e3e1..52dac82d4 100644
--- a/src/class183/Code02_Race2.java
+++ b/src/class183/Code02_Race2.java
@@ -1,6 +1,11 @@
 package class183;
 
 // 权值和为k的路径的最少边数，C++版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 给定数字k，要求路径权值和等于k，并且边的数量最小
+// 打印最小边数，如果不存在路径打印-1，注意点的编号从0开始
+// 1 <= n <= 2 * 10^5
+// 0 <= 边权、k <= 10^6
 // 测试链接 : https://www.luogu.com.cn/problem/P4149
 // 如下实现是C++的版本，C++版本和java版本逻辑完全一样
 // 提交如下代码，可以通过所有测试用例
@@ -9,6 +14,10 @@
 //
 //using namespace std;
 //
+//struct Node {
+//    int dis, edge;
+//};
+//
 //const int MAXN = 200001;
 //const int MAXK = 1000001;
 //const int INF = 1000000001;
@@ -26,8 +35,7 @@
 //int total;
 //int centroid;
 //
-//int sumArr[MAXN];
-//int edgeArr[MAXN];
+//Node arr[MAXN];
 //int cnta;
 //
 //int dp[MAXK];
@@ -56,16 +64,15 @@
 //    }
 //}
 //
-//void dfs(int u, int fa, int sum, int edge) {
-//    if (sum > k) {
+//void dfs(int u, int fa, int dis, int edge) {
+//    if (dis > k) {
 //        return;
 //    }
-//    sumArr[++cnta] = sum;
-//    edgeArr[cnta] = edge;
+//    arr[++cnta] = { dis, edge };
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            dfs(v, u, sum + weight[e], edge + 1);
+//            dfs(v, u, dis + weight[e], edge + 1);
 //        }
 //    }
 //}
@@ -80,15 +87,15 @@
 //            int tmp = cnta;
 //            dfs(v, u, weight[e], 1);
 //            for (int i = tmp + 1; i <= cnta; i++) {
-//                ans = min(ans, dp[k - sumArr[i]] + edgeArr[i]);
+//                ans = min(ans, dp[k - arr[i].dis] + arr[i].edge);
 //            }
 //            for (int i = tmp + 1; i <= cnta; i++) {
-//                dp[sumArr[i]] = min(dp[sumArr[i]], edgeArr[i]);
+//                dp[arr[i].dis] = min(dp[arr[i].dis], arr[i].edge);
 //            }
 //        }
 //    }
 //    for (int i = 1; i <= cnta; i++) {
-//        dp[sumArr[i]] = INF;
+//        dp[arr[i].dis] = INF;
 //    }
 //    return ans;
 //}

From ecb50eef8b6bd906e91f986b12c182f1a2803e7e Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 11:27:53 +0800
Subject: [PATCH 1689/1712] modify code

---
 src/class183/Code07_Maschera1.java | 76 +++++++++++++-----------------
 1 file changed, 32 insertions(+), 44 deletions(-)

diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code07_Maschera1.java
index 6da67b883..f8d9d6f26 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -12,7 +12,7 @@
 public class Code07_Maschera1 {
 
 	public static int MAXN = 100001;
-	public static int n, l, r;
+	public static int n, minEdge, maxEdge;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -88,7 +88,7 @@ public static int lowbit(int i) {
 	}
 
 	public static void add(int i, int v) {
-		while (i <= r) {
+		while (i <= maxEdge) {
 			tree[i] += v;
 			i += lowbit(i);
 		}
@@ -158,7 +158,7 @@ public static void getCentroid2(int cur, int fa) {
 
 	// 收集信息递归版，java会爆栈，C++可以通过
 	public static void dfs1(int u, int fa, int maxv, int edge) {
-		if (edge > r) {
+		if (edge > maxEdge) {
 			return;
 		}
 		curMaxv[++cntc] = maxv;
@@ -178,7 +178,7 @@ public static void dfs2(int cur, int fa, int pmaxv, int pedge) {
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
-				if (edge > r) {
+				if (edge > maxEdge) {
 					continue;
 				}
 				curMaxv[++cntc] = maxv;
@@ -205,49 +205,37 @@ public static void calc(int u) {
 				cntc = 0;
 				// dfs1(v, u, weight[e], 1);
 				dfs2(v, u, weight[e], 1);
-				if (cntc > 0) {
-					sort(curMaxv, curEdge, 1, cntc);
-					for (int i = 1; i <= cntc; i++) {
-						int left = l - curEdge[i] - 1;
-						int right = r - curEdge[i];
-						if (right >= 0) {
-							left = Math.max(left, 0);
-							right = Math.min(right, r);
-							ans -= 1L * curMaxv[i] * (sum(right) - sum(left));
-						}
-						add(curEdge[i], 1);
-					}
-					for (int i = 1; i <= cntc; i++) {
-						add(curEdge[i], -1);
-					}
-					for (int i = 1; i <= cntc; i++) {
-						allMaxv[++cnta] = curMaxv[i];
-						allEdge[cnta] = curEdge[i];
-					}
+				sort(curMaxv, curEdge, 1, cntc);
+				for (int i = 1; i <= cntc; i++) {
+					int l = minEdge - curEdge[i] - 1;
+					int r = maxEdge - curEdge[i];
+					ans -= 1L * curMaxv[i] * (sum(r) - sum(l));
+					add(curEdge[i], 1);
 				}
-			}
-		}
-		if (cnta > 0) {
-			sort(allMaxv, allEdge, 1, cnta);
-			for (int i = 1; i <= cnta; i++) {
-				int left = l - allEdge[i] - 1;
-				int right = r - allEdge[i];
-				if (right >= 0) {
-					left = Math.max(left, 0);
-					right = Math.min(right, r);
-					ans += 1L * allMaxv[i] * (sum(right) - sum(left));
+				for (int i = 1; i <= cntc; i++) {
+					add(curEdge[i], -1);
 				}
-				add(allEdge[i], 1);
-			}
-			for (int i = 1; i <= cnta; i++) {
-				add(allEdge[i], -1);
-			}
-			for (int i = 1; i <= cnta; i++) {
-				if (allEdge[i] >= l) {
-					ans += allMaxv[i];
+				for (int i = 1; i <= cntc; i++) {
+					allMaxv[++cnta] = curMaxv[i];
+					allEdge[cnta] = curEdge[i];
 				}
 			}
 		}
+		sort(allMaxv, allEdge, 1, cnta);
+		for (int i = 1; i <= cnta; i++) {
+			int l = minEdge - allEdge[i] - 1;
+			int r = maxEdge - allEdge[i];
+			ans += 1L * allMaxv[i] * (sum(r) - sum(l));
+			add(allEdge[i], 1);
+		}
+		for (int i = 1; i <= cnta; i++) {
+			add(allEdge[i], -1);
+		}
+		for (int i = 1; i <= cnta; i++) {
+			if (allEdge[i] >= minEdge) {
+				ans += allMaxv[i];
+			}
+		}
 	}
 
 	public static void solve(int u) {
@@ -269,8 +257,8 @@ public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
-		l = in.nextInt();
-		r = in.nextInt();
+		minEdge = in.nextInt();
+		maxEdge = in.nextInt();
 		for (int i = 1, u, v, w; i < n; i++) {
 			u = in.nextInt();
 			v = in.nextInt();

From 4cb88f513737c3d1b7e2dc9a580fab46029196a9 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 11:47:54 +0800
Subject: [PATCH 1690/1712] modify code

---
 src/class183/Code03_Tree1.java |   7 +-
 src/class183/Code03_Tree2.java | 120 +++++++++++++++++++++++++++++++++
 2 files changed, 126 insertions(+), 1 deletion(-)
 create mode 100644 src/class183/Code03_Tree2.java

diff --git a/src/class183/Code03_Tree1.java b/src/class183/Code03_Tree1.java
index 3a7b3db9d..a3bb57f58 100644
--- a/src/class183/Code03_Tree1.java
+++ b/src/class183/Code03_Tree1.java
@@ -1,6 +1,11 @@
 package class183;
 
 // 距离<=k的点对数量，java版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 给定数字k，求出树上两点距离<=k的点对数量
+// 1 <= n <= 4 * 10^4
+// 0 <= 边权 <= 10^3
+// 0 <= k <= 2 * 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/P4178
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -72,7 +77,7 @@ public static long calc(int u, int dis) {
 		dfs(u, 0, dis);
 		long ans = 0;
 		Arrays.sort(disArr, 1, cnta + 1);
-		for (int l = 1, r = cnta; l < r;) {
+		for (int l = 1, r = cnta; l <= r;) {
 			if (disArr[l] + disArr[r] <= k) {
 				ans += r - l;
 				l++;
diff --git a/src/class183/Code03_Tree2.java b/src/class183/Code03_Tree2.java
new file mode 100644
index 000000000..ee5813fa5
--- /dev/null
+++ b/src/class183/Code03_Tree2.java
@@ -0,0 +1,120 @@
+package class183;
+
+// 距离<=k的点对数量，C++版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 给定数字k，求出树上两点距离<=k的点对数量
+// 1 <= n <= 4 * 10^4
+// 0 <= 边权 <= 10^3
+// 0 <= k <= 2 * 10^4
+// 测试链接 : https://www.luogu.com.cn/problem/P4178
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 50001;
+//int n, k;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxPart[MAXN];
+//int total;
+//int centroid;
+//
+//int disArr[MAXN];
+//int cnta;
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxPart[u] = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxPart[u] = max(maxPart[u], siz[v]);
+//        }
+//    }
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void dfs(int u, int fa, int dis) {
+//    if (dis > k) {
+//        return;
+//    }
+//    disArr[++cnta] = dis;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            dfs(v, u, dis + weight[e]);
+//        }
+//    }
+//}
+//
+//long long calc(int u, int dis) {
+//    cnta = 0;
+//    dfs(u, 0, dis);
+//    long long ans = 0;
+//    sort(disArr + 1, disArr + cnta + 1);
+//    for (int l = 1, r = cnta; l <= r; ) {
+//        if (disArr[l] + disArr[r] <= k) {
+//            ans += r - l;
+//            l++;
+//        } else {
+//            r--;
+//        }
+//    }
+//    return ans;
+//}
+//
+//long long solve(int u) {
+//    long long ans = 0;
+//    ans += calc(u, 0);
+//    vis[u] = true;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            ans -= calc(v, weight[e]);
+//            total = siz[v];
+//            centroid = 0;
+//            getCentroid(v, 0);
+//            ans += solve(centroid);
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        addEdge(u, v, w);
+//        addEdge(v, u, w);
+//    }
+//    cin >> k;
+//    total = n;
+//    centroid = 0;
+//    getCentroid(1, 0);
+//    cout << solve(centroid) << '\n';
+//    return 0;
+//}
\ No newline at end of file

From c8f895d19644840e75f85769142763b67a78cb67 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 12:21:53 +0800
Subject: [PATCH 1691/1712] modify code

---
 src/class183/Code04_CloseVertices1.java |  12 +-
 src/class183/Code04_CloseVertices2.java | 157 ++++++++++++++++++++++++
 2 files changed, 167 insertions(+), 2 deletions(-)
 create mode 100644 src/class183/Code04_CloseVertices2.java

diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code04_CloseVertices1.java
index b47dd3eca..3b5cee60a 100644
--- a/src/class183/Code04_CloseVertices1.java
+++ b/src/class183/Code04_CloseVertices1.java
@@ -1,6 +1,14 @@
 package class183;
 
-// 相近的点对数量，java版
+// 相近点对的数量，java版
+// 一共有n个节点，所有节点组成一棵树，1号节点是树头
+// 从2号点开始，给定每个点的父节点编号、与父节点之间无向边的边权
+// 给定两个整数limitl、limitw，如下为(a, b)是相近点对的定义
+// 首先a < b，其次两者简单路径的边数不超过limitl、权值和不超过limitw
+// 打印树上有多少相近点对
+// 1 <= limitl <= n <= 10^5
+// 0 <= limitw <= 10^9
+// 0 <= 边权 <= 10^4
 // 测试链接 : https://www.luogu.com.cn/problem/CF293E
 // 测试链接 : https://codeforces.com/problemset/problem/293/E
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
@@ -12,7 +20,7 @@
 
 public class Code04_CloseVertices1 {
 
-	public static int MAXN = 100005;
+	public static int MAXN = 100002;
 	public static int n, limitl, limitw;
 
 	public static int[] head = new int[MAXN];
diff --git a/src/class183/Code04_CloseVertices2.java b/src/class183/Code04_CloseVertices2.java
new file mode 100644
index 000000000..aefdbf10c
--- /dev/null
+++ b/src/class183/Code04_CloseVertices2.java
@@ -0,0 +1,157 @@
+package class183;
+
+// 相近点对的数量，C++版
+// 一共有n个节点，所有节点组成一棵树，1号节点是树头
+// 从2号点开始，给定每个点的父节点编号、与父节点之间无向边的边权
+// 给定两个整数limitl、limitw，如下为(a, b)是相近点对的定义
+// 首先a < b，其次两者简单路径的边数不超过limitl、权值和不超过limitw
+// 打印树上有多少相近点对
+// 1 <= limitl <= n <= 10^5
+// 0 <= limitw <= 10^9
+// 0 <= 边权 <= 10^4
+// 测试链接 : https://www.luogu.com.cn/problem/CF293E
+// 测试链接 : https://codeforces.com/problemset/problem/293/E
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int dis, dep;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    return a.dis < b.dis;
+//}
+//
+//const int MAXN = 100002;
+//int n, limitl, limitw;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxPart[MAXN];
+//int total;
+//int centroid;
+//
+//Node arr[MAXN];
+//int cnta;
+//
+//int tree[MAXN];
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= limitl + 1) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxPart[u] = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxPart[u] = max(maxPart[u], siz[v]);
+//        }
+//    }
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void dfs(int u, int fa, int dis, int dep) {
+//    if (dis > limitw || dep > limitl + 1) {
+//        return;
+//    }
+//    arr[++cnta] = { dis, dep };
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            dfs(v, u, dis + weight[e], dep + 1);
+//        }
+//    }
+//}
+//
+//long long calc(int u, int dis, int dep) {
+//    cnta = 0;
+//    dfs(u, 0, dis, dep);
+//    sort(arr + 1, arr + cnta + 1, NodeCmp);
+//    for (int i = 1; i <= cnta; i++) {
+//        add(arr[i].dep, 1);
+//    }
+//    long long ret = 0;
+//    for (int l = 1, r = cnta; l <= r; ) {
+//        if (arr[l].dis + arr[r].dis <= limitw) {
+//            add(arr[l].dep, -1);
+//            ret += sum(limitl - arr[l].dep + 2);
+//            l++;
+//        } else {
+//            add(arr[r].dep, -1);
+//            r--;
+//        }
+//    }
+//    return ret;
+//}
+//
+//long long solve(int u) {
+//    vis[u] = true;
+//    long long ans = calc(u, 0, 1);
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            ans -= calc(v, weight[e], 2);
+//            total = siz[v];
+//            centroid = 0;
+//            getCentroid(v, 0);
+//            ans += solve(centroid);
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> limitl >> limitw;
+//    for (int i = 2, fa, w; i <= n; i++) {
+//        cin >> fa >> w;
+//        addEdge(i, fa, w);
+//        addEdge(fa, i, w);
+//    }
+//    total = n;
+//    centroid = 0;
+//    getCentroid(1, 0);
+//    cout << solve(centroid) << '\n';
+//    return 0;
+//}
\ No newline at end of file

From c92fb8316f970c300f9f253451cadff98fff2634 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 13:29:21 +0800
Subject: [PATCH 1692/1712] modify code

---
 src/class183/Code05_Message1.java |   6 ++
 src/class183/Code05_Message2.java | 174 ++++++++++++++++++++++++++++++
 2 files changed, 180 insertions(+)
 create mode 100644 src/class183/Code05_Message2.java

diff --git a/src/class183/Code05_Message1.java b/src/class183/Code05_Message1.java
index 0f69122cf..474ad281a 100644
--- a/src/class183/Code05_Message1.java
+++ b/src/class183/Code05_Message1.java
@@ -1,6 +1,12 @@
 package class183;
 
 // 消息传递，java版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 如果x号节点收到一个消息，那么消息会从x开始扩散，速度为每天越过一条边
+// 接下来有m条查询，每条查询都是相互独立的，格式如下
+// 查询 x k : 第0天的时候，x号节点得到一条信息，打印第k天时，新收到该消息的人数
+// 1 <= n、m <= 10^5
+// 0 <= k < n
 // 测试链接 : https://www.luogu.com.cn/problem/P6626
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
diff --git a/src/class183/Code05_Message2.java b/src/class183/Code05_Message2.java
new file mode 100644
index 000000000..1011050c7
--- /dev/null
+++ b/src/class183/Code05_Message2.java
@@ -0,0 +1,174 @@
+package class183;
+
+// 消息传递，C++版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 如果x号节点收到一个消息，那么消息会从x开始扩散，速度为每天越过一条边
+// 接下来有m条查询，每条查询都是相互独立的，格式如下
+// 查询 x k : 第0天的时候，x号节点得到一条信息，打印第k天时，新收到该消息的人数
+// 1 <= n、m <= 10^5
+// 0 <= k < n
+// 测试链接 : https://www.luogu.com.cn/problem/P6626
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int tim, qid;
+//};
+//
+//const int MAXN = 100001;
+//int t, n, m;
+//
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int cntg;
+//
+//int headq[MAXN];
+//int nextq[MAXN];
+//int tim[MAXN];
+//int qid[MAXN];
+//int cntq;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxPart[MAXN];
+//int total;
+//int centroid;
+//
+//int depCnt[MAXN];
+//int maxDep;
+//
+//Node arr[MAXN];
+//int cnta;
+//
+//int ans[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addQuery(int u, int t, int id) {
+//    nextq[++cntq] = headq[u];
+//    tim[cntq] = t;
+//    qid[cntq] = id;
+//    headq[u] = cntq;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxPart[u] = 0;
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        int v = tog[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxPart[u] = max(maxPart[u], siz[v]);
+//        }
+//    }
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void dfs(int u, int fa, int dep) {
+//    depCnt[dep]++;
+//    maxDep = max(maxDep, dep);
+//    for (int e = headq[u]; e; e = nextq[e]) {
+//        if (tim[e] + 1 >= dep) {
+//            arr[++cnta] = { tim[e] - dep + 2, qid[e] };
+//        }
+//    }
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        int v = tog[e];
+//        if (v != fa && !vis[v]) {
+//            dfs(v, u, dep + 1);
+//        }
+//    }
+//}
+//
+//void calc(int u) {
+//    cnta = 0;
+//    maxDep = 0;
+//    dfs(u, 0, 1);
+//    for (int i = 1; i <= cnta; i++) {
+//        ans[arr[i].qid] += depCnt[arr[i].tim];
+//    }
+//    for (int d = 1; d <= maxDep; d++) {
+//        depCnt[d] = 0;
+//    }
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        int v = tog[e];
+//        if (!vis[v]) {
+//            cnta = 0;
+//            maxDep = 0;
+//            dfs(v, u, 2);
+//            for (int i = 1; i <= cnta; i++) {
+//                ans[arr[i].qid] -= depCnt[arr[i].tim];
+//            }
+//            for (int d = 1; d <= maxDep; d++) {
+//                depCnt[d] = 0;
+//            }
+//        }
+//    }
+//}
+//
+//void solve(int u) {
+//    vis[u] = true;
+//    calc(u);
+//    for (int e = headg[u]; e; e = nextg[e]) {
+//        int v = tog[e];
+//        if (!vis[v]) {
+//            total = siz[v];
+//            centroid = 0;
+//            getCentroid(v, u);
+//            solve(centroid);
+//        }
+//    }
+//}
+//
+//void prepare() {
+//    cntg = 0;
+//    cntq = 0;
+//    for (int i = 1; i <= n; i++) {
+//        headg[i] = 0;
+//        headq[i] = 0;
+//        vis[i] = false;
+//    }
+//    for (int i = 1; i <= m; i++) {
+//        ans[i] = 0;
+//    }
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> t;
+//    for (int c = 1; c <= t; c++) {
+//        cin >> n >> m;
+//        prepare();
+//        for (int i = 1, u, v; i < n; i++) {
+//            cin >> u >> v;
+//            addEdge(u, v);
+//            addEdge(v, u);
+//        }
+//        for (int i = 1, x, k; i <= m; i++) {
+//            cin >> x >> k;
+//            addQuery(x, k, i);
+//        }
+//        total = n;
+//        centroid = 0;
+//        getCentroid(1, 0);
+//        solve(centroid);
+//        for (int i = 1; i <= m; i++) {
+//            cout << ans[i] << '\n';
+//        }
+//    }
+//    return 0;
+//}
\ No newline at end of file

From 1979f8c579cfead48b998f92cf939fbf745549a2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 15:15:29 +0800
Subject: [PATCH 1693/1712] modify code

---
 src/class183/Code06_Capital1.java |  29 +++---
 src/class183/Code06_Capital2.java | 149 ++++++++++++++++++++++++++++++
 2 files changed, 166 insertions(+), 12 deletions(-)
 create mode 100644 src/class183/Code06_Capital2.java

diff --git a/src/class183/Code06_Capital1.java b/src/class183/Code06_Capital1.java
index 3edb97e8d..d1ebbb793 100644
--- a/src/class183/Code06_Capital1.java
+++ b/src/class183/Code06_Capital1.java
@@ -1,6 +1,11 @@
 package class183;
 
 // 首都，java版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 给定长度为n的数组color，color[i]表示i号节点的颜色，颜色有k种
+// 你需要在树上找到一个连通区，连通区内出现的每种颜色，都不会出现在连通区外
+// 这样的连通区可能有多个，希望包含的颜色数量尽量少，打印(最少颜色数 - 1)的结果
+// 1 <= n、k <= 2 * 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P7215
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -40,12 +45,12 @@ public class Code06_Capital1 {
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][4];
-	public static int stacksize, u, f, rt, e;
+	public static int stacksize, u, f, stamp, e;
 
-	public static void push(int u, int f, int rt, int e) {
+	public static void push(int u, int f, int stamp, int e) {
 		stack[stacksize][0] = u;
 		stack[stacksize][1] = f;
-		stack[stacksize][2] = rt;
+		stack[stacksize][2] = stamp;
 		stack[stacksize][3] = e;
 		stacksize++;
 	}
@@ -54,7 +59,7 @@ public static void pop() {
 		--stacksize;
 		u = stack[stacksize][0];
 		f = stack[stacksize][1];
-		rt = stack[stacksize][2];
+		stamp = stack[stacksize][2];
 		e = stack[stacksize][3];
 	}
 
@@ -124,37 +129,37 @@ public static void getCentroid2(int cur, int fa) {
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
-	public static void dfs1(int u, int fa, int root) {
+	public static void dfs1(int u, int fa, int stamp) {
 		father[u] = fa;
-		nodeStamp[u] = root;
+		nodeStamp[u] = stamp;
 		enter[u] = false;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (v != fa && !vis[v]) {
-				dfs1(v, u, root);
+				dfs1(v, u, stamp);
 			}
 		}
 	}
 
 	// 收集信息迭代版
-	public static void dfs2(int cur, int fa, int root) {
+	public static void dfs2(int cur, int fa, int sta) {
 		stacksize = 0;
-		push(cur, fa, root, -1);
+		push(cur, fa, sta, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
 				father[u] = f;
-				nodeStamp[u] = rt;
+				nodeStamp[u] = stamp;
 				enter[u] = false;
 				e = headg[u];
 			} else {
 				e = nextg[e];
 			}
 			if (e != 0) {
-				push(u, f, rt, e);
+				push(u, f, stamp, e);
 				int v = tog[e];
 				if (v != f && !vis[v]) {
-					push(tog[e], u, rt, -1);
+					push(tog[e], u, stamp, -1);
 				}
 			}
 		}
diff --git a/src/class183/Code06_Capital2.java b/src/class183/Code06_Capital2.java
new file mode 100644
index 000000000..0180827a3
--- /dev/null
+++ b/src/class183/Code06_Capital2.java
@@ -0,0 +1,149 @@
+package class183;
+
+// 首都，C++版
+// 一共有n个节点，给定n-1条边，所有节点组成一棵树
+// 给定长度为n的数组color，color[i]表示i号节点的颜色，颜色有k种
+// 你需要在树上找到一个连通区，连通区内出现的每种颜色，都不会出现在连通区外
+// 这样的连通区可能有多个，希望包含的颜色数量尽量少，打印(最少颜色数 - 1)的结果
+// 1 <= n、k <= 2 * 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P7215
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 200001;
+//const int INF = 1000000001;
+//int n, k;
+//int color[MAXN];
+//
+//int headg[MAXN];
+//int nextg[MAXN << 1];
+//int tog[MAXN << 1];
+//int cntg;
+//
+//int headc[MAXN];
+//int nextc[MAXN];
+//int toc[MAXN];
+//int cntc;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxPart[MAXN];
+//int total;
+//int centroid;
+//
+//int father[MAXN];
+//int nodeStamp[MAXN];
+//int colorStamp[MAXN];
+//int que[MAXN];
+//bool enter[MAXN];
+//
+//void addEdge(int u, int v) {
+//    nextg[++cntg] = headg[u];
+//    tog[cntg] = v;
+//    headg[u] = cntg;
+//}
+//
+//void addNode(int color, int node) {
+//    nextc[++cntc] = headc[color];
+//    toc[cntc] = node;
+//    headc[color] = cntc;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxPart[u] = 0;
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        int v = tog[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxPart[u] = max(maxPart[u], siz[v]);
+//        }
+//    }
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void dfs(int u, int fa, int stamp) {
+//    father[u] = fa;
+//    nodeStamp[u] = stamp;
+//    enter[u] = false;
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        int v = tog[e];
+//        if (v != fa && !vis[v]) {
+//            dfs(v, u, stamp);
+//        }
+//    }
+//}
+//
+//int calc(int u) {
+//    dfs(u, 0, u);
+//    int l = 1, r = 0;
+//    que[++r] = u;
+//    enter[u] = true;
+//    int ans = 0;
+//    while (l <= r) {
+//        int cur = que[l++];
+//        if (cur != u && !enter[father[cur]]) {
+//            que[++r] = father[cur];
+//            enter[father[cur]] = true;
+//        }
+//        if (colorStamp[color[cur]] != u) {
+//            colorStamp[color[cur]] = u;
+//            ans++;
+//            for (int e = headc[color[cur]]; e > 0; e = nextc[e]) {
+//                int v = toc[e];
+//                if (nodeStamp[v] != u) {
+//                    return INF;
+//                }
+//                if (!enter[v]) {
+//                    que[++r] = v;
+//                    enter[v] = true;
+//                }
+//            }
+//        }
+//    }
+//    return ans;
+//}
+//
+//int solve(int u) {
+//    vis[u] = true;
+//    int ans = calc(u);
+//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//        int v = tog[e];
+//        if (!vis[v]) {
+//            total = siz[v];
+//            centroid = 0;
+//            getCentroid(v, u);
+//            ans = min(ans, solve(centroid));
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> k;
+//    for (int i = 1, u, v; i < n; i++) {
+//        cin >> u >> v;
+//        addEdge(u, v);
+//        addEdge(v, u);
+//    }
+//    for (int i = 1; i <= n; i++) {
+//        cin >> color[i];
+//        addNode(color[i], i);
+//    }
+//    total = n;
+//    centroid = 0;
+//    getCentroid(1, 0);
+//    int ans = solve(centroid);
+//    cout << (ans - 1) << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 5bcf1ea203107b520f8231454fadb0968b28a17d Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 16:00:45 +0800
Subject: [PATCH 1694/1712] modify code

---
 src/class183/Code07_Maschera1.java |  46 ++++----
 src/class183/Code07_Maschera2.java | 172 +++++++++++++++++++++++++++++
 2 files changed, 196 insertions(+), 22 deletions(-)
 create mode 100644 src/class183/Code07_Maschera2.java

diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code07_Maschera1.java
index f8d9d6f26..19ce70263 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code07_Maschera1.java
@@ -1,6 +1,12 @@
 package class183;
 
-// 所有路径的魔力和，java版
+// 所有合法路径的魔力和，java版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 给定两个整数l、r，对于任意两个不同节点u、v，考虑它们之间的简单路径
+// 如果路径上边的数量在[l, r]范围内，则这条路径是合法路径
+// 路径的魔力值 = 路径上所有边权的最大值，打印所有合法路径的魔力和
+// 注意，u到v和v到u视为两条不同的路径，均要计入答案
+// 1 <= n、边权 <= 10^5
 // 测试链接 : https://www.luogu.com.cn/problem/P5351
 // 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
 
@@ -12,7 +18,7 @@
 public class Code07_Maschera1 {
 
 	public static int MAXN = 100001;
-	public static int n, minEdge, maxEdge;
+	public static int n, l, r;
 
 	public static int[] head = new int[MAXN];
 	public static int[] nxt = new int[MAXN << 1];
@@ -29,15 +35,12 @@ public class Code07_Maschera1 {
 	public static int[] curMaxv = new int[MAXN];
 	public static int[] curEdge = new int[MAXN];
 	public static int cntc;
-
 	public static int[] allMaxv = new int[MAXN];
 	public static int[] allEdge = new int[MAXN];
 	public static int cnta;
 
 	public static int[] tree = new int[MAXN];
 
-	public static long ans;
-
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][5];
 	public static int stacksize, u, f, maxv, edge, e;
@@ -88,7 +91,7 @@ public static int lowbit(int i) {
 	}
 
 	public static void add(int i, int v) {
-		while (i <= maxEdge) {
+		while (i <= r) {
 			tree[i] += v;
 			i += lowbit(i);
 		}
@@ -158,7 +161,7 @@ public static void getCentroid2(int cur, int fa) {
 
 	// 收集信息递归版，java会爆栈，C++可以通过
 	public static void dfs1(int u, int fa, int maxv, int edge) {
-		if (edge > maxEdge) {
+		if (edge > r) {
 			return;
 		}
 		curMaxv[++cntc] = maxv;
@@ -178,7 +181,7 @@ public static void dfs2(int cur, int fa, int pmaxv, int pedge) {
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
-				if (edge > maxEdge) {
+				if (edge > r) {
 					continue;
 				}
 				curMaxv[++cntc] = maxv;
@@ -197,7 +200,8 @@ public static void dfs2(int cur, int fa, int pmaxv, int pedge) {
 		}
 	}
 
-	public static void calc(int u) {
+	public static long calc(int u) {
+		long ans = 0;
 		cnta = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
@@ -207,9 +211,7 @@ public static void calc(int u) {
 				dfs2(v, u, weight[e], 1);
 				sort(curMaxv, curEdge, 1, cntc);
 				for (int i = 1; i <= cntc; i++) {
-					int l = minEdge - curEdge[i] - 1;
-					int r = maxEdge - curEdge[i];
-					ans -= 1L * curMaxv[i] * (sum(r) - sum(l));
+					ans -= 1L * curMaxv[i] * (sum(r - curEdge[i]) - sum(l - curEdge[i] - 1));
 					add(curEdge[i], 1);
 				}
 				for (int i = 1; i <= cntc; i++) {
@@ -223,24 +225,23 @@ public static void calc(int u) {
 		}
 		sort(allMaxv, allEdge, 1, cnta);
 		for (int i = 1; i <= cnta; i++) {
-			int l = minEdge - allEdge[i] - 1;
-			int r = maxEdge - allEdge[i];
-			ans += 1L * allMaxv[i] * (sum(r) - sum(l));
+			ans += 1L * allMaxv[i] * (sum(r - allEdge[i]) - sum(l - allEdge[i] - 1));
 			add(allEdge[i], 1);
 		}
 		for (int i = 1; i <= cnta; i++) {
 			add(allEdge[i], -1);
 		}
 		for (int i = 1; i <= cnta; i++) {
-			if (allEdge[i] >= minEdge) {
+			if (allEdge[i] >= l) {
 				ans += allMaxv[i];
 			}
 		}
+		return ans;
 	}
 
-	public static void solve(int u) {
-		calc(u);
+	public static long solve(int u) {
 		vis[u] = true;
+		long ans = calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
@@ -248,17 +249,18 @@ public static void solve(int u) {
 				centroid = 0;
 				// getCentroid1(v, 0);
 				getCentroid2(v, 0);
-				solve(centroid);
+				ans += solve(centroid);
 			}
 		}
+		return ans;
 	}
 
 	public static void main(String[] args) throws Exception {
 		FastReader in = new FastReader(System.in);
 		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
 		n = in.nextInt();
-		minEdge = in.nextInt();
-		maxEdge = in.nextInt();
+		l = in.nextInt();
+		r = in.nextInt();
 		for (int i = 1, u, v, w; i < n; i++) {
 			u = in.nextInt();
 			v = in.nextInt();
@@ -270,7 +272,7 @@ public static void main(String[] args) throws Exception {
 		centroid = 0;
 		// getCentroid1(1, 0);
 		getCentroid2(1, 0);
-		solve(centroid);
+		long ans = solve(centroid);
 		out.println(ans << 1);
 		out.flush();
 		out.close();
diff --git a/src/class183/Code07_Maschera2.java b/src/class183/Code07_Maschera2.java
new file mode 100644
index 000000000..f6ae0f95e
--- /dev/null
+++ b/src/class183/Code07_Maschera2.java
@@ -0,0 +1,172 @@
+package class183;
+
+// 所有合法路径的魔力和，C++版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 给定两个整数l、r，对于任意两个不同节点u、v，考虑它们之间的简单路径
+// 如果路径上边的数量在[l, r]范围内，则这条路径是合法路径
+// 路径的魔力值 = 路径上所有边权的最大值，打印所有合法路径的魔力和
+// 注意，u到v和v到u视为两条不同的路径，均要计入答案
+// 1 <= n、边权 <= 10^5
+// 测试链接 : https://www.luogu.com.cn/problem/P5351
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//struct Node {
+//    int maxv, edge;
+//};
+//
+//bool NodeCmp(Node a, Node b) {
+//    return a.maxv < b.maxv;
+//}
+//
+//const int MAXN = 100001;
+//int n, l, r;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//int maxPart[MAXN];
+//int total;
+//int centroid;
+//
+//Node cur[MAXN];
+//int cntc;
+//Node all[MAXN];
+//int cnta;
+//
+//int tree[MAXN];
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//int lowbit(int i) {
+//    return i & -i;
+//}
+//
+//void add(int i, int v) {
+//    while (i <= r) {
+//        tree[i] += v;
+//        i += lowbit(i);
+//    }
+//}
+//
+//int sum(int i) {
+//    int ret = 0;
+//    while (i > 0) {
+//        ret += tree[i];
+//        i -= lowbit(i);
+//    }
+//    return ret;
+//}
+//
+//void getCentroid(int u, int fa) {
+//    siz[u] = 1;
+//    maxPart[u] = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            getCentroid(v, u);
+//            siz[u] += siz[v];
+//            maxPart[u] = max(maxPart[u], siz[v]);
+//        }
+//    }
+//    maxPart[u] = max(maxPart[u], total - siz[u]);
+//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
+//        centroid = u;
+//    }
+//}
+//
+//void dfs(int u, int fa, int maxv, int edge) {
+//    if (edge > r) {
+//        return;
+//    }
+//    cur[++cntc] = { maxv, edge };
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            dfs(v, u, max(maxv, weight[e]), edge + 1);
+//        }
+//    }
+//}
+//
+//long long calc(int u) {
+//    long long ans = 0;
+//    cnta = 0;
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            cntc = 0;
+//            dfs(v, u, weight[e], 1);
+//            sort(cur + 1, cur + cntc + 1, NodeCmp);
+//            for (int i = 1; i <= cntc; i++) {
+//                ans -= 1LL * cur[i].maxv * (sum(r - cur[i].edge) - sum(l - cur[i].edge - 1));
+//                add(cur[i].edge, 1);
+//            }
+//            for (int i = 1; i <= cntc; i++) {
+//                add(cur[i].edge, -1);
+//            }
+//            for (int i = 1; i <= cntc; i++) {
+//                all[++cnta] = cur[i];
+//            }
+//        }
+//    }
+//    sort(all + 1, all + cnta + 1, NodeCmp);
+//    for (int i = 1; i <= cnta; i++) {
+//        ans += 1LL * all[i].maxv * (sum(r - all[i].edge) - sum(l - all[i].edge - 1));
+//        add(all[i].edge, 1);
+//    }
+//    for (int i = 1; i <= cnta; i++) {
+//        add(all[i].edge, -1);
+//    }
+//    for (int i = 1; i <= cnta; i++) {
+//        if (all[i].edge >= l) {
+//            ans += all[i].maxv;
+//        }
+//    }
+//    return ans;
+//}
+//
+//long long solve(int u) {
+//    vis[u] = true;
+//    long long ans = calc(u);
+//    for (int e = head[u]; e; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            total = siz[v];
+//            centroid = 0;
+//            getCentroid(v, 0);
+//            ans += solve(centroid);
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n >> l >> r;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        addEdge(u, v, w);
+//        addEdge(v, u, w);
+//    }
+//    total = n;
+//    centroid = 0;
+//    getCentroid(1, 0);
+//    long long ans = solve(centroid);
+//    cout << (ans << 1) << '\n';
+//    return 0;
+//}
\ No newline at end of file

From e6c16032776b9ddb74629cdf9ed91ab71bf550c6 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Thu, 13 Nov 2025 16:54:45 +0800
Subject: [PATCH 1695/1712] modify code

---
 src/class183/Code01_CentroidDecomposition1.java | 2 --
 src/class183/Code01_CentroidDecomposition2.java | 2 --
 2 files changed, 4 deletions(-)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code01_CentroidDecomposition1.java
index 411b187a6..3df56c130 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code01_CentroidDecomposition1.java
@@ -37,10 +37,8 @@ public class Code01_CentroidDecomposition1 {
 
 	public static int[] curDis = new int[MAXN];
 	public static int cntc;
-
 	public static int[] allDis = new int[MAXN];
 	public static int cnta;
-
 	public static boolean[] check = new boolean[MAXV];
 
 	public static boolean[] ans = new boolean[MAXM];
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code01_CentroidDecomposition2.java
index cb1b7c376..39457a48a 100644
--- a/src/class183/Code01_CentroidDecomposition2.java
+++ b/src/class183/Code01_CentroidDecomposition2.java
@@ -35,10 +35,8 @@
 //
 //int curDis[MAXN];
 //int cntc;
-//
 //int allDis[MAXN];
 //int cnta;
-//
 //bool check[MAXV];
 //
 //bool ans[MAXM];

From 1952d8732e11aeb75eca6e2c2426c7b7bcf89a12 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 16:29:17 +0800
Subject: [PATCH 1696/1712] modify code

---
 ...Code01_CentroidDecomposition1.java => Code02_Template1.java} | 2 +-
 ...Code01_CentroidDecomposition2.java => Code02_Template2.java} | 0
 src/class183/{Code02_Race1.java => Code03_Race1.java}           | 2 +-
 src/class183/{Code02_Race2.java => Code03_Race2.java}           | 0
 src/class183/{Code03_Tree1.java => Code04_Tree1.java}           | 2 +-
 src/class183/{Code03_Tree2.java => Code04_Tree2.java}           | 0
 .../{Code04_CloseVertices1.java => Code05_CloseVertices1.java}  | 2 +-
 .../{Code04_CloseVertices2.java => Code05_CloseVertices2.java}  | 0
 src/class183/{Code07_Maschera1.java => Code06_Maschera1.java}   | 2 +-
 src/class183/{Code07_Maschera2.java => Code06_Maschera2.java}   | 0
 src/class183/{Code05_Message1.java => Code07_Message1.java}     | 2 +-
 src/class183/{Code05_Message2.java => Code07_Message2.java}     | 0
 src/class183/{Code06_Capital1.java => Code08_Capital1.java}     | 2 +-
 src/class183/{Code06_Capital2.java => Code08_Capital2.java}     | 0
 14 files changed, 7 insertions(+), 7 deletions(-)
 rename src/class183/{Code01_CentroidDecomposition1.java => Code02_Template1.java} (99%)
 rename src/class183/{Code01_CentroidDecomposition2.java => Code02_Template2.java} (100%)
 rename src/class183/{Code02_Race1.java => Code03_Race1.java} (99%)
 rename src/class183/{Code02_Race2.java => Code03_Race2.java} (100%)
 rename src/class183/{Code03_Tree1.java => Code04_Tree1.java} (99%)
 rename src/class183/{Code03_Tree2.java => Code04_Tree2.java} (100%)
 rename src/class183/{Code04_CloseVertices1.java => Code05_CloseVertices1.java} (99%)
 rename src/class183/{Code04_CloseVertices2.java => Code05_CloseVertices2.java} (100%)
 rename src/class183/{Code07_Maschera1.java => Code06_Maschera1.java} (99%)
 rename src/class183/{Code07_Maschera2.java => Code06_Maschera2.java} (100%)
 rename src/class183/{Code05_Message1.java => Code07_Message1.java} (99%)
 rename src/class183/{Code05_Message2.java => Code07_Message2.java} (100%)
 rename src/class183/{Code06_Capital1.java => Code08_Capital1.java} (99%)
 rename src/class183/{Code06_Capital2.java => Code08_Capital2.java} (100%)

diff --git a/src/class183/Code01_CentroidDecomposition1.java b/src/class183/Code02_Template1.java
similarity index 99%
rename from src/class183/Code01_CentroidDecomposition1.java
rename to src/class183/Code02_Template1.java
index 3df56c130..83d8808d2 100644
--- a/src/class183/Code01_CentroidDecomposition1.java
+++ b/src/class183/Code02_Template1.java
@@ -13,7 +13,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code01_CentroidDecomposition1 {
+public class Code02_Template1 {
 
 	public static int MAXN = 10001;
 	public static int MAXM = 101;
diff --git a/src/class183/Code01_CentroidDecomposition2.java b/src/class183/Code02_Template2.java
similarity index 100%
rename from src/class183/Code01_CentroidDecomposition2.java
rename to src/class183/Code02_Template2.java
diff --git a/src/class183/Code02_Race1.java b/src/class183/Code03_Race1.java
similarity index 99%
rename from src/class183/Code02_Race1.java
rename to src/class183/Code03_Race1.java
index d12b53e83..4006dda7b 100644
--- a/src/class183/Code02_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -15,7 +15,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code02_Race1 {
+public class Code03_Race1 {
 
 	public static int MAXN = 200001;
 	public static int MAXK = 1000001;
diff --git a/src/class183/Code02_Race2.java b/src/class183/Code03_Race2.java
similarity index 100%
rename from src/class183/Code02_Race2.java
rename to src/class183/Code03_Race2.java
diff --git a/src/class183/Code03_Tree1.java b/src/class183/Code04_Tree1.java
similarity index 99%
rename from src/class183/Code03_Tree1.java
rename to src/class183/Code04_Tree1.java
index a3bb57f58..b6c730ddc 100644
--- a/src/class183/Code03_Tree1.java
+++ b/src/class183/Code04_Tree1.java
@@ -15,7 +15,7 @@
 import java.io.PrintWriter;
 import java.util.Arrays;
 
-public class Code03_Tree1 {
+public class Code04_Tree1 {
 
 	public static int MAXN = 50001;
 	public static int n, k;
diff --git a/src/class183/Code03_Tree2.java b/src/class183/Code04_Tree2.java
similarity index 100%
rename from src/class183/Code03_Tree2.java
rename to src/class183/Code04_Tree2.java
diff --git a/src/class183/Code04_CloseVertices1.java b/src/class183/Code05_CloseVertices1.java
similarity index 99%
rename from src/class183/Code04_CloseVertices1.java
rename to src/class183/Code05_CloseVertices1.java
index 3b5cee60a..ae77dbb40 100644
--- a/src/class183/Code04_CloseVertices1.java
+++ b/src/class183/Code05_CloseVertices1.java
@@ -18,7 +18,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code04_CloseVertices1 {
+public class Code05_CloseVertices1 {
 
 	public static int MAXN = 100002;
 	public static int n, limitl, limitw;
diff --git a/src/class183/Code04_CloseVertices2.java b/src/class183/Code05_CloseVertices2.java
similarity index 100%
rename from src/class183/Code04_CloseVertices2.java
rename to src/class183/Code05_CloseVertices2.java
diff --git a/src/class183/Code07_Maschera1.java b/src/class183/Code06_Maschera1.java
similarity index 99%
rename from src/class183/Code07_Maschera1.java
rename to src/class183/Code06_Maschera1.java
index 19ce70263..c6f425bbc 100644
--- a/src/class183/Code07_Maschera1.java
+++ b/src/class183/Code06_Maschera1.java
@@ -15,7 +15,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code07_Maschera1 {
+public class Code06_Maschera1 {
 
 	public static int MAXN = 100001;
 	public static int n, l, r;
diff --git a/src/class183/Code07_Maschera2.java b/src/class183/Code06_Maschera2.java
similarity index 100%
rename from src/class183/Code07_Maschera2.java
rename to src/class183/Code06_Maschera2.java
diff --git a/src/class183/Code05_Message1.java b/src/class183/Code07_Message1.java
similarity index 99%
rename from src/class183/Code05_Message1.java
rename to src/class183/Code07_Message1.java
index 474ad281a..b70889de9 100644
--- a/src/class183/Code05_Message1.java
+++ b/src/class183/Code07_Message1.java
@@ -15,7 +15,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code05_Message1 {
+public class Code07_Message1 {
 
 	public static int MAXN = 100001;
 	public static int t, n, m;
diff --git a/src/class183/Code05_Message2.java b/src/class183/Code07_Message2.java
similarity index 100%
rename from src/class183/Code05_Message2.java
rename to src/class183/Code07_Message2.java
diff --git a/src/class183/Code06_Capital1.java b/src/class183/Code08_Capital1.java
similarity index 99%
rename from src/class183/Code06_Capital1.java
rename to src/class183/Code08_Capital1.java
index d1ebbb793..3dd9512b6 100644
--- a/src/class183/Code06_Capital1.java
+++ b/src/class183/Code08_Capital1.java
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code06_Capital1 {
+public class Code08_Capital1 {
 
 	public static int MAXN = 200001;
 	public static int INF = 1000000001;
diff --git a/src/class183/Code06_Capital2.java b/src/class183/Code08_Capital2.java
similarity index 100%
rename from src/class183/Code06_Capital2.java
rename to src/class183/Code08_Capital2.java

From 6c31a602be58715fa009c633d573eab514fa4980 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 16:45:13 +0800
Subject: [PATCH 1697/1712] modify code

---
 src/class183/Code01_Ratio1.java    | 174 +++++++++++++++++++++++++++++
 src/class183/Code02_Template1.java |  66 +++++------
 src/class183/Code02_Template2.java |  64 ++++++-----
 3 files changed, 241 insertions(+), 63 deletions(-)
 create mode 100644 src/class183/Code01_Ratio1.java

diff --git a/src/class183/Code01_Ratio1.java b/src/class183/Code01_Ratio1.java
new file mode 100644
index 000000000..d96e07a38
--- /dev/null
+++ b/src/class183/Code01_Ratio1.java
@@ -0,0 +1,174 @@
+package class183;
+
+// 聪聪可可，java版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 如果点对(u, v)的简单路径权值和能被3整除，则称这个点对是合法的
+// 认为点对(x, x)的简单路径权值和是0，并且认为(x, y)和(y, x)是不同的点对
+// 打印(合法点对的数量 / 点对的总数量)的最简分数形式
+// 1 <= n、边权 <= 2 * 10^4
+// 测试链接 : https://www.luogu.com.cn/problem/P2634
+// 提交以下的code，提交时请把类名改成"Main"，可以通过所有测试用例
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStreamWriter;
+import java.io.PrintWriter;
+
+public class Code01_Ratio1 {
+
+	public static int MAXN = 20001;
+	public static int n;
+
+	public static int[] head = new int[MAXN];
+	public static int[] nxt = new int[MAXN << 1];
+	public static int[] to = new int[MAXN << 1];
+	public static int[] weight = new int[MAXN << 1];
+	public static int cntg;
+
+	public static boolean[] vis = new boolean[MAXN];
+	public static int[] siz = new int[MAXN];
+
+	public static int[] cur = new int[3];
+	public static int[] all = new int[3];
+
+	public static int gcd(int a, int b) {
+		return b == 0 ? a : gcd(b, a % b);
+	}
+
+	public static void addEdge(int u, int v, int w) {
+		nxt[++cntg] = head[u];
+		to[cntg] = v;
+		weight[cntg] = w;
+		head[u] = cntg;
+	}
+
+	public static int getSize(int u, int fa) {
+		siz[u] = 1;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				siz[u] += getSize(v, u);
+			}
+		}
+		return siz[u];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		int half = getSize(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = head[u]; e > 0; e = nxt[e]) {
+				int v = to[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
+				}
+			}
+		}
+		return u;
+	}
+
+	public static void dfs(int u, int fa, int dis) {
+		cur[dis % 3]++;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (v != fa && !vis[v]) {
+				dfs(v, u, dis + weight[e]);
+			}
+		}
+	}
+
+	public static int calc(int u) {
+		int ans = 0;
+		all[0] = all[1] = all[2] = 0;
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			int w = weight[e];
+			if (!vis[v]) {
+				cur[0] = cur[1] = cur[2] = 0;
+				dfs(v, u, w);
+				ans += all[0] * cur[0] * 2 + all[1] * cur[2] * 2 + all[2] * cur[1] * 2 + cur[0] * 2;
+				all[0] += cur[0];
+				all[1] += cur[1];
+				all[2] += cur[2];
+			}
+		}
+		return ans;
+	}
+
+	public static int solve(int u) {
+		vis[u] = true;
+		int ans = calc(u);
+		for (int e = head[u]; e > 0; e = nxt[e]) {
+			int v = to[e];
+			if (!vis[v]) {
+				ans += solve(getCentroid(v, u));
+			}
+		}
+		return ans;
+	}
+
+	public static void main(String[] args) throws Exception {
+		FastReader in = new FastReader(System.in);
+		PrintWriter out = new PrintWriter(new OutputStreamWriter(System.out));
+		n = in.nextInt();
+		for (int i = 1, u, v, w; i < n; i++) {
+			u = in.nextInt();
+			v = in.nextInt();
+			w = in.nextInt();
+			addEdge(u, v, w);
+			addEdge(v, u, w);
+		}
+		int a = solve(getCentroid(1, 0)) + n;
+		int b = n * n;
+		int c = gcd(a, b);
+		a /= c;
+		b /= c;
+		out.println(a + "/" + b);
+		out.flush();
+		out.close();
+	}
+
+	// 读写工具类
+	static class FastReader {
+		private final byte[] buffer = new byte[1 << 16];
+		private int ptr = 0, len = 0;
+		private final InputStream in;
+
+		FastReader(InputStream in) {
+			this.in = in;
+		}
+
+		private int readByte() throws IOException {
+			if (ptr >= len) {
+				len = in.read(buffer);
+				ptr = 0;
+				if (len <= 0)
+					return -1;
+			}
+			return buffer[ptr++];
+		}
+
+		int nextInt() throws IOException {
+			int c;
+			do {
+				c = readByte();
+			} while (c <= ' ' && c != -1);
+			boolean neg = false;
+			if (c == '-') {
+				neg = true;
+				c = readByte();
+			}
+			int val = 0;
+			while (c > ' ' && c != -1) {
+				val = val * 10 + (c - '0');
+				c = readByte();
+			}
+			return neg ? -val : val;
+		}
+	}
+
+}
diff --git a/src/class183/Code02_Template1.java b/src/class183/Code02_Template1.java
index 83d8808d2..68a495169 100644
--- a/src/class183/Code02_Template1.java
+++ b/src/class183/Code02_Template1.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 点分治，也叫重心分解，java版
+// 点分治模版题，java版
 // 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
 // 一共有m条查询，每条查询给定数字k，打印树上距离为k的点对是否存在
 // 1 <= n <= 10^4    1 <= 边权 <= 10^4
@@ -31,13 +31,10 @@ public class Code02_Template1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxPart = new int[MAXN];
-	public static int total;
-	public static int centroid;
 
-	public static int[] curDis = new int[MAXN];
+	public static int[] cur = new int[MAXN];
 	public static int cntc;
-	public static int[] allDis = new int[MAXN];
+	public static int[] all = new int[MAXN];
 	public static int cnta;
 	public static boolean[] check = new boolean[MAXV];
 
@@ -50,28 +47,40 @@ public static void addEdge(int u, int v, int w) {
 		head[u] = cntg;
 	}
 
-	public static void getCentroid(int u, int fa) {
+	public static int getSize(int u, int fa) {
 		siz[u] = 1;
-		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getCentroid(v, u);
-				siz[u] += siz[v];
-				maxPart[u] = Math.max(siz[v], maxPart[u]);
+				siz[u] += getSize(v, u);
 			}
 		}
-		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-			centroid = u;
+		return siz[u];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		int half = getSize(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = head[u]; e > 0; e = nxt[e]) {
+				int v = to[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
+				}
+			}
 		}
+		return u;
 	}
 
 	public static void dfs(int u, int fa, int dis) {
 		if (dis > maxq) {
 			return;
 		}
-		curDis[++cntc] = dis;
+		cur[++cntc] = dis;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
@@ -82,41 +91,37 @@ public static void dfs(int u, int fa, int dis) {
 
 	public static void calc(int u) {
 		cnta = 0;
+		check[0] = true;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
-			int w = weight[e];
 			if (!vis[v]) {
 				cntc = 0;
-				dfs(v, u, w);
+				dfs(v, u, weight[e]);
 				for (int i = 1; i <= m; i++) {
 					for (int j = 1; j <= cntc; j++) {
-						if (query[i] - curDis[j] >= 0) {
-							ans[i] |= check[query[i] - curDis[j]];
+						if (query[i] - cur[j] >= 0) {
+							ans[i] |= check[query[i] - cur[j]];
 						}
 					}
 				}
 				for (int i = 1; i <= cntc; i++) {
-					allDis[++cnta] = curDis[i];
-					check[curDis[i]] = true;
+					all[++cnta] = cur[i];
+					check[cur[i]] = true;
 				}
 			}
 		}
 		for (int i = 1; i <= cnta; i++) {
-			check[allDis[i]] = false;
+			check[all[i]] = false;
 		}
 	}
 
 	public static void solve(int u) {
 		vis[u] = true;
-		check[0] = true;
 		calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				total = siz[v];
-				centroid = 0;
-				getCentroid(v, u);
-				solve(centroid);
+				solve(getCentroid(v, u));
 			}
 		}
 	}
@@ -137,10 +142,7 @@ public static void main(String[] args) throws Exception {
 			query[i] = in.nextInt();
 			maxq = Math.max(maxq, query[i]);
 		}
-		total = n;
-		centroid = 0;
-		getCentroid(1, 0);
-		solve(centroid);
+		solve(getCentroid(1, 0));
 		for (int i = 1; i <= m; i++) {
 			if (ans[i]) {
 				out.println("AYE");
@@ -154,7 +156,7 @@ public static void main(String[] args) throws Exception {
 
 	// 读写工具类
 	static class FastReader {
-		private final byte[] buffer = new byte[1 << 20];
+		private final byte[] buffer = new byte[1 << 16];
 		private int ptr = 0, len = 0;
 		private final InputStream in;
 
diff --git a/src/class183/Code02_Template2.java b/src/class183/Code02_Template2.java
index 39457a48a..ce36062ca 100644
--- a/src/class183/Code02_Template2.java
+++ b/src/class183/Code02_Template2.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 点分治，也叫重心分解，C++版
+// 点分治模版题，C++版
 // 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
 // 一共有m条查询，每条查询给定数字k，打印树上距离为k的点对是否存在
 // 1 <= n <= 10^4    1 <= 边权 <= 10^4
@@ -29,13 +29,10 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxPart[MAXN];
-//int total;
-//int centroid;
 //
-//int curDis[MAXN];
+//int cur[MAXN];
 //int cntc;
-//int allDis[MAXN];
+//int all[MAXN];
 //int cnta;
 //bool check[MAXV];
 //
@@ -48,28 +45,40 @@
 //    head[u] = cntg;
 //}
 //
-//void getCentroid(int u, int fa) {
+//int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    maxPart[u] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
+//            siz[u] += getSize(v, u);
 //        }
 //    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = head[u]; e; e = nxt[e]) {
+//            int v = to[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
 //    }
+//    return u;
 //}
 //
 //void dfs(int u, int fa, int dis) {
 //    if (dis > maxq) {
 //        return;
 //    }
-//    curDis[++cntc] = dis;
+//    cur[++cntc] = dis;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
@@ -80,41 +89,37 @@
 //
 //void calc(int u) {
 //    cnta = 0;
+//    check[0] = true;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
-//        int w = weight[e];
 //        if (!vis[v]) {
 //            cntc = 0;
-//            dfs(v, u, w);
+//            dfs(v, u, weight[e]);
 //            for (int i = 1; i <= m; i++) {
 //                for (int j = 1; j <= cntc; j++) {
-//                    if (query[i] - curDis[j] >= 0) {
-//                        ans[i] |= check[query[i] - curDis[j]];
+//                    if (query[i] - cur[j] >= 0) {
+//                        ans[i] |= check[query[i] - cur[j]];
 //                    }
 //                }
 //            }
 //            for (int i = 1; i <= cntc; i++) {
-//                allDis[++cnta] = curDis[i];
-//                check[curDis[i]] = true;
+//                all[++cnta] = cur[i];
+//                check[cur[i]] = true;
 //            }
 //        }
 //    }
 //    for (int i = 1; i <= cnta; i++) {
-//        check[allDis[i]] = false;
+//        check[all[i]] = false;
 //    }
 //}
 //
 //void solve(int u) {
 //    vis[u] = true;
-//    check[0] = true;
 //    calc(u);
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, u);
-//            solve(centroid);
+//            solve(getCentroid(v, u));
 //        }
 //    }
 //}
@@ -132,10 +137,7 @@
 //        cin >> query[i];
 //        maxq = max(maxq, query[i]);
 //    }
-//    total = n;
-//    centroid = 0;
-//    getCentroid(1, 0);
-//    solve(centroid);
+//    solve(getCentroid(1, 0));
 //    for (int i = 1; i <= m; i++) {
 //        if (ans[i]) {
 //            cout << "AYE" << '\n';

From 57248086cd3c4897ecf2d13794f790d28a94d6f1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 16:53:04 +0800
Subject: [PATCH 1698/1712] modify code

---
 src/class183/Code03_Race1.java | 66 +++++++++++++++++-----------------
 src/class183/Code03_Race2.java | 41 +++++++++++----------
 2 files changed, 54 insertions(+), 53 deletions(-)

diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
index 4006dda7b..9470e29f8 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -30,9 +30,6 @@ public class Code03_Race1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxPart = new int[MAXN];
-	public static int total;
-	public static int centroid;
 
 	public static int[] disArr = new int[MAXN];
 	public static int[] edgeArr = new int[MAXN];
@@ -42,7 +39,8 @@ public class Code03_Race1 {
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][5];
-	public static int stacksize, u, f, dis, edge, e;
+	public static int u, f, dis, edge, e;
+	public static int stacksize;
 
 	public static void push(int u, int f, int dis, int edge, int e) {
 		stack[stacksize][0] = u;
@@ -69,33 +67,26 @@ public static void addEdge(int u, int v, int w) {
 		head[u] = cntg;
 	}
 
-	// 找重心的递归版，java会爆栈，C++可以通过
-	public static void getCentroid1(int u, int fa) {
+	// 得到子树大小递归版，java会爆栈，C++可以通过
+	public static int getSize1(int u, int fa) {
 		siz[u] = 1;
-		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getCentroid1(v, u);
-				siz[u] += siz[v];
-				maxPart[u] = Math.max(siz[v], maxPart[u]);
+				siz[u] += getSize1(v, u);
 			}
 		}
-		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-			centroid = u;
-		}
+		return siz[u];
 	}
 
-	// 找重心的迭代版
-	public static void getCentroid2(int cur, int fa) {
+	// 得到子树大小迭代版
+	public static int getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, 0, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
 				siz[u] = 1;
-				maxPart[u] = 0;
 				e = head[u];
 			} else {
 				e = nxt[e];
@@ -104,22 +95,37 @@ public static void getCentroid2(int cur, int fa) {
 				push(u, f, 0, 0, e);
 				int v = to[e];
 				if (v != f && !vis[v]) {
-					push(to[e], u, 0, 0, -1);
+					push(v, u, 0, 0, -1);
 				}
 			} else {
 				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 					int v = to[ei];
 					if (v != f && !vis[v]) {
 						siz[u] += siz[v];
-						maxPart[u] = Math.max(siz[v], maxPart[u]);
 					}
 				}
-				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-					centroid = u;
+			}
+		}
+		return siz[cur];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		// int half = getSize1(u, fa) >> 1;
+		int half = getSize2(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = head[u]; e > 0; e = nxt[e]) {
+				int v = to[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
 				}
 			}
 		}
+		return u;
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
@@ -137,7 +143,7 @@ public static void dfs1(int u, int fa, int dis, int edge) {
 		}
 	}
 
-	// 收集信息的迭代版
+	// 收集信息迭代版
 	public static void dfs2(int cur, int fa, int pathDis, int pathEdge) {
 		stacksize = 0;
 		push(cur, fa, pathDis, pathEdge, -1);
@@ -194,11 +200,7 @@ public static int solve(int u) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				total = siz[v];
-				centroid = 0;
-				// getCentroid1(v, 0);
-				getCentroid2(v, 0);
-				ans = Math.min(ans, solve(centroid));
+				ans = Math.min(ans, solve(getCentroid(v, u)));
 			}
 		}
 		return ans;
@@ -216,12 +218,8 @@ public static void main(String[] args) throws Exception {
 			addEdge(u, v, w);
 			addEdge(v, u, w);
 		}
-		total = n;
-		centroid = 0;
-		// getCentroid1(1, 0);
-		getCentroid2(1, 0);
 		Arrays.fill(dp, INF);
-		int ans = solve(centroid);
+		int ans = solve(getCentroid(1, 0));
 		if (ans == INF) {
 			ans = -1;
 		}
@@ -232,7 +230,7 @@ public static void main(String[] args) throws Exception {
 
 	// 读写工具类
 	static class FastReader {
-		private final byte[] buffer = new byte[1 << 20];
+		private final byte[] buffer = new byte[1 << 16];
 		private int ptr = 0, len = 0;
 		private final InputStream in;
 
diff --git a/src/class183/Code03_Race2.java b/src/class183/Code03_Race2.java
index 52dac82d4..a62419b58 100644
--- a/src/class183/Code03_Race2.java
+++ b/src/class183/Code03_Race2.java
@@ -31,9 +31,6 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxPart[MAXN];
-//int total;
-//int centroid;
 //
 //Node arr[MAXN];
 //int cnta;
@@ -47,21 +44,33 @@
 //    head[u] = cntg;
 //}
 //
-//void getCentroid(int u, int fa) {
+//int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    maxPart[u] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
+//            siz[u] += getSize(v, u);
 //        }
 //    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = head[u]; e; e = nxt[e]) {
+//            int v = to[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
 //    }
+//    return u;
 //}
 //
 //void dfs(int u, int fa, int dis, int edge) {
@@ -107,10 +116,7 @@
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, 0);
-//            ans = min(ans, solve(centroid));
+//            ans = min(ans, solve(getCentroid(v, u)));
 //        }
 //    }
 //    return ans;
@@ -127,11 +133,8 @@
 //        addEdge(u, v, w);
 //        addEdge(v, u, w);
 //    }
-//    total = n;
-//    centroid = 0;
-//    getCentroid(1, 0);
 //    fill(dp, dp + MAXK, INF);
-//    int ans = solve(centroid);
+//    int ans = solve(getCentroid(1, 0));
 //    if (ans == INF) {
 //        ans = -1;
 //    }

From 2b96b4467cd67fada61546a23cc24e6c762d13af Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 16:58:44 +0800
Subject: [PATCH 1699/1712] modify code

---
 src/class183/Code04_Tree1.java | 41 ++++++++++++++++++----------------
 src/class183/Code04_Tree2.java | 41 ++++++++++++++++++----------------
 2 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/src/class183/Code04_Tree1.java b/src/class183/Code04_Tree1.java
index b6c730ddc..28fae8a1e 100644
--- a/src/class183/Code04_Tree1.java
+++ b/src/class183/Code04_Tree1.java
@@ -28,9 +28,6 @@ public class Code04_Tree1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxPart = new int[MAXN];
-	public static int total;
-	public static int centroid;
 
 	public static int[] disArr = new int[MAXN];
 	public static int cnta;
@@ -42,21 +39,33 @@ public static void addEdge(int u, int v, int w) {
 		head[u] = cntg;
 	}
 
-	public static void getCentroid(int u, int fa) {
+	public static int getSize(int u, int fa) {
 		siz[u] = 1;
-		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getCentroid(v, u);
-				siz[u] += siz[v];
-				maxPart[u] = Math.max(siz[v], maxPart[u]);
+				siz[u] += getSize(v, u);
 			}
 		}
-		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-			centroid = u;
+		return siz[u];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		int half = getSize(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = head[u]; e > 0; e = nxt[e]) {
+				int v = to[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
+				}
+			}
 		}
+		return u;
 	}
 
 	public static void dfs(int u, int fa, int dis) {
@@ -96,10 +105,7 @@ public static long solve(int u) {
 			int v = to[e];
 			if (!vis[v]) {
 				ans -= calc(v, weight[e]);
-				total = siz[v];
-				centroid = 0;
-				getCentroid(v, 0);
-				ans += solve(centroid);
+				ans += solve(getCentroid(v, u));
 			}
 		}
 		return ans;
@@ -117,10 +123,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(v, u, w);
 		}
 		k = in.nextInt();
-		total = n;
-		centroid = 0;
-		getCentroid(1, 0);
-		out.println(solve(centroid));
+		out.println(solve(getCentroid(1, 0)));
 		out.flush();
 		out.close();
 	}
diff --git a/src/class183/Code04_Tree2.java b/src/class183/Code04_Tree2.java
index ee5813fa5..0fc0704d7 100644
--- a/src/class183/Code04_Tree2.java
+++ b/src/class183/Code04_Tree2.java
@@ -25,9 +25,6 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxPart[MAXN];
-//int total;
-//int centroid;
 //
 //int disArr[MAXN];
 //int cnta;
@@ -39,21 +36,33 @@
 //    head[u] = cntg;
 //}
 //
-//void getCentroid(int u, int fa) {
+//int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    maxPart[u] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
+//            siz[u] += getSize(v, u);
 //        }
 //    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = head[u]; e; e = nxt[e]) {
+//            int v = to[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
 //    }
+//    return u;
 //}
 //
 //void dfs(int u, int fa, int dis) {
@@ -93,10 +102,7 @@
 //        int v = to[e];
 //        if (!vis[v]) {
 //            ans -= calc(v, weight[e]);
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, 0);
-//            ans += solve(centroid);
+//            ans += solve(getCentroid(v, u));
 //        }
 //    }
 //    return ans;
@@ -112,9 +118,6 @@
 //        addEdge(v, u, w);
 //    }
 //    cin >> k;
-//    total = n;
-//    centroid = 0;
-//    getCentroid(1, 0);
-//    cout << solve(centroid) << '\n';
+//    cout << solve(getCentroid(1, 0)) << '\n';
 //    return 0;
 //}
\ No newline at end of file

From 158106a78ada42aee9e0609642da64a09ebf26b2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 17:02:28 +0800
Subject: [PATCH 1700/1712] modify code

---
 src/class183/Code05_CloseVertices1.java | 41 +++++++++++++------------
 src/class183/Code05_CloseVertices2.java | 41 +++++++++++++------------
 2 files changed, 44 insertions(+), 38 deletions(-)

diff --git a/src/class183/Code05_CloseVertices1.java b/src/class183/Code05_CloseVertices1.java
index ae77dbb40..2f629eea3 100644
--- a/src/class183/Code05_CloseVertices1.java
+++ b/src/class183/Code05_CloseVertices1.java
@@ -31,9 +31,6 @@ public class Code05_CloseVertices1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxPart = new int[MAXN];
-	public static int total;
-	public static int centroid;
 
 	public static int[] disArr = new int[MAXN];
 	public static int[] depArr = new int[MAXN];
@@ -84,21 +81,33 @@ public static int sum(int i) {
 		return ret;
 	}
 
-	public static void getCentroid(int u, int fa) {
+	public static int getSize(int u, int fa) {
 		siz[u] = 1;
-		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getCentroid(v, u);
-				siz[u] += siz[v];
-				maxPart[u] = Math.max(siz[v], maxPart[u]);
+				siz[u] += getSize(v, u);
 			}
 		}
-		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-			centroid = u;
+		return siz[u];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		int half = getSize(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = head[u]; e > 0; e = nxt[e]) {
+				int v = to[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
+				}
+			}
 		}
+		return u;
 	}
 
 	public static void dfs(int u, int fa, int dis, int dep) {
@@ -143,10 +152,7 @@ public static long solve(int u) {
 			int v = to[e];
 			if (!vis[v]) {
 				ans -= calc(v, weight[e], 2);
-				total = siz[v];
-				centroid = 0;
-				getCentroid(v, 0);
-				ans += solve(centroid);
+				ans += solve(getCentroid(v, u));
 			}
 		}
 		return ans;
@@ -164,10 +170,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(i, fa, w);
 			addEdge(fa, i, w);
 		}
-		total = n;
-		centroid = 0;
-		getCentroid(1, 0);
-		out.println(solve(centroid));
+		out.println(solve(getCentroid(1, 0)));
 		out.flush();
 		out.close();
 	}
diff --git a/src/class183/Code05_CloseVertices2.java b/src/class183/Code05_CloseVertices2.java
index aefdbf10c..5e2ae10b8 100644
--- a/src/class183/Code05_CloseVertices2.java
+++ b/src/class183/Code05_CloseVertices2.java
@@ -37,9 +37,6 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxPart[MAXN];
-//int total;
-//int centroid;
 //
 //Node arr[MAXN];
 //int cnta;
@@ -73,21 +70,33 @@
 //    return ret;
 //}
 //
-//void getCentroid(int u, int fa) {
+//int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    maxPart[u] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
+//            siz[u] += getSize(v, u);
 //        }
 //    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = head[u]; e; e = nxt[e]) {
+//            int v = to[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
 //    }
+//    return u;
 //}
 //
 //void dfs(int u, int fa, int dis, int dep) {
@@ -131,10 +140,7 @@
 //        int v = to[e];
 //        if (!vis[v]) {
 //            ans -= calc(v, weight[e], 2);
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, 0);
-//            ans += solve(centroid);
+//            ans += solve(getCentroid(v, u));
 //        }
 //    }
 //    return ans;
@@ -149,9 +155,6 @@
 //        addEdge(i, fa, w);
 //        addEdge(fa, i, w);
 //    }
-//    total = n;
-//    centroid = 0;
-//    getCentroid(1, 0);
-//    cout << solve(centroid) << '\n';
+//    cout << solve(getCentroid(1, 0)) << '\n';
 //    return 0;
 //}
\ No newline at end of file

From 0e72fb96d9a9c9571cb89e7325fd231781ac521c Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 17:06:06 +0800
Subject: [PATCH 1701/1712] modify code

---
 src/class183/Code06_Maschera1.java | 59 ++++++++++++++----------------
 src/class183/Code06_Maschera2.java | 41 +++++++++++----------
 2 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/src/class183/Code06_Maschera1.java b/src/class183/Code06_Maschera1.java
index c6f425bbc..d54a0a796 100644
--- a/src/class183/Code06_Maschera1.java
+++ b/src/class183/Code06_Maschera1.java
@@ -28,9 +28,6 @@ public class Code06_Maschera1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxPart = new int[MAXN];
-	public static int total;
-	public static int centroid;
 
 	public static int[] curMaxv = new int[MAXN];
 	public static int[] curEdge = new int[MAXN];
@@ -106,33 +103,26 @@ public static int sum(int i) {
 		return ret;
 	}
 
-	// 找重心的递归版，java会爆栈，C++可以通过
-	public static void getCentroid1(int u, int fa) {
+	// 得到子树大小递归版，java会爆栈，C++可以通过
+	public static int getSize1(int u, int fa) {
 		siz[u] = 1;
-		maxPart[u] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				getCentroid1(v, u);
-				siz[u] += siz[v];
-				maxPart[u] = Math.max(siz[v], maxPart[u]);
+				siz[u] += getSize1(v, u);
 			}
 		}
-		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-			centroid = u;
-		}
+		return siz[u];
 	}
 
-	// 找重心的迭代版
-	public static void getCentroid2(int cur, int fa) {
+	// 得到子树大小迭代版
+	public static int getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, 0, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
 				siz[u] = 1;
-				maxPart[u] = 0;
 				e = head[u];
 			} else {
 				e = nxt[e];
@@ -141,22 +131,37 @@ public static void getCentroid2(int cur, int fa) {
 				push(u, f, 0, 0, e);
 				int v = to[e];
 				if (v != f && !vis[v]) {
-					push(to[e], u, 0, 0, -1);
+					push(v, u, 0, 0, -1);
 				}
 			} else {
 				for (int ei = head[u]; ei > 0; ei = nxt[ei]) {
 					int v = to[ei];
 					if (v != f && !vis[v]) {
 						siz[u] += siz[v];
-						maxPart[u] = Math.max(siz[v], maxPart[u]);
 					}
 				}
-				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-					centroid = u;
+			}
+		}
+		return siz[cur];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		// int half = getSize1(u, fa) >> 1;
+		int half = getSize2(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = head[u]; e > 0; e = nxt[e]) {
+				int v = to[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
 				}
 			}
 		}
+		return u;
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
@@ -245,11 +250,7 @@ public static long solve(int u) {
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				total = siz[v];
-				centroid = 0;
-				// getCentroid1(v, 0);
-				getCentroid2(v, 0);
-				ans += solve(centroid);
+				ans += solve(getCentroid(v, u));
 			}
 		}
 		return ans;
@@ -268,11 +269,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(u, v, w);
 			addEdge(v, u, w);
 		}
-		total = n;
-		centroid = 0;
-		// getCentroid1(1, 0);
-		getCentroid2(1, 0);
-		long ans = solve(centroid);
+		long ans = solve(getCentroid(1, 0));
 		out.println(ans << 1);
 		out.flush();
 		out.close();
diff --git a/src/class183/Code06_Maschera2.java b/src/class183/Code06_Maschera2.java
index f6ae0f95e..be15cf90a 100644
--- a/src/class183/Code06_Maschera2.java
+++ b/src/class183/Code06_Maschera2.java
@@ -34,9 +34,6 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxPart[MAXN];
-//int total;
-//int centroid;
 //
 //Node cur[MAXN];
 //int cntc;
@@ -72,21 +69,33 @@
 //    return ret;
 //}
 //
-//void getCentroid(int u, int fa) {
+//int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    maxPart[u] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
+//            siz[u] += getSize(v, u);
 //        }
 //    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = head[u]; e; e = nxt[e]) {
+//            int v = to[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
 //    }
+//    return u;
 //}
 //
 //void dfs(int u, int fa, int maxv, int edge) {
@@ -145,10 +154,7 @@
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, 0);
-//            ans += solve(centroid);
+//            ans += solve(getCentroid(v, u));
 //        }
 //    }
 //    return ans;
@@ -163,10 +169,7 @@
 //        addEdge(u, v, w);
 //        addEdge(v, u, w);
 //    }
-//    total = n;
-//    centroid = 0;
-//    getCentroid(1, 0);
-//    long long ans = solve(centroid);
+//    long long ans = solve(getCentroid(1, 0));
 //    cout << (ans << 1) << '\n';
 //    return 0;
 //}
\ No newline at end of file

From de4164af68728d2e11f016fc5167c86b748e64d0 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 17:11:49 +0800
Subject: [PATCH 1702/1712] modify code

---
 src/class183/Code07_Message1.java | 59 +++++++++++++++----------------
 src/class183/Code07_Message2.java | 41 +++++++++++----------
 2 files changed, 50 insertions(+), 50 deletions(-)

diff --git a/src/class183/Code07_Message1.java b/src/class183/Code07_Message1.java
index b70889de9..14de968e9 100644
--- a/src/class183/Code07_Message1.java
+++ b/src/class183/Code07_Message1.java
@@ -33,9 +33,6 @@ public class Code07_Message1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxPart = new int[MAXN];
-	public static int total;
-	public static int centroid;
 
 	public static int[] depCnt = new int[MAXN];
 	public static int maxDep;
@@ -79,33 +76,26 @@ public static void addQuery(int u, int t, int id) {
 		headq[u] = cntq;
 	}
 
-	// 找重心的递归版，java会爆栈，C++可以通过
-	public static void getCentroid1(int u, int fa) {
+	// 得到子树大小递归版，java会爆栈，C++可以通过
+	public static int getSize1(int u, int fa) {
 		siz[u] = 1;
-		maxPart[u] = 0;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (v != fa && !vis[v]) {
-				getCentroid1(v, u);
-				siz[u] += siz[v];
-				maxPart[u] = Math.max(siz[v], maxPart[u]);
+				siz[u] += getSize1(v, u);
 			}
 		}
-		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-			centroid = u;
-		}
+		return siz[u];
 	}
 
-	// 找重心的迭代版
-	public static void getCentroid2(int cur, int fa) {
+	// 得到子树大小迭代版
+	public static int getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
 				siz[u] = 1;
-				maxPart[u] = 0;
 				e = headg[u];
 			} else {
 				e = nextg[e];
@@ -114,22 +104,37 @@ public static void getCentroid2(int cur, int fa) {
 				push(u, f, 0, e);
 				int v = tog[e];
 				if (v != f && !vis[v]) {
-					push(tog[e], u, 0, -1);
+					push(v, u, 0, -1);
 				}
 			} else {
 				for (int ei = headg[u]; ei > 0; ei = nextg[ei]) {
 					int v = tog[ei];
 					if (v != f && !vis[v]) {
 						siz[u] += siz[v];
-						maxPart[u] = Math.max(siz[v], maxPart[u]);
 					}
 				}
-				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-					centroid = u;
+			}
+		}
+		return siz[cur];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		// int half = getSize1(u, fa) >> 1;
+		int half = getSize2(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = headg[u]; e > 0; e = nextg[e]) {
+				int v = tog[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
 				}
 			}
 		}
+		return u;
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
@@ -213,11 +218,7 @@ public static void solve(int u) {
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (!vis[v]) {
-				total = siz[v];
-				centroid = 0;
-				// getCentroid1(v, u);
-				getCentroid2(v, u);
-				solve(centroid);
+				solve(getCentroid(v, u));
 			}
 		}
 	}
@@ -254,11 +255,7 @@ public static void main(String[] args) throws Exception {
 				k = in.nextInt();
 				addQuery(x, k, i);
 			}
-			total = n;
-			centroid = 0;
-			// getCentroid1(1, 0);
-			getCentroid2(1, 0);
-			solve(centroid);
+			solve(getCentroid(1, 0));
 			for (int i = 1; i <= m; i++) {
 				out.println(ans[i]);
 			}
diff --git a/src/class183/Code07_Message2.java b/src/class183/Code07_Message2.java
index 1011050c7..5084aebbe 100644
--- a/src/class183/Code07_Message2.java
+++ b/src/class183/Code07_Message2.java
@@ -35,9 +35,6 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxPart[MAXN];
-//int total;
-//int centroid;
 //
 //int depCnt[MAXN];
 //int maxDep;
@@ -60,21 +57,33 @@
 //    headq[u] = cntq;
 //}
 //
-//void getCentroid(int u, int fa) {
+//int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    maxPart[u] = 0;
 //    for (int e = headg[u]; e; e = nextg[e]) {
 //        int v = tog[e];
 //        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
+//            siz[u] += getSize(v, u);
 //        }
 //    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = headg[u]; e; e = nextg[e]) {
+//            int v = tog[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
 //    }
+//    return u;
 //}
 //
 //void dfs(int u, int fa, int dep) {
@@ -125,10 +134,7 @@
 //    for (int e = headg[u]; e; e = nextg[e]) {
 //        int v = tog[e];
 //        if (!vis[v]) {
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, u);
-//            solve(centroid);
+//            solve(getCentroid(v, u));
 //        }
 //    }
 //}
@@ -162,10 +168,7 @@
 //            cin >> x >> k;
 //            addQuery(x, k, i);
 //        }
-//        total = n;
-//        centroid = 0;
-//        getCentroid(1, 0);
-//        solve(centroid);
+//        solve(getCentroid(1, 0));
 //        for (int i = 1; i <= m; i++) {
 //            cout << ans[i] << '\n';
 //        }

From 84dcc06fb956c9798bef06169733ecc629e59434 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 17:15:43 +0800
Subject: [PATCH 1703/1712] modify code

---
 src/class183/Code08_Capital1.java | 59 +++++++++++++++----------------
 src/class183/Code08_Capital2.java | 43 +++++++++++-----------
 2 files changed, 51 insertions(+), 51 deletions(-)

diff --git a/src/class183/Code08_Capital1.java b/src/class183/Code08_Capital1.java
index 3dd9512b6..33d25288a 100644
--- a/src/class183/Code08_Capital1.java
+++ b/src/class183/Code08_Capital1.java
@@ -33,9 +33,6 @@ public class Code08_Capital1 {
 
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
-	public static int[] maxPart = new int[MAXN];
-	public static int total;
-	public static int centroid;
 
 	public static int[] father = new int[MAXN];
 	public static int[] nodeStamp = new int[MAXN];
@@ -75,33 +72,26 @@ public static void addNode(int color, int node) {
 		headc[color] = cntc;
 	}
 
-	// 找重心的递归版，java会爆栈，C++可以通过
-	public static void getCentroid1(int u, int fa) {
+	// 得到子树大小递归版，java会爆栈，C++可以通过
+	public static int getSize1(int u, int fa) {
 		siz[u] = 1;
-		maxPart[u] = 0;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (v != fa && !vis[v]) {
-				getCentroid1(v, u);
-				siz[u] += siz[v];
-				maxPart[u] = Math.max(siz[v], maxPart[u]);
+				siz[u] += getSize1(v, u);
 			}
 		}
-		maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-		if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-			centroid = u;
-		}
+		return siz[u];
 	}
 
-	// 找重心的迭代版
-	public static void getCentroid2(int cur, int fa) {
+	// 得到子树大小迭代版
+	public static int getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, -1);
 		while (stacksize > 0) {
 			pop();
 			if (e == -1) {
 				siz[u] = 1;
-				maxPart[u] = 0;
 				e = headg[u];
 			} else {
 				e = nextg[e];
@@ -110,22 +100,37 @@ public static void getCentroid2(int cur, int fa) {
 				push(u, f, 0, e);
 				int v = tog[e];
 				if (v != f && !vis[v]) {
-					push(tog[e], u, 0, -1);
+					push(v, u, 0, -1);
 				}
 			} else {
 				for (int ei = headg[u]; ei > 0; ei = nextg[ei]) {
 					int v = tog[ei];
 					if (v != f && !vis[v]) {
 						siz[u] += siz[v];
-						maxPart[u] = Math.max(siz[v], maxPart[u]);
 					}
 				}
-				maxPart[u] = Math.max(maxPart[u], total - siz[u]);
-				if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-					centroid = u;
+			}
+		}
+		return siz[cur];
+	}
+
+	public static int getCentroid(int u, int fa) {
+		// int half = getSize1(u, fa) >> 1;
+		int half = getSize2(u, fa) >> 1;
+		boolean find = false;
+		while (!find) {
+			find = true;
+			for (int e = headg[u]; e > 0; e = nextg[e]) {
+				int v = tog[e];
+				if (v != fa && !vis[v] && siz[v] > half) {
+					fa = u;
+					u = v;
+					find = false;
+					break;
 				}
 			}
 		}
+		return u;
 	}
 
 	// 收集信息递归版，java会爆栈，C++可以通过
@@ -202,11 +207,7 @@ public static int solve(int u) {
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (!vis[v]) {
-				total = siz[v];
-				centroid = 0;
-				// getCentroid1(v, u);
-				getCentroid2(v, u);
-				ans = Math.min(ans, solve(centroid));
+				ans = Math.min(ans, solve(getCentroid(v, u)));
 			}
 		}
 		return ans;
@@ -227,11 +228,7 @@ public static void main(String[] args) throws Exception {
 			color[i] = in.nextInt();
 			addNode(color[i], i);
 		}
-		total = n;
-		centroid = 0;
-		// getCentroid1(1, 0);
-		getCentroid2(1, 0);
-		int ans = solve(centroid);
+		int ans = solve(getCentroid(1, 0));
 		out.println(ans - 1);
 		out.flush();
 		out.close();
diff --git a/src/class183/Code08_Capital2.java b/src/class183/Code08_Capital2.java
index 0180827a3..a2d548ab4 100644
--- a/src/class183/Code08_Capital2.java
+++ b/src/class183/Code08_Capital2.java
@@ -31,9 +31,6 @@
 //
 //bool vis[MAXN];
 //int siz[MAXN];
-//int maxPart[MAXN];
-//int total;
-//int centroid;
 //
 //int father[MAXN];
 //int nodeStamp[MAXN];
@@ -53,21 +50,33 @@
 //    headc[color] = cntc;
 //}
 //
-//void getCentroid(int u, int fa) {
+//int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    maxPart[u] = 0;
-//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//    for (int e = headg[u]; e; e = nextg[e]) {
 //        int v = tog[e];
 //        if (v != fa && !vis[v]) {
-//            getCentroid(v, u);
-//            siz[u] += siz[v];
-//            maxPart[u] = max(maxPart[u], siz[v]);
+//            siz[u] += getSize(v, u);
 //        }
 //    }
-//    maxPart[u] = max(maxPart[u], total - siz[u]);
-//    if (centroid == 0 || maxPart[u] < maxPart[centroid]) {
-//        centroid = u;
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = headg[u]; e; e = nextg[e]) {
+//            int v = tog[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
 //    }
+//    return u;
 //}
 //
 //void dfs(int u, int fa, int stamp) {
@@ -118,10 +127,7 @@
 //    for (int e = headg[u]; e > 0; e = nextg[e]) {
 //        int v = tog[e];
 //        if (!vis[v]) {
-//            total = siz[v];
-//            centroid = 0;
-//            getCentroid(v, u);
-//            ans = min(ans, solve(centroid));
+//            ans = min(ans, solve(getCentroid(v, u)));
 //        }
 //    }
 //    return ans;
@@ -140,10 +146,7 @@
 //        cin >> color[i];
 //        addNode(color[i], i);
 //    }
-//    total = n;
-//    centroid = 0;
-//    getCentroid(1, 0);
-//    int ans = solve(centroid);
+//    int ans = solve(getCentroid(1, 0));
 //    cout << (ans - 1) << '\n';
 //    return 0;
 //}
\ No newline at end of file

From ff859d5426807a252eee7540b47ee9957b1fbc41 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 17:20:55 +0800
Subject: [PATCH 1704/1712] modify code

---
 src/class183/Code01_Ratio2.java | 128 ++++++++++++++++++++++++++++++++
 1 file changed, 128 insertions(+)
 create mode 100644 src/class183/Code01_Ratio2.java

diff --git a/src/class183/Code01_Ratio2.java b/src/class183/Code01_Ratio2.java
new file mode 100644
index 000000000..9838e972c
--- /dev/null
+++ b/src/class183/Code01_Ratio2.java
@@ -0,0 +1,128 @@
+package class183;
+
+// 聪聪可可，C++版
+// 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
+// 如果点对(u, v)的简单路径权值和能被3整除，则称这个点对是合法的
+// 认为点对(x, x)的简单路径权值和是0，并且认为(x, y)和(y, x)是不同的点对
+// 打印(合法点对的数量 / 点对的总数量)的最简分数形式
+// 1 <= n、边权 <= 2 * 10^4
+// 测试链接 : https://www.luogu.com.cn/problem/P2634
+// 如下实现是C++的版本，C++版本和java版本逻辑完全一样
+// 提交如下代码，可以通过所有测试用例
+
+//#include <bits/stdc++.h>
+//
+//using namespace std;
+//
+//const int MAXN = 20001;
+//int n;
+//
+//int head[MAXN];
+//int nxt[MAXN << 1];
+//int to[MAXN << 1];
+//int weight[MAXN << 1];
+//int cntg;
+//
+//bool vis[MAXN];
+//int siz[MAXN];
+//
+//int cur[3];
+//int all[3];
+//
+//int gcd(int a, int b) {
+//    return b == 0 ? a : gcd(b, a % b);
+//}
+//
+//void addEdge(int u, int v, int w) {
+//    nxt[++cntg] = head[u];
+//    to[cntg] = v;
+//    weight[cntg] = w;
+//    head[u] = cntg;
+//}
+//
+//int getSize(int u, int fa) {
+//    siz[u] = 1;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            siz[u] += getSize(v, u);
+//        }
+//    }
+//    return siz[u];
+//}
+//
+//int getCentroid(int u, int fa) {
+//    int half = getSize(u, fa) >> 1;
+//    bool find = false;
+//    while (!find) {
+//        find = true;
+//        for (int e = head[u]; e > 0; e = nxt[e]) {
+//            int v = to[e];
+//            if (v != fa && !vis[v] && siz[v] > half) {
+//                fa = u;
+//                u = v;
+//                find = false;
+//                break;
+//            }
+//        }
+//    }
+//    return u;
+//}
+//
+//void dfs(int u, int fa, int dis) {
+//    cur[dis % 3]++;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (v != fa && !vis[v]) {
+//            dfs(v, u, dis + weight[e]);
+//        }
+//    }
+//}
+//
+//int calc(int u) {
+//    int ans = 0;
+//    all[0] = all[1] = all[2] = 0;
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        int w = weight[e];
+//        if (!vis[v]) {
+//            cur[0] = cur[1] = cur[2] = 0;
+//            dfs(v, u, w);
+//            ans += all[0] * cur[0] * 2 + all[1] * cur[2] * 2 + all[2] * cur[1] * 2 + cur[0] * 2;
+//            all[0] += cur[0];
+//            all[1] += cur[1];
+//            all[2] += cur[2];
+//        }
+//    }
+//    return ans;
+//}
+//
+//int solve(int u) {
+//    vis[u] = true;
+//    int ans = calc(u);
+//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//        int v = to[e];
+//        if (!vis[v]) {
+//            ans += solve(getCentroid(v, u));
+//        }
+//    }
+//    return ans;
+//}
+//
+//int main() {
+//    ios::sync_with_stdio(false);
+//    cin.tie(nullptr);
+//    cin >> n;
+//    for (int i = 1, u, v, w; i < n; i++) {
+//        cin >> u >> v >> w;
+//        addEdge(u, v, w);
+//        addEdge(v, u, w);
+//    }
+//    int a = solve(getCentroid(1, 0)) + n;
+//    int b = n * n;
+//    int c = gcd(a, b);
+//    a /= c;
+//    b /= c;
+//    cout << a << "/" << b << '\n';
+//    return 0;
+//}
\ No newline at end of file

From 1a6bc3704c6e4f1f93497464d46cbc67eac50703 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 17:24:29 +0800
Subject: [PATCH 1705/1712] modify code

---
 src/class183/Code01_Ratio2.java   | 10 +++++-----
 src/class183/Code08_Capital2.java |  6 +++---
 2 files changed, 8 insertions(+), 8 deletions(-)

diff --git a/src/class183/Code01_Ratio2.java b/src/class183/Code01_Ratio2.java
index 9838e972c..faf3157ff 100644
--- a/src/class183/Code01_Ratio2.java
+++ b/src/class183/Code01_Ratio2.java
@@ -42,7 +42,7 @@
 //
 //int getSize(int u, int fa) {
 //    siz[u] = 1;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
 //            siz[u] += getSize(v, u);
@@ -56,7 +56,7 @@
 //    bool find = false;
 //    while (!find) {
 //        find = true;
-//        for (int e = head[u]; e > 0; e = nxt[e]) {
+//        for (int e = head[u]; e; e = nxt[e]) {
 //            int v = to[e];
 //            if (v != fa && !vis[v] && siz[v] > half) {
 //                fa = u;
@@ -71,7 +71,7 @@
 //
 //void dfs(int u, int fa, int dis) {
 //    cur[dis % 3]++;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
 //            dfs(v, u, dis + weight[e]);
@@ -82,7 +82,7 @@
 //int calc(int u) {
 //    int ans = 0;
 //    all[0] = all[1] = all[2] = 0;
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        int w = weight[e];
 //        if (!vis[v]) {
@@ -100,7 +100,7 @@
 //int solve(int u) {
 //    vis[u] = true;
 //    int ans = calc(u);
-//    for (int e = head[u]; e > 0; e = nxt[e]) {
+//    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
 //            ans += solve(getCentroid(v, u));
diff --git a/src/class183/Code08_Capital2.java b/src/class183/Code08_Capital2.java
index a2d548ab4..c2cb58f75 100644
--- a/src/class183/Code08_Capital2.java
+++ b/src/class183/Code08_Capital2.java
@@ -83,7 +83,7 @@
 //    father[u] = fa;
 //    nodeStamp[u] = stamp;
 //    enter[u] = false;
-//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//    for (int e = headg[u]; e; e = nextg[e]) {
 //        int v = tog[e];
 //        if (v != fa && !vis[v]) {
 //            dfs(v, u, stamp);
@@ -106,7 +106,7 @@
 //        if (colorStamp[color[cur]] != u) {
 //            colorStamp[color[cur]] = u;
 //            ans++;
-//            for (int e = headc[color[cur]]; e > 0; e = nextc[e]) {
+//            for (int e = headc[color[cur]]; e; e = nextc[e]) {
 //                int v = toc[e];
 //                if (nodeStamp[v] != u) {
 //                    return INF;
@@ -124,7 +124,7 @@
 //int solve(int u) {
 //    vis[u] = true;
 //    int ans = calc(u);
-//    for (int e = headg[u]; e > 0; e = nextg[e]) {
+//    for (int e = headg[u]; e; e = nextg[e]) {
 //        int v = tog[e];
 //        if (!vis[v]) {
 //            ans = min(ans, solve(getCentroid(v, u)));

From 0b31bca714ff1f8db1b8fc9dd0340a0da82f3567 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Fri, 14 Nov 2025 17:38:51 +0800
Subject: [PATCH 1706/1712] modify code

---
 .../Code08_Capital1.java => class184/Code01_Capital1.java}    | 4 ++--
 .../Code08_Capital2.java => class184/Code01_Capital2.java}    | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/{class183/Code08_Capital1.java => class184/Code01_Capital1.java} (99%)
 rename src/{class183/Code08_Capital2.java => class184/Code01_Capital2.java} (99%)

diff --git a/src/class183/Code08_Capital1.java b/src/class184/Code01_Capital1.java
similarity index 99%
rename from src/class183/Code08_Capital1.java
rename to src/class184/Code01_Capital1.java
index 33d25288a..a68b40356 100644
--- a/src/class183/Code08_Capital1.java
+++ b/src/class184/Code01_Capital1.java
@@ -1,4 +1,4 @@
-package class183;
+package class184;
 
 // 首都，java版
 // 一共有n个节点，给定n-1条边，所有节点组成一棵树
@@ -14,7 +14,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code08_Capital1 {
+public class Code01_Capital1 {
 
 	public static int MAXN = 200001;
 	public static int INF = 1000000001;
diff --git a/src/class183/Code08_Capital2.java b/src/class184/Code01_Capital2.java
similarity index 99%
rename from src/class183/Code08_Capital2.java
rename to src/class184/Code01_Capital2.java
index c2cb58f75..0759475e0 100644
--- a/src/class183/Code08_Capital2.java
+++ b/src/class184/Code01_Capital2.java
@@ -1,4 +1,4 @@
-package class183;
+package class184;
 
 // 首都，C++版
 // 一共有n个节点，给定n-1条边，所有节点组成一棵树

From bad3705a5419d1eedf840c73cd7dbd38dcc5db3b Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sat, 15 Nov 2025 10:02:31 +0800
Subject: [PATCH 1707/1712] modify code

---
 src/class183/Code01_Ratio1.java         |  9 +++++----
 src/class183/Code01_Ratio2.java         |  9 +++++----
 src/class183/Code02_Template1.java      |  9 +++++----
 src/class183/Code02_Template2.java      |  9 +++++----
 src/class183/Code03_Race1.java          | 14 +++++++-------
 src/class183/Code03_Race2.java          |  9 +++++----
 src/class183/Code04_Tree1.java          |  9 +++++----
 src/class183/Code04_Tree2.java          |  9 +++++----
 src/class183/Code05_CloseVertices1.java |  9 +++++----
 src/class183/Code05_CloseVertices2.java |  9 +++++----
 src/class183/Code06_Maschera1.java      | 14 +++++++-------
 src/class183/Code06_Maschera2.java      |  9 +++++----
 src/class183/Code07_Message1.java       | 14 +++++++-------
 src/class183/Code07_Message2.java       |  9 +++++----
 src/class184/Code01_Capital1.java       | 14 +++++++-------
 src/class184/Code01_Capital2.java       |  9 +++++----
 16 files changed, 88 insertions(+), 76 deletions(-)

diff --git a/src/class183/Code01_Ratio1.java b/src/class183/Code01_Ratio1.java
index d96e07a38..dca87e2d7 100644
--- a/src/class183/Code01_Ratio1.java
+++ b/src/class183/Code01_Ratio1.java
@@ -42,19 +42,20 @@ public static void addEdge(int u, int v, int w) {
 		head[u] = cntg;
 	}
 
-	public static int getSize(int u, int fa) {
+	public static void getSize(int u, int fa) {
 		siz[u] = 1;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize(v, u);
+				getSize(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		int half = getSize(u, fa) >> 1;
+		getSize(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class183/Code01_Ratio2.java b/src/class183/Code01_Ratio2.java
index faf3157ff..f3c99fa6a 100644
--- a/src/class183/Code01_Ratio2.java
+++ b/src/class183/Code01_Ratio2.java
@@ -40,19 +40,20 @@
 //    head[u] = cntg;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;
diff --git a/src/class183/Code02_Template1.java b/src/class183/Code02_Template1.java
index 68a495169..d5e855f19 100644
--- a/src/class183/Code02_Template1.java
+++ b/src/class183/Code02_Template1.java
@@ -47,19 +47,20 @@ public static void addEdge(int u, int v, int w) {
 		head[u] = cntg;
 	}
 
-	public static int getSize(int u, int fa) {
+	public static void getSize(int u, int fa) {
 		siz[u] = 1;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize(v, u);
+				getSize(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		int half = getSize(u, fa) >> 1;
+		getSize(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class183/Code02_Template2.java b/src/class183/Code02_Template2.java
index ce36062ca..5934f081e 100644
--- a/src/class183/Code02_Template2.java
+++ b/src/class183/Code02_Template2.java
@@ -45,19 +45,20 @@
 //    head[u] = cntg;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;
diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
index 9470e29f8..6627eaca3 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -68,19 +68,19 @@ public static void addEdge(int u, int v, int w) {
 	}
 
 	// 得到子树大小递归版，java会爆栈，C++可以通过
-	public static int getSize1(int u, int fa) {
+	public static void getSize1(int u, int fa) {
 		siz[u] = 1;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize1(v, u);
+				getSize1(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	// 得到子树大小迭代版
-	public static int getSize2(int cur, int fa) {
+	public static void getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, 0, -1);
 		while (stacksize > 0) {
@@ -106,12 +106,12 @@ public static int getSize2(int cur, int fa) {
 				}
 			}
 		}
-		return siz[cur];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		// int half = getSize1(u, fa) >> 1;
-		int half = getSize2(u, fa) >> 1;
+		// getSize1(u, fa);
+		getSize2(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class183/Code03_Race2.java b/src/class183/Code03_Race2.java
index a62419b58..943181925 100644
--- a/src/class183/Code03_Race2.java
+++ b/src/class183/Code03_Race2.java
@@ -44,19 +44,20 @@
 //    head[u] = cntg;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;
diff --git a/src/class183/Code04_Tree1.java b/src/class183/Code04_Tree1.java
index 28fae8a1e..e2e163010 100644
--- a/src/class183/Code04_Tree1.java
+++ b/src/class183/Code04_Tree1.java
@@ -39,19 +39,20 @@ public static void addEdge(int u, int v, int w) {
 		head[u] = cntg;
 	}
 
-	public static int getSize(int u, int fa) {
+	public static void getSize(int u, int fa) {
 		siz[u] = 1;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize(v, u);
+				getSize(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		int half = getSize(u, fa) >> 1;
+		getSize(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class183/Code04_Tree2.java b/src/class183/Code04_Tree2.java
index 0fc0704d7..9ed2a3076 100644
--- a/src/class183/Code04_Tree2.java
+++ b/src/class183/Code04_Tree2.java
@@ -36,19 +36,20 @@
 //    head[u] = cntg;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;
diff --git a/src/class183/Code05_CloseVertices1.java b/src/class183/Code05_CloseVertices1.java
index 2f629eea3..bd753faf4 100644
--- a/src/class183/Code05_CloseVertices1.java
+++ b/src/class183/Code05_CloseVertices1.java
@@ -81,19 +81,20 @@ public static int sum(int i) {
 		return ret;
 	}
 
-	public static int getSize(int u, int fa) {
+	public static void getSize(int u, int fa) {
 		siz[u] = 1;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize(v, u);
+				getSize(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		int half = getSize(u, fa) >> 1;
+		getSize(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class183/Code05_CloseVertices2.java b/src/class183/Code05_CloseVertices2.java
index 5e2ae10b8..3331a8722 100644
--- a/src/class183/Code05_CloseVertices2.java
+++ b/src/class183/Code05_CloseVertices2.java
@@ -70,19 +70,20 @@
 //    return ret;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;
diff --git a/src/class183/Code06_Maschera1.java b/src/class183/Code06_Maschera1.java
index d54a0a796..9d0a1ad3e 100644
--- a/src/class183/Code06_Maschera1.java
+++ b/src/class183/Code06_Maschera1.java
@@ -104,19 +104,19 @@ public static int sum(int i) {
 	}
 
 	// 得到子树大小递归版，java会爆栈，C++可以通过
-	public static int getSize1(int u, int fa) {
+	public static void getSize1(int u, int fa) {
 		siz[u] = 1;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize1(v, u);
+				getSize1(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	// 得到子树大小迭代版
-	public static int getSize2(int cur, int fa) {
+	public static void getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, 0, -1);
 		while (stacksize > 0) {
@@ -142,12 +142,12 @@ public static int getSize2(int cur, int fa) {
 				}
 			}
 		}
-		return siz[cur];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		// int half = getSize1(u, fa) >> 1;
-		int half = getSize2(u, fa) >> 1;
+		// getSize1(u, fa);
+		getSize2(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class183/Code06_Maschera2.java b/src/class183/Code06_Maschera2.java
index be15cf90a..d5b3106d5 100644
--- a/src/class183/Code06_Maschera2.java
+++ b/src/class183/Code06_Maschera2.java
@@ -69,19 +69,20 @@
 //    return ret;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;
diff --git a/src/class183/Code07_Message1.java b/src/class183/Code07_Message1.java
index 14de968e9..9e5f16c13 100644
--- a/src/class183/Code07_Message1.java
+++ b/src/class183/Code07_Message1.java
@@ -77,19 +77,19 @@ public static void addQuery(int u, int t, int id) {
 	}
 
 	// 得到子树大小递归版，java会爆栈，C++可以通过
-	public static int getSize1(int u, int fa) {
+	public static void getSize1(int u, int fa) {
 		siz[u] = 1;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize1(v, u);
+				getSize1(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	// 得到子树大小迭代版
-	public static int getSize2(int cur, int fa) {
+	public static void getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, -1);
 		while (stacksize > 0) {
@@ -115,12 +115,12 @@ public static int getSize2(int cur, int fa) {
 				}
 			}
 		}
-		return siz[cur];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		// int half = getSize1(u, fa) >> 1;
-		int half = getSize2(u, fa) >> 1;
+		// getSize1(u, fa);
+		getSize2(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class183/Code07_Message2.java b/src/class183/Code07_Message2.java
index 5084aebbe..4351447c3 100644
--- a/src/class183/Code07_Message2.java
+++ b/src/class183/Code07_Message2.java
@@ -57,19 +57,20 @@
 //    headq[u] = cntq;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = headg[u]; e; e = nextg[e]) {
 //        int v = tog[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;
diff --git a/src/class184/Code01_Capital1.java b/src/class184/Code01_Capital1.java
index a68b40356..3b0f85310 100644
--- a/src/class184/Code01_Capital1.java
+++ b/src/class184/Code01_Capital1.java
@@ -73,19 +73,19 @@ public static void addNode(int color, int node) {
 	}
 
 	// 得到子树大小递归版，java会爆栈，C++可以通过
-	public static int getSize1(int u, int fa) {
+	public static void getSize1(int u, int fa) {
 		siz[u] = 1;
 		for (int e = headg[u]; e > 0; e = nextg[e]) {
 			int v = tog[e];
 			if (v != fa && !vis[v]) {
-				siz[u] += getSize1(v, u);
+				getSize1(v, u);
+				siz[u] += siz[v];
 			}
 		}
-		return siz[u];
 	}
 
 	// 得到子树大小迭代版
-	public static int getSize2(int cur, int fa) {
+	public static void getSize2(int cur, int fa) {
 		stacksize = 0;
 		push(cur, fa, 0, -1);
 		while (stacksize > 0) {
@@ -111,12 +111,12 @@ public static int getSize2(int cur, int fa) {
 				}
 			}
 		}
-		return siz[cur];
 	}
 
 	public static int getCentroid(int u, int fa) {
-		// int half = getSize1(u, fa) >> 1;
-		int half = getSize2(u, fa) >> 1;
+		// getSize1(u, fa);
+		getSize2(u, fa);
+		int half = siz[u] >> 1;
 		boolean find = false;
 		while (!find) {
 			find = true;
diff --git a/src/class184/Code01_Capital2.java b/src/class184/Code01_Capital2.java
index 0759475e0..ab83403cc 100644
--- a/src/class184/Code01_Capital2.java
+++ b/src/class184/Code01_Capital2.java
@@ -50,19 +50,20 @@
 //    headc[color] = cntc;
 //}
 //
-//int getSize(int u, int fa) {
+//void getSize(int u, int fa) {
 //    siz[u] = 1;
 //    for (int e = headg[u]; e; e = nextg[e]) {
 //        int v = tog[e];
 //        if (v != fa && !vis[v]) {
-//            siz[u] += getSize(v, u);
+//            getSize(v, u);
+//            siz[u] += siz[v];
 //        }
 //    }
-//    return siz[u];
 //}
 //
 //int getCentroid(int u, int fa) {
-//    int half = getSize(u, fa) >> 1;
+//    getSize(u, fa);
+//    int half = siz[u] >> 1;
 //    bool find = false;
 //    while (!find) {
 //        find = true;

From 39c45524dbb9af314c0b017d6a0c1573244cf9c1 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Nov 2025 11:11:09 +0800
Subject: [PATCH 1708/1712] modify code

---
 src/class183/Code06_Maschera1.java | 3 ++-
 src/class183/Code07_Message1.java  | 3 ++-
 src/class184/Code01_Capital1.java  | 3 ++-
 3 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/src/class183/Code06_Maschera1.java b/src/class183/Code06_Maschera1.java
index 9d0a1ad3e..314f0b745 100644
--- a/src/class183/Code06_Maschera1.java
+++ b/src/class183/Code06_Maschera1.java
@@ -40,7 +40,8 @@ public class Code06_Maschera1 {
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][5];
-	public static int stacksize, u, f, maxv, edge, e;
+	public static int u, f, maxv, edge, e;
+	public static int stacksize;
 
 	public static void push(int u, int f, int maxv, int edge, int e) {
 		stack[stacksize][0] = u;
diff --git a/src/class183/Code07_Message1.java b/src/class183/Code07_Message1.java
index 9e5f16c13..3a37d281c 100644
--- a/src/class183/Code07_Message1.java
+++ b/src/class183/Code07_Message1.java
@@ -45,7 +45,8 @@ public class Code07_Message1 {
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][4];
-	public static int stacksize, u, f, dep, e;
+	public static int u, f, dep, e;
+	public static int stacksize;
 
 	public static void push(int u, int f, int dep, int e) {
 		stack[stacksize][0] = u;
diff --git a/src/class184/Code01_Capital1.java b/src/class184/Code01_Capital1.java
index 3b0f85310..5678bebc3 100644
--- a/src/class184/Code01_Capital1.java
+++ b/src/class184/Code01_Capital1.java
@@ -42,7 +42,8 @@ public class Code01_Capital1 {
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][4];
-	public static int stacksize, u, f, stamp, e;
+	public static int u, f, stamp, e;
+	public static int stacksize;
 
 	public static void push(int u, int f, int stamp, int e) {
 		stack[stacksize][0] = u;

From 8f80262e83f7bb37e13b05d416def0cca3c6cf52 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Nov 2025 11:20:54 +0800
Subject: [PATCH 1709/1712] modify code

---
 src/class183/{Code02_Template1.java => Code02_Exist1.java} | 4 ++--
 src/class183/{Code02_Template2.java => Code02_Exist2.java} | 2 +-
 2 files changed, 3 insertions(+), 3 deletions(-)
 rename src/class183/{Code02_Template1.java => Code02_Exist1.java} (98%)
 rename src/class183/{Code02_Template2.java => Code02_Exist2.java} (98%)

diff --git a/src/class183/Code02_Template1.java b/src/class183/Code02_Exist1.java
similarity index 98%
rename from src/class183/Code02_Template1.java
rename to src/class183/Code02_Exist1.java
index d5e855f19..5484d790a 100644
--- a/src/class183/Code02_Template1.java
+++ b/src/class183/Code02_Exist1.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 点分治模版题，java版
+// 距离为k的点对是否存在，java版
 // 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
 // 一共有m条查询，每条查询给定数字k，打印树上距离为k的点对是否存在
 // 1 <= n <= 10^4    1 <= 边权 <= 10^4
@@ -13,7 +13,7 @@
 import java.io.OutputStreamWriter;
 import java.io.PrintWriter;
 
-public class Code02_Template1 {
+public class Code02_Exist1 {
 
 	public static int MAXN = 10001;
 	public static int MAXM = 101;
diff --git a/src/class183/Code02_Template2.java b/src/class183/Code02_Exist2.java
similarity index 98%
rename from src/class183/Code02_Template2.java
rename to src/class183/Code02_Exist2.java
index 5934f081e..3be243bd1 100644
--- a/src/class183/Code02_Template2.java
+++ b/src/class183/Code02_Exist2.java
@@ -1,6 +1,6 @@
 package class183;
 
-// 点分治模版题，C++版
+// 距离为k的点对是否存在，C++版
 // 一共有n个节点，给定n-1条边，每条边有边权，所有节点组成一棵树
 // 一共有m条查询，每条查询给定数字k，打印树上距离为k的点对是否存在
 // 1 <= n <= 10^4    1 <= 边权 <= 10^4

From 2de3b9e8d81205d1c34a5e493a00a432d4e87ba7 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Nov 2025 12:14:04 +0800
Subject: [PATCH 1710/1712] modify code

---
 src/class183/Code01_Ratio1.java | 16 ++++++++--------
 src/class183/Code01_Ratio2.java | 16 ++++++++--------
 src/class183/Code03_Race1.java  | 16 +++++++---------
 src/class183/Code03_Race2.java  | 16 +++++++---------
 4 files changed, 30 insertions(+), 34 deletions(-)

diff --git a/src/class183/Code01_Ratio1.java b/src/class183/Code01_Ratio1.java
index dca87e2d7..69c2b4c4f 100644
--- a/src/class183/Code01_Ratio1.java
+++ b/src/class183/Code01_Ratio1.java
@@ -31,6 +31,8 @@ public class Code01_Ratio1 {
 	public static int[] cur = new int[3];
 	public static int[] all = new int[3];
 
+	public static int ans;
+
 	public static int gcd(int a, int b) {
 		return b == 0 ? a : gcd(b, a % b);
 	}
@@ -82,8 +84,7 @@ public static void dfs(int u, int fa, int dis) {
 		}
 	}
 
-	public static int calc(int u) {
-		int ans = 0;
+	public static void calc(int u) {
 		all[0] = all[1] = all[2] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
@@ -97,19 +98,17 @@ public static int calc(int u) {
 				all[2] += cur[2];
 			}
 		}
-		return ans;
 	}
 
-	public static int solve(int u) {
+	public static void solve(int u) {
 		vis[u] = true;
-		int ans = calc(u);
+		calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				ans += solve(getCentroid(v, u));
+				solve(getCentroid(v, u));
 			}
 		}
-		return ans;
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -123,7 +122,8 @@ public static void main(String[] args) throws Exception {
 			addEdge(u, v, w);
 			addEdge(v, u, w);
 		}
-		int a = solve(getCentroid(1, 0)) + n;
+		solve(getCentroid(1, 0));
+		int a = ans + n;
 		int b = n * n;
 		int c = gcd(a, b);
 		a /= c;
diff --git a/src/class183/Code01_Ratio2.java b/src/class183/Code01_Ratio2.java
index f3c99fa6a..934774dfb 100644
--- a/src/class183/Code01_Ratio2.java
+++ b/src/class183/Code01_Ratio2.java
@@ -29,6 +29,8 @@
 //int cur[3];
 //int all[3];
 //
+//int ans;
+//
 //int gcd(int a, int b) {
 //    return b == 0 ? a : gcd(b, a % b);
 //}
@@ -80,8 +82,7 @@
 //    }
 //}
 //
-//int calc(int u) {
-//    int ans = 0;
+//void calc(int u) {
 //    all[0] = all[1] = all[2] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
@@ -95,19 +96,17 @@
 //            all[2] += cur[2];
 //        }
 //    }
-//    return ans;
 //}
 //
-//int solve(int u) {
+//void solve(int u) {
 //    vis[u] = true;
-//    int ans = calc(u);
+//    calc(u);
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
-//            ans += solve(getCentroid(v, u));
+//            solve(getCentroid(v, u));
 //        }
 //    }
-//    return ans;
 //}
 //
 //int main() {
@@ -119,7 +118,8 @@
 //        addEdge(u, v, w);
 //        addEdge(v, u, w);
 //    }
-//    int a = solve(getCentroid(1, 0)) + n;
+//    solve(getCentroid(1, 0));
+//    int a = ans + n;
 //    int b = n * n;
 //    int c = gcd(a, b);
 //    a /= c;
diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
index 6627eaca3..da7dfcb63 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -36,6 +36,7 @@ public class Code03_Race1 {
 	public static int cnta;
 
 	public static int[] dp = new int[MAXK];
+	public static int ans;
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][5];
@@ -169,8 +170,7 @@ public static void dfs2(int cur, int fa, int pathDis, int pathEdge) {
 		}
 	}
 
-	public static int calc(int u) {
-		int ans = INF;
+	public static void calc(int u) {
 		cnta = 0;
 		dp[0] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
@@ -190,20 +190,17 @@ public static int calc(int u) {
 		for (int i = 1; i <= cnta; i++) {
 			dp[disArr[i]] = INF;
 		}
-		return ans;
 	}
 
-	public static int solve(int u) {
-		int ans = INF;
+	public static void solve(int u) {
 		vis[u] = true;
-		ans = Math.min(ans, calc(u));
+		calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				ans = Math.min(ans, solve(getCentroid(v, u)));
+				solve(getCentroid(v, u));
 			}
 		}
-		return ans;
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -219,7 +216,8 @@ public static void main(String[] args) throws Exception {
 			addEdge(v, u, w);
 		}
 		Arrays.fill(dp, INF);
-		int ans = solve(getCentroid(1, 0));
+		ans = INF;
+		solve(getCentroid(1, 0));
 		if (ans == INF) {
 			ans = -1;
 		}
diff --git a/src/class183/Code03_Race2.java b/src/class183/Code03_Race2.java
index 943181925..5aebb611f 100644
--- a/src/class183/Code03_Race2.java
+++ b/src/class183/Code03_Race2.java
@@ -36,6 +36,7 @@
 //int cnta;
 //
 //int dp[MAXK];
+//int ans;
 //
 //void addEdge(int u, int v, int w) {
 //    nxt[++cntg] = head[u];
@@ -87,8 +88,7 @@
 //    }
 //}
 //
-//int calc(int u) {
-//    int ans = INF;
+//void calc(int u) {
 //    cnta = 0;
 //    dp[0] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
@@ -107,20 +107,17 @@
 //    for (int i = 1; i <= cnta; i++) {
 //        dp[arr[i].dis] = INF;
 //    }
-//    return ans;
 //}
 //
-//int solve(int u) {
-//    int ans = INF;
+//void solve(int u) {
 //    vis[u] = true;
-//    ans = min(ans, calc(u));
+//    calc(u);
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
-//            ans = min(ans, solve(getCentroid(v, u)));
+//            solve(getCentroid(v, u));
 //        }
 //    }
-//    return ans;
 //}
 //
 //int main() {
@@ -135,7 +132,8 @@
 //        addEdge(v, u, w);
 //    }
 //    fill(dp, dp + MAXK, INF);
-//    int ans = solve(getCentroid(1, 0));
+//    ans = INF;
+//    solve(getCentroid(1, 0));
 //    if (ans == INF) {
 //        ans = -1;
 //    }

From 49f98db8626350a885bb1fa7deef8f143ed23e27 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Nov 2025 12:27:14 +0800
Subject: [PATCH 1711/1712] modify code

---
 src/class183/Code01_Ratio1.java | 17 +++++++++--------
 src/class183/Code01_Ratio2.java | 17 +++++++++--------
 src/class183/Code03_Race1.java  | 15 ++++++++-------
 src/class183/Code03_Race2.java  | 15 ++++++++-------
 4 files changed, 34 insertions(+), 30 deletions(-)

diff --git a/src/class183/Code01_Ratio1.java b/src/class183/Code01_Ratio1.java
index 69c2b4c4f..c9a3d9683 100644
--- a/src/class183/Code01_Ratio1.java
+++ b/src/class183/Code01_Ratio1.java
@@ -31,8 +31,6 @@ public class Code01_Ratio1 {
 	public static int[] cur = new int[3];
 	public static int[] all = new int[3];
 
-	public static int ans;
-
 	public static int gcd(int a, int b) {
 		return b == 0 ? a : gcd(b, a % b);
 	}
@@ -84,7 +82,8 @@ public static void dfs(int u, int fa, int dis) {
 		}
 	}
 
-	public static void calc(int u) {
+	public static int calc(int u) {
+		int ans = 0;
 		all[0] = all[1] = all[2] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
@@ -98,17 +97,20 @@ public static void calc(int u) {
 				all[2] += cur[2];
 			}
 		}
+		return ans;
 	}
 
-	public static void solve(int u) {
+	public static int solve(int u) {
+		int ans = 0;
 		vis[u] = true;
-		calc(u);
+		ans += calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				solve(getCentroid(v, u));
+				ans += solve(getCentroid(v, u));
 			}
 		}
+		return ans;
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -122,8 +124,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(u, v, w);
 			addEdge(v, u, w);
 		}
-		solve(getCentroid(1, 0));
-		int a = ans + n;
+		int a = solve(getCentroid(1, 0)) + n;
 		int b = n * n;
 		int c = gcd(a, b);
 		a /= c;
diff --git a/src/class183/Code01_Ratio2.java b/src/class183/Code01_Ratio2.java
index 934774dfb..d3a3b5c5b 100644
--- a/src/class183/Code01_Ratio2.java
+++ b/src/class183/Code01_Ratio2.java
@@ -29,8 +29,6 @@
 //int cur[3];
 //int all[3];
 //
-//int ans;
-//
 //int gcd(int a, int b) {
 //    return b == 0 ? a : gcd(b, a % b);
 //}
@@ -82,7 +80,8 @@
 //    }
 //}
 //
-//void calc(int u) {
+//int calc(int u) {
+//    int ans = 0;
 //    all[0] = all[1] = all[2] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
@@ -96,17 +95,20 @@
 //            all[2] += cur[2];
 //        }
 //    }
+//    return ans;
 //}
 //
-//void solve(int u) {
+//int solve(int u) {
+//    int ans = 0;
 //    vis[u] = true;
-//    calc(u);
+//    ans += calc(u);
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
-//            solve(getCentroid(v, u));
+//            ans += solve(getCentroid(v, u));
 //        }
 //    }
+//    return ans;
 //}
 //
 //int main() {
@@ -118,8 +120,7 @@
 //        addEdge(u, v, w);
 //        addEdge(v, u, w);
 //    }
-//    solve(getCentroid(1, 0));
-//    int a = ans + n;
+//    int a = solve(getCentroid(1, 0)) + n;
 //    int b = n * n;
 //    int c = gcd(a, b);
 //    a /= c;
diff --git a/src/class183/Code03_Race1.java b/src/class183/Code03_Race1.java
index da7dfcb63..72695dc98 100644
--- a/src/class183/Code03_Race1.java
+++ b/src/class183/Code03_Race1.java
@@ -36,7 +36,6 @@ public class Code03_Race1 {
 	public static int cnta;
 
 	public static int[] dp = new int[MAXK];
-	public static int ans;
 
 	// 讲解118，递归函数改成迭代所需要的栈
 	public static int[][] stack = new int[MAXN][5];
@@ -170,7 +169,8 @@ public static void dfs2(int cur, int fa, int pathDis, int pathEdge) {
 		}
 	}
 
-	public static void calc(int u) {
+	public static int calc(int u) {
+		int ans = INF;
 		cnta = 0;
 		dp[0] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
@@ -190,17 +190,19 @@ public static void calc(int u) {
 		for (int i = 1; i <= cnta; i++) {
 			dp[disArr[i]] = INF;
 		}
+		return ans;
 	}
 
-	public static void solve(int u) {
+	public static int solve(int u) {
 		vis[u] = true;
-		calc(u);
+		int ans = calc(u);
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
 			if (!vis[v]) {
-				solve(getCentroid(v, u));
+				ans = Math.min(ans, solve(getCentroid(v, u)));
 			}
 		}
+		return ans;
 	}
 
 	public static void main(String[] args) throws Exception {
@@ -216,8 +218,7 @@ public static void main(String[] args) throws Exception {
 			addEdge(v, u, w);
 		}
 		Arrays.fill(dp, INF);
-		ans = INF;
-		solve(getCentroid(1, 0));
+		int ans = solve(getCentroid(1, 0));
 		if (ans == INF) {
 			ans = -1;
 		}
diff --git a/src/class183/Code03_Race2.java b/src/class183/Code03_Race2.java
index 5aebb611f..d286b37e5 100644
--- a/src/class183/Code03_Race2.java
+++ b/src/class183/Code03_Race2.java
@@ -36,7 +36,6 @@
 //int cnta;
 //
 //int dp[MAXK];
-//int ans;
 //
 //void addEdge(int u, int v, int w) {
 //    nxt[++cntg] = head[u];
@@ -88,7 +87,8 @@
 //    }
 //}
 //
-//void calc(int u) {
+//int calc(int u) {
+//    int ans = INF;
 //    cnta = 0;
 //    dp[0] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
@@ -107,17 +107,19 @@
 //    for (int i = 1; i <= cnta; i++) {
 //        dp[arr[i].dis] = INF;
 //    }
+//    return ans;
 //}
 //
-//void solve(int u) {
+//int solve(int u) {
 //    vis[u] = true;
-//    calc(u);
+//    int ans = calc(u);
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
 //        if (!vis[v]) {
-//            solve(getCentroid(v, u));
+//            ans = min(ans, solve(getCentroid(v, u)));
 //        }
 //    }
+//    return ans;
 //}
 //
 //int main() {
@@ -132,8 +134,7 @@
 //        addEdge(v, u, w);
 //    }
 //    fill(dp, dp + MAXK, INF);
-//    ans = INF;
-//    solve(getCentroid(1, 0));
+//    int ans = solve(getCentroid(1, 0));
 //    if (ans == INF) {
 //        ans = -1;
 //    }

From d663f639ba7ebfbe1a522ae3390932defca9b5b2 Mon Sep 17 00:00:00 2001
From: algorithmzuo <algorithmzuo@163.com>
Date: Sun, 16 Nov 2025 16:06:06 +0800
Subject: [PATCH 1712/1712] modify code

---
 src/class183/Code01_Ratio1.java | 7 +++++--
 src/class183/Code01_Ratio2.java | 5 +++--
 2 files changed, 8 insertions(+), 4 deletions(-)

diff --git a/src/class183/Code01_Ratio1.java b/src/class183/Code01_Ratio1.java
index c9a3d9683..675cbf0fc 100644
--- a/src/class183/Code01_Ratio1.java
+++ b/src/class183/Code01_Ratio1.java
@@ -28,6 +28,8 @@ public class Code01_Ratio1 {
 	public static boolean[] vis = new boolean[MAXN];
 	public static int[] siz = new int[MAXN];
 
+	// cur[v]，表示往下走的当前路径中，路径权值和 % 3 == v的路径有多少条
+	// all[v]，表示往下走的所有路径中，路径权值和 % 3 == v的路径有多少条
 	public static int[] cur = new int[3];
 	public static int[] all = new int[3];
 
@@ -83,7 +85,7 @@ public static void dfs(int u, int fa, int dis) {
 	}
 
 	public static int calc(int u) {
-		int ans = 0;
+		int ans = 1;
 		all[0] = all[1] = all[2] = 0;
 		for (int e = head[u]; e > 0; e = nxt[e]) {
 			int v = to[e];
@@ -124,7 +126,8 @@ public static void main(String[] args) throws Exception {
 			addEdge(u, v, w);
 			addEdge(v, u, w);
 		}
-		int a = solve(getCentroid(1, 0)) + n;
+		int centroid = getCentroid(1, 0);
+		int a = solve(centroid);
 		int b = n * n;
 		int c = gcd(a, b);
 		a /= c;
diff --git a/src/class183/Code01_Ratio2.java b/src/class183/Code01_Ratio2.java
index d3a3b5c5b..ca8a13757 100644
--- a/src/class183/Code01_Ratio2.java
+++ b/src/class183/Code01_Ratio2.java
@@ -81,7 +81,7 @@
 //}
 //
 //int calc(int u) {
-//    int ans = 0;
+//    int ans = 1;
 //    all[0] = all[1] = all[2] = 0;
 //    for (int e = head[u]; e; e = nxt[e]) {
 //        int v = to[e];
@@ -120,7 +120,8 @@
 //        addEdge(u, v, w);
 //        addEdge(v, u, w);
 //    }
-//    int a = solve(getCentroid(1, 0)) + n;
+//    int centroid = getCentroid(1, 0);
+//    int a = solve(centroid);
 //    int b = n * n;
 //    int c = gcd(a, b);
 //    a /= c;