feat: add solutions to lc problems: No.2578~2582

Author: yanglbme

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

@@ -50,6 +50,20 @@
 
 ## Solutions
 
+**Approach 1: Count + Greedy**
+
+We first use a hash table or array `cnt` to count the number of times each digit appears in `num`, and use the variable `n` to record the number of digits in `num`.
+
+Then, enumerate the number of digits $i$ of `nums`, and assign the numbers in `cnt` in ascending order alternately to `num1` and `num2`, and record it in an array of length $2$ `$ans`. Finally, return the sum of the two numbers in `ans`.
+
+The time complexity is $O(n)$ and the space complexity is $O(C)$. Where $n$ is the number of digits in `num`; and $C$ is the number of different numbers in `num`, which is $C \leq 10$ in this problem.
+
+**Approach 2: Sorting + Greedy**
+
+We can convert `num` to a string or character array and sort it. Then assign the numbers in the sorted array in ascending order alternately to `num1` and `num2`, and finally return the sum of `num1` and `num2`.
+
+The time complexity is $O(n \times \log n)$ and the space complexity is $O(n)$. Where $n$ is the number of digits in `num`.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2579.Count Total Number of Colored Cells/README_EN.md

@@ -41,6 +41,12 @@
 
 ## Solutions
 
+**Approach 1: Mathematics**
+
+We find that after the $n$th minute, there are a total of $2 \times n - 1$ columns in the grid, and the numbers on each column are respectively $1, 3, 5, \cdots, 2 \times n - 1, 2 \times n - 3, \cdots, 3, 1$. The left and right parts are both arithmetic progressions, and the sum can be obtained by $2 \times n \times (n - 1) + 1$.
+
+Time complexity $O(1)$, space complexity $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2581.Count Number of Possible Root Nodes/README_EN.md

@@ -72,6 +72,21 @@ Considering any node as root will give at least 1 correct guess.
 
 ## Solutions
 
+
+**Approach 1: Tree DP (change root)**
+
+First, we traverse the given edge set $edges$ and convert it to an adjacency list $g$ where $g[i]$ represents the adjacent nodes of node $i$. Use a hash map $gs$ to record the given guess set $guesses$.
+
+Then, we start from node $0$ and perform a DFS to count the number of edges in $guesses$ among all the nodes that can be reached from node $0$. We use the variable $cnt$ to record this number.
+
+Next, we start from node $0$ and perform a DFS to count the number of edges in $guesses$ in each tree with $0$ as the root. If the number is greater than or equal to $k$, it means that this node is a possible root node, and we add $1$ to the answer.
+
+Therefore, the problem becomes to count the number of edges in $guesses$ in each tree with each node as the root. We already know that there are $cnt$ edges in $guesses$ among all the nodes that can be reached from node $0$. We can maintain this value by adding or subtracting the current edge in $guesses$ in DFS.
+
+Assume that we are currently traversing node $i$ and $cnt$ represents the number of edges in $guesses$ with $i$ as the root node. Then, for each adjacent node $j$ of $i$, we need to calculate the number of edges in $guesses$ with $j$ as the root node. If $(i, j)$ is in $guesses$, then there is no edge $(i, j)$ in the tree with $j$ as the root node, so $cnt$ should decrease by $1$. If $(j, i)$ is in $guesses$, then there is an extra edge $(i, j)$ in the tree with $j$ as the root node, so $cnt$ should increase by $1$. That is, $f[j] = f[i] + (j, i) \in guesses - (i, j) \in guesses$. Where $f[i]$ represents the number of edges in $guesses$ with $i$ as the root node.
+
+The time complexity is $O(n + m)$ and the space complexity is $O(n + m)$, where $n$ and $m$ are the lengths of $edges$ and $guesses$ respectively.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2582.Pass the Pillow/README_EN.md

@@ -40,6 +40,23 @@ Afer two seconds, the pillow is given to the 3<sup>r</sup><sup>d</sup> person.
 
 ## Solutions
 
+**Approach 1: Simulation**
+
+We can simulate the process of passing the pillow, and each time the pillow is passed, if the pillow reaches the front or the end of the queue, the direction of the pillow will change, and the queue will continue to pass the pillow along the opposite direction.
+
+The time complexity is $O(time)$ and the space complexity is $O(1)$, where $time$ is the given time.
+
+**Approach 2: Math**
+
+We notice that there are $n - 1$ passes in each round. Therefore, we can divide $time$ by $n - 1$ to get the number of rounds $k$ that the pillow is passed, and then take the remainder of $time$ modulo $n - 1$ to get the remaining passes $mod$ in the current round.
+
+Then we judge the current round $k$:
+
+-   If $k$ is odd, then the current direction of the pillow is from the end of the queue to the front, so the pillow will be passed to the person with the number $n - mod$.
+-   If $k$ is even, then the current direction of the pillow is from the front of the queue to the back, so the pillow will be passed to the person with the number $mod + 1$.
+
+The time complexity is $O(1)$ and the space complexity is $O(1)$.
+
 <!-- tabs:start -->
 
 ### **Python3**

solution/2500-2599/2597.The Number of Beautiful Subsets/README_EN.md

@@ -41,7 +41,7 @@ It can be proved that there is only 1 beautiful subset in the array [1].
 
 ## Solutions
 
-# Approach 1: Counting + Backtracking
+**Approach 1: Counting + Backtracking**
 
 We use a hash table or an array $cnt$ to record the currently selected numbers and their counts, and use $ans$ to record the number of beautiful subsets, initially $ans = -1$, indicating that the empty set is excluded.