coder-xiaomo/leetcode-problemset
1
0
Fork 0
mirror of https://gitee.com/coder-xiaomo/leetcode-problemset synced 2025-09-05 23:41:41 +08:00
Code Issues Projects Releases Wiki Activity GitHub Gitee

update

Browse Source
This commit is contained in:
zhangbk1
2024-08-06 08:46:50 +08:00
parent 43a450d3d7
commit 91ca37c7ef
114 changed files with 28799 additions and 15728 deletions
Download Patch File Download Diff File Expand all files Collapse all files

82
leetcode-cn/problem (Chinese)/交替组 III [alternating-groups-iii].html Normal file
View File

@@ -0,0 +1,82 @@
<p>给你一个整数数组 <code>colors</code> 和一个二维整数数组 <code>queries</code> 。<code>colors</code>表示一个由红色和蓝色瓷砖组成的环，第 <code>i</code>&nbsp;块瓷砖的颜色为&nbsp;<code>colors[i]</code>&nbsp;：</p>
<ul>
<li><code>colors[i] == 0</code>&nbsp;表示第&nbsp;<code>i</code>&nbsp;块瓷砖的颜色是 <strong>红色</strong>&nbsp;。</li>
<li><code>colors[i] == 1</code>&nbsp;表示第 <code>i</code>&nbsp;块瓷砖的颜色是 <strong>蓝色</strong>&nbsp;。</li>
</ul>
<p>环中连续若干块瓷砖的颜色如果是 <strong>交替</strong>&nbsp;颜色（也就是说这组瓷砖中除了第一块和最后一块瓷砖以外，中间瓷砖的颜色与它<strong>&nbsp;左边</strong>&nbsp;和 <strong>右边</strong>&nbsp;的颜色都不同），那么它被称为一个 <strong>交替组</strong>。</p>
<p>你需要处理两种类型的查询：</p>
<ul>
<li><code>queries[i] = [1, size<sub>i</sub>]</code>，确定大小为<code>size<sub>i</sub></code>的<strong> </strong><strong>交替组</strong> 的数量。</li>
<li><code>queries[i] = [2, index<sub>i</sub>, color<sub>i</sub>]</code>，将<code>colors[index<sub>i</sub>]</code>更改为<code>color<sub>i</sub></code>。</li>
</ul>
<p>返回数组 <code>answer</code>，数组中按顺序包含第一种类型查询的结果。</p>
<p><b>注意</b>&nbsp;，由于&nbsp;<code>colors</code>&nbsp;表示一个 <strong>环</strong>&nbsp;，<strong>第一块</strong>&nbsp;瓷砖和 <strong>最后一块</strong>&nbsp;瓷砖是相邻的。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">colors = [0,1,1,0,1], queries = [[2,1,0],[1,4]]</span></p>
<p><strong>输出：</strong><span class="example-io">[2]</span></p>
<p><strong>解释：</strong></p>
<p>第一次查询：</p>
<p>将 <code>colors[1]</code> 改为 0。</p>
<p><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/03/screenshot-from-2024-06-03-20-20-25.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></p>
<p>第二次查询：</p>
<p>统计大小为 4 的交替组的数量：</p>
<p><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/03/screenshot-from-2024-06-03-20-25-02-2.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/03/screenshot-from-2024-06-03-20-24-12.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">colors = [0,0,1,0,1,1], queries = [[1,3],[2,3,0],[1,5]]</span></p>
<p><strong>输出：</strong><span class="example-io">[2,0]</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/03/screenshot-from-2024-06-03-20-35-50.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></p>
<p>第一次查询：</p>
<p>统计大小为 3 的交替组的数量。</p>
<p><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/03/screenshot-from-2024-06-03-20-37-13.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /><img alt="" data-darkreader-inline-bgcolor="" data-darkreader-inline-bgimage="" src="https://assets.leetcode.com/uploads/2024/06/03/screenshot-from-2024-06-03-20-36-40.png" style="width: 150px; height: 150px; padding: 10px; background: rgb(255, 255, 255); border-radius: 0.5rem; --darkreader-inline-bgimage: initial; --darkreader-inline-bgcolor: #181a1b;" /></p>
<p>第二次查询：<code>colors</code>不变。</p>
<p>第三次查询：不存在大小为 5 的交替组。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>4 &lt;= colors.length &lt;= 5 * 10<sup>4</sup></code></li>
<li><code>0 &lt;= colors[i] &lt;= 1</code></li>
<li><code>1 &lt;= queries.length &lt;= 5 * 10<sup>4</sup></code></li>
<li><code>queries[i][0] == 1</code> 或 <code>queries[i][0] == 2</code></li>
<li>对于所有的<code>i</code>：
<ul>
<li><code>queries[i][0] == 1</code>： <code>queries[i].length == 2</code>, <code>3 &lt;= queries[i][1] &lt;= colors.length - 1</code></li>
<li><code>queries[i][0] == 2</code>： <code>queries[i].length == 3</code>, <code>0 &lt;= queries[i][1] &lt;= colors.length - 1</code>, <code>0 &lt;= queries[i][2] &lt;= 1</code></li>
</ul>
</li>
</ul>

50
leetcode-cn/problem (Chinese)/使两个整数相等的位更改次数 [number-of-bit-changes-to-make-two-integers-equal].html Normal file
View File

@@ -0,0 +1,50 @@
<p>给你两个正整数 <code>n</code> 和 <code>k</code>。</p>
<p>你可以选择 <code>n</code> 的 <strong>二进制表示</strong> 中任意一个值为 1 的位，并将其改为 0。</p>
<p>返回使得 <code>n</code> 等于 <code>k</code> 所需要的更改次数。如果无法实现，返回 -1。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">n = 13, k = 4</span></p>
<p><strong>输出：</strong> <span class="example-io">2</span></p>
<p><strong>解释：</strong><br />
最初，<code>n</code> 和 <code>k</code> 的二进制表示分别为 <code>n = (1101)<sub>2</sub></code> 和 <code>k = (0100)<sub>2</sub></code>，</p>
<p>我们可以改变 <code>n</code> 的第一位和第四位。结果整数为 <code>n = (<u><strong>0</strong></u>10<u><strong>0</strong></u>)<sub>2</sub> = k</code>。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">n = 21, k = 21</span></p>
<p><strong>输出：</strong> <span class="example-io">0</span></p>
<p><strong>解释：</strong><br />
<code>n</code> 和 <code>k</code> 已经相等，因此不需要更改。</p>
</div>
<p><strong class="example">示例 3：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">n = 14, k = 13</span></p>
<p><strong>输出：</strong> <span class="example-io">-1</span></p>
<p><strong>解释：</strong><br />
无法使 <code>n</code> 等于 <code>k</code>。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= n, k &lt;= 10<sup>6</sup></code></li>
</ul>

59
leetcode-cn/problem (Chinese)/使差值相等的最少数组改动次数 [minimum-array-changes-to-make-differences-equal].html Normal file
View File

