feat: update lc problems

Author: yanglbme

solution/0000-0099/0091.Decode Ways/README.md

@@ -48,11 +48,9 @@
 <p><strong>示例 3：</strong></p>
 
 <pre>
-<strong>输入：</strong>s = "0"
+<strong>输入：</strong>s = "06"
 <strong>输出：</strong>0
-<strong>解释：</strong>没有字符映射到以 0 开头的数字。
-含有 0 的有效映射是 'J' -&gt; "10" 和 'T'-&gt; "20" 。
-由于没有字符，因此没有有效的方法对此进行解码，因为所有数字都需要映射。
+<strong>解释：</strong>"06" 无法映射到 "F" ，因为存在前导零（"6" 和 "06" 并不等价）。
 </pre>
 
 <p>&nbsp;</p>

solution/0600-0699/0649.Dota2 Senate/README.md

@@ -6,63 +6,56 @@
 
 <!-- 这里写题目描述 -->
 
-<p>Dota2 的世界里有两个阵营：<code>Radiant</code>(天辉)和 <code>Dire</code>(夜魇)</p>
+<p>Dota2 的世界里有两个阵营：<code>Radiant</code>（天辉）和&nbsp;<code>Dire</code>（夜魇）</p>
 
-<p>Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的<code><strong>一</strong></code>项：</p>
+<p>Dota2 参议院由来自两派的参议员组成。现在参议院希望对一个 Dota2 游戏里的改变作出决定。他们以一个基于轮为过程的投票进行。在每一轮中，每一位参议员都可以行使两项权利中的 <strong>一 </strong>项：</p>
 
-<ol>
-	<li>
-	<p><code>禁止一名参议员的权利</code>：</p>
-    <p>参议员可以让另一位参议员在这一轮和随后的几轮中丧失<strong>所有的权利</strong>。</p>
-    </li>
-    <li>
-    <p><code>宣布胜利</code>：</p>
-    </li>
-
-</ol>
-
-<p>          如果参议员发现有权利投票的参议员都是<strong>同一个阵营的</strong>，他可以宣布胜利并决定在游戏中的有关变化。</p>
-
-<p> </p>
+<ul>
+	<li><strong>禁止一名参议员的权利</strong>：参议员可以让另一位参议员在这一轮和随后的几轮中丧失<strong> 所有的权利 </strong>。</li>
+	<li><strong>宣布胜利</strong>：如果参议员发现有权利投票的参议员都是 <strong>同一个阵营的</strong> ，他可以宣布胜利并决定在游戏中的有关变化。</li>
+</ul>
 
-<p>给定一个字符串代表每个参议员的阵营。字母 “R” 和 “D” 分别代表了 <code>Radiant</code>（天辉）和 <code>Dire</code>（夜魇）。然后，如果有 <code>n</code> 个参议员，给定字符串的大小将是 <code>n</code>。</p>
+<p>给你一个字符串&nbsp;<code>senate</code> 代表每个参议员的阵营。字母 <code>'R'</code> 和 <code>'D'</code>分别代表了&nbsp;<code>Radiant</code>（天辉）和&nbsp;<code>Dire</code>（夜魇）。然后，如果有 <code>n</code> 个参议员，给定字符串的大小将是&nbsp;<code>n</code>。</p>
 
 <p>以轮为基础的过程从给定顺序的第一个参议员开始到最后一个参议员结束。这一过程将持续到投票结束。所有失去权利的参议员将在过程中被跳过。</p>
 
-<p>假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是 <code>Radiant</code> 或 <code>Dire</code>。</p>
+<p>假设每一位参议员都足够聪明，会为自己的政党做出最好的策略，你需要预测哪一方最终会宣布胜利并在 Dota2 游戏中决定改变。输出应该是&nbsp;<code>"Radiant"</code> 或 <code>"Dire"</code> 。</p>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 
 <pre>
-<strong>输入：</strong>"RD"
+<strong>输入：</strong>senate = "RD"
 <strong>输出：</strong>"Radiant"
-<strong>解释：</strong><code>第一个参议员来自 Radiant 阵营并且他可以使用第一项权利让第二个参议员失去权力，因此第二个参议员将被跳过因为他没有任何权利。然后在第二轮的时候，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人</code>
+<strong>解释：
+</strong><code>第 1 轮时，第一个参议员来自 Radiant 阵营，他可以使用第一项权利让第二个参议员失去所有权利。
+这一轮中，第二个参议员将会被跳过，因为他的权利被禁止了。
+第 2 轮时，第一个参议员可以宣布胜利，因为他是唯一一个有投票权的人</code>。
 </pre>
 
 <p><strong>示例 2：</strong></p>
 
 <pre>
