Merge branch 'main' into main

Author: Speccy-Rom

solution/1700-1799/1717.Maximum Score From Removing Substrings/README.md

@@ -88,9 +88,9 @@ tags:
 
 -   如果 $c$ 是 "a"，由于要先删除 "ab"，因此此时我们不消除该字符，只增加 $\textit{cnt1}$；
 -   如果 $c$ 是 "b"，如果此时 $\textit{cnt1} > 0$，我们可以消除一个 "ab"，并增加 $x$ 分，否则我们只能增加 $\textit{cnt2}$；
--   如果 $c$ 是其他字符，那么对于该子字符串，我们剩下了一个 $\textit{cnt2}$ 个 "b" 和 $\textit{cnt1}$ 个 "a"，我们可以消除 $\min(\textit{cnt1}, \textit{cnt2})$ 个 "ab"，并增加 $y$ 分。
+-   如果 $c$ 是其他字符，那么对于该子字符串，我们剩下了 $\textit{cnt2}$ 个 "b" 和 $\textit{cnt1}$ 个 "a"，我们可以消除 $\min(\textit{cnt1}, \textit{cnt2})$ 个 "ba"，并增加若干个 $y$ 分。
 
-遍历结束后，我们还需要额外处理一下剩余的 "ab"，增加若干个 $y$ 分。
+遍历结束后，我们还需要额外处理一下剩余的 "ba"，增加若干个 $y$ 分。
 
 时间复杂度 $O(n)$，其中 $n$ 为字符串 $s$ 的长度。空间复杂度 $O(1)$。
 

solution/1700-1799/1717.Maximum Score From Removing Substrings/README_EN.md

@@ -76,23 +76,23 @@ Total score = 5 + 4 + 5 + 5 = 19.</pre>
 
 ### Solution 1: Greedy
 
-Let's assume that the score of the substring "ab" is always not lower than the score of the substring "ba". If not, we can swap "a" and "b", and simultaneously swap $x$ and $y$.
+We can assume that the score of substring "ab" is always no less than the score of substring "ba". If not, we can swap "a" and "b", and simultaneously swap $x$ and $y$.
 
-Next, we only need to consider the case where the string contains only "a" and "b". If the string contains other characters, we can treat them as a dividing point, splitting the string into several substrings that contain only "a" and "b", and then calculate the score for each substring separately.
+Next, we only need to consider the case where the string contains only "a" and "b". If the string contains other characters, we can treat them as split points, dividing the string into several substrings that contain only "a" and "b", and then calculate the score for each substring separately.
 
-We observe that, for a substring containing only "a" and "b", no matter what operations are taken, in the end, there will only be one type of character left, or an empty string. Since each operation will delete one "a" and one "b" simultaneously, the total number of operations is fixed. We can greedily delete "ab" first, then "ba", to ensure the maximum score.
+We observe that for a substring containing only "a" and "b", no matter what operations we take, we will eventually be left with only one type of character, or an empty string. Since each operation removes one "a" and one "b" simultaneously, the total number of operations is fixed. We can greedily remove "ab" first, then remove "ba", which ensures the maximum score.
 
-Therefore, we can use two variables $\textit{cnt1}$ and $\textit{cnt2}$ to record the number of "a" and "b", respectively. Then, we traverse the string, update $\textit{cnt1}$ and $\textit{cnt2}$ based on the current character, and calculate the score.
+Therefore, we can use two variables $\textit{cnt1}$ and $\textit{cnt2}$ to record the counts of "a" and "b" respectively, then traverse the string and update $\textit{cnt1}$ and $\textit{cnt2}$ according to different cases of the current character, while calculating the score.
 
-For the current character $c$:
+For the current character $c$ being traversed:
 