@@ -0,0 +1,59 @@
<p>给你一个长度为 <code>n</code>&nbsp;的整数数组&nbsp;<code>nums</code>&nbsp;，<code>n</code>&nbsp;是 <strong>偶数</strong>&nbsp;，同时给你一个整数&nbsp;<code>k</code>&nbsp;。</p>
<p>你可以对数组进行一些操作。每次操作中，你可以将数组中 <strong>任一</strong>&nbsp;元素替换为 <code>0</code>&nbsp;到 <code>k</code>&nbsp;之间的<strong>&nbsp;任一</strong>&nbsp;整数。</p>
<p>执行完所有操作以后，你需要确保最后得到的数组满足以下条件：</p>
<ul>
<li>存在一个整数 <code>X</code>&nbsp;，满足对于所有的&nbsp;<code>(0 &lt;= i &lt; n)</code>&nbsp;都有&nbsp;<code>abs(a[i] - a[n - i - 1]) = X</code>&nbsp;。</li>
</ul>
<p>请你返回满足以上条件 <strong>最少</strong>&nbsp;修改次数。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>nums = [1,0,1,2,4,3], k = 4</span></p>
<p><span class="example-io"><b>输出：</b>2</span></p>
<p><strong>解释：</strong><br />
我们可以执行以下操作：</p>
<ul>
<li>将&nbsp;<code>nums[1]</code>&nbsp;变为 2 ，结果数组为&nbsp;<code>nums = [1,<em><strong>2</strong></em>,1,2,4,3]</code>&nbsp;。</li>
<li>将&nbsp;<code>nums[3]</code>&nbsp;变为 3 ，结果数组为&nbsp;<code>nums = [1,2,1,<em><strong>3</strong></em>,4,3]</code>&nbsp;。</li>
</ul>
<p>整数&nbsp;<code>X</code>&nbsp;为 2 。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>nums = [0,1,2,3,3,6,5,4], k = 6</span></p>
<p><span class="example-io"><b>输出：</b>2</span></p>
<p><strong>解释：</strong><br />
我们可以执行以下操作：</p>
<ul>
<li>将&nbsp;<code>nums[3]</code>&nbsp;变为 0 ，结果数组为&nbsp;<code>nums = [0,1,2,<em><strong>0</strong></em>,3,6,5,4]</code>&nbsp;。</li>
<li>将&nbsp;<code>nums[4]</code>&nbsp;变为 4 ，结果数组为&nbsp;<code>nums = [0,1,2,0,<em><strong>4</strong></em>,6,5,4]</code>&nbsp;。</li>
</ul>
<p>整数 <code>X</code>&nbsp;为 4 。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>2 &lt;= n == nums.length &lt;= 10<sup>5</sup></code></li>
<li><code>n</code>&nbsp;是偶数。</li>
<li><code>0 &lt;= nums[i] &lt;= k &lt;= 10<sup>5</sup></code></li>
</ul>

47
leetcode-cn/problem (Chinese)/使数组等于目标数组所需的最少操作次数 [minimum-operations-to-make-array-equal-to-target].html Normal file
View File

@@ -0,0 +1,47 @@
<p>给你两个长度相同的正整数数组 <code>nums</code> 和 <code>target</code>。</p>
<p>在一次操作中，你可以选择 <code>nums</code> 的任何<span data-keyword="subarray">子数组</span>，并将该子数组内的每个元素的值增加或减少 1。</p>
<p>返回使 <code>nums</code> 数组变为 <code>target</code> 数组所需的 <strong>最少 </strong>操作次数。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">nums = [3,5,1,2], target = [4,6,2,4]</span></p>
<p><strong>输出：</strong> <span class="example-io">2</span></p>
<p><strong>解释：</strong></p>
<p>执行以下操作可以使 <code>nums</code> 等于 <code>target</code>：<br />
- <code>nums[0..3]</code> 增加 1，<code>nums = [4,6,2,3]</code>。<br />
- <code>nums[3..3]</code> 增加 1，<code>nums = [4,6,2,4]</code>。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">nums = [1,3,2], target = [2,1,4]</span></p>
<p><strong>输出：</strong> <span class="example-io">5</span></p>
<p><strong>解释：</strong></p>
<p>执行以下操作可以使 <code>nums</code> 等于 <code>target</code>：<br />
- <code>nums[0..0]</code> 增加 1，<code>nums = [2,3,2]</code>。<br />
- <code>nums[1..1]</code> 减少 1，<code>nums = [2,2,2]</code>。<br />
- <code>nums[1..1]</code> 减少 1，<code>nums = [2,1,2]</code>。<br />
- <code>nums[2..2]</code> 增加 1，<code>nums = [2,1,3]</code>。<br />
- <code>nums[2..2]</code> 增加 1，<code>nums = [2,1,4]</code>。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= nums.length == target.length &lt;= 10<sup>5</sup></code></li>
<li><code>1 &lt;= nums[i], target[i] &lt;= 10<sup>8</sup></code></li>
</ul>

52
leetcode-cn/problem (Chinese)/判断是否可以赢得数字游戏 [find-if-digit-game-can-be-won].html Normal file
View File

@@ -0,0 +1,52 @@
<p>给你一个 <strong>正整数 </strong>数组 <code>nums</code>。</p>
<p>Alice 和 Bob 正在玩游戏。在游戏中，Alice 可以从 <code>nums</code> 中选择所有个位数 <strong>或</strong> 所有两位数，剩余的数字归 Bob 所有。如果 Alice 所选数字之和 <strong>严格大于 </strong>Bob 的数字之和，则 Alice 获胜。</p>
<p>如果 Alice 能赢得这场游戏，返回 <code>true</code>；否则，返回 <code>false</code>。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">nums = [1,2,3,4,10]</span></p>
<p><strong>输出：</strong><span class="example-io">false</span></p>
<p><strong>解释：</strong></p>
<p>Alice&nbsp;不管选个位数还是两位数都无法赢得比赛。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">nums = [1,2,3,4,5,14]</span></p>
<p><strong>输出：</strong><span class="example-io">true</span></p>
<p><strong>解释：</strong></p>
<p>Alice&nbsp;选择个位数可以赢得比赛，所选数字之和为 15。</p>
</div>
<p><strong class="example">示例 3：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">nums = [5,5,5,25]</span></p>
<p><strong>输出：</strong><span class="example-io">true</span></p>
<p><strong>解释：</strong></p>
<p>Alice&nbsp;选择两位数可以赢得比赛，所选数字之和为 25。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= nums.length &lt;= 100</code></li>
<li><code>1 &lt;= nums[i] &lt;= 99</code></li>
</ul>

72
leetcode-cn/problem (Chinese)/判断矩形的两个角落是否可达 [check-if-the-rectangle-corner-is-reachable].html Normal file
View File