-<strong>输入：</strong>"RDD"
+<strong>输入：</strong>senate = "RDD"
 <strong>输出：</strong>"Dire"
 <strong>解释：</strong>
-第一轮中,第一个<code>来自 Radiant 阵营的</code>参议员可以使用第一项权利禁止第二个参议员的权利
-第二个<code>来自 Dire 阵营的</code>参议员会被跳过因为他的权利被禁止
-第三个<code>来自 Dire 阵营的</code>参议员可以使用他的第一项权利禁止第一个参议员的权利
+第 1 轮时，第一个<code>来自 Radiant 阵营的</code>参议员可以使用第一项权利禁止第二个参议员的权利。
+<code>这一轮中，</code>第二个<code>来自 Dire 阵营的</code>参议员会将被跳过，因为他的权利被禁止了。
+<code>这一轮中，</code>第三个<code>来自 Dire 阵营的</code>参议员可以使用他的第一项权利禁止第一个参议员的权利。
 因此在第二轮只剩下第三个参议员拥有投票的权利,于是他可以宣布胜利
 </pre>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li>给定字符串的长度在 <code>[1, 10,000]</code> 之间.</li>
+	<li><code>n == senate.length</code></li>
+	<li><code>1 &lt;= n &lt;= 10<sup>4</sup></code></li>
+	<li><code>senate[i]</code> 为 <code>'R'</code> 或 <code>'D'</code></li>
 </ul>
 
-<p> </p>
-
 ## 解法
 
 <!-- 这里可写通用的实现逻辑 -->

solution/0700-0799/0768.Max Chunks To Make Sorted II/README.md

@@ -6,37 +6,40 @@
 
 <!-- 这里写题目描述 -->
 
-<p><em>这个问题和&ldquo;最多能完成排序的块&rdquo;相似，但给定数组中的元素可以重复，输入数组最大长度为<code>2000</code>，其中的元素最大为<code>10**8</code>。</em></p>
+<p>给你一个整数数组 <code>arr</code> 。</p>
 
-<p><code>arr</code>是一个可能包含<strong>重复元素</strong>的整数数组，我们将这个数组分割成几个&ldquo;块&rdquo;，并将这些块分别进行排序。之后再连接起来，使得连接的结果和按升序排序后的原数组相同。</p>
+<p>将 <code>arr</code> 分割成若干 <strong>块</strong> ，并将这些块分别进行排序。之后再连接起来，使得连接的结果和按升序排序后的原数组相同。</p>
 
-<p>我们最多能将数组分成多少块？</p>
+<p>返回能将数组分成的最多块数？</p>
+&nbsp;
 
-<p><strong>示例&nbsp;1:</strong></p>
+<p><strong class="example">示例 1：</strong></p>
 
 <pre>
-<strong>输入:</strong> arr = [5,4,3,2,1]
-<strong>输出:</strong> 1
-<strong>解释:</strong>
-将数组分成2块或者更多块，都无法得到所需的结果。
+<strong>输入：</strong>arr = [5,4,3,2,1]
+<strong>输出：</strong>1
+<strong>解释：</strong>
+将数组分成2块或者更多块，都无法得到所需的结果。 
 例如，分成 [5, 4], [3, 2, 1] 的结果是 [4, 5, 1, 2, 3]，这不是有序的数组。 
 </pre>
 
-<p><strong>示例 2:</strong></p>
+<p><strong class="example">示例 2：</strong></p>
 
 <pre>
-<strong>输入:</strong> arr = [2,1,3,4,4]
-<strong>输出:</strong> 4
-<strong>解释:</strong>
-我们可以把它分成两块，例如 [2, 1], [3, 4, 4]。
+<strong>输入：</strong>arr = [2,1,3,4,4]
+<strong>输出：</strong>4
+<strong>解释：</strong>
+可以把它分成两块，例如 [2, 1], [3, 4, 4]。 
 然而，分成 [2, 1], [3], [4], [4] 可以得到最多的块数。 
 </pre>
 
-<p><strong>注意:</strong></p>
+<p>&nbsp;</p>
+
+<p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>arr</code>的长度在<code>[1, 2000]</code>之间。</li>
-	<li><code>arr[i]</code>的大小在<code>[0, 10**8]</code>之间。</li>
+	<li><code>1 &lt;= arr.length &lt;= 2000</code></li>
+	<li><code>0 &lt;= arr[i] &lt;= 10<sup>8</sup></code></li>
 </ul>
 
 ## 解法

