chore: update

Author: yanglbme

solution/0800-0899/0838.Push Dominoes/README.md

@@ -29,9 +29,9 @@ tags:
 <p>给你一个字符串 <code>dominoes</code> 表示这一行多米诺骨牌的初始状态，其中：</p>
 
 <ul>
-	<li><code>dominoes[i] = 'L'</code>，表示第 <code>i</code> 张多米诺骨牌被推向左侧，</li>
-	<li><code>dominoes[i] = 'R'</code>，表示第 <code>i</code> 张多米诺骨牌被推向右侧，</li>
-	<li><code>dominoes[i] = '.'</code>，表示没有推动第 <code>i</code> 张多米诺骨牌。</li>
+ <li><code>dominoes[i] = 'L'</code>，表示第 <code>i</code> 张多米诺骨牌被推向左侧，</li>
+ <li><code>dominoes[i] = 'R'</code>，表示第 <code>i</code> 张多米诺骨牌被推向右侧，</li>
+ <li><code>dominoes[i] = '.'</code>，表示没有推动第 <code>i</code> 张多米诺骨牌。</li>
 </ul>
 
 <p>返回表示最终状态的字符串。</p>
@@ -57,9 +57,9 @@ tags:
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>n == dominoes.length</code></li>
-	<li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
-	<li><code>dominoes[i]</code> 为 <code>'L'</code>、<code>'R'</code> 或 <code>'.'</code></li>
+ <li><code>n == dominoes.length</code></li>
+ <li><code>1 &lt;= n &lt;= 10<sup>5</sup></code></li>
+ <li><code>dominoes[i]</code> 为 <code>'L'</code>、<code>'R'</code> 或 <code>'.'</code></li>
 </ul>
 
 <!-- description:end -->
@@ -72,34 +72,24 @@ tags:
 
 把所有初始受到推力的骨牌（`L` 或 `R`）视作 **源点**，它们会同时向外扩散各自的力。用队列按时间层级（0, 1, 2 …）进行 BFS：
 
-1. **建模**
+我们定义 $\text{time[i]}$ 记录第 *i* 张骨牌第一次受力的时刻，`-1` 表示尚未受力，定义 $\text{force[i]}$ 是一个长度可变的列表，存放该骨牌在同一时刻收到的方向（`'L'`、`'R'`）。初始时把所有 `L/R` 的下标压入队列，并将它们的时间置 0。
 
-    - `time[i]` 记录第 *i* 张骨牌第一次受力的时刻，`-1` 表示尚未受力。
-    - `force[i]` 是一个长度可变的列表，存放该骨牌在同一时刻收到的方向（`'L'`、`'R'`）。
-    - 初始时把所有 `L/R` 的下标压入队列，并将它们的时间置 0。
+当弹出下标 *i* 时，若 $\text{force[i]}$ 只有一个方向，骨牌就会倒向该方向 $f$。设下一张骨牌下标为
 
-2. **扩散规则**
+$$
+j =
+\begin{cases}
+i - 1, & f = L,\\
+i + 1, & f = R.
+\end{cases}
+$$
 
-    - 当弹出下标 *i* 时，若 `force[i]` 只有一个方向，骨牌就会倒向该方向 `f`。
-    - 设下一张骨牌下标为
+若 $0 \leq j < n$：
 
-        $$
-        j=\begin{cases}
-          i-1,& f=L\\[2pt]
-          i+1,& f=R
-        \end{cases}
-        $$
+-   若 $\text{time[j]}=-1$，说明 *j* 从未受力，记录 $\text{time[j]}=\text{time[i]}+1$ 并入队，同时把 $f$ 写入 $\text{force[j]}$。
+-   若 $\text{time[j]}=\text{time[i]}+1$，说明它在同一“下一刻”已受过另一股力，此时只把 $f$ 追加到 $\text{force[j]}$，形成对冲；后续因 `len(force[j])==2`，它将保持竖直。
 
-        若 `0 ≤ j < n`：
-
-        - 若 `time[j]==-1`，说明 *j* 从未受力，记录 `time[j]=time[i]+1` 并入队，同时把 `f` 写入 `force[j]`。
-        - 若 `time[j]==time[i]+1`，说明它在同一“下一刻”已受过另一股力，此时只把 `f` 追加到 `force[j]`，形成对冲；后续因 `len(force[j])==2`，它将保持竖直。
-
-3. **终态判定**
-
-    - 队列清空后，所有 `force[i]` 长度为 1 的位置倒向对应方向；长度为 2 的位置保持 `.`。最终将字符数组拼接为答案。
-
-最终相似字符串组的数量就是并查集中连通分量的数量。
+队列清空后，所有 $\text{force[i]}$ 长度为 1 的位置倒向对应方向；长度为 2 的位置保持 `.`。最终将字符数组拼接为答案。
 
 时间复杂度 $O(n)$，空间复杂度 $O(n)$。其中 $n$ 是骨牌的数量。
 

solution/0800-0899/0838.Push Dominoes/README_EN.md

@@ -69,34 +69,26 @@ tags:
 
 ### Solution 1: Multi-Source BFS
 