@@ -0,0 +1,72 @@
<p>给你两个正整数&nbsp;<code>X</code> 和&nbsp;<code>Y</code>&nbsp;和一个二维整数数组&nbsp;<code>circles</code>&nbsp;，其中&nbsp;<code>circles[i] = [x<sub>i</sub>, y<sub>i</sub>, r<sub>i</sub>]</code>&nbsp;表示一个圆心在&nbsp;<code>(x<sub>i</sub>, y<sub>i</sub>)</code>&nbsp;半径为&nbsp;<code>r<sub>i</sub></code>&nbsp;的圆。</p>
<p>坐标平面内有一个左下角在原点，右上角在&nbsp;<code>(X, Y)</code>&nbsp;的矩形。你需要判断是否存在一条从左下角到右上角的路径满足：路径&nbsp;<strong>完全</strong>&nbsp;在矩形内部，<strong>不会</strong>&nbsp;触碰或者经过 <strong>任何</strong>&nbsp;圆的内部和边界，同时&nbsp;<strong>只</strong> 在起点和终点接触到矩形。</p>
<p>如果存在这样的路径，请你返回&nbsp;<code>true</code>&nbsp;，否则返回&nbsp;<code>false</code>&nbsp;。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>X = 3, Y = 4, circles = [[2,1,1]]</span></p>
<p><span class="example-io"><b>输出：</b>true</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/05/18/example2circle1.png" style="width: 346px; height: 264px;" /></p>
<p>黑色曲线表示一条从&nbsp;<code>(0, 0)</code>&nbsp;到&nbsp;<code>(3, 4)</code>&nbsp;的路径。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>X = 3, Y = 3, circles = [[1,1,2]]</span></p>
<p><span class="example-io"><b>输出：</b>false</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/05/18/example1circle.png" style="width: 346px; height: 264px;" /></p>
<p>不存在从&nbsp;<code>(0, 0)</code> 到&nbsp;<code>(3, 3)</code>&nbsp;的路径。</p>
</div>
<p><strong class="example">示例 3：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>X = 3, Y = 3, circles = [[2,1,1],[1,2,1]]</span></p>
<p><span class="example-io"><b>输出：</b>false</span></p>
<p><b>解释：</b></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/05/18/example0circle.png" style="width: 346px; height: 264px;" /></p>
<p>不存在从&nbsp;<code>(0, 0)</code>&nbsp;到&nbsp;<code>(3, 3)</code>&nbsp;的路径。</p>
</div>
<p><strong class="example">示例 4：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">X = 4, Y = 4, circles = [[5,5,1]]</span></p>
<p><span class="example-io"><b>输出：</b>true</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/04/rectangles.png" style="width: 346px; height: 264px;" /></p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>3 &lt;= X, Y &lt;= 10<sup>9</sup></code></li>
<li><code>1 &lt;= circles.length &lt;= 1000</code></li>
<li><code>circles[i].length == 3</code></li>
<li><code>1 &lt;= x<sub>i</sub>, y<sub>i</sub>, r<sub>i</sub> &lt;= 10<sup>9</sup></code></li>
</ul>

83
leetcode-cn/problem (Chinese)/奇数和偶数交易 [odd-and-even-transactions].html Normal file
View File

@@ -0,0 +1,83 @@
<p>表：<code>transactions</code></p>
<pre>
+------------------+------+
| Column Name | Type |
+------------------+------+
| transaction_id | int |
| amount | int |
| transaction_date | date |
+------------------+------+
transactions_id 列唯一标识了表中的每一行。
这张表的每一行包含交易 id，金额总和和交易日期。
</pre>
<p>编写一个解决方案来查找每天 <strong>奇数</strong> 交易金额和 <strong>偶数</strong> 交易金额的 <strong>总和</strong>。如果某天没有奇数或偶数交易，显示为&nbsp;<code>0</code>。</p>
<p>返回结果表以&nbsp;<code>transaction_date</code> <strong>升序</strong>&nbsp;排序。</p>
<p>结果格式如下所示。</p>
<p>&nbsp;</p>
<p><strong class="example">示例：</strong></p>
<div class="example-block">
<p><b>输入：</b></p>
<p><code>transactions</code> 表：</p>
<pre class="example-io">
+----------------+--------+------------------+
| transaction_id | amount | transaction_date |
+----------------+--------+------------------+
| 1 | 150 | 2024-07-01 |
| 2 | 200 | 2024-07-01 |
| 3 | 75 | 2024-07-01 |
| 4 | 300 | 2024-07-02 |
| 5 | 50 | 2024-07-02 |
| 6 | 120 | 2024-07-03 |
+----------------+--------+------------------+
</pre>
<p><strong>输出：</strong></p>
<pre class="example-io">
+------------------+---------+----------+
| transaction_date | odd_sum | even_sum |
+------------------+---------+----------+
| 2024-07-01 | 75 | 350 |
| 2024-07-02 | 0 | 350 |
| 2024-07-03 | 0 | 120 |
+------------------+---------+----------+
</pre>
<p><strong>解释：</strong></p>
<ul>
<li>对于交易日期：
<ul>
<li>2024-07-01:
<ul>
<li>奇数交易金额总和：75</li>
<li>偶数交易金额总和：150 + 200 = 350</li>
</ul>
</li>
<li>2024-07-02:
<ul>
<li>奇数交易金额总和：0</li>
<li>偶数交易金额总和：300 + 50 = 350</li>
</ul>
</li>
<li>2024-07-03:
<ul>
<li>奇数交易金额总和：0</li>
<li>偶数交易金额总和：120</li>
</ul>
</li>
</ul>
</li>
</ul>
<p><b>注意：</b>输出表以&nbsp;<code>transaction_date</code>&nbsp;升序排序。</p>
</div>

54
leetcode-cn/problem (Chinese)/字符串元音游戏 [vowels-game-in-a-string].html Normal file
View File

@@ -0,0 +1,54 @@
<p>小红和小明在玩一个字符串元音游戏。</p>
<p>给你一个字符串 <code>s</code>，小红和小明将轮流参与游戏，小红<strong> 先 </strong>开始：</p>
<ul>
<li>在小红的回合，她必须移除 <code>s</code> 中包含 <strong>奇数 </strong>个元音的任意 <strong>非空</strong> <span data-keyword="substring">子字符串</span>。</li>
<li>在小明的回合，他必须移除 <code>s</code> 中包含 <strong>偶数 </strong>个元音的任意 <strong>非空</strong> <span data-keyword="substring">子字符串</span>。</li>
</ul>
<p>第一个无法在其回合内进行移除操作的玩家输掉游戏。假设小红和小明都采取 <strong>最优策略 </strong>。</p>
<p>如果小红赢得游戏，返回 <code>true</code>，否则返回 <code>false</code>。</p>
<p>英文元音字母包括：<code>a</code>, <code>e</code>, <code>i</code>, <code>o</code>, 和 <code>u</code>。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">s = "leetcoder"</span></p>
<p><strong>输出：</strong> <span class="example-io">true</span></p>
<p><strong>解释：</strong><br />
小红可以执行如下移除操作来赢得游戏：</p>
<ul>
<li>小红先手，她可以移除加下划线的子字符串 <code>s = "<u><strong>leetco</strong></u>der"</code>，其中包含 3 个元音。结果字符串为 <code>s = "der"</code>。</li>
<li>小明接着，他可以移除加下划线的子字符串 <code>s = "<u><strong>d</strong></u>er"</code>，其中包含 0 个元音。结果字符串为 <code>s = "er"</code>。</li>
<li>小红再次操作，她可以移除整个字符串 <code>s = "<strong><u>er</u></strong>"</code>，其中包含 1 个元音。</li>
<li>又轮到小明，由于字符串为空，无法执行移除操作，因此小红赢得游戏。</li>
</ul>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">s = "bbcd"</span></p>
<p><strong>输出：</strong> <span class="example-io">false</span></p>
<p><strong>解释：</strong><br />
小红在她的第一回合无法执行移除操作，因此小红输掉了游戏。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
<li><code>s</code> 仅由小写英文字母组成。</li>
</ul>