solution/0800-0899/0861.Score After Flipping Matrix/README.md

@@ -6,36 +6,44 @@
 
 <!-- 这里写题目描述 -->
 
-<p>有一个二维矩阵&nbsp;<code>A</code> 其中每个元素的值为&nbsp;<code>0</code>&nbsp;或&nbsp;<code>1</code>&nbsp;。</p>
+<p>给你一个大小为 <code>m x n</code> 的二元矩阵 <code>grid</code> ，矩阵中每个元素的值为 <code>0</code> 或 <code>1</code> 。</p>
 
-<p>移动是指选择任一行或列，并转换该行或列中的每一个值：将所有 <code>0</code> 都更改为 <code>1</code>，将所有 <code>1</code> 都更改为 <code>0</code>。</p>
+<p>一次 <strong>移动</strong> 是指选择任一行或列，并转换该行或列中的每一个值：将所有 <code>0</code> 都更改为 <code>1</code>，将所有 <code>1</code> 都更改为 <code>0</code>。</p>
 
-<p>在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的得分就是这些数字的总和。</p>
+<p>在做出任意次数的移动后，将该矩阵的每一行都按照二进制数来解释，矩阵的 <strong>得分</strong> 就是这些数字的总和。</p>
 
-<p>返回尽可能高的分数。</p>
+<p>在执行任意次 <strong>移动</strong> 后（含 0 次），返回可能的最高分数。</p>
 
 <p>&nbsp;</p>
 
 <ol>
 </ol>
 
-<p><strong>示例：</strong></p>
-
-<pre><strong>输入：</strong>[[0,0,1,1],[1,0,1,0],[1,1,0,0]]
+<p><strong class="example">示例 1：</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/0800-0899/0861.Score%20After%20Flipping%20Matrix/images/lc-toogle1.jpg" style="width: 500px; height: 299px;" />
+<pre>
+<strong>输入：</strong>grid = [[0,0,1,1],[1,0,1,0],[1,1,0,0]]
 <strong>输出：</strong>39
-<strong>解释：
-</strong>转换为 [[1,1,1,1],[1,0,0,1],[1,1,1,1]]
-0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39</pre>
+<strong>解释：</strong>0b1111 + 0b1001 + 0b1111 = 15 + 9 + 15 = 39
+</pre>
+
+<p><strong class="example">示例 2：</strong></p>
+
+<pre>
+<strong>输入：</strong>grid = [[0]]
+<strong>输出：</strong>1
+</pre>
 
 <p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
-<ol>
-	<li><code>1 &lt;= A.length &lt;= 20</code></li>
-	<li><code>1 &lt;= A[0].length &lt;= 20</code></li>
-	<li><code>A[i][j]</code>&nbsp;是&nbsp;<code>0</code> 或&nbsp;<code>1</code></li>
-</ol>
+<ul>
+	<li><code>m == grid.length</code></li>
+	<li><code>n == grid[i].length</code></li>
+	<li><code>1 &lt;= m, n &lt;= 20</code></li>
+	<li><code>grid[i][j]</code> 为 <code>0</code> 或 <code>1</code></li>
+</ul>
 
 ## 解法
 

solution/0800-0899/0882.Reachable Nodes In Subdivided Graph/README.md

@@ -10,7 +10,7 @@
 
 <p>图用由边组成的二维数组 <code>edges</code> 表示，其中&nbsp;<code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>, cnt<sub>i</sub>]</code> 表示原始图中节点&nbsp;<code>u<sub>i</sub></code> 和&nbsp;<code>v<sub>i</sub></code> 之间存在一条边，<code>cnt<sub>i</sub></code> 是将边 <strong>细分</strong> 后的新节点总数。注意，<code>cnt<sub>i</sub> == 0</code> 表示边不可细分。</p>
 