-Treat all dominoes initially pushed (`L` or `R`) as **sources**, which simultaneously propagate their forces outward. Use a queue to perform BFS layer by layer (0, 1, 2, ...):
+Treat all initially pushed dominoes (`L` or `R`) as **sources**, which simultaneously propagate their forces outward. Use a queue to perform BFS layer by layer (0, 1, 2, ...):
 
-1. **Modeling**
+We define $\text{time[i]}$ to record the first moment when the _i_-th domino is affected by a force, with `-1` indicating it has not been affected yet. We also define $\text{force[i]}$ as a variable-length list that stores the directions (`'L'`, `'R'`) of forces acting on the domino at the same moment. Initially, push all indices of `L/R` dominoes into the queue and set their `time` to 0.
 
-    - `time[i]` records the first moment when the _i_-th domino is affected by a force, with `-1` indicating it has not been affected yet.
-    - `force[i]` is a variable-length list that stores the directions (`'L'`, `'R'`) of forces acting on the domino at the same moment.
-    - Initially, push all indices of `L/R` dominoes into the queue and set their `time` to 0.
+When dequeuing index _i_, if $\text{force[i]}$ contains only one direction, the domino will fall in that direction $f$. Let the index of the next domino be:
 
-2. **Propagation Rules**
+$$
+j =
+\begin{cases}
+i - 1, & f = L,\\
+i + 1, & f = R.
+\end{cases}
+$$
 
-    - When dequeuing index _i_, if `force[i]` contains only one direction, the domino will fall in that direction `f`.
-    - Let the index of the next domino be:
+If $0 \leq j < n$:
 
-        $$
-        j=\begin{cases}
-          i-1,& f=L\\[2pt]
-          i+1,& f=R
-        \end{cases}
-        $$
+-   If $\text{time[j]} = -1$, it means _j_ has not been affected yet. Record $\text{time[j]} = \text{time[i]} + 1$, enqueue it, and append $f$ to $\text{force[j]}$.
+-   If $\text{time[j]} = \text{time[i]} + 1$, it means _j_ has already been affected by another force at the same "next moment." In this case, append $f$ to $\text{force[j]}$, causing a standoff. Subsequently, since $\text{len(force[j])} = 2$, it will remain upright.
 
-        If $0 \leq j < n$:
-
-        - If `time[j] == -1`, it means _j_ has not been affected yet. Record `time[j] = time[i] + 1`, enqueue it, and append `f` to `force[j]`.
-        - If `time[j] == time[i] + 1`, it means _j_ has already been affected by another force at the same "next moment." In this case, append `f` to `force[j]`, causing a standoff. Subsequently, since `len(force[j]) == 2`, it will remain upright.
-
-3. **Final State Determination**
-
-    - After the queue is emptied, all positions where `force[i]` has a length of 1 will fall in the corresponding direction, while positions with a length of 2 will remain as `.`. Finally, concatenate the character array to form the answer.
+After the queue is emptied, all positions where $\text{force[i]}$ has a length of 1 will fall in the corresponding direction, while positions with a length of 2 will remain as `.`. Finally, concatenate the character array to form the answer.
 
 The complexity is $O(n)$, and the space complexity is $O(n)$, where $n$ is the number of dominoes.
 
@@ -224,46 +216,46 @@ public:
 
 ```go
 func pushDominoes(dominoes string) string {
- n := len(dominoes)
- q := []int{}
- time := make([]int, n)
- for i := range time {
-  time[i] = -1
- }
- force := make([][]byte, n)
- for i, c := range dominoes {
-  if c != '.' {
-   q = append(q, i)
-   time[i] = 0
-   force[i] = append(force[i], byte(c))
-  }
- }
-
- ans := bytes.Repeat([]byte{'.'}, n)
- for len(q) > 0 {
-  i := q[0]
-  q = q[1:]
-  if len(force[i]) > 1 {
-   continue
-  }
-  f := force[i][0]
-  ans[i] = f
-  j := i - 1
-  if f == 'R' {
-   j = i + 1
-  }
-  if 0 <= j && j < n {
-   t := time[i]
-   if time[j] == -1 {
-    q = append(q, j)
-    time[j] = t + 1
-    force[j] = append(force[j], f)
-   } else if time[j] == t+1 {
-    force[j] = append(force[j], f)
-   }
-  }
- }
- return string(ans)
+	n := len(dominoes)
+	q := []int{}
+	time := make([]int, n)
+	for i := range time {
+		time[i] = -1
+	}
+	force := make([][]byte, n)
+	for i, c := range dominoes {
+		if c != '.' {
+			q = append(q, i)
+			time[i] = 0
+			force[i] = append(force[i], byte(c))
+		}
+	}
+
+	ans := bytes.Repeat([]byte{'.'}, n)
+	for len(q) > 0 {
+		i := q[0]
+		q = q[1:]
+		if len(force[i]) > 1 {
+			continue
+		}
+		f := force[i][0]
+		ans[i] = f
+		j := i - 1
+		if f == 'R' {
+			j = i + 1
+		}
+		if 0 <= j && j < n {
+			t := time[i]
+			if time[j] == -1 {
+				q = append(q, j)
+				time[j] = t + 1
+				force[j] = append(force[j], f)
+			} else if time[j] == t+1 {
+				force[j] = append(force[j], f)
+			}
+		}
+	}
+	return string(ans)
 }
 ```