48
leetcode-cn/problem (Chinese)/将 1 移动到末尾的最大操作次数 [maximum-number-of-operations-to-move-ones-to-the-end].html Normal file
View File

@@ -0,0 +1,48 @@
<p>给你一个 <span data-keyword="binary-string">二进制字符串</span> <code>s</code>。</p>
<p>你可以对这个字符串执行 <strong>任意次</strong> 下述操作：</p>
<ul>
<li>选择字符串中的任一下标 <code>i</code>（ <code>i + 1 &lt; s.length</code> ），该下标满足 <code>s[i] == '1'</code> 且 <code>s[i + 1] == '0'</code>。</li>
<li>将字符 <code>s[i]</code> 向 <strong>右移 </strong>直到它到达字符串的末端或另一个 <code>'1'</code>。例如，对于 <code>s = "010010"</code>，如果我们选择 <code>i = 1</code>，结果字符串将会是 <code>s = "0<strong><u>001</u></strong>10"</code>。</li>
</ul>
<p>返回你能执行的<strong> 最大 </strong>操作次数。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">s = "1001101"</span></p>
<p><strong>输出：</strong> <span class="example-io">4</span></p>
<p><strong>解释：</strong></p>
<p>可以执行以下操作：</p>
<ul>
<li>选择下标 <code>i = 0</code>。结果字符串为 <code>s = "<u><strong>001</strong></u>1101"</code>。</li>
<li>选择下标 <code>i = 4</code>。结果字符串为 <code>s = "0011<u><strong>01</strong></u>1"</code>。</li>
<li>选择下标 <code>i = 3</code>。结果字符串为 <code>s = "001<strong><u>01</u></strong>11"</code>。</li>
<li>选择下标 <code>i = 2</code>。结果字符串为 <code>s = "00<strong><u>01</u></strong>111"</code>。</li>
</ul>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">s = "00111"</span></p>
<p><strong>输出：</strong> <span class="example-io">0</span></p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 10<sup>5</sup></code></li>
<li><code>s[i]</code> 为 <code>'0'</code> 或 <code>'1'</code>。</li>
</ul>

49
leetcode-cn/problem (Chinese)/操作后字符串的最短长度 [minimum-length-of-string-after-operations].html Normal file
View File

@@ -0,0 +1,49 @@
<p>给你一个字符串&nbsp;<code>s</code>&nbsp;。</p>
<p>你需要对 <code>s</code>&nbsp;执行以下操作 <strong>任意</strong>&nbsp;次：</p>
<ul>
<li>选择一个下标 <code>i</code>&nbsp;，满足 <code>s[i]</code>&nbsp;左边和右边都&nbsp;<strong>至少</strong>&nbsp;有一个字符与它相同。</li>
<li>删除 <code>s[i]</code>&nbsp;<strong>左边</strong>&nbsp;离它 <strong>最近</strong>&nbsp;且相同的字符。</li>
<li>删除 <code>s[i]</code>&nbsp;<strong>右边</strong>&nbsp;离它 <strong>最近</strong>&nbsp;且相同的字符。</li>
</ul>
<p>请你返回执行完所有操作后， <code>s</code>&nbsp;的 <strong>最短</strong>&nbsp;长度。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>s = "abaacbcbb"</span></p>
<p><span class="example-io"><b>输出：</b>5</span></p>
<p><strong>解释：</strong><br />
我们执行以下操作：</p>
<ul>
<li>选择下标 2 ，然后删除下标 0 和 3 处的字符，得到&nbsp;<code>s = "bacbcbb"</code>&nbsp;。</li>
<li>选择下标 3 ，然后删除下标 0 和 5 处的字符，得到&nbsp;<code>s = "acbcb"</code>&nbsp;。</li>
</ul>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>s = "aa"</span></p>
<p><span class="example-io"><b>输出：</b>2</span></p>
<p><strong>解释：</strong><br />
无法对字符串进行任何操作，所以返回初始字符串的长度。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 2 * 10<sup>5</sup></code></li>
<li><code>s</code>&nbsp;只包含小写英文字母。</li>
</ul>

62
leetcode-cn/problem (Chinese)/新增道路查询后的最短距离 I [shortest-distance-after-road-addition-queries-i].html Normal file
View File