-<p>要 <strong>细分</strong> 边 <code>[ui, vi]</code> ，需要将其替换为 <code>(cnt<sub>i</sub> + 1)</code> 条新边，和&nbsp;<code>cnt<sub>i</sub></code> 个新节点。新节点为 <code>x<sub>1</sub></code>, <code>x<sub>2</sub></code>, ..., <code>x<sub>cnt<sub>i</sub></sub></code> ，新边为 <code>[u<sub>i</sub>, x<sub>1</sub>]</code>, <code>[x<sub>1</sub>, x<sub>2</sub>]</code>, <code>[x<sub>2</sub>, x<sub>3</sub>]</code>, ..., <code>[x<sub>cnt<sub>i</sub>+1</sub>, x<sub>cnt<sub>i</sub></sub>]</code>, <code>[x<sub>cnt<sub>i</sub></sub>, v<sub>i</sub>]</code> 。</p>
+<p>要 <strong>细分</strong> 边 <code>[ui, vi]</code> ，需要将其替换为 <code>(cnt<sub>i</sub> + 1)</code> 条新边，和&nbsp;<code>cnt<sub>i</sub></code> 个新节点。新节点为 <code>x<sub>1</sub></code>, <code>x<sub>2</sub></code>, ..., <code>x<sub>cnt<sub>i</sub></sub></code> ，新边为 <code>[u<sub>i</sub>, x<sub>1</sub>]</code>, <code>[x<sub>1</sub>, x<sub>2</sub>]</code>, <code>[x<sub>2</sub>, x<sub>3</sub>]</code>, ..., <code>[x<sub>cnt<sub>i</sub>-1</sub>, x<sub>cnt<sub>i</sub></sub>]</code>, <code>[x<sub>cnt<sub>i</sub></sub>, v<sub>i</sub>]</code> 。</p>
 
 <p>现在得到一个&nbsp;<strong>新的细分图</strong> ，请你计算从节点 <code>0</code> 出发，可以到达多少个节点？如果节点间距离是 <code>maxMoves</code> 或更少，则视为 <strong>可以到达</strong> 。</p>
 

solution/0900-0999/0991.Broken Calculator/README.md

@@ -46,7 +46,7 @@
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>1 &lt;= x, y &lt;= 10<sup>9</sup></code></li>
+	<li><code>1 &lt;= startValue, target &lt;= 10<sup>9</sup></code></li>
 </ul>
 
 ## 解法

solution/1000-1099/1007.Minimum Domino Rotations For Equal Row/README.md

@@ -6,43 +6,43 @@
 
 <!-- 这里写题目描述 -->
 
-<p>在一排多米诺骨牌中，<code>A[i]</code> 和 <code>B[i]</code>&nbsp;分别代表第 i 个多米诺骨牌的上半部分和下半部分。（一个多米诺是两个从 1 到 6 的数字同列平铺形成的&nbsp;&mdash;&mdash; 该平铺的每一半上都有一个数字。）</p>
+<p>在一排多米诺骨牌中，<code>tops[i]</code> 和 <code>bottoms[i]</code>&nbsp;分别代表第 <code>i</code> 个多米诺骨牌的上半部分和下半部分。（一个多米诺是两个从 1 到 6 的数字同列平铺形成的&nbsp;—— 该平铺的每一半上都有一个数字。）</p>
 
-<p>我们可以旋转第&nbsp;<code>i</code>&nbsp;张多米诺，使得&nbsp;<code>A[i]</code> 和&nbsp;<code>B[i]</code>&nbsp;的值交换。</p>
+<p>我们可以旋转第&nbsp;<code>i</code>&nbsp;张多米诺，使得 <code>tops[i]</code> 和 <code>bottoms[i]</code>&nbsp;的值交换。</p>
 
-<p>返回能使 <code>A</code> 中所有值或者 <code>B</code> 中所有值都相同的最小旋转次数。</p>
+<p>返回能使 <code>tops</code> 中所有值或者 <code>bottoms</code> 中所有值都相同的最小旋转次数。</p>
 
 <p>如果无法做到，返回&nbsp;<code>-1</code>.</p>
 
 <p>&nbsp;</p>
 
-<p><strong>示例 1：</strong></p>
-
-<p><img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1000-1099/1007.Minimum%20Domino%20Rotations%20For%20Equal%20Row/images/domino.png" style="height: 161px; width: 200px;"></p>
-
-<pre><strong>输入：</strong>A = [2,1,2,4,2,2], B = [5,2,6,2,3,2]
+<p><strong class="example">示例 1：</strong></p>
+<img alt="" src="https://fastly.jsdelivr.net/gh/doocs/leetcode@main/solution/1000-1099/1007.Minimum%20Domino%20Rotations%20For%20Equal%20Row/images/domino.png" style="height: 300px; width: 421px;" />
+<pre>
+<strong>输入：</strong>tops = [2,1,2,4,2,2], bottoms = [5,2,6,2,3,2]
 <strong>输出：</strong>2