--   If $c$ is "a", since we need to delete "ab" first, we do not eliminate this character at this time, only increase $\textit{cnt1}$;
--   If $c$ is "b", if $\textit{cnt1} > 0$ at this time, we can eliminate an "ab" and add $x$ points; otherwise, we can only increase $\textit{cnt2}$;
--   If $c$ is another character, then for this substring, we are left with $\textit{cnt2}$ "b" and $\textit{cnt1}$ "a", we can eliminate $\min(\textit{cnt1}, \textit{cnt2})$ "ab" and add $y$ points.
+-   If $c$ is "a", since we want to remove "ab" first, we don't eliminate this character at this time, only increment $\textit{cnt1}$;
+-   If $c$ is "b", if $\textit{cnt1} > 0$ at this time, we can eliminate one "ab" and add $x$ points; otherwise, we can only increment $\textit{cnt2}$;
+-   If $c$ is another character, then for this substring, we have $\textit{cnt2}$ "b"s and $\textit{cnt1}$ "a"s left. We can eliminate $\min(\textit{cnt1}, \textit{cnt2})$ "ba"s and add several $y$ points.
 
-After the traversal is finished, we also need to additionally handle the remaining "ab", adding several $y$ points.
+After traversal, we need to handle the remaining "ba"s and add several $y$ points.
 
-The time complexity is $O(n)$, where $n$ is the length of the string $s$. The space complexity is $O(1)$.
+The time complexity is $O(n)$, where $n$ is the length of string $s$. The space complexity is $O(1)$.
 
 <!-- tabs:start -->
 

solution/1900-1999/1948.Delete Duplicate Folders in System/README_EN.md

@@ -68,7 +68,7 @@ folder named "b".
 <pre>
 <strong>Input:</strong> paths = [[&quot;a&quot;],[&quot;c&quot;],[&quot;a&quot;,&quot;b&quot;],[&quot;c&quot;,&quot;b&quot;],[&quot;a&quot;,&quot;b&quot;,&quot;x&quot;],[&quot;a&quot;,&quot;b&quot;,&quot;x&quot;,&quot;y&quot;],[&quot;w&quot;],[&quot;w&quot;,&quot;y&quot;]]
 <strong>Output:</strong> [[&quot;c&quot;],[&quot;c&quot;,&quot;b&quot;],[&quot;a&quot;],[&quot;a&quot;,&quot;b&quot;]]
-<strong>Explanation: </strong>The file structure is as shown.
+<strong>Explanation: </strong>The file structure is as shown. 
 Folders &quot;/a/b/x&quot; and &quot;/w&quot; (and their subfolders) are marked for deletion because they both contain an empty folder named &quot;y&quot;.
 Note that folders &quot;/a&quot; and &quot;/c&quot; are identical after the deletion, but they are not deleted because they were not marked beforehand.
 </pre>

solution/2300-2399/2322.Minimum Score After Removals on a Tree/README.md