@@ -0,0 +1,62 @@
<p>给你一个整数 <code>n</code> 和一个二维整数数组 <code>queries</code>。</p>
<p>有 <code>n</code> 个城市，编号从 <code>0</code> 到 <code>n - 1</code>。初始时，每个城市 <code>i</code> 都有一条<strong>单向</strong>道路通往城市 <code>i + 1</code>（ <code>0 &lt;= i &lt; n - 1</code>）。</p>
<p><code>queries[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> 表示新建一条从城市 <code>u<sub>i</sub></code> 到城市 <code>v<sub>i</sub></code> 的<strong>单向</strong>道路。每次查询后，你需要找到从城市 <code>0</code> 到城市 <code>n - 1</code> 的<strong>最短路径</strong>的<strong>长度</strong>。</p>
<p>返回一个数组 <code>answer</code>，对于范围 <code>[0, queries.length - 1]</code> 中的每个 <code>i</code>，<code>answer[i]</code> 是处理完<strong>前</strong> <code>i + 1</code> 个查询后，从城市 <code>0</code> 到城市 <code>n - 1</code> 的最短路径的<em>长度</em>。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">n = 5, queries = [[2, 4], [0, 2], [0, 4]]</span></p>
<p><strong>输出：</strong> <span class="example-io">[3, 2, 1]</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image8.jpg" style="width: 350px; height: 60px;" /></p>
<p>新增一条从 2 到 4 的道路后，从 0 到 4 的最短路径长度为 3。</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image9.jpg" style="width: 350px; height: 60px;" /></p>
<p>新增一条从 0 到 2 的道路后，从 0 到 4 的最短路径长度为 2。</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image10.jpg" style="width: 350px; height: 96px;" /></p>
<p>新增一条从 0 到 4 的道路后，从 0 到 4 的最短路径长度为 1。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">n = 4, queries = [[0, 3], [0, 2]]</span></p>
<p><strong>输出：</strong> <span class="example-io">[1, 1]</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image11.jpg" style="width: 300px; height: 70px;" /></p>
<p>新增一条从 0 到 3 的道路后，从 0 到 3 的最短路径长度为 1。</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image12.jpg" style="width: 300px; height: 70px;" /></p>
<p>新增一条从 0 到 2 的道路后，从 0 到 3 的最短路径长度仍为 1。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>3 &lt;= n &lt;= 500</code></li>
<li><code>1 &lt;= queries.length &lt;= 500</code></li>
<li><code>queries[i].length == 2</code></li>
<li><code>0 &lt;= queries[i][0] &lt; queries[i][1] &lt; n</code></li>
<li><code>1 &lt; queries[i][1] - queries[i][0]</code></li>
<li>查询中没有重复的道路。</li>
</ul>

65
leetcode-cn/problem (Chinese)/新增道路查询后的最短距离 II [shortest-distance-after-road-addition-queries-ii].html Normal file
View File

@@ -0,0 +1,65 @@
<p>给你一个整数 <code>n</code> 和一个二维整数数组 <code>queries</code>。</p>
<p>有 <code>n</code> 个城市，编号从 <code>0</code> 到 <code>n - 1</code>。初始时，每个城市 <code>i</code> 都有一条<strong>单向</strong>道路通往城市 <code>i + 1</code>（ <code>0 &lt;= i &lt; n - 1</code>）。</p>
<p><code>queries[i] = [u<sub>i</sub>, v<sub>i</sub>]</code> 表示新建一条从城市 <code>u<sub>i</sub></code> 到城市 <code>v<sub>i</sub></code> 的<strong>单向</strong>道路。每次查询后，你需要找到从城市 <code>0</code> 到城市 <code>n - 1</code> 的<strong>最短路径</strong>的<strong>长度</strong>。</p>
<p>所有查询中不会存在两个查询都满足 <code>queries[i][0] &lt; queries[j][0] &lt; queries[i][1] &lt; queries[j][1]</code>。</p>
<p>返回一个数组 <code>answer</code>，对于范围 <code>[0, queries.length - 1]</code> 中的每个 <code>i</code>，<code>answer[i]</code> 是处理完<strong>前</strong> <code>i + 1</code> 个查询后，从城市 <code>0</code> 到城市 <code>n - 1</code> 的最短路径的<em>长度</em>。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">n = 5, queries = [[2, 4], [0, 2], [0, 4]]</span></p>
<p><strong>输出：</strong> <span class="example-io">[3, 2, 1]</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image8.jpg" style="width: 350px; height: 60px;" /></p>
<p>新增一条从 2 到 4 的道路后，从 0 到 4 的最短路径长度为 3。</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image9.jpg" style="width: 350px; height: 60px;" /></p>
<p>新增一条从 0 到 2 的道路后，从 0 到 4 的最短路径长度为 2。</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image10.jpg" style="width: 350px; height: 96px;" /></p>
<p>新增一条从 0 到 4 的道路后，从 0 到 4 的最短路径长度为 1。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">n = 4, queries = [[0, 3], [0, 2]]</span></p>
<p><strong>输出：</strong> <span class="example-io">[1, 1]</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image11.jpg" style="width: 300px; height: 70px;" /></p>
<p>新增一条从 0 到 3 的道路后，从 0 到 3 的最短路径长度为 1。</p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/28/image12.jpg" style="width: 300px; height: 70px;" /></p>
<p>新增一条从 0 到 2 的道路后，从 0 到 3 的最短路径长度仍为 1。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示:</strong></p>
<ul>
<li><code>3 &lt;= n &lt;= 10<sup>5</sup></code></li>
<li><code>1 &lt;= queries.length &lt;= 10<sup>5</sup></code></li>
<li><code>queries[i].length == 2</code></li>
<li><code>0 &lt;= queries[i][0] &lt; queries[i][1] &lt; n</code></li>
<li><code>1 &lt; queries[i][1] - queries[i][0]</code></li>
<li>查询中不存在重复的道路。</li>
<li>不存在两个查询都满足 <code>i != j</code> 且 <code>queries[i][0] &lt; queries[j][0] &lt; queries[i][1] &lt; queries[j][1]</code>。</li>
</ul>

60
leetcode-cn/problem (Chinese)/最少翻转次数使二进制矩阵回文 I [minimum-number-of-flips-to-make-binary-grid-palindromic-i].html Normal file
View File

@@ -0,0 +1,60 @@
<p>给你一个&nbsp;<code>m x n</code>&nbsp;的二进制矩阵&nbsp;<code>grid</code>&nbsp;。</p>
<p>如果矩阵中一行或者一列从前往后与从后往前读是一样的，那么我们称这一行或者这一列是 <strong>回文</strong> 的。</p>
<p>你可以将 <code>grid</code>&nbsp;中任意格子的值 <strong>翻转</strong>&nbsp;，也就是将格子里的值从 <code>0</code>&nbsp;变成 <code>1</code>&nbsp;，或者从 <code>1</code>&nbsp;变成 <code>0</code>&nbsp;。</p>
<p>请你返回 <strong>最少</strong>&nbsp;翻转次数，使得矩阵 <strong>要么</strong>&nbsp;所有行是 <strong>回文的</strong>&nbsp;，要么所有列是 <strong>回文的</strong>&nbsp;。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = [[1,0,0],[0,0,0],[0,0,1]]</span></p>
<p><span class="example-io"><b>输出：</b>2</span></p>
<p><b>解释：</b></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/07/07/screenshot-from-2024-07-08-00-20-10.png" style="width: 420px; height: 108px;" /></p>
<p>将高亮的格子翻转，得到所有行都是回文的。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = </span>[[0,1],[0,1],[0,0]]</p>
<p><span class="example-io"><b>输出：</b>1</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/07/07/screenshot-from-2024-07-08-00-31-23.png" style="width: 300px; height: 100px;" /></p>
<p>将高亮的格子翻转，得到所有列都是回文的。</p>
</div>
<p><strong class="example">示例 3：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = [[1],[0]]</span></p>
<p><span class="example-io"><b>输出：</b>0</span></p>
<p><strong>解释：</strong></p>
<p>所有行已经是回文的。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>m == grid.length</code></li>
<li><code>n == grid[i].length</code></li>
<li><code>1 &lt;= m * n &lt;= 2 * 10<sup>5</sup></code></li>
<li><code>0 &lt;= grid[i][j] &lt;= 1</code></li>
</ul>

56
leetcode-cn/problem (Chinese)/最少翻转次数使二进制矩阵回文 II [minimum-number-of-flips-to-make-binary-grid-palindromic-ii].html Normal file
View File

@@ -0,0 +1,56 @@
<p>给你一个&nbsp;<code>m x n</code>&nbsp;的二进制矩阵&nbsp;<code>grid</code>&nbsp;。</p>
<p>如果矩阵中一行或者一列从前往后与从后往前读是一样的，那么我们称这一行或者这一列是 <strong>回文</strong>&nbsp;的。</p>
<p>你可以将 <code>grid</code>&nbsp;中任意格子的值 <strong>翻转</strong>&nbsp;，也就是将格子里的值从 <code>0</code>&nbsp;变成 <code>1</code>&nbsp;，或者从 <code>1</code>&nbsp;变成 <code>0</code>&nbsp;。</p>
<p>请你返回 <strong>最少</strong>&nbsp;翻转次数，使得矩阵中 <strong>所有</strong>&nbsp;行和列都是 <strong>回文的</strong>&nbsp;，且矩阵中 <code>1</code>&nbsp;的数目可以被 <code>4</code>&nbsp;<strong>整除</strong>&nbsp;。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = [[1,0,0],[0,1,0],[0,0,1]]</span></p>
<p><span class="example-io"><b>输出：</b>3</span></p>
<p><strong>解释：</strong></p>
<p><img src="https://assets.leetcode.com/uploads/2024/08/01/image.png" style="width: 400px; height: 105px;" /></p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = [[0,1],[0,1],[0,0]]</span></p>
<p><span class="example-io"><b>输出：</b>2</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/07/08/screenshot-from-2024-07-09-01-37-48.png" style="width: 300px; height: 104px;" /></p>
</div>
<p><strong class="example">示例 3：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = [[1],[1]]</span></p>
<p><span class="example-io"><b>输出：</b>2</span></p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/08/01/screenshot-from-2024-08-01-23-05-26.png" style="width: 200px; height: 70px;" /></p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>m == grid.length</code></li>
<li><code>n == grid[i].length</code></li>
<li><code>1 &lt;= m * n &lt;= 2 * 10<sup>5</sup></code></li>
<li><code>0 &lt;= grid[i][j] &lt;= 1</code></li>
</ul>

95
leetcode-cn/problem (Chinese)/标记所有节点需要的时间 [time-taken-to-mark-all-nodes].html Normal file
View File

@@ -0,0 +1,95 @@
<p>给你一棵 <strong>无向</strong>&nbsp;树，树中节点从 <code>0</code>&nbsp;到 <code>n - 1</code>&nbsp;编号。同时给你一个长度为 <code>n - 1</code>&nbsp;的二维整数数组&nbsp;<code>edges</code>&nbsp;，其中&nbsp;<code>edges[i] = [u<sub>i</sub>, v<sub>i</sub>]</code>&nbsp;表示节点&nbsp;<code>u<sub>i</sub></code> 和&nbsp;<code>v<sub>i</sub></code>&nbsp;在树中有一条边。</p>
<p>一开始，<strong>所有</strong>&nbsp;节点都 <strong>未标记</strong>&nbsp;。对于节点 <code>i</code>&nbsp;：</p>
<ul>
<li>当&nbsp;<code>i</code>&nbsp;是奇数时，如果时刻 <code>x - 1</code>&nbsp;该节点有 <strong>至少</strong>&nbsp;一个相邻节点已经被标记了，那么节点 <code>i</code>&nbsp;会在时刻 <code>x</code>&nbsp;被标记。</li>
<li>当&nbsp;<code>i</code>&nbsp;是偶数时，如果时刻 <code>x - 2</code>&nbsp;该节点有 <strong>至少</strong>&nbsp;一个相邻节点已经被标记了，那么节点 <code>i</code>&nbsp;会在时刻 <code>x</code>&nbsp;被标记。</li>
</ul>
<p>请你返回一个数组&nbsp;<code>times</code>&nbsp;，表示如果你在时刻 <code>t = 0</code>&nbsp;标记节点 <code>i</code>&nbsp;，那么时刻 <code>times[i]</code>&nbsp;时，树中所有节点都会被标记。</p>
<p>请注意，每个 <code>times[i]</code> 的答案都是独立的，即当你标记节点 <code>i</code> 时，所有其他节点都未标记。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>edges = [[0,1],[0,2]]</span></p>
<p><b>输出：</b>[2,4,3]</p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/01/screenshot-2024-06-02-122236.png" style="width: 500px; height: 241px;" /></p>
<ul>
<li>对于&nbsp;<code>i = 0</code>&nbsp;：
<ul>
<li>节点 1 在时刻&nbsp;<code>t = 1</code>&nbsp;被标记，节点 2 在时刻&nbsp;<code>t = 2</code>&nbsp;被标记。</li>
</ul>
</li>
<li>对于&nbsp;<code>i = 1</code>&nbsp;：
<ul>
<li>节点 0 在时刻&nbsp;<code>t = 2</code>&nbsp;被标记，节点 2 在时刻&nbsp;<code>t = 4</code>&nbsp;被标记。</li>
</ul>
</li>
<li>对于&nbsp;<code>i = 2</code>&nbsp;：
<ul>
<li>节点 0 在时刻&nbsp;<code>t = 2</code>&nbsp;被标记，节点 1 在时刻&nbsp;<code>t = 3</code>&nbsp;被标记。</li>
</ul>
</li>
</ul>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>edges = [[0,1]]</span></p>
<p><b>输出：</b>[1,2]</p>
<p><strong>解释：</strong></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/01/screenshot-2024-06-02-122249.png" style="width: 500px; height: 257px;" /></p>
<ul>
<li>对于&nbsp;<code>i = 0</code>&nbsp;：
<ul>
<li>节点 1 在时刻&nbsp;<code>t = 1</code>&nbsp;被标记。</li>
</ul>
</li>
<li>对于&nbsp;<code>i = 1</code>&nbsp;：
<ul>
<li>节点 0 在时刻&nbsp;<code>t = 2</code>&nbsp;被标记。</li>
</ul>
</li>
</ul>
</div>
<p><strong class="example">示例 3：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>edges = </span>[[2,4],[0,1],[2,3],[0,2]]</p>
<p><b>输出：</b>[4,6,3,5,5]</p>
<p><b>解释：</b></p>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/03/screenshot-2024-06-03-210550.png" style="height: 266px; width: 500px;" /></p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 10<sup>5</sup></code></li>
<li><code>edges.length == n - 1</code></li>
<li><code>edges[i].length == 2</code></li>
<li><code>0 &lt;= edges[i][0], edges[i][1] &lt;= n - 1</code></li>
<li>输入保证&nbsp;<code>edges</code>&nbsp;表示一棵合法的树。</li>
</ul>

48
leetcode-cn/problem (Chinese)/求出硬币游戏的赢家 [find-the-winning-player-in-coin-game].html Normal file
View File

@@ -0,0 +1,48 @@
<p>给你两个 <strong>正</strong>&nbsp;整数&nbsp;<code>x</code>&nbsp;和&nbsp;<code>y</code>&nbsp;，分别表示价值为 75 和 10 的硬币的数目。</p>
<p>Alice 和 Bob 正在玩一个游戏。每一轮中，Alice&nbsp;先进行操作，Bob 后操作。每次操作中，玩家需要拿出价值 <b>总和</b>&nbsp;为 115 的硬币。如果一名玩家无法执行此操作，那么这名玩家 <strong>输掉</strong>&nbsp;游戏。</p>
<p>两名玩家都采取 <strong>最优</strong>&nbsp;策略，请你返回游戏的赢家。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>x = 2, y = 7</span></p>
<p><span class="example-io"><b>输出：</b>"Alice"</span></p>
<p><strong>解释：</strong></p>
<p>游戏一次操作后结束：</p>
<ul>
<li>Alice 拿走 1 枚价值为 75 的硬币和 4 枚价值为 10 的硬币。</li>
</ul>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>x = 4, y = 11</span></p>
<p><span class="example-io"><b>输出：</b>"Bob"</span></p>
<p><strong>解释：</strong></p>
<p>游戏 2 次操作后结束：</p>
<ul>
<li>Alice 拿走&nbsp;1 枚价值为 75 的硬币和 4 枚价值为 10 的硬币。</li>
<li>Bob 拿走&nbsp;1 枚价值为 75 的硬币和 4 枚价值为 10 的硬币。</li>
</ul>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= x, y &lt;= 100</code></li>
</ul>

64
leetcode-cn/problem (Chinese)/求出胜利玩家的数目 [find-the-number-of-winning-players].html Normal file
View File

@@ -0,0 +1,64 @@
<p>给你一个整数&nbsp;<code>n</code>&nbsp;，表示在一个游戏中的玩家数目。同时给你一个二维整数数组&nbsp;<code>pick</code>&nbsp;，其中&nbsp;<code>pick[i] = [x<sub>i</sub>, y<sub>i</sub>]</code>&nbsp;表示玩家&nbsp;<code>x<sub>i</sub></code>&nbsp;获得了一个颜色为&nbsp;<code>y<sub>i</sub></code>&nbsp;的球。</p>
<p>如果玩家 <code>i</code>&nbsp;获得的球中任何一种颜色球的数目 <strong>严格大于</strong>&nbsp;<code>i</code>&nbsp;个，那么我们说玩家 <code>i</code>&nbsp;是胜利玩家。换句话说：</p>
<ul>
<li>如果玩家 0 获得了任何的球，那么玩家 0 是胜利玩家。</li>
<li>如果玩家 1 获得了至少 2 个相同颜色的球，那么玩家 1 是胜利玩家。</li>
<li>...</li>
<li>如果玩家 <code>i</code>&nbsp;获得了至少&nbsp;<code>i + 1</code>&nbsp;个相同颜色的球，那么玩家 <code>i</code>&nbsp;是胜利玩家。</li>
</ul>
<p>请你返回游戏中 <strong>胜利玩家</strong>&nbsp;的数目。</p>
<p><strong>注意</strong>，可能有多个玩家是胜利玩家。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>n = 4, pick = [[0,0],[1,0],[1,0],[2,1],[2,1],[2,0]]</span></p>
<p><span class="example-io"><b>输出：</b>2</span></p>
<p><strong>解释：</strong></p>
<p>玩家 0 和玩家 1 是胜利玩家，玩家 2 和玩家 3 不是胜利玩家。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>n = 5, pick = [[1,1],[1,2],[1,3],[1,4]]</span></p>
<p><span class="example-io"><b>输出：</b>0</span></p>
<p><strong>解释：</strong></p>
<p>没有胜利玩家。</p>
</div>
<p><strong class="example">示例 3：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>n = 5, pick = [[1,1],[2,4],[2,4],[2,4]]</span></p>
<p><span class="example-io"><b>输出：</b>1</span></p>
<p><b>解释：</b></p>
<p>玩家 2 是胜利玩家，因为玩家 2 获得了 3 个颜色为 4 的球。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>2 &lt;= n &lt;= 10</code></li>
<li><code>1 &lt;= pick.length &lt;= 100</code></li>
<li><code>pick[i].length == 2</code></li>
<li><code>0 &lt;= x<sub>i</sub> &lt;= n - 1 </code></li>
<li><code>0 &lt;= y<sub>i</sub> &lt;= 10</code></li>
</ul>

140
leetcode-cn/problem (Chinese)/统计 1 显著的字符串的数量 [count-the-number-of-substrings-with-dominant-ones].html Normal file
View File

@@ -0,0 +1,140 @@
<p>给你一个二进制字符串 <code>s</code>。</p>
<p>请你统计并返回其中 <strong>1 显著 </strong> 的 <span data-keyword="substring-nonempty">子字符串</span> 的数量。</p>
<p>如果字符串中 1 的数量 <strong>大于或等于</strong> 0 的数量的 <strong>平方</strong>，则认为该字符串是一个 <strong>1 显著</strong> 的字符串 。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">s = "00011"</span></p>
<p><strong>输出：</strong><span class="example-io">5</span></p>
<p><strong>解释：</strong></p>
<p>1 显著的子字符串如下表所示。</p>
</div>
<table>
<thead>
<tr>
<th>i</th>
<th>j</th>
<th>s[i..j]</th>
<th>0 的数量</th>
<th>1 的数量</th>
</tr>
</thead>
<tbody>
<tr>
<td>3</td>
<td>3</td>
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>4</td>
<td>4</td>
<td>1</td>
<td>0</td>
<td>1</td>
</tr>
<tr>
<td>2</td>
<td>3</td>
<td>01</td>
<td>1</td>
<td>1</td>
</tr>
<tr>
<td>3</td>
<td>4</td>
<td>11</td>
<td>0</td>
<td>2</td>
</tr>
<tr>
<td>2</td>
<td>4</td>
<td>011</td>
<td>1</td>
<td>2</td>
</tr>
</tbody>
</table>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong><span class="example-io">s = "101101"</span></p>
<p><strong>输出：</strong><span class="example-io">16</span></p>
<p><strong>解释：</strong></p>
<p>1 不显著的子字符串如下表所示。</p>
<p>总共有 21 个子字符串，其中 5 个是 1 不显著字符串，因此有 16 个 1 显著子字符串。</p>
</div>
<table>
<thead>
<tr>
<th>i</th>
<th>j</th>
<th>s[i..j]</th>
<th>0 的数量</th>
<th>1 的数量</th>
</tr>
</thead>
<tbody>
<tr>
<td>1</td>
<td>1</td>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr>
<td>4</td>
<td>4</td>
<td>0</td>
<td>1</td>
<td>0</td>
</tr>
<tr>
<td>1</td>
<td>4</td>
<td>0110</td>
<td>2</td>
<td>2</td>
</tr>
<tr>
<td>0</td>
<td>4</td>
<td>10110</td>
<td>2</td>
<td>3</td>
</tr>
<tr>
<td>1</td>
<td>5</td>
<td>01101</td>
<td>2</td>
<td>3</td>
</tr>
</tbody>
</table>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= s.length &lt;= 4 * 10<sup>4</sup></code></li>
<li><code>s</code> 仅包含字符 <code>'0'</code> 和 <code>'1'</code>。</li>
</ul>

44
leetcode-cn/problem (Chinese)/统计不是特殊数字的数字数量 [find-the-count-of-numbers-which-are-not-special].html Normal file
View File

@@ -0,0 +1,44 @@
<p>给你两个<strong> 正整数 </strong><code>l</code> 和 <code>r</code>。对于任何数字 <code>x</code>，<code>x</code> 的所有正因数（除了 <code>x</code> 本身）被称为 <code>x</code> 的 <strong>真因数</strong>。</p>
<p><span class="text-only" data-eleid="13" style="white-space: pre;">如果一个数字恰好仅有两个</span> <strong>真因数</strong>，则称该数字为 <strong>特殊数字</strong>。例如：</p>
<ul>
<li>数字 4 是<strong> 特殊数字</strong>，因为它的真因数为 1 和 2。</li>
<li>数字 6 不是 <strong>特殊数字</strong>，因为它的真因数为 1、2 和 3。</li>
</ul>
<p>返回区间 <code>[l, r]</code> 内<strong> 不是 特殊数字 </strong>的数字数量。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">l = 5, r = 7</span></p>
<p><strong>输出：</strong> <span class="example-io">3</span></p>
<p><strong>解释：</strong></p>
<p>区间 <code>[5, 7]</code> 内不存在特殊数字。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong> <span class="example-io">l = 4, r = 16</span></p>
<p><strong>输出：</strong> <span class="reset-io">11</span></p>
<p><strong>解释：</strong></p>
<p>区间 <code>[4, 16]</code> 内的特殊数字为 4 和 9。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;= l &lt;= r &lt;= 10<sup>9</sup></code></li>
</ul>

41
leetcode-cn/problem (Chinese)/网格图操作后的最大分数 [maximum-score-from-grid-operations].html Normal file
View File

@@ -0,0 +1,41 @@
<p>给你一个大小为 <code>n x n</code>&nbsp;的二维矩阵&nbsp;<code>grid</code>&nbsp;，一开始所有格子都是白色的。一次操作中，你可以选择任意下标为&nbsp;<code>(i, j)</code>&nbsp;的格子，并将第&nbsp;<code>j</code>&nbsp;列中从最上面到第&nbsp;<code>i</code>&nbsp;行所有格子改成黑色。</p>
<p>如果格子 <code>(i, j)</code>&nbsp;为白色，且左边或者右边的格子至少一个格子为黑色，那么我们将 <code>grid[i][j]</code>&nbsp;加到最后网格图的总分中去。</p>
<p>请你返回执行任意次操作以后，最终网格图的 <strong>最大</strong>&nbsp;总分数。</p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = [[0,0,0,0,0],[0,0,3,0,0],[0,1,0,0,0],[5,0,0,3,0],[0,0,0,0,2]]</span></p>
<p><span class="example-io"><b>输出：</b>11</span></p>
<p><strong>解释：</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2024/05/11/one.png" style="width: 300px; height: 200px;" />
<p>第一次操作中，我们将第 1 列中，最上面的格子到第 3 行的格子染成黑色。第二次操作中，我们将第 4 列中，最上面的格子到最后一行的格子染成黑色。最后网格图总分为&nbsp;<code>grid[3][0] + grid[1][2] + grid[3][3]</code>&nbsp;等于 11 。</p>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><span class="example-io"><b>输入：</b>grid = [[10,9,0,0,15],[7,1,0,8,0],[5,20,0,11,0],[0,0,0,1,2],[8,12,1,10,3]]</span></p>
<p><span class="example-io"><b>输出：</b>94</span></p>
<p><strong>解释：</strong></p>
<img alt="" src="https://assets.leetcode.com/uploads/2024/05/11/two-1.png" style="width: 300px; height: 200px;" />
<p>我们对第 1 ，2 ，3 列分别从上往下染黑色到第 1 ，4， 0 行。最后网格图总分为&nbsp;<code>grid[0][0] + grid[1][0] + grid[2][1] + grid[4][1] + grid[1][3] + grid[2][3] + grid[3][3] + grid[4][3] + grid[0][4]</code>&nbsp;等于 94 。</p>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>1 &lt;=&nbsp;n == grid.length &lt;= 100</code></li>
<li><code>n == grid[i].length</code></li>
<li><code>0 &lt;= grid[i][j] &lt;= 10<sup>9</sup></code></li>
</ul>

69
leetcode-cn/problem (Chinese)/设计相邻元素求和服务 [design-neighbor-sum-service].html Normal file
View File

@@ -0,0 +1,69 @@
<p>给你一个 <code>n x n</code> 的二维数组 <code>grid</code>，它包含范围 <code>[0, n<sup>2</sup> - 1]</code> 内的<strong>不重复</strong>元素。</p>
<p>实现 <code>neighborSum</code> 类：</p>
<ul>
<li><code>neighborSum(int [][]grid)</code> 初始化对象。</li>
<li><code>int adjacentSum(int value)</code> 返回在 <code>grid</code> 中与 <code>value</code> 相邻的元素之<strong>和</strong>，相邻指的是与 <code>value</code> 在上、左、右或下的元素。</li>
<li><code>int diagonalSum(int value)</code> 返回在 <code>grid</code> 中与 <code>value</code> 对角线相邻的元素之<strong>和</strong>，对角线相邻指的是与 <code>value</code> 在左上、右上、左下或右下的元素。</li>
</ul>
<p><img alt="" src="https://assets.leetcode.com/uploads/2024/06/24/design.png" style="width: 400px; height: 248px;" /></p>
<p>&nbsp;</p>
<p><strong class="example">示例 1：</strong></p>
<div class="example-block">
<p><strong>输入：</strong></p>
<p>["neighborSum", "adjacentSum", "adjacentSum", "diagonalSum", "diagonalSum"]</p>
<p>[[[[0, 1, 2], [3, 4, 5], [6, 7, 8]]], [1], [4], [4], [8]]</p>
<p><strong>输出：</strong> [null, 6, 16, 16, 4]</p>
<p><strong>解释：</strong></p>
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2024/06/24/designexample0.png" style="width: 250px; height: 249px;" /></strong></p>
<ul>
<li>1 的相邻元素是 0、2 和 4。</li>
<li>4 的相邻元素是 1、3、5 和 7。</li>
<li>4 的对角线相邻元素是 0、2、6 和 8。</li>
<li>8 的对角线相邻元素是 4。</li>
</ul>
</div>
<p><strong class="example">示例 2：</strong></p>
<div class="example-block">
<p><strong>输入：</strong></p>
<p>["neighborSum", "adjacentSum", "diagonalSum"]</p>
<p>[[[[1, 2, 0, 3], [4, 7, 15, 6], [8, 9, 10, 11], [12, 13, 14, 5]]], [15], [9]]</p>
<p><strong>输出：</strong> [null, 23, 45]</p>
<p><strong>解释：</strong></p>
<p><strong class="example"><img alt="" src="https://assets.leetcode.com/uploads/2024/06/24/designexample2.png" style="width: 300px; height: 300px;" /></strong></p>
<ul>
<li>15 的相邻元素是 0、10、7 和 6。</li>
<li>9 的对角线相邻元素是 4、12、14 和 15。</li>
</ul>
</div>
<p>&nbsp;</p>
<p><strong>提示：</strong></p>
<ul>
<li><code>3 &lt;= n == grid.length == grid[0].length &lt;= 10</code></li>
<li><code>0 &lt;= grid[i][j] &lt;= n<sup>2</sup> - 1</code></li>
<li>所有 <code>grid[i][j]</code> 值均不重复。</li>
<li><code>adjacentSum</code> 和 <code>diagonalSum</code> 中的 <code>value</code> 均在范围 <code>[0, n<sup>2</sup> - 1]</code> 内。</li>
<li>最多会调用 <code>adjacentSum</code> 和 <code>diagonalSum</code> 总共 <code>2 * n<sup>2</sup></code> 次。</li>
</ul>