-<strong>解释：</strong>
-图一表示：在我们旋转之前， A 和 B 给出的多米诺牌。
-如果我们旋转第二个和第四个多米诺骨牌，我们可以使上面一行中的每个值都等于 2，如图二所示。
+<strong>解释：</strong> 
+图一表示：在我们旋转之前， tops 和 bottoms 给出的多米诺牌。 
+如果我们旋转第二个和第四个多米诺骨牌，我们可以使上面一行中的每个值都等于 2，如图二所示。 
 </pre>
 
-<p><strong>示例 2：</strong></p>
+<p><strong class="example">示例 2：</strong></p>
 
-<pre><strong>输入：</strong>A = [3,5,1,2,3], B = [3,6,3,3,4]
+<pre>
+<strong>输入：</strong>tops = [3,5,1,2,3], bottoms = [3,6,3,3,4]
 <strong>输出：</strong>-1
-<strong>解释：</strong>
-在这种情况下，不可能旋转多米诺牌使一行的值相等。
+<strong>解释：</strong> 在这种情况下，不可能旋转多米诺牌使一行的值相等。
 </pre>
 
 <p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
-<ol>
-	<li><code>1 &lt;= A[i], B[i] &lt;= 6</code></li>
-	<li><code>2 &lt;= A.length == B.length &lt;= 20000</code></li>
-</ol>
+<ul>
+	<li><code>2 &lt;= tops.length &lt;= 2 * 10<sup>4</sup></code></li>
+	<li><code>bottoms.length == tops.length</code></li>
+	<li><code>1 &lt;= tops[i], bottoms[i] &lt;= 6</code></li>
+</ul>
 
 ## 解法
 

solution/1000-1099/1053.Previous Permutation With One Swap/README.md

@@ -6,11 +6,11 @@
 
 <!-- 这里写题目描述 -->
 
-<p>给你一个正整数的数组 <code>A</code>（其中的元素不一定完全不同），请你返回可在 <strong>一次交换</strong>（交换两数字 <code>A[i]</code> 和 <code>A[j]</code> 的位置）后得到的、按字典序排列小于 <code>A</code> 的最大可能排列。</p>
+<p>给你一个正整数数组 <code>arr</code>（其中的元素不一定完全不同），请你返回可在&nbsp;<strong>一次交换</strong>（交换两数字 <code>arr[i]</code> 和 <code>arr[j]</code> 的位置）后得到的、按字典序排列小于 <code>arr</code> 的最大可能排列。</p>
 
 <p>如果无法这么操作，就请返回原数组。</p>
 
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>示例 1：</strong></p>
 
@@ -36,21 +36,13 @@
 <strong>解释：</strong>交换 9 和 7
 </pre>
 
-<p><strong>示例 4：</strong></p>
-
-<pre>
-<strong>输入：</strong>arr = [3,1,1,3]
-<strong>输出：</strong>[1,3,1,3]
-<strong>解释：</strong>交换 1 和 3
-</pre>
-
-<p> </p>
+<p>&nbsp;</p>
 
 <p><strong>提示：</strong></p>
 
 <ul>
-	<li><code>1 <= arr.length <= 10<sup>4</sup></code></li>
-	<li><code>1 <= arr[i] <= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= arr.length &lt;= 10<sup>4</sup></code></li>
+	<li><code>1 &lt;= arr[i] &lt;= 10<sup>4</sup></code></li>
 </ul>
 
 ## 解法

solution/1000-1099/1053.Previous Permutation With One Swap/README_EN.md

@@ -4,7 +4,7 @@
 
 ## Description
 
-<p>Given an array of positive integers <code>arr</code> (not necessarily distinct), return <em>the lexicographically largest permutation that is smaller than</em> <code>arr</code>, that can be <strong>made with exactly one swap</strong> (A <em>swap</em> exchanges the positions of two numbers <code>arr[i]</code> and <code>arr[j]</code>). If it cannot be done, then return the same array.</p>
+<p>Given an array of positive integers <code>arr</code> (not necessarily distinct), return <em>the </em><span data-keyword="lexicographically-smaller-array"><em>lexicographically</em></span><em> largest permutation that is smaller than</em> <code>arr</code>, that can be <strong>made with exactly one swap</strong> (A <em>swap</em> exchanges the positions of two numbers <code>arr[i]</code> and <code>arr[j]</code>). If it cannot be done, then return the same array.</p>
 
 <p>&nbsp;</p>
 <p><strong class="example">Example 1:</strong></p>