@@ -399,6 +399,66 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int MinimumScore(int[] nums, int[][] edges) {
+        int n = nums.Length;
+        List<int>[] g = new List<int>[n];
+        for (int i = 0; i < n; i++) {
+            g[i] = new List<int>();
+        }
+        foreach (var e in edges) {
+            int a = e[0], b = e[1];
+            g[a].Add(b);
+            g[b].Add(a);
+        }
+
+        int s = 0;
+        foreach (int x in nums) {
+            s ^= x;
+        }
+
+        int ans = int.MaxValue;
+        int s1 = 0;
+
+        int Dfs(int i, int fa) {
+            int res = nums[i];
+            foreach (int j in g[i]) {
+                if (j != fa) {
+                    res ^= Dfs(j, i);
+                }
+            }
+            return res;
+        }
+
+        int Dfs2(int i, int fa) {
+            int res = nums[i];
+            foreach (int j in g[i]) {
+                if (j != fa) {
+                    int s2 = Dfs2(j, i);
+                    res ^= s2;
+                    int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+                    int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+                    ans = Math.Min(ans, mx - mn);
+                }
+            }
+            return res;
+        }
+
+        for (int i = 0; i < n; ++i) {
+            foreach (int j in g[i]) {
+                s1 = Dfs(i, j);
+                Dfs2(i, j);
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2300-2399/2322.Minimum Score After Removals on a Tree/README_EN.md

@@ -399,6 +399,66 @@ impl Solution {
 }
 ```
 
+#### C#
+
+```cs
+public class Solution {
+    public int MinimumScore(int[] nums, int[][] edges) {
+        int n = nums.Length;
+        List<int>[] g = new List<int>[n];
+        for (int i = 0; i < n; i++) {
+            g[i] = new List<int>();
+        }
+        foreach (var e in edges) {
+            int a = e[0], b = e[1];
+            g[a].Add(b);
+            g[b].Add(a);
+        }
+
+        int s = 0;
+        foreach (int x in nums) {
+            s ^= x;
+        }
+
+        int ans = int.MaxValue;
+        int s1 = 0;
+
+        int Dfs(int i, int fa) {
+            int res = nums[i];
+            foreach (int j in g[i]) {
+                if (j != fa) {
+                    res ^= Dfs(j, i);
+                }
+            }
+            return res;
+        }
+
+        int Dfs2(int i, int fa) {
+            int res = nums[i];
+            foreach (int j in g[i]) {
+                if (j != fa) {
+                    int s2 = Dfs2(j, i);
+                    res ^= s2;
+                    int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+                    int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+                    ans = Math.Min(ans, mx - mn);
+                }
+            }
+            return res;
+        }
+
+        for (int i = 0; i < n; ++i) {
+            foreach (int j in g[i]) {
+                s1 = Dfs(i, j);
+                Dfs2(i, j);
+            }
+        }
+
+        return ans;
+    }
+}
+```
+
 <!-- tabs:end -->
 
 <!-- solution:end -->

solution/2300-2399/2322.Minimum Score After Removals on a Tree/Solution.cs

@@ -0,0 +1,55 @@
+public class Solution {
+    public int MinimumScore(int[] nums, int[][] edges) {
+        int n = nums.Length;
+        List<int>[] g = new List<int>[n];
+        for (int i = 0; i < n; i++) {
+            g[i] = new List<int>();
+        }
+        foreach (var e in edges) {
+            int a = e[0], b = e[1];
+            g[a].Add(b);
+            g[b].Add(a);
+        }
+
+        int s = 0;
+        foreach (int x in nums) {
+            s ^= x;
+        }
+
+        int ans = int.MaxValue;
+        int s1 = 0;
+
+        int Dfs(int i, int fa) {
+            int res = nums[i];
+            foreach (int j in g[i]) {
+                if (j != fa) {
+                    res ^= Dfs(j, i);
+                }
+            }
+            return res;
+        }
+
+        int Dfs2(int i, int fa) {
+            int res = nums[i];
+            foreach (int j in g[i]) {
+                if (j != fa) {
+                    int s2 = Dfs2(j, i);
+                    res ^= s2;
+                    int mx = Math.Max(Math.Max(s ^ s1, s2), s1 ^ s2);
+                    int mn = Math.Min(Math.Min(s ^ s1, s2), s1 ^ s2);
+                    ans = Math.Min(ans, mx - mn);
+                }
+            }
+            return res;
+        }
+
+        for (int i = 0; i < n; ++i) {
+            foreach (int j in g[i]) {
+                s1 = Dfs(i, j);
+                Dfs2(i, j);
+            }
+        }
+
+        return ans;
+    }
+}

solution/3600-3699/3615.Longest Palindromic Path in Graph/README.md

@@ -7,6 +7,7 @@ tags:
     - 图
     - 字符串
     - 动态规划
+    - 状态压缩
 ---
 
 <!-- problem:start -->

solution/3600-3699/3615.Longest Palindromic Path in Graph/README_EN.md

@@ -7,6 +7,7 @@ tags:
     - Graph
     - String
     - Dynamic Programming
+    - Bitmask
 ---
 
 <!-- problem:start -->

solution/3600-3699/3616.Number of Student Replacements/README.md

@@ -2,6 +2,9 @@
 comments: true
 difficulty: 中等
 edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3616.Number%20of%20Student%20Replacements/README.md
+tags:
+    - 数组
+    - 模拟
 ---
 
 <!-- problem:start -->

solution/3600-3699/3616.Number of Student Replacements/README_EN.md

@@ -2,6 +2,9 @@
 comments: true
 difficulty: Medium
 edit_url: https://github.com/doocs/leetcode/edit/main/solution/3600-3699/3616.Number%20of%20Student%20Replacements/README_EN.md
+tags:
+    - Array
+    - Simulation
 ---
 
 <!-- problem:start -->